572e33cc6573183322518be0633d880e0337f611
[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.27 2003/05/19 23:36:44 gbazin 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 DEBUG
58     snd_output_t      * p_snd_stderr;
59 #endif
60 };
61
62 #define A52_FRAME_NB 1536
63
64 /* These values are in frames.
65    To convert them to a number of bytes you have to multiply them by the
66    number of channel(s) (eg. 2 for stereo) and the size of a sample (eg.
67    2 for s16). */
68 #define ALSA_DEFAULT_PERIOD_SIZE        2048
69 #define ALSA_DEFAULT_BUFFER_SIZE        ( ALSA_DEFAULT_PERIOD_SIZE << 4 )
70 #define ALSA_SPDIF_PERIOD_SIZE          A52_FRAME_NB
71 #define ALSA_SPDIF_BUFFER_SIZE          ( ALSA_SPDIF_PERIOD_SIZE << 4 )
72 /* Why << 4 ? --Meuuh */
73 /* Why not ? --Bozo */
74 /* Right. --Meuuh */
75
76 #define DEFAULT_ALSA_DEVICE "default"
77
78 /*****************************************************************************
79  * Local prototypes
80  *****************************************************************************/
81 static int  Open         ( vlc_object_t * );
82 static void Close        ( vlc_object_t * );
83 static void Play         ( aout_instance_t * );
84 static int  ALSAThread   ( aout_instance_t * );
85 static void ALSAFill     ( aout_instance_t * );
86
87 /*****************************************************************************
88  * Module descriptor
89  *****************************************************************************/
90 vlc_module_begin();
91     add_category_hint( N_("ALSA"), NULL, VLC_FALSE );
92     add_string( "alsadev", DEFAULT_ALSA_DEVICE, aout_FindAndRestart,
93                 N_("ALSA device name"), NULL, VLC_FALSE );
94     set_description( _("ALSA audio output") );
95     set_capability( "audio output", 50 );
96     set_callbacks( Open, Close );
97 vlc_module_end();
98
99 /*****************************************************************************
100  * Probe: probe the audio device for available formats and channels
101  *****************************************************************************/
102 static void Probe( aout_instance_t * p_aout,
103                    const char * psz_device, const char * psz_iec_device,
104                    int i_snd_pcm_format )
105 {
106     struct aout_sys_t * p_sys = p_aout->output.p_sys;
107     vlc_value_t val, text;
108
109     var_Create ( p_aout, "audio-device", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );
110     text.psz_string = _("Audio device");
111     var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );
112
113     /* Now test linear PCM capabilities */
114     if ( !snd_pcm_open( &p_sys->p_snd_pcm, psz_device,
115                         SND_PCM_STREAM_PLAYBACK, 0 ) )
116     {
117         int i_channels;
118         snd_pcm_hw_params_t * p_hw;
119         snd_pcm_hw_params_alloca (&p_hw);
120
121         if ( snd_pcm_hw_params_any( p_sys->p_snd_pcm, p_hw ) < 0 )
122         {
123             msg_Warn( p_aout, "unable to retrieve initial hardware parameters"
124                               ", disabling linear PCM audio" );
125             snd_pcm_close( p_sys->p_snd_pcm );
126             return;
127         }
128
129         if ( snd_pcm_hw_params_set_format( p_sys->p_snd_pcm, p_hw,
130                                            i_snd_pcm_format ) < 0 )
131         {
132             /* Assume a FPU enabled computer can handle float32 format.
133                If somebody tells us it's not always true then we'll have
134                to change this */
135             msg_Warn( p_aout, "unable to set stream sample size and word order"
136                               ", disabling linear PCM audio" );
137             snd_pcm_close( p_sys->p_snd_pcm );
138             return;
139         }
140
141         i_channels = aout_FormatNbChannels( &p_aout->output.output );
142
143         while ( i_channels > 0 )
144         {
145             /* Here we have to probe multi-channel capabilities but I have
146                no idea (at the moment) of how its managed by the ALSA
147                library.
148                It seems that '6' channels aren't well handled on a stereo
149                sound card like my i810 but it requires some more
150                investigations. That's why '4' and '6' cases are disabled.
151                -- Bozo */
152             if ( !snd_pcm_hw_params_test_channels( p_sys->p_snd_pcm, p_hw,
153                                                    i_channels ) )
154             {
155                 switch ( i_channels )
156                 {
157                 case 1:
158                     val.i_int = AOUT_VAR_MONO;
159                     text.psz_string = N_("Mono");
160                     var_Change( p_aout, "audio-device",
161                                 VLC_VAR_ADDCHOICE, &val, &text );
162                     break;
163                 case 2:
164                     val.i_int = AOUT_VAR_STEREO;
165                     text.psz_string = N_("Stereo");
166                     var_Change( p_aout, "audio-device",
167                                 VLC_VAR_ADDCHOICE, &val, &text );
168                     break;
169 /*
170                 case 4:
171                     val.i_int = AOUT_VAR_2F2R;
172                     text.psz_string = N_("2 Front 2 Rear");
173                     var_Change( p_aout, "audio-device",
174                                 VLC_VAR_ADDCHOICE, &val, &text );
175                     break;
176                 case 6:
177                     val.i_int = AOUT_VAR_5_1;
178                     text.psz_string = N_("5.1");
179                     var_Change( p_aout, "audio-device",
180                                 VLC_VAR_ADDCHOICE, &val, &text );
181                     break;
182 */
183                 }
184             }
185
186             --i_channels;
187         }
188
189         /* Close the previously opened device */
190         snd_pcm_close( p_sys->p_snd_pcm );
191     }
192
193     /* Test for S/PDIF device if needed */
194     if ( psz_iec_device )
195     {
196         /* Opening the device should be enough */
197         if ( !snd_pcm_open( &p_sys->p_snd_pcm, psz_iec_device,
198                                 SND_PCM_STREAM_PLAYBACK, 0 ) )
199         {
200             val.i_int = AOUT_VAR_SPDIF;
201             text.psz_string = N_("A/52 over S/PDIF");
202             var_Change( p_aout, "audio-device",
203                         VLC_VAR_ADDCHOICE, &val, &text );
204             if( config_GetInt( p_aout, "spdif" ) )
205                 var_Set( p_aout, "audio-device", val );
206
207             snd_pcm_close( p_sys->p_snd_pcm );
208         }
209     }
210
211     /* Add final settings to the variable */
212     var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL );
213     val.b_bool = VLC_TRUE;
214     var_Set( p_aout, "intf-change", val );
215 }
216
217 /*****************************************************************************
218  * Open: create a handle and open an alsa device
219  *****************************************************************************
220  * This function opens an alsa device, through the alsa API.
221  *
222  * Note: the only heap-allocated string is psz_device. All the other pointers
223  * are references to psz_device or to stack-allocated data.
224  *****************************************************************************/
225 static int Open( vlc_object_t *p_this )
226 {
227     aout_instance_t * p_aout = (aout_instance_t *)p_this;
228     struct aout_sys_t * p_sys;
229     vlc_value_t val;
230
231     char psz_default_iec_device[128]; /* Buffer used to store the default
232                                          S/PDIF device */
233     char * psz_device, * psz_iec_device; /* device names for PCM and S/PDIF
234                                             output */
235
236     int i_vlc_pcm_format; /* Audio format for VLC's data */
237     int i_snd_pcm_format; /* Audio format for ALSA's data */
238
239     snd_pcm_uframes_t i_buffer_size = 0;
240     snd_pcm_uframes_t i_period_size = 0;
241     int i_channels = 0;
242
243     snd_pcm_hw_params_t *p_hw;
244     snd_pcm_sw_params_t *p_sw;
245
246     int i_snd_rc = -1;
247
248     /* Allocate structures */
249     p_aout->output.p_sys = p_sys = malloc( sizeof( aout_sys_t ) );
250     if( p_sys == NULL )
251     {
252         msg_Err( p_aout, "out of memory" );
253         return VLC_ENOMEM;
254     }
255
256     /* Get device name */
257     if( (psz_device = config_GetPsz( p_aout, "alsadev" )) == NULL )
258     {
259         msg_Err( p_aout, "no audio device given (maybe \"default\" ?)" );
260         free( p_sys );
261         return VLC_EGENERIC;
262     }
263
264     /* Choose the IEC device for S/PDIF output:
265        if the device is overriden by the user then it will be the one
266        otherwise we compute the default device based on the output format. */
267     if( AOUT_FMT_NON_LINEAR( &p_aout->output.output )
268         && !strcmp( psz_device, DEFAULT_ALSA_DEVICE ) )
269     {
270         snprintf( psz_default_iec_device, sizeof(psz_default_iec_device),
271                   "iec958:AES0=0x%x,AES1=0x%x,AES2=0x%x,AES3=0x%x",
272                   IEC958_AES0_CON_EMPHASIS_NONE | IEC958_AES0_NONAUDIO,
273                   IEC958_AES1_CON_ORIGINAL | IEC958_AES1_CON_PCM_CODER,
274                   0,
275                   ( p_aout->output.output.i_rate == 48000 ?
276                     IEC958_AES3_CON_FS_48000 :
277                     ( p_aout->output.output.i_rate == 44100 ?
278                       IEC958_AES3_CON_FS_44100 : IEC958_AES3_CON_FS_32000 ) ) );
279         psz_iec_device = psz_default_iec_device;
280     }
281     else if( AOUT_FMT_NON_LINEAR( &p_aout->output.output ) )
282     {
283         psz_iec_device = psz_device;
284     }
285     else
286     {
287         psz_iec_device = NULL;
288     }
289
290     /* Choose the linear PCM format (read the comment above about FPU
291        and float32) */
292     if( p_aout->p_libvlc->i_cpu & CPU_CAPABILITY_FPU )
293     {
294         i_vlc_pcm_format = VLC_FOURCC('f','l','3','2');
295         i_snd_pcm_format = SND_PCM_FORMAT_FLOAT;
296     }
297     else
298     {
299         i_vlc_pcm_format = AOUT_FMT_S16_NE;
300         i_snd_pcm_format = SND_PCM_FORMAT_S16;
301     }
302
303     /* If the variable doesn't exist then it's the first time we're called
304        and we have to probe the available audio formats and channels */
305     if ( var_Type( p_aout, "audio-device" ) == 0 )
306     {
307         Probe( p_aout, psz_device, psz_iec_device, i_snd_pcm_format );
308     }
309
310     if ( var_Get( p_aout, "audio-device", &val ) < 0 )
311     {
312         free( p_sys );
313         free( psz_device );
314         return VLC_EGENERIC;
315     }
316
317     if ( val.i_int == AOUT_VAR_SPDIF )
318     {
319         p_aout->output.output.i_format = VLC_FOURCC('s','p','d','i');
320     }
321     else if ( val.i_int == AOUT_VAR_5_1 )
322     {
323         p_aout->output.output.i_format = i_vlc_pcm_format;
324         p_aout->output.output.i_physical_channels
325             = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
326                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
327                | AOUT_CHAN_LFE;
328     }
329     else if ( val.i_int == AOUT_VAR_2F2R )
330     {
331         p_aout->output.output.i_format = i_vlc_pcm_format;
332         p_aout->output.output.i_physical_channels
333             = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
334                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
335     }
336     else if ( val.i_int == AOUT_VAR_STEREO )
337     {
338         p_aout->output.output.i_format = i_vlc_pcm_format;
339         p_aout->output.output.i_physical_channels
340             = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
341     }
342     else if ( val.i_int == AOUT_VAR_MONO )
343     {
344         p_aout->output.output.i_format = i_vlc_pcm_format;
345         p_aout->output.output.i_physical_channels = AOUT_CHAN_CENTER;
346     }
347
348     else
349     {
350         /* This should not happen ! */
351         msg_Err( p_aout, "internal: can't find audio-device (%i)", val.i_int );
352         free( p_sys );
353         return VLC_EGENERIC;
354     }
355
356 #ifdef DEBUG
357     snd_output_stdio_attach( &p_sys->p_snd_stderr, stderr, 0 );
358 #endif
359
360     /* Open the device */
361     if ( AOUT_FMT_NON_LINEAR( &p_aout->output.output ) )
362     {
363         if ( ( i_snd_rc = snd_pcm_open( &p_sys->p_snd_pcm, psz_iec_device,
364                             SND_PCM_STREAM_PLAYBACK, 0 ) ) < 0 )
365         {
366             msg_Err( p_aout, "cannot open ALSA device `%s' (%s)",
367                              psz_iec_device, snd_strerror( i_snd_rc ) );
368             free( p_sys );
369             free( psz_device );
370             return VLC_EGENERIC;
371         }
372         i_buffer_size = ALSA_SPDIF_BUFFER_SIZE;
373         i_snd_pcm_format = SND_PCM_FORMAT_S16;
374         i_channels = 2;
375
376         p_aout->output.i_nb_samples = i_period_size = ALSA_SPDIF_PERIOD_SIZE;
377         p_aout->output.output.i_bytes_per_frame = AOUT_SPDIF_SIZE;
378         p_aout->output.output.i_frame_length = A52_FRAME_NB;
379
380         aout_VolumeNoneInit( p_aout );
381     }
382     else
383     {
384         if ( ( i_snd_rc = snd_pcm_open( &p_sys->p_snd_pcm, psz_device,
385                             SND_PCM_STREAM_PLAYBACK, 0 ) ) < 0 )
386         {
387             msg_Err( p_aout, "cannot open ALSA device `%s' (%s)",
388                              psz_device, snd_strerror( i_snd_rc ) );
389             free( p_sys );
390             free( psz_device );
391             return VLC_EGENERIC;
392         }
393         i_buffer_size = ALSA_DEFAULT_BUFFER_SIZE;
394         i_channels = aout_FormatNbChannels( &p_aout->output.output );
395
396         p_aout->output.i_nb_samples = i_period_size = ALSA_DEFAULT_PERIOD_SIZE;
397
398         aout_VolumeSoftInit( p_aout );
399     }
400
401     /* Free psz_device so that all the remaining data is stack-allocated */
402     free( psz_device );
403
404     p_aout->output.pf_play = Play;
405
406     snd_pcm_hw_params_alloca(&p_hw);
407     snd_pcm_sw_params_alloca(&p_sw);
408
409     /* Get Initial hardware parameters */
410     if ( ( i_snd_rc = snd_pcm_hw_params_any( p_sys->p_snd_pcm, p_hw ) ) < 0 )
411     {
412         msg_Err( p_aout, "unable to retrieve initial hardware parameters (%s)",
413                          snd_strerror( i_snd_rc ) );
414         goto error;
415     }
416
417     /* Set format. */
418     if ( ( i_snd_rc = snd_pcm_hw_params_set_format( p_sys->p_snd_pcm, p_hw,
419                                                     i_snd_pcm_format ) ) < 0 )
420     {
421         msg_Err( p_aout, "unable to set stream sample size and word order (%s)",
422                          snd_strerror( i_snd_rc ) );
423         goto error;
424     }
425
426     if ( ( i_snd_rc = snd_pcm_hw_params_set_access( p_sys->p_snd_pcm, p_hw,
427                                     SND_PCM_ACCESS_RW_INTERLEAVED ) ) < 0 )
428     {
429         msg_Err( p_aout, "unable to set interleaved stream format (%s)",
430                          snd_strerror( i_snd_rc ) );
431         goto error;
432     }
433
434     /* Set channels. */
435     if ( ( i_snd_rc = snd_pcm_hw_params_set_channels( p_sys->p_snd_pcm, p_hw,
436                                                       i_channels ) ) < 0 )
437     {
438         msg_Err( p_aout, "unable to set number of output channels (%s)",
439                          snd_strerror( i_snd_rc ) );
440         goto error;
441     }
442
443     /* Set rate. */
444 #ifdef HAVE_ALSA_NEW_API
445     if ( ( i_snd_rc = snd_pcm_hw_params_set_rate_near( p_sys->p_snd_pcm, p_hw,
446                                 &p_aout->output.output.i_rate, NULL ) ) < 0 )
447 #else
448     if ( ( i_snd_rc = snd_pcm_hw_params_set_rate_near( p_sys->p_snd_pcm, p_hw,
449                                 p_aout->output.output.i_rate, NULL ) ) < 0 )
450 #endif
451     {
452         msg_Err( p_aout, "unable to set sample rate (%s)",
453                          snd_strerror( i_snd_rc ) );
454         goto error;
455     }
456
457     /* Set buffer size. */
458 #ifdef HAVE_ALSA_NEW_API
459     if ( ( i_snd_rc = snd_pcm_hw_params_set_buffer_size_near( p_sys->p_snd_pcm,
460                                     p_hw, &i_buffer_size ) ) < 0 )
461 #else
462     if ( ( i_snd_rc = snd_pcm_hw_params_set_buffer_size_near( p_sys->p_snd_pcm,
463                                     p_hw, i_buffer_size ) ) < 0 )
464 #endif
465     {
466         msg_Err( p_aout, "unable to set buffer size (%s)",
467                          snd_strerror( i_snd_rc ) );
468         goto error;
469     }
470
471     /* Set period size. */
472 #ifdef HAVE_ALSA_NEW_API
473     if ( ( i_snd_rc = snd_pcm_hw_params_set_period_size_near( p_sys->p_snd_pcm,
474                                     p_hw, &i_period_size, NULL ) ) < 0 )
475 #else
476     if ( ( i_snd_rc = snd_pcm_hw_params_set_period_size_near( p_sys->p_snd_pcm,
477                                     p_hw, i_period_size, NULL ) ) < 0 )
478 #endif
479     {
480         msg_Err( p_aout, "unable to set period size (%s)",
481                          snd_strerror( i_snd_rc ) );
482         goto error;
483     }
484     p_aout->output.i_nb_samples = i_period_size;
485
486     /* Commit hardware parameters. */
487     if ( ( i_snd_rc = snd_pcm_hw_params( p_sys->p_snd_pcm, p_hw ) ) < 0 )
488     {
489         msg_Err( p_aout, "unable to commit hardware configuration (%s)",
490                          snd_strerror( i_snd_rc ) );
491         goto error;
492     }
493
494 #ifdef HAVE_ALSA_NEW_API
495     if( ( i_snd_rc = snd_pcm_hw_params_get_period_time( p_hw,
496                                     &p_sys->i_period_time, NULL ) ) < 0 )
497 #else
498     if( ( p_sys->i_period_time =
499                   snd_pcm_hw_params_get_period_time( p_hw, NULL ) ) < 0 )
500 #endif
501     {
502         msg_Err( p_aout, "unable to get period time (%s)",
503                          snd_strerror( i_snd_rc ) );
504         goto error;
505     }
506
507     /* Get Initial software parameters */
508     snd_pcm_sw_params_current( p_sys->p_snd_pcm, p_sw );
509
510     i_snd_rc = snd_pcm_sw_params_set_sleep_min( p_sys->p_snd_pcm, p_sw, 0 );
511
512     i_snd_rc = snd_pcm_sw_params_set_avail_min( p_sys->p_snd_pcm, p_sw,
513                                                 p_aout->output.i_nb_samples );
514
515     /* Commit software parameters. */
516     if ( snd_pcm_sw_params( p_sys->p_snd_pcm, p_sw ) < 0 )
517     {
518         msg_Err( p_aout, "unable to set software configuration" );
519         goto error;
520     }
521
522 #ifdef DEBUG
523     snd_output_printf( p_sys->p_snd_stderr, "\nALSA hardware setup:\n\n" );
524     snd_pcm_dump_hw_setup( p_sys->p_snd_pcm, p_sys->p_snd_stderr );
525     snd_output_printf( p_sys->p_snd_stderr, "\nALSA software setup:\n\n" );
526     snd_pcm_dump_sw_setup( p_sys->p_snd_pcm, p_sys->p_snd_stderr );
527     snd_output_printf( p_sys->p_snd_stderr, "\n" );
528 #endif
529
530     /* Create ALSA thread and wait for its readiness. */
531     if( vlc_thread_create( p_aout, "aout", ALSAThread,
532                            VLC_THREAD_PRIORITY_OUTPUT, VLC_FALSE ) )
533     {
534         msg_Err( p_aout, "cannot create ALSA thread (%s)", strerror(errno) );
535         goto error;
536     }
537
538     return 0;
539
540 error:
541     snd_pcm_close( p_sys->p_snd_pcm );
542 #ifdef DEBUG
543     snd_output_close( p_sys->p_snd_stderr );
544 #endif
545     free( p_sys );
546     return VLC_EGENERIC;
547 }
548
549 /*****************************************************************************
550  * Play: nothing to do
551  *****************************************************************************/
552 static void Play( aout_instance_t *p_aout )
553 {
554 }
555
556 /*****************************************************************************
557  * Close: close the ALSA device
558  *****************************************************************************/
559 static void Close( vlc_object_t *p_this )
560 {
561     aout_instance_t *p_aout = (aout_instance_t *)p_this;
562     struct aout_sys_t * p_sys = p_aout->output.p_sys;
563     int i_snd_rc;
564
565     p_aout->b_die = VLC_TRUE;
566     vlc_thread_join( p_aout );
567     p_aout->b_die = VLC_FALSE;
568
569     i_snd_rc = snd_pcm_close( p_sys->p_snd_pcm );
570
571     if( i_snd_rc > 0 )
572     {
573         msg_Err( p_aout, "failed closing ALSA device (%s)",
574                          snd_strerror( i_snd_rc ) );
575     }
576
577 #ifdef DEBUG
578     snd_output_close( p_sys->p_snd_stderr );
579 #endif
580
581     free( p_sys );
582 }
583
584 /*****************************************************************************
585  * ALSAThread: asynchronous thread used to DMA the data to the device
586  *****************************************************************************/
587 static int ALSAThread( aout_instance_t * p_aout )
588 {
589     struct aout_sys_t * p_sys = p_aout->output.p_sys;
590
591     while ( !p_aout->b_die )
592     {
593         ALSAFill( p_aout );
594
595         /* Sleep during less than one period to avoid a lot of buffer
596            underruns */
597
598         /* Why do we need to sleep ? --Meuuh */
599         /* Maybe because I don't want to eat all the cpu by looping
600            all the time. --Bozo */
601         /* Shouldn't snd_pcm_wait() make us wait ? --Meuuh */
602         msleep( p_sys->i_period_time >> 1 );
603     }
604
605     return 0;
606 }
607
608 /*****************************************************************************
609  * ALSAFill: function used to fill the ALSA buffer as much as possible
610  *****************************************************************************/
611 static void ALSAFill( aout_instance_t * p_aout )
612 {
613     struct aout_sys_t * p_sys = p_aout->output.p_sys;
614
615     aout_buffer_t * p_buffer;
616     snd_pcm_status_t * p_status;
617     snd_timestamp_t ts_next;
618     int i_snd_rc;
619     mtime_t next_date;
620
621     snd_pcm_status_alloca( &p_status );
622
623     /* Wait for the device's readiness (ie. there is enough space in the
624        buffer to write at least one complete chunk) */
625     i_snd_rc = snd_pcm_wait( p_sys->p_snd_pcm, THREAD_SLEEP );
626     if( i_snd_rc < 0 )
627     {
628         msg_Err( p_aout, "ALSA device not ready !!! (%s)",
629                          snd_strerror( i_snd_rc ) );
630         return;
631     }
632
633     /* Fill in the buffer until space or audio output buffer shortage */
634     for ( ; ; )
635     {
636         /* Get the status */
637         i_snd_rc = snd_pcm_status( p_sys->p_snd_pcm, p_status );
638         if( i_snd_rc < 0 )
639         {
640             msg_Err( p_aout, "unable to get the device's status (%s)",
641                              snd_strerror( i_snd_rc ) );
642             return;
643         }
644
645         /* Handle buffer underruns and reget the status */
646         if( snd_pcm_status_get_state( p_status ) == SND_PCM_STATE_XRUN )
647         {
648             /* Prepare the device */
649             i_snd_rc = snd_pcm_prepare( p_sys->p_snd_pcm );
650
651             if( i_snd_rc == 0 )
652             {
653                 msg_Warn( p_aout, "recovered from buffer underrun" );
654
655                 /* Reget the status */
656                 i_snd_rc = snd_pcm_status( p_sys->p_snd_pcm, p_status );
657                 if( i_snd_rc < 0 )
658                 {
659                     msg_Err( p_aout,
660                         "unable to get the device's status after recovery (%s)",
661                         snd_strerror( i_snd_rc ) );
662                     return;
663                 }
664             }
665             else
666             {
667                 msg_Err( p_aout, "unable to recover from buffer underrun" );
668                 return;
669             }
670         }
671
672         /* Here the device should be either in the RUNNING state either in
673            the PREPARE state. p_status is valid. */
674
675         snd_pcm_status_get_tstamp( p_status, &ts_next );
676         next_date = (mtime_t)ts_next.tv_sec * 1000000 + ts_next.tv_usec;
677         next_date += (mtime_t)snd_pcm_status_get_delay(p_status)
678                      * 1000000 / p_aout->output.output.i_rate;
679
680         p_buffer = aout_OutputNextBuffer( p_aout, next_date,
681                         (p_aout->output.output.i_format ==
682                          VLC_FOURCC('s','p','d','i')) );
683
684         /* Audio output buffer shortage -> stop the fill process and
685            wait in ALSAThread */
686         if( p_buffer == NULL )
687             return;
688
689         i_snd_rc = snd_pcm_writei( p_sys->p_snd_pcm, p_buffer->p_buffer,
690                                    p_buffer->i_nb_samples );
691
692         if( i_snd_rc < 0 )
693         {
694             msg_Err( p_aout, "write failed (%s)",
695                              snd_strerror( i_snd_rc ) );
696         }
697
698         aout_BufferFree( p_buffer );
699
700         msleep( p_sys->i_period_time >> 2 );
701     }
702 }
703