ALACDecoder.cpp

/*
 * 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:       ALACDecoder.cpp
*/

#include <stdlib.h>
#include <string.h>

#include "ALACDecoder.h"

#include "dplib.h"
#include "aglib.h"
#include "matrixlib.h"

#include "ALACBitUtilities.h"
#include "EndianPortable.h"

// constants/data
const uint32_t kMaxBitDepth = 32;           // max allowed bit depth is 32


// prototypes
static void Zero16( int16_t * buffer, uint32_t numItems, uint32_t stride );
static void Zero24( uint8_t * buffer, uint32_t numItems, uint32_t stride );
static void Zero32( int32_t * buffer, uint32_t numItems, uint32_t stride );

/*
    Constructor
*/
ALACDecoder::ALACDecoder() :
    mMixBufferU( nil ),
    mMixBufferV( nil ),
    mPredictor( nil ),
    mShiftBuffer( nil )
{
    memset( &mConfig, 0, sizeof(mConfig) );
}

/*
    Destructor
*/
ALACDecoder::~ALACDecoder()
{
    // delete the matrix mixing buffers
    if ( mMixBufferU )
    {
        free(mMixBufferU);
        mMixBufferU = NULL;
    }
    if ( mMixBufferV )
    {
        free(mMixBufferV);
        mMixBufferV = NULL;
    }

    // delete the dynamic predictor's "corrector" buffer
    // - note: mShiftBuffer shares memory with this buffer
    if ( mPredictor )
    {
        free(mPredictor);
        mPredictor = NULL;
    }
}

/*
    Init()
    - initialize the decoder with the given configuration
*/
int32_t ALACDecoder::Init( void * inMagicCookie, uint32_t inMagicCookieSize )
{
    int32_t     status = ALAC_noErr;
    ALACSpecificConfig theConfig;
    uint8_t * theActualCookie = (uint8_t *)inMagicCookie;
    uint32_t theCookieBytesRemaining = inMagicCookieSize;

    // For historical reasons the decoder needs to be resilient to magic cookies vended by older encoders.
    // As specified in the ALACMagicCookieDescription.txt document, there may be additional data encapsulating
    // the ALACSpecificConfig. This would consist of format ('frma') and 'alac' atoms which precede the
    // ALACSpecificConfig.
    // See ALACMagicCookieDescription.txt for additional documentation concerning the 'magic cookie'

    // skip format ('frma') atom if present
    if (theActualCookie[4] == 'f' && theActualCookie[5] == 'r' && theActualCookie[6] == 'm' && theActualCookie[7] == 'a')
    {
        theActualCookie += 12;
        theCookieBytesRemaining -= 12;
    }

    // skip 'alac' atom header if present
    if (theActualCookie[4] == 'a' && theActualCookie[5] == 'l' && theActualCookie[6] == 'a' && theActualCookie[7] == 'c')
    {
        theActualCookie += 12;
        theCookieBytesRemaining -= 12;
    }

    // read the ALACSpecificConfig
    if (theCookieBytesRemaining >= sizeof(ALACSpecificConfig))
    {
        theConfig.frameLength = Swap32BtoN(((ALACSpecificConfig *)theActualCookie)->frameLength);
        theConfig.compatibleVersion = ((ALACSpecificConfig *)theActualCookie)->compatibleVersion;
        theConfig.bitDepth = ((ALACSpecificConfig *)theActualCookie)->bitDepth;
        theConfig.pb = ((ALACSpecificConfig *)theActualCookie)->pb;
        theConfig.mb = ((ALACSpecificConfig *)theActualCookie)->mb;
        theConfig.kb = ((ALACSpecificConfig *)theActualCookie)->kb;
        theConfig.numChannels = ((ALACSpecificConfig *)theActualCookie)->numChannels;
        theConfig.maxRun = Swap16BtoN(((ALACSpecificConfig *)theActualCookie)->maxRun);
        theConfig.maxFrameBytes = Swap32BtoN(((ALACSpecificConfig *)theActualCookie)->maxFrameBytes);
        theConfig.avgBitRate = Swap32BtoN(((ALACSpecificConfig *)theActualCookie)->avgBitRate);
        theConfig.sampleRate = Swap32BtoN(((ALACSpecificConfig *)theActualCookie)->sampleRate);

        mConfig = theConfig;

        RequireAction( mConfig.compatibleVersion <= kALACVersion, return kALAC_ParamError; );

        // allocate mix buffers
        mMixBufferU = (int32_t *) calloc( mConfig.frameLength * sizeof(int32_t), 1 );
        mMixBufferV = (int32_t *) calloc( mConfig.frameLength * sizeof(int32_t), 1 );

        // allocate dynamic predictor buffer
        mPredictor = (int32_t *) calloc( mConfig.frameLength * sizeof(int32_t), 1 );

        // "shift off" buffer shares memory with predictor buffer
        mShiftBuffer = (uint16_t *) mPredictor;

        RequireAction( (mMixBufferU != nil) && (mMixBufferV != nil) && (mPredictor != nil),
                       status = kALAC_MemFullError; goto Exit; );
    }
    else
    {
        status = kALAC_ParamError;
    }

    // skip to Channel Layout Info
    // theActualCookie += sizeof(ALACSpecificConfig);

    // Currently, the Channel Layout Info portion of the magic cookie (as defined in the
    // ALACMagicCookieDescription.txt document) is unused by the decoder.

Exit:
    return status;
}

