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