A lot of bug fixs for the BeOS side of VideoLAN:

- the vlc does not exhaust system resources anymore (it was creating a new
  mutex each picture so after a while there was no more mutex available in
  the entire system);
- the sound has been corrected and now it works perfectly;
- the window has now the right size (there was and additional line before).

The (BeOS) threads have also been improved especially with the cond vars
(but it is no more compliant with the pthread cond vars).

VideoLAN for BeOS now rocks and is ready for its first binary release.

include/threads.h

@@ -93,23 +93,22 @@ typedef struct s_condition {
 
 #elif defined(HAVE_KERNEL_SCHEDULER_H) && defined(HAVE_KERNEL_OS_H)
 
+/* This is the BeOS implementation of the vlc thread, note that the mutex is
+ * not a real mutex and the cond_var is not like a pthread cond_var but it is
+ * enough for what wee need */
+
 typedef thread_id vlc_thread_t;
 
 typedef struct
 {
     int32           init;
     sem_id          lock;
-    thread_id       owner;
 } vlc_mutex_t;
 
 typedef struct
 {
     int32           init;
-    sem_id          sem;
-    sem_id          handshakeSem;
-    sem_id          signalSem;
-    volatile int32  nw;
-    volatile int32  ns;
+    thread_id       thread;
 } vlc_cond_t;
 
 #elif defined(HAVE_PTHREAD_H)
@@ -212,14 +211,17 @@ static __inline__ int vlc_mutex_init( vlc_mutex_t *p_mutex )
     return 0;
 
 #elif defined(HAVE_KERNEL_SCHEDULER_H) && defined(HAVE_KERNEL_OS_H)
-/*
+
     // check the arguments and whether it's already been initialized
-    if( !p_mutex ) return B_BAD_VALUE;
-    if( p_mutex->init == 9999 ) return EALREADY;
-*/
+    if( p_mutex == NULL ) return B_BAD_VALUE;
+    if( p_mutex->init == 9999 )
+    {
+        return EALREADY;
+    }
 
     p_mutex->lock = create_sem( 1, "BeMutex" );
-    p_mutex->owner = -1;
+    if( p_mutex->lock < B_NO_ERROR )
+        return( -1 );
     p_mutex->init = 9999;
     return B_OK;
 
@@ -229,25 +231,6 @@ static __inline__ int vlc_mutex_init( vlc_mutex_t *p_mutex )
 #endif
 }
 
-#if defined(HAVE_KERNEL_SCHEDULER_H) && defined(HAVE_KERNEL_OS_H)
-/* lazy_init_mutex */
-static __inline__ void lazy_init_mutex(vlc_mutex_t* p_mutex)
-{
-    int32 v = atomic_or( &p_mutex->init, 1 );
-    if( 2000 == v ) /* we're the first, so do the init */
-    {
-        vlc_mutex_init( p_mutex );
-    }
-    else /* we're not the first, so wait until the init is finished */
-    {
-        while( p_mutex->init != 9999 )
-        {
-            snooze( 10000 );
-        }
-    }
-}
-#endif
-
 /*****************************************************************************
  * vlc_mutex_lock: lock a mutex
  *****************************************************************************/
@@ -259,17 +242,11 @@ static __inline__ int vlc_mutex_lock( vlc_mutex_t *p_mutex )
 
 #elif defined(HAVE_KERNEL_SCHEDULER_H) && defined(HAVE_KERNEL_OS_H)
     status_t err;
-/*
+
     if( !p_mutex ) return B_BAD_VALUE;
     if( p_mutex->init < 2000 ) return B_NO_INIT;
 
-    lazy_init_mutex( p_mutex );
-*/
     err = acquire_sem( p_mutex->lock );
-/*
-    if( !err ) p_mutex->owner = find_thread( NULL );
-*/
-
     return err;
 
 #elif defined(HAVE_PTHREAD_H)
@@ -288,17 +265,10 @@ static __inline__ int vlc_mutex_unlock( vlc_mutex_t *p_mutex )
     return 0;
 
 #elif defined(HAVE_KERNEL_SCHEDULER_H) && defined(HAVE_KERNEL_OS_H)
-/*
+
     if(! p_mutex) return B_BAD_VALUE;
     if( p_mutex->init < 2000 ) return B_NO_INIT;
 
-    lazy_init_mutex( p_mutex );
-
-    if( p_mutex->owner != find_thread(NULL) )
-        return ENOLCK;
-
-    p_mutex->owner = -1;
-*/
     release_sem( p_mutex->lock );
     return B_OK;
 
