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