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