FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/flacdec.c
Date: 2023-03-31 03:41:15
Exec Total Coverage
Lines: 273 407 67.1%
Functions: 14 18 77.8%
Branches: 182 336 54.2%
Line Branch Exec Source
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/crc.h"
38 #include "libavutil/opt.h"
39 #include "avcodec.h"
40 #include "codec_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 "flac_parse.h"
48 #include "thread.h"
49 #include "unary.h"
50
51
52 typedef struct FLACContext {
53 AVClass *class;
54 FLACStreaminfo stream_info;
55
56 AVCodecContext *avctx; ///< parent AVCodecContext
57 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
58
59 int blocksize; ///< number of samples in the current frame
60 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
61 int ch_mode; ///< channel decorrelation type in the current frame
62 int got_streaminfo; ///< indicates if the STREAMINFO has been read
63
64 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
65 uint8_t *decoded_buffer;
66 unsigned int decoded_buffer_size;
67 int64_t *decoded_33bps; ///< decoded samples for a 33 bps subframe
68 uint8_t *decoded_buffer_33bps;
69 unsigned int decoded_buffer_size_33bps;
70 int buggy_lpc; ///< use workaround for old lavc encoded files
71
72 FLACDSPContext dsp;
73 } FLACContext;
74
75 static int allocate_buffers(FLACContext *s);
76
77 108 static void flac_set_bps(FLACContext *s)
78 {
79 108 enum AVSampleFormat req = s->avctx->request_sample_fmt;
80 108 int need32 = s->stream_info.bps > 16;
81 108 int want32 = av_get_bytes_per_sample(req) > 2;
82 108 int planar = av_sample_fmt_is_planar(req);
83
84
3/4
✓ Branch 0 taken 90 times.
✓ Branch 1 taken 18 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 90 times.
 108 if (need32 || want32) {
85
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
 18 if (planar)
86 ✗ s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
87 else
88 18 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
89 18 s->sample_shift = 32 - s->stream_info.bps;
90 } else {
91
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 90 times.
 90 if (planar)
92 ✗ s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
93 else
94 90 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
95 90 s->sample_shift = 16 - s->stream_info.bps;
96 }
97 108 }
98
99 108 static av_cold int flac_decode_init(AVCodecContext *avctx)
100 {
101 uint8_t *streaminfo;
102 int ret;
103 108 FLACContext *s = avctx->priv_data;
104 108 s->avctx = avctx;
105
106 /* for now, the raw FLAC header is allowed to be passed to the decoder as
107 frame data instead of extradata. */
108
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 92 times.
 108 if (!avctx->extradata)
109 16 return 0;
110
111
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 92 times.
 92 if (!ff_flac_is_extradata_valid(avctx, &streaminfo))
112 ✗ return AVERROR_INVALIDDATA;
113
114 /* initialize based on the demuxer-supplied streamdata header */
115 92 ret = ff_flac_parse_streaminfo(avctx, &s->stream_info, streaminfo);
116
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 92 times.
 92 if (ret < 0)
117 ✗ return ret;
118 92 ret = allocate_buffers(s);
119
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 92 times.
 92 if (ret < 0)
120 ✗ return ret;
121 92 flac_set_bps(s);
122 92 ff_flacdsp_init(&s->dsp, avctx->sample_fmt,
123 s->stream_info.channels);
124 92 s->got_streaminfo = 1;
125
126 92 return 0;
127 }
128
129 16 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
130 {
131 16 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
132 16 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
133 16 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
134 16 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
135 16 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
136 16 }
137
138 108 static int allocate_buffers(FLACContext *s)
139 {
140 int buf_size;
141 int ret;
142
143
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108 times.
 108 av_assert0(s->stream_info.max_blocksize);
144
145 108 buf_size = av_samples_get_buffer_size(NULL, s->stream_info.channels,
146 s->stream_info.max_blocksize,
147 AV_SAMPLE_FMT_S32P, 0);
148
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108 times.
 108 if (buf_size < 0)
149 ✗ return buf_size;
150
151 108 av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
152
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108 times.
 108 if (!s->decoded_buffer)
153 ✗ return AVERROR(ENOMEM);
154
155 108 ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
156 108 s->decoded_buffer,
157 s->stream_info.channels,
158 s->stream_info.max_blocksize,
159 AV_SAMPLE_FMT_S32P, 0);
160
4/6
✓ Branch 0 taken 108 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 106 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
 108 if (ret >= 0 && s->stream_info.bps == 32 && s->stream_info.channels == 2) {
161 2 buf_size = av_samples_get_buffer_size(NULL, 1,
162 s->stream_info.max_blocksize,
163 AV_SAMPLE_FMT_S64P, 0);
164
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (buf_size < 0)
165 ✗ return buf_size;
166
167 2 av_fast_malloc(&s->decoded_buffer_33bps, &s->decoded_buffer_size_33bps, buf_size);
168
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (!s->decoded_buffer_33bps)
169 ✗ return AVERROR(ENOMEM);
170
171 2 ret = av_samples_fill_arrays((uint8_t **)&s->decoded_33bps, NULL,
172 2 s->decoded_buffer_33bps,
173 1,
174 s->stream_info.max_blocksize,
175 AV_SAMPLE_FMT_S64P, 0);
176
177 }
178 108 return ret < 0 ? ret : 0;
179 }
180
181 /**
182 * Parse the STREAMINFO from an inline header.
183 * @param s the flac decoding context
184 * @param buf input buffer, starting with the "fLaC" marker
185 * @param buf_size buffer size
186 * @return non-zero if metadata is invalid
187 */
188 ✗ static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
189 {
190 int metadata_type, metadata_size, ret;
191
192 ✗ if (buf_size < FLAC_STREAMINFO_SIZE+8) {
193 /* need more data */
194 ✗ return 0;
195 }
196 ✗ flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
197 ✗ if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
198 ✗ metadata_size != FLAC_STREAMINFO_SIZE) {
199 ✗ return AVERROR_INVALIDDATA;
200 }
201 ✗ ret = ff_flac_parse_streaminfo(s->avctx, &s->stream_info, &buf[8]);
202 ✗ if (ret < 0)
203 ✗ return ret;
204 ✗ ret = allocate_buffers(s);
205 ✗ if (ret < 0)
206 ✗ return ret;
207 ✗ flac_set_bps(s);
208 ✗ ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
209 s->stream_info.channels);
210 ✗ s->got_streaminfo = 1;
211
212 ✗ return 0;
213 }
214
215 /**
216 * Determine the size of an inline header.
217 * @param buf input buffer, starting with the "fLaC" marker
218 * @param buf_size buffer size
219 * @return number of bytes in the header, or 0 if more data is needed
220 */
221 ✗ static int get_metadata_size(const uint8_t *buf, int buf_size)
222 {
223 int metadata_last, metadata_size;
224 ✗ const uint8_t *buf_end = buf + buf_size;
225
226 ✗ buf += 4;
227 do {
228 ✗ if (buf_end - buf < 4)
229 ✗ return AVERROR_INVALIDDATA;
230 ✗ flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
231 ✗ buf += 4;
232 ✗ if (buf_end - buf < metadata_size) {
233 /* need more data in order to read the complete header */
234 ✗ return AVERROR_INVALIDDATA;
235 }
236 ✗ buf += metadata_size;
237 ✗ } while (!metadata_last);
238
239 ✗ return buf_size - (buf_end - buf);
240 }
241
242 10490 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
243 {
244 10490 GetBitContext gb = s->gb;
245 int i, tmp, partition, method_type, rice_order;
246 int rice_bits, rice_esc;
247 int samples;
248
249 10490 method_type = get_bits(&gb, 2);
250 10490 rice_order = get_bits(&gb, 4);
251
252 10490 samples = s->blocksize >> rice_order;
253 10490 rice_bits = 4 + method_type;
254 10490 rice_esc = (1 << rice_bits) - 1;
255
256 10490 decoded += pred_order;
257 10490 i = pred_order;
258
259
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10490 times.
 10490 if (method_type > 1) {
260 ✗ av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
261 method_type);
262 ✗ return AVERROR_INVALIDDATA;
263 }
264
265
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10490 times.
 10490 if (samples << rice_order != s->blocksize) {
266 ✗ av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
267 rice_order, s->blocksize);
268 ✗ return AVERROR_INVALIDDATA;
269 }
270
271
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10490 times.
 10490 if (pred_order > samples) {
272 ✗ av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
273 pred_order, samples);
274 ✗ return AVERROR_INVALIDDATA;
275 }
276
277
2/2
✓ Branch 0 taken 137620 times.
✓ Branch 1 taken 10489 times.
 148109 for (partition = 0; partition < (1 << rice_order); partition++) {
278 137620 tmp = get_bits(&gb, rice_bits);
279
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 137620 times.
 137620 if (tmp == rice_esc) {
280 ✗ tmp = get_bits(&gb, 5);
281 ✗ for (; i < samples; i++)
282 ✗ *decoded++ = get_sbits_long(&gb, tmp);
283 } else {
284
2/2
✓ Branch 0 taken 131787 times.
✓ Branch 1 taken 5833 times.
 137620 int real_limit = (tmp > 1) ? (INT_MAX >> (tmp - 1)) + 2 : INT_MAX;
285
2/2
✓ Branch 0 taken 57768762 times.
✓ Branch 1 taken 137619 times.
 57906381 for (; i < samples; i++) {
286 57768762 int v = get_sr_golomb_flac(&gb, tmp, real_limit, 1);
287
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 57768761 times.
 57768762 if (v == 0x80000000){
288 1 av_log(s->avctx, AV_LOG_ERROR, "invalid residual\n");
289 1 return AVERROR_INVALIDDATA;
290 }
291
292 57768761 *decoded++ = v;
293 }
294 }
295 137619 i= 0;
296 }
297
298 10489 s->gb = gb;
299
300 10489 return 0;
301 }
302
303 935 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
304 int pred_order, int bps)
305 {
306 935 const int blocksize = s->blocksize;
307 935 unsigned av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d);
308 int i;
309 int ret;
310
311 /* warm up samples */
312
2/2
✓ Branch 0 taken 2662 times.
✓ Branch 1 taken 935 times.
 3597 for (i = 0; i < pred_order; i++) {
313 2662 decoded[i] = get_sbits_long(&s->gb, bps);
314 }
315
316
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 935 times.
 935 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
