ffmpeg / libavcodec / alac.c @ a1301f29
History  View  Annotate  Download (21.4 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 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  
59 
#define ALAC_EXTRADATA_SIZE 36 
60 
#define MAX_CHANNELS 2 
61  
62 
typedef struct { 
63  
64 
AVCodecContext *avctx; 
65 
GetBitContext gb; 
66 
/* init to 0; first frame decode should initialize from extradata and

67 
* set this to 1 */

68 
int context_initialized;

69  
70 
int samplesize;

71 
int numchannels;

72 
int bytespersample;

73  
74 
/* buffers */

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

80 
uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */ /* max samples per frame? */ 
81 
uint8_t setinfo_7a; /* 0x00 */

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 
uint8_t setinfo_7f; /* 0x02 */

87 
uint16_t setinfo_80; /* 0x00ff */

88 
uint32_t setinfo_82; /* 0x000020e7 */ /* max sample size?? */ 
89 
uint32_t setinfo_86; /* 0x00069fe4 */ /* bit rate (average)?? */ 
90 
uint32_t setinfo_8a_rate; /* 0x0000ac44 */

91 
/* end setinfo stuff */

92  
93 
} ALACContext; 
94  
95 
static void allocate_buffers(ALACContext *alac) 
96 
{ 
97 
int chan;

98 
for (chan = 0; chan < MAX_CHANNELS; chan++) { 
99 
alac>predicterror_buffer[chan] = 
100 
av_malloc(alac>setinfo_max_samples_per_frame * 4);

101  
102 
alac>outputsamples_buffer[chan] = 
103 
av_malloc(alac>setinfo_max_samples_per_frame * 4);

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

117 
return 1; 
118 
} 
119  
120 
/* buffer size / 2 ? */

121 
alac>setinfo_max_samples_per_frame = bytestream_get_be32(&ptr); 
122 
alac>setinfo_7a = *ptr++; 
123 
alac>setinfo_sample_size = *ptr++; 
124 
alac>setinfo_rice_historymult = *ptr++; 
125 
alac>setinfo_rice_initialhistory = *ptr++; 
126 
alac>setinfo_rice_kmodifier = *ptr++; 
127 
/* channels? */

128 
alac>setinfo_7f = *ptr++; 
129 
alac>setinfo_80 = bytestream_get_be16(&ptr); 
130 
/* max coded frame size */

131 
alac>setinfo_82 = bytestream_get_be32(&ptr); 
132 
/* bitrate ? */

133 
alac>setinfo_86 = bytestream_get_be32(&ptr); 
134 
/* samplerate */

135 
alac>setinfo_8a_rate = bytestream_get_be32(&ptr); 
136  
137 
allocate_buffers(alac); 
138  
139 
return 0; 
140 
} 
141  
142 
/* hideously inefficient. could use a bitmask search,

143 
* alternatively bsr on x86,

144 
*/

145 
static int count_leading_zeros(int32_t input) 
146 
{ 
147 
int i = 0; 
148 
while (!(0x80000000 & input) && i < 32) { 
149 
i++; 
150 
input = input << 1;

151 
} 
152 
return i;

153 
} 
154  
155 
static void bastardized_rice_decompress(ALACContext *alac, 
156 
int32_t *output_buffer, 
157 
int output_size,

158 
int readsamplesize, /* arg_10 */ 
159 
int rice_initialhistory, /* arg424>b */ 
160 
int rice_kmodifier, /* arg424>d */ 
161 
int rice_historymult, /* arg424>c */ 
162 
int rice_kmodifier_mask /* arg424>e */ 
163 
) 
164 
{ 
165 
int output_count;

166 
unsigned int history = rice_initialhistory; 
167 
int sign_modifier = 0; 
168  
169 
for (output_count = 0; output_count < output_size; output_count++) { 
170 
int32_t x = 0;

171 
int32_t x_modified; 
172 
int32_t final_val; 
173  
174 
/* read x  number of 1s before 0 represent the rice */

175 
while (x <= 8 && get_bits1(&alac>gb)) { 
176 
x++; 
177 
} 
178  
179  
180 
if (x > 8) { /* RICE THRESHOLD */ 
181 
/* use alternative encoding */

182 
int32_t value; 
183  
184 
value = get_bits(&alac>gb, readsamplesize); 
185  
186 
/* mask value to readsamplesize size */

187 
if (readsamplesize != 32) 
188 
value &= (0xffffffff >> (32  readsamplesize)); 
189  
190 
x = value; 
191 
} else {

192 
/* standard rice encoding */

193 
int extrabits;

194 
int k; /* size of extra bits */ 
195  
196 
/* read k, that is bits as is */

197 
k = 31  rice_kmodifier  count_leading_zeros((history >> 9) + 3); 
198  
199 
if (k < 0) 
200 
k += rice_kmodifier; 
201 
else

202 
k = rice_kmodifier; 
203  
204 
if (k != 1) { 
205 
extrabits = show_bits(&alac>gb, k); 
206  
207 
/* multiply x by 2^k  1, as part of their strange algorithm */

208 
x = (x << k)  x; 
209  
210 
if (extrabits > 1) { 
211 
x += extrabits  1;

212 
get_bits(&alac>gb, k); 
213 
} else {

214 
get_bits(&alac>gb, k  1);

215 
} 
216 
} 
217 
} 
218  
219 
x_modified = sign_modifier + x; 
220 
final_val = (x_modified + 1) / 2; 
221 
if (x_modified & 1) final_val *= 1; 
222  
223 
output_buffer[output_count] = final_val; 
224  
225 
sign_modifier = 0;

226  
227 
/* now update the history */

228 
history += (x_modified * rice_historymult) 
229 
 ((history * rice_historymult) >> 9);

230  
231 
if (x_modified > 0xffff) 
232 
history = 0xffff;

233  
234 
/* special case: there may be compressed blocks of 0 */

235 
if ((history < 128) && (output_count+1 < output_size)) { 
236 
int block_size;

237  
238 
sign_modifier = 1;

239  
240 
x = 0;

241 
while (x <= 8 && get_bits1(&alac>gb)) { 
242 
x++; 
243 
} 
244  
245 
if (x > 8) { 
246 
block_size = get_bits(&alac>gb, 16);

247 
block_size &= 0xffff;

248 
} else {

249 
int k;

250 
int extrabits;

251  
252 
k = count_leading_zeros(history) + ((history + 16) >> 6 /* / 64 */)  24; 
253  
254 
extrabits = show_bits(&alac>gb, k); 
255  
256 
block_size = (((1 << k)  1) & rice_kmodifier_mask) * x 
257 
+ extrabits  1;

258  
259 
if (extrabits < 2) { 
260 
x = 1  extrabits;

261 
block_size += x; 
262 
get_bits(&alac>gb, k  1);

263 
} else {

264 
get_bits(&alac>gb, k); 
265 
} 
266 
} 
267  
268 
if (block_size > 0) { 
269 
memset(&output_buffer[output_count+1], 0, block_size * 4); 
270 
output_count += block_size; 
271  
272 
} 
273  
274 
if (block_size > 0xffff) 
275 
sign_modifier = 0;

276  
277 
history = 0;

278 
} 
279 
} 
280 
} 
281  
282 
#define SIGN_EXTENDED32(val, bits) ((val << (32  bits)) >> (32  bits)) 
283  
284 
#define SIGN_ONLY(v) \

285 
((v < 0) ? (1) : \ 
286 
((v > 0) ? (1) : \ 
287 
(0)))

288  
289 
static void predictor_decompress_fir_adapt(int32_t *error_buffer, 
290 
int32_t *buffer_out, 
291 
int output_size,

292 
int readsamplesize,

293 
int16_t *predictor_coef_table, 
294 
int predictor_coef_num,

295 
int predictor_quantitization)

296 
{ 
297 
int i;

298  
299 
/* first sample always copies */

300 
*buffer_out = *error_buffer; 
301  
302 
if (!predictor_coef_num) {

303 
if (output_size <= 1) return; 
304 
memcpy(buffer_out+1, error_buffer+1, (output_size1) * 4); 
305 
return;

306 
} 
307  
308 
if (predictor_coef_num == 0x1f) { /* 11111  max value of predictor_coef_num */ 
309 
/* secondbest case scenario for fir decompression,

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

311 
*/

312 
if (output_size <= 1) return; 
313 
for (i = 0; i < output_size  1; i++) { 
314 
int32_t prev_value; 
315 
int32_t error_value; 
316  
317 
prev_value = buffer_out[i]; 
318 
error_value = error_buffer[i+1];

319 
buffer_out[i+1] = SIGN_EXTENDED32((prev_value + error_value), readsamplesize);

320 
} 
321 
return;

322 
} 
323  
324 
/* read warmup samples */

325 
if (predictor_coef_num > 0) { 
326 
int i;

327 
for (i = 0; i < predictor_coef_num; i++) { 
328 
int32_t val; 
329  
330 
val = buffer_out[i] + error_buffer[i+1];

331  
332 
val = SIGN_EXTENDED32(val, readsamplesize); 
333  
334 
buffer_out[i+1] = val;

335 
} 
336 
} 
337  
338 
#if 0

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

340 
* should be unrolled and optimised

341 
*/

342 
if (predictor_coef_num == 4) {

343 
/* FIXME: optimised general case */

344 
return;

345 
}

346 

347 
if (predictor_coef_table == 8) {

348 
/* FIXME: optimised general case */

349 
return;

350 
}

351 
#endif

352  
353  
354 
/* general case */

355 
if (predictor_coef_num > 0) { 
356 
for (i = predictor_coef_num + 1; 
357 
i < output_size; 
358 
i++) { 
359 
int j;

360 
int sum = 0; 
361 
int outval;

362 
int error_val = error_buffer[i];

363  
364 
for (j = 0; j < predictor_coef_num; j++) { 
365 
sum += (buffer_out[predictor_coef_numj]  buffer_out[0]) *

366 
predictor_coef_table[j]; 
367 
} 
368  
369 
outval = (1 << (predictor_quantitization1)) + sum; 
370 
outval = outval >> predictor_quantitization; 
371 
outval = outval + buffer_out[0] + error_val;

372 
outval = SIGN_EXTENDED32(outval, readsamplesize); 
373  
374 
buffer_out[predictor_coef_num+1] = outval;

375  
376 
if (error_val > 0) { 
377 
int predictor_num = predictor_coef_num  1; 
378  
379 
while (predictor_num >= 0 && error_val > 0) { 
380 
int val = buffer_out[0]  buffer_out[predictor_coef_num  predictor_num]; 
381 
int sign = SIGN_ONLY(val);

382  
383 
predictor_coef_table[predictor_num] = sign; 
384  
385 
val *= sign; /* absolute value */

386  
387 
error_val = ((val >> predictor_quantitization) * 
388 
(predictor_coef_num  predictor_num)); 
389  
390 
predictor_num; 
391 
} 
392 
} else if (error_val < 0) { 
393 
int predictor_num = predictor_coef_num  1; 
394  
395 
while (predictor_num >= 0 && error_val < 0) { 
396 
int val = buffer_out[0]  buffer_out[predictor_coef_num  predictor_num]; 
397 
int sign =  SIGN_ONLY(val);

398  
399 
predictor_coef_table[predictor_num] = sign; 
400  
401 
val *= sign; /* neg value */

402  
403 
error_val = ((val >> predictor_quantitization) * 
404 
(predictor_coef_num  predictor_num)); 
405  
406 
predictor_num; 
407 
} 
408 
} 
409  
410 
buffer_out++; 
411 
} 
412 
} 
413 
} 
414  
415 
static void deinterlace_16(int32_t *buffer_a, int32_t *buffer_b, 
416 
int16_t *buffer_out, 
417 
int numchannels, int numsamples, 
418 
uint8_t interlacing_shift, 
419 
uint8_t interlacing_leftweight) 
420 
{ 
421 
int i;

422 
if (numsamples <= 0) return; 
423  
424 
/* weighted interlacing */

425 
if (interlacing_leftweight) {

426 
for (i = 0; i < numsamples; i++) { 
427 
int32_t difference, midright; 
428 
int16_t left; 
429 
int16_t right; 
430  
431 
midright = buffer_a[i]; 
432 
difference = buffer_b[i]; 
433  
434  
435 
right = midright  ((difference * interlacing_leftweight) >> interlacing_shift); 
436 
left = (midright  ((difference * interlacing_leftweight) >> interlacing_shift)) 
437 
+ difference; 
438  
439 
buffer_out[i*numchannels] = left; 
440 
buffer_out[i*numchannels + 1] = right;

441 
} 
442  
443 
return;

444 
} 
445  
446 
/* otherwise basic interlacing took place */

447 
for (i = 0; i < numsamples; i++) { 
448 
int16_t left, right; 
449  
450 
left = buffer_a[i]; 
451 
right = buffer_b[i]; 
452  
453 
buffer_out[i*numchannels] = left; 
454 
buffer_out[i*numchannels + 1] = right;

455 
} 
456 
} 
457  
458 
static int alac_decode_frame(AVCodecContext *avctx, 
459 
void *outbuffer, int *outputsize, 
460 
uint8_t *inbuffer, int input_buffer_size)

461 
{ 
462 
ALACContext *alac = avctx>priv_data; 
463  
464 
int channels;

465 
int32_t outputsamples; 
466 
int hassize;

467 
int readsamplesize;

468 
int wasted_bytes;

469 
int isnotcompressed;

470 
uint8_t interlacing_shift; 
471 
uint8_t interlacing_leftweight; 
472  
473 
/* shortcircuit null buffers */

474 
if (!inbuffer  !input_buffer_size)

475 
return input_buffer_size;

476  
477 
/* initialize from the extradata */

478 
if (!alac>context_initialized) {

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

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

481 
ALAC_EXTRADATA_SIZE); 
482 
return input_buffer_size;

483 
} 
484 
if (alac_set_info(alac)) {

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

486 
return input_buffer_size;

487 
} 
488 
alac>context_initialized = 1;

489 
} 
490  
491 
init_get_bits(&alac>gb, inbuffer, input_buffer_size * 8);

