* ./po/*: re-ran make update-po, fixed a few translations.
[vlc.git] / plugins / alsa / alsa.c
1 /*****************************************************************************
2  * alsa.c : alsa plugin for vlc
3  *****************************************************************************
4  * Copyright (C) 2000-2001 VideoLAN
5  * $Id: alsa.c,v 1.17 2002/04/21 10:32:20 sam Exp $
6  *
7  * Authors: Henri Fallon <henri@videolan.org> - Original Author
8  *          Jeffrey Baker <jwbaker@acm.org> - Port to ALSA 1.0 API
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  * 
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <errno.h>                                                 /* ENOMEM */
29 #include <string.h>                                            /* strerror() */
30 #include <stdio.h>                                           /* "intf_msg.h" */
31 #include <stdlib.h>                            /* calloc(), malloc(), free() */
32
33 #include <alsa/asoundlib.h>
34
35 #include <videolan/vlc.h>
36
37 #include "audio_output.h"                                   /* aout_thread_t */
38
39 /*****************************************************************************
40  * Capabilities defined in the other files.
41  *****************************************************************************/
42 static void aout_getfunctions( function_list_t * p_function_list );
43 static int  aout_Open        ( aout_thread_t * );
44 static int  aout_SetFormat   ( aout_thread_t * );
45 static void aout_HandleXrun  ( aout_thread_t *);
46 static int  aout_GetBufInfo  ( aout_thread_t *, int i_buffer_limit );
47 static void aout_Play        ( aout_thread_t *, byte_t *buffer, int i_size );
48 static void aout_Close       ( aout_thread_t * );
49
50 /*****************************************************************************
51  * Build configuration tree.
52  *****************************************************************************/
53 MODULE_CONFIG_START
54
55 MODULE_CONFIG_STOP
56
57 MODULE_INIT_START
58     SET_DESCRIPTION( _("ALSA audio module") )
59     ADD_CAPABILITY( AOUT, 50 )
60     ADD_SHORTCUT( "alsa" )
61 MODULE_INIT_STOP
62     
63 MODULE_ACTIVATE_START
64     aout_getfunctions( &p_module->p_functions->aout );
65 MODULE_ACTIVATE_STOP
66
67 MODULE_DEACTIVATE_START
68 MODULE_DEACTIVATE_STOP
69
70 /*****************************************************************************
71  * Preamble
72  *****************************************************************************/
73 typedef struct alsa_device_s
74 {
75     int i_num;
76 } alsa_device_t;
77
78 typedef struct alsa_card_s
79 {
80     int i_num;
81 } alsa_card_t;
82
83 /* here we store plugin dependant informations */
84
85 typedef struct aout_sys_s
86 {
87     snd_pcm_t   * p_alsa_handle;
88     unsigned long buffer_time;
89     unsigned long period_time;
90     unsigned long chunk_size;
91     unsigned long buffer_size;
92     unsigned long rate;
93     unsigned int  bytes_per_sample;
94     unsigned int  samples_per_frame;
95     unsigned int  bytes_per_frame;
96 } aout_sys_t;
97
98 /*****************************************************************************
99  * Functions exported as capabilities. They are declared as static so that
100  * we don't pollute the namespace too much.
101  *****************************************************************************/
102 static void aout_getfunctions( function_list_t * p_function_list )
103 {
104     p_function_list->functions.aout.pf_open = aout_Open;
105     p_function_list->functions.aout.pf_setformat = aout_SetFormat;
106     p_function_list->functions.aout.pf_getbufinfo = aout_GetBufInfo;
107     p_function_list->functions.aout.pf_play = aout_Play;
108     p_function_list->functions.aout.pf_close = aout_Close;
109 }
110
111 /*****************************************************************************
112  * aout_Open : creates a handle and opens an alsa device
113  *****************************************************************************
114  * This function opens an alsa device, through the alsa API
115  *****************************************************************************/
116 static int aout_Open( aout_thread_t *p_aout )
117 {
118     int i_ret;
119     char psz_alsadev[128];
120
121     /* Allocate structures */
122     p_aout->p_sys = malloc( sizeof( aout_sys_t ) );
123     if( p_aout->p_sys == NULL )
124     {
125         intf_ErrMsg( "aout error: failed allocating memory for ALSA (%s)",
126                      strerror(ENOMEM) );
127         return -1;
128     }
129
130     if( p_aout->i_format != AOUT_FMT_AC3 )
131     {
132         strcpy( psz_alsadev, "default" );
133     }
134     else
135     {
136         unsigned char s[4];
137         s[0] = IEC958_AES0_CON_EMPHASIS_NONE | IEC958_AES0_NONAUDIO;
138         s[1] = IEC958_AES1_CON_ORIGINAL | IEC958_AES1_CON_PCM_CODER;
139         s[2] = 0;
140         s[3] = IEC958_AES3_CON_FS_48000;
141         sprintf( psz_alsadev, "iec958:AES0=0x%x,AES1=0x%x,AES2=0x%x,AES3=0x%x",
142                  s[0], s[1], s[2], s[3] );
143     }
144
145     /* Open device */
146     i_ret = snd_pcm_open( &(p_aout->p_sys->p_alsa_handle),
147                           psz_alsadev, SND_PCM_STREAM_PLAYBACK, 0);
148     if( i_ret != 0 )
149     {
150         intf_ErrMsg( "aout error: could not open ALSA device (%s)",
151                      snd_strerror( i_ret ) );
152         return -1;
153     }
154
155     return 0;
156 }
157
158 /*****************************************************************************
159  * aout_SetFormat : sets the alsa output format
160  *****************************************************************************
161  * This function prepares the device, sets the rate, format, the mode
162  * ( "play as soon as you have data" ), and buffer information.
163  *****************************************************************************/
164 static int aout_SetFormat( aout_thread_t *p_aout )
165 {
166
167     int i_rv;
168     int i_format;
169
170     snd_pcm_hw_params_t *p_hw;
171     snd_pcm_sw_params_t *p_sw;
172
173     snd_pcm_hw_params_alloca(&p_hw);
174     snd_pcm_sw_params_alloca(&p_sw);
175
176     /* default value for snd_pcm_hw_params_set_buffer_time_near() */
177     p_aout->p_sys->buffer_time = AOUT_BUFFER_DURATION;
178
179     switch (p_aout->i_format)
180     {
181         case AOUT_FMT_S16_LE:
182             i_format = SND_PCM_FORMAT_S16_LE;
183             p_aout->p_sys->bytes_per_sample = 2;
184             break;
185
186         case AOUT_FMT_AC3:
187             i_format = SND_PCM_FORMAT_S16_LE;
188             p_aout->p_sys->bytes_per_sample = 2;
189             /* buffer_time must be 500000 to avoid a system crash */
190             p_aout->p_sys->buffer_time = 500000;
191             break;
192
193         default:
194             i_format = SND_PCM_FORMAT_S16_BE;
195             p_aout->p_sys->bytes_per_sample = 2;
196             break;
197     }
198
199     p_aout->p_sys->samples_per_frame = p_aout->i_channels;
200     p_aout->p_sys->bytes_per_frame = p_aout->p_sys->samples_per_frame *
201                                      p_aout->p_sys->bytes_per_sample;
202
203     i_rv = snd_pcm_hw_params_any( p_aout->p_sys->p_alsa_handle, p_hw );
204     if( i_rv < 0 )
205     {
206         intf_ErrMsg( "aout error: unable to retrieve initial parameters" );
207         return( -1 );
208     }
209
210     i_rv = snd_pcm_hw_params_set_access( p_aout->p_sys->p_alsa_handle, p_hw,
211                                          SND_PCM_ACCESS_RW_INTERLEAVED );
212     if( i_rv < 0 )
213     {
214         intf_ErrMsg( "aout error: unable to set interleaved stream format" );
215         return( -1 );
216     }
217
218     i_rv = snd_pcm_hw_params_set_format( p_aout->p_sys->p_alsa_handle,
219                                          p_hw, i_format );
220     if( i_rv < 0 )
221     {
222         intf_ErrMsg( "aout error: unable to set stream sample size and word"
223                      " order" );
224         return( -1 );
225     }
226
227     i_rv = snd_pcm_hw_params_set_channels( p_aout->p_sys->p_alsa_handle, p_hw,
228                                            p_aout->i_channels );
229     if( i_rv < 0 )
230     {
231         intf_ErrMsg( "aout error: unable to set number of output channels" );
232         return( -1 );
233     }
234
235     i_rv = snd_pcm_hw_params_set_rate_near( p_aout->p_sys->p_alsa_handle, p_hw,
236                                             p_aout->i_rate, 0 );
237     if( i_rv < 0 )
238     {
239         intf_ErrMsg( "aout error: unable to set sample rate" );
240         return( -1 );
241     }
242     p_aout->p_sys->rate = i_rv;
243
244     i_rv = snd_pcm_hw_params_set_buffer_time_near( p_aout->p_sys->p_alsa_handle,
245                                                    p_hw,
246                                                    p_aout->p_sys->buffer_time,
247                                                    0 );
248     if( i_rv < 0 )
249     {
250         intf_ErrMsg( "aout error: unable to set buffer time" );
251         return( -1 );
252     }
253     p_aout->p_sys->buffer_time = i_rv;
254
255     i_rv = snd_pcm_hw_params_set_period_time_near( p_aout->p_sys->p_alsa_handle,
256          p_hw, p_aout->p_sys->buffer_time / p_aout->p_sys->bytes_per_frame, 0 );
257     if( i_rv < 0 )
258     {
259         intf_ErrMsg( "aout error: unable to set period time" );
260         return( -1 );
261     }
262     p_aout->p_sys->period_time = i_rv;
263
264     i_rv = snd_pcm_hw_params(p_aout->p_sys->p_alsa_handle, p_hw);
265     if (i_rv < 0)
266     {
267         intf_ErrMsg( "aout error: unable to set hardware configuration" );
268         return( -1 );
269     }
270
271     p_aout->p_sys->chunk_size = snd_pcm_hw_params_get_period_size( p_hw, 0 );
272     p_aout->p_sys->buffer_size = snd_pcm_hw_params_get_buffer_size( p_hw );
273
274     snd_pcm_sw_params_current( p_aout->p_sys->p_alsa_handle, p_sw );
275     i_rv = snd_pcm_sw_params_set_sleep_min( p_aout->p_sys->p_alsa_handle, p_sw,
276                                             0 );
277
278     i_rv = snd_pcm_sw_params_set_avail_min( p_aout->p_sys->p_alsa_handle, p_sw,
279                                             p_aout->p_sys->chunk_size );
280
281     /* Worked with the CVS version but not with 0.9beta3
282     i_rv = snd_pcm_sw_params_set_start_threshold( p_aout->p_sys->p_alsa_handle,
283                                             p_sw, p_aout->p_sys->buffer_size );
284
285     i_rv = snd_pcm_sw_params_set_stop_threshold( p_aout->p_sys->p_alsa_handle,
286                                              p_sw, p_aout->p_sys->buffer_size);
287     */
288     i_rv = snd_pcm_sw_params( p_aout->p_sys->p_alsa_handle, p_sw );
289     if( i_rv < 0 )
290     {
291         intf_ErrMsg( "aout error: unable to set software configuration" );
292         return( -1 );
293     }
294
295     return( 0 );
296 }
297
298 /*****************************************************************************
299  * aout_HandleXrun : reprepare the output
300  *****************************************************************************
301  * When buffer gets empty, the driver goes in "Xrun" state, where it needs
302  * to be reprepared before playing again
303  *****************************************************************************/
304 static void aout_HandleXrun(aout_thread_t *p_aout)
305 {
306     int i_rv;
307
308     intf_ErrMsg( "aout error: resetting output after buffer underrun" );
309
310 //    i_rv = snd_pcm_reset( p_aout->p_sys->p_alsa_handle );
311     i_rv = snd_pcm_prepare( p_aout->p_sys->p_alsa_handle );
312     if( i_rv < 0 )
313     {
314         intf_ErrMsg( "aout error: unable to recover from buffer underrun (%s)",
315                      snd_strerror( i_rv ) );
316     }
317 }
318
319
320 /*****************************************************************************
321  * aout_BufInfo: buffer status query
322  *****************************************************************************
323  * This function returns the number of used byte in the queue.
324  * It also deals with errors : indeed if the device comes to run out
325  * of data to play, it switches to the "underrun" status. It has to
326  * be flushed and re-prepared
327  *****************************************************************************/
328 static int aout_GetBufInfo( aout_thread_t *p_aout, int i_buffer_limit )
329 {
330     snd_pcm_status_t *p_status;
331     int i_alsa_get_status_returns;
332
333     snd_pcm_status_alloca( &p_status );
334
335     i_alsa_get_status_returns = snd_pcm_status( p_aout->p_sys->p_alsa_handle,
336                                                 p_status );
337
338     if( i_alsa_get_status_returns )
339     {
340         intf_ErrMsg ( "aout error: failed getting alsa buffer info (%s)",
341                       snd_strerror ( i_alsa_get_status_returns ) );
342         return ( -1 );
343     }
344
345     switch( snd_pcm_status_get_state( p_status ) )
346     {
347         case SND_PCM_STATE_XRUN :
348             aout_HandleXrun( p_aout );
349             break;
350
351         case SND_PCM_STATE_OPEN:
352         case SND_PCM_STATE_PREPARED:
353         case SND_PCM_STATE_RUNNING:
354             break;
355
356         default:
357             intf_ErrMsg( "aout error: unhandled condition %i",
358                          snd_pcm_status_get_state( p_status ) );
359             break;
360     }
361
362     return( snd_pcm_status_get_avail(p_status) *
363             p_aout->p_sys->bytes_per_frame );
364 }
365
366 /*****************************************************************************
367  * aout_Play : plays a sample
368  *****************************************************************************
369  * Plays a sample using the snd_pcm_writei function from the alsa API
370  *****************************************************************************/
371 static void aout_Play( aout_thread_t *p_aout, byte_t *buffer, int i_size )
372 {
373     snd_pcm_uframes_t tot_frames;
374     snd_pcm_uframes_t frames_left;
375     snd_pcm_uframes_t rv;
376
377     tot_frames = i_size / p_aout->p_sys->bytes_per_frame;
378     frames_left = tot_frames;
379
380     while( frames_left > 0 )
381     {
382         rv = snd_pcm_writei( p_aout->p_sys->p_alsa_handle, buffer +
383                              (tot_frames - frames_left) *
384                              p_aout->p_sys->bytes_per_frame, frames_left );
385
386         if( (signed int) rv < 0 )
387         {
388             intf_ErrMsg( "aout error: failed writing to output (%s)",
389                          snd_strerror( rv ) );
390             return;
391         }
392
393         frames_left -= rv;
394     }
395 }
396
397 /*****************************************************************************
398  * aout_Close : close the Alsa device
399  *****************************************************************************/
400 static void aout_Close( aout_thread_t *p_aout )
401 {
402     int i_close_returns;
403
404     i_close_returns = snd_pcm_close( p_aout->p_sys->p_alsa_handle );
405
406     if( i_close_returns )
407     {
408         intf_ErrMsg( "aout error: failed closing ALSA device (%s)",
409                      i_close_returns, snd_strerror( i_close_returns ) );
410     }
411
412     free( p_aout->p_sys );
413 }
414