/[svn]/linuxsampler/trunk/src/voice.h
ViewVC logotype

Contents of /linuxsampler/trunk/src/voice.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 33 - (show annotations) (download) (as text)
Mon Feb 16 19:30:42 2004 UTC (20 years, 1 month ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 9536 byte(s)
* implemented bidirectional voice state transition, means voice state can
  switch arbitrary times between 'Sustained'<-->'Released' within it's life
  time, thus the release process of a voice can be cancelled
* src/eg_vca.cpp: extended envelope generator by additional states
  ('Attack_Hold', 'Decay_1' and 'Decay_2')
* applied patch from Vladimir Senkov which adds new command line parameters
  ('--jackout', '--alsaout' and '--samplerate')
* configure.in: fixed compiler warning

1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003 by Benno Senoner and Christian Schoenebeck *
6 * *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
11 * *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
16 * *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program; if not, write to the Free Software *
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20 * MA 02111-1307 USA *
21 ***************************************************************************/
22
23 #ifndef __VOICE_H__
24 #define __VOICE_H__
25
26 #include "global.h"
27 #include "diskthread.h"
28 #include "ringbuffer.h"
29 #include "stream.h"
30 #include "gig.h"
31 #include "eg_vca.h"
32 #include "rtelmemorypool.h"
33 #include "audiothread.h"
34
35 #define MAX_PITCH 4 //FIXME: at the moment in octaves, should be changed into semitones
36 #define USE_LINEAR_INTERPOLATION 1 ///< set to 0 if you prefer cubic interpolation (slower, better quality)
37
38 class Voice {
39 public:
40 // Attributes
41 int MIDIKey; ///< MIDI key number of the key that triggered the voice
42 uint ReleaseVelocity; ///< Reflects the release velocity value if a note-off command arrived for the voice.
43
44 // Static Attributes
45 static DiskThread* pDiskThread; ///< Pointer to the disk thread, to be able to order a disk stream and later to delete the stream again
46 static AudioThread* pEngine; ///< Pointer to the engine, to be able to access the event lists.
47
48 // Methods
49 Voice();
50 ~Voice();
51 void Kill();
52 void Render(uint Samples);
53 int Trigger(ModulationSystem::Event* pNoteOnEvent, int Pitch, gig::Instrument* pInstrument);
54 inline bool IsActive() { return Active; }
55 inline void SetOutputLeft(float* pOutput, uint MaxSamplesPerCycle) { this->pOutputLeft = pOutput; this->MaxSamplesPerCycle = MaxSamplesPerCycle; }
56 inline void SetOutputRight(float* pOutput, uint MaxSamplesPerCycle) { this->pOutputRight = pOutput; this->MaxSamplesPerCycle = MaxSamplesPerCycle; }
57 private:
58 // Types
59 enum playback_state_t {
60 playback_state_ram,
61 playback_state_disk,
62 playback_state_end
63 };
64
65 // Attributes
66 float Volume; ///< Volume level of the voice
67 float* pOutputLeft; ///< Audio output buffer (left channel)
68 float* pOutputRight; ///< Audio output buffer (right channel)
69 uint MaxSamplesPerCycle; ///< Size of each audio output buffer
70 double Pos; ///< Current playback position in sample
71 double Pitch; ///< Current pitch depth (number of sample points to move on with each render step)
72 gig::Sample* pSample; ///< Pointer to the sample to be played back
73 gig::Region* pRegion; ///< Pointer to the articulation information of the respective keyboard region of this voice
74 bool Active; ///< If this voice object is currently in usage
75 playback_state_t PlaybackState; ///< When a sample will be triggered, it will be first played from RAM cache and after a couple of sample points it will switch to disk streaming and at the end of a disk stream we have to add null samples, so the interpolator can do it's work correctly
76 bool DiskVoice; ///< If the sample is very short it completely fits into the RAM cache and doesn't need to be streamed from disk, in that case this flag is set to false
77 Stream::reference_t DiskStreamRef; ///< Reference / link to the disk stream
78 unsigned long MaxRAMPos; ///< The upper allowed limit (not actually the end) in the RAM sample cache, after that point it's not safe to chase the interpolator another time over over the current cache position, instead we switch to disk then.
79 bool RAMLoop; ///< If this voice has a loop defined which completely fits into the cached RAM part of the sample, in this case we handle the looping within the voice class, else if the loop is located in the disk stream part, we let the disk stream handle the looping
80 int LoopCyclesLeft; ///< In case there is a RAMLoop and it's not an endless loop; reflects number of loop cycles left to be passed
81 uint Delay; ///< Number of sample points the rendering process of this voice should be delayed (jitter correction), will be set to 0 after the first audio fragment cycle
82 EG_VCA EG1;
83 ModulationSystem::Event* pTriggerEvent; ///< First event on the key's list the voice should process (only needed for the first audio fragment in which voice was triggered, after that it will be set to NULL).
84
85 // Methods
86 void ProcessEvents(uint Samples);
87 void Interpolate(uint Samples, sample_t* pSrc, uint Skip);
88 void InterpolateAndLoop(uint Samples, sample_t* pSrc, uint Skip);
89 inline void InterpolateOneStep_Stereo(sample_t* pSrc, int& i, float& effective_volume, float& pitch) {
90 int pos_int = double_to_int(this->Pos); // integer position
91 float pos_fract = this->Pos - pos_int; // fractional part of position
92 pos_int <<= 1;
93
94 #if USE_LINEAR_INTERPOLATION
95 // left channel
96 this->pOutputLeft[i] += effective_volume * (pSrc[pos_int] + pos_fract * (pSrc[pos_int+2] - pSrc[pos_int]));
97 // right channel
98 this->pOutputRight[i++] += effective_volume * (pSrc[pos_int+1] + pos_fract * (pSrc[pos_int+3] - pSrc[pos_int+1]));
99 #else // polynomial interpolation
100 // calculate left channel
101 float xm1 = pSrc[pos_int];
102 float x0 = pSrc[pos_int+2];
103 float x1 = pSrc[pos_int+4];
104 float x2 = pSrc[pos_int+6];
105 float a = (3 * (x0 - x1) - xm1 + x2) / 2;
106 float b = 2 * x1 + xm1 - (5 * x0 + x2) / 2;
107 float c = (x1 - xm1) / 2;
108 this->pOutputLeft[i] += effective_volume * ((((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0);
109
110 //calculate right channel
111 xm1 = pSrc[pos_int+1];
112 x0 = pSrc[pos_int+3];
113 x1 = pSrc[pos_int+5];
114 x2 = pSrc[pos_int+7];
115 a = (3 * (x0 - x1) - xm1 + x2) / 2;
116 b = 2 * x1 + xm1 - (5 * x0 + x2) / 2;
117 c = (x1 - xm1) / 2;
118 this->pOutputRight[i++] += effective_volume * ((((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0);
119 #endif // USE_LINEAR_INTERPOLATION
120
121 this->Pos += pitch;
122 }
123 inline void InterpolateOneStep_Mono(sample_t* pSrc, int& i, float& effective_volume, float& pitch) {
124 int pos_int = double_to_int(this->Pos); // integer position
125 float pos_fract = this->Pos - pos_int; // fractional part of position
126
127 #if USE_LINEAR_INTERPOLATION
128 float sample_point = effective_volume * (pSrc[pos_int] + pos_fract * (pSrc[pos_int+1] - pSrc[pos_int]));
129 #else // polynomial interpolation
130 float xm1 = pSrc[pos_int];
131 float x0 = pSrc[pos_int+1];
132 float x1 = pSrc[pos_int+2];
133 float x2 = pSrc[pos_int+3];
134 float a = (3 * (x0 - x1) - xm1 + x2) / 2;
135 float b = 2 * x1 + xm1 - (5 * x0 + x2) / 2;
136 float c = (x1 - xm1) / 2;
137 float sample_point = effective_volume * ((((a * pos_fract) + b) * pos_fract + c) * pos_fract + x0);
138 #endif // USE_LINEAR_INTERPOLATION
139
140 this->pOutputLeft[i] += sample_point;
141 this->pOutputRight[i++] += sample_point;
142
143 this->Pos += pitch;
144 }
145 inline int double_to_int(double f) {
146 #if ARCH_X86
147 int i;
148 __asm__ ("fistl %0" : "=m"(i) : "st"(f - 0.5) );
149 return i;
150 #else
151 return (int) f;
152 #endif // ARCH_X86
153 }
154 };
155
156 #endif // __VOICE_H__

  ViewVC Help
Powered by ViewVC