engines/gig/Synthesizer.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 Christian Schoenebeck                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#ifndef __LS_GIG_SYNTHESIZER_H__
#define __LS_GIG_SYNTHESIZER_H__

#include "../../common/global.h"
#include "../../common/RTMath.h"
#include "../common/Resampler.h"
#include "../common/BiquadFilter.h"
#include "Filter.h"
#include "SynthesisParam.h"

#define SYNTHESIS_MODE_SET_INTERPOLATE(iMode,bVal)      if (bVal) iMode |= 0x01; else iMode &= ~0x01   /* (un)set mode bit 0 */
#define SYNTHESIS_MODE_SET_FILTER(iMode,bVal)           if (bVal) iMode |= 0x02; else iMode &= ~0x02   /* (un)set mode bit 1 */
#define SYNTHESIS_MODE_SET_LOOP(iMode,bVal)             if (bVal) iMode |= 0x04; else iMode &= ~0x04   /* (un)set mode bit 2 */
#define SYNTHESIS_MODE_SET_CHANNELS(iMode,bVal)         if (bVal) iMode |= 0x08; else iMode &= ~0x08   /* (un)set mode bit 3 */
#define SYNTHESIS_MODE_SET_IMPLEMENTATION(iMode,bVal)   if (bVal) iMode |= 0x10; else iMode &= ~0x10   /* (un)set mode bit 4 */
#define SYNTHESIS_MODE_SET_PROFILING(iMode,bVal)        if (bVal) iMode |= 0x20; else iMode &= ~0x20   /* (un)set mode bit 5 */

#define SYNTHESIS_MODE_GET_INTERPOLATE(iMode)           iMode & 0x01
#define SYNTHESIS_MODE_GET_FILTER(iMode)                iMode & 0x02
#define SYNTHESIS_MODE_GET_LOOP(iMode)                  iMode & 0x04
#define SYNTHESIS_MODE_GET_CHANNELS(iMode)              iMode & 0x08
#define SYNTHESIS_MODE_GET_IMPLEMENTATION(iMode)        iMode & 0x10

namespace LinuxSampler { namespace gig {

    typedef void SynthesizeFragment_Fn(SynthesisParam* pFinalParam, Loop* pLoop);

    void* GetSynthesisFunction(const int SynthesisMode);
    void RunSynthesisFunction(const int SynthesisMode, SynthesisParam* pFinalParam, Loop* pLoop);

    enum channels_t {
        MONO,
        STEREO
    };

    /** @brief Main Synthesis algorithms for the gig::Engine
     *
     * Implementation of the main synthesis algorithms of the Gigasampler
     * format capable sampler engine. This means resampling / interpolation
     * for pitching the audio signal, looping, filter and amplification.
     */
    template<channels_t CHANNELS, bool DOLOOP, bool USEFILTER, bool INTERPOLATE>
    class Synthesizer : public __RTMath<CPP>, public LinuxSampler::Resampler<INTERPOLATE> {

            // declarations of derived functions (see "Name lookup,
            // templates, and accessing members of base classes" in
            // the gcc manual for an explanation of why this is
            // needed).
            using __RTMath<CPP>::Mul;
            using __RTMath<CPP>::Float;
            //using LinuxSampler::Resampler<INTERPOLATE>::GetNextSampleMonoCPP;
            //using LinuxSampler::Resampler<INTERPOLATE>::GetNextSampleStereoCPP;
            using LinuxSampler::Resampler<INTERPOLATE>::Interpolate1StepMonoCPP;
            using LinuxSampler::Resampler<INTERPOLATE>::Interpolate1StepStereoCPP;

        public:
        //protected:

