ffmpeg / libavcodec / alac.c @ 1b47fafd
History  View  Annotate  Download (27.5 KB)
1 
/*


2 
* ALAC (Apple Lossless Audio Codec) decoder

3 
* Copyright (c) 2005 David Hammerton

4 
* All rights reserved.

5 
*

6 
* This library is free software; you can redistribute it and/or

7 
* modify it under the terms of the GNU Lesser General Public

8 
* License as published by the Free Software Foundation; either

9 
* version 2 of the License, or (at your option) any later version.

10 
*

11 
* This library is distributed in the hope that it will be useful,

12 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

13 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 
* Lesser General Public License for more details.

15 
*

16 
* You should have received a copy of the GNU Lesser General Public

17 
* License along with this library; if not, write to the Free Software

18 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

19 
*/

20  
21 
/**

22 
* @file alac.c

23 
* ALAC (Apple Lossless Audio Codec) decoder

24 
* @author 2005 David Hammerton

25 
*

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

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

28 
*

29 
* Note: This decoder expects a 36 (0x24)byte QuickTime atom to be

30 
* passed through the extradata[_size] fields. This atom is tacked onto

31 
* the end of an 'alac' stsd atom and has the following format:

32 
* bytes 03 atom size (0x24), bigendian

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

34 
* bytes 835 data bytes needed by decoder

35 
*/

36  
37  
38 
#include "avcodec.h" 
39 
#include "bitstream.h" 
40  
41 
#define ALAC_EXTRADATA_SIZE 36 
42  
43 
typedef struct { 
44  
45 
AVCodecContext *avctx; 
46 
GetBitContext gb; 
47 
/* init to 0; first frame decode should initialize from extradata and

48 
* set this to 1 */

49 
int context_initialized;

50  
51 
int samplesize;

52 
int numchannels;

53 
int bytespersample;

54  
55 
/* buffers */

56 
int32_t *predicterror_buffer_a; 
57 
int32_t *predicterror_buffer_b; 
58  
59 
int32_t *outputsamples_buffer_a; 
60 
int32_t *outputsamples_buffer_b; 
61  
62 
/* stuff from setinfo */

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

65 
uint8_t setinfo_sample_size; /* 0x10 */

66 
uint8_t setinfo_rice_historymult; /* 0x28 */

67 
uint8_t setinfo_rice_initialhistory; /* 0x0a */

68 
uint8_t setinfo_rice_kmodifier; /* 0x0e */

69 
uint8_t setinfo_7f; /* 0x02 */

70 
uint16_t setinfo_80; /* 0x00ff */

71 
uint32_t setinfo_82; /* 0x000020e7 */

72 
uint32_t setinfo_86; /* 0x00069fe4 */

73 
uint32_t setinfo_8a_rate; /* 0x0000ac44 */

74 
/* end setinfo stuff */

75  
76 
} ALACContext; 
77  
78 
static void allocate_buffers(ALACContext *alac) 
79 
{ 
80 
alac>predicterror_buffer_a = av_malloc(alac>setinfo_max_samples_per_frame * 4);

81 
alac>predicterror_buffer_b = av_malloc(alac>setinfo_max_samples_per_frame * 4);

82  
83 
alac>outputsamples_buffer_a = av_malloc(alac>setinfo_max_samples_per_frame * 4);

84 
alac>outputsamples_buffer_b = av_malloc(alac>setinfo_max_samples_per_frame * 4);

85 
} 
86  
87 
static void alac_set_info(ALACContext *alac) 
88 
{ 
89 
unsigned char *ptr = alac>avctx>extradata; 
90  
91 
ptr += 4; /* size */ 
92 
ptr += 4; /* alac */ 
93 
ptr += 4; /* 0 ? */ 
94  
95 
alac>setinfo_max_samples_per_frame = BE_32(ptr); /* buffer size / 2 ? */

96 
ptr += 4;

97 
alac>setinfo_7a = *ptr++; 
98 
alac>setinfo_sample_size = *ptr++; 
99 
alac>setinfo_rice_historymult = *ptr++; 
100 
alac>setinfo_rice_initialhistory = *ptr++; 
101 
alac>setinfo_rice_kmodifier = *ptr++; 
102 
alac>setinfo_7f = *ptr++; 
103 
alac>setinfo_80 = BE_16(ptr); 
104 
ptr += 2;

105 
alac>setinfo_82 = BE_32(ptr); 
106 
ptr += 4;

107 
alac>setinfo_86 = BE_32(ptr); 
108 
ptr += 4;

109 
alac>setinfo_8a_rate = BE_32(ptr); 
110 
ptr += 4;

111  
112 
allocate_buffers(alac); 
113 
} 
114  
115 
/* hideously inefficient. could use a bitmask search,

116 
* alternatively bsr on x86,

117 
*/

