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