diff -r 000000000000 -r 951a5db380a0 videoeditorengine/audioeditorengine/resampler/src/resampler_sinc_conv_two_to_three_int16.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/videoeditorengine/audioeditorengine/resampler/src/resampler_sinc_conv_two_to_three_int16.cpp Fri Jan 29 14:08:33 2010 +0200 @@ -0,0 +1,278 @@ +/* +* 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_two_to_three_int16.h" +#include "resampler_clip.h" +#include "resampler_sinc_conv_two_to_three_tables_standard.h" + +#include "resampler_sinc_conv_two_to_three_int16.inl" + + +#include + + +static const int LC_ZERO_CROSSINGS = RESAMPLER_TWO_TO_THREE_ZERO_CROSSINGS_STANDARD; +static const int LC_MOD3[6] = { 0, 1, 2, 0, 1, 2 }; + + +RESAMPLER_SincConvTwoToThreeInt16::RESAMPLER_SincConvTwoToThreeInt16(int channelCount) : +m_memBuffers(0), +m_scratchBuffer(0), +m_filter1(RESAMPLER_TWO_TO_THREE_FILTER1_STANDARD), +m_filter2(RESAMPLER_TWO_TO_THREE_FILTER2_STANDARD), +m_channelCount(channelCount), +m_blockSize(0), +m_channelEnabled(0), +m_inputSamples(0), +m_state(2) +{ +} + + +RESAMPLER_SincConvTwoToThreeInt16::~RESAMPLER_SincConvTwoToThreeInt16() +{ + DeInit(); +} + + +bool RESAMPLER_SincConvTwoToThreeInt16::InitInputDriven() +{ + return Init(); +} + + +bool RESAMPLER_SincConvTwoToThreeInt16::InitOutputDriven() +{ + return Init(); +} + + +/* +* This function must be called before using the converter. +* This function reserves memory for ring buffers and +* prepares the ring buffer indexing. +*/ +bool RESAMPLER_SincConvTwoToThreeInt16::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_channelCount = m_channelCount; + + 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_ZERO_CROSSINGS * 2]; + if (!m_memBuffers[i]) + { + DeInit(); + return false; + } + memset(m_memBuffers[i], 0, sizeof(int16) * (LC_ZERO_CROSSINGS * 2)); + } + + return true; +} + + +void RESAMPLER_SincConvTwoToThreeInt16::DeInit() +{ + if (m_channelCount) + { + for (int i = 0; i < m_channelCount; i++) + { + delete [] m_memBuffers[i]; + } + delete [] m_memBuffers; + delete [] m_channelEnabled; + } +} + + +void RESAMPLER_SincConvTwoToThreeInt16::EnableChannel(int channel) +{ + m_channelEnabled[channel] = true; +} + + +void RESAMPLER_SincConvTwoToThreeInt16::DisableChannel(int channel) +{ + m_channelEnabled[channel] = false; +} + + +int RESAMPLER_SincConvTwoToThreeInt16::MaxOutputSampleCount(int inSamples) const +{ + return 3 * inSamples / 2 + 1; +} + + +int RESAMPLER_SincConvTwoToThreeInt16::ProcessFromInput(int16 *outputBuffers[], + int16 *inputBuffers[], + int inSamples) +{ + int outSamples( (3*inSamples + 2 - m_state) / 2 ); + m_inputSamples = inSamples; + + return ProcessToOutput(outputBuffers, inputBuffers, outSamples); +} + + +size_t +RESAMPLER_SincConvTwoToThreeInt16::ScratchMemoryNeedOutputDriven(int maxOutputBlockSize) const +{ + return ScratchMemoryNeedInputDriven((2*maxOutputBlockSize + 2) / 3); +} + + +void +RESAMPLER_SincConvTwoToThreeInt16::SetScratchBufferOutputDriven(char *buffer) +{ + m_scratchBuffer = (int16 *)buffer; +} + +size_t +RESAMPLER_SincConvTwoToThreeInt16::ScratchMemoryNeedInputDriven(int maxInputBlockSize) const +{ + return sizeof(int16) * (LC_ZERO_CROSSINGS * 2 + maxInputBlockSize); +} + + +void +RESAMPLER_SincConvTwoToThreeInt16::SetScratchBufferInputDriven(char *buffer) +{ + m_scratchBuffer = (int16 *)buffer; +} + +int RESAMPLER_SincConvTwoToThreeInt16::MaxInputSampleCount(int outSamples) const +{ + return (2*outSamples+2)/3; +} + + +/* +* This function returns the value, which is given as +* a parameter to the nextSamplesOut() function. This +* function must be called every time before calling +* nextSamplesOut. +*/ +int RESAMPLER_SincConvTwoToThreeInt16::InSamplesNeeded(int outSamples) +{ + m_inputSamples = (2 * outSamples + m_state) / 3; + return m_inputSamples; +} + + +int RESAMPLER_SincConvTwoToThreeInt16::ProcessToOutput(int16 *outputBuffers[], + int16 *inputBuffers[], + int outSamples) +{ + static const int FILTER_LENGTH = 2 * LC_ZERO_CROSSINGS; + int i, j, k; + + int bufReadHead1 = LC_ZERO_CROSSINGS + m_state; + int bufReadHead2 = LC_ZERO_CROSSINGS + (m_state == 1 ? 1 : 0); + int bufReadHead3 = LC_ZERO_CROSSINGS + (m_state != 1 ? 1 : 0); + + for (i = 0; i < m_channelCount; i++) + { + if (!m_channelEnabled[i]) + { + break; + } + + int16 *tempBuf = m_scratchBuffer; + int16 *outBuf = outputBuffers[i]; + + memcpy(m_scratchBuffer, m_memBuffers[i], FILTER_LENGTH * sizeof(int16)); + + memcpy(tempBuf + FILTER_LENGTH, + inputBuffers[i], + m_inputSamples * sizeof(int16)); + + // copy every second sample into every third index of output buffer. + tempBuf = m_scratchBuffer + bufReadHead1; + for (j = 0, k = m_state; k < outSamples; j+=2, k+=3) + { + outBuf[k] = tempBuf[j]; + } + + // Do band limited interpolation and set the result into + // every third index in the output buffer. + tempBuf = m_scratchBuffer + bufReadHead2; + for (j = 0, k = LC_MOD3[m_state+1]; k < outSamples; j += 2, k += 3) + { + // Note that the filters are reversed + + int32 newSample = RESAMPLER_SincConvTwoToThreeFilterInt16(tempBuf + j, + m_filter2, + m_filter1, + LC_ZERO_CROSSINGS); + + // round and shift down + outBuf[k] = (int16)RESAMPLER_Clip16((newSample + 16384) >> 15); + } + + // Do band limited interpolation and set the result into + // every third index in the output buffer. + tempBuf = m_scratchBuffer + bufReadHead3; + for (j = 0, k = LC_MOD3[m_state+2]; k < outSamples; j += 2, k += 3) + { + int32 newSample = RESAMPLER_SincConvTwoToThreeFilterInt16(tempBuf + j, + m_filter1, + m_filter2, + LC_ZERO_CROSSINGS); + + // round and shift down + outBuf[k] = (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)); + } + + // Update state according to amount of output samples. + m_state = LC_MOD3[m_state + (3 - (outSamples % 3))]; + + return outSamples; +} + +