public void Clear()
 {
     _readPosition = 0;
     _writePosition = 0;
     _sampleCount = 0;
     _buffer = new SampleArray(_buffer.Length);
 }
 public CircularSampleBuffer(int size)
 {
     _buffer = new SampleArray(size);
     _writePosition = 0;
     _readPosition = 0;
     _sampleCount = 0;
 }
示例#3
0
 public CircularSampleBuffer(int size)
 {
     _buffer        = new SampleArray(size);
     _writePosition = 0;
     _readPosition  = 0;
     _sampleCount   = 0;
 }
示例#4
0
 public void Clear()
 {
     _readPosition  = 0;
     _writePosition = 0;
     _sampleCount   = 0;
     _buffer        = new SampleArray(_buffer.Length);
 }
示例#5
0
 private static void Init()
 {
     var EnvelopeSize = 64;
     var ExponentialCoeff = .09f;
     _envelopeTables = new SampleArray[4];
     _envelopeTables[0] = (RemoveDenormals(CreateSustainTable(EnvelopeSize)));
     _envelopeTables[1] = (RemoveDenormals(CreateLinearTable(EnvelopeSize)));
     _envelopeTables[2] = (RemoveDenormals(CreateExponentialTable(EnvelopeSize, ExponentialCoeff)));
     _envelopeTables[3] = (RemoveDenormals(CreateSineTable(EnvelopeSize)));
     _centTable = CreateCentTable();
     _semitoneTable = CreateSemitoneTable();
     _sincTable = CreateSincTable(SynthConstants.SincWidth, SynthConstants.SincResolution, .43f, HammingWindow);
     _isInitialized = true;
 }
示例#6
0
 public VoiceParameters()
 {
     BlockBuffer = new SampleArray(SynthConstants.DefaultBlockSize);
     //create default number of each component
     PData = new UnionData[SynthConstants.MaxVoiceComponents];
     GeneratorParams = new GeneratorParameters[SynthConstants.MaxVoiceComponents];
     Envelopes = new Envelope[SynthConstants.MaxVoiceComponents];
     Filters = new Filter[SynthConstants.MaxVoiceComponents];
     Lfos = new Lfo[SynthConstants.MaxVoiceComponents];
     //initialize each component
     for (int x = 0; x < SynthConstants.MaxVoiceComponents; x++)
     {
         GeneratorParams[x] = new GeneratorParameters();
         Envelopes[x] = new Envelope();
         Filters[x] = new Filter();
         Lfos[x] = new Lfo();
     }
 }
示例#7
0
        public Synthesizer(int sampleRate, int audioChannels, int bufferSize, int bufferCount, int polyphony)
        {
            var MinSampleRate = 8000;
            var MaxSampleRate = 96000;

            if (sampleRate < MinSampleRate || sampleRate > MaxSampleRate)
                throw new Exception("Invalid paramater: (sampleRate) Valid ranges are " + MinSampleRate + " to " +
                                    MaxSampleRate);
            if (audioChannels < 1 || audioChannels > 2)
                throw new Exception("Invalid paramater: (audioChannels) Valid ranges are " + 1 + " to " + 2);

            _midiMessageProcessed = new FastList<Action<MidiEvent>>();
            //
            // Setup synth parameters
            _synthGain = 0.35f;
            _masterVolume = 1;

            SampleRate = sampleRate;
            AudioChannels = audioChannels;
            MicroBufferSize = SynthHelper.ClampI(bufferSize, (int)(SynthConstants.MinBufferSize * sampleRate),
                (int)(SynthConstants.MaxBufferSize * sampleRate));
            MicroBufferSize =
                (int)
                    (Math.Ceiling(MicroBufferSize / (double)SynthConstants.DefaultBlockSize) *
                     SynthConstants.DefaultBlockSize); //ensure multiple of block size
            MicroBufferCount = (Math.Max(1, bufferCount));
            SampleBuffer = new SampleArray((MicroBufferSize * MicroBufferCount * audioChannels));
            LittleEndian = true;

            //Setup Controllers
            _synthChannels = new SynthParameters[SynthConstants.DefaultChannelCount];
            for (int x = 0; x < _synthChannels.Length; x++)
                _synthChannels[x] = new SynthParameters(this);
            //Create synth voices
            _voiceManager = new VoiceManager(SynthHelper.ClampI(polyphony, SynthConstants.MinPolyphony, SynthConstants.MaxPolyphony));
            //Create midi containers
            MidiEventQueue = new LinkedList<SynthEvent>();
            MidiEventCounts = new int[MicroBufferCount];
            _layerList = new Patch[15];

            _midiMessageProcessed = new FastList<Action<MidiEvent>>();
            ResetSynthControls();
        }
