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