flacdec: move lpc filter to flacdsp
[libav.git] / libavcodec / flacdec.c
CommitLineData
4f52c312
MN
1/*
2 * FLAC (Free Lossless Audio Codec) decoder
3 * Copyright (c) 2003 Alex Beregszaszi
4 *
2912e87a 5 * This file is part of Libav.
b78e7197 6 *
2912e87a 7 * Libav is free software; you can redistribute it and/or
4f52c312
MN
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
4f52c312 11 *
2912e87a 12 * Libav is distributed in the hope that it will be useful,
4f52c312
MN
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
2912e87a 18 * License along with Libav; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
4f52c312
MN
20 */
21
22/**
ba87f080 23 * @file
4f52c312
MN
24 * FLAC (Free Lossless Audio Codec) decoder
25 * @author Alex Beregszaszi
ad4cd0c2 26 * @see http://flac.sourceforge.net/
9eda2f94
MM
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.
4f52c312 32 */
115329f1 33
ac2570a8 34#include <limits.h>
115329f1 35
62d5f9e5 36#include "libavutil/audioconvert.h"
245976da 37#include "libavutil/crc.h"
4f52c312 38#include "avcodec.h"
5b37e2fc 39#include "internal.h"
9106a698 40#include "get_bits.h"
a8ec12bc 41#include "bytestream.h"
4f52c312 42#include "golomb.h"
9d48410f 43#include "flac.h"
d4df4e50 44#include "flacdata.h"
4a852834 45#include "flacdsp.h"
4f52c312 46
ac2570a8
MN
47#undef NDEBUG
48#include <assert.h>
49
4f52c312 50typedef struct FLACContext {
9d48410f
JR
51 FLACSTREAMINFO
52
64cb3765 53 AVCodecContext *avctx; ///< parent AVCodecContext
0eea2129 54 AVFrame frame;
64cb3765 55 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
4f52c312 56
64cb3765 57 int blocksize; ///< number of samples in the current frame
7f3a6a05 58 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
2a346725 59 int ch_mode; ///< channel decorrelation type in the current frame
7d030358 60 int got_streaminfo; ///< indicates if the STREAMINFO has been read
4f52c312 61
07d16e2e 62 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
4a852834
MR
63
64 FLACDSPContext dsp;
4f52c312
MN
65} FLACContext;
66
62d5f9e5
JR
67static const int64_t flac_channel_layouts[6] = {
68 AV_CH_LAYOUT_MONO,
69 AV_CH_LAYOUT_STEREO,
70 AV_CH_LAYOUT_SURROUND,
71 AV_CH_LAYOUT_QUAD,
72 AV_CH_LAYOUT_5POINT0,
73 AV_CH_LAYOUT_5POINT1
74};
75
17c90b9d 76static void allocate_buffers(FLACContext *s);
59c6178a 77
d9cca9fc 78int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,
59c6178a
JR
79 enum FLACExtradataFormat *format,
80 uint8_t **streaminfo_start)
81{
82 if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
83 av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
84 return 0;
85 }
86 if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
87 /* extradata contains STREAMINFO only */
88 if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
89 av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
90 FLAC_STREAMINFO_SIZE-avctx->extradata_size);
91 }
92 *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
93 *streaminfo_start = avctx->extradata;
94 } else {
95 if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
96 av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
97 return 0;
98 }
99 *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
100 *streaminfo_start = &avctx->extradata[8];
101 }
102 return 1;
103}
9eda2f94 104
87466f81
MR
105static void flac_set_bps(FLACContext *s)
106{
107 if (s->bps > 16) {
108 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
109 s->sample_shift = 32 - s->bps;
87466f81
MR
110 } else {
111 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
112 s->sample_shift = 16 - s->bps;
87466f81
MR
113 }
114}
115
1bec121f 116static av_cold int flac_decode_init(AVCodecContext *avctx)
4f52c312 117{
59c6178a
JR
118 enum FLACExtradataFormat format;
119 uint8_t *streaminfo;
9eda2f94
MM
120 FLACContext *s = avctx->priv_data;
121 s->avctx = avctx;
122
59c6178a
JR
123 /* for now, the raw FLAC header is allowed to be passed to the decoder as
124 frame data instead of extradata. */
125 if (!avctx->extradata)
126 return 0;
127
d9cca9fc 128 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
59c6178a
JR
129 return -1;
130
26adc8d0 131 /* initialize based on the demuxer-supplied streamdata header */
d9cca9fc 132 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
26adc8d0 133 allocate_buffers(s);
87466f81 134 flac_set_bps(s);
4a852834 135 ff_flacdsp_init(&s->dsp, avctx->sample_fmt);
7d030358 136 s->got_streaminfo = 1;
9eda2f94 137
0eea2129
JR
138 avcodec_get_frame_defaults(&s->frame);
139 avctx->coded_frame = &s->frame;
140
62d5f9e5
JR
141 if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))
142 avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];
143
4f52c312
MN
144 return 0;
145}
146
9482171b 147static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
4f52c312 148{
95db6659 149 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
4bc07e78
JR
150 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
151 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
152 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
153 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
4f52c312
MN
154}
155
1bec121f
JR
156static void allocate_buffers(FLACContext *s)
157{
4f52c312
MN
158 int i;
159
ac2570a8
MN
160 assert(s->max_blocksize);
161
1bec121f 162 for (i = 0; i < s->channels; i++) {
93e7ef9a 163 s->decoded[i] = av_malloc(sizeof(int32_t)*s->max_blocksize);
ac2570a8 164 }
ac2570a8
MN
165}
166
d9cca9fc 167void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
9482171b 168 const uint8_t *buffer)
ac2570a8 169{
a128cc91
JR
170 GetBitContext gb;
171 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
172
95db6659 173 skip_bits(&gb, 16); /* skip min blocksize */
a128cc91 174 s->max_blocksize = get_bits(&gb, 16);
07d16e2e 175 if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
2e78513c
JR
176 av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
177 s->max_blocksize);
178 s->max_blocksize = 16;
179 }
4f52c312 180
a128cc91
JR
181 skip_bits(&gb, 24); /* skip min frame size */
182 s->max_framesize = get_bits_long(&gb, 24);
115329f1 183
a128cc91
JR
184 s->samplerate = get_bits_long(&gb, 20);
185 s->channels = get_bits(&gb, 3) + 1;
186 s->bps = get_bits(&gb, 5) + 1;
115329f1 187
a128cc91
JR
188 avctx->channels = s->channels;
189 avctx->sample_rate = s->samplerate;
82159ad9 190 avctx->bits_per_raw_sample = s->bps;
4f52c312 191
aeb987ce 192 s->samples = get_bits_long(&gb, 32) << 4;
ee4d0322 193 s->samples |= get_bits(&gb, 4);
115329f1 194
ee4d0322
JR
195 skip_bits_long(&gb, 64); /* md5 sum */
196 skip_bits_long(&gb, 64); /* md5 sum */
115329f1 197
4bc07e78 198 dump_headers(avctx, s);
17c90b9d
AJ
199}
200
d9cca9fc 201void avpriv_flac_parse_block_header(const uint8_t *block_header,
5b63d33d
JR
202 int *last, int *type, int *size)
203{
204 int tmp = bytestream_get_byte(&block_header);
205 if (last)
206 *last = tmp & 0x80;
207 if (type)
208 *type = tmp & 0x7F;
209 if (size)
210 *size = bytestream_get_be24(&block_header);
211}
212
17c90b9d 213/**
a8ec12bc
JR
214 * Parse the STREAMINFO from an inline header.
215 * @param s the flac decoding context
216 * @param buf input buffer, starting with the "fLaC" marker
217 * @param buf_size buffer size
55a72738 218 * @return non-zero if metadata is invalid
17c90b9d 219 */
a8ec12bc 220static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
17c90b9d 221{
a8ec12bc 222 int metadata_type, metadata_size;
17c90b9d 223
a8ec12bc
JR
224 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
225 /* need more data */
226 return 0;
227 }
d9cca9fc 228 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
a8ec12bc
JR
229 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
230 metadata_size != FLAC_STREAMINFO_SIZE) {
231 return AVERROR_INVALIDDATA;
232 }
d9cca9fc 233 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
a8ec12bc 234 allocate_buffers(s);
4a852834
MR
235 flac_set_bps(s);
236 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt);
a8ec12bc 237 s->got_streaminfo = 1;
17c90b9d 238
a8ec12bc
JR
239 return 0;
240}
17c90b9d 241
a8ec12bc
JR
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 */
248static 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;
e0168e3b 252
a8ec12bc
JR
253 buf += 4;
254 do {
4c5e7b27
JR
255 if (buf_end - buf < 4)
256 return 0;
d9cca9fc 257 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
5b63d33d 258 buf += 4;
4c5e7b27 259 if (buf_end - buf < metadata_size) {
a8ec12bc
JR
260 /* need more data in order to read the complete header */
261 return 0;
6a85fb34 262 }
a8ec12bc 263 buf += metadata_size;
6a85fb34 264 } while (!metadata_last);
17c90b9d 265
a8ec12bc 266 return buf_size - (buf_end - buf);
4f52c312
MN
267}
268
269static int decode_residuals(FLACContext *s, int channel, int pred_order)
270{
271 int i, tmp, partition, method_type, rice_order;
272 int sample = 0, samples;
273
274 method_type = get_bits(&s->gb, 2);
1bec121f 275 if (method_type > 1) {
9f3d3ecf
JR
276 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
277 method_type);
4f52c312 278 return -1;
ac2570a8 279 }
115329f1 280
4f52c312
MN
281 rice_order = get_bits(&s->gb, 4);
282
ac2570a8 283 samples= s->blocksize >> rice_order;
5484dad7 284 if (pred_order > samples) {
9f3d3ecf
JR
285 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
286 pred_order, samples);
5484dad7
RD
287 return -1;
288 }
4f52c312 289
115329f1 290 sample=
ac2570a8 291 i= pred_order;
1bec121f 292 for (partition = 0; partition < (1 << rice_order); partition++) {
e471443a 293 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
1bec121f 294 if (tmp == (method_type == 0 ? 15 : 31)) {
4f52c312 295 tmp = get_bits(&s->gb, 5);
4f52c312 296 for (; i < samples; i++, sample++)
9de6e090 297 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
1bec121f
JR
298 } else {
299 for (; i < samples; i++, sample++) {
4fd12598 300 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
ac2570a8 301 }
4f52c312 302 }
ac2570a8 303 i= 0;
4f52c312
MN
304 }
305
4f52c312 306 return 0;
115329f1 307}
4f52c312 308
0da301e1
MR
309static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order,
310 int bps)
4f52c312 311{
08965b22
LM
312 const int blocksize = s->blocksize;
313 int32_t *decoded = s->decoded[channel];
a8798c7e 314 int a, b, c, d, i;
115329f1 315
4f52c312 316 /* warm up samples */
1bec121f 317 for (i = 0; i < pred_order; i++) {
0da301e1 318 decoded[i] = get_sbits_long(&s->gb, bps);
4f52c312 319 }
115329f1 320
4f52c312
MN
321 if (decode_residuals(s, channel, pred_order) < 0)
322 return -1;
323
1bec121f 324 if (pred_order > 0)
1f4fa6a4 325 a = decoded[pred_order-1];
1bec121f 326 if (pred_order > 1)
1f4fa6a4 327 b = a - decoded[pred_order-2];
1bec121f 328 if (pred_order > 2)
1f4fa6a4 329 c = b - decoded[pred_order-2] + decoded[pred_order-3];
1bec121f 330 if (pred_order > 3)
1f4fa6a4 331 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
08965b22 332
1bec121f
JR
333 switch (pred_order) {
334 case 0:
335 break;
336 case 1:
337 for (i = pred_order; i < blocksize; i++)
338 decoded[i] = a += decoded[i];
339 break;
340 case 2:
341 for (i = pred_order; i < blocksize; i++)
342 decoded[i] = a += b += decoded[i];
343 break;
344 case 3:
345 for (i = pred_order; i < blocksize; i++)
346 decoded[i] = a += b += c += decoded[i];
347 break;
348 case 4:
349 for (i = pred_order; i < blocksize; i++)
350 decoded[i] = a += b += c += d += decoded[i];
351 break;
352 default:
353 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
354 return -1;
4f52c312 355 }
ac2570a8 356
4f52c312
MN
357 return 0;
358}
359
0da301e1
MR
360static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order,
361 int bps)
4f52c312 362{
25accf93 363 int i;
4f52c312 364 int coeff_prec, qlevel;
8313e179 365 int coeffs[32];
d1a5c421 366 int32_t *decoded = s->decoded[channel];
115329f1 367
4f52c312 368 /* warm up samples */
1bec121f 369 for (i = 0; i < pred_order; i++) {
0da301e1 370 decoded[i] = get_sbits_long(&s->gb, bps);
4f52c312 371 }
115329f1 372
4f52c312 373 coeff_prec = get_bits(&s->gb, 4) + 1;
1bec121f 374 if (coeff_prec == 16) {
5305f40b 375 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
4f52c312
MN
376 return -1;
377 }
ac2570a8 378 qlevel = get_sbits(&s->gb, 5);
1bec121f 379 if (qlevel < 0) {
9f3d3ecf
JR
380 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
381 qlevel);
9d656110
MN
382 return -1;
383 }
384
1bec121f 385 for (i = 0; i < pred_order; i++) {
ac2570a8 386 coeffs[i] = get_sbits(&s->gb, coeff_prec);
4f52c312 387 }
115329f1 388
4f52c312
MN
389 if (decode_residuals(s, channel, pred_order) < 0)
390 return -1;
391
25accf93 392 s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
115329f1 393
4f52c312
MN
394 return 0;
395}
396
397static inline int decode_subframe(FLACContext *s, int channel)
398{
399 int type, wasted = 0;
0da301e1 400 int bps = s->bps;
4f52c312 401 int i, tmp;
115329f1 402
1bec121f 403 if (channel == 0) {
2a346725 404 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
0da301e1 405 bps++;
1bec121f 406 } else {
2a346725 407 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
0da301e1 408 bps++;
ac2570a8
MN
409 }
410
1bec121f 411 if (get_bits1(&s->gb)) {
1cef211d 412 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
4f52c312
MN
413 return -1;
414 }
415 type = get_bits(&s->gb, 6);
c5706efd 416
1bec121f 417 if (get_bits1(&s->gb)) {
52e4018b 418 int left = get_bits_left(&s->gb);
4f52c312 419 wasted = 1;
52e4018b 420 if ( left < 0 ||
0da301e1
MR
421 (left < bps && !show_bits_long(&s->gb, left)) ||
422 !show_bits_long(&s->gb, bps)) {
52e4018b
RB
423 av_log(s->avctx, AV_LOG_ERROR,
424 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
0da301e1 425 bps, left);
52e4018b
RB
426 return AVERROR_INVALIDDATA;
427 }
4f52c312
MN
428 while (!get_bits1(&s->gb))
429 wasted++;
0da301e1 430 bps -= wasted;
4f52c312 431 }
0da301e1 432 if (bps > 32) {
ce863d7f 433 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
a3d2379b
JR
434 return -1;
435 }
c5706efd 436
ac2570a8 437//FIXME use av_log2 for types
1bec121f 438 if (type == 0) {
0da301e1 439 tmp = get_sbits_long(&s->gb, bps);
4f52c312
MN
440 for (i = 0; i < s->blocksize; i++)
441 s->decoded[channel][i] = tmp;
1bec121f 442 } else if (type == 1) {
4f52c312 443 for (i = 0; i < s->blocksize; i++)
0da301e1 444 s->decoded[channel][i] = get_sbits_long(&s->gb, bps);
1bec121f 445 } else if ((type >= 8) && (type <= 12)) {
0da301e1 446 if (decode_subframe_fixed(s, channel, type & ~0x8, bps) < 0)
4f52c312 447 return -1;
1bec121f 448 } else if (type >= 32) {
0da301e1 449 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1, bps) < 0)
4f52c312 450 return -1;
1bec121f 451 } else {
1cef211d 452 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
4f52c312
MN
453 return -1;
454 }
115329f1 455
1bec121f 456 if (wasted) {
4f52c312
MN
457 int i;
458 for (i = 0; i < s->blocksize; i++)
459 s->decoded[channel][i] <<= wasted;
460 }
461
462 return 0;
463}
464
cd98a030
JR
465static int decode_frame(FLACContext *s)
466{
467 int i;
468 GetBitContext *gb = &s->gb;
469 FLACFrameInfo fi;
470
3c795698 471 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
cd98a030 472 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
9d656110
MN
473 return -1;
474 }
115329f1 475
2e0559b7 476 if (s->channels && fi.channels != s->channels) {
fbc4d9c9
JR
477 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
478 "is not supported\n");
479 return -1;
480 }
2e0559b7 481 s->channels = s->avctx->channels = fi.channels;
cd98a030 482 s->ch_mode = fi.ch_mode;
fbc4d9c9 483
2e0559b7
JR
484 if (!s->bps && !fi.bps) {
485 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
486 return -1;
487 }
488 if (!fi.bps) {
489 fi.bps = s->bps;
490 } else if (s->bps && fi.bps != s->bps) {
fbc4d9c9
JR
491 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
492 "supported\n");
493 return -1;
494 }
2e0559b7
JR
495 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
496
87466f81 497 flac_set_bps(s);
fbc4d9c9 498
2e0559b7
JR
499 if (!s->max_blocksize)
500 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
cd98a030
JR
501 if (fi.blocksize > s->max_blocksize) {
502 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
fbc4d9c9
JR
503 s->max_blocksize);
504 return -1;
505 }
cd98a030 506 s->blocksize = fi.blocksize;
fbc4d9c9 507
2e0559b7
JR
508 if (!s->samplerate && !fi.samplerate) {
509 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
510 " or frame header\n");
511 return -1;
512 }
cd98a030
JR
513 if (fi.samplerate == 0) {
514 fi.samplerate = s->samplerate;
2e0559b7 515 } else if (s->samplerate && fi.samplerate != s->samplerate) {
fbc4d9c9 516 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
cd98a030 517 s->samplerate, fi.samplerate);
fbc4d9c9 518 }
cd98a030 519 s->samplerate = s->avctx->sample_rate = fi.samplerate;
4f52c312 520
2e0559b7
JR
521 if (!s->got_streaminfo) {
522 allocate_buffers(s);
4a852834 523 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt);
2e0559b7
JR
524 s->got_streaminfo = 1;
525 dump_headers(s->avctx, (FLACStreaminfo *)s);
526 }
527
9482171b 528// dump_headers(s->avctx, (FLACStreaminfo *)s);
4f52c312
MN
529
530 /* subframes */
1bec121f 531 for (i = 0; i < s->channels; i++) {
4f52c312
MN
532 if (decode_subframe(s, i) < 0)
533 return -1;
534 }
115329f1 535
7e00bd84 536 align_get_bits(gb);
4f52c312
MN
537
538 /* frame footer */
7e00bd84 539 skip_bits(gb, 16); /* data crc */
4f52c312
MN
540
541 return 0;
542}
543
0eea2129
JR
544static int flac_decode_frame(AVCodecContext *avctx, void *data,
545 int *got_frame_ptr, AVPacket *avpkt)
4f52c312 546{
7a00bbad
TB
547 const uint8_t *buf = avpkt->data;
548 int buf_size = avpkt->size;
4f52c312 549 FLACContext *s = avctx->priv_data;
4a852834 550 int bytes_read = 0;
0eea2129 551 int ret;
ac66834c 552
0eea2129 553 *got_frame_ptr = 0;
4f52c312 554
1bec121f 555 if (s->max_framesize == 0) {
2e0559b7
JR
556 s->max_framesize =
557 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
558 FLAC_MAX_CHANNELS, 32);
ac2570a8 559 }
4f52c312 560
5ef4fa87 561 /* check that there is at least the smallest decodable amount of data.
8d1e885f
JR
562 this amount corresponds to the smallest valid FLAC frame possible.
563 FF F8 69 02 00 00 9A 00 00 34 46 */
a4151444 564 if (buf_size < FLAC_MIN_FRAME_SIZE)
60a68493 565 return buf_size;
5ef4fa87 566
55a72738 567 /* check for inline header */
a8ec12bc
JR
568 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
569 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
55a72738
JR
570 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
571 return -1;
572 }
60a68493 573 return get_metadata_size(buf, buf_size);
13de8a08 574 }
fd6fd470
JR
575
576 /* decode frame */
577 init_get_bits(&s->gb, buf, buf_size*8);
02b26d2d 578 if (decode_frame(s) < 0) {
13de8a08 579 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
13de8a08
JR
580 return -1;
581 }
bf1d7e28 582 bytes_read = (get_bits_count(&s->gb)+7)/8;
ac2570a8 583
0eea2129
JR
584 /* get output buffer */
585 s->frame.nb_samples = s->blocksize;
586 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
587 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
588 return ret;
02b26d2d 589 }
4a852834
MR
590
591 s->dsp.decorrelate[s->ch_mode](s->frame.data, s->decoded, s->channels,
592 s->blocksize, s->sample_shift);
4f52c312 593
c5199729
JR
594 if (bytes_read > buf_size) {
595 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
ac2570a8
MN
596 return -1;
597 }
60a68493
MC
598 if (bytes_read < buf_size) {
599 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
600 buf_size - bytes_read, buf_size);
601 }
4f52c312 602
0eea2129
JR
603 *got_frame_ptr = 1;
604 *(AVFrame *)data = s->frame;
605
60a68493 606 return bytes_read;
4f52c312
MN
607}
608
98a6fff9 609static av_cold int flac_decode_close(AVCodecContext *avctx)
4f52c312
MN
610{
611 FLACContext *s = avctx->priv_data;
612 int i;
115329f1 613
1bec121f 614 for (i = 0; i < s->channels; i++) {
ac2570a8 615 av_freep(&s->decoded[i]);
4f52c312 616 }
115329f1 617
4f52c312
MN
618 return 0;
619}
620
d36beb3f 621AVCodec ff_flac_decoder = {
ec6402b7
AK
622 .name = "flac",
623 .type = AVMEDIA_TYPE_AUDIO,
624 .id = CODEC_ID_FLAC,
625 .priv_data_size = sizeof(FLACContext),
626 .init = flac_decode_init,
627 .close = flac_decode_close,
628 .decode = flac_decode_frame,
0eea2129 629 .capabilities = CODEC_CAP_DR1,
00c3b67b 630 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
4f52c312 631};