flacdec: skip frame when allocated data size is too small
[libav.git] / libavcodec / flacdec.c
CommitLineData
4f52c312
MN
1/*
2 * FLAC (Free Lossless Audio Codec) decoder
3 * Copyright (c) 2003 Alex Beregszaszi
4 *
b78e7197
DB
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg 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 *
b78e7197 12 * FFmpeg 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
b78e7197 18 * License along with FFmpeg; 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/**
bad5537e 23 * @file libavcodec/flacdec.c
4f52c312
MN
24 * FLAC (Free Lossless Audio Codec) decoder
25 * @author Alex Beregszaszi
9eda2f94
MM
26 *
27 * For more information on the FLAC format, visit:
28 * http://flac.sourceforge.net/
29 *
30 * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
31 * through, starting from the initial 'fLaC' signature; or by passing the
32 * 34-byte streaminfo structure through avctx->extradata[_size] followed
33 * by data starting with the 0xFFF8 marker.
4f52c312 34 */
115329f1 35
ac2570a8 36#include <limits.h>
115329f1 37
245976da 38#include "libavutil/crc.h"
4f52c312 39#include "avcodec.h"
5b37e2fc 40#include "internal.h"
caa336b4 41#include "bitstream.h"
a8ec12bc 42#include "bytestream.h"
4f52c312 43#include "golomb.h"
9d48410f 44#include "flac.h"
d4df4e50 45#include "flacdata.h"
4f52c312 46
ac2570a8
MN
47#undef NDEBUG
48#include <assert.h>
49
4f52c312 50typedef struct FLACContext {
9d48410f
JR
51 FLACSTREAMINFO
52
64cb3765
JR
53 AVCodecContext *avctx; ///< parent AVCodecContext
54 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
4f52c312 55
64cb3765
JR
56 int blocksize; ///< number of samples in the current frame
57 int curr_bps; ///< bps for current subframe, adjusted for channel correlation and wasted bits
7f3a6a05
JR
58 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
59 int is32; ///< flag to indicate if output should be 32-bit instead of 16-bit
2a346725 60 int ch_mode; ///< channel decorrelation type in the current frame
7d030358 61 int got_streaminfo; ///< indicates if the STREAMINFO has been read
4f52c312 62
07d16e2e 63 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
ac2570a8 64 uint8_t *bitstream;
1e77df15
MN
65 unsigned int bitstream_size;
66 unsigned int bitstream_index;
f038fe8b 67 unsigned int allocated_bitstream_size;
4f52c312
MN
68} FLACContext;
69
cf2baeb3 70static const int sample_size_table[] =
4f52c312
MN
71{ 0, 8, 12, 0, 16, 20, 24, 0 };
72
1bec121f
JR
73static int64_t get_utf8(GetBitContext *gb)
74{
9d82b0dd
MN
75 int64_t val;
76 GET_UTF8(val, get_bits(gb, 8), return -1;)
ac2570a8 77 return val;
4f52c312
MN
78}
79
17c90b9d 80static void allocate_buffers(FLACContext *s);
59c6178a
JR
81
82int ff_flac_is_extradata_valid(AVCodecContext *avctx,
83 enum FLACExtradataFormat *format,
84 uint8_t **streaminfo_start)
85{
86 if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
87 av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
88 return 0;
89 }
90 if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
91 /* extradata contains STREAMINFO only */
92 if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
93 av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
94 FLAC_STREAMINFO_SIZE-avctx->extradata_size);
95 }
96 *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
97 *streaminfo_start = avctx->extradata;
98 } else {
99 if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
100 av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
101 return 0;
102 }
103 *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
104 *streaminfo_start = &avctx->extradata[8];
105 }
106 return 1;
107}
9eda2f94 108
1bec121f 109static av_cold int flac_decode_init(AVCodecContext *avctx)
4f52c312 110{
59c6178a
JR
111 enum FLACExtradataFormat format;
112 uint8_t *streaminfo;
9eda2f94
MM
113 FLACContext *s = avctx->priv_data;
114 s->avctx = avctx;
115
faeb2bd4
JR
116 avctx->sample_fmt = SAMPLE_FMT_S16;
117
59c6178a
JR
118 /* for now, the raw FLAC header is allowed to be passed to the decoder as
119 frame data instead of extradata. */
120 if (!avctx->extradata)
121 return 0;
122
123 if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
124 return -1;
125
26adc8d0
JR
126 /* initialize based on the demuxer-supplied streamdata header */
127 ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
128 allocate_buffers(s);
7d030358 129 s->got_streaminfo = 1;
9eda2f94 130
4f52c312
MN
131 return 0;
132}
133
9482171b 134static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
4f52c312 135{
95db6659 136 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
4bc07e78
JR
137 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
138 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
139 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
140 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
4f52c312
MN
141}
142
1bec121f
JR
143static void allocate_buffers(FLACContext *s)
144{
4f52c312
MN
145 int i;
146
ac2570a8
MN
147 assert(s->max_blocksize);
148
1bec121f 149 if (s->max_framesize == 0 && s->max_blocksize) {
0fb2182d
JR
150 s->max_framesize = ff_flac_get_max_frame_size(s->max_blocksize,
151 s->channels, s->bps);
ac2570a8
MN
152 }
153
1bec121f 154 for (i = 0; i < s->channels; i++) {
9f3d3ecf
JR
155 s->decoded[i] = av_realloc(s->decoded[i],
156 sizeof(int32_t)*s->max_blocksize);
ac2570a8
MN
157 }
158
1bec121f 159 if (s->allocated_bitstream_size < s->max_framesize)
9f3d3ecf
JR
160 s->bitstream= av_fast_realloc(s->bitstream,
161 &s->allocated_bitstream_size,
162 s->max_framesize);
ac2570a8
MN
163}
164
9482171b
JR
165void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
166 const uint8_t *buffer)
ac2570a8 167{
a128cc91
JR
168 GetBitContext gb;
169 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
170
95db6659 171 skip_bits(&gb, 16); /* skip min blocksize */
a128cc91 172 s->max_blocksize = get_bits(&gb, 16);
07d16e2e 173 if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
2e78513c
JR
174 av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
175 s->max_blocksize);
176 s->max_blocksize = 16;
177 }
4f52c312 178
a128cc91
JR
179 skip_bits(&gb, 24); /* skip min frame size */
180 s->max_framesize = get_bits_long(&gb, 24);
115329f1 181
a128cc91
JR
182 s->samplerate = get_bits_long(&gb, 20);
183 s->channels = get_bits(&gb, 3) + 1;
184 s->bps = get_bits(&gb, 5) + 1;
115329f1 185
a128cc91
JR
186 avctx->channels = s->channels;
187 avctx->sample_rate = s->samplerate;
82159ad9
JR
188 avctx->bits_per_raw_sample = s->bps;
189 if (s->bps > 16)
190 avctx->sample_fmt = SAMPLE_FMT_S32;
191 else
192 avctx->sample_fmt = SAMPLE_FMT_S16;
4f52c312 193
aeb987ce 194 s->samples = get_bits_long(&gb, 32) << 4;
ee4d0322 195 s->samples |= get_bits(&gb, 4);
115329f1 196
ee4d0322
JR
197 skip_bits_long(&gb, 64); /* md5 sum */
198 skip_bits_long(&gb, 64); /* md5 sum */
115329f1 199
4bc07e78 200 dump_headers(avctx, s);
17c90b9d
AJ
201}
202
5b63d33d
JR
203void ff_flac_parse_block_header(const uint8_t *block_header,
204 int *last, int *type, int *size)
205{
206 int tmp = bytestream_get_byte(&block_header);
207 if (last)
208 *last = tmp & 0x80;
209 if (type)
210 *type = tmp & 0x7F;
211 if (size)
212 *size = bytestream_get_be24(&block_header);
213}
214
17c90b9d 215/**
a8ec12bc
JR
216 * Parse the STREAMINFO from an inline header.
217 * @param s the flac decoding context
218 * @param buf input buffer, starting with the "fLaC" marker
219 * @param buf_size buffer size
55a72738 220 * @return non-zero if metadata is invalid
17c90b9d 221 */
a8ec12bc 222static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
17c90b9d 223{
a8ec12bc 224 int metadata_type, metadata_size;
17c90b9d 225
a8ec12bc
JR
226 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
227 /* need more data */
228 return 0;
229 }
5b63d33d 230 ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
a8ec12bc
JR
231 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
232 metadata_size != FLAC_STREAMINFO_SIZE) {
233 return AVERROR_INVALIDDATA;
234 }
5b63d33d 235 ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
a8ec12bc
JR
236 allocate_buffers(s);
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 {
5b63d33d
JR
255 ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
256 buf += 4;
a8ec12bc
JR
257 if (buf + metadata_size > buf_end) {
258 /* need more data in order to read the complete header */
259 return 0;
6a85fb34 260 }
a8ec12bc 261 buf += metadata_size;
6a85fb34 262 } while (!metadata_last);
17c90b9d 263
a8ec12bc 264 return buf_size - (buf_end - buf);
4f52c312
MN
265}
266
267static int decode_residuals(FLACContext *s, int channel, int pred_order)
268{
269 int i, tmp, partition, method_type, rice_order;
270 int sample = 0, samples;
271
272 method_type = get_bits(&s->gb, 2);
1bec121f 273 if (method_type > 1) {
9f3d3ecf
JR
274 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
275 method_type);
4f52c312 276 return -1;
ac2570a8 277 }
115329f1 278
4f52c312
MN
279 rice_order = get_bits(&s->gb, 4);
280
ac2570a8 281 samples= s->blocksize >> rice_order;
5484dad7 282 if (pred_order > samples) {
9f3d3ecf
JR
283 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
284 pred_order, samples);
5484dad7
RD
285 return -1;
286 }
4f52c312 287
115329f1 288 sample=
ac2570a8 289 i= pred_order;
1bec121f 290 for (partition = 0; partition < (1 << rice_order); partition++) {
e471443a 291 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
1bec121f 292 if (tmp == (method_type == 0 ? 15 : 31)) {
4f52c312 293 tmp = get_bits(&s->gb, 5);
4f52c312 294 for (; i < samples; i++, sample++)
9de6e090 295 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
1bec121f
JR
296 } else {
297 for (; i < samples; i++, sample++) {
4fd12598 298 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
ac2570a8 299 }
4f52c312 300 }
ac2570a8 301 i= 0;
4f52c312
MN
302 }
303
4f52c312 304 return 0;
115329f1 305}
4f52c312
MN
306
307static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
308{
08965b22
LM
309 const int blocksize = s->blocksize;
310 int32_t *decoded = s->decoded[channel];
7846418b 311 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
115329f1 312
4f52c312 313 /* warm up samples */
1bec121f 314 for (i = 0; i < pred_order; i++) {
9de6e090 315 decoded[i] = get_sbits_long(&s->gb, s->curr_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
357static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
358{
0187178e 359 int i, j;
4f52c312
MN
360 int coeff_prec, qlevel;
361 int coeffs[pred_order];
d1a5c421 362 int32_t *decoded = s->decoded[channel];
115329f1 363
4f52c312 364 /* warm up samples */
1bec121f 365 for (i = 0; i < pred_order; i++) {
9de6e090 366 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
4f52c312 367 }
115329f1 368
4f52c312 369 coeff_prec = get_bits(&s->gb, 4) + 1;
1bec121f 370 if (coeff_prec == 16) {
5305f40b 371 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
4f52c312
MN
372 return -1;
373 }
ac2570a8 374 qlevel = get_sbits(&s->gb, 5);
1bec121f 375 if (qlevel < 0) {
9f3d3ecf
JR
376 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
377 qlevel);
9d656110
MN
378 return -1;
379 }
380
1bec121f 381 for (i = 0; i < pred_order; i++) {
ac2570a8 382 coeffs[i] = get_sbits(&s->gb, coeff_prec);
4f52c312 383 }
115329f1 384
4f52c312
MN
385 if (decode_residuals(s, channel, pred_order) < 0)
386 return -1;
387
0187178e
LB
388 if (s->bps > 16) {
389 int64_t sum;
1bec121f 390 for (i = pred_order; i < s->blocksize; i++) {
0187178e
LB
391 sum = 0;
392 for (j = 0; j < pred_order; j++)
d1a5c421
LM
393 sum += (int64_t)coeffs[j] * decoded[i-j-1];
394 decoded[i] += sum >> qlevel;
0187178e
LB
395 }
396 } else {
1bec121f 397 for (i = pred_order; i < s->blocksize-1; i += 2) {
d1a5c421
LM
398 int c;
399 int d = decoded[i-pred_order];
400 int s0 = 0, s1 = 0;
1bec121f 401 for (j = pred_order-1; j > 0; j--) {
d1a5c421 402 c = coeffs[j];
bd49d4fd 403 s0 += c*d;
d1a5c421
LM
404 d = decoded[i-j];
405 s1 += c*d;
bd49d4fd 406 }
d1a5c421
LM
407 c = coeffs[0];
408 s0 += c*d;
409 d = decoded[i] += s0 >> qlevel;
410 s1 += c*d;
411 decoded[i+1] += s1 >> qlevel;
bd49d4fd 412 }
1bec121f 413 if (i < s->blocksize) {
bd49d4fd 414 int sum = 0;
0187178e 415 for (j = 0; j < pred_order; j++)
d1a5c421
LM
416 sum += coeffs[j] * decoded[i-j-1];
417 decoded[i] += sum >> qlevel;
0187178e 418 }
4f52c312 419 }
115329f1 420
4f52c312
MN
421 return 0;
422}
423
424static inline int decode_subframe(FLACContext *s, int channel)
425{
426 int type, wasted = 0;
427 int i, tmp;
115329f1 428
4f52c312 429 s->curr_bps = s->bps;
1bec121f 430 if (channel == 0) {
2a346725 431 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
ac2570a8 432 s->curr_bps++;
1bec121f 433 } else {
2a346725 434 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
ac2570a8
MN
435 s->curr_bps++;
436 }
437
1bec121f 438 if (get_bits1(&s->gb)) {
1cef211d 439 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
4f52c312
MN
440 return -1;
441 }
442 type = get_bits(&s->gb, 6);
c5706efd 443
1bec121f 444 if (get_bits1(&s->gb)) {
4f52c312
MN
445 wasted = 1;
446 while (!get_bits1(&s->gb))
447 wasted++;
448 s->curr_bps -= wasted;
449 }
a3d2379b
JR
450 if (s->curr_bps > 32) {
451 ff_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
452 return -1;
453 }
c5706efd 454
ac2570a8 455//FIXME use av_log2 for types
1bec121f 456 if (type == 0) {
9de6e090 457 tmp = get_sbits_long(&s->gb, s->curr_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++)
9de6e090 462 s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
1bec121f 463 } else if ((type >= 8) && (type <= 12)) {
4f52c312
MN
464 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
465 return -1;
1bec121f 466 } else if (type >= 32) {
4f52c312
MN
467 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
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
02b26d2d 483static int decode_frame(FLACContext *s)
4f52c312 484{
5c3e0340 485 int bs_code, sr_code, bps_code, i;
7660dc6f 486 int ch_mode, bps, blocksize, samplerate, channels;
7e00bd84 487 GetBitContext *gb = &s->gb;
115329f1 488
4285c292
JR
489 /* frame sync code */
490 skip_bits(&s->gb, 16);
4f52c312 491
4285c292
JR
492 /* block size and sample rate codes */
493 bs_code = get_bits(gb, 4);
3b4d96fa 494 sr_code = get_bits(gb, 4);
115329f1 495
4285c292
JR
496 /* channels and decorrelation */
497 ch_mode = get_bits(gb, 4);
492cc392 498 if (ch_mode < FLAC_MAX_CHANNELS) {
7660dc6f 499 channels = ch_mode + 1;
2a346725 500 ch_mode = FLAC_CHMODE_INDEPENDENT;
7660dc6f
JR
501 } else if (ch_mode <= FLAC_CHMODE_MID_SIDE) {
502 channels = 2;
503 } else {
504 av_log(s->avctx, AV_LOG_ERROR, "invalid channel mode: %d\n", ch_mode);
505 return -1;
506 }
507 if (channels != s->channels) {
508 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
509 "is not supported\n");
4f52c312
MN
510 return -1;
511 }
115329f1 512
4285c292 513 /* bits per sample */
3b4d96fa
JR
514 bps_code = get_bits(gb, 3);
515 if (bps_code == 0)
0496a034 516 bps= s->bps;
3b4d96fa
JR
517 else if ((bps_code != 3) && (bps_code != 7))
518 bps = sample_size_table[bps_code];
1bec121f 519 else {
9f3d3ecf 520 av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n",
3b4d96fa 521 bps_code);
4f52c312
MN
522 return -1;
523 }
82159ad9
JR
524 if (bps > 16) {
525 s->avctx->sample_fmt = SAMPLE_FMT_S32;
526 s->sample_shift = 32 - bps;
527 s->is32 = 1;
528 } else {
529 s->avctx->sample_fmt = SAMPLE_FMT_S16;
530 s->sample_shift = 16 - bps;
531 s->is32 = 0;
532 }
533 s->bps = s->avctx->bits_per_raw_sample = bps;
4f52c312 534
4285c292 535 /* reserved bit */
7e00bd84 536 if (get_bits1(gb)) {
1cef211d 537 av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
0496a034 538 return -1;
4f52c312 539 }
115329f1 540
4285c292 541 /* sample or frame count */
7e00bd84 542 if (get_utf8(gb) < 0) {
0496a034
MN
543 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
544 return -1;
545 }
115329f1 546
4285c292 547 /* blocksize */
3b4d96fa 548 if (bs_code == 0) {
dde318d5
JR
549 av_log(s->avctx, AV_LOG_ERROR, "reserved blocksize code: 0\n");
550 return -1;
3b4d96fa 551 } else if (bs_code == 6)
7e00bd84 552 blocksize = get_bits(gb, 8)+1;
3b4d96fa 553 else if (bs_code == 7)
7e00bd84 554 blocksize = get_bits(gb, 16)+1;
115329f1 555 else
3b4d96fa 556 blocksize = ff_flac_blocksize_table[bs_code];
4f52c312 557
1bec121f 558 if (blocksize > s->max_blocksize) {
9f3d3ecf
JR
559 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize,
560 s->max_blocksize);
ac2570a8
MN
561 return -1;
562 }
563
4285c292 564 /* sample rate */
3b4d96fa 565 if (sr_code == 0)
0496a034 566 samplerate= s->samplerate;
3b4d96fa
JR
567 else if (sr_code < 12)
568 samplerate = ff_flac_sample_rate_table[sr_code];
569 else if (sr_code == 12)
7e00bd84 570 samplerate = get_bits(gb, 8) * 1000;
3b4d96fa 571 else if (sr_code == 13)
7e00bd84 572 samplerate = get_bits(gb, 16);
3b4d96fa 573 else if (sr_code == 14)
7e00bd84 574 samplerate = get_bits(gb, 16) * 10;
1bec121f 575 else {
9f3d3ecf 576 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n",
3b4d96fa 577 sr_code);
ac2570a8 578 return -1;
4f52c312
MN
579 }
580
4285c292 581 /* header CRC-8 check */
7e00bd84 582 skip_bits(gb, 8);
5c3e0340
JR
583 if (av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, gb->buffer,
584 get_bits_count(gb)/8)) {
585 av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch\n");
9d656110
MN
586 return -1;
587 }
115329f1 588
0496a034
MN
589 s->blocksize = blocksize;
590 s->samplerate = samplerate;
591 s->bps = bps;
2a346725 592 s->ch_mode = ch_mode;
4f52c312 593
9482171b 594// dump_headers(s->avctx, (FLACStreaminfo *)s);
4f52c312
MN
595
596 /* subframes */
1bec121f 597 for (i = 0; i < s->channels; i++) {
4f52c312
MN
598 if (decode_subframe(s, i) < 0)
599 return -1;
600 }
115329f1 601
7e00bd84 602 align_get_bits(gb);
4f52c312
MN
603
604 /* frame footer */
7e00bd84 605 skip_bits(gb, 16); /* data crc */
4f52c312
MN
606
607 return 0;
608}
609
610static int flac_decode_frame(AVCodecContext *avctx,
611 void *data, int *data_size,
1545c5e5 612 const uint8_t *buf, int buf_size)
4f52c312
MN
613{
614 FLACContext *s = avctx->priv_data;
fd6fd470 615 int i, j = 0, input_buf_size = 0, bytes_read = 0;
82159ad9
JR
616 int16_t *samples_16 = data;
617 int32_t *samples_32 = data;
ac66834c 618 int alloc_data_size= *data_size;
02b26d2d 619 int output_size;
ac66834c
MN
620
621 *data_size=0;
4f52c312 622
1bec121f 623 if (s->max_framesize == 0) {
d3ce0792 624 s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header
ac2570a8
MN
625 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
626 }
627
1bec121f 628 if (1 && s->max_framesize) { //FIXME truncated
1df0390e
JR
629 if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C'))
630 buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize));
631 input_buf_size= buf_size;
ac2570a8 632
1df0390e
JR
633 if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
634 return -1;
e0168e3b 635
1df0390e
JR
636 if (s->allocated_bitstream_size < s->bitstream_size + buf_size)
637 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size);
e0168e3b 638
1df0390e 639 if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) {
9f3d3ecf
JR
640 memmove(s->bitstream, &s->bitstream[s->bitstream_index],
641 s->bitstream_size);
1df0390e
JR
642 s->bitstream_index=0;
643 }
9f3d3ecf
JR
644 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size],
645 buf, buf_size);
1df0390e
JR
646 buf= &s->bitstream[s->bitstream_index];
647 buf_size += s->bitstream_size;
648 s->bitstream_size= buf_size;
115329f1 649
1df0390e
JR
650 if (buf_size < s->max_framesize && input_buf_size) {
651 return input_buf_size;
652 }
ac2570a8 653 }
4f52c312 654
5ef4fa87 655 /* check that there is at least the smallest decodable amount of data.
8d1e885f
JR
656 this amount corresponds to the smallest valid FLAC frame possible.
657 FF F8 69 02 00 00 9A 00 00 34 46 */
629fb5c4 658 if (buf_size < 11)
5ef4fa87
JR
659 goto end;
660
55a72738 661 /* check for inline header */
a8ec12bc
JR
662 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
663 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
55a72738
JR
664 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
665 return -1;
666 }
a8ec12bc 667 bytes_read = get_metadata_size(buf, buf_size);
2b4b8c82 668 goto end;
55a72738 669 }
2b4b8c82 670
fd6fd470
JR
671 /* check for frame sync code and resync stream if necessary */
672 if ((AV_RB16(buf) & 0xFFFE) != 0xFFF8) {
673 const uint8_t *buf_end = buf + buf_size;
13de8a08 674 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
fd6fd470
JR
675 while (buf+2 < buf_end && (AV_RB16(buf) & 0xFFFE) != 0xFFF8)
676 buf++;
677 bytes_read = buf_size - (buf_end - buf);
678 goto end; // we may not have enough bits left to decode a frame, so try next time
13de8a08 679 }
fd6fd470
JR
680
681 /* decode frame */
682 init_get_bits(&s->gb, buf, buf_size*8);
02b26d2d 683 if (decode_frame(s) < 0) {
13de8a08
JR
684 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
685 s->bitstream_size=0;
686 s->bitstream_index=0;
687 return -1;
688 }
bf1d7e28 689 bytes_read = (get_bits_count(&s->gb)+7)/8;
ac2570a8 690
02b26d2d
JR
691 /* check if allocated data size is large enough for output */
692 output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
693 if (output_size > alloc_data_size) {
694 av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
695 "allocated data size\n");
b6fa746e 696 goto end;
02b26d2d
JR
697 }
698 *data_size = output_size;
699
c448303d
MN
700#define DECORRELATE(left, right)\
701 assert(s->channels == 2);\
1bec121f 702 for (i = 0; i < s->blocksize; i++) {\
c448303d
MN
703 int a= s->decoded[0][i];\
704 int b= s->decoded[1][i];\
82159ad9
JR
705 if (s->is32) {\
706 *samples_32++ = (left) << s->sample_shift;\
707 *samples_32++ = (right) << s->sample_shift;\
708 } else {\
709 *samples_16++ = (left) << s->sample_shift;\
710 *samples_16++ = (right) << s->sample_shift;\
711 }\
c448303d
MN
712 }\
713 break;
714
2a346725 715 switch (s->ch_mode) {
3159780b 716 case FLAC_CHMODE_INDEPENDENT:
1bec121f 717 for (j = 0; j < s->blocksize; j++) {
82159ad9
JR
718 for (i = 0; i < s->channels; i++) {
719 if (s->is32)
720 *samples_32++ = s->decoded[i][j] << s->sample_shift;
721 else
722 *samples_16++ = s->decoded[i][j] << s->sample_shift;
723 }
1bec121f
JR
724 }
725 break;
3159780b 726 case FLAC_CHMODE_LEFT_SIDE:
1bec121f 727 DECORRELATE(a,a-b)
3159780b 728 case FLAC_CHMODE_RIGHT_SIDE:
1bec121f 729 DECORRELATE(a+b,b)
3159780b 730 case FLAC_CHMODE_MID_SIDE:
1bec121f 731 DECORRELATE( (a-=b>>1) + b, a)
4f52c312 732 }
4f52c312 733
a8ec12bc 734end:
c5199729
JR
735 if (bytes_read > buf_size) {
736 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
9d656110
MN
737 s->bitstream_size=0;
738 s->bitstream_index=0;
ac2570a8
MN
739 return -1;
740 }
4f52c312 741
1bec121f 742 if (s->bitstream_size) {
c5199729
JR
743 s->bitstream_index += bytes_read;
744 s->bitstream_size -= bytes_read;
ac2570a8 745 return input_buf_size;
1bec121f 746 } else
c5199729 747 return bytes_read;
4f52c312
MN
748}
749
98a6fff9 750static av_cold int flac_decode_close(AVCodecContext *avctx)
4f52c312
MN
751{
752 FLACContext *s = avctx->priv_data;
753 int i;
115329f1 754
1bec121f 755 for (i = 0; i < s->channels; i++) {
ac2570a8 756 av_freep(&s->decoded[i]);
4f52c312 757 }
ac2570a8 758 av_freep(&s->bitstream);
115329f1 759
4f52c312
MN
760 return 0;
761}
762
1bec121f
JR
763static void flac_flush(AVCodecContext *avctx)
764{
1e31d32c
MN
765 FLACContext *s = avctx->priv_data;
766
767 s->bitstream_size=
768 s->bitstream_index= 0;
769}
770
4f52c312
MN
771AVCodec flac_decoder = {
772 "flac",
773 CODEC_TYPE_AUDIO,
774 CODEC_ID_FLAC,
775 sizeof(FLACContext),
776 flac_decode_init,
777 NULL,
778 flac_decode_close,
779 flac_decode_frame,
4c453ddb 780 CODEC_CAP_DELAY,
115329f1 781 .flush= flac_flush,
fe4bf374 782 .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
4f52c312 783};