- better communication between audio decoder and output: aout plugins
[vlc.git] / plugins / mpeg_adec / mpeg_adec_generic.c
1 /*****************************************************************************
2  * adec_generic.c: MPEG audio decoder
3  *****************************************************************************
4  * Copyright (C) 1999-2001 VideoLAN
5  * $Id: mpeg_adec_generic.c,v 1.6 2002/01/09 00:33:37 asmax Exp $
6  *
7  * Authors: Michel Kaempf <maxx@via.ecp.fr>
8  *          Michel Lespinasse <walken@via.ecp.fr>
9  *          Cyril Deguet <asmax@via.ecp.fr>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
24  *****************************************************************************/
25
26 #include <string.h>                                    /* memcpy(), memset() */
27
28 #include <videolan/vlc.h>
29
30 #include "input_ext-dec.h"
31 #include "stream_control.h"
32
33 #include "mpeg_adec_generic.h"
34 #include "mpeg_adec.h"
35 #include "adec_math.h"                                     /* DCT32(), PCM() */
36 #include "adec_layer1.h"
37 #include "adec_layer2.h"
38
39 int adec_Init( adec_thread_t * p_adec )
40 {
41     p_adec->bank_0.actual = p_adec->bank_0.v1;
42     p_adec->bank_0.pos = 0;
43     p_adec->bank_1.actual = p_adec->bank_1.v1;
44     p_adec->bank_1.pos = 0;
45     return 0;
46 }
47
48 int adec_SyncFrame( adec_thread_t * p_adec, adec_sync_info_t * p_sync_info )
49 {
50     static int mpeg1_sample_rate[3] = {44100, 48000, 32000};
51     static int mpeg1_layer1_bit_rate[15] =
52     {
53         0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448
54     };
55     static int mpeg1_layer2_bit_rate[15] =
56     {
57         0, 32, 48, 56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 384
58     };
59     static int mpeg2_layer1_bit_rate[15] =
60     {
61         0, 32, 48, 56,  64,  80,  96, 112, 128, 144, 160, 176, 192, 224, 256
62     };
63     static int mpeg2_layer2_bit_rate[15] =
64     {
65         0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160
66     };
67     static int * bit_rate_table[8] =
68     {
69         NULL, NULL, mpeg2_layer2_bit_rate, mpeg2_layer1_bit_rate,
70         NULL, NULL, mpeg1_layer2_bit_rate, mpeg1_layer1_bit_rate
71     };
72
73     u32 header;
74     int index;
75     int * bit_rates;
76     int sample_rate;
77     int bit_rate;
78     int frame_size;
79
80     /* We read the whole header, but only really take 8 bits */
81     header = GetBits( &p_adec->bit_stream, 8 ) << 24;
82     header |= ShowBits( &p_adec->bit_stream, 24 );
83
84     p_adec->header = header;
85
86     /* basic header check : sync word */
87     if( (header & 0xfff00000) != 0xfff00000 )
88     {
89         return 1;
90     }
91
92     /* calculate bit rate */
93     index = ( header >> 17 ) & 7; /* mpeg ID + layer */
94     bit_rates = bit_rate_table[ index ];
95     if( bit_rates == NULL )
96     {
97         return 1; /* invalid layer */
98     }
99
100     index = ( header >> 12 ) & 15; /* bit rate index */
101     if (index > 14)
102     {
103         return 1;
104     }
105     bit_rate = bit_rates[ index ];
106
107     /* mpeg 1 layer 2 : check that bitrate per channel is valid */
108
109     if( bit_rates == mpeg1_layer2_bit_rate )
110     {
111         if( (header & 0xc0) == 0xc0 )
112         {   /* mono */
113             if( index > 10 )
114             {
115                 return 1; /* invalid bitrate per channel */
116             }
117         }
118         else
119         {   /* stereo */
120             if( (1 << index) & 0x2e )
121             {
122                 return 1; /* invalid bitrate per channel */
123             }
124         }
125     }
126
127     /* calculate sample rate */
128
129     index = ( header >> 10 ) & 3; /* sample rate index */
130     if( index > 2 )
131     {
132         return 1;
133     }
134
135     sample_rate = mpeg1_sample_rate[ index ];
136
137     if( ! (header & 0x80000) )
138     {
139         sample_rate >>= 1; /* half sample rate for mpeg2 */
140     }
141
142     /* calculate frame length */
143
144     if( (header & 0x60000) == 0x60000 )
145     {
146         /* layer 1 */
147         frame_size = 48000 * bit_rate / sample_rate;
148
149         /* padding */
150         if( header & 0x200 )
151         {
152             frame_size += 4;
153         }
154     }
155     else
156     {
157         /* layer >1 */
158         frame_size = 144000 * bit_rate / sample_rate;
159
160         /* padding */
161         if( header & 0x200 )
162         {
163             frame_size ++;
164         }
165     }
166
167     /* Now we are sure we want this header, read it */
168     RemoveBits( &p_adec->bit_stream, 24 );
169     p_adec->i_read_bits = 32;
170
171     if( ! (p_adec->header & 0x10000) )
172     {
173         /* Error check, skip it */
174         RemoveBits( &p_adec->bit_stream, 16 );
175         p_adec->i_read_bits += 16;
176     }
177
178     p_sync_info->b_stereo = ((p_adec->header & 0xc0) != 0xc0);
179     p_sync_info->sample_rate = sample_rate;
180     p_sync_info->bit_rate = bit_rate;
181     p_sync_info->frame_size = frame_size;
182     p_adec->frame_size = frame_size;
183
184     return 0;
185 }
186
187 int adec_DecodeFrame( adec_thread_t * p_adec, s16 * buffer )
188 {
189     int i_total_bytes_read;
190
191     /* parse audio data */
192
193     switch( (p_adec->header >> 17) & 3 )
194     {
195     case 2:
196         /* layer 2 */
197         if( (p_adec->header & 0xc0) == 0xc0 )
198         {
199             if( adec_layer2_mono (p_adec, buffer) )
200             {
201                 return 1;
202             }
203         }
204         else
205         {
206             if( adec_layer2_stereo (p_adec, buffer) )
207             {
208                 return 1;
209             }
210         }
211         break;
212
213     case 3:
214         /* layer 1 */
215         if( (p_adec->header & 0xc0) == 0xc0 )
216         {
217             if( adec_layer1_mono (p_adec, buffer) )
218             {
219                 return 1;
220             }
221         }
222         else
223         {
224             if( adec_layer1_stereo (p_adec, buffer) )
225             {
226                 return 1;
227             }
228         }
229         break;
230     }
231
232     /* Skip ancillary data */
233
234     if( (p_adec->header & 0xf000) == 0 ) /* free bitrate format */
235     {
236         return 0;
237     }
238
239     RealignBits( &p_adec->bit_stream );
240     i_total_bytes_read = ( p_adec->i_read_bits + 7 ) / 8;
241
242     if( i_total_bytes_read > p_adec->frame_size )
243     {
244         return 1; /* overrun */
245     }
246
247     while( i_total_bytes_read++ < p_adec->frame_size )
248     {
249         RemoveBits( &p_adec->bit_stream, 8 ); /* skip ancillary data */
250     }
251
252     return 0;
253 }
254