Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flacdec.c @ 5d6e4c16

History | View | Annotate | Download (25.5 KB)

1
/*
2
 * FLAC (Free Lossless Audio Codec) decoder
3
 * Copyright (c) 2003 Alex Beregszaszi
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/**
23
 * @file
24
 * FLAC (Free Lossless Audio Codec) decoder
25
 * @author Alex Beregszaszi
26
 *
27
 * For more information on the FLAC format, visit:
28
 *  http://flac.sourceforge.net/
29
 *
30
 * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
31
 * through, starting from the initial 'fLaC' signature; or by passing the
32
 * 34-byte streaminfo structure through avctx->extradata[_size] followed
33
 * by data starting with the 0xFFF8 marker.
34
 */
35

    
36
#include <limits.h>
37

    
38
#include "libavutil/crc.h"
39
#include "avcodec.h"
40
#include "internal.h"
41
#include "get_bits.h"
42
#include "bytestream.h"
43
#include "golomb.h"
44
#include "flac.h"
45
#include "flacdata.h"
46

    
47
#undef NDEBUG
48
#include <assert.h>
49

    
50
typedef struct FLACContext {
51
    FLACSTREAMINFO
52

    
53
    AVCodecContext *avctx;                  ///< parent AVCodecContext
54
    GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
55

    
56
    int blocksize;                          ///< number of samples in the current frame
57
    int curr_bps;                           ///< bps for current subframe, adjusted for channel correlation and wasted bits
58
    int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
59
    int is32;                               ///< flag to indicate if output should be 32-bit instead of 16-bit
60
    int ch_mode;                            ///< channel decorrelation type in the current frame
61
    int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
62

    
63
    int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
64
    uint8_t *bitstream;
65
    unsigned int bitstream_size;
66
    unsigned int bitstream_index;
67
    unsigned int allocated_bitstream_size;
68
} FLACContext;
69

    
70
static const int sample_size_table[] =
71
{ 0, 8, 12, 0, 16, 20, 24, 0 };
72

    
73
static int64_t get_utf8(GetBitContext *gb)
74
{
75
    int64_t val;
76
    GET_UTF8(val, get_bits(gb, 8), return -1;)
77
    return val;
78
}
79

    
80
static void allocate_buffers(FLACContext *s);
81

    
82
int ff_flac_is_extradata_valid(AVCodecContext *avctx,
83
                               enum FLACExtradataFormat *format,
84
                               uint8_t **streaminfo_start)
85
{
86
    if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
87
        av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
88
        return 0;
89
    }
90
    if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
91
        /* extradata contains STREAMINFO only */
92
        if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
93
            av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
94
                   FLAC_STREAMINFO_SIZE-avctx->extradata_size);
95
        }
96
        *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
97
        *streaminfo_start = avctx->extradata;
98
    } else {
99
        if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
100
            av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
101
            return 0;
102
        }
103
        *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
104
        *streaminfo_start = &avctx->extradata[8];
105
    }
106
    return 1;
107
}
108

    
109
static av_cold int flac_decode_init(AVCodecContext *avctx)
110
{
111
    enum FLACExtradataFormat format;
112
    uint8_t *streaminfo;
113
    FLACContext *s = avctx->priv_data;
114
    s->avctx = avctx;
115

    
116
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
117

    
118
    /* for now, the raw FLAC header is allowed to be passed to the decoder as
119
       frame data instead of extradata. */
120
    if (!avctx->extradata)
121
        return 0;
122

    
123
    if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
124
        return -1;
125

    
126
    /* initialize based on the demuxer-supplied streamdata header */
127
    ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
128
    if (s->bps > 16)
129
        avctx->sample_fmt = AV_SAMPLE_FMT_S32;
130
    else
131
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
132
    allocate_buffers(s);
133
    s->got_streaminfo = 1;
134

    
135
    return 0;
136
}
137

    
138
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
139
{
140
    av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
141
    av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
142
    av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
143
    av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
144
    av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
145
}
146

    
147
static void allocate_buffers(FLACContext *s)
148
{
149
    int i;
150

    
151
    assert(s->max_blocksize);
152

    
153
    if (s->max_framesize == 0 && s->max_blocksize) {
154
        s->max_framesize = ff_flac_get_max_frame_size(s->max_blocksize,
155
                                                      s->channels, s->bps);
156
    }
157

    
158
    for (i = 0; i < s->channels; i++) {
159
        s->decoded[i] = av_realloc(s->decoded[i],
160
                                   sizeof(int32_t)*s->max_blocksize);
161
    }
162

    
163
    if (s->allocated_bitstream_size < s->max_framesize)
164
        s->bitstream= av_fast_realloc(s->bitstream,
165
                                      &s->allocated_bitstream_size,
166
                                      s->max_framesize);
167
}
168

    
169
void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
170
                              const uint8_t *buffer)
