Merge remote-tracking branch 'qatar/master'
[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 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/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 };