            static void SynthesizeSubFragment(SynthesisParam* pFinalParam, Loop* pLoop) {
                if (DOLOOP) {
                    const float fLoopEnd   = Float(pLoop->uiEnd);
                    const float fLoopStart = Float(pLoop->uiStart);
                    const float fLoopSize  = Float(pLoop->uiSize);
                    if (pLoop->uiTotalCycles) {
                        // render loop (loop count limited)
                        for (; pFinalParam->uiToGo > 0 && pLoop->uiCyclesLeft; pLoop->uiCyclesLeft -= WrapLoop(fLoopStart, fLoopSize, fLoopEnd, &pFinalParam->dPos)) {
                            const uint uiToGo = Min(pFinalParam->uiToGo, DiffToLoopEnd(fLoopEnd, &pFinalParam->dPos, pFinalParam->fFinalPitch) + 1); //TODO: instead of +1 we could also round up
                            SynthesizeSubSubFragment(pFinalParam, uiToGo);
                        }
                        // render on without loop
                        SynthesizeSubSubFragment(pFinalParam, pFinalParam->uiToGo);
                    } else { // render loop (endless loop)
                        for (; pFinalParam->uiToGo > 0; WrapLoop(fLoopStart, fLoopSize, fLoopEnd, &pFinalParam->dPos)) {
                            const uint uiToGo = Min(pFinalParam->uiToGo, DiffToLoopEnd(fLoopEnd, &pFinalParam->dPos, pFinalParam->fFinalPitch) + 1); //TODO: instead of +1 we could also round up
                            SynthesizeSubSubFragment(pFinalParam, uiToGo);
                        }
                    }
                } else { // no looping
                    SynthesizeSubSubFragment(pFinalParam, pFinalParam->uiToGo);
                }
            }

            /**
             * Returns the difference to the sample's loop end.
             */
            inline static int DiffToLoopEnd(const float& LoopEnd, const void* Pos, const float& Pitch) {
                return uint((LoopEnd - *((double *)Pos)) / Pitch);
            }

#if 0
            //TODO: this method is not in use yet, it's intended to be used for pitch=x.0f where we could use integer instead of float as playback position variable
            inline static int WrapLoop(const int& LoopStart, const int& LoopSize, const int& LoopEnd, int& Pos) {
                //TODO: we can easily eliminate the branch here
                if (Pos < LoopEnd) return 0;
                Pos = (Pos - LoopEnd) % LoopSize + LoopStart;
                return 1;
            }
#endif

            /**
             * This method handles looping of the RAM playback part of the
             * sample, thus repositioning the playback position once the
             * loop limit was reached. Note: looping of the disk streaming
             * part is handled by libgig (ReadAndLoop() method which will
             * be called by the DiskThread).
             */
            inline static int WrapLoop(const float& LoopStart, const float& LoopSize, const float& LoopEnd, void* vPos) {
                double * Pos = (double *)vPos;
                if (*Pos < LoopEnd) return 0;
                *Pos = fmod(*Pos - LoopEnd, LoopSize) + LoopStart;
                return 1;
            }