示例#8
0
 private static SampleArray CreateSquareTable(int size, int k)
 {//Uses Fourier Expansion up to k terms 
     var FourOverPi = 4 / Math.PI;
     var squaretable = new SampleArray(size);
     var inc = 1.0 / size;
     var phase = 0.0;
     for (int x = 0; x < size; x++)
     {
         var value = 0.0;
         for (int i = 1; i < k + 1; i++)
         {
             var twokminus1 = (2 * i) - 1;
             value += Math.Sin(SynthConstants.TwoPi * (twokminus1) * phase) / (twokminus1);
         }
         squaretable[x] = SynthHelper.ClampF((float)(FourOverPi * value), -1, 1);
         phase += inc;
     }
     return squaretable;
 }
示例#9
0
 public virtual void GetValues(GeneratorParameters generatorParams, SampleArray blockBuffer, double increment)
 {
     var proccessed = 0;
     do
     {
         var samplesAvailable = (int)(Math.Ceiling((generatorParams.CurrentEnd - generatorParams.Phase) / increment));
         if (samplesAvailable > blockBuffer.Length - proccessed)
         {
             while (proccessed < blockBuffer.Length)
             {
                 blockBuffer[proccessed++] = GetValue(generatorParams.Phase);
                 generatorParams.Phase += increment;
             }
         }
         else
         {
             var endProccessed = proccessed + samplesAvailable;
             while (proccessed < endProccessed)
             {
                 blockBuffer[proccessed++] = GetValue(generatorParams.Phase);
                 generatorParams.Phase += increment;
             }
             switch (generatorParams.CurrentState)
             {
                 case GeneratorState.PreLoop:
                     generatorParams.CurrentStart = LoopStartPhase;
                     generatorParams.CurrentEnd = LoopEndPhase;
                     generatorParams.CurrentState = GeneratorState.Loop;
                     break;
                 case GeneratorState.Loop:
                     generatorParams.Phase += generatorParams.CurrentStart - generatorParams.CurrentEnd;
                     break;
                 case GeneratorState.PostLoop:
                     generatorParams.CurrentState = GeneratorState.Finished;
                     while (proccessed < blockBuffer.Length)
                         blockBuffer[proccessed++] = 0;
                     break;
             }
         }
     } while (proccessed < blockBuffer.Length);
 }
示例#10
0
        public int Write(SampleArray data, int offset, int count)
        {
            var samplesWritten = 0;
            if (count > _buffer.Length - _sampleCount)
            {
                count = _buffer.Length - _sampleCount;
            }

            var writeToEnd = Math.Min(_buffer.Length - _writePosition, count);
            SampleArray.Blit(data, offset, _buffer, _writePosition, writeToEnd);
            _writePosition += writeToEnd;
            _writePosition %= _buffer.Length;
            samplesWritten += writeToEnd;
            if (samplesWritten < count)
            {
                SampleArray.Blit(data, offset + samplesWritten, _buffer, _writePosition, count - samplesWritten);
                _writePosition += (count - samplesWritten);
                samplesWritten = count;
            }
            _sampleCount += samplesWritten;
            return samplesWritten;
        }
        public int Read(SampleArray data, int offset, int count)
        {
            if (count > _sampleCount)
            {
                count = _sampleCount;
            }
            var samplesRead = 0;
            var readToEnd = Math.Min(_buffer.Length - _readPosition, count);
            SampleArray.Blit(_buffer, _readPosition, data, offset, readToEnd);
            samplesRead += readToEnd;
            _readPosition += readToEnd;
            _readPosition %= _buffer.Length;

            if (samplesRead < count)
            {
                SampleArray.Blit(_buffer, _readPosition, data, offset + samplesRead, count - samplesRead);
                _readPosition += (count - samplesRead);
                samplesRead = count;
            }

            _sampleCount -= samplesRead;
            return samplesRead;
        }