/*
    Decode()
    - the decoded samples are interleaved into the output buffer in the order they arrive in
      the bitstream
*/
int32_t ALACDecoder::Decode( BitBuffer * bits, uint8_t * sampleBuffer, uint32_t numSamples, uint32_t numChannels, uint32_t * outNumSamples )
{
    BitBuffer           shiftBits;
    uint32_t            bits1, bits2;
    uint8_t             tag;
    uint8_t             elementInstanceTag;
    AGParamRec          agParams;
    uint32_t                channelIndex;
    int16_t             coefsU[32];     // max possible size is 32 although NUMCOEPAIRS is the current limit
    int16_t             coefsV[32];
    uint8_t             numU, numV;
    uint8_t             mixBits;
    int8_t              mixRes;
    uint16_t            unusedHeader;
    uint8_t             escapeFlag;
    uint32_t            chanBits;
    uint8_t             bytesShifted;
    uint32_t            shift;
    uint8_t             modeU, modeV;
    uint32_t            denShiftU, denShiftV;
    uint16_t            pbFactorU, pbFactorV;
    uint16_t            pb;
    int16_t *           samples;
    int16_t *           out16;
    uint8_t *           out20;
    uint8_t *           out24;
    int32_t *           out32;
    uint8_t             headerByte;
    uint8_t             partialFrame;
    uint32_t            extraBits;
    int32_t             val;
    uint32_t            i, j;
    int32_t             status;

    RequireAction( (bits != nil) && (sampleBuffer != nil) && (outNumSamples != nil), return kALAC_ParamError; );
    RequireAction( numChannels > 0, return kALAC_ParamError; );

    mActiveElements = 0;
    channelIndex    = 0;

    samples = (int16_t *) sampleBuffer;

    status = ALAC_noErr;
    *outNumSamples = numSamples;

    while ( status == ALAC_noErr )
    {
        // bail if we ran off the end of the buffer
        RequireAction( bits->cur < bits->end, status = kALAC_ParamError; goto Exit; );

        // copy global decode params for this element
        pb = mConfig.pb;

        // read element tag
        tag = BitBufferReadSmall( bits, 3 );
        switch ( tag )
        {
        case ID_SCE:
        case ID_LFE:
        {
            // mono/LFE channel
            elementInstanceTag = BitBufferReadSmall( bits, 4 );
            mActiveElements |= (1u << elementInstanceTag);

            // read the 12 unused header bits
            unusedHeader = (uint16_t) BitBufferRead( bits, 12 );
            RequireAction( unusedHeader == 0, status = kALAC_ParamError; goto Exit; );

            // read the 1-bit "partial frame" flag, 2-bit "shift-off" flag & 1-bit "escape" flag
            headerByte = (uint8_t) BitBufferRead( bits, 4 );

            partialFrame = headerByte >> 3;

            bytesShifted = (headerByte >> 1) & 0x3u;
            RequireAction( bytesShifted != 3, status = kALAC_ParamError; goto Exit; );

            shift = bytesShifted * 8;

            escapeFlag = headerByte & 0x1;

            chanBits = mConfig.bitDepth - (bytesShifted * 8);

            // check for partial frame to override requested numSamples
            if ( partialFrame != 0 )
            {
                numSamples  = BitBufferRead( bits, 16 ) << 16;
                numSamples |= BitBufferRead( bits, 16 );
            }

            if ( escapeFlag == 0 )
            {
                // compressed frame, read rest of parameters
                mixBits = (uint8_t) BitBufferRead( bits, 8 );
                mixRes  = (int8_t) BitBufferRead( bits, 8 );
                //Assert( (mixBits == 0) && (mixRes == 0) );        // no mixing for mono

                headerByte  = (uint8_t) BitBufferRead( bits, 8 );
                modeU       = headerByte >> 4;
                denShiftU   = headerByte & 0xfu;

                headerByte  = (uint8_t) BitBufferRead( bits, 8 );
                pbFactorU   = headerByte >> 5;
                numU        = headerByte & 0x1fu;

                for ( i = 0; i < numU; i++ )
                    coefsU[i] = (int16_t) BitBufferRead( bits, 16 );

                // if shift active, skip the the shift buffer but remember where it starts
                if ( bytesShifted != 0 )
                {
                    shiftBits = *bits;
                    BitBufferAdvance( bits, (bytesShifted * 8) * numSamples );
                }

                // decompress
                set_ag_params( &agParams, mConfig.mb, (pb * pbFactorU) / 4, mConfig.kb, numSamples, numSamples, mConfig.maxRun );
                status = dyn_decomp( &agParams, bits, mPredictor, numSamples, chanBits, &bits1 );
                RequireNoErr( status, goto Exit; );

                if ( modeU == 0 )
                {
                    unpc_block( mPredictor, mMixBufferU, numSamples, &coefsU[0], numU, chanBits, denShiftU );
                }
                else
                {
                    // the special "numActive == 31" mode can be done in-place
                    unpc_block( mPredictor, mPredictor, numSamples, nil, 31, chanBits, 0 );
                    unpc_block( mPredictor, mMixBufferU, numSamples, &coefsU[0], numU, chanBits, denShiftU );
                }
            }
            else
            {
                //Assert( bytesShifted == 0 );

                // uncompressed frame, copy data into the mix buffer to use common output code
                shift = 32 - chanBits;
                if ( chanBits <= 16 )
                {
                    for ( i = 0; i < numSamples; i++ )
                    {
                        val = (int32_t) BitBufferRead( bits, (uint8_t) chanBits );
                        val = (val << shift) >> shift;
                        mMixBufferU[i] = val;
                    }
                }
                else
                {
                    // BitBufferRead() can't read more than 16 bits at a time so break up the reads
                    extraBits = chanBits - 16;
                    for ( i = 0; i < numSamples; i++ )
                    {
                        val = (int32_t) BitBufferRead( bits, 16 );
                        val = (val << 16) >> shift;
                        mMixBufferU[i] = val | BitBufferRead( bits, (uint8_t) extraBits );
                    }
                }

                mixBits = mixRes = 0;
                bits1 = chanBits * numSamples;
                bytesShifted = 0;
            }

            // now read the shifted values into the shift buffer
            if ( bytesShifted != 0 )
            {
                shift = bytesShifted * 8;
                //Assert( shift <= 16 );

                for ( i = 0; i < numSamples; i++ )
                    mShiftBuffer[i] = (uint16_t) BitBufferRead( &shiftBits, (uint8_t) shift );
            }

            // convert 32-bit integers into output buffer
            switch ( mConfig.bitDepth )
            {
            case 16:
                out16 = &((int16_t *)sampleBuffer)[channelIndex];
                for ( i = 0, j = 0; i < numSamples; i++, j += numChannels )
                    out16[j] = (int16_t) mMixBufferU[i];
                break;
            case 20:
                out20 = (uint8_t *)sampleBuffer + (channelIndex * 3);
                copyPredictorTo20( mMixBufferU, out20, numChannels, numSamples );
                break;
            case 24:
                out24 = (uint8_t *)sampleBuffer + (channelIndex * 3);
                if ( bytesShifted != 0 )
                    copyPredictorTo24Shift( mMixBufferU, mShiftBuffer, out24, numChannels, numSamples, bytesShifted );
                else
                    copyPredictorTo24( mMixBufferU, out24, numChannels, numSamples );
                break;
            case 32:
                out32 = &((int32_t *)sampleBuffer)[channelIndex];
                if ( bytesShifted != 0 )
                    copyPredictorTo32Shift( mMixBufferU, mShiftBuffer, out32, numChannels, numSamples, bytesShifted );
                else
                    copyPredictorTo32( mMixBufferU, out32, numChannels, numSamples);
                break;
            }

            channelIndex += 1;
            *outNumSamples = numSamples;
            break;
        }

        case ID_CPE:
        {
            // if decoding this pair would take us over the max channels limit, bail
            if ( (channelIndex + 2) > numChannels )
                goto NoMoreChannels;

            // stereo channel pair
            elementInstanceTag = BitBufferReadSmall( bits, 4 );
            mActiveElements |= (1u << elementInstanceTag);

            // read the 12 unused header bits
            unusedHeader = (uint16_t) BitBufferRead( bits, 12 );
            RequireAction( unusedHeader == 0, status = kALAC_ParamError; goto Exit; );

            // read the 1-bit "partial frame" flag, 2-bit "shift-off" flag & 1-bit "escape" flag
            headerByte = (uint8_t) BitBufferRead( bits, 4 );

            partialFrame = headerByte >> 3;

            bytesShifted = (headerByte >> 1) & 0x3u;
            RequireAction( bytesShifted != 3, status = kALAC_ParamError; goto Exit; );

            shift = bytesShifted * 8;

            escapeFlag = headerByte & 0x1;

            chanBits = mConfig.bitDepth - (bytesShifted * 8) + 1;

            // check for partial frame length to override requested numSamples
            if ( partialFrame != 0 )
            {
                numSamples  = BitBufferRead( bits, 16 ) << 16;
                numSamples |= BitBufferRead( bits, 16 );
            }

            if ( escapeFlag == 0 )
            {
                // compressed frame, read rest of parameters
                mixBits     = (uint8_t) BitBufferRead( bits, 8 );
                mixRes      = (int8_t) BitBufferRead( bits, 8 );

                headerByte  = (uint8_t) BitBufferRead( bits, 8 );
                modeU       = headerByte >> 4;
                denShiftU   = headerByte & 0xfu;

                headerByte  = (uint8_t) BitBufferRead( bits, 8 );
                pbFactorU   = headerByte >> 5;
                numU        = headerByte & 0x1fu;
                for ( i = 0; i < numU; i++ )
                    coefsU[i] = (int16_t) BitBufferRead( bits, 16 );

                headerByte  = (uint8_t) BitBufferRead( bits, 8 );
                modeV       = headerByte >> 4;
                denShiftV   = headerByte & 0xfu;

                headerByte  = (uint8_t) BitBufferRead( bits, 8 );
                pbFactorV   = headerByte >> 5;
                numV        = headerByte & 0x1fu;
                for ( i = 0; i < numV; i++ )
                    coefsV[i] = (int16_t) BitBufferRead( bits, 16 );

                // if shift active, skip the interleaved shifted values but remember where they start
                if ( bytesShifted != 0 )
                {
                    shiftBits = *bits;
                    BitBufferAdvance( bits, (bytesShifted * 8) * 2 * numSamples );
                }

                // decompress and run predictor for "left" channel
                set_ag_params( &agParams, mConfig.mb, (pb * pbFactorU) / 4, mConfig.kb, numSamples, numSamples, mConfig.maxRun );
                status = dyn_decomp( &agParams, bits, mPredictor, numSamples, chanBits, &bits1 );
                RequireNoErr( status, goto Exit; );

                if ( modeU == 0 )
                {
                    unpc_block( mPredictor, mMixBufferU, numSamples, &coefsU[0], numU, chanBits, denShiftU );
                }
                else
                {
                    // the special "numActive == 31" mode can be done in-place
                    unpc_block( mPredictor, mPredictor, numSamples, nil, 31, chanBits, 0 );
                    unpc_block( mPredictor, mMixBufferU, numSamples, &coefsU[0], numU, chanBits, denShiftU );
                }

                // decompress and run predictor for "right" channel
                set_ag_params( &agParams, mConfig.mb, (pb * pbFactorV) / 4, mConfig.kb, numSamples, numSamples, mConfig.maxRun );
                status = dyn_decomp( &agParams, bits, mPredictor, numSamples, chanBits, &bits2 );
                RequireNoErr( status, goto Exit; );

                if ( modeV == 0 )
                {
                    unpc_block( mPredictor, mMixBufferV, numSamples, &coefsV[0], numV, chanBits, denShiftV );
                }
                else
                {
                    // the special "numActive == 31" mode can be done in-place
                    unpc_block( mPredictor, mPredictor, numSamples, nil, 31, chanBits, 0 );
                    unpc_block( mPredictor, mMixBufferV, numSamples, &coefsV[0], numV, chanBits, denShiftV );
                }
            }
            else
            {
                //Assert( bytesShifted == 0 );

                // uncompressed frame, copy data into the mix buffers to use common output code
                chanBits = mConfig.bitDepth;
                shift = 32 - chanBits;
                if ( chanBits <= 16 )
                {
                    for ( i = 0; i < numSamples; i++ )
                    {
                        val = (int32_t) BitBufferRead( bits, (uint8_t) chanBits );
                        val = (val << shift) >> shift;
                        mMixBufferU[i] = val;

                        val = (int32_t) BitBufferRead( bits, (uint8_t) chanBits );
                        val = (val << shift) >> shift;
                        mMixBufferV[i] = val;
                    }
                }
                else
                {
                    // BitBufferRead() can't read more than 16 bits at a time so break up the reads
                    extraBits = chanBits - 16;
                    for ( i = 0; i < numSamples; i++ )
                    {
                        val = (int32_t) BitBufferRead( bits, 16 );
                        val = (val << 16) >> shift;
                        mMixBufferU[i] = val | BitBufferRead( bits, (uint8_t)extraBits );

                        val = (int32_t) BitBufferRead( bits, 16 );
                        val = (val << 16) >> shift;
                        mMixBufferV[i] = val | BitBufferRead( bits, (uint8_t)extraBits );
                    }
                }

                bits1 = chanBits * numSamples;
                bits2 = chanBits * numSamples;
                mixBits = mixRes = 0;
                bytesShifted = 0;
            }

            // now read the shifted values into the shift buffer
            if ( bytesShifted != 0 )
            {
                shift = bytesShifted * 8;
                //Assert( shift <= 16 );

                for ( i = 0; i < (numSamples * 2); i += 2 )
                {
                    mShiftBuffer[i + 0] = (uint16_t) BitBufferRead( &shiftBits, (uint8_t) shift );
                    mShiftBuffer[i + 1] = (uint16_t) BitBufferRead( &shiftBits, (uint8_t) shift );
                }
            }

            // un-mix the data and convert to output format
            // - note that mixRes = 0 means just interleave so we use that path for uncompressed frames
            switch ( mConfig.bitDepth )
            {
            case 16:
                out16 = &((int16_t *)sampleBuffer)[channelIndex];
                unmix16( mMixBufferU, mMixBufferV, out16, numChannels, numSamples, mixBits, mixRes );
                break;
            case 20:
                out20 = (uint8_t *)sampleBuffer + (channelIndex * 3);
                unmix20( mMixBufferU, mMixBufferV, out20, numChannels, numSamples, mixBits, mixRes );
                break;
            case 24:
                out24 = (uint8_t *)sampleBuffer + (channelIndex * 3);
                unmix24( mMixBufferU, mMixBufferV, out24, numChannels, numSamples,
                         mixBits, mixRes, mShiftBuffer, bytesShifted );
                break;
            case 32:
                out32 = &((int32_t *)sampleBuffer)[channelIndex];
                unmix32( mMixBufferU, mMixBufferV, out32, numChannels, numSamples,
                         mixBits, mixRes, mShiftBuffer, bytesShifted );
                break;
            }

            channelIndex += 2;
            *outNumSamples = numSamples;
            break;
        }

        case ID_CCE:
        case ID_PCE:
        {
            // unsupported element, bail
            //AssertNoErr( tag );
            status = kALAC_ParamError;
            break;
        }

        case ID_DSE:
        {
            // data stream element -- parse but ignore
            status = this->DataStreamElement( bits );
            break;
        }

        case ID_FIL:
        {
            // fill element -- parse but ignore
            status = this->FillElement( bits );
            break;
        }

        case ID_END:
        {
            // frame end, all done so byte align the frame and check for overruns
            BitBufferByteAlign( bits, false );
            //Assert( bits->cur == bits->end );
            goto Exit;
        }
        }

#if ! DEBUG
        // if we've decoded all of our channels, bail (but not in debug b/c we want to know if we're seeing bad bits)
        // - this also protects us if the config does not match the bitstream or crap data bits follow the audio bits
        if ( channelIndex >= numChannels )
            break;
#endif
    }

NoMoreChannels:

    // if we get here and haven't decoded all of the requested channels, fill the remaining channels with zeros
    for ( ; channelIndex < numChannels; channelIndex++ )
    {
        switch ( mConfig.bitDepth )
        {
        case 16:
        {
            int16_t *   fill16 = &((int16_t *)sampleBuffer)[channelIndex];
            Zero16( fill16, numSamples, numChannels );
            break;
        }
        case 24:
        {
            uint8_t *   fill24 = (uint8_t *)sampleBuffer + (channelIndex * 3);
            Zero24( fill24, numSamples, numChannels );
            break;
        }
        case 32:
        {
            int32_t *   fill32 = &((int32_t *)sampleBuffer)[channelIndex];
            Zero32( fill32, numSamples, numChannels );
            break;
        }
        }
    }

Exit:
    return status;
}

