ppc: Rename H.264 optimization template file for consistency.
[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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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  * @see http://flac.sourceforge.net/
27  *
28  * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
29  * through, starting from the initial 'fLaC' signature; or by passing the
30  * 34-byte streaminfo structure through avctx->extradata[_size] followed
31  * by data starting with the 0xFFF8 marker.
32  */
33
34 #include <limits.h>
35
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/crc.h"
38 #include "avcodec.h"
39 #include "internal.h"
40 #include "get_bits.h"
41 #include "bytestream.h"
42 #include "golomb.h"
43 #include "flac.h"
44 #include "flacdata.h"
45
46 #undef NDEBUG
47 #include <assert.h>
48
49 typedef struct FLACContext {
50     FLACSTREAMINFO
51
52     AVCodecContext *avctx;                  ///< parent AVCodecContext
53     AVFrame frame;
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 } FLACContext;
65
66 static const int64_t flac_channel_layouts[6] = {
67     AV_CH_LAYOUT_MONO,
68     AV_CH_LAYOUT_STEREO,
69     AV_CH_LAYOUT_SURROUND,
70     AV_CH_LAYOUT_QUAD,
71     AV_CH_LAYOUT_5POINT0,
72     AV_CH_LAYOUT_5POINT1
73 };
74
75 static void allocate_buffers(FLACContext *s);
76
77 int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,
78                                enum FLACExtradataFormat *format,
79                                uint8_t **streaminfo_start)
80 {
81     if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
82         av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
83         return 0;
84     }
85     if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
86         /* extradata contains STREAMINFO only */
87         if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
88             av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
89                    FLAC_STREAMINFO_SIZE-avctx->extradata_size);
90         }
91         *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
92         *streaminfo_start = avctx->extradata;
93     } else {
94         if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
95             av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
96             return 0;
97         }
98         *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
99         *streaminfo_start = &avctx->extradata[8];
100     }
101     return 1;
102 }
103
104 static av_cold int flac_decode_init(AVCodecContext *avctx)
105 {
106     enum FLACExtradataFormat format;
107     uint8_t *streaminfo;
108     FLACContext *s = avctx->priv_data;
109     s->avctx = avctx;
110
111     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
112
113     /* for now, the raw FLAC header is allowed to be passed to the decoder as
114        frame data instead of extradata. */
115     if (!avctx->extradata)
116         return 0;
117
118     if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
119         return -1;
120
121     /* initialize based on the demuxer-supplied streamdata header */
122     avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
123     if (s->bps > 16)
124         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
125     else
126         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
127     allocate_buffers(s);
128     s->got_streaminfo = 1;
129
130     avcodec_get_frame_defaults(&s->frame);
131     avctx->coded_frame = &s->frame;
132
133     if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))
134         avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];
135
136     return 0;
137 }
138
139 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
140 {
141     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
142     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
143     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
144     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
145     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
146 }
147
148 static void allocate_buffers(FLACContext *s)
149 {
150     int i;
151
152     assert(s->max_blocksize);
153
154     for (i = 0; i < s->channels; i++) {
155         s->decoded[i] = av_realloc(s->decoded[i],
156                                    sizeof(int32_t)*s->max_blocksize);
157     }
158 }
159
160 void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
161                               const uint8_t *buffer)
162 {
163     GetBitContext gb;
164     init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
165
166     skip_bits(&gb, 16); /* skip min blocksize */
167     s->max_blocksize = get_bits(&gb, 16);
168     if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
169         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
170                s->max_blocksize);
171         s->max_blocksize = 16;
172     }
173
174     skip_bits(&gb, 24); /* skip min frame size */
175     s->max_framesize = get_bits_long(&gb, 24);
176
177     s->samplerate = get_bits_long(&gb, 20);
178     s->channels = get_bits(&gb, 3) + 1;
179     s->bps = get_bits(&gb, 5) + 1;
180
181     avctx->channels = s->channels;
182     avctx->sample_rate = s->samplerate;
183     avctx->bits_per_raw_sample = s->bps;
184
185     s->samples  = get_bits_long(&gb, 32) << 4;
186     s->samples |= get_bits(&gb, 4);
187
188     skip_bits_long(&gb, 64); /* md5 sum */
189     skip_bits_long(&gb, 64); /* md5 sum */
190
191     dump_headers(avctx, s);
192 }
193
194 void avpriv_flac_parse_block_header(const uint8_t *block_header,
195                                 int *last, int *type, int *size)
196 {
197     int tmp = bytestream_get_byte(&block_header);
198     if (last)
199         *last = tmp & 0x80;
200     if (type)
201         *type = tmp & 0x7F;
202     if (size)
203         *size = bytestream_get_be24(&block_header);
204 }
205
206 /**
207  * Parse the STREAMINFO from an inline header.
208  * @param s the flac decoding context
209  * @param buf input buffer, starting with the "fLaC" marker
210  * @param buf_size buffer size
211  * @return non-zero if metadata is invalid
212  */
213 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
214 {
215     int metadata_type, metadata_size;
216
217     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
218         /* need more data */
219         return 0;
220     }
221     avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
222     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
223         metadata_size != FLAC_STREAMINFO_SIZE) {
224         return AVERROR_INVALIDDATA;
225     }
226     avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
227     allocate_buffers(s);
228     s->got_streaminfo = 1;
229
230     return 0;
231 }
232
233 /**
234  * Determine the size of an inline header.
235  * @param buf input buffer, starting with the "fLaC" marker
236  * @param buf_size buffer size
237  * @return number of bytes in the header, or 0 if more data is needed
238  */
239 static int get_metadata_size(const uint8_t *buf, int buf_size)
240 {
241     int metadata_last, metadata_size;
242     const uint8_t *buf_end = buf + buf_size;
243
244     buf += 4;
245     do {
246         if (buf_end - buf < 4)
247             return 0;
248         avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
249         buf += 4;
250         if (buf_end - buf < metadata_size) {
251             /* need more data in order to read the complete header */
252             return 0;
253         }
254         buf += metadata_size;
255     } while (!metadata_last);
256
257     return buf_size - (buf_end - buf);
258 }
259
260 static int decode_residuals(FLACContext *s, int channel, int pred_order)
261 {
262     int i, tmp, partition, method_type, rice_order;
263     int sample = 0, samples;
264
265     method_type = get_bits(&s->gb, 2);
266     if (method_type > 1) {
267         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
268                method_type);
269         return -1;
270     }
271
272     rice_order = get_bits(&s->gb, 4);
273
274     samples= s->blocksize >> rice_order;
275     if (pred_order > samples) {
276         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
277                pred_order, samples);
278         return -1;
279     }
280
281     sample=
282     i= pred_order;
283     for (partition = 0; partition < (1 << rice_order); partition++) {
284         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
285         if (tmp == (method_type == 0 ? 15 : 31)) {
286             tmp = get_bits(&s->gb, 5);
287             for (; i < samples; i++, sample++)
288                 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
289         } else {
290             for (; i < samples; i++, sample++) {
291                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
292             }
293         }
294         i= 0;
295     }
296
297     return 0;
298 }
299
300 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
301 {
302     const int blocksize = s->blocksize;
303     int32_t *decoded = s->decoded[channel];
304     int a, b, c, d, i;
305
306     /* warm up samples */
307     for (i = 0; i < pred_order; i++) {
308         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
309     }
310
311     if (decode_residuals(s, channel, pred_order) < 0)
312         return -1;
313
314     if (pred_order > 0)
315         a = decoded[pred_order-1];
316     if (pred_order > 1)
317         b = a - decoded[pred_order-2];
318     if (pred_order > 2)
319         c = b - decoded[pred_order-2] + decoded[pred_order-3];
320     if (pred_order > 3)
321         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
322
323     switch (pred_order) {
324     case 0:
325         break;
326     case 1:
327         for (i = pred_order; i < blocksize; i++)
328             decoded[i] = a += decoded[i];
329         break;
330     case 2:
331         for (i = pred_order; i < blocksize; i++)
332             decoded[i] = a += b += decoded[i];
333         break;
334     case 3:
335         for (i = pred_order; i < blocksize; i++)
336             decoded[i] = a += b += c += decoded[i];
337         break;
338     case 4:
339         for (i = pred_order; i < blocksize; i++)
340             decoded[i] = a += b += c += d += decoded[i];
341         break;
342     default:
343         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
344         return -1;
345     }
346
347     return 0;
348 }
349
350 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
351 {
352     int i, j;
353     int coeff_prec, qlevel;
354     int coeffs[32];
355     int32_t *decoded = s->decoded[channel];
356
357     /* warm up samples */
358     for (i = 0; i < pred_order; i++) {
359         decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
360     }
361
362     coeff_prec = get_bits(&s->gb, 4) + 1;
363     if (coeff_prec == 16) {
364         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
365         return -1;
366     }
367     qlevel = get_sbits(&s->gb, 5);
368     if (qlevel < 0) {
369         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
370                qlevel);
371         return -1;
372     }
373
374     for (i = 0; i < pred_order; i++) {
375         coeffs[i] = get_sbits(&s->gb, coeff_prec);
376     }
377
378     if (decode_residuals(s, channel, pred_order) < 0)
379         return -1;
380
381     if (s->bps > 16) {
382         int64_t sum;
383         for (i = pred_order; i < s->blocksize; i++) {
384             sum = 0;
385             for (j = 0; j < pred_order; j++)
386                 sum += (int64_t)coeffs[j] * decoded[i-j-1];
387             decoded[i] += sum >> qlevel;
388         }
389     } else {
390         for (i = pred_order; i < s->blocksize-1; i += 2) {
391             int c;
392             int d = decoded[i-pred_order];
393             int s0 = 0, s1 = 0;
394             for (j = pred_order-1; j > 0; j--) {
395                 c = coeffs[j];
396                 s0 += c*d;
397                 d = decoded[i-j];
398                 s1 += c*d;
399             }
400             c = coeffs[0];
401             s0 += c*d;
402             d = decoded[i] += s0 >> qlevel;
403             s1 += c*d;
404             decoded[i+1] += s1 >> qlevel;
405         }
406         if (i < s->blocksize) {
407             int sum = 0;
408             for (j = 0; j < pred_order; j++)
409                 sum += coeffs[j] * decoded[i-j-1];
410             decoded[i] += sum >> qlevel;
411         }
412     }
413
414     return 0;
415 }
416
417 static inline int decode_subframe(FLACContext *s, int channel)
418 {
419     int type, wasted = 0;
420     int i, tmp;
421
422     s->curr_bps = s->bps;
423     if (channel == 0) {
424         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
425             s->curr_bps++;
426     } else {
427         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
428             s->curr_bps++;
429     }
430
431     if (get_bits1(&s->gb)) {
432         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
433         return -1;
434     }
435     type = get_bits(&s->gb, 6);
436
437     if (get_bits1(&s->gb)) {
438         int left = get_bits_left(&s->gb);
439         wasted = 1;
440         if ( left < 0 ||
441             (left < s->curr_bps && !show_bits_long(&s->gb, left)) ||
442                                    !show_bits_long(&s->gb, s->curr_bps)) {
443             av_log(s->avctx, AV_LOG_ERROR,
444                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
445                    s->curr_bps, left);
446             return AVERROR_INVALIDDATA;
447         }
448         while (!get_bits1(&s->gb))
449             wasted++;
450         s->curr_bps -= wasted;
451     }
452     if (s->curr_bps > 32) {
453         av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
454         return -1;
455     }
456
457 //FIXME use av_log2 for types
458     if (type == 0) {
459         tmp = get_sbits_long(&s->gb, s->curr_bps);
460         for (i = 0; i < s->blocksize; i++)
461             s->decoded[channel][i] = tmp;
462     } else if (type == 1) {
463         for (i = 0; i < s->blocksize; i++)
464             s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
465     } else if ((type >= 8) && (type <= 12)) {
466         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
467             return -1;
468     } else if (type >= 32) {
469         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
470             return -1;
471     } else {
472         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
473         return -1;
474     }
475
476     if (wasted) {
477         int i;
478         for (i = 0; i < s->blocksize; i++)
479             s->decoded[channel][i] <<= wasted;
480     }
481
482     return 0;
483 }
484
485 static int decode_frame(FLACContext *s)
486 {
487     int i;
488     GetBitContext *gb = &s->gb;
489     FLACFrameInfo fi;
490
491     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
492         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
493         return -1;
494     }
495
496     if (s->channels && fi.channels != s->channels) {
497         av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
498                                        "is not supported\n");
499         return -1;
500     }
501     s->channels = s->avctx->channels = fi.channels;
502     s->ch_mode = fi.ch_mode;
503
504     if (!s->bps && !fi.bps) {
505         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
506         return -1;
507     }
508     if (!fi.bps) {
509         fi.bps = s->bps;
510     } else if (s->bps && fi.bps != s->bps) {
511         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
512                                        "supported\n");
513         return -1;
514     }
515     s->bps = s->avctx->bits_per_raw_sample = fi.bps;
516
517     if (s->bps > 16) {
518         s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
519         s->sample_shift = 32 - s->bps;
520         s->is32 = 1;
521     } else {
522         s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
523         s->sample_shift = 16 - s->bps;
524         s->is32 = 0;
525     }
526
527     if (!s->max_blocksize)
528         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
529     if (fi.blocksize > s->max_blocksize) {
530         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
531                s->max_blocksize);
532         return -1;
533     }
534     s->blocksize = fi.blocksize;
535
536     if (!s->samplerate && !fi.samplerate) {
537         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
538                                         " or frame header\n");
539         return -1;
540     }
541     if (fi.samplerate == 0) {
542         fi.samplerate = s->samplerate;
543     } else if (s->samplerate && fi.samplerate != s->samplerate) {
544         av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
545                s->samplerate, fi.samplerate);
546     }
547     s->samplerate = s->avctx->sample_rate = fi.samplerate;
548
549     if (!s->got_streaminfo) {
550         allocate_buffers(s);
551         s->got_streaminfo = 1;
552         dump_headers(s->avctx, (FLACStreaminfo *)s);
553     }
554
555 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
556
557     /* subframes */
558     for (i = 0; i < s->channels; i++) {
559         if (decode_subframe(s, i) < 0)
560             return -1;
561     }
562
563     align_get_bits(gb);
564
565     /* frame footer */
566     skip_bits(gb, 16); /* data crc */
567
568     return 0;
569 }
570
571 static int flac_decode_frame(AVCodecContext *avctx, void *data,
572                              int *got_frame_ptr, AVPacket *avpkt)
573 {
574     const uint8_t *buf = avpkt->data;
575     int buf_size = avpkt->size;
576     FLACContext *s = avctx->priv_data;
577     int i, j = 0, bytes_read = 0;
578     int16_t *samples_16;
579     int32_t *samples_32;
580     int ret;
581
582     *got_frame_ptr = 0;
583
584     if (s->max_framesize == 0) {
585         s->max_framesize =
586             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
587                                        FLAC_MAX_CHANNELS, 32);
588     }
589
590     /* check that there is at least the smallest decodable amount of data.
591        this amount corresponds to the smallest valid FLAC frame possible.
592        FF F8 69 02 00 00 9A 00 00 34 46 */
593     if (buf_size < FLAC_MIN_FRAME_SIZE)
594         return buf_size;
595
596     /* check for inline header */
597     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
598         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
599             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
600             return -1;
601         }
602         return get_metadata_size(buf, buf_size);
603     }
604
605     /* decode frame */
606     init_get_bits(&s->gb, buf, buf_size*8);
607     if (decode_frame(s) < 0) {
608         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
609         return -1;
610     }
611     bytes_read = (get_bits_count(&s->gb)+7)/8;
612
613     /* get output buffer */
614     s->frame.nb_samples = s->blocksize;
615     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
616         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
617         return ret;
618     }
619     samples_16 = (int16_t *)s->frame.data[0];
620     samples_32 = (int32_t *)s->frame.data[0];
621
622 #define DECORRELATE(left, right)\
623             assert(s->channels == 2);\
624             for (i = 0; i < s->blocksize; i++) {\
625                 int a= s->decoded[0][i];\
626                 int b= s->decoded[1][i];\
627                 if (s->is32) {\
628                     *samples_32++ = (left)  << s->sample_shift;\
629                     *samples_32++ = (right) << s->sample_shift;\
630                 } else {\
631                     *samples_16++ = (left)  << s->sample_shift;\
632                     *samples_16++ = (right) << s->sample_shift;\
633                 }\
634             }\
635             break;
636
637     switch (s->ch_mode) {
638     case FLAC_CHMODE_INDEPENDENT:
639         for (j = 0; j < s->blocksize; j++) {
640             for (i = 0; i < s->channels; i++) {
641                 if (s->is32)
642                     *samples_32++ = s->decoded[i][j] << s->sample_shift;
643                 else
644                     *samples_16++ = s->decoded[i][j] << s->sample_shift;
645             }
646         }
647         break;
648     case FLAC_CHMODE_LEFT_SIDE:
649         DECORRELATE(a,a-b)
650     case FLAC_CHMODE_RIGHT_SIDE:
651         DECORRELATE(a+b,b)
652     case FLAC_CHMODE_MID_SIDE:
653         DECORRELATE( (a-=b>>1) + b, a)
654     }
655
656     if (bytes_read > buf_size) {
657         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
658         return -1;
659     }
660     if (bytes_read < buf_size) {
661         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
662                buf_size - bytes_read, buf_size);
663     }
664
665     *got_frame_ptr   = 1;
666     *(AVFrame *)data = s->frame;
667
668     return bytes_read;
669 }
670
671 static av_cold int flac_decode_close(AVCodecContext *avctx)
672 {
673     FLACContext *s = avctx->priv_data;
674     int i;
675
676     for (i = 0; i < s->channels; i++) {
677         av_freep(&s->decoded[i]);
678     }
679
680     return 0;
681 }
682
683 AVCodec ff_flac_decoder = {
684     .name           = "flac",
685     .type           = AVMEDIA_TYPE_AUDIO,
686     .id             = CODEC_ID_FLAC,
687     .priv_data_size = sizeof(FLACContext),
688     .init           = flac_decode_init,
689     .close          = flac_decode_close,
690     .decode         = flac_decode_frame,
691     .capabilities   = CODEC_CAP_DR1,
692     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
693 };