171
{
172
    GetBitContext gb;
173
    init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
174

    
175
    skip_bits(&gb, 16); /* skip min blocksize */
176
    s->max_blocksize = get_bits(&gb, 16);
177
    if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
178
        av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
179
               s->max_blocksize);
180
        s->max_blocksize = 16;
181
    }
182

    
183
    skip_bits(&gb, 24); /* skip min frame size */
184
    s->max_framesize = get_bits_long(&gb, 24);
185

    
186
    s->samplerate = get_bits_long(&gb, 20);
187
    s->channels = get_bits(&gb, 3) + 1;
188
    s->bps = get_bits(&gb, 5) + 1;
189

    
190
    avctx->channels = s->channels;
191
    avctx->sample_rate = s->samplerate;
192
    avctx->bits_per_raw_sample = s->bps;
193

    
194
    s->samples  = get_bits_long(&gb, 32) << 4;
195
    s->samples |= get_bits(&gb, 4);
196

    
197
    skip_bits_long(&gb, 64); /* md5 sum */
198
    skip_bits_long(&gb, 64); /* md5 sum */
199

    
200
    dump_headers(avctx, s);
201
}
202

    
203
void ff_flac_parse_block_header(const uint8_t *block_header,
204
                                int *last, int *type, int *size)
205
{
206
    int tmp = bytestream_get_byte(&block_header);
207
    if (last)
208
        *last = tmp & 0x80;
209
    if (type)
210
        *type = tmp & 0x7F;
211
    if (size)
212
        *size = bytestream_get_be24(&block_header);
213
}
214

    
215
/**
216
 * Parse the STREAMINFO from an inline header.
217
 * @param s the flac decoding context
218
 * @param buf input buffer, starting with the "fLaC" marker
219
 * @param buf_size buffer size
220
 * @return non-zero if metadata is invalid
221
 */
222
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
223
{
224
    int metadata_type, metadata_size;
225

    
226
    if (buf_size < FLAC_STREAMINFO_SIZE+8) {
227
        /* need more data */
228
        return 0;
229
    }
230
    ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
231
    if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
232
        metadata_size != FLAC_STREAMINFO_SIZE) {
233
        return AVERROR_INVALIDDATA;
234
    }
235
    ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
236
    allocate_buffers(s);
237
    s->got_streaminfo = 1;
238

    
239
    return 0;
240
}
241

    
242
/**
243
 * Determine the size of an inline header.
244
 * @param buf input buffer, starting with the "fLaC" marker
245
 * @param buf_size buffer size
246
 * @return number of bytes in the header, or 0 if more data is needed
247
 */
248
static int get_metadata_size(const uint8_t *buf, int buf_size)
249
{
250
    int metadata_last, metadata_size;
251
    const uint8_t *buf_end = buf + buf_size;
252

    
253
    buf += 4;
254
    do {
255
        ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
256
        buf += 4;
257
        if (buf + metadata_size > buf_end) {
258
            /* need more data in order to read the complete header */
259
            return 0;
260
        }
261
        buf += metadata_size;
262
    } while (!metadata_last);
263

    
264
    return buf_size - (buf_end - buf);
265
}
266

    
267
static int decode_residuals(FLACContext *s, int channel, int pred_order)
268
{
269
    int i, tmp, partition, method_type, rice_order;
270
    int sample = 0, samples;
271

    
272
    method_type = get_bits(&s->gb, 2);
273
    if (method_type > 1) {
274
        av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
275
               method_type);
276
        return -1;
277
    }
278

    
279
    rice_order = get_bits(&s->gb, 4);
280

    
281
    samples= s->blocksize >> rice_order;
282
    if (pred_order > samples) {
283
        av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
284
               pred_order, samples);
285
        return -1;
286
    }
287

    
288
    sample=
289
    i= pred_order;
290
    for (partition = 0; partition < (1 << rice_order); partition++) {
291
        tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
292
        if (tmp == (method_type == 0 ? 15 : 31)) {
293
            tmp = get_bits(&s->gb, 5);
294
            for (; i < samples; i++, sample++)
295
                s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
296
        } else {
297
            for (; i < samples; i++, sample++) {
298
                s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
299
            }
300
        }
301
        i= 0;
302
    }
