Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flac.c @ da9c9637

History | View | Annotate | Download (23.6 KB)

1 4f52c312 Michael Niedermayer
/*
2
 * FLAC (Free Lossless Audio Codec) decoder
3
 * Copyright (c) 2003 Alex Beregszaszi
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19
20
/**
21
 * @file flac.c
22
 * FLAC (Free Lossless Audio Codec) decoder
23
 * @author Alex Beregszaszi
24 9eda2f94 Mike Melanson
 *
25
 * For more information on the FLAC format, visit:
26
 *  http://flac.sourceforge.net/
27
 *
28
 * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
29
 * through, starting from the initial 'fLaC' signature; or by passing the
30
 * 34-byte streaminfo structure through avctx->extradata[_size] followed
31
 * by data starting with the 0xFFF8 marker.
32 4f52c312 Michael Niedermayer
 */
33
 
34 ac2570a8 Michael Niedermayer
#include <limits.h>
35
 
36 4f52c312 Michael Niedermayer
#include "avcodec.h"
37
#include "golomb.h"
38
39 ac2570a8 Michael Niedermayer
#undef NDEBUG
40
#include <assert.h>
41
42 4f52c312 Michael Niedermayer
#define MAX_CHANNELS 8
43
#define MAX_BLOCKSIZE 65535
44 9eda2f94 Mike Melanson
#define FLAC_STREAMINFO_SIZE 34
45 4f52c312 Michael Niedermayer
46 9d656110 Michael Niedermayer
enum decorrelation_type {
47 4f52c312 Michael Niedermayer
    INDEPENDENT,
48
    LEFT_SIDE,
49
    RIGHT_SIDE,
50
    MID_SIDE,
51
};
52
53
typedef struct FLACContext {
54
    AVCodecContext *avctx;
55
    GetBitContext gb;
56
57
    int min_blocksize, max_blocksize;
58
    int min_framesize, max_framesize;
59
    int samplerate, channels;
60 ac2570a8 Michael Niedermayer
    int blocksize/*, last_blocksize*/;
61 4f52c312 Michael Niedermayer
    int bps, curr_bps;
62 9d656110 Michael Niedermayer
    enum decorrelation_type decorrelation;
63 4f52c312 Michael Niedermayer
64 ac2570a8 Michael Niedermayer
    int32_t *decoded[MAX_CHANNELS];
65
    uint8_t *bitstream;
66
    int bitstream_size;
67
    int bitstream_index;
68
    int allocated_bitstream_size;
69 4f52c312 Michael Niedermayer
} FLACContext;
70
71
#define METADATA_TYPE_STREAMINFO 0
72
73
static int sample_rate_table[] =
74
{ 0, 0, 0, 0,
75
  8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
76
  0, 0, 0, 0 }; 