317 ✗ return ret;
318
319
2/2
✓ Branch 0 taken 837 times.
✓ Branch 1 taken 98 times.
 935 if (pred_order > 0)
320 837 a = decoded[pred_order-1];
321
2/2
✓ Branch 0 taken 721 times.
✓ Branch 1 taken 214 times.
 935 if (pred_order > 1)
322 721 b = a - decoded[pred_order-2];
323
2/2
✓ Branch 0 taken 591 times.
✓ Branch 1 taken 344 times.
 935 if (pred_order > 2)
324 591 c = b - decoded[pred_order-2] + decoded[pred_order-3];
325
2/2
✓ Branch 0 taken 513 times.
✓ Branch 1 taken 422 times.
 935 if (pred_order > 3)
326 513 d = c - decoded[pred_order-2] + 2U*decoded[pred_order-3] - decoded[pred_order-4];
327
328
5/6
✓ Branch 0 taken 98 times.
✓ Branch 1 taken 116 times.
✓ Branch 2 taken 130 times.
✓ Branch 3 taken 78 times.
✓ Branch 4 taken 513 times.
✗ Branch 5 not taken.
 935 switch (pred_order) {
329 98 case 0:
330 98 break;
331 116 case 1:
332
2/2
✓ Branch 0 taken 505740 times.
✓ Branch 1 taken 116 times.
 505856 for (i = pred_order; i < blocksize; i++)
333 505740 decoded[i] = a += decoded[i];
334 116 break;
335 130 case 2:
336
2/2
✓ Branch 0 taken 549640 times.
✓ Branch 1 taken 130 times.
 549770 for (i = pred_order; i < blocksize; i++)
337 549640 decoded[i] = a += b += decoded[i];
338 130 break;
339 78 case 3:
340
2/2
✓ Branch 0 taken 117270 times.
✓ Branch 1 taken 78 times.
 117348 for (i = pred_order; i < blocksize; i++)
341 117270 decoded[i] = a += b += c += decoded[i];
342 78 break;
343 513 case 4:
344
2/2
✓ Branch 0 taken 587484 times.
✓ Branch 1 taken 513 times.
 587997 for (i = pred_order; i < blocksize; i++)
345 587484 decoded[i] = a += b += c += d += decoded[i];
346 513 break;
347 ✗ default:
348 ✗ av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
349 ✗ return AVERROR_INVALIDDATA;
350 }
351
352 935 return 0;
353 }
354
355 #define DECODER_SUBFRAME_FIXED_WIDE(residual) { \
356 const int blocksize = s->blocksize; \
357 int ret; \
358 \
359 if ((ret = decode_residuals(s, residual, pred_order)) < 0) \
360 return ret; \
361 \
362 switch (pred_order) { \
363 case 0: \
364 for (int i = pred_order; i < blocksize; i++) \
365 decoded[i] = residual[i]; \
366 break; \
367 case 1: \
368 for (int i = pred_order; i < blocksize; i++) \
369 decoded[i] = (int64_t)residual[i] + (int64_t)decoded[i-1];\
370 break; \
371 case 2: \
372 for (int i = pred_order; i < blocksize; i++) \
373 decoded[i] = (int64_t)residual[i] + 2*(int64_t)decoded[i-1] - (int64_t)decoded[i-2]; \
374 break; \
375 case 3: \
376 for (int i = pred_order; i < blocksize; i++) \
377 decoded[i] = (int64_t)residual[i] + 3*(int64_t)decoded[i-1] - 3*(int64_t)decoded[i-2] + (int64_t)decoded[i-3]; \
378 break; \
379 case 4: \
380 for (int i = pred_order; i < blocksize; i++) \
381 decoded[i] = (int64_t)residual[i] + 4*(int64_t)decoded[i-1] - 6*(int64_t)decoded[i-2] + 4*(int64_t)decoded[i-3] - (int64_t)decoded[i-4]; \
382 break; \
383 default: \
384 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); \
385 return AVERROR_INVALIDDATA; \
386 } \
387 return 0; \
388 }
389
390 ✗ static int decode_subframe_fixed_wide(FLACContext *s, int32_t *decoded,
391 int pred_order, int bps)
392 {
393 /* warm up samples */
394 ✗ for (int i = 0; i < pred_order; i++) {
395 ✗ decoded[i] = get_sbits_long(&s->gb, bps);
396 }
397 ✗ DECODER_SUBFRAME_FIXED_WIDE(decoded);
398 }
399
400
401 ✗ static int decode_subframe_fixed_33bps(FLACContext *s, int64_t *decoded,
402 int32_t *residual, int pred_order)
403 {
404 /* warm up samples */ \
405 ✗ for (int i = 0; i < pred_order; i++) { \
406 ✗ decoded[i] = get_sbits64(&s->gb, 33); \
407 } \
408 ✗ DECODER_SUBFRAME_FIXED_WIDE(residual);
409 }
410
411 1932 static void lpc_analyze_remodulate(SUINT32 *decoded, const int coeffs[32],
412 int order, int qlevel, int len, int bps)
413 {
414 int i, j;
415 1932 int ebps = 1 << (bps-1);
416 1932 unsigned sigma = 0;
417
418
2/2
✓ Branch 0 taken 8474229 times.
✓ Branch 1 taken 1932 times.
 8476161 for (i = order; i < len; i++)
419 8474229 sigma |= decoded[i] + ebps;
420
421
1/2
✓ Branch 0 taken 1932 times.
✗ Branch 1 not taken.
 1932 if (sigma < 2*ebps)
422 1932 return;
423
424 ✗ for (i = len - 1; i >= order; i--) {
425 ✗ int64_t p = 0;
426 ✗ for (j = 0; j < order; j++)
427 ✗ p += coeffs[j] * (int64_t)(int32_t)decoded[i-order+j];
428 ✗ decoded[i] -= p >> qlevel;
429 }
430 ✗ for (i = order; i < len; i++, decoded++) {
431 ✗ int32_t p = 0;
432 ✗ for (j = 0; j < order; j++)
433 ✗ p += coeffs[j] * (uint32_t)decoded[j];
434 ✗ decoded[j] += p >> qlevel;
435 }
436 }
437
438 9553 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
439 int bps)
440 {
441 int i, ret;
442 int coeff_prec, qlevel;
443 int coeffs[32];
444
445 /* warm up samples */
446
2/2
✓ Branch 0 taken 41424 times.
✓ Branch 1 taken 9553 times.
 50977 for (i = 0; i < pred_order; i++) {
447 41424 decoded[i] = get_sbits_long(&s->gb, bps);
448 }
449
450 9553 coeff_prec = get_bits(&s->gb, 4) + 1;
451
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9553 times.
 9553 if (coeff_prec == 16) {
452 ✗ av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
453 ✗ return AVERROR_INVALIDDATA;
454 }
455 9553 qlevel = get_sbits(&s->gb, 5);
456
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9553 times.
 9553 if (qlevel < 0) {
457 ✗ av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
458 qlevel);
459 ✗ return AVERROR_INVALIDDATA;
460 }
461
462
2/2
✓ Branch 0 taken 41424 times.
✓ Branch 1 taken 9553 times.
 50977 for (i = 0; i < pred_order; i++) {
463 41424 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
464 }
465
466
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 9552 times.
 9553 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
