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
27 * For more information on the ALAC format, visit:
28 * http://crazney.net/programs/itunes/alac.html
30 * Note: This decoder expects a 36- (0x24-)byte QuickTime atom to be
31 * passed through the extradata[_size] fields. This atom is tacked onto
32 * the end of an 'alac' stsd atom and has the following format:
33 * bytes 0-3 atom size (0x24), big-endian
34 * bytes 4-7 atom type ('alac', not the 'alac' tag from start of stsd)
35 * bytes 8-35 data bytes needed by decoder
41 * 32bit max sample per frame
45 * 8bit initial history
49 * 32bit max coded frame size
56 #include "bitstream.h"
57 #include "bytestream.h"
60 #define ALAC_EXTRADATA_SIZE 36
61 #define MAX_CHANNELS 2
65 AVCodecContext
*avctx
;
67 /* init to 0; first frame decode should initialize from extradata and
69 int context_initialized
;
76 int32_t *predicterror_buffer
[MAX_CHANNELS
];
78 int32_t *outputsamples_buffer
[MAX_CHANNELS
];
80 /* stuff from setinfo */
81 uint32_t setinfo_max_samples_per_frame
; /* 0x1000 = 4096 */ /* max samples per frame? */
82 uint8_t setinfo_7a
; /* 0x00 */
83 uint8_t setinfo_sample_size
; /* 0x10 */
84 uint8_t setinfo_rice_historymult
; /* 0x28 */
85 uint8_t setinfo_rice_initialhistory
; /* 0x0a */
86 uint8_t setinfo_rice_kmodifier
; /* 0x0e */
87 uint8_t setinfo_7f
; /* 0x02 */
88 uint16_t setinfo_80
; /* 0x00ff */
89 uint32_t setinfo_82
; /* 0x000020e7 */ /* max sample size?? */
90 uint32_t setinfo_86
; /* 0x00069fe4 */ /* bit rate (average)?? */
91 uint32_t setinfo_8a_rate
; /* 0x0000ac44 */
92 /* end setinfo stuff */
96 static void allocate_buffers(ALACContext
*alac
)
99 for (chan
= 0; chan
< MAX_CHANNELS
; chan
++) {
100 alac
->predicterror_buffer
[chan
] =
101 av_malloc(alac
->setinfo_max_samples_per_frame
* 4);
103 alac
->outputsamples_buffer
[chan
] =
104 av_malloc(alac
->setinfo_max_samples_per_frame
* 4);
108 static int alac_set_info(ALACContext
*alac
)
110 const unsigned char *ptr
= alac
->avctx
->extradata
;
116 if(AV_RB32(ptr
) >= UINT_MAX
/4){
117 av_log(alac
->avctx
, AV_LOG_ERROR
, "setinfo_max_samples_per_frame too large\n");
121 /* buffer size / 2 ? */
122 alac
->setinfo_max_samples_per_frame
= bytestream_get_be32(&ptr
);
123 alac
->setinfo_7a
= *ptr
++;
124 alac
->setinfo_sample_size
= *ptr
++;
125 alac
->setinfo_rice_historymult
= *ptr
++;
126 alac
->setinfo_rice_initialhistory
= *ptr
++;
127 alac
->setinfo_rice_kmodifier
= *ptr
++;
129 alac
->setinfo_7f
= *ptr
++;
130 alac
->setinfo_80
= bytestream_get_be16(&ptr
);
131 /* max coded frame size */
132 alac
->setinfo_82
= bytestream_get_be32(&ptr
);
134 alac
->setinfo_86
= bytestream_get_be32(&ptr
);
136 alac
->setinfo_8a_rate
= bytestream_get_be32(&ptr
);
138 allocate_buffers(alac
);
143 static inline int count_leading_zeros(int32_t input
)
145 return 31-av_log2(input
);
148 static void bastardized_rice_decompress(ALACContext
*alac
,
149 int32_t *output_buffer
,
151 int readsamplesize
, /* arg_10 */
152 int rice_initialhistory
, /* arg424->b */
153 int rice_kmodifier
, /* arg424->d */
154 int rice_historymult
, /* arg424->c */
155 int rice_kmodifier_mask
/* arg424->e */
159 unsigned int history
= rice_initialhistory
;
160 int sign_modifier
= 0;
162 for (output_count
= 0; output_count
< output_size
; output_count
++) {
167 /* read x - number of 1s before 0 represent the rice */
168 x
= get_unary_0_9(&alac
->gb
);
170 if (x
> 8) { /* RICE THRESHOLD */
171 /* use alternative encoding */
174 value
= get_bits(&alac
->gb
, readsamplesize
);
176 /* mask value to readsamplesize size */
177 if (readsamplesize
!= 32)
178 value
&= (0xffffffff >> (32 - readsamplesize
));
182 /* standard rice encoding */
184 int k
; /* size of extra bits */
186 /* read k, that is bits as is */
187 k
= 31 - rice_kmodifier
- count_leading_zeros((history
>> 9) + 3);
195 extrabits
= show_bits(&alac
->gb
, k
);
197 /* multiply x by 2^k - 1, as part of their strange algorithm */
202 skip_bits(&alac
->gb
, k
);
204 skip_bits(&alac
->gb
, k
- 1);
208 x_modified
= sign_modifier
+ x
;
209 final_val
= (x_modified
+ 1) / 2;
210 if (x_modified
& 1) final_val
*= -1;
212 output_buffer
[output_count
] = final_val
;
216 /* now update the history */
217 history
+= x_modified
* rice_historymult
218 - ((history
* rice_historymult
) >> 9);
220 if (x_modified
> 0xffff)
223 /* special case: there may be compressed blocks of 0 */
224 if ((history
< 128) && (output_count
+1 < output_size
)) {
229 x
= get_unary_0_9(&alac
->gb
);
232 block_size
= get_bits(&alac
->gb
, 16);
233 block_size
&= 0xffff;
238 k
= count_leading_zeros(history
) + ((history
+ 16) >> 6 /* / 64 */) - 24;
240 extrabits
= show_bits(&alac
->gb
, k
);
242 block_size
= (((1 << k
) - 1) & rice_kmodifier_mask
) * x
248 skip_bits(&alac
->gb
, k
- 1);
250 skip_bits(&alac
->gb
, k
);
254 if (block_size
> 0) {
255 memset(&output_buffer
[output_count
+1], 0, block_size
* 4);
256 output_count
+= block_size
;
259 if (block_size
> 0xffff)
267 static inline int32_t extend_sign32(int32_t val
, int bits
)
269 return (val
<< (32 - bits
)) >> (32 - bits
);
272 static inline int sign_only(int v
)
274 return v
? FFSIGN(v
) : 0;
277 static void predictor_decompress_fir_adapt(int32_t *error_buffer
,
281 int16_t *predictor_coef_table
,
282 int predictor_coef_num
,
283 int predictor_quantitization
)
287 /* first sample always copies */
288 *buffer_out
= *error_buffer
;
290 if (!predictor_coef_num
) {
291 if (output_size
<= 1)
294 memcpy(buffer_out
+1, error_buffer
+1, (output_size
-1) * 4);
298 if (predictor_coef_num
== 0x1f) { /* 11111 - max value of predictor_coef_num */
299 /* second-best case scenario for fir decompression,
300 * error describes a small difference from the previous sample only
302 if (output_size
<= 1)
304 for (i
= 0; i
< output_size
- 1; i
++) {
308 prev_value
= buffer_out
[i
];
309 error_value
= error_buffer
[i
+1];
311 extend_sign32((prev_value
+ error_value
), readsamplesize
);
316 /* read warm-up samples */
317 if (predictor_coef_num
> 0)
318 for (i
= 0; i
< predictor_coef_num
; i
++) {
321 val
= buffer_out
[i
] + error_buffer
[i
+1];
322 val
= extend_sign32(val
, readsamplesize
);
323 buffer_out
[i
+1] = val
;
327 /* 4 and 8 are very common cases (the only ones i've seen). these
328 * should be unrolled and optimized
330 if (predictor_coef_num
== 4) {
331 /* FIXME: optimized general case */
335 if (predictor_coef_table
== 8) {
336 /* FIXME: optimized general case */
342 if (predictor_coef_num
> 0) {
343 for (i
= predictor_coef_num
+ 1; i
< output_size
; i
++) {
347 int error_val
= error_buffer
[i
];
349 for (j
= 0; j
< predictor_coef_num
; j
++) {
350 sum
+= (buffer_out
[predictor_coef_num
-j
] - buffer_out
[0]) *
351 predictor_coef_table
[j
];
354 outval
= (1 << (predictor_quantitization
-1)) + sum
;
355 outval
= outval
>> predictor_quantitization
;
356 outval
= outval
+ buffer_out
[0] + error_val
;
357 outval
= extend_sign32(outval
, readsamplesize
);
359 buffer_out
[predictor_coef_num
+1] = outval
;
362 int predictor_num
= predictor_coef_num
- 1;
364 while (predictor_num
>= 0 && error_val
> 0) {
365 int val
= buffer_out
[0] - buffer_out
[predictor_coef_num
- predictor_num
];
366 int sign
= sign_only(val
);
368 predictor_coef_table
[predictor_num
] -= sign
;
370 val
*= sign
; /* absolute value */
372 error_val
-= ((val
>> predictor_quantitization
) *
373 (predictor_coef_num
- predictor_num
));
377 } else if (error_val
< 0) {
378 int predictor_num
= predictor_coef_num
- 1;
380 while (predictor_num
>= 0 && error_val
< 0) {
381 int val
= buffer_out
[0] - buffer_out
[predictor_coef_num
- predictor_num
];
382 int sign
= - sign_only(val
);
384 predictor_coef_table
[predictor_num
] -= sign
;
386 val
*= sign
; /* neg value */
388 error_val
-= ((val
>> predictor_quantitization
) *
389 (predictor_coef_num
- predictor_num
));
400 static void reconstruct_stereo_16(int32_t *buffer
[MAX_CHANNELS
],
402 int numchannels
, int numsamples
,
403 uint8_t interlacing_shift
,
404 uint8_t interlacing_leftweight
)
410 /* weighted interlacing */
411 if (interlacing_leftweight
) {
412 for (i
= 0; i
< numsamples
; i
++) {
418 a
-= (b
* interlacing_leftweight
) >> interlacing_shift
;
421 buffer_out
[i
*numchannels
] = b
;
422 buffer_out
[i
*numchannels
+ 1] = a
;
428 /* otherwise basic interlacing took place */
429 for (i
= 0; i
< numsamples
; i
++) {
433 right
= buffer
[1][i
];
435 buffer_out
[i
*numchannels
] = left
;
436 buffer_out
[i
*numchannels
+ 1] = right
;
440 static int alac_decode_frame(AVCodecContext
*avctx
,
441 void *outbuffer
, int *outputsize
,
442 const uint8_t *inbuffer
, int input_buffer_size
)
444 ALACContext
*alac
= avctx
->priv_data
;
447 int32_t outputsamples
;
452 uint8_t interlacing_shift
;
453 uint8_t interlacing_leftweight
;
455 /* short-circuit null buffers */
456 if (!inbuffer
|| !input_buffer_size
)
457 return input_buffer_size
;
459 /* initialize from the extradata */
460 if (!alac
->context_initialized
) {
461 if (alac
->avctx
->extradata_size
!= ALAC_EXTRADATA_SIZE
) {
462 av_log(avctx
, AV_LOG_ERROR
, "alac: expected %d extradata bytes\n",
463 ALAC_EXTRADATA_SIZE
);
464 return input_buffer_size
;
466 if (alac_set_info(alac
)) {
467 av_log(avctx
, AV_LOG_ERROR
, "alac: set_info failed\n");
468 return input_buffer_size
;
470 alac
->context_initialized
= 1;
473 init_get_bits(&alac
->gb
, inbuffer
, input_buffer_size
* 8);
475 channels
= get_bits(&alac
->gb
, 3) + 1;
476 if (channels
> MAX_CHANNELS
) {
477 av_log(avctx
, AV_LOG_ERROR
, "channels > %d not supported\n",
479 return input_buffer_size
;
482 /* 2^result = something to do with output waiting.
483 * perhaps matters if we read > 1 frame in a pass?
485 skip_bits(&alac
->gb
, 4);
487 skip_bits(&alac
->gb
, 12); /* unknown, skip 12 bits */
489 /* the output sample size is stored soon */
490 hassize
= get_bits1(&alac
->gb
);
492 wasted_bytes
= get_bits(&alac
->gb
, 2); /* unknown ? */
494 /* whether the frame is compressed */
495 isnotcompressed
= get_bits1(&alac
->gb
);
498 /* now read the number of samples as a 32bit integer */
499 outputsamples
= get_bits(&alac
->gb
, 32);
501 outputsamples
= alac
->setinfo_max_samples_per_frame
;
503 *outputsize
= outputsamples
* alac
->bytespersample
;
504 readsamplesize
= alac
->setinfo_sample_size
- (wasted_bytes
* 8) + channels
- 1;
506 if (!isnotcompressed
) {
507 /* so it is compressed */
508 int16_t predictor_coef_table
[channels
][32];
509 int predictor_coef_num
[channels
];
510 int prediction_type
[channels
];
511 int prediction_quantitization
[channels
];
512 int ricemodifier
[channels
];
515 interlacing_shift
= get_bits(&alac
->gb
, 8);
516 interlacing_leftweight
= get_bits(&alac
->gb
, 8);
518 for (chan
= 0; chan
< channels
; chan
++) {
519 prediction_type
[chan
] = get_bits(&alac
->gb
, 4);
520 prediction_quantitization
[chan
] = get_bits(&alac
->gb
, 4);
522 ricemodifier
[chan
] = get_bits(&alac
->gb
, 3);
523 predictor_coef_num
[chan
] = get_bits(&alac
->gb
, 5);
525 /* read the predictor table */
526 for (i
= 0; i
< predictor_coef_num
[chan
]; i
++)
527 predictor_coef_table
[chan
][i
] = (int16_t)get_bits(&alac
->gb
, 16);
531 av_log(avctx
, AV_LOG_ERROR
, "FIXME: unimplemented, unhandling of wasted_bytes\n");
533 for (chan
= 0; chan
< channels
; chan
++) {
534 bastardized_rice_decompress(alac
,
535 alac
->predicterror_buffer
[chan
],
538 alac
->setinfo_rice_initialhistory
,
539 alac
->setinfo_rice_kmodifier
,
540 ricemodifier
[chan
] * alac
->setinfo_rice_historymult
/ 4,
541 (1 << alac
->setinfo_rice_kmodifier
) - 1);
543 if (prediction_type
[chan
] == 0) {
545 predictor_decompress_fir_adapt(alac
->predicterror_buffer
[chan
],
546 alac
->outputsamples_buffer
[chan
],
549 predictor_coef_table
[chan
],
550 predictor_coef_num
[chan
],
551 prediction_quantitization
[chan
]);
553 av_log(avctx
, AV_LOG_ERROR
, "FIXME: unhandled prediction type: %i\n", prediction_type
[chan
]);
554 /* I think the only other prediction type (or perhaps this is
555 * just a boolean?) runs adaptive fir twice.. like:
556 * predictor_decompress_fir_adapt(predictor_error, tempout, ...)
557 * predictor_decompress_fir_adapt(predictor_error, outputsamples ...)
563 /* not compressed, easy case */
564 if (alac
->setinfo_sample_size
<= 16) {
566 for (chan
= 0; chan
< channels
; chan
++)
567 for (i
= 0; i
< outputsamples
; i
++) {
570 audiobits
= get_bits(&alac
->gb
, alac
->setinfo_sample_size
);
571 audiobits
= extend_sign32(audiobits
, readsamplesize
);
573 alac
->outputsamples_buffer
[chan
][i
] = audiobits
;
577 for (chan
= 0; chan
< channels
; chan
++)
578 for (i
= 0; i
< outputsamples
; i
++) {
581 audiobits
= get_bits(&alac
->gb
, 16);
582 /* special case of sign extension..
583 * as we'll be ORing the low 16bits into this */
584 audiobits
= audiobits
<< 16;
585 audiobits
= audiobits
>> (32 - alac
->setinfo_sample_size
);
586 audiobits
|= get_bits(&alac
->gb
, alac
->setinfo_sample_size
- 16);
588 alac
->outputsamples_buffer
[chan
][i
] = audiobits
;
591 /* wasted_bytes = 0; */
592 interlacing_shift
= 0;
593 interlacing_leftweight
= 0;
596 switch(alac
->setinfo_sample_size
) {
599 reconstruct_stereo_16(alac
->outputsamples_buffer
,
604 interlacing_leftweight
);
607 for (i
= 0; i
< outputsamples
; i
++) {
608 int16_t sample
= alac
->outputsamples_buffer
[0][i
];
609 ((int16_t*)outbuffer
)[i
* alac
->numchannels
] = sample
;
615 // It is not clear if there exist any encoder that creates 24 bit ALAC
616 // files. iTunes convert 24 bit raw files to 16 bit before encoding.
618 av_log(avctx
, AV_LOG_ERROR
, "FIXME: unimplemented sample size %i\n", alac
->setinfo_sample_size
);
624 return input_buffer_size
;
627 static int alac_decode_init(AVCodecContext
* avctx
)
629 ALACContext
*alac
= avctx
->priv_data
;
631 alac
->context_initialized
= 0;
633 alac
->samplesize
= alac
->avctx
->bits_per_sample
;
634 alac
->numchannels
= alac
->avctx
->channels
;
635 alac
->bytespersample
= (alac
->samplesize
/ 8) * alac
->numchannels
;
640 static int alac_decode_close(AVCodecContext
*avctx
)
642 ALACContext
*alac
= avctx
->priv_data
;
645 for (chan
= 0; chan
< MAX_CHANNELS
; chan
++) {
646 av_free(alac
->predicterror_buffer
[chan
]);
647 av_free(alac
->outputsamples_buffer
[chan
]);
653 AVCodec alac_decoder
= {