/*
* 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_44_to_48_int16.h"
#include "resampler_clip.h"
#include "resampler_sinc_conv_44_to_48_tables_economy.h"
#include "resampler_sinc_conv_44_to_48_tables_standard.h"
#include "resampler_sinc_conv_44_to_48_tables_premium.h"

#include <string.h>

#include "resampler_sinc_conv_filter_int16.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_ZERO_CROSSINGS = RESAMPLER_44_TO_48_ZERO_CROSSINGS_PREMIUM;

static const int LC_BUFFER_ACCESS_OUTPUT = LC_MAX_ZERO_CROSSINGS;

/*
 * The number of filters needed in 44.1 to 48 kHz sinc interpolation
 * sampling rate conversion. Filter symmetry is utilized.
 */
static const int LC_FILTER_COUNT = 160;

/*
 * Calculated as 160-147.
 * 147/160 is the smallest ratio of 44100/48000.
 * Used as a hop increment in the filter table defined below.
 */
static const int LC_MATRIX_HOP_SIZE = 13;       

/*
 * This constant is calculated as ceil(2^23/160).
 * and used in InSamplesNeeded() method to 
 * avoid the division by 160. The result of the multiplication
 * has to be shifted afterwards by 23 bits right.
 */
static const int LC_SAMPLE_COUNT_MULT = 52429;   

/** Do not remove! LC_MAX_BLOCK_SIZE used in assert!
 */
#if 0
/* 
 * M_INPUT_COUNT_MULT * (6289*13+160) = 4294826393 (0xfffdd999).
 * 6289 is the largest number that fits 32 bits in the
 * input sample count multiplication method.
 */
static const int LC_MAX_BLOCK_SIZE = 6289;      
#endif // 0


RESAMPLER_SincConv44To48Int16::RESAMPLER_SincConv44To48Int16(int channelCount) :
m_memBuffers(0),
m_scratchBuffer(0),
m_channelCount(channelCount),
m_blockSize(0),
m_channelEnabled(0),
m_inputSamples(0),
m_index1(LC_FILTER_COUNT),
m_index2(0),
m_zeroCrossings(RESAMPLER_44_TO_48_ZERO_CROSSINGS_STANDARD),
m_filterMatrix(RESAMPLER_44_TO_48_FILTERS_STANDARD)
{
}


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

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


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

bool RESAMPLER_SincConv44To48Int16::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_ZERO_CROSSINGS * 2];
        if (!m_memBuffers[i])
        {
            DeInit();
            return false;
        }
        memset(m_memBuffers[i], 0, sizeof(int16) * (LC_MAX_ZERO_CROSSINGS * 2));
    }

    return true;
}

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

bool 
RESAMPLER_SincConv44To48Int16::SetQualityInputDriven(int mode)
{
    return SetQualityOutputDriven(mode);
}

bool 
RESAMPLER_SincConv44To48Int16::SetQualityOutputDriven(int mode)
{
    switch (mode)
    {
    case RESAMPLER_RATE_CONVERSION_QUALITY_ECONOMY:
        m_zeroCrossings = RESAMPLER_44_TO_48_ZERO_CROSSINGS_ECONOMY;
        m_filterMatrix  = RESAMPLER_44_TO_48_FILTERS_ECONOMY;
        break;
    case RESAMPLER_RATE_CONVERSION_QUALITY_STANDARD:
        m_zeroCrossings = RESAMPLER_44_TO_48_ZERO_CROSSINGS_STANDARD;
        m_filterMatrix  = RESAMPLER_44_TO_48_FILTERS_STANDARD;
        break;
    case RESAMPLER_RATE_CONVERSION_QUALITY_PREMIUM:
        m_zeroCrossings = RESAMPLER_44_TO_48_ZERO_CROSSINGS_PREMIUM;
        m_filterMatrix  = RESAMPLER_44_TO_48_FILTERS_PREMIUM;
        break;
    default:
        return false;
    }
    return true;
}

void 
RESAMPLER_SincConv44To48Int16::EnableChannelInputDriven(int channel)
{
    EnableChannelOutputDriven(channel);
}


