Commit 6cda0a5f authored by sagnowski's avatar sagnowski
Browse files

Clean up float/int buffer usage in decoder executable, non-VoIP

parent 5df99fe9
Loading
Loading
Loading
Loading
+124 −74
Original line number Diff line number Diff line
@@ -45,6 +45,9 @@
#include "head_rotation_file_reader.h"
#include "jbm_file_writer.h"
#include "evs_rtp_payload.h"
#ifdef FLOAT_INTERFACE_ENC
#include "buffer_conversions.h"
#endif
#ifdef DEBUGGING
#include "debug.h"
#endif
@@ -123,7 +126,12 @@ typedef struct

static bool parseCmdlIVAS_dec( int16_t argc, char **argv, DecArguments *arg );
static void usage_dec( void );
static ivas_error decodeG192( DecArguments arg, BS_READER_HANDLE hBsReader, HeadRotFileReader *headRotReader, IVAS_DEC_HANDLE hIvasDec, int16_t *pcmBuf );
static ivas_error decodeG192( DecArguments arg, BS_READER_HANDLE hBsReader, HeadRotFileReader *headRotReader, IVAS_DEC_HANDLE hIvasDec
#ifndef FLOAT_INTERFACE_ENC
                              ,
                              int16_t *pcmBuf
#endif
);
static ivas_error decodeVoIP( DecArguments arg, BS_READER_HANDLE hBsReader, IVAS_DEC_HANDLE hIvasDec );
#ifdef DEBUGGING
static ivas_error printBitstreamInfoVoip( DecArguments arg, BS_READER_HANDLE hBsReader, IVAS_DEC_HANDLE hIvasDec );
@@ -131,61 +139,6 @@ static int16_t app_own_random( int16_t *seed );
static IVAS_DEC_FORCED_REND_MODE parseForcedRendModeDec( char *forcedRendModeChar );
#endif

#ifdef FLOAT_INTERFACE_DEC_REND
/* TODO(sgi): move to lib_util, re-use between renderer, encoder and decoder */
/*--------------------------------------------------------------------------*
 * copyBufferPackedFloatToInterleavedInt()
 *
 *
 *--------------------------------------------------------------------------*/

static void copyBufferPackedFloatToInterleavedInt(
    const float *inBuffer,
    const int16_t numSamplesPerChannel,
    const int16_t numChannels,
    int16_t *outBuffer )
{
    int16_t chnl, smpl;

    for ( chnl = 0; chnl < numChannels; ++chnl )
    {
        for ( smpl = 0; smpl < numSamplesPerChannel; ++smpl )
        {
            /* TODO(sgi): This is not bit-exact with what is done in ivas_syn_output() */
            outBuffer[smpl * numChannels + chnl] = inBuffer[chnl * numSamplesPerChannel + smpl];
        }
    }

    return;
}

/* TODO(sgi): move to lib_util, re-use between renderer, encoder and decoder */
/*--------------------------------------------------------------------------*
 * copyBufferPackedFloatToInterleavedInt()
 *
 *
 *--------------------------------------------------------------------------*/

static void copyBufferPackedIntToInterleavedInt(
    const int16_t *inBuffer,
    const int16_t numSamplesPerChannel,
    const int16_t numChannels,
    int16_t *outBuffer )
{
    int16_t chnl, smpl;

    for ( chnl = 0; chnl < numChannels; ++chnl )
    {
        for ( smpl = 0; smpl < numSamplesPerChannel; ++smpl )
        {
            outBuffer[smpl * numChannels + chnl] = inBuffer[chnl * numSamplesPerChannel + smpl];
        }
    }

    return;
}
#endif