77
78
static int sample_size_table[] = 
79
{ 0, 8, 12, 0, 16, 20, 24, 0 };
80
81 0496a034 Michael Niedermayer
static int blocksize_table[] = {
82
     0,    192, 576<<0, 576<<1, 576<<2, 576<<3,      0,      0, 
83
256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7 
84
};
85
86 9d656110 Michael Niedermayer
static const uint8_t table_crc8[256] = {
87
    0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
88
    0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
89
    0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,
90
    0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d,
91
    0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5,
92
    0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
93
    0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85,
94
    0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd,
95
    0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2,
96
    0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea,
97
    0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2,
98
    0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
99
    0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32,
100
    0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a,
101
    0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42,
102
    0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a,
103
    0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c,
104
    0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
105
    0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec,
106
    0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4,
107
    0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c,
108
    0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44,
109
    0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c,
110
    0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
111
    0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b,
112
    0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63,
113
    0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b,
114
    0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13,
115
    0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb,
116
    0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
117
    0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb,
118
    0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3
119
};
120
121 ac2570a8 Michael Niedermayer
static int64_t get_utf8(GetBitContext *gb)
122 4f52c312 Michael Niedermayer
{
123 ac2570a8 Michael Niedermayer
    uint64_t val;
124
    int ones=0, bytes;
125
    
126
    while(get_bits1(gb))
127
        ones++;
128 4f52c312 Michael Niedermayer
129 ac2570a8 Michael Niedermayer
    if     (ones==0) bytes=0;
130
    else if(ones==1) return -1;
131
    else             bytes= ones - 1;
132
    
133
    val= get_bits(gb, 7-ones);
134
    while(bytes--){
135 4f52c312 Michael Niedermayer
        const int tmp = get_bits(gb, 8);
136
        
137 ac2570a8 Michael Niedermayer
        if((tmp>>6) != 2)
138
            return -1;
139
        val<<=6;
140
        val|= tmp&0x3F;
141 4f52c312 Michael Niedermayer
    }
142 ac2570a8 Michael Niedermayer
    return val;
143 4f52c312 Michael Niedermayer
}
144
145 41aecb13 Alex Beregszaszi
static int skip_utf8(GetBitContext *gb)
146
{
147
    int ones=0, bytes;
148
    
149
    while(get_bits1(gb))
150
        ones++;
151
152
    if     (ones==0) bytes=0;
153
    else if(ones==1) return -1;
154
    else             bytes= ones - 1;
155
    
156
    skip_bits(gb, 7-ones);
157
    while(bytes--){
158
        const int tmp = get_bits(gb, 8);
159
        
160
        if((tmp>>6) != 2)
161
            return -1;
162
    }
163
    return 0;
164
}
165
166 62c438a2 Zdenek Kabelac
static int get_crc8(const uint8_t *buf, int count){
167 9d656110 Michael Niedermayer
    int crc=0;
168
    int i;
169
    
170
    for(i=0; i<count; i++){
171
        crc = table_crc8[crc ^ buf[i]];
172
    }
173
174
    return crc;
175
}
176
177 9eda2f94 Mike Melanson
static void metadata_streaminfo(FLACContext *s);
178
static void dump_headers(FLACContext *s);
179
180 4f52c312 Michael Niedermayer
static int flac_decode_init(AVCodecContext * avctx)
181
{
182 9eda2f94 Mike Melanson
    FLACContext *s = avctx->priv_data;
183
    s->avctx = avctx;
184
185
    /* initialize based on the demuxer-supplied streamdata header */
186
    if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
187
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
188
        metadata_streaminfo(s);
189
        dump_headers(s);
190
    }
191
192 4f52c312 Michael Niedermayer
    return 0;
