FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/flacdec.c
Date: 2022-01-18 10:05:52
Exec Total Coverage
Lines: 226 338 66.9%
Branches: 144 240 60.0%

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 "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 AVClass *class;
53 struct FLACStreaminfo flac_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 int buggy_lpc; ///< use workaround for old lavc encoded files
67
68 FLACDSPContext dsp;
69 } FLACContext;
70
71 static int allocate_buffers(FLACContext *s);
72
73 100 static void flac_set_bps(FLACContext *s)
74 {
75 100 enum AVSampleFormat req = s->avctx->request_sample_fmt;
76 100 int need32 = s->flac_stream_info.bps > 16;
77 100 int want32 = av_get_bytes_per_sample(req) > 2;
78 100 int planar = av_sample_fmt_is_planar(req);
79
80
3/4
✓ Branch 0 taken 86 times.
✓ Branch 1 taken 14 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 86 times.
100 if (need32 || want32) {
81
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14 times.
14 if (planar)
82 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
83 else
84 14 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
85 14 s->sample_shift = 32 - s->flac_stream_info.bps;
86 } else {
87
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 86 times.
86 if (planar)
88 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
89 else
90 86 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
91 86 s->sample_shift = 16 - s->flac_stream_info.bps;
92 }
93 100 }
94
95 100 static av_cold int flac_decode_init(AVCodecContext *avctx)
96 {
97 enum FLACExtradataFormat format;
98 uint8_t *streaminfo;
99 int ret;
100 100 FLACContext *s = avctx->priv_data;
101 100 s->avctx = avctx;
102
103 /* for now, the raw FLAC header is allowed to be passed to the decoder as
104 frame data instead of extradata. */
105
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 84 times.
100 if (!avctx->extradata)
106 16 return 0;
107
108
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 84 times.
84 if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
109 return AVERROR_INVALIDDATA;
110
111 /* initialize based on the demuxer-supplied streamdata header */
112 84 ret = ff_flac_parse_streaminfo(avctx, &s->flac_stream_info, streaminfo);
113
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 84 times.
84 if (ret < 0)
114 return ret;
115 84 ret = allocate_buffers(s);
116
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 84 times.
84 if (ret < 0)
117 return ret;
118 84 flac_set_bps(s);
119 84 ff_flacdsp_init(&s->dsp, avctx->sample_fmt,
120 s->flac_stream_info.channels, s->flac_stream_info.bps);
121 84 s->got_streaminfo = 1;
122
123 84 return 0;
124 }
125
126 16 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
127 {
128 16 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
129 16 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
130 16 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
131 16 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
132 16 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
133 16 }
134
135 100 static int allocate_buffers(FLACContext *s)
136 {
137 int buf_size;
138 int ret;
139
140
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 100 times.
100 av_assert0(s->flac_stream_info.max_blocksize);
141
142 100 buf_size = av_samples_get_buffer_size(NULL, s->flac_stream_info.channels,
143 s->flac_stream_info.max_blocksize,
144 AV_SAMPLE_FMT_S32P, 0);
145
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 100 times.
100 if (buf_size < 0)
146 return buf_size;
147
148 100 av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
149
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 100 times.
100 if (!s->decoded_buffer)
150 return AVERROR(ENOMEM);
151
152 100 ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
153 100 s->decoded_buffer,
154 s->flac_stream_info.channels,
155 s->flac_stream_info.max_blocksize,
156 AV_SAMPLE_FMT_S32P, 0);
157 100 return ret < 0 ? ret : 0;
158 }
159
160 /**
161 * Parse the STREAMINFO from an inline header.
162 * @param s the flac decoding context
163 * @param buf input buffer, starting with the "fLaC" marker
164 * @param buf_size buffer size
165 * @return non-zero if metadata is invalid
166 */
167 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
168 {
169 int metadata_type, metadata_size, ret;
170
171 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
172 /* need more data */
173 return 0;
174 }
175 flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
176 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
177 metadata_size != FLAC_STREAMINFO_SIZE) {
178 return AVERROR_INVALIDDATA;
179 }
180 ret = ff_flac_parse_streaminfo(s->avctx, &s->flac_stream_info, &buf[8]);
181 if (ret < 0)
182 return ret;
183 ret = allocate_buffers(s);
184 if (ret < 0)
185 return ret;
186 flac_set_bps(s);
187 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
188 s->flac_stream_info.channels, s->flac_stream_info.bps);
189 s->got_streaminfo = 1;
190
191 return 0;
192 }
193
194 /**
195 * Determine the size of an inline header.
196 * @param buf input buffer, starting with the "fLaC" marker
197 * @param buf_size buffer size
198 * @return number of bytes in the header, or 0 if more data is needed
199 */
200 static int get_metadata_size(const uint8_t *buf, int buf_size)
201 {
202 int metadata_last, metadata_size;
203 const uint8_t *buf_end = buf + buf_size;
204
205 buf += 4;
206 do {
207 if (buf_end - buf < 4)
208 return AVERROR_INVALIDDATA;
209 flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
210 buf += 4;
211 if (buf_end - buf < metadata_size) {
212 /* need more data in order to read the complete header */
213 return AVERROR_INVALIDDATA;
214 }
215 buf += metadata_size;
216 } while (!metadata_last);
217
218 return buf_size - (buf_end - buf);
219 }
220
221 9885 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
222 {
223 9885 GetBitContext gb = s->gb;
224 int i, tmp, partition, method_type, rice_order;
225 int rice_bits, rice_esc;
226 int samples;
227
228 9885 method_type = get_bits(&gb, 2);
229 9885 rice_order = get_bits(&gb, 4);
230
231 9885 samples = s->blocksize >> rice_order;
232 9885 rice_bits = 4 + method_type;
233 9885 rice_esc = (1 << rice_bits) - 1;
234
235 9885 decoded += pred_order;
236 9885 i = pred_order;
237
238
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9885 times.
9885 if (method_type > 1) {
239 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
240 method_type);
241 return AVERROR_INVALIDDATA;
242 }
243
244
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9885 times.
9885 if (samples << rice_order != s->blocksize) {
245 av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
246 rice_order, s->blocksize);
247 return AVERROR_INVALIDDATA;
248 }
249
250
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9885 times.
9885 if (pred_order > samples) {
251 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
252 pred_order, samples);
253 return AVERROR_INVALIDDATA;
254 }
255
256
2/2
✓ Branch 0 taken 128148 times.
✓ Branch 1 taken 9884 times.
138032 for (partition = 0; partition < (1 << rice_order); partition++) {
257 128148 tmp = get_bits(&gb, rice_bits);
258
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 128148 times.
128148 if (tmp == rice_esc) {
259 tmp = get_bits(&gb, 5);
260 for (; i < samples; i++)
261 *decoded++ = get_sbits_long(&gb, tmp);
262 } else {
263
2/2
✓ Branch 0 taken 122958 times.
✓ Branch 1 taken 5190 times.
128148 int real_limit = tmp ? (INT_MAX >> tmp) + 2 : INT_MAX;
264
2/2
✓ Branch 0 taken 54994357 times.
✓ Branch 1 taken 128147 times.
55122504 for (; i < samples; i++) {
265 54994357 int v = get_sr_golomb_flac(&gb, tmp, real_limit, 1);
266
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 54994356 times.
54994357 if (v == 0x80000000){
267 1 av_log(s->avctx, AV_LOG_ERROR, "invalid residual\n");
268 1 return AVERROR_INVALIDDATA;
269 }
270
271 54994356 *decoded++ = v;
272 }
273 }
274 128147 i= 0;
275 }
276
277 9884 s->gb = gb;
278
279 9884 return 0;
280 }
281
282 935 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
283 int pred_order, int bps)
284 {
285 935 const int blocksize = s->blocksize;
286 935 unsigned av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d);
287 int i;
288 int ret;
289
290 /* warm up samples */
291
2/2
✓ Branch 0 taken 2662 times.
✓ Branch 1 taken 935 times.
3597 for (i = 0; i < pred_order; i++) {
292 2662 decoded[i] = get_sbits_long(&s->gb, bps);
293 }
294
295
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 935 times.
935 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
296 return ret;
297
298
2/2
✓ Branch 0 taken 837 times.
✓ Branch 1 taken 98 times.
935 if (pred_order > 0)
299 837 a = decoded[pred_order-1];
300
2/2
✓ Branch 0 taken 721 times.
✓ Branch 1 taken 214 times.
935 if (pred_order > 1)
301 721 b = a - decoded[pred_order-2];
302
2/2
✓ Branch 0 taken 591 times.
✓ Branch 1 taken 344 times.
935 if (pred_order > 2)
303 591 c = b - decoded[pred_order-2] + decoded[pred_order-3];
304
2/2
✓ Branch 0 taken 513 times.
✓ Branch 1 taken 422 times.
935 if (pred_order > 3)
305 513 d = c - decoded[pred_order-2] + 2U*decoded[pred_order-3] - decoded[pred_order-4];
306
307
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) {
308 98 case 0:
309 98 break;
310 116 case 1:
311
2/2
✓ Branch 0 taken 505740 times.
✓ Branch 1 taken 116 times.
505856 for (i = pred_order; i < blocksize; i++)
312 505740 decoded[i] = a += decoded[i];
313 116 break;
314 130 case 2:
315
2/2
✓ Branch 0 taken 549640 times.
✓ Branch 1 taken 130 times.
549770 for (i = pred_order; i < blocksize; i++)
316 549640 decoded[i] = a += b += decoded[i];
317 130 break;
318 78 case 3:
319
2/2
✓ Branch 0 taken 117270 times.
✓ Branch 1 taken 78 times.
117348 for (i = pred_order; i < blocksize; i++)
320 117270 decoded[i] = a += b += c += decoded[i];
321 78 break;
322 513 case 4:
323
2/2
✓ Branch 0 taken 587484 times.
✓ Branch 1 taken 513 times.
587997 for (i = pred_order; i < blocksize; i++)
324 587484 decoded[i] = a += b += c += d += decoded[i];
325 513 break;
326 default:
327 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
328 return AVERROR_INVALIDDATA;
329 }
330
331 935 return 0;
332 }
333
334 1932 static void lpc_analyze_remodulate(SUINT32 *decoded, const int coeffs[32],
335 int order, int qlevel, int len, int bps)
336 {
337 int i, j;
338 1932 int ebps = 1 << (bps-1);
339 1932 unsigned sigma = 0;
340
341
2/2
✓ Branch 0 taken 8474229 times.
✓ Branch 1 taken 1932 times.
8476161 for (i = order; i < len; i++)
342 8474229 sigma |= decoded[i] + ebps;
343
344
1/2
✓ Branch 0 taken 1932 times.
✗ Branch 1 not taken.
1932 if (sigma < 2*ebps)
345 1932 return;
346
347 for (i = len - 1; i >= order; i--) {
348 int64_t p = 0;
349 for (j = 0; j < order; j++)
350 p += coeffs[j] * (int64_t)(int32_t)decoded[i-order+j];
351 decoded[i] -= p >> qlevel;
352 }
353 for (i = order; i < len; i++, decoded++) {
354 int32_t p = 0;
355 for (j = 0; j < order; j++)
356 p += coeffs[j] * (uint32_t)decoded[j];
357 decoded[j] += p >> qlevel;
358 }
359 }
360
361 8950 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
362 int bps)
363 {
364 int i, ret;
365 int coeff_prec, qlevel;
366 int coeffs[32];
367
368 /* warm up samples */
369
2/2
✓ Branch 0 taken 35999 times.
✓ Branch 1 taken 8950 times.
44949 for (i = 0; i < pred_order; i++) {
370 35999 decoded[i] = get_sbits_long(&s->gb, bps);
371 }
372
373 8950 coeff_prec = get_bits(&s->gb, 4) + 1;
374
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8950 times.
8950 if (coeff_prec == 16) {
375 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
376 return AVERROR_INVALIDDATA;
377 }
378 8950 qlevel = get_sbits(&s->gb, 5);
379
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8950 times.
8950 if (qlevel < 0) {
380 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
381 qlevel);
382 return AVERROR_INVALIDDATA;
383 }
384
385
2/2
✓ Branch 0 taken 35999 times.
✓ Branch 1 taken 8950 times.
44949 for (i = 0; i < pred_order; i++) {
386 35999 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
387 }
388
389
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 8949 times.
8950 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
390 1 return ret;
391
392
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 8949 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
8949 if ( ( s->buggy_lpc && s->flac_stream_info.bps <= 16)
393
3/4
✓ Branch 0 taken 8949 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6864 times.
✓ Branch 3 taken 2085 times.
8949 || ( !s->buggy_lpc && bps <= 16
394
2/2
✓ Branch 0 taken 6171 times.
✓ Branch 1 taken 693 times.
6864 && bps + coeff_prec + av_log2(pred_order) <= 32)) {
395 6171 s->dsp.lpc16(decoded, coeffs, pred_order, qlevel, s->blocksize);
396 } else {
397 2778 s->dsp.lpc32(decoded, coeffs, pred_order, qlevel, s->blocksize);
398
2/2
✓ Branch 0 taken 1932 times.
✓ Branch 1 taken 846 times.
2778 if (s->flac_stream_info.bps <= 16)
399 1932 lpc_analyze_remodulate(decoded, coeffs, pred_order, qlevel, s->blocksize, bps);
400 }
401
402 8949 return 0;
403 }
404
405 15600 static inline int decode_subframe(FLACContext *s, int channel)
406 {
407 15600 int32_t *decoded = s->decoded[channel];
408 15600 int type, wasted = 0;
409 15600 int bps = s->flac_stream_info.bps;
410 int i, tmp, ret;
411
412
2/2
✓ Branch 0 taken 5744 times.
✓ Branch 1 taken 9856 times.
15600 if (channel == 0) {
413
2/2
✓ Branch 0 taken 549 times.
✓ Branch 1 taken 5195 times.
5744 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
414 549 bps++;
415 } else {
416
4/4
✓ Branch 0 taken 8271 times.
✓ Branch 1 taken 1585 times.
✓ Branch 2 taken 742 times.
✓ Branch 3 taken 7529 times.
9856 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
417 2327 bps++;
418 }
419
420
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15600 times.
15600 if (get_bits1(&s->gb)) {
421 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
422 return AVERROR_INVALIDDATA;
423 }
424 15600 type = get_bits(&s->gb, 6);
425
426
2/2
✓ Branch 1 taken 5234 times.
✓ Branch 2 taken 10366 times.
15600 if (get_bits1(&s->gb)) {
427 5234 int left = get_bits_left(&s->gb);
428
2/4
✓ Branch 0 taken 5234 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5234 times.
5234 if ( left <= 0 ||
429
1/4
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 5234 times.
5234 (left < bps && !show_bits_long(&s->gb, left)) ||
430 5234 !show_bits_long(&s->gb, bps)) {
431 av_log(s->avctx, AV_LOG_ERROR,
432 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
433 bps, left);
434 return AVERROR_INVALIDDATA;
435 }
436 5234 wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
437 5234 bps -= wasted;
438 }
439
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15600 times.
15600 if (bps > 32) {
440 avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
441 return AVERROR_PATCHWELCOME;
442 }
443
444 //FIXME use av_log2 for types
445
2/2
✓ Branch 0 taken 5715 times.
✓ Branch 1 taken 9885 times.
15600 if (type == 0) {
446 5715 tmp = get_sbits_long(&s->gb, bps);
447
2/2
✓ Branch 0 taken 35461632 times.
✓ Branch 1 taken 5715 times.
35467347 for (i = 0; i < s->blocksize; i++)
448 35461632 decoded[i] = tmp;
449
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9885 times.
9885 } else if (type == 1) {
450 for (i = 0; i < s->blocksize; i++)
451 decoded[i] = get_sbits_long(&s->gb, bps);
452
3/4
✓ Branch 0 taken 9885 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 935 times.
✓ Branch 3 taken 8950 times.
9885 } else if ((type >= 8) && (type <= 12)) {
453
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 935 times.
935 if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
454 return ret;
455
1/2
✓ Branch 0 taken 8950 times.
✗ Branch 1 not taken.
8950 } else if (type >= 32) {
456
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 8949 times.
8950 if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
457 1 return ret;
458 } else {
459 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
460 return AVERROR_INVALIDDATA;
461 }
462
463
3/4
✓ Branch 0 taken 5234 times.
✓ Branch 1 taken 10365 times.
✓ Branch 2 taken 5234 times.
✗ Branch 3 not taken.
15599 if (wasted && wasted < 32) {
464 int i;
465
2/2
✓ Branch 0 taken 34178824 times.
✓ Branch 1 taken 5234 times.
34184058 for (i = 0; i < s->blocksize; i++)
466 34178824 decoded[i] = (unsigned)decoded[i] << wasted;
467 }
468
469 15599 return 0;
470 }
471
472 5744 static int decode_frame(FLACContext *s)
473 {
474 int i, ret;
475 5744 GetBitContext *gb = &s->gb;
476 FLACFrameInfo fi;
477
478
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5744 times.
5744 if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
479 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
480 return ret;
481 }
482
483
2/2
✓ Branch 0 taken 5728 times.
✓ Branch 1 taken 16 times.
5744 if ( s->flac_stream_info.channels
484
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5728 times.
5728 && fi.channels != s->flac_stream_info.channels
485 && s->got_streaminfo) {
486 s->flac_stream_info.channels = s->avctx->channels = fi.channels;
487 ff_flac_set_channel_layout(s->avctx);
488 ret = allocate_buffers(s);
489 if (ret < 0)
490 return ret;
491 }
492 5744 s->flac_stream_info.channels = s->avctx->channels = fi.channels;
493
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5744 times.
5744 if (!s->avctx->channel_layout)
494 ff_flac_set_channel_layout(s->avctx);
495 5744 s->ch_mode = fi.ch_mode;
496
497
3/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 5728 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
5744 if (!s->flac_stream_info.bps && !fi.bps) {
498 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
499 return AVERROR_INVALIDDATA;
500 }
501
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5744 times.
5744 if (!fi.bps) {
502 fi.bps = s->flac_stream_info.bps;
503
3/4
✓ Branch 0 taken 5728 times.
✓ Branch 1 taken 16 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5728 times.
5744 } else if (s->flac_stream_info.bps && fi.bps != s->flac_stream_info.bps) {
504 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
505 "supported\n");
506 return AVERROR_INVALIDDATA;
507 }
508
509
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 5728 times.
5744 if (!s->flac_stream_info.bps) {
510 16 s->flac_stream_info.bps = s->avctx->bits_per_raw_sample = fi.bps;
511 16 flac_set_bps(s);
512 }
513
514
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 5728 times.
5744 if (!s->flac_stream_info.max_blocksize)
515 16 s->flac_stream_info.max_blocksize = FLAC_MAX_BLOCKSIZE;
516
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5744 times.
5744 if (fi.blocksize > s->flac_stream_info.max_blocksize) {
517 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
518 s->flac_stream_info.max_blocksize);
519 return AVERROR_INVALIDDATA;
520 }
521 5744 s->blocksize = fi.blocksize;
522
523
3/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 5728 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
5744 if (!s->flac_stream_info.samplerate && !fi.samplerate) {
524 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
525 " or frame header\n");
526 return AVERROR_INVALIDDATA;
527 }
528
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5744 times.
5744 if (fi.samplerate == 0)
529 fi.samplerate = s->flac_stream_info.samplerate;
530 5744 s->flac_stream_info.samplerate = s->avctx->sample_rate = fi.samplerate;
531
532
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 5728 times.
5744 if (!s->got_streaminfo) {
533 16 ret = allocate_buffers(s);
534
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
16 if (ret < 0)
535 return ret;
536 16 s->got_streaminfo = 1;
537 16 dump_headers(s->avctx, &s->flac_stream_info);
538 }
539 5744 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
540 s->flac_stream_info.channels, s->flac_stream_info.bps);
541
542 // dump_headers(s->avctx, &s->flac_stream_info);
543
544 /* subframes */
545
2/2
✓ Branch 0 taken 15600 times.
✓ Branch 1 taken 5743 times.
21343 for (i = 0; i < s->flac_stream_info.channels; i++) {
546
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 15599 times.
15600 if ((ret = decode_subframe(s, i)) < 0)
547 1 return ret;
548 }
549
550 5743 align_get_bits(gb);
551
552 /* frame footer */
553 5743 skip_bits(gb, 16); /* data crc */
554
555 5743 return 0;
556 }
557
558 5744 static int flac_decode_frame(AVCodecContext *avctx, void *data,
559 int *got_frame_ptr, AVPacket *avpkt)
560 {
561 5744 AVFrame *frame = data;
562 5744 ThreadFrame tframe = { .f = data };
563 5744 const uint8_t *buf = avpkt->data;
564 5744 int buf_size = avpkt->size;
565 5744 FLACContext *s = avctx->priv_data;
566 5744 int bytes_read = 0;
567 int ret;
568
569 5744 *got_frame_ptr = 0;
570
571
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 5728 times.
5744 if (s->flac_stream_info.max_framesize == 0) {
572 16 s->flac_stream_info.max_framesize =
573
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
16 ff_flac_get_max_frame_size(s->flac_stream_info.max_blocksize ? s->flac_stream_info.max_blocksize : FLAC_MAX_BLOCKSIZE,
574 FLAC_MAX_CHANNELS, 32);
575 }
576
577
2/4
✓ Branch 0 taken 5744 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5744 times.
5744 if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
578 av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
579 return buf_size;
580 }
581
582
2/4
✓ Branch 0 taken 5744 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5744 times.
5744 if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
583 av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
584 return buf_size;
585 }
586
587 /* check that there is at least the smallest decodable amount of data.
588 this amount corresponds to the smallest valid FLAC frame possible.
589 FF F8 69 02 00 00 9A 00 00 34 46 */
590
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5744 times.
5744 if (buf_size < FLAC_MIN_FRAME_SIZE)
591 return buf_size;
592
593 /* check for inline header */
594
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5744 times.
5744 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
595 if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
596 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
597 return ret;
598 }
599 return get_metadata_size(buf, buf_size);
600 }
601
602 /* decode frame */
603
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5744 times.
5744 if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
604 return ret;
605
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 5743 times.
5744 if ((ret = decode_frame(s)) < 0) {
606 1 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
607 1 return ret;
608 }
609 5743 bytes_read = get_bits_count(&s->gb)/8;
610
611
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5743 times.
5743 if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
612 av_crc(av_crc_get_table(AV_CRC_16_ANSI),
613 0, buf, bytes_read)) {
614 av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
615 if (s->avctx->err_recognition & AV_EF_EXPLODE)
616 return AVERROR_INVALIDDATA;
617 }
618
619 /* get output buffer */
620 5743 frame->nb_samples = s->blocksize;
621
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5743 times.
5743 if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
622 return ret;
623
624 5743 s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded,
625 s->flac_stream_info.channels,
626 s->blocksize, s->sample_shift);
627
628
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5743 times.
5743 if (bytes_read > buf_size) {
629 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
630 return AVERROR_INVALIDDATA;
631 }
632
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5743 times.
5743 if (bytes_read < buf_size) {
633 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
634 buf_size - bytes_read, buf_size);
635 }
636
637 5743 *got_frame_ptr = 1;
638
639 5743 return bytes_read;
640 }
641
642 100 static av_cold int flac_decode_close(AVCodecContext *avctx)
643 {
644 100 FLACContext *s = avctx->priv_data;
645
646 100 av_freep(&s->decoded_buffer);
647
648 100 return 0;
649 }
650
651 static const AVOption options[] = {
652 { "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 },
653 { NULL },
654 };
655
656 static const AVClass flac_decoder_class = {
657 .class_name = "FLAC decoder",
658 .item_name = av_default_item_name,
659 .option = options,
660 .version = LIBAVUTIL_VERSION_INT,
661 };
662
663 const AVCodec ff_flac_decoder = {
664 .name = "flac",
665 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
666 .type = AVMEDIA_TYPE_AUDIO,
667 .id = AV_CODEC_ID_FLAC,
668 .priv_data_size = sizeof(FLACContext),
669 .init = flac_decode_init,
670 .close = flac_decode_close,
671 .decode = flac_decode_frame,
672 .capabilities = AV_CODEC_CAP_CHANNEL_CONF |
673 AV_CODEC_CAP_DR1 |
674 AV_CODEC_CAP_FRAME_THREADS,
675 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
676 AV_SAMPLE_FMT_S16P,
677 AV_SAMPLE_FMT_S32,
678 AV_SAMPLE_FMT_S32P,
679 AV_SAMPLE_FMT_NONE },
680 .priv_class = &flac_decoder_class,
681 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
682 };
683