            static void SynthesizeSubSubFragment(SynthesisParam* pFinalParam, uint uiToGo) {
                switch (CHANNELS) {
                    case MONO: {
                        if (INTERPOLATE) {
                            if (USEFILTER) {
                                Filter filterL = pFinalParam->filterLeft;
                                sample_t* pSrc = pFinalParam->pSrc;
                                double dPos    = pFinalParam->dPos;
                                float fPitch   = pFinalParam->fFinalPitch;
                                float* pOutL   = pFinalParam->pOutLeft;
                                float* pOutR   = pFinalParam->pOutRight;
                                float fVolumeL = pFinalParam->fFinalVolumeLeft;
                                float fVolumeR = pFinalParam->fFinalVolumeRight;
                                float samplePoint;
                                for (int i = 0; i < uiToGo; ++i) {
                                    samplePoint = Interpolate1StepMonoCPP(pSrc, &dPos, fPitch);
                                    samplePoint = filterL.Apply(samplePoint);
                                    pOutL[i] += samplePoint * fVolumeL;
                                    pOutR[i] += samplePoint * fVolumeR;
                                }
                                pFinalParam->dPos = dPos;
                            } else { // no filter needed
                                sample_t* pSrc = pFinalParam->pSrc;
                                double dPos    = pFinalParam->dPos;
                                float fPitch   = pFinalParam->fFinalPitch;
                                float* pOutL   = pFinalParam->pOutLeft;
                                float* pOutR   = pFinalParam->pOutRight;
                                float fVolumeL = pFinalParam->fFinalVolumeLeft;
                                float fVolumeR = pFinalParam->fFinalVolumeRight;
                                float samplePoint;
                                for (int i = 0; i < uiToGo; ++i) {
                                    samplePoint = Interpolate1StepMonoCPP(pSrc, &dPos, fPitch);
                                    pOutL[i] += samplePoint * fVolumeL;
                                    pOutR[i] += samplePoint * fVolumeR;
                                }
                                pFinalParam->dPos = dPos;
                            }
                        } else { // no interpolation
                            if (USEFILTER) {
                                Filter filterL = pFinalParam->filterLeft;
                                sample_t* pSrc  = pFinalParam->pSrc;
                                float* pOutL   = pFinalParam->pOutLeft;
                                float* pOutR   = pFinalParam->pOutRight;
                                float fVolumeL = pFinalParam->fFinalVolumeLeft;
                                float fVolumeR = pFinalParam->fFinalVolumeRight;
                                int pos_offset = (int) pFinalParam->dPos;
                                float samplePoint;
                                for (int i = 0; i < uiToGo; ++i) {
                                    samplePoint = pSrc[i + pos_offset];
                                    samplePoint = filterL.Apply(samplePoint);
                                    pOutL[i] += samplePoint * fVolumeL;
                                    pOutR[i] += samplePoint * fVolumeR;
                                }
                                pFinalParam->dPos += uiToGo;
                            } else { // no filter needed
                                sample_t* pSrc  = pFinalParam->pSrc;
                                float* pOutL   = pFinalParam->pOutLeft;
                                float* pOutR   = pFinalParam->pOutRight;
                                float fVolumeL = pFinalParam->fFinalVolumeLeft;
                                float fVolumeR = pFinalParam->fFinalVolumeRight;
                                int pos_offset = (int) pFinalParam->dPos;
                                float samplePoint;
                                for (int i = 0; i < uiToGo; ++i) {
                                    samplePoint = pSrc[i + pos_offset];
                                    pOutL[i] += samplePoint * fVolumeL;
                                    pOutR[i] += samplePoint * fVolumeR;
                                }
                                pFinalParam->dPos += uiToGo;
                            }
                        }
                        break;
                    }
                    case STEREO: {
                        if (INTERPOLATE) {
                            if (USEFILTER) {
                                Filter filterL = pFinalParam->filterLeft;
                                Filter filterR = pFinalParam->filterRight;
                                sample_t* pSrc = pFinalParam->pSrc;
                                double dPos    = pFinalParam->dPos;
                                float fPitch   = pFinalParam->fFinalPitch;
                                float* pOutL   = pFinalParam->pOutLeft;
                                float* pOutR   = pFinalParam->pOutRight;
                                float fVolumeL = pFinalParam->fFinalVolumeLeft;
                                float fVolumeR = pFinalParam->fFinalVolumeRight;
                                stereo_sample_t samplePoint;
                                for (int i = 0; i < uiToGo; ++i) {
                                    samplePoint = Interpolate1StepStereoCPP(pSrc, &dPos, fPitch);
                                    samplePoint.left  = filterL.Apply(samplePoint.left);
                                    samplePoint.right = filterR.Apply(samplePoint.right);
                                    pOutL[i] += samplePoint.left  * fVolumeL;
                                    pOutR[i] += samplePoint.right * fVolumeR;
                                }
                                pFinalParam->dPos = dPos;
                            } else { // no filter needed
                                sample_t* pSrc = pFinalParam->pSrc;
                                double dPos    = pFinalParam->dPos;
                                float fPitch   = pFinalParam->fFinalPitch;
                                float* pOutL   = pFinalParam->pOutLeft;
                                float* pOutR   = pFinalParam->pOutRight;
                                float fVolumeL = pFinalParam->fFinalVolumeLeft;
                                float fVolumeR = pFinalParam->fFinalVolumeRight;
                                stereo_sample_t samplePoint;
                                for (int i = 0; i < uiToGo; ++i) {
                                    samplePoint = Interpolate1StepStereoCPP(pSrc, &dPos, fPitch);
                                    pOutL[i] += samplePoint.left  * fVolumeL;
                                    pOutR[i] += samplePoint.right * fVolumeR;
                                }
                                pFinalParam->dPos = dPos;
                            }
                        } else { // no interpolation
                            if (USEFILTER) {
                                Filter filterL = pFinalParam->filterLeft;
                                Filter filterR = pFinalParam->filterRight;
                                sample_t* pSrc  = pFinalParam->pSrc;
                                float* pOutL   = pFinalParam->pOutLeft;
                                float* pOutR   = pFinalParam->pOutRight;
                                float fVolumeL = pFinalParam->fFinalVolumeLeft;
                                float fVolumeR = pFinalParam->fFinalVolumeRight;
                                int pos_offset = ((int) pFinalParam->dPos) << 1;
                                stereo_sample_t samplePoint;
                                for (int i = 0, ii = 0; i < uiToGo; ++i, ii+=2) {
                                    samplePoint.left  = pSrc[ii + pos_offset];
                                    samplePoint.right = pSrc[ii + pos_offset + 1];
                                    samplePoint.left  = filterL.Apply(samplePoint.left);
                                    samplePoint.right = filterR.Apply(samplePoint.right);
                                    pOutL[i] += samplePoint.left  * fVolumeL;
                                    pOutR[i] += samplePoint.right * fVolumeR;
                                }
                                pFinalParam->dPos += uiToGo;
                            } else { // no filter needed
                                sample_t* pSrc  = pFinalParam->pSrc;
                                float* pOutL   = pFinalParam->pOutLeft;
                                float* pOutR   = pFinalParam->pOutRight;
                                float fVolumeL = pFinalParam->fFinalVolumeLeft;
                                float fVolumeR = pFinalParam->fFinalVolumeRight;
                                int pos_offset = ((int) pFinalParam->dPos) << 1;
                                stereo_sample_t samplePoint;
                                for (int i = 0, ii = 0; i < uiToGo; ++i, ii+=2) {
                                    samplePoint.left  = pSrc[ii + pos_offset];
                                    samplePoint.right = pSrc[ii + pos_offset + 1];
                                    pOutL[i] += samplePoint.left  * fVolumeL;
                                    pOutR[i] += samplePoint.right * fVolumeR;
                                }
                                pFinalParam->dPos += uiToGo;
                            }
                        }
                        break;
                    }
                }
                pFinalParam->pOutRight += uiToGo;
                pFinalParam->pOutLeft  += uiToGo;
                pFinalParam->uiToGo    -= uiToGo;
            }
    };

}} // namespace LinuxSampler::gig

