diff -r 000000000000 -r 951a5db380a0 videoeditorengine/audioeditorengine/resampler/src/resampler_sinc_conv_44_to_48_int16.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/videoeditorengine/audioeditorengine/resampler/src/resampler_sinc_conv_44_to_48_int16.cpp Fri Jan 29 14:08:33 2010 +0200 @@ -0,0 +1,352 @@ +/* +* 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 + +#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; +} +