Replace deprecated symbols SAMPLE_FMT_* with AV_SAMPLE_FMT_*, and enum
[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
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 };