303

    
304
    return 0;
305
}
306

    
307
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
308
{
309
    const int blocksize = s->blocksize;
310
    int32_t *decoded = s->decoded[channel];
311
    int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
312

    
313
    /* warm up samples */
314
    for (i = 0; i < pred_order; i++) {
315
        decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
316
    }
317

    
318
    if (decode_residuals(s, channel, pred_order) < 0)
319
        return -1;
320

    
321
    if (pred_order > 0)
322
        a = decoded[pred_order-1];
323
    if (pred_order > 1)
324
        b = a - decoded[pred_order-2];
325
    if (pred_order > 2)
326
        c = b - decoded[pred_order-2] + decoded[pred_order-3];
327
    if (pred_order > 3)
328
        d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
329

    
330
    switch (pred_order) {
331
    case 0:
332
        break;
333
    case 1:
334
        for (i = pred_order; i < blocksize; i++)
335
            decoded[i] = a += decoded[i];
336
        break;
337
    case 2:
338
        for (i = pred_order; i < blocksize; i++)
339
            decoded[i] = a += b += decoded[i];
340
        break;
341
    case 3:
342
        for (i = pred_order; i < blocksize; i++)
343
            decoded[i] = a += b += c += decoded[i];
344
        break;
345
    case 4:
346
        for (i = pred_order; i < blocksize; i++)
347
            decoded[i] = a += b += c += d += decoded[i];
348
        break;
349
    default:
350
        av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
351
        return -1;
352
    }
353

    
354
    return 0;
355
}
356

    
357
static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
358
{
359
    int i, j;
360
    int coeff_prec, qlevel;
361
    int coeffs[32];
362
    int32_t *decoded = s->decoded[channel];
363

    
364
    /* warm up samples */
365
    for (i = 0; i < pred_order; i++) {
366
        decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
367
    }
368

    
369
    coeff_prec = get_bits(&s->gb, 4) + 1;
370
    if (coeff_prec == 16) {
371
        av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
372
        return -1;
373
    }
374
    qlevel = get_sbits(&s->gb, 5);
375
    if (qlevel < 0) {
376
        av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
377
               qlevel);
378
        return -1;
379
    }
380

    
381
    for (i = 0; i < pred_order; i++) {
382
        coeffs[i] = get_sbits(&s->gb, coeff_prec);
383
    }
384

    
385
    if (decode_residuals(s, channel, pred_order) < 0)
386
        return -1;
387

    
388
    if (s->bps > 16) {
389
        int64_t sum;
390
        for (i = pred_order; i < s->blocksize; i++) {
391
            sum = 0;
392
            for (j = 0; j < pred_order; j++)
393
                sum += (int64_t)coeffs[j] * decoded[i-j-1];
394
            decoded[i] += sum >> qlevel;
395
        }
396
    } else {
397
        for (i = pred_order; i < s->blocksize-1; i += 2) {
398
            int c;
399
            int d = decoded[i-pred_order];
400
            int s0 = 0, s1 = 0;
401
            for (j = pred_order-1; j > 0; j--) {
402
                c = coeffs[j];
403
                s0 += c*d;
404
                d = decoded[i-j];
405
                s1 += c*d;
406
            }
407
            c = coeffs[0];
408
            s0 += c*d;
409
            d = decoded[i] += s0 >> qlevel;
410
            s1 += c*d;
411
            decoded[i+1] += s1 >> qlevel;
412
        }
413
        if (i < s->blocksize) {
414
            int sum = 0;
415
            for (j = 0; j < pred_order; j++)
416
                sum += coeffs[j] * decoded[i-j-1];
417
            decoded[i] += sum >> qlevel;
418
        }
419
    }
420

    
421
    return 0;
