engines/common/Voice.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck    *
 *   Copyright (C) 2005-2010 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_VOICE_H__
#define __LS_VOICE_H__

#include "Event.h"
#include "../../common/Pool.h"

#include <gig.h> // TODO: remove gig dependency

namespace LinuxSampler {

    class Voice {
        public:
            enum playback_state_t {
                playback_state_end  = 0,
                playback_state_init = 1,
                playback_state_ram  = 2,
                playback_state_disk = 3
            };

            // Type bits. Mostly mutual exclusive, but a voice may both be of one shot type and require a release trigger at the same time.
            enum type_t {
                type_normal = 0,
                type_release_trigger_required = 1 << 1,  ///< If the key of this voice will be released, it causes a release triggered voice to be spawned
                type_release_trigger = 1 << 2,           ///< Release triggered voice which cannot be killed by releasing its key
                type_one_shot = 1 << 3,                  ///< Voice should not be released by note off
                type_controller_triggered = 1 << 4       ///< Voice is triggered by MIDI CC instead of a note on
            };

            struct PitchInfo {
                float PitchBase;      ///< Basic pitch depth, stays the same for the whole life time of the voice
                float PitchBend;      ///< Current pitch value of the pitchbend wheel
                float PitchBendRange; ///< The pitch range of the pitchbend wheel, value is in cents / 8192
            };

            struct EGInfo {
                double Attack;
                double Decay;
                double Release;
            };

            struct SampleInfo {
                uint SampleRate;
                uint ChannelCount;
                uint FrameSize;
                uint TotalFrameCount;
                uint BitDepth;
                bool HasLoops;
                uint LoopStart;
                uint LoopLength;
                uint LoopPlayCount; ///< Number of times the loop should be played (a value of 0 = infinite).
                bool Unpitched; ///< sound which is not characterized by a perceived frequency
            };

            struct RegionInfo {
                uint8_t UnityNote; ///< The MIDI key number of the recorded pitch of the sample
                int16_t FineTune;
                int     Pan; ///< Panorama / Balance (-64..0..63 <-> left..middle..right)
                uint    SampleStartOffset; ///< Number of samples the sample start should be moved

                double  EG1PreAttack; ///< Preattack value of the sample amplitude EG (in permilles)
                double  EG1Attack; ///< Attack time of the sample amplitude EG (in seconds)
                double  EG1Hold;  ///< If true, Decay1 stage should be postponed until the sample reached the sample loop start
                double  EG1Decay1;  ///< Decay time of the sample amplitude EG (in seconds)
                double  EG1Decay2;  ///< Only if (EG1InfiniteSustain == false): 2nd decay stage time of the sample amplitude EG (in seconds)
                double  EG1Sustain; ///< Sustain value of the sample amplitude EG (in permilles)
                bool    EG1InfiniteSustain; ///< If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released.
                double  EG1Release; ///< Release time of the sample amplitude EG (in seconds)

                double  EG2PreAttack; ///< Preattack value of the filter cutoff EG (in permilles)
                double  EG2Attack; ///< Attack time of the filter cutoff EG (in seconds)
                double  EG2Decay1;  ///< Decay time of the filter cutoff EG (in seconds)
                double  EG2Decay2;  ///< Only if (EG2InfiniteSustain == false): 2nd decay stage time of the filter cutoff EG (in seconds)
                double  EG2Sustain; ///< Sustain value of the filter cutoff EG (in permilles)
                bool    EG2InfiniteSustain; ///< If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released.
                double  EG2Release; ///< Release time of the filter cutoff EG (in seconds)

                double  EG3Attack;  ///< Attack time of the sample pitch EG (in seconds)
                int     EG3Depth;   ///< Depth of the sample pitch EG (-1200 - +1200)
                double  ReleaseTriggerDecay; ///< How much release sample volume depends on note length. Release sample amplitude is multiplied with (1 - ReleaseTriggerDecay * note length).

                bool               VCFEnabled;    ///< If filter should be used.
                ::gig::vcf_type_t  VCFType;       ///< Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).
                uint8_t            VCFResonance;  ///< Firm internal filter resonance weight.
            };

            struct InstrumentInfo {
                int   FineTune; // in cents
                uint  PitchbendRange;    ///< Number of semitones pitchbend controller can pitch
            };

            /// Reflects a MIDI controller
            struct midi_ctrl {
                uint8_t controller; ///< MIDI control change controller number
                uint8_t value;      ///< Current MIDI controller value
                float   fvalue;     ///< Transformed / effective value (e.g. volume level or filter cutoff frequency)
            };

            Voice() { }
            virtual ~Voice() { }
    };

    // |= operator for the type_t enum
    inline Voice::type_t operator|=(Voice::type_t& lhs, Voice::type_t rhs) {
        return lhs = static_cast<Voice::type_t>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs));
    }

} // namespace LinuxSampler