#endif // __LS_GIG_SYNTHESIZER_H__
1	schoenebeck	320	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	schoenebeck	411	* Copyright (C) 2005 Christian Schoenebeck *
7	schoenebeck	320	* *
8			* This program is free software; you can redistribute it and/or modify *
9			* it under the terms of the GNU General Public License as published by *
10			* the Free Software Foundation; either version 2 of the License, or *
11			* (at your option) any later version. *
12			* *
13			* This program is distributed in the hope that it will be useful, *
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16			* GNU General Public License for more details. *
17			* *
18			* You should have received a copy of the GNU General Public License *
19			* along with this program; if not, write to the Free Software *
20			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21			* MA 02111-1307 USA *
22			***************************************************************************/
23
24			#ifndef __LS_GIG_SYNTHESIZER_H__
25			#define __LS_GIG_SYNTHESIZER_H__
26
27	schoenebeck	328	#include "../../common/global.h"
28	schoenebeck	320	#include "../../common/RTMath.h"
29			#include "../common/Resampler.h"
30			#include "../common/BiquadFilter.h"
31			#include "Filter.h"
32	schoenebeck	770	#include "SynthesisParam.h"
33	schoenebeck	320
34	schoenebeck	738	#define SYNTHESIS_MODE_SET_INTERPOLATE(iMode,bVal) if (bVal) iMode \|= 0x01; else iMode &= ~0x01 /* (un)set mode bit 0 */
35			#define SYNTHESIS_MODE_SET_FILTER(iMode,bVal) if (bVal) iMode \|= 0x02; else iMode &= ~0x02 /* (un)set mode bit 1 */
36			#define SYNTHESIS_MODE_SET_LOOP(iMode,bVal) if (bVal) iMode \|= 0x04; else iMode &= ~0x04 /* (un)set mode bit 2 */
37			#define SYNTHESIS_MODE_SET_CHANNELS(iMode,bVal) if (bVal) iMode \|= 0x08; else iMode &= ~0x08 /* (un)set mode bit 3 */
38			#define SYNTHESIS_MODE_SET_IMPLEMENTATION(iMode,bVal) if (bVal) iMode \|= 0x10; else iMode &= ~0x10 /* (un)set mode bit 4 */
39	schoenebeck	770	#define SYNTHESIS_MODE_SET_PROFILING(iMode,bVal) if (bVal) iMode \|= 0x20; else iMode &= ~0x20 /* (un)set mode bit 5 */
40	schoenebeck	320
41	schoenebeck	738	#define SYNTHESIS_MODE_GET_INTERPOLATE(iMode) iMode & 0x01
42			#define SYNTHESIS_MODE_GET_FILTER(iMode) iMode & 0x02
43			#define SYNTHESIS_MODE_GET_LOOP(iMode) iMode & 0x04
44			#define SYNTHESIS_MODE_GET_CHANNELS(iMode) iMode & 0x08
45			#define SYNTHESIS_MODE_GET_IMPLEMENTATION(iMode) iMode & 0x10
46
47	schoenebeck	320	namespace LinuxSampler { namespace gig {
48
49	schoenebeck	770	typedef void SynthesizeFragment_Fn(SynthesisParam* pFinalParam, Loop* pLoop);
50	schoenebeck	320
51			void* GetSynthesisFunction(const int SynthesisMode);
52	schoenebeck	770	void RunSynthesisFunction(const int SynthesisMode, SynthesisParam* pFinalParam, Loop* pLoop);
53	schoenebeck	320
54			enum channels_t {
55			MONO,
56			STEREO
57			};
58
59	schoenebeck	563	/** @brief Main Synthesis algorithms for the gig::Engine
60			*
61			* Implementation of the main synthesis algorithms of the Gigasampler
62			* format capable sampler engine. This means resampling / interpolation
63			* for pitching the audio signal, looping, filter and amplification.
64			*/
65	schoenebeck	770	template<channels_t CHANNELS, bool DOLOOP, bool USEFILTER, bool INTERPOLATE>
66			class Synthesizer : public __RTMath<CPP>, public LinuxSampler::Resampler<INTERPOLATE> {
67	persson	497
68			// declarations of derived functions (see "Name lookup,
69			// templates, and accessing members of base classes" in
70			// the gcc manual for an explanation of why this is
71			// needed).
72	schoenebeck	770	using __RTMath<CPP>::Mul;
73			using __RTMath<CPP>::Float;
74			//using LinuxSampler::Resampler<INTERPOLATE>::GetNextSampleMonoCPP;
75			//using LinuxSampler::Resampler<INTERPOLATE>::GetNextSampleStereoCPP;
76			using LinuxSampler::Resampler<INTERPOLATE>::Interpolate1StepMonoCPP;
77			using LinuxSampler::Resampler<INTERPOLATE>::Interpolate1StepStereoCPP;
78	persson	497
79	schoenebeck	320	public:
80			//protected:
81
82	schoenebeck	770	static void SynthesizeSubFragment(SynthesisParam* pFinalParam, Loop* pLoop) {
83	schoenebeck	320	if (DOLOOP) {
84	schoenebeck	770	const float fLoopEnd = Float(pLoop->uiEnd);
85			const float fLoopStart = Float(pLoop->uiStart);
86			const float fLoopSize = Float(pLoop->uiSize);
87			if (pLoop->uiTotalCycles) {
88	schoenebeck	320	// render loop (loop count limited)
89	schoenebeck	770	for (; pFinalParam->uiToGo > 0 && pLoop->uiCyclesLeft; pLoop->uiCyclesLeft -= WrapLoop(fLoopStart, fLoopSize, fLoopEnd, &pFinalParam->dPos)) {
90			const uint uiToGo = Min(pFinalParam->uiToGo, DiffToLoopEnd(fLoopEnd, &pFinalParam->dPos, pFinalParam->fFinalPitch) + 1); //TODO: instead of +1 we could also round up
91			SynthesizeSubSubFragment(pFinalParam, uiToGo);
92	schoenebeck	320	}
93			// render on without loop
94	schoenebeck	770	SynthesizeSubSubFragment(pFinalParam, pFinalParam->uiToGo);
95			} else { // render loop (endless loop)
96			for (; pFinalParam->uiToGo > 0; WrapLoop(fLoopStart, fLoopSize, fLoopEnd, &pFinalParam->dPos)) {
97			const uint uiToGo = Min(pFinalParam->uiToGo, DiffToLoopEnd(fLoopEnd, &pFinalParam->dPos, pFinalParam->fFinalPitch) + 1); //TODO: instead of +1 we could also round up
98			SynthesizeSubSubFragment(pFinalParam, uiToGo);
99	schoenebeck	320	}
100			}
101	schoenebeck	770	} else { // no looping
102			SynthesizeSubSubFragment(pFinalParam, pFinalParam->uiToGo);
103	schoenebeck	320	}
104			}
105
106	schoenebeck	563	/**
107			* Returns the difference to the sample's loop end.
108			*/
109	schoenebeck	320	inline static int DiffToLoopEnd(const float& LoopEnd, const void* Pos, const float& Pitch) {
110	schoenebeck	770	return uint((LoopEnd - ((double )Pos)) / Pitch);
111	schoenebeck	320	}
112
113	schoenebeck	770	#if 0
114	schoenebeck	738	//TODO: this method is not in use yet, it's intended to be used for pitch=x.0f where we could use integer instead of float as playback position variable
115			inline static int WrapLoop(const int& LoopStart, const int& LoopSize, const int& LoopEnd, int& Pos) {
116	schoenebeck	770	//TODO: we can easily eliminate the branch here
117			if (Pos < LoopEnd) return 0;
118			Pos = (Pos - LoopEnd) % LoopSize + LoopStart;
119			return 1;
120	schoenebeck	738	}
121	schoenebeck	770	#endif
122	schoenebeck	738
123	schoenebeck	563	/**
124			* This method handles looping of the RAM playback part of the
125			* sample, thus repositioning the playback position once the
126			* loop limit was reached. Note: looping of the disk streaming
127			* part is handled by libgig (ReadAndLoop() method which will
128			* be called by the DiskThread).
129			*/
130	schoenebeck	320	inline static int WrapLoop(const float& LoopStart, const float& LoopSize, const float& LoopEnd, void* vPos) {
131	schoenebeck	770	double * Pos = (double *)vPos;
132			if (*Pos < LoopEnd) return 0;
133			Pos = fmod(Pos - LoopEnd, LoopSize) + LoopStart;
134			return 1;
135	schoenebeck	320	}
136
137	schoenebeck	770	static void SynthesizeSubSubFragment(SynthesisParam* pFinalParam, uint uiToGo) {
138			switch (CHANNELS) {
139			case MONO: {
140			if (INTERPOLATE) {
141			if (USEFILTER) {
142			Filter filterL = pFinalParam->filterLeft;
143			sample_t* pSrc = pFinalParam->pSrc;
144			double dPos = pFinalParam->dPos;
145			float fPitch = pFinalParam->fFinalPitch;
146			float* pOutL = pFinalParam->pOutLeft;
147			float* pOutR = pFinalParam->pOutRight;
148			float fVolumeL = pFinalParam->fFinalVolumeLeft;
149			float fVolumeR = pFinalParam->fFinalVolumeRight;
150			float samplePoint;
151			for (int i = 0; i < uiToGo; ++i) {
152			samplePoint = Interpolate1StepMonoCPP(pSrc, &dPos, fPitch);
153			samplePoint = filterL.Apply(samplePoint);
154			pOutL[i] += samplePoint * fVolumeL;
155			pOutR[i] += samplePoint * fVolumeR;
156			}
157			pFinalParam->dPos = dPos;
158			} else { // no filter needed
159			sample_t* pSrc = pFinalParam->pSrc;
160			double dPos = pFinalParam->dPos;
161			float fPitch = pFinalParam->fFinalPitch;
162			float* pOutL = pFinalParam->pOutLeft;
163			float* pOutR = pFinalParam->pOutRight;
164			float fVolumeL = pFinalParam->fFinalVolumeLeft;
165			float fVolumeR = pFinalParam->fFinalVolumeRight;
166			float samplePoint;
167			for (int i = 0; i < uiToGo; ++i) {
168			samplePoint = Interpolate1StepMonoCPP(pSrc, &dPos, fPitch);
169			pOutL[i] += samplePoint * fVolumeL;
170			pOutR[i] += samplePoint * fVolumeR;
171			}
172			pFinalParam->dPos = dPos;
173	schoenebeck	320	}
174	schoenebeck	770	} else { // no interpolation
175			if (USEFILTER) {
176			Filter filterL = pFinalParam->filterLeft;
177			sample_t* pSrc = pFinalParam->pSrc;
178			float* pOutL = pFinalParam->pOutLeft;
179			float* pOutR = pFinalParam->pOutRight;
180			float fVolumeL = pFinalParam->fFinalVolumeLeft;
181			float fVolumeR = pFinalParam->fFinalVolumeRight;
182			int pos_offset = (int) pFinalParam->dPos;
183			float samplePoint;
184			for (int i = 0; i < uiToGo; ++i) {
185			samplePoint = pSrc[i + pos_offset];
186			samplePoint = filterL.Apply(samplePoint);
187			pOutL[i] += samplePoint * fVolumeL;
188			pOutR[i] += samplePoint * fVolumeR;
189	schoenebeck	320	}
190	schoenebeck	770	pFinalParam->dPos += uiToGo;
191			} else { // no filter needed
192			sample_t* pSrc = pFinalParam->pSrc;
193			float* pOutL = pFinalParam->pOutLeft;
194			float* pOutR = pFinalParam->pOutRight;
195			float fVolumeL = pFinalParam->fFinalVolumeLeft;
196			float fVolumeR = pFinalParam->fFinalVolumeRight;
197			int pos_offset = (int) pFinalParam->dPos;
198			float samplePoint;
199			for (int i = 0; i < uiToGo; ++i) {
200			samplePoint = pSrc[i + pos_offset];
201			pOutL[i] += samplePoint * fVolumeL;
202			pOutR[i] += samplePoint * fVolumeR;
203			}
204			pFinalParam->dPos += uiToGo;
205	schoenebeck	320	}
206			}
207			break;
208			}
209	schoenebeck	770	case STEREO: {
210			if (INTERPOLATE) {
211			if (USEFILTER) {
212			Filter filterL = pFinalParam->filterLeft;
213			Filter filterR = pFinalParam->filterRight;
214			sample_t* pSrc = pFinalParam->pSrc;
215			double dPos = pFinalParam->dPos;
216			float fPitch = pFinalParam->fFinalPitch;
217			float* pOutL = pFinalParam->pOutLeft;
218			float* pOutR = pFinalParam->pOutRight;
219			float fVolumeL = pFinalParam->fFinalVolumeLeft;
220			float fVolumeR = pFinalParam->fFinalVolumeRight;
221			stereo_sample_t samplePoint;
222			for (int i = 0; i < uiToGo; ++i) {
223			samplePoint = Interpolate1StepStereoCPP(pSrc, &dPos, fPitch);
224			samplePoint.left = filterL.Apply(samplePoint.left);
225			samplePoint.right = filterR.Apply(samplePoint.right);
226			pOutL[i] += samplePoint.left * fVolumeL;
227			pOutR[i] += samplePoint.right * fVolumeR;
228	schoenebeck	320	}
229	schoenebeck	770	pFinalParam->dPos = dPos;
230			} else { // no filter needed
231			sample_t* pSrc = pFinalParam->pSrc;
232			double dPos = pFinalParam->dPos;
233			float fPitch = pFinalParam->fFinalPitch;
234			float* pOutL = pFinalParam->pOutLeft;
235			float* pOutR = pFinalParam->pOutRight;
236			float fVolumeL = pFinalParam->fFinalVolumeLeft;
237			float fVolumeR = pFinalParam->fFinalVolumeRight;
238			stereo_sample_t samplePoint;
239			for (int i = 0; i < uiToGo; ++i) {
240			samplePoint = Interpolate1StepStereoCPP(pSrc, &dPos, fPitch);
241			pOutL[i] += samplePoint.left * fVolumeL;
242			pOutR[i] += samplePoint.right * fVolumeR;
243			}
244			pFinalParam->dPos = dPos;
245	schoenebeck	320	}
246	schoenebeck	770	} else { // no interpolation
247			if (USEFILTER) {
248			Filter filterL = pFinalParam->filterLeft;
249			Filter filterR = pFinalParam->filterRight;
250			sample_t* pSrc = pFinalParam->pSrc;
251			float* pOutL = pFinalParam->pOutLeft;
252			float* pOutR = pFinalParam->pOutRight;
253			float fVolumeL = pFinalParam->fFinalVolumeLeft;
254			float fVolumeR = pFinalParam->fFinalVolumeRight;
255			int pos_offset = ((int) pFinalParam->dPos) << 1;
256			stereo_sample_t samplePoint;
257			for (int i = 0, ii = 0; i < uiToGo; ++i, ii+=2) {
258			samplePoint.left = pSrc[ii + pos_offset];
259			samplePoint.right = pSrc[ii + pos_offset + 1];
260			samplePoint.left = filterL.Apply(samplePoint.left);
261			samplePoint.right = filterR.Apply(samplePoint.right);
262			pOutL[i] += samplePoint.left * fVolumeL;
263			pOutR[i] += samplePoint.right * fVolumeR;
264	schoenebeck	320	}
265	schoenebeck	770	pFinalParam->dPos += uiToGo;
266			} else { // no filter needed
267			sample_t* pSrc = pFinalParam->pSrc;
268			float* pOutL = pFinalParam->pOutLeft;
269			float* pOutR = pFinalParam->pOutRight;
270			float fVolumeL = pFinalParam->fFinalVolumeLeft;
271			float fVolumeR = pFinalParam->fFinalVolumeRight;
272			int pos_offset = ((int) pFinalParam->dPos) << 1;
273			stereo_sample_t samplePoint;
274			for (int i = 0, ii = 0; i < uiToGo; ++i, ii+=2) {
275			samplePoint.left = pSrc[ii + pos_offset];
276			samplePoint.right = pSrc[ii + pos_offset + 1];
277			pOutL[i] += samplePoint.left * fVolumeL;
278			pOutR[i] += samplePoint.right * fVolumeR;
279			}
280			pFinalParam->dPos += uiToGo;
281	schoenebeck	320	}
282			}
283	schoenebeck	770	break;
284	schoenebeck	320	}
285			}
286	schoenebeck	770	pFinalParam->pOutRight += uiToGo;
287			pFinalParam->pOutLeft += uiToGo;
288			pFinalParam->uiToGo -= uiToGo;
289	schoenebeck	320	}
290			};
291
292			}} // namespace LinuxSampler::gig
293
294			#endif // __LS_GIG_SYNTHESIZER_H__