422
}
423

    
424
static inline int decode_subframe(FLACContext *s, int channel)
425
{
426
    int type, wasted = 0;
427
    int i, tmp;
428

    
429
    s->curr_bps = s->bps;
430
    if (channel == 0) {
431
        if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
432
            s->curr_bps++;
433
    } else {
434
        if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
435
            s->curr_bps++;
436
    }
437

    
438
    if (get_bits1(&s->gb)) {
439
        av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
440
        return -1;
441
    }
442
    type = get_bits(&s->gb, 6);
443

    
444
    if (get_bits1(&s->gb)) {
445
        wasted = 1;
446
        while (!get_bits1(&s->gb))
447
            wasted++;
448
        s->curr_bps -= wasted;
449
    }
450
    if (s->curr_bps > 32) {
451
        av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
452
        return -1;
453
    }
454

    
455
//FIXME use av_log2 for types
456
    if (type == 0) {
457
        tmp = get_sbits_long(&s->gb, s->curr_bps);
458
        for (i = 0; i < s->blocksize; i++)
459
            s->decoded[channel][i] = tmp;
460
    } else if (type == 1) {
461
        for (i = 0; i < s->blocksize; i++)
462
            s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
463
    } else if ((type >= 8) && (type <= 12)) {
464
        if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
465
            return -1;
466
    } else if (type >= 32) {
467
        if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
468
            return -1;
469
    } else {
470
        av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
471
        return -1;
472
    }
473

    
474
    if (wasted) {
475
        int i;
476
        for (i = 0; i < s->blocksize; i++)
477
            s->decoded[channel][i] <<= wasted;
478
    }
479

    
480
    return 0;
481
}
482

    
483
/**
484
 * Validate and decode a frame header.
485
 * @param      avctx AVCodecContext to use as av_log() context
486
 * @param      gb    GetBitContext from which to read frame header
487
 * @param[out] fi    frame information
488
 * @return non-zero on error, 0 if ok
489
 */
490
static int decode_frame_header(AVCodecContext *avctx, GetBitContext *gb,
491
                               FLACFrameInfo *fi)
492
{
493
    int bs_code, sr_code, bps_code;
494

    
495
    /* frame sync code */
496
    skip_bits(gb, 16);
497

    
498
    /* block size and sample rate codes */
499
    bs_code = get_bits(gb, 4);
500
    sr_code = get_bits(gb, 4);
501

    
502
    /* channels and decorrelation */
503
    fi->ch_mode = get_bits(gb, 4);
504
    if (fi->ch_mode < FLAC_MAX_CHANNELS) {
505
        fi->channels = fi->ch_mode + 1;
506
        fi->ch_mode = FLAC_CHMODE_INDEPENDENT;
507
    } else if (fi->ch_mode <= FLAC_CHMODE_MID_SIDE) {
508
        fi->channels = 2;
509
    } else {
510
        av_log(avctx, AV_LOG_ERROR, "invalid channel mode: %d\n", fi->ch_mode);
511
        return -1;
512
    }
513

    
514
    /* bits per sample */
515
    bps_code = get_bits(gb, 3);
516
    if (bps_code == 3 || bps_code == 7) {
517
        av_log(avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n",
518
               bps_code);
519
        return -1;
520
    }
521
    fi->bps = sample_size_table[bps_code];
522

    
523
    /* reserved bit */
524
    if (get_bits1(gb)) {
525
        av_log(avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
526
        return -1;
527
    }
528

    
529
    /* sample or frame count */
530
    if (get_utf8(gb) < 0) {
531
        av_log(avctx, AV_LOG_ERROR, "utf8 fscked\n");
532
        return -1;
533
    }
534

    
535
    /* blocksize */
536
    if (bs_code == 0) {
537
        av_log(avctx, AV_LOG_ERROR, "reserved blocksize code: 0\n");
538
        return -1;
539
    } else if (bs_code == 6) {
540
        fi->blocksize = get_bits(gb, 8) + 1;
541
    } else if (bs_code == 7) {
542
        fi->blocksize = get_bits(gb, 16) + 1;
543
    } else {
544
        fi->blocksize = ff_flac_blocksize_table[bs_code];
545
    }
546

    
547
    /* sample rate */
548
    if (sr_code < 12) {
549
        fi->samplerate = ff_flac_sample_rate_table[sr_code];
550
    } else if (sr_code == 12) {
551
        fi->samplerate = get_bits(gb, 8) * 1000;
552
    } else if (sr_code == 13) {
553
        fi->samplerate = get_bits(gb, 16);
554
    } else if (sr_code == 14) {
555
        fi->samplerate = get_bits(gb, 16) * 10;
556
    } else {
557
        av_log(avctx, AV_LOG_ERROR, "illegal sample rate code %d\n",
558
               sr_code);
559
        return -1;
560
    }
561

    
562
    /* header CRC-8 check */
563
    skip_bits(gb, 8);
564
    if (av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, gb->buffer,
565
               get_bits_count(gb)/8)) {
566
        av_log(avctx, AV_LOG_ERROR, "header crc mismatch\n");
567
        return -1;
568
    }
569

    
570
    return 0;
571
}
572

    
573
static int decode_frame(FLACContext *s)
574
{
575
    int i;
576
    GetBitContext *gb = &s->gb;
577
    FLACFrameInfo fi;
578

    
579
    if (decode_frame_header(s->avctx, gb, &fi)) {
580
        av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
581
        return -1;
582
    }
583

    
584
    if (s->channels && fi.channels != s->channels) {
585
        av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
586
                                       "is not supported\n");
587
        return -1;
588
    }
