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