flacdec: skip frame when allocated data size is too small
[libav.git] / libavcodec / flacdec.c
1 /*
2 * FLAC (Free Lossless Audio Codec) decoder
3 * Copyright (c) 2003 Alex Beregszaszi
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
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
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /**
23 * @file libavcodec/flacdec.c
24 * FLAC (Free Lossless Audio Codec) decoder
25 * @author Alex Beregszaszi
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.
34 */
35
36 #include <limits.h>
37
38 #include "libavutil/crc.h"
39 #include "avcodec.h"
40 #include "internal.h"
41 #include "bitstream.h"
42 #include "bytestream.h"
43 #include "golomb.h"
44 #include "flac.h"
45 #include "flacdata.h"
46
47 #undef NDEBUG
48 #include <assert.h>
49
50 typedef struct FLACContext {
51 FLACSTREAMINFO
52
53 AVCodecContext *avctx; ///< parent AVCodecContext
54 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
55
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
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
60 int ch_mode; ///< channel decorrelation type in the current frame
61 int got_streaminfo; ///< indicates if the STREAMINFO has been read
62
63 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
64 uint8_t *bitstream;
65 unsigned int bitstream_size;
66 unsigned int bitstream_index;
67 unsigned int allocated_bitstream_size;
68 } FLACContext;
69
70 static const int sample_size_table[] =
71 { 0, 8, 12, 0, 16, 20, 24, 0 };
72
73 static int64_t get_utf8(GetBitContext *gb)
74 {
75 int64_t val;
76 GET_UTF8(val, get_bits(gb, 8), return -1;)
77 return val;
78 }
79
80 static void allocate_buffers(FLACContext *s);
81
82 int 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 }
108
109 static av_cold int flac_decode_init(AVCodecContext *avctx)
110 {
111 enum FLACExtradataFormat format;
112 uint8_t *streaminfo;
113 FLACContext *s = avctx->priv_data;
114 s->avctx = avctx;
115
116 avctx->sample_fmt = SAMPLE_FMT_S16;
117
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
126 /* initialize based on the demuxer-supplied streamdata header */
127 ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
128 allocate_buffers(s);
129 s->got_streaminfo = 1;
130
131 return 0;
132 }
133
134 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
135 {
136 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
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);
141 }
142
143 static void allocate_buffers(FLACContext *s)
144 {
145 int i;
146
147 assert(s->max_blocksize);
148
149 if (s->max_framesize == 0 && s->max_blocksize) {
150 s->max_framesize = ff_flac_get_max_frame_size(s->max_blocksize,
151 s->channels, s->bps);
152 }
153
154 for (i = 0; i < s->channels; i++) {
155 s->decoded[i] = av_realloc(s->decoded[i],
156 sizeof(int32_t)*s->max_blocksize);
157 }
158
159 if (s->allocated_bitstream_size < s->max_framesize)
160 s->bitstream= av_fast_realloc(s->bitstream,
161 &s->allocated_bitstream_size,
162 s->max_framesize);
163 }
164
165 void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
166 const uint8_t *buffer)
167 {
168 GetBitContext gb;
169 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
170
171 skip_bits(&gb, 16); /* skip min blocksize */
172 s->max_blocksize = get_bits(&gb, 16);
173 if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
174 av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
175 s->max_blocksize);
176 s->max_blocksize = 16;
177 }
178
179 skip_bits(&gb, 24); /* skip min frame size */
180 s->max_framesize = get_bits_long(&gb, 24);
181
182 s->samplerate = get_bits_long(&gb, 20);
183 s->channels = get_bits(&gb, 3) + 1;
184 s->bps = get_bits(&gb, 5) + 1;
185
186 avctx->channels = s->channels;
187 avctx->sample_rate = s->samplerate;
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;
193
194 s->samples = get_bits_long(&gb, 32) << 4;
195 s->samples |= get_bits(&gb, 4);
196
197 skip_bits_long(&gb, 64); /* md5 sum */
198 skip_bits_long(&gb, 64); /* md5 sum */
199
200 dump_headers(avctx, s);
201 }
202
203 void 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
215 /**
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
220 * @return non-zero if metadata is invalid
221 */
222 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
223 {
224 int metadata_type, metadata_size;
225
226 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
227 /* need more data */
228 return 0;
229 }
230 ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
231 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
232 metadata_size != FLAC_STREAMINFO_SIZE) {
233 return AVERROR_INVALIDDATA;
234 }
235 ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
236 allocate_buffers(s);
237 s->got_streaminfo = 1;
238
239 return 0;
240 }
241
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 */
248 static 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;
252
253 buf += 4;
254 do {
255 ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
256 buf += 4;
257 if (buf + metadata_size > buf_end) {
258 /* need more data in order to read the complete header */
259 return 0;
260 }
261 buf += metadata_size;
262 } while (!metadata_last);
263
264 return buf_size - (buf_end - buf);
265 }
266
267 static 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);
273 if (method_type > 1) {
274 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
275 method_type);
276 return -1;
277 }
278
279 rice_order = get_bits(&s->gb, 4);
280
281 samples= s->blocksize >> rice_order;
282 if (pred_order > samples) {
283 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
284 pred_order, samples);
285 return -1;
286 }
287
288 sample=
289 i= pred_order;
290 for (partition = 0; partition < (1 << rice_order); partition++) {
291 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
292 if (tmp == (method_type == 0 ? 15 : 31)) {
293 tmp = get_bits(&s->gb, 5);
294 for (; i < samples; i++, sample++)
295 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
296 } else {
297 for (; i < samples; i++, sample++) {
298 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
299 }
300 }
301 i= 0;
302 }
303
304 return 0;
305 }
306
307 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
308 {
309 const int blocksize = s->blocksize;
310 int32_t *decoded = s->decoded[channel];
311 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
312
313 /* warm up samples */
314 for (i = 0; i < pred_order; i++) {
315 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
316 }
317
318 if (decode_residuals(s, channel, pred_order) < 0)
319 return -1;
320
321 if (pred_order > 0)
322 a = decoded[pred_order-1];
323 if (pred_order > 1)
324 b = a - decoded[pred_order-2];
325 if (pred_order > 2)
326 c = b - decoded[pred_order-2] + decoded[pred_order-3];
327 if (pred_order > 3)
328 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
329
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;
352 }
353
354 return 0;
355 }
356
357 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
358 {
359 int i, j;
360 int coeff_prec, qlevel;
361 int coeffs[pred_order];
362 int32_t *decoded = s->decoded[channel];
363
364 /* warm up samples */
365 for (i = 0; i < pred_order; i++) {
366 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
367 }
368
369 coeff_prec = get_bits(&s->gb, 4) + 1;
370 if (coeff_prec == 16) {
371 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
372 return -1;
373 }
374 qlevel = get_sbits(&s->gb, 5);
375 if (qlevel < 0) {
376 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
377 qlevel);
378 return -1;
379 }
380
381 for (i = 0; i < pred_order; i++) {
382 coeffs[i] = get_sbits(&s->gb, coeff_prec);
383 }
384
385 if (decode_residuals(s, channel, pred_order) < 0)
386 return -1;
387
388 if (s->bps > 16) {
389 int64_t sum;
390 for (i = pred_order; i < s->blocksize; i++) {
391 sum = 0;
392 for (j = 0; j < pred_order; j++)
393 sum += (int64_t)coeffs[j] * decoded[i-j-1];
394 decoded[i] += sum >> qlevel;
395 }
396 } else {
397 for (i = pred_order; i < s->blocksize-1; i += 2) {
398 int c;
399 int d = decoded[i-pred_order];
400 int s0 = 0, s1 = 0;
401 for (j = pred_order-1; j > 0; j--) {
402 c = coeffs[j];
403 s0 += c*d;
404 d = decoded[i-j];
405 s1 += c*d;
406 }
407 c = coeffs[0];
408 s0 += c*d;
409 d = decoded[i] += s0 >> qlevel;
410 s1 += c*d;
411 decoded[i+1] += s1 >> qlevel;
412 }
413 if (i < s->blocksize) {
414 int sum = 0;
415 for (j = 0; j < pred_order; j++)
416 sum += coeffs[j] * decoded[i-j-1];
417 decoded[i] += sum >> qlevel;
418 }
419 }
420
421 return 0;
422 }
423
424 static inline int decode_subframe(FLACContext *s, int channel)
425 {
426 int type, wasted = 0;
427 int i, tmp;
428
429 s->curr_bps = s->bps;
430 if (channel == 0) {
431 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
432 s->curr_bps++;
433 } else {
434 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
435 s->curr_bps++;
436 }
437
438 if (get_bits1(&s->gb)) {
439 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
440 return -1;
441 }
442 type = get_bits(&s->gb, 6);
443
444 if (get_bits1(&s->gb)) {
445 wasted = 1;
446 while (!get_bits1(&s->gb))
447 wasted++;
448 s->curr_bps -= wasted;
449 }
450 if (s->curr_bps > 32) {
451 ff_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
452 return -1;
453 }
454
455 //FIXME use av_log2 for types
456 if (type == 0) {
457 tmp = get_sbits_long(&s->gb, s->curr_bps);
458 for (i = 0; i < s->blocksize; i++)
459 s->decoded[channel][i] = tmp;
460 } else if (type == 1) {
461 for (i = 0; i < s->blocksize; i++)
462 s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
463 } else if ((type >= 8) && (type <= 12)) {
464 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
465 return -1;
466 } else if (type >= 32) {
467 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
468 return -1;
469 } else {
470 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
471 return -1;
472 }
473
474 if (wasted) {
475 int i;
476 for (i = 0; i < s->blocksize; i++)
477 s->decoded[channel][i] <<= wasted;
478 }
479
480 return 0;
481 }
482
483 static int decode_frame(FLACContext *s)
484 {
485 int bs_code, sr_code, bps_code, i;
486 int ch_mode, bps, blocksize, samplerate, channels;
487 GetBitContext *gb = &s->gb;
488
489 /* frame sync code */
490 skip_bits(&s->gb, 16);
491
492 /* block size and sample rate codes */
493 bs_code = get_bits(gb, 4);
494 sr_code = get_bits(gb, 4);
495
496 /* channels and decorrelation */
497 ch_mode = get_bits(gb, 4);
498 if (ch_mode < FLAC_MAX_CHANNELS) {
499 channels = ch_mode + 1;
500 ch_mode = FLAC_CHMODE_INDEPENDENT;
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");
510 return -1;
511 }
512
513 /* bits per sample */
514 bps_code = get_bits(gb, 3);
515 if (bps_code == 0)
516 bps= s->bps;
517 else if ((bps_code != 3) && (bps_code != 7))
518 bps = sample_size_table[bps_code];
519 else {
520 av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n",
521 bps_code);
522 return -1;
523 }
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;
534
535 /* reserved bit */
536 if (get_bits1(gb)) {
537 av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
538 return -1;
539 }
540
541 /* sample or frame count */
542 if (get_utf8(gb) < 0) {
543 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
544 return -1;
545 }
546
547 /* blocksize */
548 if (bs_code == 0) {
549 av_log(s->avctx, AV_LOG_ERROR, "reserved blocksize code: 0\n");
550 return -1;
551 } else if (bs_code == 6)
552 blocksize = get_bits(gb, 8)+1;
553 else if (bs_code == 7)
554 blocksize = get_bits(gb, 16)+1;
555 else
556 blocksize = ff_flac_blocksize_table[bs_code];
557
558 if (blocksize > s->max_blocksize) {
559 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize,
560 s->max_blocksize);
561 return -1;
562 }
563
564 /* sample rate */
565 if (sr_code == 0)
566 samplerate= s->samplerate;
567 else if (sr_code < 12)
568 samplerate = ff_flac_sample_rate_table[sr_code];
569 else if (sr_code == 12)
570 samplerate = get_bits(gb, 8) * 1000;
571 else if (sr_code == 13)
572 samplerate = get_bits(gb, 16);
573 else if (sr_code == 14)
574 samplerate = get_bits(gb, 16) * 10;
575 else {
576 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n",
577 sr_code);
578 return -1;
579 }
580
581 /* header CRC-8 check */
582 skip_bits(gb, 8);
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");
586 return -1;
587 }
588
589 s->blocksize = blocksize;
590 s->samplerate = samplerate;
591 s->bps = bps;
592 s->ch_mode = ch_mode;
593
594 // dump_headers(s->avctx, (FLACStreaminfo *)s);
595
596 /* subframes */
597 for (i = 0; i < s->channels; i++) {
598 if (decode_subframe(s, i) < 0)
599 return -1;
600 }
601
602 align_get_bits(gb);
603
604 /* frame footer */
605 skip_bits(gb, 16); /* data crc */
606
607 return 0;
608 }
609
610 static int flac_decode_frame(AVCodecContext *avctx,
611 void *data, int *data_size,
612 const uint8_t *buf, int buf_size)
613 {
614 FLACContext *s = avctx->priv_data;
615 int i, j = 0, input_buf_size = 0, bytes_read = 0;
616 int16_t *samples_16 = data;
617 int32_t *samples_32 = data;
618 int alloc_data_size= *data_size;
619 int output_size;
620
621 *data_size=0;
622
623 if (s->max_framesize == 0) {
624 s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header
625 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
626 }
627
628 if (1 && s->max_framesize) { //FIXME truncated
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;
632
633 if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
634 return -1;
635
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);
638
639 if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) {
640 memmove(s->bitstream, &s->bitstream[s->bitstream_index],
641 s->bitstream_size);
642 s->bitstream_index=0;
643 }
644 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size],
645 buf, buf_size);
646 buf= &s->bitstream[s->bitstream_index];
647 buf_size += s->bitstream_size;
648 s->bitstream_size= buf_size;
649
650 if (buf_size < s->max_framesize && input_buf_size) {
651 return input_buf_size;
652 }
653 }
654
655 /* check that there is at least the smallest decodable amount of data.
656 this amount corresponds to the smallest valid FLAC frame possible.
657 FF F8 69 02 00 00 9A 00 00 34 46 */
658 if (buf_size < 11)
659 goto end;
660
661 /* check for inline header */
662 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
663 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
664 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
665 return -1;
666 }
667 bytes_read = get_metadata_size(buf, buf_size);
668 goto end;
669 }
670
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;
674 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
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
679 }
680
681 /* decode frame */
682 init_get_bits(&s->gb, buf, buf_size*8);
683 if (decode_frame(s) < 0) {
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 }
689 bytes_read = (get_bits_count(&s->gb)+7)/8;
690
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");
696 goto end;
697 }
698 *data_size = output_size;
699
700 #define DECORRELATE(left, right)\
701 assert(s->channels == 2);\
702 for (i = 0; i < s->blocksize; i++) {\
703 int a= s->decoded[0][i];\
704 int b= s->decoded[1][i];\
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 }\
712 }\
713 break;
714
715 switch (s->ch_mode) {
716 case FLAC_CHMODE_INDEPENDENT:
717 for (j = 0; j < s->blocksize; j++) {
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 }
724 }
725 break;
726 case FLAC_CHMODE_LEFT_SIDE:
727 DECORRELATE(a,a-b)
728 case FLAC_CHMODE_RIGHT_SIDE:
729 DECORRELATE(a+b,b)
730 case FLAC_CHMODE_MID_SIDE:
731 DECORRELATE( (a-=b>>1) + b, a)
732 }
733
734 end:
735 if (bytes_read > buf_size) {
736 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
737 s->bitstream_size=0;
738 s->bitstream_index=0;
739 return -1;
740 }
741
742 if (s->bitstream_size) {
743 s->bitstream_index += bytes_read;
744 s->bitstream_size -= bytes_read;
745 return input_buf_size;
746 } else
747 return bytes_read;
748 }
749
750 static av_cold int flac_decode_close(AVCodecContext *avctx)
751 {
752 FLACContext *s = avctx->priv_data;
753 int i;
754
755 for (i = 0; i < s->channels; i++) {
756 av_freep(&s->decoded[i]);
757 }
758 av_freep(&s->bitstream);
759
760 return 0;
761 }
762
763 static void flac_flush(AVCodecContext *avctx)
764 {
765 FLACContext *s = avctx->priv_data;
766
767 s->bitstream_size=
768 s->bitstream_index= 0;
769 }
770
771 AVCodec 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,
780 CODEC_CAP_DELAY,
781 .flush= flac_flush,
782 .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
783 };