589
    s->channels = s->avctx->channels = fi.channels;
590
    s->ch_mode = fi.ch_mode;
591

    
592
    if (!s->bps && !fi.bps) {
593
        av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
594
        return -1;
595
    }
596
    if (!fi.bps) {
597
        fi.bps = s->bps;
598
    } else if (s->bps && fi.bps != s->bps) {
599
        av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
600
                                       "supported\n");
601
        return -1;
602
    }
603
    s->bps = s->avctx->bits_per_raw_sample = fi.bps;
604

    
605
    if (s->bps > 16) {
606
        s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
607
        s->sample_shift = 32 - s->bps;
608
        s->is32 = 1;
609
    } else {
610
        s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
611
        s->sample_shift = 16 - s->bps;
612
        s->is32 = 0;
613
    }
614

    
615
    if (!s->max_blocksize)
616
        s->max_blocksize = FLAC_MAX_BLOCKSIZE;
617
    if (fi.blocksize > s->max_blocksize) {
618
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
619
               s->max_blocksize);
620
        return -1;
621
    }
622
    s->blocksize = fi.blocksize;
623

    
624
    if (!s->samplerate && !fi.samplerate) {
625
        av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
626
                                        " or frame header\n");
627
        return -1;
628
    }
629
    if (fi.samplerate == 0) {
630
        fi.samplerate = s->samplerate;
631
    } else if (s->samplerate && fi.samplerate != s->samplerate) {
632
        av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
633
               s->samplerate, fi.samplerate);
634
    }
635
    s->samplerate = s->avctx->sample_rate = fi.samplerate;
636

    
637
    if (!s->got_streaminfo) {
638
        allocate_buffers(s);
639
        s->got_streaminfo = 1;
640
        dump_headers(s->avctx, (FLACStreaminfo *)s);
641
    }
642

    
643
//    dump_headers(s->avctx, (FLACStreaminfo *)s);
644

    
645
    /* subframes */
646
    for (i = 0; i < s->channels; i++) {
647
        if (decode_subframe(s, i) < 0)
648
            return -1;
649
    }
650

    
651
    align_get_bits(gb);
652

    
653
    /* frame footer */
654
    skip_bits(gb, 16); /* data crc */
655

    
656
    return 0;
657
}
658

    
659
static int flac_decode_frame(AVCodecContext *avctx,
660
                            void *data, int *data_size,
661
                            AVPacket *avpkt)
662
{
663
    const uint8_t *buf = avpkt->data;
664
    int buf_size = avpkt->size;
665
    FLACContext *s = avctx->priv_data;
666
    int i, j = 0, input_buf_size = 0, bytes_read = 0;
667
    int16_t *samples_16 = data;
668
    int32_t *samples_32 = data;
669
    int alloc_data_size= *data_size;
670
    int output_size;
671

    
672
    *data_size=0;
673

    
674
    if (s->max_framesize == 0) {
675
        s->max_framesize =
676
            ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
677
                                       FLAC_MAX_CHANNELS, 32);
678
        s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
679
    }
680

    
681
    if (1 && s->max_framesize) { //FIXME truncated
682
        if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C'))
683
            buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize));
684
        input_buf_size= buf_size;
685

    
686
        if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
687
            return -1;
688

    
689
        if (s->allocated_bitstream_size < s->bitstream_size + buf_size)
690
            s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size);
691

    
692
        if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) {
693
            memmove(s->bitstream, &s->bitstream[s->bitstream_index],
694
                    s->bitstream_size);
695
            s->bitstream_index=0;
696
        }
697
        memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size],
698
               buf, buf_size);
699
        buf= &s->bitstream[s->bitstream_index];
700
        buf_size += s->bitstream_size;
701
        s->bitstream_size= buf_size;
702

    
703
        if (buf_size < s->max_framesize && input_buf_size) {
704
            return input_buf_size;
705
        }
706
    }
707

    
708
    /* check that there is at least the smallest decodable amount of data.
709
       this amount corresponds to the smallest valid FLAC frame possible.
710
       FF F8 69 02 00 00 9A 00 00 34 46 */
