1 /*
2 * Copyright (c) 2011 Apple Inc. All rights reserved.
3 *
4 * @APPLE_APACHE_LICENSE_HEADER_START@
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 * @APPLE_APACHE_LICENSE_HEADER_END@
19 */
20
21 /*
22 File: ALACDecoder.cpp
23 */
24
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "ALACDecoder.h"
29
30 #include "dplib.h"
31 #include "aglib.h"
32 #include "matrixlib.h"
33
34 #include "ALACBitUtilities.h"
35 #include "EndianPortable.h"
36
37 // constants/data
38 const uint32_t kMaxBitDepth = 32; // max allowed bit depth is 32
39
40
41 // prototypes
42 static void Zero16( int16_t * buffer, uint32_t numItems, uint32_t stride );
43 static void Zero24( uint8_t * buffer, uint32_t numItems, uint32_t stride );
44 static void Zero32( int32_t * buffer, uint32_t numItems, uint32_t stride );
45
46 /*
47 Constructor
48 */
ALACDecoder()49 ALACDecoder::ALACDecoder() :
50 mMixBufferU( nil ),
51 mMixBufferV( nil ),
52 mPredictor( nil ),
53 mShiftBuffer( nil )
54 {
55 memset( &mConfig, 0, sizeof(mConfig) );
56 }
57
58 /*
59 Destructor
60 */
~ALACDecoder()61 ALACDecoder::~ALACDecoder()
62 {
63 // delete the matrix mixing buffers
64 if ( mMixBufferU )
65 {
66 free(mMixBufferU);
67 mMixBufferU = NULL;
68 }
69 if ( mMixBufferV )
70 {
71 free(mMixBufferV);
72 mMixBufferV = NULL;
73 }
74
75 // delete the dynamic predictor's "corrector" buffer
76 // - note: mShiftBuffer shares memory with this buffer
77 if ( mPredictor )
78 {
79 free(mPredictor);
80 mPredictor = NULL;
81 }
82 }
83
84 /*
85 Init()
86 - initialize the decoder with the given configuration
87 */
Init(void * inMagicCookie,uint32_t inMagicCookieSize)88 int32_t ALACDecoder::Init( void * inMagicCookie, uint32_t inMagicCookieSize )
89 {
90 int32_t status = ALAC_noErr;
91 ALACSpecificConfig theConfig;
92 uint8_t * theActualCookie = (uint8_t *)inMagicCookie;
93 uint32_t theCookieBytesRemaining = inMagicCookieSize;
94
95 // For historical reasons the decoder needs to be resilient to magic cookies vended by older encoders.
96 // As specified in the ALACMagicCookieDescription.txt document, there may be additional data encapsulating
97 // the ALACSpecificConfig. This would consist of format ('frma') and 'alac' atoms which precede the
98 // ALACSpecificConfig.
99 // See ALACMagicCookieDescription.txt for additional documentation concerning the 'magic cookie'
100
101 // skip format ('frma') atom if present
102 if (theActualCookie[4] == 'f' && theActualCookie[5] == 'r' && theActualCookie[6] == 'm' && theActualCookie[7] == 'a')
103 {
104 theActualCookie += 12;
105 theCookieBytesRemaining -= 12;
106 }
107
108 // skip 'alac' atom header if present
109 if (theActualCookie[4] == 'a' && theActualCookie[5] == 'l' && theActualCookie[6] == 'a' && theActualCookie[7] == 'c')
110 {
111 theActualCookie += 12;
112 theCookieBytesRemaining -= 12;
113 }
114
115 // read the ALACSpecificConfig
116 if (theCookieBytesRemaining >= sizeof(ALACSpecificConfig))
117 {
118 theConfig.frameLength = Swap32BtoN(((ALACSpecificConfig *)theActualCookie)->frameLength);
119 theConfig.compatibleVersion = ((ALACSpecificConfig *)theActualCookie)->compatibleVersion;
120 theConfig.bitDepth = ((ALACSpecificConfig *)theActualCookie)->bitDepth;
121 theConfig.pb = ((ALACSpecificConfig *)theActualCookie)->pb;
122 theConfig.mb = ((ALACSpecificConfig *)theActualCookie)->mb;
123 theConfig.kb = ((ALACSpecificConfig *)theActualCookie)->kb;
124 theConfig.numChannels = ((ALACSpecificConfig *)theActualCookie)->numChannels;
125 theConfig.maxRun = Swap16BtoN(((ALACSpecificConfig *)theActualCookie)->maxRun);
126 theConfig.maxFrameBytes = Swap32BtoN(((ALACSpecificConfig *)theActualCookie)->maxFrameBytes);
127 theConfig.avgBitRate = Swap32BtoN(((ALACSpecificConfig *)theActualCookie)->avgBitRate);
128 theConfig.sampleRate = Swap32BtoN(((ALACSpecificConfig *)theActualCookie)->sampleRate);
129
130 mConfig = theConfig;
131
132 RequireAction( mConfig.compatibleVersion <= kALACVersion, return kALAC_ParamError; );
133
134 // allocate mix buffers
135 mMixBufferU = (int32_t *) calloc( mConfig.frameLength * sizeof(int32_t), 1 );
136 mMixBufferV = (int32_t *) calloc( mConfig.frameLength * sizeof(int32_t), 1 );
137
138 // allocate dynamic predictor buffer
139 mPredictor = (int32_t *) calloc( mConfig.frameLength * sizeof(int32_t), 1 );
140
141 // "shift off" buffer shares memory with predictor buffer
142 mShiftBuffer = (uint16_t *) mPredictor;
143
144 RequireAction( (mMixBufferU != nil) && (mMixBufferV != nil) && (mPredictor != nil),
145 status = kALAC_MemFullError; goto Exit; );
146 }
147 else
148 {
149 status = kALAC_ParamError;
150 }
151
152 // skip to Channel Layout Info
153 // theActualCookie += sizeof(ALACSpecificConfig);
154
155 // Currently, the Channel Layout Info portion of the magic cookie (as defined in the
156 // ALACMagicCookieDescription.txt document) is unused by the decoder.
157
158 Exit:
159 return status;
160 }
161
162 /*
163 Decode()
164 - the decoded samples are interleaved into the output buffer in the order they arrive in
165 the bitstream
166 */
Decode(BitBuffer * bits,uint8_t * sampleBuffer,uint32_t numSamples,uint32_t numChannels,uint32_t * outNumSamples)167 int32_t ALACDecoder::Decode( BitBuffer * bits, uint8_t * sampleBuffer, uint32_t numSamples, uint32_t numChannels, uint32_t * outNumSamples )
168 {
169 BitBuffer shiftBits;
170 uint32_t bits1, bits2;
171 uint8_t tag;
172 uint8_t elementInstanceTag;
173 AGParamRec agParams;
174 uint32_t channelIndex;
175 int16_t coefsU[32]; // max possible size is 32 although NUMCOEPAIRS is the current limit
176 int16_t coefsV[32];
177 uint8_t numU, numV;
178 uint8_t mixBits;
179 int8_t mixRes;
180 uint16_t unusedHeader;
181 uint8_t escapeFlag;
182 uint32_t chanBits;
183 uint8_t bytesShifted;
184 uint32_t shift;
185 uint8_t modeU, modeV;
186 uint32_t denShiftU, denShiftV;
187 uint16_t pbFactorU, pbFactorV;
188 uint16_t pb;
189 int16_t * samples;
190 int16_t * out16;
191 uint8_t * out20;
192 uint8_t * out24;
193 int32_t * out32;
194 uint8_t headerByte;
195 uint8_t partialFrame;
196 uint32_t extraBits;
197 int32_t val;
198 uint32_t i, j;
199 int32_t status;
200
201 RequireAction( (bits != nil) && (sampleBuffer != nil) && (outNumSamples != nil), return kALAC_ParamError; );
202 RequireAction( numChannels > 0, return kALAC_ParamError; );
203
204 mActiveElements = 0;
205 channelIndex = 0;
206
207 samples = (int16_t *) sampleBuffer;
208
209 status = ALAC_noErr;
210 *outNumSamples = numSamples;
211
212 while ( status == ALAC_noErr )
213 {
214 // bail if we ran off the end of the buffer
215 RequireAction( bits->cur < bits->end, status = kALAC_ParamError; goto Exit; );
216
217 // copy global decode params for this element
218 pb = mConfig.pb;
219
220 // read element tag
221 tag = BitBufferReadSmall( bits, 3 );
222 switch ( tag )
223 {
224 case ID_SCE:
225 case ID_LFE:
226 {
227 // mono/LFE channel
228 elementInstanceTag = BitBufferReadSmall( bits, 4 );
229 mActiveElements |= (1u << elementInstanceTag);
230
231 // read the 12 unused header bits
232 unusedHeader = (uint16_t) BitBufferRead( bits, 12 );
233 RequireAction( unusedHeader == 0, status = kALAC_ParamError; goto Exit; );
234
235 // read the 1-bit "partial frame" flag, 2-bit "shift-off" flag & 1-bit "escape" flag
236 headerByte = (uint8_t) BitBufferRead( bits, 4 );
237
238 partialFrame = headerByte >> 3;
239
240 bytesShifted = (headerByte >> 1) & 0x3u;
241 RequireAction( bytesShifted != 3, status = kALAC_ParamError; goto Exit; );
242
243 shift = bytesShifted * 8;
244
245 escapeFlag = headerByte & 0x1;
246
247 chanBits = mConfig.bitDepth - (bytesShifted * 8);
248
249 // check for partial frame to override requested numSamples
250 if ( partialFrame != 0 )
251 {
252 numSamples = BitBufferRead( bits, 16 ) << 16;
253 numSamples |= BitBufferRead( bits, 16 );
254 }
255
256 if ( escapeFlag == 0 )
257 {
258 // compressed frame, read rest of parameters
259 mixBits = (uint8_t) BitBufferRead( bits, 8 );
260 mixRes = (int8_t) BitBufferRead( bits, 8 );
261 //Assert( (mixBits == 0) && (mixRes == 0) ); // no mixing for mono
262
263 headerByte = (uint8_t) BitBufferRead( bits, 8 );
264 modeU = headerByte >> 4;
265 denShiftU = headerByte & 0xfu;
266
267 headerByte = (uint8_t) BitBufferRead( bits, 8 );
268 pbFactorU = headerByte >> 5;
269 numU = headerByte & 0x1fu;
270
271 for ( i = 0; i < numU; i++ )
272 coefsU[i] = (int16_t) BitBufferRead( bits, 16 );
273
274 // if shift active, skip the the shift buffer but remember where it starts
275 if ( bytesShifted != 0 )
276 {
277 shiftBits = *bits;
278 BitBufferAdvance( bits, (bytesShifted * 8) * numSamples );
279 }
280
281 // decompress
282 set_ag_params( &agParams, mConfig.mb, (pb * pbFactorU) / 4, mConfig.kb, numSamples, numSamples, mConfig.maxRun );
283 status = dyn_decomp( &agParams, bits, mPredictor, numSamples, chanBits, &bits1 );
284 RequireNoErr( status, goto Exit; );
285
286 if ( modeU == 0 )
287 {
288 unpc_block( mPredictor, mMixBufferU, numSamples, &coefsU[0], numU, chanBits, denShiftU );
289 }
290 else
291 {
292 // the special "numActive == 31" mode can be done in-place
293 unpc_block( mPredictor, mPredictor, numSamples, nil, 31, chanBits, 0 );
294 unpc_block( mPredictor, mMixBufferU, numSamples, &coefsU[0], numU, chanBits, denShiftU );
295 }
296 }
297 else
298 {
299 //Assert( bytesShifted == 0 );
300
301 // uncompressed frame, copy data into the mix buffer to use common output code
302 shift = 32 - chanBits;
303 if ( chanBits <= 16 )
304 {
305 for ( i = 0; i < numSamples; i++ )
306 {
307 val = (int32_t) BitBufferRead( bits, (uint8_t) chanBits );
308 val = (val << shift) >> shift;
309 mMixBufferU[i] = val;
310 }
311 }
312 else
313 {
314 // BitBufferRead() can't read more than 16 bits at a time so break up the reads
315 extraBits = chanBits - 16;
316 for ( i = 0; i < numSamples; i++ )
317 {
318 val = (int32_t) BitBufferRead( bits, 16 );
319 val = (val << 16) >> shift;
320 mMixBufferU[i] = val | BitBufferRead( bits, (uint8_t) extraBits );
321 }
322 }
323
324 mixBits = mixRes = 0;
325 bits1 = chanBits * numSamples;
326 bytesShifted = 0;
327 }
328
329 // now read the shifted values into the shift buffer
330 if ( bytesShifted != 0 )
331 {
332 shift = bytesShifted * 8;
333 //Assert( shift <= 16 );
334
335 for ( i = 0; i < numSamples; i++ )
336 mShiftBuffer[i] = (uint16_t) BitBufferRead( &shiftBits, (uint8_t) shift );
337 }
338
339 // convert 32-bit integers into output buffer
340 switch ( mConfig.bitDepth )
341 {
342 case 16:
343 out16 = &((int16_t *)sampleBuffer)[channelIndex];
344 for ( i = 0, j = 0; i < numSamples; i++, j += numChannels )
345 out16[j] = (int16_t) mMixBufferU[i];
346 break;
347 case 20:
348 out20 = (uint8_t *)sampleBuffer + (channelIndex * 3);
349 copyPredictorTo20( mMixBufferU, out20, numChannels, numSamples );
350 break;
351 case 24:
352 out24 = (uint8_t *)sampleBuffer + (channelIndex * 3);
353 if ( bytesShifted != 0 )
354 copyPredictorTo24Shift( mMixBufferU, mShiftBuffer, out24, numChannels, numSamples, bytesShifted );
355 else
356 copyPredictorTo24( mMixBufferU, out24, numChannels, numSamples );
357 break;
358 case 32:
359 out32 = &((int32_t *)sampleBuffer)[channelIndex];
360 if ( bytesShifted != 0 )
361 copyPredictorTo32Shift( mMixBufferU, mShiftBuffer, out32, numChannels, numSamples, bytesShifted );
362 else
363 copyPredictorTo32( mMixBufferU, out32, numChannels, numSamples);
364 break;
365 }
366
367 channelIndex += 1;
368 *outNumSamples = numSamples;
369 break;
370 }
371
372 case ID_CPE:
373 {
374 // if decoding this pair would take us over the max channels limit, bail
375 if ( (channelIndex + 2) > numChannels )
376 goto NoMoreChannels;
377
378 // stereo channel pair
379 elementInstanceTag = BitBufferReadSmall( bits, 4 );
380 mActiveElements |= (1u << elementInstanceTag);
381
382 // read the 12 unused header bits
383 unusedHeader = (uint16_t) BitBufferRead( bits, 12 );
384 RequireAction( unusedHeader == 0, status = kALAC_ParamError; goto Exit; );
385
386 // read the 1-bit "partial frame" flag, 2-bit "shift-off" flag & 1-bit "escape" flag
387 headerByte = (uint8_t) BitBufferRead( bits, 4 );
388
389 partialFrame = headerByte >> 3;
390
391 bytesShifted = (headerByte >> 1) & 0x3u;
392 RequireAction( bytesShifted != 3, status = kALAC_ParamError; goto Exit; );
393
394 shift = bytesShifted * 8;
395
396 escapeFlag = headerByte & 0x1;
397
398 chanBits = mConfig.bitDepth - (bytesShifted * 8) + 1;
399
400 // check for partial frame length to override requested numSamples
401 if ( partialFrame != 0 )
402 {
403 numSamples = BitBufferRead( bits, 16 ) << 16;
404 numSamples |= BitBufferRead( bits, 16 );
405 }
406
407 if ( escapeFlag == 0 )
408 {
409 // compressed frame, read rest of parameters
410 mixBits = (uint8_t) BitBufferRead( bits, 8 );
411 mixRes = (int8_t) BitBufferRead( bits, 8 );
412
413 headerByte = (uint8_t) BitBufferRead( bits, 8 );
414 modeU = headerByte >> 4;
415 denShiftU = headerByte & 0xfu;
416
417 headerByte = (uint8_t) BitBufferRead( bits, 8 );
418 pbFactorU = headerByte >> 5;
419 numU = headerByte & 0x1fu;
420 for ( i = 0; i < numU; i++ )
421 coefsU[i] = (int16_t) BitBufferRead( bits, 16 );
422
423 headerByte = (uint8_t) BitBufferRead( bits, 8 );
424 modeV = headerByte >> 4;
425 denShiftV = headerByte & 0xfu;
426
427 headerByte = (uint8_t) BitBufferRead( bits, 8 );
428 pbFactorV = headerByte >> 5;
429 numV = headerByte & 0x1fu;
430 for ( i = 0; i < numV; i++ )
431 coefsV[i] = (int16_t) BitBufferRead( bits, 16 );
432
433 // if shift active, skip the interleaved shifted values but remember where they start
434 if ( bytesShifted != 0 )
435 {
436 shiftBits = *bits;
437 BitBufferAdvance( bits, (bytesShifted * 8) * 2 * numSamples );
438 }
439
440 // decompress and run predictor for "left" channel
441 set_ag_params( &agParams, mConfig.mb, (pb * pbFactorU) / 4, mConfig.kb, numSamples, numSamples, mConfig.maxRun );
442 status = dyn_decomp( &agParams, bits, mPredictor, numSamples, chanBits, &bits1 );
443 RequireNoErr( status, goto Exit; );
444
445 if ( modeU == 0 )
446 {
447 unpc_block( mPredictor, mMixBufferU, numSamples, &coefsU[0], numU, chanBits, denShiftU );
448 }
449 else
450 {
451 // the special "numActive == 31" mode can be done in-place
452 unpc_block( mPredictor, mPredictor, numSamples, nil, 31, chanBits, 0 );
453 unpc_block( mPredictor, mMixBufferU, numSamples, &coefsU[0], numU, chanBits, denShiftU );
454 }
455
456 // decompress and run predictor for "right" channel
457 set_ag_params( &agParams, mConfig.mb, (pb * pbFactorV) / 4, mConfig.kb, numSamples, numSamples, mConfig.maxRun );
458 status = dyn_decomp( &agParams, bits, mPredictor, numSamples, chanBits, &bits2 );
459 RequireNoErr( status, goto Exit; );
460
461 if ( modeV == 0 )
462 {
463 unpc_block( mPredictor, mMixBufferV, numSamples, &coefsV[0], numV, chanBits, denShiftV );
464 }
465 else
466 {
467 // the special "numActive == 31" mode can be done in-place
468 unpc_block( mPredictor, mPredictor, numSamples, nil, 31, chanBits, 0 );
469 unpc_block( mPredictor, mMixBufferV, numSamples, &coefsV[0], numV, chanBits, denShiftV );
470 }
471 }
472 else
473 {
474 //Assert( bytesShifted == 0 );
475
476 // uncompressed frame, copy data into the mix buffers to use common output code
477 chanBits = mConfig.bitDepth;
478 shift = 32 - chanBits;
479 if ( chanBits <= 16 )
480 {
481 for ( i = 0; i < numSamples; i++ )
482 {
483 val = (int32_t) BitBufferRead( bits, (uint8_t) chanBits );
484 val = (val << shift) >> shift;
485 mMixBufferU[i] = val;
486
487 val = (int32_t) BitBufferRead( bits, (uint8_t) chanBits );
488 val = (val << shift) >> shift;
489 mMixBufferV[i] = val;
490 }
491 }
492 else
493 {
494 // BitBufferRead() can't read more than 16 bits at a time so break up the reads
495 extraBits = chanBits - 16;
496 for ( i = 0; i < numSamples; i++ )
497 {
498 val = (int32_t) BitBufferRead( bits, 16 );
499 val = (val << 16) >> shift;
500 mMixBufferU[i] = val | BitBufferRead( bits, (uint8_t)extraBits );
501
502 val = (int32_t) BitBufferRead( bits, 16 );
503 val = (val << 16) >> shift;
504 mMixBufferV[i] = val | BitBufferRead( bits, (uint8_t)extraBits );
505 }
506 }
507
508 bits1 = chanBits * numSamples;
509 bits2 = chanBits * numSamples;
510 mixBits = mixRes = 0;
511 bytesShifted = 0;
512 }
513
514 // now read the shifted values into the shift buffer
515 if ( bytesShifted != 0 )
516 {
517 shift = bytesShifted * 8;
518 //Assert( shift <= 16 );
519
520 for ( i = 0; i < (numSamples * 2); i += 2 )
521 {
522 mShiftBuffer[i + 0] = (uint16_t) BitBufferRead( &shiftBits, (uint8_t) shift );
523 mShiftBuffer[i + 1] = (uint16_t) BitBufferRead( &shiftBits, (uint8_t) shift );
524 }
525 }
526
527 // un-mix the data and convert to output format
528 // - note that mixRes = 0 means just interleave so we use that path for uncompressed frames
529 switch ( mConfig.bitDepth )
530 {
531 case 16:
532 out16 = &((int16_t *)sampleBuffer)[channelIndex];
533 unmix16( mMixBufferU, mMixBufferV, out16, numChannels, numSamples, mixBits, mixRes );
534 break;
535 case 20:
536 out20 = (uint8_t *)sampleBuffer + (channelIndex * 3);
537 unmix20( mMixBufferU, mMixBufferV, out20, numChannels, numSamples, mixBits, mixRes );
538 break;
539 case 24:
540 out24 = (uint8_t *)sampleBuffer + (channelIndex * 3);
541 unmix24( mMixBufferU, mMixBufferV, out24, numChannels, numSamples,
542 mixBits, mixRes, mShiftBuffer, bytesShifted );
543 break;
544 case 32:
545 out32 = &((int32_t *)sampleBuffer)[channelIndex];
546 unmix32( mMixBufferU, mMixBufferV, out32, numChannels, numSamples,
547 mixBits, mixRes, mShiftBuffer, bytesShifted );
548 break;
549 }
550
551 channelIndex += 2;
552 *outNumSamples = numSamples;
553 break;
554 }
555
556 case ID_CCE:
557 case ID_PCE:
558 {
559 // unsupported element, bail
560 //AssertNoErr( tag );
561 status = kALAC_ParamError;
562 break;
563 }
564
565 case ID_DSE:
566 {
567 // data stream element -- parse but ignore
568 status = this->DataStreamElement( bits );
569 break;
570 }
571
572 case ID_FIL:
573 {
574 // fill element -- parse but ignore
575 status = this->FillElement( bits );
576 break;
577 }
578
579 case ID_END:
580 {
581 // frame end, all done so byte align the frame and check for overruns
582 BitBufferByteAlign( bits, false );
583 //Assert( bits->cur == bits->end );
584 goto Exit;
585 }
586 }
587
588 #if ! DEBUG
589 // if we've decoded all of our channels, bail (but not in debug b/c we want to know if we're seeing bad bits)
590 // - this also protects us if the config does not match the bitstream or crap data bits follow the audio bits
591 if ( channelIndex >= numChannels )
592 break;
593 #endif
594 }
595
596 NoMoreChannels:
597
598 // if we get here and haven't decoded all of the requested channels, fill the remaining channels with zeros
599 for ( ; channelIndex < numChannels; channelIndex++ )
600 {
601 switch ( mConfig.bitDepth )
602 {
603 case 16:
604 {
605 int16_t * fill16 = &((int16_t *)sampleBuffer)[channelIndex];
606 Zero16( fill16, numSamples, numChannels );
607 break;
608 }
609 case 24:
610 {
611 uint8_t * fill24 = (uint8_t *)sampleBuffer + (channelIndex * 3);
612 Zero24( fill24, numSamples, numChannels );
613 break;
614 }
615 case 32:
616 {
617 int32_t * fill32 = &((int32_t *)sampleBuffer)[channelIndex];
618 Zero32( fill32, numSamples, numChannels );
619 break;
620 }
621 }
622 }
623
624 Exit:
625 return status;
626 }
627
628 #if PRAGMA_MARK
629 #pragma mark -
630 #endif
631
632 /*
633 FillElement()
634 - they're just filler so we don't need 'em
635 */
FillElement(BitBuffer * bits)636 int32_t ALACDecoder::FillElement( BitBuffer * bits )
637 {
638 int16_t count;
639
640 // 4-bit count or (4-bit + 8-bit count) if 4-bit count == 15
641 // - plus this weird -1 thing I still don't fully understand
642 count = BitBufferReadSmall( bits, 4 );
643 if ( count == 15 )
644 count += (int16_t) BitBufferReadSmall( bits, 8 ) - 1;
645
646 BitBufferAdvance( bits, count * 8 );
647
648 RequireAction( bits->cur <= bits->end, return kALAC_ParamError; );
649
650 return ALAC_noErr;
651 }
652
653 /*
654 DataStreamElement()
655 - we don't care about data stream elements so just skip them
656 */
DataStreamElement(BitBuffer * bits)657 int32_t ALACDecoder::DataStreamElement( BitBuffer * bits )
658 {
659 uint8_t element_instance_tag;
660 int32_t data_byte_align_flag;
661 uint16_t count;
662
663 // the tag associates this data stream element with a given audio element
664 element_instance_tag = BitBufferReadSmall( bits, 4 );
665
666 data_byte_align_flag = BitBufferReadOne( bits );
667
668 // 8-bit count or (8-bit + 8-bit count) if 8-bit count == 255
669 count = BitBufferReadSmall( bits, 8 );
670 if ( count == 255 )
671 count += BitBufferReadSmall( bits, 8 );
672
673 // the align flag means the bitstream should be byte-aligned before reading the following data bytes
674 if ( data_byte_align_flag )
675 BitBufferByteAlign( bits, false );
676
677 // skip the data bytes
678 BitBufferAdvance( bits, count * 8 );
679
680 RequireAction( bits->cur <= bits->end, return kALAC_ParamError; );
681
682 return ALAC_noErr;
683 }
684
685 /*
686 ZeroN()
687 - helper routines to clear out output channel buffers when decoding fewer channels than requested
688 */
Zero16(int16_t * buffer,uint32_t numItems,uint32_t stride)689 static void Zero16( int16_t * buffer, uint32_t numItems, uint32_t stride )
690 {
691 if ( stride == 1 )
692 {
693 memset( buffer, 0, numItems * sizeof(int16_t) );
694 }
695 else
696 {
697 for ( uint32_t index = 0; index < (numItems * stride); index += stride )
698 buffer[index] = 0;
699 }
700 }
701
Zero24(uint8_t * buffer,uint32_t numItems,uint32_t stride)702 static void Zero24( uint8_t * buffer, uint32_t numItems, uint32_t stride )
703 {
704 if ( stride == 1 )
705 {
706 memset( buffer, 0, numItems * 3 );
707 }
708 else
709 {
710 for ( uint32_t index = 0; index < (numItems * stride * 3); index += (stride * 3) )
711 {
712 buffer[index + 0] = 0;
713 buffer[index + 1] = 0;
714 buffer[index + 2] = 0;
715 }
716 }
717 }
718
Zero32(int32_t * buffer,uint32_t numItems,uint32_t stride)719 static void Zero32( int32_t * buffer, uint32_t numItems, uint32_t stride )
720 {
721 if ( stride == 1 )
722 {
723 memset( buffer, 0, numItems * sizeof(int32_t) );
724 }
725 else
726 {
727 for ( uint32_t index = 0; index < (numItems * stride); index += stride )
728 buffer[index] = 0;
729 }
730 }
731