示例#12
0
        public int Write(SampleArray data, int offset, int count)
        {
            var samplesWritten = 0;

            if (count > _buffer.Length - _sampleCount)
            {
                count = _buffer.Length - _sampleCount;
            }

            var writeToEnd = Math.Min(_buffer.Length - _writePosition, count);

            SampleArray.Blit(data, offset, _buffer, _writePosition, writeToEnd);
            _writePosition += writeToEnd;
            _writePosition %= _buffer.Length;
            samplesWritten += writeToEnd;
            if (samplesWritten < count)
            {
                SampleArray.Blit(data, offset + samplesWritten, _buffer, _writePosition, count - samplesWritten);
                _writePosition += (count - samplesWritten);
                samplesWritten  = count;
            }
            _sampleCount += samplesWritten;
            return(samplesWritten);
        }
示例#13
0
 public override void GetValues(GeneratorParameters generatorParams, SampleArray blockBuffer, double increment)
 {
     int proccessed = 0;
     do
     {
         int samplesAvailable = (int)Math.Ceiling((generatorParams.CurrentEnd - generatorParams.Phase) / increment);
         if (samplesAvailable > blockBuffer.Length - proccessed)
         {
             Interpolate(generatorParams, blockBuffer, increment, proccessed, blockBuffer.Length);
             return; //proccessed = blockBuffer.Length;
         }
         else
         {
             int endProccessed = proccessed + samplesAvailable;
             Interpolate(generatorParams, blockBuffer, increment, proccessed, endProccessed);
             proccessed = endProccessed;
             switch (generatorParams.CurrentState)
             {
                 case GeneratorState.PreLoop:
                     generatorParams.CurrentStart = LoopStartPhase;
                     generatorParams.CurrentEnd = LoopEndPhase;
                     generatorParams.CurrentState = GeneratorState.Loop;
                     break;
                 case GeneratorState.Loop:
                     generatorParams.Phase += generatorParams.CurrentStart - generatorParams.CurrentEnd;
                     break;
                 case GeneratorState.PostLoop:
                     generatorParams.CurrentState = GeneratorState.Finished;
                     while (proccessed < blockBuffer.Length)
                         blockBuffer[proccessed++] = 0f;
                     break;
             }
         }
     }
     while (proccessed < blockBuffer.Length);
 }
示例#14
0
        public int Read(SampleArray data, int offset, int count)
        {
            if (count > _sampleCount)
            {
                count = _sampleCount;
            }
            var samplesRead = 0;
            var readToEnd   = Math.Min(_buffer.Length - _readPosition, count);

            SampleArray.Blit(_buffer, _readPosition, data, offset, readToEnd);
            samplesRead   += readToEnd;
            _readPosition += readToEnd;
            _readPosition %= _buffer.Length;

            if (samplesRead < count)
            {
                SampleArray.Blit(_buffer, _readPosition, data, offset + samplesRead, count - samplesRead);
                _readPosition += (count - samplesRead);
                samplesRead    = count;
            }

            _sampleCount -= samplesRead;
            return(samplesRead);
        }
