Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flac.c @ da9c9637

History | View | Annotate | Download (23.6 KB)

1
/*
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
 *
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
 */
33
 
34
#include <limits.h>
35
 
36
#include "avcodec.h"
37
#include "golomb.h"
38

    
39
#undef NDEBUG
40
#include <assert.h>
41

    
42
#define MAX_CHANNELS 8
43
#define MAX_BLOCKSIZE 65535
44
#define FLAC_STREAMINFO_SIZE 34
45

    
46
enum decorrelation_type {
47
    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
    int blocksize/*, last_blocksize*/;
61
    int bps, curr_bps;
62
    enum decorrelation_type decorrelation;
63

    
64
    int32_t *decoded[MAX_CHANNELS];
65
    uint8_t *bitstream;
66
    int bitstream_size;
67
    int bitstream_index;
68
    int allocated_bitstream_size;
69
} 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
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
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
static int64_t get_utf8(GetBitContext *gb)
122
{
123
    uint64_t val;
124
    int ones=0, bytes;
125
    
126
    while(get_bits1(gb))
127
        ones++;
128

    
129
    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
        const int tmp = get_bits(gb, 8);
136
        
137
        if((tmp>>6) != 2)
138
            return -1;
139
        val<<=6;
140
        val|= tmp&0x3F;
141
    }
142
    return val;
143
}
144

    
145
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
static int get_crc8(const uint8_t *buf, int count){
167
    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
static void metadata_streaminfo(FLACContext *s);
178
static void dump_headers(FLACContext *s);
179

    
180
static int flac_decode_init(AVCodecContext * avctx)
181
{
182
    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
    return 0;
193
}
194

    
195
static void dump_headers(FLACContext *s)
196
{
197
    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
}
203

    
204
static void allocate_buffers(FLACContext *s){
205
    int i;
206

    
207
    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
    /* 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
    
242
    allocate_buffers(s);
243
}
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
    if (method_type != 0){
252
        av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
253
        return -1;
254
    }
255
    
256
    rice_order = get_bits(&s->gb, 4);
257

    
258
    samples= s->blocksize >> rice_order;
259

    
260
    sample= 
261
    i= pred_order;
262
    for (partition = 0; partition < (1 << rice_order); partition++)
263
    {
264
        tmp = get_bits(&s->gb, 4);
265
        if (tmp == 15)
266
        {
267
            av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
268
            tmp = get_bits(&s->gb, 5);
269
            for (; i < samples; i++, sample++)
270
                s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
271
        }
272
        else
273
        {
274
//            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
275
            for (; i < samples; i++, sample++){
276
                s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
277
            }
278
        }
279
        i= 0;
280
    }
281

    
282
//    av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
283

    
284
    return 0;
285
}    
286

    
287
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
288
{
289
    int i;
290
        
291
//    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME FIXED\n");
292
        
293
    /* warm up samples */
294
//    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
295
        
296
    for (i = 0; i < pred_order; i++)
297
    {
298
        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
    }
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
                s->decoded[channel][i] +=   s->decoded[channel][i-1];
312
            break;
313
        case 2:
314
            for (i = pred_order; i < s->blocksize; i++)
315
                s->decoded[channel][i] += 2*s->decoded[channel][i-1]
316
                                          - s->decoded[channel][i-2];
317
            break;
318
        case 3:
319
            for (i = pred_order; i < s->blocksize; i++)
320
                s->decoded[channel][i] += 3*s->decoded[channel][i-1] 
321
                                        - 3*s->decoded[channel][i-2]
322
                                        +   s->decoded[channel][i-3];
323
            break;
324
        case 4:
325
            for (i = pred_order; i < s->blocksize; i++)
326
                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
            break;
331
        default:
332
            av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
333
            return -1;
334
    }
335

    
336
    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
//    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME LPC\n");
346
        
347
    /* warm up samples */
348
//    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
349
        
350
    for (i = 0; i < pred_order; i++)
351
    {
352
        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
    }
355
    
356
    coeff_prec = get_bits(&s->gb, 4) + 1;
357
    if (coeff_prec == 16)
358
    {
359
        av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
360
        return -1;
361
    }
362
//    av_log(s->avctx, AV_LOG_DEBUG, "   qlp coeff prec: %d\n", coeff_prec);
363
    qlevel = get_sbits(&s->gb, 5);
364
//    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
    for (i = 0; i < pred_order; i++)
371
    {
372
        coeffs[i] = get_sbits(&s->gb, coeff_prec);
373
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, coeffs[i]);
374
    }
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
        s->decoded[channel][i] += sum >> qlevel;
385
    }
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
    if(channel == 0){
397
        if(s->decorrelation == RIGHT_SIDE)
398
            s->curr_bps++;
399
    }else{
400
        if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
401
            s->curr_bps++;
402
    }
403

    
404
    if (get_bits1(&s->gb))
