/[svn]/linuxsampler/trunk/src/engines/gig/Synthesizer.h
ViewVC logotype

Diff of /linuxsampler/trunk/src/engines/gig/Synthesizer.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 320 by schoenebeck, Mon Dec 13 00:53:16 2004 UTC revision 332 by senkov, Sat Jan 1 03:06:06 2005 UTC
# Line 23  Line 23 
23  #ifndef __LS_GIG_SYNTHESIZER_H__  #ifndef __LS_GIG_SYNTHESIZER_H__
24  #define __LS_GIG_SYNTHESIZER_H__  #define __LS_GIG_SYNTHESIZER_H__
25    
26    #include "../../common/global.h"
27  #include "../../common/RTMath.h"  #include "../../common/RTMath.h"
28  #include "../common/Resampler.h"  #include "../common/Resampler.h"
29  #include "../common/BiquadFilter.h"  #include "../common/BiquadFilter.h"
30  #include "Filter.h"  #include "Filter.h"
31  #include "Voice.h"  #include "Voice.h"
32    
33  #define SYNTHESIS_MODE_SET_CONSTPITCH(iMode,bVal)       if (bVal) iMode |= 0x01; else iMode &= 0xfe   /* (un)set mode bit 0 */  #define SYNTHESIS_MODE_SET_CONSTPITCH(iMode,bVal)       if (bVal) iMode |= 0x01; else iMode &= ~0x01   /* (un)set mode bit 0 */
34  #define SYNTHESIS_MODE_SET_LOOP(iMode,bVal)             if (bVal) iMode |= 0x02; else iMode &= 0xfd   /* (un)set mode bit 1 */  #define SYNTHESIS_MODE_SET_LOOP(iMode,bVal)             if (bVal) iMode |= 0x02; else iMode &= ~0x02   /* (un)set mode bit 1 */
35  #define SYNTHESIS_MODE_SET_INTERPOLATE(iMode,bVal)      if (bVal) iMode |= 0x04; else iMode &= 0xfb   /* (un)set mode bit 2 */  #define SYNTHESIS_MODE_SET_INTERPOLATE(iMode,bVal)      if (bVal) iMode |= 0x04; else iMode &= ~0x04   /* (un)set mode bit 2 */
36  #define SYNTHESIS_MODE_SET_FILTER(iMode,bVal)           if (bVal) iMode |= 0x08; else iMode &= 0xf7   /* (un)set mode bit 3 */  #define SYNTHESIS_MODE_SET_FILTER(iMode,bVal)           if (bVal) iMode |= 0x08; else iMode &= ~0x08   /* (un)set mode bit 3 */
37  #define SYNTHESIS_MODE_SET_CHANNELS(iMode,bVal)         if (bVal) iMode |= 0x10; else iMode &= 0xef   /* (un)set mode bit 4 */  #define SYNTHESIS_MODE_SET_CHANNELS(iMode,bVal)         if (bVal) iMode |= 0x10; else iMode &= ~0x10   /* (un)set mode bit 4 */
38  #define SYNTHESIS_MODE_SET_IMPLEMENTATION(iMode,bVal)   if (bVal) iMode |= 0x20; else iMode &= 0xdf   /* (un)set mode bit 5 */  #define SYNTHESIS_MODE_SET_IMPLEMENTATION(iMode,bVal)   if (bVal) iMode |= 0x20; else iMode &= ~0x20   /* (un)set mode bit 5 */
39    #define SYNTHESIS_MODE_SET_PROFILING(iMode,bVal)        if (bVal) iMode |= 0x40; else iMode &= ~0x40   /* (un)set mode bit 6 */
40    
41  #define SYNTHESIS_MODE_GET_CONSTPITCH(iMode)            iMode & 0x01  #define SYNTHESIS_MODE_GET_CONSTPITCH(iMode)            iMode & 0x01
42  #define SYNTHESIS_MODE_GET_LOOP(iMode)                  iMode & 0x02  #define SYNTHESIS_MODE_GET_LOOP(iMode)                  iMode & 0x02
# Line 52  Line 54 
54    
55  namespace LinuxSampler { namespace gig {  namespace LinuxSampler { namespace gig {
56    
57      typedef void SynthesizeFragment_Fn(VOICE&, uint, sample_t*, int);      typedef void SynthesizeFragment_Fn(VOICE&, uint, sample_t*, uint);
58    
59      void* GetSynthesisFunction(const int SynthesisMode);      void* GetSynthesisFunction(const int SynthesisMode);
60        void RunSynthesisFunction(const int SynthesisMode, VOICE& voice, uint Samples, sample_t* pSrc, uint Skip);
61    
62      enum channels_t {      enum channels_t {
63          MONO,          MONO,
# Line 65  namespace LinuxSampler { namespace gig { Line 68  namespace LinuxSampler { namespace gig {
68      class Synthesizer : public __RTMath<IMPLEMENTATION>, public LinuxSampler::Resampler<INTERPOLATE> {      class Synthesizer : public __RTMath<IMPLEMENTATION>, public LinuxSampler::Resampler<INTERPOLATE> {
69          public:          public:
70              template<typename VOICE_T>              template<typename VOICE_T>
71              inline static void SynthesizeFragment(VOICE_T& Voice, uint Samples, sample_t* pSrc, int& i) {              inline static void SynthesizeFragment(VOICE_T& Voice, uint Samples, sample_t* pSrc, uint i) {
72                  if (IMPLEMENTATION == ASM_X86_MMX_SSE) {                  if (IMPLEMENTATION == ASM_X86_MMX_SSE) {
73                      float fPos = (float) Voice.Pos;                      float fPos = (float) Voice.Pos;
74                      SynthesizeFragment(Voice, Samples, pSrc, i, Voice.pSample->LoopPlayCount,                      SynthesizeFragment(Voice, Samples, pSrc, i, Voice.pSample->LoopPlayCount,
# Line 93  namespace LinuxSampler { namespace gig { Line 96  namespace LinuxSampler { namespace gig {
96          //protected:          //protected:
97    
98              template<typename VOICE_T>              template<typename VOICE_T>
99              inline static void SynthesizeFragment(VOICE_T& Voice, uint Samples, sample_t* pSrc, int& i, uint& LoopPlayCount, uint LoopStart, uint LoopEnd, uint LoopSize, uint& LoopCyclesLeft, void* Pos, float& PitchBase, float& PitchBend) {              inline static void SynthesizeFragment(VOICE_T& Voice, uint Samples, sample_t* pSrc, uint& i, uint& LoopPlayCount, uint LoopStart, uint LoopEnd, uint LoopSize, uint& LoopCyclesLeft, void* Pos, float& PitchBase, float& PitchBend) {
100                  const float loopEnd = Float(LoopEnd);                  const float loopEnd = Float(LoopEnd);
101                  const float PBbyPB = Mul(PitchBase, PitchBend);                  const float PBbyPB = Mul(PitchBase, PitchBend);
102                  const float f_LoopStart = Float(LoopStart);                  const float f_LoopStart = Float(LoopStart);
# Line 103  namespace LinuxSampler { namespace gig { Line 106  namespace LinuxSampler { namespace gig {
106                          // render loop (loop count limited)                          // render loop (loop count limited)
107                          while (i < Samples && LoopCyclesLeft) {                          while (i < Samples && LoopCyclesLeft) {
108                              if (CONSTPITCH) {                              if (CONSTPITCH) {
109                                  const int processEnd = Min(Samples, i + DiffToLoopEnd(loopEnd,Pos, PBbyPB) + 1); //TODO: instead of +1 we could also round up                                  const uint processEnd = Min(Samples, i + DiffToLoopEnd(loopEnd,Pos, PBbyPB) + 1); //TODO: instead of +1 we could also round up
110                                  while (i < processEnd) Synthesize(Voice, Pos, pSrc, i);                                  while (i < processEnd) Synthesize(Voice, Pos, pSrc, i);
111                              }                              }
112                              else Synthesize(Voice, Pos, pSrc, i);                              else Synthesize(Voice, Pos, pSrc, i);
# Line 115  namespace LinuxSampler { namespace gig { Line 118  namespace LinuxSampler { namespace gig {
118                      else { // render loop (endless loop)                      else { // render loop (endless loop)
119                          while (i < Samples) {                          while (i < Samples) {
120                              if (CONSTPITCH) {                              if (CONSTPITCH) {
121                                  const int processEnd = Min(Samples, i + DiffToLoopEnd(loopEnd, Pos, PBbyPB) + 1); //TODO: instead of +1 we could also round up                                  const uint processEnd = Min(Samples, i + DiffToLoopEnd(loopEnd, Pos, PBbyPB) + 1); //TODO: instead of +1 we could also round up
122                                  while (i < processEnd) Synthesize(Voice, Pos, pSrc, i);                                  while (i < processEnd) Synthesize(Voice, Pos, pSrc, i);
123                              }                              }
124                              else Synthesize(Voice, Pos, pSrc, i);                              else Synthesize(Voice, Pos, pSrc, i);
# Line 129  namespace LinuxSampler { namespace gig { Line 132  namespace LinuxSampler { namespace gig {
132              }              }
133    
134              template<typename VOICE_T>              template<typename VOICE_T>
135              inline static void Synthesize(VOICE_T& Voice, void* Pos, sample_t* pSrc, int& i) {              inline static void Synthesize(VOICE_T& Voice, void* Pos, sample_t* pSrc, uint& i) {
136                  Synthesize(pSrc, Pos,                  Synthesize(pSrc, Pos,
137                             Voice.pEngine->pSynthesisParameters[Event::destination_vco][i],                             Voice.pEngine->pSynthesisParameters[Event::destination_vco][i],
138                             Voice.pEngine->pOutputLeft,                             Voice.pEngine->pOutputLeft,
# Line 148  namespace LinuxSampler { namespace gig { Line 151  namespace LinuxSampler { namespace gig {
151                  switch (IMPLEMENTATION) {                  switch (IMPLEMENTATION) {
152                      // pure C++ implementation (thus platform independent)                      // pure C++ implementation (thus platform independent)
153                      case CPP: {                      case CPP: {
154                          return int((LoopEnd - *((double *)Pos)) / Pitch);                          return uint((LoopEnd - *((double *)Pos)) / Pitch);
155                      }                      }
156                        #if ARCH_X86
157                      case ASM_X86_MMX_SSE: {                      case ASM_X86_MMX_SSE: {
158                          int result;                          int result;
159                          __asm__ __volatile__ (                          __asm__ __volatile__ (
# Line 164  namespace LinuxSampler { namespace gig { Line 168  namespace LinuxSampler { namespace gig {
168                          );                          );
169                          return result;                          return result;
170                      }                      }
171                        #endif // ARCH_X86
172                  }                  }
173              }              }
174    
# Line 176  namespace LinuxSampler { namespace gig { Line 181  namespace LinuxSampler { namespace gig {
181                          *Pos = fmod(*Pos - LoopEnd, LoopSize) + LoopStart;                          *Pos = fmod(*Pos - LoopEnd, LoopSize) + LoopStart;
182                          return 1;                          return 1;
183                      }                      }
184                        #if ARCH_X86
185                      case ASM_X86_MMX_SSE: {                      case ASM_X86_MMX_SSE: {
186                          int result;                          int result;
187                          __asm__ __volatile__ (                          __asm__ __volatile__ (
# Line 208  namespace LinuxSampler { namespace gig { Line 214  namespace LinuxSampler { namespace gig {
214                          );                          );
215                          return result;                          return result;
216                      }                      }
217                        #endif // ARCH_X86
218                  }                  }
219              }              }
220    
221              inline static void Synthesize(sample_t* pSrc, void* Pos, float& Pitch, float* pOutL, float* pOutR, int& i, float* Volume, float* PanL, float* PanR, Filter& FilterL, Filter& FilterR, biquad_param_t& bqBase, biquad_param_t& bqMain) {              inline static void Synthesize(sample_t* pSrc, void* Pos, float& Pitch, float* pOutL, float* pOutR, uint& i, float* Volume, float* PanL, float* PanR, Filter& FilterL, Filter& FilterR, biquad_param_t& bqBase, biquad_param_t& bqMain) {
222                  switch (IMPLEMENTATION) {                  switch (IMPLEMENTATION) {
223                      // pure C++ implementation (thus platform independent)                      // pure C++ implementation (thus platform independent)
224                      case CPP: {                      case CPP: {
# Line 238  namespace LinuxSampler { namespace gig { Line 245  namespace LinuxSampler { namespace gig {
245                          }                          }
246                          break;                          break;
247                      }                      }
248                        #if ARCH_X86
249                      // Assembly optimization using the MMX & SSE(1) instruction set (thus only for x86)                      // Assembly optimization using the MMX & SSE(1) instruction set (thus only for x86)
250                      case ASM_X86_MMX_SSE: {                      case ASM_X86_MMX_SSE: {
251                          const int ii = i & 0xfffffffc;                          const int ii = i & 0xfffffffc;
# Line 323  namespace LinuxSampler { namespace gig { Line 331  namespace LinuxSampler { namespace gig {
331                                "r" (&pOutR[ii])  /* %1 - must be 16 byte aligned ! */                                "r" (&pOutR[ii])  /* %1 - must be 16 byte aligned ! */
332                          );                          );
333                      }                      }
334                        #endif // ARCH_X86
335                  }                  }
336              }              }
337      };      };
Legend:
Removed from v.320  
changed lines
  Added in v.332
  ViewVC Help
Powered by ViewVC