2 * FLAC (Free Lossless Audio Codec) decoder
3 * Copyright (c) 2003 Alex Beregszaszi
5 * This file is part of FFmpeg.
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.
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.
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
23 * @file libavcodec/flacdec.c
24 * FLAC (Free Lossless Audio Codec) decoder
25 * @author Alex Beregszaszi
27 * For more information on the FLAC format, visit:
28 * http://flac.sourceforge.net/
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.
38 #include "libavutil/crc.h"
41 #include "bitstream.h"
42 #include "bytestream.h"
50 typedef struct FLACContext
{
53 AVCodecContext
*avctx
; ///< parent AVCodecContext
54 GetBitContext gb
; ///< GetBitContext initialized to start at the current frame
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
63 int32_t *decoded
[FLAC_MAX_CHANNELS
]; ///< decoded samples
65 unsigned int bitstream_size
;
66 unsigned int bitstream_index
;
67 unsigned int allocated_bitstream_size
;
70 static const int sample_size_table
[] =
71 { 0, 8, 12, 0, 16, 20, 24, 0 };
73 static int64_t get_utf8(GetBitContext
*gb
)
76 GET_UTF8(val
, get_bits(gb
, 8), return -1;)
80 static void allocate_buffers(FLACContext
*s
);
82 int ff_flac_is_extradata_valid(AVCodecContext
*avctx
,
83 enum FLACExtradataFormat
*format
,
84 uint8_t **streaminfo_start
)
86 if (!avctx
->extradata
|| avctx
->extradata_size
< FLAC_STREAMINFO_SIZE
) {
87 av_log(avctx
, AV_LOG_ERROR
, "extradata NULL or too small.\n");
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
);
96 *format
= FLAC_EXTRADATA_FORMAT_STREAMINFO
;
97 *streaminfo_start
= avctx
->extradata
;
99 if (avctx
->extradata_size
< 8+FLAC_STREAMINFO_SIZE
) {
100 av_log(avctx
, AV_LOG_ERROR
, "extradata too small.\n");
103 *format
= FLAC_EXTRADATA_FORMAT_FULL_HEADER
;
104 *streaminfo_start
= &avctx
->extradata
[8];
109 static av_cold
int flac_decode_init(AVCodecContext
*avctx
)
111 enum FLACExtradataFormat format
;
113 FLACContext
*s
= avctx
->priv_data
;
116 avctx
->sample_fmt
= SAMPLE_FMT_S16
;
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
)
123 if (!ff_flac_is_extradata_valid(avctx
, &format
, &streaminfo
))
126 /* initialize based on the demuxer-supplied streamdata header */
127 ff_flac_parse_streaminfo(avctx
, (FLACStreaminfo
*)s
, streaminfo
);
129 s
->got_streaminfo
= 1;
134 static void dump_headers(AVCodecContext
*avctx
, FLACStreaminfo
*s
)
136 av_log(avctx
, AV_LOG_DEBUG
, " Max Blocksize: %d\n", s
->max_blocksize
);
137 av_log(avctx
, AV_LOG_DEBUG
, " Max Framesize: %d\n", s
->max_framesize
);
138 av_log(avctx
, AV_LOG_DEBUG
, " Samplerate: %d\n", s
->samplerate
);
139 av_log(avctx
, AV_LOG_DEBUG
, " Channels: %d\n", s
->channels
);
140 av_log(avctx
, AV_LOG_DEBUG
, " Bits: %d\n", s
->bps
);
143 static void allocate_buffers(FLACContext
*s
)
147 assert(s
->max_blocksize
);
149 if (s
->max_framesize
== 0 && s
->max_blocksize
) {
150 s
->max_framesize
= ff_flac_get_max_frame_size(s
->max_blocksize
,
151 s
->channels
, s
->bps
);
154 for (i
= 0; i
< s
->channels
; i
++) {
155 s
->decoded
[i
] = av_realloc(s
->decoded
[i
],
156 sizeof(int32_t)*s
->max_blocksize
);
159 if (s
->allocated_bitstream_size
< s
->max_framesize
)
160 s
->bitstream
= av_fast_realloc(s
->bitstream
,
161 &s
->allocated_bitstream_size
,
165 void ff_flac_parse_streaminfo(AVCodecContext
*avctx
, struct FLACStreaminfo
*s
,
166 const uint8_t *buffer
)
169 init_get_bits(&gb
, buffer
, FLAC_STREAMINFO_SIZE
*8);
171 skip_bits(&gb
, 16); /* skip min blocksize */
172 s
->max_blocksize
= get_bits(&gb
, 16);
173 if (s
->max_blocksize
< FLAC_MIN_BLOCKSIZE
) {
174 av_log(avctx
, AV_LOG_WARNING
, "invalid max blocksize: %d\n",
176 s
->max_blocksize
= 16;
179 skip_bits(&gb
, 24); /* skip min frame size */
180 s
->max_framesize
= get_bits_long(&gb
, 24);
182 s
->samplerate
= get_bits_long(&gb
, 20);
183 s
->channels
= get_bits(&gb
, 3) + 1;
184 s
->bps
= get_bits(&gb
, 5) + 1;
186 avctx
->channels
= s
->channels
;
187 avctx
->sample_rate
= s
->samplerate
;
188 avctx
->bits_per_raw_sample
= s
->bps
;
190 avctx
->sample_fmt
= SAMPLE_FMT_S32
;
192 avctx
->sample_fmt
= SAMPLE_FMT_S16
;
194 s
->samples
= get_bits_long(&gb
, 32) << 4;
195 s
->samples
|= get_bits(&gb
, 4);
197 skip_bits_long(&gb
, 64); /* md5 sum */
198 skip_bits_long(&gb
, 64); /* md5 sum */
200 dump_headers(avctx
, s
);
203 void ff_flac_parse_block_header(const uint8_t *block_header
,
204 int *last
, int *type
, int *size
)
206 int tmp
= bytestream_get_byte(&block_header
);
212 *size
= bytestream_get_be24(&block_header
);
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
222 static int parse_streaminfo(FLACContext
*s
, const uint8_t *buf
, int buf_size
)
224 int metadata_type
, metadata_size
;
226 if (buf_size
< FLAC_STREAMINFO_SIZE
+8) {
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
;
235 ff_flac_parse_streaminfo(s
->avctx
, (FLACStreaminfo
*)s
, &buf
[8]);
237 s
->got_streaminfo
= 1;
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
248 static int get_metadata_size(const uint8_t *buf
, int buf_size
)
250 int metadata_last
, metadata_size
;
251 const uint8_t *buf_end
= buf
+ buf_size
;
255 ff_flac_parse_block_header(buf
, &metadata_last
, NULL
, &metadata_size
);
257 if (buf
+ metadata_size
> buf_end
) {
258 /* need more data in order to read the complete header */
261 buf
+= metadata_size
;
262 } while (!metadata_last
);
264 return buf_size
- (buf_end
- buf
);
267 static int decode_residuals(FLACContext
*s
, int channel
, int pred_order
)
269 int i
, tmp
, partition
, method_type
, rice_order
;
270 int sample
= 0, samples
;
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",
279 rice_order
= get_bits(&s
->gb
, 4);
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
);
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
);
297 for (; i
< samples
; i
++, sample
++) {
298 s
->decoded
[channel
][sample
] = get_sr_golomb_flac(&s
->gb
, tmp
, INT_MAX
, 0);
307 static int decode_subframe_fixed(FLACContext
*s
, int channel
, int pred_order
)
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
;
313 /* warm up samples */
314 for (i
= 0; i
< pred_order
; i
++) {
315 decoded
[i
] = get_sbits_long(&s
->gb
, s
->curr_bps
);
318 if (decode_residuals(s
, channel
, pred_order
) < 0)
322 a
= decoded
[pred_order
-1];
324 b
= a
- decoded
[pred_order
-2];
326 c
= b
- decoded
[pred_order
-2] + decoded
[pred_order
-3];
328 d
= c
- decoded
[pred_order
-2] + 2*decoded
[pred_order
-3] - decoded
[pred_order
-4];
330 switch (pred_order
) {
334 for (i
= pred_order
; i
< blocksize
; i
++)
335 decoded
[i
] = a
+= decoded
[i
];
338 for (i
= pred_order
; i
< blocksize
; i
++)
339 decoded
[i
] = a
+= b
+= decoded
[i
];
342 for (i
= pred_order
; i
< blocksize
; i
++)
343 decoded
[i
] = a
+= b
+= c
+= decoded
[i
];
346 for (i
= pred_order
; i
< blocksize
; i
++)
347 decoded
[i
] = a
+= b
+= c
+= d
+= decoded
[i
];
350 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal pred order %d\n", pred_order
);
357 static int decode_subframe_lpc(FLACContext
*s
, int channel
, int pred_order
)
360 int coeff_prec
, qlevel
;
361 int coeffs
[pred_order
];
362 int32_t *decoded
= s
->decoded
[channel
];
364 /* warm up samples */
365 for (i
= 0; i
< pred_order
; i
++) {
366 decoded
[i
] = get_sbits_long(&s
->gb
, s
->curr_bps
);
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");
374 qlevel
= get_sbits(&s
->gb
, 5);
376 av_log(s
->avctx
, AV_LOG_ERROR
, "qlevel %d not supported, maybe buggy stream\n",
381 for (i
= 0; i
< pred_order
; i
++) {
382 coeffs
[i
] = get_sbits(&s
->gb
, coeff_prec
);
385 if (decode_residuals(s
, channel
, pred_order
) < 0)
390 for (i
= pred_order
; i
< s
->blocksize
; i
++) {
392 for (j
= 0; j
< pred_order
; j
++)
393 sum
+= (int64_t)coeffs
[j
] * decoded
[i
-j
-1];
394 decoded
[i
] += sum
>> qlevel
;
397 for (i
= pred_order
; i
< s
->blocksize
-1; i
+= 2) {
399 int d
= decoded
[i
-pred_order
];
401 for (j
= pred_order
-1; j
> 0; j
--) {
409 d
= decoded
[i
] += s0
>> qlevel
;
411 decoded
[i
+1] += s1
>> qlevel
;
413 if (i
< s
->blocksize
) {
415 for (j
= 0; j
< pred_order
; j
++)
416 sum
+= coeffs
[j
] * decoded
[i
-j
-1];
417 decoded
[i
] += sum
>> qlevel
;
424 static inline int decode_subframe(FLACContext
*s
, int channel
)
426 int type
, wasted
= 0;
429 s
->curr_bps
= s
->bps
;
431 if (s
->ch_mode
== FLAC_CHMODE_RIGHT_SIDE
)
434 if (s
->ch_mode
== FLAC_CHMODE_LEFT_SIDE
|| s
->ch_mode
== FLAC_CHMODE_MID_SIDE
)
438 if (get_bits1(&s
->gb
)) {
439 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid subframe padding\n");
442 type
= get_bits(&s
->gb
, 6);
444 if (get_bits1(&s
->gb
)) {
446 while (!get_bits1(&s
->gb
))
448 s
->curr_bps
-= wasted
;
450 if (s
->curr_bps
> 32) {
451 ff_log_missing_feature(s
->avctx
, "decorrelated bit depth > 32", 0);
455 //FIXME use av_log2 for types
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)
466 } else if (type
>= 32) {
467 if (decode_subframe_lpc(s
, channel
, (type
& ~0x20)+1) < 0)
470 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid coding type\n");
476 for (i
= 0; i
< s
->blocksize
; i
++)
477 s
->decoded
[channel
][i
] <<= wasted
;
483 static int decode_frame(FLACContext
*s
)
485 int bs_code
, sr_code
, bps_code
, i
;
486 int ch_mode
, bps
, blocksize
, samplerate
, channels
;
487 GetBitContext
*gb
= &s
->gb
;
489 /* frame sync code */
490 skip_bits(&s
->gb
, 16);
492 /* block size and sample rate codes */
493 bs_code
= get_bits(gb
, 4);
494 sr_code
= get_bits(gb
, 4);
496 /* channels and decorrelation */
497 ch_mode
= get_bits(gb
, 4);
498 if (ch_mode
< FLAC_MAX_CHANNELS
) {
499 channels
= ch_mode
+ 1;
500 ch_mode
= FLAC_CHMODE_INDEPENDENT
;
501 } else if (ch_mode
<= FLAC_CHMODE_MID_SIDE
) {
504 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid channel mode: %d\n", ch_mode
);
507 if (channels
!= s
->channels
) {
508 av_log(s
->avctx
, AV_LOG_ERROR
, "switching channel layout mid-stream "
509 "is not supported\n");
513 /* bits per sample */
514 bps_code
= get_bits(gb
, 3);
515 if (bps_code
== 3 || bps_code
== 7) {
516 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid sample size code (%d)\n",
520 bps
= sample_size_table
[bps_code
];
521 if (bps
&& bps
!= s
->bps
) {
522 av_log(s
->avctx
, AV_LOG_ERROR
, "switching bps mid-stream is not "
527 s
->avctx
->sample_fmt
= SAMPLE_FMT_S32
;
528 s
->sample_shift
= 32 - s
->bps
;
531 s
->avctx
->sample_fmt
= SAMPLE_FMT_S16
;
532 s
->sample_shift
= 16 - s
->bps
;
538 av_log(s
->avctx
, AV_LOG_ERROR
, "broken stream, invalid padding\n");
542 /* sample or frame count */
543 if (get_utf8(gb
) < 0) {
544 av_log(s
->avctx
, AV_LOG_ERROR
, "utf8 fscked\n");
550 av_log(s
->avctx
, AV_LOG_ERROR
, "reserved blocksize code: 0\n");
552 } else if (bs_code
== 6) {
553 blocksize
= get_bits(gb
, 8) + 1;
554 } else if (bs_code
== 7) {
555 blocksize
= get_bits(gb
, 16) + 1;
557 blocksize
= ff_flac_blocksize_table
[bs_code
];
559 if (blocksize
> s
->max_blocksize
) {
560 av_log(s
->avctx
, AV_LOG_ERROR
, "blocksize %d > %d\n", blocksize
,
567 samplerate
= s
->samplerate
;
568 } else if (sr_code
< 12) {
569 samplerate
= ff_flac_sample_rate_table
[sr_code
];
570 } else if (sr_code
== 12) {
571 samplerate
= get_bits(gb
, 8) * 1000;
572 } else if (sr_code
== 13) {
573 samplerate
= get_bits(gb
, 16);
574 } else if (sr_code
== 14) {
575 samplerate
= get_bits(gb
, 16) * 10;
577 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal sample rate code %d\n",
582 /* header CRC-8 check */
584 if (av_crc(av_crc_get_table(AV_CRC_8_ATM
), 0, gb
->buffer
,
585 get_bits_count(gb
)/8)) {
586 av_log(s
->avctx
, AV_LOG_ERROR
, "header crc mismatch\n");
590 s
->blocksize
= blocksize
;
591 s
->samplerate
= samplerate
;
593 s
->ch_mode
= ch_mode
;
595 // dump_headers(s->avctx, (FLACStreaminfo *)s);
598 for (i
= 0; i
< s
->channels
; i
++) {
599 if (decode_subframe(s
, i
) < 0)
606 skip_bits(gb
, 16); /* data crc */
611 static int flac_decode_frame(AVCodecContext
*avctx
,
612 void *data
, int *data_size
,
613 const uint8_t *buf
, int buf_size
)
615 FLACContext
*s
= avctx
->priv_data
;
616 int i
, j
= 0, input_buf_size
= 0, bytes_read
= 0;
617 int16_t *samples_16
= data
;
618 int32_t *samples_32
= data
;
619 int alloc_data_size
= *data_size
;
624 if (s
->max_framesize
== 0) {
625 s
->max_framesize
= FFMAX(4, buf_size
); // should hopefully be enough for the first header
626 s
->bitstream
= av_fast_realloc(s
->bitstream
, &s
->allocated_bitstream_size
, s
->max_framesize
);
629 if (1 && s
->max_framesize
) { //FIXME truncated
630 if (s
->bitstream_size
< 4 || AV_RL32(s
->bitstream
) != MKTAG('f','L','a','C'))
631 buf_size
= FFMIN(buf_size
, s
->max_framesize
- FFMIN(s
->bitstream_size
, s
->max_framesize
));
632 input_buf_size
= buf_size
;
634 if (s
->bitstream_size
+ buf_size
< buf_size
|| s
->bitstream_index
+ s
->bitstream_size
+ buf_size
< s
->bitstream_index
)
637 if (s
->allocated_bitstream_size
< s
->bitstream_size
+ buf_size
)
638 s
->bitstream
= av_fast_realloc(s
->bitstream
, &s
->allocated_bitstream_size
, s
->bitstream_size
+ buf_size
);
640 if (s
->bitstream_index
+ s
->bitstream_size
+ buf_size
> s
->allocated_bitstream_size
) {
641 memmove(s
->bitstream
, &s
->bitstream
[s
->bitstream_index
],
643 s
->bitstream_index
=0;
645 memcpy(&s
->bitstream
[s
->bitstream_index
+ s
->bitstream_size
],
647 buf
= &s
->bitstream
[s
->bitstream_index
];
648 buf_size
+= s
->bitstream_size
;
649 s
->bitstream_size
= buf_size
;
651 if (buf_size
< s
->max_framesize
&& input_buf_size
) {
652 return input_buf_size
;
656 /* check that there is at least the smallest decodable amount of data.
657 this amount corresponds to the smallest valid FLAC frame possible.
658 FF F8 69 02 00 00 9A 00 00 34 46 */
662 /* check for inline header */
663 if (AV_RB32(buf
) == MKBETAG('f','L','a','C')) {
664 if (!s
->got_streaminfo
&& parse_streaminfo(s
, buf
, buf_size
)) {
665 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid header\n");
668 bytes_read
= get_metadata_size(buf
, buf_size
);
672 /* check for frame sync code and resync stream if necessary */
673 if ((AV_RB16(buf
) & 0xFFFE) != 0xFFF8) {
674 const uint8_t *buf_end
= buf
+ buf_size
;
675 av_log(s
->avctx
, AV_LOG_ERROR
, "FRAME HEADER not here\n");
676 while (buf
+2 < buf_end
&& (AV_RB16(buf
) & 0xFFFE) != 0xFFF8)
678 bytes_read
= buf_size
- (buf_end
- buf
);
679 goto end
; // we may not have enough bits left to decode a frame, so try next time
683 init_get_bits(&s
->gb
, buf
, buf_size
*8);
684 if (decode_frame(s
) < 0) {
685 av_log(s
->avctx
, AV_LOG_ERROR
, "decode_frame() failed\n");
687 s
->bitstream_index
=0;
690 bytes_read
= (get_bits_count(&s
->gb
)+7)/8;
692 /* check if allocated data size is large enough for output */
693 output_size
= s
->blocksize
* s
->channels
* (s
->is32
? 4 : 2);
694 if (output_size
> alloc_data_size
) {
695 av_log(s
->avctx
, AV_LOG_ERROR
, "output data size is larger than "
696 "allocated data size\n");
699 *data_size
= output_size
;
701 #define DECORRELATE(left, right)\
702 assert(s->channels == 2);\
703 for (i = 0; i < s->blocksize; i++) {\
704 int a= s->decoded[0][i];\
705 int b= s->decoded[1][i];\
707 *samples_32++ = (left) << s->sample_shift;\
708 *samples_32++ = (right) << s->sample_shift;\
710 *samples_16++ = (left) << s->sample_shift;\
711 *samples_16++ = (right) << s->sample_shift;\
716 switch (s
->ch_mode
) {
717 case FLAC_CHMODE_INDEPENDENT
:
718 for (j
= 0; j
< s
->blocksize
; j
++) {
719 for (i
= 0; i
< s
->channels
; i
++) {
721 *samples_32
++ = s
->decoded
[i
][j
] << s
->sample_shift
;
723 *samples_16
++ = s
->decoded
[i
][j
] << s
->sample_shift
;
727 case FLAC_CHMODE_LEFT_SIDE
:
729 case FLAC_CHMODE_RIGHT_SIDE
:
731 case FLAC_CHMODE_MID_SIDE
:
732 DECORRELATE( (a
-=b
>>1) + b
, a
)
736 if (bytes_read
> buf_size
) {
737 av_log(s
->avctx
, AV_LOG_ERROR
, "overread: %d\n", bytes_read
- buf_size
);
739 s
->bitstream_index
=0;
743 if (s
->bitstream_size
) {
744 s
->bitstream_index
+= bytes_read
;
745 s
->bitstream_size
-= bytes_read
;
746 return input_buf_size
;
751 static av_cold
int flac_decode_close(AVCodecContext
*avctx
)
753 FLACContext
*s
= avctx
->priv_data
;
756 for (i
= 0; i
< s
->channels
; i
++) {
757 av_freep(&s
->decoded
[i
]);
759 av_freep(&s
->bitstream
);
764 static void flac_flush(AVCodecContext
*avctx
)
766 FLACContext
*s
= avctx
->priv_data
;
769 s
->bitstream_index
= 0;
772 AVCodec flac_decoder
= {
783 .long_name
= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),