467 1 return ret;
468
469
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 9552 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 9552 if ( ( s->buggy_lpc && s->stream_info.bps <= 16)
470
3/4
✓ Branch 0 taken 9552 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6866 times.
✓ Branch 3 taken 2686 times.
 9552 || ( !s->buggy_lpc && bps <= 16
471
2/2
✓ Branch 0 taken 6173 times.
✓ Branch 1 taken 693 times.
 6866 && bps + coeff_prec + av_log2(pred_order) <= 32)) {
472 6173 s->dsp.lpc16(decoded, coeffs, pred_order, qlevel, s->blocksize);
473 } else {
474 3379 s->dsp.lpc32(decoded, coeffs, pred_order, qlevel, s->blocksize);
475
2/2
✓ Branch 0 taken 1932 times.
✓ Branch 1 taken 1447 times.
 3379 if (s->stream_info.bps <= 16)
476 1932 lpc_analyze_remodulate(decoded, coeffs, pred_order, qlevel, s->blocksize, bps);
477 }
478
479 9552 return 0;
480 }
481
482 2 static int decode_subframe_lpc_33bps(FLACContext *s, int64_t *decoded,
483 int32_t *residual, int pred_order)
484 {
485 int i, j, ret;
486 int coeff_prec, qlevel;
487 int coeffs[32];
488
489 /* warm up samples */
490
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 2 times.
 18 for (i = 0; i < pred_order; i++) {
491 16 decoded[i] = get_sbits64(&s->gb, 33);
492 }
493
494 2 coeff_prec = get_bits(&s->gb, 4) + 1;
495
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (coeff_prec == 16) {
496 ✗ av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
497 ✗ return AVERROR_INVALIDDATA;
498 }
499 2 qlevel = get_sbits(&s->gb, 5);
500
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (qlevel < 0) {
501 ✗ av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
502 qlevel);
503 ✗ return AVERROR_INVALIDDATA;
504 }
505
506
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 2 times.
 18 for (i = 0; i < pred_order; i++) {
507 16 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
508 }
509
510
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if ((ret = decode_residuals(s, residual, pred_order)) < 0)
511 ✗ return ret;
512
513
2/2
✓ Branch 0 taken 9200 times.
✓ Branch 1 taken 2 times.
 9202 for (i = pred_order; i < s->blocksize; i++, decoded++) {
514 9200 int64_t sum = 0;
515
2/2
✓ Branch 0 taken 73600 times.
✓ Branch 1 taken 9200 times.
 82800 for (j = 0; j < pred_order; j++)
516 73600 sum += (int64_t)coeffs[j] * decoded[j];
517 9200 decoded[j] = residual[i] + (sum >> qlevel);
518 }
519
520 2 return 0;
521 }
522
523 16270 static inline int decode_subframe(FLACContext *s, int channel)
524 {
525 16270 int32_t *decoded = s->decoded[channel];
526 16270 int type, wasted = 0;
527 16270 int bps = s->stream_info.bps;
528 int i, ret;
529
530
2/2
✓ Branch 0 taken 6059 times.
✓ Branch 1 taken 10211 times.
 16270 if (channel == 0) {
531
2/2
✓ Branch 0 taken 642 times.
✓ Branch 1 taken 5417 times.
 6059 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
532 642 bps++;
533 } else {
534
4/4
✓ Branch 0 taken 8582 times.
✓ Branch 1 taken 1629 times.
✓ Branch 2 taken 907 times.
✓ Branch 3 taken 7675 times.
 10211 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
535 2536 bps++;
536 }
537
538
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16270 times.
 16270 if (get_bits1(&s->gb)) {
539 ✗ av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
540 ✗ return AVERROR_INVALIDDATA;
541 }
542 16270 type = get_bits(&s->gb, 6);
543
544
2/2
✓ Branch 1 taken 5246 times.
✓ Branch 2 taken 11024 times.
 16270 if (get_bits1(&s->gb)) {
545 5246 int left = get_bits_left(&s->gb);
546
2/4
✓ Branch 0 taken 5246 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5246 times.
 5246 if ( left <= 0 ||
547
1/4
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 5246 times.
 5246 (left < bps && !show_bits_long(&s->gb, left)) ||
548 5246 !show_bits_long(&s->gb, bps-1)) {
549 ✗ av_log(s->avctx, AV_LOG_ERROR,
550 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
551 bps, left);
552 ✗ return AVERROR_INVALIDDATA;
553 }
554 5246 wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
555 5246 bps -= wasted;
556 }
557
558 //FIXME use av_log2 for types
559
2/2
✓ Branch 0 taken 5779 times.
✓ Branch 1 taken 10491 times.
 16270 if (type == 0) {
560
1/2
✓ Branch 0 taken 5779 times.
✗ Branch 1 not taken.
 5779 if (bps < 33) {
561 5779 int32_t tmp = get_sbits_long(&s->gb, bps);
562
2/2
✓ Branch 0 taken 35731968 times.
✓ Branch 1 taken 5779 times.
 35737747 for (i = 0; i < s->blocksize; i++)
563 35731968 decoded[i] = tmp;
564 } else {
565 ✗ int64_t tmp = get_sbits64(&s->gb, 33);
566 ✗ for (i = 0; i < s->blocksize; i++)
567 ✗ s->decoded_33bps[i] = tmp;
568 }
569
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 10490 times.
 10491 } else if (type == 1) {
570
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (bps < 33) {
571 ✗ for (i = 0; i < s->blocksize; i++)
572 ✗ decoded[i] = get_sbits_long(&s->gb, bps);
573 } else {
574
2/2
✓ Branch 0 taken 4608 times.
✓ Branch 1 taken 1 times.
 4609 for (i = 0; i < s->blocksize; i++)
575 4608 s->decoded_33bps[i] = get_sbits64(&s->gb, 33);
576 }
577
3/4
✓ Branch 0 taken 10490 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 935 times.
✓ Branch 3 taken 9555 times.
 11425 } else if ((type >= 8) && (type <= 12)) {
578 935 int order = type & ~0x8;
579
1/2
✓ Branch 0 taken 935 times.
✗ Branch 1 not taken.
 935 if (bps < 33) {
580
1/2
✓ Branch 0 taken 935 times.
✗ Branch 1 not taken.
 935 if (bps + order <= 32) {
581
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 935 times.
 935 if ((ret = decode_subframe_fixed(s, decoded, order, bps)) < 0)
582 ✗ return ret;
583 } else {
584 ✗ if ((ret = decode_subframe_fixed_wide(s, decoded, order, bps)) < 0)
585 ✗ return ret;
586 }
587 } else {
588 ✗ if ((ret = decode_subframe_fixed_33bps(s, s->decoded_33bps, decoded, order)) < 0)
589 ✗ return ret;
590 }
591
1/2
✓ Branch 0 taken 9555 times.
✗ Branch 1 not taken.
 9555 } else if (type >= 32) {
592
2/2
✓ Branch 0 taken 9553 times.
✓ Branch 1 taken 2 times.
 9555 if (bps < 33) {
593
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 9552 times.
 9553 if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
594 1 return ret;
595 } else {
596
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if ((ret = decode_subframe_lpc_33bps(s, s->decoded_33bps, decoded, (type & ~0x20)+1)) < 0)
597 ✗ return ret;
598 }
599 } else {
600 ✗ av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
601 ✗ return AVERROR_INVALIDDATA;
602 }
603
604
2/2
✓ Branch 0 taken 5246 times.
✓ Branch 1 taken 11023 times.
 16269 if (wasted) {
605
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 5240 times.
 5246 if (wasted+bps == 33) {
606 int i;
607
2/2
✓ Branch 0 taken 25701 times.
✓ Branch 1 taken 6 times.
 25707 for (i = 0; i < s->blocksize; i++)
608 25701 s->decoded_33bps[i] = (uint64_t)decoded[i] << wasted;
609
1/2
✓ Branch 0 taken 5240 times.
✗ Branch 1 not taken.
 5240 } else if (wasted < 32) {
610 int i;
611
2/2
✓ Branch 0 taken 34204525 times.
✓ Branch 1 taken 5240 times.
 34209765 for (i = 0; i < s->blocksize; i++)
612 34204525 decoded[i] = (unsigned)decoded[i] << wasted;
613 }
614 }
615
616 16269 return 0;
617 }
618
619 6059 static int decode_frame(FLACContext *s)
620 {
621 int i, ret;
622 6059 GetBitContext *gb = &s->gb;
623 FLACFrameInfo fi;
624
625
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6059 times.
 6059 if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
626 ✗ av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
627 ✗ return ret;
628 }
629
630
2/2
✓ Branch 0 taken 6043 times.
✓ Branch 1 taken 16 times.
 6059 if ( s->stream_info.channels
631
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6043 times.
 6043 && fi.channels != s->stream_info.channels
632 ✗ && s->got_streaminfo) {
633 ✗ s->stream_info.channels = fi.channels;
634 ✗ ff_flac_set_channel_layout(s->avctx, fi.channels);
635 ✗ ret = allocate_buffers(s);
636 ✗ if (ret < 0)
637 ✗ return ret;
638 }
639 6059 s->stream_info.channels = fi.channels;
640 6059 ff_flac_set_channel_layout(s->avctx, fi.channels);
641 6059 s->ch_mode = fi.ch_mode;
642
643
3/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 6043 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
 6059 if (!s->stream_info.bps && !fi.bps) {
644 ✗ av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
645 ✗ return AVERROR_INVALIDDATA;
646 }
647
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6059 times.
 6059 if (!fi.bps) {
648 ✗ fi.bps = s->stream_info.bps;
649
3/4
✓ Branch 0 taken 6043 times.
✓ Branch 1 taken 16 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 6043 times.
 6059 } else if (s->stream_info.bps && fi.bps != s->stream_info.bps) {
650 ✗ av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
651 "supported\n");
652 ✗ return AVERROR_INVALIDDATA;
653 }
654
655
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 6043 times.
 6059 if (!s->stream_info.bps) {
656 16 s->stream_info.bps = s->avctx->bits_per_raw_sample = fi.bps;
657 16 flac_set_bps(s);
658 }
659
660
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 6043 times.
 6059 if (!s->stream_info.max_blocksize)