/*------------------------------------------------------------------------------------------*
 * main()
@@ -205,7 +158,9 @@ int main(
    hrtfFileReader *hrtfReader = NULL;
    HeadRotFileReader *headRotReader = NULL;
    ivas_error error = IVAS_ERR_UNKNOWN;
#ifndef FLOAT_INTERFACE_ENC
    int16_t pcmBuf[MAX_OUTPUT_PCM_BUFFER_SIZE];
#endif
    RenderConfigReader *renderConfigReader = NULL;
#ifdef DEBUGGING
    int32_t noClipping;
@@ -546,7 +501,11 @@ int main(
    }
    else
    {
#ifdef FLOAT_INTERFACE_ENC
        error = decodeG192( arg, hBsReader, headRotReader, hIvasDec );
#else
        error = decodeG192( arg, hBsReader, headRotReader, hIvasDec, pcmBuf );
#endif
    }

    if ( error == IVAS_ERR_OK || error == IVAS_ERR_END_OF_FILE )
@@ -1333,9 +1292,12 @@ static ivas_error decodeG192(
    DecArguments arg,
    BS_READER_HANDLE hBsReader,
    HeadRotFileReader *headRotReader,
    IVAS_DEC_HANDLE hIvasDec,
    int16_t *pcmBuf )

    IVAS_DEC_HANDLE hIvasDec
#ifndef FLOAT_INTERFACE_ENC
    ,
    int16_t *pcmBuf
#endif
)
{
    bool decodingFailed = true; /* Assume failure until cleanup is reached without errors */
    uint16_t bit_stream[IVAS_MAX_BITS_PER_FRAME + 4 * 8];
