Uniformize source files encoding
[vlc.git] / modules / audio_filter / channel_mixer / dolby.c
1 /*****************************************************************************
2  * dolby.c : simple decoder for dolby surround encoded streams
3  *****************************************************************************
4  * Copyright (C) 2005 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 #include <stdlib.h>                                      /* malloc(), free() */
28 #include <string.h>
29
30 #include <vlc/vlc.h>
31 #include "audio_output.h"
32 #include "aout_internal.h"
33
34 /*****************************************************************************
35  * Local prototypes
36  *****************************************************************************/
37 static int  Create    ( vlc_object_t * );
38 static void Destroy   ( vlc_object_t * );
39
40 static void DoWork    ( aout_instance_t *, aout_filter_t *, aout_buffer_t *,
41                         aout_buffer_t * );
42
43 /*****************************************************************************
44  * Module descriptor
45  *****************************************************************************/
46 vlc_module_begin();
47     set_description( N_("Simple decoder for dolby surround encoded streams") );
48     set_shortname( _("Dolby surround decoder") );
49     set_category( CAT_INPUT );
50     set_subcategory( SUBCAT_INPUT_ACODEC );
51     set_capability( "audio filter", 5 );
52     set_callbacks( Create, Destroy );
53 vlc_module_end();
54
55 /*****************************************************************************
56  * Internal data structures
57  *****************************************************************************/
58 struct aout_filter_sys_t
59 {
60     int i_left;
61     int i_center;
62     int i_right;
63     int i_rear_left;
64     int i_rear_center;
65     int i_rear_right;
66 };
67
68 /* our internal channel order (WG-4 order) */
69 static const uint32_t pi_channels[] =
70 { AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT, AOUT_CHAN_MIDDLELEFT, AOUT_CHAN_MIDDLERIGHT,
71   AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, AOUT_CHAN_REARCENTER,
72   AOUT_CHAN_CENTER, AOUT_CHAN_LFE, 0 };
73
74 /*****************************************************************************
75  * Create: allocate headphone downmixer
76  *****************************************************************************/
77 static int Create( vlc_object_t *p_this )
78 {
79     int i = 0;
80     int i_offset = 0;
81     aout_filter_t * p_filter = (aout_filter_t *)p_this;
82
83     /* Validate audio filter format */
84     if ( p_filter->input.i_physical_channels != (AOUT_CHAN_LEFT|AOUT_CHAN_RIGHT)
85        || ! ( p_filter->input.i_original_channels & AOUT_CHAN_DOLBYSTEREO )
86        || aout_FormatNbChannels( &p_filter->output ) <= 2
87        || ( p_filter->input.i_original_channels & ~AOUT_CHAN_DOLBYSTEREO )
88           != ( p_filter->output.i_original_channels & ~AOUT_CHAN_DOLBYSTEREO ) )
89     {
90         return VLC_EGENERIC;
91     }
92
93     if ( p_filter->input.i_rate != p_filter->output.i_rate )
94     {
95         return VLC_EGENERIC;
96     }
97
98     if ( p_filter->input.i_format != VLC_FOURCC('f','l','3','2')
99           || p_filter->output.i_format != VLC_FOURCC('f','l','3','2') )
100     {
101         return VLC_EGENERIC;
102     }
103
104     /* Allocate the memory needed to store the module's structure */
105     p_filter->p_sys = malloc( sizeof(struct aout_filter_sys_t) );
106     if ( p_filter->p_sys == NULL )
107     {
108         msg_Err( p_filter, "Out of memory" );
109         return VLC_EGENERIC;
110     }
111     p_filter->p_sys->i_left = -1;
112     p_filter->p_sys->i_center = -1;
113     p_filter->p_sys->i_right = -1;
114     p_filter->p_sys->i_rear_left = -1;
115     p_filter->p_sys->i_rear_center = -1;
116     p_filter->p_sys->i_rear_right = -1;
117
118     while ( pi_channels[i] )
119     {
120         if ( p_filter->output.i_physical_channels & pi_channels[i] )
121         {
122             switch ( pi_channels[i] )
123             {
124                 case AOUT_CHAN_LEFT:
125                     p_filter->p_sys->i_left = i_offset;
126                     break;
127                 case AOUT_CHAN_CENTER:
128                     p_filter->p_sys->i_center = i_offset;
129                     break;
130                 case AOUT_CHAN_RIGHT:
131                     p_filter->p_sys->i_right = i_offset;
132                     break;
133                 case AOUT_CHAN_REARLEFT:
134                     p_filter->p_sys->i_rear_left = i_offset;
135                     break;
136                 case AOUT_CHAN_REARCENTER:
137                     p_filter->p_sys->i_rear_center = i_offset;
138                     break;
139                 case AOUT_CHAN_REARRIGHT:
140                     p_filter->p_sys->i_rear_right = i_offset;
141                     break;
142             }
143             ++i_offset;
144         }
145         ++i;
146     }
147
148     p_filter->pf_do_work = DoWork;
149     p_filter->b_in_place = 0;
150
151     return VLC_SUCCESS;
152 }
153
154 /*****************************************************************************
155  * Destroy: deallocate resources associated with headphone downmixer
156  *****************************************************************************/
157 static void Destroy( vlc_object_t *p_this )
158 {
159     aout_filter_t * p_filter = (aout_filter_t *)p_this;
160
161     if ( p_filter->p_sys != NULL )
162     {
163         free ( p_filter->p_sys );
164         p_filter->p_sys = NULL;
165     }
166 }
167
168 /*****************************************************************************
169  * DoWork: convert a buffer
170  *****************************************************************************/
171 static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter,
172                     aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf )
173 {
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 }