661 16 s->stream_info.max_blocksize = FLAC_MAX_BLOCKSIZE;
662
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6059 times.
 6059 if (fi.blocksize > s->stream_info.max_blocksize) {
663 ✗ av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
664 s->stream_info.max_blocksize);
665 ✗ return AVERROR_INVALIDDATA;
666 }
667 6059 s->blocksize = fi.blocksize;
668
669
3/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 6043 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
 6059 if (!s->stream_info.samplerate && !fi.samplerate) {
670 ✗ av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
671 " or frame header\n");
672 ✗ return AVERROR_INVALIDDATA;
673 }
674
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6059 times.
 6059 if (fi.samplerate == 0)
675 ✗ fi.samplerate = s->stream_info.samplerate;
676 6059 s->stream_info.samplerate = s->avctx->sample_rate = fi.samplerate;
677
678
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 6043 times.
 6059 if (!s->got_streaminfo) {
679 16 ret = allocate_buffers(s);
680
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (ret < 0)
681 ✗ return ret;
682 16 s->got_streaminfo = 1;
683 16 dump_headers(s->avctx, &s->stream_info);
684 }
685 6059 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
686 s->stream_info.channels);
687
688 // dump_headers(s->avctx, &s->stream_info);
689
690 /* subframes */
691
2/2
✓ Branch 0 taken 16270 times.
✓ Branch 1 taken 6058 times.
 22328 for (i = 0; i < s->stream_info.channels; i++) {
692
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 16269 times.
 16270 if ((ret = decode_subframe(s, i)) < 0)
693 1 return ret;
694 }
695
696 6058 align_get_bits(gb);
697
698 /* frame footer */
699 6058 skip_bits(gb, 16); /* data crc */
700
701 6058 return 0;
702 }
703
704 9 static void decorrelate_33bps(int ch_mode, int32_t **decoded, int64_t *decoded_33bps, int len)
705 {
706 int i;
707
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (ch_mode == FLAC_CHMODE_LEFT_SIDE ) {
708 ✗ for (i = 0; i < len; i++)
709 ✗ decoded[1][i] = decoded[0][i] - decoded_33bps[i];
710
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 1 times.
 9 } else if (ch_mode == FLAC_CHMODE_RIGHT_SIDE ) {
711
2/2
✓ Branch 0 taken 34917 times.
✓ Branch 1 taken 8 times.
 34925 for (i = 0; i < len; i++)
712 34917 decoded[0][i] = decoded[1][i] + decoded_33bps[i];
713
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 } else if (ch_mode == FLAC_CHMODE_MID_SIDE ) {
714
2/2
✓ Branch 0 taken 4608 times.
✓ Branch 1 taken 1 times.
 4609 for (i = 0; i < len; i++) {
715 4608 uint64_t a = decoded[0][i];
716 4608 int64_t b = decoded_33bps[i];
717 4608 a -= b >> 1;
718 4608 decoded[0][i] = (a + b);
719 4608 decoded[1][i] = a;
720 }
721 }
722 9 }
723
724 6059 static int flac_decode_frame(AVCodecContext *avctx, AVFrame *frame,
725 int *got_frame_ptr, AVPacket *avpkt)
726 {
727 6059 const uint8_t *buf = avpkt->data;
728 6059 int buf_size = avpkt->size;
729 6059 FLACContext *s = avctx->priv_data;
730 6059 int bytes_read = 0;
731 int ret;
732
733 6059 *got_frame_ptr = 0;
734
735
2/4
✓ Branch 0 taken 6059 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6059 times.
 6059 if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
736 ✗ av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
737 ✗ return buf_size;
738 }
739
740
2/4
✓ Branch 0 taken 6059 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6059 times.
 6059 if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
