1 /*****************************************************************************
2 * vout_beos.cpp: beos video output display method
3 *****************************************************************************
4 * Copyright (C) 2000, 2001 VideoLAN
5 * $Id: vout_beos.cpp,v 1.61 2002/07/20 18:01:42 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 /*****************************************************************************
29 *****************************************************************************/
30 #include <errno.h> /* ENOMEM */
31 #include <stdlib.h> /* free() */
33 #include <string.h> /* strerror() */
34 #include <InterfaceKit.h>
35 #include <DirectWindow.h>
36 #include <Application.h>
43 #include "VideoWindow.h"
44 #include "DrawingTidbits.h"
46 /*****************************************************************************
47 * vout_sys_t: BeOS video output method descriptor
48 *****************************************************************************
49 * This structure is part of the video output thread descriptor.
50 * It describes the BeOS specific properties of an output thread.
51 *****************************************************************************/
54 VideoWindow * p_window;
63 /*****************************************************************************
64 * beos_GetAppWindow : retrieve a BWindow pointer from the window name
65 *****************************************************************************/
66 BWindow *beos_GetAppWindow(char *name)
71 for (index = 0 ; ; index++)
73 window = be_app->WindowAt(index);
76 if (window->LockWithTimeout(20000) == B_OK)
78 if (strcmp(window->Name(), name) == 0)
89 /****************************************************************************
90 * DrawingThread : thread that really does the drawing
91 ****************************************************************************/
92 int32 Draw(void *data)
95 p_win = (VideoWindow *) data;
97 if ( p_win->LockWithTimeout(50000) == B_OK )
102 screen = new BScreen(p_win);
103 screen-> WaitForRetrace(22000);
106 if (p_win-> mode == OVERLAY)
109 p_win-> view->SetViewOverlay(p_win-> bitmap[p_win-> i_buffer],
110 p_win-> bitmap[p_win-> i_buffer]->Bounds() ,
111 p_win-> view->Bounds(),
113 B_OVERLAY_FILTER_HORIZONTAL|B_OVERLAY_FILTER_VERTICAL|
114 B_OVERLAY_TRANSFER_CHANNEL);
115 p_win-> view->SetViewColor(key);
119 p_win-> view-> DrawBitmap( p_win-> bitmap[p_win-> i_buffer],
120 p_win-> view->Bounds() );
127 /*****************************************************************************
128 * VideoWindow constructor and destructor
129 *****************************************************************************/
130 VideoWindow::VideoWindow( int v_width, int v_height,
132 : BWindow( frame, NULL, B_TITLED_WINDOW,
133 B_NOT_CLOSABLE | B_NOT_MINIMIZABLE )
135 BView *mainView = new BView( Bounds(), "mainView",
136 B_FOLLOW_ALL, B_FULL_UPDATE_ON_RESIZE);
138 mainView->SetViewColor(kBlack);
140 /* create the view to do the display */
141 view = new VLCView( Bounds() );
142 mainView->AddChild(view);
144 /* set the VideoWindow variables */
145 teardownwindow = false;
149 /* call ScreenChanged to set vsync correctly */
151 display_mode disp_mode;
154 screen = new BScreen(this);
156 screen-> GetMode(&disp_mode);
158 (disp_mode.timing.pixel_clock * 1000)/((disp_mode.timing.h_total)*
159 (disp_mode.timing.v_total));
166 // remember current settings
167 i_width = frame.IntegerWidth();
168 i_height = frame.IntegerHeight();
169 FrameResized(frame.IntegerWidth(), frame.IntegerHeight());
171 mode = SelectDrawingMode(v_width, v_height);
175 VideoWindow::~VideoWindow()
179 teardownwindow = true;
180 wait_for_thread(fDrawThreadID, &result);
186 bool VideoWindow::QuitRequested()
191 void VideoWindow::drawBuffer(int bufferIndex)
195 i_buffer = bufferIndex;
196 // sync to the screen if required
200 screen = new BScreen(this);
201 screen-> WaitForRetrace(22000);
206 // switch the overlay bitmap
210 view->SetViewOverlay(bitmap[i_buffer],
211 bitmap[i_buffer]->Bounds() ,
214 B_OVERLAY_FILTER_HORIZONTAL|B_OVERLAY_FILTER_VERTICAL|
215 B_OVERLAY_TRANSFER_CHANNEL);
216 //view->SetViewColor(key);
221 view-> DrawBitmap(bitmap[i_buffer], view->Bounds() );
227 void VideoWindow::Zoom(BPoint origin, float width, float height )
231 is_zoomed = !is_zoomed;
232 MoveTo(winSize.left, winSize.top);
233 ResizeTo(winSize.IntegerWidth(), winSize.IntegerHeight());
234 be_app->ShowCursor();
238 is_zoomed = !is_zoomed;
240 screen = new BScreen(this);
241 BRect rect = screen->Frame();
244 ResizeTo(rect.IntegerWidth(), rect.IntegerHeight());
245 be_app->ObscureCursor();
249 void VideoWindow::FrameMoved(BPoint origin)
251 if (is_zoomed) return ;
255 void VideoWindow::FrameResized( float width, float height )
257 float out_width, out_height;
258 float out_left, out_top;
259 float width_scale = width / i_width;
260 float height_scale = height / i_height;
262 if (width_scale <= height_scale)
264 out_width = (i_width * width_scale);
265 out_height = (i_height * width_scale);
267 out_top = (height - out_height) / 2;
269 else /* if the height is proportionally smaller */
271 out_width = (i_width * height_scale);
272 out_height = (i_height * height_scale);
274 out_left = (width - out_width) /2;
276 view->MoveTo(out_left,out_top);
277 view->ResizeTo(out_width, out_height);
284 void VideoWindow::ScreenChanged(BRect frame, color_space mode)
289 screen = new BScreen(this);
290 display_mode disp_mode;
292 screen-> GetMode(&disp_mode);
294 (disp_mode.timing.pixel_clock * 1000)/((disp_mode.timing.h_total)*
295 (disp_mode.timing.v_total));
301 view->SetViewOverlay(bitmap[i_buffer],
302 bitmap[i_buffer]->Bounds() ,
305 B_OVERLAY_FILTER_HORIZONTAL|B_OVERLAY_FILTER_VERTICAL);
306 view->SetViewColor(key);
309 void VideoWindow::WindowActivated(bool active)
313 int VideoWindow::SelectDrawingMode(int width, int height)
315 int drawingMode = BITMAP;
317 int noOverlay = !config_GetInt( p_vout, "overlay" );
318 for (int i = 0; i < COLOR_COUNT; i++)
320 if (noOverlay) break;
321 bitmap[0] = new BBitmap ( BRect( 0, 0, width, height ),
322 B_BITMAP_WILL_OVERLAY,
323 colspace[i].colspace);
325 if(bitmap[0] && bitmap[0]->InitCheck() == B_OK)
329 bitmap[1] = new BBitmap( BRect( 0, 0, width, height ), B_BITMAP_WILL_OVERLAY,
330 colspace[colspace_index].colspace);
331 bitmap[2] = new BBitmap( BRect( 0, 0, width, height ), B_BITMAP_WILL_OVERLAY,
332 colspace[colspace_index].colspace);
333 if ( (bitmap[2] && bitmap[2]->InitCheck() == B_OK) )
335 drawingMode = OVERLAY;
337 view->SetViewOverlay(bitmap[0],
338 bitmap[0]->Bounds() ,
341 B_OVERLAY_FILTER_HORIZONTAL|B_OVERLAY_FILTER_VERTICAL);
342 view->SetViewColor(key);
343 SetTitle(VOUT_TITLE " (Overlay)");
359 if (drawingMode == BITMAP)
362 colspace_index = DEFAULT_COL;
363 SetTitle(VOUT_TITLE " (Bitmap)");
364 bitmap[0] = new BBitmap( BRect( 0, 0, width, height ), colspace[colspace_index].colspace);
365 bitmap[1] = new BBitmap( BRect( 0, 0, width, height ), colspace[colspace_index].colspace);
366 bitmap[2] = new BBitmap( BRect( 0, 0, width, height ), colspace[colspace_index].colspace);
371 /*****************************************************************************
373 *****************************************************************************/
374 VLCView::VLCView(BRect bounds) : BView(bounds, "", B_FOLLOW_NONE,
378 SetViewColor(B_TRANSPARENT_32_BIT);
381 /*****************************************************************************
383 *****************************************************************************/
388 /*****************************************************************************
390 *****************************************************************************/
391 void VLCView::MouseDown(BPoint point)
393 BWindow *win = Window();
397 /*****************************************************************************
399 *****************************************************************************/
400 void VLCView::Draw(BRect updateRect)
402 VideoWindow *win = (VideoWindow *) Window();
403 if (win->mode == BITMAP)
404 FillRect(updateRect);
411 /*****************************************************************************
413 *****************************************************************************/
414 static int vout_Create ( vout_thread_t * );
415 static int vout_Init ( vout_thread_t * );
416 static void vout_End ( vout_thread_t * );
417 static void vout_Destroy ( vout_thread_t * );
418 static int vout_Manage ( vout_thread_t * );
419 static void vout_Display ( vout_thread_t *, picture_t * );
420 static void vout_Render ( vout_thread_t *, picture_t * );
422 static int BeosOpenDisplay ( vout_thread_t *p_vout );
423 static void BeosCloseDisplay( vout_thread_t *p_vout );
425 /*****************************************************************************
426 * Functions exported as capabilities. They are declared as static so that
427 * we don't pollute the namespace too much.
428 *****************************************************************************/
429 void _M( vout_getfunctions )( function_list_t * p_function_list )
431 p_function_list->functions.vout.pf_create = vout_Create;
432 p_function_list->functions.vout.pf_init = vout_Init;
433 p_function_list->functions.vout.pf_end = vout_End;
434 p_function_list->functions.vout.pf_destroy = vout_Destroy;
435 p_function_list->functions.vout.pf_manage = vout_Manage;
436 p_function_list->functions.vout.pf_display = vout_Display;
437 p_function_list->functions.vout.pf_render = vout_Render;
440 /*****************************************************************************
441 * vout_Create: allocates BeOS video thread output method
442 *****************************************************************************
443 * This function allocates and initializes a BeOS vout method.
444 *****************************************************************************/
445 int vout_Create( vout_thread_t *p_vout )
447 /* Allocate structure */
448 p_vout->p_sys = (vout_sys_t*) malloc( sizeof( vout_sys_t ) );
449 if( p_vout->p_sys == NULL )
451 msg_Err( p_vout, "out of memory" );
454 p_vout->p_sys->i_width = p_vout->render.i_width;
455 p_vout->p_sys->i_height = p_vout->render.i_height;
460 /*****************************************************************************
461 * vout_Init: initialize BeOS video thread output method
462 *****************************************************************************/
463 int vout_Init( vout_thread_t *p_vout )
468 I_OUTPUTPICTURES = 0;
470 /* Open and initialize device */
471 if( BeosOpenDisplay( p_vout ) )
473 msg_Err( p_vout, "cannot open display" );
476 /* Set the buffers */
477 p_vout->p_sys->pp_buffer[0] = (u8*)p_vout->p_sys->p_window->bitmap[0]->Bits();
478 p_vout->p_sys->pp_buffer[1] = (u8*)p_vout->p_sys->p_window->bitmap[1]->Bits();
479 p_vout->p_sys->pp_buffer[2] = (u8*)p_vout->p_sys->p_window->bitmap[2]->Bits();
480 p_vout->output.i_width = p_vout->render.i_width;
481 p_vout->output.i_height = p_vout->render.i_height;
483 /* Assume we have square pixels */
484 p_vout->output.i_aspect = p_vout->p_sys->i_width
485 * VOUT_ASPECT_FACTOR / p_vout->p_sys->i_height;
486 p_vout->output.i_chroma = colspace[p_vout->p_sys->p_window->colspace_index].chroma;
487 p_vout->p_sys->i_index = 0;
489 p_vout->output.i_rmask = 0x00ff0000;
490 p_vout->output.i_gmask = 0x0000ff00;
491 p_vout->output.i_bmask = 0x000000ff;
493 for (int buffer_index = 0 ; buffer_index < 3; buffer_index++)
496 /* Find an empty picture slot */
497 for( i_index = 0 ; i_index < VOUT_MAX_PICTURES ; i_index++ )
500 if( p_vout->p_picture[ i_index ].i_status == FREE_PICTURE )
502 p_pic = p_vout->p_picture + i_index;
511 p_pic->p->p_pixels = p_vout->p_sys->pp_buffer[0];
512 p_pic->p->i_lines = p_vout->p_sys->i_height;
514 p_pic->p->i_pixel_bytes = colspace[p_vout->p_sys->p_window->colspace_index].pixel_bytes;
515 p_pic->i_planes = colspace[p_vout->p_sys->p_window->colspace_index].planes;
516 p_pic->p->i_pitch = p_vout->p_sys->p_window->bitmap[0]->BytesPerRow();
518 if (p_vout->p_sys->p_window->mode == OVERLAY)
520 p_pic->p->i_visible_bytes = (p_vout->p_sys->p_window->bitmap[0]->Bounds().IntegerWidth()+1)
521 * p_pic->p->i_pixel_bytes;
522 p_pic->p->b_margin = 1;
523 p_pic->p->b_hidden = 0;
527 p_pic->p->b_margin = 0;
528 p_pic->p->i_visible_bytes = p_pic->p->i_pitch;
531 p_pic->i_status = DESTROYED_PICTURE;
532 p_pic->i_type = DIRECT_PICTURE;
534 PP_OUTPUTPICTURE[ I_OUTPUTPICTURES ] = p_pic;
542 /*****************************************************************************
543 * vout_End: terminate BeOS video thread output method
544 *****************************************************************************/
545 void vout_End( vout_thread_t *p_vout )
547 BeosCloseDisplay( p_vout );
550 /*****************************************************************************
551 * vout_Destroy: destroy BeOS video thread output method
552 *****************************************************************************
553 * Terminate an output method created by DummyCreateOutputMethod
554 *****************************************************************************/
555 void vout_Destroy( vout_thread_t *p_vout )
557 free( p_vout->p_sys );
560 /*****************************************************************************
561 * vout_Manage: handle BeOS events
562 *****************************************************************************
563 * This function should be called regularly by video output thread. It manages
564 * console events. It returns a non null value on error.
565 *****************************************************************************/
566 int vout_Manage( vout_thread_t *p_vout )
572 /*****************************************************************************
573 * vout_Render: render previously calculated output
574 *****************************************************************************/
575 void vout_Render( vout_thread_t *p_vout, picture_t *p_pic )
580 /*****************************************************************************
581 * vout_Display: displays previously rendered output
582 *****************************************************************************
583 * This function send the currently rendered image to BeOS image, waits until
584 * it is displayed and switch the two rendering buffers, preparing next frame.
585 *****************************************************************************/
586 void vout_Display( vout_thread_t *p_vout, picture_t *p_pic )
588 VideoWindow * p_win = p_vout->p_sys->p_window;
590 /* draw buffer if required */
591 if (!p_win->teardownwindow)
593 p_win->drawBuffer(p_vout->p_sys->i_index);
596 p_vout->p_sys->i_index = ++p_vout->p_sys->i_index % 3;
597 p_pic->p->p_pixels = p_vout->p_sys->pp_buffer[p_vout->p_sys->i_index];
600 /* following functions are local */
602 /*****************************************************************************
603 * BeosOpenDisplay: open and initialize BeOS device
604 *****************************************************************************/
605 static int BeosOpenDisplay( vout_thread_t *p_vout )
608 p_vout->p_sys->p_window = new VideoWindow( p_vout->p_sys->i_width - 1,
609 p_vout->p_sys->i_height - 1,
611 20 + p_vout->i_window_width - 1,
612 50 + p_vout->i_window_height - 1 ));
614 if( p_vout->p_sys->p_window == NULL )
616 msg_Err( p_vout, "cannot allocate VideoWindow" );
623 /*****************************************************************************
624 * BeosDisplay: close and reset BeOS device
625 *****************************************************************************
626 * Returns all resources allocated by BeosOpenDisplay and restore the original
627 * state of the device.
628 *****************************************************************************/
629 static void BeosCloseDisplay( vout_thread_t *p_vout )
631 VideoWindow * p_win = p_vout->p_sys->p_window;
632 /* Destroy the video window */
633 if( p_win != NULL && !p_win->teardownwindow)
636 p_win->teardownwindow = true;