4ebfcf0675ac0ed5532f85bcb2dd41abfc301666
[vlc.git] / src / audio_output / dec.c
1 /*****************************************************************************
2  * dec.c : audio output API towards decoders
3  *****************************************************************************
4  * Copyright (C) 2002-2007 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <vlc_common.h>
32
33 #ifdef HAVE_ALLOCA_H
34 #   include <alloca.h>
35 #endif
36
37 #include <vlc_aout.h>
38 #include <vlc_input.h>
39
40 #include "aout_internal.h"
41
42 /*****************************************************************************
43  * aout_DecNew : create a decoder
44  *****************************************************************************/
45 static aout_input_t * DecNew( aout_instance_t * p_aout,
46                               audio_sample_format_t *p_format,
47                               const audio_replay_gain_t *p_replay_gain,
48                               const aout_request_vout_t *p_request_vout )
49 {
50     aout_input_t * p_input;
51
52     /* Sanitize audio format */
53     if( p_format->i_channels > 32 )
54     {
55         msg_Err( p_aout, "too many audio channels (%u)",
56                  p_format->i_channels );
57         return NULL;
58     }
59     if( p_format->i_channels <= 0 )
60     {
61         msg_Err( p_aout, "no audio channels" );
62         return NULL;
63     }
64     if( p_format->i_channels != aout_FormatNbChannels( p_format ) )
65     {
66         msg_Err( p_aout, "incompatible audio channels count with layout mask" );
67         return NULL;
68     }
69
70     if( p_format->i_rate > 192000 )
71     {
72         msg_Err( p_aout, "excessive audio sample frequency (%u)",
73                  p_format->i_rate );
74         return NULL;
75     }
76     if( p_format->i_rate < 4000 )
77     {
78         msg_Err( p_aout, "too low audio sample frequency (%u)",
79                  p_format->i_rate );
80         return NULL;
81     }
82
83     /* We can only be called by the decoder, so no need to lock
84      * p_input->lock. */
85     aout_lock_mixer( p_aout );
86
87     if ( p_aout->i_nb_inputs >= AOUT_MAX_INPUTS )
88     {
89         msg_Err( p_aout, "too many inputs already (%d)", p_aout->i_nb_inputs );
90         goto error;
91     }
92
93     p_input = calloc( 1, sizeof(aout_input_t));
94     if( !p_input )
95         goto error;
96
97     vlc_mutex_init( &p_input->lock );
98
99     p_input->b_changed = false;
100     p_input->b_error = true;
101     p_input->b_paused = false;
102     p_input->i_pause_date = 0;
103
104     aout_FormatPrepare( p_format );
105
106     memcpy( &p_input->input, p_format,
107             sizeof(audio_sample_format_t) );
108     if( p_replay_gain )
109         p_input->replay_gain = *p_replay_gain;
110
111     aout_lock_input_fifos( p_aout );
112     p_aout->pp_inputs[p_aout->i_nb_inputs] = p_input;
113     p_aout->i_nb_inputs++;
114
115     if ( !p_aout->p_mixer )
116     {
117         int i;
118
119         var_Destroy( p_aout, "audio-device" );
120         var_Destroy( p_aout, "audio-channels" );
121
122         /* Recreate the output using the new format. */
123         if ( aout_OutputNew( p_aout, p_format ) < 0 )
124         {
125             for ( i = 0; i < p_aout->i_nb_inputs - 1; i++ )
126             {
127                 aout_lock_input( p_aout, p_aout->pp_inputs[i] );
128                 aout_InputDelete( p_aout, p_aout->pp_inputs[i] );
129                 aout_unlock_input( p_aout, p_aout->pp_inputs[i] );
130             }
131             aout_unlock_input_fifos( p_aout );
132             aout_unlock_mixer( p_aout );
133             return p_input;
134         }
135
136         /* Create other input streams. */
137         for ( i = 0; i < p_aout->i_nb_inputs - 1; i++ )
138         {
139             aout_input_t *p_input = p_aout->pp_inputs[i];
140
141             aout_lock_input( p_aout, p_input );
142             aout_InputDelete( p_aout, p_input );
143             aout_InputNew( p_aout, p_input, &p_input->request_vout );
144             aout_unlock_input( p_aout, p_input );
145         }
146     }
147     else
148     {
149         aout_MixerDelete( p_aout );
150     }
151
152     if ( aout_MixerNew( p_aout ) == -1 )
153     {
154         aout_OutputDelete( p_aout );
155         aout_unlock_input_fifos( p_aout );
156         goto error;
157     }
158
159     aout_InputNew( p_aout, p_input, p_request_vout );
160     aout_unlock_input_fifos( p_aout );
161
162     aout_unlock_mixer( p_aout );
163
164     return p_input;
165
166 error:
167     aout_unlock_mixer( p_aout );
168     return NULL;
169 }
170
171 aout_input_t * __aout_DecNew( vlc_object_t * p_this,
172                               aout_instance_t ** pp_aout,
173                               audio_sample_format_t * p_format,
174                               const audio_replay_gain_t *p_replay_gain,
175                               const aout_request_vout_t *p_request_video )
176 {
177     aout_instance_t *p_aout = *pp_aout;
178     if ( p_aout == NULL )
179     {
180         msg_Dbg( p_this, "no aout present, spawning one" );
181         p_aout = aout_New( p_this );
182
183         /* Everything failed, I'm a loser, I just wanna die */
184         if( p_aout == NULL )
185             return NULL;
186
187         vlc_object_attach( p_aout, p_this );
188         *pp_aout = p_aout;
189     }
190
191     return DecNew( p_aout, p_format, p_replay_gain, p_request_video );
192 }
193
194 /*****************************************************************************
195  * aout_DecDelete : delete a decoder
196  *****************************************************************************/
197 int aout_DecDelete( aout_instance_t * p_aout, aout_input_t * p_input )
198 {
199     int i_input;
200
201     /* This function can only be called by the decoder itself, so no need
202      * to lock p_input->lock. */
203     aout_lock_mixer( p_aout );
204
205     for ( i_input = 0; i_input < p_aout->i_nb_inputs; i_input++ )
206     {
207         if ( p_aout->pp_inputs[i_input] == p_input )
208         {
209             break;
210         }
211     }
212
213     if ( i_input == p_aout->i_nb_inputs )
214     {
215         msg_Err( p_aout, "cannot find an input to delete" );
216         aout_unlock_mixer( p_aout );
217         return -1;
218     }
219
220     /* Remove the input from the list. */
221     memmove( &p_aout->pp_inputs[i_input], &p_aout->pp_inputs[i_input + 1],
222              (AOUT_MAX_INPUTS - i_input - 1) * sizeof(aout_input_t *) );
223     p_aout->i_nb_inputs--;
224
225     aout_InputDelete( p_aout, p_input );
226
227     vlc_mutex_destroy( &p_input->lock );
228     free( p_input );
229
230     if ( !p_aout->i_nb_inputs )
231     {
232         aout_OutputDelete( p_aout );
233         aout_MixerDelete( p_aout );
234         var_Destroy( p_aout, "audio-device" );
235         var_Destroy( p_aout, "audio-channels" );
236     }
237
238     aout_unlock_mixer( p_aout );
239
240     return 0;
241 }
242
243
244 /*
245  * Buffer management
246  */
247
248 /*****************************************************************************
249  * aout_DecNewBuffer : ask for a new empty buffer
250  *****************************************************************************/
251 aout_buffer_t * aout_DecNewBuffer( aout_input_t * p_input,
252                                    size_t i_nb_samples )
253 {
254     aout_buffer_t * p_buffer;
255     mtime_t duration;
256
257     aout_lock_input( NULL, p_input );
258
259     if ( p_input->b_error )
260     {
261         aout_unlock_input( NULL, p_input );
262         return NULL;
263     }
264
265     duration = (1000000 * (mtime_t)i_nb_samples) / p_input->input.i_rate;
266
267     /* This necessarily allocates in the heap. */
268     aout_BufferAlloc( &p_input->input_alloc, duration, NULL, p_buffer );
269     if( p_buffer != NULL )
270         p_buffer->i_nb_bytes = i_nb_samples * p_input->input.i_bytes_per_frame
271                                   / p_input->input.i_frame_length;
272
273     /* Suppose the decoder doesn't have more than one buffered buffer */
274     p_input->b_changed = false;
275
276     aout_unlock_input( NULL, p_input );
277
278     if( p_buffer == NULL )
279         return NULL;
280
281     p_buffer->i_nb_samples = i_nb_samples;
282     p_buffer->start_date = p_buffer->end_date = 0;
283     return p_buffer;
284 }
285
286 /*****************************************************************************
287  * aout_DecDeleteBuffer : destroy an undecoded buffer
288  *****************************************************************************/
289 void aout_DecDeleteBuffer( aout_instance_t * p_aout, aout_input_t * p_input,
290                            aout_buffer_t * p_buffer )
291 {
292     (void)p_aout; (void)p_input;
293     aout_BufferFree( p_buffer );
294 }
295
296 /*****************************************************************************
297  * aout_DecPlay : filter & mix the decoded buffer
298  *****************************************************************************/
299 int aout_DecPlay( aout_instance_t * p_aout, aout_input_t * p_input,
300                   aout_buffer_t * p_buffer, int i_input_rate )
301 {
302     assert( i_input_rate >= INPUT_RATE_DEFAULT / AOUT_MAX_INPUT_RATE &&
303             i_input_rate <= INPUT_RATE_DEFAULT * AOUT_MAX_INPUT_RATE );
304
305     assert( p_buffer->start_date > 0 );
306
307     p_buffer->end_date = p_buffer->start_date
308                             + (mtime_t)p_buffer->i_nb_samples * 1000000
309                                 / p_input->input.i_rate;
310
311     aout_lock_input( p_aout, p_input );
312
313     if( p_input->b_error )
314     {
315         aout_unlock_input( p_aout, p_input );
316         aout_BufferFree( p_buffer );
317         return -1;
318     }
319
320     if( p_input->b_changed )
321     {
322         /* Maybe the allocation size has changed. Re-allocate a buffer. */
323         aout_buffer_t * p_new_buffer;
324         mtime_t duration = (1000000 * (mtime_t)p_buffer->i_nb_samples)
325                             / p_input->input.i_rate;
326
327         aout_BufferAlloc( &p_input->input_alloc, duration, NULL, p_new_buffer );
328         vlc_memcpy( p_new_buffer->p_buffer, p_buffer->p_buffer,
329                     p_buffer->i_nb_bytes );
330         p_new_buffer->i_nb_samples = p_buffer->i_nb_samples;
331         p_new_buffer->i_nb_bytes = p_buffer->i_nb_bytes;
332         p_new_buffer->start_date = p_buffer->start_date;
333         p_new_buffer->end_date = p_buffer->end_date;
334         aout_BufferFree( p_buffer );
335         p_buffer = p_new_buffer;
336         p_input->b_changed = false;
337     }
338
339     int i_ret = aout_InputPlay( p_aout, p_input, p_buffer, i_input_rate );
340
341     aout_unlock_input( p_aout, p_input );
342
343     if( i_ret == -1 )
344         return -1;
345
346     /* Run the mixer if it is able to run. */
347     aout_lock_mixer( p_aout );
348
349     aout_MixerRun( p_aout );
350
351     aout_unlock_mixer( p_aout );
352
353     return 0;
354 }
355
356 int aout_DecGetResetLost( aout_instance_t *p_aout, aout_input_t *p_input )
357 {
358     aout_lock_input( p_aout, p_input );
359     int i_value = p_input->i_buffer_lost;
360     p_input->i_buffer_lost = 0;
361     aout_unlock_input( p_aout, p_input );
362
363     return i_value;
364 }
365
366 void aout_DecChangePause( aout_instance_t *p_aout, aout_input_t *p_input, bool b_paused, mtime_t i_date )
367 {
368     mtime_t i_duration = 0;
369     aout_lock_input( p_aout, p_input );
370     assert( !p_input->b_paused || !b_paused );
371     if( p_input->b_paused )
372     {
373         i_duration = i_date - p_input->i_pause_date;
374     }
375     p_input->b_paused = b_paused;
376     p_input->i_pause_date = i_date;
377     aout_unlock_input( p_aout, p_input );
378
379     if( i_duration != 0 )
380     {
381         aout_lock_mixer( p_aout );
382         for( aout_buffer_t *p = p_input->mixer.fifo.p_first; p != NULL; p = p->p_next )
383         {
384             p->start_date += i_duration;
385             p->end_date += i_duration;
386         }
387         aout_unlock_mixer( p_aout );
388     }
389 }
390
391 void aout_DecFlush( aout_instance_t *p_aout, aout_input_t *p_input )
392 {
393     aout_lock_input_fifos( p_aout );
394
395     aout_FifoSet( p_aout, &p_input->mixer.fifo, 0 );
396     p_input->mixer.begin = NULL;
397
398     aout_unlock_input_fifos( p_aout );
399 }
400