2 * ALAC (Apple Lossless Audio Codec) decoder
3 * Copyright (c) 2005 David Hammerton
5 * This file is part of FFmpeg.
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.
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.
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
24 * ALAC (Apple Lossless Audio Codec) decoder
25 * @author 2005 David Hammerton
26 * @see http://crazney.net/programs/itunes/alac.html
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:
34 * 32bit tag version (0)
35 * 32bit samples per frame (used when not set explicitly in the frames)
36 * 8bit compatible version (0)
38 * 8bit history mult (40)
39 * 8bit initial history (10)
40 * 8bit rice param limit (14)
43 * 32bit max coded frame size (0 means unknown)
44 * 32bit average bitrate (0 means unknown)
50 #include "libavutil/channel_layout.h"
51 #include "libavutil/opt.h"
54 #include "bytestream.h"
59 #include "alac_data.h"
61 #define ALAC_EXTRADATA_SIZE 36
65 AVCodecContext
*avctx
;
69 int32_t *predict_error_buffer
[2];
70 int32_t *output_samples_buffer
[2];
71 int32_t *extra_bits_buffer
[2];
73 uint32_t max_samples_per_frame
;
75 uint8_t rice_history_mult
;
76 uint8_t rice_initial_history
;
79 int extra_bits
; /**< number of extra bits beyond 16-bit */
80 int nb_samples
; /**< number of samples in the current frame */
86 static inline unsigned int decode_scalar(GetBitContext
*gb
, int k
, int bps
)
88 unsigned int x
= get_unary_0_9(gb
);
90 if (x
> 8) { /* RICE THRESHOLD */
91 /* use alternative encoding */
92 x
= get_bits_long(gb
, bps
);
94 int extrabits
= show_bits(gb
, k
);
96 /* multiply x by 2^k - 1, as part of their strange algorithm */
103 skip_bits(gb
, k
- 1);
108 static int rice_decompress(ALACContext
*alac
, int32_t *output_buffer
,
109 int nb_samples
, int bps
, int rice_history_mult
)
112 unsigned int history
= alac
->rice_initial_history
;
113 int sign_modifier
= 0;
115 for (i
= 0; i
< nb_samples
; i
++) {
119 if(get_bits_left(&alac
->gb
) <= 0)
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
);
128 output_buffer
[i
] = (x
>> 1) ^ -(x
& 1);
130 /* update the history */
134 history
+= x
* rice_history_mult
-
135 ((history
* rice_history_mult
) >> 9);
137 /* special case: there may be compressed blocks of 0 */
138 if ((history
< 128) && (i
+ 1 < nb_samples
)) {
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);
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
,
151 block_size
= nb_samples
- i
- 1;
153 memset(&output_buffer
[i
+ 1], 0,
154 block_size
* sizeof(*output_buffer
));
157 if (block_size
<= 0xffff)
165 static inline int sign_only(int v
)
167 return v
? FFSIGN(v
) : 0;
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
)
175 int32_t *pred
= buffer_out
;
177 /* first sample always copies */
178 *buffer_out
= *error_buffer
;
184 memcpy(&buffer_out
[1], &error_buffer
[1],
185 (nb_samples
- 1) * sizeof(*buffer_out
));
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
],
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
);
202 /* NOTE: 4 and 8 are very common cases that could be optimized. */
204 for (; i
< nb_samples
; i
++) {
207 int error_val
= error_buffer
[i
];
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
);
218 /* adapt LPC coefficients */
219 error_sign
= sign_only(error_val
);
221 for (j
= 0; j
< lpc_order
&& error_val
* error_sign
> 0; j
++) {
224 sign
= sign_only(val
) * error_sign
;
225 lpc_coefs
[j
] -= sign
;
227 error_val
-= (val
>> lpc_quant
) * (j
+ 1);
233 static void decorrelate_stereo(int32_t *buffer
[2], int nb_samples
,
234 int decorr_shift
, int decorr_left_weight
)
238 for (i
= 0; i
< nb_samples
; i
++) {
244 a
-= (b
* decorr_left_weight
) >> decorr_shift
;
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
)
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
];
262 static int decode_element(AVCodecContext
*avctx
, AVFrame
*frame
, int ch_index
,
265 ALACContext
*alac
= avctx
->priv_data
;
266 int has_size
, bps
, is_compressed
, decorr_shift
, decorr_left_weight
, ret
;
267 uint32_t output_samples
;
270 skip_bits(&alac
->gb
, 4); /* element instance tag */
271 skip_bits(&alac
->gb
, 12); /* unused header bits */
273 /* the number of output samples is stored in the frame */
274 has_size
= get_bits1(&alac
->gb
);
276 alac
->extra_bits
= get_bits(&alac
->gb
, 2) << 3;
277 bps
= alac
->sample_size
- alac
->extra_bits
+ channels
- 1;
279 av_log(avctx
, AV_LOG_ERROR
, "bps is unsupported: %d\n", bps
);
280 return AVERROR_PATCHWELCOME
;
283 /* whether the frame is compressed */
284 is_compressed
= !get_bits1(&alac
->gb
);
287 output_samples
= get_bits_long(&alac
->gb
, 32);
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",
293 return AVERROR_INVALIDDATA
;
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)
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
;
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
];
313 int16_t lpc_coefs
[2][32];
315 int prediction_type
[2];
317 int rice_history_mult
[2];
319 decorr_shift
= get_bits(&alac
->gb
, 8);
320 decorr_left_weight
= get_bits(&alac
->gb
, 8);
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);
328 if (lpc_order
[ch
] >= alac
->max_samples_per_frame
)
329 return AVERROR_INVALIDDATA
;
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);
336 if (alac
->extra_bits
) {
337 for (i
= 0; i
< alac
->nb_samples
; i
++) {
338 if(get_bits_left(&alac
->gb
) <= 0)
340 for (ch
= 0; ch
< channels
; ch
++)
341 alac
->extra_bits_buffer
[ch
][i
] = get_bits(&alac
->gb
, alac
->extra_bits
);
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);
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.
357 * However, this prediction type is not currently used by the
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
]);
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
]);
372 /* not compressed, easy case */
373 for (i
= 0; i
< alac
->nb_samples
; i
++) {
374 if(get_bits_left(&alac
->gb
) <= 0)
376 for (ch
= 0; ch
< channels
; ch
++) {
377 alac
->output_samples_buffer
[ch
][i
] =
378 get_sbits_long(&alac
->gb
, alac
->sample_size
);
381 alac
->extra_bits
= 0;
383 decorr_left_weight
= 0;
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
);
391 if (channels
== 2 && decorr_left_weight
) {
392 decorrelate_stereo(alac
->output_samples_buffer
, alac
->nb_samples
,
393 decorr_shift
, decorr_left_weight
);
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
);
401 if(av_sample_fmt_is_planar(avctx
->sample_fmt
)) {
402 switch(alac
->sample_size
) {
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
];
411 for (ch
= 0; ch
< channels
; ch
++) {
412 for (i
= 0; i
< alac
->nb_samples
; i
++)
413 alac
->output_samples_buffer
[ch
][i
] <<= 8;
418 switch(alac
->sample_size
) {
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
;
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
;
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
;
452 static int alac_decode_frame(AVCodecContext
*avctx
, void *data
,
453 int *got_frame_ptr
, AVPacket
*avpkt
)
455 ALACContext
*alac
= avctx
->priv_data
;
456 AVFrame
*frame
= data
;
457 enum AlacRawDataBlockType element
;
459 int ch
, ret
, got_end
;
461 if ((ret
= init_get_bits8(&alac
->gb
, avpkt
->data
, avpkt
->size
)) < 0)
465 alac
->nb_samples
= 0;
467 while (get_bits_left(&alac
->gb
) >= 3) {
468 element
= get_bits(&alac
->gb
, 3);
469 if (element
== TYPE_END
) {
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
;
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
;
485 ret
= decode_element(avctx
, frame
,
486 ff_alac_channel_layout_offsets
[alac
->channels
- 1][ch
],
488 if (ret
< 0 && get_bits_left(&alac
->gb
))
494 av_log(avctx
, AV_LOG_ERROR
, "no end tag found. incomplete packet.\n");
495 return AVERROR_INVALIDDATA
;
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
));
503 if (alac
->channels
== ch
)
506 av_log(avctx
, AV_LOG_WARNING
, "Failed to decode all channels\n");
511 static av_cold
int alac_decode_close(AVCodecContext
*avctx
)
513 ALACContext
*alac
= avctx
->priv_data
;
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
]);
526 static int allocate_buffers(ALACContext
*alac
)
529 int buf_size
= alac
->max_samples_per_frame
* sizeof(int32_t);
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
);
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
);
541 FF_ALLOC_OR_GOTO(alac
->avctx
, alac
->extra_bits_buffer
[ch
],
542 buf_size
, buf_alloc_fail
);
546 alac_decode_close(alac
->avctx
);
547 return AVERROR(ENOMEM
);
550 static int alac_set_info(ALACContext
*alac
)
554 bytestream2_init(&gb
, alac
->avctx
->extradata
,
555 alac
->avctx
->extradata_size
);
557 bytestream2_skipu(&gb
, 12); // size:4, alac:4, version:4
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
;
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
581 static av_cold
int alac_decode_init(AVCodecContext
* avctx
)
585 ALACContext
*alac
= avctx
->priv_data
;
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
;
593 if (alac_set_info(alac
)) {
594 av_log(avctx
, AV_LOG_ERROR
, "set_info failed\n");
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
;
603 case 32: avctx
->sample_fmt
= req_packed
? AV_SAMPLE_FMT_S32
: AV_SAMPLE_FMT_S32P
;
605 default: avpriv_request_sample(avctx
, "Sample depth %d", alac
->sample_size
);
606 return AVERROR_PATCHWELCOME
;
608 avctx
->bits_per_raw_sample
= alac
->sample_size
;
610 if (alac
->channels
< 1) {
611 av_log(avctx
, AV_LOG_WARNING
, "Invalid channel count\n");
612 alac
->channels
= avctx
->channels
;
614 if (alac
->channels
> ALAC_MAX_CHANNELS
)
615 alac
->channels
= avctx
->channels
;
617 avctx
->channels
= alac
->channels
;
619 if (avctx
->channels
> ALAC_MAX_CHANNELS
|| avctx
->channels
<= 0 ) {
620 av_log(avctx
, AV_LOG_ERROR
, "Unsupported channel count: %d\n",
622 return AVERROR_PATCHWELCOME
;
624 avctx
->channel_layout
= ff_alac_channel_layouts
[alac
->channels
- 1];
626 if ((ret
= allocate_buffers(alac
)) < 0) {
627 av_log(avctx
, AV_LOG_ERROR
, "Error allocating buffers\n");
634 static int init_thread_copy(AVCodecContext
*avctx
)
636 ALACContext
*alac
= avctx
->priv_data
;
638 return allocate_buffers(alac
);
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
},
648 static const AVClass alac_class
= {
649 .class_name
= "alac",
650 .item_name
= av_default_item_name
,
652 .version
= LIBAVUTIL_VERSION_INT
,
655 AVCodec ff_alac_decoder
= {
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