711
    if (buf_size < 11)
712
        goto end;
713

    
714
    /* check for inline header */
715
    if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
716
        if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
717
            av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
718
            return -1;
719
        }
720
        bytes_read = get_metadata_size(buf, buf_size);
721
        goto end;
722
    }
723

    
724
    /* check for frame sync code and resync stream if necessary */
725
    if ((AV_RB16(buf) & 0xFFFE) != 0xFFF8) {
726
        const uint8_t *buf_end = buf + buf_size;
727
        av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
728
        while (buf+2 < buf_end && (AV_RB16(buf) & 0xFFFE) != 0xFFF8)
729
            buf++;
730
        bytes_read = buf_size - (buf_end - buf);
731
        goto end; // we may not have enough bits left to decode a frame, so try next time
732
    }
733

    
734
    /* decode frame */
735
    init_get_bits(&s->gb, buf, buf_size*8);
736
    if (decode_frame(s) < 0) {
737
        av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
738
        s->bitstream_size=0;
739
        s->bitstream_index=0;
740
        return -1;
741
    }
742
    bytes_read = (get_bits_count(&s->gb)+7)/8;
743

    
744
    /* check if allocated data size is large enough for output */
745
    output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
746
    if (output_size > alloc_data_size) {
747
        av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
748
                                       "allocated data size\n");
749
        goto end;
750
    }
751
    *data_size = output_size;
752

    
753
#define DECORRELATE(left, right)\
754
            assert(s->channels == 2);\
755
            for (i = 0; i < s->blocksize; i++) {\
756
                int a= s->decoded[0][i];\
757
                int b= s->decoded[1][i];\
758
                if (s->is32) {\
759
                    *samples_32++ = (left)  << s->sample_shift;\
760
                    *samples_32++ = (right) << s->sample_shift;\
761
                } else {\
762
                    *samples_16++ = (left)  << s->sample_shift;\
763
                    *samples_16++ = (right) << s->sample_shift;\
764
                }\
765
            }\
766
            break;
767

    
768
    switch (s->ch_mode) {
769
    case FLAC_CHMODE_INDEPENDENT:
770
        for (j = 0; j < s->blocksize; j++) {
771
            for (i = 0; i < s->channels; i++) {
772
                if (s->is32)
773
                    *samples_32++ = s->decoded[i][j] << s->sample_shift;
774
                else
775
                    *samples_16++ = s->decoded[i][j] << s->sample_shift;
776
            }
777
        }
778
        break;
779
    case FLAC_CHMODE_LEFT_SIDE:
780
        DECORRELATE(a,a-b)
781
    case FLAC_CHMODE_RIGHT_SIDE:
782
        DECORRELATE(a+b,b)
783
    case FLAC_CHMODE_MID_SIDE:
784
        DECORRELATE( (a-=b>>1) + b, a)
785
    }
786

    
787
end:
788
    if (bytes_read > buf_size) {
789
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
790
        s->bitstream_size=0;
791
        s->bitstream_index=0;
792
        return -1;
793
    }
794

    
795
    if (s->bitstream_size) {
796
        s->bitstream_index += bytes_read;
797
        s->bitstream_size  -= bytes_read;
798
        return input_buf_size;
799
    } else
800
        return bytes_read;
801
}
802

    
803
static av_cold int flac_decode_close(AVCodecContext *avctx)
804
{
805
    FLACContext *s = avctx->priv_data;
806
    int i;
807

    
808
    for (i = 0; i < s->channels; i++) {
809
        av_freep(&s->decoded[i]);
810
    }
811
    av_freep(&s->bitstream);
812

    
813
    return 0;
814
}
815

    
816
static void flac_flush(AVCodecContext *avctx)
817
{
818
    FLACContext *s = avctx->priv_data;
819

    
820
    s->bitstream_size=
821
    s->bitstream_index= 0;
822
}
823

    
824
AVCodec flac_decoder = {
825
    "flac",
826
    AVMEDIA_TYPE_AUDIO,
827
    CODEC_ID_FLAC,
828
    sizeof(FLACContext),
829
    flac_decode_init,
830
    NULL,
831
    flac_decode_close,
832
    flac_decode_frame,
833
    CODEC_CAP_DELAY | CODEC_CAP_SUBFRAMES, /* FIXME: add a FLAC parser so that
834
                                              we will not need to use either
835
                                              of these capabilities */
836
    .flush= flac_flush,
837
    .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
838
};