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.

diff --git a/include/threads.h b/include/threads.h
index da0642f50a7eb71dc2165ef06fcc3a4d8b55b193..41c70dfb335d442e67e1419e83f2c435034b6912 100644 (file)
--- a/include/threads.h
+++ b/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
+        {
+            // ok, we have to wake up that thread
+            resume_thread( p_condvar->thread );
+            return 0;
         }
     }
-    else
-    {
-        release_sem( p_condvar->signalSem );
-    }
-    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 );

diff --git a/plugins/beos/aout_beos.cpp b/plugins/beos/aout_beos.cpp
index aae2af37257aa42243c2fb62e903d605199607f0..6f4045706b4ce2637e0be2e75cb312b2f5561c61 100644 (file)
--- a/plugins/beos/aout_beos.cpp
+++ b/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;
+         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;
     }
 }

diff --git a/plugins/beos/intf_beos.cpp b/plugins/beos/intf_beos.cpp
index 2677b74e8cdded5d045f2113d54b1be5ccd6b49c..7647d0ef54c392a430f4b313b31e9f3fad850e6c 100644 (file)
--- a/plugins/beos/intf_beos.cpp
+++ b/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 );
 }
 

diff --git a/plugins/beos/vout_beos.cpp b/plugins/beos/vout_beos.cpp
index af25651a5d0c9edd885691724a7ea28df55af563..a78f4cbb53ddf89f887600ad576d6ae2f935e81d 100644 (file)
--- a/plugins/beos/vout_beos.cpp
+++ b/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 );