Commit | Line | Data |
---|---|---|
4f52c312 MN |
1 | /* |
2 | * FLAC (Free Lossless Audio Codec) decoder | |
3 | * Copyright (c) 2003 Alex Beregszaszi | |
4 | * | |
2912e87a | 5 | * This file is part of Libav. |
b78e7197 | 6 | * |
2912e87a | 7 | * Libav is free software; you can redistribute it and/or |
4f52c312 MN |
8 | * modify it under the terms of the GNU Lesser General Public |
9 | * License as published by the Free Software Foundation; either | |
b78e7197 | 10 | * version 2.1 of the License, or (at your option) any later version. |
4f52c312 | 11 | * |
2912e87a | 12 | * Libav is distributed in the hope that it will be useful, |
4f52c312 MN |
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 | |
2912e87a | 18 | * License along with Libav; if not, write to the Free Software |
5509bffa | 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
4f52c312 MN |
20 | */ |
21 | ||
22 | /** | |
ba87f080 | 23 | * @file |
4f52c312 MN |
24 | * FLAC (Free Lossless Audio Codec) decoder |
25 | * @author Alex Beregszaszi | |
ad4cd0c2 | 26 | * @see http://flac.sourceforge.net/ |
9eda2f94 MM |
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. | |
4f52c312 | 32 | */ |
115329f1 | 33 | |
ac2570a8 | 34 | #include <limits.h> |
115329f1 | 35 | |
62d5f9e5 | 36 | #include "libavutil/audioconvert.h" |
245976da | 37 | #include "libavutil/crc.h" |
4f52c312 | 38 | #include "avcodec.h" |
5b37e2fc | 39 | #include "internal.h" |
9106a698 | 40 | #include "get_bits.h" |
a8ec12bc | 41 | #include "bytestream.h" |
4f52c312 | 42 | #include "golomb.h" |
9d48410f | 43 | #include "flac.h" |
d4df4e50 | 44 | #include "flacdata.h" |
4a852834 | 45 | #include "flacdsp.h" |
4f52c312 | 46 | |
ac2570a8 MN |
47 | #undef NDEBUG |
48 | #include <assert.h> | |
49 | ||
4f52c312 | 50 | typedef struct FLACContext { |
9d48410f JR |
51 | FLACSTREAMINFO |
52 | ||
64cb3765 | 53 | AVCodecContext *avctx; ///< parent AVCodecContext |
0eea2129 | 54 | AVFrame frame; |
64cb3765 | 55 | GetBitContext gb; ///< GetBitContext initialized to start at the current frame |
4f52c312 | 56 | |
64cb3765 | 57 | int blocksize; ///< number of samples in the current frame |
7f3a6a05 | 58 | int sample_shift; ///< shift required to make output samples 16-bit or 32-bit |
2a346725 | 59 | int ch_mode; ///< channel decorrelation type in the current frame |
7d030358 | 60 | int got_streaminfo; ///< indicates if the STREAMINFO has been read |
4f52c312 | 61 | |
07d16e2e | 62 | int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples |
4a852834 MR |
63 | |
64 | FLACDSPContext dsp; | |
4f52c312 MN |
65 | } FLACContext; |
66 | ||
62d5f9e5 JR |
67 | static const int64_t flac_channel_layouts[6] = { |
68 | AV_CH_LAYOUT_MONO, | |
69 | AV_CH_LAYOUT_STEREO, | |
70 | AV_CH_LAYOUT_SURROUND, | |
71 | AV_CH_LAYOUT_QUAD, | |
72 | AV_CH_LAYOUT_5POINT0, | |
73 | AV_CH_LAYOUT_5POINT1 | |
74 | }; | |
75 | ||
17c90b9d | 76 | static void allocate_buffers(FLACContext *s); |
59c6178a | 77 | |
d9cca9fc | 78 | int avpriv_flac_is_extradata_valid(AVCodecContext *avctx, |
59c6178a JR |
79 | enum FLACExtradataFormat *format, |
80 | uint8_t **streaminfo_start) | |
81 | { | |
82 | if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) { | |
83 | av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n"); | |
84 | return 0; | |
85 | } | |
86 | if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) { | |
87 | /* extradata contains STREAMINFO only */ | |
88 | if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) { | |
89 | av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n", | |
90 | FLAC_STREAMINFO_SIZE-avctx->extradata_size); | |
91 | } | |
92 | *format = FLAC_EXTRADATA_FORMAT_STREAMINFO; | |
93 | *streaminfo_start = avctx->extradata; | |
94 | } else { | |
95 | if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) { | |
96 | av_log(avctx, AV_LOG_ERROR, "extradata too small.\n"); | |
97 | return 0; | |
98 | } | |
99 | *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER; | |
100 | *streaminfo_start = &avctx->extradata[8]; | |
101 | } | |
102 | return 1; | |
103 | } | |
9eda2f94 | 104 | |
87466f81 MR |
105 | static void flac_set_bps(FLACContext *s) |
106 | { | |
107 | if (s->bps > 16) { | |
108 | s->avctx->sample_fmt = AV_SAMPLE_FMT_S32; | |
109 | s->sample_shift = 32 - s->bps; | |
87466f81 MR |
110 | } else { |
111 | s->avctx->sample_fmt = AV_SAMPLE_FMT_S16; | |
112 | s->sample_shift = 16 - s->bps; | |
87466f81 MR |
113 | } |
114 | } | |
115 | ||
1bec121f | 116 | static av_cold int flac_decode_init(AVCodecContext *avctx) |
4f52c312 | 117 | { |
59c6178a JR |
118 | enum FLACExtradataFormat format; |
119 | uint8_t *streaminfo; | |
9eda2f94 MM |
120 | FLACContext *s = avctx->priv_data; |
121 | s->avctx = avctx; | |
122 | ||
59c6178a JR |
123 | /* for now, the raw FLAC header is allowed to be passed to the decoder as |
124 | frame data instead of extradata. */ | |
125 | if (!avctx->extradata) | |
126 | return 0; | |
127 | ||
d9cca9fc | 128 | if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo)) |
59c6178a JR |
129 | return -1; |
130 | ||
26adc8d0 | 131 | /* initialize based on the demuxer-supplied streamdata header */ |
d9cca9fc | 132 | avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo); |
26adc8d0 | 133 | allocate_buffers(s); |
87466f81 | 134 | flac_set_bps(s); |
4a852834 | 135 | ff_flacdsp_init(&s->dsp, avctx->sample_fmt); |
7d030358 | 136 | s->got_streaminfo = 1; |
9eda2f94 | 137 | |
0eea2129 JR |
138 | avcodec_get_frame_defaults(&s->frame); |
139 | avctx->coded_frame = &s->frame; | |
140 | ||
62d5f9e5 JR |
141 | if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts)) |
142 | avctx->channel_layout = flac_channel_layouts[avctx->channels - 1]; | |
143 | ||
4f52c312 MN |
144 | return 0; |
145 | } | |
146 | ||
9482171b | 147 | static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s) |
4f52c312 | 148 | { |
95db6659 | 149 | av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize); |
4bc07e78 JR |
150 | av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize); |
151 | av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate); | |
152 | av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels); | |
153 | av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps); | |
4f52c312 MN |
154 | } |
155 | ||
1bec121f JR |
156 | static void allocate_buffers(FLACContext *s) |
157 | { | |
4f52c312 MN |
158 | int i; |
159 | ||
ac2570a8 MN |
160 | assert(s->max_blocksize); |
161 | ||
1bec121f | 162 | for (i = 0; i < s->channels; i++) { |
93e7ef9a | 163 | s->decoded[i] = av_malloc(sizeof(int32_t)*s->max_blocksize); |
ac2570a8 | 164 | } |
ac2570a8 MN |
165 | } |
166 | ||
d9cca9fc | 167 | void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, |
9482171b | 168 | const uint8_t *buffer) |
ac2570a8 | 169 | { |
a128cc91 JR |
170 | GetBitContext gb; |
171 | init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8); | |
172 | ||
95db6659 | 173 | skip_bits(&gb, 16); /* skip min blocksize */ |
a128cc91 | 174 | s->max_blocksize = get_bits(&gb, 16); |
07d16e2e | 175 | if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) { |
2e78513c JR |
176 | av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n", |
177 | s->max_blocksize); | |
178 | s->max_blocksize = 16; | |
179 | } | |
4f52c312 | 180 | |
a128cc91 JR |
181 | skip_bits(&gb, 24); /* skip min frame size */ |
182 | s->max_framesize = get_bits_long(&gb, 24); | |
115329f1 | 183 | |
a128cc91 JR |
184 | s->samplerate = get_bits_long(&gb, 20); |
185 | s->channels = get_bits(&gb, 3) + 1; | |
186 | s->bps = get_bits(&gb, 5) + 1; | |
115329f1 | 187 | |
a128cc91 JR |
188 | avctx->channels = s->channels; |
189 | avctx->sample_rate = s->samplerate; | |
82159ad9 | 190 | avctx->bits_per_raw_sample = s->bps; |
4f52c312 | 191 | |
aeb987ce | 192 | s->samples = get_bits_long(&gb, 32) << 4; |
ee4d0322 | 193 | s->samples |= get_bits(&gb, 4); |
115329f1 | 194 | |
ee4d0322 JR |
195 | skip_bits_long(&gb, 64); /* md5 sum */ |
196 | skip_bits_long(&gb, 64); /* md5 sum */ | |
115329f1 | 197 | |
4bc07e78 | 198 | dump_headers(avctx, s); |
17c90b9d AJ |
199 | } |
200 | ||
d9cca9fc | 201 | void avpriv_flac_parse_block_header(const uint8_t *block_header, |
5b63d33d JR |
202 | int *last, int *type, int *size) |
203 | { | |
204 | int tmp = bytestream_get_byte(&block_header); | |
205 | if (last) | |
206 | *last = tmp & 0x80; | |
207 | if (type) | |
208 | *type = tmp & 0x7F; | |
209 | if (size) | |
210 | *size = bytestream_get_be24(&block_header); | |
211 | } | |
212 | ||
17c90b9d | 213 | /** |
a8ec12bc JR |
214 | * Parse the STREAMINFO from an inline header. |
215 | * @param s the flac decoding context | |
216 | * @param buf input buffer, starting with the "fLaC" marker | |
217 | * @param buf_size buffer size | |
55a72738 | 218 | * @return non-zero if metadata is invalid |
17c90b9d | 219 | */ |
a8ec12bc | 220 | static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size) |
17c90b9d | 221 | { |
a8ec12bc | 222 | int metadata_type, metadata_size; |
17c90b9d | 223 | |
a8ec12bc JR |
224 | if (buf_size < FLAC_STREAMINFO_SIZE+8) { |
225 | /* need more data */ | |
226 | return 0; | |
227 | } | |
d9cca9fc | 228 | avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size); |
a8ec12bc JR |
229 | if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO || |
230 | metadata_size != FLAC_STREAMINFO_SIZE) { | |
231 | return AVERROR_INVALIDDATA; | |
232 | } | |
d9cca9fc | 233 | avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]); |
a8ec12bc | 234 | allocate_buffers(s); |
4a852834 MR |
235 | flac_set_bps(s); |
236 | ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt); | |
a8ec12bc | 237 | s->got_streaminfo = 1; |
17c90b9d | 238 | |
a8ec12bc JR |
239 | return 0; |
240 | } | |
17c90b9d | 241 | |
a8ec12bc JR |
242 | /** |
243 | * Determine the size of an inline header. | |
244 | * @param buf input buffer, starting with the "fLaC" marker | |
245 | * @param buf_size buffer size | |
246 | * @return number of bytes in the header, or 0 if more data is needed | |
247 | */ | |
248 | static int get_metadata_size(const uint8_t *buf, int buf_size) | |
249 | { | |
250 | int metadata_last, metadata_size; | |
251 | const uint8_t *buf_end = buf + buf_size; | |
e0168e3b | 252 | |
a8ec12bc JR |
253 | buf += 4; |
254 | do { | |
4c5e7b27 JR |
255 | if (buf_end - buf < 4) |
256 | return 0; | |
d9cca9fc | 257 | avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size); |
5b63d33d | 258 | buf += 4; |
4c5e7b27 | 259 | if (buf_end - buf < metadata_size) { |
a8ec12bc JR |
260 | /* need more data in order to read the complete header */ |
261 | return 0; | |
6a85fb34 | 262 | } |
a8ec12bc | 263 | buf += metadata_size; |
6a85fb34 | 264 | } while (!metadata_last); |
17c90b9d | 265 | |
a8ec12bc | 266 | return buf_size - (buf_end - buf); |
4f52c312 MN |
267 | } |
268 | ||
269 | static int decode_residuals(FLACContext *s, int channel, int pred_order) | |
270 | { | |
271 | int i, tmp, partition, method_type, rice_order; | |
272 | int sample = 0, samples; | |
273 | ||
274 | method_type = get_bits(&s->gb, 2); | |
1bec121f | 275 | if (method_type > 1) { |
9f3d3ecf JR |
276 | av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n", |
277 | method_type); | |
4f52c312 | 278 | return -1; |
ac2570a8 | 279 | } |
115329f1 | 280 | |
4f52c312 MN |
281 | rice_order = get_bits(&s->gb, 4); |
282 | ||
ac2570a8 | 283 | samples= s->blocksize >> rice_order; |
5484dad7 | 284 | if (pred_order > samples) { |
9f3d3ecf JR |
285 | av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n", |
286 | pred_order, samples); | |
5484dad7 RD |
287 | return -1; |
288 | } | |
4f52c312 | 289 | |
115329f1 | 290 | sample= |
ac2570a8 | 291 | i= pred_order; |
1bec121f | 292 | for (partition = 0; partition < (1 << rice_order); partition++) { |
e471443a | 293 | tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5); |
1bec121f | 294 | if (tmp == (method_type == 0 ? 15 : 31)) { |
4f52c312 | 295 | tmp = get_bits(&s->gb, 5); |
4f52c312 | 296 | for (; i < samples; i++, sample++) |
9de6e090 | 297 | s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp); |
1bec121f JR |
298 | } else { |
299 | for (; i < samples; i++, sample++) { | |
4fd12598 | 300 | s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0); |
ac2570a8 | 301 | } |
4f52c312 | 302 | } |
ac2570a8 | 303 | i= 0; |
4f52c312 MN |
304 | } |
305 | ||
4f52c312 | 306 | return 0; |
115329f1 | 307 | } |
4f52c312 | 308 | |
0da301e1 MR |
309 | static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order, |
310 | int bps) | |
4f52c312 | 311 | { |
08965b22 LM |
312 | const int blocksize = s->blocksize; |
313 | int32_t *decoded = s->decoded[channel]; | |
a8798c7e | 314 | int a, b, c, d, i; |
115329f1 | 315 | |
4f52c312 | 316 | /* warm up samples */ |
1bec121f | 317 | for (i = 0; i < pred_order; i++) { |
0da301e1 | 318 | decoded[i] = get_sbits_long(&s->gb, bps); |
4f52c312 | 319 | } |
115329f1 | 320 | |
4f52c312 MN |
321 | if (decode_residuals(s, channel, pred_order) < 0) |
322 | return -1; | |
323 | ||
1bec121f | 324 | if (pred_order > 0) |
1f4fa6a4 | 325 | a = decoded[pred_order-1]; |
1bec121f | 326 | if (pred_order > 1) |
1f4fa6a4 | 327 | b = a - decoded[pred_order-2]; |
1bec121f | 328 | if (pred_order > 2) |
1f4fa6a4 | 329 | c = b - decoded[pred_order-2] + decoded[pred_order-3]; |
1bec121f | 330 | if (pred_order > 3) |
1f4fa6a4 | 331 | d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4]; |
08965b22 | 332 | |
1bec121f JR |
333 | switch (pred_order) { |
334 | case 0: | |
335 | break; | |
336 | case 1: | |
337 | for (i = pred_order; i < blocksize; i++) | |
338 | decoded[i] = a += decoded[i]; | |
339 | break; | |
340 | case 2: | |
341 | for (i = pred_order; i < blocksize; i++) | |
342 | decoded[i] = a += b += decoded[i]; | |
343 | break; | |
344 | case 3: | |
345 | for (i = pred_order; i < blocksize; i++) | |
346 | decoded[i] = a += b += c += decoded[i]; | |
347 | break; | |
348 | case 4: | |
349 | for (i = pred_order; i < blocksize; i++) | |
350 | decoded[i] = a += b += c += d += decoded[i]; | |
351 | break; | |
352 | default: | |
353 | av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); | |
354 | return -1; | |
4f52c312 | 355 | } |
ac2570a8 | 356 | |
4f52c312 MN |
357 | return 0; |
358 | } | |
359 | ||
0da301e1 MR |
360 | static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order, |
361 | int bps) | |
4f52c312 | 362 | { |
0187178e | 363 | int i, j; |
4f52c312 | 364 | int coeff_prec, qlevel; |
8313e179 | 365 | int coeffs[32]; |
d1a5c421 | 366 | int32_t *decoded = s->decoded[channel]; |
115329f1 | 367 | |
4f52c312 | 368 | /* warm up samples */ |
1bec121f | 369 | for (i = 0; i < pred_order; i++) { |
0da301e1 | 370 | decoded[i] = get_sbits_long(&s->gb, bps); |
4f52c312 | 371 | } |
115329f1 | 372 | |
4f52c312 | 373 | coeff_prec = get_bits(&s->gb, 4) + 1; |
1bec121f | 374 | if (coeff_prec == 16) { |
5305f40b | 375 | av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n"); |
4f52c312 MN |
376 | return -1; |
377 | } | |
ac2570a8 | 378 | qlevel = get_sbits(&s->gb, 5); |
1bec121f | 379 | if (qlevel < 0) { |
9f3d3ecf JR |
380 | av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n", |
381 | qlevel); | |
9d656110 MN |
382 | return -1; |
383 | } | |
384 | ||
1bec121f | 385 | for (i = 0; i < pred_order; i++) { |
ac2570a8 | 386 | coeffs[i] = get_sbits(&s->gb, coeff_prec); |
4f52c312 | 387 | } |
115329f1 | 388 | |
4f52c312 MN |
389 | if (decode_residuals(s, channel, pred_order) < 0) |
390 | return -1; | |
391 | ||
0187178e LB |
392 | if (s->bps > 16) { |
393 | int64_t sum; | |
1bec121f | 394 | for (i = pred_order; i < s->blocksize; i++) { |
0187178e LB |
395 | sum = 0; |
396 | for (j = 0; j < pred_order; j++) | |
d1a5c421 LM |
397 | sum += (int64_t)coeffs[j] * decoded[i-j-1]; |
398 | decoded[i] += sum >> qlevel; | |
0187178e LB |
399 | } |
400 | } else { | |
1bec121f | 401 | for (i = pred_order; i < s->blocksize-1; i += 2) { |
d1a5c421 LM |
402 | int c; |
403 | int d = decoded[i-pred_order]; | |
404 | int s0 = 0, s1 = 0; | |
1bec121f | 405 | for (j = pred_order-1; j > 0; j--) { |
d1a5c421 | 406 | c = coeffs[j]; |
bd49d4fd | 407 | s0 += c*d; |
d1a5c421 LM |
408 | d = decoded[i-j]; |
409 | s1 += c*d; | |
bd49d4fd | 410 | } |
d1a5c421 LM |
411 | c = coeffs[0]; |
412 | s0 += c*d; | |
413 | d = decoded[i] += s0 >> qlevel; | |
414 | s1 += c*d; | |
415 | decoded[i+1] += s1 >> qlevel; | |
bd49d4fd | 416 | } |
1bec121f | 417 | if (i < s->blocksize) { |
bd49d4fd | 418 | int sum = 0; |
0187178e | 419 | for (j = 0; j < pred_order; j++) |
d1a5c421 LM |
420 | sum += coeffs[j] * decoded[i-j-1]; |
421 | decoded[i] += sum >> qlevel; | |
0187178e | 422 | } |
4f52c312 | 423 | } |
115329f1 | 424 | |
4f52c312 MN |
425 | return 0; |
426 | } | |
427 | ||
428 | static inline int decode_subframe(FLACContext *s, int channel) | |
429 | { | |
430 | int type, wasted = 0; | |
0da301e1 | 431 | int bps = s->bps; |
4f52c312 | 432 | int i, tmp; |
115329f1 | 433 | |
1bec121f | 434 | if (channel == 0) { |
2a346725 | 435 | if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE) |
0da301e1 | 436 | bps++; |
1bec121f | 437 | } else { |
2a346725 | 438 | if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE) |
0da301e1 | 439 | bps++; |
ac2570a8 MN |
440 | } |
441 | ||
1bec121f | 442 | if (get_bits1(&s->gb)) { |
1cef211d | 443 | av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n"); |
4f52c312 MN |
444 | return -1; |
445 | } | |
446 | type = get_bits(&s->gb, 6); | |
c5706efd | 447 | |
1bec121f | 448 | if (get_bits1(&s->gb)) { |
52e4018b | 449 | int left = get_bits_left(&s->gb); |
4f52c312 | 450 | wasted = 1; |
52e4018b | 451 | if ( left < 0 || |
0da301e1 MR |
452 | (left < bps && !show_bits_long(&s->gb, left)) || |
453 | !show_bits_long(&s->gb, bps)) { | |
52e4018b RB |
454 | av_log(s->avctx, AV_LOG_ERROR, |
455 | "Invalid number of wasted bits > available bits (%d) - left=%d\n", | |
0da301e1 | 456 | bps, left); |
52e4018b RB |
457 | return AVERROR_INVALIDDATA; |
458 | } | |
4f52c312 MN |
459 | while (!get_bits1(&s->gb)) |
460 | wasted++; | |
0da301e1 | 461 | bps -= wasted; |
4f52c312 | 462 | } |
0da301e1 | 463 | if (bps > 32) { |
ce863d7f | 464 | av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0); |
a3d2379b JR |
465 | return -1; |
466 | } | |
c5706efd | 467 | |
ac2570a8 | 468 | //FIXME use av_log2 for types |
1bec121f | 469 | if (type == 0) { |
0da301e1 | 470 | tmp = get_sbits_long(&s->gb, bps); |
4f52c312 MN |
471 | for (i = 0; i < s->blocksize; i++) |
472 | s->decoded[channel][i] = tmp; | |
1bec121f | 473 | } else if (type == 1) { |
4f52c312 | 474 | for (i = 0; i < s->blocksize; i++) |
0da301e1 | 475 | s->decoded[channel][i] = get_sbits_long(&s->gb, bps); |
1bec121f | 476 | } else if ((type >= 8) && (type <= 12)) { |
0da301e1 | 477 | if (decode_subframe_fixed(s, channel, type & ~0x8, bps) < 0) |
4f52c312 | 478 | return -1; |
1bec121f | 479 | } else if (type >= 32) { |
0da301e1 | 480 | if (decode_subframe_lpc(s, channel, (type & ~0x20)+1, bps) < 0) |
4f52c312 | 481 | return -1; |
1bec121f | 482 | } else { |
1cef211d | 483 | av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n"); |
4f52c312 MN |
484 | return -1; |
485 | } | |
115329f1 | 486 | |
1bec121f | 487 | if (wasted) { |
4f52c312 MN |
488 | int i; |
489 | for (i = 0; i < s->blocksize; i++) | |
490 | s->decoded[channel][i] <<= wasted; | |
491 | } | |
492 | ||
493 | return 0; | |
494 | } | |
495 | ||
cd98a030 JR |
496 | static int decode_frame(FLACContext *s) |
497 | { | |
498 | int i; | |
499 | GetBitContext *gb = &s->gb; | |
500 | FLACFrameInfo fi; | |
501 | ||
3c795698 | 502 | if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) { |
cd98a030 | 503 | av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n"); |
9d656110 MN |
504 | return -1; |
505 | } | |
115329f1 | 506 | |
2e0559b7 | 507 | if (s->channels && fi.channels != s->channels) { |
fbc4d9c9 JR |
508 | av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream " |
509 | "is not supported\n"); | |
510 | return -1; | |
511 | } | |
2e0559b7 | 512 | s->channels = s->avctx->channels = fi.channels; |
cd98a030 | 513 | s->ch_mode = fi.ch_mode; |
fbc4d9c9 | 514 | |
2e0559b7 JR |
515 | if (!s->bps && !fi.bps) { |
516 | av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n"); | |
517 | return -1; | |
518 | } | |
519 | if (!fi.bps) { | |
520 | fi.bps = s->bps; | |
521 | } else if (s->bps && fi.bps != s->bps) { | |
fbc4d9c9 JR |
522 | av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not " |
523 | "supported\n"); | |
524 | return -1; | |
525 | } | |
2e0559b7 JR |
526 | s->bps = s->avctx->bits_per_raw_sample = fi.bps; |
527 | ||
87466f81 | 528 | flac_set_bps(s); |
fbc4d9c9 | 529 | |
2e0559b7 JR |
530 | if (!s->max_blocksize) |
531 | s->max_blocksize = FLAC_MAX_BLOCKSIZE; | |
cd98a030 JR |
532 | if (fi.blocksize > s->max_blocksize) { |
533 | av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize, | |
fbc4d9c9 JR |
534 | s->max_blocksize); |
535 | return -1; | |
536 | } | |
cd98a030 | 537 | s->blocksize = fi.blocksize; |
fbc4d9c9 | 538 | |
2e0559b7 JR |
539 | if (!s->samplerate && !fi.samplerate) { |
540 | av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO" | |
541 | " or frame header\n"); | |
542 | return -1; | |
543 | } | |
cd98a030 JR |
544 | if (fi.samplerate == 0) { |
545 | fi.samplerate = s->samplerate; | |
2e0559b7 | 546 | } else if (s->samplerate && fi.samplerate != s->samplerate) { |
fbc4d9c9 | 547 | av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n", |
cd98a030 | 548 | s->samplerate, fi.samplerate); |
fbc4d9c9 | 549 | } |
cd98a030 | 550 | s->samplerate = s->avctx->sample_rate = fi.samplerate; |
4f52c312 | 551 | |
2e0559b7 JR |
552 | if (!s->got_streaminfo) { |
553 | allocate_buffers(s); | |
4a852834 | 554 | ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt); |
2e0559b7 JR |
555 | s->got_streaminfo = 1; |
556 | dump_headers(s->avctx, (FLACStreaminfo *)s); | |
557 | } | |
558 | ||
9482171b | 559 | // dump_headers(s->avctx, (FLACStreaminfo *)s); |
4f52c312 MN |
560 | |
561 | /* subframes */ | |
1bec121f | 562 | for (i = 0; i < s->channels; i++) { |
4f52c312 MN |
563 | if (decode_subframe(s, i) < 0) |
564 | return -1; | |
565 | } | |
115329f1 | 566 | |
7e00bd84 | 567 | align_get_bits(gb); |
4f52c312 MN |
568 | |
569 | /* frame footer */ | |
7e00bd84 | 570 | skip_bits(gb, 16); /* data crc */ |
4f52c312 MN |
571 | |
572 | return 0; | |
573 | } | |
574 | ||
0eea2129 JR |
575 | static int flac_decode_frame(AVCodecContext *avctx, void *data, |
576 | int *got_frame_ptr, AVPacket *avpkt) | |
4f52c312 | 577 | { |
7a00bbad TB |
578 | const uint8_t *buf = avpkt->data; |
579 | int buf_size = avpkt->size; | |
4f52c312 | 580 | FLACContext *s = avctx->priv_data; |
4a852834 | 581 | int bytes_read = 0; |
0eea2129 | 582 | int ret; |
ac66834c | 583 | |
0eea2129 | 584 | *got_frame_ptr = 0; |
4f52c312 | 585 | |
1bec121f | 586 | if (s->max_framesize == 0) { |
2e0559b7 JR |
587 | s->max_framesize = |
588 | ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE, | |
589 | FLAC_MAX_CHANNELS, 32); | |
ac2570a8 | 590 | } |
4f52c312 | 591 | |
5ef4fa87 | 592 | /* check that there is at least the smallest decodable amount of data. |
8d1e885f JR |
593 | this amount corresponds to the smallest valid FLAC frame possible. |
594 | FF F8 69 02 00 00 9A 00 00 34 46 */ | |
a4151444 | 595 | if (buf_size < FLAC_MIN_FRAME_SIZE) |
60a68493 | 596 | return buf_size; |
5ef4fa87 | 597 | |
55a72738 | 598 | /* check for inline header */ |
a8ec12bc JR |
599 | if (AV_RB32(buf) == MKBETAG('f','L','a','C')) { |
600 | if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) { | |
55a72738 JR |
601 | av_log(s->avctx, AV_LOG_ERROR, "invalid header\n"); |
602 | return -1; | |
603 | } | |
60a68493 | 604 | return get_metadata_size(buf, buf_size); |
13de8a08 | 605 | } |
fd6fd470 JR |
606 | |
607 | /* decode frame */ | |
608 | init_get_bits(&s->gb, buf, buf_size*8); | |
02b26d2d | 609 | if (decode_frame(s) < 0) { |
13de8a08 | 610 | av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n"); |
13de8a08 JR |
611 | return -1; |
612 | } | |
bf1d7e28 | 613 | bytes_read = (get_bits_count(&s->gb)+7)/8; |
ac2570a8 | 614 | |
0eea2129 JR |
615 | /* get output buffer */ |
616 | s->frame.nb_samples = s->blocksize; | |
617 | if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) { | |
618 | av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
619 | return ret; | |
02b26d2d | 620 | } |
4a852834 MR |
621 | |
622 | s->dsp.decorrelate[s->ch_mode](s->frame.data, s->decoded, s->channels, | |
623 | s->blocksize, s->sample_shift); | |
4f52c312 | 624 | |
c5199729 JR |
625 | if (bytes_read > buf_size) { |
626 | av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size); | |
ac2570a8 MN |
627 | return -1; |
628 | } | |
60a68493 MC |
629 | if (bytes_read < buf_size) { |
630 | av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n", | |
631 | buf_size - bytes_read, buf_size); | |
632 | } | |
4f52c312 | 633 | |
0eea2129 JR |
634 | *got_frame_ptr = 1; |
635 | *(AVFrame *)data = s->frame; | |
636 | ||
60a68493 | 637 | return bytes_read; |
4f52c312 MN |
638 | } |
639 | ||
98a6fff9 | 640 | static av_cold int flac_decode_close(AVCodecContext *avctx) |
4f52c312 MN |
641 | { |
642 | FLACContext *s = avctx->priv_data; | |
643 | int i; | |
115329f1 | 644 | |
1bec121f | 645 | for (i = 0; i < s->channels; i++) { |
ac2570a8 | 646 | av_freep(&s->decoded[i]); |
4f52c312 | 647 | } |
115329f1 | 648 | |
4f52c312 MN |
649 | return 0; |
650 | } | |
651 | ||
d36beb3f | 652 | AVCodec ff_flac_decoder = { |
ec6402b7 AK |
653 | .name = "flac", |
654 | .type = AVMEDIA_TYPE_AUDIO, | |
655 | .id = CODEC_ID_FLAC, | |
656 | .priv_data_size = sizeof(FLACContext), | |
657 | .init = flac_decode_init, | |
658 | .close = flac_decode_close, | |
659 | .decode = flac_decode_frame, | |
0eea2129 | 660 | .capabilities = CODEC_CAP_DR1, |
00c3b67b | 661 | .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"), |
4f52c312 | 662 | }; |