flacdec: split off channel decorrelation as 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{
0187178e 363 int i, j;
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
0187178e
LB
392 if (s->bps > 16) {
393 int64_t sum;
1bec121f 394 for (i = pred_order; i < s->blocksize; i++) {
0187178e
LB
395 sum = 0;
396 for (j = 0; j < pred_order; j++)
d1a5c421
LM
397 sum += (int64_t)coeffs[j] * decoded[i-j-1];
398 decoded[i] += sum >> qlevel;
0187178e
LB
399 }
400 } else {
1bec121f 401 for (i = pred_order; i < s->blocksize-1; i += 2) {
d1a5c421
LM
402 int c;
403 int d = decoded[i-pred_order];
404 int s0 = 0, s1 = 0;
1bec121f 405 for (j = pred_order-1; j > 0; j--) {
d1a5c421 406 c = coeffs[j];
bd49d4fd 407 s0 += c*d;
d1a5c421
LM
408 d = decoded[i-j];
409 s1 += c*d;
bd49d4fd 410 }
d1a5c421
LM
411 c = coeffs[0];
412 s0 += c*d;
413 d = decoded[i] += s0 >> qlevel;
414 s1 += c*d;
415 decoded[i+1] += s1 >> qlevel;
bd49d4fd 416 }
1bec121f 417 if (i < s->blocksize) {
bd49d4fd 418 int sum = 0;
0187178e 419 for (j = 0; j < pred_order; j++)
d1a5c421
LM
420 sum += coeffs[j] * decoded[i-j-1];
421 decoded[i] += sum >> qlevel;
0187178e 422 }
4f52c312 423 }
115329f1 424
4f52c312
MN
425 return 0;
426}
427
428static inline int decode_subframe(FLACContext *s, int channel)
429{
430 int type, wasted = 0;
0da301e1 431 int bps = s->bps;
4f52c312 432 int i, tmp;
115329f1 433
1bec121f 434 if (channel == 0) {
2a346725 435 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
0da301e1 436 bps++;
1bec121f 437 } else {
2a346725 438 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
0da301e1 439 bps++;
ac2570a8
MN
440 }
441
1bec121f 442 if (get_bits1(&s->gb)) {
1cef211d 443 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
4f52c312
MN
444 return -1;
445 }
446 type = get_bits(&s->gb, 6);
c5706efd 447
1bec121f 448 if (get_bits1(&s->gb)) {
52e4018b 449 int left = get_bits_left(&s->gb);
4f52c312 450 wasted = 1;
52e4018b 451 if ( left < 0 ||
0da301e1
MR
452 (left < bps && !show_bits_long(&s->gb, left)) ||
453 !show_bits_long(&s->gb, bps)) {
52e4018b
RB
454 av_log(s->avctx, AV_LOG_ERROR,
455 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
0da301e1 456 bps, left);
52e4018b
RB
457 return AVERROR_INVALIDDATA;
458 }
4f52c312
MN
459 while (!get_bits1(&s->gb))
460 wasted++;
0da301e1 461 bps -= wasted;
4f52c312 462 }
0da301e1 463 if (bps > 32) {
ce863d7f 464 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
a3d2379b
JR
465 return -1;
466 }
c5706efd 467
ac2570a8 468//FIXME use av_log2 for types
1bec121f 469 if (type == 0) {
0da301e1 470 tmp = get_sbits_long(&s->gb, bps);
4f52c312
MN
471 for (i = 0; i < s->blocksize; i++)
472 s->decoded[channel][i] = tmp;
1bec121f 473 } else if (type == 1) {
4f52c312 474 for (i = 0; i < s->blocksize; i++)
0da301e1 475 s->decoded[channel][i] = get_sbits_long(&s->gb, bps);
1bec121f 476 } else if ((type >= 8) && (type <= 12)) {
0da301e1 477 if (decode_subframe_fixed(s, channel, type & ~0x8, bps) < 0)
4f52c312 478 return -1;
1bec121f 479 } else if (type >= 32) {
0da301e1 480 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1, bps) < 0)
4f52c312 481 return -1;
1bec121f 482 } else {
1cef211d 483 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
4f52c312
MN
484 return -1;
485 }
115329f1 486
1bec121f 487 if (wasted) {
4f52c312
MN
488 int i;
489 for (i = 0; i < s->blocksize; i++)
490 s->decoded[channel][i] <<= wasted;
491 }
492
493 return 0;
494}
495
cd98a030
JR
496static int decode_frame(FLACContext *s)
497{
498 int i;
499 GetBitContext *gb = &s->gb;
500 FLACFrameInfo fi;
501
3c795698 502 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
cd98a030 503 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
9d656110
MN
504 return -1;
505 }
115329f1 506
2e0559b7 507 if (s->channels && fi.channels != s->channels) {
fbc4d9c9
JR
508 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
509 "is not supported\n");
510 return -1;
511 }
2e0559b7 512 s->channels = s->avctx->channels = fi.channels;
cd98a030 513 s->ch_mode = fi.ch_mode;
fbc4d9c9 514
2e0559b7
JR
515 if (!s->bps && !fi.bps) {
516 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
517 return -1;
518 }
519 if (!fi.bps) {
520 fi.bps = s->bps;
521 } else if (s->bps && fi.bps != s->bps) {
fbc4d9c9
JR
522 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
523 "supported\n");
524 return -1;
525 }
2e0559b7
JR
526 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
527
87466f81 528 flac_set_bps(s);
fbc4d9c9 529
2e0559b7
JR
530 if (!s->max_blocksize)
531 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
cd98a030
JR
532 if (fi.blocksize > s->max_blocksize) {
533 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
fbc4d9c9
JR
534 s->max_blocksize);
535 return -1;
536 }
cd98a030 537 s->blocksize = fi.blocksize;
fbc4d9c9 538
2e0559b7
JR
539 if (!s->samplerate && !fi.samplerate) {
540 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
541 " or frame header\n");
542 return -1;
543 }
cd98a030
JR
544 if (fi.samplerate == 0) {
545 fi.samplerate = s->samplerate;
2e0559b7 546 } else if (s->samplerate && fi.samplerate != s->samplerate) {
fbc4d9c9 547 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
cd98a030 548 s->samplerate, fi.samplerate);
fbc4d9c9 549 }
cd98a030 550 s->samplerate = s->avctx->sample_rate = fi.samplerate;
4f52c312 551
2e0559b7
JR
552 if (!s->got_streaminfo) {
553 allocate_buffers(s);
4a852834 554 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt);
2e0559b7
JR
555 s->got_streaminfo = 1;
556 dump_headers(s->avctx, (FLACStreaminfo *)s);
557 }
558
9482171b 559// dump_headers(s->avctx, (FLACStreaminfo *)s);
4f52c312
MN
560
561 /* subframes */
1bec121f 562 for (i = 0; i < s->channels; i++) {
4f52c312
MN
563 if (decode_subframe(s, i) < 0)
564 return -1;
565 }
115329f1 566
7e00bd84 567 align_get_bits(gb);
4f52c312
MN
568
569 /* frame footer */
7e00bd84 570 skip_bits(gb, 16); /* data crc */
4f52c312
MN
571
572 return 0;
573}
574
0eea2129
JR
575static int flac_decode_frame(AVCodecContext *avctx, void *data,
576 int *got_frame_ptr, AVPacket *avpkt)
4f52c312 577{
7a00bbad
TB
578 const uint8_t *buf = avpkt->data;
579 int buf_size = avpkt->size;
4f52c312 580 FLACContext *s = avctx->priv_data;
4a852834 581 int bytes_read = 0;
0eea2129 582 int ret;
ac66834c 583
0eea2129 584 *got_frame_ptr = 0;
4f52c312 585
1bec121f 586 if (s->max_framesize == 0) {
2e0559b7
JR
587 s->max_framesize =
588 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
589 FLAC_MAX_CHANNELS, 32);
ac2570a8 590 }
4f52c312 591
5ef4fa87 592 /* check that there is at least the smallest decodable amount of data.
8d1e885f
JR
593 this amount corresponds to the smallest valid FLAC frame possible.
594 FF F8 69 02 00 00 9A 00 00 34 46 */
a4151444 595 if (buf_size < FLAC_MIN_FRAME_SIZE)
60a68493 596 return buf_size;
5ef4fa87 597
55a72738 598 /* check for inline header */
a8ec12bc
JR
599 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
600 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
55a72738
JR
601 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
602 return -1;
603 }
60a68493 604 return get_metadata_size(buf, buf_size);
13de8a08 605 }
fd6fd470
JR
606
607 /* decode frame */
608 init_get_bits(&s->gb, buf, buf_size*8);
02b26d2d 609 if (decode_frame(s) < 0) {
13de8a08 610 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
13de8a08
JR
611 return -1;
612 }
bf1d7e28 613 bytes_read = (get_bits_count(&s->gb)+7)/8;
ac2570a8 614
0eea2129
JR
615 /* get output buffer */
616 s->frame.nb_samples = s->blocksize;
617 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
618 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
619 return ret;
02b26d2d 620 }
4a852834
MR
621
622 s->dsp.decorrelate[s->ch_mode](s->frame.data, s->decoded, s->channels,
623 s->blocksize, s->sample_shift);
4f52c312 624
c5199729
JR
625 if (bytes_read > buf_size) {
626 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
ac2570a8
MN
627 return -1;
628 }
60a68493
MC
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 }
4f52c312 633
0eea2129
JR
634 *got_frame_ptr = 1;
635 *(AVFrame *)data = s->frame;
636
60a68493 637 return bytes_read;
4f52c312
MN
638}
639
98a6fff9 640static av_cold int flac_decode_close(AVCodecContext *avctx)
4f52c312
MN
641{
642 FLACContext *s = avctx->priv_data;
643 int i;
115329f1 644
1bec121f 645 for (i = 0; i < s->channels; i++) {
ac2570a8 646 av_freep(&s->decoded[i]);
4f52c312 647 }
115329f1 648
4f52c312
MN
649 return 0;
650}
651
d36beb3f 652AVCodec ff_flac_decoder = {
ec6402b7
AK
653 .name = "flac",
654 .type = AVMEDIA_TYPE_AUDIO,
655 .id = CODEC_ID_FLAC,
656 .priv_data_size = sizeof(FLACContext),
657 .init = flac_decode_init,
658 .close = flac_decode_close,
659 .decode = flac_decode_frame,
0eea2129 660 .capabilities = CODEC_CAP_DR1,
00c3b67b 661 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
4f52c312 662};