492  
493 
channels = get_bits(&alac>gb, 3) + 1; 
494  
495 
/* 2^result = something to do with output waiting.

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

497 
*/

498 
get_bits(&alac>gb, 4);

499  
500 
get_bits(&alac>gb, 12); /* unknown, skip 12 bits */ 
501  
502 
hassize = get_bits(&alac>gb, 1); /* the output sample size is stored soon */ 
503  
504 
wasted_bytes = get_bits(&alac>gb, 2); /* unknown ? */ 
505  
506 
isnotcompressed = get_bits(&alac>gb, 1); /* whether the frame is compressed */ 
507  
508 
if (hassize) {

509 
/* now read the number of samples,

510 
* as a 32bit integer */

511 
outputsamples = get_bits(&alac>gb, 32);

512 
} else

513 
outputsamples = alac>setinfo_max_samples_per_frame; 
514  
515 
*outputsize = outputsamples * alac>bytespersample; 
516 
readsamplesize = alac>setinfo_sample_size  (wasted_bytes * 8) + channels  1; 
517  
518 
if (!isnotcompressed) {

519 
/* so it is compressed */

520 
int16_t predictor_coef_table[channels][32];

521 
int predictor_coef_num[channels];

522 
int prediction_type[channels];

523 
int prediction_quantitization[channels];

524 
int ricemodifier[channels];

525  
526 
int i, chan;

527  
528 
interlacing_shift = get_bits(&alac>gb, 8);

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

530  
531 
for (chan = 0; chan < channels; chan++) { 
532 
prediction_type[chan] = get_bits(&alac>gb, 4);

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

534  
535 
ricemodifier[chan] = get_bits(&alac>gb, 3);

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

537  
538 
/* read the predictor table */

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

541 
} 
542 
} 
543  
544 
if (wasted_bytes) {

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

546 
} 
547  
548 
for (chan = 0; chan < channels; chan++) { 
549 
bastardized_rice_decompress(alac, 
550 
alac>predicterror_buffer[chan], 
551 
outputsamples, 
552 
readsamplesize, 
553 
alac>setinfo_rice_initialhistory, 
554 
alac>setinfo_rice_kmodifier, 
555 
ricemodifier[chan] * alac>setinfo_rice_historymult / 4,

556 
(1 << alac>setinfo_rice_kmodifier)  1); 
557  
558 
if (prediction_type[chan] == 0) { 
559 
/* adaptive fir */

560 
predictor_decompress_fir_adapt(alac>predicterror_buffer[chan], 
561 
alac>outputsamples_buffer[chan], 
562 
outputsamples, 
563 
readsamplesize, 
564 
predictor_coef_table[chan], 
565 
predictor_coef_num[chan], 
566 
prediction_quantitization[chan]); 
567 
} else {

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

569 
/* i think the only other prediction type (or perhaps this is just a

570 
* boolean?) runs adaptive fir twice.. like:

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

572 
* predictor_decompress_fir_adapt(predictor_error, outputsamples ...)

573 
* little strange..

574 
*/

575 
} 
576 
} 
577 
} else {

578 
/* not compressed, easy case */

579 
if (alac>setinfo_sample_size <= 16) { 
580 
int i, chan;

581 
for (chan = 0; chan < channels; chan++) { 
582 
for (i = 0; i < outputsamples; i++) { 
583 
int32_t audiobits; 
584  
585 
audiobits = get_bits(&alac>gb, alac>setinfo_sample_size); 
586 
audiobits = SIGN_EXTENDED32(audiobits, readsamplesize); 
587  
588 
alac>outputsamples_buffer[chan][i] = audiobits; 
589 
} 
590 
} 
591 
} else {

592 
int i, chan;

593 
for (chan = 0; chan < channels; chan++) { 
594 
for (i = 0; i < outputsamples; i++) { 
595 
int32_t audiobits; 
596  
597 
audiobits = get_bits(&alac>gb, 16);

598 
/* special case of sign extension..

599 
* as we'll be ORing the low 16bits into this */

600 
audiobits = audiobits << 16;

601 
audiobits = audiobits >> (32  alac>setinfo_sample_size);

602 
audiobits = get_bits(&alac>gb, alac>setinfo_sample_size  16);

603  
604 
alac>outputsamples_buffer[chan][i] = audiobits; 
605 
} 
606 
} 
607 
} 
608 
/* wasted_bytes = 0; */

609 
interlacing_shift = 0;

610 
interlacing_leftweight = 0;

611 
} 
612  
613 
switch(alac>setinfo_sample_size) {

614 
case 16: { 
615 
if (channels == 2) { 
616 
deinterlace_16(alac>outputsamples_buffer[0],

617 
alac>outputsamples_buffer[1],

618 
(int16_t*)outbuffer, 
619 
alac>numchannels, 
620 
outputsamples, 
621 
interlacing_shift, 
622 
interlacing_leftweight); 
623 
} else {

624 
int i;

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

627 
((int16_t*)outbuffer)[i * alac>numchannels] = sample; 
628 
} 
629 
} 
630 
break;

631 
} 
632 
case 20: 
633 
case 24: 
634 
case 32: 
635 
av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented sample size %i\n", alac>setinfo_sample_size);

