vout_beos.cpp 19.4 KB
Newer Older
1
2
3
/*****************************************************************************
 * vout_beos.cpp: beos video output display method
 *****************************************************************************
Sam Hocevar's avatar
   
Sam Hocevar committed
4
 * Copyright (C) 2000, 2001 VideoLAN
gbazin's avatar
   
gbazin committed
5
 * $Id: vout_beos.cpp,v 1.42 2002/02/24 20:51:09 gbazin Exp $
6
 *
Sam Hocevar's avatar
   
Sam Hocevar committed
7
8
 * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
 *          Samuel Hocevar <sam@zoy.org>
Richard Shepherd's avatar
Richard Shepherd committed
9
 *          Tony Castley <tcastley@mail.powerup.com.au>
Sam Hocevar's avatar
   
Sam Hocevar committed
10
 *          Richard Shepherd <richard@rshepherd.demon.co.uk>
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
 *****************************************************************************/

/*****************************************************************************
 * Preamble
 *****************************************************************************/
#include <errno.h>                                                 /* ENOMEM */
#include <stdlib.h>                                                /* free() */
#include <stdio.h>
#include <string.h>                                            /* strerror() */
34
35
#include <InterfaceKit.h>
#include <DirectWindow.h>
36
#include <Application.h>
37
#include <Bitmap.h>
38
39
40

extern "C"
{
Sam Hocevar's avatar
   
Sam Hocevar committed
41
#include <videolan/vlc.h>
42
43
44
45

#include "video.h"
#include "video_output.h"

Sam Hocevar's avatar
   
Sam Hocevar committed
46
#include "interface.h"
47
48
}

Sam Hocevar's avatar
   
Sam Hocevar committed
49
#include "VideoWindow.h"
50

Sam Hocevar's avatar
   
Sam Hocevar committed
51
52
#define BITS_PER_PLANE  16
#define BYTES_PER_PIXEL 2
53
54

/*****************************************************************************
Sam Hocevar's avatar
   
Sam Hocevar committed
55
 * vout_sys_t: BeOS video output method descriptor
56
57
 *****************************************************************************
 * This structure is part of the video output thread descriptor.
Sam Hocevar's avatar
   
Sam Hocevar committed
58
 * It describes the BeOS specific properties of an output thread.
59
60
61
 *****************************************************************************/
typedef struct vout_sys_s
{
Sam Hocevar's avatar
   
Sam Hocevar committed
62
    VideoWindow *  p_window;
Sam Hocevar's avatar
   
Sam Hocevar committed
63

Sam Hocevar's avatar
   
Sam Hocevar committed
64
65
    s32 i_width;
    s32 i_height;
Sam Hocevar's avatar
   
Sam Hocevar committed
66
67
68
69

    u8 *pp_buffer[2];
    int i_index;

70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
} vout_sys_t;


/*****************************************************************************
 * beos_GetAppWindow : retrieve a BWindow pointer from the window name
 *****************************************************************************/
BWindow *beos_GetAppWindow(char *name)
{
    int32       index;
    BWindow     *window;
    
    for (index = 0 ; ; index++)
    {
        window = be_app->WindowAt(index);
        if (window == NULL)
            break;
86
        if (window->LockWithTimeout(20000) == B_OK)
87
88
89
90
91
92
93
94
95
96
97
98
        {
            if (strcmp(window->Name(), name) == 0)
            {
                window->Unlock();
                break;
            }
            window->Unlock();
        }
    }
    return window; 
}

99
100
/**************************************************************************** 
 * DrawingThread : thread that really does the drawing 
Sam Hocevar's avatar
   
Sam Hocevar committed
101
 ****************************************************************************/ 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