193
}
194
195
static void dump_headers(FLACContext *s)
196
{
197 ac2570a8 Michael Niedermayer
    av_log(s->avctx, AV_LOG_DEBUG, "  Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
198
    av_log(s->avctx, AV_LOG_DEBUG, "  Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
199
    av_log(s->avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
200
    av_log(s->avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
201
    av_log(s->avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
202 4f52c312 Michael Niedermayer
}
203
204 ac2570a8 Michael Niedermayer
static void allocate_buffers(FLACContext *s){
205 4f52c312 Michael Niedermayer
    int i;
206
207 ac2570a8 Michael Niedermayer
    assert(s->max_blocksize);
208
209
    if(s->max_framesize == 0 && s->max_blocksize){
210
        s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
211
    }
212
213
    for (i = 0; i < s->channels; i++)
214
    {
215
        s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
216
    }
217
218
    s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
219
}
220
221
static void metadata_streaminfo(FLACContext *s)
222
{
223 4f52c312 Michael Niedermayer
    /* mandatory streaminfo */
224
    s->min_blocksize = get_bits(&s->gb, 16);
225
    s->max_blocksize = get_bits(&s->gb, 16);
226
227
    s->min_framesize = get_bits_long(&s->gb, 24);
228
    s->max_framesize = get_bits_long(&s->gb, 24);
229
    
230
    s->samplerate = get_bits_long(&s->gb, 20);
231
    s->channels = get_bits(&s->gb, 3) + 1;
232
    s->bps = get_bits(&s->gb, 5) + 1;
233
    
234
    s->avctx->channels = s->channels;
235
    s->avctx->sample_rate = s->samplerate;
236
237
    skip_bits(&s->gb, 36); /* total num of samples */
238
    
239
    skip_bits(&s->gb, 64); /* md5 sum */
240
    skip_bits(&s->gb, 64); /* md5 sum */
241 ac2570a8 Michael Niedermayer
    
242
    allocate_buffers(s);
243 4f52c312 Michael Niedermayer
}
244
245
static int decode_residuals(FLACContext *s, int channel, int pred_order)
246
{
247
    int i, tmp, partition, method_type, rice_order;
248
    int sample = 0, samples;
249
250
    method_type = get_bits(&s->gb, 2);
251 ac2570a8 Michael Niedermayer
    if (method_type != 0){
252
        av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
253 4f52c312 Michael Niedermayer
        return -1;
254 ac2570a8 Michael Niedermayer
    }
255 4f52c312 Michael Niedermayer
    
256
    rice_order = get_bits(&s->gb, 4);
257
258 ac2570a8 Michael Niedermayer
    samples= s->blocksize >> rice_order;
259 4f52c312 Michael Niedermayer
260 ac2570a8 Michael Niedermayer
    sample= 
261
    i= pred_order;
262 4f52c312 Michael Niedermayer
    for (partition = 0; partition < (1 << rice_order); partition++)
263
    {
264
        tmp = get_bits(&s->gb, 4);
265 ac2570a8 Michael Niedermayer
        if (tmp == 15)
266 4f52c312 Michael Niedermayer
        {
267 ac2570a8 Michael Niedermayer
            av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
268 4f52c312 Michael Niedermayer
            tmp = get_bits(&s->gb, 5);
269
            for (; i < samples; i++, sample++)
270 4fd12598 Michael Niedermayer
                s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
271 4f52c312 Michael Niedermayer
        }
272
        else
273
        {
274 ac2570a8 Michael Niedermayer
//            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
275
            for (; i < samples; i++, sample++){
276 4fd12598 Michael Niedermayer
                s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
277 ac2570a8 Michael Niedermayer
            }
278 4f52c312 Michael Niedermayer
        }
279 ac2570a8 Michael Niedermayer
        i= 0;
280 4f52c312 Michael Niedermayer
    }
281
282 ac2570a8 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
283 4f52c312 Michael Niedermayer
284
    return 0;
285
}    
286
287
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
288
{
289
    int i;
290
        
291 9d656110 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME FIXED\n");
292 4f52c312 Michael Niedermayer
        
293
    /* warm up samples */
294 9d656110 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
295 4f52c312 Michael Niedermayer
        
296
    for (i = 0; i < pred_order; i++)
297
    {
298 ac2570a8 Michael Niedermayer
        s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
299
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
300 4f52c312 Michael Niedermayer
    }
301
    
302
    if (decode_residuals(s, channel, pred_order) < 0)
303
        return -1;
304
305
    switch(pred_order)
306
    {
307
        case 0:
308
            break;
309
        case 1:
310
            for (i = pred_order; i < s->blocksize; i++)
311 4fd12598 Michael Niedermayer
                s->decoded[channel][i] +=   s->decoded[channel][i-1];
312 4f52c312 Michael Niedermayer
            break;
313
        case 2:
314
            for (i = pred_order; i < s->blocksize; i++)
315 4fd12598 Michael Niedermayer
                s->decoded[channel][i] += 2*s->decoded[channel][i-1]
316
                                          - s->decoded[channel][i-2];
317 4f52c312 Michael Niedermayer
            break;
318
        case 3:
319
            for (i = pred_order; i < s->blocksize; i++)
320 4fd12598 Michael Niedermayer
                s->decoded[channel][i] += 3*s->decoded[channel][i-1] 
321
                                        - 3*s->decoded[channel][i-2]
322
                                        +   s->decoded[channel][i-3];
323 4f52c312 Michael Niedermayer
            break;
324
        case 4:
325
            for (i = pred_order; i < s->blocksize; i++)
326 4fd12598 Michael Niedermayer
                s->decoded[channel][i] += 4*s->decoded[channel][i-1] 
327
                                        - 6*s->decoded[channel][i-2]
328
                                        + 4*s->decoded[channel][i-3]
329
                                        -   s->decoded[channel][i-4];
330 4f52c312 Michael Niedermayer
            break;
331 ac2570a8 Michael Niedermayer
        default:
332
            av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
333
            return -1;
334 4f52c312 Michael Niedermayer
    }
335 ac2570a8 Michael Niedermayer
336 4f52c312 Michael Niedermayer
    return 0;
337
}
338
339
static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
340
{
341
    int sum, i, j;
342
    int coeff_prec, qlevel;
343
    int coeffs[pred_order];
344
        
345 ac2570a8 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME LPC\n");
346 4f52c312 Michael Niedermayer
        
347
    /* warm up samples */
348 ac2570a8 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
349 4f52c312 Michael Niedermayer
        
350
    for (i = 0; i < pred_order; i++)
351
    {
352 ac2570a8 Michael Niedermayer
        s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
353
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
354 4f52c312 Michael Niedermayer
    }
355
    
356
    coeff_prec = get_bits(&s->gb, 4) + 1;
357
    if (coeff_prec == 16)
358
    {
359 ac2570a8 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
360 4f52c312 Michael Niedermayer
        return -1;
361
    }
362 9d656110 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "   qlp coeff prec: %d\n", coeff_prec);
363 ac2570a8 Michael Niedermayer
    qlevel = get_sbits(&s->gb, 5);
364 9d656110 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "   quant level: %d\n", qlevel);
365
    if(qlevel < 0){
366
        av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
367
        return -1;
368
    }
369
370 4f52c312 Michael Niedermayer
    for (i = 0; i < pred_order; i++)
371
    {
372 ac2570a8 Michael Niedermayer
        coeffs[i] = get_sbits(&s->gb, coeff_prec);
373
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, coeffs[i]);
374 4f52c312 Michael Niedermayer
    }
375
    
376
    if (decode_residuals(s, channel, pred_order) < 0)
377
        return -1;
378
379
    for (i = pred_order; i < s->blocksize; i++)
380
    {
381
        sum = 0;
382
        for (j = 0; j < pred_order; j++)
383
            sum += coeffs[j] * s->decoded[channel][i-j-1];
384 4fd12598 Michael Niedermayer
        s->decoded[channel][i] += sum >> qlevel;
385 4f52c312 Michael Niedermayer
    }
386
    
387
    return 0;
388
}
389
390
static inline int decode_subframe(FLACContext *s, int channel)
391
{
392
    int type, wasted = 0;
393
    int i, tmp;
394
    
395
    s->curr_bps = s->bps;
396 ac2570a8 Michael Niedermayer
    if(channel == 0){
397 9d656110 Michael Niedermayer
        if(s->decorrelation == RIGHT_SIDE)
398 ac2570a8 Michael Niedermayer
            s->curr_bps++;
399
    }else{
400 9d656110 Michael Niedermayer
        if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
401 ac2570a8 Michael Niedermayer
            s->curr_bps++;
402
    }
403
404 4f52c312 Michael Niedermayer
    if (get_bits1(&s->gb))
405
    {
406 ac2570a8 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "invalid subframe padding\n");
407 4f52c312 Michael Niedermayer
        return -1;
408
    }
409
    type = get_bits(&s->gb, 6);
410
//    wasted = get_bits1(&s->gb);
411
    
412
//    if (wasted)
413
//    {
414
//        while (!get_bits1(&s->gb))
415
//            wasted++;
416
//        if (wasted)
417
//            wasted++;
418
//        s->curr_bps -= wasted;
419
//    }
420 ac2570a8 Michael Niedermayer
#if 0
421
    wasted= 16 - av_log2(show_bits(&s->gb, 17));
422
    skip_bits(&s->gb, wasted+1);
423
    s->curr_bps -= wasted;
424
#else
425 4f52c312 Michael Niedermayer
    if (get_bits1(&s->gb))
426
    {
427
        wasted = 1;
428
        while (!get_bits1(&s->gb))
429
            wasted++;
430
        s->curr_bps -= wasted;
431 ac2570a8 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
432 4f52c312 Michael Niedermayer
    }
433 ac2570a8 Michael Niedermayer
#endif
434
//FIXME use av_log2 for types
435 4f52c312 Michael Niedermayer
    if (type == 0)
436
    {
437 ac2570a8 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
438
        tmp = get_sbits(&s->gb, s->curr_bps);
439 4f52c312 Michael Niedermayer
        for (i = 0; i < s->blocksize; i++)
440
            s->decoded[channel][i] = tmp;
441
    }
442
    else if (type == 1)
443
    {
444 ac2570a8 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
445 4f52c312 Michael Niedermayer
        for (i = 0; i < s->blocksize; i++)
446 ac2570a8 Michael Niedermayer
            s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
447 4f52c312 Michael Niedermayer
    }
448
    else if ((type >= 8) && (type <= 12))
449
    {
450 9d656110 Michael Niedermayer
//        av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
451 4f52c312 Michael Niedermayer
        if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
452
            return -1;
453
    }
454
    else if (type >= 32)
455
    {
456 ac2570a8 Michael Niedermayer
//        av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
457 4f52c312 Michael Niedermayer
        if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
458
            return -1;
459
    }
460
    else
461
    {
462 ac2570a8 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "invalid coding type\n");
463 4f52c312 Michael Niedermayer
        return -1;
464
    }
465
        
466
    if (wasted)
467
    {
468
        int i;
469
        for (i = 0; i < s->blocksize; i++)
470
            s->decoded[channel][i] <<= wasted;
471
    }
472
473
    return 0;
474
}
475
476
static int decode_frame(FLACContext *s)
477
{
478 9d656110 Michael Niedermayer
    int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
479 0496a034 Michael Niedermayer
    int decorrelation, bps, blocksize, samplerate;
480 4f52c312 Michael Niedermayer
    
481
    blocksize_code = get_bits(&s->gb, 4);
482
483
    sample_rate_code = get_bits(&s->gb, 4);
484
    
485
    assignment = get_bits(&s->gb, 4); /* channel assignment */
486 0496a034 Michael Niedermayer
    if (assignment < 8 && s->channels == assignment+1)
487
        decorrelation = INDEPENDENT;
488
    else if (assignment >=8 && assignment < 11 && s->channels == 2)
489
        decorrelation = LEFT_SIDE + assignment - 8;
490 4f52c312 Michael Niedermayer
    else
491
    {
492 0496a034 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
493 4f52c312 Michael Niedermayer
        return -1;
494
    }
495
        
496
    sample_size_code = get_bits(&s->gb, 3);
497 0496a034 Michael Niedermayer
    if(sample_size_code == 0)
498
        bps= s->bps;
499
    else if((sample_size_code != 3) && (sample_size_code != 7))
500
        bps = sample_size_table[sample_size_code];
501
    else 
502 4f52c312 Michael Niedermayer
    {
503 ac2570a8 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
504 4f52c312 Michael Niedermayer
        return -1;
505
    }
506
507
    if (get_bits1(&s->gb))
508
    {
509 ac2570a8 Michael Niedermayer
        av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
510 0496a034 Michael Niedermayer
        return -1;
511 4f52c312 Michael Niedermayer
    }
512
    
513 0496a034 Michael Niedermayer
    if(get_utf8(&s->gb) < 0){
514
        av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
515
        return -1;
516
    }
517
#if 0    
518 ac2570a8 Michael Niedermayer
    if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
519
        (s->min_blocksize != s->max_blocksize)){
520
    }else{
521 4f52c312 Michael Niedermayer
    }
