root/modules/audio_filter/channel_mixer/dolby.c

Revision b674dab81ccd2a089896b26a2afc258118e6a990, 8.2 kB (checked in by Rémi Duraffort <ivoire@videolan.org>, 5 months ago)

Remove unneeded msg_Error about memory failure.
Fix a double malloc.
Fix potential segfault.

  • Property mode set to 100644
Line 
1 /*****************************************************************************
2  * dolby.c : simple decoder for dolby surround encoded streams
3  *****************************************************************************
4  * Copyright (C) 2005, 2006 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Boris Dorès <babal@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
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33 #include <vlc_plugin.h>
34 #include <vlc_aout.h>
35
36 /*****************************************************************************
37  * Local prototypes
38  *****************************************************************************/
39 static int  Create    ( vlc_object_t * );
40 static void Destroy   ( vlc_object_t * );
41
42 static void DoWork    ( aout_instance_t *, aout_filter_t *, aout_buffer_t *,
43                         aout_buffer_t * );
44
45 /*****************************************************************************
46  * Module descriptor
47  *****************************************************************************/
48 vlc_module_begin();
49     set_description( N_("Simple decoder for Dolby Surround encoded streams") );
50     set_shortname( N_("Dolby Surround decoder") );
51     set_category( CAT_INPUT );
52     set_subcategory( SUBCAT_INPUT_ACODEC );
53     set_capability( "audio filter", 5 );
54     set_callbacks( Create, Destroy );
55 vlc_module_end();
56
57 /*****************************************************************************
58  * Internal data structures
59  *****************************************************************************/
60 struct aout_filter_sys_t
61 {
62     int i_left;
63     int i_center;
64     int i_right;
65     int i_rear_left;
66     int i_rear_center;
67     int i_rear_right;
68 };
69
70 /* our internal channel order (WG-4 order) */
71 static const uint32_t pi_channels[] =
72 { AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT, AOUT_CHAN_MIDDLELEFT, AOUT_CHAN_MIDDLERIGHT,
73   AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, AOUT_CHAN_REARCENTER,
74   AOUT_CHAN_CENTER, AOUT_CHAN_LFE, 0 };
75
76 /*****************************************************************************
77  * Create: allocate headphone downmixer
78  *****************************************************************************/
79 static int Create( vlc_object_t *p_this )
80 {
81     int i = 0;
82     int i_offset = 0;
83     aout_filter_t * p_filter = (aout_filter_t *)p_this;
84
85     /* Validate audio filter format */
86     if ( p_filter->input.i_physical_channels != (AOUT_CHAN_LEFT|AOUT_CHAN_RIGHT)
87        || ! ( p_filter->input.i_original_channels & AOUT_CHAN_DOLBYSTEREO )
88        || aout_FormatNbChannels( &p_filter->output ) <= 2
89        || ( p_filter->input.i_original_channels & ~AOUT_CHAN_DOLBYSTEREO )
90           != ( p_filter->output.i_original_channels & ~AOUT_CHAN_DOLBYSTEREO ) )
91     {
92         return VLC_EGENERIC;
93     }
94
95     if ( p_filter->input.i_rate != p_filter->output.i_rate )
96     {
97         return VLC_EGENERIC;
98     }
99
100     if ( p_filter->input.i_format != VLC_FOURCC('f','l','3','2')
101           || p_filter->output.i_format != VLC_FOURCC('f','l','3','2') )
102     {
103         return VLC_EGENERIC;
104     }
105
106     /* Allocate the memory needed to store the module's structure */
107     p_filter->p_sys = malloc( sizeof(struct aout_filter_sys_t) );
108     if ( p_filter->p_sys == NULL )
109         return VLC_ENOMEM;
110     p_filter->p_sys->i_left = -1;
111     p_filter->p_sys->i_center = -1;
112     p_filter->p_sys->i_right = -1;
113     p_filter->p_sys->i_rear_left = -1;
114     p_filter->p_sys->i_rear_center = -1;
115     p_filter->p_sys->i_rear_right = -1;
116
117     while ( pi_channels[i] )
118     {
119         if ( p_filter->output.i_physical_channels & pi_channels[i] )
120         {
121             switch ( pi_channels[i] )
122             {
123                 case AOUT_CHAN_LEFT:
124                     p_filter->p_sys->i_left = i_offset;
125                     break;
126                 case AOUT_CHAN_CENTER:
127                     p_filter->p_sys->i_center = i_offset;
128                     break;
129                 case AOUT_CHAN_RIGHT:
130                     p_filter->p_sys->i_right = i_offset;
131                     break;
132                 case AOUT_CHAN_REARLEFT:
133                     p_filter->p_sys->i_rear_left = i_offset;
134                     break;
135                 case AOUT_CHAN_REARCENTER:
136                     p_filter->p_sys->i_rear_center = i_offset;
137                     break;
138                 case AOUT_CHAN_REARRIGHT:
139                     p_filter->p_sys->i_rear_right = i_offset;
140                     break;
141             }
142             ++i_offset;
143         }
144         ++i;
145     }
146
147     p_filter->pf_do_work = DoWork;
148     p_filter->b_in_place = 0;
149
150     return VLC_SUCCESS;
151 }
152
153 /*****************************************************************************
154  * Destroy: deallocate resources associated with headphone downmixer
155  *****************************************************************************/
156 static void Destroy( vlc_object_t *p_this )
157 {
158     aout_filter_t * p_filter = (aout_filter_t *)p_this;
159
160     if ( p_filter->p_sys != NULL )
161     {
162         free ( p_filter->p_sys );
163         p_filter->p_sys = NULL;
164     }
165 }
166
167 /*****************************************************************************
168  * DoWork: convert a buffer
169  *****************************************************************************/
170 static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter,
171                     aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf )
172 {
173     VLC_UNUSED(p_aout);
174     float * p_in = (float*) p_in_buf->p_buffer;
175     float * p_out = (float*) p_out_buf->p_buffer;
176     size_t i_nb_samples = p_in_buf->i_nb_samples;
177     size_t i_nb_channels = aout_FormatNbChannels( &p_filter->output );
178
179     p_out_buf->i_nb_samples = i_nb_samples;
180     p_out_buf->i_nb_bytes = sizeof(float) * i_nb_samples
181                             * aout_FormatNbChannels( &p_filter->output );
182     memset ( p_out , 0 , p_out_buf->i_nb_bytes );
183
184     if ( p_filter->p_sys != NULL )
185     {
186         struct aout_filter_sys_t * p_sys = p_filter->p_sys;
187         size_t i_nb_rear = 0;
188         size_t i;
189
190         if ( p_sys->i_rear_left >= 0 )
191         {
192             ++i_nb_rear;
193         }
194         if ( p_sys->i_rear_center >= 0 )
195         {
196             ++i_nb_rear;
197         }
198         if ( p_sys->i_rear_right >= 0 )
199         {
200             ++i_nb_rear;
201         }
202
203         for ( i = 0; i < i_nb_samples; ++i )
204         {
205             float f_left = p_in[ i * 2 ];
206             float f_right = p_in[ i * 2 + 1 ];
207             float f_rear = ( f_left - f_right ) / i_nb_rear;
208
209             if ( p_sys->i_center >= 0 )
210             {
211                 float f_center = f_left + f_right;
212                 f_left -= f_center / 2;
213                 f_right -= f_center / 2;
214
215                 p_out[ i * i_nb_channels + p_sys->i_center ] = f_center;
216             }
217
218             if ( p_sys->i_left >= 0 )
219             {
220                 p_out[ i * i_nb_channels + p_sys->i_left ] = f_left;
221             }
222             if ( p_sys->i_right >= 0 )
223             {
224                 p_out[ i * i_nb_channels + p_sys->i_right ] = f_right;
225             }
226             if ( p_sys->i_rear_left >= 0 )
227             {
228                 p_out[ i * i_nb_channels + p_sys->i_rear_left ] = f_rear;
229             }
230             if ( p_sys->i_rear_center >= 0 )
231             {
232                 p_out[ i * i_nb_channels + p_sys->i_rear_center ] = f_rear;
233             }
234             if ( p_sys->i_rear_right >= 0 )
235             {
236                 p_out[ i * i_nb_channels + p_sys->i_rear_right ] = f_rear;
237             }
238         }
239     }
240 }
Note: See TracBrowser for help on using the browser.