avcodec/flacdec: fix handling of av_samples_fill_arrays() return value
[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 #include "thread.h"
48 #include "unary.h"
49
50
51 typedef struct FLACContext {
52     FLACSTREAMINFO
53
54     AVCodecContext *avctx;                  ///< parent AVCodecContext
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 AVERROR_INVALIDDATA;
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     return 0;
119 }
120
121 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
122 {
123     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
124     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
125     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
126     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
127     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
128 }
129
130 static int allocate_buffers(FLACContext *s)
131 {
132     int buf_size;
133     int ret;
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     ret = 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     return ret < 0 ? ret : 0;
150 }
151
152 /**
153  * Parse the STREAMINFO from an inline header.
154  * @param s the flac decoding context
155  * @param buf input buffer, starting with the "fLaC" marker
156  * @param buf_size buffer size
157  * @return non-zero if metadata is invalid
158  */
159 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
160 {
161     int metadata_type, metadata_size, ret;
162
163     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
164         /* need more data */
165         return 0;
166     }
167     flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
168     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
169         metadata_size != FLAC_STREAMINFO_SIZE) {
170         return AVERROR_INVALIDDATA;
171     }
172     avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
173     ret = allocate_buffers(s);
174     if (ret < 0)
175         return ret;
176     flac_set_bps(s);
177     ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
178     s->got_streaminfo = 1;
179
180     return 0;
181 }
182
183 /**
184  * Determine the size of an inline header.
185  * @param buf input buffer, starting with the "fLaC" marker
186  * @param buf_size buffer size
187  * @return number of bytes in the header, or 0 if more data is needed
188  */
189 static int get_metadata_size(const uint8_t *buf, int buf_size)
190 {
191     int metadata_last, metadata_size;
192     const uint8_t *buf_end = buf + buf_size;
193
194     buf += 4;
195     do {
196         if (buf_end - buf < 4)
197             return 0;
198         flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
199         buf += 4;
200         if (buf_end - buf < metadata_size) {
201             /* need more data in order to read the complete header */
202             return 0;
203         }
204         buf += metadata_size;
205     } while (!metadata_last);
206
207     return buf_size - (buf_end - buf);
208 }
209
210 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
211 {
212     int i, tmp, partition, method_type, rice_order;
213     int rice_bits, rice_esc;
214     int samples;
215
216     method_type = get_bits(&s->gb, 2);
217     if (method_type > 1) {
218         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
219                method_type);
220         return AVERROR_INVALIDDATA;
221     }
222
223     rice_order = get_bits(&s->gb, 4);
224
225     samples= s->blocksize >> rice_order;
226     if (samples << rice_order != s->blocksize) {
227         av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
228                rice_order, s->blocksize);
229         return AVERROR_INVALIDDATA;
230     }
231
232     if (pred_order > samples) {
233         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
234                pred_order, samples);
235         return AVERROR_INVALIDDATA;
236     }
237
238     rice_bits = 4 + method_type;
239     rice_esc  = (1 << rice_bits) - 1;
240
241     decoded += pred_order;
242     i= pred_order;
243     for (partition = 0; partition < (1 << rice_order); partition++) {
244         tmp = get_bits(&s->gb, rice_bits);
245         if (tmp == rice_esc) {
246             tmp = get_bits(&s->gb, 5);
247             for (; i < samples; i++)
248                 *decoded++ = get_sbits_long(&s->gb, tmp);
249         } else {
250             for (; i < samples; i++) {
251                 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
252             }
253         }
254         i= 0;
255     }
256
257     return 0;
258 }
259
260 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
261                                  int pred_order, int bps)
262 {
263     const int blocksize = s->blocksize;
264     int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
265     int ret;
266
267     /* warm up samples */
268     for (i = 0; i < pred_order; i++) {
269         decoded[i] = get_sbits_long(&s->gb, bps);
270     }
271
272     if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
273         return ret;
274
275     if (pred_order > 0)
276         a = decoded[pred_order-1];
277     if (pred_order > 1)
278         b = a - decoded[pred_order-2];
279     if (pred_order > 2)
280         c = b - decoded[pred_order-2] + decoded[pred_order-3];
281     if (pred_order > 3)
282         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
283
284     switch (pred_order) {
285     case 0:
286         break;
287     case 1:
288         for (i = pred_order; i < blocksize; i++)
289             decoded[i] = a += decoded[i];
290         break;
291     case 2:
292         for (i = pred_order; i < blocksize; i++)
293             decoded[i] = a += b += decoded[i];
294         break;
295     case 3:
296         for (i = pred_order; i < blocksize; i++)
297             decoded[i] = a += b += c += decoded[i];
298         break;
299     case 4:
300         for (i = pred_order; i < blocksize; i++)
301             decoded[i] = a += b += c += d += decoded[i];
302         break;
303     default:
304         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
305         return AVERROR_INVALIDDATA;
306     }
307
308     return 0;
309 }
310
311 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
312                                int bps)
313 {
314     int i, ret;
315     int coeff_prec, qlevel;
316     int coeffs[32];
317
318     /* warm up samples */
319     for (i = 0; i < pred_order; i++) {
320         decoded[i] = get_sbits_long(&s->gb, bps);
321     }
322
323     coeff_prec = get_bits(&s->gb, 4) + 1;
324     if (coeff_prec == 16) {
325         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
326         return AVERROR_INVALIDDATA;
327     }
328     qlevel = get_sbits(&s->gb, 5);
329     if (qlevel < 0) {
330         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
331                qlevel);
332         return AVERROR_INVALIDDATA;
333     }
334
335     for (i = 0; i < pred_order; i++) {
336         coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
337     }
338
339     if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
340         return ret;
341
342     s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
343
344     return 0;
345 }
346
347 static inline int decode_subframe(FLACContext *s, int channel)
348 {
349     int32_t *decoded = s->decoded[channel];
350     int type, wasted = 0;
351     int bps = s->bps;
352     int i, tmp, ret;
353
354     if (channel == 0) {
355         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
356             bps++;
357     } else {
358         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
359             bps++;
360     }
361
362     if (get_bits1(&s->gb)) {
363         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
364         return AVERROR_INVALIDDATA;
365     }
366     type = get_bits(&s->gb, 6);
367
368     if (get_bits1(&s->gb)) {
369         int left = get_bits_left(&s->gb);
370         if ( left < 0 ||
371             (left < bps && !show_bits_long(&s->gb, left)) ||
372                            !show_bits_long(&s->gb, bps)) {
373             av_log(s->avctx, AV_LOG_ERROR,
374                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
375                    bps, left);
376             return AVERROR_INVALIDDATA;
377         }
378         wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
379         bps -= wasted;
380     }
381     if (bps > 32) {
382         avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
383         return AVERROR_PATCHWELCOME;
384     }
385
386 //FIXME use av_log2 for types
387     if (type == 0) {
388         tmp = get_sbits_long(&s->gb, bps);
389         for (i = 0; i < s->blocksize; i++)
390             decoded[i] = tmp;
391     } else if (type == 1) {
392         for (i = 0; i < s->blocksize; i++)
393             decoded[i] = get_sbits_long(&s->gb, bps);
394     } else if ((type >= 8) && (type <= 12)) {
395         if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
396             return ret;
397     } else if (type >= 32) {
398         if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
399             return ret;
400     } else {
401         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
402         return AVERROR_INVALIDDATA;
403     }
404
405     if (wasted) {
406         int i;
407         for (i = 0; i < s->blocksize; i++)
408             decoded[i] <<= wasted;
409     }
410
411     return 0;
412 }
413
414 static int decode_frame(FLACContext *s)
415 {
416     int i, ret;
417     GetBitContext *gb = &s->gb;
418     FLACFrameInfo fi;
419
420     if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
421         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
422         return ret;
423     }
424
425     if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
426         s->channels = s->avctx->channels = fi.channels;
427         ff_flac_set_channel_layout(s->avctx);
428         ret = allocate_buffers(s);
429         if (ret < 0)
430             return ret;
431     }
432     s->channels = s->avctx->channels = fi.channels;
433     if (!s->avctx->channel_layout)
434         ff_flac_set_channel_layout(s->avctx);
435     s->ch_mode = fi.ch_mode;
436
437     if (!s->bps && !fi.bps) {
438         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
439         return AVERROR_INVALIDDATA;
440     }
441     if (!fi.bps) {
442         fi.bps = s->bps;
443     } else if (s->bps && fi.bps != s->bps) {
444         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
445                                        "supported\n");
446         return AVERROR_INVALIDDATA;
447     }
448
449     if (!s->bps) {
450         s->bps = s->avctx->bits_per_raw_sample = fi.bps;
451         flac_set_bps(s);
452     }
453
454     if (!s->max_blocksize)
455         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
456     if (fi.blocksize > s->max_blocksize) {
457         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
458                s->max_blocksize);
459         return AVERROR_INVALIDDATA;
460     }
461     s->blocksize = fi.blocksize;
462
463     if (!s->samplerate && !fi.samplerate) {
464         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
465                                         " or frame header\n");
466         return AVERROR_INVALIDDATA;
467     }
468     if (fi.samplerate == 0)
469         fi.samplerate = s->samplerate;
470     s->samplerate = s->avctx->sample_rate = fi.samplerate;
471
472     if (!s->got_streaminfo) {
473         ret = allocate_buffers(s);
474         if (ret < 0)
475             return ret;
476         ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
477         s->got_streaminfo = 1;
478         dump_headers(s->avctx, (FLACStreaminfo *)s);
479     }
480
481 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
482
483     /* subframes */
484     for (i = 0; i < s->channels; i++) {
485         if ((ret = decode_subframe(s, i)) < 0)
486             return ret;
487     }
488
489     align_get_bits(gb);
490
491     /* frame footer */
492     skip_bits(gb, 16); /* data crc */
493
494     return 0;
495 }
496
497 static int flac_decode_frame(AVCodecContext *avctx, void *data,
498                              int *got_frame_ptr, AVPacket *avpkt)
499 {
500     AVFrame *frame     = data;
501     ThreadFrame tframe = { .f = data };
502     const uint8_t *buf = avpkt->data;
503     int buf_size = avpkt->size;
504     FLACContext *s = avctx->priv_data;
505     int bytes_read = 0;
506     int ret;
507
508     *got_frame_ptr = 0;
509
510     if (s->max_framesize == 0) {
511         s->max_framesize =
512             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
513                                        FLAC_MAX_CHANNELS, 32);
514     }
515
516     if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
517         av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
518         return buf_size;
519     }
520
521     if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
522         av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
523         return buf_size;
524     }
525
526     /* check that there is at least the smallest decodable amount of data.
527        this amount corresponds to the smallest valid FLAC frame possible.
528        FF F8 69 02 00 00 9A 00 00 34 46 */
529     if (buf_size < FLAC_MIN_FRAME_SIZE)
530         return buf_size;
531
532     /* check for inline header */
533     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
534         if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
535             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
536             return ret;
537         }
538         return get_metadata_size(buf, buf_size);
539     }
540
541     /* decode frame */
542     if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
543         return ret;
544     if ((ret = decode_frame(s)) < 0) {
545         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
546         return ret;
547     }
548     bytes_read = get_bits_count(&s->gb)/8;
549
550     if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
551         av_crc(av_crc_get_table(AV_CRC_16_ANSI),
552                0, buf, bytes_read)) {
553         av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
554         if (s->avctx->err_recognition & AV_EF_EXPLODE)
555             return AVERROR_INVALIDDATA;
556     }
557
558     /* get output buffer */
559     frame->nb_samples = s->blocksize;
560     if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
561         return ret;
562
563     s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
564                                    s->blocksize, s->sample_shift);
565
566     if (bytes_read > buf_size) {
567         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
568         return AVERROR_INVALIDDATA;
569     }
570     if (bytes_read < buf_size) {
571         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
572                buf_size - bytes_read, buf_size);
573     }
574
575     *got_frame_ptr = 1;
576
577     return bytes_read;
578 }
579
580 static int init_thread_copy(AVCodecContext *avctx)
581 {
582     FLACContext *s = avctx->priv_data;
583     s->decoded_buffer = NULL;
584     s->decoded_buffer_size = 0;
585     s->avctx = avctx;
586     if (s->max_blocksize)
587         return allocate_buffers(s);
588     return 0;
589 }
590
591 static av_cold int flac_decode_close(AVCodecContext *avctx)
592 {
593     FLACContext *s = avctx->priv_data;
594
595     av_freep(&s->decoded_buffer);
596
597     return 0;
598 }
599
600 AVCodec ff_flac_decoder = {
601     .name           = "flac",
602     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
603     .type           = AVMEDIA_TYPE_AUDIO,
604     .id             = AV_CODEC_ID_FLAC,
605     .priv_data_size = sizeof(FLACContext),
606     .init           = flac_decode_init,
607     .close          = flac_decode_close,
608     .decode         = flac_decode_frame,
609     .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
610     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
611     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
612                                                       AV_SAMPLE_FMT_S16P,
613                                                       AV_SAMPLE_FMT_S32,
614                                                       AV_SAMPLE_FMT_S32P,
615                                                       AV_SAMPLE_FMT_NONE },
616 };