PageRenderTime 110ms CodeModel.GetById 20ms app.highlight 34ms RepoModel.GetById 1ms app.codeStats 0ms

/external/pysoundtouch14/libsoundtouch/mmx_optimized.cpp

http://echo-nest-remix.googlecode.com/
C++ | 305 lines | 138 code | 68 blank | 99 comment | 6 complexity | 19b2dd27bb322136dc97dea54d3c85b3 MD5 | raw file
  1////////////////////////////////////////////////////////////////////////////////
  2///
  3/// MMX optimized routines. All MMX optimized functions have been gathered into 
  4/// this single source code file, regardless to their class or original source 
  5/// code file, in order to ease porting the library to other compiler and 
  6/// processor platforms.
  7///
  8/// The MMX-optimizations are programmed using MMX compiler intrinsics that
  9/// are supported both by Microsoft Visual C++ and GCC compilers, so this file
 10/// should compile with both toolsets.
 11///
 12/// NOTICE: If using Visual Studio 6.0, you'll need to install the "Visual C++ 
 13/// 6.0 processor pack" update to support compiler intrinsic syntax. The update
 14/// is available for download at Microsoft Developers Network, see here:
 15/// http://msdn.microsoft.com/en-us/vstudio/aa718349.aspx
 16///
 17/// Author        : Copyright (c) Olli Parviainen
 18/// Author e-mail : oparviai 'at' iki.fi
 19/// SoundTouch WWW: http://www.surina.net/soundtouch
 20///
 21////////////////////////////////////////////////////////////////////////////////
 22//
 23// Last changed  : $Date: 2009-01-25 16:13:39 +0200 (Sun, 25 Jan 2009) $
 24// File revision : $Revision: 4 $
 25//
 26// $Id: mmx_optimized.cpp 51 2009-01-25 14:13:39Z oparviai $
 27//
 28////////////////////////////////////////////////////////////////////////////////
 29//
 30// License :
 31//
 32//  SoundTouch audio processing library
 33//  Copyright (c) Olli Parviainen
 34//
 35//  This library is free software; you can redistribute it and/or
 36//  modify it under the terms of the GNU Lesser General Public
 37//  License as published by the Free Software Foundation; either
 38//  version 2.1 of the License, or (at your option) any later version.
 39//
 40//  This library is distributed in the hope that it will be useful,
 41//  but WITHOUT ANY WARRANTY; without even the implied warranty of
 42//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 43//  Lesser General Public License for more details.
 44//
 45//  You should have received a copy of the GNU Lesser General Public
 46//  License along with this library; if not, write to the Free Software
 47//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 48//
 49////////////////////////////////////////////////////////////////////////////////
 50
 51#include "STTypes.h"

 52
 53#ifdef ALLOW_MMX

 54// MMX routines available only with integer sample type
 55
 56//#if !(WIN32 || __i386__ || __x86_64__)
 57//#error "wrong platform - this source code file is exclusively for x86 platforms"
 58//#endif
 59
 60using namespace soundtouch;
 61
 62//////////////////////////////////////////////////////////////////////////////
 63//
 64// implementation of MMX optimized functions of class 'TDStretchMMX'
 65//
 66//////////////////////////////////////////////////////////////////////////////
 67
 68#include "TDStretch.h"

 69#include <mmintrin.h>

 70#include <limits.h>

 71
 72
 73// Calculates cross correlation of two buffers
 74long TDStretchMMX::calcCrossCorrStereo(const short *pV1, const short *pV2) const
 75{
 76    const __m64 *pVec1, *pVec2;
 77    __m64 shifter;
 78    __m64 accu;
 79    long corr;
 80    int i;
 81   
 82    pVec1 = (__m64*)pV1;
 83    pVec2 = (__m64*)pV2;
 84
 85    shifter = _m_from_int(overlapDividerBits);
 86    accu = _mm_setzero_si64();
 87
 88    // Process 4 parallel sets of 2 * stereo samples each during each 
 89    // round to improve CPU-level parallellization.
 90    for (i = 0; i < overlapLength / 8; i ++)
 91    {
 92        __m64 temp;
 93
 94        // dictionary of instructions:
 95        // _m_pmaddwd   : 4*16bit multiply-add, resulting two 32bits = [a0*b0+a1*b1 ; a2*b2+a3*b3]
 96        // _mm_add_pi32 : 2*32bit add
 97        // _m_psrad     : 32bit right-shift
 98
 99        temp = _mm_add_pi32(_mm_madd_pi16(pVec1[0], pVec2[0]),
100                            _mm_madd_pi16(pVec1[1], pVec2[1]));
101        accu = _mm_add_pi32(accu, _mm_sra_pi32(temp, shifter));
102
103        temp = _mm_add_pi32(_mm_madd_pi16(pVec1[2], pVec2[2]),
104                            _mm_madd_pi16(pVec1[3], pVec2[3]));
105        accu = _mm_add_pi32(accu, _mm_sra_pi32(temp, shifter));
106
107        pVec1 += 4;
108        pVec2 += 4;
109    }
110
111    // copy hi-dword of mm0 to lo-dword of mm1, then sum mmo+mm1
112    // and finally store the result into the variable "corr"
113
114    accu = _mm_add_pi32(accu, _mm_srli_si64(accu, 32));
115    corr = _m_to_int(accu);
116
117    // Clear MMS state
118    _m_empty();
119
120    return corr;
121    // Note: Warning about the missing EMMS instruction is harmless
122    // as it'll be called elsewhere.
123}
124
125
126
127void TDStretchMMX::clearCrossCorrState()
128{
129    // Clear MMS state
130    _m_empty();
131    //_asm EMMS;
132}
133
134
135
136// MMX-optimized version of the function overlapStereo
137void TDStretchMMX::overlapStereo(short *output, const short *input) const
138{
139    const __m64 *pVinput, *pVMidBuf;
140    __m64 *pVdest;
141    __m64 mix1, mix2, adder, shifter;
142    int i;
143
144    pVinput  = (const __m64*)input;
145    pVMidBuf = (const __m64*)pMidBuffer;
146    pVdest   = (__m64*)output;
147
148    // mix1  = mixer values for 1st stereo sample
149    // mix1  = mixer values for 2nd stereo sample
150    // adder = adder for updating mixer values after each round
151    
152    mix1  = _mm_set_pi16(0, overlapLength,   0, overlapLength);
153    adder = _mm_set_pi16(1, -1, 1, -1);
154    mix2  = _mm_add_pi16(mix1, adder);
155    adder = _mm_add_pi16(adder, adder);
156
157    shifter = _m_from_int(overlapDividerBits);
158
159    for (i = 0; i < overlapLength / 4; i ++)
160    {
161        __m64 temp1, temp2;
162                
163        // load & shuffle data so that input & mixbuffer data samples are paired
164        temp1 = _mm_unpacklo_pi16(pVMidBuf[0], pVinput[0]);     // = i0l m0l i0r m0r
165        temp2 = _mm_unpackhi_pi16(pVMidBuf[0], pVinput[0]);     // = i1l m1l i1r m1r
166
167        // temp = (temp .* mix) >> shifter
168        temp1 = _mm_sra_pi32(_mm_madd_pi16(temp1, mix1), shifter);
169        temp2 = _mm_sra_pi32(_mm_madd_pi16(temp2, mix2), shifter);
170        pVdest[0] = _mm_packs_pi32(temp1, temp2); // pack 2*2*32bit => 4*16bit
171
172        // update mix += adder
173        mix1 = _mm_add_pi16(mix1, adder);
174        mix2 = _mm_add_pi16(mix2, adder);
175
176        // --- second round begins here ---
177
178        // load & shuffle data so that input & mixbuffer data samples are paired
179        temp1 = _mm_unpacklo_pi16(pVMidBuf[1], pVinput[1]);       // = i2l m2l i2r m2r
180        temp2 = _mm_unpackhi_pi16(pVMidBuf[1], pVinput[1]);       // = i3l m3l i3r m3r
181
182        // temp = (temp .* mix) >> shifter
183        temp1 = _mm_sra_pi32(_mm_madd_pi16(temp1, mix1), shifter);
184        temp2 = _mm_sra_pi32(_mm_madd_pi16(temp2, mix2), shifter);
185        pVdest[1] = _mm_packs_pi32(temp1, temp2); // pack 2*2*32bit => 4*16bit
186
187        // update mix += adder
188        mix1 = _mm_add_pi16(mix1, adder);
189        mix2 = _mm_add_pi16(mix2, adder);
190
191        pVinput  += 2;
192        pVMidBuf += 2;
193        pVdest   += 2;
194    }
195
196    _m_empty(); // clear MMS state
197}
198
199
200//////////////////////////////////////////////////////////////////////////////
201//
202// implementation of MMX optimized functions of class 'FIRFilter'
203//
204//////////////////////////////////////////////////////////////////////////////
205
206#include "FIRFilter.h"

