* if we are paused in fullscreen, show cursor.
[vlc.git] / 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.34 2003/02/15 12:57:51 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     intf_thread_t * p_intf = [NSApp getIntf];
824     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
825                                                FIND_ANYWHERE );
826     
827     if( p_playlist == NULL )
828     {
829         return;
830     }
831
832     vlc_mutex_lock( &p_playlist->object_lock );
833     o_title = [NSMutableString stringWithUTF8String: 
834         p_playlist->pp_items[p_playlist->i_index]->psz_name]; 
835     vlc_mutex_unlock( &p_playlist->object_lock );
836
837     vlc_object_release( p_playlist );
838
839     if (o_title)
840     {
841         NSRange prefixrange = [o_title rangeOfString: @"file:"];
842         if ( prefixrange.location != NSNotFound )
843             [o_title deleteCharactersInRange: prefixrange];
844
845         [self setTitleWithRepresentedFilename: o_title];
846     }
847     else
848     {
849         [self setTitle:
850             [NSString stringWithCString: VOUT_TITLE " (QuickTime)"]];
851     }
852 }
853
854 /* This is actually the same as VLCControls::stop. */
855 - (BOOL)windowShouldClose:(id)sender
856 {
857     intf_thread_t * p_intf = [NSApp getIntf];
858     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
859                                                        FIND_ANYWHERE );
860     if( p_playlist == NULL )      
861     {
862         return NO;
863     }
864
865     playlist_Stop( p_playlist );
866     vlc_object_release( p_playlist );
867
868     /* The window will be closed by the intf later. */
869     return NO;
870 }
871
872 @end
873
874 /*****************************************************************************
875  * VLCView implementation
876  *****************************************************************************/
877 @implementation VLCView
878
879 - (void)drawRect:(NSRect)rect
880 {
881     vout_thread_t * p_vout;
882     id o_window = [self window];
883     p_vout = (vout_thread_t *)[o_window getVout];
884     
885     [[NSColor blackColor] set];
886     NSRectFill( rect );
887     [super drawRect: rect];
888
889     p_vout->i_changes |= VOUT_SIZE_CHANGE;
890 }
891
892 - (BOOL)acceptsFirstResponder
893 {
894     return( YES );
895 }
896
897 - (BOOL)becomeFirstResponder
898 {
899     [[self window] setAcceptsMouseMovedEvents: YES];
900     return( YES );
901 }
902
903 - (BOOL)resignFirstResponder
904 {
905     [[self window] setAcceptsMouseMovedEvents: NO];
906     return( YES );
907 }
908
909 - (void)mouseUp:(NSEvent *)o_event
910 {
911     vout_thread_t * p_vout;
912     id o_window = [self window];
913     p_vout = (vout_thread_t *)[o_window getVout];
914
915     switch( [o_event type] )
916     {
917         case NSLeftMouseUp:
918         {
919             vlc_value_t val;
920             val.b_bool = VLC_TRUE;
921             var_Set( p_vout, "mouse-clicked", val );        
922         }
923         break;
924
925         default:
926             [super mouseUp: o_event];
927         break;
928     }
929 }
930
931 - (void)mouseMoved:(NSEvent *)o_event
932 {
933     NSPoint ml;
934     NSRect s_rect;
935     BOOL b_inside;
936
937     vout_thread_t * p_vout;
938     id o_window = [self window];
939     p_vout = (vout_thread_t *)[o_window getVout];
940
941     s_rect = [self bounds];
942     ml = [self convertPoint: [o_event locationInWindow] fromView: nil];
943     b_inside = [self mouse: ml inRect: s_rect];
944
945     if( b_inside )
946     {
947         vlc_value_t val;
948         int i_width, i_height, i_x, i_y;
949         
950         vout_PlacePicture( p_vout, (unsigned int)s_rect.size.width,
951                                    (unsigned int)s_rect.size.height,
952                                    &i_x, &i_y, &i_width, &i_height );
953
954         val.i_int = ( ((int)ml.x) - i_x ) * 
955                     p_vout->render.i_width / i_width;
956         var_Set( p_vout, "mouse-x", val );
957
958         val.i_int = ( ((int)ml.y) - i_y ) * 
959                     p_vout->render.i_height / i_height;
960         var_Set( p_vout, "mouse-y", val );
961             
962         val.b_bool = VLC_TRUE;
963         var_Set( p_vout, "mouse-moved", val );
964     }
965     p_vout->p_sys->i_time_mouse_last_moved = mdate();
966     p_vout->p_sys->b_mouse_moved = 1;
967     [super mouseMoved: o_event];
968 }
969
970 @end
971
972 /*****************************************************************************
973  * VLCVout implementation
974  *****************************************************************************/
975 @implementation VLCVout
976
977 - (void)createWindow:(NSValue *)o_value
978 {
979     vlc_value_t val;
980     VLCView * o_view;
981     NSScreen * o_screen;
982     vout_thread_t * p_vout;
983     vlc_bool_t b_main_screen;
984     
985     p_vout = (vout_thread_t *)[o_value pointerValue];
986
987     p_vout->p_sys->o_window = [VLCWindow alloc];
988     [p_vout->p_sys->o_window setVout: p_vout];
989     [p_vout->p_sys->o_window setReleasedWhenClosed: YES];
990
991     if( var_Get( p_vout, "video-device", &val ) < 0 )
992     {
993         o_screen = [NSScreen mainScreen];
994         b_main_screen = 1;
995     }
996     else
997     {
998         unsigned int i_index = 0;
999         NSArray *o_screens = [NSScreen screens];
1000
1001         if( !sscanf( val.psz_string, _("Screen %d"), &i_index ) ||
1002             [o_screens count] < i_index )
1003         {
1004             o_screen = [NSScreen mainScreen];
1005             b_main_screen = 1;
1006         }
1007         else
1008         {
1009             i_index--;
1010             o_screen = [o_screens objectAtIndex: i_index];
1011             config_PutInt( p_vout, "macosx-vdev", i_index );
1012             b_main_screen = (i_index == 0);
1013         } 
1014
1015         free( val.psz_string );
1016     } 
1017
1018     if( p_vout->b_fullscreen )
1019     {
1020         NSRect screen_rect = [o_screen frame];
1021         screen_rect.origin.x = screen_rect.origin.y = 0;
1022
1023         if ( b_main_screen && p_vout->p_sys->p_fullscreen_state == NULL )
1024             BeginFullScreen( &p_vout->p_sys->p_fullscreen_state, NULL, 0, 0,
1025                              NULL, NULL, fullScreenAllowEvents );
1026
1027         [p_vout->p_sys->o_window 
1028             initWithContentRect: screen_rect
1029             styleMask: NSBorderlessWindowMask
1030             backing: NSBackingStoreBuffered
1031             defer: NO screen: o_screen];
1032
1033         [p_vout->p_sys->o_window setLevel: NSPopUpMenuWindowLevel - 1];
1034         p_vout->p_sys->b_mouse_moved = 1;
1035         p_vout->p_sys->i_time_mouse_last_moved = mdate();
1036     }
1037     else
1038     {
1039         unsigned int i_stylemask = NSTitledWindowMask |
1040                                    NSMiniaturizableWindowMask |
1041                                    NSClosableWindowMask |
1042                                    NSResizableWindowMask;
1043         
1044         if ( p_vout->p_sys->p_fullscreen_state != NULL )
1045             EndFullScreen ( p_vout->p_sys->p_fullscreen_state, NULL );
1046         p_vout->p_sys->p_fullscreen_state = NULL;
1047
1048         [p_vout->p_sys->o_window 
1049             initWithContentRect: p_vout->p_sys->s_rect
1050             styleMask: i_stylemask
1051             backing: NSBackingStoreBuffered
1052             defer: NO screen: o_screen];
1053
1054         if( !p_vout->p_sys->b_pos_saved )   
1055         {
1056             [p_vout->p_sys->o_window center];
1057         }
1058     }
1059
1060     o_view = [[VLCView alloc] init];
1061     /* FIXME: [o_view setMenu:] */
1062     [p_vout->p_sys->o_window setContentView: o_view];
1063     [o_view autorelease];
1064
1065     [o_view lockFocus];
1066     p_vout->p_sys->p_qdport = [o_view qdPort];
1067     [o_view unlockFocus];
1068     
1069     [p_vout->p_sys->o_window updateTitle];
1070     [p_vout->p_sys->o_window makeKeyAndOrderFront: nil];
1071 }
1072
1073 - (void)destroyWindow:(NSValue *)o_value
1074 {
1075     vout_thread_t * p_vout;
1076
1077     p_vout = (vout_thread_t *)[o_value pointerValue];
1078
1079     if( !p_vout->b_fullscreen )
1080     {
1081         NSRect s_rect;
1082
1083         s_rect = [[p_vout->p_sys->o_window contentView] frame];
1084         p_vout->p_sys->s_rect.size = s_rect.size;
1085
1086         s_rect = [p_vout->p_sys->o_window frame];
1087         p_vout->p_sys->s_rect.origin = s_rect.origin;
1088
1089         p_vout->p_sys->b_pos_saved = 1;
1090     }
1091     
1092     p_vout->p_sys->p_qdport = nil;
1093     [p_vout->p_sys->o_window close];
1094     p_vout->p_sys->o_window = nil;
1095 }
1096
1097 @end