#endif  /* __LS_VOICE_H__ */
1	iliev	2012	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003,2004 by Benno Senoner and Christian Schoenebeck *
6	persson	2115	* Copyright (C) 2005-2010 Christian Schoenebeck *
7	iliev	2012	* *
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_VOICE_H__
25	persson	2115	#define __LS_VOICE_H__
26	iliev	2012
27			#include "Event.h"
28			#include "../../common/Pool.h"
29
30	iliev	2015	#include <gig.h> // TODO: remove gig dependency
31
32	iliev	2012	namespace LinuxSampler {
33
34			class Voice {
35			public:
36			enum playback_state_t {
37			playback_state_end = 0,
38			playback_state_init = 1,
39			playback_state_ram = 2,
40			playback_state_disk = 3
41			};
42
43	persson	2115	// Type bits. Mostly mutual exclusive, but a voice may both be of one shot type and require a release trigger at the same time.
44	iliev	2012	enum type_t {
45	persson	2115	type_normal = 0,
46			type_release_trigger_required = 1 << 1, ///< If the key of this voice will be released, it causes a release triggered voice to be spawned
47			type_release_trigger = 1 << 2, ///< Release triggered voice which cannot be killed by releasing its key
48			type_one_shot = 1 << 3, ///< Voice should not be released by note off
49			type_controller_triggered = 1 << 4 ///< Voice is triggered by MIDI CC instead of a note on
50	iliev	2012	};
51	iliev	2015
52			struct PitchInfo {
53			float PitchBase; ///< Basic pitch depth, stays the same for the whole life time of the voice
54			float PitchBend; ///< Current pitch value of the pitchbend wheel
55			float PitchBendRange; ///< The pitch range of the pitchbend wheel, value is in cents / 8192
56			};
57
58			struct EGInfo {
59			double Attack;
60			double Decay;
61			double Release;
62			};
63
64			struct SampleInfo {
65			uint SampleRate;
66			uint ChannelCount;
67			uint FrameSize;
68			uint TotalFrameCount;
69			uint BitDepth;
70			bool HasLoops;
71			uint LoopStart;
72			uint LoopLength;
73			uint LoopPlayCount; ///< Number of times the loop should be played (a value of 0 = infinite).
74			bool Unpitched; ///< sound which is not characterized by a perceived frequency
75			};
76
77			struct RegionInfo {
78			uint8_t UnityNote; ///< The MIDI key number of the recorded pitch of the sample
79			int16_t FineTune;
80			int Pan; ///< Panorama / Balance (-64..0..63 <-> left..middle..right)
81			uint SampleStartOffset; ///< Number of samples the sample start should be moved
82
83			double EG1PreAttack; ///< Preattack value of the sample amplitude EG (in permilles)
84			double EG1Attack; ///< Attack time of the sample amplitude EG (in seconds)
85			double EG1Hold; ///< If true, Decay1 stage should be postponed until the sample reached the sample loop start
86			double EG1Decay1; ///< Decay time of the sample amplitude EG (in seconds)
87			double EG1Decay2; ///< Only if (EG1InfiniteSustain == false): 2nd decay stage time of the sample amplitude EG (in seconds)
88			double EG1Sustain; ///< Sustain value of the sample amplitude EG (in permilles)
89			bool EG1InfiniteSustain; ///< If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released.
90			double EG1Release; ///< Release time of the sample amplitude EG (in seconds)
91
92			double EG2PreAttack; ///< Preattack value of the filter cutoff EG (in permilles)
93			double EG2Attack; ///< Attack time of the filter cutoff EG (in seconds)
94			double EG2Decay1; ///< Decay time of the filter cutoff EG (in seconds)
95			double EG2Decay2; ///< Only if (EG2InfiniteSustain == false): 2nd decay stage time of the filter cutoff EG (in seconds)
96			double EG2Sustain; ///< Sustain value of the filter cutoff EG (in permilles)
97			bool EG2InfiniteSustain; ///< If true, instead of going into Decay2 phase, Decay1 level will be hold until note will be released.
98			double EG2Release; ///< Release time of the filter cutoff EG (in seconds)
99
100			double EG3Attack; ///< Attack time of the sample pitch EG (in seconds)
101			int EG3Depth; ///< Depth of the sample pitch EG (-1200 - +1200)
102	persson	2061	double ReleaseTriggerDecay; ///< How much release sample volume depends on note length. Release sample amplitude is multiplied with (1 - ReleaseTriggerDecay * note length).
103	iliev	2015
104			bool VCFEnabled; ///< If filter should be used.
105			::gig::vcf_type_t VCFType; ///< Defines the general filter characteristic (lowpass, highpass, bandpass, etc.).
106			uint8_t VCFResonance; ///< Firm internal filter resonance weight.
107			};
108
109			struct InstrumentInfo {
110			int FineTune; // in cents
111			uint PitchbendRange; ///< Number of semitones pitchbend controller can pitch
112			};
113
114			/// Reflects a MIDI controller
115			struct midi_ctrl {
116			uint8_t controller; ///< MIDI control change controller number
117			uint8_t value; ///< Current MIDI controller value
118			float fvalue; ///< Transformed / effective value (e.g. volume level or filter cutoff frequency)
119			};
120
121			Voice() { }
122			virtual ~Voice() { }
123	iliev	2012	};
124	persson	2115
125			// \|= operator for the type_t enum
126			inline Voice::type_t operator\|=(Voice::type_t& lhs, Voice::type_t rhs) {
127			return lhs = static_cast<Voice::type_t>(static_cast<unsigned>(lhs) \| static_cast<unsigned>(rhs));
128			}
129
130	iliev	2012	} // namespace LinuxSampler
131
132	persson	2115	#endif /* __LS_VOICE_H__ */