FFmpeg coverage

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