int32 Draw(void *data) 
{ 
    //rudolf: sync init: 
    BScreen *screen; 
    display_mode disp_mode; 
    static uint32 refresh, oldrefresh = 0; 

    screen = new BScreen(); 
    screen-> GetMode(&disp_mode); 
    refresh = 
         (disp_mode.timing.pixel_clock * 1000)/((disp_mode.timing.h_total)* 
         (disp_mode.timing.v_total)); 
    if (!(refresh == oldrefresh)) 
    { 
Sam Hocevar's avatar
   
Sam Hocevar committed
116
        intf_WarnMsg( 1, "vout info: new refreshrate is %ld:Hz", refresh ); 
117
        oldrefresh = refresh; 
Sam Hocevar's avatar
   
Sam Hocevar committed
118
        if (refresh < 61 ) 
119
        { 
Sam Hocevar's avatar
   
Sam Hocevar committed
120
            intf_WarnMsg( 1, "vout info: enabling retrace sync" ); 
121
122
123
        } 
        else 
        { 
Sam Hocevar's avatar
   
Sam Hocevar committed
124
            intf_WarnMsg( 1, "vout info: disabling retrace sync" ); 
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
        } 
    } 

    VideoWindow* p_win; 
    p_win = (VideoWindow *) data; 
    if ( p_win-> voutWindow-> LockLooper() ) 
    { 
        //rudolf: sync: 
        if (refresh  < 61) 
        { 
            screen-> WaitForRetrace(22000);//set timeout for  < 45 Hz... 
        } 

        p_win-> view-> DrawBitmap( p_win-> bitmap[p_win-> i_buffer], 
                                 p_win-> bitmap[p_win-> i_buffer]-> Bounds(), 
                                 p_win-> voutWindow-> Bounds() );  
        p_win-> voutWindow-> UnlockLooper(); 
    } 
    return B_OK; 
Sam Hocevar's avatar
   
Sam Hocevar committed
144
145
}

146
/*****************************************************************************
147
 * bitmapWindow : This is the bitmap window output
148
 *****************************************************************************/
149
150
151
bitmapWindow::bitmapWindow(BRect frame, VideoWindow *theOwner)
        : BWindow( frame, NULL, B_TITLED_WINDOW, 
                   B_OUTLINE_RESIZE | B_NOT_CLOSABLE | B_NOT_MINIMIZABLE )
152
{
Sam Hocevar's avatar
   
Sam Hocevar committed
153
    is_zoomed = false;
154
155
156
157
    origRect = frame;
    owner = theOwner;
    SetTitle(VOUT_TITLE " (BBitmap output)");
}
158

159
160
161
bitmapWindow::~bitmapWindow()
{
}
Richard Shepherd's avatar
Richard Shepherd committed
162

163
164
void bitmapWindow::FrameResized( float width, float height )
{
Sam Hocevar's avatar
   
Sam Hocevar committed
165
166
167
168
169
170
171
172
173
174
    if (is_zoomed)
    {
        return;
    }
    float width_scale;
    float height_scale;

    width_scale = width / origRect.Width();
    height_scale = height / origRect.Height();
    
175
176
177
178
179
180
181
182
183
184
    /* if the width is proportionally smaller */
    if (width_scale <= height_scale)
    {
        ResizeTo(width, origRect.Height() * width_scale);
    }
    else /* if the height is proportionally smaller */
    {
        ResizeTo(origRect.Width() * height_scale, height);
    }
}
185

186
187
void bitmapWindow::Zoom(BPoint origin, float width, float height )
{
Sam Hocevar's avatar
   
Sam Hocevar committed
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
    if(is_zoomed)
    {
        MoveTo(origRect.left, origRect.top);
        ResizeTo(origRect.IntegerWidth(), origRect.IntegerHeight());
        be_app->ShowCursor();
    }
    else
    {
        BScreen *screen;
        screen = new BScreen(this);
        BRect rect = screen->Frame();
        delete screen;
        MoveTo(0,0);
        ResizeTo(rect.IntegerWidth(), rect.IntegerHeight());
        be_app->HideCursor();
    }
    is_zoomed = !is_zoomed;
205
206
}

207
208
209
210
211
212
/*****************************************************************************
 * directWindow : This is the bitmap window output
 *****************************************************************************/
directWindow::directWindow(BRect frame, VideoWindow *theOwner)
        : BDirectWindow( frame, NULL, B_TITLED_WINDOW, 
                   B_OUTLINE_RESIZE | B_NOT_CLOSABLE | B_NOT_MINIMIZABLE )
213
{
214
215
216
217
218
    is_zoomed = false;
    origRect = frame;
    owner = theOwner;
    SetTitle(VOUT_TITLE " (DirectWindow output)");
}
Sam Hocevar's avatar
   
Sam Hocevar committed
219

220
221
222
directWindow::~directWindow()
{
}
Sam Hocevar's avatar
   
Sam Hocevar committed
223

224
225
226
void directWindow::DirectConnected(direct_buffer_info *info)
{
}
227

228
void directWindow::FrameResized( float width, float height )
Sam Hocevar's avatar
   
