]> git.sesse.net Git - vlc/blobdiff - modules/audio_output/arts.c
* modules/demux/mpeg: Added DVB stream type for A/52 streams (0x6),
[vlc] / modules / audio_output / arts.c
index c00d85f40fb22699ae2ea2bac18bfe11390eb99f..71b82920d6f986bc8076b76734509dde1bd4e7f1 100644 (file)
@@ -2,6 +2,7 @@
  * arts.c : aRts module
  *****************************************************************************
  * Copyright (C) 2001-2002 VideoLAN
+ * $Id: arts.c,v 1.14 2002/10/20 12:23:47 massiot Exp $
  *
  * Authors: Emmanuel Blindauer <manu@agat.net>
  *          Samuel Hocevar <sam@zoy.org>
@@ -46,7 +47,6 @@
 struct aout_sys_t
 {
     arts_stream_t stream;
-    vlc_bool_t    b_initialized;
 
     mtime_t       latency;
     int           i_size;
@@ -57,9 +57,7 @@ struct aout_sys_t
  *****************************************************************************/
 static int  Open         ( vlc_object_t * );
 static void Close        ( vlc_object_t * );
-
-static int  SetFormat    ( aout_instance_t * );
-static void Play         ( aout_instance_t *, aout_buffer_t * );
+static void Play         ( aout_instance_t * );
 static int  aRtsThread   ( aout_instance_t * );
 
 /*****************************************************************************
@@ -79,6 +77,7 @@ static int Open( vlc_object_t *p_this )
     aout_instance_t *p_aout = (aout_instance_t *)p_this;
     struct aout_sys_t * p_sys;
     int i_err;
+    int i_nb_channels;
 
     /* Allocate structure */
     p_sys = malloc( sizeof( aout_sys_t ) );
@@ -87,6 +86,7 @@ static int Open( vlc_object_t *p_this )
         msg_Err( p_aout, "out of memory" );
         return -1;
     }
+    p_aout->output.p_sys = p_sys;
 
     i_err = arts_init();
     
@@ -97,71 +97,63 @@ static int Open( vlc_object_t *p_this )
         return -1;
     }
 
-    p_aout->output.p_sys = p_sys;
-
-    /* Create aRts thread and wait for its readiness. */
-    p_sys->b_initialized = VLC_FALSE;
-    if( vlc_thread_create( p_aout, "aout", aRtsThread, VLC_FALSE ) )
-    {
-        msg_Err( p_aout, "cannot create aRts thread (%s)", strerror(errno) );
-        free( p_sys );
-        return -1;
-    }
-
-    p_aout->output.pf_setformat = SetFormat;
     p_aout->output.pf_play = Play;
+    aout_VolumeSoftInit( p_aout );
 
-    p_sys->stream = NULL;
-
-    return 0;
-}
-
-/*****************************************************************************
- * SetFormat: set the output format
- *****************************************************************************/
-static int SetFormat( aout_instance_t *p_aout )
-{
-    struct aout_sys_t * p_sys = p_aout->output.p_sys;
-
-    p_sys->b_initialized = VLC_FALSE;
-
-    if( p_sys->stream )
+    p_aout->output.output.i_format = AOUT_FMT_S16_NE;
+    i_nb_channels = aout_FormatNbChannels( &p_aout->output.output );
+    if ( i_nb_channels > 2 )
     {
-        arts_close_stream( p_sys->stream );
+        /* aRts doesn't support more than two channels. */
+        i_nb_channels = 2;
+        p_aout->output.output.i_channels = AOUT_CHAN_STEREO;
     }
 
-    /* open a socket for playing a stream */
+    /* Open a socket for playing a stream, set format to 16 bits */
     p_sys->stream = arts_play_stream( p_aout->output.output.i_rate, 16,
-                                      p_aout->output.output.i_channels, "vlc" );
+                                      i_nb_channels, "vlc" );
     if( p_sys->stream == NULL )
     {
         msg_Err( p_aout, "cannot open aRts socket" );
+        free( p_sys );
         return -1;
     }
 
     /* Try not to bufferize more than 200 ms */
-    arts_stream_set( p_sys->stream, ARTS_P_BUFFER_TIME, 200 );
+    arts_stream_set( p_sys->stream, ARTS_P_BUFFER_TIME, 50 );
 
     /* Estimate latency with a half full buffer */
     p_sys->latency = (mtime_t)1000
-       * (mtime_t)( arts_stream_get( p_sys->stream, ARTS_P_SERVER_LATENCY )
-                  + arts_stream_get( p_sys->stream, ARTS_P_BUFFER_TIME ) / 2 );
+       * (mtime_t)arts_stream_get( p_sys->stream, ARTS_P_SERVER_LATENCY );
     p_sys->i_size = arts_stream_get( p_sys->stream, ARTS_P_PACKET_SIZE );
 