405
    {
406
        av_log(s->avctx, AV_LOG_DEBUG, "invalid subframe padding\n");
407
        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
#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
    if (get_bits1(&s->gb))
426
    {
427
        wasted = 1;
428
        while (!get_bits1(&s->gb))
429
            wasted++;
430
        s->curr_bps -= wasted;
431
        av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
432
    }
433
#endif
434
//FIXME use av_log2 for types
435
    if (type == 0)
436
    {
437
        av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
438
        tmp = get_sbits(&s->gb, s->curr_bps);
439
        for (i = 0; i < s->blocksize; i++)
440
            s->decoded[channel][i] = tmp;
441
    }
442
    else if (type == 1)
443
    {
444
        av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
445
        for (i = 0; i < s->blocksize; i++)
446
            s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
447
    }
448
    else if ((type >= 8) && (type <= 12))
449
    {
450
//        av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
451
        if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
452
            return -1;
453
    }
454
    else if (type >= 32)
455
    {
456
//        av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
457
        if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
458
            return -1;
459
    }
460
    else
461
    {
462
        av_log(s->avctx, AV_LOG_DEBUG, "invalid coding type\n");
463
        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
    int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
479
    int decorrelation, bps, blocksize, samplerate;
480
    
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
    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
    else
491
    {
492
        av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
493
        return -1;
494
    }
495
        
496
    sample_size_code = get_bits(&s->gb, 3);
497
    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
    {
503
        av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
504
        return -1;
505
    }
506

    
507
    if (get_bits1(&s->gb))
508
    {
509
        av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
510
        return -1;
511
    }
512
    
513
    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
    if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
519
        (s->min_blocksize != s->max_blocksize)){
520
    }else{
521
    }
522
#endif
523
    
524
    if (blocksize_code == 0)
525
        blocksize = s->min_blocksize;
526
    else if (blocksize_code == 6)
527
        blocksize = get_bits(&s->gb, 8)+1;
528
    else if (blocksize_code == 7)
529
        blocksize = get_bits(&s->gb, 16)+1;
530
    else 
531
        blocksize = blocksize_table[blocksize_code];
532

    
533
    if(blocksize > s->max_blocksize){
534
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
535
        return -1;
536
    }
537

    
538
    if (sample_rate_code == 0){
539
        samplerate= s->samplerate;
540
    }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
541
        samplerate = sample_rate_table[sample_rate_code];
542
    else if (sample_rate_code == 12)
543
        samplerate = get_bits(&s->gb, 8) * 1000;
544
    else if (sample_rate_code == 13)
545
        samplerate = get_bits(&s->gb, 16);
546
    else if (sample_rate_code == 14)
547
        samplerate = get_bits(&s->gb, 16) * 10;
548
    else{
549
        av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
550
        return -1;
551
    }
552

    
553
    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
    
560
    s->blocksize    = blocksize;
561
    s->samplerate   = samplerate;
562
    s->bps          = bps;
563
    s->decorrelation= decorrelation;
564

    
565
//    dump_headers(s);
566

    
567
    /* subframes */
568
    for (i = 0; i < s->channels; i++)
569
    {
570
//        av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
571
        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
    int metadata_last, metadata_type, metadata_size;
589
    int tmp = 0, i, j = 0, input_buf_size = 0;
590
    int16_t *samples = data;
591

    
592
    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

    
617
    init_get_bits(&s->gb, buf, buf_size*8);
618
    
619
    /* fLaC signature (be) */
620
    if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
621
    {
622
        skip_bits(&s->gb, 32);
623

    
624
        av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
625
        do {
626
            metadata_last = get_bits(&s->gb, 1);
627
            metadata_type = get_bits(&s->gb, 7);
628
            metadata_size = get_bits_long(&s->gb, 24);
629
            
630
            av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
631
                metadata_last, metadata_type,
632
                metadata_size);
633
            if(metadata_size){
634
                switch(metadata_type)
635
                {
636
                case METADATA_TYPE_STREAMINFO:
637
                    metadata_streaminfo(s);
638
                    dump_headers(s);
639
                    break;
640
                default:
641
                    for(i=0; i<metadata_size; i++)
642
                        skip_bits(&s->gb, 8);
643
                }
644
            }
645
        } while(!metadata_last);
646
    }
647
    else
648
    {
649
        
650
        tmp = show_bits(&s->gb, 16);
651
        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
        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
            return -1;
663
        }
664
    }
665

    
666
    
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
//                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
704
        }
705
        *data_size += s->blocksize;
706
    }
707
    }
708
#else
709
    switch(s->decorrelation)
710
    {
711
        case INDEPENDENT:
712
            for (j = 0; j < s->blocksize; j++)
713
            {
714
                for (i = 0; i < s->channels; i++)
715
                    *(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
                int mid, side;
739
                mid = s->decoded[0][i];
740
                side = s->decoded[1][i];
741

    
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
                
748
                mid <<= 1;
749
                if (side & 1)
750
                    mid++;
751
                *(samples++) = (mid + side) >> 1;
752
                *(samples++) = (mid - side) >> 1;
753
#endif
754
            }
755
            break;
756
    }
757
#endif
758

    
759
    *data_size = (int8_t *)samples - (int8_t *)data;
760
//    av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
761

    
762
//    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
        s->bitstream_size=0;
768
        s->bitstream_index=0;
769
        return -1;
770
    }
771

    
772
    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
}
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
        av_freep(&s->decoded[i]);
788
    }
789
    av_freep(&s->bitstream);
790
    
791
    return 0;
792
}
793

    
794
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
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
    .flush= flac_flush,    
811
};