git.sesse.net Git - vlc/blob - modules/gui/macosx/vout.m

   1 /*****************************************************************************
   2  * vout.m: MacOS X video output plugin
   3  *****************************************************************************
   4  * Copyright (C) 2001-2003 VideoLAN
   5  * $Id: vout.m,v 1.36 2003/03/04 23:32:06 hartman Exp $
   6  *
   7  * Authors: Colin Delacroix <colin@zoy.org>
   8  *          Florian G. Pflug <fgp@phlo.org>
   9  *          Jon Lech Johansen <jon-vl@nanocrew.net>
  10  *          Derk-Jan Hartman <thedj@users.sourceforge.net>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  25  *****************************************************************************/
  26
  27 /*****************************************************************************
  28  * Preamble
  29  *****************************************************************************/
  30 #include <errno.h>                                                 /* ENOMEM */
  31 #include <stdlib.h>                                                /* free() */
  32 #include <string.h>                                            /* strerror() */
  33
  34 #include <QuickTime/QuickTime.h>
  35
  36 #include "intf.h"
  37 #include "vout.h"
  38
  39 #define QT_MAX_DIRECTBUFFERS 10
  40
  41 struct picture_sys_t
  42 {
  43     void *p_info;
  44     unsigned int i_size;
  45
  46     /* When using I420 output */
  47     PlanarPixmapInfoYUV420 pixmap_i420;
  48 };
  49
  50 /*****************************************************************************
  51  * Local prototypes
  52  *****************************************************************************/
  53 static int  vout_Init      ( vout_thread_t * );
  54 static void vout_End       ( vout_thread_t * );
  55 static int  vout_Manage    ( vout_thread_t * );
  56 static void vout_Display   ( vout_thread_t *, picture_t * );
  57
  58 static int  CoSendRequest      ( vout_thread_t *, SEL );
  59 static int  CoCreateWindow     ( vout_thread_t * );
  60 static int  CoDestroyWindow    ( vout_thread_t * );
  61 static int  CoToggleFullscreen ( vout_thread_t * );
  62
  63 static void QTScaleMatrix      ( vout_thread_t * );
  64 static int  QTCreateSequence   ( vout_thread_t * );
  65 static void QTDestroySequence  ( vout_thread_t * );
  66 static int  QTNewPicture       ( vout_thread_t *, picture_t * );
  67 static void QTFreePicture      ( vout_thread_t *, picture_t * );
  68
  69 /*****************************************************************************
  70  * OpenVideo: allocates MacOS X video thread output method
  71  *****************************************************************************
  72  * This function allocates and initializes a MacOS X vout method.
  73  *****************************************************************************/
  74 int E_(OpenVideo) ( vlc_object_t *p_this )
  75 {
  76     vout_thread_t * p_vout = (vout_thread_t *)p_this;
  77     OSErr err;
  78     int i_timeout;
  79
  80     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
  81     if( p_vout->p_sys == NULL )
  82     {
  83         msg_Err( p_vout, "out of memory" );
  84         return( 1 );
  85     }
  86
  87     memset( p_vout->p_sys, 0, sizeof( vout_sys_t ) );
  88
  89     /* Wait for a MacOS X interface to appear. Timeout is 2 seconds. */
  90     for( i_timeout = 20 ; i_timeout-- ; )
  91     {
  92         if( NSApp == NULL )
  93         {
  94             msleep( INTF_IDLE_SLEEP );
  95         }
  96     }
  97
  98     if( NSApp == NULL )
  99     {
 100         msg_Err( p_vout, "no MacOS X interface present" );
 101         free( p_vout->p_sys );
 102         return( 1 );
 103     }
 104
 105     if( [NSApp respondsToSelector: @selector(getIntf)] )
 106     {
 107         intf_thread_t * p_intf;
 108
 109         for( i_timeout = 10 ; i_timeout-- ; )
 110         {
 111             if( ( p_intf = [NSApp getIntf] ) == NULL )
 112             {
 113                 msleep( INTF_IDLE_SLEEP );
 114             }
 115         }
 116
 117         if( p_intf == NULL )
 118         {
 119             msg_Err( p_vout, "MacOS X intf has getIntf, but is NULL" );
 120             free( p_vout->p_sys );
 121             return( 1 );
 122         }
 123     }
 124
 125     p_vout->p_sys->h_img_descr =
 126         (ImageDescriptionHandle)NewHandleClear( sizeof(ImageDescription) );
 127     p_vout->p_sys->p_matrix = (MatrixRecordPtr)malloc( sizeof(MatrixRecord) );
 128     p_vout->p_sys->p_fullscreen_state = NULL;
 129
 130     p_vout->p_sys->b_mouse_pointer_visible = 1;
 131
 132     /* set window size */
 133     p_vout->p_sys->s_rect.size.width = p_vout->i_window_width;
 134     p_vout->p_sys->s_rect.size.height = p_vout->i_window_height;
 135
 136     if( ( err = EnterMovies() ) != noErr )
 137     {
 138         msg_Err( p_vout, "EnterMovies failed: %d", err );
 139         free( p_vout->p_sys->p_matrix );
 140         DisposeHandle( (Handle)p_vout->p_sys->h_img_descr );
 141         free( p_vout->p_sys );
 142         return( 1 );
 143     }
 144
 145     if( vout_ChromaCmp( p_vout->render.i_chroma, VLC_FOURCC('I','4','2','0') ) )
 146     {
 147         err = FindCodec( kYUV420CodecType, bestSpeedCodec,
 148                          nil, &p_vout->p_sys->img_dc );
 149         if( err == noErr && p_vout->p_sys->img_dc != 0 )
 150         {
 151             p_vout->output.i_chroma = VLC_FOURCC('I','4','2','0');
 152             p_vout->p_sys->i_codec = kYUV420CodecType;
 153         }
 154         else
 155         {
 156             msg_Err( p_vout, "failed to find an appropriate codec" );
 157         }
 158     }
 159     else
 160     {
 161         msg_Err( p_vout, "chroma 0x%08x not supported",
 162                          p_vout->render.i_chroma );
 163     }
 164
 165     if( p_vout->p_sys->img_dc == 0 )
 166     {
 167         free( p_vout->p_sys->p_matrix );
 168         DisposeHandle( (Handle)p_vout->p_sys->h_img_descr );
 169         free( p_vout->p_sys );
 170         return( 1 );
 171     }
 172
 173     NSAutoreleasePool * o_pool = [[NSAutoreleasePool alloc] init];
 174     NSArray * o_screens = [NSScreen screens];
 175     if( [o_screens count] > 0 && var_Type( p_vout, "video-device" ) == 0 )
 176     {
 177         int i = 1;
 178         vlc_value_t val;
 179         NSScreen * o_screen;
 180
 181         int i_option = config_GetInt( p_vout, "macosx-vdev" );
 182
 183         var_Create( p_vout, "video-device", VLC_VAR_STRING |
 184                                             VLC_VAR_HASCHOICE );
 185
 186         NSEnumerator * o_enumerator = [o_screens objectEnumerator];
 187
 188         while( (o_screen = [o_enumerator nextObject]) != NULL )
 189         {
 190             char psz_temp[255];
 191             NSRect s_rect = [o_screen frame];
 192
 193             snprintf( psz_temp, sizeof(psz_temp)/sizeof(psz_temp[0])-1,
 194                       "%s %d (%dx%d)", _("Screen"), i,
 195                       (int)s_rect.size.width, (int)s_rect.size.height );
 196
 197             val.psz_string = psz_temp;
 198             var_Change( p_vout, "video-device", VLC_VAR_ADDCHOICE, &val );
 199
 200             if( ( i - 1 ) == i_option )
 201             {
 202                 var_Set( p_vout, "video-device", val );
 203             }
 204
 205             i++;
 206         }
 207
 208         var_AddCallback( p_vout, "video-device", vout_VarCallback,
 209                          NULL );
 210
 211         val.b_bool = VLC_TRUE;
 212         var_Set( p_vout, "intf-change", val );
 213     }
 214     [o_pool release];
 215
 216     if( CoCreateWindow( p_vout ) )
 217     {
 218         msg_Err( p_vout, "unable to create window" );
 219         free( p_vout->p_sys->p_matrix );
 220         DisposeHandle( (Handle)p_vout->p_sys->h_img_descr );
 221         free( p_vout->p_sys );
 222         return( 1 );
 223     }
 224
 225     p_vout->pf_init = vout_Init;
 226     p_vout->pf_end = vout_End;
 227     p_vout->pf_manage = vout_Manage;
 228     p_vout->pf_render = NULL;
 229     p_vout->pf_display = vout_Display;
 230
 231     return( 0 );
 232 }
 233
 234 /*****************************************************************************
 235  * vout_Init: initialize video thread output method
 236  *****************************************************************************/
 237 static int vout_Init( vout_thread_t *p_vout )
 238 {
 239     int i_index;
 240     picture_t *p_pic;
 241
 242     I_OUTPUTPICTURES = 0;
 243
 244     /* Initialize the output structure; we already found a codec,
 245      * and the corresponding chroma we will be using. Since we can
 246      * arbitrary scale, stick to the coordinates and aspect. */
 247     p_vout->output.i_width  = p_vout->render.i_width;
 248     p_vout->output.i_height = p_vout->render.i_height;
 249     p_vout->output.i_aspect = p_vout->render.i_aspect;
 250
 251     SetPort( p_vout->p_sys->p_qdport );
 252     QTScaleMatrix( p_vout );
 253
 254     if( QTCreateSequence( p_vout ) )
 255     {
 256         msg_Err( p_vout, "unable to create sequence" );
 257         return( 1 );
 258     }
 259
 260     /* Try to initialize up to QT_MAX_DIRECTBUFFERS direct buffers */
 261     while( I_OUTPUTPICTURES < QT_MAX_DIRECTBUFFERS )
 262     {
 263         p_pic = NULL;
 264
 265         /* Find an empty picture slot */
 266         for( i_index = 0; i_index < VOUT_MAX_PICTURES; i_index++ )
 267         {
 268             if( p_vout->p_picture[ i_index ].i_status == FREE_PICTURE )
 269             {
 270                 p_pic = p_vout->p_picture + i_index;
 271                 break;
 272             }
 273         }
 274
 275         /* Allocate the picture */
 276         if( p_pic == NULL || QTNewPicture( p_vout, p_pic ) )
 277         {
 278             break;
 279         }
 280
 281         p_pic->i_status = DESTROYED_PICTURE;
 282         p_pic->i_type   = DIRECT_PICTURE;
 283
 284         PP_OUTPUTPICTURE[ I_OUTPUTPICTURES ] = p_pic;
 285
 286         I_OUTPUTPICTURES++;
 287     }
 288
 289     return( 0 );
 290 }
 291
 292 /*****************************************************************************
 293  * vout_End: terminate video thread output method
 294  *****************************************************************************/
 295 static void vout_End( vout_thread_t *p_vout )
 296 {
 297     int i_index;
 298
 299     QTDestroySequence( p_vout );
 300
 301     /* Free the direct buffers we allocated */
 302     for( i_index = I_OUTPUTPICTURES; i_index; )
 303     {
 304         i_index--;
 305         QTFreePicture( p_vout, PP_OUTPUTPICTURE[ i_index ] );
 306     }
 307 }
 308
 309 /*****************************************************************************
 310  * CloseVideo: destroy video thread output method
 311  *****************************************************************************/
 312 void E_(CloseVideo) ( vlc_object_t *p_this )
 313 {
 314     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 315
 316     if( CoDestroyWindow( p_vout ) )
 317     {
 318         msg_Err( p_vout, "unable to destroy window" );
 319     }
 320
 321     if ( p_vout->p_sys->p_fullscreen_state != NULL )
 322         EndFullScreen ( p_vout->p_sys->p_fullscreen_state, NULL );
 323
 324     ExitMovies();
 325
 326     free( p_vout->p_sys->p_matrix );
 327     DisposeHandle( (Handle)p_vout->p_sys->h_img_descr );
 328
 329     free( p_vout->p_sys );
 330 }
 331
 332 /*****************************************************************************
 333  * vout_Manage: handle events
 334  *****************************************************************************
 335  * This function should be called regularly by video output thread. It manages
 336  * console events. It returns a non null value on error.
 337  *****************************************************************************/
 338 static int vout_Manage( vout_thread_t *p_vout )
 339 {
 340     vlc_bool_t b_change = 0;
 341     intf_thread_t * p_intf = [NSApp getIntf];
 342
 343     if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
 344     {
 345         if( CoToggleFullscreen( p_vout ) )
 346         {
 347             return( 1 );
 348         }
 349
 350         p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
 351     }
 352
 353     if( p_vout->i_changes & VOUT_SIZE_CHANGE )
 354     {
 355         QTScaleMatrix( p_vout );
 356         SetDSequenceMatrix( p_vout->p_sys->i_seq,
 357                             p_vout->p_sys->p_matrix );
 358
 359         p_vout->i_changes &= ~VOUT_SIZE_CHANGE;
 360     }
 361
 362     /* hide/show mouse cursor */
 363     if( p_vout->p_sys->b_mouse_moved && p_vout->b_fullscreen &&
 364                         p_intf->p_sys->b_play_status )
 365     {
 366         if( !p_vout->p_sys->b_mouse_pointer_visible )
 367         {
 368             CGDisplayShowCursor( kCGDirectMainDisplay );
 369             p_vout->p_sys->b_mouse_pointer_visible = 1;
 370             b_change = 1;
 371         }
 372         else if( mdate() - p_vout->p_sys->i_time_mouse_last_moved > 2000000 &&
 373                    p_vout->p_sys->b_mouse_pointer_visible )
 374         {
 375             CGDisplayHideCursor( kCGDirectMainDisplay );
 376             p_vout->p_sys->b_mouse_pointer_visible = 0;
 377             b_change = 1;
 378         }
 379
 380     }
 381     else if ( p_vout->b_fullscreen && !p_intf->p_sys->b_play_status )
 382     {
 383         if( !p_vout->p_sys->b_mouse_pointer_visible )
 384         {
 385             CGDisplayShowCursor( kCGDirectMainDisplay );
 386             p_vout->p_sys->b_mouse_pointer_visible = 1;
 387             b_change = 1;
 388         }
 389         else if( p_vout->p_sys->b_mouse_pointer_visible )
 390         {
 391             p_vout->p_sys->i_time_mouse_last_moved = mdate();
 392             p_vout->p_sys->b_mouse_moved = 1;
 393         }
 394     }
 395
 396     if( b_change )
 397     {
 398         p_vout->p_sys->b_mouse_moved = 0;
 399         p_vout->p_sys->i_time_mouse_last_moved = 0;
 400     }
 401
 402     return( 0 );
 403 }
 404
 405 /*****************************************************************************
 406  * vout_Display: displays previously rendered output
 407  *****************************************************************************
 408  * This function sends the currently rendered image to the display.
 409  *****************************************************************************/
 410 static void vout_Display( vout_thread_t *p_vout, picture_t *p_pic )
 411 {
 412     OSErr err;
 413     CodecFlags flags;
 414
 415     if( ( err = DecompressSequenceFrameS(
 416                     p_vout->p_sys->i_seq,
 417                     p_pic->p_sys->p_info,
 418                     p_pic->p_sys->i_size,
 419                     codecFlagUseImageBuffer, &flags, nil ) != noErr ) )
 420     {
 421         msg_Warn( p_vout, "DecompressSequenceFrameS failed: %d", err );
 422     }
 423     else
 424     {
 425         QDFlushPortBuffer( p_vout->p_sys->p_qdport, nil );
 426     }
 427 }
 428
 429 /*****************************************************************************
 430  * CoSendRequest: send request to interface thread
 431  *****************************************************************************
 432  * Returns 0 on success, 1 otherwise
 433  *****************************************************************************/
 434 static int CoSendRequest( vout_thread_t *p_vout, SEL sel )
 435 {
 436     int i_ret = 0;
 437
 438     VLCVout * o_vlv = [[VLCVout alloc] init];
 439
 440     if( ( i_ret = ExecuteOnMainThread( o_vlv, sel, (void *)p_vout ) ) )
 441     {
 442         msg_Err( p_vout, "SendRequest: no way to communicate with mt" );
 443     }
 444
 445     [o_vlv release];
 446
 447     return( i_ret );
 448 }
 449
 450 /*****************************************************************************
 451  * CoCreateWindow: create new window
 452  *****************************************************************************
 453  * Returns 0 on success, 1 otherwise
 454  *****************************************************************************/
 455 static int CoCreateWindow( vout_thread_t *p_vout )
 456 {
 457     if( CoSendRequest( p_vout, @selector(createWindow:) ) )
 458     {
 459         msg_Err( p_vout, "CoSendRequest (createWindow) failed" );
 460         return( 1 );
 461     }
 462
 463     return( 0 );
 464 }
 465
 466 /*****************************************************************************
 467  * CoDestroyWindow: destroy window
 468  *****************************************************************************
 469  * Returns 0 on success, 1 otherwise
 470  *****************************************************************************/
 471 static int CoDestroyWindow( vout_thread_t *p_vout )
 472 {
 473     if( !p_vout->p_sys->b_mouse_pointer_visible )
 474     {
 475         CGDisplayShowCursor( kCGDirectMainDisplay );
 476         p_vout->p_sys->b_mouse_pointer_visible = 1;
 477     }
 478
 479     if( CoSendRequest( p_vout, @selector(destroyWindow:) ) )
 480     {
 481         msg_Err( p_vout, "CoSendRequest (destroyWindow) failed" );
 482         return( 1 );
 483     }
 484
 485     return( 0 );
 486 }
 487
 488 /*****************************************************************************
 489  * CoToggleFullscreen: toggle fullscreen
 490  *****************************************************************************
 491  * Returns 0 on success, 1 otherwise
 492  *****************************************************************************/
 493 static int CoToggleFullscreen( vout_thread_t *p_vout )
 494 {
 495     QTDestroySequence( p_vout );
 496
 497     if( CoDestroyWindow( p_vout ) )
 498     {
 499         msg_Err( p_vout, "unable to destroy window" );
 500         return( 1 );
 501     }
 502
 503     p_vout->b_fullscreen = !p_vout->b_fullscreen;
 504
 505     config_PutInt( p_vout, "fullscreen", p_vout->b_fullscreen );
 506
 507     if( CoCreateWindow( p_vout ) )
 508     {
 509         msg_Err( p_vout, "unable to create window" );
 510         return( 1 );
 511     }
 512
 513     SetPort( p_vout->p_sys->p_qdport );
 514     QTScaleMatrix( p_vout );
 515
 516     if( QTCreateSequence( p_vout ) )
 517     {
 518         msg_Err( p_vout, "unable to create sequence" );
 519         return( 1 );
 520     }
 521
 522     return( 0 );
 523 }
 524
 525 /*****************************************************************************
 526  * QTScaleMatrix: scale matrix
 527  *****************************************************************************/
 528 static void QTScaleMatrix( vout_thread_t *p_vout )
 529 {
 530     Rect s_rect;
 531     unsigned int i_width, i_height;
 532     Fixed factor_x, factor_y;
 533     unsigned int i_offset_x = 0;
 534     unsigned int i_offset_y = 0;
 535
 536     GetPortBounds( p_vout->p_sys->p_qdport, &s_rect );
 537
 538     i_width = s_rect.right - s_rect.left;
 539     i_height = s_rect.bottom - s_rect.top;
 540
 541     if( i_height * p_vout->output.i_aspect < i_width * VOUT_ASPECT_FACTOR )
 542     {
 543         int i_adj_width = i_height * p_vout->output.i_aspect /
 544                           VOUT_ASPECT_FACTOR;
 545
 546         factor_x = FixDiv( Long2Fix( i_adj_width ),
 547                            Long2Fix( p_vout->output.i_width ) );
 548         factor_y = FixDiv( Long2Fix( i_height ),
 549                            Long2Fix( p_vout->output.i_height ) );
 550
 551         i_offset_x = (i_width - i_adj_width) / 2;
 552     }
 553     else
 554     {
 555         int i_adj_height = i_width * VOUT_ASPECT_FACTOR /
 556                            p_vout->output.i_aspect;
 557
 558         factor_x = FixDiv( Long2Fix( i_width ),
 559                            Long2Fix( p_vout->output.i_width ) );
 560         factor_y = FixDiv( Long2Fix( i_adj_height ),
 561                            Long2Fix( p_vout->output.i_height ) );
 562
 563         i_offset_y = (i_height - i_adj_height) / 2;
 564     }
 565
 566     SetIdentityMatrix( p_vout->p_sys->p_matrix );
 567
 568     ScaleMatrix( p_vout->p_sys->p_matrix,
 569                  factor_x, factor_y,
 570                  Long2Fix(0), Long2Fix(0) );
 571
 572     TranslateMatrix( p_vout->p_sys->p_matrix,
 573                      Long2Fix(i_offset_x),
 574                      Long2Fix(i_offset_y) );
 575 }
 576
 577 /*****************************************************************************
 578  * QTCreateSequence: create a new sequence
 579  *****************************************************************************
 580  * Returns 0 on success, 1 otherwise
 581  *****************************************************************************/
 582 static int QTCreateSequence( vout_thread_t *p_vout )
 583 {
 584     OSErr err;
 585     ImageDescriptionPtr p_descr;
 586
 587     HLock( (Handle)p_vout->p_sys->h_img_descr );
 588     p_descr = *p_vout->p_sys->h_img_descr;
 589
 590     p_descr->idSize = sizeof(ImageDescription);
 591     p_descr->cType = p_vout->p_sys->i_codec;
 592     p_descr->version = 1;
 593     p_descr->revisionLevel = 0;
 594     p_descr->vendor = 'appl';
 595     p_descr->width = p_vout->output.i_width;
 596     p_descr->height = p_vout->output.i_height;
 597     p_descr->hRes = Long2Fix(72);
 598     p_descr->vRes = Long2Fix(72);
 599     p_descr->spatialQuality = codecLosslessQuality;
 600     p_descr->frameCount = 1;
 601     p_descr->clutID = -1;
 602     p_descr->dataSize = 0;
 603     p_descr->depth = 24;
 604
 605     HUnlock( (Handle)p_vout->p_sys->h_img_descr );
 606
 607     if( ( err = DecompressSequenceBeginS(
 608                               &p_vout->p_sys->i_seq,
 609                               p_vout->p_sys->h_img_descr,
 610                               NULL, 0,
 611                               p_vout->p_sys->p_qdport,
 612                               NULL, NULL,
 613                               p_vout->p_sys->p_matrix,
 614                               0, NULL,
 615                               codecFlagUseImageBuffer,
 616                               codecLosslessQuality,
 617                               p_vout->p_sys->img_dc ) ) )
 618     {
 619         msg_Err( p_vout, "DecompressSequenceBeginS failed: %d", err );
 620         return( 1 );
 621     }
 622
 623     return( 0 );
 624 }
 625
 626 /*****************************************************************************
 627  * QTDestroySequence: destroy sequence
 628  *****************************************************************************/
 629 static void QTDestroySequence( vout_thread_t *p_vout )
 630 {
 631     CDSequenceEnd( p_vout->p_sys->i_seq );
 632 }
 633
 634 /*****************************************************************************
 635  * QTNewPicture: allocate a picture
 636  *****************************************************************************
 637  * Returns 0 on success, 1 otherwise
 638  *****************************************************************************/
 639 static int QTNewPicture( vout_thread_t *p_vout, picture_t *p_pic )
 640 {
 641     int i_width  = p_vout->output.i_width;
 642     int i_height = p_vout->output.i_height;
 643
 644     /* We know the chroma, allocate a buffer which will be used
 645      * directly by the decoder */
 646     p_pic->p_sys = malloc( sizeof( picture_sys_t ) );
 647
 648     if( p_pic->p_sys == NULL )
 649     {
 650         return( -1 );
 651     }
 652
 653     switch( p_vout->output.i_chroma )
 654     {
 655         case VLC_FOURCC('I','4','2','0'):
 656
 657             p_pic->p_sys->p_info = (void *)&p_pic->p_sys->pixmap_i420;
 658             p_pic->p_sys->i_size = sizeof(PlanarPixmapInfoYUV420);
 659
 660             /* Allocate the memory buffer */
 661             p_pic->p_data = vlc_memalign( &p_pic->p_data_orig,
 662                                           16, i_width * i_height * 3 / 2 );
 663
 664             /* Y buffer */
 665             p_pic->Y_PIXELS = p_pic->p_data;
 666             p_pic->p[Y_PLANE].i_lines = i_height;
 667             p_pic->p[Y_PLANE].i_pitch = i_width;
 668             p_pic->p[Y_PLANE].i_pixel_pitch = 1;
 669             p_pic->p[Y_PLANE].i_visible_pitch = i_width;
 670
 671             /* U buffer */
 672             p_pic->U_PIXELS = p_pic->Y_PIXELS + i_height * i_width;
 673             p_pic->p[U_PLANE].i_lines = i_height / 2;
 674             p_pic->p[U_PLANE].i_pitch = i_width / 2;
 675             p_pic->p[U_PLANE].i_pixel_pitch = 1;
 676             p_pic->p[U_PLANE].i_visible_pitch = i_width / 2;
 677
 678             /* V buffer */
 679             p_pic->V_PIXELS = p_pic->U_PIXELS + i_height * i_width / 4;
 680             p_pic->p[V_PLANE].i_lines = i_height / 2;
 681             p_pic->p[V_PLANE].i_pitch = i_width / 2;
 682             p_pic->p[V_PLANE].i_pixel_pitch = 1;
 683             p_pic->p[V_PLANE].i_visible_pitch = i_width / 2;
 684
 685             /* We allocated 3 planes */
 686             p_pic->i_planes = 3;
 687
 688 #define P p_pic->p_sys->pixmap_i420
 689             P.componentInfoY.offset = (void *)p_pic->Y_PIXELS
 690                                        - p_pic->p_sys->p_info;
 691             P.componentInfoCb.offset = (void *)p_pic->U_PIXELS
 692                                         - p_pic->p_sys->p_info;
 693             P.componentInfoCr.offset = (void *)p_pic->V_PIXELS
 694                                         - p_pic->p_sys->p_info;
 695
 696             P.componentInfoY.rowBytes = i_width;
 697             P.componentInfoCb.rowBytes = i_width / 2;
 698             P.componentInfoCr.rowBytes = i_width / 2;
 699 #undef P
 700
 701             break;
 702
 703     default:
 704         /* Unknown chroma, tell the guy to get lost */
 705         free( p_pic->p_sys );
 706         msg_Err( p_vout, "never heard of chroma 0x%.8x (%4.4s)",
 707                  p_vout->output.i_chroma, (char*)&p_vout->output.i_chroma );
 708         p_pic->i_planes = 0;
 709         return( -1 );
 710     }
 711
 712     return( 0 );
 713 }
 714
 715 /*****************************************************************************
 716  * QTFreePicture: destroy a picture allocated with QTNewPicture
 717  *****************************************************************************/
 718 static void QTFreePicture( vout_thread_t *p_vout, picture_t *p_pic )
 719 {
 720     switch( p_vout->output.i_chroma )
 721     {
 722         case VLC_FOURCC('I','4','2','0'):
 723             free( p_pic->p_data_orig );
 724             break;
 725     }
 726
 727     free( p_pic->p_sys );
 728 }
 729
 730 /*****************************************************************************
 731  * VLCWindow implementation
 732  *****************************************************************************/
 733 @implementation VLCWindow
 734
 735 - (void)setVout:(vout_thread_t *)_p_vout
 736 {
 737     p_vout = _p_vout;
 738 }
 739
 740 - (vout_thread_t *)getVout
 741 {
 742     return( p_vout );
 743 }
 744
 745 - (void)scaleWindowWithFactor: (float)factor
 746 {
 747     NSSize newsize;
 748     int i_corrected_height;
 749     NSPoint topleftbase;
 750     NSPoint topleftscreen;
 751
 752     if ( !p_vout->b_fullscreen )
 753     {
 754         topleftbase.x = 0;
 755         topleftbase.y = [self frame].size.height;
 756         topleftscreen = [self convertBaseToScreen: topleftbase];
 757
 758         i_corrected_height = p_vout->output.i_width * VOUT_ASPECT_FACTOR /
 759                                             p_vout->output.i_aspect;
 760         newsize.width = (int) ( p_vout->render.i_width * factor );
 761         newsize.height = (int) ( i_corrected_height * factor );
 762         [self setContentSize: newsize];
 763
 764         [self setFrameTopLeftPoint: topleftscreen];
 765         p_vout->i_changes |= VOUT_SIZE_CHANGE;
 766     }
 767 }
 768
 769 - (void)toggleFullscreen
 770 {
 771     p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
 772 }
 773
 774 - (BOOL)isFullscreen
 775 {
 776     return( p_vout->b_fullscreen );
 777 }
 778
 779 - (BOOL)canBecomeKeyWindow
 780 {
 781     return( YES );
 782 }
 783
 784 - (void)keyDown:(NSEvent *)o_event
 785 {
 786     unichar key = 0;
 787
 788     if( [[o_event characters] length] )
 789     {
 790         key = [[o_event characters] characterAtIndex: 0];
 791     }
 792
 793     switch( key )
 794     {
 795         case 'f': case 'F':
 796             [self toggleFullscreen];
 797             break;
 798
 799         case (unichar)0x1b: /* escape */
 800             if( [self isFullscreen] )
 801             {
 802                 [self toggleFullscreen];
 803             }
 804             break;
 805
 806         case 'q': case 'Q':
 807             p_vout->p_vlc->b_die = VLC_TRUE;
 808             break;
 809
 810         case ' ':
 811             input_SetStatus( p_vout, INPUT_STATUS_PAUSE );
 812             break;
 813
 814         default:
 815             [super keyDown: o_event];
 816             break;
 817     }
 818 }
 819
 820 - (void)updateTitle
 821 {
 822     NSMutableString * o_title;
 823
 824     intf_thread_t * p_intf = [NSApp getIntf];
 825     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 826                                                        FIND_ANYWHERE );
 827
 828     if( p_playlist == NULL )
 829     {
 830         return;
 831     }
 832
 833     vlc_mutex_lock( &p_playlist->object_lock );
 834     o_title = [NSMutableString stringWithUTF8String:
 835         p_playlist->pp_items[p_playlist->i_index]->psz_name];
 836     vlc_mutex_unlock( &p_playlist->object_lock );
 837
 838     vlc_object_release( p_playlist );
 839
 840     if( o_title != nil )
 841     {
 842         NSRange prefix_range = [o_title rangeOfString: @"file:"];
 843         if( prefix_range.location != NSNotFound )
 844         {
 845             [o_title deleteCharactersInRange: prefix_range];
 846         }
 847
 848         [self setTitleWithRepresentedFilename: o_title];
 849     }
 850     else
 851     {
 852         [self setTitle:
 853             [NSString stringWithCString: VOUT_TITLE " (QuickTime)"]];
 854     }
 855 }
 856
 857 /* This is actually the same as VLCControls::stop. */
 858 - (BOOL)windowShouldClose:(id)sender
 859 {
 860     intf_thread_t * p_intf = [NSApp getIntf];
 861     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 862                                                        FIND_ANYWHERE );
 863     if( p_playlist == NULL )
 864     {
 865         return NO;
 866     }
 867
 868     playlist_Stop( p_playlist );
 869     vlc_object_release( p_playlist );
 870
 871     /* The window will be closed by the intf later. */
 872     return NO;
 873 }
 874
 875 @end
 876
 877 /*****************************************************************************
 878  * VLCView implementation
 879  *****************************************************************************/
 880 @implementation VLCView
 881
 882 - (void)drawRect:(NSRect)rect
 883 {
 884     vout_thread_t * p_vout;
 885     id o_window = [self window];
 886     p_vout = (vout_thread_t *)[o_window getVout];
 887
 888     [[NSColor blackColor] set];
 889     NSRectFill( rect );
 890     [super drawRect: rect];
 891
 892     p_vout->i_changes |= VOUT_SIZE_CHANGE;
 893 }
 894
 895 - (BOOL)acceptsFirstResponder
 896 {
 897     return( YES );
 898 }
 899
 900 - (BOOL)becomeFirstResponder
 901 {
 902     [[self window] setAcceptsMouseMovedEvents: YES];
 903     return( YES );
 904 }
 905
 906 - (BOOL)resignFirstResponder
 907 {
 908     [[self window] setAcceptsMouseMovedEvents: NO];
 909     return( YES );
 910 }
 911
 912 - (void)mouseDown:(NSEvent *)o_event
 913 {
 914     vout_thread_t * p_vout;
 915     id o_window = [self window];
 916     p_vout = (vout_thread_t *)[o_window getVout];
 917     vlc_value_t val;
 918
 919     switch( [o_event type] )
 920     {
 921         case NSLeftMouseDown:
 922         {
 923             var_Get( p_vout, "mouse-button-down", &val );
 924             val.i_int |= 1;
 925             var_Set( p_vout, "mouse-button-down", val );
 926         }
 927         break;
 928
 929         default:
 930             [super mouseDown: o_event];
 931         break;
 932     }
 933 }
 934
 935 - (void)otherMouseDown:(NSEvent *)o_event
 936 {
 937     vout_thread_t * p_vout;
 938     id o_window = [self window];
 939     p_vout = (vout_thread_t *)[o_window getVout];
 940     vlc_value_t val;
 941
 942     switch( [o_event type] )
 943     {
 944         case NSOtherMouseDown:
 945         {
 946             var_Get( p_vout, "mouse-button-down", &val );
 947             val.i_int |= 2;
 948             var_Set( p_vout, "mouse-button-down", val );
 949         }
 950         break;
 951
 952         default:
 953             [super mouseDown: o_event];
 954         break;
 955     }
 956 }
 957
 958 - (void)rightMouseDown:(NSEvent *)o_event
 959 {
 960     vout_thread_t * p_vout;
 961     id o_window = [self window];
 962     p_vout = (vout_thread_t *)[o_window getVout];
 963     vlc_value_t val;
 964
 965     switch( [o_event type] )
 966     {
 967         case NSRightMouseDown:
 968         {
 969             var_Get( p_vout, "mouse-button-down", &val );
 970             val.i_int |= 4;
 971             var_Set( p_vout, "mouse-button-down", val );
 972         }
 973         break;
 974
 975         default:
 976             [super mouseDown: o_event];
 977         break;
 978     }
 979 }
 980
 981 - (void)mouseUp:(NSEvent *)o_event
 982 {
 983     vout_thread_t * p_vout;
 984     id o_window = [self window];
 985     p_vout = (vout_thread_t *)[o_window getVout];
 986     vlc_value_t val;
 987
 988     switch( [o_event type] )
 989     {
 990         case NSLeftMouseUp:
 991         {
 992             vlc_value_t b_val;
 993             b_val.b_bool = VLC_TRUE;
 994             var_Set( p_vout, "mouse-clicked", b_val );
 995
 996             var_Get( p_vout, "mouse-button-down", &val );
 997             val.i_int &= ~1;
 998             var_Set( p_vout, "mouse-button-down", val );
 999         }
1000         break;
1001
1002         default:
1003             [super mouseUp: o_event];
1004         break;
1005     }
1006 }
1007
1008 - (void)otherMouseUp:(NSEvent *)o_event
1009 {
1010     vout_thread_t * p_vout;
1011     id o_window = [self window];
1012     p_vout = (vout_thread_t *)[o_window getVout];
1013     vlc_value_t val;
1014
1015     switch( [o_event type] )
1016     {
1017         case NSOtherMouseUp:
1018         {
1019             var_Get( p_vout, "mouse-button-down", &val );
1020             val.i_int &= ~2;
1021             var_Set( p_vout, "mouse-button-down", val );
1022         }
1023         break;
1024
1025         default:
1026             [super mouseUp: o_event];
1027         break;
1028     }
1029 }
1030
1031 - (void)rightMouseUp:(NSEvent *)o_event
1032 {
1033     vout_thread_t * p_vout;
1034     id o_window = [self window];
1035     p_vout = (vout_thread_t *)[o_window getVout];
1036     vlc_value_t val;
1037
1038     switch( [o_event type] )
1039     {
1040         case NSRightMouseUp:
1041         {
1042             var_Get( p_vout, "mouse-button-down", &val );
1043             val.i_int &= ~4;
1044             var_Set( p_vout, "mouse-button-down", val );
1045         }
1046         break;
1047
1048         default:
1049             [super mouseUp: o_event];
1050         break;
1051     }
1052 }
1053
1054 - (void)mouseDragged:(NSEvent *)o_event
1055 {
1056     [self mouseMoved:o_event];
1057 }
1058
1059 - (void)otherMouseDragged:(NSEvent *)o_event
1060 {
1061     [self mouseMoved:o_event];
1062 }
1063
1064 - (void)rightMouseDragged:(NSEvent *)o_event
1065 {
1066     [self mouseMoved:o_event];
1067 }
1068
1069 - (void)mouseMoved:(NSEvent *)o_event
1070 {
1071     NSPoint ml;
1072     NSRect s_rect;
1073     BOOL b_inside;
1074
1075     vout_thread_t * p_vout;
1076     id o_window = [self window];
1077     p_vout = (vout_thread_t *)[o_window getVout];
1078
1079     s_rect = [self bounds];
1080     ml = [self convertPoint: [o_event locationInWindow] fromView: nil];
1081     b_inside = [self mouse: ml inRect: s_rect];
1082
1083     if( b_inside )
1084     {
1085         vlc_value_t val;
1086         int i_width, i_height, i_x, i_y;
1087
1088         vout_PlacePicture( p_vout, (unsigned int)s_rect.size.width,
1089                                    (unsigned int)s_rect.size.height,
1090                                    &i_x, &i_y, &i_width, &i_height );
1091
1092         val.i_int = ( ((int)ml.x) - i_x ) *
1093                     p_vout->render.i_width / i_width;
1094         var_Set( p_vout, "mouse-x", val );
1095
1096         val.i_int = ( ((int)ml.y) - i_y ) *
1097                     p_vout->render.i_height / i_height;
1098         var_Set( p_vout, "mouse-y", val );
1099
1100         val.b_bool = VLC_TRUE;
1101         var_Set( p_vout, "mouse-moved", val );
1102     }
1103     p_vout->p_sys->i_time_mouse_last_moved = mdate();
1104     p_vout->p_sys->b_mouse_moved = 1;
1105     [super mouseMoved: o_event];
1106 }
1107
1108 @end
1109
1110 /*****************************************************************************
1111  * VLCVout implementation
1112  *****************************************************************************/
1113 @implementation VLCVout
1114
1115 - (void)createWindow:(NSValue *)o_value
1116 {
1117     vlc_value_t val;
1118     VLCView * o_view;
1119     NSScreen * o_screen;
1120     vout_thread_t * p_vout;
1121     vlc_bool_t b_main_screen;
1122
1123     p_vout = (vout_thread_t *)[o_value pointerValue];
1124
1125     p_vout->p_sys->o_window = [VLCWindow alloc];
1126     [p_vout->p_sys->o_window setVout: p_vout];
1127     [p_vout->p_sys->o_window setReleasedWhenClosed: YES];
1128
1129     if( var_Get( p_vout, "video-device", &val ) < 0 )
1130     {
1131         o_screen = [NSScreen mainScreen];
1132         b_main_screen = 1;
1133     }
1134     else
1135     {
1136         unsigned int i_index = 0;
1137         NSArray *o_screens = [NSScreen screens];
1138
1139         if( !sscanf( val.psz_string, _("Screen %d"), &i_index ) ||
1140             [o_screens count] < i_index )
1141         {
1142             o_screen = [NSScreen mainScreen];
1143             b_main_screen = 1;
1144         }
1145         else
1146         {
1147             i_index--;
1148             o_screen = [o_screens objectAtIndex: i_index];
1149             config_PutInt( p_vout, "macosx-vdev", i_index );
1150             b_main_screen = (i_index == 0);
1151         }
1152
1153         free( val.psz_string );
1154     }
1155
1156     if( p_vout->b_fullscreen )
1157     {
1158         NSRect screen_rect = [o_screen frame];
1159         screen_rect.origin.x = screen_rect.origin.y = 0;
1160
1161         if ( b_main_screen && p_vout->p_sys->p_fullscreen_state == NULL )
1162             BeginFullScreen( &p_vout->p_sys->p_fullscreen_state, NULL, 0, 0,
1163                              NULL, NULL, fullScreenAllowEvents );
1164
1165         [p_vout->p_sys->o_window
1166             initWithContentRect: screen_rect
1167             styleMask: NSBorderlessWindowMask
1168             backing: NSBackingStoreBuffered
1169             defer: NO screen: o_screen];
1170
1171         [p_vout->p_sys->o_window setLevel: NSPopUpMenuWindowLevel - 1];
1172         p_vout->p_sys->b_mouse_moved = 1;
1173         p_vout->p_sys->i_time_mouse_last_moved = mdate();
1174     }
1175     else
1176     {
1177         unsigned int i_stylemask = NSTitledWindowMask |
1178                                    NSMiniaturizableWindowMask |
1179                                    NSClosableWindowMask |
1180                                    NSResizableWindowMask;
1181
1182         if ( p_vout->p_sys->p_fullscreen_state != NULL )
1183             EndFullScreen ( p_vout->p_sys->p_fullscreen_state, NULL );
1184         p_vout->p_sys->p_fullscreen_state = NULL;
1185
1186         [p_vout->p_sys->o_window
1187             initWithContentRect: p_vout->p_sys->s_rect
1188             styleMask: i_stylemask
1189             backing: NSBackingStoreBuffered
1190             defer: NO screen: o_screen];
1191
1192         if( !p_vout->p_sys->b_pos_saved )
1193         {
1194             [p_vout->p_sys->o_window center];
1195         }
1196     }
1197
1198     o_view = [[VLCView alloc] init];
1199     /* FIXME: [o_view setMenu:] */
1200     [p_vout->p_sys->o_window setContentView: o_view];
1201     [o_view autorelease];
1202
1203     [o_view lockFocus];
1204     p_vout->p_sys->p_qdport = [o_view qdPort];
1205     [o_view unlockFocus];
1206
1207     [p_vout->p_sys->o_window updateTitle];
1208     [p_vout->p_sys->o_window makeKeyAndOrderFront: nil];
1209 }
1210
1211 - (void)destroyWindow:(NSValue *)o_value
1212 {
1213     vout_thread_t * p_vout;
1214
1215     p_vout = (vout_thread_t *)[o_value pointerValue];
1216
1217     if( !p_vout->b_fullscreen )
1218     {
1219         NSRect s_rect;
1220
1221         s_rect = [[p_vout->p_sys->o_window contentView] frame];
1222         p_vout->p_sys->s_rect.size = s_rect.size;
1223
1224         s_rect = [p_vout->p_sys->o_window frame];
1225         p_vout->p_sys->s_rect.origin = s_rect.origin;
1226
1227         p_vout->p_sys->b_pos_saved = 1;
1228     }
1229
1230     p_vout->p_sys->p_qdport = nil;
1231     [p_vout->p_sys->o_window close];
1232     p_vout->p_sys->o_window = nil;
1233 }
1234
1235 @end