636 
break;

637 
default:

638 
break;

639 
} 
640  
641  
642 
return input_buffer_size;

643 
} 
644  
645 
static int alac_decode_init(AVCodecContext * avctx) 
646 
{ 
647 
ALACContext *alac = avctx>priv_data; 
648 
alac>avctx = avctx; 
649 
alac>context_initialized = 0;

650  
651 
alac>samplesize = alac>avctx>bits_per_sample; 
652 
alac>numchannels = alac>avctx>channels; 
653 
alac>bytespersample = (alac>samplesize / 8) * alac>numchannels;

654  
655 
return 0; 
656 
} 
657  
658 
static int alac_decode_close(AVCodecContext *avctx) 
659 
{ 
660 
ALACContext *alac = avctx>priv_data; 
661  
662 
int chan;

663 
for (chan = 0; chan < MAX_CHANNELS; chan++) { 
664 
av_free(alac>predicterror_buffer[chan]); 
665 
av_free(alac>outputsamples_buffer[chan]); 
666 
} 
667  
668 
return 0; 
669 
} 
670  
671 
AVCodec alac_decoder = { 
672 
"alac",

673 
CODEC_TYPE_AUDIO, 
674 
CODEC_ID_ALAC, 
675 
sizeof(ALACContext),

676 
alac_decode_init, 
677 
NULL,

678 
alac_decode_close, 
679 
alac_decode_frame, 
680 
}; 