ffmpeg / libavcodec / alac.c @ 6053da01
History  View  Annotate  Download (19.9 KB)
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 021101301 USA

20 
*/

21  
22 
/**

23 
* @file libavcodec/alac.c

24 
* ALAC (Apple Lossless Audio Codec) decoder

25 
* @author 2005 David Hammerton

26 
*

27 
* For more information on the ALAC format, visit:

28 
* http://crazney.net/programs/itunes/alac.html

29 
*

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 03 atom size (0x24), bigendian

34 
* bytes 47 atom type ('alac', not the 'alac' tag from start of stsd)

35 
* bytes 835 data bytes needed by decoder

36 
*

37 
* Extradata:

38 
* 32bit size

39 
* 32bit tag (=alac)

40 
* 32bit zero?

41 
* 32bit max sample per frame

42 
* 8bit ?? (zero?)

43 
* 8bit sample size

44 
* 8bit history mult

45 
* 8bit initial history

46 
* 8bit kmodifier

47 
* 8bit channels?

48 
* 16bit ??

49 
* 32bit max coded frame size

50 
* 32bit bitrate?

51 
* 32bit samplerate

52 
*/

53  
54  
55 
#include "avcodec.h" 
56 
#include "bitstream.h" 
57 
#include "bytestream.h" 
58 
#include "unary.h" 
59 
#include "mathops.h" 
60  
61 
#define ALAC_EXTRADATA_SIZE 36 
62 
#define MAX_CHANNELS 2 
63  
64 
typedef struct { 
65  
66 
AVCodecContext *avctx; 
67 
GetBitContext gb; 
68 
/* init to 0; first frame decode should initialize from extradata and

69 
* set this to 1 */

70 
int context_initialized;

71  
72 
int numchannels;

73 
int bytespersample;

74  
75 
/* buffers */

76 
int32_t *predicterror_buffer[MAX_CHANNELS]; 
77  
78 
int32_t *outputsamples_buffer[MAX_CHANNELS]; 
79  
80 
/* stuff from setinfo */

81 
uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */ /* max samples per frame? */ 
82 
uint8_t setinfo_sample_size; /* 0x10 */

83 
uint8_t setinfo_rice_historymult; /* 0x28 */

84 
uint8_t setinfo_rice_initialhistory; /* 0x0a */

85 
uint8_t setinfo_rice_kmodifier; /* 0x0e */

86 
/* end setinfo stuff */

87  
88 
} ALACContext; 
89  
90 
static void allocate_buffers(ALACContext *alac) 
91 
{ 
92 
int chan;

93 
for (chan = 0; chan < MAX_CHANNELS; chan++) { 
94 
alac>predicterror_buffer[chan] = 
95 
av_malloc(alac>setinfo_max_samples_per_frame * 4);

96  
97 
alac>outputsamples_buffer[chan] = 
98 
av_malloc(alac>setinfo_max_samples_per_frame * 4);

99 
} 
100 
} 
101  
102 
static int alac_set_info(ALACContext *alac) 
103 
{ 
104 
const unsigned char *ptr = alac>avctx>extradata; 
105  
106 
ptr += 4; /* size */ 
107 
ptr += 4; /* alac */ 
108 
ptr += 4; /* 0 ? */ 
109  
110 
if(AV_RB32(ptr) >= UINT_MAX/4){ 
111 
av_log(alac>avctx, AV_LOG_ERROR, "setinfo_max_samples_per_frame too large\n");

112 
return 1; 
113 
} 
114  
115 
/* buffer size / 2 ? */

116 
alac>setinfo_max_samples_per_frame = bytestream_get_be32(&ptr); 
117 
ptr++; /* ??? */

118 
alac>setinfo_sample_size = *ptr++; 
119 
if (alac>setinfo_sample_size > 32) { 
120 
av_log(alac>avctx, AV_LOG_ERROR, "setinfo_sample_size too large\n");

121 
return 1; 
122 
} 
123 
alac>setinfo_rice_historymult = *ptr++; 
124 
alac>setinfo_rice_initialhistory = *ptr++; 
125 
alac>setinfo_rice_kmodifier = *ptr++; 
126 
ptr++; /* channels? */

127 
bytestream_get_be16(&ptr); /* ??? */

128 
bytestream_get_be32(&ptr); /* max coded frame size */

129 
bytestream_get_be32(&ptr); /* bitrate ? */

130 
bytestream_get_be32(&ptr); /* samplerate */

131  
132 
allocate_buffers(alac); 
133  
134 
return 0; 
135 
} 
136  
137 
static inline int decode_scalar(GetBitContext *gb, int k, int limit, int readsamplesize){ 
138 
/* read x  number of 1s before 0 represent the rice */

139 
int x = get_unary_0_9(gb);

140  
141 
if (x > 8) { /* RICE THRESHOLD */ 
142 
/* use alternative encoding */

143 
x = get_bits(gb, readsamplesize); 
144 
} else {

145 
if (k >= limit)

146 
k = limit; 
147  
148 
if (k != 1) { 
149 
int extrabits = show_bits(gb, k);

150  
151 
/* multiply x by 2^k  1, as part of their strange algorithm */

152 
x = (x << k)  x; 
153  
154 
if (extrabits > 1) { 
155 
x += extrabits  1;

156 
skip_bits(gb, k); 
157 
} else

158 
skip_bits(gb, k  1);

159 
} 
160 
} 
161 
return x;

162 
} 
163  
164 
static void bastardized_rice_decompress(ALACContext *alac, 
165 
int32_t *output_buffer, 
166 
int output_size,

167 
int readsamplesize, /* arg_10 */ 
168 
int rice_initialhistory, /* arg424>b */ 
169 
int rice_kmodifier, /* arg424>d */ 
170 
int rice_historymult, /* arg424>c */ 
171 
int rice_kmodifier_mask /* arg424>e */ 
172 
) 
173 
{ 
174 
int output_count;

175 
unsigned int history = rice_initialhistory; 
176 
int sign_modifier = 0; 
177  
178 
for (output_count = 0; output_count < output_size; output_count++) { 
179 
int32_t x; 
180 
int32_t x_modified; 
181 
int32_t final_val; 
182  
183 
/* standard rice encoding */

184 
int k; /* size of extra bits */ 
185  
186 
/* read k, that is bits as is */

187 
k = av_log2((history >> 9) + 3); 
188 
x= decode_scalar(&alac>gb, k, rice_kmodifier, readsamplesize); 
189  
190 
x_modified = sign_modifier + x; 
191 
final_val = (x_modified + 1) / 2; 
192 
if (x_modified & 1) final_val *= 1; 
193  
194 
output_buffer[output_count] = final_val; 
195  
196 
sign_modifier = 0;

197  
198 
/* now update the history */

199 
history += x_modified * rice_historymult 
200 
 ((history * rice_historymult) >> 9);

201  
202 
if (x_modified > 0xffff) 
203 
history = 0xffff;

204  
205 
/* special case: there may be compressed blocks of 0 */

206 
if ((history < 128) && (output_count+1 < output_size)) { 
207 
int k;

208 
unsigned int block_size; 
209  
210 
sign_modifier = 1;

211  
212 
k = 7  av_log2(history) + ((history + 16) >> 6 /* / 64 */); 
213  
214 
block_size= decode_scalar(&alac>gb, k, rice_kmodifier, 16);

215  
216 
if (block_size > 0) { 
217 
if(block_size >= output_size  output_count){

218 
av_log(alac>avctx, AV_LOG_ERROR, "invalid zero block size of %d %d %d\n", block_size, output_size, output_count);

219 
block_size= output_size  output_count  1;

220 
} 
221 
memset(&output_buffer[output_count+1], 0, block_size * 4); 
222 
output_count += block_size; 
223 
} 
224  
225 
if (block_size > 0xffff) 
226 
sign_modifier = 0;

227  
228 
history = 0;

229 
} 
230 
} 
231 
} 
232  
233 
static inline int sign_only(int v) 
234 
{ 
235 
return v ? FFSIGN(v) : 0; 
236 
} 
237  
238 
static void predictor_decompress_fir_adapt(int32_t *error_buffer, 
239 
int32_t *buffer_out, 
240 
int output_size,

241 
int readsamplesize,

242 
int16_t *predictor_coef_table, 
243 
int predictor_coef_num,

244 
int predictor_quantitization)

