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