示例#15
0
 public void AddSamples(SampleArray samples)
 {
     var uint8 = new Uint8Array(samples.Buffer);
     var b64 = JsCode("window.btoa(String.fromCharCode.apply(null, uint8))").As<string>();
     document.getElementById(_swfId).As<IFlashSynthOutput>().AlphaSynthAddSamples(b64);
 }
        private void GenerateSound(DOMEvent e)
        {
            var ae = (AudioProcessingEvent)e;
            var left = ae.outputBuffer.getChannelData(0);
            var right = ae.outputBuffer.getChannelData(1);
            var samples = left.length + right.length;
            if (_circularBuffer.Count < samples)
            {
                if (_finished)
                {
                    if (Finished != null) Finished();
                    Stop();
                }
                else
                {
                    // when buffering we count it as pause time
                    _pauseTime += (int)((BufferSize * 1000) / (2 * _context.sampleRate));
                }
            }
            else
            {
                var buffer = new SampleArray(samples);
                _circularBuffer.Read(buffer, 0, buffer.Length);

                var s = 0;
                for (int i = 0; i < left.length; i++)
                {
                    left[i] = buffer[s++];
                    right[i] = buffer[s++];
                }
            }

            if (PositionChanged != null)
            {
                PositionChanged((int)(CalcPosition()));
            }

            if (!_finished)
            {
                RequestBuffers();
            }
        }
