0a8eb50bb0abb86d4705da4f70c5fe6ca8761f31
[vlc.git] / modules / audio_output / alsa.c
1 /*****************************************************************************
2  * alsa.c : alsa plugin for vlc
3  *****************************************************************************
4  * Copyright (C) 2000-2001 VideoLAN
5  * $Id: alsa.c,v 1.37 2004/01/25 17:32:29 murray Exp $
6  *
7  * Authors: Henri Fallon <henri@videolan.org> - Original Author
8  *          Jeffrey Baker <jwbaker@acm.org> - Port to ALSA 1.0 API
9  *          John Paul Lorenti <jpl31@columbia.edu> - Device selection
10  *          Arnaud de Bossoreille de Ribou <bozo@via.ecp.fr> - S/PDIF and aout3
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
25  *****************************************************************************/
26
27 /*****************************************************************************
28  * Preamble
29  *****************************************************************************/
30 #include <errno.h>                                                 /* ENOMEM */
31 #include <string.h>                                            /* strerror() */
32 #include <stdlib.h>                            /* calloc(), malloc(), free() */
33
34 #include <vlc/vlc.h>
35
36 #include <vlc/aout.h>
37
38 #include "aout_internal.h"
39
40 /* ALSA part
41    Note: we use the new API which is available since 0.9.0beta10a. */
42 #define ALSA_PCM_NEW_HW_PARAMS_API
43 #define ALSA_PCM_NEW_SW_PARAMS_API
44 #include <alsa/asoundlib.h>
45
46 /*****************************************************************************
47  * aout_sys_t: ALSA audio output method descriptor
48  *****************************************************************************
49  * This structure is part of the audio output thread descriptor.
50  * It describes the ALSA specific properties of an audio device.
51  *****************************************************************************/
52 struct aout_sys_t
53 {
54     snd_pcm_t         * p_snd_pcm;
55     int                 i_period_time;
56
57 #ifdef ALSA_DEBUG
58     snd_output_t      * p_snd_stderr;
59 #endif
60
61     int b_playing;                                         /* playing status */
62     mtime_t start_date;
63
64     vlc_mutex_t lock;
65     vlc_cond_t  wait ;
66 };
67
68 #define A52_FRAME_NB 1536
69
70 /* These values are in frames.
71    To convert them to a number of bytes you have to multiply them by the
72    number of channel(s) (eg. 2 for stereo) and the size of a sample (eg.
73    2 for int16_t). */
74 #define ALSA_DEFAULT_PERIOD_SIZE        1024
75 #define ALSA_DEFAULT_BUFFER_SIZE        ( ALSA_DEFAULT_PERIOD_SIZE << 8 )
76 #define ALSA_SPDIF_PERIOD_SIZE          A52_FRAME_NB
77 #define ALSA_SPDIF_BUFFER_SIZE          ( ALSA_SPDIF_PERIOD_SIZE << 4 )
78 /* Why << 4 ? --Meuuh */
79 /* Why not ? --Bozo */
80 /* Right. --Meuuh */
81
82 #define DEFAULT_ALSA_DEVICE N_("default")
83
84 /*****************************************************************************
85  * Local prototypes
86  *****************************************************************************/
87 static int  Open         ( vlc_object_t * );
88 static void Close        ( vlc_object_t * );
89 static void Play         ( aout_instance_t * );
90 static int  ALSAThread   ( aout_instance_t * );
91 static void ALSAFill     ( aout_instance_t * );
92
93 /*****************************************************************************
94  * Module descriptor
95  *****************************************************************************/
96 vlc_module_begin();
97     add_category_hint( N_("ALSA"), NULL, VLC_FALSE );
98     add_string( "alsadev", DEFAULT_ALSA_DEVICE, aout_FindAndRestart,
99                 N_("ALSA Device Name"), NULL, VLC_FALSE );
100     set_description( _("ALSA Audio Output") );
101     set_capability( "audio output", 150 );
102     set_callbacks( Open, Close );
103 vlc_module_end();
104
105 /*****************************************************************************
106  * Probe: probe the audio device for available formats and channels
107  *****************************************************************************/
108 static void Probe( aout_instance_t * p_aout,
109                    const char * psz_device, const char * psz_iec_device,
110                    int *pi_snd_pcm_format )
111 {
112     struct aout_sys_t * p_sys = p_aout->output.p_sys;
113     vlc_value_t val, text;
114     int i_ret;
115
116     var_Create ( p_aout, "audio-device", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );
117     text.psz_string = _("Audio Device");
118     var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );
119
120     /* We'll open the audio device in non blocking mode so we can just exit
121      * when it is already in use, but for the real stuff we'll still use
122      * the blocking mode */
123
124     /* Now test linear PCM capabilities */
125     if ( !(i_ret = snd_pcm_open( &p_sys->p_snd_pcm, psz_device,
126                                  SND_PCM_STREAM_PLAYBACK,
127                                  SND_PCM_NONBLOCK ) ) )
128     {
129         int i_channels;
130         snd_pcm_hw_params_t * p_hw;
131         snd_pcm_hw_params_alloca (&p_hw);
132
133         if ( snd_pcm_hw_params_any( p_sys->p_snd_pcm, p_hw ) < 0 )
134         {
135             msg_Warn( p_aout, "unable to retrieve initial hardware parameters"
136                               ", disabling linear PCM audio" );
137             snd_pcm_close( p_sys->p_snd_pcm );
138             var_Destroy( p_aout, "audio-device" );
139             return;
140         }
141
142         if ( snd_pcm_hw_params_set_format( p_sys->p_snd_pcm, p_hw,
143                                            *pi_snd_pcm_format ) < 0 )
144         {
145             if( *pi_snd_pcm_format != SND_PCM_FORMAT_S16 )
146             {
147                 *pi_snd_pcm_format = SND_PCM_FORMAT_S16;
148                 if ( snd_pcm_hw_params_set_format( p_sys->p_snd_pcm, p_hw,
149                                                    *pi_snd_pcm_format ) < 0 )
150                 {
151                     msg_Warn( p_aout, "unable to set stream sample size and "
152                               "word order, disabling linear PCM audio" );
153                     snd_pcm_close( p_sys->p_snd_pcm );
154                     var_Destroy( p_aout, "audio-device" );
155                     return;
156                 }
157             }
158         }
159
160         i_channels = aout_FormatNbChannels( &p_aout->output.output );
161
162         while ( i_channels > 0 )
163         {
164             if ( !snd_pcm_hw_params_test_channels( p_sys->p_snd_pcm, p_hw,
165                                                    i_channels ) )
166             {
167                 switch ( i_channels )
168                 {
169                 case 1:
170                     val.i_int = AOUT_VAR_MONO;
171                     text.psz_string = N_("Mono");
172                     var_Change( p_aout, "audio-device",
173                                 VLC_VAR_ADDCHOICE, &val, &text );
174                     break;
175                 case 2:
176                     val.i_int = AOUT_VAR_STEREO;
177                     text.psz_string = N_("Stereo");
178                     var_Change( p_aout, "audio-device",
179                                 VLC_VAR_ADDCHOICE, &val, &text );
180                     var_Set( p_aout, "audio-device", val );
181                     break;
182                 case 4:
183                     val.i_int = AOUT_VAR_2F2R;
184                     text.psz_string = N_("2 Front 2 Rear");
185                     var_Change( p_aout, "audio-device",
186                                 VLC_VAR_ADDCHOICE, &val, &text );
187                     break;
188                 case 6:
189                     val.i_int = AOUT_VAR_5_1;
190                     text.psz_string = N_("5.1");
191                     var_Change( p_aout, "audio-device",
192                                 VLC_VAR_ADDCHOICE, &val, &text );
193                     break;
194                 }
195             }
196
197             --i_channels;
198         }
199
200         /* Close the previously opened device */
201         snd_pcm_close( p_sys->p_snd_pcm );
202     }
203     else if ( i_ret == -EBUSY )
204     {
205         msg_Warn( p_aout, "audio device: %s is already in use", psz_device );
206     }
207
208     /* Test for S/PDIF device if needed */
209     if ( psz_iec_device )
210     {
211         /* Opening the device should be enough */
212         if ( !(i_ret = snd_pcm_open( &p_sys->p_snd_pcm, psz_iec_device,
213                                      SND_PCM_STREAM_PLAYBACK,
214                                      SND_PCM_NONBLOCK ) ) )
215         {
216             val.i_int = AOUT_VAR_SPDIF;
217             text.psz_string = N_("A/52 over S/PDIF");
218             var_Change( p_aout, "audio-device",
219                         VLC_VAR_ADDCHOICE, &val, &text );
220             if( config_GetInt( p_aout, "spdif" ) )
221                 var_Set( p_aout, "audio-device", val );
222
223             snd_pcm_close( p_sys->p_snd_pcm );
224         }
225         else if ( i_ret == -EBUSY )
226         {
227             msg_Warn( p_aout, "audio device: %s is already in use",
228                       psz_iec_device );
229         }
230     }
231
232     var_Change( p_aout, "audio-device", VLC_VAR_CHOICESCOUNT, &val, NULL );
233     if( val.i_int <= 0 )
234     {
235         /* Probe() has failed. */
236         var_Destroy( p_aout, "audio-device" );
237         return;
238     }
239
240     /* Add final settings to the variable */
241     var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL );
242     val.b_bool = VLC_TRUE;
243     var_Set( p_aout, "intf-change", val );
244 }
245
246 /*****************************************************************************
247  * Open: create a handle and open an alsa device
248  *****************************************************************************
249  * This function opens an alsa device, through the alsa API.
250  *
251  * Note: the only heap-allocated string is psz_device. All the other pointers
252  * are references to psz_device or to stack-allocated data.
253  *****************************************************************************/
254 static int Open( vlc_object_t *p_this )
255 {
256     aout_instance_t * p_aout = (aout_instance_t *)p_this;
257     struct aout_sys_t * p_sys;
258     vlc_value_t val;
259
260     char psz_default_iec_device[128]; /* Buffer used to store the default
261                                          S/PDIF device */
262     char * psz_device, * psz_iec_device; /* device names for PCM and S/PDIF
263                                             output */
264
265     int i_vlc_pcm_format; /* Audio format for VLC's data */
266     int i_snd_pcm_format; /* Audio format for ALSA's data */
267
268     snd_pcm_uframes_t i_buffer_size = 0;
269     snd_pcm_uframes_t i_period_size = 0;
270     int i_channels = 0;
271
272     snd_pcm_hw_params_t *p_hw;
273     snd_pcm_sw_params_t *p_sw;
274
275     int i_snd_rc = -1;
276
277     /* Allocate structures */
278     p_aout->output.p_sys = p_sys = malloc( sizeof( aout_sys_t ) );
279     if( p_sys == NULL )
280     {
281         msg_Err( p_aout, "out of memory" );
282         return VLC_ENOMEM;
283     }
284     p_sys->b_playing = VLC_FALSE;
285     p_sys->start_date = 0;
286     vlc_cond_init( p_aout, &p_sys->wait );
287     vlc_mutex_init( p_aout, &p_sys->lock );
288
289     /* Get device name */
290     if( (psz_device = config_GetPsz( p_aout, "alsadev" )) == NULL )
291     {
292         msg_Err( p_aout, "no audio device given (maybe \"default\" ?)" );
293         free( p_sys );
294         return VLC_EGENERIC;
295     }
296
297     /* Choose the IEC device for S/PDIF output:
298        if the device is overriden by the user then it will be the one
299        otherwise we compute the default device based on the output format. */
300     if( AOUT_FMT_NON_LINEAR( &p_aout->output.output )
301         && !strcmp( psz_device, DEFAULT_ALSA_DEVICE ) )
302     {
303         snprintf( psz_default_iec_device, sizeof(psz_default_iec_device),
304                   "iec958:AES0=0x%x,AES1=0x%x,AES2=0x%x,AES3=0x%x",
305                   IEC958_AES0_CON_EMPHASIS_NONE | IEC958_AES0_NONAUDIO,
306                   IEC958_AES1_CON_ORIGINAL | IEC958_AES1_CON_PCM_CODER,
307                   0,
308                   ( p_aout->output.output.i_rate == 48000 ?
309                     IEC958_AES3_CON_FS_48000 :
310                     ( p_aout->output.output.i_rate == 44100 ?
311                       IEC958_AES3_CON_FS_44100 : IEC958_AES3_CON_FS_32000 ) ) );
312         psz_iec_device = psz_default_iec_device;
313     }
314     else if( AOUT_FMT_NON_LINEAR( &p_aout->output.output ) )
315     {
316         psz_iec_device = psz_device;
317     }
318     else
319     {
320         psz_iec_device = NULL;
321     }
322
323     /* Choose the linear PCM format (read the comment above about FPU
324        and float32) */
325     if( p_aout->p_libvlc->i_cpu & CPU_CAPABILITY_FPU )
326     {
327         i_vlc_pcm_format = VLC_FOURCC('f','l','3','2');
328         i_snd_pcm_format = SND_PCM_FORMAT_FLOAT;
329     }
330     else
331     {
332         i_vlc_pcm_format = AOUT_FMT_S16_NE;
333         i_snd_pcm_format = SND_PCM_FORMAT_S16;
334     }
335
336     /* If the variable doesn't exist then it's the first time we're called
337        and we have to probe the available audio formats and channels */
338     if ( var_Type( p_aout, "audio-device" ) == 0 )
339     {
340         Probe( p_aout, psz_device, psz_iec_device, &i_snd_pcm_format );
341         switch( i_snd_pcm_format )
342         {
343         case SND_PCM_FORMAT_FLOAT:
344             i_vlc_pcm_format = VLC_FOURCC('f','l','3','2');
345             break;
346         case SND_PCM_FORMAT_S16:
347             i_vlc_pcm_format = AOUT_FMT_S16_NE;
348             break;
349         }
350     }
351
352     if ( var_Get( p_aout, "audio-device", &val ) < 0 )
353     {
354         free( p_sys );
355         free( psz_device );
356         return VLC_EGENERIC;
357     }
358
359     if ( val.i_int == AOUT_VAR_SPDIF )
360     {
361         p_aout->output.output.i_format = VLC_FOURCC('s','p','d','i');
362     }
363     else if ( val.i_int == AOUT_VAR_5_1 )
364     {
365         p_aout->output.output.i_format = i_vlc_pcm_format;
366         p_aout->output.output.i_physical_channels
367             = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
368                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
369                | AOUT_CHAN_LFE;
370         free( psz_device );
371         psz_device = strdup( "surround51" );
372     }
373     else if ( val.i_int == AOUT_VAR_2F2R )
374     {
375         p_aout->output.output.i_format = i_vlc_pcm_format;
376         p_aout->output.output.i_physical_channels
377             = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
378                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
379         free( psz_device );
380         psz_device = strdup( "surround40" );
381     }
382     else if ( val.i_int == AOUT_VAR_STEREO )
383     {
384         p_aout->output.output.i_format = i_vlc_pcm_format;
385         p_aout->output.output.i_physical_channels
386             = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
387     }
388     else if ( val.i_int == AOUT_VAR_MONO )
389     {
390         p_aout->output.output.i_format = i_vlc_pcm_format;
391         p_aout->output.output.i_physical_channels = AOUT_CHAN_CENTER;
392     }
393
394     else
395     {
396         /* This should not happen ! */
397         msg_Err( p_aout, "internal: can't find audio-device (%i)", val.i_int );
398         free( p_sys );
399         return VLC_EGENERIC;
400     }
401
402 #ifdef ALSA_DEBUG
403     snd_output_stdio_attach( &p_sys->p_snd_stderr, stderr, 0 );
404 #endif
405
406     /* Open the device */
407     if ( AOUT_FMT_NON_LINEAR( &p_aout->output.output ) )
408     {
409         if ( ( i_snd_rc = snd_pcm_open( &p_sys->p_snd_pcm, psz_iec_device,
410                             SND_PCM_STREAM_PLAYBACK, 0 ) ) < 0 )
411         {
412             msg_Err( p_aout, "cannot open ALSA device `%s' (%s)",
413                              psz_iec_device, snd_strerror( i_snd_rc ) );
414             free( p_sys );
415             free( psz_device );
416             return VLC_EGENERIC;
417         }
418         i_buffer_size = ALSA_SPDIF_BUFFER_SIZE;
419         i_snd_pcm_format = SND_PCM_FORMAT_S16;
420         i_channels = 2;
421
422         p_aout->output.i_nb_samples = i_period_size = ALSA_SPDIF_PERIOD_SIZE;
423         p_aout->output.output.i_bytes_per_frame = AOUT_SPDIF_SIZE;
424         p_aout->output.output.i_frame_length = A52_FRAME_NB;
425
426         aout_VolumeNoneInit( p_aout );
427     }
428     else
429     {
430         msg_Dbg( p_aout, "opening ALSA device `%s'", psz_device );
431
432         if ( ( i_snd_rc = snd_pcm_open( &p_sys->p_snd_pcm, psz_device,
433                             SND_PCM_STREAM_PLAYBACK, 0 ) ) < 0 )
434         {
435             msg_Err( p_aout, "cannot open ALSA device `%s' (%s)",
436                              psz_device, snd_strerror( i_snd_rc ) );
437             free( p_sys );
438             free( psz_device );
439             return VLC_EGENERIC;
440         }
441         i_buffer_size = ALSA_DEFAULT_BUFFER_SIZE;
442         i_channels = aout_FormatNbChannels( &p_aout->output.output );
443
444         p_aout->output.i_nb_samples = i_period_size = ALSA_DEFAULT_PERIOD_SIZE;
445
446         aout_VolumeSoftInit( p_aout );
447     }
448
449     /* Free psz_device so that all the remaining data is stack-allocated */
450     free( psz_device );
451
452     p_aout->output.pf_play = Play;
453
454     snd_pcm_hw_params_alloca(&p_hw);
455     snd_pcm_sw_params_alloca(&p_sw);
456
457     /* Get Initial hardware parameters */
458     if ( ( i_snd_rc = snd_pcm_hw_params_any( p_sys->p_snd_pcm, p_hw ) ) < 0 )
459     {
460         msg_Err( p_aout, "unable to retrieve initial hardware parameters (%s)",
461                          snd_strerror( i_snd_rc ) );
462         goto error;
463     }
464
465     /* Set format. */
466     if ( ( i_snd_rc = snd_pcm_hw_params_set_format( p_sys->p_snd_pcm, p_hw,
467                                                     i_snd_pcm_format ) ) < 0 )
468     {
469         msg_Err( p_aout, "unable to set stream sample size and word order (%s)",
470                          snd_strerror( i_snd_rc ) );
471         goto error;
472     }
473
474     if ( ( i_snd_rc = snd_pcm_hw_params_set_access( p_sys->p_snd_pcm, p_hw,
475                                     SND_PCM_ACCESS_RW_INTERLEAVED ) ) < 0 )
476     {
477         msg_Err( p_aout, "unable to set interleaved stream format (%s)",
478                          snd_strerror( i_snd_rc ) );
479         goto error;
480     }
481
482     /* Set channels. */
483     if ( ( i_snd_rc = snd_pcm_hw_params_set_channels( p_sys->p_snd_pcm, p_hw,
484                                                       i_channels ) ) < 0 )
485     {
486         msg_Err( p_aout, "unable to set number of output channels (%s)",
487                          snd_strerror( i_snd_rc ) );
488         goto error;
489     }
490
491     /* Set rate. */
492 #ifdef HAVE_ALSA_NEW_API
493     if ( ( i_snd_rc = snd_pcm_hw_params_set_rate_near( p_sys->p_snd_pcm, p_hw,
494                                 &p_aout->output.output.i_rate, NULL ) ) < 0 )
495 #else
496     if ( ( i_snd_rc = snd_pcm_hw_params_set_rate_near( p_sys->p_snd_pcm, p_hw,
497                                 p_aout->output.output.i_rate, NULL ) ) < 0 )
498 #endif
499     {
500         msg_Warn( p_aout, "The rate %d Hz is not supported by your hardware. "
501                   "Using %d Hz instead.\n", p_aout->output.output.i_rate,
502                   i_snd_rc );
503         p_aout->output.output.i_rate = i_snd_rc;
504     }
505
506     /* Set buffer size. */
507 #ifdef HAVE_ALSA_NEW_API
508     if ( ( i_snd_rc = snd_pcm_hw_params_set_buffer_size_near( p_sys->p_snd_pcm,
509                                     p_hw, &i_buffer_size ) ) < 0 )
510 #else
511     if ( ( i_snd_rc = snd_pcm_hw_params_set_buffer_size_near( p_sys->p_snd_pcm,
512                                     p_hw, i_buffer_size ) ) < 0 )
513 #endif
514     {
515         msg_Err( p_aout, "unable to set buffer size (%s)",
516                          snd_strerror( i_snd_rc ) );
517         goto error;
518     }
519
520     /* Set period size. */
521 #ifdef HAVE_ALSA_NEW_API
522     if ( ( i_snd_rc = snd_pcm_hw_params_set_period_size_near( p_sys->p_snd_pcm,
523                                     p_hw, &i_period_size, NULL ) ) < 0 )
524 #else
525     if ( ( i_snd_rc = snd_pcm_hw_params_set_period_size_near( p_sys->p_snd_pcm,
526                                     p_hw, i_period_size, NULL ) ) < 0 )
527 #endif
528     {
529         msg_Err( p_aout, "unable to set period size (%s)",
530                          snd_strerror( i_snd_rc ) );
531         goto error;
532     }
533     p_aout->output.i_nb_samples = i_period_size;
534
535     /* Commit hardware parameters. */
536     if ( ( i_snd_rc = snd_pcm_hw_params( p_sys->p_snd_pcm, p_hw ) ) < 0 )
537     {
538         msg_Err( p_aout, "unable to commit hardware configuration (%s)",
539                          snd_strerror( i_snd_rc ) );
540         goto error;
541     }
542
543 #ifdef HAVE_ALSA_NEW_API
544     if( ( i_snd_rc = snd_pcm_hw_params_get_period_time( p_hw,
545                                     &p_sys->i_period_time, NULL ) ) < 0 )
546 #else
547     if( ( p_sys->i_period_time =
548                   snd_pcm_hw_params_get_period_time( p_hw, NULL ) ) < 0 )
549 #endif
550     {
551         msg_Err( p_aout, "unable to get period time (%s)",
552                          snd_strerror( i_snd_rc ) );
553         goto error;
554     }
555
556     /* Get Initial software parameters */
557     snd_pcm_sw_params_current( p_sys->p_snd_pcm, p_sw );
558
559     i_snd_rc = snd_pcm_sw_params_set_sleep_min( p_sys->p_snd_pcm, p_sw, 0 );
560
561     i_snd_rc = snd_pcm_sw_params_set_avail_min( p_sys->p_snd_pcm, p_sw,
562                                                 p_aout->output.i_nb_samples );
563
564     /* Commit software parameters. */
565     if ( snd_pcm_sw_params( p_sys->p_snd_pcm, p_sw ) < 0 )
566     {
567         msg_Err( p_aout, "unable to set software configuration" );
568         goto error;
569     }
570
571 #ifdef ALSA_DEBUG
572     snd_output_printf( p_sys->p_snd_stderr, "\nALSA hardware setup:\n\n" );
573     snd_pcm_dump_hw_setup( p_sys->p_snd_pcm, p_sys->p_snd_stderr );
574     snd_output_printf( p_sys->p_snd_stderr, "\nALSA software setup:\n\n" );
575     snd_pcm_dump_sw_setup( p_sys->p_snd_pcm, p_sys->p_snd_stderr );
576     snd_output_printf( p_sys->p_snd_stderr, "\n" );
577 #endif
578
579     /* Create ALSA thread and wait for its readiness. */
580     if( vlc_thread_create( p_aout, "aout", ALSAThread,
581                            VLC_THREAD_PRIORITY_OUTPUT, VLC_FALSE ) )
582     {
583         msg_Err( p_aout, "cannot create ALSA thread (%s)", strerror(errno) );
584         goto error;
585     }
586
587     return 0;
588
589 error:
590     snd_pcm_close( p_sys->p_snd_pcm );
591 #ifdef ALSA_DEBUG
592     snd_output_close( p_sys->p_snd_stderr );
593 #endif
594     free( p_sys );
595     return VLC_EGENERIC;
596 }
597
598 /*****************************************************************************
599  * Play: nothing to do
600  *****************************************************************************/
601 static void Play( aout_instance_t *p_aout )
602 {
603     if( !p_aout->output.p_sys->b_playing )
604     {
605         p_aout->output.p_sys->b_playing = 1;
606
607         /* get the playing date of the first aout buffer */
608         p_aout->output.p_sys->start_date =
609             aout_FifoFirstDate( p_aout, &p_aout->output.fifo );
610
611         /* wake up the audio output thread */
612         vlc_mutex_lock( &p_aout->output.p_sys->lock );
613         vlc_cond_signal( &p_aout->output.p_sys->wait );
614         vlc_mutex_unlock( &p_aout->output.p_sys->lock );
615     }
616 }
617
618 /*****************************************************************************
619  * Close: close the ALSA device
620  *****************************************************************************/
621 static void Close( vlc_object_t *p_this )
622 {
623     aout_instance_t *p_aout = (aout_instance_t *)p_this;
624     struct aout_sys_t * p_sys = p_aout->output.p_sys;
625     int i_snd_rc;
626
627     /* make sure the audio output thread is waken up */
628     vlc_mutex_lock( &p_aout->output.p_sys->lock );
629     vlc_cond_signal( &p_aout->output.p_sys->wait );
630     vlc_mutex_unlock( &p_aout->output.p_sys->lock );
631
632     p_aout->b_die = VLC_TRUE;
633     vlc_thread_join( p_aout );
634     p_aout->b_die = VLC_FALSE;
635
636     i_snd_rc = snd_pcm_close( p_sys->p_snd_pcm );
637
638     if( i_snd_rc > 0 )
639     {
640         msg_Err( p_aout, "failed closing ALSA device (%s)",
641                          snd_strerror( i_snd_rc ) );
642     }
643
644 #ifdef ALSA_DEBUG
645     snd_output_close( p_sys->p_snd_stderr );
646 #endif
647
648     free( p_sys );
649 }
650
651 /*****************************************************************************
652  * ALSAThread: asynchronous thread used to DMA the data to the device
653  *****************************************************************************/
654 static int ALSAThread( aout_instance_t * p_aout )
655 {
656     /* Wait for the exact time to start playing (avoids resampling) */
657     vlc_mutex_lock( &p_aout->output.p_sys->lock );
658     if( !p_aout->output.p_sys->start_date )
659         vlc_cond_wait( &p_aout->output.p_sys->wait,
660                        &p_aout->output.p_sys->lock );
661     vlc_mutex_unlock( &p_aout->output.p_sys->lock );
662
663     mwait( p_aout->output.p_sys->start_date - AOUT_PTS_TOLERANCE / 4 );
664
665     while ( !p_aout->b_die )
666     {
667         ALSAFill( p_aout );
668     }
669
670     return 0;
671 }
672
673 /*****************************************************************************
674  * ALSAFill: function used to fill the ALSA buffer as much as possible
675  *****************************************************************************/
676 static void ALSAFill( aout_instance_t * p_aout )
677 {
678     struct aout_sys_t * p_sys = p_aout->output.p_sys;
679
680     aout_buffer_t * p_buffer;
681     snd_pcm_status_t * p_status;
682     snd_timestamp_t ts_next;
683     int i_snd_rc;
684     mtime_t next_date;
685
686     snd_pcm_status_alloca( &p_status );
687
688     /* Fill in the buffer until space or audio output buffer shortage */
689     {
690         /* Get the status */
691         i_snd_rc = snd_pcm_status( p_sys->p_snd_pcm, p_status );
692         if( i_snd_rc < 0 )
693         {
694             msg_Err( p_aout, "unable to get the device's status (%s)",
695                              snd_strerror( i_snd_rc ) );
696
697             msleep( p_sys->i_period_time >> 1 );
698             return;
699         }
700
701         /* Handle buffer underruns and reget the status */
702         if( snd_pcm_status_get_state( p_status ) == SND_PCM_STATE_XRUN )
703         {
704             /* Prepare the device */
705             i_snd_rc = snd_pcm_prepare( p_sys->p_snd_pcm );
706
707             if( i_snd_rc == 0 )
708             {
709                 msg_Warn( p_aout, "recovered from buffer underrun" );
710
711                 /* Reget the status */
712                 i_snd_rc = snd_pcm_status( p_sys->p_snd_pcm, p_status );
713                 if( i_snd_rc < 0 )
714                 {
715                     msg_Err( p_aout, "unable to get the device's status after "
716                              "recovery (%s)", snd_strerror( i_snd_rc ) );
717
718                     msleep( p_sys->i_period_time >> 1 );
719                     return;
720                 }
721             }
722             else
723             {
724                 msg_Err( p_aout, "unable to recover from buffer underrun" );
725
726                 msleep( p_sys->i_period_time >> 1 );
727                 return;
728             }
729
730             /* Underrun, try to recover as quickly as possible */
731             next_date = mdate();
732         }
733         else
734         {
735             /* Here the device should be either in the RUNNING state.
736              * p_status is valid. */
737
738             snd_pcm_status_get_tstamp( p_status, &ts_next );
739             next_date = (mtime_t)ts_next.tv_sec * 1000000 + ts_next.tv_usec;
740             next_date += (mtime_t)snd_pcm_status_get_delay(p_status)
741                 * 1000000 / p_aout->output.output.i_rate;
742         }
743
744         p_buffer = aout_OutputNextBuffer( p_aout, next_date,
745                         (p_aout->output.output.i_format ==
746                          VLC_FOURCC('s','p','d','i')) );
747
748         /* Audio output buffer shortage -> stop the fill process and wait */
749         if( p_buffer == NULL )
750         {
751             msleep( p_sys->i_period_time >> 1 );
752             return;
753         }
754
755         i_snd_rc = snd_pcm_writei( p_sys->p_snd_pcm, p_buffer->p_buffer,
756                                    p_buffer->i_nb_samples );
757
758         if( i_snd_rc < 0 )
759         {
760             msg_Err( p_aout, "write failed (%s)",
761                              snd_strerror( i_snd_rc ) );
762         }
763
764         aout_BufferFree( p_buffer );
765     }
766 }