@@ -329,12 +299,9 @@ static __inline__ int vlc_cond_init( vlc_cond_t *p_condvar )
     if( p_condvar->init == 9999 )
         return EALREADY;
 
-    p_condvar->sem = create_sem( 0, "CVSem" );
-    p_condvar->handshakeSem = create_sem( 0, "CVHandshake" );
-    p_condvar->signalSem = create_sem( 1, "CVSignal" );
-    p_condvar->ns = p_condvar->nw = 0;
+    p_condvar->thread = -1;
     p_condvar->init = 9999;
-    return B_OK;
+    return 0;
 
 #elif defined(HAVE_PTHREAD_H)
     return pthread_cond_init( p_condvar, NULL );
@@ -342,26 +309,6 @@ static __inline__ int vlc_cond_init( vlc_cond_t *p_condvar )
 #endif
 }
 
-
-#if defined(HAVE_KERNEL_SCHEDULER_H) && defined(HAVE_KERNEL_OS_H)
-/* lazy_init_cond */
-static __inline__ void lazy_init_cond( vlc_cond_t* p_condvar )
-{
-    int32 v = atomic_or( &p_condvar->init, 1 );
-    if( 2000 == v ) /* we're the first, so do the init */
-    {
-        vlc_cond_init( p_condvar );
-    }
-    else /* we're not the first, so wait until the init is finished */
-    {
-        while( p_condvar->init != 9999 )
-        {
-            snooze( 10000 );
-        }
-    }
-}
-#endif
-
 /*****************************************************************************
  * vlc_cond_signal: start a thread on condition completion
  *****************************************************************************/
@@ -376,35 +323,33 @@ static __inline__ int vlc_cond_signal( vlc_cond_t *p_condvar )
     return 0;
 
 #elif defined(HAVE_KERNEL_SCHEDULER_H) && defined(HAVE_KERNEL_OS_H)
-    status_t err = B_OK;
-
     if( !p_condvar )
         return B_BAD_VALUE;
 
     if( p_condvar->init < 2000 )
         return B_NO_INIT;
 
-    lazy_init_cond( p_condvar );
-
-    if( acquire_sem(p_condvar->signalSem) == B_INTERRUPTED)
-        return B_INTERRUPTED;
-
-    if( p_condvar->nw > p_condvar->ns )
+    while( p_condvar->thread != -1 )
     {
-        p_condvar->ns += 1;
-        release_sem( p_condvar->sem );
-        release_sem( p_condvar->signalSem );
+        thread_info info;
+        if( get_thread_info(p_condvar->thread, &info) == B_BAD_VALUE )
+            return 0;
 
-        while( acquire_sem(p_condvar->handshakeSem) == B_INTERRUPTED )
+        // is the thread sleeping ?
+        if( info.state != B_THREAD_SUSPENDED )
         {
-            err = B_INTERRUPTED;
-        }
+            // wait a little
+            snooze( 10000 );
         }
         else
         {
-        release_sem( p_condvar->signalSem );
+            // ok, we have to wake up that thread
+            resume_thread( p_condvar->thread );
+            return 0;
         }
-    return err;
+    }
+    
+    return 0;
 
 #elif defined(HAVE_PTHREAD_H)
     return pthread_cond_signal( p_condvar );
