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

Diff of /linuxsampler/trunk/src/audiothread.h

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

revision 31 by schoenebeck, Sun Jan 18 20:31:31 2004 UTC revision 32 by schoenebeck, Tue Feb 3 13:21:19 2004 UTC
# Line 36  Line 36 
36  #include "rtelmemorypool.h"  #include "rtelmemorypool.h"
37  #include "modulationsystem.h"  #include "modulationsystem.h"
38    
39  #define PITCHBEND_SEMITONES     12  #define PITCHBEND_SEMITONES             12
40  #define MAX_AUDIO_VOICES        64  #define MAX_AUDIO_VOICES                64
41    #define MAX_EVENTS_PER_FRAGMENT         1024
42    
43  // preload 64k samples = 128kB of data in RAM for 16 bit mono samples  // preload 64k samples = 128kB of data in RAM for 16 bit mono samples
44  #define NUM_RAM_PRELOAD_SAMPLES 32768  #define NUM_RAM_PRELOAD_SAMPLES 32768
45    
46    // just symbol prototyping
47    class Voice;
48    
49  //FIXME: Class name "AudioThread" is now misleading, because there is no thread anymore, but the name will change soon to "Engine" when we restructure the source tree  //FIXME: Class name "AudioThread" is now misleading, because there is no thread anymore, but the name will change soon to "Engine" when we restructure the source tree
50  class AudioThread {  class AudioThread {
51      public:      public:
# Line 51  class AudioThread { Line 55  class AudioThread {
55    
56          AudioThread(AudioIO* pAudioIO, DiskThread* pDiskThread, gig::Instrument* pInstrument);          AudioThread(AudioIO* pAudioIO, DiskThread* pDiskThread, gig::Instrument* pInstrument);
57         ~AudioThread();         ~AudioThread();
58          void          SendNoteOn(uint8_t Pitch, uint8_t Velocity);          void          SendNoteOn(uint8_t Key, uint8_t Velocity);
59          void          SendNoteOff(uint8_t Pitch, uint8_t Velocity);          void          SendNoteOff(uint8_t Key, uint8_t Velocity);
60          void          SendControlChange(uint8_t Channel, uint8_t Number, uint8_t Value);          void          SendPitchbend(int Pitch);
61            void          SendControlChange(uint8_t Controller, uint8_t Value);
62          int           RenderAudio(uint Samples);          int           RenderAudio(uint Samples);
63          inline float* GetAudioSumBuffer(uint Channel) {          inline float* GetAudioSumBuffer(uint Channel) {
64              return pAudioSumBuffer[Channel];              return pAudioSumBuffer[Channel];
65          };          };
66      private:      protected:
         enum command_type_t {  
             command_type_note_on,  
             command_type_note_off,  
             command_type_continuous_controller  
         };  
         struct command_t {  
             command_type_t type;  
             uint8_t        channel;  
             uint8_t        pitch;  
             uint8_t        velocity;  
             uint8_t        number;  
             uint8_t        value;  
         } command;  
67          struct midi_key_info_t {          struct midi_key_info_t {
68              RTEList<Voice*>*             pActiveVoices;         ///< Contains the active voices associated with the MIDI key.              RTEList<Voice>*                      pActiveVoices;         ///< Contains the active voices associated with the MIDI key.
69              RTEList<Voice*>::NodeHandle  hSustainPtr;           ///< Points to the voice element in the active voice list which has not received a note-off yet (this pointer is needed for sustain pedal handling)              Voice*                               pSustainPtr;           ///< Points to the voice element in the active voice list which has not received a note-off yet (this pointer is needed for sustain pedal handling)
70              bool                         Sustained;             ///< Is true if the MIDI key is currently sustained, thus if Note-off arrived while sustain pedal pressed.              bool                                 Sustained;             ///< Is true if the MIDI key is currently sustained, thus if Note-off arrived while sustain pedal pressed.
71              bool                         KeyPressed;            ///< Is true if the respective MIDI key is currently pressed.              bool                                 KeyPressed;            ///< Is true if the respective MIDI key is currently pressed.
72              uint*                        pSustainPoolNode;      ///< FIXME: hack to allow fast deallocation of the key from the sustained key pool              uint*                                pSustainPoolNode;      ///< FIXME: hack to allow fast deallocation of the key from the sustained key pool
73          };          };
74    
75          RingBuffer<command_t>*           pCommandQueue;          RingBuffer<ModulationSystem::Event>*     pEventQueue;           ///< Input event queue.
76          float*                           pAudioSumBuffer[2];    ///< Audio sum of all voices (32 bit, index 0 = left channel, index 1 = right channel)          float*                                   pAudioSumBuffer[2];    ///< Audio sum of all voices (32 bit, index 0 = left channel, index 1 = right channel)
77          Voice**                          pVoices;               ///< The voice pool, containing all Voices (active and inactice voices) in unsorted order          midi_key_info_t                          pMIDIKeyInfo[128];     ///< Contains all active voices sorted by MIDI key number and other informations to the respective MIDI key
         midi_key_info_t                  pMIDIKeyInfo[128];     ///< Contains all active voices sorted by MIDI key number and other informations to the respective MIDI key  
78          /* ActiveVoicePool is a memory pool of limited size (size=MAX VOICES) of active voices.          /* ActiveVoicePool is a memory pool of limited size (size=MAX VOICES) of active voices.
79             it can be allocated dynamically in real time and the allocated elements can be added to             it can be allocated dynamically in real time and the allocated elements can be added to
80             the linked lists represented by ActiveVoices[MIDIKey]. This means we can have unlimited             the linked lists represented by ActiveVoices[MIDIKey]. This means we can have unlimited
81             active voices per key. This if for example useful to manage the sustain pedal messages             active voices per key. This if for example useful to manage the sustain pedal messages
82           */           */
83          RTELMemoryPool<Voice*>*          ActiveVoicePool;          RTELMemoryPool<Voice>*                   pVoicePool;            ///< Contains all voices that can be activated.
84          RTELMemoryPool<uint>*            SustainedKeyPool;      ///< Contains the MIDI key numbers of all currently sustained keys.          RTELMemoryPool<uint>*                    pSustainedKeyPool;     ///< Contains the MIDI key numbers of all currently sustained keys.
85          AudioIO*                         pAudioIO;          RTELMemoryPool<ModulationSystem::Event>* pEventPool;            ///< Contains all Event objects that can be used.
86          DiskThread*                      pDiskThread;          RTEList<ModulationSystem::Event>*        pEvents;               ///< All events for the current audio fragment.
87          gig::Instrument*                 pInstrument;          RTEList<ModulationSystem::Event>*        pCCEvents[ModulationSystem::destination_count];  ///< Control change events for the current audio fragment.
88          bool                             SustainPedal;          ///< true if sustain pedal is down          AudioIO*                                 pAudioIO;
89          uint8_t                          PrevHoldCCValue;          DiskThread*                              pDiskThread;
90            gig::Instrument*                         pInstrument;
91          void ProcessNoteOn(uint8_t MIDIKey, uint8_t Velocity);          bool                                     SustainPedal;          ///< true if sustain pedal is down
92          void ProcessNoteOff(uint8_t MIDIKey, uint8_t Velocity);          uint8_t                                  PrevHoldCCValue;
93          void ProcessControlChange(uint8_t Channel, uint8_t Number, uint8_t Value);          int                                      Pitch;                 ///< Current (absolute) MIDI pitch value.
94    
95            void ProcessNoteOn(ModulationSystem::Event* pNoteOnEvent);
96            void ProcessNoteOff(ModulationSystem::Event* pNoteOffEvent);
97            void ProcessPitchbend(ModulationSystem::Event* pPitchbendEvent);
98            void ProcessControlChange(ModulationSystem::Event* pControlChangeEvent);
99          void KillVoice(Voice* pVoice);          void KillVoice(Voice* pVoice);
100          void CacheInitialSamples(gig::Sample* pSample);          void CacheInitialSamples(gig::Sample* pSample);
101    
102            friend class Voice;
103  };  };
104    
105  #endif // __AUDIOTHREAD_H__  #endif // __AUDIOTHREAD_H__
Legend:
Removed from v.31  
changed lines
  Added in v.32
  ViewVC Help
Powered by ViewVC