245 
{ 
246 
int i;

247  
248 
/* first sample always copies */

249 
*buffer_out = *error_buffer; 
250  
251 
if (!predictor_coef_num) {

252 
if (output_size <= 1) 
253 
return;

254  
255 
memcpy(buffer_out+1, error_buffer+1, (output_size1) * 4); 
256 
return;

257 
} 
258  
259 
if (predictor_coef_num == 0x1f) { /* 11111  max value of predictor_coef_num */ 
260 
/* secondbest case scenario for fir decompression,

261 
* error describes a small difference from the previous sample only

262 
*/

263 
if (output_size <= 1) 
264 
return;

265 
for (i = 0; i < output_size  1; i++) { 
266 
int32_t prev_value; 
267 
int32_t error_value; 
268  
269 
prev_value = buffer_out[i]; 
270 
error_value = error_buffer[i+1];

271 
buffer_out[i+1] =

272 
sign_extend((prev_value + error_value), readsamplesize); 
273 
} 
274 
return;

275 
} 
276  
277 
/* read warmup samples */

278 
if (predictor_coef_num > 0) 
279 
for (i = 0; i < predictor_coef_num; i++) { 
280 
int32_t val; 
281  
282 
val = buffer_out[i] + error_buffer[i+1];

283 
val = sign_extend(val, readsamplesize); 
284 
buffer_out[i+1] = val;

285 
} 
286  
287 
#if 0

288 
/* 4 and 8 are very common cases (the only ones i've seen). these

289 
* should be unrolled and optimized

290 
*/

291 
if (predictor_coef_num == 4) {

292 
/* FIXME: optimized general case */

293 
return;

294 
}

295 

296 
if (predictor_coef_table == 8) {

297 
/* FIXME: optimized general case */

298 
return;

299 
}

300 
#endif

301  
302 
/* general case */

303 
if (predictor_coef_num > 0) { 
304 
for (i = predictor_coef_num + 1; i < output_size; i++) { 
305 
int j;

306 
int sum = 0; 
307 
int outval;

308 
int error_val = error_buffer[i];

309  
310 
for (j = 0; j < predictor_coef_num; j++) { 
311 
sum += (buffer_out[predictor_coef_numj]  buffer_out[0]) *

312 
predictor_coef_table[j]; 
313 
} 
314  
315 
outval = (1 << (predictor_quantitization1)) + sum; 
316 
outval = outval >> predictor_quantitization; 
317 
outval = outval + buffer_out[0] + error_val;

318 
outval = sign_extend(outval, readsamplesize); 
319  
320 
buffer_out[predictor_coef_num+1] = outval;

321  
322 
if (error_val > 0) { 
323 
int predictor_num = predictor_coef_num  1; 
324  
325 
while (predictor_num >= 0 && error_val > 0) { 
326 
int val = buffer_out[0]  buffer_out[predictor_coef_num  predictor_num]; 
327 
int sign = sign_only(val);

328  
329 
predictor_coef_table[predictor_num] = sign; 
330  
331 
val *= sign; /* absolute value */

332  
333 
error_val = ((val >> predictor_quantitization) * 
334 
(predictor_coef_num  predictor_num)); 
335  
336 
predictor_num; 
337 
} 
338 
} else if (error_val < 0) { 
339 
int predictor_num = predictor_coef_num  1; 
340  
341 
while (predictor_num >= 0 && error_val < 0) { 
342 
int val = buffer_out[0]  buffer_out[predictor_coef_num  predictor_num]; 
343 
int sign =  sign_only(val);

344  
345 
predictor_coef_table[predictor_num] = sign; 
346  
347 
val *= sign; /* neg value */

348  
349 
error_val = ((val >> predictor_quantitization) * 
350 
(predictor_coef_num  predictor_num)); 
351  
352 
predictor_num; 
353 
} 
354 
} 
355  
356 
buffer_out++; 
357 
} 
358 
} 
359 
} 
360  
361 
static void reconstruct_stereo_16(int32_t *buffer[MAX_CHANNELS], 
362 
int16_t *buffer_out, 
363 
int numchannels, int numsamples, 
364 
uint8_t interlacing_shift, 
365 
uint8_t interlacing_leftweight) 
366 
{ 
367 
int i;

368 
if (numsamples <= 0) 
369 
return;

370  
371 
/* weighted interlacing */

372 
if (interlacing_leftweight) {

373 
for (i = 0; i < numsamples; i++) { 
374 
int32_t a, b; 
375  
376 
a = buffer[0][i];

377 
b = buffer[1][i];

378  
379 
a = (b * interlacing_leftweight) >> interlacing_shift; 
380 
b += a; 
381  
382 
buffer_out[i*numchannels] = b; 
383 
buffer_out[i*numchannels + 1] = a;

384 
} 
385  
386 
return;

387 
} 
388  
389 
/* otherwise basic interlacing took place */

390 
for (i = 0; i < numsamples; i++) { 
391 
int16_t left, right; 
392  
393 
left = buffer[0][i];

394 
right = buffer[1][i];

395  
396 
buffer_out[i*numchannels] = left; 
397 
buffer_out[i*numchannels + 1] = right;

398 
} 
399 
} 
400  
401 
static int alac_decode_frame(AVCodecContext *avctx, 
402 
void *outbuffer, int *outputsize, 
403 
const uint8_t *inbuffer, int input_buffer_size) 
404 
{ 
405 
ALACContext *alac = avctx>priv_data; 
406  
407 
int channels;

408 
unsigned int outputsamples; 
409 
int hassize;

410 
unsigned int readsamplesize; 
411 
int wasted_bytes;

412 
int isnotcompressed;

413 
uint8_t interlacing_shift; 
414 
uint8_t interlacing_leftweight; 
415  
416 
/* shortcircuit null buffers */

417 
if (!inbuffer  !input_buffer_size)

418 
return input_buffer_size;

419  
420 
/* initialize from the extradata */

421 
if (!alac>context_initialized) {

422 
if (alac>avctx>extradata_size != ALAC_EXTRADATA_SIZE) {

423 
av_log(avctx, AV_LOG_ERROR, "alac: expected %d extradata bytes\n",

424 
ALAC_EXTRADATA_SIZE); 
425 
return input_buffer_size;

426 
} 
427 
if (alac_set_info(alac)) {

428 
av_log(avctx, AV_LOG_ERROR, "alac: set_info failed\n");

429 
return input_buffer_size;

430 
} 
431 
alac>context_initialized = 1;

432 
} 
433  
434 
init_get_bits(&alac>gb, inbuffer, input_buffer_size * 8);

435  
436 
channels = get_bits(&alac>gb, 3) + 1; 
437 
if (channels > MAX_CHANNELS) {

438 
av_log(avctx, AV_LOG_ERROR, "channels > %d not supported\n",

439 
MAX_CHANNELS); 
440 
return input_buffer_size;

441 
} 
442  
443 
/* 2^result = something to do with output waiting.

444 
* perhaps matters if we read > 1 frame in a pass?

445 
*/

446 
skip_bits(&alac>gb, 4);

447  
448 
skip_bits(&alac>gb, 12); /* unknown, skip 12 bits */ 
449  
450 
/* the output sample size is stored soon */

451 
hassize = get_bits1(&alac>gb); 
452  
453 
wasted_bytes = get_bits(&alac>gb, 2); /* unknown ? */ 
454  
455 
/* whether the frame is compressed */

456 
isnotcompressed = get_bits1(&alac>gb); 
457  
458 
if (hassize) {

459 
/* now read the number of samples as a 32bit integer */

460 
outputsamples = get_bits_long(&alac>gb, 32);

461 
if(outputsamples > alac>setinfo_max_samples_per_frame){

462 
av_log(avctx, AV_LOG_ERROR, "outputsamples %d > %d\n", outputsamples, alac>setinfo_max_samples_per_frame);

463 
return 1; 
464 
} 
465 
} else

466 
outputsamples = alac>setinfo_max_samples_per_frame; 
467  
468 
if(outputsamples > *outputsize / alac>bytespersample){

469 
av_log(avctx, AV_LOG_ERROR, "sample buffer too small\n");

470 
return 1; 
471 
} 
472  
473 
*outputsize = outputsamples * alac>bytespersample; 
474 
readsamplesize = alac>setinfo_sample_size  (wasted_bytes * 8) + channels  1; 
475 
if (readsamplesize > MIN_CACHE_BITS) {

476 
av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize);

477 
return 1; 
478 
} 
479  
480 
if (!isnotcompressed) {

481 
/* so it is compressed */

482 
int16_t predictor_coef_table[channels][32];

483 
int predictor_coef_num[channels];

484 
int prediction_type[channels];

485 
int prediction_quantitization[channels];

486 
int ricemodifier[channels];

487 
int i, chan;

488  
489 
interlacing_shift = get_bits(&alac>gb, 8);

490 
interlacing_leftweight = get_bits(&alac>gb, 8);

491  
492 
for (chan = 0; chan < channels; chan++) { 
493 
prediction_type[chan] = get_bits(&alac>gb, 4);

494 
prediction_quantitization[chan] = get_bits(&alac>gb, 4);

495  
496 
ricemodifier[chan] = get_bits(&alac>gb, 3);

497 
predictor_coef_num[chan] = get_bits(&alac>gb, 5);

498  
499 
/* read the predictor table */

500 
for (i = 0; i < predictor_coef_num[chan]; i++) 
501 
predictor_coef_table[chan][i] = (int16_t)get_bits(&alac>gb, 16);

502 
} 
503  
504 
if (wasted_bytes)

505 
av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of wasted_bytes\n");

506  
507 
for (chan = 0; chan < channels; chan++) { 
508 
bastardized_rice_decompress(alac, 
509 
alac>predicterror_buffer[chan], 
510 
outputsamples, 
511 
readsamplesize, 
512 
alac>setinfo_rice_initialhistory, 
513 
alac>setinfo_rice_kmodifier, 
514 
ricemodifier[chan] * alac>setinfo_rice_historymult / 4,

515 
(1 << alac>setinfo_rice_kmodifier)  1); 
516  
517 
if (prediction_type[chan] == 0) { 
518 
/* adaptive fir */

519 
predictor_decompress_fir_adapt(alac>predicterror_buffer[chan], 
520 
alac>outputsamples_buffer[chan], 
521 
outputsamples, 
522 
readsamplesize, 
523 
predictor_coef_table[chan], 
524 
predictor_coef_num[chan], 
525 
prediction_quantitization[chan]); 
526 
} else {

527 
av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type[chan]);

528 
/* I think the only other prediction type (or perhaps this is

529 
* just a boolean?) runs adaptive fir twice.. like:

530 
* predictor_decompress_fir_adapt(predictor_error, tempout, ...)

531 
* predictor_decompress_fir_adapt(predictor_error, outputsamples ...)

532 
* little strange..

533 
*/

534 
} 
535 
} 
536 
} else {

537 
/* not compressed, easy case */

538 
int i, chan;

539 
for (i = 0; i < outputsamples; i++) 
540 
for (chan = 0; chan < channels; chan++) { 
541 
int32_t audiobits; 
542  
543 
audiobits = get_sbits_long(&alac>gb, alac>setinfo_sample_size); 
544  
545 
alac>outputsamples_buffer[chan][i] = audiobits; 
546 
} 
547 
/* wasted_bytes = 0; */

548 
interlacing_shift = 0;

549 
interlacing_leftweight = 0;

550 
} 
551 
if (get_bits(&alac>gb, 3) != 7) 
552 
av_log(avctx, AV_LOG_ERROR, "Error : Wrong End Of Frame\n");

