/* * Copyright (c) 2011 Apple Inc. All rights reserved. * * @APPLE_APACHE_LICENSE_HEADER_START@ * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * @APPLE_APACHE_LICENSE_HEADER_END@ */ /* File: ALACEncoder.cpp */ // build stuff #define VERBOSE_DEBUG 0 // headers #include #include #include #include "ALACEncoder.h" #include "aglib.h" #include "dplib.h" #include "matrixlib.h" #include "ALACBitUtilities.h" #include "ALACAudioTypes.h" #include "EndianPortable.h" // Note: in C you can't typecast to a 2-dimensional array pointer but that's what we need when // picking which coefs to use so we declare this typedef b/c we *can* typecast to this type typedef int16_t (*SearchCoefs)[kALACMaxCoefs]; // defines/constants const uint32_t kALACEncoderMagic = 'dpge'; const uint32_t kMaxSampleSize = 32; // max allowed bit width is 32 const uint32_t kDefaultMixBits = 2; const uint32_t kDefaultMixRes = 0; const uint32_t kMaxRes = 4; const uint32_t kDefaultNumUV = 8; const uint32_t kMinUV = 4; const uint32_t kMaxUV = 8; // static functions #if VERBOSE_DEBUG static void AddFiller( BitBuffer * bits, int32_t numBytes ); #endif /* Map Format: 3-bit field per channel which is the same as the "element tag" that should be placed at the beginning of the frame for that channel. Indicates whether SCE, CPE, or LFE. Each particular field is accessed via the current channel index. Note that the channel index increments by two for channel pairs. For example: C L R 3-channel input = (ID_CPE << 3) | (ID_SCE) index 0 value = (map & (0x7ul << (0 * 3))) >> (0 * 3) index 1 value = (map & (0x7ul << (1 * 3))) >> (1 * 3) C L R Ls Rs LFE 5.1-channel input = (ID_LFE << 15) | (ID_CPE << 9) | (ID_CPE << 3) | (ID_SCE) index 0 value = (map & (0x7ul << (0 * 3))) >> (0 * 3) index 1 value = (map & (0x7ul << (1 * 3))) >> (1 * 3) index 3 value = (map & (0x7ul << (3 * 3))) >> (3 * 3) index 5 value = (map & (0x7ul << (5 * 3))) >> (5 * 3) index 7 value = (map & (0x7ul << (7 * 3))) >> (7 * 3) */ static const uint32_t sChannelMaps[kALACMaxChannels] = { ID_SCE, ID_CPE, (ID_CPE << 3) | (ID_SCE), (ID_SCE << 9) | (ID_CPE << 3) | (ID_SCE), (ID_CPE << 9) | (ID_CPE << 3) | (ID_SCE), (ID_SCE << 15) | (ID_CPE << 9) | (ID_CPE << 3) | (ID_SCE), (ID_SCE << 18) | (ID_SCE << 15) | (ID_CPE << 9) | (ID_CPE << 3) | (ID_SCE), (ID_SCE << 21) | (ID_CPE << 15) | (ID_CPE << 9) | (ID_CPE << 3) | (ID_SCE) }; static const uint32_t sSupportediPodSampleRates[] = { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }; /* Constructor */ ALACEncoder::ALACEncoder() : mBitDepth( 0 ), mFastMode( 0 ), mMixBufferU( nil ), mMixBufferV( nil ), mPredictorU( nil ), mPredictorV( nil ), mShiftBufferUV( nil ), mWorkBuffer( nil ), mTotalBytesGenerated( 0 ), mAvgBitRate( 0 ), mMaxFrameBytes( 0 ) { // overrides mFrameSize = kALACDefaultFrameSize; } /* Destructor */ ALACEncoder::~ALACEncoder() { // delete the matrix mixing buffers if ( mMixBufferU ) { free(mMixBufferU); mMixBufferU = NULL; } if ( mMixBufferV ) { free(mMixBufferV); mMixBufferV = NULL; } // delete the dynamic predictor's "corrector" buffers if ( mPredictorU ) { free(mPredictorU); mPredictorU = NULL; } if ( mPredictorV ) { free(mPredictorV); mPredictorV = NULL; } // delete the unused byte shift buffer if ( mShiftBufferUV ) { free(mShiftBufferUV); mShiftBufferUV = NULL; } // delete the work buffer if ( mWorkBuffer ) { free(mWorkBuffer); mWorkBuffer = NULL; } } #if PRAGMA_MARK #pragma mark - #endif /* HEADER SPECIFICATION For every segment we adopt the following header: 1 byte reserved (always 0) 1 byte flags (see below) [4 byte frame length] (optional, see below) ---Next, the per-segment ALAC parameters--- 1 byte mixBits (middle-side parameter) 1 byte mixRes (middle-side parameter, interpreted as signed char) 1 byte shiftU (4 bits modeU, 4 bits denShiftU) 1 byte filterU (3 bits pbFactorU, 5 bits numU) (numU) shorts (signed DP coefficients for V channel) ---Next, 2nd-channel ALAC parameters in case of stereo mode--- 1 byte shiftV (4 bits modeV, 4 bits denShiftV) 1 byte filterV (3 bits pbFactorV, 5 bits numV) (numV) shorts (signed DP coefficients for V channel) ---After this come the shift-off bytes for (>= 24)-bit data (n-byte shift) if indicated--- ---Then comes the AG-compressor bitstream--- FLAGS ----- The presence of certain flag bits changes the header format such that the parameters might not even be sent. The currently defined flags format is: 0000psse where 0 = reserved, must be 0 p = 1-bit field "partial frame" flag indicating 32-bit frame length follows this byte ss = 2-bit field indicating "number of shift-off bytes ignored by compression" e = 1-bit field indicating "escape" The "partial frame" flag means that the following segment is not equal to the frame length specified in the out-of-band decoder configuration. This allows the decoder to deal with end-of-file partial segments without incurring the 32-bit overhead for each segment. The "shift-off" field indicates the number of bytes at the bottom of the word that were passed through uncompressed. The reason for this is that the entropy inherent in the LS bytes of >= 24-bit words quite often means that the frame would have to be "escaped" b/c the compressed size would be >= the uncompressed size. However, by shifting the input values down and running the remaining bits through the normal compression algorithm, a net win can be achieved. If this field is non-zero, it means that the shifted-off bytes follow after the parameter section of the header and before the compressed bitstream. Note that doing this also allows us to use matrixing on 32-bit inputs after one or more bytes are shifted off the bottom which helps the eventual compression ratio. For stereo channels, the shifted off bytes are interleaved. The "escape" flag means that this segment was not compressed b/c the compressed size would be >= uncompressed size. In that case, the audio data was passed through uncompressed after the header. The other header parameter bytes will not be sent. PARAMETERS ---------- If the segment is not a partial or escape segment, the total header size (in bytes) is given exactly by: 4 + (2 + 2 * numU) (mono mode) 4 + (2 + 2 * numV) + (2 + 2 * numV) (stereo mode) where the ALAC filter-lengths numU, numV are bounded by a constant (in the current source, numU, numV <= NUMCOEPAIRS), and this forces an absolute upper bound on header size. Each segment-decode process loads up these bytes from the front of the local stream, in the above order, then follows with the entropy-encoded bits for the given segment. To generalize middle-side, there are various mixing modes including middle-side, each lossless, as embodied in the mix() and unmix() functions. These functions exploit a generalized middle-side transformation: u := [(rL + (m-r)R)/m]; v := L - R; where [ ] denotes integer floor. The (lossless) inverse is L = u + v - [rV/m]; R = L - v; In the segment header, m and r are encoded in mixBits and mixRes. Classical "middle-side" is obtained with m = 2, r = 1, but now we have more generalized mixes. NOTES ----- The relevance of the ALAC coefficients is explained in detail in patent documents. */ /* EncodeStereo() - encode a channel pair */ int32_t ALACEncoder::EncodeStereo( BitBuffer * bitstream, void * inputBuffer, uint32_t stride, uint32_t channelIndex, uint32_t numSamples ) { BitBuffer workBits; BitBuffer startBits = *bitstream; // squirrel away copy of current state in case we need to go back and do an escape packet AGParamRec agParams; uint32_t bits1, bits2; uint32_t dilate; int32_t mixBits, mixRes, maxRes; uint32_t minBits, minBits1, minBits2; uint32_t numU, numV; uint32_t mode; uint32_t pbFactor; uint32_t chanBits; uint32_t denShift; uint8_t bytesShifted; SearchCoefs coefsU; SearchCoefs coefsV; uint32_t index; uint8_t partialFrame; uint32_t escapeBits; bool doEscape; int32_t status = ALAC_noErr; // make sure we handle this bit-depth before we get going RequireAction( (mBitDepth == 16) || (mBitDepth == 20) || (mBitDepth == 24) || (mBitDepth == 32), return kALAC_ParamError; ); // reload coefs pointers for this channel pair // - note that, while you might think they should be re-initialized per block, retaining state across blocks // actually results in better overall compression // - strangely, re-using the same coefs for the different passes of the "mixRes" search loop instead of using // different coefs for the different passes of "mixRes" results in even better compression coefsU = (SearchCoefs) mCoefsU[channelIndex]; coefsV = (SearchCoefs) mCoefsV[channelIndex]; // matrix encoding adds an extra bit but 32-bit inputs cannot be matrixed b/c 33 is too many // so enable 16-bit "shift off" and encode in 17-bit mode // - in addition, 24-bit mode really improves with one byte shifted off if ( mBitDepth == 32 ) bytesShifted = 2; else if ( mBitDepth >= 24 ) bytesShifted = 1; else bytesShifted = 0; chanBits = mBitDepth - (bytesShifted * 8) + 1; // flag whether or not this is a partial frame partialFrame = (numSamples == mFrameSize) ? 0 : 1; // brute-force encode optimization loop // - run over variations of the encoding params to find the best choice mixBits = kDefaultMixBits; maxRes = kMaxRes; numU = numV = kDefaultNumUV; denShift = DENSHIFT_DEFAULT; mode = 0; pbFactor = 4; dilate = 8; minBits = minBits1 = minBits2 = 1ul << 31; int32_t bestRes = mLastMixRes[channelIndex]; for ( mixRes = 0; mixRes <= maxRes; mixRes++ ) { // mix the stereo inputs switch ( mBitDepth ) { case 16: mix16( (int16_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples/dilate, mixBits, mixRes ); break; case 20: mix20( (uint8_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples/dilate, mixBits, mixRes ); break; case 24: // includes extraction of shifted-off bytes mix24( (uint8_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples/dilate, mixBits, mixRes, mShiftBufferUV, bytesShifted ); break; case 32: // includes extraction of shifted-off bytes mix32( (int32_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples/dilate, mixBits, mixRes, mShiftBufferUV, bytesShifted ); break; } BitBufferInit( &workBits, mWorkBuffer, mMaxOutputBytes ); // run the dynamic predictors pc_block( mMixBufferU, mPredictorU, numSamples/dilate, coefsU[numU - 1], numU, chanBits, DENSHIFT_DEFAULT ); pc_block( mMixBufferV, mPredictorV, numSamples/dilate, coefsV[numV - 1], numV, chanBits, DENSHIFT_DEFAULT ); // run the lossless compressor on each channel set_ag_params( &agParams, MB0, (pbFactor * PB0) / 4, KB0, numSamples/dilate, numSamples/dilate, MAX_RUN_DEFAULT ); status = dyn_comp( &agParams, mPredictorU, &workBits, numSamples/dilate, chanBits, &bits1 ); RequireNoErr( status, goto Exit; ); set_ag_params( &agParams, MB0, (pbFactor * PB0) / 4, KB0, numSamples/dilate, numSamples/dilate, MAX_RUN_DEFAULT ); status = dyn_comp( &agParams, mPredictorV, &workBits, numSamples/dilate, chanBits, &bits2 ); RequireNoErr( status, goto Exit; ); // look for best match if ( (bits1 + bits2) < minBits1 ) { minBits1 = bits1 + bits2; bestRes = mixRes; } } mLastMixRes[channelIndex] = (int16_t)bestRes; // mix the stereo inputs with the current best mixRes mixRes = mLastMixRes[channelIndex]; switch ( mBitDepth ) { case 16: mix16( (int16_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples, mixBits, mixRes ); break; case 20: mix20( (uint8_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples, mixBits, mixRes ); break; case 24: // also extracts the shifted off bytes into the shift buffers mix24( (uint8_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples, mixBits, mixRes, mShiftBufferUV, bytesShifted ); break; case 32: // also extracts the shifted off bytes into the shift buffers mix32( (int32_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples, mixBits, mixRes, mShiftBufferUV, bytesShifted ); break; } // now it's time for the predictor coefficient search loop numU = numV = kMinUV; minBits1 = minBits2 = 1ul << 31; for ( uint32_t numUV = kMinUV; numUV <= kMaxUV; numUV += 4 ) { BitBufferInit( &workBits, mWorkBuffer, mMaxOutputBytes ); dilate = 32; // run the predictor over the same data multiple times to help it converge for ( uint32_t converge = 0; converge < 8; converge++ ) { pc_block( mMixBufferU, mPredictorU, numSamples/dilate, coefsU[numUV-1], numUV, chanBits, DENSHIFT_DEFAULT ); pc_block( mMixBufferV, mPredictorV, numSamples/dilate, coefsV[numUV-1], numUV, chanBits, DENSHIFT_DEFAULT ); } dilate = 8; set_ag_params( &agParams, MB0, (pbFactor * PB0)/4, KB0, numSamples/dilate, numSamples/dilate, MAX_RUN_DEFAULT ); status = dyn_comp( &agParams, mPredictorU, &workBits, numSamples/dilate, chanBits, &bits1 ); if ( (bits1 * dilate + 16 * numUV) < minBits1 ) { minBits1 = bits1 * dilate + 16 * numUV; numU = numUV; } set_ag_params( &agParams, MB0, (pbFactor * PB0)/4, KB0, numSamples/dilate, numSamples/dilate, MAX_RUN_DEFAULT ); status = dyn_comp( &agParams, mPredictorV, &workBits, numSamples/dilate, chanBits, &bits2 ); if ( (bits2 * dilate + 16 * numUV) < minBits2 ) { minBits2 = bits2 * dilate + 16 * numUV; numV = numUV; } } // test for escape hatch if best calculated compressed size turns out to be more than the input size minBits = minBits1 + minBits2 + (8 /* mixRes/maxRes/etc. */ * 8) + ((partialFrame == true) ? 32 : 0); if ( bytesShifted != 0 ) minBits += (numSamples * (bytesShifted * 8) * 2); escapeBits = (numSamples * mBitDepth * 2) + ((partialFrame == true) ? 32 : 0) + (2 * 8); /* 2 common header bytes */ doEscape = (minBits >= escapeBits) ? true : false; if ( doEscape == false ) { // write bitstream header and coefs BitBufferWrite( bitstream, 0, 12 ); BitBufferWrite( bitstream, (partialFrame << 3) | (bytesShifted << 1), 4 ); if ( partialFrame ) BitBufferWrite( bitstream, numSamples, 32 ); BitBufferWrite( bitstream, mixBits, 8 ); BitBufferWrite( bitstream, mixRes, 8 ); //Assert( (mode < 16) && (DENSHIFT_DEFAULT < 16) ); //Assert( (pbFactor < 8) && (numU < 32) ); //Assert( (pbFactor < 8) && (numV < 32) ); BitBufferWrite( bitstream, (mode << 4) | DENSHIFT_DEFAULT, 8 ); BitBufferWrite( bitstream, (pbFactor << 5) | numU, 8 ); for ( index = 0; index < numU; index++ ) BitBufferWrite( bitstream, coefsU[numU - 1][index], 16 ); BitBufferWrite( bitstream, (mode << 4) | DENSHIFT_DEFAULT, 8 ); BitBufferWrite( bitstream, (pbFactor << 5) | numV, 8 ); for ( index = 0; index < numV; index++ ) BitBufferWrite( bitstream, coefsV[numV - 1][index], 16 ); // if shift active, write the interleaved shift buffers if ( bytesShifted != 0 ) { uint32_t bitShift = bytesShifted * 8; //Assert( bitShift <= 16 ); for ( index = 0; index < (numSamples * 2); index += 2 ) { uint32_t shiftedVal; shiftedVal = ((uint32_t)mShiftBufferUV[index + 0] << bitShift) | (uint32_t)mShiftBufferUV[index + 1]; BitBufferWrite( bitstream, shiftedVal, bitShift * 2 ); } } // run the dynamic predictor and lossless compression for the "left" channel // - note: to avoid allocating more buffers, we're mixing and matching between the available buffers instead // of only using "U" buffers for the U-channel and "V" buffers for the V-channel if ( mode == 0 ) { pc_block( mMixBufferU, mPredictorU, numSamples, coefsU[numU - 1], numU, chanBits, DENSHIFT_DEFAULT ); } else { pc_block( mMixBufferU, mPredictorV, numSamples, coefsU[numU - 1], numU, chanBits, DENSHIFT_DEFAULT ); pc_block( mPredictorV, mPredictorU, numSamples, nil, 31, chanBits, 0 ); } set_ag_params( &agParams, MB0, (pbFactor * PB0) / 4, KB0, numSamples, numSamples, MAX_RUN_DEFAULT ); status = dyn_comp( &agParams, mPredictorU, bitstream, numSamples, chanBits, &bits1 ); RequireNoErr( status, goto Exit; ); // run the dynamic predictor and lossless compression for the "right" channel if ( mode == 0 ) { pc_block( mMixBufferV, mPredictorV, numSamples, coefsV[numV - 1], numV, chanBits, DENSHIFT_DEFAULT ); } else { pc_block( mMixBufferV, mPredictorU, numSamples, coefsV[numV - 1], numV, chanBits, DENSHIFT_DEFAULT ); pc_block( mPredictorU, mPredictorV, numSamples, nil, 31, chanBits, 0 ); } set_ag_params( &agParams, MB0, (pbFactor * PB0) / 4, KB0, numSamples, numSamples, MAX_RUN_DEFAULT ); status = dyn_comp( &agParams, mPredictorV, bitstream, numSamples, chanBits, &bits2 ); RequireNoErr( status, goto Exit; ); /* if we happened to create a compressed packet that was actually bigger than an escape packet would be, chuck it and do an escape packet */ minBits = BitBufferGetPosition( bitstream ) - BitBufferGetPosition( &startBits ); if ( minBits >= escapeBits ) { *bitstream = startBits; // reset bitstream state doEscape = true; } } if ( doEscape == true ) { /* escape */ status = this->EncodeStereoEscape( bitstream, inputBuffer, stride, numSamples ); #if VERBOSE_DEBUG DebugMsg( "escape!: %lu vs %lu", minBits, escapeBits ); #endif } Exit: return status; } /* EncodeStereoFast() - encode a channel pair without the search loop for maximum possible speed */ int32_t ALACEncoder::EncodeStereoFast( BitBuffer * bitstream, void * inputBuffer, uint32_t stride, uint32_t channelIndex, uint32_t numSamples ) { BitBuffer startBits = *bitstream; // squirrel away current bit position in case we decide to use escape hatch AGParamRec agParams; uint32_t bits1, bits2; int32_t mixBits, mixRes; uint32_t minBits, minBits1, minBits2; uint32_t numU, numV; uint32_t mode; uint32_t pbFactor; uint32_t chanBits; uint32_t denShift; uint8_t bytesShifted; SearchCoefs coefsU; SearchCoefs coefsV; uint32_t index; uint8_t partialFrame; uint32_t escapeBits; bool doEscape; int32_t status; // make sure we handle this bit-depth before we get going RequireAction( (mBitDepth == 16) || (mBitDepth == 20) || (mBitDepth == 24) || (mBitDepth == 32), return kALAC_ParamError; ); // reload coefs pointers for this channel pair // - note that, while you might think they should be re-initialized per block, retaining state across blocks // actually results in better overall compression // - strangely, re-using the same coefs for the different passes of the "mixRes" search loop instead of using // different coefs for the different passes of "mixRes" results in even better compression coefsU = (SearchCoefs) mCoefsU[channelIndex]; coefsV = (SearchCoefs) mCoefsV[channelIndex]; // matrix encoding adds an extra bit but 32-bit inputs cannot be matrixed b/c 33 is too many // so enable 16-bit "shift off" and encode in 17-bit mode // - in addition, 24-bit mode really improves with one byte shifted off if ( mBitDepth == 32 ) bytesShifted = 2; else if ( mBitDepth >= 24 ) bytesShifted = 1; else bytesShifted = 0; chanBits = mBitDepth - (bytesShifted * 8) + 1; // flag whether or not this is a partial frame partialFrame = (numSamples == mFrameSize) ? 0 : 1; // set up default encoding parameters for "fast" mode mixBits = kDefaultMixBits; mixRes = kDefaultMixRes; numU = numV = kDefaultNumUV; denShift = DENSHIFT_DEFAULT; mode = 0; pbFactor = 4; minBits = minBits1 = minBits2 = 1ul << 31; // mix the stereo inputs with default mixBits/mixRes switch ( mBitDepth ) { case 16: mix16( (int16_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples, mixBits, mixRes ); break; case 20: mix20( (uint8_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples, mixBits, mixRes ); break; case 24: // also extracts the shifted off bytes into the shift buffers mix24( (uint8_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples, mixBits, mixRes, mShiftBufferUV, bytesShifted ); break; case 32: // also extracts the shifted off bytes into the shift buffers mix32( (int32_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples, mixBits, mixRes, mShiftBufferUV, bytesShifted ); break; } /* speculatively write the bitstream assuming the compressed version will be smaller */ // write bitstream header and coefs BitBufferWrite( bitstream, 0, 12 ); BitBufferWrite( bitstream, (partialFrame << 3) | (bytesShifted << 1), 4 ); if ( partialFrame ) BitBufferWrite( bitstream, numSamples, 32 ); BitBufferWrite( bitstream, mixBits, 8 ); BitBufferWrite( bitstream, mixRes, 8 ); //Assert( (mode < 16) && (DENSHIFT_DEFAULT < 16) ); //Assert( (pbFactor < 8) && (numU < 32) ); //Assert( (pbFactor < 8) && (numV < 32) ); BitBufferWrite( bitstream, (mode << 4) | DENSHIFT_DEFAULT, 8 ); BitBufferWrite( bitstream, (pbFactor << 5) | numU, 8 ); for ( index = 0; index < numU; index++ ) BitBufferWrite( bitstream, coefsU[numU - 1][index], 16 ); BitBufferWrite( bitstream, (mode << 4) | DENSHIFT_DEFAULT, 8 ); BitBufferWrite( bitstream, (pbFactor << 5) | numV, 8 ); for ( index = 0; index < numV; index++ ) BitBufferWrite( bitstream, coefsV[numV - 1][index], 16 ); // if shift active, write the interleaved shift buffers if ( bytesShifted != 0 ) { uint32_t bitShift = bytesShifted * 8; //Assert( bitShift <= 16 ); for ( index = 0; index < (numSamples * 2); index += 2 ) { uint32_t shiftedVal; shiftedVal = ((uint32_t)mShiftBufferUV[index + 0] << bitShift) | (uint32_t)mShiftBufferUV[index + 1]; BitBufferWrite( bitstream, shiftedVal, bitShift * 2 ); } } // run the dynamic predictor and lossless compression for the "left" channel // - note: we always use mode 0 in the "fast" path so we don't need the code for mode != 0 pc_block( mMixBufferU, mPredictorU, numSamples, coefsU[numU - 1], numU, chanBits, DENSHIFT_DEFAULT ); set_ag_params( &agParams, MB0, (pbFactor * PB0) / 4, KB0, numSamples, numSamples, MAX_RUN_DEFAULT ); status = dyn_comp( &agParams, mPredictorU, bitstream, numSamples, chanBits, &bits1 ); RequireNoErr( status, goto Exit; ); // run the dynamic predictor and lossless compression for the "right" channel pc_block( mMixBufferV, mPredictorV, numSamples, coefsV[numV - 1], numV, chanBits, DENSHIFT_DEFAULT ); set_ag_params( &agParams, MB0, (pbFactor * PB0) / 4, KB0, numSamples, numSamples, MAX_RUN_DEFAULT ); status = dyn_comp( &agParams, mPredictorV, bitstream, numSamples, chanBits, &bits2 ); RequireNoErr( status, goto Exit; ); // do bit requirement calculations minBits1 = bits1 + (numU * sizeof(int16_t) * 8); minBits2 = bits2 + (numV * sizeof(int16_t) * 8); // test for escape hatch if best calculated compressed size turns out to be more than the input size minBits = minBits1 + minBits2 + (8 /* mixRes/maxRes/etc. */ * 8) + ((partialFrame == true) ? 32 : 0); if ( bytesShifted != 0 ) minBits += (numSamples * (bytesShifted * 8) * 2); escapeBits = (numSamples * mBitDepth * 2) + ((partialFrame == true) ? 32 : 0) + (2 * 8); /* 2 common header bytes */ doEscape = (minBits >= escapeBits) ? true : false; if ( doEscape == false ) { /* if we happened to create a compressed packet that was actually bigger than an escape packet would be, chuck it and do an escape packet */ minBits = BitBufferGetPosition( bitstream ) - BitBufferGetPosition( &startBits ); if ( minBits >= escapeBits ) { doEscape = true; } } if ( doEscape == true ) { /* escape */ // reset bitstream position since we speculatively wrote the compressed version *bitstream = startBits; // write escape frame status = this->EncodeStereoEscape( bitstream, inputBuffer, stride, numSamples ); #if VERBOSE_DEBUG DebugMsg( "escape!: %u vs %u", minBits, (numSamples * mBitDepth * 2) ); #endif } Exit: return status; } /* EncodeStereoEscape() - encode stereo escape frame */ int32_t ALACEncoder::EncodeStereoEscape( BitBuffer * bitstream, void * inputBuffer, uint32_t stride, uint32_t numSamples ) { int16_t * input16; int32_t * input32; uint8_t partialFrame; uint32_t index; // flag whether or not this is a partial frame partialFrame = (numSamples == mFrameSize) ? 0 : 1; // write bitstream header BitBufferWrite( bitstream, 0, 12 ); BitBufferWrite( bitstream, (partialFrame << 3) | 1, 4 ); // LSB = 1 means "frame not compressed" if ( partialFrame ) BitBufferWrite( bitstream, numSamples, 32 ); // just copy the input data to the output buffer switch ( mBitDepth ) { case 16: input16 = (int16_t *) inputBuffer; for ( index = 0; index < (numSamples * stride); index += stride ) { BitBufferWrite( bitstream, input16[index + 0], 16 ); BitBufferWrite( bitstream, input16[index + 1], 16 ); } break; case 20: // mix20() with mixres param = 0 means de-interleave so use it to simplify things mix20( (uint8_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples, 0, 0 ); for ( index = 0; index < numSamples; index++ ) { BitBufferWrite( bitstream, mMixBufferU[index], 20 ); BitBufferWrite( bitstream, mMixBufferV[index], 20 ); } break; case 24: // mix24() with mixres param = 0 means de-interleave so use it to simplify things mix24( (uint8_t *) inputBuffer, stride, mMixBufferU, mMixBufferV, numSamples, 0, 0, mShiftBufferUV, 0 ); for ( index = 0; index < numSamples; index++ ) { BitBufferWrite( bitstream, mMixBufferU[index], 24 ); BitBufferWrite( bitstream, mMixBufferV[index], 24 ); } break; case 32: input32 = (int32_t *) inputBuffer; for ( index = 0; index < (numSamples * stride); index += stride ) { BitBufferWrite( bitstream, input32[index + 0], 32 ); BitBufferWrite( bitstream, input32[index + 1], 32 ); } break; } return ALAC_noErr; } /* EncodeMono() - encode a mono input buffer */ int32_t ALACEncoder::EncodeMono( BitBuffer * bitstream, void * inputBuffer, uint32_t stride, uint32_t channelIndex, uint32_t numSamples ) { BitBuffer startBits = *bitstream; // squirrel away copy of current state in case we need to go back and do an escape packet AGParamRec agParams; uint32_t bits1; uint32_t numU; SearchCoefs coefsU; uint32_t dilate; uint32_t minBits, bestU; uint32_t minU, maxU; uint32_t index, index2; uint8_t bytesShifted; uint32_t shift; uint32_t mask; uint32_t chanBits; uint8_t pbFactor; uint8_t partialFrame; int16_t * input16; int32_t * input32; uint32_t escapeBits; bool doEscape; int32_t status; // make sure we handle this bit-depth before we get going RequireAction( (mBitDepth == 16) || (mBitDepth == 20) || (mBitDepth == 24) || (mBitDepth == 32), return kALAC_ParamError; ); status = ALAC_noErr; // reload coefs array from previous frame coefsU = (SearchCoefs) mCoefsU[channelIndex]; // pick bit depth for actual encoding // - we lop off the lower byte(s) for 24-/32-bit encodings if ( mBitDepth == 32 ) bytesShifted = 2; else if ( mBitDepth >= 24 ) bytesShifted = 1; else bytesShifted = 0; shift = bytesShifted * 8; mask = (1ul << shift) - 1; chanBits = mBitDepth - (bytesShifted * 8); // flag whether or not this is a partial frame partialFrame = (numSamples == mFrameSize) ? 0 : 1; // convert N-bit data to 32-bit for predictor switch ( mBitDepth ) { case 16: { // convert 16-bit data to 32-bit for predictor input16 = (int16_t *) inputBuffer; for ( index = 0, index2 = 0; index < numSamples; index++, index2 += stride ) mMixBufferU[index] = (int32_t) input16[index2]; break; } case 20: // convert 20-bit data to 32-bit for predictor copy20ToPredictor( (uint8_t *) inputBuffer, stride, mMixBufferU, numSamples ); break; case 24: // convert 24-bit data to 32-bit for the predictor and extract the shifted off byte(s) copy24ToPredictor( (uint8_t *) inputBuffer, stride, mMixBufferU, numSamples ); for ( index = 0; index < numSamples; index++ ) { mShiftBufferUV[index] = (uint16_t)(mMixBufferU[index] & mask); mMixBufferU[index] >>= shift; } break; case 32: { // just copy the 32-bit input data for the predictor and extract the shifted off byte(s) input32 = (int32_t *) inputBuffer; for ( index = 0, index2 = 0; index < numSamples; index++, index2 += stride ) { int32_t val = input32[index2]; mShiftBufferUV[index] = (uint16_t)(val & mask); mMixBufferU[index] = val >> shift; } break; } } // brute-force encode optimization loop (implied "encode depth" of 0 if comparing to cmd line tool) // - run over variations of the encoding params to find the best choice minU = 4; maxU = 8; minBits = 1ul << 31; pbFactor = 4; minBits = 1ul << 31; bestU = minU; for ( numU = minU; numU <= maxU; numU += 4 ) { BitBuffer workBits; uint32_t numBits; BitBufferInit( &workBits, mWorkBuffer, mMaxOutputBytes ); dilate = 32; for ( uint32_t converge = 0; converge < 7; converge++ ) pc_block( mMixBufferU, mPredictorU, numSamples/dilate, coefsU[numU-1], numU, chanBits, DENSHIFT_DEFAULT ); dilate = 8; pc_block( mMixBufferU, mPredictorU, numSamples/dilate, coefsU[numU-1], numU, chanBits, DENSHIFT_DEFAULT ); set_ag_params( &agParams, MB0, (pbFactor * PB0) / 4, KB0, numSamples/dilate, numSamples/dilate, MAX_RUN_DEFAULT ); status = dyn_comp( &agParams, mPredictorU, &workBits, numSamples/dilate, chanBits, &bits1 ); RequireNoErr( status, goto Exit; ); numBits = (dilate * bits1) + (16 * numU); if ( numBits < minBits ) { bestU = numU; minBits = numBits; } } // test for escape hatch if best calculated compressed size turns out to be more than the input size // - first, add bits for the header bytes mixRes/maxRes/shiftU/filterU minBits += (4 /* mixRes/maxRes/etc. */ * 8) + ((partialFrame == true) ? 32 : 0); if ( bytesShifted != 0 ) minBits += (numSamples * (bytesShifted * 8)); escapeBits = (numSamples * mBitDepth) + ((partialFrame == true) ? 32 : 0) + (2 * 8); /* 2 common header bytes */ doEscape = (minBits >= escapeBits) ? true : false; if ( doEscape == false ) { // write bitstream header BitBufferWrite( bitstream, 0, 12 ); BitBufferWrite( bitstream, (partialFrame << 3) | (bytesShifted << 1), 4 ); if ( partialFrame ) BitBufferWrite( bitstream, numSamples, 32 ); BitBufferWrite( bitstream, 0, 16 ); // mixBits = mixRes = 0 // write the params and predictor coefs numU = bestU; BitBufferWrite( bitstream, (0 << 4) | DENSHIFT_DEFAULT, 8 ); // modeU = 0 BitBufferWrite( bitstream, (pbFactor << 5) | numU, 8 ); for ( index = 0; index < numU; index++ ) BitBufferWrite( bitstream, coefsU[numU-1][index], 16 ); // if shift active, write the interleaved shift buffers if ( bytesShifted != 0 ) { for ( index = 0; index < numSamples; index++ ) BitBufferWrite( bitstream, mShiftBufferUV[index], shift ); } // run the dynamic predictor with the best result pc_block( mMixBufferU, mPredictorU, numSamples, coefsU[numU-1], numU, chanBits, DENSHIFT_DEFAULT ); // do lossless compression set_standard_ag_params( &agParams, numSamples, numSamples ); status = dyn_comp( &agParams, mPredictorU, bitstream, numSamples, chanBits, &bits1 ); //AssertNoErr( status ); /* if we happened to create a compressed packet that was actually bigger than an escape packet would be, chuck it and do an escape packet */ minBits = BitBufferGetPosition( bitstream ) - BitBufferGetPosition( &startBits ); if ( minBits >= escapeBits ) { *bitstream = startBits; // reset bitstream state doEscape = true; } } if ( doEscape == true ) { // write bitstream header and coefs BitBufferWrite( bitstream, 0, 12 ); BitBufferWrite( bitstream, (partialFrame << 3) | 1, 4 ); // LSB = 1 means "frame not compressed" if ( partialFrame ) BitBufferWrite( bitstream, numSamples, 32 ); // just copy the input data to the output buffer switch ( mBitDepth ) { case 16: input16 = (int16_t *) inputBuffer; for ( index = 0; index < (numSamples * stride); index += stride ) BitBufferWrite( bitstream, input16[index], 16 ); break; case 20: // convert 20-bit data to 32-bit for simplicity copy20ToPredictor( (uint8_t *) inputBuffer, stride, mMixBufferU, numSamples ); for ( index = 0; index < numSamples; index++ ) BitBufferWrite( bitstream, mMixBufferU[index], 20 ); break; case 24: // convert 24-bit data to 32-bit for simplicity copy24ToPredictor( (uint8_t *) inputBuffer, stride, mMixBufferU, numSamples ); for ( index = 0; index < numSamples; index++ ) BitBufferWrite( bitstream, mMixBufferU[index], 24 ); break; case 32: input32 = (int32_t *) inputBuffer; for ( index = 0; index < (numSamples * stride); index += stride ) BitBufferWrite( bitstream, input32[index], 32 ); break; } #if VERBOSE_DEBUG DebugMsg( "escape!: %lu vs %lu", minBits, (numSamples * mBitDepth) ); #endif } Exit: return status; } #if PRAGMA_MARK #pragma mark - #endif /* Encode() - encode the next block of samples */ int32_t ALACEncoder::Encode(AudioFormatDescription theInputFormat, AudioFormatDescription theOutputFormat, unsigned char * theReadBuffer, unsigned char * theWriteBuffer, int32_t * ioNumBytes) { uint32_t numFrames; uint32_t outputSize; BitBuffer bitstream; int32_t status; numFrames = *ioNumBytes/theInputFormat.mBytesPerPacket; // create a bit buffer structure pointing to our output buffer BitBufferInit( &bitstream, theWriteBuffer, mMaxOutputBytes ); if ( theInputFormat.mChannelsPerFrame == 2 ) { // add 3-bit frame start tag ID_CPE = channel pair & 4-bit element instance tag = 0 BitBufferWrite( &bitstream, ID_CPE, 3 ); BitBufferWrite( &bitstream, 0, 4 ); // encode stereo input buffer if ( mFastMode == false ) status = this->EncodeStereo( &bitstream, theReadBuffer, 2, 0, numFrames ); else status = this->EncodeStereoFast( &bitstream, theReadBuffer, 2, 0, numFrames ); RequireNoErr( status, goto Exit; ); } else if ( theInputFormat.mChannelsPerFrame == 1 ) { // add 3-bit frame start tag ID_SCE = mono channel & 4-bit element instance tag = 0 BitBufferWrite( &bitstream, ID_SCE, 3 ); BitBufferWrite( &bitstream, 0, 4 ); // encode mono input buffer status = this->EncodeMono( &bitstream, theReadBuffer, 1, 0, numFrames ); RequireNoErr( status, goto Exit; ); } else { char * inputBuffer; uint32_t tag; uint32_t channelIndex; uint32_t inputIncrement; uint8_t stereoElementTag; uint8_t monoElementTag; uint8_t lfeElementTag; inputBuffer = (char *) theReadBuffer; inputIncrement = ((mBitDepth + 7) / 8); stereoElementTag = 0; monoElementTag = 0; lfeElementTag = 0; for ( channelIndex = 0; channelIndex < theInputFormat.mChannelsPerFrame; ) { tag = (sChannelMaps[theInputFormat.mChannelsPerFrame - 1] & (0x7ul << (channelIndex * 3))) >> (channelIndex * 3); BitBufferWrite( &bitstream, tag, 3 ); switch ( tag ) { case ID_SCE: // mono BitBufferWrite( &bitstream, monoElementTag, 4 ); status = this->EncodeMono( &bitstream, inputBuffer, theInputFormat.mChannelsPerFrame, channelIndex, numFrames ); inputBuffer += inputIncrement; channelIndex++; monoElementTag++; break; case ID_CPE: // stereo BitBufferWrite( &bitstream, stereoElementTag, 4 ); status = this->EncodeStereo( &bitstream, inputBuffer, theInputFormat.mChannelsPerFrame, channelIndex, numFrames ); inputBuffer += (inputIncrement * 2); channelIndex += 2; stereoElementTag++; break; case ID_LFE: // LFE channel (subwoofer) BitBufferWrite( &bitstream, lfeElementTag, 4 ); status = this->EncodeMono( &bitstream, inputBuffer, theInputFormat.mChannelsPerFrame, channelIndex, numFrames ); inputBuffer += inputIncrement; channelIndex++; lfeElementTag++; break; default: status = kALAC_ParamError; goto Exit; } RequireNoErr( status, goto Exit; ); } } #if VERBOSE_DEBUG { // if there is room left in the output buffer, add some random fill data to test decoder int32_t bitsLeft; int32_t bytesLeft; bitsLeft = BitBufferGetPosition( &bitstream ) - 3; // - 3 for ID_END tag bytesLeft = bitstream.byteSize - ((bitsLeft + 7) / 8); if ( (bytesLeft > 20) && ((bytesLeft & 0x4u) != 0) ) AddFiller( &bitstream, bytesLeft ); } #endif // add 3-bit frame end tag: ID_END BitBufferWrite( &bitstream, ID_END, 3 ); // byte-align the output data BitBufferByteAlign( &bitstream, true ); outputSize = BitBufferGetPosition( &bitstream ) / 8; //Assert( outputSize <= mMaxOutputBytes ); // all good, let iTunes know what happened and remember the total number of input sample frames *ioNumBytes = outputSize; //mEncodedFrames += encodeMsg->numInputSamples; // gather encoding stats mTotalBytesGenerated += outputSize; mMaxFrameBytes = MAX( mMaxFrameBytes, outputSize ); status = ALAC_noErr; Exit: return status; } /* Finish() - drain out any leftover samples */ int32_t ALACEncoder::Finish() { /* // finalize bit rate statistics if ( mSampleSize.numEntries != 0 ) mAvgBitRate = (uint32_t)( (((float)mTotalBytesGenerated * 8.0f) / (float)mSampleSize.numEntries) * ((float)mSampleRate / (float)mFrameSize) ); else mAvgBitRate = 0; */ return ALAC_noErr; } #if PRAGMA_MARK #pragma mark - #endif /* GetConfig() */ void ALACEncoder::GetConfig( ALACSpecificConfig & config ) { config.frameLength = Swap32NtoB(mFrameSize); config.compatibleVersion = (uint8_t) kALACCompatibleVersion; config.bitDepth = (uint8_t) mBitDepth; config.pb = (uint8_t) PB0; config.kb = (uint8_t) KB0; config.mb = (uint8_t) MB0; config.numChannels = (uint8_t) mNumChannels; config.maxRun = Swap16NtoB((uint16_t) MAX_RUN_DEFAULT); config.maxFrameBytes = Swap32NtoB(mMaxFrameBytes); config.avgBitRate = Swap32NtoB(mAvgBitRate); config.sampleRate = Swap32NtoB(mOutputSampleRate); } uint32_t ALACEncoder::GetMagicCookieSize(uint32_t inNumChannels) { if (inNumChannels > 2) { return sizeof(ALACSpecificConfig) + kChannelAtomSize + sizeof(ALACAudioChannelLayout); } else { return sizeof(ALACSpecificConfig); } } void ALACEncoder::GetMagicCookie(void * outCookie, uint32_t * ioSize) { ALACSpecificConfig theConfig = {0}; ALACAudioChannelLayout theChannelLayout = {0}; uint8_t theChannelAtom[kChannelAtomSize] = {0, 0, 0, 0, 'c', 'h', 'a', 'n', 0, 0, 0, 0}; uint32_t theCookieSize = sizeof(ALACSpecificConfig); uint8_t * theCookiePointer = (uint8_t *)outCookie; GetConfig(theConfig); if (theConfig.numChannels > 2) { theChannelLayout.mChannelLayoutTag = Swap32NtoB(ALACChannelLayoutTags[theConfig.numChannels - 1]); theCookieSize += (sizeof(ALACAudioChannelLayout) + kChannelAtomSize); } if (*ioSize >= theCookieSize) { memcpy(theCookiePointer, &theConfig, sizeof(ALACSpecificConfig)); theChannelAtom[3] = (sizeof(ALACAudioChannelLayout) + kChannelAtomSize); if (theConfig.numChannels > 2) { theCookiePointer += sizeof(ALACSpecificConfig); memcpy(theCookiePointer, theChannelAtom, kChannelAtomSize); theCookiePointer += kChannelAtomSize; memcpy(theCookiePointer, &theChannelLayout, sizeof(ALACAudioChannelLayout)); } *ioSize = theCookieSize; } else { *ioSize = 0; // no incomplete cookies } } /* InitializeEncoder() - initialize the encoder component with the current config */ int32_t ALACEncoder::InitializeEncoder(AudioFormatDescription theOutputFormat) { int32_t status; mOutputSampleRate = theOutputFormat.mSampleRate; mNumChannels = theOutputFormat.mChannelsPerFrame; switch(theOutputFormat.mFormatFlags) { case 1: mBitDepth = 16; break; case 2: mBitDepth = 20; break; case 3: mBitDepth = 24; break; case 4: mBitDepth = 32; break; default: break; } // set up default encoding parameters and state // - note: mFrameSize is set in the constructor or via SetFrameSize() which must be called before this routine for ( uint32_t index = 0; index < kALACMaxChannels; index++ ) mLastMixRes[index] = kDefaultMixRes; // the maximum output frame size can be no bigger than (samplesPerBlock * numChannels * ((10 + sampleSize)/8) + 1) // but note that this can be bigger than the input size! // - since we don't yet know what our input format will be, use our max allowed sample size in the calculation mMaxOutputBytes = mFrameSize * mNumChannels * ((10 + kMaxSampleSize) / 8) + 1; // allocate mix buffers mMixBufferU = (int32_t *) calloc( mFrameSize * sizeof(int32_t), 1 ); mMixBufferV = (int32_t *) calloc( mFrameSize * sizeof(int32_t), 1 ); // allocate dynamic predictor buffers mPredictorU = (int32_t *) calloc( mFrameSize * sizeof(int32_t), 1 ); mPredictorV = (int32_t *) calloc( mFrameSize * sizeof(int32_t), 1 ); // allocate combined shift buffer mShiftBufferUV = (uint16_t *) calloc( mFrameSize * 2 * sizeof(uint16_t),1 ); // allocate work buffer for search loop mWorkBuffer = (uint8_t *) calloc( mMaxOutputBytes, 1 ); RequireAction( (mMixBufferU != nil) && (mMixBufferV != nil) && (mPredictorU != nil) && (mPredictorV != nil) && (mShiftBufferUV != nil) && (mWorkBuffer != nil ), status = kALAC_MemFullError; goto Exit; ); status = ALAC_noErr; // initialize coefs arrays once b/c retaining state across blocks actually improves the encode ratio for ( int32_t channel = 0; channel < (int32_t)mNumChannels; channel++ ) { for ( int32_t search = 0; search < kALACMaxSearches; search++ ) { init_coefs( mCoefsU[channel][search], DENSHIFT_DEFAULT, kALACMaxCoefs ); init_coefs( mCoefsV[channel][search], DENSHIFT_DEFAULT, kALACMaxCoefs ); } } Exit: return status; } /* GetSourceFormat() - given the input format, return one of our supported formats */ void ALACEncoder::GetSourceFormat( const AudioFormatDescription * source, AudioFormatDescription * output ) { // default is 16-bit native endian // - note: for float input we assume that's coming from one of our decoders (mp3, aac) so it only makes sense // to encode to 16-bit since the source was lossy in the first place // - note: if not a supported bit depth, find the closest supported bit depth to the input one if ( (source->mFormatID != kALACFormatLinearPCM) || ((source->mFormatFlags & kALACFormatFlagIsFloat) != 0) || ( source->mBitsPerChannel <= 16 ) ) mBitDepth = 16; else if ( source->mBitsPerChannel <= 20 ) mBitDepth = 20; else if ( source->mBitsPerChannel <= 24 ) mBitDepth = 24; else mBitDepth = 32; // we support 16/20/24/32-bit integer data at any sample rate and our target number of channels // and sample rate were specified when we were configured /* MakeUncompressedAudioFormat( mNumChannels, (float) mOutputSampleRate, mBitDepth, kAudioFormatFlagsNativeIntegerPacked, output ); */ } #if VERBOSE_DEBUG #if PRAGMA_MARK #pragma mark - #endif /* AddFiller() - add fill and data stream elements to the bitstream to test the decoder */ static void AddFiller( BitBuffer * bits, int32_t numBytes ) { uint8_t tag; uint32_t index; // out of lameness, subtract 6 bytes to deal with header + alignment as required for fill/data elements numBytes -= 6; if ( numBytes <= 0 ) return; // randomly pick Fill or Data Stream Element based on numBytes requested tag = (numBytes & 0x8) ? ID_FIL : ID_DSE; BitBufferWrite( bits, tag, 3 ); if ( tag == ID_FIL ) { // can't write more than 269 bytes in a fill element numBytes = (numBytes > 269) ? 269 : numBytes; // fill element = 4-bit size unless >= 15 then 4-bit size + 8-bit extension size if ( numBytes >= 15 ) { uint16_t extensionSize; BitBufferWrite( bits, 15, 4 ); // 8-bit extension count field is "extra + 1" which is weird but I didn't define the syntax // - otherwise, there's no way to represent 15 // - for example, to really mean 15 bytes you must encode extensionSize = 1 // - why it's not like data stream elements I have no idea extensionSize = (numBytes - 15) + 1; Assert( extensionSize <= 255 ); BitBufferWrite( bits, extensionSize, 8 ); } else BitBufferWrite( bits, numBytes, 4 ); BitBufferWrite( bits, 0x10, 8 ); // extension_type = FILL_DATA = b0001 or'ed with fill_nibble = b0000 for ( index = 0; index < (numBytes - 1); index++ ) BitBufferWrite( bits, 0xa5, 8 ); // fill_byte = b10100101 = 0xa5 } else { // can't write more than 510 bytes in a data stream element numBytes = (numBytes > 510) ? 510 : numBytes; BitBufferWrite( bits, 0, 4 ); // element instance tag BitBufferWrite( bits, 1, 1 ); // byte-align flag = true // data stream element = 8-bit size unless >= 255 then 8-bit size + 8-bit size if ( numBytes >= 255 ) { BitBufferWrite( bits, 255, 8 ); BitBufferWrite( bits, numBytes - 255, 8 ); } else BitBufferWrite( bits, numBytes, 8 ); BitBufferByteAlign( bits, true ); // byte-align with zeros for ( index = 0; index < numBytes; index++ ) BitBufferWrite( bits, 0x5a, 8 ); } } #endif /* VERBOSE_DEBUG */