Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flac.c @ b6204677

History | View | Annotate | Download (23.8 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 "bitstream.h"
38
#include "golomb.h"
39

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

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

    
47
enum decorrelation_type {
48
    INDEPENDENT,
49
    LEFT_SIDE,
50
    RIGHT_SIDE,
51
    MID_SIDE,
52
};
53

    
54
typedef struct FLACContext {
55
    AVCodecContext *avctx;
56
    GetBitContext gb;
57

    
58
    int min_blocksize, max_blocksize;
59
    int min_framesize, max_framesize;
60
    int samplerate, channels;
61
    int blocksize/*, last_blocksize*/;
62
    int bps, curr_bps;
63
    enum decorrelation_type decorrelation;
64

    
65
    int32_t *decoded[MAX_CHANNELS];
66
    uint8_t *bitstream;
67
    int bitstream_size;
68
    int bitstream_index;
69
    int allocated_bitstream_size;
70
} FLACContext;
71

    
72
#define METADATA_TYPE_STREAMINFO 0
73

    
74
static int sample_rate_table[] =
75
{ 0, 0, 0, 0,
76
  8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
77
  0, 0, 0, 0 };
78

    
79
static int sample_size_table[] =
80
{ 0, 8, 12, 0, 16, 20, 24, 0 };
81

    
82
static int blocksize_table[] = {
83
     0,    192, 576<<0, 576<<1, 576<<2, 576<<3,      0,      0,
84
256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
85
};
86

    
87
static const uint8_t table_crc8[256] = {
88
    0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
89
    0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
90
    0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,
91
    0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d,
92
    0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5,
93
    0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
94
    0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85,
95
    0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd,
96
    0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2,
97
    0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea,
98
    0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2,
99
    0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
100
    0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32,
101
    0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a,
102
    0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42,
103
    0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a,
104
    0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c,
105
    0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
106
    0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec,
107
    0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4,
108
    0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c,
109
    0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44,
110
    0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c,
111
    0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
112
    0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b,
113
    0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63,
114
    0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b,
115
    0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13,
116
    0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb,
117
    0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
118
    0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb,
119
    0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3
120
};
121

    
122
static int64_t get_utf8(GetBitContext *gb)
123
{
124
    uint64_t val;
125
    int ones=0, bytes;
126

    
127
    while(get_bits1(gb))
128
        ones++;
129

    
130
    if     (ones==0) bytes=0;
131
    else if(ones==1) return -1;
132
    else             bytes= ones - 1;
133

    
134
    val= get_bits(gb, 7-ones);
135
    while(bytes--){
136
        const int tmp = get_bits(gb, 8);
137

    
138
        if((tmp>>6) != 2)
139
            return -1;
140
        val<<=6;
141
        val|= tmp&0x3F;
142
    }
143
    return val;
144
}
145

    
146
#if 0
147
static int skip_utf8(GetBitContext *gb)
148
{
149
    int ones=0, bytes;
150

151
    while(get_bits1(gb))
152
        ones++;
153

154
    if     (ones==0) bytes=0;
155
    else if(ones==1) return -1;
156
    else             bytes= ones - 1;
157

158
    skip_bits(gb, 7-ones);
159
    while(bytes--){
160
        const int tmp = get_bits(gb, 8);
161

162
        if((tmp>>6) != 2)
163
            return -1;
164
    }
165
    return 0;
166
}
167
#endif
168

    
169
static int get_crc8(const uint8_t *buf, int count){
170
    int crc=0;
171
    int i;
172

    
173
    for(i=0; i<count; i++){
174
        crc = table_crc8[crc ^ buf[i]];
175
    }
176

    
177
    return crc;
178
}
179

    
180
static void metadata_streaminfo(FLACContext *s);
181
static void dump_headers(FLACContext *s);
182

    
183
static int flac_decode_init(AVCodecContext * avctx)
184
{
185
    FLACContext *s = avctx->priv_data;
186
    s->avctx = avctx;
187

    
188
    /* initialize based on the demuxer-supplied streamdata header */
189
    if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
190
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
191
        metadata_streaminfo(s);
192
        dump_headers(s);
193
    }
194

    
195
    return 0;
196
}
197

    
198
static void dump_headers(FLACContext *s)
199
{
200
    av_log(s->avctx, AV_LOG_DEBUG, "  Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
201
    av_log(s->avctx, AV_LOG_DEBUG, "  Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
202
    av_log(s->avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
203
    av_log(s->avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
204
    av_log(s->avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
205
}
206

    
207
static void allocate_buffers(FLACContext *s){
208
    int i;
209

    
210
    assert(s->max_blocksize);
211

    
212
    if(s->max_framesize == 0 && s->max_blocksize){
213
        s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
214
    }
215

    
216
    for (i = 0; i < s->channels; i++)
217
    {
218
        s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
219
    }
220

    
221
    s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
222
}
223

    
224
static void metadata_streaminfo(FLACContext *s)
225
{
226
    /* mandatory streaminfo */
227
    s->min_blocksize = get_bits(&s->gb, 16);
228
    s->max_blocksize = get_bits(&s->gb, 16);
229

    
230
    s->min_framesize = get_bits_long(&s->gb, 24);
231
    s->max_framesize = get_bits_long(&s->gb, 24);
232

    
233
    s->samplerate = get_bits_long(&s->gb, 20);
234
    s->channels = get_bits(&s->gb, 3) + 1;
235
    s->bps = get_bits(&s->gb, 5) + 1;
236

    
237
    s->avctx->channels = s->channels;
238
    s->avctx->sample_rate = s->samplerate;
239

    
240
    skip_bits(&s->gb, 36); /* total num of samples */
241

    
242
    skip_bits(&s->gb, 64); /* md5 sum */
243
    skip_bits(&s->gb, 64); /* md5 sum */
244

    
245
    allocate_buffers(s);
246
}
247

    
248
static int decode_residuals(FLACContext *s, int channel, int pred_order)
249
{
250
    int i, tmp, partition, method_type, rice_order;
251
    int sample = 0, samples;
252

    
253
    method_type = get_bits(&s->gb, 2);
254
    if (method_type != 0){
255
        av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
256
        return -1;
257
    }
258

    
259
    rice_order = get_bits(&s->gb, 4);
260

    
261
    samples= s->blocksize >> rice_order;
262

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

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

    
287
    return 0;
288
}
289

    
290
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
291
{
292
    int i;
293

    
294
//    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME FIXED\n");
295

    
296
    /* warm up samples */
297
//    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
298

    
299
    for (i = 0; i < pred_order; i++)
300
    {
301
        s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
302
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
303
    }
304

    
305
    if (decode_residuals(s, channel, pred_order) < 0)
306
        return -1;
307

    
308
    switch(pred_order)
309
    {
310
        case 0:
311
            break;
312
        case 1:
313
            for (i = pred_order; i < s->blocksize; i++)
314
                s->decoded[channel][i] +=   s->decoded[channel][i-1];
315
            break;
316
        case 2:
317
            for (i = pred_order; i < s->blocksize; i++)
318
                s->decoded[channel][i] += 2*s->decoded[channel][i-1]
319
                                          - s->decoded[channel][i-2];
320
            break;
321
        case 3:
322
            for (i = pred_order; i < s->blocksize; i++)
323
                s->decoded[channel][i] += 3*s->decoded[channel][i-1]
324
                                        - 3*s->decoded[channel][i-2]
325
                                        +   s->decoded[channel][i-3];
326
            break;
327
        case 4:
328
            for (i = pred_order; i < s->blocksize; i++)
329
                s->decoded[channel][i] += 4*s->decoded[channel][i-1]
330
                                        - 6*s->decoded[channel][i-2]
331
                                        + 4*s->decoded[channel][i-3]
332
                                        -   s->decoded[channel][i-4];
333
            break;
334
        default:
335
            av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
336
            return -1;
337
    }
338

    
339
    return 0;
340
}
341

    
342
static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
343
{
344
    int sum, i, j;
345
    int coeff_prec, qlevel;
346
    int coeffs[pred_order];
347

    
348
//    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME LPC\n");
349

    
350
    /* warm up samples */
351
//    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
352

    
353
    for (i = 0; i < pred_order; i++)
354
    {
355
        s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
356
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
357
    }
358

    
359
    coeff_prec = get_bits(&s->gb, 4) + 1;
360
    if (coeff_prec == 16)
361
    {
362
        av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
363
        return -1;
364
    }
365
//    av_log(s->avctx, AV_LOG_DEBUG, "   qlp coeff prec: %d\n", coeff_prec);
366
    qlevel = get_sbits(&s->gb, 5);
367
//    av_log(s->avctx, AV_LOG_DEBUG, "   quant level: %d\n", qlevel);
368
    if(qlevel < 0){
369
        av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
370
        return -1;
371
    }
372

    
373
    for (i = 0; i < pred_order; i++)
374
    {
375
        coeffs[i] = get_sbits(&s->gb, coeff_prec);
376
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, coeffs[i]);
377
    }
378

    
379
    if (decode_residuals(s, channel, pred_order) < 0)
380
        return -1;
381

    
382
    for (i = pred_order; i < s->blocksize; i++)
383
    {
384
        sum = 0;
385
        for (j = 0; j < pred_order; j++)
386
            sum += coeffs[j] * s->decoded[channel][i-j-1];
387
        s->decoded[channel][i] += sum >> qlevel;
388
    }
389

    
390
    return 0;
391
}
392

    
393
static inline int decode_subframe(FLACContext *s, int channel)
394
{
395
    int type, wasted = 0;
396
    int i, tmp;
397

    
398
    s->curr_bps = s->bps;
399
    if(channel == 0){
400
        if(s->decorrelation == RIGHT_SIDE)
401
            s->curr_bps++;
402
    }else{
403
        if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
404
            s->curr_bps++;
405
    }
406

    
407
    if (get_bits1(&s->gb))
408
    {
409
        av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
410
        return -1;
411
    }
412
    type = get_bits(&s->gb, 6);
413
//    wasted = get_bits1(&s->gb);
414

    
415
//    if (wasted)
416
//    {
417
//        while (!get_bits1(&s->gb))
418
//            wasted++;
419
//        if (wasted)
420
//            wasted++;
421
//        s->curr_bps -= wasted;
422
//    }
423
#if 0
424
    wasted= 16 - av_log2(show_bits(&s->gb, 17));
425
    skip_bits(&s->gb, wasted+1);
426
    s->curr_bps -= wasted;
427
#else
428
    if (get_bits1(&s->gb))
429
    {
430
        wasted = 1;
431
        while (!get_bits1(&s->gb))
432
            wasted++;
433
        s->curr_bps -= wasted;
434
        av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
435
    }
436
#endif
437
//FIXME use av_log2 for types
438
    if (type == 0)
439
    {
440
        av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
441
        tmp = get_sbits(&s->gb, s->curr_bps);
442
        for (i = 0; i < s->blocksize; i++)
443
            s->decoded[channel][i] = tmp;
444
    }
445
    else if (type == 1)
446
    {
447
        av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
448
        for (i = 0; i < s->blocksize; i++)
449
            s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
450
    }
451
    else if ((type >= 8) && (type <= 12))
452
    {
453
//        av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
454
        if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
455
            return -1;
456
    }
457
    else if (type >= 32)
458
    {
459
//        av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
460
        if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
461
            return -1;
462
    }
463
    else
464
    {
465
        av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
466
        return -1;
467
    }
468

    
469
    if (wasted)
470
    {
471
        int i;
472
        for (i = 0; i < s->blocksize; i++)
473
            s->decoded[channel][i] <<= wasted;
474
    }
475

    
476
    return 0;
477
}
478

    
479
static int decode_frame(FLACContext *s)
480
{
481
    int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
482
    int decorrelation, bps, blocksize, samplerate;
483

    
484
    blocksize_code = get_bits(&s->gb, 4);
485

    
486
    sample_rate_code = get_bits(&s->gb, 4);
487

    
488
    assignment = get_bits(&s->gb, 4); /* channel assignment */
489
    if (assignment < 8 && s->channels == assignment+1)
490
        decorrelation = INDEPENDENT;
491
    else if (assignment >=8 && assignment < 11 && s->channels == 2)
492
        decorrelation = LEFT_SIDE + assignment - 8;
493
    else
494
    {
495
        av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
496
        return -1;
497
    }
498

    
499
    sample_size_code = get_bits(&s->gb, 3);
500
    if(sample_size_code == 0)
501
        bps= s->bps;
502
    else if((sample_size_code != 3) && (sample_size_code != 7))
503
        bps = sample_size_table[sample_size_code];
504
    else
505
    {
506
        av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", sample_size_code);
507
        return -1;
508
    }
509

    
510
    if (get_bits1(&s->gb))
511
    {
512
        av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
513
        return -1;
514
    }
515

    
516
    if(get_utf8(&s->gb) < 0){
517
        av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
518
        return -1;
519
    }
520
#if 0
521
    if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
522
        (s->min_blocksize != s->max_blocksize)){
523
    }else{
524
    }
525
#endif
526

    
527
    if (blocksize_code == 0)
528
        blocksize = s->min_blocksize;
529
    else if (blocksize_code == 6)
530
        blocksize = get_bits(&s->gb, 8)+1;
531
    else if (blocksize_code == 7)
532
        blocksize = get_bits(&s->gb, 16)+1;
533
    else
534
        blocksize = blocksize_table[blocksize_code];
535

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

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

    
556
    skip_bits(&s->gb, 8);
557
    crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
558
    if(crc8){
559
        av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
560
        return -1;
561
    }
562

    
563
    s->blocksize    = blocksize;
564
    s->samplerate   = samplerate;
565
    s->bps          = bps;
566
    s->decorrelation= decorrelation;
567

    
568
//    dump_headers(s);
569

    
570
    /* subframes */
571
    for (i = 0; i < s->channels; i++)
572
    {
573
//        av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
574
        if (decode_subframe(s, i) < 0)
575
            return -1;
576
    }
577

    
578
    align_get_bits(&s->gb);
579

    
580
    /* frame footer */
581
    skip_bits(&s->gb, 16); /* data crc */
582

    
583
    return 0;
584
}
585

    
586
static int flac_decode_frame(AVCodecContext *avctx,
587
                            void *data, int *data_size,
588
                            uint8_t *buf, int buf_size)
589
{
590
    FLACContext *s = avctx->priv_data;
591
    int metadata_last, metadata_type, metadata_size;
592
    int tmp = 0, i, j = 0, input_buf_size = 0;
593
    int16_t *samples = data;
594

    
595
    if(s->max_framesize == 0){
596
        s->max_framesize= 65536; // should hopefully be enough for the first header
597
        s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
598
    }
599

    
600
    if(1 && s->max_framesize){//FIXME truncated
601
            buf_size= FFMAX(FFMIN(buf_size, s->max_framesize - s->bitstream_size), 0);
602
            input_buf_size= buf_size;
603

    
604
            if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
605
//                printf("memmove\n");
606
                memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
607
                s->bitstream_index=0;
608
            }
609
            memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
610
            buf= &s->bitstream[s->bitstream_index];
611
            buf_size += s->bitstream_size;
612
            s->bitstream_size= buf_size;
613

    
614
            if(buf_size < s->max_framesize){
615
//                printf("wanna more data ...\n");
616
                return input_buf_size;
617
            }
618
    }
619

    
620
    init_get_bits(&s->gb, buf, buf_size*8);
621

    
622
    /* fLaC signature (be) */
623
    if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
624
    {
625
        skip_bits(&s->gb, 32);
626

    
627
        av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
628
        do {
629
            metadata_last = get_bits(&s->gb, 1);
630
            metadata_type = get_bits(&s->gb, 7);
631
            metadata_size = get_bits_long(&s->gb, 24);
632

    
633
            av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
634
                metadata_last, metadata_type,
635
                metadata_size);
636
            if(metadata_size){
637
                switch(metadata_type)
638
                {
639
                case METADATA_TYPE_STREAMINFO:{
640
                    metadata_streaminfo(s);
641

    
642
                    /* Buffer might have been reallocated, reinit bitreader */
643
                    if(buf != &s->bitstream[s->bitstream_index])
644
                    {
645
                        int bits_count = get_bits_count(&s->gb);
646
                        buf= &s->bitstream[s->bitstream_index];
647
                        init_get_bits(&s->gb, buf, buf_size*8);
648
                        skip_bits(&s->gb, bits_count);
649
                    }
650

    
651
                    dump_headers(s);
652
                    break;}
653
                default:
654
                    for(i=0; i<metadata_size; i++)
655
                        skip_bits(&s->gb, 8);
656
                }
657
            }
658
        } while(!metadata_last);
659
    }
660
    else
661
    {
662

    
663
        tmp = show_bits(&s->gb, 16);
664
        if(tmp != 0xFFF8){
665
            av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
666
            while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
667
                skip_bits(&s->gb, 8);
668
            goto end; // we may not have enough bits left to decode a frame, so try next time
669
        }
670
        skip_bits(&s->gb, 16);
671
        if (decode_frame(s) < 0){
672
            av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
673
            s->bitstream_size=0;
674
            s->bitstream_index=0;
675
            return -1;
676
        }
677
    }
678

    
679

    
680
#if 0
681
    /* fix the channel order here */
682
    if (s->order == MID_SIDE)
683
    {
684
        short *left = samples;
685
        short *right = samples + s->blocksize;
686
        for (i = 0; i < s->blocksize; i += 2)
687
        {
688
            uint32_t x = s->decoded[0][i];
689
            uint32_t y = s->decoded[0][i+1];
690

691
            right[i] = x - (y / 2);
692
            left[i] = right[i] + y;
693
        }
694
        *data_size = 2 * s->blocksize;
695
    }
696
    else
697
    {
698
    for (i = 0; i < s->channels; i++)
699
    {
700
        switch(s->order)
701
        {
702
            case INDEPENDENT:
703
                for (j = 0; j < s->blocksize; j++)
704
                    samples[(s->blocksize*i)+j] = s->decoded[i][j];
705
                break;
706
            case LEFT_SIDE:
707
            case RIGHT_SIDE:
708
                if (i == 0)
709
                    for (j = 0; j < s->blocksize; j++)
710
                        samples[(s->blocksize*i)+j] = s->decoded[0][j];
711
                else
712
                    for (j = 0; j < s->blocksize; j++)
713
                        samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
714
                break;
715
//            case MID_SIDE:
716
//                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
717
        }
718
        *data_size += s->blocksize;
719
    }
720
    }
721
#else
722
    switch(s->decorrelation)
723
    {
724
        case INDEPENDENT:
725
            for (j = 0; j < s->blocksize; j++)
726
            {
727
                for (i = 0; i < s->channels; i++)
728
                    *(samples++) = s->decoded[i][j];
729
            }
730
            break;
731
        case LEFT_SIDE:
732
            assert(s->channels == 2);
733
            for (i = 0; i < s->blocksize; i++)
734
            {
735
                *(samples++) = s->decoded[0][i];
736
                *(samples++) = s->decoded[0][i] - s->decoded[1][i];
737
            }
738
            break;
739
        case RIGHT_SIDE:
740
            assert(s->channels == 2);
741
            for (i = 0; i < s->blocksize; i++)
742
            {
743
                *(samples++) = s->decoded[0][i] + s->decoded[1][i];
744
                *(samples++) = s->decoded[1][i];
745
            }
746
            break;
747
        case MID_SIDE:
748
            assert(s->channels == 2);
749
            for (i = 0; i < s->blocksize; i++)
750
            {
751
                int mid, side;
752
                mid = s->decoded[0][i];
753
                side = s->decoded[1][i];
754

    
755
#if 1 //needs to be checked but IMHO it should be binary identical
756
                mid -= side>>1;
757
                *(samples++) = mid + side;
758
                *(samples++) = mid;
759
#else
760

    
761
                mid <<= 1;
762
                if (side & 1)
763
                    mid++;
764
                *(samples++) = (mid + side) >> 1;
765
                *(samples++) = (mid - side) >> 1;
766
#endif
767
            }
768
            break;
769
    }
770
#endif
771

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

    
775
//    s->last_blocksize = s->blocksize;
776
end:
777
    i= (get_bits_count(&s->gb)+7)/8;;
778
    if(i > buf_size){
779
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
780
        s->bitstream_size=0;
781
        s->bitstream_index=0;
782
        return -1;
783
    }
784

    
785
    if(s->bitstream_size){
786
        s->bitstream_index += i;
787
        s->bitstream_size  -= i;
788
        return input_buf_size;
789
    }else
790
        return i;
791
}
792

    
793
static int flac_decode_close(AVCodecContext *avctx)
794
{
795
    FLACContext *s = avctx->priv_data;
796
    int i;
797

    
798
    for (i = 0; i < s->channels; i++)
799
    {
800
        av_freep(&s->decoded[i]);
801
    }
802
    av_freep(&s->bitstream);
803

    
804
    return 0;
805
}
806

    
807
static void flac_flush(AVCodecContext *avctx){
808
    FLACContext *s = avctx->priv_data;
809

    
810
    s->bitstream_size=
811
    s->bitstream_index= 0;
812
}
813

    
814
AVCodec flac_decoder = {
815
    "flac",
816
    CODEC_TYPE_AUDIO,
817
    CODEC_ID_FLAC,
818
    sizeof(FLACContext),
819
    flac_decode_init,
820
    NULL,
821
    flac_decode_close,
822
    flac_decode_frame,
823
    .flush= flac_flush,
824
};