741 ✗ av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
742 ✗ return buf_size;
743 }
744
745 /* check that there is at least the smallest decodable amount of data.
746 this amount corresponds to the smallest valid FLAC frame possible.
747 FF F8 69 02 00 00 9A 00 00 34 */
748
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6059 times.
 6059 if (buf_size < FLAC_MIN_FRAME_SIZE)
749 ✗ return buf_size;
750
751 /* check for inline header */
752
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6059 times.
 6059 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
753 ✗ if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
754 ✗ av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
755 ✗ return ret;
756 }
757 ✗ return get_metadata_size(buf, buf_size);
758 }
759
760 /* decode frame */
761
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6059 times.
 6059 if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
762 ✗ return ret;
763
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 6058 times.
 6059 if ((ret = decode_frame(s)) < 0) {
764 1 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
765 1 return ret;
766 }
767 6058 bytes_read = get_bits_count(&s->gb)/8;
768
769
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6058 times.
 6058 if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
770 ✗ av_crc(av_crc_get_table(AV_CRC_16_ANSI),
771 0, buf, bytes_read)) {
772 ✗ av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
773 ✗ if (s->avctx->err_recognition & AV_EF_EXPLODE)
774 ✗ return AVERROR_INVALIDDATA;
775 }
776
777 /* get output buffer */
778 6058 frame->nb_samples = s->blocksize;
779
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6058 times.
 6058 if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