示例#17
0
 private void Interpolate(GeneratorParameters generatorParams, SampleArray blockBuffer, double increment, int start, int end)
 {
     switch (SynthConstants.InterpolationMode)
     {
         case Interpolation.Linear:
             #region Linear
             {
                 double _end = generatorParams.CurrentState == GeneratorState.Loop ? this.LoopEndPhase - 1 : this.EndPhase - 1;
                 int index;
                 float s1, s2, mu;
                 while (start < end && generatorParams.Phase < _end)//do this until we reach an edge case or fill the buffer
                 {
                     index = (int)generatorParams.Phase;
                     s1 = Samples[index];
                     s2 = Samples[index + 1];
                     mu = (float)(generatorParams.Phase - index);
                     blockBuffer[start++] = s1 + mu * (s2 - s1);
                     generatorParams.Phase += increment;
                 }
                 while (start < end)//edge case, if in loop wrap to loop start else use duplicate sample
                 {
                     index = (int)generatorParams.Phase;
                     s1 = Samples[index];
                     if (generatorParams.CurrentState == GeneratorState.Loop)
                         s2 = Samples[(int)generatorParams.CurrentStart];
                     else
                         s2 = s1;
                     mu = (float)(generatorParams.Phase - index);
                     blockBuffer[start++] = s1 + mu * (s2 - s1);
                     generatorParams.Phase += increment;
                 }
             }
             #endregion
             break;
         case Interpolation.Cosine:
             #region Cosine
             {
                 double _end = generatorParams.CurrentState == GeneratorState.Loop ? this.LoopEndPhase - 1 : this.EndPhase - 1;
                 int index;
                 float s1, s2, mu;
                 while (start < end && generatorParams.Phase < _end)//do this until we reach an edge case or fill the buffer
                 {
                     index = (int)generatorParams.Phase;
                     s1 = Samples[index];
                     s2 = Samples[index + 1];
                     mu = (1f - (float)Math.Cos((generatorParams.Phase - index) * Math.PI)) * 0.5f;
                     blockBuffer[start++] = s1 * (1f - mu) + s2 * mu;
                     generatorParams.Phase += increment;
                 }
                 while (start < end)//edge case, if in loop wrap to loop start else use duplicate sample
                 {
                     index = (int)generatorParams.Phase;
                     s1 = Samples[index];
                     if (generatorParams.CurrentState == GeneratorState.Loop)
                         s2 = Samples[(int)generatorParams.CurrentStart];
                     else
                         s2 = s1;
                     mu = (1f - (float)Math.Cos((generatorParams.Phase - index) * Math.PI)) * 0.5f;
                     blockBuffer[start++] = s1 * (1f - mu) + s2 * mu;
                     generatorParams.Phase += increment;
                 }
             }
             #endregion
             break;
         case Interpolation.CubicSpline:
             #region CubicSpline
             {
                 double _end = generatorParams.CurrentState == GeneratorState.Loop ? this.LoopStartPhase + 1 : this.StartPhase + 1;
                 int index;
                 float s0, s1, s2, s3, mu;
                 while (start < end && generatorParams.Phase < _end)//edge case, wrap to endpoint or duplicate sample
                 {
                     index = (int)generatorParams.Phase;
                     if (generatorParams.CurrentState == GeneratorState.Loop)
                         s0 = Samples[(int)generatorParams.CurrentEnd - 1];
                     else
                         s0 = Samples[index];
                     s1 = Samples[index];
                     s2 = Samples[index + 1];
                     s3 = Samples[index + 2];
                     mu = (float)(generatorParams.Phase - index);
                     blockBuffer[start++] = ((-0.5f * s0 + 1.5f * s1 - 1.5f * s2 + 0.5f * s3) * mu * mu * mu + (s0 - 2.5f * s1 + 2f * s2 - 0.5f * s3) * mu * mu + (-0.5f * s0 + 0.5f * s2) * mu + (s1));
                     generatorParams.Phase += increment;
                 }
                 _end = generatorParams.CurrentState == GeneratorState.Loop ? this.LoopEndPhase - 2 : this.EndPhase - 2;
                 while (start < end && generatorParams.Phase < _end)
                 {
                     index = (int)generatorParams.Phase;
                     s0 = Samples[index - 1];
                     s1 = Samples[index];
                     s2 = Samples[index + 1];
                     s3 = Samples[index + 2];
                     mu = (float)(generatorParams.Phase - index);
                     blockBuffer[start++] = ((-0.5f * s0 + 1.5f * s1 - 1.5f * s2 + 0.5f * s3) * mu * mu * mu + (s0 - 2.5f * s1 + 2f * s2 - 0.5f * s3) * mu * mu + (-0.5f * s0 + 0.5f * s2) * mu + (s1));
                     generatorParams.Phase += increment;
                 }
                 _end += 1;
                 while (start < end)//edge case, wrap to startpoint or duplicate sample
                 {
                     index = (int)generatorParams.Phase;
                     s0 = Samples[index - 1];
                     s1 = Samples[index];
                     if (generatorParams.Phase < _end)
                     {
                         s2 = Samples[index + 1];
                         if (generatorParams.CurrentState == GeneratorState.Loop)
                             s3 = Samples[(int)generatorParams.CurrentStart];
                         else
                             s3 = s2;
                     }
                     else
                     {
                         if (generatorParams.CurrentState == GeneratorState.Loop)
                         {
                             s2 = Samples[(int)generatorParams.CurrentStart];
                             s3 = Samples[(int)generatorParams.CurrentStart + 1];
                         }
                         else
                         {
                             s2 = s1;
                             s3 = s1;
                         }
                     }
                     mu = (float)(generatorParams.Phase - index);
                     blockBuffer[start++] = ((-0.5f * s0 + 1.5f * s1 - 1.5f * s2 + 0.5f * s3) * mu * mu * mu + (s0 - 2.5f * s1 + 2f * s2 - 0.5f * s3) * mu * mu + (-0.5f * s0 + 0.5f * s2) * mu + (s1));
                     generatorParams.Phase += increment;
                 }
             }
             #endregion
             break;
         default:
             #region None
             {
                 while (start < end)
                 {
                     blockBuffer[start++] = Samples[(int)generatorParams.Phase];
                     generatorParams.Phase += increment;
                 }
             }
             #endregion
             break;
     }
 }
