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