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