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