. nouveaux plugins - ne fonctionnent pas encore tous
[vlc.git] / plugins / beos / vout_beos.cpp
1 /*****************************************************************************
2  * vout_beos.cpp: beos video output display method
3  *****************************************************************************
4  * Copyright (C) 2000 VideoLAN
5  *
6  * Authors:
7  * Jean-Marc Dressler
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  * 
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include "defs.h"
28
29 #include <errno.h>                                                 /* ENOMEM */
30 #include <stdlib.h>                                                /* free() */
31 #include <stdio.h>
32 #include <string.h>                                            /* strerror() */
33 #include <kernel/OS.h>
34 #include <View.h>
35 #include <Application.h>
36 #include <DirectWindow.h>
37 #include <Locker.h>
38 #include <malloc.h>
39 #include <string.h>
40
41 extern "C"
42 {
43 #include "config.h"
44 #include "common.h"
45 #include "threads.h"
46 #include "mtime.h"
47 #include "plugins.h"
48
49 #include "video.h"
50 #include "video_output.h"
51
52 #include "intf_msg.h"
53 #include "interface.h" /* XXX maybe to remove if beos_window.h is splitted */
54
55 #include "main.h"
56 }
57
58 #include "beos_window.h"
59
60 #define WIDTH 128
61 #define HEIGHT 64
62 #define BITS_PER_PLANE 16
63 #define BYTES_PER_PIXEL 2
64
65 /*****************************************************************************
66  * vout_sys_t: dummy video output method descriptor
67  *****************************************************************************
68  * This structure is part of the video output thread descriptor.
69  * It describes the dummy specific properties of an output thread.
70  *****************************************************************************/
71  
72 typedef struct vout_sys_s
73 {
74     VideoWindow *         p_window;
75     
76     byte_t *              pp_buffer[2];
77     s32                   i_width;
78     s32                   i_height;
79 } vout_sys_t;
80
81
82 /*****************************************************************************
83  * beos_GetAppWindow : retrieve a BWindow pointer from the window name
84  *****************************************************************************/
85
86 BWindow *beos_GetAppWindow(char *name)
87 {
88     int32       index;
89     BWindow     *window;
90     
91     for (index = 0 ; ; index++)
92     {
93         window = be_app->WindowAt(index);
94         if (window == NULL)
95             break;
96         if (window->LockWithTimeout(200000) == B_OK)
97         {
98             if (strcmp(window->Name(), name) == 0)
99             {
100                 window->Unlock();
101                 break;
102             }
103             window->Unlock();
104         }
105     }
106     return window; 
107 }
108
109 /*****************************************************************************
110  * DrawingThread : thread that really does the drawing
111  *****************************************************************************/
112
113 int32 DrawingThread(void *data)
114 {
115     uint32 i, j, y;
116     uint64 *pp, *qq;
117     uint8 *p, *q;
118     uint32 byte_width;
119     uint32 height, bytes_per_line;
120     clipping_rect *clip;
121
122     VideoWindow *w;
123     w = (VideoWindow*) data;
124     
125     while(!w->fConnectionDisabled)
126     {
127         w->locker->Lock();
128         if( w->fConnected )
129         {
130             if( w->fDirty && (!w->fReady || w->i_screen_depth != w->p_vout->i_screen_depth) )
131             {
132                 bytes_per_line = w->fRowBytes;
133                 for( i=0 ; i < w->fNumClipRects ; i++ )
134                 {
135                     clip = &(w->fClipList[i]);
136                     height = clip->bottom - clip->top +1;
137                     byte_width = w->i_bytes_per_pixel * ((clip->right - clip->left)+1);
138                     p = w->fBits + clip->top*w->fRowBytes + clip->left * w->i_bytes_per_pixel;
139                     for( y=0 ; y < height ; )
140                     {
141                         pp = (uint64*) p;
142                         for( j=0 ; j < byte_width/64 ; j++ )
143                         {
144                             *pp++ = 0;
145                             *pp++ = 0; 
146                             *pp++ = 0;
147                             *pp++ = 0; 
148                             *pp++ = 0;
149                             *pp++ = 0; 
150                             *pp++ = 0;
151                             *pp++ = 0; 
152                         }
153                         memset( pp , 0, byte_width & 63 );
154                         y++;
155                         p += bytes_per_line;
156                     }
157                 }
158             }
159             else if( w->fDirty )
160             {
161                 bytes_per_line = w->fRowBytes;
162                 for( i=0 ; i < w->fNumClipRects ; i++ )
163                 {
164                     clip = &(w->fClipList[i]);
165                     height = clip->bottom - clip->top +1;
166                     byte_width = w->i_bytes_per_pixel * ((clip->right - clip->left)+1);
167                     p = w->fBits + clip->top * bytes_per_line + clip->left * w->i_bytes_per_pixel;
168                     q = w->p_vout->p_sys->pp_buffer[ !w->p_vout->i_buffer_index ] +
169                         clip->top * w->p_vout->i_bytes_per_line + clip->left *
170                         w->p_vout->i_bytes_per_pixel;
171                     for( y=0 ; y < height ; )
172                     {
173                         pp = (uint64*) p;
174                         qq = (uint64*) q;
175                         for( j=0 ; j < byte_width/64 ; j++ )
176                         {
177                             *pp++ = *qq++;
178                             *pp++ = *qq++; 
179                             *pp++ = *qq++;
180                             *pp++ = *qq++; 
181                             *pp++ = *qq++;
182                             *pp++ = *qq++; 
183                             *pp++ = *qq++;
184                             *pp++ = *qq++; 
185                         }
186                         memcpy( pp , qq, byte_width & 63 );
187                         y++;
188                         p += bytes_per_line;
189                         q += w->p_vout->p_sys->i_width * w->p_vout->i_bytes_per_pixel;
190                     }
191                 }
192             }
193             w->fDirty = false;
194         }
195         w->locker->Unlock();
196         snooze( 20000 );
197     }
198     return B_OK;
199 }
200
201 /*****************************************************************************
202  * VideoWindow constructor and destructor
203  *****************************************************************************/
204
205 VideoWindow::VideoWindow(BRect frame, const char *name, vout_thread_t *p_video_output )
206         : BDirectWindow(frame, name, B_TITLED_WINDOW, B_NOT_RESIZABLE|B_NOT_ZOOMABLE)
207 {
208     BView * view;
209
210     fReady = false;
211     fConnected = false;
212     fConnectionDisabled = false;
213     locker = new BLocker();
214     fClipList = NULL;
215     fNumClipRects = 0;
216     p_vout = p_video_output;
217
218     view = new BView(Bounds(), "", B_FOLLOW_ALL, B_WILL_DRAW);
219     view->SetViewColor(B_TRANSPARENT_32_BIT);
220     AddChild(view);
221 /*
222     if(!SupportsWindowMode())
223     {
224         SetFullScreen(true);
225     }
226 */
227     fDirty = false;
228     fDrawThreadID = spawn_thread(DrawingThread, "drawing_thread",
229                     B_DISPLAY_PRIORITY, (void*) this);
230     resume_thread(fDrawThreadID);
231     Show();
232 }
233
234 VideoWindow::~VideoWindow()
235 {
236     int32 result;
237
238     fConnectionDisabled = true;
239     Hide();
240     Sync();
241     wait_for_thread(fDrawThreadID, &result);
242     free(fClipList);
243     delete locker;
244 }
245
246 /*****************************************************************************
247  * VideoWindow::DirectConnected
248  *****************************************************************************/
249
250 void VideoWindow::DirectConnected(direct_buffer_info *info)
251 {
252     unsigned int i;
253
254     if(!fConnected && fConnectionDisabled)
255     {
256         return;
257     }
258     locker->Lock();
259
260     switch(info->buffer_state & B_DIRECT_MODE_MASK)
261     {
262     case B_DIRECT_START:
263         fConnected = true;
264     case B_DIRECT_MODIFY:
265         fBits = (uint8*)((char*)info->bits +
266         (info->window_bounds.top) * info->bytes_per_row +
267         (info->window_bounds.left) * (info->bits_per_pixel>>3));;
268         
269         i_bytes_per_pixel = info->bits_per_pixel >> 3;
270         i_screen_depth = info->bits_per_pixel;
271         
272         fRowBytes = info->bytes_per_row;
273         fFormat = info->pixel_format;
274         fBounds = info->window_bounds;
275         fDirty = true;
276
277         if(fClipList)
278         {
279             free(fClipList);
280             fClipList = NULL;
281         }
282         fNumClipRects = info->clip_list_count;
283         fClipList = (clipping_rect*) malloc(fNumClipRects*sizeof(clipping_rect));
284         for( i=0 ; i<info->clip_list_count ; i++ )
285         {
286             fClipList[i].top = info->clip_list[i].top - info->window_bounds.top;
287             fClipList[i].left = info->clip_list[i].left - info->window_bounds.left;
288             fClipList[i].bottom = info->clip_list[i].bottom - info->window_bounds.top;
289             fClipList[i].right = info->clip_list[i].right - info->window_bounds.left;
290         }
291         break;
292     case B_DIRECT_STOP:
293         fConnected = false;
294         break;
295     }
296     locker->Unlock();
297 }
298
299 /*****************************************************************************
300  * VideoWindow::MessageReceived
301  *****************************************************************************/
302
303 void VideoWindow::MessageReceived( BMessage * p_message )
304 {
305     BWindow * p_win;
306     
307     switch( p_message->what )
308     {
309     case B_KEY_DOWN:
310         // post the message to the interface window which will handle it
311         p_win = beos_GetAppWindow( "interface" );
312         if( p_win != NULL )
313         {
314             p_win->PostMessage( p_message );
315         }
316         break;
317     
318     default:
319         BWindow::MessageReceived( p_message );
320         break;
321     }
322 }
323
324 /*****************************************************************************
325  * VideoWindow::QuitRequested
326  *****************************************************************************/
327
328 bool VideoWindow::QuitRequested()
329 {
330     return( true );
331 }
332
333 extern "C"
334 {
335
336 /*****************************************************************************
337  * Local prototypes
338  *****************************************************************************/
339 static int     BeosOpenDisplay   ( vout_thread_t *p_vout );
340 static void    BeosCloseDisplay  ( vout_thread_t *p_vout );
341
342 /*****************************************************************************
343  * vout_SysCreate: allocates dummy video thread output method
344  *****************************************************************************
345  * This function allocates and initializes a dummy vout method.
346  *****************************************************************************/
347 int vout_SysCreate( vout_thread_t *p_vout, char *psz_display,
348                     int i_root_window, void *p_data )
349 {
350     /* Allocate structure */
351     p_vout->p_sys = (vout_sys_t*) malloc( sizeof( vout_sys_t ) );
352     if( p_vout->p_sys == NULL )
353     {
354         intf_ErrMsg( "error: %s\n", strerror(ENOMEM) );
355         return( 1 );
356     }
357     
358     /* Set video window's size */
359     p_vout->i_width =  main_GetIntVariable( VOUT_WIDTH_VAR, VOUT_WIDTH_DEFAULT );
360     p_vout->i_height = main_GetIntVariable( VOUT_HEIGHT_VAR, VOUT_HEIGHT_DEFAULT );
361
362     /* Open and initialize device */
363     if( BeosOpenDisplay( p_vout ) )
364     {
365         intf_ErrMsg("vout error: can't open display\n");
366         free( p_vout->p_sys );
367         return( 1 );
368     }
369
370     return( 0 );
371 }
372
373 /*****************************************************************************
374  * vout_SysInit: initialize dummy video thread output method
375  *****************************************************************************/
376 int vout_SysInit( vout_thread_t *p_vout )
377 {
378     VideoWindow * p_win = p_vout->p_sys->p_window;
379     u32 i_page_size;
380
381     p_win->locker->Lock();
382
383     i_page_size =   p_vout->i_width * p_vout->i_height * p_vout->i_bytes_per_pixel;
384     
385     p_vout->p_sys->i_width =         p_vout->i_width;
386     p_vout->p_sys->i_height =        p_vout->i_height;    
387
388     /* Allocate memory for the 2 display buffers */
389     p_vout->p_sys->pp_buffer[0] = (byte_t*) malloc( i_page_size );
390     p_vout->p_sys->pp_buffer[1] = (byte_t*) malloc( i_page_size );
391     if( p_vout->p_sys->pp_buffer[0] == NULL  || p_vout->p_sys->pp_buffer[0] == NULL )
392     {
393         intf_ErrMsg("vout error: can't allocate video memory (%s)\n", strerror(errno) );
394         if( p_vout->p_sys->pp_buffer[0] != NULL ) free( p_vout->p_sys->pp_buffer[0] );
395         if( p_vout->p_sys->pp_buffer[1] != NULL ) free( p_vout->p_sys->pp_buffer[1] );
396         p_win->locker->Unlock();
397         return( 1 );
398     }
399
400     /* Set and initialize buffers */
401     vout_SetBuffers( p_vout, p_vout->p_sys->pp_buffer[0],
402                      p_vout->p_sys->pp_buffer[1] );
403
404     p_win->locker->Unlock();
405     return( 0 );
406 }
407
408 /*****************************************************************************
409  * vout_SysEnd: terminate dummy video thread output method
410  *****************************************************************************/
411 void vout_SysEnd( vout_thread_t *p_vout )
412 {
413    VideoWindow * p_win = p_vout->p_sys->p_window;
414    
415    p_win->Lock();
416    
417    free( p_vout->p_sys->pp_buffer[0] );
418    free( p_vout->p_sys->pp_buffer[1] );
419
420    p_win->fReady = false;
421    p_win->Unlock();   
422 }
423
424 /*****************************************************************************
425  * vout_SysDestroy: destroy dummy video thread output method
426  *****************************************************************************
427  * Terminate an output method created by DummyCreateOutputMethod
428  *****************************************************************************/
429 void vout_SysDestroy( vout_thread_t *p_vout )
430 {
431     BeosCloseDisplay( p_vout );
432     
433     free( p_vout->p_sys );
434 }
435
436 /*****************************************************************************
437  * vout_SysManage: handle dummy events
438  *****************************************************************************
439  * This function should be called regularly by video output thread. It manages
440  * console events. It returns a non null value on error.
441  *****************************************************************************/
442 int vout_SysManage( vout_thread_t *p_vout )
443 {
444     if( p_vout->i_changes & VOUT_SIZE_CHANGE )
445     {
446         intf_DbgMsg("resizing window\n");
447         p_vout->i_changes &= ~VOUT_SIZE_CHANGE;
448
449         /* Resize window */
450         p_vout->p_sys->p_window->ResizeTo( p_vout->i_width, p_vout->i_height );
451
452         /* Destroy XImages to change their size */
453         vout_SysEnd( p_vout );
454
455         /* Recreate XImages. If SysInit failed, the thread can't go on. */
456         if( vout_SysInit( p_vout ) )
457         {
458             intf_ErrMsg("error: can't resize display\n");
459             return( 1 );
460         }
461
462         /* Tell the video output thread that it will need to rebuild YUV
463          * tables. This is needed since convertion buffer size may have changed */
464         p_vout->i_changes |= VOUT_YUV_CHANGE;
465         intf_Msg("Video display resized (%dx%d)\n", p_vout->i_width, p_vout->i_height);
466     }
467     return( 0 );
468 }
469
470 /*****************************************************************************
471  * vout_SysDisplay: displays previously rendered output
472  *****************************************************************************
473  * This function send the currently rendered image to dummy image, waits until
474  * it is displayed and switch the two rendering buffers, preparing next frame.
475  *****************************************************************************/
476 void vout_SysDisplay( vout_thread_t *p_vout )
477 {
478     VideoWindow * p_win = p_vout->p_sys->p_window;
479     
480     p_win->locker->Lock();
481     p_vout->i_buffer_index = ++p_vout->i_buffer_index & 1;
482     p_win->fReady = true;
483     p_win->fDirty = true;
484     p_win->locker->Unlock();
485 }
486
487 /* following functions are local */
488
489 /*****************************************************************************
490  * BeosOpenDisplay: open and initialize dummy device
491  *****************************************************************************
492  * XXX?? The framebuffer mode is only provided as a fast and efficient way to
493  * display video, providing the card is configured and the mode ok. It is
494  * not portable, and is not supposed to work with many cards. Use at your
495  * own risk !
496  *****************************************************************************/
497
498 static int BeosOpenDisplay( vout_thread_t *p_vout )
499
500     /* Create the DirectDraw video window */
501     p_vout->p_sys->p_window =
502         new VideoWindow(  BRect( 100, 100, 100+p_vout->i_width, 100+p_vout->i_height ), "VideoLAN", p_vout );
503     if( p_vout->p_sys->p_window == 0 )
504     {
505         free( p_vout->p_sys );
506         intf_ErrMsg( "error: cannot allocate memory for VideoWindow\n" );
507         return( 1 );
508     }   
509     VideoWindow * p_win = p_vout->p_sys->p_window;
510     
511     /* Wait until DirectConnected has been called */
512     while( !p_win->fConnected )
513         snooze( 50000 );
514
515     p_vout->i_screen_depth =         p_win->i_screen_depth;
516     p_vout->i_bytes_per_pixel =      p_win->i_bytes_per_pixel;
517     p_vout->i_bytes_per_line =       p_vout->i_width*p_win->i_bytes_per_pixel;
518     
519     switch( p_vout->i_screen_depth )
520     {
521     case 8:
522         intf_ErrMsg( "vout error: 8 bit mode not fully supported\n" );
523         break;
524     case 15:
525         p_vout->i_red_mask =        0x7c00;
526         p_vout->i_green_mask =      0x03e0;
527         p_vout->i_blue_mask =       0x001f;
528         break;
529     case 16:
530         p_vout->i_red_mask =        0xf800;
531         p_vout->i_green_mask =      0x07e0;
532         p_vout->i_blue_mask =       0x001f;
533         break;
534     case 24:
535     case 32:
536     default:
537         p_vout->i_red_mask =        0xff0000;
538         p_vout->i_green_mask =      0x00ff00;
539         p_vout->i_blue_mask =       0x0000ff;
540         break;
541     }
542
543     return( 0 );
544 }
545
546 /*****************************************************************************
547  * BeosDisplay: close and reset dummy device
548  *****************************************************************************
549  * Returns all resources allocated by BeosOpenDisplay and restore the original
550  * state of the device.
551  *****************************************************************************/
552 static void BeosCloseDisplay( vout_thread_t *p_vout )
553 {    
554     /* Destroy the video window */
555     p_vout->p_sys->p_window->Lock();
556     p_vout->p_sys->p_window->Quit();
557 }
558
559 } /* extern "C" */