Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flac.c @ 3f1899a8

History | View | Annotate | Download (23.2 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 get_crc8(const uint8_t *buf, int count){
146
    int crc=0;
147
    int i;
148
    
149
    for(i=0; i<count; i++){
150
        crc = table_crc8[crc ^ buf[i]];
151
    }
152

    
153
    return crc;
154
}
155

    
156
static void metadata_streaminfo(FLACContext *s);
157
static void dump_headers(FLACContext *s);
158

    
159
static int flac_decode_init(AVCodecContext * avctx)
160
{
161
    FLACContext *s = avctx->priv_data;
162
    s->avctx = avctx;
163

    
164
    /* initialize based on the demuxer-supplied streamdata header */
165
    if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
166
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
167
        metadata_streaminfo(s);
168
        dump_headers(s);
169
    }
170

    
171
    return 0;
172
}
173

    
174
static void dump_headers(FLACContext *s)
175
{
176
    av_log(s->avctx, AV_LOG_DEBUG, "  Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
177
    av_log(s->avctx, AV_LOG_DEBUG, "  Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
178
    av_log(s->avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
179
    av_log(s->avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
180
    av_log(s->avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
181
}
182

    
183
static void allocate_buffers(FLACContext *s){
184
    int i;
185

    
186
    assert(s->max_blocksize);
187

    
188
    if(s->max_framesize == 0 && s->max_blocksize){
189
        s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
190
    }
191

    
192
    for (i = 0; i < s->channels; i++)
193
    {
194
        s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
195
    }
196

    
197
    s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
198
}
199

    
200
static void metadata_streaminfo(FLACContext *s)
201
{
202
    /* mandatory streaminfo */
203
    s->min_blocksize = get_bits(&s->gb, 16);
204
    s->max_blocksize = get_bits(&s->gb, 16);
205

    
206
    s->min_framesize = get_bits_long(&s->gb, 24);
207
    s->max_framesize = get_bits_long(&s->gb, 24);
208
    
209
    s->samplerate = get_bits_long(&s->gb, 20);
210
    s->channels = get_bits(&s->gb, 3) + 1;
211
    s->bps = get_bits(&s->gb, 5) + 1;
212
    
213
    s->avctx->channels = s->channels;
214
    s->avctx->sample_rate = s->samplerate;
215

    
216
    skip_bits(&s->gb, 36); /* total num of samples */
217
    
218
    skip_bits(&s->gb, 64); /* md5 sum */
219
    skip_bits(&s->gb, 64); /* md5 sum */
220
    
221
    allocate_buffers(s);
222
}
223

    
224
static int decode_residuals(FLACContext *s, int channel, int pred_order)
225
{
226
    int i, tmp, partition, method_type, rice_order;
227
    int sample = 0, samples;
228

    
229
    method_type = get_bits(&s->gb, 2);
230
    if (method_type != 0){
231
        av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
232
        return -1;
233
    }
234
    
235
    rice_order = get_bits(&s->gb, 4);
236

    
237
    samples= s->blocksize >> rice_order;
238

    
239
    sample= 
240
    i= pred_order;
241
    for (partition = 0; partition < (1 << rice_order); partition++)
242
    {
243
        tmp = get_bits(&s->gb, 4);
244
        if (tmp == 15)
245
        {
246
            av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
247
            tmp = get_bits(&s->gb, 5);
248
            for (; i < samples; i++, sample++)
249
                s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
250
        }
251
        else
252
        {
253
//            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
254
            for (; i < samples; i++, sample++){
255
                s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
256
            }
257
        }
258
        i= 0;
259
    }
260

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

    
263
    return 0;
264
}    
265

    
266
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
267
{
268
    int i;
269
        
270
//    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME FIXED\n");
271
        
272
    /* warm up samples */
273
//    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
274
        
275
    for (i = 0; i < pred_order; i++)
276
    {
277
        s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
278
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
279
    }
280
    
281
    if (decode_residuals(s, channel, pred_order) < 0)
282
        return -1;
283

    
284
    switch(pred_order)
285
    {
286
        case 0:
287
            break;
288
        case 1:
289
            for (i = pred_order; i < s->blocksize; i++)
290
                s->decoded[channel][i] +=   s->decoded[channel][i-1];
291
            break;
292
        case 2:
293
            for (i = pred_order; i < s->blocksize; i++)
294
                s->decoded[channel][i] += 2*s->decoded[channel][i-1]
295
                                          - s->decoded[channel][i-2];
296
            break;
297
        case 3:
298
            for (i = pred_order; i < s->blocksize; i++)
299
                s->decoded[channel][i] += 3*s->decoded[channel][i-1] 
300
                                        - 3*s->decoded[channel][i-2]
301
                                        +   s->decoded[channel][i-3];
302
            break;
303
        case 4:
304
            for (i = pred_order; i < s->blocksize; i++)
305
                s->decoded[channel][i] += 4*s->decoded[channel][i-1] 
306
                                        - 6*s->decoded[channel][i-2]
307
                                        + 4*s->decoded[channel][i-3]
308
                                        -   s->decoded[channel][i-4];
309
            break;
310
        default:
311
            av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
312
            return -1;
313
    }
314

    
315
    return 0;
316
}
317

    
318
static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
319
{
320
    int sum, i, j;
321
    int coeff_prec, qlevel;
322
    int coeffs[pred_order];
323
        
324
//    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME LPC\n");
325
        
326
    /* warm up samples */
327
//    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
328
        
329
    for (i = 0; i < pred_order; i++)
330
    {
331
        s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
332
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
333
    }
334
    
335
    coeff_prec = get_bits(&s->gb, 4) + 1;
336
    if (coeff_prec == 16)
337
    {
338
        av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
339
        return -1;
340
    }
341
//    av_log(s->avctx, AV_LOG_DEBUG, "   qlp coeff prec: %d\n", coeff_prec);
342
    qlevel = get_sbits(&s->gb, 5);
343
//    av_log(s->avctx, AV_LOG_DEBUG, "   quant level: %d\n", qlevel);
344
    if(qlevel < 0){
345
        av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
346
        return -1;
347
    }
348

    
349
    for (i = 0; i < pred_order; i++)
350
    {
351
        coeffs[i] = get_sbits(&s->gb, coeff_prec);
352
//        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, coeffs[i]);
353
    }
354
    
355
    if (decode_residuals(s, channel, pred_order) < 0)
356
        return -1;
357

    
358
    for (i = pred_order; i < s->blocksize; i++)
359
    {
360
        sum = 0;
361
        for (j = 0; j < pred_order; j++)
362
            sum += coeffs[j] * s->decoded[channel][i-j-1];
363
        s->decoded[channel][i] += sum >> qlevel;
364
    }
365
    
366
    return 0;
367
}
368

    
369
static inline int decode_subframe(FLACContext *s, int channel)
370
{
371
    int type, wasted = 0;
372
    int i, tmp;
373
    
374
    s->curr_bps = s->bps;
375
    if(channel == 0){
376
        if(s->decorrelation == RIGHT_SIDE)
377
            s->curr_bps++;
378
    }else{
379
        if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
380
            s->curr_bps++;
381
    }
382

    
383
    if (get_bits1(&s->gb))
384
    {
385
        av_log(s->avctx, AV_LOG_DEBUG, "invalid subframe padding\n");
386
        return -1;
387
    }
388
    type = get_bits(&s->gb, 6);
389
//    wasted = get_bits1(&s->gb);
390
    
391
//    if (wasted)
392
//    {
393
//        while (!get_bits1(&s->gb))
394
//            wasted++;
395
//        if (wasted)
396
//            wasted++;
397
//        s->curr_bps -= wasted;
398
//    }
399
#if 0
400
    wasted= 16 - av_log2(show_bits(&s->gb, 17));
401
    skip_bits(&s->gb, wasted+1);
402
    s->curr_bps -= wasted;
403
#else
404
    if (get_bits1(&s->gb))
405
    {
406
        wasted = 1;
407
        while (!get_bits1(&s->gb))
408
            wasted++;
409
        s->curr_bps -= wasted;
410
        av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
411
    }
412
#endif
413
//FIXME use av_log2 for types
414
    if (type == 0)
415
    {
416
        av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
417
        tmp = get_sbits(&s->gb, s->curr_bps);
418
        for (i = 0; i < s->blocksize; i++)
419
            s->decoded[channel][i] = tmp;
420
    }
421
    else if (type == 1)
422
    {
423
        av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
424
        for (i = 0; i < s->blocksize; i++)
425
            s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
426
    }
427
    else if ((type >= 8) && (type <= 12))
428
    {
429
//        av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
430
        if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
431
            return -1;
432
    }
433
    else if (type >= 32)
434
    {
435
//        av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
436
        if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
437
            return -1;
438
    }
439
    else
440
    {
441
        av_log(s->avctx, AV_LOG_DEBUG, "invalid coding type\n");
442
        return -1;
443
    }
444
        
445
    if (wasted)
446
    {
447
        int i;
448
        for (i = 0; i < s->blocksize; i++)
449
            s->decoded[channel][i] <<= wasted;
450
    }
451

    
452
    return 0;
453
}
454

    
455
static int decode_frame(FLACContext *s)
456
{
457
    int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
458
    int decorrelation, bps, blocksize, samplerate;
459
    
460
    blocksize_code = get_bits(&s->gb, 4);
461

    
462
    sample_rate_code = get_bits(&s->gb, 4);
463
    
464
    assignment = get_bits(&s->gb, 4); /* channel assignment */
465
    if (assignment < 8 && s->channels == assignment+1)
466
        decorrelation = INDEPENDENT;
467
    else if (assignment >=8 && assignment < 11 && s->channels == 2)
468
        decorrelation = LEFT_SIDE + assignment - 8;
469
    else
470
    {
471
        av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
472
        return -1;
473
    }
474
        
475
    sample_size_code = get_bits(&s->gb, 3);
476
    if(sample_size_code == 0)
477
        bps= s->bps;
478
    else if((sample_size_code != 3) && (sample_size_code != 7))
479
        bps = sample_size_table[sample_size_code];
480
    else 
481
    {
482
        av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
483
        return -1;
484
    }
485

    
486
    if (get_bits1(&s->gb))
487
    {
488
        av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
489
        return -1;
490
    }
491
    
492
    if(get_utf8(&s->gb) < 0){
493
        av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
494
        return -1;
495
    }
496
#if 0    
497
    if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
498
        (s->min_blocksize != s->max_blocksize)){
499
    }else{
500
    }
501
#endif
502
    
503
    if (blocksize_code == 0)
504
        blocksize = s->min_blocksize;
505
    else if (blocksize_code == 6)
506
        blocksize = get_bits(&s->gb, 8)+1;
507
    else if (blocksize_code == 7)
508
        blocksize = get_bits(&s->gb, 16)+1;
509
    else 
510
        blocksize = blocksize_table[blocksize_code];
511

    
512
    if(blocksize > s->max_blocksize){
513
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
514
        return -1;
515
    }
516

    
517
    if (sample_rate_code == 0){
518
        samplerate= s->samplerate;
519
    }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
520
        samplerate = sample_rate_table[sample_rate_code];
521
    else if (sample_rate_code == 12)
522
        samplerate = get_bits(&s->gb, 8) * 1000;
523
    else if (sample_rate_code == 13)
524
        samplerate = get_bits(&s->gb, 16);
525
    else if (sample_rate_code == 14)
526
        samplerate = get_bits(&s->gb, 16) * 10;
527
    else{
528
        av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
529
        return -1;
530
    }
531

    
532
    skip_bits(&s->gb, 8);
533
    crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
534
    if(crc8){
535
        av_log(s->avctx, AV_LOG_ERROR, "header crc missmatch crc=%2X\n", crc8);
536
        return -1;
537
    }
538
    
539
    s->blocksize    = blocksize;
540
    s->samplerate   = samplerate;
541
    s->bps          = bps;
542
    s->decorrelation= decorrelation;
543

    
544
//    dump_headers(s);
545

    
546
    /* subframes */
547
    for (i = 0; i < s->channels; i++)
548
    {
549
//        av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
550
        if (decode_subframe(s, i) < 0)
551
            return -1;
552
    }
553
    
554
    align_get_bits(&s->gb);
555

    
556
    /* frame footer */
557
    skip_bits(&s->gb, 16); /* data crc */
558

    
559
    return 0;
560
}
561

    
562
static int flac_decode_frame(AVCodecContext *avctx,
563
                            void *data, int *data_size,
564
                            uint8_t *buf, int buf_size)
565
{
566
    FLACContext *s = avctx->priv_data;
567
    int metadata_last, metadata_type, metadata_size;
568
    int tmp = 0, i, j = 0, input_buf_size = 0;
569
    int16_t *samples = data;
570

    
571
    if(s->max_framesize == 0){
572
        s->max_framesize= 8192; // should hopefully be enough for the first header
573
        s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
574
    }
575

    
576
    if(1 && s->max_framesize){//FIXME truncated
577
            buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
578
            input_buf_size= buf_size;
579

    
580
            if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
581
//                printf("memmove\n");
582
                memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
583
                s->bitstream_index=0;
584
            }
585
            memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
586
            buf= &s->bitstream[s->bitstream_index];
587
            buf_size += s->bitstream_size;
588
            s->bitstream_size= buf_size;
589
            
590
            if(buf_size < s->max_framesize){
591
//                printf("wanna more data ...\n");
592
                return input_buf_size;
593
            }
594
    }
595

    
596
    init_get_bits(&s->gb, buf, buf_size*8);
597
    
598
    /* fLaC signature (be) */
599
    if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
600
    {
601
        skip_bits(&s->gb, 32);
602

    
603
        av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
604
        do {
605
            metadata_last = get_bits(&s->gb, 1);
606
            metadata_type = get_bits(&s->gb, 7);
607
            metadata_size = get_bits_long(&s->gb, 24);
608
            
609
            av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
610
                metadata_last, metadata_type,
611
                metadata_size);
612
            if(metadata_size){
613
                switch(metadata_type)
614
                {
615
                case METADATA_TYPE_STREAMINFO:
616
                    metadata_streaminfo(s);
617
                    dump_headers(s);
618
                    break;
619
                default:
620
                    for(i=0; i<metadata_size; i++)
621
                        skip_bits(&s->gb, 8);
622
                }
623
            }
624
        } while(!metadata_last);
625
    }
626
    else
627
    {
628
        
629
        tmp = show_bits(&s->gb, 16);
630
        if(tmp != 0xFFF8){
631
            av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
632
            while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
633
                skip_bits(&s->gb, 8);
634
            goto end; // we may not have enough bits left to decode a frame, so try next time
635
        }
636
        skip_bits(&s->gb, 16);
637
        if (decode_frame(s) < 0){
638
            av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
639
            s->bitstream_size=0;
640
            s->bitstream_index=0;
641
            return -1;
642
        }
643
    }
644

    
645
    
646
#if 0
647
    /* fix the channel order here */
648
    if (s->order == MID_SIDE)
649
    {
650
        short *left = samples;
651
        short *right = samples + s->blocksize;
652
        for (i = 0; i < s->blocksize; i += 2)
653
        {
654
            uint32_t x = s->decoded[0][i];
655
            uint32_t y = s->decoded[0][i+1];
656

657
            right[i] = x - (y / 2);
658
            left[i] = right[i] + y;
659
        }
660
        *data_size = 2 * s->blocksize;
661
    }
662
    else
663
    {
664
    for (i = 0; i < s->channels; i++)
665
    {
666
        switch(s->order)
667
        {
668
            case INDEPENDENT:
669
                for (j = 0; j < s->blocksize; j++)
670
                    samples[(s->blocksize*i)+j] = s->decoded[i][j];
671
                break;
672
            case LEFT_SIDE:
673
            case RIGHT_SIDE:
674
                if (i == 0)
675
                    for (j = 0; j < s->blocksize; j++)
676
                        samples[(s->blocksize*i)+j] = s->decoded[0][j];
677
                else
678
                    for (j = 0; j < s->blocksize; j++)
679
                        samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
680
                break;
681
//            case MID_SIDE:
682
//                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
683
        }
684
        *data_size += s->blocksize;
685
    }
686
    }
687
#else
688
    switch(s->decorrelation)
689
    {
690
        case INDEPENDENT:
691
            for (j = 0; j < s->blocksize; j++)
692
            {
693
                for (i = 0; i < s->channels; i++)
694
                    *(samples++) = s->decoded[i][j];
695
            }
696
            break;
697
        case LEFT_SIDE:
698
            assert(s->channels == 2);
699
            for (i = 0; i < s->blocksize; i++)
700
            {
701
                *(samples++) = s->decoded[0][i];
702
                *(samples++) = s->decoded[0][i] - s->decoded[1][i];
703
            }
704
            break;
705
        case RIGHT_SIDE:
706
            assert(s->channels == 2);
707
            for (i = 0; i < s->blocksize; i++)
708
            {
709
                *(samples++) = s->decoded[0][i] + s->decoded[1][i];
710
                *(samples++) = s->decoded[1][i];
711
            }
712
            break;
713
        case MID_SIDE:
714
            assert(s->channels == 2);
715
            for (i = 0; i < s->blocksize; i++)
716
            {
717
                int mid, side;
718
                mid = s->decoded[0][i];
719
                side = s->decoded[1][i];
720

    
721
#if 1 //needs to be checked but IMHO it should be binary identical
722
                mid -= side>>1;
723
                *(samples++) = mid + side;
724
                *(samples++) = mid;
725
#else
726
                
727
                mid <<= 1;
728
                if (side & 1)
729
                    mid++;
730
                *(samples++) = (mid + side) >> 1;
731
                *(samples++) = (mid - side) >> 1;
732
#endif
733
            }
734
            break;
735
    }
736
#endif
737

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

    
741
//    s->last_blocksize = s->blocksize;
742
end:
743
    i= (get_bits_count(&s->gb)+7)/8;;
744
    if(i > buf_size){
745
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
746
        s->bitstream_size=0;
747
        s->bitstream_index=0;
748
        return -1;
749
    }
750

    
751
    if(s->bitstream_size){
752
        s->bitstream_index += i;
753
        s->bitstream_size  -= i;
754
        return input_buf_size;
755
    }else 
756
        return i;
757
}
758

    
759
static int flac_decode_close(AVCodecContext *avctx)
760
{
761
    FLACContext *s = avctx->priv_data;
762
    int i;
763
    
764
    for (i = 0; i < s->channels; i++)
765
    {
766
        av_freep(&s->decoded[i]);
767
    }
768
    av_freep(&s->bitstream);
769
    
770
    return 0;
771
}
772

    
773
static void flac_flush(AVCodecContext *avctx){
774
    FLACContext *s = avctx->priv_data;
775

    
776
    s->bitstream_size=
777
    s->bitstream_index= 0;
778
}
779

    
780
AVCodec flac_decoder = {
781
    "flac",
782
    CODEC_TYPE_AUDIO,
783
    CODEC_ID_FLAC,
784
    sizeof(FLACContext),
785
    flac_decode_init,
786
    NULL,
787
    flac_decode_close,
788
    flac_decode_frame,
789
    .flush= flac_flush,    
790
};