FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/flacdec.c
Date: 2021-09-16 08:47:15
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 96 static void flac_set_bps(FLACContext *s)
74 {
75 96 enum AVSampleFormat req = s->avctx->request_sample_fmt;
76 96 int need32 = s->flac_stream_info.bps > 16;
77 96 int want32 = av_get_bytes_per_sample(req) > 2;
78 96 int planar = av_sample_fmt_is_planar(req);
79
80
3/4
✓ Branch 0 taken 82 times.
✓ Branch 1 taken 14 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 82 times.
96 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 82 times.
82 if (planar)
88 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
89 else
90 82 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
91 82 s->sample_shift = 16 - s->flac_stream_info.bps;
92 }
93 96 }
94
95 96 static av_cold int flac_decode_init(AVCodecContext *avctx)
96 {
97 enum FLACExtradataFormat format;
98 uint8_t *streaminfo;
99 int ret;
100 96 FLACContext *s = avctx->priv_data;
101 96 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 80 times.
96 if (!avctx->extradata)
106 16 return 0;
107
108
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 80 times.
80 if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
109 return AVERROR_INVALIDDATA;
110
111 /* initialize based on the demuxer-supplied streamdata header */
112 80 ret = ff_flac_parse_streaminfo(avctx, &s->flac_stream_info, streaminfo);
113
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 80 times.
80 if (ret < 0)
114 return ret;
115 80 ret = allocate_buffers(s);
116
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 80 times.
80 if (ret < 0)
117 return ret;
118 80 flac_set_bps(s);
119 80 ff_flacdsp_init(&s->dsp, avctx->sample_fmt,
120 s->flac_stream_info.channels, s->flac_stream_info.bps);
121 80 s->got_streaminfo = 1;
122
123 80 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 96 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 96 times.
96 av_assert0(s->flac_stream_info.max_blocksize);
141
142 96 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 96 times.
96 if (buf_size < 0)
146 return buf_size;
147
148 96 av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
149
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 96 times.
96 if (!s->decoded_buffer)
150 return AVERROR(ENOMEM);
151
152 96 ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
153 96 s->decoded_buffer,
154 s->flac_stream_info.channels,
155 s->flac_stream_info.max_blocksize,
156 AV_SAMPLE_FMT_S32P, 0);
157 96 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 9879 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
222 {
223 9879 GetBitContext gb = s->gb;
224 int i, tmp, partition, method_type, rice_order;
225 int rice_bits, rice_esc;
226 int samples;
227
228 9879 method_type = get_bits(&gb, 2);
229 9879 rice_order = get_bits(&gb, 4);
230
231 9879 samples = s->blocksize >> rice_order;
232 9879 rice_bits = 4 + method_type;
233 9879 rice_esc = (1 << rice_bits) - 1;
234
235 9879 decoded += pred_order;
236 9879 i = pred_order;
237
238
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9879 times.
9879 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 9879 times.
9879 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 9879 times.
9879 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 128061 times.
✓ Branch 1 taken 9878 times.
137939 for (partition = 0; partition < (1 << rice_order); partition++) {
257 128061 tmp = get_bits(&gb, rice_bits);
258
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 128061 times.
128061 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 122877 times.
✓ Branch 1 taken 5184 times.
128061 int real_limit = tmp ? (INT_MAX >> tmp) + 2 : INT_MAX;
264
2/2
✓ Branch 0 taken 54968340 times.
✓ Branch 1 taken 128060 times.
55096400 for (; i < samples; i++) {
265 54968340 int v = get_sr_golomb_flac(&gb, tmp, real_limit, 1);
266
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 54968339 times.
54968340 if (v == 0x80000000){
267 1 av_log(s->avctx, AV_LOG_ERROR, "invalid residual\n");
268 1 return AVERROR_INVALIDDATA;
269 }
270
271 54968339 *decoded++ = v;
272 }
273 }
274 128060 i= 0;
275 }
276
277 9878 s->gb = gb;
278
279 9878 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 1926 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 1926 int ebps = 1 << (bps-1);
339 1926 unsigned sigma = 0;
340
341
2/2
✓ Branch 0 taken 8448212 times.
✓ Branch 1 taken 1926 times.
8450138 for (i = order; i < len; i++)
342 8448212 sigma |= decoded[i] + ebps;
343
344
1/2
✓ Branch 0 taken 1926 times.
✗ Branch 1 not taken.
1926 if (sigma < 2*ebps)
345 1926 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 8944 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 35952 times.
✓ Branch 1 taken 8944 times.
44896 for (i = 0; i < pred_order; i++) {
370 35952 decoded[i] = get_sbits_long(&s->gb, bps);
371 }
372
373 8944 coeff_prec = get_bits(&s->gb, 4) + 1;
374
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8944 times.
8944 if (coeff_prec == 16) {
375 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
376 return AVERROR_INVALIDDATA;
377 }
378 8944 qlevel = get_sbits(&s->gb, 5);
379
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8944 times.
8944 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 35952 times.
✓ Branch 1 taken 8944 times.
44896 for (i = 0; i < pred_order; i++) {
386 35952 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
387 }
388
389
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 8943 times.
8944 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
390 1 return ret;
391
392
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 8943 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
8943 if ( ( s->buggy_lpc && s->flac_stream_info.bps <= 16)
393
3/4
✓ Branch 0 taken 8943 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6861 times.
✓ Branch 3 taken 2082 times.
8943 || ( !s->buggy_lpc && bps <= 16
394
2/2
✓ Branch 0 taken 6171 times.
✓ Branch 1 taken 690 times.
6861 && bps + coeff_prec + av_log2(pred_order) <= 32)) {
395 6171 s->dsp.lpc16(decoded, coeffs, pred_order, qlevel, s->blocksize);
396 } else {
397 2772 s->dsp.lpc32(decoded, coeffs, pred_order, qlevel, s->blocksize);
398
2/2
✓ Branch 0 taken 1926 times.
✓ Branch 1 taken 846 times.
2772 if (s->flac_stream_info.bps <= 16)
399 1926 lpc_analyze_remodulate(decoded, coeffs, pred_order, qlevel, s->blocksize, bps);
400 }
401
402 8943 return 0;
403 }
404
405 15588 static inline int decode_subframe(FLACContext *s, int channel)
406 {
407 15588 int32_t *decoded = s->decoded[channel];
408 15588 int type, wasted = 0;
409 15588 int bps = s->flac_stream_info.bps;
410 int i, tmp, ret;
411
412
2/2
✓ Branch 0 taken 5738 times.
✓ Branch 1 taken 9850 times.
15588 if (channel == 0) {
413
2/2
✓ Branch 0 taken 549 times.
✓ Branch 1 taken 5189 times.
5738 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
414 549 bps++;
415 } else {
416
4/4
✓ Branch 0 taken 8265 times.
✓ Branch 1 taken 1585 times.
✓ Branch 2 taken 739 times.
✓ Branch 3 taken 7526 times.
9850 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
417 2324 bps++;
418 }
419
420
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 15588 times.
15588 if (get_bits1(&s->gb)) {
421 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
422 return AVERROR_INVALIDDATA;
423 }
424 15588 type = get_bits(&s->gb, 6);
425
426
2/2
✓ Branch 1 taken 5234 times.
✓ Branch 2 taken 10354 times.
15588 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 15588 times.
15588 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 5709 times.
✓ Branch 1 taken 9879 times.
15588 if (type == 0) {
446 5709 tmp = get_sbits_long(&s->gb, bps);
447
2/2
✓ Branch 0 taken 35433984 times.
✓ Branch 1 taken 5709 times.
35439693 for (i = 0; i < s->blocksize; i++)
448 35433984 decoded[i] = tmp;
449
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9879 times.
9879 } 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 9879 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 935 times.
✓ Branch 3 taken 8944 times.
9879 } 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 8944 times.
✗ Branch 1 not taken.
8944 } else if (type >= 32) {
456
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 8943 times.
8944 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 10353 times.
✓ Branch 2 taken 5234 times.
✗ Branch 3 not taken.
15587 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 15587 return 0;
470 }
471
472 5738 static int decode_frame(FLACContext *s)
473 {
474 int i, ret;
475 5738 GetBitContext *gb = &s->gb;
476 FLACFrameInfo fi;
477
478
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5738 times.
5738 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 5722 times.
✓ Branch 1 taken 16 times.
5738 if ( s->flac_stream_info.channels
484
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5722 times.
5722 && 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 5738 s->flac_stream_info.channels = s->avctx->channels = fi.channels;
493
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5738 times.
5738 if (!s->avctx->channel_layout)
494 ff_flac_set_channel_layout(s->avctx);
495 5738 s->ch_mode = fi.ch_mode;
496
497
3/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 5722 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
5738 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 5738 times.
5738 if (!fi.bps) {
502 fi.bps = s->flac_stream_info.bps;
503
3/4
✓ Branch 0 taken 5722 times.
✓ Branch 1 taken 16 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5722 times.
5738 } 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 5722 times.
5738 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 5722 times.
5738 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 5738 times.
5738 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 5738 s->blocksize = fi.blocksize;
522
523
3/4
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 5722 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 16 times.
5738 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 5738 times.
5738 if (fi.samplerate == 0)
529 fi.samplerate = s->flac_stream_info.samplerate;
530 5738 s->flac_stream_info.samplerate = s->avctx->sample_rate = fi.samplerate;
531
532
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 5722 times.
5738 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 5738 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 15588 times.
✓ Branch 1 taken 5737 times.
21325 for (i = 0; i < s->flac_stream_info.channels; i++) {
546
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 15587 times.
15588 if ((ret = decode_subframe(s, i)) < 0)
547 1 return ret;
548 }
549
550 5737 align_get_bits(gb);
551
552 /* frame footer */
553 5737 skip_bits(gb, 16); /* data crc */
554
555 5737 return 0;
556 }
557
558 5738 static int flac_decode_frame(AVCodecContext *avctx, void *data,
559 int *got_frame_ptr, AVPacket *avpkt)
560 {
561 5738 AVFrame *frame = data;
562 5738 ThreadFrame tframe = { .f = data };
563 5738 const uint8_t *buf = avpkt->data;
564 5738 int buf_size = avpkt->size;
565 5738 FLACContext *s = avctx->priv_data;
566 5738 int bytes_read = 0;
567 int ret;
568
569 5738 *got_frame_ptr = 0;
570
571
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 5722 times.
5738 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 5738 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5738 times.
5738 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 5738 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5738 times.
5738 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 5738 times.
5738 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 5738 times.
5738 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 5738 times.
5738 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 5737 times.
5738 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 5737 bytes_read = get_bits_count(&s->gb)/8;
610
611
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5737 times.
5737 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 5737 frame->nb_samples = s->blocksize;
621
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5737 times.
5737 if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
622 return ret;
623
624 5737 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 5737 times.
5737 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 5737 times.
5737 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 5737 *got_frame_ptr = 1;
638
639 5737 return bytes_read;
640 }
641
642 96 static av_cold int flac_decode_close(AVCodecContext *avctx)
643 {
644 96 FLACContext *s = avctx->priv_data;
645
646 96 av_freep(&s->decoded_buffer);
647
648 96 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