示例#18
0
 private static SampleArray CreateSincTable(int windowSize, int resolution, float cornerRatio, Func<float, int, float> windowFunction)
 {
     var subWindow = ((windowSize / 2) + 1);
     var table = new SampleArray((subWindow * resolution));
     var gain = 2.0 * cornerRatio;
     for (int x = 0; x < subWindow; x++)
     {
         for (int y = 0; y < resolution; y++)
         {
             var a = x + (y / (float)(resolution));
             var sinc = SynthConstants.TwoPi * cornerRatio * a;
             if (Math.Abs(sinc) > 0.00001)
                 sinc = Math.Sin(sinc) / sinc;
             else
                 sinc = 1.0;
             table[x * SynthConstants.SincResolution + y] = (float)(gain * sinc * windowFunction(a, windowSize));
         }
     }
     return table;
 }
示例#19
0
 private static SampleArray CreateSineTable(int size)
 {
     var graph = new SampleArray(size);
     var inc = (float)(3.0 * Math.PI / 2.0) / (size - 1);
     var phase = 0.0;
     for (int x = 0; x < size; x++)
     {
         graph[x] = (float)Math.Abs(Math.Sin(phase));
         phase += inc;
     }
     return graph;
 }
示例#20
0
 private static SampleArray CreateLinearTable(int size)
 {
     var table = new SampleArray(size);
     for (int x = 0; x < size; x++)
     {
         table[x] = x / (float)(size - 1);
     }
     return table;
 }
示例#21
0
        public override int Read(float[] buffer, int offset, int count)
        {
            if (_circularBuffer.Count < count)
            {
                if (_finished)
                {
                    if (Finished != null) Finished();
                    Stop();
                }
                else
                {
                    // when buffering we count it as pause time
                    _pauseTime += (BufferSize * 1000) / (2 * WaveFormat.SampleRate);
                }
            }
            else
            {
                var read = new SampleArray(count);
                _circularBuffer.Read(read, 0, read.Length);

                for (int i = 0; i < count; i++)
                {
                    buffer[offset + i] = read[i];
                }
            }

            if (PositionChanged != null)
            {
                PositionChanged((int)(CalcPosition()));
            }

            if (!_finished)
            {
                RequestBuffers();
            }

            return count;
        }
示例#22
0
 public static void Blit(SampleArray src, int srcPos, SampleArray dest, int destPos, int len)
 {
 }
示例#23
0
 public void AddSamples(SampleArray samples)
 {
     PostMessage(new { cmd = "playerAddSamples", samples = samples });
 }
示例#24
0
 public static void Blit(SampleArray src, int srcPos, SampleArray dest, int destPos, int len)
 {
     Array.Copy(src.Samples, srcPos, dest.Samples, destPos, len);
 }
示例#25
0
 public static void Blit(SampleArray src, int srcPos, SampleArray dest, int destPos, int len)
 {
 }
示例#26
0
 private static SampleArray CreateSemitoneTable()
 {//-127 to 127 semitones
     var table = new SampleArray(255);
     for (int x = 0; x < table.Length; x++)
     {
         table[x] = (float)Math.Pow(2.0, (x - 127.0) / 12.0);
     }
     return table;
 }
示例#27
0
 private static SampleArray CreateSustainTable(int size)
 {
     var table = new SampleArray(size);
     for (int x = 0; x < size; x++)
     {
         table[x] = 1;
     }
     return table;
 }
示例#28
0
        public override int Read(float[] buffer, int offset, int count)
        {
            if (_circularBuffer.Count < count)
            {
                if (_finished)
                {
                    if (Finished != null) Finished();
                    Stop();
                }
            }
            else
            {
                var read = new SampleArray(count);
                _circularBuffer.Read(read, 0, read.Length);

                for (int i = 0; i < count; i++)
                {
                    buffer[offset + i] = read[i];
                }

                var samples = count/2.0;
                _currentTime += (samples / SampleRate) * 1000 * _playbackSpeed;

            }

            if (PositionChanged != null)
            {
                PositionChanged((int)_currentTime);
            }

            if (!_finished)
            {
                RequestBuffers();
            }

            return count;
        }