Sam Hocevar committed
229
{
Sam Hocevar's avatar
   
Sam Hocevar committed
230
231
232
233
234
235
236
237
238
239
    if (is_zoomed)
    {
        return;
    }
    float width_scale;
    float height_scale;

    width_scale = width / origRect.Width();
    height_scale = height / origRect.Height();
    
240
241
242
    /* if the width is proportionally smaller */
    if (width_scale <= height_scale)
    {
243
        ResizeTo(width, origRect.Height() * width_scale);
244
245
246
    }
    else /* if the height is proportionally smaller */
    {
247
        ResizeTo(origRect.Width() * height_scale, height);
248
    }
Sam Hocevar's avatar
   
Sam Hocevar committed
249
250
}

251
void directWindow::Zoom(BPoint origin, float width, float height )
Sam Hocevar's avatar
   
Sam Hocevar committed
252
{
Sam Hocevar's avatar
   
Sam Hocevar committed
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
    if(is_zoomed)
    {
        SetFullScreen(false);
        MoveTo(origRect.left, origRect.top);
        ResizeTo(origRect.IntegerWidth(), origRect.IntegerHeight());
        be_app->ShowCursor();
    }
    else
    {
        SetFullScreen(true);
        BScreen *screen;
        screen = new BScreen(this);
        BRect rect = screen->Frame();
        delete screen;
        MoveTo(0,0);
        ResizeTo(rect.IntegerWidth(), rect.IntegerHeight());
        be_app->HideCursor();
    }
    is_zoomed = !is_zoomed;
Sam Hocevar's avatar
   
Sam Hocevar committed
272
273
}

274
/*****************************************************************************
275
 * VideoWindow constructor and destructor
276
 *****************************************************************************/
277
278
VideoWindow::VideoWindow( int width, int height, 
                          vout_thread_t *p_video_output )
279
{
280
281
282
    if ( BDirectWindow::SupportsWindowMode() )
    { 
        voutWindow = new directWindow( BRect( 80, 50, 
Sam Hocevar's avatar
   
Sam Hocevar committed
283
                                          80 + width, 50 + height ), this );
284
285
286
    }
    else
    {
Sam Hocevar's avatar
   
Sam Hocevar committed
287
288
289
        voutWindow = new bitmapWindow( BRect( 80, 50, 
                                          80 + width, 50 + height ), this );
    }
290

Sam Hocevar's avatar
   
Sam Hocevar committed
291
    /* set the VideoWindow variables */
292
    teardownwindow = false;
Sam Hocevar's avatar
   
Sam Hocevar committed
293
294
    
    /* create the view to do the display */
295
296
    view = new VLCView( voutWindow->Bounds() );
    voutWindow->AddChild(view);
297
    
Sam Hocevar's avatar
   
Sam Hocevar committed
298
299
    /* Bitmap mode overlay not available, set the system to 32bits
     * and let BeOS do all the work */
Sam Hocevar's avatar
   
Sam Hocevar committed
300
301
302
303
304
305
306
    bitmap[0] = new BBitmap( voutWindow->Bounds(), B_RGB32);
    bitmap[1] = new BBitmap( voutWindow->Bounds(), B_RGB32);
    memset(bitmap[0]->Bits(), 0, bitmap[0]->BitsLength());
    memset(bitmap[1]->Bits(), 0, bitmap[1]->BitsLength());

    i_width = bitmap[0]->Bounds().IntegerWidth();
    i_height = bitmap[0]->Bounds().IntegerHeight();
307
308
309
310
311
312
313
314
315
316
317
318
319
320

    voutWindow->Show();
}

VideoWindow::~VideoWindow()
{
    int32 result;

    voutWindow->Hide();
    voutWindow->Sync();
    voutWindow->Lock();
    voutWindow->Quit();
    teardownwindow = true;
    wait_for_thread(fDrawThreadID, &result);
Sam Hocevar's avatar
   
Sam Hocevar committed
321
322
    delete bitmap[0];
    delete bitmap[1];
323
324
325
326
327
328
329
}

void VideoWindow::resizeIfRequired( int newWidth, int newHeight )
{
    if (( newWidth != i_width + 1) &&
        ( newHeight != i_height + 1) &&
        ( newWidth != 0 ))
330
    {
331
        if ( voutWindow->Lock() )
332
        {
333
334
335
336
337
            view->ClearViewBitmap();
            i_width = newWidth - 1;
            i_height = newHeight -1;
            voutWindow->ResizeTo((float) i_width, (float) i_height); 
            voutWindow->Unlock();
338
339
340
341
        }
    }
}