#if PRAGMA_MARK
#pragma mark -
#endif

/*
    FillElement()
    - they're just filler so we don't need 'em
*/
int32_t ALACDecoder::FillElement( BitBuffer * bits )
{
    int16_t     count;

    // 4-bit count or (4-bit + 8-bit count) if 4-bit count == 15
    // - plus this weird -1 thing I still don't fully understand
    count = BitBufferReadSmall( bits, 4 );
    if ( count == 15 )
        count += (int16_t) BitBufferReadSmall( bits, 8 ) - 1;

    BitBufferAdvance( bits, count * 8 );

    RequireAction( bits->cur <= bits->end, return kALAC_ParamError; );

    return ALAC_noErr;
}

/*
    DataStreamElement()
    - we don't care about data stream elements so just skip them
*/
int32_t ALACDecoder::DataStreamElement( BitBuffer * bits )
{
    uint8_t     element_instance_tag;
    int32_t     data_byte_align_flag;
    uint16_t        count;

    // the tag associates this data stream element with a given audio element
    element_instance_tag = BitBufferReadSmall( bits, 4 );

    data_byte_align_flag = BitBufferReadOne( bits );

    // 8-bit count or (8-bit + 8-bit count) if 8-bit count == 255
    count = BitBufferReadSmall( bits, 8 );
    if ( count == 255 )
        count += BitBufferReadSmall( bits, 8 );

    // the align flag means the bitstream should be byte-aligned before reading the following data bytes
    if ( data_byte_align_flag )
        BitBufferByteAlign( bits, false );

    // skip the data bytes
    BitBufferAdvance( bits, count * 8 );

    RequireAction( bits->cur <= bits->end, return kALAC_ParamError; );

    return ALAC_noErr;
}

/*
    ZeroN()
    - helper routines to clear out output channel buffers when decoding fewer channels than requested
*/
static void Zero16( int16_t * buffer, uint32_t numItems, uint32_t stride )
{
    if ( stride == 1 )
    {
        memset( buffer, 0, numItems * sizeof(int16_t) );
    }
    else
    {
        for ( uint32_t index = 0; index < (numItems * stride); index += stride )
            buffer[index] = 0;
    }
}

static void Zero24( uint8_t * buffer, uint32_t numItems, uint32_t stride )
{
    if ( stride == 1 )
    {
        memset( buffer, 0, numItems * 3 );
    }
    else
    {
        for ( uint32_t index = 0; index < (numItems * stride * 3); index += (stride * 3) )
        {
            buffer[index + 0] = 0;
            buffer[index + 1] = 0;
            buffer[index + 2] = 0;
        }
    }
}

static void Zero32( int32_t * buffer, uint32_t numItems, uint32_t stride )
{
    if ( stride == 1 )
    {
        memset( buffer, 0, numItems * sizeof(int32_t) );
    }
    else
    {
        for ( uint32_t index = 0; index < (numItems * stride); index += stride )
            buffer[index] = 0;
    }
}