share channel mode constants between the FLAC decoder and FLAC encoder
[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 decorrelation;                      ///< 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->decorrelation == FLAC_CHMODE_RIGHT_SIDE)
442             s->curr_bps++;
443     } else {
444         if (s->decorrelation == FLAC_CHMODE_LEFT_SIDE || s->decorrelation == 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, assignment, i, crc8;
496     int decorrelation, bps, blocksize, samplerate;
497
498     blocksize_code = get_bits(&s->gb, 4);
499
500     sample_rate_code = get_bits(&s->gb, 4);
501
502     assignment = get_bits(&s->gb, 4); /* channel assignment */
503     if (assignment < FLAC_MAX_CHANNELS && s->channels == assignment+1)
504         decorrelation = FLAC_CHMODE_INDEPENDENT;
505     else if (assignment >= FLAC_MAX_CHANNELS && assignment < 11 && s->channels == 2)
506         decorrelation = assignment;
507     else {
508         av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n",
509                assignment, s->channels);
510         return -1;
511     }
512
513     sample_size_code = get_bits(&s->gb, 3);
514     if (sample_size_code == 0)
515         bps= s->bps;
516     else if ((sample_size_code != 3) && (sample_size_code != 7))
517         bps = sample_size_table[sample_size_code];
518     else {
519         av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n",
520                sample_size_code);
521         return -1;
522     }
523     if (bps > 16) {
524         s->avctx->sample_fmt = SAMPLE_FMT_S32;
525         s->sample_shift = 32 - bps;
526         s->is32 = 1;
527     } else {
528         s->avctx->sample_fmt = SAMPLE_FMT_S16;
529         s->sample_shift = 16 - bps;
530         s->is32 = 0;
531     }
532     s->bps = s->avctx->bits_per_raw_sample = bps;
533
534     if (get_bits1(&s->gb)) {
535         av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
536         return -1;
537     }
538
539     if (get_utf8(&s->gb) < 0) {
540         av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
541         return -1;
542     }
543
544     if (blocksize_code == 0) {
545         av_log(s->avctx, AV_LOG_ERROR, "reserved blocksize code: 0\n");
546         return -1;
547     } else if (blocksize_code == 6)
548         blocksize = get_bits(&s->gb, 8)+1;
549     else if (blocksize_code == 7)
550         blocksize = get_bits(&s->gb, 16)+1;
551     else
552         blocksize = blocksize_table[blocksize_code];
553
554     if (blocksize > s->max_blocksize) {
555         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize,
556                s->max_blocksize);
557         return -1;
558     }
559
560     if (blocksize * s->channels * (s->is32 ? 4 : 2) > alloc_data_size)
561         return -1;
562
563     if (sample_rate_code == 0)
564         samplerate= s->samplerate;
565     else if (sample_rate_code < 12)
566         samplerate = sample_rate_table[sample_rate_code];
567     else if (sample_rate_code == 12)
568         samplerate = get_bits(&s->gb, 8) * 1000;
569     else if (sample_rate_code == 13)
570         samplerate = get_bits(&s->gb, 16);
571     else if (sample_rate_code == 14)
572         samplerate = get_bits(&s->gb, 16) * 10;
573     else {
574         av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n",
575                sample_rate_code);
576         return -1;
577     }
578
579     skip_bits(&s->gb, 8);
580     crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
581                   s->gb.buffer, get_bits_count(&s->gb)/8);
582     if (crc8) {
583         av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
584         return -1;
585     }
586
587     s->blocksize    = blocksize;
588     s->samplerate   = samplerate;
589     s->bps          = bps;
590     s->decorrelation= decorrelation;
591
592 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
593
594     /* subframes */
595     for (i = 0; i < s->channels; i++) {
596         if (decode_subframe(s, i) < 0)
597             return -1;
598     }
599
600     align_get_bits(&s->gb);
601
602     /* frame footer */
603     skip_bits(&s->gb, 16); /* data crc */
604
605     return 0;
606 }
607
608 static int flac_decode_frame(AVCodecContext *avctx,
609                             void *data, int *data_size,
610                             const uint8_t *buf, int buf_size)
611 {
612     FLACContext *s = avctx->priv_data;
613     int i, j = 0, input_buf_size = 0, bytes_read = 0;
614     int16_t *samples_16 = data;
615     int32_t *samples_32 = data;
616     int alloc_data_size= *data_size;
617
618     *data_size=0;
619
620     if (s->max_framesize == 0) {
621         s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header
622         s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
623     }
624
625     if (1 && s->max_framesize) { //FIXME truncated
626         if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C'))
627             buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize));
628         input_buf_size= buf_size;
629
630         if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
631             return -1;
632
633         if (s->allocated_bitstream_size < s->bitstream_size + buf_size)
634             s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size);
635
636         if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) {
637             memmove(s->bitstream, &s->bitstream[s->bitstream_index],
638                     s->bitstream_size);
639             s->bitstream_index=0;
640         }
641         memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size],
642                buf, buf_size);
643         buf= &s->bitstream[s->bitstream_index];
644         buf_size += s->bitstream_size;
645         s->bitstream_size= buf_size;
646
647         if (buf_size < s->max_framesize && input_buf_size) {
648             return input_buf_size;
649         }
650     }
651
652     /* check that there is at least the smallest decodable amount of data.
653        this amount corresponds to the smallest valid FLAC frame possible.
654        FF F8 69 02 00 00 9A 00 00 34 46 */
655     if (buf_size < 11)
656         goto end;
657
658     /* check for inline header */
659     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
660         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
661             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
662             return -1;
663         }
664         bytes_read = get_metadata_size(buf, buf_size);
665         goto end;
666     }
667
668     /* check for frame sync code and resync stream if necessary */
669     if ((AV_RB16(buf) & 0xFFFE) != 0xFFF8) {
670         const uint8_t *buf_end = buf + buf_size;
671         av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
672         while (buf+2 < buf_end && (AV_RB16(buf) & 0xFFFE) != 0xFFF8)
673             buf++;
674         bytes_read = buf_size - (buf_end - buf);
675         goto end; // we may not have enough bits left to decode a frame, so try next time
676     }
677
678     /* decode frame */
679     init_get_bits(&s->gb, buf, buf_size*8);
680     skip_bits(&s->gb, 16);
681     if (decode_frame(s, alloc_data_size) < 0) {
682         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
683         s->bitstream_size=0;
684         s->bitstream_index=0;
685         return -1;
686     }
687     *data_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
688     bytes_read = (get_bits_count(&s->gb)+7)/8;
689
690 #define DECORRELATE(left, right)\
691             assert(s->channels == 2);\
692             for (i = 0; i < s->blocksize; i++) {\
693                 int a= s->decoded[0][i];\
694                 int b= s->decoded[1][i];\
695                 if (s->is32) {\
696                     *samples_32++ = (left)  << s->sample_shift;\
697                     *samples_32++ = (right) << s->sample_shift;\
698                 } else {\
699                     *samples_16++ = (left)  << s->sample_shift;\
700                     *samples_16++ = (right) << s->sample_shift;\
701                 }\
702             }\
703             break;
704
705     switch (s->decorrelation) {
706     case FLAC_CHMODE_INDEPENDENT:
707         for (j = 0; j < s->blocksize; j++) {
708             for (i = 0; i < s->channels; i++) {
709                 if (s->is32)
710                     *samples_32++ = s->decoded[i][j] << s->sample_shift;
711                 else
712                     *samples_16++ = s->decoded[i][j] << s->sample_shift;
713             }
714         }
715         break;
716     case FLAC_CHMODE_LEFT_SIDE:
717         DECORRELATE(a,a-b)
718     case FLAC_CHMODE_RIGHT_SIDE:
719         DECORRELATE(a+b,b)
720     case FLAC_CHMODE_MID_SIDE:
721         DECORRELATE( (a-=b>>1) + b, a)
722     }
723
724 end:
725     if (bytes_read > buf_size) {
726         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
727         s->bitstream_size=0;
728         s->bitstream_index=0;
729         return -1;
730     }
731
732     if (s->bitstream_size) {
733         s->bitstream_index += bytes_read;
734         s->bitstream_size  -= bytes_read;
735         return input_buf_size;
736     } else
737         return bytes_read;
738 }
739
740 static av_cold int flac_decode_close(AVCodecContext *avctx)
741 {
742     FLACContext *s = avctx->priv_data;
743     int i;
744
745     for (i = 0; i < s->channels; i++) {
746         av_freep(&s->decoded[i]);
747     }
748     av_freep(&s->bitstream);
749
750     return 0;
751 }
752
753 static void flac_flush(AVCodecContext *avctx)
754 {
755     FLACContext *s = avctx->priv_data;
756
757     s->bitstream_size=
758     s->bitstream_index= 0;
759 }
760
761 AVCodec flac_decoder = {
762     "flac",
763     CODEC_TYPE_AUDIO,
764     CODEC_ID_FLAC,
765     sizeof(FLACContext),
766     flac_decode_init,
767     NULL,
768     flac_decode_close,
769     flac_decode_frame,
770     CODEC_CAP_DELAY,
771     .flush= flac_flush,
772     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
773 };