Rewritten vout for BeOS. Now does not support overlay however code is simpler
[vlc.git] / plugins / beos / vout_beos.cpp
1 /*****************************************************************************
2  * vout_beos.cpp: beos video output display method
3  *****************************************************************************
4  * Copyright (C) 2000, 2001 VideoLAN
5  * $Id: vout_beos.cpp,v 1.28 2001/08/14 12:09:03 tcastley Exp $
6  *
7  * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
8  *          Samuel Hocevar <sam@zoy.org>
9  *          Tony Castley <tcastley@mail.powerup.com.au>
10  *          Richard Shepherd <richard@rshepherd.demon.co.uk>
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 #define MODULE_NAME beos
28 #include "modules_inner.h"
29
30 /*****************************************************************************
31  * Preamble
32  *****************************************************************************/
33 #include "defs.h"
34
35 #include <errno.h>                                                 /* ENOMEM */
36 #include <stdlib.h>                                                /* free() */
37 #include <stdio.h>
38 #include <string.h>                                            /* strerror() */
39 #include <kernel/OS.h>
40 #include <View.h>
41 #include <Application.h>
42 #include <Window.h>
43 #include <Locker.h>
44 #include <Screen.h>
45 #include <malloc.h>
46 #include <string.h>
47
48 extern "C"
49 {
50 #include "config.h"
51 #include "common.h"
52 #include "threads.h"
53 #include "mtime.h"
54 #include "tests.h"
55
56 #include "video.h"
57 #include "video_output.h"
58
59 #include "interface.h"
60 #include "intf_msg.h"
61
62 #include "main.h"
63
64 #include "modules.h"
65 #include "modules_export.h"
66 }
67
68 #include "VideoWindow.h"
69 #include <Screen.h>
70
71 #define WIDTH 128
72 #define HEIGHT 64
73 #define BITS_PER_PLANE 16
74 #define BYTES_PER_PIXEL 2
75
76 /*****************************************************************************
77  * vout_sys_t: BeOS video output method descriptor
78  *****************************************************************************
79  * This structure is part of the video output thread descriptor.
80  * It describes the BeOS specific properties of an output thread.
81  *****************************************************************************/
82  
83 typedef struct vout_sys_s
84 {
85     VideoWindow *         p_window;
86
87     byte_t *              pp_buffer[2];
88     s32                   i_width;
89     s32                   i_height;
90 } vout_sys_t;
91
92
93 /*****************************************************************************
94  * beos_GetAppWindow : retrieve a BWindow pointer from the window name
95  *****************************************************************************/
96
97 BWindow *beos_GetAppWindow(char *name)
98 {
99     int32       index;
100     BWindow     *window;
101     
102     for (index = 0 ; ; index++)
103     {
104         window = be_app->WindowAt(index);
105         if (window == NULL)
106             break;
107         if (window->LockWithTimeout(20000) == B_OK)
108         {
109             if (strcmp(window->Name(), name) == 0)
110             {
111                 window->Unlock();
112                 break;
113             }
114             window->Unlock();
115         }
116     }
117     return window; 
118 }
119
120 /*****************************************************************************
121  * DrawingThread : thread that really does the drawing
122  *****************************************************************************/
123
124 int32 Draw(void *data)
125 {
126   VideoWindow *w;
127   w = (VideoWindow*) data;
128           if (w->LockLooper())
129       {
130         w->view->DrawBitmap( w->bitmap[w->i_buffer_index],
131                               w->bitmap[w->i_buffer_index]->Bounds(),
132                               w->Bounds());
133 //          w->view->Sync();
134         w->UnlockLooper();
135       }
136   return B_OK;
137 }
138
139 /*****************************************************************************
140  * VideoWindow constructor and destructor
141  *****************************************************************************/
142
143 VideoWindow::VideoWindow(BRect frame, const char *name, vout_thread_t *p_video_output )
144         : BWindow(frame, name, B_TITLED_WINDOW, NULL)
145 {
146
147         /* set the VideoWindow variables */
148     teardownwindow = false;
149     is_zoomed = false;
150         fUsingOverlay = false;
151         p_video_output->b_YCbr = false;
152         i_screen_depth = 16;
153         
154         /* create the view to do the display */
155     view = new VLCView(Bounds());
156     AddChild(view);
157     
158     /* Bitmap mode overlay not available */
159         bitmap[0] = new BBitmap(Bounds(), B_RGB32);
160         bitmap[1] = new BBitmap(Bounds(), B_RGB32);
161         i_screen_depth = 32;
162         SetTitle(VOUT_TITLE " (BBitmap output)");
163
164         memset(bitmap[0]->Bits(), 0, bitmap[0]->BitsLength());
165         memset(bitmap[1]->Bits(), 0, bitmap[1]->BitsLength());
166
167         i_width = bitmap[0]->Bounds().IntegerWidth();
168         i_height = bitmap[0]->Bounds().IntegerHeight();
169         i_bytes_per_pixel = bitmap[0]->BytesPerRow()/i_width;
170     fRowBytes = bitmap[0]->BytesPerRow();
171         i_screen_depth = 8 * i_bytes_per_pixel;
172
173     fDirty = false;
174     Show();
175 }
176
177 VideoWindow::~VideoWindow()
178 {
179     int32 result;
180
181     Hide();
182     Sync();
183     teardownwindow = true;
184     wait_for_thread(fDrawThreadID, &result);
185         delete bitmap[0];
186         delete bitmap[1];
187  }
188
189
190 /*****************************************************************************
191  * VideoWindow::FrameResized
192  *****************************************************************************/
193 void VideoWindow::FrameResized( float width, float height )
194 {
195 }
196
197 /*****************************************************************************
198  * VideoWindow::Zoom
199  *****************************************************************************/
200
201 void VideoWindow::Zoom(BPoint origin, float width, float height )
202 {
203         if(is_zoomed)
204         {
205                 MoveTo(rect.left, rect.top);
206                 ResizeTo(rect.IntegerWidth(), rect.IntegerHeight());
207                 be_app->ShowCursor();
208         }
209         else
210         {
211                 rect = Frame();
212                 BScreen *screen;
213                 screen = new BScreen(this);
214                 BRect rect = screen->Frame();
215                 delete screen;
216                 MoveTo(0,0);
217                 ResizeTo(rect.IntegerWidth(), rect.IntegerHeight());
218                 be_app->HideCursor();
219         }
220         is_zoomed = !is_zoomed;
221 }
222
223 /*****************************************************************************
224  * VideoWindow::MessageReceived
225  *****************************************************************************/
226
227 void VideoWindow::MessageReceived( BMessage * p_message )
228 {
229     BWindow * p_win;
230     
231     switch( p_message->what )
232     {
233     case B_KEY_DOWN:
234     case B_SIMPLE_DATA:
235         // post the message to the interface window which will handle it
236         p_win = beos_GetAppWindow( "interface" );
237         if( p_win != NULL )
238         {
239             p_win->PostMessage( p_message );
240         }
241         break;
242     
243     default:
244         BWindow::MessageReceived( p_message );
245         break;
246     }
247 }
248
249 /*****************************************************************************
250  * VideoWindow::QuitRequested
251  *****************************************************************************/
252
253 bool VideoWindow::QuitRequested()
254 {
255     /* FIXME: send a message ! */
256     p_main->p_intf->b_die = 1;
257     teardownwindow = true;
258     return( false );
259 }
260
261 /*****************************************************************************
262  * VLCView::VLCView
263  *****************************************************************************/
264 VLCView::VLCView(BRect bounds) : BView(bounds, "", B_FOLLOW_ALL, B_WILL_DRAW)
265 {
266         SetViewColor(B_TRANSPARENT_32_BIT);
267 }
268
269 /*****************************************************************************
270  * VLCView::~VLCView
271  *****************************************************************************/
272 VLCView::~VLCView()
273 {
274
275 }
276
277 /*****************************************************************************
278  * VLCVIew::~VLCView
279  *****************************************************************************/
280 void VLCView::MouseDown(BPoint point)
281 {
282         VideoWindow *w = (VideoWindow *) Window();
283         if(w->is_zoomed)
284         {
285                 BWindow *win = Window();
286                 win->Zoom();
287         }
288 }
289
290 extern "C"
291 {
292
293 /*****************************************************************************
294  * Local prototypes
295  *****************************************************************************/
296 static int  vout_Probe      ( probedata_t *p_data );
297 static int  vout_Create     ( struct vout_thread_s * );
298 static int  vout_Init       ( struct vout_thread_s * );
299 static void vout_End        ( struct vout_thread_s * );
300 static void vout_Destroy    ( struct vout_thread_s * );
301 static int  vout_Manage     ( struct vout_thread_s * );
302 static void vout_Display    ( struct vout_thread_s * );
303
304 static int  BeosOpenDisplay ( vout_thread_t *p_vout );
305 static void BeosCloseDisplay( vout_thread_t *p_vout );
306
307 /*****************************************************************************
308  * Functions exported as capabilities. They are declared as static so that
309  * we don't pollute the namespace too much.
310  *****************************************************************************/
311 void _M( vout_getfunctions )( function_list_t * p_function_list )
312 {
313     p_function_list->pf_probe = vout_Probe;
314     p_function_list->functions.vout.pf_create     = vout_Create;
315     p_function_list->functions.vout.pf_init       = vout_Init;
316     p_function_list->functions.vout.pf_end        = vout_End;
317     p_function_list->functions.vout.pf_destroy    = vout_Destroy;
318     p_function_list->functions.vout.pf_manage     = vout_Manage;
319     p_function_list->functions.vout.pf_display    = vout_Display;
320     p_function_list->functions.vout.pf_setpalette = NULL;
321 }
322
323 /*****************************************************************************
324  * vout_Probe: probe the video driver and return a score
325  *****************************************************************************
326  * This function tries to initialize SDL and returns a score to the
327  * plugin manager so that it can select the best plugin.
328  *****************************************************************************/
329 static int vout_Probe( probedata_t *p_data )
330 {
331     if( TestMethod( VOUT_METHOD_VAR, "beos" ) )
332     {
333         return( 999 );
334     }
335
336     return( 100 );
337 }
338
339 /*****************************************************************************
340  * vout_Create: allocates BeOS video thread output method
341  *****************************************************************************
342  * This function allocates and initializes a BeOS vout method.
343  *****************************************************************************/
344 int vout_Create( vout_thread_t *p_vout )
345 {
346     /* Allocate structure */
347     p_vout->p_sys = (vout_sys_t*) malloc( sizeof( vout_sys_t ) );
348     if( p_vout->p_sys == NULL )
349     {
350         intf_ErrMsg( "error: %s", strerror(ENOMEM) );
351         return( 1 );
352     }
353     
354     /* Set video window's size */
355     p_vout->i_width =  main_GetIntVariable( VOUT_WIDTH_VAR,
356                                             VOUT_WIDTH_DEFAULT );
357     p_vout->i_height = main_GetIntVariable( VOUT_HEIGHT_VAR,
358                                             VOUT_HEIGHT_DEFAULT );
359
360     /* Open and initialize device */
361     if( BeosOpenDisplay( p_vout ) )
362     {
363         intf_ErrMsg("vout error: can't open display");
364         free( p_vout->p_sys );
365         return( 1 );
366     }
367
368     return( 0 );
369 }
370
371 /*****************************************************************************
372  * vout_Init: initialize BeOS video thread output method
373  *****************************************************************************/
374 int vout_Init( vout_thread_t *p_vout )
375 {
376     VideoWindow * p_win = p_vout->p_sys->p_window;
377     u32 i_page_size;
378
379
380     i_page_size =   p_vout->i_width * p_vout->i_height * p_vout->i_bytes_per_pixel;
381     
382     if((p_win->bitmap[0] != NULL) && (p_win->bitmap[1] != NULL))
383         {
384         p_vout->pf_setbuffers( p_vout,
385                (byte_t *)p_win->bitmap[0]->Bits(),
386                (byte_t *)p_win->bitmap[1]->Bits());
387     }
388     return( 0 );
389 }
390
391 /*****************************************************************************
392  * vout_End: terminate BeOS video thread output method
393  *****************************************************************************/
394 void vout_End( vout_thread_t *p_vout )
395 {
396 }
397
398 /*****************************************************************************
399  * vout_Destroy: destroy BeOS video thread output method
400  *****************************************************************************
401  * Terminate an output method created by DummyCreateOutputMethod
402  *****************************************************************************/
403 void vout_Destroy( vout_thread_t *p_vout )
404 {
405     BeosCloseDisplay( p_vout );
406     
407     free( p_vout->p_sys );
408 }
409
410 /*****************************************************************************
411  * vout_Manage: handle BeOS events
412  *****************************************************************************
413  * This function should be called regularly by video output thread. It manages
414  * console events. It returns a non null value on error.
415  *****************************************************************************/
416 int vout_Manage( vout_thread_t *p_vout )
417 {
418         return( 0 );
419 }
420
421 /*****************************************************************************
422  * vout_Display: displays previously rendered output
423  *****************************************************************************
424  * This function send the currently rendered image to BeOS image, waits until
425  * it is displayed and switch the two rendering buffers, preparing next frame.
426  *****************************************************************************/
427 void vout_Display( vout_thread_t *p_vout )
428 {
429         status_t status;
430
431     VideoWindow * p_win = p_vout->p_sys->p_window;
432     
433         p_win->i_buffer_index = p_vout->i_buffer_index;
434         p_vout->i_buffer_index = ++p_vout->i_buffer_index & 1;
435
436         p_win->fDrawThreadID = spawn_thread(Draw, "drawing_thread",
437               B_DISPLAY_PRIORITY, (void*) p_win);
438     wait_for_thread(p_win->fDrawThreadID, &status);
439         
440 }
441
442 /* following functions are local */
443
444 /*****************************************************************************
445  * BeosOpenDisplay: open and initialize BeOS device
446  *****************************************************************************
447  * XXX?? The framebuffer mode is only provided as a fast and efficient way to
448  * display video, providing the card is configured and the mode ok. It is
449  * not portable, and is not supposed to work with many cards. Use at your
450  * own risk !
451  *****************************************************************************/
452
453 static int BeosOpenDisplay( vout_thread_t *p_vout )
454
455     
456     p_vout->p_sys->p_window =
457         new VideoWindow(  BRect( 80, 50, 80+p_vout->i_width-1, 50+p_vout->i_height-1 ), NULL, p_vout );
458     if( p_vout->p_sys->p_window == 0 )
459     {
460         free( p_vout->p_sys );
461         intf_ErrMsg( "error: cannot allocate memory for VideoWindow" );
462         return( 1 );
463     }   
464     VideoWindow * p_win = p_vout->p_sys->p_window;
465     
466     p_vout->i_screen_depth =         p_win->i_screen_depth;
467     p_vout->i_bytes_per_pixel =      p_win->i_bytes_per_pixel;
468     p_vout->i_width =                            p_win->i_width + 1;
469     p_vout->i_height =                           p_win->i_height + 1;
470     p_vout->i_bytes_per_line =       p_vout->i_width*p_win->i_bytes_per_pixel;
471
472     switch( p_vout->i_screen_depth )
473     {
474     case 8:
475         intf_ErrMsg( "vout error: 8 bit mode not fully supported" );
476         break;
477     case 15:
478         p_vout->i_red_mask =        0x7c00;
479         p_vout->i_green_mask =      0x03e0;
480         p_vout->i_blue_mask =       0x001f;
481         break;
482     case 16:
483         p_vout->i_red_mask =        0xf800;
484         p_vout->i_green_mask =      0x07e0;
485         p_vout->i_blue_mask =       0x001f;
486         break;
487     case 24:
488     case 32:
489     default:
490         p_vout->i_red_mask =        0xff0000;
491         p_vout->i_green_mask =      0x00ff00;
492         p_vout->i_blue_mask =       0x0000ff;
493         break;
494     }
495     return( 0 );
496 }
497
498 /*****************************************************************************
499  * BeosDisplay: close and reset BeOS device
500  *****************************************************************************
501  * Returns all resources allocated by BeosOpenDisplay and restore the original
502  * state of the device.
503  *****************************************************************************/
504 static void BeosCloseDisplay( vout_thread_t *p_vout )
505 {    
506     /* Destroy the video window */
507     p_vout->p_sys->p_window->Lock();
508     p_vout->p_sys->p_window->Quit();
509 }
510
511 } /* extern "C" */