Mercurial > mplayer.hg
annotate libvo/vo_quartz.c @ 15885:b2f434649dec
properly redraw fullscreen window with -fs and zoom
author | nplourde |
---|---|
date | Sat, 02 Jul 2005 13:28:25 +0000 |
parents | ab6d02448e57 |
children | c8e414e49fef |
rev | line source |
---|---|
12296 | 1 /* |
2 vo_quartz.c | |
3 | |
13693
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
4 by Nicolas Plourde <nicolasplourde@gmail.com> |
12296 | 5 |
6 Copyright (c) Nicolas Plourde - April 2004 | |
12414 | 7 |
8 YUV support Copyright (C) 2004 Romain Dolbeau <romain@dolbeau.org> | |
12296 | 9 |
10 MPlayer Mac OSX Quartz video out module. | |
11 | |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
12 todo: -screen overlay output |
13818
9f707a805967
window now save is old position when going in fullscreen or while using resize preset
nplourde
parents:
13796
diff
changeset
|
13 -fit osd in black bar when available |
15702 | 14 -fix RGB32 |
12296 | 15 -(add sugestion here) |
12120 | 16 */ |
17 | |
18 //SYS | |
19 #include <stdio.h> | |
20 | |
21 //OSX | |
22 #include <Carbon/Carbon.h> | |
12414 | 23 #include <QuickTime/QuickTime.h> |
12120 | 24 |
25 //MPLAYER | |
26 #include "config.h" | |
12414 | 27 #include "fastmemcpy.h" |
12120 | 28 #include "video_out.h" |
29 #include "video_out_internal.h" | |
30 #include "aspect.h" | |
12414 | 31 #include "mp_msg.h" |
32 #include "m_option.h" | |
12120 | 33 |
13787
e047e70a9767
Handle "xxx.h" vs "../xxx.h" include paths in a consistent way.
diego
parents:
13779
diff
changeset
|
34 #include "input/input.h" |
e047e70a9767
Handle "xxx.h" vs "../xxx.h" include paths in a consistent way.
diego
parents:
13779
diff
changeset
|
35 #include "input/mouse.h" |
12120 | 36 |
37 #include "vo_quartz.h" | |
38 | |
12296 | 39 static vo_info_t info = |
40 { | |
41 "Mac OSX (Quartz)", | |
42 "quartz", | |
12414 | 43 "Nicolas Plourde <nicolasplourde@hotmail.com>, Romain Dolbeau <romain@dolbeau.org>", |
12296 | 44 "" |
12120 | 45 }; |
46 | |
12296 | 47 LIBVO_EXTERN(quartz) |
12120 | 48 |
12414 | 49 static uint32_t image_depth; |
50 static uint32_t image_format; | |
51 static uint32_t image_size; | |
52 static uint32_t image_buffer_size; | |
12432 | 53 static char *image_data; |
12414 | 54 |
12432 | 55 static ImageSequence seqId; |
12414 | 56 static CodecType image_qtcodec; |
12487 | 57 static PlanarPixmapInfoYUV420 *P = NULL; |
12424 | 58 static struct |
59 { | |
60 ImageDescriptionHandle desc; | |
61 Handle extension_colr; | |
62 Handle extension_fiel; | |
63 Handle extension_clap; | |
64 Handle extension_pasp; | |
12414 | 65 } yuv_qt_stuff; |
12432 | 66 static MatrixRecord matrix; |
12414 | 67 static int EnterMoviesDone = 0; |
12487 | 68 static int get_image_done = 0; |
12120 | 69 |
12912
1f6bb2356d18
add var vo_rootwin and -rootwin switch for mac osx
nplourde
parents:
12889
diff
changeset
|
70 extern int vo_rootwin; |
12296 | 71 extern int vo_ontop; |
12487 | 72 extern int vo_fs; // user want fullscreen |
73 static int vo_quartz_fs; // we are in fullscreen | |
13791 | 74 extern float monitor_aspect; |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
75 extern int vo_keepaspect; //keep aspect ratio when resizing |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
76 extern float movie_aspect; |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
77 static float old_movie_aspect; |
13795 | 78 extern float vo_panscan; |
12120 | 79 |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
80 static int winLevel = 1; |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
81 int levelList[] = |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
82 { |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
83 kCGDesktopWindowLevelKey, |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
84 kCGNormalWindowLevelKey, |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
85 kCGScreenSaverWindowLevelKey |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
86 }; |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
87 |
12487 | 88 static int int_pause = 0; |
89 static float winAlpha = 1; | |
15881 | 90 static int mouseHide = 0; |
12296 | 91 |
12487 | 92 static int device_width; |
93 static int device_height; | |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
94 static int device_id; |
12120 | 95 |
13788
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
96 static short fs_res_x=0; |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
97 static short fs_res_y=0; |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
98 |
12487 | 99 static WindowRef theWindow = NULL; |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
100 static WindowGroupRef winGroup = NULL; |
13124 | 101 static CGContextRef context; |
102 static CGRect bounds; | |
13840 | 103 static GDHandle deviceHdl; |
13124 | 104 |
105 static CGDataProviderRef dataProviderRef; | |
106 static CGImageAlphaInfo alphaInfo; | |
107 static CGImageRef image; | |
12296 | 108 |
12487 | 109 static Rect imgRect; // size of the original image (unscaled) |
110 static Rect dstRect; // size of the displayed image (after scaling) | |
111 static Rect winRect; // size of the window containg the displayed image (include padding) | |
112 static Rect oldWinRect; // size of the window containg the displayed image (include padding) when NOT in FS mode | |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
113 static Rect deviceRect; // size of the display device |
13840 | 114 static Rect oldWinBounds; |
12296 | 115 |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
116 static MenuRef windMenu; |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
117 static MenuRef movMenu; |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
118 static MenuRef aspectMenu; |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
119 |
13693
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
120 enum |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
121 { |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
122 kQuitCmd = 1, |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
123 kHalfScreenCmd = 2, |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
124 kNormalScreenCmd = 3, |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
125 kDoubleScreenCmd = 4, |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
126 kFullScreenCmd = 5, |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
127 kKeepAspectCmd = 6, |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
128 kAspectOrgCmd = 7, |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
129 kAspectFullCmd = 8, |
13795 | 130 kAspectWideCmd = 9, |
131 kPanScanCmd = 10 | |
13693
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
132 }; |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
133 |
13787
e047e70a9767
Handle "xxx.h" vs "../xxx.h" include paths in a consistent way.
diego
parents:
13779
diff
changeset
|
134 #include "osdep/keycodes.h" |
15702 | 135 |
12296 | 136 extern void mplayer_put_key(int code); |
137 extern void vo_draw_text(int dxs,int dys,void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride)); | |
12120 | 138 |
139 //PROTOTYPE///////////////////////////////////////////////////////////////// | |
15702 | 140 static OSStatus KeyEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData); |
141 static OSStatus MouseEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData); | |
142 static OSStatus WindowEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData); | |
12296 | 143 void window_resized(); |
144 void window_ontop(); | |
145 void window_fullscreen(); | |
13840 | 146 void window_panscan(); |
12120 | 147 |
12886
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
148 static inline int convert_key(UInt32 key, UInt32 charcode) |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
149 { |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
150 switch(key) |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
151 { |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
152 case QZ_IBOOK_ENTER: |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
153 case QZ_RETURN: return KEY_ENTER; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
154 case QZ_ESCAPE: return KEY_ESC; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
155 case QZ_BACKSPACE: return KEY_BACKSPACE; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
156 case QZ_LALT: return KEY_BACKSPACE; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
157 case QZ_LCTRL: return KEY_BACKSPACE; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
158 case QZ_LSHIFT: return KEY_BACKSPACE; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
159 case QZ_F1: return KEY_F+1; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
160 case QZ_F2: return KEY_F+2; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
161 case QZ_F3: return KEY_F+3; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
162 case QZ_F4: return KEY_F+4; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
163 case QZ_F5: return KEY_F+5; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
164 case QZ_F6: return KEY_F+6; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
165 case QZ_F7: return KEY_F+7; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
166 case QZ_F8: return KEY_F+8; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
167 case QZ_F9: return KEY_F+9; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
168 case QZ_F10: return KEY_F+10; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
169 case QZ_F11: return KEY_F+11; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
170 case QZ_F12: return KEY_F+12; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
171 case QZ_INSERT: return KEY_INSERT; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
172 case QZ_DELETE: return KEY_DELETE; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
173 case QZ_HOME: return KEY_HOME; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
174 case QZ_END: return KEY_END; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
175 case QZ_KP_PLUS: return '+'; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
176 case QZ_KP_MINUS: return '-'; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
177 case QZ_TAB: return KEY_TAB; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
178 case QZ_PAGEUP: return KEY_PAGE_UP; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
179 case QZ_PAGEDOWN: return KEY_PAGE_DOWN; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
180 case QZ_UP: return KEY_UP; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
181 case QZ_DOWN: return KEY_DOWN; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
182 case QZ_LEFT: return KEY_LEFT; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
183 case QZ_RIGHT: return KEY_RIGHT; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
184 case QZ_KP_MULTIPLY: return '*'; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
185 case QZ_KP_DIVIDE: return '/'; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
186 case QZ_KP_ENTER: return KEY_BACKSPACE; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
187 case QZ_KP_PERIOD: return KEY_KPDEC; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
188 case QZ_KP0: return KEY_KP0; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
189 case QZ_KP1: return KEY_KP1; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
190 case QZ_KP2: return KEY_KP2; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
191 case QZ_KP3: return KEY_KP3; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
192 case QZ_KP4: return KEY_KP4; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
193 case QZ_KP5: return KEY_KP5; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
194 case QZ_KP6: return KEY_KP6; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
195 case QZ_KP7: return KEY_KP7; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
196 case QZ_KP8: return KEY_KP8; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
197 case QZ_KP9: return KEY_KP9; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
198 default: return charcode; |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
199 } |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
200 } |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
201 |
12296 | 202 static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src, unsigned char *srca, int stride) |
203 { | |
12424 | 204 switch (image_format) |
205 { | |
206 case IMGFMT_RGB32: | |
207 vo_draw_alpha_rgb32(w,h,src,srca,stride,image_data+4*(y0*imgRect.right+x0),4*imgRect.right); | |
208 break; | |
209 case IMGFMT_YV12: | |
210 case IMGFMT_IYUV: | |
211 case IMGFMT_I420: | |
12487 | 212 vo_draw_alpha_yv12(w,h,src,srca,stride, ((char*)P) + P->componentInfoY.offset + x0 + y0 * imgRect.right, imgRect.right); |
12424 | 213 break; |
214 case IMGFMT_UYVY: | |
12517 | 215 vo_draw_alpha_uyvy(w,h,src,srca,stride,((char*)P) + (x0 + y0 * imgRect.right) * 2,imgRect.right*2); |
12424 | 216 break; |
217 case IMGFMT_YUY2: | |
12487 | 218 vo_draw_alpha_yuy2(w,h,src,srca,stride,((char*)P) + (x0 + y0 * imgRect.right) * 2,imgRect.right*2); |
12424 | 219 break; |
12487 | 220 } |
12296 | 221 } |
12120 | 222 |
15702 | 223 //default keyboard event handler |
224 static OSStatus KeyEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData) | |
12120 | 225 { |
12624 | 226 OSStatus result = noErr; |
12460 | 227 UInt32 class = GetEventClass (event); |
228 UInt32 kind = GetEventKind (event); | |
12624 | 229 |
230 result = CallNextEventHandler(nextHandler, event); | |
13693
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
231 |
13712
f6ef5a0ad7e4
removed duplicate case and fixed aspect ratio for window zoom feature
nplourde
parents:
13707
diff
changeset
|
232 if(class == kEventClassKeyboard) |
12460 | 233 { |
234 char macCharCodes; | |
235 UInt32 macKeyCode; | |
236 UInt32 macKeyModifiers; | |
237 | |
238 GetEventParameter(event, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(macCharCodes), NULL, &macCharCodes); | |
239 GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL, sizeof(macKeyCode), NULL, &macKeyCode); | |
240 GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(macKeyModifiers), NULL, &macKeyModifiers); | |
13693
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
241 |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
242 if(macKeyModifiers != 256) |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
243 { |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
244 if (kind == kEventRawKeyRepeat || kind == kEventRawKeyDown) |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
245 { |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
246 int key = convert_key(macKeyCode, macCharCodes); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
247 if(key != -1) |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
248 mplayer_put_key(key); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
249 } |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
250 } |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
251 else if(macKeyModifiers == 256) |
12296 | 252 { |
13693
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
253 switch(macCharCodes) |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
254 { |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
255 case '[': SetWindowAlpha(theWindow, winAlpha-=0.05); break; |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
256 case ']': SetWindowAlpha(theWindow, winAlpha+=0.05); break; |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
257 } |
12460 | 258 } |
12886
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
259 else |
9b95958f4eb0
listen for key repeats, patch by Dan Christiansen
nplourde
parents:
12830
diff
changeset
|
260 result = eventNotHandledErr; |
12460 | 261 } |
15702 | 262 |
263 return result; | |
264 } | |
265 | |
266 //default mouse event handler | |
267 static OSStatus MouseEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData) | |
268 { | |
269 OSStatus result = noErr; | |
270 UInt32 class = GetEventClass (event); | |
271 UInt32 kind = GetEventKind (event); | |
272 | |
273 result = CallNextEventHandler(nextHandler, event); | |
274 | |
275 if(class == kEventClassMouse) | |
12460 | 276 { |
277 WindowPtr tmpWin; | |
278 Point mousePos; | |
15702 | 279 Point winMousePos; |
12460 | 280 |
281 GetEventParameter(event, kEventParamMouseLocation, typeQDPoint, 0, sizeof(Point), 0, &mousePos); | |
15702 | 282 GetEventParameter(event, kEventParamWindowMouseLocation, typeQDPoint, 0, sizeof(Point), 0, &winMousePos); |
12460 | 283 |
284 switch (kind) | |
285 { | |
15881 | 286 case kEventMouseMoved: |
287 { | |
288 if(vo_quartz_fs) | |
289 { | |
290 ShowCursor(); | |
291 mouseHide = FALSE; | |
292 } | |
293 } | |
294 break; | |
295 | |
15702 | 296 case kEventMouseWheelMoved: |
297 { | |
298 int wheel; | |
299 short part; | |
300 | |
301 GetEventParameter(event, kEventParamMouseWheelDelta, typeSInt32, 0, sizeof(int), 0, &wheel); | |
302 | |
303 part = FindWindow(mousePos,&tmpWin); | |
304 | |
305 if(part == inContent) | |
306 { | |
307 if(wheel > 0) | |
308 mplayer_put_key(MOUSE_BTN3); | |
309 else | |
310 mplayer_put_key(MOUSE_BTN4); | |
311 } | |
312 } | |
313 break; | |
314 | |
12460 | 315 case kEventMouseDown: |
12296 | 316 { |
12460 | 317 EventMouseButton button; |
13719 | 318 short part; |
15702 | 319 Rect bounds; |
320 | |
321 GetWindowPortBounds(theWindow, &bounds); | |
12460 | 322 GetEventParameter(event, kEventParamMouseButton, typeMouseButton, 0, sizeof(EventMouseButton), 0, &button); |
323 | |
13719 | 324 part = FindWindow(mousePos,&tmpWin); |
12296 | 325 |
15702 | 326 if( (winMousePos.h > (bounds.right - 15)) && (winMousePos.v > (bounds.bottom)) ) |
327 { | |
15723 | 328 if(!vo_quartz_fs) |
329 { | |
330 GrowWindow(theWindow, mousePos, NULL); | |
331 } | |
15702 | 332 } |
333 else if(part == inMenuBar) | |
12296 | 334 { |
335 MenuSelect(mousePos); | |
12460 | 336 HiliteMenu(0); |
12296 | 337 } |
12460 | 338 else if(part == inContent) |
339 { | |
340 switch(button) | |
341 { | |
342 case 1: mplayer_put_key(MOUSE_BTN0);break; | |
343 case 2: mplayer_put_key(MOUSE_BTN2);break; | |
344 case 3: mplayer_put_key(MOUSE_BTN1);break; | |
345 | |
12624 | 346 default:result = eventNotHandledErr;break; |
12460 | 347 } |
348 } | |
349 } | |
350 break; | |
351 | |
15702 | 352 case kEventMouseUp: |
12460 | 353 break; |
354 | |
15702 | 355 case kEventMouseDragged: |
356 break; | |
357 | |
12624 | 358 default:result = eventNotHandledErr;break; |
12460 | 359 } |
360 } | |
15702 | 361 |
12624 | 362 return result; |
12296 | 363 } |
12120 | 364 |
15702 | 365 //default window event handler |
366 static OSStatus WindowEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData) | |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
367 { |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
368 OSStatus result = noErr; |
13722 | 369 uint32_t d_width; |
370 uint32_t d_height; | |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
371 UInt32 class = GetEventClass (event); |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
372 UInt32 kind = GetEventKind (event); |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
373 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
374 result = CallNextEventHandler(nextHandler, event); |
13712
f6ef5a0ad7e4
removed duplicate case and fixed aspect ratio for window zoom feature
nplourde
parents:
13707
diff
changeset
|
375 |
f6ef5a0ad7e4
removed duplicate case and fixed aspect ratio for window zoom feature
nplourde
parents:
13707
diff
changeset
|
376 aspect(&d_width,&d_height,A_NOZOOM); |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
377 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
378 if(class == kEventClassCommand) |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
379 { |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
380 HICommand theHICommand; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
381 GetEventParameter( event, kEventParamDirectObject, typeHICommand, NULL, sizeof( HICommand ), NULL, &theHICommand ); |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
382 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
383 switch ( theHICommand.commandID ) |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
384 { |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
385 case kHICommandQuit: |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
386 mplayer_put_key(KEY_ESC); |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
387 break; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
388 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
389 case kHalfScreenCmd: |
13734 | 390 if(vo_quartz_fs) |
391 { | |
392 vo_fs = (!(vo_fs)); window_fullscreen(); | |
393 } | |
394 | |
15702 | 395 SizeWindow(theWindow, (d_width/2), ((d_width/movie_aspect)/2), 1); |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
396 window_resized(); |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
397 break; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
398 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
399 case kNormalScreenCmd: |
13734 | 400 if(vo_quartz_fs) |
401 { | |
402 vo_fs = (!(vo_fs)); window_fullscreen(); | |
403 } | |
404 | |
15702 | 405 SizeWindow(theWindow, d_width, (d_width/movie_aspect), 1); |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
406 window_resized(); |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
407 break; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
408 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
409 case kDoubleScreenCmd: |
13734 | 410 if(vo_quartz_fs) |
411 { | |
412 vo_fs = (!(vo_fs)); window_fullscreen(); | |
413 } | |
414 | |
15702 | 415 SizeWindow(theWindow, (d_width*2), ((d_width/movie_aspect)*2), 1); |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
416 window_resized(); |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
417 break; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
418 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
419 case kFullScreenCmd: |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
420 vo_fs = (!(vo_fs)); window_fullscreen(); |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
421 break; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
422 |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
423 case kKeepAspectCmd: |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
424 vo_keepaspect = (!(vo_keepaspect)); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
425 CheckMenuItem (aspectMenu, 1, vo_keepaspect); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
426 break; |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
427 |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
428 case kAspectOrgCmd: |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
429 movie_aspect = old_movie_aspect; |
15702 | 430 SizeWindow(theWindow, dstRect.right, (dstRect.right/movie_aspect),1); |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
431 window_resized(); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
432 break; |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
433 |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
434 case kAspectFullCmd: |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
435 movie_aspect = 4.0f/3.0f; |
15702 | 436 SizeWindow(theWindow, dstRect.right, (dstRect.right/movie_aspect),1); |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
437 window_resized(); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
438 break; |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
439 |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
440 case kAspectWideCmd: |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
441 movie_aspect = 16.0f/9.0f; |
15702 | 442 SizeWindow(theWindow, dstRect.right, (dstRect.right/movie_aspect),1); |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
443 window_resized(); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
444 break; |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
445 |
13795 | 446 case kPanScanCmd: |
13840 | 447 vo_panscan = (!(vo_panscan)); |
448 CheckMenuItem (aspectMenu, 2, vo_panscan); | |
13795 | 449 break; |
450 | |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
451 default: |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
452 result = eventNotHandledErr; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
453 break; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
454 } |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
455 } |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
456 else if(class == kEventClassWindow) |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
457 { |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
458 WindowRef window; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
459 Rect rectPort = {0,0,0,0}; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
460 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
461 GetEventParameter(event, kEventParamDirectObject, typeWindowRef, NULL, sizeof(WindowRef), NULL, &window); |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
462 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
463 if(window) |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
464 { |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
465 GetPortBounds(GetWindowPort(window), &rectPort); |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
466 } |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
467 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
468 switch (kind) |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
469 { |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
470 case kEventWindowClosed: |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
471 theWindow = NULL; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
472 mplayer_put_key(KEY_ESC); |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
473 break; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
474 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
475 //resize window |
15702 | 476 case kEventWindowZoomed: |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
477 case kEventWindowBoundsChanged: |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
478 window_resized(); |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
479 flip_page(); |
15885
b2f434649dec
properly redraw fullscreen window with -fs and zoom
nplourde
parents:
15881
diff
changeset
|
480 window_resized(); |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
481 break; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
482 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
483 default: |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
484 result = eventNotHandledErr; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
485 break; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
486 } |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
487 } |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
488 |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
489 return result; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
490 } |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
491 |
12487 | 492 static void quartz_CreateWindow(uint32_t d_width, uint32_t d_height, WindowAttributes windowAttrs) |
493 { | |
494 CFStringRef titleKey; | |
495 CFStringRef windowTitle; | |
496 OSStatus result; | |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
497 |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
498 MenuItemIndex index; |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
499 CFStringRef movMenuTitle; |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
500 CFStringRef aspMenuTitle; |
12487 | 501 |
502 SetRect(&winRect, 0, 0, d_width, d_height); | |
503 SetRect(&oldWinRect, 0, 0, d_width, d_height); | |
504 SetRect(&dstRect, 0, 0, d_width, d_height); | |
13693
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
505 |
14081 | 506 //Clear Menu Bar |
507 ClearMenuBar(); | |
508 | |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
509 //Create Window Menu |
13693
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
510 CreateStandardWindowMenu(0, &windMenu); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
511 InsertMenu(windMenu, 0); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
512 |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
513 //Create Movie Menu |
13693
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
514 CreateNewMenu (1004, 0, &movMenu); |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
515 movMenuTitle = CFSTR("Movie"); |
13693
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
516 SetMenuTitleWithCFString(movMenu, movMenuTitle); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
517 |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
518 AppendMenuItemTextWithCFString(movMenu, CFSTR("Half Size"), 0, kHalfScreenCmd, &index); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
519 SetMenuItemCommandKey(movMenu, index, 0, '0'); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
520 |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
521 AppendMenuItemTextWithCFString(movMenu, CFSTR("Normal Size"), 0, kNormalScreenCmd, &index); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
522 SetMenuItemCommandKey(movMenu, index, 0, '1'); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
523 |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
524 AppendMenuItemTextWithCFString(movMenu, CFSTR("Double Size"), 0, kDoubleScreenCmd, &index); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
525 SetMenuItemCommandKey(movMenu, index, 0, '2'); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
526 |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
527 AppendMenuItemTextWithCFString(movMenu, CFSTR("Full Size"), 0, kFullScreenCmd, &index); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
528 SetMenuItemCommandKey(movMenu, index, 0, 'F'); |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
529 |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
530 AppendMenuItemTextWithCFString(movMenu, NULL, kMenuItemAttrSeparator, NULL, &index); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
531 |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
532 AppendMenuItemTextWithCFString(movMenu, CFSTR("Aspect Ratio"), 0, NULL, &index); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
533 |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
534 ////Create Aspect Ratio Sub Menu |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
535 CreateNewMenu (0, 0, &aspectMenu); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
536 aspMenuTitle = CFSTR("Aspect Ratio"); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
537 SetMenuTitleWithCFString(aspectMenu, aspMenuTitle); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
538 SetMenuItemHierarchicalMenu(movMenu, 6, aspectMenu); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
539 |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
540 AppendMenuItemTextWithCFString(aspectMenu, CFSTR("Keep"), 0, kKeepAspectCmd, &index); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
541 CheckMenuItem (aspectMenu, 1, vo_keepaspect); |
13795 | 542 AppendMenuItemTextWithCFString(aspectMenu, CFSTR("Pan-Scan"), 0, kPanScanCmd, &index); |
13840 | 543 CheckMenuItem (aspectMenu, 2, vo_panscan); |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
544 AppendMenuItemTextWithCFString(aspectMenu, NULL, kMenuItemAttrSeparator, NULL, &index); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
545 AppendMenuItemTextWithCFString(aspectMenu, CFSTR("Original"), 0, kAspectOrgCmd, &index); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
546 AppendMenuItemTextWithCFString(aspectMenu, CFSTR("4:3"), 0, kAspectFullCmd, &index); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
547 AppendMenuItemTextWithCFString(aspectMenu, CFSTR("16:9"), 0, kAspectWideCmd, &index); |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
548 |
13693
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
549 InsertMenu(movMenu, GetMenuID(windMenu)); //insert before Window menu |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
550 |
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
551 DrawMenuBar(); |
12487 | 552 |
13693
abba514689a1
fix menu bar support and add new movie zoom option menu a la quicktime
nplourde
parents:
13124
diff
changeset
|
553 //create window |
12487 | 554 CreateNewWindow(kDocumentWindowClass, windowAttrs, &winRect, &theWindow); |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
555 |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
556 CreateWindowGroup(0, &winGroup); |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
557 SetWindowGroup(theWindow, winGroup); |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
558 |
12487 | 559 //Set window title |
12785
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
560 titleKey = CFSTR("MPlayer - The Movie Player"); |
12487 | 561 windowTitle = CFCopyLocalizedString(titleKey, NULL); |
562 result = SetWindowTitleWithCFString(theWindow, windowTitle); | |
563 CFRelease(titleKey); | |
564 CFRelease(windowTitle); | |
565 | |
566 //Install event handler | |
15702 | 567 const EventTypeSpec win_events[] = { |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
568 { kEventClassWindow, kEventWindowClosed }, |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
569 { kEventClassWindow, kEventWindowBoundsChanged }, |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
570 { kEventClassCommand, kEventCommandProcess } |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
571 }; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
572 |
15702 | 573 const EventTypeSpec key_events[] = { |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
574 { kEventClassKeyboard, kEventRawKeyDown }, |
15702 | 575 { kEventClassKeyboard, kEventRawKeyRepeat } |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
576 }; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
577 |
15702 | 578 const EventTypeSpec mouse_events[] = { |
15881 | 579 { kEventClassMouse, kEventMouseMoved }, |
15702 | 580 { kEventClassMouse, kEventMouseWheelMoved }, |
581 { kEventClassMouse, kEventMouseDown }, | |
582 { kEventClassMouse, kEventMouseUp }, | |
583 { kEventClassMouse, kEventMouseDragged } | |
584 }; | |
585 | |
586 InstallApplicationEventHandler (NewEventHandlerUPP (KeyEventHandler), GetEventTypeCount(key_events), key_events, NULL, NULL); | |
587 InstallApplicationEventHandler (NewEventHandlerUPP (MouseEventHandler), GetEventTypeCount(mouse_events), mouse_events, NULL, NULL); | |
588 InstallWindowEventHandler (theWindow, NewEventHandlerUPP (WindowEventHandler), GetEventTypeCount(win_events), win_events, theWindow, NULL); | |
12487 | 589 } |
590 | |
12296 | 591 static uint32_t config(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t flags, char *title, uint32_t format) |
592 { | |
593 WindowAttributes windowAttrs; | |
12414 | 594 OSErr qterr; |
13719 | 595 int i; |
15702 | 596 CGRect tmpBounds; |
13719 | 597 |
12296 | 598 //Get Main device info/////////////////////////////////////////////////// |
13719 | 599 |
600 | |
12296 | 601 deviceHdl = GetMainDevice(); |
602 | |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
603 for(i=0; i<device_id; i++) |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
604 { |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
605 deviceHdl = GetNextDevice(deviceHdl); |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
606 |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
607 if(deviceHdl == NULL) |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
608 { |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
609 mp_msg(MSGT_VO, MSGL_FATAL, "Quartz error: Device ID %d do not exist, falling back to main device.\n", device_id); |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
610 deviceHdl = GetMainDevice(); |
14699
779230cb313d
set device id to 0 if the device selected on startup do not exist
nplourde
parents:
14082
diff
changeset
|
611 device_id = 0; |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
612 break; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
613 } |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
614 } |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
615 |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
616 deviceRect = (*deviceHdl)->gdRect; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
617 device_width = deviceRect.right-deviceRect.left; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
618 device_height = deviceRect.bottom-deviceRect.top; |
12296 | 619 |
13791 | 620 monitor_aspect = (float)device_width/(float)device_height; |
621 | |
12296 | 622 //misc mplayer setup///////////////////////////////////////////////////// |
12487 | 623 SetRect(&imgRect, 0, 0, width, height); |
12414 | 624 switch (image_format) |
625 { | |
626 case IMGFMT_RGB32: | |
12432 | 627 image_depth = 32; |
12414 | 628 break; |
629 case IMGFMT_YV12: | |
630 case IMGFMT_IYUV: | |
631 case IMGFMT_I420: | |
632 case IMGFMT_UYVY: | |
633 case IMGFMT_YUY2: | |
634 image_depth = 16; | |
635 break; | |
636 } | |
12487 | 637 image_size = ((imgRect.right*imgRect.bottom*image_depth)+7)/8; |
12296 | 638 |
639 vo_fs = flags & VOFLAG_FULLSCREEN; | |
640 | |
641 //get movie aspect | |
13795 | 642 panscan_init(); |
12296 | 643 aspect_save_orig(width,height); |
644 aspect_save_prescale(d_width,d_height); | |
645 aspect_save_screenres(device_width, device_height); | |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
646 |
12296 | 647 aspect(&d_width,&d_height,A_NOZOOM); |
13124 | 648 |
13793 | 649 movie_aspect = (float)d_width/(float)d_height; |
650 old_movie_aspect = movie_aspect; | |
651 | |
13124 | 652 if(image_data) |
653 free(image_data); | |
654 | |
655 image_data = malloc(image_size); | |
12296 | 656 |
657 //Create player window////////////////////////////////////////////////// | |
658 windowAttrs = kWindowStandardDocumentAttributes | |
659 | kWindowStandardHandlerAttribute | |
660 | kWindowLiveResizeAttribute; | |
12425 | 661 |
15702 | 662 windowAttrs &= (~kWindowResizableAttribute); |
663 | |
12487 | 664 if (theWindow == NULL) |
665 { | |
15702 | 666 quartz_CreateWindow(d_width, d_height, windowAttrs); |
12487 | 667 |
668 if (theWindow == NULL) | |
669 { | |
670 mp_msg(MSGT_VO, MSGL_FATAL, "Quartz error: Couldn't create window !!!!!\n"); | |
671 return -1; | |
672 } | |
15702 | 673 tmpBounds = CGRectMake( 0, 0, winRect.right, winRect.bottom); |
674 CreateCGContextForPort(GetWindowPort(theWindow),&context); | |
675 CGContextFillRect(context, tmpBounds); | |
12487 | 676 } |
677 else | |
678 { | |
679 HideWindow(theWindow); | |
680 ChangeWindowAttributes(theWindow, ~windowAttrs, windowAttrs); | |
681 SetRect(&winRect, 0, 0, d_width, d_height); | |
682 SetRect(&oldWinRect, 0, 0, d_width, d_height); | |
683 SizeWindow (theWindow, d_width, d_height, 1); | |
684 } | |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
685 |
12432 | 686 switch (image_format) |
687 { | |
13124 | 688 case IMGFMT_RGB32: |
689 { | |
690 CreateCGContextForPort (GetWindowPort (theWindow), &context); | |
691 | |
692 dataProviderRef = CGDataProviderCreateWithData (0, image_data, imgRect.right * imgRect.bottom * 4, 0); | |
693 | |
694 image = CGImageCreate (imgRect.right, | |
695 imgRect.bottom, | |
696 8, | |
697 image_depth, | |
698 ((imgRect.right*32)+7)/8, | |
699 CGColorSpaceCreateDeviceRGB(), | |
700 kCGImageAlphaNoneSkipFirst, | |
701 dataProviderRef, 0, 1, kCGRenderingIntentDefault); | |
702 break; | |
703 } | |
704 | |
12432 | 705 case IMGFMT_YV12: |
706 case IMGFMT_IYUV: | |
707 case IMGFMT_I420: | |
708 case IMGFMT_UYVY: | |
709 case IMGFMT_YUY2: | |
12424 | 710 { |
12623 | 711 get_image_done = 0; |
712 | |
713 if (!EnterMoviesDone) | |
714 { | |
715 qterr = EnterMovies(); | |
716 EnterMoviesDone = 1; | |
717 } | |
718 else | |
719 qterr = 0; | |
720 | |
721 if (qterr) | |
722 { | |
723 mp_msg(MSGT_VO, MSGL_FATAL, "Quartz error: EnterMovies (%d)\n", qterr); | |
724 return -1; | |
725 } | |
726 | |
727 | |
728 SetIdentityMatrix(&matrix); | |
729 | |
730 if ((d_width != width) || (d_height != height)) | |
731 { | |
732 ScaleMatrix(&matrix, FixDiv(Long2Fix(d_width),Long2Fix(width)), FixDiv(Long2Fix(d_height),Long2Fix(height)), 0, 0); | |
733 } | |
734 | |
12432 | 735 yuv_qt_stuff.desc = (ImageDescriptionHandle)NewHandleClear( sizeof(ImageDescription) ); |
12424 | 736 |
12432 | 737 yuv_qt_stuff.extension_colr = NewHandleClear(sizeof(NCLCColorInfoImageDescriptionExtension)); |
738 ((NCLCColorInfoImageDescriptionExtension*)(*yuv_qt_stuff.extension_colr))->colorParamType = kVideoColorInfoImageDescriptionExtensionType; | |
739 ((NCLCColorInfoImageDescriptionExtension*)(*yuv_qt_stuff.extension_colr))->primaries = 2; | |
740 ((NCLCColorInfoImageDescriptionExtension*)(*yuv_qt_stuff.extension_colr))->transferFunction = 2; | |
741 ((NCLCColorInfoImageDescriptionExtension*)(*yuv_qt_stuff.extension_colr))->matrix = 2; | |
742 | |
743 yuv_qt_stuff.extension_fiel = NewHandleClear(sizeof(FieldInfoImageDescriptionExtension)); | |
744 ((FieldInfoImageDescriptionExtension*)(*yuv_qt_stuff.extension_fiel))->fieldCount = 1; | |
745 ((FieldInfoImageDescriptionExtension*)(*yuv_qt_stuff.extension_fiel))->fieldOrderings = 0; | |
12424 | 746 |
12432 | 747 yuv_qt_stuff.extension_clap = NewHandleClear(sizeof(CleanApertureImageDescriptionExtension)); |
12487 | 748 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->cleanApertureWidthN = imgRect.right; |
12432 | 749 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->cleanApertureWidthD = 1; |
12487 | 750 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->cleanApertureHeightN = imgRect.bottom; |
12432 | 751 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->cleanApertureHeightD = 1; |
752 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->horizOffN = 0; | |
753 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->horizOffD = 1; | |
754 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->vertOffN = 0; | |
755 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->vertOffD = 1; | |
756 | |
757 yuv_qt_stuff.extension_pasp = NewHandleClear(sizeof(PixelAspectRatioImageDescriptionExtension)); | |
758 ((PixelAspectRatioImageDescriptionExtension*)(*yuv_qt_stuff.extension_pasp))->hSpacing = 1; | |
759 ((PixelAspectRatioImageDescriptionExtension*)(*yuv_qt_stuff.extension_pasp))->vSpacing = 1; | |
760 | |
761 (*yuv_qt_stuff.desc)->idSize = sizeof(ImageDescription); | |
762 (*yuv_qt_stuff.desc)->cType = image_qtcodec; | |
763 (*yuv_qt_stuff.desc)->version = 2; | |
764 (*yuv_qt_stuff.desc)->revisionLevel = 0; | |
765 (*yuv_qt_stuff.desc)->vendor = 'mpla'; | |
12487 | 766 (*yuv_qt_stuff.desc)->width = imgRect.right; |
767 (*yuv_qt_stuff.desc)->height = imgRect.bottom; | |
12432 | 768 (*yuv_qt_stuff.desc)->hRes = Long2Fix(72); |
769 (*yuv_qt_stuff.desc)->vRes = Long2Fix(72); | |
770 (*yuv_qt_stuff.desc)->temporalQuality = 0; | |
771 (*yuv_qt_stuff.desc)->spatialQuality = codecLosslessQuality; | |
772 (*yuv_qt_stuff.desc)->frameCount = 1; | |
773 (*yuv_qt_stuff.desc)->dataSize = 0; | |
774 (*yuv_qt_stuff.desc)->depth = 24; | |
775 (*yuv_qt_stuff.desc)->clutID = -1; | |
12424 | 776 |
12432 | 777 qterr = AddImageDescriptionExtension(yuv_qt_stuff.desc, yuv_qt_stuff.extension_colr, kColorInfoImageDescriptionExtension); |
778 if (qterr) | |
779 { | |
12487 | 780 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: AddImageDescriptionExtension [colr] (%d)\n", qterr); |
12432 | 781 } |
782 | |
783 qterr = AddImageDescriptionExtension(yuv_qt_stuff.desc, yuv_qt_stuff.extension_fiel, kFieldInfoImageDescriptionExtension); | |
784 if (qterr) | |
785 { | |
12487 | 786 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: AddImageDescriptionExtension [fiel] (%d)\n", qterr); |
12432 | 787 } |
788 | |
789 qterr = AddImageDescriptionExtension(yuv_qt_stuff.desc, yuv_qt_stuff.extension_clap, kCleanApertureImageDescriptionExtension); | |
790 if (qterr) | |
791 { | |
12487 | 792 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: AddImageDescriptionExtension [clap] (%d)\n", qterr); |
12432 | 793 } |
794 | |
795 qterr = AddImageDescriptionExtension(yuv_qt_stuff.desc, yuv_qt_stuff.extension_pasp, kCleanApertureImageDescriptionExtension); | |
796 if (qterr) | |
797 { | |
12487 | 798 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: AddImageDescriptionExtension [pasp] (%d)\n", qterr); |
12432 | 799 } |
12487 | 800 if (P != NULL) { // second or subsequent movie |
801 free(P); | |
802 } | |
12432 | 803 P = calloc(sizeof(PlanarPixmapInfoYUV420) + image_size, 1); |
804 switch (image_format) | |
805 { | |
806 case IMGFMT_YV12: | |
807 case IMGFMT_IYUV: | |
808 case IMGFMT_I420: | |
809 P->componentInfoY.offset = sizeof(PlanarPixmapInfoYUV420); | |
810 P->componentInfoCb.offset = P->componentInfoY.offset + image_size / 2; | |
811 P->componentInfoCr.offset = P->componentInfoCb.offset + image_size / 4; | |
12487 | 812 P->componentInfoY.rowBytes = imgRect.right; |
813 P->componentInfoCb.rowBytes = imgRect.right / 2; | |
814 P->componentInfoCr.rowBytes = imgRect.right / 2; | |
12432 | 815 image_buffer_size = image_size + sizeof(PlanarPixmapInfoYUV420); |
816 break; | |
817 case IMGFMT_UYVY: | |
818 case IMGFMT_YUY2: | |
819 image_buffer_size = image_size; | |
820 break; | |
821 } | |
12414 | 822 |
12432 | 823 qterr = DecompressSequenceBeginS(&seqId, |
12414 | 824 yuv_qt_stuff.desc, |
12432 | 825 (char *)P, |
12414 | 826 image_buffer_size, |
12623 | 827 GetWindowPort(theWindow), |
12432 | 828 NULL, |
829 NULL, | |
12414 | 830 ((d_width != width) || (d_height != height)) ? |
12432 | 831 &matrix : NULL, |
12414 | 832 srcCopy, |
12432 | 833 NULL, |
834 0, | |
12414 | 835 codecLosslessQuality, |
836 bestSpeedCodec); | |
12432 | 837 |
838 if (qterr) | |
839 { | |
840 mp_msg(MSGT_VO, MSGL_FATAL, "Quartz error: DecompressSequenceBeginS (%d)\n", qterr); | |
12487 | 841 return -1; |
12432 | 842 } |
12424 | 843 } |
12432 | 844 break; |
12414 | 845 } |
12296 | 846 |
15885
b2f434649dec
properly redraw fullscreen window with -fs and zoom
nplourde
parents:
15881
diff
changeset
|
847 //Show window |
b2f434649dec
properly redraw fullscreen window with -fs and zoom
nplourde
parents:
15881
diff
changeset
|
848 RepositionWindow(theWindow, NULL, kWindowCenterOnMainScreen); |
b2f434649dec
properly redraw fullscreen window with -fs and zoom
nplourde
parents:
15881
diff
changeset
|
849 ShowWindow (theWindow); |
b2f434649dec
properly redraw fullscreen window with -fs and zoom
nplourde
parents:
15881
diff
changeset
|
850 |
12296 | 851 if(vo_fs) |
852 window_fullscreen(); | |
853 | |
854 if(vo_ontop) | |
855 window_ontop(); | |
12888 | 856 |
12912
1f6bb2356d18
add var vo_rootwin and -rootwin switch for mac osx
nplourde
parents:
12889
diff
changeset
|
857 if(vo_rootwin) |
12888 | 858 { |
859 vo_fs = TRUE; | |
860 winLevel = 0; | |
861 SetWindowGroupLevel(winGroup, CGWindowLevelForKey(levelList[winLevel])); | |
862 window_fullscreen(); | |
863 } | |
12296 | 864 |
15885
b2f434649dec
properly redraw fullscreen window with -fs and zoom
nplourde
parents:
15881
diff
changeset
|
865 window_resized(); |
15702 | 866 |
12296 | 867 return 0; |
12120 | 868 } |
869 | |
12296 | 870 static void check_events(void) |
12120 | 871 { |
12296 | 872 EventRef theEvent; |
873 EventTargetRef theTarget; | |
874 OSStatus theErr; | |
875 | |
876 //Get event | |
877 theTarget = GetEventDispatcherTarget(); | |
878 theErr = ReceiveNextEvent(0, 0, kEventDurationNoWait,true, &theEvent); | |
879 if(theErr == noErr && theEvent != NULL) | |
880 { | |
881 SendEventToEventTarget (theEvent, theTarget); | |
882 ReleaseEvent(theEvent); | |
883 } | |
12120 | 884 |
12296 | 885 //update activity every 30 seconds to prevent |
886 //screensaver from starting up. | |
887 DateTimeRec d; | |
888 unsigned long curTime; | |
889 static unsigned long lastTime = 0; | |
890 | |
891 GetTime(&d); | |
892 DateToSeconds( &d, &curTime); | |
893 | |
894 if( ( (curTime - lastTime) >= 30) || (lastTime == 0)) | |
895 { | |
896 UpdateSystemActivity(UsrActivity); | |
897 lastTime = curTime; | |
898 } | |
899 } | |
12120 | 900 |
12296 | 901 static void draw_osd(void) |
902 { | |
12487 | 903 vo_draw_text(imgRect.right,imgRect.bottom,draw_alpha); |
12296 | 904 } |
12120 | 905 |
12296 | 906 static void flip_page(void) |
907 { | |
13707
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
908 if(theWindow == NULL) |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
909 return; |
3fff37ed4fe7
Fixed event handling for menubar and window close button.
nplourde
parents:
13693
diff
changeset
|
910 |
12432 | 911 switch (image_format) |
912 { | |
13124 | 913 case IMGFMT_RGB32: |
914 { | |
915 CGContextDrawImage (context, bounds, image); | |
916 } | |
917 break; | |
918 | |
12433 | 919 case IMGFMT_YV12: |
920 case IMGFMT_IYUV: | |
921 case IMGFMT_I420: | |
922 case IMGFMT_UYVY: | |
923 case IMGFMT_YUY2: | |
924 if (EnterMoviesDone) | |
925 { | |
926 OSErr qterr; | |
927 CodecFlags flags = 0; | |
928 qterr = DecompressSequenceFrameWhen(seqId, | |
929 (char *)P, | |
930 image_buffer_size, | |
931 0, //codecFlagUseImageBuffer, | |
932 &flags, | |
933 NULL, | |
934 NULL); | |
935 if (qterr) | |
936 { | |
12487 | 937 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: DecompressSequenceFrameWhen in flip_page (%d) flags:0x%08x\n", qterr, flags); |
12433 | 938 } |
939 } | |
940 break; | |
941 } | |
15723 | 942 |
943 if(!vo_quartz_fs) | |
944 { | |
945 //render resize box | |
946 CGContextBeginPath(context); | |
947 CGContextSetAllowsAntialiasing(context, false); | |
948 //CGContextSaveGState(context); | |
949 | |
950 //line white | |
951 CGContextSetRGBStrokeColor (context, 0.2, 0.2, 0.2, 0.5); | |
952 CGContextMoveToPoint( context, winRect.right-1, 1); CGContextAddLineToPoint( context, winRect.right-1, 1); | |
953 CGContextMoveToPoint( context, winRect.right-1, 5); CGContextAddLineToPoint( context, winRect.right-5, 1); | |
954 CGContextMoveToPoint( context, winRect.right-1, 9); CGContextAddLineToPoint( context, winRect.right-9, 1); | |
955 CGContextStrokePath( context ); | |
956 | |
957 //line gray | |
958 CGContextSetRGBStrokeColor (context, 0.4, 0.4, 0.4, 0.5); | |
959 CGContextMoveToPoint( context, winRect.right-1, 2); CGContextAddLineToPoint( context, winRect.right-2, 1); | |
960 CGContextMoveToPoint( context, winRect.right-1, 6); CGContextAddLineToPoint( context, winRect.right-6, 1); | |
961 CGContextMoveToPoint( context, winRect.right-1, 10); CGContextAddLineToPoint( context, winRect.right-10, 1); | |
962 CGContextStrokePath( context ); | |
963 | |
964 //line black | |
965 CGContextSetRGBStrokeColor (context, 0.6, 0.6, 0.6, 0.5); | |
966 CGContextMoveToPoint( context, winRect.right-1, 3); CGContextAddLineToPoint( context, winRect.right-3, 1); | |
967 CGContextMoveToPoint( context, winRect.right-1, 7); CGContextAddLineToPoint( context, winRect.right-7, 1); | |
968 CGContextMoveToPoint( context, winRect.right-1, 11); CGContextAddLineToPoint( context, winRect.right-11, 1); | |
969 CGContextStrokePath( context ); | |
970 | |
971 //CGContextRestoreGState( context ); | |
972 CGContextFlush (context); | |
973 } | |
15881 | 974 |
975 //auto hide mouse cursor and futur on-screen control? | |
976 if(vo_quartz_fs && !mouseHide) | |
977 { | |
978 DateTimeRec d; | |
979 unsigned long curTime; | |
980 static unsigned long lastTime = 0; | |
981 | |
982 GetTime(&d); | |
983 DateToSeconds( &d, &curTime); | |
984 | |
985 if( ((curTime - lastTime) >= 5) || (lastTime == 0) ) | |
986 { | |
987 HideCursor(); | |
988 mouseHide = TRUE; | |
989 lastTime = curTime; | |
990 } | |
991 } | |
12296 | 992 } |
993 | |
994 static uint32_t draw_slice(uint8_t *src[], int stride[], int w,int h,int x,int y) | |
995 { | |
12433 | 996 switch (image_format) |
997 { | |
12487 | 998 case IMGFMT_YV12: |
999 case IMGFMT_I420: | |
1000 memcpy_pic(((char*)P) + P->componentInfoY.offset + x + imgRect.right * y, src[0], w, h, imgRect.right, stride[0]); | |
1001 x=x/2;y=y/2;w=w/2;h=h/2; | |
1002 | |
1003 memcpy_pic(((char*)P) + P->componentInfoCb.offset + x + imgRect.right / 2 * y, src[1], w, h, imgRect.right / 2, stride[1]); | |
1004 memcpy_pic(((char*)P) + P->componentInfoCr.offset + x + imgRect.right / 2 * y, src[2], w, h, imgRect.right / 2, stride[2]); | |
1005 return 0; | |
1006 | |
1007 case IMGFMT_IYUV: | |
1008 memcpy_pic(((char*)P) + P->componentInfoY.offset + x + imgRect.right * y, src[0], w, h, imgRect.right, stride[0]); | |
1009 x=x/2;y=y/2;w=w/2;h=h/2; | |
1010 | |
1011 memcpy_pic(((char*)P) + P->componentInfoCr.offset + x + imgRect.right / 2 * y, src[1], w, h, imgRect.right / 2, stride[1]); | |
1012 memcpy_pic(((char*)P) + P->componentInfoCb.offset + x + imgRect.right / 2 * y, src[2], w, h, imgRect.right / 2, stride[2]); | |
1013 return 0; | |
12433 | 1014 } |
12296 | 1015 return -1; |
1016 } | |
1017 | |
1018 static uint32_t draw_frame(uint8_t *src[]) | |
1019 { | |
12433 | 1020 switch (image_format) |
1021 { | |
13124 | 1022 case IMGFMT_RGB32: |
1023 memcpy(image_data,src[0],image_size); | |
1024 return 0; | |
1025 | |
12433 | 1026 case IMGFMT_UYVY: |
1027 case IMGFMT_YUY2: | |
12487 | 1028 memcpy_pic(((char*)P), src[0], imgRect.right * 2, imgRect.bottom, imgRect.right * 2, imgRect.right * 2); |
12433 | 1029 return 0; |
1030 } | |
1031 return -1; | |
12296 | 1032 } |
12120 | 1033 |
12296 | 1034 static uint32_t query_format(uint32_t format) |
1035 { | |
1036 image_format = format; | |
12432 | 1037 image_qtcodec = 0; |
13124 | 1038 |
1039 if (format == IMGFMT_RGB32) | |
1040 { | |
1041 return VFCAP_CSP_SUPPORTED | VFCAP_OSD | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN; | |
1042 } | |
12432 | 1043 |
12424 | 1044 if ((format == IMGFMT_YV12) || (format == IMGFMT_IYUV) || (format == IMGFMT_I420)) |
1045 { | |
1046 image_qtcodec = kMpegYUV420CodecType; //kYUV420CodecType ?; | |
12487 | 1047 return VFCAP_CSP_SUPPORTED | VFCAP_OSD | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN | VFCAP_ACCEPT_STRIDE; |
12414 | 1048 } |
1049 | |
12424 | 1050 if (format == IMGFMT_YUY2) |
1051 { | |
1052 image_qtcodec = kComponentVideoUnsigned; | |
12487 | 1053 return VFCAP_CSP_SUPPORTED | VFCAP_OSD | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN; |
12414 | 1054 } |
1055 | |
12424 | 1056 if (format == IMGFMT_UYVY) |
1057 { | |
1058 image_qtcodec = k422YpCbCr8CodecType; | |
12487 | 1059 return VFCAP_CSP_SUPPORTED | VFCAP_OSD | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN; |
12424 | 1060 } |
12414 | 1061 |
12296 | 1062 return 0; |
1063 } | |
12120 | 1064 |
12296 | 1065 static void uninit(void) |
1066 { | |
12432 | 1067 OSErr qterr; |
13124 | 1068 |
1069 switch (image_format) | |
12432 | 1070 { |
13124 | 1071 case IMGFMT_YV12: |
1072 case IMGFMT_IYUV: | |
1073 case IMGFMT_I420: | |
1074 case IMGFMT_UYVY: | |
1075 case IMGFMT_YUY2: | |
12432 | 1076 { |
13124 | 1077 if (EnterMoviesDone) |
1078 { | |
1079 qterr = CDSequenceEnd(seqId); | |
1080 if (qterr) | |
1081 { | |
1082 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: CDSequenceEnd (%d)\n", qterr); | |
1083 } | |
1084 } | |
1085 break; | |
12424 | 1086 } |
13124 | 1087 default: |
1088 break; | |
12414 | 1089 } |
12432 | 1090 |
12296 | 1091 ShowMenuBar(); |
1092 } | |
12120 | 1093 |
12296 | 1094 static uint32_t preinit(const char *arg) |
1095 { | |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1096 int parse_err = 0; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1097 |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1098 if(arg) |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1099 { |
12623 | 1100 char *parse_pos = (char *)&arg[0]; |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1101 while (parse_pos[0] && !parse_err) |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1102 { |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1103 if (strncmp (parse_pos, "device_id=", 10) == 0) |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1104 { |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1105 parse_pos = &parse_pos[10]; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1106 device_id = strtol(parse_pos, &parse_pos, 0); |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1107 } |
13788
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1108 if (strncmp (parse_pos, "fs_res=", 7) == 0) |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1109 { |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1110 parse_pos = &parse_pos[7]; |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1111 fs_res_x = strtol(parse_pos, &parse_pos, 0); |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1112 parse_pos = &parse_pos[1]; |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1113 fs_res_y = strtol(parse_pos, &parse_pos, 0); |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1114 } |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1115 if (parse_pos[0] == ':') parse_pos = &parse_pos[1]; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1116 else if (parse_pos[0]) parse_err = 1; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1117 } |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
1118 } |
12785
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1119 |
14082 | 1120 #if !defined (MACOSX_FINDER_SUPPORT) || !defined (HAVE_SDL) |
12785
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1121 //this chunk of code is heavily based off SDL_macosx.m from SDL |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1122 //it uses an Apple private function to request foreground operation |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1123 |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1124 void CPSEnableForegroundOperation(ProcessSerialNumber* psn); |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1125 ProcessSerialNumber myProc, frProc; |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1126 Boolean sameProc; |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1127 |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1128 if (GetFrontProcess(&frProc) == noErr) |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1129 { |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1130 if (GetCurrentProcess(&myProc) == noErr) |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1131 { |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1132 if (SameProcess(&frProc, &myProc, &sameProc) == noErr && !sameProc) |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1133 { |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1134 CPSEnableForegroundOperation(&myProc); |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1135 } |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1136 SetFrontProcess(&myProc); |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1137 } |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1138 } |
13909
07dadc3066f3
add support for macosx finder argument support (let you bundle mplayer to be a finder compliant .app) patch by Chris Roccati <roccati@pobox.com>
nplourde
parents:
13856
diff
changeset
|
1139 #endif |
12785
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
1140 |
12296 | 1141 return 0; |
12120 | 1142 } |
1143 | |
12424 | 1144 static uint32_t draw_yuv_image(mp_image_t *mpi) |
1145 { | |
1146 // ATM we're only called for planar IMGFMT | |
1147 // drawing is done directly in P | |
1148 // and displaying is in flip_page. | |
12487 | 1149 return get_image_done ? VO_TRUE : VO_FALSE; |
12414 | 1150 } |
1151 | |
12424 | 1152 static uint32_t get_yuv_image(mp_image_t *mpi) |
1153 { | |
1154 if(mpi->type!=MP_IMGTYPE_EXPORT) return VO_FALSE; | |
12414 | 1155 |
12424 | 1156 if(mpi->imgfmt!=image_format) return VO_FALSE; |
12414 | 1157 |
12424 | 1158 if(mpi->flags&MP_IMGFLAG_PLANAR) |
1159 { | |
1160 if (mpi->num_planes != 3) | |
1161 { | |
1162 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: only 3 planes allowed in get_yuv_image for planar (%d) \n", mpi->num_planes); | |
1163 return VO_FALSE; | |
1164 } | |
12414 | 1165 |
12424 | 1166 mpi->planes[0]=((char*)P) + P->componentInfoY.offset; |
12487 | 1167 mpi->stride[0]=imgRect.right; |
1168 mpi->width=imgRect.right; | |
12414 | 1169 |
12424 | 1170 if(mpi->flags&MP_IMGFLAG_SWAPPED) |
1171 { | |
1172 // I420 | |
1173 mpi->planes[1]=((char*)P) + P->componentInfoCb.offset; | |
1174 mpi->planes[2]=((char*)P) + P->componentInfoCr.offset; | |
12487 | 1175 mpi->stride[1]=imgRect.right/2; |
1176 mpi->stride[2]=imgRect.right/2; | |
12424 | 1177 } |
1178 else | |
1179 { | |
1180 // YV12 | |
1181 mpi->planes[1]=((char*)P) + P->componentInfoCr.offset; | |
1182 mpi->planes[2]=((char*)P) + P->componentInfoCb.offset; | |
12487 | 1183 mpi->stride[1]=imgRect.right/2; |
1184 mpi->stride[2]=imgRect.right/2; | |
12424 | 1185 } |
1186 | |
1187 mpi->flags|=MP_IMGFLAG_DIRECT; | |
12487 | 1188 get_image_done = 1; |
12424 | 1189 return VO_TRUE; |
1190 } | |
1191 else | |
12433 | 1192 { |
1193 // doesn't work yet | |
12424 | 1194 if (mpi->num_planes != 1) |
1195 { | |
1196 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: only 1 plane allowed in get_yuv_image for packed (%d) \n", mpi->num_planes); | |
1197 return VO_FALSE; | |
1198 } | |
12414 | 1199 |
12424 | 1200 mpi->planes[0] = (char*)P; |
12487 | 1201 mpi->stride[0] = imgRect.right * 2; |
1202 mpi->width=imgRect.right; | |
12424 | 1203 mpi->flags|=MP_IMGFLAG_DIRECT; |
12487 | 1204 get_image_done = 1; |
12424 | 1205 return VO_TRUE; |
1206 } | |
1207 return VO_FALSE; | |
12414 | 1208 } |
1209 | |
12296 | 1210 static uint32_t control(uint32_t request, void *data, ...) |
12120 | 1211 { |
12424 | 1212 switch (request) |
1213 { | |
1214 case VOCTRL_PAUSE: return (int_pause=1); | |
1215 case VOCTRL_RESUME: return (int_pause=0); | |
12460 | 1216 case VOCTRL_FULLSCREEN: vo_fs = (!(vo_fs)); window_fullscreen(); return VO_TRUE; |
1217 case VOCTRL_ONTOP: vo_ontop = (!(vo_ontop)); window_ontop(); return VO_TRUE; | |
12424 | 1218 case VOCTRL_QUERY_FORMAT: return query_format(*((uint32_t*)data)); |
13795 | 1219 case VOCTRL_GET_PANSCAN: return VO_TRUE; |
13840 | 1220 case VOCTRL_SET_PANSCAN: window_panscan(); return VO_TRUE; |
13795 | 1221 |
12424 | 1222 case VOCTRL_GET_IMAGE: |
1223 switch (image_format) | |
1224 { | |
1225 case IMGFMT_YV12: | |
1226 case IMGFMT_IYUV: | |
1227 case IMGFMT_I420: | |
12487 | 1228 case IMGFMT_UYVY: |
1229 case IMGFMT_YUY2: | |
12424 | 1230 return get_yuv_image(data); |
1231 break; | |
12487 | 1232 default: |
1233 break; | |
12424 | 1234 } |
1235 case VOCTRL_DRAW_IMAGE: | |
1236 switch (image_format) | |
1237 { | |
1238 case IMGFMT_YV12: | |
1239 case IMGFMT_IYUV: | |
1240 case IMGFMT_I420: | |
12487 | 1241 case IMGFMT_UYVY: |
1242 case IMGFMT_YUY2: | |
12424 | 1243 return draw_yuv_image(data); |
1244 break; | |
12487 | 1245 default: |
1246 break; | |
12424 | 1247 } |
1248 } | |
1249 return VO_NOTIMPL; | |
12120 | 1250 } |
1251 | |
12296 | 1252 void window_resized() |
12120 | 1253 { |
12296 | 1254 float aspectX; |
1255 float aspectY; | |
1256 | |
13855 | 1257 int padding = 0; |
12296 | 1258 |
1259 uint32_t d_width; | |
1260 uint32_t d_height; | |
1261 | |
13779 | 1262 CGRect tmpBounds; |
13734 | 1263 |
12623 | 1264 GetPortBounds( GetWindowPort(theWindow), &winRect ); |
12120 | 1265 |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
1266 if(vo_keepaspect) |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
1267 { |
12296 | 1268 aspect( &d_width, &d_height, A_NOZOOM); |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
1269 d_height = ((float)d_width/movie_aspect); |
12296 | 1270 |
1271 aspectX = (float)((float)winRect.right/(float)d_width); | |
15702 | 1272 aspectY = (float)((float)(winRect.bottom)/(float)d_height); |
12296 | 1273 |
15702 | 1274 if((d_height*aspectX)>(winRect.bottom)) |
12296 | 1275 { |
1276 padding = (winRect.right - d_width*aspectY)/2; | |
1277 SetRect(&dstRect, padding, 0, d_width*aspectY+padding, d_height*aspectY); | |
1278 } | |
1279 else | |
1280 { | |
15702 | 1281 padding = ((winRect.bottom) - d_height*aspectX)/2; |
12296 | 1282 SetRect(&dstRect, 0, padding, (d_width*aspectX), d_height*aspectX+padding); |
1283 } | |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
1284 } |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
1285 else |
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
1286 { |
15702 | 1287 SetRect(&dstRect, 0, 0, winRect.right, winRect.bottom); |
13792
d603c33bb3d3
menu option to set desired movie aspect & keep aspect on window resize
nplourde
parents:
13791
diff
changeset
|
1288 } |
13124 | 1289 |
1290 switch (image_format) | |
12432 | 1291 { |
13124 | 1292 case IMGFMT_RGB32: |
1293 { | |
15702 | 1294 bounds = CGRectMake(dstRect.left, dstRect.top, dstRect.right-dstRect.left, dstRect.bottom-dstRect.top); |
13124 | 1295 CreateCGContextForPort (GetWindowPort (theWindow), &context); |
1296 break; | |
1297 } | |
1298 case IMGFMT_YV12: | |
1299 case IMGFMT_IYUV: | |
1300 case IMGFMT_I420: | |
1301 case IMGFMT_UYVY: | |
1302 case IMGFMT_YUY2: | |
12432 | 1303 { |
13124 | 1304 long scale_X = FixDiv(Long2Fix(dstRect.right - dstRect.left),Long2Fix(imgRect.right)); |
1305 long scale_Y = FixDiv(Long2Fix(dstRect.bottom - dstRect.top),Long2Fix(imgRect.bottom)); | |
1306 | |
1307 SetIdentityMatrix(&matrix); | |
1308 if (((dstRect.right - dstRect.left) != imgRect.right) || ((dstRect.bottom - dstRect.right) != imgRect.bottom)) | |
1309 { | |
1310 ScaleMatrix(&matrix, scale_X, scale_Y, 0, 0); | |
1311 | |
1312 if (padding > 0) | |
1313 { | |
1314 TranslateMatrix(&matrix, Long2Fix(dstRect.left), Long2Fix(dstRect.top)); | |
1315 } | |
1316 } | |
1317 | |
1318 SetDSequenceMatrix(seqId, &matrix); | |
1319 break; | |
12432 | 1320 } |
13124 | 1321 default: |
1322 break; | |
12432 | 1323 } |
15702 | 1324 |
1325 //Clear Background | |
1326 tmpBounds = CGRectMake( 0, 0, winRect.right, winRect.bottom); | |
1327 CreateCGContextForPort(GetWindowPort(theWindow),&context); | |
1328 CGContextFillRect(context, tmpBounds); | |
12120 | 1329 } |
1330 | |
12296 | 1331 void window_ontop() |
12460 | 1332 { |
13788
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1333 if(!vo_quartz_fs) |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1334 { |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
1335 //Cycle between level |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
1336 winLevel++; |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
1337 if(winLevel>2) |
15524 | 1338 winLevel = 1; |
13788
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1339 } |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
1340 SetWindowGroupLevel(winGroup, CGWindowLevelForKey(levelList[winLevel])); |
12120 | 1341 } |
1342 | |
12296 | 1343 void window_fullscreen() |
12120 | 1344 { |
13788
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1345 static Ptr restoreState = NULL; |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1346 |
12296 | 1347 //go fullscreen |
12432 | 1348 if(vo_fs) |
12296 | 1349 { |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
1350 if(winLevel != 0) |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
1351 { |
13841
394deaee5d21
do not hide mouse and menubar in fulscreen if not using main device
nplourde
parents:
13840
diff
changeset
|
1352 if(device_id == 0) |
394deaee5d21
do not hide mouse and menubar in fulscreen if not using main device
nplourde
parents:
13840
diff
changeset
|
1353 { |
15881 | 1354 SetSystemUIMode( kUIModeAllHidden, kUIOptionAutoShowMenuBar); |
13841
394deaee5d21
do not hide mouse and menubar in fulscreen if not using main device
nplourde
parents:
13840
diff
changeset
|
1355 HideCursor(); |
15881 | 1356 mouseHide = 1; |
13841
394deaee5d21
do not hide mouse and menubar in fulscreen if not using main device
nplourde
parents:
13840
diff
changeset
|
1357 } |
13788
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1358 |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1359 if(fs_res_x != 0 || fs_res_y != 0) |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1360 { |
13840 | 1361 BeginFullScreen( &restoreState, deviceHdl, &fs_res_x, &fs_res_y, NULL, NULL, NULL); |
13788
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1362 |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1363 //Get Main device info/////////////////////////////////////////////////// |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1364 deviceRect = (*deviceHdl)->gdRect; |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1365 |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1366 device_width = deviceRect.right; |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1367 device_height = deviceRect.bottom; |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1368 } |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
1369 } |
12120 | 1370 |
12296 | 1371 //save old window size |
12487 | 1372 if (!vo_quartz_fs) |
13818
9f707a805967
window now save is old position when going in fullscreen or while using resize preset
nplourde
parents:
13796
diff
changeset
|
1373 { |
12487 | 1374 GetWindowPortBounds(theWindow, &oldWinRect); |
13818
9f707a805967
window now save is old position when going in fullscreen or while using resize preset
nplourde
parents:
13796
diff
changeset
|
1375 GetWindowBounds(theWindow, kWindowContentRgn, &oldWinBounds); |
9f707a805967
window now save is old position when going in fullscreen or while using resize preset
nplourde
parents:
13796
diff
changeset
|
1376 } |
12296 | 1377 |
1378 //go fullscreen | |
13840 | 1379 panscan_calc(); |
15702 | 1380 ChangeWindowAttributes(theWindow, kWindowNoShadowAttribute, 0); |
13840 | 1381 MoveWindow(theWindow, deviceRect.left-(vo_panscan_x >> 1), deviceRect.top-(vo_panscan_y >> 1), 1); |
1382 SizeWindow(theWindow, device_width+vo_panscan_x, device_height+vo_panscan_y,1); | |
12487 | 1383 |
1384 vo_quartz_fs = 1; | |
12296 | 1385 } |
1386 else //go back to windowed mode | |
1387 { | |
13788
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1388 if(restoreState != NULL) |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1389 { |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1390 EndFullScreen(restoreState, NULL); |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1391 |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1392 //Get Main device info/////////////////////////////////////////////////// |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1393 deviceRect = (*deviceHdl)->gdRect; |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1394 |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1395 device_width = deviceRect.right; |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1396 device_height = deviceRect.bottom; |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1397 restoreState = NULL; |
ced61fa921ca
let you choose fullscreen resolution for slower system
nplourde
parents:
13787
diff
changeset
|
1398 } |
15881 | 1399 SetSystemUIMode( kUIModeNormal, NULL); |
12120 | 1400 |
12296 | 1401 //show mouse cursor |
1402 ShowCursor(); | |
15881 | 1403 mouseHide = 0; |
12296 | 1404 |
1405 //revert window to previous setting | |
15702 | 1406 ChangeWindowAttributes(theWindow, 0, kWindowNoShadowAttribute); |
12487 | 1407 SizeWindow(theWindow, oldWinRect.right, oldWinRect.bottom,1); |
13818
9f707a805967
window now save is old position when going in fullscreen or while using resize preset
nplourde
parents:
13796
diff
changeset
|
1408 MoveWindow(theWindow, oldWinBounds.left, oldWinBounds.top, 1); |
12487 | 1409 |
1410 vo_quartz_fs = 0; | |
12296 | 1411 } |
15702 | 1412 window_resized(); |
12120 | 1413 } |
13840 | 1414 |
1415 void window_panscan() | |
1416 { | |
1417 panscan_calc(); | |
1418 | |
1419 if(vo_panscan > 0) | |
1420 CheckMenuItem (aspectMenu, 2, 1); | |
1421 else | |
1422 CheckMenuItem (aspectMenu, 2, 0); | |
1423 | |
1424 if(vo_quartz_fs) | |
1425 { | |
1426 MoveWindow(theWindow, deviceRect.left-(vo_panscan_x >> 1), deviceRect.top-(vo_panscan_y >> 1), 1); | |
1427 SizeWindow(theWindow, device_width+vo_panscan_x, device_height+vo_panscan_y,1); | |
1428 } | |
1429 } |