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 * @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/avassert.h"
37 #include "libavutil/crc.h"
38 #include "libavutil/opt.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 #include "flacdsp.h"
47 #include "thread.h"
48 #include "unary.h"
49
50
51 typedef struct FLACContext {
52 AVClass *class;
53 struct FLACStreaminfo flac_stream_info;
54
55 AVCodecContext *avctx; ///< parent AVCodecContext
56 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
57
58 int blocksize; ///< number of samples in the current frame
59 int sample_shift; ///< shift required to make output samples 16-bit or 32-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 *decoded_buffer;
65 unsigned int decoded_buffer_size;
66 int buggy_lpc; ///< use workaround for old lavc encoded files
67
68 FLACDSPContext dsp;
69 } FLACContext;
70
71 static int allocate_buffers(FLACContext *s);
72
flac_set_bps(FLACContext * s)73 static void flac_set_bps(FLACContext *s)
74 {
75 enum AVSampleFormat req = s->avctx->request_sample_fmt;
76 int need32 = s->flac_stream_info.bps > 16;
77 int want32 = av_get_bytes_per_sample(req) > 2;
78 int planar = av_sample_fmt_is_planar(req);
79
80 if (need32 || want32) {
81 if (planar)
82 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
83 else
84 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
85 s->sample_shift = 32 - s->flac_stream_info.bps;
86 } else {
87 if (planar)
88 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
89 else
90 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
91 s->sample_shift = 16 - s->flac_stream_info.bps;
92 }
93 }
94
flac_decode_init(AVCodecContext * avctx)95 static av_cold int flac_decode_init(AVCodecContext *avctx)
96 {
97 enum FLACExtradataFormat format;
98 uint8_t *streaminfo;
99 int ret;
100 FLACContext *s = avctx->priv_data;
101 s->avctx = avctx;
102
103 /* for now, the raw FLAC header is allowed to be passed to the decoder as
104 frame data instead of extradata. */
105 if (!avctx->extradata)
106 return 0;
107
108 if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
109 return AVERROR_INVALIDDATA;
110
111 /* initialize based on the demuxer-supplied streamdata header */
112 ret = ff_flac_parse_streaminfo(avctx, &s->flac_stream_info, streaminfo);
113 if (ret < 0)
114 return ret;
115 ret = allocate_buffers(s);
116 if (ret < 0)
117 return ret;
118 flac_set_bps(s);
119 ff_flacdsp_init(&s->dsp, avctx->sample_fmt,
120 s->flac_stream_info.channels, s->flac_stream_info.bps);
121 s->got_streaminfo = 1;
122
123 return 0;
124 }
125
dump_headers(AVCodecContext * avctx,FLACStreaminfo * s)126 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
127 {
128 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
129 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
130 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
131 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
132 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
133 }
134
allocate_buffers(FLACContext * s)135 static int allocate_buffers(FLACContext *s)
136 {
137 int buf_size;
138 int ret;
139
140 av_assert0(s->flac_stream_info.max_blocksize);
141
142 buf_size = av_samples_get_buffer_size(NULL, s->flac_stream_info.channels,
143 s->flac_stream_info.max_blocksize,
144 AV_SAMPLE_FMT_S32P, 0);
145 if (buf_size < 0)
146 return buf_size;
147
148 av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
149 if (!s->decoded_buffer)
150 return AVERROR(ENOMEM);
151
152 ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
153 s->decoded_buffer,
154 s->flac_stream_info.channels,
155 s->flac_stream_info.max_blocksize,
156 AV_SAMPLE_FMT_S32P, 0);
157 return ret < 0 ? ret : 0;
158 }
159
160 /**
161 * Parse the STREAMINFO from an inline header.
162 * @param s the flac decoding context
163 * @param buf input buffer, starting with the "fLaC" marker
164 * @param buf_size buffer size
165 * @return non-zero if metadata is invalid
166 */
parse_streaminfo(FLACContext * s,const uint8_t * buf,int buf_size)167 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
168 {
169 int metadata_type, metadata_size, ret;
170
171 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
172 /* need more data */
173 return 0;
174 }
175 flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
176 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
177 metadata_size != FLAC_STREAMINFO_SIZE) {
178 return AVERROR_INVALIDDATA;
179 }
180 ret = ff_flac_parse_streaminfo(s->avctx, &s->flac_stream_info, &buf[8]);
181 if (ret < 0)
182 return ret;
183 ret = allocate_buffers(s);
184 if (ret < 0)
185 return ret;
186 flac_set_bps(s);
187 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
188 s->flac_stream_info.channels, s->flac_stream_info.bps);
189 s->got_streaminfo = 1;
190
191 return 0;
192 }
193
194 /**
195 * Determine the size of an inline header.
196 * @param buf input buffer, starting with the "fLaC" marker
197 * @param buf_size buffer size
198 * @return number of bytes in the header, or 0 if more data is needed
199 */
get_metadata_size(const uint8_t * buf,int buf_size)200 static int get_metadata_size(const uint8_t *buf, int buf_size)
201 {
202 int metadata_last, metadata_size;
203 const uint8_t *buf_end = buf + buf_size;
204
205 buf += 4;
206 do {
207 if (buf_end - buf < 4)
208 return AVERROR_INVALIDDATA;
209 flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
210 buf += 4;
211 if (buf_end - buf < metadata_size) {
212 /* need more data in order to read the complete header */
213 return AVERROR_INVALIDDATA;
214 }
215 buf += metadata_size;
216 } while (!metadata_last);
217
218 return buf_size - (buf_end - buf);
219 }
220
decode_residuals(FLACContext * s,int32_t * decoded,int pred_order)221 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
222 {
223 GetBitContext gb = s->gb;
224 int i, tmp, partition, method_type, rice_order;
225 int rice_bits, rice_esc;
226 int samples;
227
228 method_type = get_bits(&gb, 2);
229 rice_order = get_bits(&gb, 4);
230
231 samples = s->blocksize >> rice_order;
232 rice_bits = 4 + method_type;
233 rice_esc = (1 << rice_bits) - 1;
234
235 decoded += pred_order;
236 i = pred_order;
237
238 if (method_type > 1) {
239 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
240 method_type);
241 return AVERROR_INVALIDDATA;
242 }
243
244 if (samples << rice_order != s->blocksize) {
245 av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
246 rice_order, s->blocksize);
247 return AVERROR_INVALIDDATA;
248 }
249
250 if (pred_order > samples) {
251 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
252 pred_order, samples);
253 return AVERROR_INVALIDDATA;
254 }
255
256 for (partition = 0; partition < (1 << rice_order); partition++) {
257 tmp = get_bits(&gb, rice_bits);
258 if (tmp == rice_esc) {
259 tmp = get_bits(&gb, 5);
260 for (; i < samples; i++)
261 *decoded++ = get_sbits_long(&gb, tmp);
262 } else {
263 int real_limit = tmp ? (INT_MAX >> tmp) + 2 : INT_MAX;
264 for (; i < samples; i++) {
265 int v = get_sr_golomb_flac(&gb, tmp, real_limit, 1);
266 if (v == 0x80000000){
267 av_log(s->avctx, AV_LOG_ERROR, "invalid residual\n");
268 return AVERROR_INVALIDDATA;
269 }
270
271 *decoded++ = v;
272 }
273 }
274 i= 0;
275 }
276
277 s->gb = gb;
278
279 return 0;
280 }
281
decode_subframe_fixed(FLACContext * s,int32_t * decoded,int pred_order,int bps)282 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
283 int pred_order, int bps)
284 {
285 const int blocksize = s->blocksize;
286 unsigned av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d);
287 int i;
288 int ret;
289
290 /* warm up samples */
291 for (i = 0; i < pred_order; i++) {
292 decoded[i] = get_sbits_long(&s->gb, bps);
293 }
294
295 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
296 return ret;
297
298 if (pred_order > 0)
299 a = decoded[pred_order-1];
300 if (pred_order > 1)
301 b = a - decoded[pred_order-2];
302 if (pred_order > 2)
303 c = b - decoded[pred_order-2] + decoded[pred_order-3];
304 if (pred_order > 3)
305 d = c - decoded[pred_order-2] + 2U*decoded[pred_order-3] - decoded[pred_order-4];
306
307 switch (pred_order) {
308 case 0:
309 break;
310 case 1:
311 for (i = pred_order; i < blocksize; i++)
312 decoded[i] = a += decoded[i];
313 break;
314 case 2:
315 for (i = pred_order; i < blocksize; i++)
316 decoded[i] = a += b += decoded[i];
317 break;
318 case 3:
319 for (i = pred_order; i < blocksize; i++)
320 decoded[i] = a += b += c += decoded[i];
321 break;
322 case 4:
323 for (i = pred_order; i < blocksize; i++)
324 decoded[i] = a += b += c += d += decoded[i];
325 break;
326 default:
327 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
328 return AVERROR_INVALIDDATA;
329 }
330
331 return 0;
332 }
333
lpc_analyze_remodulate(SUINT32 * decoded,const int coeffs[32],int order,int qlevel,int len,int bps)334 static void lpc_analyze_remodulate(SUINT32 *decoded, const int coeffs[32],
335 int order, int qlevel, int len, int bps)
336 {
337 int i, j;
338 int ebps = 1 << (bps-1);
339 unsigned sigma = 0;
340
341 for (i = order; i < len; i++)
342 sigma |= decoded[i] + ebps;
343
344 if (sigma < 2*ebps)
345 return;
346
347 for (i = len - 1; i >= order; i--) {
348 int64_t p = 0;
349 for (j = 0; j < order; j++)
350 p += coeffs[j] * (int64_t)(int32_t)decoded[i-order+j];
351 decoded[i] -= p >> qlevel;
352 }
353 for (i = order; i < len; i++, decoded++) {
354 int32_t p = 0;
355 for (j = 0; j < order; j++)
356 p += coeffs[j] * (uint32_t)decoded[j];
357 decoded[j] += p >> qlevel;
358 }
359 }
360
decode_subframe_lpc(FLACContext * s,int32_t * decoded,int pred_order,int bps)361 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
362 int bps)
363 {
364 int i, ret;
365 int coeff_prec, qlevel;
366 int coeffs[32];
367
368 /* warm up samples */
369 for (i = 0; i < pred_order; i++) {
370 decoded[i] = get_sbits_long(&s->gb, bps);
371 }
372
373 coeff_prec = get_bits(&s->gb, 4) + 1;
374 if (coeff_prec == 16) {
375 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
376 return AVERROR_INVALIDDATA;
377 }
378 qlevel = get_sbits(&s->gb, 5);
379 if (qlevel < 0) {
380 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
381 qlevel);
382 return AVERROR_INVALIDDATA;
383 }
384
385 for (i = 0; i < pred_order; i++) {
386 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
387 }
388
389 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
390 return ret;
391
392 if ( ( s->buggy_lpc && s->flac_stream_info.bps <= 16)
393 || ( !s->buggy_lpc && bps <= 16
394 && bps + coeff_prec + av_log2(pred_order) <= 32)) {
395 s->dsp.lpc16(decoded, coeffs, pred_order, qlevel, s->blocksize);
396 } else {
397 s->dsp.lpc32(decoded, coeffs, pred_order, qlevel, s->blocksize);
398 if (s->flac_stream_info.bps <= 16)
399 lpc_analyze_remodulate(decoded, coeffs, pred_order, qlevel, s->blocksize, bps);
400 }
401
402 return 0;
403 }
404
decode_subframe(FLACContext * s,int channel)405 static inline int decode_subframe(FLACContext *s, int channel)
406 {
407 int32_t *decoded = s->decoded[channel];
408 int type, wasted = 0;
409 int bps = s->flac_stream_info.bps;
410 int i, tmp, ret;
411
412 if (channel == 0) {
413 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
414 bps++;
415 } else {
416 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
417 bps++;
418 }
419
420 if (get_bits1(&s->gb)) {
421 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
422 return AVERROR_INVALIDDATA;
423 }
424 type = get_bits(&s->gb, 6);
425
426 if (get_bits1(&s->gb)) {
427 int left = get_bits_left(&s->gb);
428 if ( left <= 0 ||
429 (left < bps && !show_bits_long(&s->gb, left)) ||
430 !show_bits_long(&s->gb, bps)) {
431 av_log(s->avctx, AV_LOG_ERROR,
432 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
433 bps, left);
434 return AVERROR_INVALIDDATA;
435 }
436 wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
437 bps -= wasted;
438 }
439 if (bps > 32) {
440 avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
441 return AVERROR_PATCHWELCOME;
442 }
443
444 //FIXME use av_log2 for types
445 if (type == 0) {
446 tmp = get_sbits_long(&s->gb, bps);
447 for (i = 0; i < s->blocksize; i++)
448 decoded[i] = tmp;
449 } else if (type == 1) {
450 for (i = 0; i < s->blocksize; i++)
451 decoded[i] = get_sbits_long(&s->gb, bps);
452 } else if ((type >= 8) && (type <= 12)) {
453 if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
454 return ret;
455 } else if (type >= 32) {
456 if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
457 return ret;
458 } else {
459 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
460 return AVERROR_INVALIDDATA;
461 }
462
463 if (wasted && wasted < 32) {
464 int i;
465 for (i = 0; i < s->blocksize; i++)
466 decoded[i] = (unsigned)decoded[i] << wasted;
467 }
468
469 return 0;
470 }
471
decode_frame(FLACContext * s)472 static int decode_frame(FLACContext *s)
473 {
474 int i, ret;
475 GetBitContext *gb = &s->gb;
476 FLACFrameInfo fi;
477
478 if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
479 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
480 return ret;
481 }
482
483 if ( s->flac_stream_info.channels
484 && fi.channels != s->flac_stream_info.channels
485 && s->got_streaminfo) {
486 s->flac_stream_info.channels = s->avctx->channels = fi.channels;
487 ff_flac_set_channel_layout(s->avctx);
488 ret = allocate_buffers(s);
489 if (ret < 0)
490 return ret;
491 }
492 s->flac_stream_info.channels = s->avctx->channels = fi.channels;
493 if (!s->avctx->channel_layout)
494 ff_flac_set_channel_layout(s->avctx);
495 s->ch_mode = fi.ch_mode;
496
497 if (!s->flac_stream_info.bps && !fi.bps) {
498 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
499 return AVERROR_INVALIDDATA;
500 }
501 if (!fi.bps) {
502 fi.bps = s->flac_stream_info.bps;
503 } else if (s->flac_stream_info.bps && fi.bps != s->flac_stream_info.bps) {
504 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
505 "supported\n");
506 return AVERROR_INVALIDDATA;
507 }
508
509 if (!s->flac_stream_info.bps) {
510 s->flac_stream_info.bps = s->avctx->bits_per_raw_sample = fi.bps;
511 flac_set_bps(s);
512 }
513
514 if (!s->flac_stream_info.max_blocksize)
515 s->flac_stream_info.max_blocksize = FLAC_MAX_BLOCKSIZE;
516 if (fi.blocksize > s->flac_stream_info.max_blocksize) {
517 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
518 s->flac_stream_info.max_blocksize);
519 return AVERROR_INVALIDDATA;
520 }
521 s->blocksize = fi.blocksize;
522
523 if (!s->flac_stream_info.samplerate && !fi.samplerate) {
524 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
525 " or frame header\n");
526 return AVERROR_INVALIDDATA;
527 }
528 if (fi.samplerate == 0)
529 fi.samplerate = s->flac_stream_info.samplerate;
530 s->flac_stream_info.samplerate = s->avctx->sample_rate = fi.samplerate;
531
532 if (!s->got_streaminfo) {
533 ret = allocate_buffers(s);
534 if (ret < 0)
535 return ret;
536 s->got_streaminfo = 1;
537 dump_headers(s->avctx, &s->flac_stream_info);
538 }
539 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
540 s->flac_stream_info.channels, s->flac_stream_info.bps);
541
542 // dump_headers(s->avctx, &s->flac_stream_info);
543
544 /* subframes */
545 for (i = 0; i < s->flac_stream_info.channels; i++) {
546 if ((ret = decode_subframe(s, i)) < 0)
547 return ret;
548 }
549
550 align_get_bits(gb);
551
552 /* frame footer */
553 skip_bits(gb, 16); /* data crc */
554
555 return 0;
556 }
557
flac_decode_frame(AVCodecContext * avctx,void * data,int * got_frame_ptr,AVPacket * avpkt)558 static int flac_decode_frame(AVCodecContext *avctx, void *data,
559 int *got_frame_ptr, AVPacket *avpkt)
560 {
561 AVFrame *frame = data;
562 ThreadFrame tframe = { .f = data };
563 const uint8_t *buf = avpkt->data;
564 int buf_size = avpkt->size;
565 FLACContext *s = avctx->priv_data;
566 int bytes_read = 0;
567 int ret;
568
569 *got_frame_ptr = 0;
570
571 if (s->flac_stream_info.max_framesize == 0) {
572 s->flac_stream_info.max_framesize =
573 ff_flac_get_max_frame_size(s->flac_stream_info.max_blocksize ? s->flac_stream_info.max_blocksize : FLAC_MAX_BLOCKSIZE,
574 FLAC_MAX_CHANNELS, 32);
575 }
576
577 if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
578 av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
579 return buf_size;
580 }
581
582 if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
583 av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
584 return buf_size;
585 }
586
587 /* check that there is at least the smallest decodable amount of data.
588 this amount corresponds to the smallest valid FLAC frame possible.
589 FF F8 69 02 00 00 9A 00 00 34 46 */
590 if (buf_size < FLAC_MIN_FRAME_SIZE)
591 return buf_size;
592
593 /* check for inline header */
594 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
595 if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
596 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
597 return ret;
598 }
599 return get_metadata_size(buf, buf_size);
600 }
601
602 /* decode frame */
603 if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
604 return ret;
605 if ((ret = decode_frame(s)) < 0) {
606 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
607 return ret;
608 }
609 bytes_read = get_bits_count(&s->gb)/8;
610
611 if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
612 av_crc(av_crc_get_table(AV_CRC_16_ANSI),
613 0, buf, bytes_read)) {
614 av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
615 if (s->avctx->err_recognition & AV_EF_EXPLODE)
616 return AVERROR_INVALIDDATA;
617 }
618
619 /* get output buffer */
620 frame->nb_samples = s->blocksize;
621 if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
622 return ret;
623
624 s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded,
625 s->flac_stream_info.channels,
626 s->blocksize, s->sample_shift);
627
628 if (bytes_read > buf_size) {
629 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
630 return AVERROR_INVALIDDATA;
631 }
632 if (bytes_read < buf_size) {
633 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
634 buf_size - bytes_read, buf_size);
635 }
636
637 *got_frame_ptr = 1;
638
639 return bytes_read;
640 }
641
flac_decode_close(AVCodecContext * avctx)642 static av_cold int flac_decode_close(AVCodecContext *avctx)
643 {
644 FLACContext *s = avctx->priv_data;
645
646 av_freep(&s->decoded_buffer);
647
648 return 0;
649 }
650
651 static const AVOption options[] = {
652 { "use_buggy_lpc", "emulate old buggy lavc behavior", offsetof(FLACContext, buggy_lpc), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM },
653 { NULL },
654 };
655
656 static const AVClass flac_decoder_class = {
657 .class_name = "FLAC decoder",
658 .item_name = av_default_item_name,
659 .option = options,
660 .version = LIBAVUTIL_VERSION_INT,
661 };
662
663 AVCodec ff_flac_decoder = {
664 .name = "flac",
665 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
666 .type = AVMEDIA_TYPE_AUDIO,
667 .id = AV_CODEC_ID_FLAC,
668 .priv_data_size = sizeof(FLACContext),
669 .init = flac_decode_init,
670 .close = flac_decode_close,
671 .decode = flac_decode_frame,
672 .capabilities = AV_CODEC_CAP_CHANNEL_CONF |
673 AV_CODEC_CAP_DR1 |
674 AV_CODEC_CAP_FRAME_THREADS,
675 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
676 AV_SAMPLE_FMT_S16P,
677 AV_SAMPLE_FMT_S32,
678 AV_SAMPLE_FMT_S32P,
679 AV_SAMPLE_FMT_NONE },
680 .priv_class = &flac_decoder_class,
681 };
682