553  
554 
switch(alac>setinfo_sample_size) {

555 
case 16: 
556 
if (channels == 2) { 
557 
reconstruct_stereo_16(alac>outputsamples_buffer, 
558 
(int16_t*)outbuffer, 
559 
alac>numchannels, 
560 
outputsamples, 
561 
interlacing_shift, 
562 
interlacing_leftweight); 
563 
} else {

564 
int i;

565 
for (i = 0; i < outputsamples; i++) { 
566 
int16_t sample = alac>outputsamples_buffer[0][i];

567 
((int16_t*)outbuffer)[i * alac>numchannels] = sample; 
568 
} 
569 
} 
570 
break;

571 
case 20: 
572 
case 24: 
573 
// It is not clear if there exist any encoder that creates 24 bit ALAC

574 
// files. iTunes convert 24 bit raw files to 16 bit before encoding.

575 
case 32: 
576 
av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented sample size %i\n", alac>setinfo_sample_size);

577 
break;

578 
default:

579 
break;

580 
} 
581  
582 
if (input_buffer_size * 8  get_bits_count(&alac>gb) > 8) 
583 
av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8  get_bits_count(&alac>gb)); 
584  
585 
return input_buffer_size;

586 
} 
587  
588 
static av_cold int alac_decode_init(AVCodecContext * avctx) 
589 
{ 
590 
ALACContext *alac = avctx>priv_data; 
591 
alac>avctx = avctx; 
592 
alac>context_initialized = 0;

593  
594 
alac>numchannels = alac>avctx>channels; 
595 
alac>bytespersample = 2 * alac>numchannels;

596 
avctx>sample_fmt = SAMPLE_FMT_S16; 
597  
598 
return 0; 
599 
} 
600  
601 
static av_cold int alac_decode_close(AVCodecContext *avctx) 
602 
{ 
603 
ALACContext *alac = avctx>priv_data; 
604  
605 
int chan;

606 
for (chan = 0; chan < MAX_CHANNELS; chan++) { 
607 
av_free(alac>predicterror_buffer[chan]); 
608 
av_free(alac>outputsamples_buffer[chan]); 
609 
} 
610  
611 
return 0; 
612 
} 
613  
614 
AVCodec alac_decoder = { 
615 
"alac",

616 
CODEC_TYPE_AUDIO, 
617 
CODEC_ID_ALAC, 
618 
sizeof(ALACContext),

619 
alac_decode_init, 
620 
NULL,

621 
alac_decode_close, 
622 
alac_decode_frame, 
623 
.long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),

624 
}; 