Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flacdec.c @ 72415b2a

History | View | Annotate | Download (24.7 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 libavcodec/flacdec.c
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 = 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 = SAMPLE_FMT_S32;
130
    else
131
        avctx->sample_fmt = 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 (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->ch_mode = fi.ch_mode;
590

    
591
    if (fi.bps && fi.bps != s->bps) {
592
        av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
593
                                       "supported\n");
594
        return -1;
595
    }
596
    if (s->bps > 16) {
597
        s->avctx->sample_fmt = SAMPLE_FMT_S32;
598
        s->sample_shift = 32 - s->bps;
599
        s->is32 = 1;
600
    } else {
601
        s->avctx->sample_fmt = SAMPLE_FMT_S16;
602
        s->sample_shift = 16 - s->bps;
603
        s->is32 = 0;
604
    }
605

    
606
    if (fi.blocksize > s->max_blocksize) {
607
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
608
               s->max_blocksize);
609
        return -1;
610
    }
611
    s->blocksize = fi.blocksize;
612

    
613
    if (fi.samplerate == 0) {
614
        fi.samplerate = s->samplerate;
615
    } else if (fi.samplerate != s->samplerate) {
616
        av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
617
               s->samplerate, fi.samplerate);
618
    }
619
    s->samplerate = s->avctx->sample_rate = fi.samplerate;
620

    
621
//    dump_headers(s->avctx, (FLACStreaminfo *)s);
622

    
623
    /* subframes */
624
    for (i = 0; i < s->channels; i++) {
625
        if (decode_subframe(s, i) < 0)
626
            return -1;
627
    }
628

    
629
    align_get_bits(gb);
630

    
631
    /* frame footer */
632
    skip_bits(gb, 16); /* data crc */
633

    
634
    return 0;
635
}
636

    
637
static int flac_decode_frame(AVCodecContext *avctx,
638
                            void *data, int *data_size,
639
                            AVPacket *avpkt)
640
{
641
    const uint8_t *buf = avpkt->data;
642
    int buf_size = avpkt->size;
643
    FLACContext *s = avctx->priv_data;
644
    int i, j = 0, input_buf_size = 0, bytes_read = 0;
645
    int16_t *samples_16 = data;
646
    int32_t *samples_32 = data;
647
    int alloc_data_size= *data_size;
648
    int output_size;
649

    
650
    *data_size=0;
651

    
652
    if (s->max_framesize == 0) {
653
        s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header
654
        s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
655
    }
656

    
657
    if (1 && s->max_framesize) { //FIXME truncated
658
        if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C'))
659
            buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize));
660
        input_buf_size= buf_size;
661

    
662
        if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
663
            return -1;
664

    
665
        if (s->allocated_bitstream_size < s->bitstream_size + buf_size)
666
            s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size);
667

    
668
        if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) {
669
            memmove(s->bitstream, &s->bitstream[s->bitstream_index],
670
                    s->bitstream_size);
671
            s->bitstream_index=0;
672
        }
673
        memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size],
674
               buf, buf_size);
675
        buf= &s->bitstream[s->bitstream_index];
676
        buf_size += s->bitstream_size;
677
        s->bitstream_size= buf_size;
678

    
679
        if (buf_size < s->max_framesize && input_buf_size) {
680
            return input_buf_size;
681
        }
682
    }
683

    
684
    /* check that there is at least the smallest decodable amount of data.
685
       this amount corresponds to the smallest valid FLAC frame possible.
686
       FF F8 69 02 00 00 9A 00 00 34 46 */
687
    if (buf_size < 11)
688
        goto end;
689

    
690
    /* check for inline header */
691
    if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
692
        if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
693
            av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
694
            return -1;
695
        }
696
        bytes_read = get_metadata_size(buf, buf_size);
697
        goto end;
698
    }
699

    
700
    /* check for frame sync code and resync stream if necessary */
