1 /*****************************************************************************
2 * vout_beos.cpp: beos video output display method
3 *****************************************************************************
4 * Copyright (C) 2000, 2001 VideoLAN
5 * $Id: vout_beos.cpp,v 1.26 2001/05/30 17:03:11 sam Exp $
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>
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.
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.
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 *****************************************************************************/
27 #define MODULE_NAME beos
28 #include "modules_inner.h"
30 /*****************************************************************************
32 *****************************************************************************/
35 #include <errno.h> /* ENOMEM */
36 #include <stdlib.h> /* free() */
38 #include <string.h> /* strerror() */
39 #include <kernel/OS.h>
41 #include <Application.h>
58 #include "video_output.h"
60 #include "interface.h"
66 #include "VideoWindow.h"
71 #define BITS_PER_PLANE 16
72 #define BYTES_PER_PIXEL 2
74 /*****************************************************************************
75 * vout_sys_t: BeOS video output method descriptor
76 *****************************************************************************
77 * This structure is part of the video output thread descriptor.
78 * It describes the BeOS specific properties of an output thread.
79 *****************************************************************************/
81 typedef struct vout_sys_s
83 VideoWindow * p_window;
85 byte_t * pp_buffer[2];
91 /*****************************************************************************
92 * beos_GetAppWindow : retrieve a BWindow pointer from the window name
93 *****************************************************************************/
95 BWindow *beos_GetAppWindow(char *name)
100 for (index = 0 ; ; index++)
102 window = be_app->WindowAt(index);
105 if (window->LockWithTimeout(200000) == B_OK)
107 if (strcmp(window->Name(), name) == 0)
118 /*****************************************************************************
119 * DrawingThread : thread that really does the drawing
120 *****************************************************************************/
122 int32 DrawingThread(void *data)
125 w = (VideoWindow*) data;
127 while(!w->teardownwindow)
136 w->view->SetViewOverlay( w->bitmap[w->i_buffer_index],
137 w->bitmap[w->i_buffer_index]->Bounds(),
141 B_OVERLAY_FILTER_HORIZONTAL | B_OVERLAY_FILTER_VERTICAL
142 | B_OVERLAY_TRANSFER_CHANNEL );
143 w->view->SetViewColor(key);
147 w->view->DrawBitmap( w->bitmap[w->i_buffer_index],
148 w->bitmap[w->i_buffer_index]->Bounds(),
156 else // we couldn't lock the window, it probably closed.
165 /*****************************************************************************
166 * VideoWindow constructor and destructor
167 *****************************************************************************/
169 VideoWindow::VideoWindow(BRect frame, const char *name, vout_thread_t *p_video_output )
170 : BWindow(frame, name, B_TITLED_WINDOW, NULL)
172 float minWidth, minHeight, maxWidth, maxHeight;
174 teardownwindow = false;
176 p_vout = p_video_output;
177 fDrawThreadID = NULL;
182 view = new VLCView(Bounds());
184 bitmap[0] = new BBitmap(Bounds(), B_BITMAP_WILL_OVERLAY|B_BITMAP_RESERVE_OVERLAY_CHANNEL, B_YCbCr422);
185 bitmap[1] = new BBitmap(Bounds(), B_BITMAP_WILL_OVERLAY, B_YCbCr422);
186 fUsingOverlay = true;
188 p_vout->b_YCbr = true;
190 if ((bitmap[0]->InitCheck() != B_OK) || (bitmap[1]->InitCheck() != B_OK))
194 p_vout->b_YCbr = false;
195 fUsingOverlay = false;
197 screen = new BScreen();
198 color_space space = screen->ColorSpace();
203 bitmap[0] = new BBitmap(Bounds(), B_RGB15);
204 bitmap[1] = new BBitmap(Bounds(), B_RGB15);
207 else if(space == B_RGB16)
209 bitmap[0] = new BBitmap(Bounds(), B_RGB16);
210 bitmap[1] = new BBitmap(Bounds(), B_RGB16);
213 else //default to 32bpp
215 bitmap[0] = new BBitmap(Bounds(), B_RGB32);
216 bitmap[1] = new BBitmap(Bounds(), B_RGB32);
219 SetTitle(VOUT_TITLE " (BBitmap output)");
225 view->SetViewOverlay(bitmap[0], bitmap[0]->Bounds(), Bounds(), &key, B_FOLLOW_ALL,
226 B_OVERLAY_FILTER_HORIZONTAL|B_OVERLAY_FILTER_VERTICAL);
227 view->SetViewColor(key);
228 SetTitle(VOUT_TITLE " (Overlay output)");
229 GetSizeLimits(&minWidth, &maxWidth, &minHeight, &maxHeight);
230 SetSizeLimits((float) Bounds().IntegerWidth(), maxWidth, (float) Bounds().IntegerHeight(), maxHeight);
234 fDrawThreadID = spawn_thread(DrawingThread, "drawing_thread",
235 B_DISPLAY_PRIORITY, (void*) this);
236 resume_thread(fDrawThreadID);
239 memset(bitmap[0]->Bits(), 0, bitmap[0]->BitsLength());
240 memset(bitmap[1]->Bits(), 0, bitmap[1]->BitsLength());
241 i_bytes_per_pixel = bitmap[0]->BytesPerRow()/bitmap[0]->Bounds().IntegerWidth();
242 fRowBytes = bitmap[0]->BytesPerRow();
247 VideoWindow::~VideoWindow()
253 // if(!fUsingOverlay)
255 teardownwindow = true;
256 wait_for_thread(fDrawThreadID, &result);
263 /*****************************************************************************
264 * VideoWindow::FrameResized
265 *****************************************************************************/
266 void VideoWindow::FrameResized( float width, float height )
270 /*****************************************************************************
272 *****************************************************************************/
274 void VideoWindow::Zoom(BPoint origin, float width, float height )
278 MoveTo(rect.left, rect.top);
279 ResizeTo(rect.IntegerWidth(), rect.IntegerHeight());
280 be_app->ShowCursor();
286 screen = new BScreen(this);
287 BRect rect = screen->Frame();
290 ResizeTo(rect.IntegerWidth(), rect.IntegerHeight());
291 be_app->HideCursor();
293 is_zoomed = !is_zoomed;
296 /*****************************************************************************
297 * VideoWindow::MessageReceived
298 *****************************************************************************/
300 void VideoWindow::MessageReceived( BMessage * p_message )
304 switch( p_message->what )
308 // post the message to the interface window which will handle it
309 p_win = beos_GetAppWindow( "interface" );
312 p_win->PostMessage( p_message );
317 BWindow::MessageReceived( p_message );
322 /*****************************************************************************
323 * VideoWindow::QuitRequested
324 *****************************************************************************/
326 bool VideoWindow::QuitRequested()
328 /* FIXME: send a message ! */
329 p_main->p_intf->b_die = 1;
330 teardownwindow = true;
334 /*****************************************************************************
336 *****************************************************************************/
337 VLCView::VLCView(BRect bounds) : BView(bounds, "", B_FOLLOW_ALL, B_WILL_DRAW)
339 SetViewColor(B_TRANSPARENT_32_BIT);
342 /*****************************************************************************
344 *****************************************************************************/
350 /*****************************************************************************
352 *****************************************************************************/
353 void VLCView::MouseDown(BPoint point)
355 VideoWindow *w = (VideoWindow *) Window();
358 BWindow *win = Window();
366 /*****************************************************************************
368 *****************************************************************************/
369 static int vout_Probe ( probedata_t *p_data );
370 static int vout_Create ( struct vout_thread_s * );
371 static int vout_Init ( struct vout_thread_s * );
372 static void vout_End ( struct vout_thread_s * );
373 static void vout_Destroy ( struct vout_thread_s * );
374 static int vout_Manage ( struct vout_thread_s * );
375 static void vout_Display ( struct vout_thread_s * );
377 static int BeosOpenDisplay ( vout_thread_t *p_vout );
378 static void BeosCloseDisplay( vout_thread_t *p_vout );
380 /*****************************************************************************
381 * Functions exported as capabilities. They are declared as static so that
382 * we don't pollute the namespace too much.
383 *****************************************************************************/
384 void _M( vout_getfunctions )( function_list_t * p_function_list )
386 p_function_list->pf_probe = vout_Probe;
387 p_function_list->functions.vout.pf_create = vout_Create;
388 p_function_list->functions.vout.pf_init = vout_Init;
389 p_function_list->functions.vout.pf_end = vout_End;
390 p_function_list->functions.vout.pf_destroy = vout_Destroy;
391 p_function_list->functions.vout.pf_manage = vout_Manage;
392 p_function_list->functions.vout.pf_display = vout_Display;
393 p_function_list->functions.vout.pf_setpalette = NULL;
396 /*****************************************************************************
397 * vout_Probe: probe the video driver and return a score
398 *****************************************************************************
399 * This function tries to initialize SDL and returns a score to the
400 * plugin manager so that it can select the best plugin.
401 *****************************************************************************/
402 static int vout_Probe( probedata_t *p_data )
404 if( TestMethod( VOUT_METHOD_VAR, "beos" ) )
412 /*****************************************************************************
413 * vout_Create: allocates BeOS video thread output method
414 *****************************************************************************
415 * This function allocates and initializes a BeOS vout method.
416 *****************************************************************************/
417 int vout_Create( vout_thread_t *p_vout )
419 /* Allocate structure */
420 p_vout->p_sys = (vout_sys_t*) malloc( sizeof( vout_sys_t ) );
421 if( p_vout->p_sys == NULL )
423 intf_ErrMsg( "error: %s", strerror(ENOMEM) );
427 /* Set video window's size */
428 p_vout->i_width = main_GetIntVariable( VOUT_WIDTH_VAR,
429 VOUT_WIDTH_DEFAULT );
430 p_vout->i_height = main_GetIntVariable( VOUT_HEIGHT_VAR,
431 VOUT_HEIGHT_DEFAULT );
433 /* Open and initialize device */
434 if( BeosOpenDisplay( p_vout ) )
436 intf_ErrMsg("vout error: can't open display");
437 free( p_vout->p_sys );
444 /*****************************************************************************
445 * vout_Init: initialize BeOS video thread output method
446 *****************************************************************************/
447 int vout_Init( vout_thread_t *p_vout )
449 VideoWindow * p_win = p_vout->p_sys->p_window;
453 i_page_size = p_vout->i_width * p_vout->i_height * p_vout->i_bytes_per_pixel;
455 p_vout->p_sys->i_width = p_vout->i_width;
456 p_vout->p_sys->i_height = p_vout->i_height;
458 /* if(p_win->fUsingOverlay)
460 if(p_win->bitmap[0] != NULL)
462 p_vout->pf_setbuffers( p_vout,
463 (byte_t *)p_win->bitmap[0]->Bits(),
464 (byte_t *)p_win->bitmap[0]->Bits());
465 delete p_win->bitmap[0];
466 p_win->bitmap[0] = NULL;
471 if((p_win->bitmap[0] != NULL) && (p_win->bitmap[1] != NULL))
473 p_vout->pf_setbuffers( p_vout,
474 (byte_t *)p_win->bitmap[0]->Bits(),
475 (byte_t *)p_win->bitmap[1]->Bits());
478 if((p_win->bitmap[0] != NULL) && (p_win->bitmap[1] != NULL))
480 p_vout->pf_setbuffers( p_vout,
481 (byte_t *)p_win->bitmap[0]->Bits(),
482 (byte_t *)p_win->bitmap[1]->Bits());
488 /*****************************************************************************
489 * vout_End: terminate BeOS video thread output method
490 *****************************************************************************/
491 void vout_End( vout_thread_t *p_vout )
495 /*****************************************************************************
496 * vout_Destroy: destroy BeOS video thread output method
497 *****************************************************************************
498 * Terminate an output method created by DummyCreateOutputMethod
499 *****************************************************************************/
500 void vout_Destroy( vout_thread_t *p_vout )
502 BeosCloseDisplay( p_vout );
504 free( p_vout->p_sys );
507 /*****************************************************************************
508 * vout_Manage: handle BeOS events
509 *****************************************************************************
510 * This function should be called regularly by video output thread. It manages
511 * console events. It returns a non null value on error.
512 *****************************************************************************/
513 int vout_Manage( vout_thread_t *p_vout )
515 VideoWindow * p_win = p_vout->p_sys->p_window;
517 float minWidth, minHeight, maxWidth, maxHeight;
519 if( (p_vout->i_width != p_vout->p_sys->i_width) ||
520 (p_vout->i_height != p_vout->p_sys->i_height) )
522 /* If video output size has changed, change interface window size */
523 intf_DbgMsg( "resizing output window" );
524 if(p_win->fUsingOverlay)
527 p_win->view->ClearViewOverlay();
528 delete p_win->bitmap[0];
529 delete p_win->bitmap[1];
530 p_vout->p_sys->i_width = p_vout->i_width;
531 p_vout->p_sys->i_height = p_vout->i_height;;
532 p_win->GetSizeLimits(&minWidth, &maxWidth, &minHeight, &maxHeight);
533 p_win->SetSizeLimits((float) p_vout->p_sys->i_width, maxWidth, (float) p_vout->p_sys->i_height, maxHeight);
534 p_win->ResizeTo(p_vout->p_sys->i_width, p_vout->p_sys->i_height);
535 p_win->bitmap[0] = new BBitmap(p_win->Bounds(),
536 B_BITMAP_WILL_OVERLAY|B_BITMAP_RESERVE_OVERLAY_CHANNEL,
538 p_win->bitmap[0] = new BBitmap(p_win->Bounds(),
539 B_BITMAP_WILL_OVERLAY, B_YCbCr422);
540 memset(p_win->bitmap[0]->Bits(), 0, p_win->bitmap[0]->BitsLength());
541 memset(p_win->bitmap[1]->Bits(), 0, p_win->bitmap[1]->BitsLength());
542 p_win->view->SetViewOverlay(p_win->bitmap[0], p_win->bitmap[0]->Bounds(), p_win->Bounds(), &key, B_FOLLOW_ALL,
543 B_OVERLAY_FILTER_HORIZONTAL|B_OVERLAY_FILTER_VERTICAL|B_OVERLAY_TRANSFER_CHANNEL);
544 p_win->view->SetViewColor(key);
546 p_vout->pf_setbuffers( p_vout,
547 (byte_t *)p_win->bitmap[0]->Bits(),
548 (byte_t *)p_win->bitmap[0]->Bits());
549 delete p_win->bitmap[0];
555 /*****************************************************************************
556 * vout_Display: displays previously rendered output
557 *****************************************************************************
558 * This function send the currently rendered image to BeOS image, waits until
559 * it is displayed and switch the two rendering buffers, preparing next frame.
560 *****************************************************************************/
561 void vout_Display( vout_thread_t *p_vout )
563 VideoWindow * p_win = p_vout->p_sys->p_window;
565 p_win->i_buffer_index = p_vout->i_buffer_index;
566 if(p_win->fUsingOverlay)
567 p_vout->i_buffer_index = p_vout->i_buffer_index & 1;
569 p_vout->i_buffer_index = ++p_vout->i_buffer_index & 1;
570 p_win->fDirty = true;
573 /* following functions are local */
575 /*****************************************************************************
576 * BeosOpenDisplay: open and initialize BeOS device
577 *****************************************************************************
578 * XXX?? The framebuffer mode is only provided as a fast and efficient way to
579 * display video, providing the card is configured and the mode ok. It is
580 * not portable, and is not supposed to work with many cards. Use at your
582 *****************************************************************************/
584 static int BeosOpenDisplay( vout_thread_t *p_vout )
586 p_vout->p_sys->p_window =
587 new VideoWindow( BRect( 80, 50, 80+p_vout->i_width-1, 50+p_vout->i_height-1 ), NULL, p_vout );
588 if( p_vout->p_sys->p_window == 0 )
590 free( p_vout->p_sys );
591 intf_ErrMsg( "error: cannot allocate memory for VideoWindow" );
594 VideoWindow * p_win = p_vout->p_sys->p_window;
596 p_vout->i_screen_depth = p_win->i_screen_depth;
597 p_vout->i_bytes_per_pixel = p_win->i_bytes_per_pixel;
598 p_vout->i_bytes_per_line = p_vout->i_width*p_win->i_bytes_per_pixel;
600 switch( p_vout->i_screen_depth )
603 intf_ErrMsg( "vout error: 8 bit mode not fully supported" );
606 p_vout->i_red_mask = 0x7c00;
607 p_vout->i_green_mask = 0x03e0;
608 p_vout->i_blue_mask = 0x001f;
611 p_vout->i_red_mask = 0xf800;
612 p_vout->i_green_mask = 0x07e0;
613 p_vout->i_blue_mask = 0x001f;
618 p_vout->i_red_mask = 0xff0000;
619 p_vout->i_green_mask = 0x00ff00;
620 p_vout->i_blue_mask = 0x0000ff;
626 /*****************************************************************************
627 * BeosDisplay: close and reset BeOS device
628 *****************************************************************************
629 * Returns all resources allocated by BeosOpenDisplay and restore the original
630 * state of the device.
631 *****************************************************************************/
632 static void BeosCloseDisplay( vout_thread_t *p_vout )
634 /* Destroy the video window */
635 p_vout->p_sys->p_window->Lock();
636 p_vout->p_sys->p_window->Quit();