780 ✗ return ret;
781
782
4/4
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 6047 times.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 2 times.
 6058 if (s->stream_info.bps == 32 && s->ch_mode > 0) {
783 9 decorrelate_33bps(s->ch_mode, s->decoded, s->decoded_33bps, s->blocksize);
784 9 s->dsp.decorrelate[0](frame->data, s->decoded, s->stream_info.channels,
785 s->blocksize, s->sample_shift);
786 } else {
787 6049 s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded,
788 s->stream_info.channels,
789 s->blocksize, s->sample_shift);
790 }
791
792
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6058 times.
 6058 if (bytes_read > buf_size) {
793 ✗ av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
794 ✗ return AVERROR_INVALIDDATA;
795 }
796
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6058 times.
 6058 if (bytes_read < buf_size) {
797 ✗ av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
798 buf_size - bytes_read, buf_size);
799 }
800
801 6058 *got_frame_ptr = 1;
802
803 6058 return bytes_read;
804 }
805
806 108 static av_cold int flac_decode_close(AVCodecContext *avctx)
807 {
808 108 FLACContext *s = avctx->priv_data;
809
810 108 av_freep(&s->decoded_buffer);
811 108 av_freep(&s->decoded_buffer_33bps);
812
813 108 return 0;
814 }
815
816 static const AVOption options[] = {
817 { "use_buggy_lpc", "emulate old buggy lavc behavior", offsetof(FLACContext, buggy_lpc), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM },
818 { NULL },
819 };
820
821 static const AVClass flac_decoder_class = {
822 .class_name = "FLAC decoder",
823 .item_name = av_default_item_name,
824 .option = options,
825 .version = LIBAVUTIL_VERSION_INT,
826 };
827
828 const FFCodec ff_flac_decoder = {
829 .p.name = "flac",
830 CODEC_LONG_NAME("FLAC (Free Lossless Audio Codec)"),
831 .p.type = AVMEDIA_TYPE_AUDIO,
832 .p.id = AV_CODEC_ID_FLAC,
833 .priv_data_size = sizeof(FLACContext),
834 .init = flac_decode_init,
835 .close = flac_decode_close,
836 FF_CODEC_DECODE_CB(flac_decode_frame),
837 .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |
838 AV_CODEC_CAP_DR1 |
839 AV_CODEC_CAP_FRAME_THREADS,
840 .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
841 AV_SAMPLE_FMT_S16P,
842 AV_SAMPLE_FMT_S32,
843 AV_SAMPLE_FMT_S32P,
844 AV_SAMPLE_FMT_NONE },
845 .p.priv_class = &flac_decoder_class,
846 };
847