Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * ALAC (Apple Lossless Audio Codec) decoder | |
3 | * Copyright (c) 2005 David Hammerton | |
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 | * ALAC (Apple Lossless Audio Codec) decoder | |
25 | * @author 2005 David Hammerton | |
26 | * @see http://crazney.net/programs/itunes/alac.html | |
27 | * | |
28 | * Note: This decoder expects a 36-byte QuickTime atom to be | |
29 | * passed through the extradata[_size] fields. This atom is tacked onto | |
30 | * the end of an 'alac' stsd atom and has the following format: | |
31 | * | |
32 | * 32bit atom size | |
33 | * 32bit tag ("alac") | |
34 | * 32bit tag version (0) | |
35 | * 32bit samples per frame (used when not set explicitly in the frames) | |
36 | * 8bit compatible version (0) | |
37 | * 8bit sample size | |
38 | * 8bit history mult (40) | |
39 | * 8bit initial history (10) | |
40 | * 8bit rice param limit (14) | |
41 | * 8bit channels | |
42 | * 16bit maxRun (255) | |
43 | * 32bit max coded frame size (0 means unknown) | |
44 | * 32bit average bitrate (0 means unknown) | |
45 | * 32bit samplerate | |
46 | */ | |
47 | ||
48 | #include <inttypes.h> | |
49 | ||
50 | #include "libavutil/channel_layout.h" | |
51 | #include "libavutil/opt.h" | |
52 | #include "avcodec.h" | |
53 | #include "get_bits.h" | |
54 | #include "bytestream.h" | |
55 | #include "internal.h" | |
56 | #include "thread.h" | |
57 | #include "unary.h" | |
58 | #include "mathops.h" | |
59 | #include "alac_data.h" | |
60 | ||
61 | #define ALAC_EXTRADATA_SIZE 36 | |
62 | ||
63 | typedef struct { | |
64 | AVClass *class; | |
65 | AVCodecContext *avctx; | |
66 | GetBitContext gb; | |
67 | int channels; | |
68 | ||
69 | int32_t *predict_error_buffer[2]; | |
70 | int32_t *output_samples_buffer[2]; | |
71 | int32_t *extra_bits_buffer[2]; | |
72 | ||
73 | uint32_t max_samples_per_frame; | |
74 | uint8_t sample_size; | |
75 | uint8_t rice_history_mult; | |
76 | uint8_t rice_initial_history; | |
77 | uint8_t rice_limit; | |
78 | ||
79 | int extra_bits; /**< number of extra bits beyond 16-bit */ | |
80 | int nb_samples; /**< number of samples in the current frame */ | |
81 | ||
82 | int direct_output; | |
83 | int extra_bit_bug; | |
84 | } ALACContext; | |
85 | ||
86 | static inline unsigned int decode_scalar(GetBitContext *gb, int k, int bps) | |
87 | { | |
88 | unsigned int x = get_unary_0_9(gb); | |
89 | ||
90 | if (x > 8) { /* RICE THRESHOLD */ | |
91 | /* use alternative encoding */ | |
92 | x = get_bits_long(gb, bps); | |
93 | } else if (k != 1) { | |
94 | int extrabits = show_bits(gb, k); | |
95 | ||
96 | /* multiply x by 2^k - 1, as part of their strange algorithm */ | |
97 | x = (x << k) - x; | |
98 | ||
99 | if (extrabits > 1) { | |
100 | x += extrabits - 1; | |
101 | skip_bits(gb, k); | |
102 | } else | |
103 | skip_bits(gb, k - 1); | |
104 | } | |
105 | return x; | |
106 | } | |
107 | ||
108 | static int rice_decompress(ALACContext *alac, int32_t *output_buffer, | |
109 | int nb_samples, int bps, int rice_history_mult) | |
110 | { | |
111 | int i; | |
112 | unsigned int history = alac->rice_initial_history; | |
113 | int sign_modifier = 0; | |
114 | ||
115 | for (i = 0; i < nb_samples; i++) { | |
116 | int k; | |
117 | unsigned int x; | |
118 | ||
119 | if(get_bits_left(&alac->gb) <= 0) | |
120 | return -1; | |
121 | ||
122 | /* calculate rice param and decode next value */ | |
123 | k = av_log2((history >> 9) + 3); | |
124 | k = FFMIN(k, alac->rice_limit); | |
125 | x = decode_scalar(&alac->gb, k, bps); | |
126 | x += sign_modifier; | |
127 | sign_modifier = 0; | |
128 | output_buffer[i] = (x >> 1) ^ -(x & 1); | |
129 | ||
130 | /* update the history */ | |
131 | if (x > 0xffff) | |
132 | history = 0xffff; | |
133 | else | |
134 | history += x * rice_history_mult - | |
135 | ((history * rice_history_mult) >> 9); | |
136 | ||
137 | /* special case: there may be compressed blocks of 0 */ | |
138 | if ((history < 128) && (i + 1 < nb_samples)) { | |
139 | int block_size; | |
140 | ||
141 | /* calculate rice param and decode block size */ | |
142 | k = 7 - av_log2(history) + ((history + 16) >> 6); | |
143 | k = FFMIN(k, alac->rice_limit); | |
144 | block_size = decode_scalar(&alac->gb, k, 16); | |
145 | ||
146 | if (block_size > 0) { | |
147 | if (block_size >= nb_samples - i) { | |
148 | av_log(alac->avctx, AV_LOG_ERROR, | |
149 | "invalid zero block size of %d %d %d\n", block_size, | |
150 | nb_samples, i); | |
151 | block_size = nb_samples - i - 1; | |
152 | } | |
153 | memset(&output_buffer[i + 1], 0, | |
154 | block_size * sizeof(*output_buffer)); | |
155 | i += block_size; | |
156 | } | |
157 | if (block_size <= 0xffff) | |
158 | sign_modifier = 1; | |
159 | history = 0; | |
160 | } | |
161 | } | |
162 | return 0; | |
163 | } | |
164 | ||
165 | static inline int sign_only(int v) | |
166 | { | |
167 | return v ? FFSIGN(v) : 0; | |
168 | } | |
169 | ||
170 | static void lpc_prediction(int32_t *error_buffer, int32_t *buffer_out, | |
171 | int nb_samples, int bps, int16_t *lpc_coefs, | |
172 | int lpc_order, int lpc_quant) | |
173 | { | |
174 | int i; | |
175 | int32_t *pred = buffer_out; | |
176 | ||
177 | /* first sample always copies */ | |
178 | *buffer_out = *error_buffer; | |
179 | ||
180 | if (nb_samples <= 1) | |
181 | return; | |
182 | ||
183 | if (!lpc_order) { | |
184 | memcpy(&buffer_out[1], &error_buffer[1], | |
185 | (nb_samples - 1) * sizeof(*buffer_out)); | |
186 | return; | |
187 | } | |
188 | ||
189 | if (lpc_order == 31) { | |
190 | /* simple 1st-order prediction */ | |
191 | for (i = 1; i < nb_samples; i++) { | |
192 | buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i], | |
193 | bps); | |
194 | } | |
195 | return; | |
196 | } | |
197 | ||
198 | /* read warm-up samples */ | |
199 | for (i = 1; i <= lpc_order && i < nb_samples; i++) | |
200 | buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i], bps); | |
201 | ||
202 | /* NOTE: 4 and 8 are very common cases that could be optimized. */ | |
203 | ||
204 | for (; i < nb_samples; i++) { | |
205 | int j; | |
206 | int val = 0; | |
207 | int error_val = error_buffer[i]; | |
208 | int error_sign; | |
209 | int d = *pred++; | |
210 | ||
211 | /* LPC prediction */ | |
212 | for (j = 0; j < lpc_order; j++) | |
213 | val += (pred[j] - d) * lpc_coefs[j]; | |
214 | val = (val + (1 << (lpc_quant - 1))) >> lpc_quant; | |
215 | val += d + error_val; | |
216 | buffer_out[i] = sign_extend(val, bps); | |
217 | ||
218 | /* adapt LPC coefficients */ | |
219 | error_sign = sign_only(error_val); | |
220 | if (error_sign) { | |
221 | for (j = 0; j < lpc_order && error_val * error_sign > 0; j++) { | |
222 | int sign; | |
223 | val = d - pred[j]; | |
224 | sign = sign_only(val) * error_sign; | |
225 | lpc_coefs[j] -= sign; | |
226 | val *= sign; | |
227 | error_val -= (val >> lpc_quant) * (j + 1); | |
228 | } | |
229 | } | |
230 | } | |
231 | } | |
232 | ||
233 | static void decorrelate_stereo(int32_t *buffer[2], int nb_samples, | |
234 | int decorr_shift, int decorr_left_weight) | |
235 | { | |
236 | int i; | |
237 | ||
238 | for (i = 0; i < nb_samples; i++) { | |
239 | int32_t a, b; | |
240 | ||
241 | a = buffer[0][i]; | |
242 | b = buffer[1][i]; | |
243 | ||
244 | a -= (b * decorr_left_weight) >> decorr_shift; | |
245 | b += a; | |
246 | ||
247 | buffer[0][i] = b; | |
248 | buffer[1][i] = a; | |
249 | } | |
250 | } | |
251 | ||
252 | static void append_extra_bits(int32_t *buffer[2], int32_t *extra_bits_buffer[2], | |
253 | int extra_bits, int channels, int nb_samples) | |
254 | { | |
255 | int i, ch; | |
256 | ||
257 | for (ch = 0; ch < channels; ch++) | |
258 | for (i = 0; i < nb_samples; i++) | |
259 | buffer[ch][i] = (buffer[ch][i] << extra_bits) | extra_bits_buffer[ch][i]; | |
260 | } | |
261 | ||
262 | static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index, | |
263 | int channels) | |
264 | { | |
265 | ALACContext *alac = avctx->priv_data; | |
266 | int has_size, bps, is_compressed, decorr_shift, decorr_left_weight, ret; | |
267 | uint32_t output_samples; | |
268 | int i, ch; | |
269 | ||
270 | skip_bits(&alac->gb, 4); /* element instance tag */ | |
271 | skip_bits(&alac->gb, 12); /* unused header bits */ | |
272 | ||
273 | /* the number of output samples is stored in the frame */ | |
274 | has_size = get_bits1(&alac->gb); | |
275 | ||
276 | alac->extra_bits = get_bits(&alac->gb, 2) << 3; | |
277 | bps = alac->sample_size - alac->extra_bits + channels - 1; | |
278 | if (bps > 32U) { | |
279 | av_log(avctx, AV_LOG_ERROR, "bps is unsupported: %d\n", bps); | |
280 | return AVERROR_PATCHWELCOME; | |
281 | } | |
282 | ||
283 | /* whether the frame is compressed */ | |
284 | is_compressed = !get_bits1(&alac->gb); | |
285 | ||
286 | if (has_size) | |
287 | output_samples = get_bits_long(&alac->gb, 32); | |
288 | else | |
289 | output_samples = alac->max_samples_per_frame; | |
290 | if (!output_samples || output_samples > alac->max_samples_per_frame) { | |
291 | av_log(avctx, AV_LOG_ERROR, "invalid samples per frame: %"PRIu32"\n", | |
292 | output_samples); | |
293 | return AVERROR_INVALIDDATA; | |
294 | } | |
295 | if (!alac->nb_samples) { | |
296 | ThreadFrame tframe = { .f = frame }; | |
297 | /* get output buffer */ | |
298 | frame->nb_samples = output_samples; | |
299 | if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0) | |
300 | return ret; | |
301 | } else if (output_samples != alac->nb_samples) { | |
302 | av_log(avctx, AV_LOG_ERROR, "sample count mismatch: %"PRIu32" != %d\n", | |
303 | output_samples, alac->nb_samples); | |
304 | return AVERROR_INVALIDDATA; | |
305 | } | |
306 | alac->nb_samples = output_samples; | |
307 | if (alac->direct_output) { | |
308 | for (ch = 0; ch < channels; ch++) | |
309 | alac->output_samples_buffer[ch] = (int32_t *)frame->extended_data[ch_index + ch]; | |
310 | } | |
311 | ||
312 | if (is_compressed) { | |
313 | int16_t lpc_coefs[2][32]; | |
314 | int lpc_order[2]; | |
315 | int prediction_type[2]; | |
316 | int lpc_quant[2]; | |
317 | int rice_history_mult[2]; | |
318 | ||
319 | decorr_shift = get_bits(&alac->gb, 8); | |
320 | decorr_left_weight = get_bits(&alac->gb, 8); | |
321 | ||
322 | for (ch = 0; ch < channels; ch++) { | |
323 | prediction_type[ch] = get_bits(&alac->gb, 4); | |
324 | lpc_quant[ch] = get_bits(&alac->gb, 4); | |
325 | rice_history_mult[ch] = get_bits(&alac->gb, 3); | |
326 | lpc_order[ch] = get_bits(&alac->gb, 5); | |
327 | ||
328 | if (lpc_order[ch] >= alac->max_samples_per_frame) | |
329 | return AVERROR_INVALIDDATA; | |
330 | ||
331 | /* read the predictor table */ | |
332 | for (i = lpc_order[ch] - 1; i >= 0; i--) | |
333 | lpc_coefs[ch][i] = get_sbits(&alac->gb, 16); | |
334 | } | |
335 | ||
336 | if (alac->extra_bits) { | |
337 | for (i = 0; i < alac->nb_samples; i++) { | |
338 | if(get_bits_left(&alac->gb) <= 0) | |
339 | return -1; | |
340 | for (ch = 0; ch < channels; ch++) | |
341 | alac->extra_bits_buffer[ch][i] = get_bits(&alac->gb, alac->extra_bits); | |
342 | } | |
343 | } | |
344 | for (ch = 0; ch < channels; ch++) { | |
345 | int ret=rice_decompress(alac, alac->predict_error_buffer[ch], | |
346 | alac->nb_samples, bps, | |
347 | rice_history_mult[ch] * alac->rice_history_mult / 4); | |
348 | if(ret<0) | |
349 | return ret; | |
350 | ||
351 | /* adaptive FIR filter */ | |
352 | if (prediction_type[ch] == 15) { | |
353 | /* Prediction type 15 runs the adaptive FIR twice. | |
354 | * The first pass uses the special-case coef_num = 31, while | |
355 | * the second pass uses the coefs from the bitstream. | |
356 | * | |
357 | * However, this prediction type is not currently used by the | |
358 | * reference encoder. | |
359 | */ | |
360 | lpc_prediction(alac->predict_error_buffer[ch], | |
361 | alac->predict_error_buffer[ch], | |
362 | alac->nb_samples, bps, NULL, 31, 0); | |
363 | } else if (prediction_type[ch] > 0) { | |
364 | av_log(avctx, AV_LOG_WARNING, "unknown prediction type: %i\n", | |
365 | prediction_type[ch]); | |
366 | } | |
367 | lpc_prediction(alac->predict_error_buffer[ch], | |
368 | alac->output_samples_buffer[ch], alac->nb_samples, | |
369 | bps, lpc_coefs[ch], lpc_order[ch], lpc_quant[ch]); | |
370 | } | |
371 | } else { | |
372 | /* not compressed, easy case */ | |
373 | for (i = 0; i < alac->nb_samples; i++) { | |
374 | if(get_bits_left(&alac->gb) <= 0) | |
375 | return -1; | |
376 | for (ch = 0; ch < channels; ch++) { | |
377 | alac->output_samples_buffer[ch][i] = | |
378 | get_sbits_long(&alac->gb, alac->sample_size); | |
379 | } | |
380 | } | |
381 | alac->extra_bits = 0; | |
382 | decorr_shift = 0; | |
383 | decorr_left_weight = 0; | |
384 | } | |
385 | ||
386 | if (alac->extra_bits && alac->extra_bit_bug) { | |
387 | append_extra_bits(alac->output_samples_buffer, alac->extra_bits_buffer, | |
388 | alac->extra_bits, channels, alac->nb_samples); | |
389 | } | |
390 | ||
391 | if (channels == 2 && decorr_left_weight) { | |
392 | decorrelate_stereo(alac->output_samples_buffer, alac->nb_samples, | |
393 | decorr_shift, decorr_left_weight); | |
394 | } | |
395 | ||
396 | if (alac->extra_bits && !alac->extra_bit_bug) { | |
397 | append_extra_bits(alac->output_samples_buffer, alac->extra_bits_buffer, | |
398 | alac->extra_bits, channels, alac->nb_samples); | |
399 | } | |
400 | ||
401 | if(av_sample_fmt_is_planar(avctx->sample_fmt)) { | |
402 | switch(alac->sample_size) { | |
403 | case 16: { | |
404 | for (ch = 0; ch < channels; ch++) { | |
405 | int16_t *outbuffer = (int16_t *)frame->extended_data[ch_index + ch]; | |
406 | for (i = 0; i < alac->nb_samples; i++) | |
407 | *outbuffer++ = alac->output_samples_buffer[ch][i]; | |
408 | }} | |
409 | break; | |
410 | case 24: { | |
411 | for (ch = 0; ch < channels; ch++) { | |
412 | for (i = 0; i < alac->nb_samples; i++) | |
413 | alac->output_samples_buffer[ch][i] <<= 8; | |
414 | }} | |
415 | break; | |
416 | } | |
417 | }else{ | |
418 | switch(alac->sample_size) { | |
419 | case 16: { | |
420 | int16_t *outbuffer = ((int16_t *)frame->extended_data[0]) + ch_index; | |
421 | for (i = 0; i < alac->nb_samples; i++) { | |
422 | for (ch = 0; ch < channels; ch++) | |
423 | *outbuffer++ = alac->output_samples_buffer[ch][i]; | |
424 | outbuffer += alac->channels - channels; | |
425 | } | |
426 | } | |
427 | break; | |
428 | case 24: { | |
429 | int32_t *outbuffer = ((int32_t *)frame->extended_data[0]) + ch_index; | |
430 | for (i = 0; i < alac->nb_samples; i++) { | |
431 | for (ch = 0; ch < channels; ch++) | |
432 | *outbuffer++ = alac->output_samples_buffer[ch][i] << 8; | |
433 | outbuffer += alac->channels - channels; | |
434 | } | |
435 | } | |
436 | break; | |
437 | case 32: { | |
438 | int32_t *outbuffer = ((int32_t *)frame->extended_data[0]) + ch_index; | |
439 | for (i = 0; i < alac->nb_samples; i++) { | |
440 | for (ch = 0; ch < channels; ch++) | |
441 | *outbuffer++ = alac->output_samples_buffer[ch][i]; | |
442 | outbuffer += alac->channels - channels; | |
443 | } | |
444 | } | |
445 | break; | |
446 | } | |
447 | } | |
448 | ||
449 | return 0; | |
450 | } | |
451 | ||
452 | static int alac_decode_frame(AVCodecContext *avctx, void *data, | |
453 | int *got_frame_ptr, AVPacket *avpkt) | |
454 | { | |
455 | ALACContext *alac = avctx->priv_data; | |
456 | AVFrame *frame = data; | |
457 | enum AlacRawDataBlockType element; | |
458 | int channels; | |
459 | int ch, ret, got_end; | |
460 | ||
461 | if ((ret = init_get_bits8(&alac->gb, avpkt->data, avpkt->size)) < 0) | |
462 | return ret; | |
463 | ||
464 | got_end = 0; | |
465 | alac->nb_samples = 0; | |
466 | ch = 0; | |
467 | while (get_bits_left(&alac->gb) >= 3) { | |
468 | element = get_bits(&alac->gb, 3); | |
469 | if (element == TYPE_END) { | |
470 | got_end = 1; | |
471 | break; | |
472 | } | |
473 | if (element > TYPE_CPE && element != TYPE_LFE) { | |
474 | av_log(avctx, AV_LOG_ERROR, "syntax element unsupported: %d\n", element); | |
475 | return AVERROR_PATCHWELCOME; | |
476 | } | |
477 | ||
478 | channels = (element == TYPE_CPE) ? 2 : 1; | |
479 | if (ch + channels > alac->channels || | |
480 | ff_alac_channel_layout_offsets[alac->channels - 1][ch] + channels > alac->channels) { | |
481 | av_log(avctx, AV_LOG_ERROR, "invalid element channel count\n"); | |
482 | return AVERROR_INVALIDDATA; | |
483 | } | |
484 | ||
485 | ret = decode_element(avctx, frame, | |
486 | ff_alac_channel_layout_offsets[alac->channels - 1][ch], | |
487 | channels); | |
488 | if (ret < 0 && get_bits_left(&alac->gb)) | |
489 | return ret; | |
490 | ||
491 | ch += channels; | |
492 | } | |
493 | if (!got_end) { | |
494 | av_log(avctx, AV_LOG_ERROR, "no end tag found. incomplete packet.\n"); | |
495 | return AVERROR_INVALIDDATA; | |
496 | } | |
497 | ||
498 | if (avpkt->size * 8 - get_bits_count(&alac->gb) > 8) { | |
499 | av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", | |
500 | avpkt->size * 8 - get_bits_count(&alac->gb)); | |
501 | } | |
502 | ||
503 | if (alac->channels == ch) | |
504 | *got_frame_ptr = 1; | |
505 | else | |
506 | av_log(avctx, AV_LOG_WARNING, "Failed to decode all channels\n"); | |
507 | ||
508 | return avpkt->size; | |
509 | } | |
510 | ||
511 | static av_cold int alac_decode_close(AVCodecContext *avctx) | |
512 | { | |
513 | ALACContext *alac = avctx->priv_data; | |
514 | ||
515 | int ch; | |
516 | for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) { | |
517 | av_freep(&alac->predict_error_buffer[ch]); | |
518 | if (!alac->direct_output) | |
519 | av_freep(&alac->output_samples_buffer[ch]); | |
520 | av_freep(&alac->extra_bits_buffer[ch]); | |
521 | } | |
522 | ||
523 | return 0; | |
524 | } | |
525 | ||
526 | static int allocate_buffers(ALACContext *alac) | |
527 | { | |
528 | int ch; | |
529 | int buf_size = alac->max_samples_per_frame * sizeof(int32_t); | |
530 | ||
531 | for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) { | |
532 | FF_ALLOC_OR_GOTO(alac->avctx, alac->predict_error_buffer[ch], | |
533 | buf_size, buf_alloc_fail); | |
534 | ||
535 | alac->direct_output = alac->sample_size > 16 && av_sample_fmt_is_planar(alac->avctx->sample_fmt); | |
536 | if (!alac->direct_output) { | |
537 | FF_ALLOC_OR_GOTO(alac->avctx, alac->output_samples_buffer[ch], | |
538 | buf_size, buf_alloc_fail); | |
539 | } | |
540 | ||
541 | FF_ALLOC_OR_GOTO(alac->avctx, alac->extra_bits_buffer[ch], | |
542 | buf_size, buf_alloc_fail); | |
543 | } | |
544 | return 0; | |
545 | buf_alloc_fail: | |
546 | alac_decode_close(alac->avctx); | |
547 | return AVERROR(ENOMEM); | |
548 | } | |
549 | ||
550 | static int alac_set_info(ALACContext *alac) | |
551 | { | |
552 | GetByteContext gb; | |
553 | ||
554 | bytestream2_init(&gb, alac->avctx->extradata, | |
555 | alac->avctx->extradata_size); | |
556 | ||
557 | bytestream2_skipu(&gb, 12); // size:4, alac:4, version:4 | |
558 | ||
559 | alac->max_samples_per_frame = bytestream2_get_be32u(&gb); | |
560 | if (!alac->max_samples_per_frame || | |
561 | alac->max_samples_per_frame > INT_MAX / sizeof(int32_t)) { | |
562 | av_log(alac->avctx, AV_LOG_ERROR, | |
563 | "max samples per frame invalid: %"PRIu32"\n", | |
564 | alac->max_samples_per_frame); | |
565 | return AVERROR_INVALIDDATA; | |
566 | } | |
567 | bytestream2_skipu(&gb, 1); // compatible version | |
568 | alac->sample_size = bytestream2_get_byteu(&gb); | |
569 | alac->rice_history_mult = bytestream2_get_byteu(&gb); | |
570 | alac->rice_initial_history = bytestream2_get_byteu(&gb); | |
571 | alac->rice_limit = bytestream2_get_byteu(&gb); | |
572 | alac->channels = bytestream2_get_byteu(&gb); | |
573 | bytestream2_get_be16u(&gb); // maxRun | |
574 | bytestream2_get_be32u(&gb); // max coded frame size | |
575 | bytestream2_get_be32u(&gb); // average bitrate | |
576 | bytestream2_get_be32u(&gb); // samplerate | |
577 | ||
578 | return 0; | |
579 | } | |
580 | ||
581 | static av_cold int alac_decode_init(AVCodecContext * avctx) | |
582 | { | |
583 | int ret; | |
584 | int req_packed; | |
585 | ALACContext *alac = avctx->priv_data; | |
586 | alac->avctx = avctx; | |
587 | ||
588 | /* initialize from the extradata */ | |
589 | if (alac->avctx->extradata_size < ALAC_EXTRADATA_SIZE) { | |
590 | av_log(avctx, AV_LOG_ERROR, "extradata is too small\n"); | |
591 | return AVERROR_INVALIDDATA; | |
592 | } | |
593 | if (alac_set_info(alac)) { | |
594 | av_log(avctx, AV_LOG_ERROR, "set_info failed\n"); | |
595 | return -1; | |
596 | } | |
597 | ||
598 | req_packed = LIBAVCODEC_VERSION_MAJOR < 55 && !av_sample_fmt_is_planar(avctx->request_sample_fmt); | |
599 | switch (alac->sample_size) { | |
600 | case 16: avctx->sample_fmt = req_packed ? AV_SAMPLE_FMT_S16 : AV_SAMPLE_FMT_S16P; | |
601 | break; | |
602 | case 24: | |
603 | case 32: avctx->sample_fmt = req_packed ? AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S32P; | |
604 | break; | |
605 | default: avpriv_request_sample(avctx, "Sample depth %d", alac->sample_size); | |
606 | return AVERROR_PATCHWELCOME; | |
607 | } | |
608 | avctx->bits_per_raw_sample = alac->sample_size; | |
609 | ||
610 | if (alac->channels < 1) { | |
611 | av_log(avctx, AV_LOG_WARNING, "Invalid channel count\n"); | |
612 | alac->channels = avctx->channels; | |
613 | } else { | |
614 | if (alac->channels > ALAC_MAX_CHANNELS) | |
615 | alac->channels = avctx->channels; | |
616 | else | |
617 | avctx->channels = alac->channels; | |
618 | } | |
619 | if (avctx->channels > ALAC_MAX_CHANNELS || avctx->channels <= 0 ) { | |
620 | av_log(avctx, AV_LOG_ERROR, "Unsupported channel count: %d\n", | |
621 | avctx->channels); | |
622 | return AVERROR_PATCHWELCOME; | |
623 | } | |
624 | avctx->channel_layout = ff_alac_channel_layouts[alac->channels - 1]; | |
625 | ||
626 | if ((ret = allocate_buffers(alac)) < 0) { | |
627 | av_log(avctx, AV_LOG_ERROR, "Error allocating buffers\n"); | |
628 | return ret; | |
629 | } | |
630 | ||
631 | return 0; | |
632 | } | |
633 | ||
634 | static int init_thread_copy(AVCodecContext *avctx) | |
635 | { | |
636 | ALACContext *alac = avctx->priv_data; | |
637 | alac->avctx = avctx; | |
638 | return allocate_buffers(alac); | |
639 | } | |
640 | ||
641 | static const AVOption options[] = { | |
642 | { "extra_bits_bug", "Force non-standard decoding process", | |
643 | offsetof(ALACContext, extra_bit_bug), AV_OPT_TYPE_INT, { .i64 = 0 }, | |
644 | 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM }, | |
645 | { NULL }, | |
646 | }; | |
647 | ||
648 | static const AVClass alac_class = { | |
649 | .class_name = "alac", | |
650 | .item_name = av_default_item_name, | |
651 | .option = options, | |
652 | .version = LIBAVUTIL_VERSION_INT, | |
653 | }; | |
654 | ||
655 | AVCodec ff_alac_decoder = { | |
656 | .name = "alac", | |
657 | .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"), | |
658 | .type = AVMEDIA_TYPE_AUDIO, | |
659 | .id = AV_CODEC_ID_ALAC, | |
660 | .priv_data_size = sizeof(ALACContext), | |
661 | .init = alac_decode_init, | |
662 | .close = alac_decode_close, | |
663 | .decode = alac_decode_frame, | |
664 | .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy), | |
665 | .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS, | |
666 | .priv_class = &alac_class | |
667 | }; |