ALSA: allocate PCM status on the stack
[vlc.git] / modules / audio_output / alsa.c
1 /*****************************************************************************
2  * alsa.c : alsa plugin for vlc
3  *****************************************************************************
4  * Copyright (C) 2000-2001 the VideoLAN team
5  * $Id$
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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25  *****************************************************************************/
26
27 /*****************************************************************************
28  * Preamble
29  *****************************************************************************/
30 #ifdef HAVE_CONFIG_H
31 # include "config.h"
32 #endif
33
34 #include <vlc_common.h>
35 #include <vlc_plugin.h>
36
37 #include <errno.h>                                                 /* ENOMEM */
38 #include <vlc_dialog.h>
39
40 #include <vlc_aout.h>
41 #include <vlc_cpu.h>
42
43 /* ALSA part
44    Note: we use the new API which is available since 0.9.0beta10a. */
45 #define ALSA_PCM_NEW_HW_PARAMS_API
46 #define ALSA_PCM_NEW_SW_PARAMS_API
47 #include <alsa/asoundlib.h>
48
49 /*#define ALSA_DEBUG*/
50
51 /*****************************************************************************
52  * aout_sys_t: ALSA audio output method descriptor
53  *****************************************************************************
54  * This structure is part of the audio output thread descriptor.
55  * It describes the ALSA specific properties of an audio device.
56  *****************************************************************************/
57 struct aout_sys_t
58 {
59     snd_pcm_t         * p_snd_pcm;
60     unsigned int                 i_period_time;
61
62 #ifdef ALSA_DEBUG
63     snd_output_t      * p_snd_stderr;
64 #endif
65
66     bool b_playing;  /* playing status */
67     mtime_t start_date;
68
69     vlc_mutex_t lock;
70     vlc_cond_t  wait ;
71 };
72
73 #define A52_FRAME_NB 1536
74
75 /* These values are in frames.
76    To convert them to a number of bytes you have to multiply them by the
77    number of channel(s) (eg. 2 for stereo) and the size of a sample (eg.
78    2 for int16_t). */
79 #define ALSA_DEFAULT_PERIOD_SIZE        1024
80 #define ALSA_DEFAULT_BUFFER_SIZE        ( ALSA_DEFAULT_PERIOD_SIZE << 8 )
81 #define ALSA_SPDIF_PERIOD_SIZE          A52_FRAME_NB
82 #define ALSA_SPDIF_BUFFER_SIZE          ( ALSA_SPDIF_PERIOD_SIZE << 4 )
83 /* Why << 4 ? --Meuuh */
84 /* Why not ? --Bozo */
85 /* Right. --Meuuh */
86
87 #define DEFAULT_ALSA_DEVICE N_("default")
88
89 /*****************************************************************************
90  * Local prototypes
91  *****************************************************************************/
92 static int   Open         ( vlc_object_t * );
93 static void  Close        ( vlc_object_t * );
94 static void  Play         ( aout_instance_t * );
95 static void* ALSAThread   ( vlc_object_t * );
96 static void  ALSAFill     ( aout_instance_t * );
97 static int FindDevicesCallback( vlc_object_t *p_this, char const *psz_name,
98                                 vlc_value_t newval, vlc_value_t oldval, void *p_unused );
99
100 /*****************************************************************************
101  * Module descriptor
102  *****************************************************************************/
103 static const char *const ppsz_devices[] = { "default" };
104 static const char *const ppsz_devices_text[] = { N_("Default") };
105 vlc_module_begin ()
106     set_shortname( "ALSA" )
107     set_description( N_("ALSA audio output") )
108     set_category( CAT_AUDIO )
109     set_subcategory( SUBCAT_AUDIO_AOUT )
110     add_string( "alsa-audio-device", DEFAULT_ALSA_DEVICE, aout_FindAndRestart,
111                 N_("ALSA Device Name"), NULL, false )
112         add_deprecated_alias( "alsadev" )   /* deprecated since 0.9.3 */
113         change_string_list( ppsz_devices, ppsz_devices_text, FindDevicesCallback )
114         change_action_add( FindDevicesCallback, N_("Refresh list") )
115
116     set_capability( "audio output", 150 )
117     set_callbacks( Open, Close )
118 vlc_module_end ()
119
120 /*****************************************************************************
121  * Probe: probe the audio device for available formats and channels
122  *****************************************************************************/
123 static void Probe( aout_instance_t * p_aout,
124                    const char * psz_device, const char * psz_iec_device,
125                    int *pi_snd_pcm_format )
126 {
127     struct aout_sys_t * p_sys = p_aout->output.p_sys;
128     vlc_value_t val, text;
129     int i_ret;
130
131     var_Create ( p_aout, "audio-device", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );
132     text.psz_string = _("Audio Device");
133     var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );
134
135     /* We'll open the audio device in non blocking mode so we can just exit
136      * when it is already in use, but for the real stuff we'll still use
137      * the blocking mode */
138
139     /* Now test linear PCM capabilities */
140     if ( !(i_ret = snd_pcm_open( &p_sys->p_snd_pcm, psz_device,
141                                  SND_PCM_STREAM_PLAYBACK,
142                                  SND_PCM_NONBLOCK ) ) )
143     {
144         int i_channels;
145         snd_pcm_hw_params_t * p_hw;
146         snd_pcm_hw_params_alloca (&p_hw);
147
148         if ( snd_pcm_hw_params_any( p_sys->p_snd_pcm, p_hw ) < 0 )
149         {
150             msg_Warn( p_aout, "unable to retrieve initial hardware parameters"
151                               ", disabling linear PCM audio" );
152             snd_pcm_close( p_sys->p_snd_pcm );
153             var_Destroy( p_aout, "audio-device" );
154             return;
155         }
156
157         if ( snd_pcm_hw_params_set_format( p_sys->p_snd_pcm, p_hw,
158                                            *pi_snd_pcm_format ) < 0 )
159         {
160             int i_snd_rc = -1;
161
162             if( *pi_snd_pcm_format != SND_PCM_FORMAT_S16 )
163             {
164                 *pi_snd_pcm_format = SND_PCM_FORMAT_S16;
165                 i_snd_rc = snd_pcm_hw_params_set_format( p_sys->p_snd_pcm,
166                                                     p_hw, *pi_snd_pcm_format );
167             }
168             if ( i_snd_rc < 0 )
169             {
170                 msg_Warn( p_aout, "unable to set stream sample size and "
171                           "word order, disabling linear PCM audio" );
172                 snd_pcm_close( p_sys->p_snd_pcm );
173                 var_Destroy( p_aout, "audio-device" );
174                 return;
175             }
176         }
177
178         i_channels = aout_FormatNbChannels( &p_aout->output.output );
179
180         while ( i_channels > 0 )
181         {
182             if ( !snd_pcm_hw_params_test_channels( p_sys->p_snd_pcm, p_hw,
183                                                    i_channels ) )
184             {
185                 switch ( i_channels )
186                 {
187                 case 1:
188                     val.i_int = AOUT_VAR_MONO;
189                     text.psz_string = _("Mono");
190                     var_Change( p_aout, "audio-device",
191                                 VLC_VAR_ADDCHOICE, &val, &text );
192                     break;
193                 case 2:
194                     val.i_int = AOUT_VAR_STEREO;
195                     text.psz_string = _("Stereo");
196                     var_Change( p_aout, "audio-device",
197                                 VLC_VAR_ADDCHOICE, &val, &text );
198                     var_Set( p_aout, "audio-device", val );
199                     break;
200                 case 4:
201                     val.i_int = AOUT_VAR_2F2R;
202                     text.psz_string = _("2 Front 2 Rear");
203                     var_Change( p_aout, "audio-device",
204                                 VLC_VAR_ADDCHOICE, &val, &text );
205                     break;
206                 case 6:
207                     val.i_int = AOUT_VAR_5_1;
208                     text.psz_string = "5.1";
209                     var_Change( p_aout, "audio-device",
210                                 VLC_VAR_ADDCHOICE, &val, &text );
211                     break;
212                 }
213             }
214
215             --i_channels;
216         }
217
218         /* Special case for mono on stereo only boards */
219         i_channels = aout_FormatNbChannels( &p_aout->output.output );
220         var_Change( p_aout, "audio-device", VLC_VAR_CHOICESCOUNT, &val, NULL );
221         if( val.i_int <= 0 && i_channels == 1 )
222         {
223             if ( !snd_pcm_hw_params_test_channels( p_sys->p_snd_pcm, p_hw, 2 ))
224             {
225                 val.i_int = AOUT_VAR_STEREO;
226                 text.psz_string = (char*)N_("Stereo");
227                 var_Change( p_aout, "audio-device",
228                             VLC_VAR_ADDCHOICE, &val, &text );
229                 var_Set( p_aout, "audio-device", val );
230             }
231         }
232
233         /* Close the previously opened device */
234         snd_pcm_close( p_sys->p_snd_pcm );
235     }
236     else if ( i_ret == -EBUSY )
237     {
238         msg_Warn( p_aout, "audio device: %s is already in use", psz_device );
239     }
240
241     /* Test for S/PDIF device if needed */
242     if ( psz_iec_device )
243     {
244         /* Opening the device should be enough */
245         if ( !(i_ret = snd_pcm_open( &p_sys->p_snd_pcm, psz_iec_device,
246                                      SND_PCM_STREAM_PLAYBACK,
247                                      SND_PCM_NONBLOCK ) ) )
248         {
249             val.i_int = AOUT_VAR_SPDIF;
250             text.psz_string = (char*)N_("A/52 over S/PDIF");
251             var_Change( p_aout, "audio-device",
252                         VLC_VAR_ADDCHOICE, &val, &text );
253             if( config_GetInt( p_aout, "spdif" ) )
254                 var_Set( p_aout, "audio-device", val );
255
256             snd_pcm_close( p_sys->p_snd_pcm );
257         }
258         else if ( i_ret == -EBUSY )
259         {
260             msg_Warn( p_aout, "audio device: %s is already in use",
261                       psz_iec_device );
262         }
263     }
264
265     var_Change( p_aout, "audio-device", VLC_VAR_CHOICESCOUNT, &val, NULL );
266     if( val.i_int <= 0 )
267     {
268         /* Probe() has failed. */
269         msg_Dbg( p_aout, "failed to find a usable alsa configuration" );
270         var_Destroy( p_aout, "audio-device" );
271         return;
272     }
273
274     /* Add final settings to the variable */
275     var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL );
276     var_SetBool( p_aout, "intf-change", true );
277 }
278
279 /*****************************************************************************
280  * Open: create a handle and open an alsa device
281  *****************************************************************************
282  * This function opens an alsa device, through the alsa API.
283  *
284  * Note: the only heap-allocated string is psz_device. All the other pointers
285  * are references to psz_device or to stack-allocated data.
286  *****************************************************************************/
287 static int Open( vlc_object_t *p_this )
288 {
289     aout_instance_t * p_aout = (aout_instance_t *)p_this;
290     struct aout_sys_t * p_sys;
291     vlc_value_t val;
292
293     char psz_default_iec_device[128]; /* Buffer used to store the default
294                                          S/PDIF device */
295     char * psz_device, * psz_iec_device; /* device names for PCM and S/PDIF
296                                             output */
297
298     int i_vlc_pcm_format; /* Audio format for VLC's data */
299     int i_snd_pcm_format; /* Audio format for ALSA's data */
300
301     snd_pcm_uframes_t i_buffer_size = 0;
302     snd_pcm_uframes_t i_period_size = 0;
303     int i_channels = 0;
304
305     snd_pcm_hw_params_t *p_hw;
306     snd_pcm_sw_params_t *p_sw;
307
308     int i_snd_rc = -1;
309     unsigned int i_old_rate;
310     bool b_retry = true;
311
312     /* Allocate structures */
313     p_aout->output.p_sys = p_sys = malloc( sizeof( aout_sys_t ) );
314     if( p_sys == NULL )
315         return VLC_ENOMEM;
316     p_sys->b_playing = false;
317     p_sys->start_date = 0;
318     vlc_cond_init( &p_sys->wait );
319     vlc_mutex_init( &p_sys->lock );
320
321     /* Get device name */
322     if( (psz_device = config_GetPsz( p_aout, "alsa-audio-device" )) == NULL )
323     {
324         msg_Err( p_aout, "no audio device given (maybe \"default\" ?)" );
325         dialog_Fatal( p_aout, _("No Audio Device"), "%s",
326                         _("No audio device name was given. You might want to " \
327                           "enter \"default\".") );
328         free( p_sys );
329         return VLC_EGENERIC;
330     }
331
332     /* Choose the IEC device for S/PDIF output:
333        if the device is overriden by the user then it will be the one
334        otherwise we compute the default device based on the output format. */
335     if( AOUT_FMT_NON_LINEAR( &p_aout->output.output )
336         && !strcmp( psz_device, DEFAULT_ALSA_DEVICE ) )
337     {
338         snprintf( psz_default_iec_device, sizeof(psz_default_iec_device),
339                   "iec958:AES0=0x%x,AES1=0x%x,AES2=0x%x,AES3=0x%x",
340                   IEC958_AES0_CON_EMPHASIS_NONE | IEC958_AES0_NONAUDIO,
341                   IEC958_AES1_CON_ORIGINAL | IEC958_AES1_CON_PCM_CODER,
342                   0,
343                   ( p_aout->output.output.i_rate == 48000 ?
344                     IEC958_AES3_CON_FS_48000 :
345                     ( p_aout->output.output.i_rate == 44100 ?
346                       IEC958_AES3_CON_FS_44100 : IEC958_AES3_CON_FS_32000 ) ) );
347         psz_iec_device = psz_default_iec_device;
348     }
349     else if( AOUT_FMT_NON_LINEAR( &p_aout->output.output ) )
350     {
351         psz_iec_device = psz_device;
352     }
353     else
354     {
355         psz_iec_device = NULL;
356     }
357
358     /* Choose the linear PCM format (read the comment above about FPU
359        and float32) */
360     if( HAVE_FPU )
361     {
362         i_vlc_pcm_format = VLC_CODEC_FL32;
363         i_snd_pcm_format = SND_PCM_FORMAT_FLOAT;
364     }
365     else
366     {
367         i_vlc_pcm_format = VLC_CODEC_S16N;
368         i_snd_pcm_format = SND_PCM_FORMAT_S16;
369     }
370
371     /* If the variable doesn't exist then it's the first time we're called
372        and we have to probe the available audio formats and channels */
373     if ( var_Type( p_aout, "audio-device" ) == 0 )
374     {
375         Probe( p_aout, psz_device, psz_iec_device, &i_snd_pcm_format );
376     }
377
378     if ( var_Get( p_aout, "audio-device", &val ) < 0 )
379     {
380         free( p_sys );
381         free( psz_device );
382         return VLC_EGENERIC;
383     }
384
385     p_aout->output.output.i_format = i_vlc_pcm_format;
386     if ( val.i_int == AOUT_VAR_5_1 )
387     {
388         p_aout->output.output.i_physical_channels
389             = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
390                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
391                | AOUT_CHAN_LFE;
392         free( psz_device );
393         psz_device = strdup( "surround51" );
394     }
395     else if ( val.i_int == AOUT_VAR_2F2R )
396     {
397         p_aout->output.output.i_physical_channels
398             = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
399                | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
400         free( psz_device );
401         psz_device = strdup( "surround40" );
402     }
403     else if ( val.i_int == AOUT_VAR_STEREO )
404     {
405         p_aout->output.output.i_physical_channels
406             = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
407     }
408     else if ( val.i_int == AOUT_VAR_MONO )
409     {
410         p_aout->output.output.i_physical_channels = AOUT_CHAN_CENTER;
411     }
412     else if( val.i_int != AOUT_VAR_SPDIF )
413     {
414         /* This should not happen ! */
415         msg_Err( p_aout, "internal: can't find audio-device (%i)", val.i_int );
416         free( p_sys );
417         free( psz_device );
418         return VLC_EGENERIC;
419     }
420
421 #ifdef ALSA_DEBUG
422     snd_output_stdio_attach( &p_sys->p_snd_stderr, stderr, 0 );
423 #endif
424
425     /* Open the device */
426     if ( val.i_int == AOUT_VAR_SPDIF )
427     {
428         if ( ( i_snd_rc = snd_pcm_open( &p_sys->p_snd_pcm, psz_iec_device,
429                             SND_PCM_STREAM_PLAYBACK, 0 ) ) < 0 )
430         {
431             msg_Err( p_aout, "cannot open ALSA device `%s' (%s)",
432                              psz_iec_device, snd_strerror( i_snd_rc ) );
433             dialog_Fatal( p_aout, _("Audio output failed"),
434                             _("VLC could not open the ALSA device \"%s\" (%s)."),
435                             psz_iec_device, snd_strerror( i_snd_rc ) );
436             free( p_sys );
437             free( psz_device );
438             return VLC_EGENERIC;
439         }
440         i_buffer_size = ALSA_SPDIF_BUFFER_SIZE;
441         i_snd_pcm_format = SND_PCM_FORMAT_S16;
442         i_channels = 2;
443
444         i_vlc_pcm_format = VLC_CODEC_SPDIFL;
445         p_aout->output.i_nb_samples = i_period_size = ALSA_SPDIF_PERIOD_SIZE;
446         p_aout->output.output.i_bytes_per_frame = AOUT_SPDIF_SIZE;
447         p_aout->output.output.i_frame_length = A52_FRAME_NB;
448
449         aout_VolumeNoneInit( p_aout );
450     }
451     else
452     {
453         int i;
454
455         msg_Dbg( p_aout, "opening ALSA device `%s'", psz_device );
456
457         /* Since it seems snd_pcm_close hasn't really released the device at
458           the time it returns, probe if the device is available in loop for 1s.
459           We cannot use blocking mode since the we would wait indefinitely when
460           switching from a dmx device to surround51. */
461
462         for( i = 10; i >= 0; i-- )
463         {
464             if ( ( i_snd_rc = snd_pcm_open( &p_sys->p_snd_pcm, psz_device,
465                    SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK ) ) == -EBUSY )
466             {
467                 if( i ) msleep( 100000 /* 100ms */ );
468                 else
469                 {
470                     msg_Err( p_aout, "audio device: %s is already in use",
471                               psz_device );
472                     dialog_Fatal( p_aout, _("Audio output failed"),
473                                     _("The audio device \"%s\" is already in use."),
474                                     psz_device );
475                 }
476                 continue;
477             }
478             break;
479         }
480         if( i_snd_rc < 0 )
481         {
482             msg_Err( p_aout, "cannot open ALSA device `%s' (%s)",
483                              psz_device, snd_strerror( i_snd_rc ) );
484             dialog_Fatal( p_aout, _("Audio output failed"),
485                             _("VLC could not open the ALSA device \"%s\" (%s)."),
486                             psz_device, snd_strerror( i_snd_rc ) );
487             free( p_sys );
488             free( psz_device );
489             return VLC_EGENERIC;
490         }
491
492         /* We want blocking mode */
493         snd_pcm_nonblock( p_sys->p_snd_pcm, 0 );
494
495         i_buffer_size = ALSA_DEFAULT_BUFFER_SIZE;
496         i_channels = aout_FormatNbChannels( &p_aout->output.output );
497
498         p_aout->output.i_nb_samples = i_period_size = ALSA_DEFAULT_PERIOD_SIZE;
499
500         aout_VolumeSoftInit( p_aout );
501     }
502
503     /* Free psz_device so that all the remaining data is stack-allocated */
504     free( psz_device );
505
506     p_aout->output.pf_play = Play;
507
508     snd_pcm_hw_params_alloca(&p_hw);
509     snd_pcm_sw_params_alloca(&p_sw);
510
511     /* Due to some bugs in alsa with some drivers, we need to retry in s16l
512        if snd_pcm_hw_params fails in fl32 */
513     while ( b_retry )
514     {
515         b_retry = false;
516
517         /* Get Initial hardware parameters */
518         if ( ( i_snd_rc = snd_pcm_hw_params_any( p_sys->p_snd_pcm, p_hw ) ) < 0 )
519         {
520             msg_Err( p_aout, "unable to retrieve initial hardware parameters (%s)",
521                          snd_strerror( i_snd_rc ) );
522             goto error;
523         }
524
525         /* Set format. */
526         if ( ( i_snd_rc = snd_pcm_hw_params_set_format( p_sys->p_snd_pcm, p_hw,
527                                                     i_snd_pcm_format ) ) < 0 )
528         {
529             if( i_snd_pcm_format != SND_PCM_FORMAT_S16 )
530             {
531                 i_snd_pcm_format = SND_PCM_FORMAT_S16;
532                 i_snd_rc = snd_pcm_hw_params_set_format( p_sys->p_snd_pcm,
533                                                      p_hw, i_snd_pcm_format );
534             }
535             if ( i_snd_rc < 0 )
536             {
537                 msg_Err( p_aout, "unable to set stream sample size and "
538                      "word order (%s)", snd_strerror( i_snd_rc ) );
539                 goto error;
540             }
541         }
542         if( i_vlc_pcm_format != VLC_CODEC_SPDIFL )
543         switch( i_snd_pcm_format )
544         {
545         case SND_PCM_FORMAT_FLOAT:
546             i_vlc_pcm_format = VLC_CODEC_FL32;
547             break;
548         case SND_PCM_FORMAT_S16:
549             i_vlc_pcm_format = VLC_CODEC_S16N;
550             break;
551         }
552         p_aout->output.output.i_format = i_vlc_pcm_format;
553
554         if ( ( i_snd_rc = snd_pcm_hw_params_set_access( p_sys->p_snd_pcm, p_hw,
555                                     SND_PCM_ACCESS_RW_INTERLEAVED ) ) < 0 )
556         {
557             msg_Err( p_aout, "unable to set interleaved stream format (%s)",
558                              snd_strerror( i_snd_rc ) );
559             goto error;
560         }
561
562         /* Set channels. */
563         if ( ( i_snd_rc = snd_pcm_hw_params_set_channels( p_sys->p_snd_pcm, p_hw,
564                                                       i_channels ) ) < 0 )
565         {
566             msg_Err( p_aout, "unable to set number of output channels (%s)",
567                              snd_strerror( i_snd_rc ) );
568             goto error;
569         }
570
571         /* Set rate. */
572         i_old_rate = p_aout->output.output.i_rate;
573         i_snd_rc = snd_pcm_hw_params_set_rate_near( p_sys->p_snd_pcm, p_hw,
574                                                 &p_aout->output.output.i_rate,
575                                                 NULL );
576         if( i_snd_rc < 0 || p_aout->output.output.i_rate != i_old_rate )
577         {
578             msg_Warn( p_aout, "The rate %d Hz is not supported by your " \
579                 "hardware. Using %d Hz instead.\n", i_old_rate, \
580                 p_aout->output.output.i_rate );
581         }
582
583         /* Set period size. */
584         if ( ( i_snd_rc = snd_pcm_hw_params_set_period_size_near( p_sys->p_snd_pcm,
585                                     p_hw, &i_period_size, NULL ) ) < 0 )
586         {
587             msg_Err( p_aout, "unable to set period size (%s)",
588                          snd_strerror( i_snd_rc ) );
589             goto error;
590         }
591         p_aout->output.i_nb_samples = i_period_size;
592
593 /* Set buffer size. */
594         if ( ( i_snd_rc = snd_pcm_hw_params_set_buffer_size_near( p_sys->p_snd_pcm,
595                                     p_hw, &i_buffer_size ) ) < 0 )
596         {
597             msg_Err( p_aout, "unable to set buffer size (%s)",
598                          snd_strerror( i_snd_rc ) );
599             goto error;
600         }
601
602         /* Commit hardware parameters. */
603         if ( ( i_snd_rc = snd_pcm_hw_params( p_sys->p_snd_pcm, p_hw ) ) < 0 )
604         {
605             if ( b_retry == false &&
606                                 i_snd_pcm_format == SND_PCM_FORMAT_FLOAT)
607             {
608                 b_retry = true;
609                 i_snd_pcm_format = SND_PCM_FORMAT_S16;
610                 p_aout->output.output.i_format = VLC_CODEC_S16N;
611                 msg_Warn( p_aout, "unable to commit hardware configuration "
612                                   "with fl32 samples. Retrying with s16l (%s)",                                     snd_strerror( i_snd_rc ) );
613             }
614             else
615             {
616                 msg_Err( p_aout, "unable to commit hardware configuration (%s)",
617                          snd_strerror( i_snd_rc ) );
618                 goto error;
619             }
620         }
621     }
622
623     if( ( i_snd_rc = snd_pcm_hw_params_get_period_time( p_hw,
624                                     &p_sys->i_period_time, NULL ) ) < 0 )
625     {
626         msg_Err( p_aout, "unable to get period time (%s)",
627                          snd_strerror( i_snd_rc ) );
628         goto error;
629     }
630
631     /* Get Initial software parameters */
632     snd_pcm_sw_params_current( p_sys->p_snd_pcm, p_sw );
633
634     i_snd_rc = snd_pcm_sw_params_set_sleep_min( p_sys->p_snd_pcm, p_sw, 0 );
635
636     i_snd_rc = snd_pcm_sw_params_set_avail_min( p_sys->p_snd_pcm, p_sw,
637                                                 p_aout->output.i_nb_samples );
638     /* start playing when one period has been written */
639     i_snd_rc = snd_pcm_sw_params_set_start_threshold( p_sys->p_snd_pcm, p_sw,
640                                                       ALSA_DEFAULT_PERIOD_SIZE);
641     if( i_snd_rc < 0 )
642     {
643         msg_Err( p_aout, "unable to set start threshold (%s)",
644                           snd_strerror( i_snd_rc ) );
645         goto error;
646     }
647
648     /* Commit software parameters. */
649     if ( snd_pcm_sw_params( p_sys->p_snd_pcm, p_sw ) < 0 )
650     {
651         msg_Err( p_aout, "unable to set software configuration" );
652         goto error;
653     }
654
655 #ifdef ALSA_DEBUG
656     snd_output_printf( p_sys->p_snd_stderr, "\nALSA hardware setup:\n\n" );
657     snd_pcm_dump_hw_setup( p_sys->p_snd_pcm, p_sys->p_snd_stderr );
658     snd_output_printf( p_sys->p_snd_stderr, "\nALSA software setup:\n\n" );
659     snd_pcm_dump_sw_setup( p_sys->p_snd_pcm, p_sys->p_snd_stderr );
660     snd_output_printf( p_sys->p_snd_stderr, "\n" );
661 #endif
662
663     /* Create ALSA thread and wait for its readiness. */
664     if( vlc_thread_create( p_aout, "aout", ALSAThread,
665                            VLC_THREAD_PRIORITY_OUTPUT ) )
666     {
667         msg_Err( p_aout, "cannot create ALSA thread (%m)" );
668         goto error;
669     }
670
671     return 0;
672
673 error:
674     snd_pcm_close( p_sys->p_snd_pcm );
675 #ifdef ALSA_DEBUG
676     snd_output_close( p_sys->p_snd_stderr );
677 #endif
678     free( p_sys );
679     return VLC_EGENERIC;
680 }
681
682 /*****************************************************************************
683  * Play: nothing to do
684  *****************************************************************************/
685 static void Play( aout_instance_t *p_aout )
686 {
687     if( !p_aout->output.p_sys->b_playing )
688     {
689         p_aout->output.p_sys->b_playing = true;
690
691         /* get the playing date of the first aout buffer */
692         vlc_mutex_lock( &p_aout->output.p_sys->lock );
693         p_aout->output.p_sys->start_date =
694             aout_FifoFirstDate( p_aout, &p_aout->output.fifo );
695
696         /* wake up the audio output thread */
697         vlc_cond_signal( &p_aout->output.p_sys->wait );
698         vlc_mutex_unlock( &p_aout->output.p_sys->lock );
699     }
700 }
701
702 /*****************************************************************************
703  * Close: close the ALSA device
704  *****************************************************************************/
705 static void Close( vlc_object_t *p_this )
706 {
707     aout_instance_t *p_aout = (aout_instance_t *)p_this;
708     struct aout_sys_t * p_sys = p_aout->output.p_sys;
709     int i_snd_rc;
710
711     /* Make sure that the thread will stop once it is waken up */
712     vlc_object_kill( p_aout );
713
714     /* make sure the audio output thread is waken up */
715     vlc_mutex_lock( &p_aout->output.p_sys->lock );
716     vlc_cond_signal( &p_aout->output.p_sys->wait );
717     vlc_mutex_unlock( &p_aout->output.p_sys->lock );
718
719     /* */
720     vlc_thread_join( p_aout );
721     p_aout->b_die = false;
722
723     i_snd_rc = snd_pcm_close( p_sys->p_snd_pcm );
724
725     if( i_snd_rc > 0 )
726     {
727         msg_Err( p_aout, "failed closing ALSA device (%s)",
728                          snd_strerror( i_snd_rc ) );
729     }
730
731 #ifdef ALSA_DEBUG
732     snd_output_close( p_sys->p_snd_stderr );
733 #endif
734
735     free( p_sys );
736 }
737
738 /*****************************************************************************
739  * ALSAThread: asynchronous thread used to DMA the data to the device
740  *****************************************************************************/
741 static void* ALSAThread( vlc_object_t* p_this )
742 {
743     aout_instance_t * p_aout = (aout_instance_t*)p_this;
744     struct aout_sys_t * p_sys = p_aout->output.p_sys;
745     int canc = vlc_savecancel ();
746
747     /* Wait for the exact time to start playing (avoids resampling) */
748     vlc_mutex_lock( &p_sys->lock );
749     while( !p_sys->start_date && vlc_object_alive (p_aout) )
750         vlc_cond_wait( &p_sys->wait, &p_sys->lock );
751     vlc_mutex_unlock( &p_sys->lock );
752
753     if( !vlc_object_alive (p_aout) )
754         goto cleanup;
755
756     mwait( p_sys->start_date - AOUT_PTS_TOLERANCE / 4 );
757
758     while ( vlc_object_alive (p_aout) )
759     {
760         ALSAFill( p_aout );
761     }
762
763 cleanup:
764     snd_pcm_drop( p_sys->p_snd_pcm );
765     vlc_restorecancel (canc);
766     return NULL;
767 }
768
769 /*****************************************************************************
770  * ALSAFill: function used to fill the ALSA buffer as much as possible
771  *****************************************************************************/
772 static void ALSAFill( aout_instance_t * p_aout )
773 {
774     struct aout_sys_t * p_sys = p_aout->output.p_sys;
775     aout_buffer_t * p_buffer;
776     snd_pcm_status_t * p_status;
777     int i_snd_rc;
778     mtime_t next_date;
779
780     /* Fill in the buffer until space or audio output buffer shortage */
781
782     /* Get the status */
783     snd_pcm_status_alloca(&p_status);
784     i_snd_rc = snd_pcm_status( p_sys->p_snd_pcm, p_status );
785     if( i_snd_rc < 0 )
786     {
787         msg_Err( p_aout, "cannot get device status" );
788         goto error;
789     }
790
791     /* Handle buffer underruns and get the status again */
792     if( snd_pcm_status_get_state( p_status ) == SND_PCM_STATE_XRUN )
793     {
794         /* Prepare the device */
795         i_snd_rc = snd_pcm_prepare( p_sys->p_snd_pcm );
796
797         if( i_snd_rc )
798         {
799             msg_Err( p_aout, "cannot recover from buffer underrun" );
800             goto error;
801         }
802
803         msg_Dbg( p_aout, "recovered from buffer underrun" );
804
805         /* Get the new status */
806         i_snd_rc = snd_pcm_status( p_sys->p_snd_pcm, p_status );
807         if( i_snd_rc < 0 )
808         {
809             msg_Err( p_aout, "cannot get device status after recovery" );
810             goto error;
811         }
812
813         /* Underrun, try to recover as quickly as possible */
814         next_date = mdate();
815     }
816     else
817     {
818         /* Here the device should be in RUNNING state, p_status is valid. */
819         snd_pcm_sframes_t delay = snd_pcm_status_get_delay( p_status );
820         if( delay == 0 ) /* workaround buggy alsa drivers */
821             if( snd_pcm_delay( p_sys->p_snd_pcm, &delay ) < 0 )
822                 delay = 0; /* FIXME: use a positive minimal delay */
823         int i_bytes = snd_pcm_frames_to_bytes( p_sys->p_snd_pcm, delay );
824         next_date = mdate() + ( (mtime_t)i_bytes * 1000000
825                 / p_aout->output.output.i_bytes_per_frame
826                 / p_aout->output.output.i_rate
827                 * p_aout->output.output.i_frame_length );
828
829 #ifdef ALSA_DEBUG
830         snd_pcm_state_t state = snd_pcm_status_get_state( p_status );
831         if( state != SND_PCM_STATE_RUNNING )
832             msg_Err( p_aout, "pcm status (%d) != RUNNING", state );
833
834         msg_Dbg( p_aout, "Delay is %ld frames (%d bytes)", delay, i_bytes );
835
836         msg_Dbg( p_aout, "Bytes per frame: %d", p_aout->output.output.i_bytes_per_frame );
837         msg_Dbg( p_aout, "Rate: %d", p_aout->output.output.i_rate );
838         msg_Dbg( p_aout, "Frame length: %d", p_aout->output.output.i_frame_length );
839
840         msg_Dbg( p_aout, "Next date is in %d microseconds", (int)(next_date - mdate()) );
841 #endif
842     }
843
844     p_buffer = aout_OutputNextBuffer( p_aout, next_date,
845            (p_aout->output.output.i_format ==  VLC_CODEC_SPDIFL) );
846
847     /* Audio output buffer shortage -> stop the fill process and wait */
848     if( p_buffer == NULL )
849         goto error;
850
851     for (;;)
852     {
853         i_snd_rc = snd_pcm_writei( p_sys->p_snd_pcm, p_buffer->p_buffer,
854                                    p_buffer->i_nb_samples );
855         if( i_snd_rc != -ESTRPIPE )
856             break;
857
858         /* a suspend event occurred
859          * (stream is suspended and waiting for an application recovery) */
860         msg_Dbg( p_aout, "entering in suspend mode, trying to resume..." );
861
862         while( vlc_object_alive (p_aout) && vlc_object_alive (p_aout->p_libvlc) &&
863                ( i_snd_rc = snd_pcm_resume( p_sys->p_snd_pcm ) ) == -EAGAIN )
864         {
865             msleep( 1000000 );
866         }
867
868         if( i_snd_rc < 0 )
869             /* Device does not supprot resuming, restart it */
870             i_snd_rc = snd_pcm_prepare( p_sys->p_snd_pcm );
871
872     }
873
874     if( i_snd_rc < 0 )
875         msg_Err( p_aout, "cannot write: %s", snd_strerror( i_snd_rc ) );
876
877     aout_BufferFree( p_buffer );
878     return;
879
880 error:
881     if( i_snd_rc < 0 )
882         msg_Err( p_aout, "ALSA error: %s", snd_strerror( i_snd_rc ) );
883     msleep( p_sys->i_period_time >> 1 );
884 }
885
886 static void GetDevicesForCard( module_config_t *p_item, int i_card );
887 static void GetDevices( module_config_t *p_item );
888
889 /*****************************************************************************
890  * config variable callback
891  *****************************************************************************/
892 static int FindDevicesCallback( vlc_object_t *p_this, char const *psz_name,
893                                vlc_value_t newval, vlc_value_t oldval, void *p_unused )
894 {
895     module_config_t *p_item;
896     int i;
897     (void)newval;
898     (void)oldval;
899     (void)p_unused;
900
901     p_item = config_FindConfig( p_this, psz_name );
902     if( !p_item ) return VLC_SUCCESS;
903
904     /* Clear-up the current list */
905     if( p_item->i_list )
906     {
907         /* Keep the first entrie */
908         for( i = 1; i < p_item->i_list; i++ )
909         {
910             free( (char *)p_item->ppsz_list[i] );
911             free( (char *)p_item->ppsz_list_text[i] );
912         }
913         /* TODO: Remove when no more needed */
914         p_item->ppsz_list[i] = NULL;
915         p_item->ppsz_list_text[i] = NULL;
916     }
917     p_item->i_list = 1;
918
919     GetDevices( p_item );
920
921     /* Signal change to the interface */
922     p_item->b_dirty = true;
923
924     return VLC_SUCCESS;
925 }
926
927
928 static void GetDevicesForCard( module_config_t *p_item, int i_card )
929 {
930     int i_pcm_device = -1;
931     int i_err = 0;
932     snd_pcm_info_t *p_pcm_info;
933     snd_ctl_t *p_ctl;
934     char psz_dev[64];
935     char *psz_card_name;
936
937     sprintf( psz_dev, "hw:%i", i_card );
938
939     if( ( i_err = snd_ctl_open( &p_ctl, psz_dev, 0 ) ) < 0 )
940         return;
941
942     if( ( i_err = snd_card_get_name( i_card, &psz_card_name ) ) != 0)
943         psz_card_name = _("Unknown soundcard");
944
945     snd_pcm_info_alloca( &p_pcm_info );
946
947     for (;;)
948     {
949         char *psz_device, *psz_descr;
950         if( ( i_err = snd_ctl_pcm_next_device( p_ctl, &i_pcm_device ) ) < 0 )
951             i_pcm_device = -1;
952         if( i_pcm_device < 0 )
953             break;
954
955         snd_pcm_info_set_device( p_pcm_info, i_pcm_device );
956         snd_pcm_info_set_subdevice( p_pcm_info, 0 );
957         snd_pcm_info_set_stream( p_pcm_info, SND_PCM_STREAM_PLAYBACK );
958
959         if( ( i_err = snd_ctl_pcm_info( p_ctl, p_pcm_info ) ) < 0 )
960         {
961             if( i_err != -ENOENT )
962             {
963                 /*printf( "get_devices_for_card(): "
964                          "snd_ctl_pcm_info() "
965                          "failed (%d:%d): %s.\n", i_card,
966                          i_pcm_device, snd_strerror( -i_err ) );*/
967             }
968             continue;
969         }
970
971         if( asprintf( &psz_device, "hw:%d,%d", i_card, i_pcm_device ) == -1 )
972             break;
973         if( asprintf( &psz_descr, "%s: %s (%s)", psz_card_name,
974                   snd_pcm_info_get_name(p_pcm_info), psz_device ) == -1 )
975         {
976             free( psz_device );
977             break;
978         }
979
980         p_item->ppsz_list =
981             (char **)realloc( p_item->ppsz_list,
982                               (p_item->i_list + 2) * sizeof(char *) );
983         p_item->ppsz_list_text =
984             (char **)realloc( p_item->ppsz_list_text,
985                               (p_item->i_list + 2) * sizeof(char *) );
986         p_item->ppsz_list[ p_item->i_list ] = psz_device;
987         p_item->ppsz_list_text[ p_item->i_list ] = psz_descr;
988         p_item->i_list++;
989         p_item->ppsz_list[ p_item->i_list ] = NULL;
990         p_item->ppsz_list_text[ p_item->i_list ] = NULL;
991     }
992
993     snd_ctl_close( p_ctl );
994 }
995
996
997
998 static void GetDevices( module_config_t *p_item )
999 {
1000     int i_card = -1;
1001     int i_err = 0;
1002
1003     if( ( i_err = snd_card_next( &i_card ) ) != 0 )
1004     {
1005         /*printf( "snd_card_next() failed: %s", snd_strerror( -i_err ) );*/
1006         return;
1007     }
1008
1009     while( i_card > -1 )
1010     {
1011         GetDevicesForCard( p_item, i_card );
1012         if( ( i_err = snd_card_next( &i_card ) ) != 0 )
1013         {
1014             /*printf( "snd_card_next() failed: %s", snd_strerror( -i_err ) );*/
1015             break;
1016         }
1017     }
1018 }