1 /*****************************************************************************
2 * vout_beos.cpp: beos video output display method
3 *****************************************************************************
4 * Copyright (C) 2000, 2001 VideoLAN
6 * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
7 * Samuel Hocevar <sam@zoy.org>
8 * Richard Shepherd <richard@rshepherd.demon.co.uk>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
23 *****************************************************************************/
25 #define MODULE_NAME beos
26 #include "modules_inner.h"
28 /*****************************************************************************
30 *****************************************************************************/
33 #include <errno.h> /* ENOMEM */
34 #include <stdlib.h> /* free() */
36 #include <string.h> /* strerror() */
37 #include <kernel/OS.h>
39 #include <Application.h>
56 #include "video_output.h"
58 #include "interface.h"
64 #include "VideoWindow.h"
69 #define BITS_PER_PLANE 16
70 #define BYTES_PER_PIXEL 2
72 /*****************************************************************************
73 * vout_sys_t: BeOS video output method descriptor
74 *****************************************************************************
75 * This structure is part of the video output thread descriptor.
76 * It describes the BeOS specific properties of an output thread.
77 *****************************************************************************/
79 typedef struct vout_sys_s
81 VideoWindow * p_window;
83 byte_t * pp_buffer[2];
89 /*****************************************************************************
90 * beos_GetAppWindow : retrieve a BWindow pointer from the window name
91 *****************************************************************************/
93 BWindow *beos_GetAppWindow(char *name)
98 for (index = 0 ; ; index++)
100 window = be_app->WindowAt(index);
103 if (window->LockWithTimeout(200000) == B_OK)
105 if (strcmp(window->Name(), name) == 0)
116 /*****************************************************************************
117 * DrawingThread : thread that really does the drawing
118 *****************************************************************************/
120 int32 DrawingThread(void *data)
123 w = (VideoWindow*) data;
125 while(!w->teardownwindow)
130 if(!w->fUsingOverlay)
131 w->view->DrawBitmap(w->bitmap[w->i_buffer_index], w->bitmap[w->i_buffer_index]->Bounds(), w->Bounds());
140 /*****************************************************************************
141 * VideoWindow constructor and destructor
142 *****************************************************************************/
144 VideoWindow::VideoWindow(BRect frame, const char *name, vout_thread_t *p_video_output )
145 : BWindow(frame, name, B_TITLED_WINDOW, NULL)
147 float minWidth, minHeight, maxWidth, maxHeight;
149 teardownwindow = false;
151 p_vout = p_video_output;
154 view = new VLCView(Bounds());
156 bitmap[0] = new BBitmap(Bounds(), B_BITMAP_WILL_OVERLAY|B_BITMAP_RESERVE_OVERLAY_CHANNEL, B_YCbCr422);
157 fUsingOverlay = true;
159 p_vout->b_YCbr = true;
161 if (bitmap[0]->InitCheck() != B_OK)
164 p_vout->b_YCbr = false;
165 fUsingOverlay = false;
167 screen = new BScreen();
168 color_space space = screen->ColorSpace();
173 bitmap[0] = new BBitmap(Bounds(), B_RGB15);
174 bitmap[1] = new BBitmap(Bounds(), B_RGB15);
177 else if(space == B_RGB16)
179 bitmap[0] = new BBitmap(Bounds(), B_RGB16);
180 bitmap[1] = new BBitmap(Bounds(), B_RGB16);
183 else //default to 32bpp
185 bitmap[0] = new BBitmap(Bounds(), B_RGB32);
186 bitmap[1] = new BBitmap(Bounds(), B_RGB32);
189 memset(bitmap[0]->Bits(), 0, bitmap[0]->BitsLength());
190 memset(bitmap[1]->Bits(), 0, bitmap[1]->BitsLength());
191 SetTitle(VOUT_TITLE " (BBitmap output)");
196 memset(bitmap[0]->Bits(), 0, bitmap[0]->BitsLength());
198 view->SetViewOverlay(bitmap[0], bitmap[0]->Bounds(), Bounds(), &key, B_FOLLOW_ALL,
199 B_OVERLAY_FILTER_HORIZONTAL|B_OVERLAY_FILTER_VERTICAL);
200 view->SetViewColor(key);
201 SetTitle(VOUT_TITLE " (Overlay output)");
202 GetSizeLimits(&minWidth, &maxWidth, &minHeight, &maxHeight);
203 SetSizeLimits((float) Bounds().IntegerWidth(), maxWidth, (float) Bounds().IntegerHeight(), maxHeight);
206 i_bytes_per_pixel = bitmap[0]->BytesPerRow()/bitmap[0]->Bounds().IntegerWidth();
207 fRowBytes = bitmap[0]->BytesPerRow();
209 fDrawThreadID = spawn_thread(DrawingThread, "drawing_thread",
210 B_DISPLAY_PRIORITY, (void*) this);
211 resume_thread(fDrawThreadID);
215 VideoWindow::~VideoWindow()
221 wait_for_thread(fDrawThreadID, &result);
228 /*****************************************************************************
229 * VideoWindow::FrameResized
230 *****************************************************************************/
231 void VideoWindow::FrameResized( float width, float height )
235 /*****************************************************************************
237 *****************************************************************************/
239 void VideoWindow::Zoom(BPoint origin, float width, float height )
243 MoveTo(rect.left, rect.top);
244 ResizeTo(rect.IntegerWidth(), rect.IntegerHeight());
245 be_app->ShowCursor();
251 screen = new BScreen(this);
252 BRect rect = screen->Frame();
255 ResizeTo(rect.IntegerWidth(), rect.IntegerHeight());
256 be_app->HideCursor();
258 is_zoomed = !is_zoomed;
261 /*****************************************************************************
262 * VideoWindow::MessageReceived
263 *****************************************************************************/
265 void VideoWindow::MessageReceived( BMessage * p_message )
269 switch( p_message->what )
273 // post the message to the interface window which will handle it
274 p_win = beos_GetAppWindow( "interface" );
277 p_win->PostMessage( p_message );
282 BWindow::MessageReceived( p_message );
287 /*****************************************************************************
288 * VideoWindow::QuitRequested
289 *****************************************************************************/
291 bool VideoWindow::QuitRequested()
293 /* FIXME: send a message ! */
294 p_main->p_intf->b_die = 1;
295 teardownwindow = true;
299 /*****************************************************************************
301 *****************************************************************************/
302 VLCView::VLCView(BRect bounds) : BView(bounds, "", B_FOLLOW_ALL, B_WILL_DRAW)
304 SetViewColor(B_TRANSPARENT_32_BIT);
307 /*****************************************************************************
309 *****************************************************************************/
315 /*****************************************************************************
317 *****************************************************************************/
318 void VLCView::MouseDown(BPoint point)
320 VideoWindow *w = (VideoWindow *) Window();
323 BWindow *win = Window();
331 /*****************************************************************************
333 *****************************************************************************/
334 static int vout_Probe ( probedata_t *p_data );
335 static int vout_Create ( struct vout_thread_s * );
336 static int vout_Init ( struct vout_thread_s * );
337 static void vout_End ( struct vout_thread_s * );
338 static void vout_Destroy ( struct vout_thread_s * );
339 static int vout_Manage ( struct vout_thread_s * );
340 static void vout_Display ( struct vout_thread_s * );
342 static int BeosOpenDisplay ( vout_thread_t *p_vout );
343 static void BeosCloseDisplay( vout_thread_t *p_vout );
345 /*****************************************************************************
346 * Functions exported as capabilities. They are declared as static so that
347 * we don't pollute the namespace too much.
348 *****************************************************************************/
349 void _M( vout_getfunctions )( function_list_t * p_function_list )
351 p_function_list->pf_probe = vout_Probe;
352 p_function_list->functions.vout.pf_create = vout_Create;
353 p_function_list->functions.vout.pf_init = vout_Init;
354 p_function_list->functions.vout.pf_end = vout_End;
355 p_function_list->functions.vout.pf_destroy = vout_Destroy;
356 p_function_list->functions.vout.pf_manage = vout_Manage;
357 p_function_list->functions.vout.pf_display = vout_Display;
358 p_function_list->functions.vout.pf_setpalette = NULL;
361 /*****************************************************************************
362 * vout_Probe: probe the video driver and return a score
363 *****************************************************************************
364 * This function tries to initialize SDL and returns a score to the
365 * plugin manager so that it can select the best plugin.
366 *****************************************************************************/
367 static int vout_Probe( probedata_t *p_data )
369 if( TestMethod( VOUT_METHOD_VAR, "beos" ) )
377 /*****************************************************************************
378 * vout_Create: allocates BeOS video thread output method
379 *****************************************************************************
380 * This function allocates and initializes a BeOS vout method.
381 *****************************************************************************/
382 int vout_Create( vout_thread_t *p_vout )
384 /* Allocate structure */
385 p_vout->p_sys = (vout_sys_t*) malloc( sizeof( vout_sys_t ) );
386 if( p_vout->p_sys == NULL )
388 intf_ErrMsg( "error: %s", strerror(ENOMEM) );
392 /* Set video window's size */
393 p_vout->i_width = main_GetIntVariable( VOUT_WIDTH_VAR,
394 VOUT_WIDTH_DEFAULT );
395 p_vout->i_height = main_GetIntVariable( VOUT_HEIGHT_VAR,
396 VOUT_HEIGHT_DEFAULT );
398 /* Open and initialize device */
399 if( BeosOpenDisplay( p_vout ) )
401 intf_ErrMsg("vout error: can't open display");
402 free( p_vout->p_sys );
409 /*****************************************************************************
410 * vout_Init: initialize BeOS video thread output method
411 *****************************************************************************/
412 int vout_Init( vout_thread_t *p_vout )
414 VideoWindow * p_win = p_vout->p_sys->p_window;
418 i_page_size = p_vout->i_width * p_vout->i_height * p_vout->i_bytes_per_pixel;
420 p_vout->p_sys->i_width = p_vout->i_width;
421 p_vout->p_sys->i_height = p_vout->i_height;
423 if(p_win->fUsingOverlay)
425 vout_SetBuffers( p_vout, (byte_t *)p_win->bitmap[0]->Bits(),
426 (byte_t *)p_win->bitmap[0]->Bits());
430 vout_SetBuffers( p_vout, (byte_t *)p_win->bitmap[0]->Bits(),
431 (byte_t *)p_win->bitmap[1]->Bits());
436 /*****************************************************************************
437 * vout_End: terminate BeOS video thread output method
438 *****************************************************************************/
439 void vout_End( vout_thread_t *p_vout )
443 /*****************************************************************************
444 * vout_Destroy: destroy BeOS video thread output method
445 *****************************************************************************
446 * Terminate an output method created by DummyCreateOutputMethod
447 *****************************************************************************/
448 void vout_Destroy( vout_thread_t *p_vout )
450 BeosCloseDisplay( p_vout );
452 free( p_vout->p_sys );
455 /*****************************************************************************
456 * vout_Manage: handle BeOS events
457 *****************************************************************************
458 * This function should be called regularly by video output thread. It manages
459 * console events. It returns a non null value on error.
460 *****************************************************************************/
461 int vout_Manage( vout_thread_t *p_vout )
466 /*****************************************************************************
467 * vout_Display: displays previously rendered output
468 *****************************************************************************
469 * This function send the currently rendered image to BeOS image, waits until
470 * it is displayed and switch the two rendering buffers, preparing next frame.
471 *****************************************************************************/
472 void vout_Display( vout_thread_t *p_vout )
474 VideoWindow * p_win = p_vout->p_sys->p_window;
476 p_win->i_buffer_index = p_vout->i_buffer_index;
477 p_vout->i_buffer_index = ++p_vout->i_buffer_index & 1;
478 p_win->fDirty = true;
481 /* following functions are local */
483 /*****************************************************************************
484 * BeosOpenDisplay: open and initialize BeOS device
485 *****************************************************************************
486 * XXX?? The framebuffer mode is only provided as a fast and efficient way to
487 * display video, providing the card is configured and the mode ok. It is
488 * not portable, and is not supposed to work with many cards. Use at your
490 *****************************************************************************/
492 static int BeosOpenDisplay( vout_thread_t *p_vout )
494 p_vout->p_sys->p_window =
495 new VideoWindow( BRect( 50, 150, 50+p_vout->i_width-1, 150+p_vout->i_height-1 ), NULL, p_vout );
496 if( p_vout->p_sys->p_window == 0 )
498 free( p_vout->p_sys );
499 intf_ErrMsg( "error: cannot allocate memory for VideoWindow" );
502 VideoWindow * p_win = p_vout->p_sys->p_window;
504 p_vout->i_screen_depth = p_win->i_screen_depth;
505 p_vout->i_bytes_per_pixel = p_win->i_bytes_per_pixel;
506 p_vout->i_bytes_per_line = p_vout->i_width*p_win->i_bytes_per_pixel;
508 switch( p_vout->i_screen_depth )
511 intf_ErrMsg( "vout error: 8 bit mode not fully supported" );
514 p_vout->i_red_mask = 0x7c00;
515 p_vout->i_green_mask = 0x03e0;
516 p_vout->i_blue_mask = 0x001f;
519 p_vout->i_red_mask = 0xf800;
520 p_vout->i_green_mask = 0x07e0;
521 p_vout->i_blue_mask = 0x001f;
526 p_vout->i_red_mask = 0xff0000;
527 p_vout->i_green_mask = 0x00ff00;
528 p_vout->i_blue_mask = 0x0000ff;
534 /*****************************************************************************
535 * BeosDisplay: close and reset BeOS device
536 *****************************************************************************
537 * Returns all resources allocated by BeosOpenDisplay and restore the original
538 * state of the device.
539 *****************************************************************************/
540 static void BeosCloseDisplay( vout_thread_t *p_vout )
542 /* Destroy the video window */
543 p_vout->p_sys->p_window->Lock();
544 p_vout->p_sys->p_window->Quit();