FFmpeg coverage

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