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 "codec_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 > 1) ? (INT_MAX >> (tmp - 1)) + 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 = fi.channels;
487 ff_flac_set_channel_layout(s->avctx, fi.channels);
488 ret = allocate_buffers(s);
489 if (ret < 0)
490 return ret;
491 }
492 s->flac_stream_info.channels = fi.channels;
493 ff_flac_set_channel_layout(s->avctx, fi.channels);
494 s->ch_mode = fi.ch_mode;
495
496 if (!s->flac_stream_info.bps && !fi.bps) {
497 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
498 return AVERROR_INVALIDDATA;
499 }
500 if (!fi.bps) {
501 fi.bps = s->flac_stream_info.bps;
502 } else if (s->flac_stream_info.bps && fi.bps != s->flac_stream_info.bps) {
503 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
504 "supported\n");
505 return AVERROR_INVALIDDATA;
506 }
507
508 if (!s->flac_stream_info.bps) {
509 s->flac_stream_info.bps = s->avctx->bits_per_raw_sample = fi.bps;
510 flac_set_bps(s);
511 }
512
513 if (!s->flac_stream_info.max_blocksize)
514 s->flac_stream_info.max_blocksize = FLAC_MAX_BLOCKSIZE;
515 if (fi.blocksize > s->flac_stream_info.max_blocksize) {
516 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
517 s->flac_stream_info.max_blocksize);
518 return AVERROR_INVALIDDATA;
519 }
520 s->blocksize = fi.blocksize;
521
522 if (!s->flac_stream_info.samplerate && !fi.samplerate) {
523 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
524 " or frame header\n");
525 return AVERROR_INVALIDDATA;
526 }
527 if (fi.samplerate == 0)
528 fi.samplerate = s->flac_stream_info.samplerate;
529 s->flac_stream_info.samplerate = s->avctx->sample_rate = fi.samplerate;
530
531 if (!s->got_streaminfo) {
532 ret = allocate_buffers(s);
533 if (ret < 0)
534 return ret;
535 s->got_streaminfo = 1;
536 dump_headers(s->avctx, &s->flac_stream_info);
537 }
538 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
539 s->flac_stream_info.channels, s->flac_stream_info.bps);
540
541 // dump_headers(s->avctx, &s->flac_stream_info);
542
543 /* subframes */
544 for (i = 0; i < s->flac_stream_info.channels; i++) {
545 if ((ret = decode_subframe(s, i)) < 0)
546 return ret;
547 }
548
549 align_get_bits(gb);
550
551 /* frame footer */
552 skip_bits(gb, 16); /* data crc */
553
554 return 0;
555 }
556
flac_decode_frame(AVCodecContext * avctx,AVFrame * frame,int * got_frame_ptr,AVPacket * avpkt)557 static int flac_decode_frame(AVCodecContext *avctx, AVFrame *frame,
558 int *got_frame_ptr, AVPacket *avpkt)
559 {
560 const uint8_t *buf = avpkt->data;
561 int buf_size = avpkt->size;
562 FLACContext *s = avctx->priv_data;
563 int bytes_read = 0;
564 int ret;
565
566 *got_frame_ptr = 0;
567
568 if (s->flac_stream_info.max_framesize == 0) {
569 s->flac_stream_info.max_framesize =
570 ff_flac_get_max_frame_size(s->flac_stream_info.max_blocksize ? s->flac_stream_info.max_blocksize : FLAC_MAX_BLOCKSIZE,
571 FLAC_MAX_CHANNELS, 32);
572 }
573
574 if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
575 av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
576 return buf_size;
577 }
578
579 if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
580 av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
581 return buf_size;
582 }
583
584 /* check that there is at least the smallest decodable amount of data.
585 this amount corresponds to the smallest valid FLAC frame possible.
586 FF F8 69 02 00 00 9A 00 00 34 46 */
587 if (buf_size < FLAC_MIN_FRAME_SIZE)
588 return buf_size;
589
590 /* check for inline header */
591 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
592 if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
593 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
594 return ret;
595 }
596 return get_metadata_size(buf, buf_size);
597 }
598
599 /* decode frame */
600 if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
601 return ret;
602 if ((ret = decode_frame(s)) < 0) {
603 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
604 return ret;
605 }
606 bytes_read = get_bits_count(&s->gb)/8;
607
608 if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
609 av_crc(av_crc_get_table(AV_CRC_16_ANSI),
610 0, buf, bytes_read)) {
611 av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
612 if (s->avctx->err_recognition & AV_EF_EXPLODE)
613 return AVERROR_INVALIDDATA;
614 }
615
616 /* get output buffer */
617 frame->nb_samples = s->blocksize;
618 if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
619 return ret;
620
621 s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded,
622 s->flac_stream_info.channels,
623 s->blocksize, s->sample_shift);
624
625 if (bytes_read > buf_size) {
626 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
627 return AVERROR_INVALIDDATA;
628 }
629 if (bytes_read < buf_size) {
630 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
631 buf_size - bytes_read, buf_size);
632 }
633
634 *got_frame_ptr = 1;
635
636 return bytes_read;
637 }
638
flac_decode_close(AVCodecContext * avctx)639 static av_cold int flac_decode_close(AVCodecContext *avctx)
640 {
641 FLACContext *s = avctx->priv_data;
642
643 av_freep(&s->decoded_buffer);
644
645 return 0;
646 }
647
648 static const AVOption options[] = {
649 { "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 },
650 { NULL },
651 };
652
653 static const AVClass flac_decoder_class = {
654 .class_name = "FLAC decoder",
655 .item_name = av_default_item_name,
656 .option = options,
657 .version = LIBAVUTIL_VERSION_INT,
658 };
659
660 const FFCodec ff_flac_decoder = {
661 .p.name = "flac",
662 .p.long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
663 .p.type = AVMEDIA_TYPE_AUDIO,
664 .p.id = AV_CODEC_ID_FLAC,
665 .priv_data_size = sizeof(FLACContext),
666 .init = flac_decode_init,
667 .close = flac_decode_close,
668 FF_CODEC_DECODE_CB(flac_decode_frame),
669 .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
670 AV_CODEC_CAP_DR1 |
671 AV_CODEC_CAP_FRAME_THREADS,
672 .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
673 AV_SAMPLE_FMT_S16P,
674 AV_SAMPLE_FMT_S32,
675 AV_SAMPLE_FMT_S32P,
676 AV_SAMPLE_FMT_NONE },
677 .p.priv_class = &flac_decoder_class,
678 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
679 };
680