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>
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.
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.
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 *****************************************************************************/
24 #define MODULE_NAME beos
25 #include "modules_inner.h"
27 /*****************************************************************************
29 *****************************************************************************/
32 #include <errno.h> /* ENOMEM */
33 #include <stdlib.h> /* free() */
35 #include <string.h> /* strerror() */
36 #include <kernel/OS.h>
38 #include <Application.h>
39 #include <DirectWindow.h>
54 #include "video_output.h"
56 #include "interface.h" /* XXX maybe to remove if beos_window.h is splitted */
62 #include "beos_window.h"
66 #define BITS_PER_PLANE 16
67 #define BYTES_PER_PIXEL 2
69 /*****************************************************************************
70 * vout_sys_t: BeOS video output method descriptor
71 *****************************************************************************
72 * This structure is part of the video output thread descriptor.
73 * It describes the BeOS specific properties of an output thread.
74 *****************************************************************************/
76 typedef struct vout_sys_s
78 VideoWindow * p_window;
80 byte_t * pp_buffer[2];
86 /*****************************************************************************
87 * beos_GetAppWindow : retrieve a BWindow pointer from the window name
88 *****************************************************************************/
90 BWindow *beos_GetAppWindow(char *name)
95 for (index = 0 ; ; index++)
97 window = be_app->WindowAt(index);
100 if (window->LockWithTimeout(200000) == B_OK)
102 if (strcmp(window->Name(), name) == 0)
113 /*****************************************************************************
114 * DrawingThread : thread that really does the drawing
115 *****************************************************************************/
117 int32 DrawingThread(void *data)
123 uint32 height, bytes_per_line;
127 w = (VideoWindow*) data;
129 while(!w->fConnectionDisabled)
134 if( w->fDirty && (!w->fReady || w->i_screen_depth != w->p_vout->i_screen_depth) )
136 bytes_per_line = w->fRowBytes;
137 for( i=0 ; i < w->fNumClipRects ; i++ )
139 clip = &(w->fClipList[i]);
140 height = clip->bottom - clip->top +1;
141 byte_width = w->i_bytes_per_pixel * ((clip->right - clip->left)+1);
142 p = w->fBits + clip->top*w->fRowBytes + clip->left * w->i_bytes_per_pixel;
143 for( y=0 ; y < height ; )
146 for( j=0 ; j < byte_width/64 ; j++ )
157 memset( pp , 0, byte_width & 63 );
165 bytes_per_line = w->fRowBytes;
166 for( i=0 ; i < w->fNumClipRects ; i++ )
168 clip = &(w->fClipList[i]);
169 height = clip->bottom - clip->top +1;
170 byte_width = w->i_bytes_per_pixel * ((clip->right - clip->left)+1);
171 p = w->fBits + clip->top * bytes_per_line + clip->left * w->i_bytes_per_pixel;
172 q = w->p_vout->p_sys->pp_buffer[ !w->p_vout->i_buffer_index ] +
173 clip->top * w->p_vout->i_bytes_per_line + clip->left *
174 w->p_vout->i_bytes_per_pixel;
175 for( y=0 ; y < height ; )
179 for( j=0 ; j < byte_width/64 ; j++ )
190 memcpy( pp , qq, byte_width & 63 );
193 q += w->p_vout->p_sys->i_width * w->p_vout->i_bytes_per_pixel;
205 /*****************************************************************************
206 * VideoWindow constructor and destructor
207 *****************************************************************************/
209 VideoWindow::VideoWindow(BRect frame, const char *name, vout_thread_t *p_video_output )
210 : BDirectWindow(frame, name, B_TITLED_WINDOW, B_NOT_RESIZABLE|B_NOT_ZOOMABLE)
216 fConnectionDisabled = false;
217 locker = new BLocker();
220 p_vout = p_video_output;
222 view = new BView(Bounds(), "", B_FOLLOW_ALL, B_WILL_DRAW);
223 view->SetViewColor(B_TRANSPARENT_32_BIT);
226 if(!SupportsWindowMode())
232 fDrawThreadID = spawn_thread(DrawingThread, "drawing_thread",
233 B_DISPLAY_PRIORITY, (void*) this);
234 resume_thread(fDrawThreadID);
238 VideoWindow::~VideoWindow()
242 fConnectionDisabled = true;
245 wait_for_thread(fDrawThreadID, &result);
250 /*****************************************************************************
251 * VideoWindow::DirectConnected
252 *****************************************************************************/
254 void VideoWindow::DirectConnected(direct_buffer_info *info)
258 if(!fConnected && fConnectionDisabled)
264 switch(info->buffer_state & B_DIRECT_MODE_MASK)
268 case B_DIRECT_MODIFY:
269 fBits = (uint8*)((char*)info->bits +
270 (info->window_bounds.top) * info->bytes_per_row +
271 (info->window_bounds.left) * (info->bits_per_pixel>>3));;
273 i_bytes_per_pixel = info->bits_per_pixel >> 3;
274 i_screen_depth = info->bits_per_pixel;
276 fRowBytes = info->bytes_per_row;
277 fFormat = info->pixel_format;
278 fBounds = info->window_bounds;
286 fNumClipRects = info->clip_list_count;
287 fClipList = (clipping_rect*) malloc(fNumClipRects*sizeof(clipping_rect));
288 for( i=0 ; i<info->clip_list_count ; i++ )
290 fClipList[i].top = info->clip_list[i].top - info->window_bounds.top;
291 fClipList[i].left = info->clip_list[i].left - info->window_bounds.left;
292 fClipList[i].bottom = info->clip_list[i].bottom - info->window_bounds.top;
293 fClipList[i].right = info->clip_list[i].right - info->window_bounds.left;
303 /*****************************************************************************
304 * VideoWindow::FrameResized
305 *****************************************************************************/
307 void VideoWindow::FrameResized( float width, float height )
312 /*****************************************************************************
313 * VideoWindow::MessageReceived
314 *****************************************************************************/
316 void VideoWindow::MessageReceived( BMessage * p_message )
320 switch( p_message->what )
324 // post the message to the interface window which will handle it
325 p_win = beos_GetAppWindow( "interface" );
328 p_win->PostMessage( p_message );
333 BWindow::MessageReceived( p_message );
338 /*****************************************************************************
339 * VideoWindow::QuitRequested
340 *****************************************************************************/
342 bool VideoWindow::QuitRequested()
344 /* FIXME: send a message ! */
345 p_main->p_intf->b_die = 1;
353 /*****************************************************************************
355 *****************************************************************************/
356 static int vout_Probe ( probedata_t *p_data );
357 static int vout_Create ( struct vout_thread_s * );
358 static int vout_Init ( struct vout_thread_s * );
359 static void vout_End ( struct vout_thread_s * );
360 static void vout_Destroy ( struct vout_thread_s * );
361 static int vout_Manage ( struct vout_thread_s * );
362 static void vout_Display ( struct vout_thread_s * );
364 static int BeosOpenDisplay ( vout_thread_t *p_vout );
365 static void BeosCloseDisplay( vout_thread_t *p_vout );
367 /*****************************************************************************
368 * Functions exported as capabilities. They are declared as static so that
369 * we don't pollute the namespace too much.
370 *****************************************************************************/
371 void _M( vout_getfunctions )( function_list_t * p_function_list )
373 p_function_list->pf_probe = vout_Probe;
374 p_function_list->functions.vout.pf_create = vout_Create;
375 p_function_list->functions.vout.pf_init = vout_Init;
376 p_function_list->functions.vout.pf_end = vout_End;
377 p_function_list->functions.vout.pf_destroy = vout_Destroy;
378 p_function_list->functions.vout.pf_manage = vout_Manage;
379 p_function_list->functions.vout.pf_display = vout_Display;
380 p_function_list->functions.vout.pf_setpalette = NULL;
383 /*****************************************************************************
384 * vout_Probe: probe the video driver and return a score
385 *****************************************************************************
386 * This function tries to initialize SDL and returns a score to the
387 * plugin manager so that it can select the best plugin.
388 *****************************************************************************/
389 static int vout_Probe( probedata_t *p_data )
391 if( TestMethod( VOUT_METHOD_VAR, "beos" ) )
399 /*****************************************************************************
400 * vout_Create: allocates BeOS video thread output method
401 *****************************************************************************
402 * This function allocates and initializes a BeOS vout method.
403 *****************************************************************************/
404 int vout_Create( vout_thread_t *p_vout )
406 /* Allocate structure */
407 p_vout->p_sys = (vout_sys_t*) malloc( sizeof( vout_sys_t ) );
408 if( p_vout->p_sys == NULL )
410 intf_ErrMsg( "error: %s", strerror(ENOMEM) );
414 /* Set video window's size */
415 p_vout->i_width = main_GetIntVariable( VOUT_WIDTH_VAR,
416 VOUT_WIDTH_DEFAULT );
417 p_vout->i_height = main_GetIntVariable( VOUT_HEIGHT_VAR,
418 VOUT_HEIGHT_DEFAULT );
420 /* Open and initialize device */
421 if( BeosOpenDisplay( p_vout ) )
423 intf_ErrMsg("vout error: can't open display");
424 free( p_vout->p_sys );
431 /*****************************************************************************
432 * vout_Init: initialize BeOS video thread output method
433 *****************************************************************************/
434 int vout_Init( vout_thread_t *p_vout )
436 VideoWindow * p_win = p_vout->p_sys->p_window;
439 p_win->locker->Lock();
441 i_page_size = p_vout->i_width * p_vout->i_height * p_vout->i_bytes_per_pixel;
443 p_vout->p_sys->i_width = p_vout->i_width;
444 p_vout->p_sys->i_height = p_vout->i_height;
446 /* Allocate memory for the 2 display buffers */
447 p_vout->p_sys->pp_buffer[0] = (byte_t*) malloc( i_page_size );
448 p_vout->p_sys->pp_buffer[1] = (byte_t*) malloc( i_page_size );
449 if( p_vout->p_sys->pp_buffer[0] == NULL || p_vout->p_sys->pp_buffer[0] == NULL )
451 intf_ErrMsg("vout error: can't allocate video memory (%s)", strerror(errno) );
452 if( p_vout->p_sys->pp_buffer[0] != NULL ) free( p_vout->p_sys->pp_buffer[0] );
453 if( p_vout->p_sys->pp_buffer[1] != NULL ) free( p_vout->p_sys->pp_buffer[1] );
454 p_win->locker->Unlock();
458 /* Set and initialize buffers */
459 vout_SetBuffers( p_vout, p_vout->p_sys->pp_buffer[0],
460 p_vout->p_sys->pp_buffer[1] );
462 p_win->locker->Unlock();
466 /*****************************************************************************
467 * vout_End: terminate BeOS video thread output method
468 *****************************************************************************/
469 void vout_End( vout_thread_t *p_vout )
471 VideoWindow * p_win = p_vout->p_sys->p_window;
475 free( p_vout->p_sys->pp_buffer[0] );
476 free( p_vout->p_sys->pp_buffer[1] );
478 p_win->fReady = false;
482 /*****************************************************************************
483 * vout_Destroy: destroy BeOS video thread output method
484 *****************************************************************************
485 * Terminate an output method created by DummyCreateOutputMethod
486 *****************************************************************************/
487 void vout_Destroy( vout_thread_t *p_vout )
489 BeosCloseDisplay( p_vout );
491 free( p_vout->p_sys );
494 /*****************************************************************************
495 * vout_Manage: handle BeOS events
496 *****************************************************************************
497 * This function should be called regularly by video output thread. It manages
498 * console events. It returns a non null value on error.
499 *****************************************************************************/
500 int vout_Manage( vout_thread_t *p_vout )
502 if( p_vout->p_sys->p_window->b_resized )
504 p_vout->p_sys->p_window->b_resized = 0;
505 p_vout->i_changes |= VOUT_SIZE_CHANGE;
508 if( p_vout->i_changes & VOUT_SIZE_CHANGE )
510 intf_WarnMsg( 1, "resizing window" );
511 p_vout->i_changes &= ~VOUT_SIZE_CHANGE;
514 p_vout->p_sys->p_window->ResizeTo( p_vout->i_width, p_vout->i_height );
516 /* Destroy XImages to change their size */
519 /* Recreate XImages. If SysInit failed, the thread can't go on. */
520 if( vout_Init( p_vout ) )
522 intf_ErrMsg( "error: can't resize display" );
526 /* Tell the video output thread that it will need to rebuild YUV
527 * tables. This is needed since convertion buffer size may have
529 p_vout->i_changes |= VOUT_YUV_CHANGE;
530 intf_Msg( "vout: video display resized (%dx%d)",
531 p_vout->i_width, p_vout->i_height );
537 /*****************************************************************************
538 * vout_Display: displays previously rendered output
539 *****************************************************************************
540 * This function send the currently rendered image to BeOS image, waits until
541 * it is displayed and switch the two rendering buffers, preparing next frame.
542 *****************************************************************************/
543 void vout_Display( vout_thread_t *p_vout )
545 VideoWindow * p_win = p_vout->p_sys->p_window;
547 p_win->locker->Lock();
548 p_vout->i_buffer_index = ++p_vout->i_buffer_index & 1;
549 p_win->fReady = true;
550 p_win->fDirty = true;
551 p_win->locker->Unlock();
554 /* following functions are local */
556 /*****************************************************************************
557 * BeosOpenDisplay: open and initialize BeOS device
558 *****************************************************************************
559 * XXX?? The framebuffer mode is only provided as a fast and efficient way to
560 * display video, providing the card is configured and the mode ok. It is
561 * not portable, and is not supposed to work with many cards. Use at your
563 *****************************************************************************/
565 static int BeosOpenDisplay( vout_thread_t *p_vout )
567 /* Create the DirectDraw video window */
568 p_vout->p_sys->p_window =
569 new VideoWindow( BRect( 50, 150, 50+p_vout->i_width-1, 150+p_vout->i_height-1 ), VOUT_TITLE " (BeOS output) - drop a file here to play it !", p_vout );
570 if( p_vout->p_sys->p_window == 0 )
572 free( p_vout->p_sys );
573 intf_ErrMsg( "error: cannot allocate memory for VideoWindow" );
576 VideoWindow * p_win = p_vout->p_sys->p_window;
578 /* Wait until DirectConnected has been called */
579 while( !p_win->fConnected )
582 p_vout->i_screen_depth = p_win->i_screen_depth;
583 p_vout->i_bytes_per_pixel = p_win->i_bytes_per_pixel;
584 p_vout->i_bytes_per_line = p_vout->i_width*p_win->i_bytes_per_pixel;
586 switch( p_vout->i_screen_depth )
589 intf_ErrMsg( "vout error: 8 bit mode not fully supported" );
592 p_vout->i_red_mask = 0x7c00;
593 p_vout->i_green_mask = 0x03e0;
594 p_vout->i_blue_mask = 0x001f;
597 p_vout->i_red_mask = 0xf800;
598 p_vout->i_green_mask = 0x07e0;
599 p_vout->i_blue_mask = 0x001f;
604 p_vout->i_red_mask = 0xff0000;
605 p_vout->i_green_mask = 0x00ff00;
606 p_vout->i_blue_mask = 0x0000ff;
613 /*****************************************************************************
614 * BeosDisplay: close and reset BeOS device
615 *****************************************************************************
616 * Returns all resources allocated by BeosOpenDisplay and restore the original
617 * state of the device.
618 *****************************************************************************/
619 static void BeosCloseDisplay( vout_thread_t *p_vout )
621 /* Destroy the video window */
622 p_vout->p_sys->p_window->Lock();
623 p_vout->p_sys->p_window->Quit();