522 0496a034 Michael Niedermayer
#endif
523
    
524 ac2570a8 Michael Niedermayer
    if (blocksize_code == 0)
525 0496a034 Michael Niedermayer
        blocksize = s->min_blocksize;
526 ac2570a8 Michael Niedermayer
    else if (blocksize_code == 6)
527 0496a034 Michael Niedermayer
        blocksize = get_bits(&s->gb, 8)+1;
528 ac2570a8 Michael Niedermayer
    else if (blocksize_code == 7)
529 0496a034 Michael Niedermayer
        blocksize = get_bits(&s->gb, 16)+1;
530
    else 
531
        blocksize = blocksize_table[blocksize_code];
532 4f52c312 Michael Niedermayer
533 0496a034 Michael Niedermayer
    if(blocksize > s->max_blocksize){
534
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
535 ac2570a8 Michael Niedermayer
        return -1;
536
    }
537
538
    if (sample_rate_code == 0){
539 0496a034 Michael Niedermayer
        samplerate= s->samplerate;
540 ac2570a8 Michael Niedermayer
    }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
541 0496a034 Michael Niedermayer
        samplerate = sample_rate_table[sample_rate_code];
542 ac2570a8 Michael Niedermayer
    else if (sample_rate_code == 12)
543 0496a034 Michael Niedermayer
        samplerate = get_bits(&s->gb, 8) * 1000;
