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