@@ -1356,6 +1318,12 @@ static ivas_error decodeG192(
    ivas_error error = IVAS_ERR_UNKNOWN;
    uint16_t numObj = 0;
    IVAS_DEC_BS_FORMAT bsFormat = IVAS_DEC_BS_UNKOWN;
#ifdef FLOAT_INTERFACE_ENC
    int16_t *audioDecBufInt = NULL;   /* Buffer for receiving audio from decoder via int interface. Packed. */
    float *audioDecBufFloat = NULL;   /* Buffer for receiving audio from decoder via float interface. Packed. */
    int16_t *audioWriteBufInt = NULL; /* Buffer for writing audio to int wav/pcm files. Interleaved. */
    float *audioWriteBufFloat = NULL; /* Buffer for reading audio to float wav files. Interleaved. */
#endif

    IsmFileWriter *ismWriters[IVAS_MAX_NUM_OBJECTS];
    for ( i = 0; i < IVAS_MAX_NUM_OBJECTS; ++i )
@@ -1373,6 +1341,46 @@ static ivas_error decodeG192(
        fprintf( stdout, "\n-- Start the decoder (quiet mode) --\n\n" );
    }

#ifdef FLOAT_INTERFACE_ENC
    /*------------------------------------------------------------------------------------------*
     * Allocate output audio buffers
     *------------------------------------------------------------------------------------------*/

    if ( arg.outputFormat == IVAS_DEC_OUTPUT_EXT )
    {
        nOutChannels = 4; /* Currently allocating max expected */ /* TODO(sgi): Get this from decoder before GetSamples() is called - then EXT is no longer a special case */
    }
    else
    {
        if ( ( error = IVAS_DEC_GetNumOutputChannels( hIvasDec, &nOutChannels ) ) != IVAS_ERR_OK )
        {
            goto cleanup;
        }
    }
    nOutSamples = arg.output_Fs / 50; /* TODO(sgi): Get from API */

    bool outputFileIsFloat = false; /* TODO(sgi):  */
    bool useInt16Interface = true;  /* TODO(sgi):  */

    if ( useInt16Interface )
    {
        audioDecBufInt = malloc( nOutChannels * nOutSamples * sizeof( int16_t ) );
    }
    else
    {
        audioDecBufFloat = malloc( nOutChannels * nOutSamples * sizeof( float ) );
    }

    if ( outputFileIsFloat )
    {
        audioWriteBufFloat = malloc( nOutChannels * nOutSamples * sizeof( float ) );
    }
    else
    {
        audioWriteBufInt = malloc( nOutChannels * nOutSamples * sizeof( int16_t ) );
    }
#endif

#ifdef WMOPS
    reset_stack();
    reset_wmops();
@@ -1440,24 +1448,24 @@ static ivas_error decodeG192(
        }

#ifdef FLOAT_INTERFACE_DEC_REND
        bool useFloat = false; /* TODO(sgi): get from input file type or command line flag */
        if (useFloat)
        if ( useInt16Interface )
        {
            if ( ( error = IVAS_DEC_GetSamplesInt( hIvasDec, audioDecBufInt, &nOutSamples ) ) != IVAS_ERR_OK )
            {
                fprintf( stderr, "\nError: could not get samples from decoder: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );
                goto cleanup;
            }
        }
        else
        {
            // /* TODO(sgi): Don't allocate on every frame, use correct size */
            error = IVAS_ERR_NOT_IMPLEMENTED;
            goto cleanup;
            // if ( ( error = IVAS_DEC_GetSamplesFloat( hIvasDec, tmpFloatBuf, &nOutSamples ) ) != IVAS_ERR_OK )
            // {
            //     fprintf( stderr, "\nError: could not get samples from decoder: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );
            //     goto cleanup;
            // }
        }
        else
        {
            if ( ( error = IVAS_DEC_GetSamplesInt( hIvasDec, pcmBuf, &nOutSamples ) ) != IVAS_ERR_OK )
            {
                fprintf( stderr, "\nError: could not get samples from decoder: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );
                goto cleanup;
            }
        }
#else
        /* Run decoder for one frame (get rendered output) */
        if ( ( error = IVAS_DEC_GetSamples( hIvasDec, pcmBuf, &nOutSamples ) ) != IVAS_ERR_OK )
@@ -1511,17 +1519,35 @@ static ivas_error decodeG192(
            if ( delayNumSamples < nOutSamples )
            {
#ifdef FLOAT_INTERFACE_DEC_REND
                int16_t pcmBufInterleaved[MAX_OUTPUT_PCM_BUFFER_SIZE];
                copyBufferPackedIntToInterleavedInt(pcmBuf, nOutSamples, nOutChannels, pcmBufInterleaved);
                if ( outputFileIsFloat )
                {
                    error = IVAS_ERR_NOT_IMPLEMENTED;
                    goto cleanup;
                }
                else
                {
                    if ( outputFileIsFloat )
                    {
                        copyBufferPackedIntToInterleavedFloat( audioDecBufInt, nOutSamples, audioWriteBufFloat, nOutSamples, nOutChannels );
                    }
                    else
                    {
                        copyBufferPackedIntToInterleavedInt( audioDecBufInt, nOutSamples, audioWriteBufInt, nOutSamples, nOutChannels );
                    }

                if ( ( error = AudioFileWriter_write( afWriter, &pcmBufInterleaved[delayNumSamples * nOutChannels], nOutSamples * nOutChannels - ( delayNumSamples * nOutChannels ) ) ) != IVAS_ERR_OK )
                    if ( ( error = AudioFileWriter_write( afWriter, &audioWriteBufInt[delayNumSamples * nOutChannels], nOutSamples * nOutChannels - ( delayNumSamples * nOutChannels ) ) ) != IVAS_ERR_OK )
                    {
                        fprintf( stderr, "\nOutput audio file writer error\n" );
                        goto cleanup;
                    }
                }
#else
                if ( ( error = AudioFileWriter_write( afWriter, &pcmBuf[delayNumSamples * nOutChannels], nOutSamples * nOutChannels - ( delayNumSamples * nOutChannels ) ) ) != IVAS_ERR_OK )
#endif
                {
                    fprintf( stderr, "\nOutput audio file writer error\n" );
                    goto cleanup;
                }
#endif
                delayNumSamples = 0;
            }
            else
@@ -1621,12 +1647,29 @@ static ivas_error decodeG192(
    }

    /* add zeros at the end to have equal length of synthesized signals */
#ifdef FLOAT_INTERFACE_ENC
    if ( outputFileIsFloat )
    {
        error = IVAS_ERR_NOT_IMPLEMENTED;
        goto cleanup;
    }
    else
    {
        memset( audioWriteBufInt, 0, delayNumSamples_orig * nOutChannels * sizeof( int16_t ) );
        if ( ( error = AudioFileWriter_write( afWriter, audioWriteBufInt, delayNumSamples_orig * nOutChannels ) ) != IVAS_ERR_OK )
        {
            fprintf( stderr, "\nError writing output file: %s\n", ivas_error_to_string( error ) );
            goto cleanup;
        }
    }
#else
    memset( pcmBuf, 0, delayNumSamples_orig * nOutChannels * sizeof( int16_t ) );
    if ( ( error = AudioFileWriter_write( afWriter, pcmBuf, delayNumSamples_orig * nOutChannels ) ) != IVAS_ERR_OK )
    {
        fprintf( stderr, "\nError writing output file: %s\n", ivas_error_to_string( error ) );
        goto cleanup;
    }
#endif

    /*------------------------------------------------------------------------------------------*
     * Close files and deallocate resources
@@ -1636,6 +1679,13 @@ static ivas_error decodeG192(

cleanup:

#ifdef FLOAT_INTERFACE_ENC
    free( audioDecBufInt );
    free( audioDecBufFloat );
    free( audioWriteBufInt );
    free( audioWriteBufFloat );
#endif

    AudioFileWriter_close( &afWriter );
    MasaFileWriter_close( &masaWriter );
    for ( i = 0; i < IVAS_MAX_NUM_OBJECTS; i++ )
+1 −1
Original line number Diff line number Diff line
@@ -179,7 +179,7 @@ int main(
        ismReaders[i] = NULL;
    }
#ifdef FLOAT_INTERFACE_ENC
    int16_t *audioReadBufInt = NULL; /* Buffer for reading audio from int wav files. Interleaved. */
    int16_t *audioReadBufInt = NULL; /* Buffer for reading audio from int wav/pcm files. Interleaved. */
    float *audioReadBufFloat = NULL; /* Buffer for reading audio from float wav files. Interleaved. */
    int16_t *audioFeedBufInt = NULL; /* Buffer for feeding audio to encoder via int interface. Packed. */
    float *audioFeedBufFloat = NULL; /* Buffer for feeding audio to encoder via float interface. Packed. */
+43 −9
Original line number Diff line number Diff line
@@ -439,7 +439,7 @@ ivas_error IVAS_DEC_Configure(
        hDecoderConfig->nchan_out = 1;
    }

    if ( outputFormat != IVAS_DEC_OUTPUT_EXT && outputFormat != IVAS_DEC_OUTPUT_LS_CUSTOM )
    if ( outputFormat != IVAS_DEC_OUTPUT_EXT && outputFormat != IVAS_DEC_OUTPUT_LS_CUSTOM ) /* TODO(sgi): Why not possible to get nchan_out with custom ls setup at this point? */
    {
        hDecoderConfig->nchan_out = audioCfg2channels( hDecoderConfig->output_config );
    }
@@ -772,8 +772,7 @@ ivas_error IVAS_DEC_GetSamples(
ivas_error IVAS_DEC_GetSamplesFloat(
    IVAS_DEC_HANDLE hIvasDec,
    float *pcmBuf,
    int16_t *nOutSamples
)
    int16_t *nOutSamples )
{
    Decoder_Struct *st_ivas;
    ivas_error error;
@@ -882,6 +881,38 @@ ivas_error IVAS_DEC_GetNumOutputChannels(
    int16_t *numOutputChannels /* o  : number of PCM output channels   */
)
{
#ifdef FLOAT_INTERFACE_ENC
    if ( hIvasDec->st_ivas->hDecoderConfig->output_config == AUDIO_CONFIG_EXTERNAL )
    {
        /* Number of output channels is only known once bitstream config is known. */
        if ( hIvasDec->hasDecodedFirstGoodFrame )
        {
            *numOutputChannels = hIvasDec->st_ivas->hDecoderConfig->nchan_out;
        }
        else
        {
            return IVAS_ERR_NUM_CHANNELS_UNKNOWN;
        }
    }
    else if ( hIvasDec->st_ivas->hDecoderConfig->output_config == AUDIO_CONFIG_LS_CUSTOM )
    {
        /* When hLsSetupCustom allocated, it is initialized with num_spk = -1 and num_lfe = -1.
         * If these values have not changed, this means that a valid custom setup was not yet provided to the decoder via IVAS_DEC_FeedCustomLsData(). */
        if ( hIvasDec->st_ivas->hLsSetupCustom->num_spk > 0 || hIvasDec->st_ivas->hLsSetupCustom->num_lfe > 0 )
        {
            *numOutputChannels = hIvasDec->st_ivas->hLsSetupCustom->num_spk + hIvasDec->st_ivas->hLsSetupCustom->num_lfe;
        }
        else
        {
            return IVAS_ERR_NUM_CHANNELS_UNKNOWN;
        }
    }
    else
    {
        /* For all other configs, number of channels is known after call to IVAS_DEC_Configure() */
        *numOutputChannels = hIvasDec->st_ivas->hDecoderConfig->nchan_out;
    }
#else
    if ( hIvasDec->hasDecodedFirstGoodFrame )
    {
        *numOutputChannels = hIvasDec->st_ivas->hDecoderConfig->nchan_out;
@@ -890,6 +921,7 @@ ivas_error IVAS_DEC_GetNumOutputChannels(
    {
        *numOutputChannels = 0;
    }
#endif

    return IVAS_ERR_OK;
}
@@ -1322,6 +1354,7 @@ ivas_error IVAS_DEC_HasDecodedFirstGoodFrame(
 *
 *---------------------------------------------------------------------*/

/* TODO(sgi): Also add function for numSamplesPerChannel for consistency with encoder */
ivas_error IVAS_DEC_GetPcmFrameSize(
    IVAS_DEC_HANDLE hIvasDec, /* i/o: IVAS decoder handle                                                     */
    int32_t *pcmFrameSize     /* o  : total size of the PCM output frame. This takes into account the number of output channels */
@@ -1332,6 +1365,7 @@ ivas_error IVAS_DEC_GetPcmFrameSize(
        return IVAS_ERR_UNEXPECTED_NULL_POINTER;
    }

    /* TODO(sgi): Make this work also without good frame for configs other than EXT */
    if ( hIvasDec->hasDecodedFirstGoodFrame )
    {
        *pcmFrameSize = hIvasDec->st_ivas->hDecoderConfig->nchan_out * hIvasDec->st_ivas->hDecoderConfig->output_Fs / FRAMES_PER_SEC;
+125 −0
Original line number Diff line number Diff line
@@ -174,4 +174,129 @@ void copyBufferInterleavedIntToPackedInt(

    return;
}

/*--------------------------------------------------------------------------*
 * copyBufferPackedFloatToInterleavedFloat()
 *
 *--------------------------------------------------------------------------*/
void copyBufferPackedFloatToInterleavedFloat(
    const float *srcBuffer,
    const int16_t srcBufferNumSamplesPerChannel,
    float *dstBuffer,
    const int16_t dstBufferNumSamplesPerChannel,
    const int16_t dstBufferNumChannels )
{
    int16_t chnl, smpl;

    for ( smpl = 0; smpl < dstBufferNumSamplesPerChannel; ++smpl )
    {
        for ( chnl = 0; chnl < dstBufferNumChannels; ++chnl )
        {
            if ( smpl < srcBufferNumSamplesPerChannel )
            {
                dstBuffer[smpl * dstBufferNumChannels + chnl] = srcBuffer[chnl * srcBufferNumSamplesPerChannel + smpl];
            }
            else
            {
                dstBuffer[smpl * dstBufferNumChannels + chnl] = 0.0f;
            }
        }
    }

    return;
}

/*--------------------------------------------------------------------------*
 * copyBufferPackedFloatToInterleavedInt()
 *
 *--------------------------------------------------------------------------*/
void copyBufferPackedFloatToInterleavedInt(
    const float *srcBuffer,
    const int16_t srcBufferNumSamplesPerChannel,
    int16_t *dstBuffer,
    const int16_t dstBufferNumSamplesPerChannel,
    const int16_t dstBufferNumChannels )
{
    int16_t chnl, smpl;

    for ( smpl = 0; smpl < dstBufferNumSamplesPerChannel; ++smpl )
    {
        for ( chnl = 0; chnl < dstBufferNumChannels; ++chnl )
        {
            if ( smpl < srcBufferNumSamplesPerChannel )
            {
                dstBuffer[smpl * dstBufferNumChannels + chnl] = (int16_t) srcBuffer[chnl * srcBufferNumSamplesPerChannel + smpl];
            }
            else
            {
                dstBuffer[smpl * dstBufferNumChannels + chnl] = 0;
            }
        }
    }

    return;
}

/*--------------------------------------------------------------------------*
 * copyBufferPackedIntToInterleavedFloat()
 *
 *--------------------------------------------------------------------------*/
void copyBufferPackedIntToInterleavedFloat(
    const int16_t *srcBuffer,
    const int16_t srcBufferNumSamplesPerChannel,
    float *dstBuffer,
    const int16_t dstBufferNumSamplesPerChannel,
    const int16_t dstBufferNumChannels )
{
    int16_t chnl, smpl;

    for ( smpl = 0; smpl < dstBufferNumSamplesPerChannel; ++smpl )
    {
        for ( chnl = 0; chnl < dstBufferNumChannels; ++chnl )
        {
            if ( smpl < srcBufferNumSamplesPerChannel )
            {
                dstBuffer[smpl * dstBufferNumChannels + chnl] = (float) srcBuffer[chnl * srcBufferNumSamplesPerChannel + smpl];
            }
            else
            {
                dstBuffer[smpl * dstBufferNumChannels + chnl] = 0.0f;
            }
        }
    }

    return;
}

/*--------------------------------------------------------------------------*
 * copyBufferPackedIntToInterleavedInt()
 *
 *--------------------------------------------------------------------------*/
void copyBufferPackedIntToInterleavedInt(
    const int16_t *srcBuffer,
    const int16_t srcBufferNumSamplesPerChannel,
    int16_t *dstBuffer,
    const int16_t dstBufferNumSamplesPerChannel,
    const int16_t dstBufferNumChannels )
{
    int16_t chnl, smpl;

    for ( smpl = 0; smpl < dstBufferNumSamplesPerChannel; ++smpl )
    {
        for ( chnl = 0; chnl < dstBufferNumChannels; ++chnl )
        {
            if ( smpl < srcBufferNumSamplesPerChannel )
            {
                dstBuffer[smpl * dstBufferNumChannels + chnl] = srcBuffer[chnl * srcBufferNumSamplesPerChannel + smpl];
            }
            else
            {
                dstBuffer[smpl * dstBufferNumChannels + chnl] = 0;
            }
        }
    }

    return;
}

#endif
+34 −5
Original line number Diff line number Diff line
@@ -40,32 +40,61 @@

void copyBufferInterleavedFloatToPackedFloat(
    const float *srcBuffer,
    const int16_t srcBufferTotalNumSamples,
    const int16_t srcBufferTotalNumSamples, /* TODO(sgi): Change to num samples per channel */
    float *dstBuffer,
    const int16_t dstBufferNumSamplesPerChannel,
    const int16_t dstBufferNumChannels );

void copyBufferInterleavedFloatToPackedInt(
    const float *srcBuffer,
    const int16_t srcBufferTotalNumSamples,
    const int16_t srcBufferTotalNumSamples,  /* TODO(sgi): Change to num samples per channel */
    int16_t *dstBuffer,
    const int16_t dstBufferNumSamplesPerChannel,
    const int16_t dstBufferNumChannels );

void copyBufferInterleavedIntToPackedFloat(
    const int16_t *srcBuffer,
    const int16_t srcBufferTotalNumSamples,
    const int16_t srcBufferTotalNumSamples,  /* TODO(sgi): Change to num samples per channel */
    float *dstBuffer,
    const int16_t dstBufferNumSamplesPerChannel,
    const int16_t dstBufferNumChannels );

void copyBufferInterleavedIntToPackedInt(
    const int16_t *srcBuffer,
    const int16_t srcBufferTotalNumSamples,
    const int16_t srcBufferTotalNumSamples,  /* TODO(sgi): Change to num samples per channel */
    int16_t *dstBuffer,
    const int16_t dstBufferNumSamplesPerChannel,
    const int16_t dstBufferNumChannels );
#endif

void copyBufferPackedFloatToInterleavedFloat(
    const float *srcBuffer,
    const int16_t srcBufferNumSamplesPerChannel,
    float *dstBuffer,
    const int16_t dstBufferNumSamplesPerChannel,
    const int16_t dstBufferNumChannels );

void copyBufferPackedFloatToInterleavedInt(
    const float *srcBuffer,
    const int16_t srcBufferNumSamplesPerChannel,
    int16_t *dstBuffer,
    const int16_t dstBufferNumSamplesPerChannel,
    const int16_t dstBufferNumChannels );

void copyBufferPackedIntToInterleavedFloat(
    const int16_t *srcBuffer,
    const int16_t srcBufferNumSamplesPerChannel,
    float *dstBuffer,
    const int16_t dstBufferNumSamplesPerChannel,
    const int16_t dstBufferNumChannels );

void copyBufferPackedIntToInterleavedInt(
    const int16_t *srcBuffer,
    const int16_t srcBufferNumSamplesPerChannel,
    int16_t *dstBuffer,
    const int16_t dstBufferNumSamplesPerChannel,
    const int16_t dstBufferNumChannels );


#endif /* FLOAT_INTERFACE_ENC */

#endif