Mercurial > mplayer.hg
annotate libvo/vo_quartz.c @ 12849:2f1ba5dc43b4
removed unnecessary comments
author | paszczi |
---|---|
date | Sun, 18 Jul 2004 22:10:54 +0000 |
parents | b177cc8afdc0 |
children | 9b95958f4eb0 |
rev | line source |
---|---|
12296 | 1 /* |
2 vo_quartz.c | |
3 | |
4 by Nicolas Plourde <nicolasplourde@hotmail.com> | |
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 | |
12785
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
12 todo: -RGB32 color space support |
12460 | 13 -screen overlay output |
12623 | 14 -while mouse button down event mplayer is locked, fix that |
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 |
34 #include "../input/input.h" | |
35 #include "../input/mouse.h" | |
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 |
12296 | 70 extern int vo_ontop; |
12487 | 71 extern int vo_fs; // user want fullscreen |
72 static int vo_quartz_fs; // we are in fullscreen | |
12120 | 73 |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
74 static int winLevel = 1; |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
75 int levelList[] = |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
76 { |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
77 kCGDesktopWindowLevelKey, |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
78 kCGNormalWindowLevelKey, |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
79 kCGScreenSaverWindowLevelKey |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
80 }; |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
81 |
12487 | 82 static int int_pause = 0; |
83 static float winAlpha = 1; | |
12296 | 84 |
12487 | 85 static int device_width; |
86 static int device_height; | |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
87 static int device_id; |
12120 | 88 |
12487 | 89 static WindowRef theWindow = NULL; |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
90 static WindowGroupRef winGroup = NULL; |
12296 | 91 |
12487 | 92 static Rect imgRect; // size of the original image (unscaled) |
93 static Rect dstRect; // size of the displayed image (after scaling) | |
94 static Rect winRect; // size of the window containg the displayed image (include padding) | |
95 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
|
96 static Rect deviceRect; // size of the display device |
12296 | 97 |
12120 | 98 #include "../osdep/keycodes.h" |
12296 | 99 extern void mplayer_put_key(int code); |
100 | |
101 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 | 102 |
103 //PROTOTYPE///////////////////////////////////////////////////////////////// | |
12296 | 104 void window_resized(); |
105 void window_ontop(); | |
106 void window_fullscreen(); | |
12120 | 107 |
12460 | 108 static OSStatus MainEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData); |
12296 | 109 |
110 static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src, unsigned char *srca, int stride) | |
111 { | |
12424 | 112 switch (image_format) |
113 { | |
114 case IMGFMT_RGB32: | |
115 vo_draw_alpha_rgb32(w,h,src,srca,stride,image_data+4*(y0*imgRect.right+x0),4*imgRect.right); | |
116 break; | |
117 case IMGFMT_YV12: | |
118 case IMGFMT_IYUV: | |
119 case IMGFMT_I420: | |
12487 | 120 vo_draw_alpha_yv12(w,h,src,srca,stride, ((char*)P) + P->componentInfoY.offset + x0 + y0 * imgRect.right, imgRect.right); |
12424 | 121 break; |
122 case IMGFMT_UYVY: | |
12517 | 123 vo_draw_alpha_uyvy(w,h,src,srca,stride,((char*)P) + (x0 + y0 * imgRect.right) * 2,imgRect.right*2); |
12424 | 124 break; |
125 case IMGFMT_YUY2: | |
12487 | 126 vo_draw_alpha_yuy2(w,h,src,srca,stride,((char*)P) + (x0 + y0 * imgRect.right) * 2,imgRect.right*2); |
12424 | 127 break; |
12487 | 128 } |
12296 | 129 } |
12120 | 130 |
131 //default window event handler | |
12460 | 132 static OSStatus MainEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData) |
12120 | 133 { |
12624 | 134 OSStatus result = noErr; |
12460 | 135 UInt32 class = GetEventClass (event); |
136 UInt32 kind = GetEventKind (event); | |
12624 | 137 |
138 result = CallNextEventHandler(nextHandler, event); | |
139 | |
12460 | 140 if(class == kEventClassWindow) |
141 { | |
142 WindowRef window; | |
143 Rect rectPort = {0,0,0,0}; | |
144 | |
145 GetEventParameter(event, kEventParamDirectObject, typeWindowRef, NULL, sizeof(WindowRef), NULL, &window); | |
146 | |
147 if(window) | |
148 { | |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
149 GetPortBounds(GetWindowPort(window), &rectPort); |
12460 | 150 } |
12296 | 151 |
12460 | 152 switch (kind) |
153 { | |
154 //close window | |
155 case kEventWindowClosed: | |
156 mplayer_put_key(KEY_ESC); | |
157 break; | |
158 | |
159 //resize window | |
160 case kEventWindowBoundsChanged: | |
161 window_resized(); | |
162 flip_page(); | |
163 break; | |
164 | |
12624 | 165 default:result = eventNotHandledErr;break; |
12460 | 166 } |
167 } | |
168 else if(class == kEventClassKeyboard) | |
169 { | |
170 char macCharCodes; | |
171 UInt32 macKeyCode; | |
172 UInt32 macKeyModifiers; | |
173 | |
174 GetEventParameter(event, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(macCharCodes), NULL, &macCharCodes); | |
175 GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL, sizeof(macKeyCode), NULL, &macKeyCode); | |
176 GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(macKeyModifiers), NULL, &macKeyModifiers); | |
12296 | 177 |
12460 | 178 switch (kind) |
12296 | 179 { |
12460 | 180 case kEventRawKeyDown: |
181 { | |
182 switch(macKeyCode) | |
12624 | 183 { |
184 case QZ_IBOOK_ENTER: | |
12460 | 185 case QZ_RETURN: mplayer_put_key(KEY_ENTER);break; |
186 case QZ_ESCAPE: mplayer_put_key(KEY_ESC);break; | |
12624 | 187 case QZ_BACKSPACE: mplayer_put_key(KEY_BACKSPACE);break; |
188 case QZ_LALT: mplayer_put_key(KEY_BACKSPACE);break; | |
189 case QZ_LCTRL: mplayer_put_key(KEY_BACKSPACE);break; | |
190 case QZ_LSHIFT: mplayer_put_key(KEY_BACKSPACE);break; | |
12460 | 191 case QZ_F1: mplayer_put_key(KEY_F+1);break; |
192 case QZ_F2: mplayer_put_key(KEY_F+2);break; | |
193 case QZ_F3: mplayer_put_key(KEY_F+3);break; | |
194 case QZ_F4: mplayer_put_key(KEY_F+4);break; | |
195 case QZ_F5: mplayer_put_key(KEY_F+5);break; | |
196 case QZ_F6: mplayer_put_key(KEY_F+6);break; | |
197 case QZ_F7: mplayer_put_key(KEY_F+7);break; | |
198 case QZ_F8: mplayer_put_key(KEY_F+8);break; | |
199 case QZ_F9: mplayer_put_key(KEY_F+9);break; | |
200 case QZ_F10: mplayer_put_key(KEY_F+10);break; | |
201 case QZ_F11: mplayer_put_key(KEY_F+11);break; | |
202 case QZ_F12: mplayer_put_key(KEY_F+12);break; | |
12624 | 203 case QZ_INSERT: mplayer_put_key(KEY_INSERT);break; |
204 case QZ_DELETE: mplayer_put_key(KEY_DELETE);break; | |
205 case QZ_HOME: mplayer_put_key(KEY_HOME);break; | |
206 case QZ_END: mplayer_put_key(KEY_END);break; | |
12460 | 207 case QZ_KP_PLUS: mplayer_put_key('+');break; |
208 case QZ_KP_MINUS: mplayer_put_key('-');break; | |
12624 | 209 case QZ_TAB: mplayer_put_key(KEY_TAB);break; |
12460 | 210 case QZ_PAGEUP: mplayer_put_key(KEY_PAGE_UP);break; |
211 case QZ_PAGEDOWN: mplayer_put_key(KEY_PAGE_DOWN);break; | |
212 case QZ_UP: mplayer_put_key(KEY_UP);break; | |
213 case QZ_DOWN: mplayer_put_key(KEY_DOWN);break; | |
214 case QZ_LEFT: mplayer_put_key(KEY_LEFT);break; | |
215 case QZ_RIGHT: mplayer_put_key(KEY_RIGHT);break; | |
12624 | 216 case QZ_KP_MULTIPLY: mplayer_put_key('*');break; |
217 case QZ_KP_DIVIDE: mplayer_put_key('/');break; | |
218 case QZ_KP_ENTER: mplayer_put_key(KEY_BACKSPACE);break; | |
219 case QZ_KP_PERIOD: mplayer_put_key(KEY_KPDEC); break; | |
12460 | 220 case QZ_KP0: mplayer_put_key(KEY_KP0); break; |
221 case QZ_KP1: mplayer_put_key(KEY_KP1); break; | |
222 case QZ_KP2: mplayer_put_key(KEY_KP2); break; | |
223 case QZ_KP3: mplayer_put_key(KEY_KP3); break; | |
224 case QZ_KP4: mplayer_put_key(KEY_KP4); break; | |
225 case QZ_KP5: mplayer_put_key(KEY_KP5); break; | |
226 case QZ_KP6: mplayer_put_key(KEY_KP6); break; | |
227 case QZ_KP7: mplayer_put_key(KEY_KP7); break; | |
228 case QZ_KP8: mplayer_put_key(KEY_KP8); break; | |
229 case QZ_KP9: mplayer_put_key(KEY_KP9); break; | |
230 case QZ_LEFTBRACKET: SetWindowAlpha(theWindow, winAlpha-=0.05);break; | |
231 case QZ_RIGHTBRACKET: SetWindowAlpha(theWindow, winAlpha+=0.05);break; | |
12624 | 232 |
12460 | 233 default:mplayer_put_key(macCharCodes);break; |
234 } | |
235 } | |
236 | |
12624 | 237 default:result = eventNotHandledErr;break; |
12460 | 238 } |
239 } | |
240 else if(class == kEventClassMouse) | |
241 { | |
242 WindowPtr tmpWin; | |
243 Point mousePos; | |
244 | |
245 GetEventParameter(event, kEventParamMouseLocation, typeQDPoint, 0, sizeof(Point), 0, &mousePos); | |
246 | |
247 switch (kind) | |
248 { | |
249 case kEventMouseDown: | |
12296 | 250 { |
12460 | 251 EventMouseButton button; |
252 GetEventParameter(event, kEventParamMouseButton, typeMouseButton, 0, sizeof(EventMouseButton), 0, &button); | |
253 | |
12296 | 254 short part = FindWindow(mousePos,&tmpWin); |
255 | |
256 if(part == inMenuBar) | |
257 { | |
258 MenuSelect(mousePos); | |
12460 | 259 HiliteMenu(0); |
12296 | 260 } |
12460 | 261 else if(part == inContent) |
262 { | |
263 switch(button) | |
264 { | |
265 case 1: mplayer_put_key(MOUSE_BTN0);break; | |
266 case 2: mplayer_put_key(MOUSE_BTN2);break; | |
267 case 3: mplayer_put_key(MOUSE_BTN1);break; | |
268 | |
12624 | 269 default:result = eventNotHandledErr;break; |
12460 | 270 } |
271 } | |
272 } | |
273 break; | |
274 | |
275 case kEventMouseWheelMoved: | |
276 { | |
277 int wheel; | |
278 GetEventParameter(event, kEventParamMouseWheelDelta, typeSInt32, 0, sizeof(int), 0, &wheel); | |
279 | |
280 short part = FindWindow(mousePos,&tmpWin); | |
281 | |
282 if(part == inContent) | |
283 { | |
284 if(wheel > 0) | |
285 mplayer_put_key(MOUSE_BTN3); | |
286 else | |
287 mplayer_put_key(MOUSE_BTN4); | |
288 } | |
289 } | |
290 break; | |
291 | |
12624 | 292 default:result = eventNotHandledErr;break; |
12460 | 293 } |
294 } | |
295 | |
12624 | 296 return result; |
12296 | 297 } |
12120 | 298 |
12487 | 299 static void quartz_CreateWindow(uint32_t d_width, uint32_t d_height, WindowAttributes windowAttrs) |
300 { | |
301 CFStringRef titleKey; | |
302 CFStringRef windowTitle; | |
303 OSStatus result; | |
304 | |
305 SetRect(&winRect, 0, 0, d_width, d_height); | |
306 SetRect(&oldWinRect, 0, 0, d_width, d_height); | |
307 SetRect(&dstRect, 0, 0, d_width, d_height); | |
308 | |
309 CreateNewWindow(kDocumentWindowClass, windowAttrs, &winRect, &theWindow); | |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
310 |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
311 CreateWindowGroup(0, &winGroup); |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
312 SetWindowGroup(theWindow, winGroup); |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
313 |
12487 | 314 //Set window title |
12785
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
315 titleKey = CFSTR("MPlayer - The Movie Player"); |
12487 | 316 windowTitle = CFCopyLocalizedString(titleKey, NULL); |
317 result = SetWindowTitleWithCFString(theWindow, windowTitle); | |
318 CFRelease(titleKey); | |
319 CFRelease(windowTitle); | |
320 | |
321 //Install event handler | |
322 const EventTypeSpec winEvents[] = { { kEventClassKeyboard, kEventRawKeyDown }, | |
323 { kEventClassMouse, kEventMouseDown }, | |
324 { kEventClassMouse, kEventMouseWheelMoved }, | |
325 { kEventClassWindow, kEventWindowClosed }, | |
326 { kEventClassWindow, kEventWindowBoundsChanged } }; | |
327 | |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
328 InstallApplicationEventHandler (NewEventHandlerUPP (MainEventHandler), GetEventTypeCount(winEvents), winEvents, NULL, NULL); |
12487 | 329 } |
330 | |
12296 | 331 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) |
332 { | |
333 WindowAttributes windowAttrs; | |
334 GDHandle deviceHdl; | |
12414 | 335 OSErr qterr; |
12296 | 336 |
337 //Get Main device info/////////////////////////////////////////////////// | |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
338 int i; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
339 |
12296 | 340 deviceHdl = GetMainDevice(); |
341 | |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
342 for(i=0; i<device_id; i++) |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
343 { |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
344 deviceHdl = GetNextDevice(deviceHdl); |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
345 |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
346 if(deviceHdl == NULL) |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
347 { |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
348 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
|
349 deviceHdl = GetMainDevice(); |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
350 break; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
351 } |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
352 } |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
353 |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
354 deviceRect = (*deviceHdl)->gdRect; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
355 device_width = deviceRect.right-deviceRect.left; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
356 device_height = deviceRect.bottom-deviceRect.top; |
12296 | 357 |
358 //misc mplayer setup///////////////////////////////////////////////////// | |
12487 | 359 SetRect(&imgRect, 0, 0, width, height); |
12414 | 360 switch (image_format) |
361 { | |
362 case IMGFMT_RGB32: | |
12432 | 363 image_depth = 32; |
12414 | 364 break; |
365 case IMGFMT_YV12: | |
366 case IMGFMT_IYUV: | |
367 case IMGFMT_I420: | |
368 case IMGFMT_UYVY: | |
369 case IMGFMT_YUY2: | |
370 image_depth = 16; | |
371 break; | |
372 } | |
12487 | 373 image_size = ((imgRect.right*imgRect.bottom*image_depth)+7)/8; |
12296 | 374 |
375 vo_fs = flags & VOFLAG_FULLSCREEN; | |
376 | |
377 //get movie aspect | |
378 aspect_save_orig(width,height); | |
379 aspect_save_prescale(d_width,d_height); | |
380 aspect_save_screenres(device_width, device_height); | |
381 | |
382 aspect(&d_width,&d_height,A_NOZOOM); | |
383 | |
384 //Create player window////////////////////////////////////////////////// | |
385 windowAttrs = kWindowStandardDocumentAttributes | |
386 | kWindowStandardHandlerAttribute | |
387 | kWindowLiveResizeAttribute; | |
12425 | 388 |
12432 | 389 windowAttrs &= (~kWindowResizableAttribute); |
12296 | 390 |
12487 | 391 if (theWindow == NULL) |
392 { | |
393 quartz_CreateWindow(d_width, d_height, windowAttrs); | |
394 | |
395 if (theWindow == NULL) | |
396 { | |
397 mp_msg(MSGT_VO, MSGL_FATAL, "Quartz error: Couldn't create window !!!!!\n"); | |
398 return -1; | |
399 } | |
400 } | |
401 else | |
402 { | |
403 HideWindow(theWindow); | |
404 ChangeWindowAttributes(theWindow, ~windowAttrs, windowAttrs); | |
405 SetRect(&winRect, 0, 0, d_width, d_height); | |
406 SetRect(&oldWinRect, 0, 0, d_width, d_height); | |
407 SizeWindow (theWindow, d_width, d_height, 1); | |
408 } | |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
409 |
12623 | 410 SetPort(GetWindowPort(theWindow)); |
12433 | 411 |
12432 | 412 switch (image_format) |
413 { | |
414 case IMGFMT_YV12: | |
415 case IMGFMT_IYUV: | |
416 case IMGFMT_I420: | |
417 case IMGFMT_UYVY: | |
418 case IMGFMT_YUY2: | |
12424 | 419 { |
12623 | 420 get_image_done = 0; |
421 | |
422 if (!EnterMoviesDone) | |
423 { | |
424 qterr = EnterMovies(); | |
425 EnterMoviesDone = 1; | |
426 } | |
427 else | |
428 qterr = 0; | |
429 | |
430 if (qterr) | |
431 { | |
432 mp_msg(MSGT_VO, MSGL_FATAL, "Quartz error: EnterMovies (%d)\n", qterr); | |
433 return -1; | |
434 } | |
435 | |
436 | |
437 SetIdentityMatrix(&matrix); | |
438 | |
439 if ((d_width != width) || (d_height != height)) | |
440 { | |
441 ScaleMatrix(&matrix, FixDiv(Long2Fix(d_width),Long2Fix(width)), FixDiv(Long2Fix(d_height),Long2Fix(height)), 0, 0); | |
442 } | |
443 | |
12432 | 444 yuv_qt_stuff.desc = (ImageDescriptionHandle)NewHandleClear( sizeof(ImageDescription) ); |
12424 | 445 |
12432 | 446 yuv_qt_stuff.extension_colr = NewHandleClear(sizeof(NCLCColorInfoImageDescriptionExtension)); |
447 ((NCLCColorInfoImageDescriptionExtension*)(*yuv_qt_stuff.extension_colr))->colorParamType = kVideoColorInfoImageDescriptionExtensionType; | |
448 ((NCLCColorInfoImageDescriptionExtension*)(*yuv_qt_stuff.extension_colr))->primaries = 2; | |
449 ((NCLCColorInfoImageDescriptionExtension*)(*yuv_qt_stuff.extension_colr))->transferFunction = 2; | |
450 ((NCLCColorInfoImageDescriptionExtension*)(*yuv_qt_stuff.extension_colr))->matrix = 2; | |
451 | |
452 yuv_qt_stuff.extension_fiel = NewHandleClear(sizeof(FieldInfoImageDescriptionExtension)); | |
453 ((FieldInfoImageDescriptionExtension*)(*yuv_qt_stuff.extension_fiel))->fieldCount = 1; | |
454 ((FieldInfoImageDescriptionExtension*)(*yuv_qt_stuff.extension_fiel))->fieldOrderings = 0; | |
12424 | 455 |
12432 | 456 yuv_qt_stuff.extension_clap = NewHandleClear(sizeof(CleanApertureImageDescriptionExtension)); |
12487 | 457 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->cleanApertureWidthN = imgRect.right; |
12432 | 458 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->cleanApertureWidthD = 1; |
12487 | 459 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->cleanApertureHeightN = imgRect.bottom; |
12432 | 460 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->cleanApertureHeightD = 1; |
461 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->horizOffN = 0; | |
462 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->horizOffD = 1; | |
463 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->vertOffN = 0; | |
464 ((CleanApertureImageDescriptionExtension*)(*yuv_qt_stuff.extension_clap))->vertOffD = 1; | |
465 | |
466 yuv_qt_stuff.extension_pasp = NewHandleClear(sizeof(PixelAspectRatioImageDescriptionExtension)); | |
467 ((PixelAspectRatioImageDescriptionExtension*)(*yuv_qt_stuff.extension_pasp))->hSpacing = 1; | |
468 ((PixelAspectRatioImageDescriptionExtension*)(*yuv_qt_stuff.extension_pasp))->vSpacing = 1; | |
469 | |
470 (*yuv_qt_stuff.desc)->idSize = sizeof(ImageDescription); | |
471 (*yuv_qt_stuff.desc)->cType = image_qtcodec; | |
472 (*yuv_qt_stuff.desc)->version = 2; | |
473 (*yuv_qt_stuff.desc)->revisionLevel = 0; | |
474 (*yuv_qt_stuff.desc)->vendor = 'mpla'; | |
12487 | 475 (*yuv_qt_stuff.desc)->width = imgRect.right; |
476 (*yuv_qt_stuff.desc)->height = imgRect.bottom; | |
12432 | 477 (*yuv_qt_stuff.desc)->hRes = Long2Fix(72); |
478 (*yuv_qt_stuff.desc)->vRes = Long2Fix(72); | |
479 (*yuv_qt_stuff.desc)->temporalQuality = 0; | |
480 (*yuv_qt_stuff.desc)->spatialQuality = codecLosslessQuality; | |
481 (*yuv_qt_stuff.desc)->frameCount = 1; | |
482 (*yuv_qt_stuff.desc)->dataSize = 0; | |
483 (*yuv_qt_stuff.desc)->depth = 24; | |
484 (*yuv_qt_stuff.desc)->clutID = -1; | |
12424 | 485 |
12432 | 486 qterr = AddImageDescriptionExtension(yuv_qt_stuff.desc, yuv_qt_stuff.extension_colr, kColorInfoImageDescriptionExtension); |
487 if (qterr) | |
488 { | |
12487 | 489 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: AddImageDescriptionExtension [colr] (%d)\n", qterr); |
12432 | 490 } |
491 | |
492 qterr = AddImageDescriptionExtension(yuv_qt_stuff.desc, yuv_qt_stuff.extension_fiel, kFieldInfoImageDescriptionExtension); | |
493 if (qterr) | |
494 { | |
12487 | 495 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: AddImageDescriptionExtension [fiel] (%d)\n", qterr); |
12432 | 496 } |
497 | |
498 qterr = AddImageDescriptionExtension(yuv_qt_stuff.desc, yuv_qt_stuff.extension_clap, kCleanApertureImageDescriptionExtension); | |
499 if (qterr) | |
500 { | |
12487 | 501 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: AddImageDescriptionExtension [clap] (%d)\n", qterr); |
12432 | 502 } |
503 | |
504 qterr = AddImageDescriptionExtension(yuv_qt_stuff.desc, yuv_qt_stuff.extension_pasp, kCleanApertureImageDescriptionExtension); | |
505 if (qterr) | |
506 { | |
12487 | 507 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: AddImageDescriptionExtension [pasp] (%d)\n", qterr); |
12432 | 508 } |
12487 | 509 if (P != NULL) { // second or subsequent movie |
510 free(P); | |
511 } | |
12432 | 512 P = calloc(sizeof(PlanarPixmapInfoYUV420) + image_size, 1); |
513 switch (image_format) | |
514 { | |
515 case IMGFMT_YV12: | |
516 case IMGFMT_IYUV: | |
517 case IMGFMT_I420: | |
518 P->componentInfoY.offset = sizeof(PlanarPixmapInfoYUV420); | |
519 P->componentInfoCb.offset = P->componentInfoY.offset + image_size / 2; | |
520 P->componentInfoCr.offset = P->componentInfoCb.offset + image_size / 4; | |
12487 | 521 P->componentInfoY.rowBytes = imgRect.right; |
522 P->componentInfoCb.rowBytes = imgRect.right / 2; | |
523 P->componentInfoCr.rowBytes = imgRect.right / 2; | |
12432 | 524 image_buffer_size = image_size + sizeof(PlanarPixmapInfoYUV420); |
525 break; | |
526 case IMGFMT_UYVY: | |
527 case IMGFMT_YUY2: | |
528 image_buffer_size = image_size; | |
529 break; | |
530 } | |
12414 | 531 |
12432 | 532 qterr = DecompressSequenceBeginS(&seqId, |
12414 | 533 yuv_qt_stuff.desc, |
12432 | 534 (char *)P, |
12414 | 535 image_buffer_size, |
12623 | 536 GetWindowPort(theWindow), |
12432 | 537 NULL, |
538 NULL, | |
12414 | 539 ((d_width != width) || (d_height != height)) ? |
12432 | 540 &matrix : NULL, |
12414 | 541 srcCopy, |
12432 | 542 NULL, |
543 0, | |
12414 | 544 codecLosslessQuality, |
545 bestSpeedCodec); | |
12432 | 546 |
547 if (qterr) | |
548 { | |
549 mp_msg(MSGT_VO, MSGL_FATAL, "Quartz error: DecompressSequenceBeginS (%d)\n", qterr); | |
12487 | 550 return -1; |
12432 | 551 } |
12424 | 552 } |
12432 | 553 break; |
12414 | 554 } |
555 | |
12424 | 556 //Show window |
557 RepositionWindow(theWindow, NULL, kWindowCascadeOnMainScreen); | |
12296 | 558 ShowWindow (theWindow); |
559 | |
560 if(vo_fs) | |
561 window_fullscreen(); | |
562 | |
563 if(vo_ontop) | |
564 window_ontop(); | |
565 | |
566 return 0; | |
12120 | 567 } |
568 | |
12296 | 569 static void check_events(void) |
12120 | 570 { |
12296 | 571 EventRef theEvent; |
572 EventTargetRef theTarget; | |
573 OSStatus theErr; | |
574 | |
575 //Get event | |
576 theTarget = GetEventDispatcherTarget(); | |
577 theErr = ReceiveNextEvent(0, 0, kEventDurationNoWait,true, &theEvent); | |
578 if(theErr == noErr && theEvent != NULL) | |
579 { | |
580 SendEventToEventTarget (theEvent, theTarget); | |
581 ReleaseEvent(theEvent); | |
582 } | |
12120 | 583 |
12296 | 584 //update activity every 30 seconds to prevent |
585 //screensaver from starting up. | |
586 DateTimeRec d; | |
587 unsigned long curTime; | |
588 static unsigned long lastTime = 0; | |
589 | |
590 GetTime(&d); | |
591 DateToSeconds( &d, &curTime); | |
592 | |
593 if( ( (curTime - lastTime) >= 30) || (lastTime == 0)) | |
594 { | |
595 UpdateSystemActivity(UsrActivity); | |
596 lastTime = curTime; | |
597 } | |
598 } | |
12120 | 599 |
12296 | 600 static void draw_osd(void) |
601 { | |
12487 | 602 vo_draw_text(imgRect.right,imgRect.bottom,draw_alpha); |
12296 | 603 } |
12120 | 604 |
12296 | 605 static void flip_page(void) |
606 { | |
12432 | 607 switch (image_format) |
608 { | |
12433 | 609 case IMGFMT_YV12: |
610 case IMGFMT_IYUV: | |
611 case IMGFMT_I420: | |
612 case IMGFMT_UYVY: | |
613 case IMGFMT_YUY2: | |
614 if (EnterMoviesDone) | |
615 { | |
616 OSErr qterr; | |
617 CodecFlags flags = 0; | |
618 qterr = DecompressSequenceFrameWhen(seqId, | |
619 (char *)P, | |
620 image_buffer_size, | |
621 0, //codecFlagUseImageBuffer, | |
622 &flags, | |
623 NULL, | |
624 NULL); | |
625 if (qterr) | |
626 { | |
12487 | 627 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: DecompressSequenceFrameWhen in flip_page (%d) flags:0x%08x\n", qterr, flags); |
12433 | 628 } |
629 } | |
630 break; | |
631 } | |
12296 | 632 } |
633 | |
634 static uint32_t draw_slice(uint8_t *src[], int stride[], int w,int h,int x,int y) | |
635 { | |
12433 | 636 switch (image_format) |
637 { | |
12487 | 638 case IMGFMT_YV12: |
639 case IMGFMT_I420: | |
640 memcpy_pic(((char*)P) + P->componentInfoY.offset + x + imgRect.right * y, src[0], w, h, imgRect.right, stride[0]); | |
641 x=x/2;y=y/2;w=w/2;h=h/2; | |
642 | |
643 memcpy_pic(((char*)P) + P->componentInfoCb.offset + x + imgRect.right / 2 * y, src[1], w, h, imgRect.right / 2, stride[1]); | |
644 memcpy_pic(((char*)P) + P->componentInfoCr.offset + x + imgRect.right / 2 * y, src[2], w, h, imgRect.right / 2, stride[2]); | |
645 return 0; | |
646 | |
647 case IMGFMT_IYUV: | |
648 memcpy_pic(((char*)P) + P->componentInfoY.offset + x + imgRect.right * y, src[0], w, h, imgRect.right, stride[0]); | |
649 x=x/2;y=y/2;w=w/2;h=h/2; | |
650 | |
651 memcpy_pic(((char*)P) + P->componentInfoCr.offset + x + imgRect.right / 2 * y, src[1], w, h, imgRect.right / 2, stride[1]); | |
652 memcpy_pic(((char*)P) + P->componentInfoCb.offset + x + imgRect.right / 2 * y, src[2], w, h, imgRect.right / 2, stride[2]); | |
653 return 0; | |
12433 | 654 } |
12296 | 655 return -1; |
656 } | |
657 | |
658 static uint32_t draw_frame(uint8_t *src[]) | |
659 { | |
12433 | 660 switch (image_format) |
661 { | |
662 case IMGFMT_UYVY: | |
663 case IMGFMT_YUY2: | |
12487 | 664 memcpy_pic(((char*)P), src[0], imgRect.right * 2, imgRect.bottom, imgRect.right * 2, imgRect.right * 2); |
12433 | 665 return 0; |
666 } | |
667 return -1; | |
12296 | 668 } |
12120 | 669 |
12296 | 670 static uint32_t query_format(uint32_t format) |
671 { | |
672 image_format = format; | |
12432 | 673 image_qtcodec = 0; |
674 | |
12424 | 675 if ((format == IMGFMT_YV12) || (format == IMGFMT_IYUV) || (format == IMGFMT_I420)) |
676 { | |
677 image_qtcodec = kMpegYUV420CodecType; //kYUV420CodecType ?; | |
12487 | 678 return VFCAP_CSP_SUPPORTED | VFCAP_OSD | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN | VFCAP_ACCEPT_STRIDE; |
12414 | 679 } |
680 | |
12424 | 681 if (format == IMGFMT_YUY2) |
682 { | |
683 image_qtcodec = kComponentVideoUnsigned; | |
12487 | 684 return VFCAP_CSP_SUPPORTED | VFCAP_OSD | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN; |
12414 | 685 } |
686 | |
12424 | 687 if (format == IMGFMT_UYVY) |
688 { | |
689 image_qtcodec = k422YpCbCr8CodecType; | |
12487 | 690 return VFCAP_CSP_SUPPORTED | VFCAP_OSD | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN; |
12424 | 691 } |
12414 | 692 |
12296 | 693 return 0; |
694 } | |
12120 | 695 |
12296 | 696 static void uninit(void) |
697 { | |
12432 | 698 OSErr qterr; |
12424 | 699 |
12432 | 700 if (EnterMoviesDone) |
701 { | |
702 qterr = CDSequenceEnd(seqId); | |
703 if (qterr) | |
704 { | |
12487 | 705 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: CDSequenceEnd (%d)\n", qterr); |
12424 | 706 } |
12414 | 707 } |
12432 | 708 |
12296 | 709 ShowMenuBar(); |
710 } | |
12120 | 711 |
12296 | 712 static uint32_t preinit(const char *arg) |
713 { | |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
714 int parse_err = 0; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
715 |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
716 if(arg) |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
717 { |
12623 | 718 char *parse_pos = (char *)&arg[0]; |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
719 while (parse_pos[0] && !parse_err) |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
720 { |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
721 if (strncmp (parse_pos, "device_id=", 10) == 0) |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
722 { |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
723 parse_pos = &parse_pos[10]; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
724 device_id = strtol(parse_pos, &parse_pos, 0); |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
725 } |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
726 if (parse_pos[0] == ':') parse_pos = &parse_pos[1]; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
727 else if (parse_pos[0]) parse_err = 1; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
728 } |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
729 } |
12785
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
730 |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
731 //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
|
732 //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
|
733 |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
734 void CPSEnableForegroundOperation(ProcessSerialNumber* psn); |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
735 ProcessSerialNumber myProc, frProc; |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
736 Boolean sameProc; |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
737 |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
738 if (GetFrontProcess(&frProc) == noErr) |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
739 { |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
740 if (GetCurrentProcess(&myProc) == noErr) |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
741 { |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
742 if (SameProcess(&frProc, &myProc, &sameProc) == noErr && !sameProc) |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
743 { |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
744 CPSEnableForegroundOperation(&myProc); |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
745 } |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
746 SetFrontProcess(&myProc); |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
747 } |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
748 } |
33f58bfc8a1b
make mplayer capable of being in the foreground by Dan Christiansen
nplourde
parents:
12624
diff
changeset
|
749 |
12296 | 750 return 0; |
12120 | 751 } |
752 | |
12424 | 753 static uint32_t draw_yuv_image(mp_image_t *mpi) |
754 { | |
755 // ATM we're only called for planar IMGFMT | |
756 // drawing is done directly in P | |
757 // and displaying is in flip_page. | |
12487 | 758 return get_image_done ? VO_TRUE : VO_FALSE; |
12414 | 759 } |
760 | |
12424 | 761 static uint32_t get_yuv_image(mp_image_t *mpi) |
762 { | |
763 if(mpi->type!=MP_IMGTYPE_EXPORT) return VO_FALSE; | |
12414 | 764 |
12424 | 765 if(mpi->imgfmt!=image_format) return VO_FALSE; |
12414 | 766 |
12424 | 767 if(mpi->flags&MP_IMGFLAG_PLANAR) |
768 { | |
769 if (mpi->num_planes != 3) | |
770 { | |
771 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: only 3 planes allowed in get_yuv_image for planar (%d) \n", mpi->num_planes); | |
772 return VO_FALSE; | |
773 } | |
12414 | 774 |
12424 | 775 mpi->planes[0]=((char*)P) + P->componentInfoY.offset; |
12487 | 776 mpi->stride[0]=imgRect.right; |
777 mpi->width=imgRect.right; | |
12414 | 778 |
12424 | 779 if(mpi->flags&MP_IMGFLAG_SWAPPED) |
780 { | |
781 // I420 | |
782 mpi->planes[1]=((char*)P) + P->componentInfoCb.offset; | |
783 mpi->planes[2]=((char*)P) + P->componentInfoCr.offset; | |
12487 | 784 mpi->stride[1]=imgRect.right/2; |
785 mpi->stride[2]=imgRect.right/2; | |
12424 | 786 } |
787 else | |
788 { | |
789 // YV12 | |
790 mpi->planes[1]=((char*)P) + P->componentInfoCr.offset; | |
791 mpi->planes[2]=((char*)P) + P->componentInfoCb.offset; | |
12487 | 792 mpi->stride[1]=imgRect.right/2; |
793 mpi->stride[2]=imgRect.right/2; | |
12424 | 794 } |
795 | |
796 mpi->flags|=MP_IMGFLAG_DIRECT; | |
12487 | 797 get_image_done = 1; |
12424 | 798 return VO_TRUE; |
799 } | |
800 else | |
12433 | 801 { |
802 // doesn't work yet | |
12424 | 803 if (mpi->num_planes != 1) |
804 { | |
805 mp_msg(MSGT_VO, MSGL_ERR, "Quartz error: only 1 plane allowed in get_yuv_image for packed (%d) \n", mpi->num_planes); | |
806 return VO_FALSE; | |
807 } | |
12414 | 808 |
12424 | 809 mpi->planes[0] = (char*)P; |
12487 | 810 mpi->stride[0] = imgRect.right * 2; |
811 mpi->width=imgRect.right; | |
12424 | 812 mpi->flags|=MP_IMGFLAG_DIRECT; |
12487 | 813 get_image_done = 1; |
12424 | 814 return VO_TRUE; |
815 } | |
816 return VO_FALSE; | |
12414 | 817 } |
818 | |
12296 | 819 static uint32_t control(uint32_t request, void *data, ...) |
12120 | 820 { |
12424 | 821 switch (request) |
822 { | |
823 case VOCTRL_PAUSE: return (int_pause=1); | |
824 case VOCTRL_RESUME: return (int_pause=0); | |
12460 | 825 case VOCTRL_FULLSCREEN: vo_fs = (!(vo_fs)); window_fullscreen(); return VO_TRUE; |
826 case VOCTRL_ONTOP: vo_ontop = (!(vo_ontop)); window_ontop(); return VO_TRUE; | |
12424 | 827 case VOCTRL_QUERY_FORMAT: return query_format(*((uint32_t*)data)); |
828 case VOCTRL_GET_IMAGE: | |
829 switch (image_format) | |
830 { | |
831 case IMGFMT_YV12: | |
832 case IMGFMT_IYUV: | |
833 case IMGFMT_I420: | |
12487 | 834 case IMGFMT_UYVY: |
835 case IMGFMT_YUY2: | |
12424 | 836 return get_yuv_image(data); |
837 break; | |
12487 | 838 default: |
839 break; | |
12424 | 840 } |
841 case VOCTRL_DRAW_IMAGE: | |
842 switch (image_format) | |
843 { | |
844 case IMGFMT_YV12: | |
845 case IMGFMT_IYUV: | |
846 case IMGFMT_I420: | |
12487 | 847 case IMGFMT_UYVY: |
848 case IMGFMT_YUY2: | |
12424 | 849 return draw_yuv_image(data); |
850 break; | |
12487 | 851 default: |
852 break; | |
12424 | 853 } |
854 } | |
855 return VO_NOTIMPL; | |
12120 | 856 } |
857 | |
12296 | 858 void window_resized() |
12120 | 859 { |
12296 | 860 float aspectX; |
861 float aspectY; | |
862 | |
863 int padding; | |
864 | |
865 uint32_t d_width; | |
866 uint32_t d_height; | |
867 | |
12623 | 868 GetPortBounds( GetWindowPort(theWindow), &winRect ); |
12120 | 869 |
12296 | 870 aspect( &d_width, &d_height, A_NOZOOM); |
871 | |
872 aspectX = (float)((float)winRect.right/(float)d_width); | |
873 aspectY = (float)((float)winRect.bottom/(float)d_height); | |
874 | |
875 if((d_height*aspectX)>winRect.bottom) | |
876 { | |
877 padding = (winRect.right - d_width*aspectY)/2; | |
878 SetRect(&dstRect, padding, 0, d_width*aspectY+padding, d_height*aspectY); | |
879 } | |
880 else | |
881 { | |
882 padding = (winRect.bottom - d_height*aspectX)/2; | |
883 SetRect(&dstRect, 0, padding, (d_width*aspectX), d_height*aspectX+padding); | |
884 } | |
12120 | 885 |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
886 //Clear Background |
12623 | 887 SetGWorld( GetWindowPort(theWindow), NULL ); |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
888 RGBColor blackC = { 0x0000, 0x0000, 0x0000 }; |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
889 RGBForeColor( &blackC ); |
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
890 PaintRect( &winRect ); |
12414 | 891 |
12487 | 892 long scale_X = FixDiv(Long2Fix(dstRect.right - dstRect.left),Long2Fix(imgRect.right)); |
893 long scale_Y = FixDiv(Long2Fix(dstRect.bottom - dstRect.top),Long2Fix(imgRect.bottom)); | |
12414 | 894 |
12432 | 895 SetIdentityMatrix(&matrix); |
12487 | 896 if (((dstRect.right - dstRect.left) != imgRect.right) || ((dstRect.bottom - dstRect.right) != imgRect.bottom)) |
12432 | 897 { |
898 ScaleMatrix(&matrix, scale_X, scale_Y, 0, 0); | |
12414 | 899 |
12432 | 900 if (padding > 0) |
901 { | |
902 TranslateMatrix(&matrix, Long2Fix(dstRect.left), Long2Fix(dstRect.top)); | |
903 } | |
904 } | |
12424 | 905 |
12432 | 906 SetDSequenceMatrix(seqId, &matrix); |
12120 | 907 } |
908 | |
12296 | 909 void window_ontop() |
12460 | 910 { |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
911 //Cycle between level |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
912 winLevel++; |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
913 if(winLevel>2) |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
914 winLevel = 0; |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
915 |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
916 //hide menu bar and mouse cursor if in fullscreen and quiting wallpaper mode |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
917 if(vo_fs) |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
918 { |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
919 if(winLevel != 0) |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
920 { |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
921 HideMenuBar(); |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
922 HideCursor(); |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
923 } |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
924 else |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
925 { |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
926 ShowMenuBar(); |
12830 | 927 ShowCursor(); |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
928 } |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
929 } |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
930 |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
931 SetWindowGroupLevel(winGroup, CGWindowLevelForKey(levelList[winLevel])); |
12120 | 932 } |
933 | |
12296 | 934 void window_fullscreen() |
12120 | 935 { |
12296 | 936 //go fullscreen |
12432 | 937 if(vo_fs) |
12296 | 938 { |
12826
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
939 if(winLevel != 0) |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
940 { |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
941 HideMenuBar(); |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
942 HideCursor(); |
fb55f94f3001
Add Window Level Key, Can switch mode with T key
nplourde
parents:
12785
diff
changeset
|
943 } |
12120 | 944 |
12296 | 945 //save old window size |
12487 | 946 if (!vo_quartz_fs) |
947 GetWindowPortBounds(theWindow, &oldWinRect); | |
12296 | 948 |
949 //go fullscreen | |
12432 | 950 //ChangeWindowAttributes(theWindow, 0, kWindowResizableAttribute); |
12425 | 951 |
12519
12a87d539f6d
choose fullscreen device with suboption device_id=#
nplourde
parents:
12517
diff
changeset
|
952 MoveWindow (theWindow, deviceRect.left, deviceRect.top, 1); |
12296 | 953 SizeWindow(theWindow, device_width, device_height,1); |
12487 | 954 |
955 vo_quartz_fs = 1; | |
12296 | 956 } |
957 else //go back to windowed mode | |
958 { | |
959 ShowMenuBar(); | |
12120 | 960 |
12296 | 961 //show mouse cursor |
962 ShowCursor(); | |
963 | |
964 //revert window to previous setting | |
12432 | 965 //ChangeWindowAttributes(theWindow, kWindowResizableAttribute, 0); |
12425 | 966 |
12487 | 967 SizeWindow(theWindow, oldWinRect.right, oldWinRect.bottom,1); |
12296 | 968 RepositionWindow(theWindow, NULL, kWindowCascadeOnMainScreen); |
12487 | 969 |
970 vo_quartz_fs = 0; | |
12296 | 971 } |
972 | |
973 window_resized(); | |
12120 | 974 } |