示例#29
0
 private static SampleArray CreateExponentialTable(int size, float coeff)
 {
     coeff = SynthHelper.ClampF(coeff, .001f, .9f);
     var graph = new SampleArray(size);
     var val = 0.0;
     for (int x = 0; x < size; x++)
     {
         graph[x] = (float)val;
         val += coeff * ((1 / 0.63) - val);
     }
     for (int x = 0; x < size; x++)
     {
         graph[x] = graph[x] / graph[graph.Length - 1];
     }
     return graph;
 }
示例#30
0
 public void SetAudioChannelCount(int channels)
 {
     channels = SynthHelper.ClampI(channels, 1, 2);
     if (AudioChannels != channels)
     {
         AudioChannels = channels;
         SampleBuffer = new SampleArray((MicroBufferSize * MicroBufferCount * AudioChannels));
     }
 }
示例#31
0
 private static SampleArray RemoveDenormals(SampleArray data)
 {
     for (int x = 0; x < data.Length; x++)
     {
         if (Math.Abs(data[x]) < SynthConstants.DenormLimit)
             data[x] = 0;
     }
     return data;
 }
示例#32
0
 public void ApplyFilter(SampleArray data)
 {
     switch (FilterMethod)
     {
         case FilterType.BiquadHighpass:
         case FilterType.BiquadLowpass:
             for (int x = 0; x < data.Length; x++)
             {
                 _m3 = data[x] - _a1 * _m1 - _a2 * _m2;
                 data[x] = _b2 * (_m3 + _m2) + _b1 * _m1;
                 _m2 = _m1;
                 _m1 = _m3;
             }
             break;
         case FilterType.OnePoleLowpass:
             for (int x = 0; x < data.Length; x++)
             {
                 _m1 += _a1 * (data[x] - _m1);
                 data[x] = _m1;
             }
             break;
     }
 }
示例#33
0
 public void ApplyFilterInterp(SampleArray data, int sampleRate)
 {
     float[] ic = GenerateFilterCoeff(CutOff / sampleRate, Resonance);
     float a1_inc = (ic[0] - _a1) / data.Length;
     float a2_inc = (ic[1] - _a2) / data.Length;
     float b1_inc = (ic[2] - _b1) / data.Length;
     float b2_inc = (ic[3] - _b2) / data.Length;
     switch (FilterMethod)
     {
         case FilterType.BiquadHighpass:
         case FilterType.BiquadLowpass:
             for (int x = 0; x < data.Length; x++)
             {
                 _a1 += a1_inc;
                 _a2 += a2_inc;
                 _b1 += b1_inc;
                 _b2 += b2_inc;
                 _m3 = data[x] - _a1 * _m1 - _a2 * _m2;
                 data[x] = _b2 * (_m3 + _m2) + _b1 * _m1;
                 _m2 = _m1;
                 _m1 = _m3;
             }
             _a1 = ic[0];
             _a2 = ic[1];
             _b1 = ic[2];
             _b2 = ic[3];
             break;
         case FilterType.OnePoleLowpass:
             for (int x = 0; x < data.Length; x++)
             {
                 _a1 += a1_inc;
                 _m1 += _a1 * (data[x] - _m1);
                 data[x] = _m1;
             }
             _a1 = ic[0];
             break;
     }
     CoeffNeedsUpdating = false;
 }
 public void AddSamples(SampleArray f)
 {
     _circularBuffer.Write(f, 0, f.Length);
 }
示例#35
0
 private static SampleArray CreateCentTable()
 {//-100 to 100 cents
     var cents = new SampleArray(201);
     for (int x = 0; x < cents.Length; x++)
     {
         cents[x] = (float)Math.Pow(2.0, (x - 100.0) / 1200.0);
     }
     return cents;
 }
示例#36
0
 public static void Blit(SampleArray src, int srcPos, SampleArray dest, int destPos, int len)
 {
     Array.Copy(src.Samples, srcPos, dest.Samples, destPos, len);
 }