@@ -422,8 +367,6 @@ static __inline__ int vlc_cond_wait( vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex
     return 0;
 
 #elif defined(HAVE_KERNEL_SCHEDULER_H) && defined(HAVE_KERNEL_OS_H)
-    status_t err;
-
     if( !p_condvar )
         return B_BAD_VALUE;
 
@@ -433,35 +376,13 @@ static __inline__ int vlc_cond_wait( vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex
     if( p_condvar->init < 2000 )
         return B_NO_INIT;
 
-    lazy_init_cond( p_condvar );
-
-    if( acquire_sem(p_condvar->signalSem) == B_INTERRUPTED )
-        return B_INTERRUPTED;
-
-    p_condvar->nw += 1;
-    release_sem( p_condvar->signalSem );
-
+    p_condvar->thread = find_thread( NULL );
     vlc_mutex_unlock( p_mutex );
-    err = acquire_sem( p_condvar->sem );
-
-    while( acquire_sem(p_condvar->signalSem) == B_INTERRUPTED)
-    {
-        err = B_INTERRUPTED;
-    }
+    suspend_thread( p_condvar->thread );
+    p_condvar->thread = -1;
 
-    if( p_condvar->ns > 0 )
-    {
-        release_sem( p_condvar->handshakeSem );
-        p_condvar->ns -= 1;
-    }
-    p_condvar->nw -= 1;
-    release_sem( p_condvar->signalSem );
-
-    while( vlc_mutex_lock(p_mutex) == B_INTERRUPTED)
-    {
-        err = B_INTERRUPTED;
-    }
-    return err;
+    vlc_mutex_lock( p_mutex );
+    return 0;
 
 #elif defined(HAVE_PTHREAD_H)
     return pthread_cond_wait( p_condvar, p_mutex );

plugins/beos/aout_beos.cpp

@@ -106,7 +106,7 @@ int aout_BeOpen( aout_thread_t *p_aout )
     p_aout->p_sys->p_format->channel_count = p_aout->i_channels;
     p_aout->p_sys->p_format->format = gs_audio_format::B_GS_S16;
     p_aout->p_sys->p_format->byte_order = B_MEDIA_LITTLE_ENDIAN;
-    p_aout->p_sys->p_format->buffer_size = 8192;
+    p_aout->p_sys->p_format->buffer_size = 4*8192;
     p_aout->p_sys->i_buffer_pos = 0;
 
     /* Allocate BPushGameSound */
@@ -173,20 +173,16 @@ int aout_BeSetRate( aout_thread_t *p_aout )
  *****************************************************************************/
 long aout_BeGetBufInfo( aout_thread_t *p_aout, long l_buffer_limit )
 {
-
+    /* Each value is 4 bytes long (stereo signed 16 bits) */
     long i_hard_pos = 4 * p_aout->p_sys->p_sound->CurrentPosition();
 
-    /*fprintf( stderr, "read 0x%.6lx - write 0x%.6lx = ",
-             i_hard_pos, p_aout->p_sys->i_buffer_pos );*/
-
-    if( i_hard_pos < p_aout->p_sys->i_buffer_pos )
+    i_hard_pos = p_aout->p_sys->i_buffer_pos - i_hard_pos;
+    if( i_hard_pos < 0 )
     {
          i_hard_pos += p_aout->p_sys->i_buffer_size;
     }
 
-    /*fprintf( stderr, "0x%.6lx\n", i_hard_pos - p_aout->p_sys->i_buffer_pos ); */
-
-    return( (p_aout->p_sys->i_buffer_size - (i_hard_pos - p_aout->p_sys->i_buffer_pos)) );
+    return( i_hard_pos );
 }
 
 /*****************************************************************************
@@ -198,8 +194,6 @@ void aout_BePlaySamples( aout_thread_t *p_aout, byte_t *buffer, int i_size )
 {
     long i_newbuf_pos;
 
-    //fprintf( stderr, "writing %i\n", i_size );
-
     if( (i_newbuf_pos = p_aout->p_sys->i_buffer_pos + i_size)
               > p_aout->p_sys->i_buffer_size )
     {
@@ -209,16 +203,18 @@ void aout_BePlaySamples( aout_thread_t *p_aout, byte_t *buffer, int i_size )
                 p_aout->p_sys->i_buffer_size - p_aout->p_sys->i_buffer_pos );
 
         memcpy( (void *)((int)p_aout->p_sys->p_buffer),
-                buffer,
+                buffer + p_aout->p_sys->i_buffer_size - p_aout->p_sys->i_buffer_pos,
                 i_size - ( p_aout->p_sys->i_buffer_size
                              - p_aout->p_sys->i_buffer_pos ) );
         
         p_aout->p_sys->i_buffer_pos = i_newbuf_pos - p_aout->p_sys->i_buffer_size;
+
     }
     else
     {
         memcpy( (void *)((int)p_aout->p_sys->p_buffer + p_aout->p_sys->i_buffer_pos),
                 buffer, i_size );
+
         p_aout->p_sys->i_buffer_pos = i_newbuf_pos;
     }
 }

plugins/beos/intf_beos.cpp

@@ -158,11 +158,10 @@ int intf_BeCreate( intf_thread_t *p_intf )
             return( 1 );
         }
     }
+
     /* Bind normal keys. */
     intf_AssignNormalKeys( p_intf );
 
-
-
     return( 0 );
 }
 

plugins/beos/vout_beos.cpp

@@ -499,7 +499,7 @@ static int BeosOpenDisplay( vout_thread_t *p_vout )
 { 
     /* Create the DirectDraw video window */
     p_vout->p_sys->p_window =
-        new VideoWindow(  BRect( 100, 100, 100+p_vout->i_width, 100+p_vout->i_height ), "VideoLAN", p_vout );
+        new VideoWindow(  BRect( 100, 100, 100+p_vout->i_width-1, 100+p_vout->i_height-1 ), "VideoLAN", p_vout );
     if( p_vout->p_sys->p_window == 0 )
     {
         free( p_vout->p_sys );