118 
static int count_leading_zeros(int32_t input) 
119 
{ 
120 
int i = 0; 
121 
while (!(0x80000000 & input) && i < 32) { 
122 
i++; 
123 
input = input << 1;

124 
} 
125 
return i;

126 
} 
127  
128 
static void bastardized_rice_decompress(ALACContext *alac, 
129 
int32_t *output_buffer, 
130 
int output_size,

131 
int readsamplesize, /* arg_10 */ 
132 
int rice_initialhistory, /* arg424>b */ 
133 
int rice_kmodifier, /* arg424>d */ 
134 
int rice_historymult, /* arg424>c */ 
135 
int rice_kmodifier_mask /* arg424>e */ 
136 
) 
137 
{ 
138 
int output_count;

139 
unsigned int history = rice_initialhistory; 
140 
int sign_modifier = 0; 
141  
142 
for (output_count = 0; output_count < output_size; output_count++) { 
143 
int32_t x = 0;

144 
int32_t x_modified; 
145 
int32_t final_val; 
146  
147 
/* read x  number of 1s before 0 represent the rice */

148 
while (x <= 8 && get_bits1(&alac>gb)) { 
149 
x++; 
150 
} 
151  
152  
153 
if (x > 8) { /* RICE THRESHOLD */ 
154 
/* use alternative encoding */

155 
int32_t value; 
156  
157 
value = get_bits(&alac>gb, readsamplesize); 
158  
159 
/* mask value to readsamplesize size */

160 
if (readsamplesize != 32) 
161 
value &= (0xffffffff >> (32  readsamplesize)); 
162  
163 
x = value; 
164 
} else {

165 
/* standard rice encoding */

166 
int extrabits;

167 
int k; /* size of extra bits */ 
168  
169 
/* read k, that is bits as is */

170 
k = 31  rice_kmodifier  count_leading_zeros((history >> 9) + 3); 
171  
172 
if (k < 0) 
173 
k += rice_kmodifier; 
174 
else

175 
k = rice_kmodifier; 
176  
177 
if (k != 1) { 
178 
extrabits = show_bits(&alac>gb, k); 
179  
180 
/* multiply x by 2^k  1, as part of their strange algorithm */

181 
x = (x << k)  x; 
182  
183 
if (extrabits > 1) { 
184 
x += extrabits  1;

185 
get_bits(&alac>gb, k); 
186 
} else {

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

188 
} 
189 
} 
190 
} 
191  
192 
x_modified = sign_modifier + x; 
193 
final_val = (x_modified + 1) / 2; 
194 
if (x_modified & 1) final_val *= 1; 
195  
196 
output_buffer[output_count] = final_val; 
197  
198 
sign_modifier = 0;

199  
200 
/* now update the history */

201 
history += (x_modified * rice_historymult) 
202 
 ((history * rice_historymult) >> 9);

203  
204 
if (x_modified > 0xffff) 
205 
history = 0xffff;

206  
207 
/* special case: there may be compressed blocks of 0 */

208 
if ((history < 128) && (output_count+1 < output_size)) { 
209 
int block_size;

210  
211 
sign_modifier = 1;

212  
213 
x = 0;

214 
while (x <= 8 && get_bits1(&alac>gb)) { 
215 
x++; 
216 
} 
217  
218 
if (x > 8) { 
219 
block_size = get_bits(&alac>gb, 16);

220 
block_size &= 0xffff;

221 
} else {

222 
int k;

223 
int extrabits;

224  
225 
k = count_leading_zeros(history) + ((history + 16) >> 6 /* / 64 */)  24; 
226  
227 
extrabits = show_bits(&alac>gb, k); 
228  
229 
block_size = (((1 << k)  1) & rice_kmodifier_mask) * x 
230 
+ extrabits  1;

231  
232 
if (extrabits < 2) { 
233 
x = 1  extrabits;

234 
block_size += x; 
235 
get_bits(&alac>gb, k  1);

236 
} else {

237 
get_bits(&alac>gb, k); 
238 
} 
239 
} 
240  
241 
if (block_size > 0) { 
242 
memset(&output_buffer[output_count+1], 0, block_size * 4); 
243 
output_count += block_size; 
244  
245 
} 
246  
247 
if (block_size > 0xffff) 
248 
sign_modifier = 0;

249  
250 
history = 0;

251 
} 
252 
} 
253 
} 
254  
255 
#define SIGN_EXTENDED32(val, bits) ((val << (32  bits)) >> (32  bits)) 
256  
257 
#define SIGN_ONLY(v) \

