All: preliminary support for audio while playing faster/slower (1/4 -> 4).
[vlc.git] / src / audio_output / filters.c
1 /*****************************************************************************
2  * filters.c : audio output filters management
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 #include <stdlib.h>                            /* calloc(), malloc(), free() */
28 #include <string.h>
29
30 #include <vlc/vlc.h>
31 #include <vlc_interface.h>
32
33 #ifdef HAVE_ALLOCA_H
34 #   include <alloca.h>
35 #endif
36
37 #include <vlc_aout.h>
38 #include "aout_internal.h"
39
40 /*****************************************************************************
41  * FindFilter: find an audio filter for a specific transformation
42  *****************************************************************************/
43 static aout_filter_t * FindFilter( aout_instance_t * p_aout,
44                              const audio_sample_format_t * p_input_format,
45                              const audio_sample_format_t * p_output_format )
46 {
47     aout_filter_t * p_filter = vlc_object_create( p_aout,
48                                                   sizeof(aout_filter_t) );
49
50     if ( p_filter == NULL ) return NULL;
51     vlc_object_attach( p_filter, p_aout );
52
53     memcpy( &p_filter->input, p_input_format, sizeof(audio_sample_format_t) );
54     memcpy( &p_filter->output, p_output_format,
55             sizeof(audio_sample_format_t) );
56     p_filter->p_module = module_Need( p_filter, "audio filter", NULL, 0 );
57     if ( p_filter->p_module == NULL )
58     {
59         vlc_object_detach( p_filter );
60         vlc_object_destroy( p_filter );
61         return NULL;
62     }
63
64     p_filter->b_continuity = VLC_FALSE;
65
66     return p_filter;
67 }
68
69 /*****************************************************************************
70  * SplitConversion: split a conversion in two parts
71  *****************************************************************************
72  * Returns the number of conversions required by the first part - 0 if only
73  * one conversion was asked.
74  * Beware : p_output_format can be modified during this function if the
75  * developer passed SplitConversion( toto, titi, titi, ... ). That is legal.
76  * SplitConversion( toto, titi, toto, ... ) isn't.
77  *****************************************************************************/
78 static int SplitConversion( const audio_sample_format_t * p_input_format,
79                             const audio_sample_format_t * p_output_format,
80                             audio_sample_format_t * p_middle_format )
81 {
82     vlc_bool_t b_format =
83              (p_input_format->i_format != p_output_format->i_format);
84     vlc_bool_t b_rate = (p_input_format->i_rate != p_output_format->i_rate);
85     vlc_bool_t b_channels =
86         (p_input_format->i_physical_channels
87           != p_output_format->i_physical_channels)
88      || (p_input_format->i_original_channels
89           != p_output_format->i_original_channels);
90     int i_nb_conversions = b_format + b_rate + b_channels;
91
92     if ( i_nb_conversions <= 1 ) return 0;
93
94     memcpy( p_middle_format, p_output_format, sizeof(audio_sample_format_t) );
95
96     if ( i_nb_conversions == 2 )
97     {
98         if ( !b_format || !b_channels )
99         {
100             p_middle_format->i_rate = p_input_format->i_rate;
101             aout_FormatPrepare( p_middle_format );
102             return 1;
103         }
104
105         /* !b_rate */
106         p_middle_format->i_physical_channels
107              = p_input_format->i_physical_channels;
108         p_middle_format->i_original_channels
109              = p_input_format->i_original_channels;
110         aout_FormatPrepare( p_middle_format );
111         return 1;
112     }
113
114     /* i_nb_conversion == 3 */
115     p_middle_format->i_rate = p_input_format->i_rate;
116     aout_FormatPrepare( p_middle_format );
117     return 2;
118 }
119
120 static void ReleaseFilter( aout_filter_t * p_filter )
121 {
122     module_Unneed( p_filter, p_filter->p_module );
123     vlc_object_detach( p_filter );
124     vlc_object_destroy( p_filter );
125 }
126
127 /*****************************************************************************
128  * aout_FiltersCreatePipeline: create a filters pipeline to transform a sample
129  *                             format to another
130  *****************************************************************************
131  * pi_nb_filters must be initialized before calling this function
132  *****************************************************************************/
133 int aout_FiltersCreatePipeline( aout_instance_t * p_aout,
134                                 aout_filter_t ** pp_filters_start,
135                                 int * pi_nb_filters,
136                                 const audio_sample_format_t * p_input_format,
137                                 const audio_sample_format_t * p_output_format )
138 {
139     aout_filter_t** pp_filters = pp_filters_start + *pi_nb_filters;
140     audio_sample_format_t temp_format;
141     int i_nb_conversions;
142
143     if ( AOUT_FMTS_IDENTICAL( p_input_format, p_output_format ) )
144     {
145         msg_Dbg( p_aout, "no need for any filter" );
146         return 0;
147     }
148
149     aout_FormatsPrint( p_aout, "filter(s)", p_input_format, p_output_format );
150
151     if( *pi_nb_filters + 1 > AOUT_MAX_FILTERS )
152     {
153         msg_Err( p_aout, "max filter reached (%d)", AOUT_MAX_FILTERS );
154         intf_UserFatal( p_aout, VLC_FALSE, _("Audio filtering failed"), 
155                         _("The maximum number of filters (%d) was reached."),
156                         AOUT_MAX_FILTERS );
157         return -1;
158     }
159
160     /* Try to find a filter to do the whole conversion. */
161     pp_filters[0] = FindFilter( p_aout, p_input_format, p_output_format );
162     if ( pp_filters[0] != NULL )
163     {
164         msg_Dbg( p_aout, "found a filter for the whole conversion" );
165         ++*pi_nb_filters;
166         return 0;
167     }
168
169     /* We'll have to split the conversion. We always do the downmixing
170      * before the resampling, because the audio decoder can probably do it
171      * for us. */
172     i_nb_conversions = SplitConversion( p_input_format,
173                                         p_output_format, &temp_format );
174     if ( !i_nb_conversions )
175     {
176         /* There was only one conversion to do, and we already failed. */
177         msg_Err( p_aout, "couldn't find a filter for the conversion" );
178         return -1;
179     }
180
181     pp_filters[0] = FindFilter( p_aout, p_input_format, &temp_format );
182     if ( pp_filters[0] == NULL && i_nb_conversions == 2 )
183     {
184         /* Try with only one conversion. */
185         SplitConversion( p_input_format, &temp_format, &temp_format );
186         pp_filters[0] = FindFilter( p_aout, p_input_format, &temp_format );
187     }
188     if ( pp_filters[0] == NULL )
189     {
190         msg_Err( p_aout,
191               "couldn't find a filter for the first part of the conversion" );
192         return -1;
193     }
194
195     /* We have the first stage of the conversion. Find a filter for
196      * the rest. */
197     if( *pi_nb_filters + 2 > AOUT_MAX_FILTERS )
198     {
199         ReleaseFilter( pp_filters[0] );
200         msg_Err( p_aout, "max filter reached (%d)", AOUT_MAX_FILTERS );
201         intf_UserFatal( p_aout, VLC_FALSE, _("Audio filtering failed"), 
202                         _("The maximum number of filters (%d) was reached."),
203                         AOUT_MAX_FILTERS );
204         return -1;
205     }
206     pp_filters[1] = FindFilter( p_aout, &pp_filters[0]->output,
207                                 p_output_format );
208     if ( pp_filters[1] == NULL )
209     {
210         /* Try to split the conversion. */
211         i_nb_conversions = SplitConversion( &pp_filters[0]->output,
212                                            p_output_format, &temp_format );
213         if ( !i_nb_conversions )
214         {
215             ReleaseFilter( pp_filters[0] );
216             msg_Err( p_aout,
217               "couldn't find a filter for the second part of the conversion" );
218             return -1;
219         }
220         if( *pi_nb_filters + 3 > AOUT_MAX_FILTERS )
221         {
222             ReleaseFilter( pp_filters[0] );
223             msg_Err( p_aout, "max filter reached (%d)", AOUT_MAX_FILTERS );
224             intf_UserFatal( p_aout, VLC_FALSE, _("Audio filtering failed"), 
225                             _("The maximum number of filters (%d) was reached."),
226                             AOUT_MAX_FILTERS );
227             return -1;
228         }
229         pp_filters[1] = FindFilter( p_aout, &pp_filters[0]->output,
230                                     &temp_format );
231         pp_filters[2] = FindFilter( p_aout, &temp_format,
232                                     p_output_format );
233
234         if ( pp_filters[1] == NULL || pp_filters[2] == NULL )
235         {
236             ReleaseFilter( pp_filters[0] );
237             if ( pp_filters[1] != NULL )
238             {
239                 ReleaseFilter( pp_filters[1] );
240             }
241             if ( pp_filters[2] != NULL )
242             {
243                 ReleaseFilter( pp_filters[2] );
244             }
245             msg_Err( p_aout,
246                "couldn't find filters for the second part of the conversion" );
247             return -1;
248         }
249         *pi_nb_filters += 3;
250         msg_Dbg( p_aout, "found 3 filters for the whole conversion" );
251     }
252     else
253     {
254         *pi_nb_filters += 2;
255         msg_Dbg( p_aout, "found 2 filters for the whole conversion" );
256     }
257
258     return 0;
259 }
260
261 /*****************************************************************************
262  * aout_FiltersDestroyPipeline: deallocate a filters pipeline
263  *****************************************************************************/
264 void aout_FiltersDestroyPipeline( aout_instance_t * p_aout,
265                                   aout_filter_t ** pp_filters,
266                                   int i_nb_filters )
267 {
268     int i;
269     (void)p_aout;
270
271     for ( i = 0; i < i_nb_filters; i++ )
272     {
273         module_Unneed( pp_filters[i], pp_filters[i]->p_module );
274         vlc_object_detach( pp_filters[i] );
275         vlc_object_destroy( pp_filters[i] );
276     }
277 }
278
279 /*****************************************************************************
280  * aout_FiltersHintBuffers: fill in aout_alloc_t structures to optimize
281  *                          buffer allocations
282  *****************************************************************************/
283 void aout_FiltersHintBuffers( aout_instance_t * p_aout,
284                               aout_filter_t ** pp_filters,
285                               int i_nb_filters, aout_alloc_t * p_first_alloc )
286 {
287     int i;
288
289     (void)p_aout; /* unused */
290
291     for ( i = i_nb_filters - 1; i >= 0; i-- )
292     {
293         aout_filter_t * p_filter = pp_filters[i];
294
295         int i_output_size = p_filter->output.i_bytes_per_frame
296                              * p_filter->output.i_rate * AOUT_MAX_INPUT_RATE
297                              / p_filter->output.i_frame_length;
298         int i_input_size = p_filter->input.i_bytes_per_frame
299                              * p_filter->input.i_rate * AOUT_MAX_INPUT_RATE
300                              / p_filter->input.i_frame_length;
301
302         p_first_alloc->i_bytes_per_sec = __MAX( p_first_alloc->i_bytes_per_sec,
303                                                 i_output_size );
304
305         if ( p_filter->b_in_place )
306         {
307             p_first_alloc->i_bytes_per_sec = __MAX(
308                                          p_first_alloc->i_bytes_per_sec,
309                                          i_input_size );
310             p_filter->output_alloc.i_alloc_type = AOUT_ALLOC_NONE;
311         }
312         else
313         {
314             /* We're gonna need a buffer allocation. */
315             memcpy( &p_filter->output_alloc, p_first_alloc,
316                     sizeof(aout_alloc_t) );
317             p_first_alloc->i_alloc_type = AOUT_ALLOC_STACK;
318             p_first_alloc->i_bytes_per_sec = i_input_size;
319         }
320     }
321 }
322
323 /*****************************************************************************
324  * aout_FiltersPlay: play a buffer
325  *****************************************************************************/
326 void aout_FiltersPlay( aout_instance_t * p_aout,
327                        aout_filter_t ** pp_filters,
328                        int i_nb_filters, aout_buffer_t ** pp_input_buffer )
329 {
330     int i;
331
332     for ( i = 0; i < i_nb_filters; i++ )
333     {
334         aout_filter_t * p_filter = pp_filters[i];
335         aout_buffer_t * p_output_buffer;
336
337         /* Resamplers can produce slightly more samples than (i_in_nb *
338          * p_filter->output.i_rate / p_filter->input.i_rate) so we need
339          * slightly bigger buffers. */
340         aout_BufferAlloc( &p_filter->output_alloc,
341             ((mtime_t)(*pp_input_buffer)->i_nb_samples + 2)
342             * 1000000 / p_filter->input.i_rate,
343             *pp_input_buffer, p_output_buffer );
344         if ( p_output_buffer == NULL )
345         {
346             msg_Err( p_aout, "out of memory" );
347             return;
348         }
349         /* Please note that p_output_buffer->i_nb_samples & i_nb_bytes
350          * shall be set by the filter plug-in. */
351
352         p_filter->pf_do_work( p_aout, p_filter, *pp_input_buffer,
353                               p_output_buffer );
354
355         if ( !p_filter->b_in_place )
356         {
357             aout_BufferFree( *pp_input_buffer );
358             *pp_input_buffer = p_output_buffer;
359         }
360
361         if( p_output_buffer->i_nb_samples <= 0 )
362             break;
363     }
364 }
365