342
void VideoWindow::drawBuffer(int bufferIndex)
343
{
Sam Hocevar's avatar
   
Sam Hocevar committed
344
345
346
347
    status_t status;
    
    i_buffer = bufferIndex; 
    
348
349
350
    fDrawThreadID = spawn_thread(Draw, "drawing_thread",
                    B_DISPLAY_PRIORITY, (void*) this);
    wait_for_thread(fDrawThreadID, &status);
351
352
}

Sam Hocevar's avatar
   
Sam Hocevar committed
353
354
355
356
357
/*****************************************************************************
 * VLCView::VLCView
 *****************************************************************************/
VLCView::VLCView(BRect bounds) : BView(bounds, "", B_FOLLOW_ALL, B_WILL_DRAW)
{
Sam Hocevar's avatar
   
Sam Hocevar committed
358
    SetViewColor(B_TRANSPARENT_32_BIT);
Sam Hocevar's avatar
   
Sam Hocevar committed
359
360
361
362
363
364
365
366
367
368
369
370
371
372
}

/*****************************************************************************
 * VLCView::~VLCView
 *****************************************************************************/
VLCView::~VLCView()
{
}

/*****************************************************************************
 * VLCVIew::~VLCView
 *****************************************************************************/
void VLCView::MouseDown(BPoint point)
{
Sam Hocevar's avatar
   
Sam Hocevar committed
373
374
    BWindow *win = Window();
    win->Zoom();
Sam Hocevar's avatar
   
Sam Hocevar committed
375
376
}