544 ac2570a8 Michael Niedermayer
    else if (sample_rate_code == 13)
545 0496a034 Michael Niedermayer
        samplerate = get_bits(&s->gb, 16);
546 ac2570a8 Michael Niedermayer
    else if (sample_rate_code == 14)
547 0496a034 Michael Niedermayer
        samplerate = get_bits(&s->gb, 16) * 10;
548 ac2570a8 Michael Niedermayer
    else{
549
        av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
550
        return -1;
551 4f52c312 Michael Niedermayer
    }
552
553 9d656110 Michael Niedermayer
    skip_bits(&s->gb, 8);
554
    crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
555
    if(crc8){
556
        av_log(s->avctx, AV_LOG_ERROR, "header crc missmatch crc=%2X\n", crc8);
557
        return -1;
558
    }
559 0496a034 Michael Niedermayer
    
560
    s->blocksize    = blocksize;
561
    s->samplerate   = samplerate;
562
    s->bps          = bps;
563
    s->decorrelation= decorrelation;
564 4f52c312 Michael Niedermayer
565 ac2570a8 Michael Niedermayer
//    dump_headers(s);
566 4f52c312 Michael Niedermayer
567
    /* subframes */
568
    for (i = 0; i < s->channels; i++)
569
    {
570 ac2570a8 Michael Niedermayer
//        av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
571 4f52c312 Michael Niedermayer
        if (decode_subframe(s, i) < 0)
572
            return -1;
573
    }
