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