377
378
379
380
381
382
extern "C"
{

/*****************************************************************************
 * Local prototypes
 *****************************************************************************/
Sam Hocevar's avatar
   
Sam Hocevar committed
383
384
385
386
387
388
389
static int  vout_Create     ( vout_thread_t * );
static int  vout_Init       ( vout_thread_t * );
static void vout_End        ( vout_thread_t * );
static void vout_Destroy    ( vout_thread_t * );
static int  vout_Manage     ( vout_thread_t * );
static void vout_Display    ( vout_thread_t *, picture_t * );
static void vout_Render     ( vout_thread_t *, picture_t * );
Sam Hocevar's avatar
   
Sam Hocevar committed
390
391
392
393
394
395
396
397

static int  BeosOpenDisplay ( vout_thread_t *p_vout );
static void BeosCloseDisplay( vout_thread_t *p_vout );

/*****************************************************************************
 * Functions exported as capabilities. They are declared as static so that
 * we don't pollute the namespace too much.
 *****************************************************************************/
Sam Hocevar's avatar
   
Sam Hocevar committed
398
void _M( vout_getfunctions )( function_list_t * p_function_list )
Sam Hocevar's avatar
   
Sam Hocevar committed
399
400
401
402
403
404
405
{
    p_function_list->functions.vout.pf_create     = vout_Create;
    p_function_list->functions.vout.pf_init       = vout_Init;
    p_function_list->functions.vout.pf_end        = vout_End;
    p_function_list->functions.vout.pf_destroy    = vout_Destroy;
    p_function_list->functions.vout.pf_manage     = vout_Manage;
    p_function_list->functions.vout.pf_display    = vout_Display;
Sam Hocevar's avatar
   
Sam Hocevar committed
406
    p_function_list->functions.vout.pf_render     = vout_Render;
Sam Hocevar's avatar
   
Sam Hocevar committed
407
408
}

409
/*****************************************************************************
Sam Hocevar's avatar
   
Sam Hocevar committed
410
 * vout_Create: allocates BeOS video thread output method
411
 *****************************************************************************
Sam Hocevar's avatar
   
Sam Hocevar committed
412
 * This function allocates and initializes a BeOS vout method.
413
 *****************************************************************************/
Sam Hocevar's avatar
   
Sam Hocevar committed
414
int vout_Create( vout_thread_t *p_vout )
415
416
417
418
419
{
    /* Allocate structure */
    p_vout->p_sys = (vout_sys_t*) malloc( sizeof( vout_sys_t ) );
    if( p_vout->p_sys == NULL )
    {
Sam Hocevar's avatar
   
Sam Hocevar committed
420
        intf_ErrMsg( "error: %s", strerror(ENOMEM) );
421
422
        return( 1 );
    }
Sam Hocevar's avatar
   
Sam Hocevar committed
423
424
425
426
427
428
429
430
431
432
433
434
435
436

    if( p_vout->render.i_height * p_vout->render.i_aspect
         >= p_vout->render.i_width * VOUT_ASPECT_FACTOR )
    {
        p_vout->p_sys->i_width = p_vout->render.i_height
            * p_vout->render.i_aspect / VOUT_ASPECT_FACTOR;
        p_vout->p_sys->i_height = p_vout->render.i_height;
    }
    else
    {
        p_vout->p_sys->i_width = p_vout->render.i_width;
        p_vout->p_sys->i_height = p_vout->render.i_width
            * VOUT_ASPECT_FACTOR / p_vout->render.i_aspect;
    }
437
438
439
440

    /* Open and initialize device */
    if( BeosOpenDisplay( p_vout ) )
    {
Sam Hocevar's avatar
   
Sam Hocevar committed
441
        intf_ErrMsg("vout error: can't open display");
442
443
444
445
446
447
448
449
        free( p_vout->p_sys );
        return( 1 );
    }

    return( 0 );
}

/*****************************************************************************
Sam Hocevar's avatar
   
Sam Hocevar committed
450
 * vout_Init: initialize BeOS video thread output method
451
 *****************************************************************************/
Sam Hocevar's avatar
   
Sam Hocevar committed
452
int vout_Init( vout_thread_t *p_vout )
453
{
Sam Hocevar's avatar
   
Sam Hocevar committed
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
    VideoWindow *p_win = p_vout->p_sys->p_window;

    int i_index;
    picture_t *p_pic;

    I_OUTPUTPICTURES = 0;

    p_vout->output.i_width  = p_vout->p_sys->i_width;
    p_vout->output.i_height = p_vout->p_sys->i_height;
    p_vout->output.i_aspect = p_vout->p_sys->i_width
                               * VOUT_ASPECT_FACTOR
                               / p_vout->p_sys->i_height;
    p_vout->output.i_chroma = FOURCC_RV32;

    p_pic = NULL;

    /* Find an empty picture slot */
    for( i_index = 0 ; i_index < VOUT_MAX_PICTURES ; i_index++ )
    {
        if( p_vout->p_picture[ i_index ].i_status == FREE_PICTURE )
        {
            p_pic = p_vout->p_picture + i_index;
            break;
        }
    }
479

Sam Hocevar's avatar
   
Sam Hocevar committed
480
    if( p_pic == NULL )
Sam Hocevar's avatar
   
Sam Hocevar committed
481
    {
Sam Hocevar's avatar
   
Sam Hocevar committed
482
        return 0;
483
    }
Sam Hocevar's avatar
   
Sam Hocevar committed
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504

    p_vout->p_sys->i_index = 0;
    p_pic->p->p_pixels = p_vout->p_sys->pp_buffer[0];
    p_pic->p->i_pixel_bytes = 4;
    p_pic->p->i_lines = p_vout->p_sys->i_height;
    p_pic->p->b_margin = 0;
    p_pic->p->i_pitch = 4 * p_vout->p_sys->i_width;

    p_pic->p->i_red_mask   = 0x00ff0000;
    p_pic->p->i_green_mask = 0x0000ff00;
    p_pic->p->i_blue_mask  = 0x000000ff;

    p_pic->i_planes = 1;

    p_pic->i_status = DESTROYED_PICTURE;
    p_pic->i_type   = DIRECT_PICTURE;

    PP_OUTPUTPICTURE[ I_OUTPUTPICTURES ] = p_pic;

    I_OUTPUTPICTURES++;

505
506
507
508
    return( 0 );
}

/*****************************************************************************
Sam Hocevar's avatar
   
Sam Hocevar committed
509
 * vout_End: terminate BeOS video thread output method
510
 *****************************************************************************/
Sam Hocevar's avatar
   
Sam Hocevar committed
511
void vout_End( vout_thread_t *p_vout )
512
{
Sam Hocevar's avatar
   
Sam Hocevar committed
513
    /* place code here to end the video */
514
515
516
}

/*****************************************************************************
Sam Hocevar's avatar
   
Sam Hocevar committed
517
 * vout_Destroy: destroy BeOS video thread output method
518
519
520
 *****************************************************************************
 * Terminate an output method created by DummyCreateOutputMethod
 *****************************************************************************/
Sam Hocevar's avatar
   
Sam Hocevar committed
521
void vout_Destroy( vout_thread_t *p_vout )
522
523
524
525
526
527
{
    BeosCloseDisplay( p_vout );
    free( p_vout->p_sys );
}

/*****************************************************************************
Sam Hocevar's avatar
   
Sam Hocevar committed
528
 * vout_Manage: handle BeOS events
529
530
531
532
 *****************************************************************************
 * This function should be called regularly by video output thread. It manages
 * console events. It returns a non null value on error.
 *****************************************************************************/
Sam Hocevar's avatar
   
Sam Hocevar committed
533
int vout_Manage( vout_thread_t *p_vout )
534
{
535
536
    VideoWindow * p_win = p_vout->p_sys->p_window;
    
Sam Hocevar's avatar
   
Sam Hocevar committed
537
538
//    p_win->resizeIfRequired(p_vout->p_sys->pp_buffer[p_vout->p_sys->i_index].i_pic_width,
//                            p_vout->p_sys->pp_buffer[p_vout->p_sys->i_index].i_pic_height);
539
                            
Sam Hocevar's avatar
   
Sam Hocevar committed
540
541
542
543
544
545
546
547
548
    return( 0 );
}

/*****************************************************************************
 * vout_Render: render previously calculated output
 *****************************************************************************/
void vout_Render( vout_thread_t *p_vout, picture_t *p_pic )
{
    ;
549
550
551
}

/*****************************************************************************
Sam Hocevar's avatar
   
Sam Hocevar committed
552
 * vout_Display: displays previously rendered output
553
 *****************************************************************************
Sam Hocevar's avatar
   
Sam Hocevar committed
554
 * This function send the currently rendered image to BeOS image, waits until
555
556
 * it is displayed and switch the two rendering buffers, preparing next frame.
 *****************************************************************************/
Sam Hocevar's avatar
   
Sam Hocevar committed
557
void vout_Display( vout_thread_t *p_vout, picture_t *p_pic )
558
559
{
    VideoWindow * p_win = p_vout->p_sys->p_window;
Sam Hocevar's avatar
   
Sam Hocevar committed
560

561
    /* draw buffer if required */    
Sam Hocevar's avatar
   
Sam Hocevar committed
562
563
    if (!p_win->teardownwindow)
    {
Sam Hocevar's avatar
   
Sam Hocevar committed
564
       p_win->drawBuffer(p_vout->p_sys->i_index);
565
    }
566
    /* change buffer */
Sam Hocevar's avatar
   
Sam Hocevar committed
567
568
    p_vout->p_sys->i_index = ++p_vout->p_sys->i_index & 1;
    p_pic->p->p_pixels = p_vout->p_sys->pp_buffer[p_vout->p_sys->i_index];
569
570
571
572
573
}

/* following functions are local */

/*****************************************************************************
Sam Hocevar's avatar
   
Sam Hocevar committed
574
 * BeosOpenDisplay: open and initialize BeOS device
575
576
577
 *****************************************************************************/
static int BeosOpenDisplay( vout_thread_t *p_vout )
{ 
Sam Hocevar's avatar
   
Sam Hocevar committed
578
    p_vout->p_sys->p_window = new VideoWindow(
gbazin's avatar
   
gbazin committed
579
580
            config_GetIntVariable( VOUT_WIDTH_VAR ) - 1,
            config_GetIntVariable( VOUT_HEIGHT_VAR ) - 1,
Sam Hocevar's avatar
   
Sam Hocevar committed
581
            p_vout );
582

Sam Hocevar's avatar
   
Sam Hocevar committed
583
    if( p_vout->p_sys->p_window == NULL )
584
    {
Sam Hocevar's avatar
   
Sam Hocevar committed
585
        intf_ErrMsg( "error: cannot allocate memory for VideoWindow" );
586
587
588
        return( 1 );
    }   
    
Sam Hocevar's avatar
   
Sam Hocevar committed
589
590
591
592
593
    p_vout->p_sys->i_width    = p_vout->p_sys->p_window->i_width + 1;
    p_vout->p_sys->i_height   = p_vout->p_sys->p_window->i_height + 1;

    p_vout->p_sys->pp_buffer[0] = (u8*)p_vout->p_sys->p_window->bitmap[0]->Bits();
    p_vout->p_sys->pp_buffer[1] = (u8*)p_vout->p_sys->p_window->bitmap[1]->Bits();
594

595
596
597
598
    return( 0 );
}

/*****************************************************************************
Sam Hocevar's avatar
   
Sam Hocevar committed
599
 * BeosDisplay: close and reset BeOS device
600
601
602
603
604
605
606
 *****************************************************************************
 * Returns all resources allocated by BeosOpenDisplay and restore the original
 * state of the device.
 *****************************************************************************/
static void BeosCloseDisplay( vout_thread_t *p_vout )
{    
    /* Destroy the video window */
607
    delete p_vout->p_sys->p_window;
608
609
610
}

} /* extern "C" */