7a63d8a9a45af2cf382b6fd450b367679bea9c6c
[ffmpeg.git] / libavcodec / flacdec.c
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 "bitstream.h"
42 #include "bytestream.h"
43 #include "golomb.h"
44 #include "flac.h"
45
46 #undef NDEBUG
47 #include <assert.h>
48
49 typedef struct FLACContext {
50     FLACSTREAMINFO
51
52     AVCodecContext *avctx;                  ///< parent AVCodecContext
53     GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
54
55     int blocksize;                          ///< number of samples in the current frame
56     int curr_bps;                           ///< bps for current subframe, adjusted for channel correlation and wasted bits
57     int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
58     int is32;                               ///< flag to indicate if output should be 32-bit instead of 16-bit
59     int ch_mode;                            ///< channel decorrelation type in the current frame
60     int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
61
62     int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
63     uint8_t *bitstream;
64     unsigned int bitstream_size;
65     unsigned int bitstream_index;
66     unsigned int allocated_bitstream_size;
67 } FLACContext;
68
69 static const int sample_rate_table[] =
70 { 0,
71   88200, 176400, 192000,
72   8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
73   0, 0, 0, 0 };
74
75 static const int sample_size_table[] =
76 { 0, 8, 12, 0, 16, 20, 24, 0 };
77
78 static const int blocksize_table[] = {
79      0,    192, 576<<0, 576<<1, 576<<2, 576<<3,      0,      0,
80 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
81 };
82
83 static int64_t get_utf8(GetBitContext *gb)
84 {
85     int64_t val;
86     GET_UTF8(val, get_bits(gb, 8), return -1;)
87     return val;
88 }
89
90 static void allocate_buffers(FLACContext *s);
91
92 int ff_flac_is_extradata_valid(AVCodecContext *avctx,
93                                enum FLACExtradataFormat *format,
94                                uint8_t **streaminfo_start)
95 {
96     if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
97         av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
98         return 0;
99     }
100     if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
101         /* extradata contains STREAMINFO only */
102         if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
103             av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
104                    FLAC_STREAMINFO_SIZE-avctx->extradata_size);
105         }
106         *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
107         *streaminfo_start = avctx->extradata;
108     } else {
109         if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
110             av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
111             return 0;
112         }
113         *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
114         *streaminfo_start = &avctx->extradata[8];
115     }
116     return 1;
117 }
118
119 static av_cold int flac_decode_init(AVCodecContext *avctx)
120 {
121     enum FLACExtradataFormat format;
122     uint8_t *streaminfo;
123     FLACContext *s = avctx->priv_data;
124     s->avctx = avctx;
125
126     avctx->sample_fmt = SAMPLE_FMT_S16;
127
128     /* for now, the raw FLAC header is allowed to be passed to the decoder as
129        frame data instead of extradata. */
130     if (!avctx->extradata)
131         return 0;
132
133     if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
134         return -1;
135
136     /* initialize based on the demuxer-supplied streamdata header */
137     ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
138     allocate_buffers(s);
139     s->got_streaminfo = 1;
140
141     return 0;
142 }
143
144 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
145 {
146     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
147     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
148     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
149     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
150     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
151 }
152
153 static void allocate_buffers(FLACContext *s)
154 {
155     int i;
156
157     assert(s->max_blocksize);
158
159     if (s->max_framesize == 0 && s->max_blocksize) {
160         // FIXME header overhead
161         s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8;
162     }
163
164     for (i = 0; i < s->channels; i++) {
165         s->decoded[i] = av_realloc(s->decoded[i],
166                                    sizeof(int32_t)*s->max_blocksize);
167     }
168
169     if (s->allocated_bitstream_size < s->max_framesize)
170         s->bitstream= av_fast_realloc(s->bitstream,
171                                       &s->allocated_bitstream_size,
172                                       s->max_framesize);
173 }
174
175 void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
176                               const uint8_t *buffer)
177 {
178     GetBitContext gb;
179     init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
180
181     skip_bits(&gb, 16); /* skip min blocksize */
182     s->max_blocksize = get_bits(&gb, 16);
183     if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
184         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
185                s->max_blocksize);
186         s->max_blocksize = 16;
187     }
188
189     skip_bits(&gb, 24); /* skip min frame size */
190     s->max_framesize = get_bits_long(&gb, 24);
191
192     s->samplerate = get_bits_long(&gb, 20);
193     s->channels = get_bits(&gb, 3) + 1;
194     s->bps = get_bits(&gb, 5) + 1;
195
196     avctx->channels = s->channels;
197     avctx->sample_rate = s->samplerate;
198     avctx->bits_per_raw_sample = s->bps;
199     if (s->bps > 16)
200         avctx->sample_fmt = SAMPLE_FMT_S32;
201     else
202         avctx->sample_fmt = SAMPLE_FMT_S16;
203
204     s->samples  = get_bits_long(&gb, 32) << 4;
205     s->samples |= get_bits(&gb, 4);
206
207     skip_bits_long(&gb, 64); /* md5 sum */
208     skip_bits_long(&gb, 64); /* md5 sum */
209
210     dump_headers(avctx, s);
211 }
212
213 void ff_flac_parse_block_header(const uint8_t *block_header,
214                                 int *last, int *type, int *size)
215 {
216     int tmp = bytestream_get_byte(&block_header);
217     if (last)
218         *last = tmp & 0x80;
219     if (type)
220         *type = tmp & 0x7F;
221     if (size)
222         *size = bytestream_get_be24(&block_header);
223 }
224
225 /**
226  * Parse the STREAMINFO from an inline header.
227  * @param s the flac decoding context
228  * @param buf input buffer, starting with the "fLaC" marker
229  * @param buf_size buffer size
230  * @return non-zero if metadata is invalid
231  */
232 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
233 {
234     int metadata_type, metadata_size;
235
236     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
237         /* need more data */
238         return 0;
239     }
240     ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
241     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
242         metadata_size != FLAC_STREAMINFO_SIZE) {
243         return AVERROR_INVALIDDATA;
244     }
245     ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
246     allocate_buffers(s);
247     s->got_streaminfo = 1;
248
249     return 0;
250 }
251
252 /**
253  * Determine the size of an inline header.
254  * @param buf input buffer, starting with the "fLaC" marker
255  * @param buf_size buffer size
256  * @return number of bytes in the header, or 0 if more data is needed
257  */
258 static int get_metadata_size(const uint8_t *buf, int buf_size)
259 {
260     int metadata_last, metadata_size;
261     const uint8_t *buf_end = buf + buf_size;
262
263     buf += 4;
264     do {
265         ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
266         buf += 4;
267         if (buf + metadata_size > buf_end) {
268             /* need more data in order to read the complete header */
269             return 0;
270         }
271         buf += metadata_size;
272     } while (!metadata_last);
273
274     return buf_size - (buf_end - buf);
275 }
276
277 static int decode_residuals(FLACContext *s, int channel, int pred_order)
278 {
279     int i, tmp, partition, method_type, rice_order;
280     int sample = 0, samples;
281
282     method_type = get_bits(&s->gb, 2);
283     if (method_type > 1) {
284         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
285                method_type);
286         return -1;
287     }
288
289     rice_order = get_bits(&s->gb, 4);
290
291     samples= s->blocksize >> rice_order;
292     if (pred_order > samples) {
293         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
294                pred_order, samples);
295         return -1;
296     }
297
298     sample=
299     i= pred_order;
300     for (partition = 0; partition < (1 << rice_order); partition++) {
301         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
302         if (tmp == (method_type == 0 ? 15 : 31)) {
303             tmp = get_bits(&s->gb, 5);
304             for (; i < samples; i++, sample++)
305                 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
306         } else {
307             for (; i < samples; i++, sample++) {
308                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
309             }
310         }
311         i= 0;
312     }
313
314     return 0;
315 }
316
317 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
318 {
319     const int blocksize = s->blocksize;
320     int32_t *decoded = s->decoded[channel];
321     int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
322
323     /* warm up samples */
324     for (i = 0; i < pred_order; i++) {
325         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
326     }
327
328     if (decode_residuals(s, channel, pred_order) < 0)
329         return -1;
330
331     if (pred_order > 0)
332         a = decoded[pred_order-1];
333     if (pred_order > 1)
334         b = a - decoded[pred_order-2];
335     if (pred_order > 2)
336         c = b - decoded[pred_order-2] + decoded[pred_order-3];
337     if (pred_order > 3)
338         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
339
340     switch (pred_order) {
341     case 0:
342         break;
343     case 1:
344         for (i = pred_order; i < blocksize; i++)
345             decoded[i] = a += decoded[i];
346         break;
347     case 2:
348         for (i = pred_order; i < blocksize; i++)
349             decoded[i] = a += b += decoded[i];
350         break;
351     case 3:
352         for (i = pred_order; i < blocksize; i++)
353             decoded[i] = a += b += c += decoded[i];
354         break;
355     case 4:
356         for (i = pred_order; i < blocksize; i++)
357             decoded[i] = a += b += c += d += decoded[i];
358         break;
359     default:
360         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
361         return -1;
362     }
363
364     return 0;
365 }
366
367 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
368 {
369     int i, j;
370     int coeff_prec, qlevel;
371     int coeffs[pred_order];
372     int32_t *decoded = s->decoded[channel];
373
374     /* warm up samples */
375     for (i = 0; i < pred_order; i++) {
376         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
377     }
378
379     coeff_prec = get_bits(&s->gb, 4) + 1;
380     if (coeff_prec == 16) {
381         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
382         return -1;
383     }
384     qlevel = get_sbits(&s->gb, 5);
385     if (qlevel < 0) {
386         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
387                qlevel);
388         return -1;
389     }
390
391     for (i = 0; i < pred_order; i++) {
392         coeffs[i] = get_sbits(&s->gb, coeff_prec);
393     }
394
395     if (decode_residuals(s, channel, pred_order) < 0)
396         return -1;
397
398     if (s->bps > 16) {
399         int64_t sum;
400         for (i = pred_order; i < s->blocksize; i++) {
401             sum = 0;
402             for (j = 0; j < pred_order; j++)
403                 sum += (int64_t)coeffs[j] * decoded[i-j-1];
404             decoded[i] += sum >> qlevel;
405         }
406     } else {
407         for (i = pred_order; i < s->blocksize-1; i += 2) {
408             int c;
409             int d = decoded[i-pred_order];
410             int s0 = 0, s1 = 0;
411             for (j = pred_order-1; j > 0; j--) {
412                 c = coeffs[j];
413                 s0 += c*d;
414                 d = decoded[i-j];
415                 s1 += c*d;
416             }
417             c = coeffs[0];
418             s0 += c*d;
419             d = decoded[i] += s0 >> qlevel;
420             s1 += c*d;
421             decoded[i+1] += s1 >> qlevel;
422         }
423         if (i < s->blocksize) {
424             int sum = 0;
425             for (j = 0; j < pred_order; j++)
426                 sum += coeffs[j] * decoded[i-j-1];
427             decoded[i] += sum >> qlevel;
428         }
429     }
430
431     return 0;
432 }
433
434 static inline int decode_subframe(FLACContext *s, int channel)
435 {
436     int type, wasted = 0;
437     int i, tmp;
438
439     s->curr_bps = s->bps;
440     if (channel == 0) {
441         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
442             s->curr_bps++;
443     } else {
444         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
445             s->curr_bps++;
446     }
447
448     if (get_bits1(&s->gb)) {
449         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
450         return -1;
451     }
452     type = get_bits(&s->gb, 6);
453
454     if (get_bits1(&s->gb)) {
455         wasted = 1;
456         while (!get_bits1(&s->gb))
457             wasted++;
458         s->curr_bps -= wasted;
459     }
460     if (s->curr_bps > 32) {
461         ff_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
462         return -1;
463     }
464
465 //FIXME use av_log2 for types
466     if (type == 0) {
467         tmp = get_sbits_long(&s->gb, s->curr_bps);
468         for (i = 0; i < s->blocksize; i++)
469             s->decoded[channel][i] = tmp;
470     } else if (type == 1) {
471         for (i = 0; i < s->blocksize; i++)
472             s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
473     } else if ((type >= 8) && (type <= 12)) {
474         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
475             return -1;
476     } else if (type >= 32) {
477         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
478             return -1;
479     } else {
480         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
481         return -1;
482     }
483
484     if (wasted) {
485         int i;
486         for (i = 0; i < s->blocksize; i++)
487             s->decoded[channel][i] <<= wasted;
488     }
489
490     return 0;
491 }
492
493 static int decode_frame(FLACContext *s, int alloc_data_size)
494 {
495     int blocksize_code, sample_rate_code, sample_size_code, i, crc8;
496     int ch_mode, bps, blocksize, samplerate;
497
498     blocksize_code = get_bits(&s->gb, 4);
499
500     sample_rate_code = get_bits(&s->gb, 4);
501
502     ch_mode = get_bits(&s->gb, 4); /* channel assignment */
503     if (ch_mode < FLAC_MAX_CHANNELS && s->channels == ch_mode+1) {
504         ch_mode = FLAC_CHMODE_INDEPENDENT;
505     } else if (ch_mode > FLAC_CHMODE_MID_SIDE || s->channels != 2) {
506         av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n",
507                ch_mode, s->channels);
508         return -1;
509     }
510
511     sample_size_code = get_bits(&s->gb, 3);
512     if (sample_size_code == 0)
513         bps= s->bps;
514     else if ((sample_size_code != 3) && (sample_size_code != 7))
515         bps = sample_size_table[sample_size_code];
516     else {
517         av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n",
518                sample_size_code);
519         return -1;
520     }
521     if (bps > 16) {
522         s->avctx->sample_fmt = SAMPLE_FMT_S32;
523         s->sample_shift = 32 - bps;
524         s->is32 = 1;
525     } else {
526         s->avctx->sample_fmt = SAMPLE_FMT_S16;
527         s->sample_shift = 16 - bps;
528         s->is32 = 0;
529     }
530     s->bps = s->avctx->bits_per_raw_sample = bps;
531
532     if (get_bits1(&s->gb)) {
533         av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
534         return -1;
535     }
536
537     if (get_utf8(&s->gb) < 0) {
538         av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
539         return -1;
540     }
541
542     if (blocksize_code == 0) {
543         av_log(s->avctx, AV_LOG_ERROR, "reserved blocksize code: 0\n");
544         return -1;
545     } else if (blocksize_code == 6)
546         blocksize = get_bits(&s->gb, 8)+1;
547     else if (blocksize_code == 7)
548         blocksize = get_bits(&s->gb, 16)+1;
549     else
550         blocksize = blocksize_table[blocksize_code];
551
552     if (blocksize > s->max_blocksize) {
553         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize,
554                s->max_blocksize);
555         return -1;
556     }
557
558     if (blocksize * s->channels * (s->is32 ? 4 : 2) > alloc_data_size)
559         return -1;
560
561     if (sample_rate_code == 0)
562         samplerate= s->samplerate;
563     else if (sample_rate_code < 12)
564         samplerate = sample_rate_table[sample_rate_code];
565     else if (sample_rate_code == 12)
566         samplerate = get_bits(&s->gb, 8) * 1000;
567     else if (sample_rate_code == 13)
568         samplerate = get_bits(&s->gb, 16);
569     else if (sample_rate_code == 14)
570         samplerate = get_bits(&s->gb, 16) * 10;
571     else {
572         av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n",
573                sample_rate_code);
574         return -1;
575     }
576
577     skip_bits(&s->gb, 8);
578     crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
579                   s->gb.buffer, get_bits_count(&s->gb)/8);
580     if (crc8) {
581         av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
582         return -1;
583     }
584
585     s->blocksize    = blocksize;
586     s->samplerate   = samplerate;
587     s->bps          = bps;
588     s->ch_mode      = ch_mode;
589
590 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
591
592     /* subframes */
593     for (i = 0; i < s->channels; i++) {
594         if (decode_subframe(s, i) < 0)
595             return -1;
596     }
597
598     align_get_bits(&s->gb);
599
600     /* frame footer */
601     skip_bits(&s->gb, 16); /* data crc */
602
603     return 0;
604 }
605
606 static int flac_decode_frame(AVCodecContext *avctx,
607                             void *data, int *data_size,
608                             const uint8_t *buf, int buf_size)
609 {
610     FLACContext *s = avctx->priv_data;
611     int i, j = 0, input_buf_size = 0, bytes_read = 0;
612     int16_t *samples_16 = data;
613     int32_t *samples_32 = data;
614     int alloc_data_size= *data_size;
615
616     *data_size=0;
617
618     if (s->max_framesize == 0) {
619         s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header
620         s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
621     }
622
623     if (1 && s->max_framesize) { //FIXME truncated
624         if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C'))
625             buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize));
626         input_buf_size= buf_size;
627
628         if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
629             return -1;
630
631         if (s->allocated_bitstream_size < s->bitstream_size + buf_size)
632             s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size);
633
634         if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) {
635             memmove(s->bitstream, &s->bitstream[s->bitstream_index],
636                     s->bitstream_size);
637             s->bitstream_index=0;
638         }
639         memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size],
640                buf, buf_size);
641         buf= &s->bitstream[s->bitstream_index];
642         buf_size += s->bitstream_size;
643         s->bitstream_size= buf_size;
644
645         if (buf_size < s->max_framesize && input_buf_size) {
646             return input_buf_size;
647         }
648     }
649
650     /* check that there is at least the smallest decodable amount of data.
651        this amount corresponds to the smallest valid FLAC frame possible.
652        FF F8 69 02 00 00 9A 00 00 34 46 */
653     if (buf_size < 11)
654         goto end;
655
656     /* check for inline header */
657     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
658         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
659             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
660             return -1;
661         }
662         bytes_read = get_metadata_size(buf, buf_size);
663         goto end;
664     }
665
666     /* check for frame sync code and resync stream if necessary */
667     if ((AV_RB16(buf) & 0xFFFE) != 0xFFF8) {
668         const uint8_t *buf_end = buf + buf_size;
669         av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
670         while (buf+2 < buf_end && (AV_RB16(buf) & 0xFFFE) != 0xFFF8)
671             buf++;
672         bytes_read = buf_size - (buf_end - buf);
673         goto end; // we may not have enough bits left to decode a frame, so try next time
674     }
675
676     /* decode frame */
677     init_get_bits(&s->gb, buf, buf_size*8);
678     skip_bits(&s->gb, 16);
679     if (decode_frame(s, alloc_data_size) < 0) {
680         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
681         s->bitstream_size=0;
682         s->bitstream_index=0;
683         return -1;
684     }
685     *data_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
686     bytes_read = (get_bits_count(&s->gb)+7)/8;
687
688 #define DECORRELATE(left, right)\
689             assert(s->channels == 2);\
690             for (i = 0; i < s->blocksize; i++) {\
691                 int a= s->decoded[0][i];\
692                 int b= s->decoded[1][i];\
693                 if (s->is32) {\
694                     *samples_32++ = (left)  << s->sample_shift;\
695                     *samples_32++ = (right) << s->sample_shift;\
696                 } else {\
697                     *samples_16++ = (left)  << s->sample_shift;\
698                     *samples_16++ = (right) << s->sample_shift;\
699                 }\
700             }\
701             break;
702
703     switch (s->ch_mode) {
704     case FLAC_CHMODE_INDEPENDENT:
705         for (j = 0; j < s->blocksize; j++) {
706             for (i = 0; i < s->channels; i++) {
707                 if (s->is32)
708                     *samples_32++ = s->decoded[i][j] << s->sample_shift;
709                 else
710                     *samples_16++ = s->decoded[i][j] << s->sample_shift;
711             }
712         }
713         break;
714     case FLAC_CHMODE_LEFT_SIDE:
715         DECORRELATE(a,a-b)
716     case FLAC_CHMODE_RIGHT_SIDE:
717         DECORRELATE(a+b,b)
718     case FLAC_CHMODE_MID_SIDE:
719         DECORRELATE( (a-=b>>1) + b, a)
720     }
721
722 end:
723     if (bytes_read > buf_size) {
724         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
725         s->bitstream_size=0;
726         s->bitstream_index=0;
727         return -1;
728     }
729
730     if (s->bitstream_size) {
731         s->bitstream_index += bytes_read;
732         s->bitstream_size  -= bytes_read;
733         return input_buf_size;
734     } else
735         return bytes_read;
736 }
737
738 static av_cold int flac_decode_close(AVCodecContext *avctx)
739 {
740     FLACContext *s = avctx->priv_data;
741     int i;
742
743     for (i = 0; i < s->channels; i++) {
744         av_freep(&s->decoded[i]);
745     }
746     av_freep(&s->bitstream);
747
748     return 0;
749 }
750
751 static void flac_flush(AVCodecContext *avctx)
752 {
753     FLACContext *s = avctx->priv_data;
754
755     s->bitstream_size=
756     s->bitstream_index= 0;
757 }
758
759 AVCodec flac_decoder = {
760     "flac",
761     CODEC_TYPE_AUDIO,
762     CODEC_ID_FLAC,
763     sizeof(FLACContext),
764     flac_decode_init,
765     NULL,
766     flac_decode_close,
767     flac_decode_frame,
768     CODEC_CAP_DELAY,
769     .flush= flac_flush,
770     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
771 };