libvo/vo_quartz.c

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