Mercurial > libavcodec.hg
comparison alac.c @ 2559:7d8ba28e18d9 libavcodec
replace custom bit-reading functions with FFmpeg's internal function;
roll alac_file data structure members into ALACContext
author | melanson |
---|---|
date | Thu, 10 Mar 2005 05:34:10 +0000 |
parents | 621cc4a94695 |
children | 67ea9a5a8fff |
comparison
equal
deleted
inserted
replaced
2558:2b01396ab483 | 2559:7d8ba28e18d9 |
---|---|
34 * bytes 8-35 data bytes needed by decoder | 34 * bytes 8-35 data bytes needed by decoder |
35 */ | 35 */ |
36 | 36 |
37 | 37 |
38 #include "avcodec.h" | 38 #include "avcodec.h" |
39 #include "bitstream.h" | |
39 | 40 |
40 #define ALAC_EXTRADATA_SIZE 36 | 41 #define ALAC_EXTRADATA_SIZE 36 |
41 | 42 |
42 struct alac_file { | 43 typedef struct { |
43 unsigned char *input_buffer; | 44 |
44 int input_buffer_index; | 45 AVCodecContext *avctx; |
45 int input_buffer_size; | 46 GetBitContext gb; |
46 int input_buffer_bitaccumulator; /* used so we can do arbitary | 47 /* init to 0; first frame decode should initialize from extradata and |
47 bit reads */ | 48 * set this to 1 */ |
49 int context_initialized; | |
48 | 50 |
49 int samplesize; | 51 int samplesize; |
50 int numchannels; | 52 int numchannels; |
51 int bytespersample; | 53 int bytespersample; |
52 | 54 |
53 | |
54 /* buffers */ | 55 /* buffers */ |
55 int32_t *predicterror_buffer_a; | 56 int32_t *predicterror_buffer_a; |
56 int32_t *predicterror_buffer_b; | 57 int32_t *predicterror_buffer_b; |
57 | 58 |
58 int32_t *outputsamples_buffer_a; | 59 int32_t *outputsamples_buffer_a; |
59 int32_t *outputsamples_buffer_b; | 60 int32_t *outputsamples_buffer_b; |
60 | |
61 | 61 |
62 /* stuff from setinfo */ | 62 /* stuff from setinfo */ |
63 uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */ /* max samples per frame? */ | 63 uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */ /* max samples per frame? */ |
64 uint8_t setinfo_7a; /* 0x00 */ | 64 uint8_t setinfo_7a; /* 0x00 */ |
65 uint8_t setinfo_sample_size; /* 0x10 */ | 65 uint8_t setinfo_sample_size; /* 0x10 */ |
70 uint16_t setinfo_80; /* 0x00ff */ | 70 uint16_t setinfo_80; /* 0x00ff */ |
71 uint32_t setinfo_82; /* 0x000020e7 */ | 71 uint32_t setinfo_82; /* 0x000020e7 */ |
72 uint32_t setinfo_86; /* 0x00069fe4 */ | 72 uint32_t setinfo_86; /* 0x00069fe4 */ |
73 uint32_t setinfo_8a_rate; /* 0x0000ac44 */ | 73 uint32_t setinfo_8a_rate; /* 0x0000ac44 */ |
74 /* end setinfo stuff */ | 74 /* end setinfo stuff */ |
75 }; | 75 |
76 | |
77 typedef struct alac_file alac_file; | |
78 | |
79 typedef struct { | |
80 | |
81 AVCodecContext *avctx; | |
82 /* init to 0; first frame decode should initialize from extradata and | |
83 * set this to 1 */ | |
84 int context_initialized; | |
85 | |
86 alac_file *alac; | |
87 } ALACContext; | 76 } ALACContext; |
88 | 77 |
89 static void allocate_buffers(alac_file *alac) | 78 static void allocate_buffers(ALACContext *alac) |
90 { | 79 { |
91 alac->predicterror_buffer_a = av_malloc(alac->setinfo_max_samples_per_frame * 4); | 80 alac->predicterror_buffer_a = av_malloc(alac->setinfo_max_samples_per_frame * 4); |
92 alac->predicterror_buffer_b = av_malloc(alac->setinfo_max_samples_per_frame * 4); | 81 alac->predicterror_buffer_b = av_malloc(alac->setinfo_max_samples_per_frame * 4); |
93 | 82 |
94 alac->outputsamples_buffer_a = av_malloc(alac->setinfo_max_samples_per_frame * 4); | 83 alac->outputsamples_buffer_a = av_malloc(alac->setinfo_max_samples_per_frame * 4); |
95 alac->outputsamples_buffer_b = av_malloc(alac->setinfo_max_samples_per_frame * 4); | 84 alac->outputsamples_buffer_b = av_malloc(alac->setinfo_max_samples_per_frame * 4); |
96 } | 85 } |
97 | 86 |
98 void alac_set_info(alac_file *alac, char *inputbuffer) | 87 void alac_set_info(ALACContext *alac) |
99 { | 88 { |
100 unsigned char *ptr = inputbuffer; | 89 unsigned char *ptr = alac->avctx->extradata; |
101 | 90 |
102 ptr += 4; /* size */ | 91 ptr += 4; /* size */ |
103 ptr += 4; /* alac */ | 92 ptr += 4; /* alac */ |
104 ptr += 4; /* 0 ? */ | 93 ptr += 4; /* 0 ? */ |
105 | 94 |
121 ptr += 4; | 110 ptr += 4; |
122 | 111 |
123 allocate_buffers(alac); | 112 allocate_buffers(alac); |
124 } | 113 } |
125 | 114 |
126 /* stream reading */ | |
127 | |
128 /* supports reading 1 to 16 bits, in big endian format */ | |
129 static uint32_t readbits_16(alac_file *alac, int bits) | |
130 { | |
131 uint32_t result; | |
132 int new_accumulator; | |
133 | |
134 if (alac->input_buffer_index + 2 >= alac->input_buffer_size) { | |
135 av_log(NULL, AV_LOG_ERROR, "alac: input buffer went out of bounds (%d >= %d)\n", | |
136 alac->input_buffer_index + 2, alac->input_buffer_size); | |
137 } | |
138 result = (alac->input_buffer[alac->input_buffer_index + 0] << 16) | | |
139 (alac->input_buffer[alac->input_buffer_index + 1] << 8) | | |
140 (alac->input_buffer[alac->input_buffer_index + 2]); | |
141 | |
142 /* shift left by the number of bits we've already read, | |
143 * so that the top 'n' bits of the 24 bits we read will | |
144 * be the return bits */ | |
145 result = result << alac->input_buffer_bitaccumulator; | |
146 | |
147 result = result & 0x00ffffff; | |
148 | |
149 /* and then only want the top 'n' bits from that, where | |
150 * n is 'bits' */ | |
151 result = result >> (24 - bits); | |
152 | |
153 new_accumulator = (alac->input_buffer_bitaccumulator + bits); | |
154 | |
155 /* increase the buffer pointer if we've read over n bytes. */ | |
156 alac->input_buffer_index += (new_accumulator >> 3); | |
157 | |
158 /* and the remainder goes back into the bit accumulator */ | |
159 alac->input_buffer_bitaccumulator = (new_accumulator & 7); | |
160 | |
161 return result; | |
162 } | |
163 | |
164 /* supports reading 1 to 32 bits, in big endian format */ | |
165 static uint32_t readbits(alac_file *alac, int bits) | |
166 { | |
167 int32_t result = 0; | |
168 | |
169 if (bits > 16) { | |
170 bits -= 16; | |
171 result = readbits_16(alac, 16) << bits; | |
172 } | |
173 | |
174 result |= readbits_16(alac, bits); | |
175 | |
176 return result; | |
177 } | |
178 | |
179 /* reads a single bit */ | |
180 static int readbit(alac_file *alac) | |
181 { | |
182 int result; | |
183 int new_accumulator; | |
184 | |
185 if (alac->input_buffer_index >= alac->input_buffer_size) { | |
186 av_log(NULL, AV_LOG_ERROR, "alac: input buffer went out of bounds (%d >= %d)\n", | |
187 alac->input_buffer_index + 2, alac->input_buffer_size); | |
188 } | |
189 | |
190 result = alac->input_buffer[alac->input_buffer_index]; | |
191 | |
192 result = result << alac->input_buffer_bitaccumulator; | |
193 | |
194 result = result >> 7 & 1; | |
195 | |
196 new_accumulator = (alac->input_buffer_bitaccumulator + 1); | |
197 | |
198 alac->input_buffer_index += (new_accumulator / 8); | |
199 | |
200 alac->input_buffer_bitaccumulator = (new_accumulator % 8); | |
201 | |
202 return result; | |
203 } | |
204 | |
205 static void unreadbits(alac_file *alac, int bits) | |
206 { | |
207 int new_accumulator = (alac->input_buffer_bitaccumulator - bits); | |
208 | |
209 alac->input_buffer_index += (new_accumulator >> 3); | |
210 | |
211 alac->input_buffer_bitaccumulator = (new_accumulator & 7); | |
212 if (alac->input_buffer_bitaccumulator < 0) | |
213 alac->input_buffer_bitaccumulator *= -1; | |
214 } | |
215 | |
216 /* hideously inefficient. could use a bitmask search, | 115 /* hideously inefficient. could use a bitmask search, |
217 * alternatively bsr on x86, | 116 * alternatively bsr on x86, |
218 */ | 117 */ |
219 static int count_leading_zeros(int32_t input) | 118 static int count_leading_zeros(int32_t input) |
220 { | 119 { |
224 input = input << 1; | 123 input = input << 1; |
225 } | 124 } |
226 return i; | 125 return i; |
227 } | 126 } |
228 | 127 |
229 void bastardized_rice_decompress(alac_file *alac, | 128 void bastardized_rice_decompress(ALACContext *alac, |
230 int32_t *output_buffer, | 129 int32_t *output_buffer, |
231 int output_size, | 130 int output_size, |
232 int readsamplesize, /* arg_10 */ | 131 int readsamplesize, /* arg_10 */ |
233 int rice_initialhistory, /* arg424->b */ | 132 int rice_initialhistory, /* arg424->b */ |
234 int rice_kmodifier, /* arg424->d */ | 133 int rice_kmodifier, /* arg424->d */ |
244 int32_t x = 0; | 143 int32_t x = 0; |
245 int32_t x_modified; | 144 int32_t x_modified; |
246 int32_t final_val; | 145 int32_t final_val; |
247 | 146 |
248 /* read x - number of 1s before 0 represent the rice */ | 147 /* read x - number of 1s before 0 represent the rice */ |
249 while (x <= 8 && readbit(alac)) { | 148 while (x <= 8 && get_bits1(&alac->gb)) { |
250 x++; | 149 x++; |
251 } | 150 } |
252 | 151 |
253 | 152 |
254 if (x > 8) { /* RICE THRESHOLD */ | 153 if (x > 8) { /* RICE THRESHOLD */ |
255 /* use alternative encoding */ | 154 /* use alternative encoding */ |
256 int32_t value; | 155 int32_t value; |
257 | 156 |
258 value = readbits(alac, readsamplesize); | 157 value = get_bits(&alac->gb, readsamplesize); |
259 | 158 |
260 /* mask value to readsamplesize size */ | 159 /* mask value to readsamplesize size */ |
261 if (readsamplesize != 32) | 160 if (readsamplesize != 32) |
262 value &= (0xffffffff >> (32 - readsamplesize)); | 161 value &= (0xffffffff >> (32 - readsamplesize)); |
263 | 162 |
274 k += rice_kmodifier; | 173 k += rice_kmodifier; |
275 else | 174 else |
276 k = rice_kmodifier; | 175 k = rice_kmodifier; |
277 | 176 |
278 if (k != 1) { | 177 if (k != 1) { |
279 extrabits = readbits(alac, k); | 178 extrabits = show_bits(&alac->gb, k); |
280 | 179 |
281 /* multiply x by 2^k - 1, as part of their strange algorithm */ | 180 /* multiply x by 2^k - 1, as part of their strange algorithm */ |
282 x = (x << k) - x; | 181 x = (x << k) - x; |
283 | 182 |
284 if (extrabits > 1) { | 183 if (extrabits > 1) { |
285 x += extrabits - 1; | 184 x += extrabits - 1; |
286 } else | 185 get_bits(&alac->gb, k); |
287 unreadbits(alac, 1); | 186 } else { |
187 get_bits(&alac->gb, k - 1); | |
188 } | |
288 } | 189 } |
289 } | 190 } |
290 | 191 |
291 x_modified = sign_modifier + x; | 192 x_modified = sign_modifier + x; |
292 final_val = (x_modified + 1) / 2; | 193 final_val = (x_modified + 1) / 2; |
308 int block_size; | 209 int block_size; |
309 | 210 |
310 sign_modifier = 1; | 211 sign_modifier = 1; |
311 | 212 |
312 x = 0; | 213 x = 0; |
313 while (x <= 8 && readbit(alac)) { | 214 while (x <= 8 && get_bits1(&alac->gb)) { |
314 x++; | 215 x++; |
315 } | 216 } |
316 | 217 |
317 if (x > 8) { | 218 if (x > 8) { |
318 block_size = readbits(alac, 16); | 219 block_size = get_bits(&alac->gb, 16); |
319 block_size &= 0xffff; | 220 block_size &= 0xffff; |
320 } else { | 221 } else { |
321 int k; | 222 int k; |
322 int extrabits; | 223 int extrabits; |
323 | 224 |
324 k = count_leading_zeros(history) + ((history + 16) >> 6 /* / 64 */) - 24; | 225 k = count_leading_zeros(history) + ((history + 16) >> 6 /* / 64 */) - 24; |
325 | 226 |
326 extrabits = readbits(alac, k); | 227 extrabits = show_bits(&alac->gb, k); |
327 | 228 |
328 block_size = (((1 << k) - 1) & rice_kmodifier_mask) * x | 229 block_size = (((1 << k) - 1) & rice_kmodifier_mask) * x |
329 + extrabits - 1; | 230 + extrabits - 1; |
330 | 231 |
331 if (extrabits < 2) { | 232 if (extrabits < 2) { |
332 x = 1 - extrabits; | 233 x = 1 - extrabits; |
333 block_size += x; | 234 block_size += x; |
334 unreadbits(alac, 1); | 235 get_bits(&alac->gb, k - 1); |
236 } else { | |
237 get_bits(&alac->gb, k); | |
335 } | 238 } |
336 } | 239 } |
337 | 240 |
338 if (block_size > 0) { | 241 if (block_size > 0) { |
339 memset(&output_buffer[output_count+1], 0, block_size * 4); | 242 memset(&output_buffer[output_count+1], 0, block_size * 4); |
527 | 430 |
528 static int alac_decode_frame(AVCodecContext *avctx, | 431 static int alac_decode_frame(AVCodecContext *avctx, |
529 void *outbuffer, int *outputsize, | 432 void *outbuffer, int *outputsize, |
530 uint8_t *inbuffer, int input_buffer_size) | 433 uint8_t *inbuffer, int input_buffer_size) |
531 { | 434 { |
532 ALACContext *s = avctx->priv_data; | 435 ALACContext *alac = avctx->priv_data; |
533 alac_file *alac = s->alac; | |
534 | 436 |
535 int channels; | 437 int channels; |
536 int32_t outputsamples; | 438 int32_t outputsamples; |
537 | 439 |
538 /* short-circuit null buffers */ | 440 /* short-circuit null buffers */ |
539 if (!inbuffer || !input_buffer_size) | 441 if (!inbuffer || !input_buffer_size) |
540 return input_buffer_size; | 442 return input_buffer_size; |
541 | 443 |
542 /* initialize from the extradata */ | 444 /* initialize from the extradata */ |
543 if (!s->context_initialized) { | 445 if (!alac->context_initialized) { |
544 if (s->avctx->extradata_size != ALAC_EXTRADATA_SIZE) { | 446 if (alac->avctx->extradata_size != ALAC_EXTRADATA_SIZE) { |
545 av_log(NULL, AV_LOG_ERROR, "alac: expected %d extradata bytes\n", | 447 av_log(NULL, AV_LOG_ERROR, "alac: expected %d extradata bytes\n", |
546 ALAC_EXTRADATA_SIZE); | 448 ALAC_EXTRADATA_SIZE); |
547 return input_buffer_size; | 449 return input_buffer_size; |
548 } | 450 } |
549 alac_set_info(s->alac, s->avctx->extradata); | 451 alac_set_info(alac); |
550 s->context_initialized = 1; | 452 alac->context_initialized = 1; |
551 } | 453 } |
552 | 454 |
553 outputsamples = alac->setinfo_max_samples_per_frame; | 455 outputsamples = alac->setinfo_max_samples_per_frame; |
554 | 456 |
555 /* setup the stream */ | 457 init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8); |
556 alac->input_buffer = inbuffer; | 458 |
557 alac->input_buffer_index = 0; | 459 channels = get_bits(&alac->gb, 3); |
558 alac->input_buffer_size = input_buffer_size; | |
559 alac->input_buffer_bitaccumulator = 0; | |
560 | |
561 channels = readbits(alac, 3); | |
562 | 460 |
563 *outputsize = outputsamples * alac->bytespersample; | 461 *outputsize = outputsamples * alac->bytespersample; |
564 | 462 |
565 switch(channels) { | 463 switch(channels) { |
566 case 0: { /* 1 channel */ | 464 case 0: { /* 1 channel */ |
573 | 471 |
574 | 472 |
575 /* 2^result = something to do with output waiting. | 473 /* 2^result = something to do with output waiting. |
576 * perhaps matters if we read > 1 frame in a pass? | 474 * perhaps matters if we read > 1 frame in a pass? |
577 */ | 475 */ |
578 readbits(alac, 4); | 476 get_bits(&alac->gb, 4); |
579 | 477 |
580 readbits(alac, 12); /* unknown, skip 12 bits */ | 478 get_bits(&alac->gb, 12); /* unknown, skip 12 bits */ |
581 | 479 |
582 hassize = readbits(alac, 1); /* the output sample size is stored soon */ | 480 hassize = get_bits(&alac->gb, 1); /* the output sample size is stored soon */ |
583 | 481 |
584 wasted_bytes = readbits(alac, 2); /* unknown ? */ | 482 wasted_bytes = get_bits(&alac->gb, 2); /* unknown ? */ |
585 | 483 |
586 isnotcompressed = readbits(alac, 1); /* whether the frame is compressed */ | 484 isnotcompressed = get_bits(&alac->gb, 1); /* whether the frame is compressed */ |
587 | 485 |
588 if (hassize) { | 486 if (hassize) { |
589 /* now read the number of samples, | 487 /* now read the number of samples, |
590 * as a 32bit integer */ | 488 * as a 32bit integer */ |
591 outputsamples = readbits(alac, 32); | 489 outputsamples = get_bits(&alac->gb, 32); |
592 *outputsize = outputsamples * alac->bytespersample; | 490 *outputsize = outputsamples * alac->bytespersample; |
593 } | 491 } |
594 | 492 |
595 readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8); | 493 readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8); |
596 | 494 |
602 int prediction_quantitization; | 500 int prediction_quantitization; |
603 int i; | 501 int i; |
604 | 502 |
605 /* skip 16 bits, not sure what they are. seem to be used in | 503 /* skip 16 bits, not sure what they are. seem to be used in |
606 * two channel case */ | 504 * two channel case */ |
607 readbits(alac, 8); | 505 get_bits(&alac->gb, 8); |
608 readbits(alac, 8); | 506 get_bits(&alac->gb, 8); |
609 | 507 |
610 prediction_type = readbits(alac, 4); | 508 prediction_type = get_bits(&alac->gb, 4); |
611 prediction_quantitization = readbits(alac, 4); | 509 prediction_quantitization = get_bits(&alac->gb, 4); |
612 | 510 |
613 ricemodifier = readbits(alac, 3); | 511 ricemodifier = get_bits(&alac->gb, 3); |
614 predictor_coef_num = readbits(alac, 5); | 512 predictor_coef_num = get_bits(&alac->gb, 5); |
615 | 513 |
616 /* read the predictor table */ | 514 /* read the predictor table */ |
617 for (i = 0; i < predictor_coef_num; i++) { | 515 for (i = 0; i < predictor_coef_num; i++) { |
618 predictor_coef_table[i] = (int16_t)readbits(alac, 16); | 516 predictor_coef_table[i] = (int16_t)get_bits(&alac->gb, 16); |
619 } | 517 } |
620 | 518 |
621 if (wasted_bytes) { | 519 if (wasted_bytes) { |
622 /* these bytes seem to have something to do with | 520 /* these bytes seem to have something to do with |
623 * > 2 channel files. | 521 * > 2 channel files. |
656 } else { | 554 } else { |
657 /* not compressed, easy case */ | 555 /* not compressed, easy case */ |
658 if (readsamplesize <= 16) { | 556 if (readsamplesize <= 16) { |
659 int i; | 557 int i; |
660 for (i = 0; i < outputsamples; i++) { | 558 for (i = 0; i < outputsamples; i++) { |
661 int32_t audiobits = readbits(alac, readsamplesize); | 559 int32_t audiobits = get_bits(&alac->gb, readsamplesize); |
662 | 560 |
663 audiobits = SIGN_EXTENDED32(audiobits, readsamplesize); | 561 audiobits = SIGN_EXTENDED32(audiobits, readsamplesize); |
664 | 562 |
665 alac->outputsamples_buffer_a[i] = audiobits; | 563 alac->outputsamples_buffer_a[i] = audiobits; |
666 } | 564 } |
667 } else { | 565 } else { |
668 int i; | 566 int i; |
669 for (i = 0; i < outputsamples; i++) { | 567 for (i = 0; i < outputsamples; i++) { |
670 int32_t audiobits; | 568 int32_t audiobits; |
671 | 569 |
672 audiobits = readbits(alac, 16); | 570 audiobits = get_bits(&alac->gb, 16); |
673 /* special case of sign extension.. | 571 /* special case of sign extension.. |
674 * as we'll be ORing the low 16bits into this */ | 572 * as we'll be ORing the low 16bits into this */ |
675 audiobits = audiobits << 16; | 573 audiobits = audiobits << 16; |
676 audiobits = audiobits >> (32 - readsamplesize); | 574 audiobits = audiobits >> (32 - readsamplesize); |
677 | 575 |
678 audiobits |= readbits(alac, readsamplesize - 16); | 576 audiobits |= get_bits(&alac->gb, readsamplesize - 16); |
679 | 577 |
680 alac->outputsamples_buffer_a[i] = audiobits; | 578 alac->outputsamples_buffer_a[i] = audiobits; |
681 } | 579 } |
682 } | 580 } |
683 /* wasted_bytes = 0; // unused */ | 581 /* wasted_bytes = 0; // unused */ |
714 uint8_t interlacing_leftweight; | 612 uint8_t interlacing_leftweight; |
715 | 613 |
716 /* 2^result = something to do with output waiting. | 614 /* 2^result = something to do with output waiting. |
717 * perhaps matters if we read > 1 frame in a pass? | 615 * perhaps matters if we read > 1 frame in a pass? |
718 */ | 616 */ |
719 readbits(alac, 4); | 617 get_bits(&alac->gb, 4); |
720 | 618 |
721 readbits(alac, 12); /* unknown, skip 12 bits */ | 619 get_bits(&alac->gb, 12); /* unknown, skip 12 bits */ |
722 | 620 |
723 hassize = readbits(alac, 1); /* the output sample size is stored soon */ | 621 hassize = get_bits(&alac->gb, 1); /* the output sample size is stored soon */ |
724 | 622 |
725 wasted_bytes = readbits(alac, 2); /* unknown ? */ | 623 wasted_bytes = get_bits(&alac->gb, 2); /* unknown ? */ |
726 | 624 |
727 isnotcompressed = readbits(alac, 1); /* whether the frame is compressed */ | 625 isnotcompressed = get_bits(&alac->gb, 1); /* whether the frame is compressed */ |
728 | 626 |
729 if (hassize) { | 627 if (hassize) { |
730 /* now read the number of samples, | 628 /* now read the number of samples, |
731 * as a 32bit integer */ | 629 * as a 32bit integer */ |
732 outputsamples = readbits(alac, 32); | 630 outputsamples = get_bits(&alac->gb, 32); |
733 *outputsize = outputsamples * alac->bytespersample; | 631 *outputsize = outputsamples * alac->bytespersample; |
734 } | 632 } |
735 | 633 |
736 readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8) + 1; | 634 readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8) + 1; |
737 | 635 |
749 int prediction_quantitization_b; | 647 int prediction_quantitization_b; |
750 int ricemodifier_b; | 648 int ricemodifier_b; |
751 | 649 |
752 int i; | 650 int i; |
753 | 651 |
754 interlacing_shift = readbits(alac, 8); | 652 interlacing_shift = get_bits(&alac->gb, 8); |
755 interlacing_leftweight = readbits(alac, 8); | 653 interlacing_leftweight = get_bits(&alac->gb, 8); |
756 | 654 |
757 /******** channel 1 ***********/ | 655 /******** channel 1 ***********/ |
758 prediction_type_a = readbits(alac, 4); | 656 prediction_type_a = get_bits(&alac->gb, 4); |
759 prediction_quantitization_a = readbits(alac, 4); | 657 prediction_quantitization_a = get_bits(&alac->gb, 4); |
760 | 658 |
761 ricemodifier_a = readbits(alac, 3); | 659 ricemodifier_a = get_bits(&alac->gb, 3); |
762 predictor_coef_num_a = readbits(alac, 5); | 660 predictor_coef_num_a = get_bits(&alac->gb, 5); |
763 | 661 |
764 /* read the predictor table */ | 662 /* read the predictor table */ |
765 for (i = 0; i < predictor_coef_num_a; i++) { | 663 for (i = 0; i < predictor_coef_num_a; i++) { |
766 predictor_coef_table_a[i] = (int16_t)readbits(alac, 16); | 664 predictor_coef_table_a[i] = (int16_t)get_bits(&alac->gb, 16); |
767 } | 665 } |
768 | 666 |
769 /******** channel 2 *********/ | 667 /******** channel 2 *********/ |
770 prediction_type_b = readbits(alac, 4); | 668 prediction_type_b = get_bits(&alac->gb, 4); |
771 prediction_quantitization_b = readbits(alac, 4); | 669 prediction_quantitization_b = get_bits(&alac->gb, 4); |
772 | 670 |
773 ricemodifier_b = readbits(alac, 3); | 671 ricemodifier_b = get_bits(&alac->gb, 3); |
774 predictor_coef_num_b = readbits(alac, 5); | 672 predictor_coef_num_b = get_bits(&alac->gb, 5); |
775 | 673 |
776 /* read the predictor table */ | 674 /* read the predictor table */ |
777 for (i = 0; i < predictor_coef_num_b; i++) { | 675 for (i = 0; i < predictor_coef_num_b; i++) { |
778 predictor_coef_table_b[i] = (int16_t)readbits(alac, 16); | 676 predictor_coef_table_b[i] = (int16_t)get_bits(&alac->gb, 16); |
779 } | 677 } |
780 | 678 |
781 /*********************/ | 679 /*********************/ |
782 if (wasted_bytes) { | 680 if (wasted_bytes) { |
783 /* see mono case */ | 681 /* see mono case */ |
835 if (alac->setinfo_sample_size <= 16) { | 733 if (alac->setinfo_sample_size <= 16) { |
836 int i; | 734 int i; |
837 for (i = 0; i < outputsamples; i++) { | 735 for (i = 0; i < outputsamples; i++) { |
838 int32_t audiobits_a, audiobits_b; | 736 int32_t audiobits_a, audiobits_b; |
839 | 737 |
840 audiobits_a = readbits(alac, alac->setinfo_sample_size); | 738 audiobits_a = get_bits(&alac->gb, alac->setinfo_sample_size); |
841 audiobits_b = readbits(alac, alac->setinfo_sample_size); | 739 audiobits_b = get_bits(&alac->gb, alac->setinfo_sample_size); |
842 | 740 |
843 audiobits_a = SIGN_EXTENDED32(audiobits_a, alac->setinfo_sample_size); | 741 audiobits_a = SIGN_EXTENDED32(audiobits_a, alac->setinfo_sample_size); |
844 audiobits_b = SIGN_EXTENDED32(audiobits_b, alac->setinfo_sample_size); | 742 audiobits_b = SIGN_EXTENDED32(audiobits_b, alac->setinfo_sample_size); |
845 | 743 |
846 alac->outputsamples_buffer_a[i] = audiobits_a; | 744 alac->outputsamples_buffer_a[i] = audiobits_a; |
849 } else { | 747 } else { |
850 int i; | 748 int i; |
851 for (i = 0; i < outputsamples; i++) { | 749 for (i = 0; i < outputsamples; i++) { |
852 int32_t audiobits_a, audiobits_b; | 750 int32_t audiobits_a, audiobits_b; |
853 | 751 |
854 audiobits_a = readbits(alac, 16); | 752 audiobits_a = get_bits(&alac->gb, 16); |
855 audiobits_a = audiobits_a << 16; | 753 audiobits_a = audiobits_a << 16; |
856 audiobits_a = audiobits_a >> (32 - alac->setinfo_sample_size); | 754 audiobits_a = audiobits_a >> (32 - alac->setinfo_sample_size); |
857 audiobits_a |= readbits(alac, alac->setinfo_sample_size - 16); | 755 audiobits_a |= get_bits(&alac->gb, alac->setinfo_sample_size - 16); |
858 | 756 |
859 audiobits_b = readbits(alac, 16); | 757 audiobits_b = get_bits(&alac->gb, 16); |
860 audiobits_b = audiobits_b << 16; | 758 audiobits_b = audiobits_b << 16; |
861 audiobits_b = audiobits_b >> (32 - alac->setinfo_sample_size); | 759 audiobits_b = audiobits_b >> (32 - alac->setinfo_sample_size); |
862 audiobits_b |= readbits(alac, alac->setinfo_sample_size - 16); | 760 audiobits_b |= get_bits(&alac->gb, alac->setinfo_sample_size - 16); |
863 | 761 |
864 alac->outputsamples_buffer_a[i] = audiobits_a; | 762 alac->outputsamples_buffer_a[i] = audiobits_a; |
865 alac->outputsamples_buffer_b[i] = audiobits_b; | 763 alac->outputsamples_buffer_b[i] = audiobits_b; |
866 } | 764 } |
867 } | 765 } |
897 return input_buffer_size; | 795 return input_buffer_size; |
898 } | 796 } |
899 | 797 |
900 static int alac_decode_init(AVCodecContext * avctx) | 798 static int alac_decode_init(AVCodecContext * avctx) |
901 { | 799 { |
902 ALACContext *s = avctx->priv_data; | 800 ALACContext *alac = avctx->priv_data; |
903 s->avctx = avctx; | 801 alac->avctx = avctx; |
904 s->context_initialized = 0; | 802 alac->context_initialized = 0; |
905 | 803 |
906 s->alac = av_malloc(sizeof(alac_file)); | 804 alac->samplesize = alac->avctx->bits_per_sample; |
907 | 805 alac->numchannels = alac->avctx->channels; |
908 s->alac->samplesize = s->avctx->bits_per_sample; | 806 alac->bytespersample = (alac->samplesize / 8) * alac->numchannels; |
909 s->alac->numchannels = s->avctx->channels; | |
910 s->alac->bytespersample = (s->alac->samplesize / 8) * s->alac->numchannels; | |
911 | 807 |
912 return 0; | 808 return 0; |
913 } | 809 } |
914 | 810 |
915 static int alac_decode_close(AVCodecContext *avctx) | 811 static int alac_decode_close(AVCodecContext *avctx) |
916 { | 812 { |
917 ALACContext *s = avctx->priv_data; | 813 ALACContext *alac = avctx->priv_data; |
918 | 814 |
919 av_free(s->alac->predicterror_buffer_a); | 815 av_free(alac->predicterror_buffer_a); |
920 av_free(s->alac->predicterror_buffer_b); | 816 av_free(alac->predicterror_buffer_b); |
921 | 817 |
922 av_free(s->alac->outputsamples_buffer_a); | 818 av_free(alac->outputsamples_buffer_a); |
923 av_free(s->alac->outputsamples_buffer_b); | 819 av_free(alac->outputsamples_buffer_b); |
924 | 820 |
925 return 0; | 821 return 0; |
926 } | 822 } |
927 | 823 |
928 AVCodec alac_decoder = { | 824 AVCodec alac_decoder = { |