258 
((v < 0) ? (1) : \ 
259 
((v > 0) ? (1) : \ 
260 
(0)))

261  
262 
static void predictor_decompress_fir_adapt(int32_t *error_buffer, 
263 
int32_t *buffer_out, 
264 
int output_size,

265 
int readsamplesize,

266 
int16_t *predictor_coef_table, 
267 
int predictor_coef_num,

268 
int predictor_quantitization)

269 
{ 
270 
int i;

271  
272 
/* first sample always copies */

273 
*buffer_out = *error_buffer; 
274  
275 
if (!predictor_coef_num) {

276 
if (output_size <= 1) return; 
277 
memcpy(buffer_out+1, error_buffer+1, (output_size1) * 4); 
278 
return;

279 
} 
280  
281 
if (predictor_coef_num == 0x1f) { /* 11111  max value of predictor_coef_num */ 
282 
/* secondbest case scenario for fir decompression,

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

284 
*/

285 
if (output_size <= 1) return; 
286 
for (i = 0; i < output_size  1; i++) { 
287 
int32_t prev_value; 
288 
int32_t error_value; 
289  
290 
prev_value = buffer_out[i]; 
291 
error_value = error_buffer[i+1];

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

293 
} 
294 
return;

295 
} 
296  
297 
/* read warmup samples */

298 
if (predictor_coef_num > 0) { 
299 
int i;

300 
for (i = 0; i < predictor_coef_num; i++) { 
301 
int32_t val; 
302  
303 
val = buffer_out[i] + error_buffer[i+1];

304  
305 
val = SIGN_EXTENDED32(val, readsamplesize); 
306  
307 
buffer_out[i+1] = val;

308 
} 
309 
} 
310  
311 
#if 0

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

313 
* should be unrolled and optimised

314 
*/

315 
if (predictor_coef_num == 4) {

316 
/* FIXME: optimised general case */

317 
return;

318 
}

319 

320 
if (predictor_coef_table == 8) {

321 
/* FIXME: optimised general case */

322 
return;

323 
}

324 
#endif

325  
326  
327 
/* general case */

328 
if (predictor_coef_num > 0) { 
329 
for (i = predictor_coef_num + 1; 
330 
i < output_size; 
331 
i++) { 
332 
int j;

333 
int sum = 0; 
334 
int outval;

335 
int error_val = error_buffer[i];

336  
337 
for (j = 0; j < predictor_coef_num; j++) { 
338 
sum += (buffer_out[predictor_coef_numj]  buffer_out[0]) *

339 
predictor_coef_table[j]; 
340 
} 
341  
342 
outval = (1 << (predictor_quantitization1)) + sum; 
343 
outval = outval >> predictor_quantitization; 
344 
outval = outval + buffer_out[0] + error_val;

345 
outval = SIGN_EXTENDED32(outval, readsamplesize); 
346  
347 
buffer_out[predictor_coef_num+1] = outval;

348  
349 
if (error_val > 0) { 
350 
int predictor_num = predictor_coef_num  1; 
351  
352 
while (predictor_num >= 0 && error_val > 0) { 
353 
int val = buffer_out[0]  buffer_out[predictor_coef_num  predictor_num]; 
354 
int sign = SIGN_ONLY(val);

355  
356 
predictor_coef_table[predictor_num] = sign; 
357  
358 
val *= sign; /* absolute value */

359  
360 
error_val = ((val >> predictor_quantitization) * 
361 
(predictor_coef_num  predictor_num)); 
362  
363 
predictor_num; 
364 
} 
365 
} else if (error_val < 0) { 
366 
int predictor_num = predictor_coef_num  1; 
367  
368 
while (predictor_num >= 0 && error_val < 0) { 
369 
int val = buffer_out[0]  buffer_out[predictor_coef_num  predictor_num]; 
370 
int sign =  SIGN_ONLY(val);

371  
372 
predictor_coef_table[predictor_num] = sign; 
373  
374 
val *= sign; /* neg value */

375  
376 
error_val = ((val >> predictor_quantitization) * 
377 
(predictor_coef_num  predictor_num)); 
378  
379 
predictor_num; 
380 
} 
381 
} 
382  
383 
buffer_out++; 
384 
} 
385 
} 
386 
} 
387  
388 
void deinterlace_16(int32_t *buffer_a, int32_t *buffer_b,

389 
int16_t *buffer_out, 
390 
int numchannels, int numsamples, 
391 
uint8_t interlacing_shift, 
392 
uint8_t interlacing_leftweight) 
393 
{ 
394 
int i;

395 
if (numsamples <= 0) return; 
396  
397 
/* weighted interlacing */

398 
if (interlacing_leftweight) {

399 
for (i = 0; i < numsamples; i++) { 
400 
int32_t difference, midright; 
401 
int16_t left; 
402 
int16_t right; 
403  
404 
midright = buffer_a[i]; 
405 
difference = buffer_b[i]; 
406  
407  
408 
right = midright  ((difference * interlacing_leftweight) >> interlacing_shift); 
409 
left = (midright  ((difference * interlacing_leftweight) >> interlacing_shift)) 
410 
+ difference; 
411  
412 
buffer_out[i*numchannels] = left; 
413 
buffer_out[i*numchannels + 1] = right;

414 
} 
415  
416 
return;

417 
} 
418  
419 
/* otherwise basic interlacing took place */

420 
for (i = 0; i < numsamples; i++) { 
421 
int16_t left, right; 
422  
423 
left = buffer_a[i]; 
424 
right = buffer_b[i]; 
425  
426 
buffer_out[i*numchannels] = left; 
427 
buffer_out[i*numchannels + 1] = right;

428 
} 
429 
} 
430  
431 
static int alac_decode_frame(AVCodecContext *avctx, 
432 
void *outbuffer, int *outputsize, 
433 
uint8_t *inbuffer, int input_buffer_size)

