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