void 
RESAMPLER_SincConv44To48Int16::DisableChannelInputDriven(int channel)
{
    DisableChannelOutputDriven(channel);
}


void 
RESAMPLER_SincConv44To48Int16::EnableChannelOutputDriven(int channel)
{
    m_channelEnabled[channel] = true;
}


void 
RESAMPLER_SincConv44To48Int16::DisableChannelOutputDriven(int channel)
{
    m_channelEnabled[channel] = false;
}

size_t 
RESAMPLER_SincConv44To48Int16::ScratchMemoryNeedInputDriven(int maxInputBlockSize) const
{
    /** 6289 == LC_MAX_BLOCK_SIZE
     */
    if (maxInputBlockSize > 6289 * 44100.0/48000.0)
        {
        return 0;
        }

    return sizeof(int16) * (LC_MAX_ZERO_CROSSINGS * 2 + maxInputBlockSize);
}

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

size_t 
RESAMPLER_SincConv44To48Int16::ScratchMemoryNeedOutputDriven(int maxOutputBlockSize) const
{
    int blockSize =  (int)((maxOutputBlockSize * 44100.0/48000.0) + 1); 
    
    return ScratchMemoryNeedInputDriven(blockSize);
}

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



int 
RESAMPLER_SincConv44To48Int16::MaxInputSampleCount(int outSamples) const
{ 
    return (int)((outSamples * (44100.0 / 48000.0)) + 1); 
}


int 
RESAMPLER_SincConv44To48Int16::InSamplesNeeded(int outSamples)
{
    m_inputSamples = outSamples - ((LC_SAMPLE_COUNT_MULT * (outSamples*13+m_index2)) >> 23);
 
    return m_inputSamples;
}

int 
RESAMPLER_SincConv44To48Int16::MaxOutputSampleCount(int inSamples) const
{ 
    return (int)(inSamples * 160.0 / 147.0 + 1.0); 
}


int RESAMPLER_SincConv44To48Int16::ProcessFromInput(int16 *outputBuffers[], 
                                              int16 *inputBuffers[], 
                                              int inSamples)
{
    int outSamples = (int)((inSamples * 160.0 + m_index2) / 147.0);
    m_inputSamples = inSamples;
    return ProcessToOutput(outputBuffers, inputBuffers, outSamples);
}

int 
RESAMPLER_SincConv44To48Int16::ProcessToOutput(int16 *outputBuffers[], 
                                         int16 *inputBuffers[], 
                                         int outSamples)
{
    static const int FILTER_LENGTH = 2 * LC_MAX_ZERO_CROSSINGS;
	int i, j;
    int index1 = m_index1;
    int index2 = m_index2;

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

        int16 *tempBuf = m_scratchBuffer;
        int16 *outBuf  = outputBuffers[i];
        index1 = m_index1; /* 160 SRC filter number */
        index2 = m_index2; /* 0 */
        
        int state = 0;

        memcpy(m_scratchBuffer, 
               m_memBuffers[i], 
               FILTER_LENGTH * sizeof(int16));

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

        // Do band limited interpolation and set the result into 
        // every index in the output buffer. 
        for (j = 0; j < outSamples; j++) 
        {
            index1 -= LC_MATRIX_HOP_SIZE; /* -13 */ 
            index2 += LC_MATRIX_HOP_SIZE;  /* +13 */ 

            if (index1 <= 0)
            {
                index1 += LC_FILTER_COUNT; /* +160 */
                index2 -= LC_FILTER_COUNT;  /* -160 */
                state++;
            }

            /*lint -e{662} */
            const int16 *filterPtr1 = m_filterMatrix + index1 * m_zeroCrossings;
            const int16 *filterPtr2 = m_filterMatrix + index2 * m_zeroCrossings;
              
            int32 newSample = 
                RESAMPLER_SincConvFilterInt16(tempBuf + LC_BUFFER_ACCESS_OUTPUT - state + j,
                                        filterPtr1,
                                        filterPtr2,
                                        m_zeroCrossings);
             
            // 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 + m_inputSamples, 
               FILTER_LENGTH * sizeof(int16));       
    }

    m_index1 = index1;
    m_index2 = index2;

	return outSamples;
}