701
    if ((AV_RB16(buf) & 0xFFFE) != 0xFFF8) {
702
        const uint8_t *buf_end = buf + buf_size;
703
        av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
704
        while (buf+2 < buf_end && (AV_RB16(buf) & 0xFFFE) != 0xFFF8)
705
            buf++;
706
        bytes_read = buf_size - (buf_end - buf);
707
        goto end; // we may not have enough bits left to decode a frame, so try next time
708
    }
709

    
710
    /* decode frame */
711
    init_get_bits(&s->gb, buf, buf_size*8);
712
    if (decode_frame(s) < 0) {
713
        av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
714
        s->bitstream_size=0;
715
        s->bitstream_index=0;
716
        return -1;
717
    }
718
    bytes_read = (get_bits_count(&s->gb)+7)/8;
719

    
720
    /* check if allocated data size is large enough for output */
721
    output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
722
    if (output_size > alloc_data_size) {
723
        av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
724
                                       "allocated data size\n");
725
        goto end;
726
    }
727
    *data_size = output_size;
728

    
729
#define DECORRELATE(left, right)\
730
            assert(s->channels == 2);\
731
            for (i = 0; i < s->blocksize; i++) {\
732
                int a= s->decoded[0][i];\
733
                int b= s->decoded[1][i];\
734
                if (s->is32) {\
735
                    *samples_32++ = (left)  << s->sample_shift;\
736
                    *samples_32++ = (right) << s->sample_shift;\
737
                } else {\
738
                    *samples_16++ = (left)  << s->sample_shift;\
739
                    *samples_16++ = (right) << s->sample_shift;\
740
                }\
741
            }\
742
            break;
743

    
744
    switch (s->ch_mode) {
745
    case FLAC_CHMODE_INDEPENDENT:
746
        for (j = 0; j < s->blocksize; j++) {
747
            for (i = 0; i < s->channels; i++) {
748
                if (s->is32)
749
                    *samples_32++ = s->decoded[i][j] << s->sample_shift;
750
                else
751
                    *samples_16++ = s->decoded[i][j] << s->sample_shift;
752
            }
753
        }
754
        break;
755
    case FLAC_CHMODE_LEFT_SIDE:
756
        DECORRELATE(a,a-b)
757
    case FLAC_CHMODE_RIGHT_SIDE:
758
        DECORRELATE(a+b,b)
759
    case FLAC_CHMODE_MID_SIDE:
760
        DECORRELATE( (a-=b>>1) + b, a)
761
    }
762

    
763
end:
764
    if (bytes_read > buf_size) {
765
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
766
        s->bitstream_size=0;
767
        s->bitstream_index=0;
768
        return -1;
769
    }
770

    
771
    if (s->bitstream_size) {
772
        s->bitstream_index += bytes_read;
773
        s->bitstream_size  -= bytes_read;
774
        return input_buf_size;
775
    } else
776
        return bytes_read;
777
}
778

    
779
static av_cold int flac_decode_close(AVCodecContext *avctx)
780
{
781
    FLACContext *s = avctx->priv_data;
782
    int i;
783

    
784
    for (i = 0; i < s->channels; i++) {
785
        av_freep(&s->decoded[i]);
786
    }
787
    av_freep(&s->bitstream);
788

    
789
    return 0;
790
}
791

    
792
static void flac_flush(AVCodecContext *avctx)
793
{
794
    FLACContext *s = avctx->priv_data;
795

    
796
    s->bitstream_size=
797
    s->bitstream_index= 0;
798
}
799

    
800
AVCodec flac_decoder = {
801
    "flac",
802
    AVMEDIA_TYPE_AUDIO,
803
    CODEC_ID_FLAC,
804
    sizeof(FLACContext),
805
    flac_decode_init,
806
    NULL,
807
    flac_decode_close,
808
    flac_decode_frame,
809
    CODEC_CAP_DELAY | CODEC_CAP_SUBFRAMES, /* FIXME: add a FLAC parser so that
810
                                              we will not need to use either
811
                                              of these capabilities */
812
    .flush= flac_flush,
813
    .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
814
};