/[svn]/linuxsampler/trunk/src/common/RTMath.h
ViewVC logotype

Diff of /linuxsampler/trunk/src/common/RTMath.h

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

revision 319 by schoenebeck, Mon Dec 13 00:46:42 2004 UTC revision 328 by schoenebeck, Sat Dec 25 21:58:58 2004 UTC
# Line 24  Line 24 
24  #define __RT_MATH_H__  #define __RT_MATH_H__
25    
26  #include <math.h>  #include <math.h>
27    #include <stdint.h>
28  #include "global.h"  #include "global.h"
29    
30  /// Needed for calculating frequency ratio used to pitch a sample  /// Needed for calculating frequency ratio used to pitch a sample
31  #define TWELVEHUNDREDTH_ROOT_OF_TWO     1.000577789506555  #define TWELVEHUNDREDTH_ROOT_OF_TWO     1.000577789506555
32    
33  enum implementation_t {  enum implementation_t {
34      CPP,      CPP
35      ASM_X86_MMX_SSE      #if ARCH_X86
36        ,ASM_X86_MMX_SSE
37        #endif // ARCH_X86
38  };  };
39    
40  class RTMathBase {  class RTMathBase {
41      public:      public:
42          /**          /**
43             * Highly accurate time stamp.
44             */
45            typedef uint32_t time_stamp_t;
46    
47            /**
48             * We read the processor's cycle count register as a reference
49             * for the real time. These are of course only abstract values
50             * with arbitrary time entity, but that's not a problem as long
51             * as we calculate relatively.
52             */
53            static time_stamp_t CreateTimeStamp();
54    
55            /**
56           * Calculates the frequency ratio for a pitch value given in cents           * Calculates the frequency ratio for a pitch value given in cents
57           * (assuming equal tempered scale of course, divided into 12           * (assuming equal tempered scale of course, divided into 12
58           * semitones per octave and 100 cents per semitone).           * semitones per octave and 100 cents per semitone).
# Line 75  class __RTMath : public RTMathBase { Line 91  class __RTMath : public RTMathBase {
91                  case CPP: {                  case CPP: {
92                      return (int) a;                      return (int) a;
93                  }                  }
94                    #if ARCH_X86
95                  case ASM_X86_MMX_SSE: {                  case ASM_X86_MMX_SSE: {
96                      int ret;                      int ret;
97                      asm (                      asm (
# Line 84  class __RTMath : public RTMathBase { Line 101  class __RTMath : public RTMathBase {
101                      );                      );
102                      return ret;                      return ret;
103                  }                  }
104                    #endif // ARCH_X86
105              }              }
106          }          }
107    
# Line 97  class __RTMath : public RTMathBase { Line 115  class __RTMath : public RTMathBase {
115                  case CPP: {                  case CPP: {
116                      return (float) a;                      return (float) a;
117                  }                  }
118                    #if ARCH_X86
119                  case ASM_X86_MMX_SSE: {                  case ASM_X86_MMX_SSE: {
120                      float ret;                      float ret;
121                      asm (                      asm (
# Line 107  class __RTMath : public RTMathBase { Line 126  class __RTMath : public RTMathBase {
126                      );                      );
127                      return ret;                      return ret;
128                  }                  }
129                    #endif // ARCH_X86
130              }              }
131          }          }
132    
# Line 122  class __RTMath : public RTMathBase { Line 142  class __RTMath : public RTMathBase {
142                  case CPP: {                  case CPP: {
143                      return (a + b);                      return (a + b);
144                  }                  }
145                    #if ARCH_X86
146                  case ASM_X86_MMX_SSE: {                  case ASM_X86_MMX_SSE: {
147                      float ret;                      float ret;
148                      asm (                      asm (
# Line 133  class __RTMath : public RTMathBase { Line 154  class __RTMath : public RTMathBase {
154                      );                      );
155                      return ret;                      return ret;
156                  }                  }
157                    #endif // ARCH_X86
158              }              }
159          }          }
160    
# Line 145  class __RTMath : public RTMathBase { Line 167  class __RTMath : public RTMathBase {
167                  case CPP: {                  case CPP: {
168                      return (a - b);                      return (a - b);
169                  }                  }
170                    #if ARCH_X86
171                  case ASM_X86_MMX_SSE: {                  case ASM_X86_MMX_SSE: {
172                      float ret;                      float ret;
173                      asm (                      asm (
# Line 156  class __RTMath : public RTMathBase { Line 179  class __RTMath : public RTMathBase {
179                      );                      );
180                      return ret;                      return ret;
181                  }                  }
182                    #endif // ARCH_X86
183              }              }
184          }          }
185    
# Line 168  class __RTMath : public RTMathBase { Line 192  class __RTMath : public RTMathBase {
192                  case CPP: {                  case CPP: {
193                      return (a * b);                      return (a * b);
194                  }                  }
195                    #if ARCH_X86
196                  case ASM_X86_MMX_SSE: {                  case ASM_X86_MMX_SSE: {
197                      float ret;                      float ret;
198                      asm (                      asm (
# Line 179  class __RTMath : public RTMathBase { Line 204  class __RTMath : public RTMathBase {
204                      );                      );
205                      return ret;                      return ret;
206                  }                  }
207                    #endif // ARCH_X86
208              }              }
209          }          }
210    
# Line 191  class __RTMath : public RTMathBase { Line 217  class __RTMath : public RTMathBase {
217                  case CPP: {                  case CPP: {
218                      return (a / b);                      return (a / b);
219                  }                  }
220                    #if ARCH_X86
221                  case ASM_X86_MMX_SSE: {                  case ASM_X86_MMX_SSE: {
222                      float ret;                      float ret;
223                      asm (                      asm (
# Line 202  class __RTMath : public RTMathBase { Line 229  class __RTMath : public RTMathBase {
229                      );                      );
230                      return ret;                      return ret;
231                  }                  }
232                    #endif // ARCH_X86
233              }              }
234          }          }
235    
# Line 214  class __RTMath : public RTMathBase { Line 242  class __RTMath : public RTMathBase {
242                  case CPP: {                  case CPP: {
243                      return (b < a) ? b : a;                      return (b < a) ? b : a;
244                  }                  }
245                    #if ARCH_X86
246                  case ASM_X86_MMX_SSE: {                  case ASM_X86_MMX_SSE: {
247                      float ret;                      float ret;
248                      asm (                      asm (
# Line 225  class __RTMath : public RTMathBase { Line 254  class __RTMath : public RTMathBase {
254                      );                      );
255                      return ret;                      return ret;
256                  }                  }
257                    #endif // ARCH_X86
258              }              }
259          }          }
260    
# Line 237  class __RTMath : public RTMathBase { Line 267  class __RTMath : public RTMathBase {
267                  case CPP: {                  case CPP: {
268                      return (b > a) ? b : a;                      return (b > a) ? b : a;
269                  }                  }
270                    #if ARCH_X86
271                  case ASM_X86_MMX_SSE: {                  case ASM_X86_MMX_SSE: {
272                      float ret;                      float ret;
273                      asm (                      asm (
# Line 248  class __RTMath : public RTMathBase { Line 279  class __RTMath : public RTMathBase {
279                      );                      );
280                      return ret;                      return ret;
281                  }                  }
282                    #endif // ARCH_X86
283              }              }
284          }          }
285    
# Line 260  class __RTMath : public RTMathBase { Line 292  class __RTMath : public RTMathBase {
292                  case CPP: {                  case CPP: {
293                      return fmodf(a, b);                      return fmodf(a, b);
294                  }                  }
295                    #if ARCH_X86
296                  case ASM_X86_MMX_SSE: {                  case ASM_X86_MMX_SSE: {
297                      float ret;                      float ret;
298                      asm (                      asm (
# Line 278  class __RTMath : public RTMathBase { Line 311  class __RTMath : public RTMathBase {
311                      );                      );
312                      return ret;                      return ret;
313                  }                  }
314                    #endif // ARCH_X86
315              }              }
316          }          }
317  };  };
Legend:
Removed from v.319  
changed lines
  Added in v.328
  ViewVC Help
Powered by ViewVC