/*
* Copyright (c) 2010 Ixonos Plc.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - Initial contribution
*
* Contributors:
* Ixonos Plc
*
* Description:
*
*/


#include "resampler_sinc_conv_three_to_one_int16.h"
#include "resampler_clip.h"
#include "resampler_sinc_conv_three_to_one_tables_standard.h"
#include "resampler_sinc_conv_filter_three_to_one_int16.h"


#include <string.h>

/*
 * The amount of zero crossings in positive or negative
 * side of the sinc function. Because of filter symmetry
 * the amount of filter taps used in convolution is
 * zero crossings * 2.
 */
static const int LC_MAX_COEFF_COUNT = RESAMPLER_THREE_TO_ONE_COEFF_COUNT_STANDARD;

static const int LC_BUFFER_ACCESS_OUTPUT = LC_MAX_COEFF_COUNT - 1;


RESAMPLER_SincConvThreeToOneInt16::RESAMPLER_SincConvThreeToOneInt16(int channelCount) :
m_memBuffers(0),
m_scratchBuffer(0),
m_channelCount(channelCount),
m_blockSize(0),
m_channelEnabled(0),
m_state(0),
m_coeffCount(RESAMPLER_THREE_TO_ONE_COEFF_COUNT_STANDARD),
m_filterMatrix(RESAMPLER_THREE_TO_ONE_FILTERS_STANDARD)
{
}


RESAMPLER_SincConvThreeToOneInt16::~RESAMPLER_SincConvThreeToOneInt16()
{
    DeInit();
}

bool RESAMPLER_SincConvThreeToOneInt16::InitInputDriven()
{
    return Init();
}

bool RESAMPLER_SincConvThreeToOneInt16::InitOutputDriven()
{
    return Init();
}

bool 
RESAMPLER_SincConvThreeToOneInt16::Init()
{
    int i(0);

    m_memBuffers = new int16 *[m_channelCount];
    if (!m_memBuffers)
    {
        return false;
    }

    for (i = 0; i < m_channelCount; i++) 
    {
        m_memBuffers[i] = 0;
    }

    m_channelEnabled = new bool[m_channelCount];
    if (!m_channelEnabled)
    {
        DeInit();
        return false;
    }
    for (i = 0; i < m_channelCount; i++) 
    {
        m_channelEnabled[i] = true;
    }

    for (i = 0; i < m_channelCount; i++) 
    {
        m_memBuffers[i] = new int16[LC_MAX_COEFF_COUNT * 2 - 1];
        if (!m_memBuffers[i])
        {
            DeInit();
            return false;
        }
        memset(m_memBuffers[i], 0, sizeof(int16) * (LC_MAX_COEFF_COUNT * 2 - 1));
    }

    return true;
}

void 
RESAMPLER_SincConvThreeToOneInt16::DeInit()
{
    if (m_channelCount)
    {
        for (int i = 0; i < m_channelCount; i++)
        {
            delete [] m_memBuffers[i];
        }
        delete [] m_memBuffers;
        delete [] m_channelEnabled;
    }
}


void 
RESAMPLER_SincConvThreeToOneInt16::EnableChannel(int channel)
{
    m_channelEnabled[channel] = true;
}

void 
RESAMPLER_SincConvThreeToOneInt16::DisableChannel(int channel)
{
    m_channelEnabled[channel] = false;
}

size_t 
RESAMPLER_SincConvThreeToOneInt16::ScratchMemoryNeedInputDriven(int maxInputBlockSize) const
{
    return sizeof(int16) * ((LC_MAX_COEFF_COUNT * 2 - 1) + maxInputBlockSize);
}

void 
RESAMPLER_SincConvThreeToOneInt16::SetScratchBufferInputDriven(char *buffer)
{
    m_scratchBuffer = (int16 *)buffer;
}

size_t 
RESAMPLER_SincConvThreeToOneInt16::ScratchMemoryNeedOutputDriven(int maxOutputBlockSize) const
{
    int blockSize = 3 * maxOutputBlockSize; 
    
    return ScratchMemoryNeedInputDriven(blockSize);
}

void 
RESAMPLER_SincConvThreeToOneInt16::SetScratchBufferOutputDriven(char *buffer)
{
    m_scratchBuffer = (int16 *)buffer;
}


int 
RESAMPLER_SincConvThreeToOneInt16::MaxOutputSampleCount(int inSamples) const 
{ 
    return ( inSamples + 2 ) / 3; 
}

int 
RESAMPLER_SincConvThreeToOneInt16::MaxInputSampleCount(int outSamples) const
{ 
    return 3 * outSamples; 
}


int 
RESAMPLER_SincConvThreeToOneInt16::InSamplesNeeded(int outSamples)
{
    return 3 * outSamples;
}


int 
RESAMPLER_SincConvThreeToOneInt16::ProcessToOutput(int16 *outputBuffers[], 
                                             int16 *inputBuffers[], 
                                             int outSamples)
{
    int inSamples( 3 * outSamples );
    
    return ProcessFromInput(outputBuffers, inputBuffers, inSamples);
}

int 
RESAMPLER_SincConvThreeToOneInt16::ProcessFromInput(int16 *outputBuffers[], 
                                              int16 *inputBuffers[], 
                                              int inSamples)
{
    static const int FILTER_LENGTH = LC_MAX_COEFF_COUNT * 2 - 1;
	int i, j;
    int state = m_state;
	int outSamples = (inSamples + state) / 3;

    for (i = 0; i < m_channelCount; i++) 
    {
        if (!m_channelEnabled[i])
        {
            break;
        }

        int16 *tempBuf = m_scratchBuffer;
        int16 *outBuf  = outputBuffers[i];
        state = m_state;
        
        memcpy(m_scratchBuffer, 
               m_memBuffers[i], 
               FILTER_LENGTH * sizeof(int16));

        // Read samples into memory
        memcpy(tempBuf + FILTER_LENGTH, 
               inputBuffers[i], 
               inSamples * sizeof(int16));

        tempBuf += LC_BUFFER_ACCESS_OUTPUT - state;

        for (j = 0; j < outSamples; j++) 
        {
            int32 newSample = 
                RESAMPLER_SincConvFilterThreeToOneInt16(tempBuf,
									              m_filterMatrix,
												  m_coeffCount);
            tempBuf += 3;

            // round and shift down
	        outBuf[j] = (int16)RESAMPLER_Clip16((newSample + 16384 ) >> 15);
		}
        
        // Copy the newest samples to the beginning of the buffer
        memcpy(m_memBuffers[i], 
               m_scratchBuffer + inSamples, 
               FILTER_LENGTH * sizeof(int16));       
    }

    m_state = (state + inSamples) % 3;

	return outSamples;
}