434 
{ 
435 
ALACContext *alac = avctx>priv_data; 
436  
437 
int channels;

438 
int32_t outputsamples; 
439  
440 
/* shortcircuit null buffers */

441 
if (!inbuffer  !input_buffer_size)

442 
return input_buffer_size;

443  
444 
/* initialize from the extradata */

445 
if (!alac>context_initialized) {

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

447 
av_log(NULL, AV_LOG_ERROR, "alac: expected %d extradata bytes\n", 
448 
ALAC_EXTRADATA_SIZE); 
449 
return input_buffer_size;

450 
} 
451 
alac_set_info(alac); 
452 
alac>context_initialized = 1;

453 
} 
454  
455 
outputsamples = alac>setinfo_max_samples_per_frame; 
456  
457 
init_get_bits(&alac>gb, inbuffer, input_buffer_size * 8);

458  
459 
channels = get_bits(&alac>gb, 3);

460  
461 
*outputsize = outputsamples * alac>bytespersample; 
462  
463 
switch(channels) {

464 
case 0: { /* 1 channel */ 
465 
int hassize;

466 
int isnotcompressed;

467 
int readsamplesize;

468  
469 
int wasted_bytes;

470 
int ricemodifier;

471  
472  
473 
/* 2^result = something to do with output waiting.

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

475 
*/

476 
get_bits(&alac>gb, 4);

477  
478 
get_bits(&alac>gb, 12); /* unknown, skip 12 bits */ 
479  
480 
hassize = get_bits(&alac>gb, 1); /* the output sample size is stored soon */ 
481  
482 
wasted_bytes = get_bits(&alac>gb, 2); /* unknown ? */ 
483  
484 
isnotcompressed = get_bits(&alac>gb, 1); /* whether the frame is compressed */ 
485  
486 
if (hassize) {

487 
/* now read the number of samples,

488 
* as a 32bit integer */

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

490 
*outputsize = outputsamples * alac>bytespersample; 
491 
} 
492  
493 
readsamplesize = alac>setinfo_sample_size  (wasted_bytes * 8);

494  
495 
if (!isnotcompressed) {

496 
/* so it is compressed */

497 
int16_t predictor_coef_table[32];

498 
int predictor_coef_num;

499 
int prediction_type;

500 
int prediction_quantitization;

501 
int i;

502  
503 
/* skip 16 bits, not sure what they are. seem to be used in

504 
* two channel case */

505 
get_bits(&alac>gb, 8);

506 
get_bits(&alac>gb, 8);

507  
508 
prediction_type = get_bits(&alac>gb, 4);

509 
prediction_quantitization = get_bits(&alac>gb, 4);

510  
511 
ricemodifier = get_bits(&alac>gb, 3);

512 
predictor_coef_num = get_bits(&alac>gb, 5);

513  
514 
/* read the predictor table */

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

517 
} 
518  
519 
if (wasted_bytes) {

520 
/* these bytes seem to have something to do with

521 
* > 2 channel files.

522 
*/

523 
av_log(NULL, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of wasted_bytes\n"); 
524 
} 
525  
526 
bastardized_rice_decompress(alac, 
527 
alac>predicterror_buffer_a, 
528 
outputsamples, 
529 
readsamplesize, 
530 
alac>setinfo_rice_initialhistory, 
531 
alac>setinfo_rice_kmodifier, 
532 
ricemodifier * alac>setinfo_rice_historymult / 4,

533 
(1 << alac>setinfo_rice_kmodifier)  1); 
534  
535 
if (prediction_type == 0) { 
536 
/* adaptive fir */

537 
predictor_decompress_fir_adapt(alac>predicterror_buffer_a, 
538 
alac>outputsamples_buffer_a, 
539 
outputsamples, 
540 
readsamplesize, 
541 
predictor_coef_table, 
542 
predictor_coef_num, 
543 
prediction_quantitization); 
544 
} else {

545 
av_log(NULL, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type); 
546 
/* i think the only other prediction type (or perhaps this is just a

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

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

549 
* predictor_decompress_fir_adapt(predictor_error, outputsamples ...)

550 
* little strange..

551 
*/

552 
} 
553  
554 
} else {

555 
/* not compressed, easy case */

556 
if (readsamplesize <= 16) { 
557 
int i;

558 
for (i = 0; i < outputsamples; i++) { 
559 
int32_t audiobits = get_bits(&alac>gb, readsamplesize); 
560  
561 
audiobits = SIGN_EXTENDED32(audiobits, readsamplesize); 
562  
563 
alac>outputsamples_buffer_a[i] = audiobits; 
564 
} 
565 
} else {

566 
int i;

567 
for (i = 0; i < outputsamples; i++) { 
568 
int32_t audiobits; 
569  
570 
audiobits = get_bits(&alac>gb, 16);

571 
/* special case of sign extension..

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

573 
audiobits = audiobits << 16;

574 
audiobits = audiobits >> (32  readsamplesize);

575  
576 
audiobits = get_bits(&alac>gb, readsamplesize  16);

577  
578 
alac>outputsamples_buffer_a[i] = audiobits; 
579 
} 
580 
} 
581 
/* wasted_bytes = 0; // unused */

582 
} 
583  
584 
switch(alac>setinfo_sample_size) {

585 
case 16: { 
586 
int i;

587 
for (i = 0; i < outputsamples; i++) { 
588 
int16_t sample = alac>outputsamples_buffer_a[i]; 
589 
sample = be2me_16(sample); 
590 
((int16_t*)outbuffer)[i * alac>numchannels] = sample; 
591 
} 
592 
break;

593 
} 
594 
case 20: 
595 
case 24: 
596 
case 32: 
597 
av_log(NULL, AV_LOG_ERROR, "FIXME: unimplemented sample size %i\n", alac>setinfo_sample_size); 
598 
break;

599 
default:

600 
break;

601 
} 
602 
break;

603 
} 
604 
case 1: { /* 2 channels */ 
605 
int hassize;

606 
int isnotcompressed;

607 
int readsamplesize;

608  
609 
int wasted_bytes;

610  
611 
uint8_t interlacing_shift; 
612 
uint8_t interlacing_leftweight; 
613  
614 
/* 2^result = something to do with output waiting.

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

616 
*/

617 
get_bits(&alac>gb, 4);

618  
619 
get_bits(&alac>gb, 12); /* unknown, skip 12 bits */ 
620  
621 
hassize = get_bits(&alac>gb, 1); /* the output sample size is stored soon */ 
622  
623 
wasted_bytes = get_bits(&alac>gb, 2); /* unknown ? */ 
624  
625 
isnotcompressed = get_bits(&alac>gb, 1); /* whether the frame is compressed */ 
626  
627 
if (hassize) {

628 
/* now read the number of samples,

629 
* as a 32bit integer */

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

631 
*outputsize = outputsamples * alac>bytespersample; 
632 
} 
633  
634 
readsamplesize = alac>setinfo_sample_size  (wasted_bytes * 8) + 1; 
635  
636 
if (!isnotcompressed) {

637 
/* compressed */

638 
int16_t predictor_coef_table_a[32];

639 
int predictor_coef_num_a;

640 
int prediction_type_a;

641 
int prediction_quantitization_a;

642 
int ricemodifier_a;

643  
644 
int16_t predictor_coef_table_b[32];

645 
int predictor_coef_num_b;

646 
int prediction_type_b;

647 
int prediction_quantitization_b;

648 
int ricemodifier_b;

649  
650 
int i;

651  
652 
interlacing_shift = get_bits(&alac>gb, 8);

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

654  
655 
/******** channel 1 ***********/

656 
prediction_type_a = get_bits(&alac>gb, 4);

657 
prediction_quantitization_a = get_bits(&alac>gb, 4);

658  
659 
ricemodifier_a = get_bits(&alac>gb, 3);

660 
predictor_coef_num_a = get_bits(&alac>gb, 5);

661  
662 
/* read the predictor table */

663 
for (i = 0; i < predictor_coef_num_a; i++) { 
664 
predictor_coef_table_a[i] = (int16_t)get_bits(&alac>gb, 16);

665 
} 
666  
667 
/******** channel 2 *********/

668 
prediction_type_b = get_bits(&alac>gb, 4);

669 
prediction_quantitization_b = get_bits(&alac>gb, 4);

670  
671 
ricemodifier_b = get_bits(&alac>gb, 3);

672 
predictor_coef_num_b = get_bits(&alac>gb, 5);

673  
674 
/* read the predictor table */

675 
for (i = 0; i < predictor_coef_num_b; i++) { 
676 
predictor_coef_table_b[i] = (int16_t)get_bits(&alac>gb, 16);

677 
} 
678  
679 
/*********************/

680 
if (wasted_bytes) {

681 
/* see mono case */

682 
av_log(NULL, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of wasted_bytes\n"); 
683 
} 
684  
685 
/* channel 1 */

686 
bastardized_rice_decompress(alac, 
687 
alac>predicterror_buffer_a, 
688 
outputsamples, 
689 
readsamplesize, 
690 
alac>setinfo_rice_initialhistory, 
691 
alac>setinfo_rice_kmodifier, 
692 
ricemodifier_a * alac>setinfo_rice_historymult / 4,

693 
(1 << alac>setinfo_rice_kmodifier)  1); 
694  
695 
if (prediction_type_a == 0) { 
696 
/* adaptive fir */

697 
predictor_decompress_fir_adapt(alac>predicterror_buffer_a, 
698 
alac>outputsamples_buffer_a, 
699 
outputsamples, 
700 
readsamplesize, 
701 
predictor_coef_table_a, 
702 
predictor_coef_num_a, 
703 
prediction_quantitization_a); 
704 
} else {

705 
/* see mono case */

706 
av_log(NULL, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type_a); 
707 
} 
708  
709 
/* channel 2 */

710 
bastardized_rice_decompress(alac, 
711 
alac>predicterror_buffer_b, 
712 
outputsamples, 
713 
readsamplesize, 
714 
alac>setinfo_rice_initialhistory, 
715 
alac>setinfo_rice_kmodifier, 
716 
ricemodifier_b * alac>setinfo_rice_historymult / 4,

717 
(1 << alac>setinfo_rice_kmodifier)  1); 
718  
719 
if (prediction_type_b == 0) { 
720 
/* adaptive fir */

721 
predictor_decompress_fir_adapt(alac>predicterror_buffer_b, 
722 
alac>outputsamples_buffer_b, 
723 
outputsamples, 
724 
readsamplesize, 
725 
predictor_coef_table_b, 
726 
predictor_coef_num_b, 
727 
prediction_quantitization_b); 
728 
} else {

729 
av_log(NULL, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type_b); 
730 
} 
731 
} else {

732 
/* not compressed, easy case */

733 
if (alac>setinfo_sample_size <= 16) { 
734 
int i;

735 
for (i = 0; i < outputsamples; i++) { 
736 
int32_t audiobits_a, audiobits_b; 
737  
738 
audiobits_a = get_bits(&alac>gb, alac>setinfo_sample_size); 
739 
audiobits_b = get_bits(&alac>gb, alac>setinfo_sample_size); 
740  
741 
audiobits_a = SIGN_EXTENDED32(audiobits_a, alac>setinfo_sample_size); 
742 
audiobits_b = SIGN_EXTENDED32(audiobits_b, alac>setinfo_sample_size); 
743  
744 
alac>outputsamples_buffer_a[i] = audiobits_a; 
745 
alac>outputsamples_buffer_b[i] = audiobits_b; 
746 
} 
747 
} else {

748 
int i;

749 
for (i = 0; i < outputsamples; i++) { 
750 
int32_t audiobits_a, audiobits_b; 
751  
752 
audiobits_a = get_bits(&alac>gb, 16);

753 
audiobits_a = audiobits_a << 16;

754 
audiobits_a = audiobits_a >> (32  alac>setinfo_sample_size);

755 
audiobits_a = get_bits(&alac>gb, alac>setinfo_sample_size  16);

756  
757 
audiobits_b = get_bits(&alac>gb, 16);

758 
audiobits_b = audiobits_b << 16;

759 
audiobits_b = audiobits_b >> (32  alac>setinfo_sample_size);

760 
audiobits_b = get_bits(&alac>gb, alac>setinfo_sample_size  16);

761  
762 
alac>outputsamples_buffer_a[i] = audiobits_a; 
763 
alac>outputsamples_buffer_b[i] = audiobits_b; 
764 
} 
765 
} 
766 
/* wasted_bytes = 0; */

767 
interlacing_shift = 0;

768 
interlacing_leftweight = 0;

769 
} 
770  
771 
switch(alac>setinfo_sample_size) {

772 
case 16: { 
773 
deinterlace_16(alac>outputsamples_buffer_a, 
774 
alac>outputsamples_buffer_b, 
775 
(int16_t*)outbuffer, 
776 
alac>numchannels, 
777 
outputsamples, 
778 
interlacing_shift, 
779 
interlacing_leftweight); 
780 
break;

781 
} 
782 
case 20: 
783 
case 24: 
784 
case 32: 
785 
av_log(NULL, AV_LOG_ERROR, "FIXME: unimplemented sample size %i\n", alac>setinfo_sample_size); 
786 
break;

787 
default:

788 
break;

789 
} 
790  
791 
break;

792 
} 
793 
} 
794  
795 
return input_buffer_size;

796 
} 
797  
798 
static int alac_decode_init(AVCodecContext * avctx) 
799 
{ 
800 
ALACContext *alac = avctx>priv_data; 
801 
alac>avctx = avctx; 
802 
alac>context_initialized = 0;

803  
804 
alac>samplesize = alac>avctx>bits_per_sample; 
805 
alac>numchannels = alac>avctx>channels; 
806 
alac>bytespersample = (alac>samplesize / 8) * alac>numchannels;

807  
808 
return 0; 
809 
} 
810  
811 
static int alac_decode_close(AVCodecContext *avctx) 
812 
{ 
813 
ALACContext *alac = avctx>priv_data; 
814  
815 
av_free(alac>predicterror_buffer_a); 
816 
av_free(alac>predicterror_buffer_b); 
817  
818 
av_free(alac>outputsamples_buffer_a); 
819 
av_free(alac>outputsamples_buffer_b); 
820  
821 
return 0; 
822 
} 
823  
824 
AVCodec alac_decoder = { 
825 
"alac",

826 
CODEC_TYPE_AUDIO, 
827 
CODEC_ID_ALAC, 
828 
sizeof(ALACContext),

829 
alac_decode_init, 
830 
NULL,

831 
alac_decode_close, 
832 
alac_decode_frame, 
833 
}; 