-    p_aout->output.output.i_format = AOUT_FMT_S16_NE;
-    p_aout->output.i_nb_samples = p_sys->i_size;
+    msg_Dbg( p_aout, "aRts initialized, latency %i000, %i packets of size %i",
+                     arts_stream_get( p_sys->stream, ARTS_P_SERVER_LATENCY ),
+                     arts_stream_get( p_sys->stream, ARTS_P_PACKET_COUNT ),
+                     arts_stream_get( p_sys->stream, ARTS_P_PACKET_SIZE ) );
 
-    p_sys->b_initialized = VLC_TRUE;
+    p_aout->output.i_nb_samples = p_sys->i_size / sizeof(u16) / i_nb_channels;
+
+    /* Create aRts thread and wait for its readiness. */
+    if( vlc_thread_create( p_aout, "aout", aRtsThread,
+                           VLC_THREAD_PRIORITY_OUTPUT, VLC_FALSE ) )
+    {
+        msg_Err( p_aout, "cannot create aRts thread (%s)", strerror(errno) );
+        arts_close_stream( p_sys->stream );
+        arts_free();
+        free( p_sys );
+        return -1;
+    }
 
     return 0;
 }
 
 /*****************************************************************************
- * Play: queue a buffer for playing by aRtsThread
+ * Play: nothing to do
  *****************************************************************************/
-static void Play( aout_instance_t *p_aout, aout_buffer_t * p_buffer )
+static void Play( aout_instance_t *p_aout )
 {
-    aout_FifoPush( p_aout, &p_aout->output.fifo, p_buffer );
+    ;
 }
 
 /*****************************************************************************
@@ -175,11 +167,7 @@ static void Close( vlc_object_t *p_this )
     p_aout->b_die = 1;
     vlc_thread_join( p_aout );
 
-    if( p_sys->stream )
-    {
-        arts_close_stream( p_sys->stream );
-    }
-
+    arts_close_stream( p_sys->stream );
     arts_free();
     free( p_sys );
 }
@@ -190,6 +178,7 @@ static void Close( vlc_object_t *p_this )
 static int aRtsThread( aout_instance_t * p_aout )
 {
     struct aout_sys_t * p_sys = p_aout->output.p_sys;
+mtime_t calldate = mdate();
 
     while ( !p_aout->b_die )
     {
@@ -197,31 +186,37 @@ static int aRtsThread( aout_instance_t * p_aout )
         int i_tmp, i_size;
         byte_t * p_bytes;
 
-        if( !p_sys->b_initialized )
-        {
-            msleep( THREAD_SLEEP );
-            continue;
-        }
+fprintf(stderr, "can write %i\n", arts_stream_get( p_sys->stream, ARTS_P_BUFFER_SPACE ) );
+while( arts_stream_get( p_sys->stream, ARTS_P_BUFFER_SPACE ) < 16384*3/2 )
+{
+fprintf(stderr, "sleep\n");
+    msleep( 10000 );
+}
+fprintf(stderr, "after sleep: can write %i\n", arts_stream_get( p_sys->stream, ARTS_P_BUFFER_SPACE ) );
 
         /* Get the presentation date of the next write() operation. It
          * is equal to the current date + latency */
-        p_buffer = aout_OutputNextBuffer( p_aout, mdate() + p_sys->latency );
+        p_buffer = aout_OutputNextBuffer( p_aout, mdate() + p_sys->latency / 4,
+                                                  VLC_TRUE );
 
         if ( p_buffer != NULL )
         {
+fprintf(stderr, "buffer duration %lld, bytes %i\n", p_buffer->end_date - p_buffer->start_date, p_buffer->i_nb_bytes);
             p_bytes = p_buffer->p_buffer;
             i_size = p_buffer->i_nb_bytes;
         }
         else
         {
-            i_size = aout_FormatToByterate( &p_aout->output.output )
-                      * p_sys->i_size
-                      / p_aout->output.output.i_rate;
-            p_bytes = alloca( i_size );
+            i_size = p_sys->i_size;
+            p_bytes = malloc( i_size );
             memset( p_bytes, 0, i_size );
         }
 
+fprintf(stderr, "WRITING %i bytes\n", i_size);
         i_tmp = arts_write( p_sys->stream, p_bytes, i_size );
+fprintf(stderr, "mdate: %lld\n", mdate() - calldate);
+calldate = mdate();
+fprintf(stderr, "can write %i\n", arts_stream_get( p_sys->stream, ARTS_P_BUFFER_SPACE ) );
 
         if( i_tmp < 0 )
         {
@@ -232,6 +227,10 @@ static int aRtsThread( aout_instance_t * p_aout )
         {
             aout_BufferFree( p_buffer );
         }
+        else
+        {
+            free( p_bytes );
+        }
     }
 
     return 0;