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