207
208
209FIRFilterMMX::FIRFilterMMX() : FIRFilter()
210{
211    filterCoeffsUnalign = NULL;
212}
213
214
215FIRFilterMMX::~FIRFilterMMX()
216{
217    delete[] filterCoeffsUnalign;
218}
219
220
221// (overloaded) Calculates filter coefficients for MMX routine
222void FIRFilterMMX::setCoefficients(const short *coeffs, uint newLength, uint uResultDivFactor)
223{
224    uint i;
225    FIRFilter::setCoefficients(coeffs, newLength, uResultDivFactor);
226
227    // Ensure that filter coeffs array is aligned to 16-byte boundary
228    delete[] filterCoeffsUnalign;
229    filterCoeffsUnalign = new short[2 * newLength + 8];
230    filterCoeffsAlign = (short *)(((ulong)filterCoeffsUnalign + 15) & -16);
231
232    // rearrange the filter coefficients for mmx routines 
233    for (i = 0;i < length; i += 4) 
234    {
235        filterCoeffsAlign[2 * i + 0] = coeffs[i + 0];
236        filterCoeffsAlign[2 * i + 1] = coeffs[i + 2];
237        filterCoeffsAlign[2 * i + 2] = coeffs[i + 0];
238        filterCoeffsAlign[2 * i + 3] = coeffs[i + 2];
239
240        filterCoeffsAlign[2 * i + 4] = coeffs[i + 1];
241        filterCoeffsAlign[2 * i + 5] = coeffs[i + 3];
242        filterCoeffsAlign[2 * i + 6] = coeffs[i + 1];
243        filterCoeffsAlign[2 * i + 7] = coeffs[i + 3];
244    }
245}
246
247
248
249// mmx-optimized version of the filter routine for stereo sound
250uint FIRFilterMMX::evaluateFilterStereo(short *dest, const short *src, uint numSamples) const
251{
252    // Create stack copies of the needed member variables for asm routines :
253    uint i, j;
254    __m64 *pVdest = (__m64*)dest;
255
256    if (length < 2) return 0;
257
258    for (i = 0; i < numSamples / 2; i ++)
259    {
260        __m64 accu1;
261        __m64 accu2;
262        const __m64 *pVsrc = (const __m64*)src;
263        const __m64 *pVfilter = (const __m64*)filterCoeffsAlign;
264
265        accu1 = accu2 = _mm_setzero_si64();
266        for (j = 0; j < lengthDiv8 * 2; j ++)
267        {
268            __m64 temp1, temp2;
269
270            temp1 = _mm_unpacklo_pi16(pVsrc[0], pVsrc[1]);  // = l2 l0 r2 r0
271            temp2 = _mm_unpackhi_pi16(pVsrc[0], pVsrc[1]);  // = l3 l1 r3 r1
272
273            accu1 = _mm_add_pi32(accu1, _mm_madd_pi16(temp1, pVfilter[0]));  // += l2*f2+l0*f0 r2*f2+r0*f0
274            accu1 = _mm_add_pi32(accu1, _mm_madd_pi16(temp2, pVfilter[1]));  // += l3*f3+l1*f1 r3*f3+r1*f1
275
276            temp1 = _mm_unpacklo_pi16(pVsrc[1], pVsrc[2]);  // = l4 l2 r4 r2
277
278            accu2 = _mm_add_pi32(accu2, _mm_madd_pi16(temp2, pVfilter[0]));  // += l3*f2+l1*f0 r3*f2+r1*f0
279            accu2 = _mm_add_pi32(accu2, _mm_madd_pi16(temp1, pVfilter[1]));  // += l4*f3+l2*f1 r4*f3+r2*f1
280
281            // accu1 += l2*f2+l0*f0 r2*f2+r0*f0
282            //       += l3*f3+l1*f1 r3*f3+r1*f1
283
284            // accu2 += l3*f2+l1*f0 r3*f2+r1*f0
285            //          l4*f3+l2*f1 r4*f3+r2*f1
286
287            pVfilter += 2;
288            pVsrc += 2;
289        }
290        // accu >>= resultDivFactor
291        accu1 = _mm_srai_pi32(accu1, resultDivFactor);
292        accu2 = _mm_srai_pi32(accu2, resultDivFactor);
293
294        // pack 2*2*32bits => 4*16 bits
295        pVdest[0] = _mm_packs_pi32(accu1, accu2);
296        src += 4;
297        pVdest ++;
298    }
299
300   _m_empty();  // clear emms state
301
302    return (numSamples & 0xfffffffe) - length;
303}
304
305#endif  // ALLOW_MMX