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