Separate the raw FLAC muxer from raw.c to its own file, flacenc.c.
[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
75c998a2 38#define ALT_BITSTREAM_READER
245976da 39#include "libavutil/crc.h"
4f52c312 40#include "avcodec.h"
caa336b4 41#include "bitstream.h"
4f52c312 42#include "golomb.h"
9d48410f 43#include "flac.h"
4f52c312 44
ac2570a8
MN
45#undef NDEBUG
46#include <assert.h>
47
4f52c312
MN
48#define MAX_CHANNELS 8
49#define MAX_BLOCKSIZE 65535
50
9d656110 51enum decorrelation_type {
4f52c312
MN
52 INDEPENDENT,
53 LEFT_SIDE,
54 RIGHT_SIDE,
55 MID_SIDE,
56};
57
58typedef struct FLACContext {
9d48410f
JR
59 FLACSTREAMINFO
60
64cb3765
JR
61 AVCodecContext *avctx; ///< parent AVCodecContext
62 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
4f52c312 63
64cb3765
JR
64 int blocksize; ///< number of samples in the current frame
65 int curr_bps; ///< bps for current subframe, adjusted for channel correlation and wasted bits
7f3a6a05
JR
66 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
67 int is32; ///< flag to indicate if output should be 32-bit instead of 16-bit
64cb3765 68 enum decorrelation_type decorrelation; ///< channel decorrelation type in the current frame
4f52c312 69
64cb3765 70 int32_t *decoded[MAX_CHANNELS]; ///< decoded samples
ac2570a8 71 uint8_t *bitstream;
1e77df15
MN
72 unsigned int bitstream_size;
73 unsigned int bitstream_index;
f038fe8b 74 unsigned int allocated_bitstream_size;
4f52c312
MN
75} FLACContext;
76
cf2baeb3 77static const int sample_rate_table[] =
959e0006
JR
78{ 0,
79 88200, 176400, 192000,
4f52c312 80 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
115329f1 81 0, 0, 0, 0 };
4f52c312 82
cf2baeb3 83static const int sample_size_table[] =
4f52c312
MN
84{ 0, 8, 12, 0, 16, 20, 24, 0 };
85
cf2baeb3 86static const int blocksize_table[] = {
115329f1
DB
87 0, 192, 576<<0, 576<<1, 576<<2, 576<<3, 0, 0,
88256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
0496a034
MN
89};
90
1bec121f
JR
91static int64_t get_utf8(GetBitContext *gb)
92{
9d82b0dd
MN
93 int64_t val;
94 GET_UTF8(val, get_bits(gb, 8), return -1;)
ac2570a8 95 return val;
4f52c312
MN
96}
97
17c90b9d
AJ
98static void allocate_buffers(FLACContext *s);
99static int metadata_parse(FLACContext *s);
9eda2f94 100
1bec121f 101static av_cold int flac_decode_init(AVCodecContext *avctx)
4f52c312 102{
9eda2f94
MM
103 FLACContext *s = avctx->priv_data;
104 s->avctx = avctx;
105
faeb2bd4
JR
106 avctx->sample_fmt = SAMPLE_FMT_S16;
107
17c90b9d
AJ
108 if (avctx->extradata_size > 4) {
109 /* initialize based on the demuxer-supplied streamdata header */
17c90b9d 110 if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
9f3d3ecf
JR
111 ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s,
112 avctx->extradata);
17c90b9d
AJ
113 allocate_buffers(s);
114 } else {
512b37bb 115 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
17c90b9d
AJ
116 metadata_parse(s);
117 }
9eda2f94
MM
118 }
119
4f52c312
MN
120 return 0;
121}
122
9482171b 123static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
4f52c312 124{
9f3d3ecf
JR
125 av_log(avctx, AV_LOG_DEBUG, " Blocksize: %d .. %d\n", s->min_blocksize,
126 s->max_blocksize);
4bc07e78
JR
127 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
128 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
129 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
130 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
4f52c312
MN
131}
132
1bec121f
JR
133static void allocate_buffers(FLACContext *s)
134{
4f52c312
MN
135 int i;
136
ac2570a8
MN
137 assert(s->max_blocksize);
138
1bec121f 139 if (s->max_framesize == 0 && s->max_blocksize) {
9f3d3ecf
JR
140 // FIXME header overhead
141 s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8;
ac2570a8
MN
142 }
143
1bec121f 144 for (i = 0; i < s->channels; i++) {
9f3d3ecf
JR
145 s->decoded[i] = av_realloc(s->decoded[i],
146 sizeof(int32_t)*s->max_blocksize);
ac2570a8
MN
147 }
148
1bec121f 149 if (s->allocated_bitstream_size < s->max_framesize)
9f3d3ecf
JR
150 s->bitstream= av_fast_realloc(s->bitstream,
151 &s->allocated_bitstream_size,
152 s->max_framesize);
ac2570a8
MN
153}
154
9482171b
JR
155void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
156 const uint8_t *buffer)
ac2570a8 157{
a128cc91
JR
158 GetBitContext gb;
159 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
160
4f52c312 161 /* mandatory streaminfo */
a128cc91
JR
162 s->min_blocksize = get_bits(&gb, 16);
163 s->max_blocksize = get_bits(&gb, 16);
4f52c312 164
a128cc91
JR
165 skip_bits(&gb, 24); /* skip min frame size */
166 s->max_framesize = get_bits_long(&gb, 24);
115329f1 167
a128cc91
JR
168 s->samplerate = get_bits_long(&gb, 20);
169 s->channels = get_bits(&gb, 3) + 1;
170 s->bps = get_bits(&gb, 5) + 1;
115329f1 171
a128cc91
JR
172 avctx->channels = s->channels;
173 avctx->sample_rate = s->samplerate;
82159ad9
JR
174 avctx->bits_per_raw_sample = s->bps;
175 if (s->bps > 16)
176 avctx->sample_fmt = SAMPLE_FMT_S32;
177 else
178 avctx->sample_fmt = SAMPLE_FMT_S16;
4f52c312 179
aeb987ce
JR
180 s->samples = get_bits_long(&gb, 32) << 4;
181 s->samples |= get_bits_long(&gb, 4);
115329f1 182
a128cc91
JR
183 skip_bits(&gb, 64); /* md5 sum */
184 skip_bits(&gb, 64); /* md5 sum */
115329f1 185
4bc07e78 186 dump_headers(avctx, s);
17c90b9d
AJ
187}
188
189/**
190 * Parse a list of metadata blocks. This list of blocks must begin with
191 * the fLaC marker.
192 * @param s the flac decoding context containing the gb bit reader used to
193 * parse metadata
194 * @return 1 if some metadata was read, 0 if no fLaC marker was found
195 */
196static int metadata_parse(FLACContext *s)
197{
198 int i, metadata_last, metadata_type, metadata_size, streaminfo_updated=0;
e0168e3b 199 int initial_pos= get_bits_count(&s->gb);
17c90b9d
AJ
200
201 if (show_bits_long(&s->gb, 32) == MKBETAG('f','L','a','C')) {
202 skip_bits(&s->gb, 32);
203
17c90b9d 204 do {
5fc32c27 205 metadata_last = get_bits1(&s->gb);
17c90b9d
AJ
206 metadata_type = get_bits(&s->gb, 7);
207 metadata_size = get_bits_long(&s->gb, 24);
208
1bec121f 209 if (get_bits_count(&s->gb) + 8*metadata_size > s->gb.size_in_bits) {
e0168e3b
MN
210 skip_bits_long(&s->gb, initial_pos - get_bits_count(&s->gb));
211 break;
212 }
213
17c90b9d
AJ
214 if (metadata_size) {
215 switch (metadata_type) {
d38b8821 216 case FLAC_METADATA_TYPE_STREAMINFO:
9f3d3ecf
JR
217 ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s,
218 s->gb.buffer+get_bits_count(&s->gb)/8);
17c90b9d 219 streaminfo_updated = 1;
17c90b9d
AJ
220
221 default:
1bec121f 222 for (i = 0; i < metadata_size; i++)
17c90b9d
AJ
223 skip_bits(&s->gb, 8);
224 }
225 }
226 } while (!metadata_last);
227
228 if (streaminfo_updated)
229 allocate_buffers(s);
230 return 1;
231 }
232 return 0;
4f52c312
MN
233}
234
235static int decode_residuals(FLACContext *s, int channel, int pred_order)
236{
237 int i, tmp, partition, method_type, rice_order;
238 int sample = 0, samples;
239
240 method_type = get_bits(&s->gb, 2);
1bec121f 241 if (method_type > 1) {
9f3d3ecf
JR
242 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
243 method_type);
4f52c312 244 return -1;
ac2570a8 245 }
115329f1 246
4f52c312
MN
247 rice_order = get_bits(&s->gb, 4);
248
ac2570a8 249 samples= s->blocksize >> rice_order;
5484dad7 250 if (pred_order > samples) {
9f3d3ecf
JR
251 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
252 pred_order, samples);
5484dad7
RD
253 return -1;
254 }
4f52c312 255
115329f1 256 sample=
ac2570a8 257 i= pred_order;
1bec121f 258 for (partition = 0; partition < (1 << rice_order); partition++) {
e471443a 259 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
1bec121f 260 if (tmp == (method_type == 0 ? 15 : 31)) {
4f52c312 261 tmp = get_bits(&s->gb, 5);
4f52c312 262 for (; i < samples; i++, sample++)
4fd12598 263 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
1bec121f
JR
264 } else {
265 for (; i < samples; i++, sample++) {
4fd12598 266 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
ac2570a8 267 }
4f52c312 268 }
ac2570a8 269 i= 0;
4f52c312
MN
270 }
271
4f52c312 272 return 0;
115329f1 273}
4f52c312
MN
274
275static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
276{
08965b22
LM
277 const int blocksize = s->blocksize;
278 int32_t *decoded = s->decoded[channel];
7846418b 279 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
115329f1 280
4f52c312 281 /* warm up samples */
1bec121f 282 for (i = 0; i < pred_order; i++) {
08965b22 283 decoded[i] = get_sbits(&s->gb, s->curr_bps);
4f52c312 284 }
115329f1 285
4f52c312
MN
286 if (decode_residuals(s, channel, pred_order) < 0)
287 return -1;
288
1bec121f 289 if (pred_order > 0)
1f4fa6a4 290 a = decoded[pred_order-1];
1bec121f 291 if (pred_order > 1)
1f4fa6a4 292 b = a - decoded[pred_order-2];
1bec121f 293 if (pred_order > 2)
1f4fa6a4 294 c = b - decoded[pred_order-2] + decoded[pred_order-3];
1bec121f 295 if (pred_order > 3)
1f4fa6a4 296 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
08965b22 297
1bec121f
JR
298 switch (pred_order) {
299 case 0:
300 break;
301 case 1:
302 for (i = pred_order; i < blocksize; i++)
303 decoded[i] = a += decoded[i];
304 break;
305 case 2:
306 for (i = pred_order; i < blocksize; i++)
307 decoded[i] = a += b += decoded[i];
308 break;
309 case 3:
310 for (i = pred_order; i < blocksize; i++)
311 decoded[i] = a += b += c += decoded[i];
312 break;
313 case 4:
314 for (i = pred_order; i < blocksize; i++)
315 decoded[i] = a += b += c += d += decoded[i];
316 break;
317 default:
318 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
319 return -1;
4f52c312 320 }
ac2570a8 321
4f52c312
MN
322 return 0;
323}
324
325static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
326{
0187178e 327 int i, j;
4f52c312
MN
328 int coeff_prec, qlevel;
329 int coeffs[pred_order];
d1a5c421 330 int32_t *decoded = s->decoded[channel];
115329f1 331
4f52c312 332 /* warm up samples */
1bec121f 333 for (i = 0; i < pred_order; i++) {
d1a5c421 334 decoded[i] = get_sbits(&s->gb, s->curr_bps);
4f52c312 335 }
115329f1 336
4f52c312 337 coeff_prec = get_bits(&s->gb, 4) + 1;
1bec121f 338 if (coeff_prec == 16) {
5305f40b 339 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
4f52c312
MN
340 return -1;
341 }
ac2570a8 342 qlevel = get_sbits(&s->gb, 5);
1bec121f 343 if (qlevel < 0) {
9f3d3ecf
JR
344 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
345 qlevel);
9d656110
MN
346 return -1;
347 }
348
1bec121f 349 for (i = 0; i < pred_order; i++) {
ac2570a8 350 coeffs[i] = get_sbits(&s->gb, coeff_prec);
4f52c312 351 }
115329f1 352
4f52c312
MN
353 if (decode_residuals(s, channel, pred_order) < 0)
354 return -1;
355
0187178e
LB
356 if (s->bps > 16) {
357 int64_t sum;
1bec121f 358 for (i = pred_order; i < s->blocksize; i++) {
0187178e
LB
359 sum = 0;
360 for (j = 0; j < pred_order; j++)
d1a5c421
LM
361 sum += (int64_t)coeffs[j] * decoded[i-j-1];
362 decoded[i] += sum >> qlevel;
0187178e
LB
363 }
364 } else {
1bec121f 365 for (i = pred_order; i < s->blocksize-1; i += 2) {
d1a5c421
LM
366 int c;
367 int d = decoded[i-pred_order];
368 int s0 = 0, s1 = 0;
1bec121f 369 for (j = pred_order-1; j > 0; j--) {
d1a5c421 370 c = coeffs[j];
bd49d4fd 371 s0 += c*d;
d1a5c421
LM
372 d = decoded[i-j];
373 s1 += c*d;
bd49d4fd 374 }
d1a5c421
LM
375 c = coeffs[0];
376 s0 += c*d;
377 d = decoded[i] += s0 >> qlevel;
378 s1 += c*d;
379 decoded[i+1] += s1 >> qlevel;
bd49d4fd 380 }
1bec121f 381 if (i < s->blocksize) {
bd49d4fd 382 int sum = 0;
0187178e 383 for (j = 0; j < pred_order; j++)
d1a5c421
LM
384 sum += coeffs[j] * decoded[i-j-1];
385 decoded[i] += sum >> qlevel;
0187178e 386 }
4f52c312 387 }
115329f1 388
4f52c312
MN
389 return 0;
390}
391
392static inline int decode_subframe(FLACContext *s, int channel)
393{
394 int type, wasted = 0;
395 int i, tmp;
115329f1 396
4f52c312 397 s->curr_bps = s->bps;
1bec121f
JR
398 if (channel == 0) {
399 if (s->decorrelation == RIGHT_SIDE)
ac2570a8 400 s->curr_bps++;
1bec121f
JR
401 } else {
402 if (s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
ac2570a8
MN
403 s->curr_bps++;
404 }
405
1bec121f 406 if (get_bits1(&s->gb)) {
1cef211d 407 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
4f52c312
MN
408 return -1;
409 }
410 type = get_bits(&s->gb, 6);
c5706efd 411
1bec121f 412 if (get_bits1(&s->gb)) {
4f52c312
MN
413 wasted = 1;
414 while (!get_bits1(&s->gb))
415 wasted++;
416 s->curr_bps -= wasted;
417 }
c5706efd 418
ac2570a8 419//FIXME use av_log2 for types
1bec121f 420 if (type == 0) {
ac2570a8 421 tmp = get_sbits(&s->gb, s->curr_bps);
4f52c312
MN
422 for (i = 0; i < s->blocksize; i++)
423 s->decoded[channel][i] = tmp;
1bec121f 424 } else if (type == 1) {
4f52c312 425 for (i = 0; i < s->blocksize; i++)
ac2570a8 426 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
1bec121f 427 } else if ((type >= 8) && (type <= 12)) {
4f52c312
MN
428 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
429 return -1;
1bec121f 430 } else if (type >= 32) {
4f52c312
MN
431 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
432 return -1;
1bec121f 433 } else {
1cef211d 434 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
4f52c312
MN
435 return -1;
436 }
115329f1 437
1bec121f 438 if (wasted) {
4f52c312
MN
439 int i;
440 for (i = 0; i < s->blocksize; i++)
441 s->decoded[channel][i] <<= wasted;
442 }
443
444 return 0;
445}
446
ac66834c 447static int decode_frame(FLACContext *s, int alloc_data_size)
4f52c312 448{
9d656110 449 int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
0496a034 450 int decorrelation, bps, blocksize, samplerate;
115329f1 451
4f52c312 452 blocksize_code = get_bits(&s->gb, 4);
4f52c312
MN
453
454 sample_rate_code = get_bits(&s->gb, 4);
115329f1 455
4f52c312 456 assignment = get_bits(&s->gb, 4); /* channel assignment */
0496a034
MN
457 if (assignment < 8 && s->channels == assignment+1)
458 decorrelation = INDEPENDENT;
459 else if (assignment >=8 && assignment < 11 && s->channels == 2)
460 decorrelation = LEFT_SIDE + assignment - 8;
1bec121f 461 else {
9f3d3ecf
JR
462 av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n",
463 assignment, s->channels);
4f52c312
MN
464 return -1;
465 }
115329f1 466
4f52c312 467 sample_size_code = get_bits(&s->gb, 3);
1bec121f 468 if (sample_size_code == 0)
0496a034 469 bps= s->bps;
1bec121f 470 else if ((sample_size_code != 3) && (sample_size_code != 7))
0496a034 471 bps = sample_size_table[sample_size_code];
1bec121f 472 else {
9f3d3ecf
JR
473 av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n",
474 sample_size_code);
4f52c312
MN
475 return -1;
476 }
82159ad9
JR
477 if (bps > 16) {
478 s->avctx->sample_fmt = SAMPLE_FMT_S32;
479 s->sample_shift = 32 - bps;
480 s->is32 = 1;
481 } else {
482 s->avctx->sample_fmt = SAMPLE_FMT_S16;
483 s->sample_shift = 16 - bps;
484 s->is32 = 0;
485 }
486 s->bps = s->avctx->bits_per_raw_sample = bps;
4f52c312 487
1bec121f 488 if (get_bits1(&s->gb)) {
1cef211d 489 av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
0496a034 490 return -1;
4f52c312 491 }
115329f1 492
1bec121f 493 if (get_utf8(&s->gb) < 0) {
0496a034
MN
494 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
495 return -1;
496 }
115329f1 497
ac2570a8 498 if (blocksize_code == 0)
0496a034 499 blocksize = s->min_blocksize;
ac2570a8 500 else if (blocksize_code == 6)
0496a034 501 blocksize = get_bits(&s->gb, 8)+1;
ac2570a8 502 else if (blocksize_code == 7)
0496a034 503 blocksize = get_bits(&s->gb, 16)+1;
115329f1 504 else
0496a034 505 blocksize = blocksize_table[blocksize_code];
4f52c312 506
1bec121f 507 if (blocksize > s->max_blocksize) {
9f3d3ecf
JR
508 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize,
509 s->max_blocksize);
ac2570a8
MN
510 return -1;
511 }
512
1bec121f 513 if (blocksize * s->channels * sizeof(int16_t) > alloc_data_size)
ac66834c
MN
514 return -1;
515
1bec121f 516 if (sample_rate_code == 0)
0496a034 517 samplerate= s->samplerate;
1bec121f 518 else if (sample_rate_code < 12)
0496a034 519 samplerate = sample_rate_table[sample_rate_code];
ac2570a8 520 else if (sample_rate_code == 12)
0496a034 521 samplerate = get_bits(&s->gb, 8) * 1000;
ac2570a8 522 else if (sample_rate_code == 13)
0496a034 523 samplerate = get_bits(&s->gb, 16);
ac2570a8 524 else if (sample_rate_code == 14)
0496a034 525 samplerate = get_bits(&s->gb, 16) * 10;
1bec121f 526 else {
9f3d3ecf
JR
527 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n",
528 sample_rate_code);
ac2570a8 529 return -1;
4f52c312
MN
530 }
531
9d656110 532 skip_bits(&s->gb, 8);
3abe5fbd
AJ
533 crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
534 s->gb.buffer, get_bits_count(&s->gb)/8);
1bec121f 535 if (crc8) {
160d679c 536 av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
9d656110
MN
537 return -1;
538 }
115329f1 539
0496a034
MN
540 s->blocksize = blocksize;
541 s->samplerate = samplerate;
542 s->bps = bps;
543 s->decorrelation= decorrelation;
4f52c312 544
9482171b 545// dump_headers(s->avctx, (FLACStreaminfo *)s);
4f52c312
MN
546
547 /* subframes */
1bec121f 548 for (i = 0; i < s->channels; i++) {
4f52c312
MN
549 if (decode_subframe(s, i) < 0)
550 return -1;
551 }
115329f1 552
4f52c312
MN
553 align_get_bits(&s->gb);
554
555 /* frame footer */
556 skip_bits(&s->gb, 16); /* data crc */
557
558 return 0;
559}
560
561static int flac_decode_frame(AVCodecContext *avctx,
562 void *data, int *data_size,
1545c5e5 563 const uint8_t *buf, int buf_size)
4f52c312
MN
564{
565 FLACContext *s = avctx->priv_data;
3f1899a8 566 int tmp = 0, i, j = 0, input_buf_size = 0;
82159ad9
JR
567 int16_t *samples_16 = data;
568 int32_t *samples_32 = data;
ac66834c
MN
569 int alloc_data_size= *data_size;
570
571 *data_size=0;
4f52c312 572
1bec121f 573 if (s->max_framesize == 0) {
d3ce0792 574 s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header
ac2570a8
MN
575 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
576 }
577
1bec121f 578 if (1 && s->max_framesize) { //FIXME truncated
1df0390e
JR
579 if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C'))
580 buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize));
581 input_buf_size= buf_size;
ac2570a8 582
1df0390e
JR
583 if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
584 return -1;
e0168e3b 585
1df0390e
JR
586 if (s->allocated_bitstream_size < s->bitstream_size + buf_size)
587 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size);
e0168e3b 588
1df0390e 589 if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) {
9f3d3ecf
JR
590 memmove(s->bitstream, &s->bitstream[s->bitstream_index],
591 s->bitstream_size);
1df0390e
JR
592 s->bitstream_index=0;
593 }
9f3d3ecf
JR
594 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size],
595 buf, buf_size);
1df0390e
JR
596 buf= &s->bitstream[s->bitstream_index];
597 buf_size += s->bitstream_size;
598 s->bitstream_size= buf_size;
115329f1 599
1df0390e
JR
600 if (buf_size < s->max_framesize && input_buf_size) {
601 return input_buf_size;
602 }
ac2570a8 603 }
4f52c312
MN
604
605 init_get_bits(&s->gb, buf, buf_size*8);
115329f1 606
1bec121f 607 if (metadata_parse(s))
2b4b8c82
MN
608 goto end;
609
13de8a08 610 tmp = show_bits(&s->gb, 16);
1bec121f 611 if ((tmp & 0xFFFE) != 0xFFF8) {
13de8a08 612 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
1bec121f 613 while (get_bits_count(&s->gb)/8+2 < buf_size && (show_bits(&s->gb, 16) & 0xFFFE) != 0xFFF8)
13de8a08
JR
614 skip_bits(&s->gb, 8);
615 goto end; // we may not have enough bits left to decode a frame, so try next time
616 }
617 skip_bits(&s->gb, 16);
1bec121f 618 if (decode_frame(s, alloc_data_size) < 0) {
13de8a08
JR
619 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
620 s->bitstream_size=0;
621 s->bitstream_index=0;
622 return -1;
623 }
ac2570a8 624
c448303d
MN
625#define DECORRELATE(left, right)\
626 assert(s->channels == 2);\
1bec121f 627 for (i = 0; i < s->blocksize; i++) {\
c448303d
MN
628 int a= s->decoded[0][i];\
629 int b= s->decoded[1][i];\
82159ad9
JR
630 if (s->is32) {\
631 *samples_32++ = (left) << s->sample_shift;\
632 *samples_32++ = (right) << s->sample_shift;\
633 } else {\
634 *samples_16++ = (left) << s->sample_shift;\
635 *samples_16++ = (right) << s->sample_shift;\
636 }\
c448303d
MN
637 }\
638 break;
639
1bec121f
JR
640 switch (s->decorrelation) {
641 case INDEPENDENT:
642 for (j = 0; j < s->blocksize; j++) {
82159ad9
JR
643 for (i = 0; i < s->channels; i++) {
644 if (s->is32)
645 *samples_32++ = s->decoded[i][j] << s->sample_shift;
646 else
647 *samples_16++ = s->decoded[i][j] << s->sample_shift;
648 }
1bec121f
JR
649 }
650 break;
651 case LEFT_SIDE:
652 DECORRELATE(a,a-b)
653 case RIGHT_SIDE:
654 DECORRELATE(a+b,b)
655 case MID_SIDE:
656 DECORRELATE( (a-=b>>1) + b, a)
4f52c312 657 }
4f52c312 658
82159ad9 659 *data_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
4f52c312 660
ac2570a8 661end:
cea96420 662 i= (get_bits_count(&s->gb)+7)/8;
1bec121f 663 if (i > buf_size) {
ac2570a8 664 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
9d656110
MN
665 s->bitstream_size=0;
666 s->bitstream_index=0;
ac2570a8
MN
667 return -1;
668 }
4f52c312 669
1bec121f 670 if (s->bitstream_size) {
ac2570a8
MN
671 s->bitstream_index += i;
672 s->bitstream_size -= i;
673 return input_buf_size;
1bec121f 674 } else
ac2570a8 675 return i;
4f52c312
MN
676}
677
98a6fff9 678static av_cold int flac_decode_close(AVCodecContext *avctx)
4f52c312
MN
679{
680 FLACContext *s = avctx->priv_data;
681 int i;
115329f1 682
1bec121f 683 for (i = 0; i < s->channels; i++) {
ac2570a8 684 av_freep(&s->decoded[i]);
4f52c312 685 }
ac2570a8 686 av_freep(&s->bitstream);
115329f1 687
4f52c312
MN
688 return 0;
689}
690
1bec121f
JR
691static void flac_flush(AVCodecContext *avctx)
692{
1e31d32c
MN
693 FLACContext *s = avctx->priv_data;
694
695 s->bitstream_size=
696 s->bitstream_index= 0;
697}
698
4f52c312
MN
699AVCodec flac_decoder = {
700 "flac",
701 CODEC_TYPE_AUDIO,
702 CODEC_ID_FLAC,
703 sizeof(FLACContext),
704 flac_decode_init,
705 NULL,
706 flac_decode_close,
707 flac_decode_frame,
4c453ddb 708 CODEC_CAP_DELAY,
115329f1 709 .flush= flac_flush,
fe4bf374 710 .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
4f52c312 711};