1422 lines
46 KiB
C++
1422 lines
46 KiB
C++
/*
|
|
* 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 <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#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 */
|