574
    
575
    align_get_bits(&s->gb);
576
577
    /* frame footer */
578
    skip_bits(&s->gb, 16); /* data crc */
579
580
    return 0;
581
}
582
583
static int flac_decode_frame(AVCodecContext *avctx,
584
                            void *data, int *data_size,
585
                            uint8_t *buf, int buf_size)
586
{
587
    FLACContext *s = avctx->priv_data;
588 ac2570a8 Michael Niedermayer
    int metadata_last, metadata_type, metadata_size;
589 3f1899a8 Mike Melanson
    int tmp = 0, i, j = 0, input_buf_size = 0;
590
    int16_t *samples = data;
591 4f52c312 Michael Niedermayer
592 ac2570a8 Michael Niedermayer
    if(s->max_framesize == 0){
593
        s->max_framesize= 8192; // should hopefully be enough for the first header
594
        s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
595
    }
596
597
    if(1 && s->max_framesize){//FIXME truncated
598
            buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
599
            input_buf_size= buf_size;
600
601
            if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
602
//                printf("memmove\n");
603
                memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
604
                s->bitstream_index=0;
605
            }
606
            memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
607
            buf= &s->bitstream[s->bitstream_index];
608
            buf_size += s->bitstream_size;
609
            s->bitstream_size= buf_size;
610
            
611
            if(buf_size < s->max_framesize){
612
//                printf("wanna more data ...\n");
613
                return input_buf_size;
614
            }
615
    }
616 4f52c312 Michael Niedermayer
617
    init_get_bits(&s->gb, buf, buf_size*8);
618
    
619
    /* fLaC signature (be) */
620 ac2570a8 Michael Niedermayer
    if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
621 4f52c312 Michael Niedermayer
    {
622 ac2570a8 Michael Niedermayer
        skip_bits(&s->gb, 32);
623
624
        av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
625 4f52c312 Michael Niedermayer
        do {
626 ac2570a8 Michael Niedermayer
            metadata_last = get_bits(&s->gb, 1);
627 4f52c312 Michael Niedermayer
            metadata_type = get_bits(&s->gb, 7);
628
            metadata_size = get_bits_long(&s->gb, 24);
629
            
630 ac2570a8 Michael Niedermayer
            av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
631
                metadata_last, metadata_type,
632 4f52c312 Michael Niedermayer
                metadata_size);
633 ac2570a8 Michael Niedermayer
            if(metadata_size){
634
                switch(metadata_type)
635
                {
636 4f52c312 Michael Niedermayer
                case METADATA_TYPE_STREAMINFO:
637
                    metadata_streaminfo(s);
638
                    dump_headers(s);
639
                    break;
640
                default:
641 ac2570a8 Michael Niedermayer
                    for(i=0; i<metadata_size; i++)
642 4f52c312 Michael Niedermayer
                        skip_bits(&s->gb, 8);
643 ac2570a8 Michael Niedermayer
                }
644 4f52c312 Michael Niedermayer
            }
645 ac2570a8 Michael Niedermayer
        } while(!metadata_last);
646 4f52c312 Michael Niedermayer
    }
647
    else
648
    {
649 ac2570a8 Michael Niedermayer
        
650 9d656110 Michael Niedermayer
        tmp = show_bits(&s->gb, 16);
651 ac2570a8 Michael Niedermayer
        if(tmp != 0xFFF8){
652
            av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
653
            while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
654
                skip_bits(&s->gb, 8);
655
            goto end; // we may not have enough bits left to decode a frame, so try next time
656
        }
657
        skip_bits(&s->gb, 16);
658 9d656110 Michael Niedermayer
        if (decode_frame(s) < 0){
659
            av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
660
            s->bitstream_size=0;
661
            s->bitstream_index=0;
662 4f52c312 Michael Niedermayer
            return -1;
663 9d656110 Michael Niedermayer
        }
664 4f52c312 Michael Niedermayer
    }
665 ac2570a8 Michael Niedermayer
666 4f52c312 Michael Niedermayer
    
667
#if 0
668
    /* fix the channel order here */
669
    if (s->order == MID_SIDE)
670
    {
671
        short *left = samples;
672
        short *right = samples + s->blocksize;
673
        for (i = 0; i < s->blocksize; i += 2)
674
        {
675
            uint32_t x = s->decoded[0][i];
676
            uint32_t y = s->decoded[0][i+1];
677

678
            right[i] = x - (y / 2);
679
            left[i] = right[i] + y;
680
        }
681
        *data_size = 2 * s->blocksize;
682
    }
683
    else
684
    {
685
    for (i = 0; i < s->channels; i++)
686
    {
687
        switch(s->order)
688
        {
689
            case INDEPENDENT:
690
                for (j = 0; j < s->blocksize; j++)
691
                    samples[(s->blocksize*i)+j] = s->decoded[i][j];
692
                break;
693
            case LEFT_SIDE:
694
            case RIGHT_SIDE:
695
                if (i == 0)
696
                    for (j = 0; j < s->blocksize; j++)
697
                        samples[(s->blocksize*i)+j] = s->decoded[0][j];
698
                else
699
                    for (j = 0; j < s->blocksize; j++)
700
                        samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
701
                break;
702
//            case MID_SIDE:
703 ac2570a8 Michael Niedermayer
//                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
704 4f52c312 Michael Niedermayer
        }
705
        *data_size += s->blocksize;
706
    }
707
    }
708
#else
709 9d656110 Michael Niedermayer
    switch(s->decorrelation)
710 4f52c312 Michael Niedermayer
    {
711
        case INDEPENDENT:
712 ac2570a8 Michael Niedermayer
            for (j = 0; j < s->blocksize; j++)
713 4f52c312 Michael Niedermayer
            {
714 ac2570a8 Michael Niedermayer
                for (i = 0; i < s->channels; i++)
715 4f52c312 Michael Niedermayer
                    *(samples++) = s->decoded[i][j];
716
            }
717
            break;
718
        case LEFT_SIDE:
719
            assert(s->channels == 2);
720
            for (i = 0; i < s->blocksize; i++)
721
            {
722
                *(samples++) = s->decoded[0][i];
723
                *(samples++) = s->decoded[0][i] - s->decoded[1][i];
724
            }
725
            break;
726
        case RIGHT_SIDE:
727
            assert(s->channels == 2);
728
            for (i = 0; i < s->blocksize; i++)
729
            {
730
                *(samples++) = s->decoded[0][i] + s->decoded[1][i];
731
                *(samples++) = s->decoded[1][i];
732
            }
733
            break;
734
        case MID_SIDE:
735
            assert(s->channels == 2);
736
            for (i = 0; i < s->blocksize; i++)
737
            {
738 ac2570a8 Michael Niedermayer
                int mid, side;
739 4f52c312 Michael Niedermayer
                mid = s->decoded[0][i];
740
                side = s->decoded[1][i];
741 9d656110 Michael Niedermayer
742
#if 1 //needs to be checked but IMHO it should be binary identical
743
                mid -= side>>1;
744
                *(samples++) = mid + side;
745
                *(samples++) = mid;
746
#else
747 4f52c312 Michael Niedermayer
                
748
                mid <<= 1;
749
                if (side & 1)
750
                    mid++;
751
                *(samples++) = (mid + side) >> 1;
752
                *(samples++) = (mid - side) >> 1;
753 9d656110 Michael Niedermayer
#endif
754 4f52c312 Michael Niedermayer
            }
755
            break;
756
    }
757
#endif
758
759 ac2570a8 Michael Niedermayer
    *data_size = (int8_t *)samples - (int8_t *)data;
760 9d656110 Michael Niedermayer
//    av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
761 4f52c312 Michael Niedermayer
762 ac2570a8 Michael Niedermayer
//    s->last_blocksize = s->blocksize;
763
end:
764
    i= (get_bits_count(&s->gb)+7)/8;;
765
    if(i > buf_size){
766
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
767 9d656110 Michael Niedermayer
        s->bitstream_size=0;
768
        s->bitstream_index=0;
769 ac2570a8 Michael Niedermayer
        return -1;
770
    }
771 4f52c312 Michael Niedermayer
772 ac2570a8 Michael Niedermayer
    if(s->bitstream_size){
773
        s->bitstream_index += i;
774
        s->bitstream_size  -= i;
775
        return input_buf_size;
776
    }else 
777
        return i;
778 4f52c312 Michael Niedermayer
}
779
780
static int flac_decode_close(AVCodecContext *avctx)
781
{
782
    FLACContext *s = avctx->priv_data;
783
    int i;
784
    
785
    for (i = 0; i < s->channels; i++)
786
    {
787 ac2570a8 Michael Niedermayer
        av_freep(&s->decoded[i]);
788 4f52c312 Michael Niedermayer
    }
789 ac2570a8 Michael Niedermayer
    av_freep(&s->bitstream);
790 4f52c312 Michael Niedermayer
    
791
    return 0;
792
}
793
794 1e31d32c Michael Niedermayer
static void flac_flush(AVCodecContext *avctx){
795
    FLACContext *s = avctx->priv_data;
796
797
    s->bitstream_size=
798
    s->bitstream_index= 0;
799
}
800
801 4f52c312 Michael Niedermayer
AVCodec flac_decoder = {
802
    "flac",
803
    CODEC_TYPE_AUDIO,
804
    CODEC_ID_FLAC,
805
    sizeof(FLACContext),
806
    flac_decode_init,
807
    NULL,
808
    flac_decode_close,
809
    flac_decode_frame,
810 1e31d32c Michael Niedermayer
    .flush= flac_flush,    
811 4f52c312 Michael Niedermayer
};