예제 #1
0
        private void CreateOptimizedArray()
        {
            long offset     = 0;
            long numSamples = mDrawSource.Length;
            int  x          = 0;
            int  y          = 0;

            //Nth item holds maxVal, N+1th item holds minVal so allocate an array of double size
            mOptimizedArray = new float[((numSamples / mThresholdSample) + 1) * 2];
            float[] data        = new float[mThresholdSample];
            int     samplesRead = 1;

            mDrawSource.Position = 0;
            string rawFilePath = System.Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + @"\SoundFactory\";

            if (!Directory.Exists(rawFilePath))
            {
                Directory.CreateDirectory(rawFilePath);
            }
            mRawFileName = rawFilePath + Guid.NewGuid().ToString() + ".raw";
            FileStream   rawFile = new FileStream(mRawFileName, FileMode.Create, FileAccess.ReadWrite);
            BinaryWriter bin     = new BinaryWriter(rawFile);

            while (offset < numSamples && samplesRead > 0)
            {
                samplesRead = mDrawSource.Read(data, 0, mThresholdSample);
                if (samplesRead > 0) //for some files file length is wrong so samplesRead may become 0 even if we did not come to the end of the file
                {
                    for (int i = 0; i < samplesRead; i++)
                    {
                        bin.Write(data[i]);
                    }

                    float maxVal = -1;
                    float minVal = 1;
                    // finds the max & min peaks for this pixel
                    for (x = 0; x < samplesRead; x++)
                    {
                        maxVal = Math.Max(maxVal, data[x]);
                        minVal = Math.Min(minVal, data[x]);
                    }
                    mOptimizedArray[y]     = minVal;
                    mOptimizedArray[y + 1] = maxVal;
                    y              += 2;
                    offset         += samplesRead;
                    mProgressStatus = (int)(((float)offset / numSamples) * 100);
                    if (progress.Value != mProgressStatus)
                    {
                        InvokeOnUiThreadIfRequired(() => progress.Value = mProgressStatus);
                    }
                }
            }
            rawFile.Close();
        }
        public bool Read(ArraySegment <float> samples)
        {
            // If synchroniser is not enabled just pass the request upstream with no playback rate adjustment
            if (!_enabled)
            {
                PlaybackRate = 1;
                return(_upstream.Read(samples));
            }

            // Start the timer when the first sample is read. All subsequent timing will be based off this.
            if (!_timer.IsRunning)
            {
                _timer.Reset();
                _timer.Start();
            }

            // We always read the amount of requested data, update the count of total data read now
            _totalSamplesRead += samples.Count;

            // Calculate how out of sync playback is (based on actual samples read vs time passed)
            _desync.Update(IdealPlaybackPosition, PlaybackPosition);

            // If playback rate is too fast, slow down immediately (to prevent exhausting the buffer). If playback speed is too slow, ramp up over the next few frames.
            var corrected = _desync.CorrectedPlaybackSpeed;

            PlaybackRate = corrected < PlaybackRate
                         ? corrected
                         : Mathf.LerpUnclamped(PlaybackRate, _desync.CorrectedPlaybackSpeed, 0.25f);

            // Skip audio if necessary to resync the audio stream
            int skippedSamples;
            int skippedMilliseconds;
            var complete = Skip(_desync.DesyncMilliseconds, out skippedSamples, out skippedMilliseconds);

            if (skippedSamples > 0)
            {
                _totalSamplesRead += skippedSamples;
                _desync.Skip(skippedMilliseconds);
            }

            // If skipping completed the session return silence
            if (complete)
            {
                // ReSharper disable once AssignNullToNotNullAttribute
                Array.Clear(samples.Array, samples.Offset, samples.Count);
                return(true);
            }

            // Read from upstream
            return(_upstream.Read(samples));
        }
예제 #3
0
        public bool Read(ArraySegment <float> samples)
        {
            // Start the timer when the first sample is read. All subsequent timing will be based off this.
            if (!_timer.IsRunning)
            {
                _timer.Reset();
                _timer.Start();
            }

            // We always read the amount of requested data, update the count of total data read now
            _totalSamplesRead += samples.Count;

            // If the buffer is too small slighty increase the count of samples read (by 0.1ms) Desync compensation will think it is ahead of
            // where it should be and will slow down playback, which will cause the buffer to grow.
            if (_pipeline.BufferCount < 1)
            {
                _totalSamplesRead += WaveFormat.SampleRate / 10000;
            }

            // Calculate how out of sync playback is (based on actual samples read vs time passed)
            _desync.Update(IdealPlaybackPosition, PlaybackPosition);

            // If playback rate is too fast, slow down immediately (to prevent exhausting the buffer). If playback speed is too slow, ramp up over the next few frames.
            var corrected = _desync.CorrectedPlaybackSpeed;

            PlaybackRate = corrected < PlaybackRate
                         ? corrected
                         : Mathf.LerpUnclamped(PlaybackRate, _desync.CorrectedPlaybackSpeed, 0.25f);

            // Skip audio if necessary to resync the audio stream
            int skippedSamples;
            int skippedMilliseconds;
            var complete = Skip(_desync.DesyncMilliseconds, out skippedSamples, out skippedMilliseconds);

            if (skippedSamples > 0)
            {
                _totalSamplesRead += skippedSamples;
                _desync.Skip(skippedMilliseconds);
            }

            // If skipping completed the session return silence
            if (complete)
            {
                // ReSharper disable once AssignNullToNotNullAttribute
                Array.Clear(samples.Array, samples.Offset, samples.Count);
                return(true);
            }

            // Read from upstream
            return(_upstream.Read(samples));
        }
예제 #4
0
        /// <summary>Reads processed data to the provided buffer.</summary>
        /// <param name="buffer">The buffer.</param>
        /// <param name="offset">The offset to the first value.</param>
        /// <param name="count">The number of the values to read.</param>
        /// <returns>The number of read values.</returns>
        public int Read(float[] buffer, int offset, int count)
        {
            int read = resampler.Read(buffer, offset, count);

            SamplesAvailable?.Invoke(this, new SamplesAvailableEventArgs(buffer, offset, read));
            return(read);
        }
예제 #5
0
        public int Read(float[] buffer, int offset, int count)
        {
            lock (_lockObj)
            {
                int read = _source.Read(buffer, offset, count);

                for (int n = 0; n < read; n += WaveFormat.Channels)
                {
                    if (WaveFormat.Channels > 1)
                    {
                        if (Mode != SampleDataProviderMode.Left && Mode != SampleDataProviderMode.Merge)
                        {
                            _sampleBuffer1.Enqueue(buffer[n + 1]);
                        }
                        else if (Mode == SampleDataProviderMode.Merge)
                        {
                            _sampleBuffer.Enqueue((buffer[n] + buffer[n + 1]) / 2f);
                        }
                    }
                    if (Mode != SampleDataProviderMode.Right && Mode != SampleDataProviderMode.Merge)
                    {
                        _sampleBuffer.Enqueue(buffer[n]);
                    }
                    if (_sampleBuffer.Count >= BlockSize || _sampleBuffer1.Count > BlockSize)
                    {
                        RaiseBlockRead();
                        Mode = Mode;
                    }
                }

                return(read);
            }
        }
예제 #6
0
파일: Wav.cs 프로젝트: jlai1997/Pianotes
 private void Initialise(ISampleSource sampleSource)
 {
     Initialise(sampleSource.WaveFormat.SampleRate, (int)sampleSource.Length / sampleSource.WaveFormat.Channels, sampleSource.WaveFormat.Channels);
     float[] buffer = new float[sampleSource.Length];
     sampleSource.Read(buffer, 0, (int)sampleSource.Length);
     LoadAudioData(buffer);
 }
예제 #7
0
        // Helper for State.Looking
        void StartCapture()
        {
            Debug.Assert(m_State == State.Looking);
            Debug.Assert(m_AudioCapture != null);

            // TODO: This starts as a WaveSource (raw bytes), converts to floats
            // so we can notify once for each sample.
            // The SingleBlockNotificationStream is very garbagey; we should use our own
            // wrapper that grabs all the samples read and pushes them into m_HotValues
            // en masse instead of one-at-a-time.
            var soundInSource = new SoundInSource(m_AudioCapture);
            var sampleSource  = soundInSource.ToSampleSource();
            var singleBlockNotificationStream = new SingleBlockNotificationStream(sampleSource);

            m_FinalSource = singleBlockNotificationStream;

            // Consume and discard any bytes when they come in. We do this for
            // its side effects (firing the SingleBlockNotificationStream event).
            // buffer is closed-over by the lambda.
            float[] buffer = new float[m_FinalSource.WaveFormat.BytesPerSecond / 4];
            soundInSource.DataAvailable += (s, e) =>
            {
                int read;
                do
                {
                    read = m_FinalSource.Read(buffer, 0, buffer.Length);
                } while (read > 0);
            };

            singleBlockNotificationStream.SingleBlockRead += SingleBlockNotificationStreamOnSingleBlockRead;
            m_AudioCapture.Start();
        }
예제 #8
0
        public bool Read(ArraySegment <float> samples)
        {
            var result = _upstream.Read(samples);

            _clipper.Clip(samples);
            return(result);
        }
        private void GenerateVideo(ISampleSource source)
        {
            Console.WriteLine("Initializing video writer...");
            using (var writer = new VideoWriter(options.OutputFile.FullName))
            {
                writer.Width           = 1920;
                writer.Height          = 1080;
                writer.Fps             = options.Fps;
                writer.AudioSampleRate = source.WaveFormat.SampleRate;
                writer.Open();

                double totalFrames = FrameMath.CalculateTotalFrames(source, options);

                Console.WriteLine("Initializing renderer...");
                using (var renderer = new GLRenderer(false))
                {
                    var wallpaper = Image.FromFile(options.WallpaperFile.FullName) as Bitmap;
                    wallpaperTexture = renderer.LoadTexture(wallpaper);
                    effectChain.Initialize(source.ToMono(), options);

                    Console.WriteLine("Generating video...");
                    float[] sampleBuffer = new float[writer.AudioSamplesPerFrame];

                    var frameNumber = 0;
                    while (true)
                    {
                        if (writer.WriteVideo)
                        {
                            renderer.Clear();
                            RenderFrame(renderer, new Frame(frameNumber, TimeSpan.FromSeconds(frameNumber / (double)options.Fps)));

                            var frame = renderer.Snapshot();
                            writer.WriteVideoFrame(frame);

                            if (frameNumber % 60 == 0)
                            {
                                ProgressHandler?.Invoke(Math.Round(frameNumber / totalFrames * 100.0, 2));
                            }

                            frameNumber++;
                        }
                        else
                        {
                            var read = source.Read(sampleBuffer, 0, sampleBuffer.Length);
                            if (read > 0)
                            {
                                writer.WriteAudioFrame(sampleBuffer);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                    ProgressHandler?.Invoke(Math.Round(frameNumber / totalFrames * 100.0, 2));
                }
            }
        }
        public bool Read(ArraySegment<float> samples)
        {
            FlushTransferBuffer();
            var complete = _output.Read(samples);

            if (complete)
                _completionHandler(this);

            return complete;
        }
예제 #11
0
        /// <summary>
        /// Reads from this sample provider
        /// </summary>
        public int Read(float[] buffer, int offset, int count)
        {
            float[] inBuffer;
            int     inBufferOffset;
            int     framesRequested = count / channels;
            int     inNeeded        = resampler.ResamplePrepare(framesRequested, outFormat.Channels, out inBuffer, out inBufferOffset);
            int     inAvailable     = source.Read(inBuffer, inBufferOffset, inNeeded * channels) / channels;
            int     outAvailable    = resampler.ResampleOut(buffer, offset, inAvailable, framesRequested, channels);

            return(outAvailable * channels);
        }
        public int Read(float[] buffer, int offset, int count)
        {
            int status = audiostream.Read(buffer, offset, count);

            audioThisTime = buffer;
            for (int i = offset; i < offset + status; i++)
            {
                buffer[i] = buffer[i] * gain;
            }
            PitchProcessing.PitchShift(pitchFactor, offset, count, 2048, 4, audiostream.WaveFormat.SampleRate, buffer);
            return(status);
        }
예제 #13
0
        static void NewData(ISampleSource source)
        {
            newDataIsRunning = true;
            if (source == null)
            {
                WriteLog("ERROR! (newData): Something went wrong (source is null). Exiting.");
                Exit(1);
            }
            int  read;
            bool res = false;

            float[] buffer = new float[source.WaveFormat.BytesPerSecond / 1000];
            while ((read = source.Read(buffer, 0, buffer.Length)) > 0)
            {
                ;
            }
            int   i   = 0;
            float sum = 0;

            foreach (float item in buffer)
            {
                sum += item;
                i++;
            }
            sum = Math.Abs(sum);
            if (sum.GetHashCode() > 0)
            {
                res = true;
            }

            bool ret = IsProgramRunning(appName);

            if (isMusicPlaying & !res & !noSoundIsRunning)
            {
                Thread noSound = new Thread(NoSound);
                noSound.IsBackground = true;
                noSound.Start();
            }
            else if (!isMusicPlaying & !res & !noSoundIsRunning)
            {
                Thread noSound = new Thread(NoSound);
                noSound.IsBackground = true;
                noSound.Start();
            }
            else if (!isMusicPlaying & res)
            {
                WriteLog("(newData): We have sound! Player is running: " + ret.ToString());
            }

            isMusicPlaying = res;

            Thread.Sleep(100);
        }
예제 #14
0
        public bool Read(ArraySegment <float> samples)
        {
            var inFormat  = _source.WaveFormat;
            var outFormat = _outputFormat;

            if (outFormat.SampleRate == inFormat.SampleRate)
            {
                return(_source.Read(samples));
            }

            if (_resampler == null || outFormat.SampleRate != (int)_resampler.OutputSampleRate)
            {
                Log.Debug("Initializing resampler to resample {0}Hz source to {1}Hz output", inFormat.SampleRate, outFormat.SampleRate);

                _resampler = new WdlResampler();
                _resampler.SetMode(true, 2, false);
                _resampler.SetFilterParms();
                _resampler.SetFeedMode(false); // output driven
                _resampler.SetRates(inFormat.SampleRate, outFormat.SampleRate);
            }

            var channels = inFormat.Channels;

            // prepare buffers
            float[] inBuffer;
            int     inBufferOffset;
            var     samplesPerChannelRequested = samples.Count / channels;
            var     samplesPerChannelRequired  = _resampler.ResamplePrepare(samplesPerChannelRequested, channels, out inBuffer, out inBufferOffset);
            var     sourceBuffer = new ArraySegment <float>(inBuffer, inBufferOffset, samplesPerChannelRequired * channels);

            // read source
            var complete = _source.Read(sourceBuffer);

            // resample
            Log.Trace("Resampling {0}Hz -> {1}Hz", inFormat.SampleRate, outFormat.SampleRate);
            _resampler.ResampleOut(samples.Array, samples.Offset, samplesPerChannelRequired, samplesPerChannelRequested, channels);

            return(complete);
        }
예제 #15
0
    private void OnReadAudio(float[] data)
    {
        if (_decoder == null)
        {
            throw new ObjectDisposedException("this", "This resource has already disposed.");
        }

        var remainedLength = _loopEnd - _decoder.Position / _decoder.WaveFormat.Channels;

        if (remainedLength < data.Length)
        {
            var readLength = remainedLength == 0 ? 0 : _decoder.Read(data, 0, (int)remainedLength);
            _decoder.Position = _loopBegin;
            _decoder.Read(data, readLength, data.Length - readLength);
        }
        else
        {
            var buffer = new float[data.Length];
            _decoder.Read(buffer, 0, buffer.Length);
            buffer.CopyTo(data, 0);
        }
    }
예제 #16
0
        public virtual int Read(float[] buffer, int offset, int count)
        {
            if (offset % WaveFormat.Channels != 0)
            {
                throw new ArgumentOutOfRangeException("offset");
            }
            if (count % WaveFormat.Channels != 0)
            {
                throw new ArgumentOutOfRangeException("count");
            }

            return(_source.Read(buffer, offset, count));
        }
예제 #17
0
        public int Read(float[] buffer, int offset, int count)
        {
            int sourceSampleRate = source.WaveFormat.SampleRate;
            int mySampleRate     = WaveFormat.SampleRate;

            int numTheirSamples = (int)Mathf.Floor((count * (float)sourceSampleRate / mySampleRate));

            if (source == null)
            {
                return(0);
            }
            int res = 100;

            try
            {
                res = source.Read(tempBuffer1, 0, numTheirSamples);
                if (res == 0)
                {
                    if (count == 0)
                    {
                        return(0);
                    }
                    if (count == 1)
                    {
                        buffer[offset] = lastThing;
                        return(1);
                    }
                    if (count >= 2)
                    {
                        buffer[offset]     = lastThing * 0.8f;
                        buffer[offset + 1] = lastThing * 0.6f;
                        return(2);
                    }
                }
                int numOurSamples = (int)Mathf.Round((res * (float)mySampleRate / sourceSampleRate));
                res = src_simple_plain(tempBuffer1, tempBuffer2, res, numOurSamples, (float)mySampleRate / sourceSampleRate, quality, source.WaveFormat.Channels);
                if (res > count)
                {
                    res = count;
                }
                Buffer.BlockCopy(tempBuffer2, 0, buffer, offset, res * 4);
                lastThing = buffer[offset + res - 1];
            }
            catch (Exception e)
            {
                Debug.Log("failed read: " + e.Message);
            }

            return(Mathf.Max(res, 2));
        }
예제 #18
0
        public override int Read(float[] buffer, int offset, int count)
        {
            lock (lockObject)
            {
                if (_seekRequested)
                {
                    _soundTouch.Clear();
                    _seekRequested = false;
                }

                var samplesRead = 0;
                var endOfSource = false;

                while (samplesRead < count)
                {
                    if (_soundTouch.NumberOfSamples() == 0)
                    {
                        var readFromSource = _sampleSource.Read(_sourceReadBuffer, 0, _sourceReadBuffer.Length);
                        if (_sampleSource.Position >= _sampleSource.Length)
                        {
                            return(samplesRead);
                        }
                        if (readFromSource == 0)
                        {
                            endOfSource = true;
                            _soundTouch.Flush();
                            return(0);
                        }

                        _soundTouch.PutSamples(_sourceReadBuffer, readFromSource / _sampleSource.WaveFormat.Channels);
                    }

                    var desiredSampleFrames = (count - samplesRead) / _sampleSource.WaveFormat.Channels;
                    var received            = _soundTouch.ReceiveSamples(_soundTouchReadBuffer, desiredSampleFrames) * _sampleSource.WaveFormat.Channels;

                    for (int n = 0; n < received; n++)
                    {
                        buffer[offset + samplesRead++] = _soundTouchReadBuffer[n];
                    }

                    if (received == 0 && endOfSource)
                    {
                        break;
                    }
                }

                return(samplesRead);
            }
        }
예제 #19
0
        public static void chargerChanson(string chemin, out double Fe, out double[] res)
        {
            IWaveSource   source = CodecFactory.Instance.GetCodec(chemin);
            ISampleSource signal = source.ToSampleSource();

            Fe     = source.WaveFormat.SampleRate;
            signal = signal.ToMono();
            int size = (int)signal.Length;

            float[] valeurs = new float[size];
            signal.Read(valeurs, 0, size);
            res = new double[size];
            for (int i = 0; i < size; i++)
            {
                res[i] = (double)valeurs[i];
            }
        }
예제 #20
0
        public int Read(float[] buffer, int offset, int count)
        {
            float gainAmplification = (float)(Math.Pow(10.0, GainDB / 20.0));
            int   samples           = mSource.Read(buffer, offset, count);

            if (gainAmplification != 1.0f)
            {
                for (int i = offset; i < offset + samples; i++)
                {
                    buffer[i] = Math.Max(Math.Min(buffer[i] * gainAmplification, 1), -1);
                }
            }

            if (PitchShift != 1.0f)
            {
                PitchShifter.PitchShift(PitchShift, offset, count, 2048, 4, mSource.WaveFormat.SampleRate, buffer);
            }
            return(samples);
        }
예제 #21
0
        //##########################################################################################################################################################################################################

        /// <summary>
        /// Read the WAV file and split the samples to the left and right channel
        /// </summary>
        private void ReadToList()
        {
            if (!File.Exists(Filepath))
            {
                return;
            }

            WaveFileReader reader = new WaveFileReader(Filepath);

            format = reader.WaveFormat;

            //Length_s = reader.GetLength().TotalSeconds;             // reader.GetLength() contains the FormatChunks too!
            //Length_s = (reader.Length / format.BytesPerSecond);     // reader.Length contains the FormatChunks too!
            List <CSCore.Codecs.WAV.WaveFileChunk> waveFileDataChunks = reader.Chunks.Where(c => c.GetType() == typeof(DataChunk)).ToList();
            long waveFileDataChunksSizeBytes = waveFileDataChunks.Sum(c => c.ChunkDataSize);

            Length_s = (waveFileDataChunksSizeBytes / format.BytesPerSecond);

            //long _sampleCount = reader.Length / (reader.WaveFormat.BitsPerSample / 8);
            //_sampleCount /= reader.WaveFormat.Channels;                                 //Each sample contains the values of the right and left channel for (Waveformat.Channels == 2)

            ISampleSource source = WaveToSampleBase.CreateConverter(reader);

            format = source.WaveFormat;

            float[] sample_buffer = new float[format.Channels];
            while (source.Read(sample_buffer, 0, sample_buffer.Length) > 0 && source.Position < (waveFileDataChunksSizeBytes / format.Channels))          //At least one byte read
            {
                double time_ms = ((1 / (double)source.WaveFormat.BytesPerSecond) * source.WaveFormat.BytesPerSample * source.Position) * 1000;

                AudioSample sample_left = new AudioSample(sample_buffer[0], time_ms, AudioChannels.LEFT);
                Samples.Add(sample_left);

                if (reader.WaveFormat.Channels == 2)
                {
                    AudioSample sample_right = new AudioSample(sample_buffer[1], time_ms, AudioChannels.RIGHT);
                    Samples.Add(sample_right);
                }
            }
            reader.Dispose();
        }
예제 #22
0
        public bool Read(ArraySegment <float> samples)
        {
            var inFormat  = _source.WaveFormat;
            var outFormat = _outputFormat;

            // Configure the rate of the resampler based on the requested playback rate.
            // If rate adjustment is very small (<1%) play back at the base rate, this means
            // in the normal case (rate=1) the rate won't be changing every frame
            var outputRate = (double)outFormat.SampleRate;

            if (Mathf.Abs(_rate.PlaybackRate - 1) > 0.01f)
            {
                outputRate = outFormat.SampleRate * (1 / _rate.PlaybackRate);
            }

            // ReSharper disable once CompareOfFloatsByEqualityOperator (justification: we want exact comparison)
            if (outputRate != _resampler.OutputSampleRate)
            {
                Log.Trace("Changing resampler rate to {0}Hz", outputRate);
                _resampler.SetRates(inFormat.SampleRate, outputRate);
            }

            var channels = inFormat.Channels;

            // prepare buffers
            float[] inBuffer;
            int     inBufferOffset;
            var     samplesPerChannelRequested = samples.Count / channels;
            var     samplesPerChannelRequired  = _resampler.ResamplePrepare(samplesPerChannelRequested, channels, out inBuffer, out inBufferOffset);
            var     sourceBuffer = new ArraySegment <float>(inBuffer, inBufferOffset, samplesPerChannelRequired * channels);

            // read source
            var complete = _source.Read(sourceBuffer);

            // resample
            Log.Trace("Resampling {0}Hz -> {1}Hz", inFormat.SampleRate, outFormat.SampleRate);
            _resampler.ResampleOut(samples.Array, samples.Offset, samplesPerChannelRequired, samplesPerChannelRequested, channels);

            return(complete);
        }
예제 #23
0
        /// <summary>
        /// Fetch data dynamically from the SampleSource.
        /// </summary>
        /// <param name="start"></param>
        /// <param name="length"></param>
        /// <param name="resolution"></param>
        /// <returns></returns>
        public float[] GetDataRange(int start, int length, int resolution = 2048)
        {
            if (start + length > _sampleSource.Length)
            {
                return(null);
            }

            if (resolution <= 0)
            {
                return(null);
            }

            if (length < resolution)
            {
                resolution = length;
            }

            var blockSize = length / resolution;
            var samples   = new float[resolution];

            _sampleSource.Position = start;
            var buffer = new float[blockSize];

            for (var i = 0; i < resolution; i++)
            {
                int read = _sampleSource.Read(buffer, 0, blockSize);

                if (read < buffer.Length)
                {
                    Array.Clear(samples, read, buffer.Length - read);
                }

                samples[i] = GetPeak(buffer);
            }

            return(samples);
        }
예제 #24
0
        public List <Onset> Detect(ISampleSource audio)
        {
            _onsets.Clear();
            _completed  = 0;
            _sliceCount = 0;
            _onsets     = new List <float>();
            _amplitudes = new List <float>();
            var onsets = new List <Onset>();

            //init detection specific variables
            int sliceSampleSize  = (int)Math.Ceiling(_options.SliceLength * audio.WaveFormat.SampleRate); //the size of each slice's sample
            int slicePaddingSize = (int)Math.Ceiling(_options.SlicePaddingLength * audio.WaveFormat.SampleRate);

            _sliceCount = (int)Math.Ceiling((float)audio.Length / audio.WaveFormat.Channels / sliceSampleSize); //the number of slices needed
            var samples = (int)audio.Length / audio.WaveFormat.Channels;

            //init parallel specific variables
            var pOptions = new ParallelOptions();

            if (_options.MaxDegreeOfParallelism != -1)
            {
                pOptions.MaxDegreeOfParallelism = _options.MaxDegreeOfParallelism;
            }
            ParallelLoopState loopState;

            List <Wav> wavSlices = new List <Wav>();

            for (int i = 0; i < _sliceCount; i++)
            {
                int     baseStart     = i * sliceSampleSize;
                int     adjustedStart = (baseStart - sliceSampleSize > 0) ? baseStart - slicePaddingSize : 0;
                int     count         = (sliceSampleSize + slicePaddingSize + baseStart > samples) ? samples - adjustedStart : sliceSampleSize + (baseStart - adjustedStart) + slicePaddingSize;
                float   delay         = (float)adjustedStart / audio.WaveFormat.SampleRate;
                float[] buffer        = new float[count * audio.WaveFormat.Channels];
                audio.SetPosition(TimeConverter.SampleSourceTimeConverter.ToTimeSpan(audio.WaveFormat, adjustedStart * audio.WaveFormat.Channels));
                audio.Read(buffer, 0, count * audio.WaveFormat.Channels);
                wavSlices.Add(new Wav(buffer, audio.WaveFormat.SampleRate, count, audio.WaveFormat.Channels)
                {
                    Delay   = delay,
                    Padding = ((delay > 0) ? slicePaddingSize : 0) / audio.WaveFormat.SampleRate
                });
            }

            int             bucketSize  = 5;
            int             bucketcount = (int)Math.Ceiling((double)wavSlices.Count / bucketSize);
            MemoryAllocator _allocator  = new MemoryAllocator();

            for (int i = 0; i < bucketcount; i++)
            {
                _allocator.Reset();
                int count = bucketSize;
                if ((i + 1) * bucketSize > wavSlices.Count)
                {
                    count = wavSlices.Count - i * bucketSize;
                }

                if (count < 0)
                {
                    continue;
                }

                List <Wav> parallel    = wavSlices.GetRange(i * bucketSize, count);
                var        ploopResult = Parallel.ForEach(parallel, pOptions, (w, state) => GetOnsets(w, _allocator));
                if (!ploopResult.IsCompleted)
                {
                    throw new Exception();
                }
            }

            onsets = _onsets.Zip(_amplitudes, (onset, amplitude) => new Onset {
                OnsetTime = onset, OnsetAmplitude = amplitude
            }).ToList();
            onsets = onsets.OrderBy(f => f.OnsetTime).ToList();

            float prev    = 0;
            float combine = 0.03f;
            var   ret     = new List <Onset>();

            for (int i = 0; i < onsets.Count; i++)
            {
                if (onsets[i].OnsetTime - prev < _options.MinimumTimeDelta / 1000.0f)
                {
                    continue;
                }
                prev = onsets[i].OnsetTime;
                ret.Add(onsets[i]);
            }
            return(ret);
        }
예제 #25
0
 private void Initialise(ISampleSource sampleSource)
 {
     Initialise(sampleSource.WaveFormat.SampleRate, (int)sampleSource.Length / sampleSource.WaveFormat.Channels, sampleSource.WaveFormat.Channels);
     float[] buffer = new float[sampleSource.Length];
     sampleSource.Read(buffer, 0, (int)sampleSource.Length);
     LoadAudioData(buffer);
 }
예제 #26
0
            //public int Read(byte[] buffer, int offset, int count)
            //{
            //    return _audioSource.Read(buffer, 0, count);
            //}

            public int Read(float[] buffer, int offset, int count)
            {
                return(_audioSource.Read(buffer, 0, count));
            }
예제 #27
0
        public string GetLevelsFromAudioFX(string audioType, string audioFile)
        {
            string audioFilename  = Path.Combine(Executor.Current.ExpanderSharedFiles, audioType, audioFile);
            string levelsFilename = Path.Combine(Executor.Current.ExpanderSharedFiles, audioType, audioFile + ".levels");

            if (!File.Exists(levelsFilename))
            {
                using (ISampleSource source = CodecFactory.Instance.GetCodec(audioFilename).ToSampleSource())
                {
                    var fftProvider = new FftProvider(source.WaveFormat.Channels, FftSize.Fft1024);

                    int millisecondsPerFrame = 1000 / 40;

                    long maxBufferLengthInSamples = source.GetRawElements(millisecondsPerFrame);

                    long bufferLength = Math.Min(source.Length, maxBufferLengthInSamples);

                    float[] buffer = new float[bufferLength];

                    int read             = 0;
                    int totalSamplesRead = 0;

                    var fftData = new float[1024];

                    var   list    = new List <float>();
                    float highest = 0;
                    do
                    {
                        //determine how many samples to read
                        int samplesToRead = (int)Math.Min(source.Length - totalSamplesRead, buffer.Length);

                        read = source.Read(buffer, 0, samplesToRead);
                        if (read == 0)
                        {
                            break;
                        }

                        totalSamplesRead += read;

                        //add read data to the fftProvider
                        fftProvider.Add(buffer, read);

                        fftProvider.GetFftData(fftData);

                        float highestAmplitude = 0;
                        for (int i = 0; i < fftData.Length / 2; i++)
                        {
                            if (fftData[i] > highestAmplitude)
                            {
                                highestAmplitude = fftData[i];
                            }
                        }

                        list.Add(highestAmplitude);
                        if (highestAmplitude > highest)
                        {
                            highest = highestAmplitude;
                        }
                    } while (totalSamplesRead < source.Length);

                    if (highest > 0)
                    {
                        // Adjust to equalize
                        float adjustment = 1 / highest;

                        for (int i = 0; i < list.Count; i++)
                        {
                            list[i] *= adjustment;
                        }
                    }

                    using (var fs = File.Create(levelsFilename))
                    {
                        fs.Write(list.Select(x => (byte)(x * 255)).ToArray(), 0, list.Count);
                    }
                }
            }

            return(levelsFilename);
        }
예제 #28
0
 public int Read(float[] buffer, int offset, int count) =>
 m_source.Read(new Span <float>(buffer, offset, count));
예제 #29
0
        //private Bitmap DrawWave(Pen pen, int w, int h)
        //{
        //    Color defaultColor = pen.Color;
        //    long numSamples = mDrawSource.Length;

        //    int mSamplesPerPixel = (int)(mDrawSource.Length / w);
        //    int mDrawingStartOffset = 0;
        //    int mPrevSamplesPerPixel = mSamplesPerPixel;
        //    Bitmap mBitmap = null;
        //    if (mBitmap == null || ((mBitmap.Width != w) | (mBitmap.Height != h)))
        //    {
        //        if (mBitmap != null)
        //            mBitmap.Dispose();
        //        mBitmap = new Bitmap(w, h);
        //    }
        //    Graphics canvas = Graphics.FromImage(mBitmap);

        //    int prevX = 0;
        //    int prevMaxY = 0;
        //    int prevMinY = 0;
        //    float maxVal = 0;
        //    float minVal = 0;
        //    int i = 0;
        //    // index is how far to offset into the data array
        //    long index = 0;
        //    int maxSampleToShow = (int)Math.Min((mSamplesPerPixel * w) + mDrawingStartOffset, numSamples);
        //    int sampleCount = 0;
        //    int offsetIndex = 0;
        //    if (mSamplesPerPixel > mThresholdSample)
        //    {
        //        sampleCount = (int)(mSamplesPerPixel / mThresholdSample) * 2;
        //        offsetIndex = (int)Math.Floor((decimal)(mDrawingStartOffset / mThresholdSample)) * 2;
        //    }
        //    float[] data = new float[mSamplesPerPixel];
        //    mDrawSource.Position = mDrawingStartOffset;

        //    int x = 0;

        //    while (index < maxSampleToShow)
        //    {
        //        maxVal = -1;
        //        minVal = 1;
        //        int samplesRead = 0;
        //        if (mSamplesPerPixel > mThresholdSample)
        //        {
        //            int startIndex = offsetIndex + (i * sampleCount);
        //            int endIndex = Math.Min(mOptimizedArray.Length - 1, startIndex + sampleCount - 1);
        //            for (x = startIndex; x <= endIndex; x++)
        //            {
        //                maxVal = Math.Max(maxVal, mOptimizedArray[x]);
        //                minVal = Math.Min(minVal, mOptimizedArray[x]);
        //            }
        //        }
        //        else
        //        {
        //            samplesRead = mDrawSource.Read(data, 0, data.Length);
        //            // finds the max & min peaks for this pixel
        //            for (x = 0; x < samplesRead; x++)
        //            {
        //                maxVal = Math.Max(maxVal, data[x]);
        //                minVal = Math.Min(minVal, data[x]);
        //            }
        //        }
        //        //8-bit samples are stored as unsigned bytes, ranging from 0 to 255.
        //        //16-bit samples are stored as 2's-complement signed integers, ranging from -32768 to 32767.
        //        // scales based on height of window
        //        int scaledMinVal = (int)(((minVal + 1) * h) / 2);
        //        int scaledMaxVal = (int)(((maxVal + 1) * h) / 2);
        //        // if the max/min are the same, then draw a line from the previous position,
        //        // otherwise we will not see anything
        //        if (prevX >= Math.Min(splitP1.X, splitP2.X) - 10 && prevX <= Math.Max(splitP1.X, splitP2.X) - 10)
        //        {
        //            pen.Color = defaultColor;
        //        }
        //        else
        //        {
        //            pen.Color = Color.Black;
        //        }
        //        if (scaledMinVal == scaledMaxVal)
        //        {
        //            if (prevMaxY != 0)
        //            {
        //                canvas.DrawLine(pen, prevX, prevMaxY, i, scaledMaxVal);
        //            }
        //        }
        //        else
        //        {
        //            if (i > prevX)
        //            {
        //                if (prevMaxY < scaledMinVal)
        //                {

        //                    canvas.DrawLine(pen, prevX, prevMaxY, i, scaledMinVal);
        //                }
        //                else
        //                {
        //                    if (prevMinY > scaledMaxVal)
        //                    {
        //                        canvas.DrawLine(pen, prevX, prevMinY, i, scaledMaxVal);
        //                    }
        //                }
        //            }

        //            canvas.DrawLine(pen, i, scaledMinVal, i, scaledMaxVal);
        //        }

        //        prevX = i;
        //        prevMaxY = scaledMaxVal;
        //        prevMinY = scaledMinVal;
        //        i += 1;
        //        index = (i * mSamplesPerPixel) + mDrawingStartOffset;
        //    }

        //    return mBitmap;

        //}

        //private string mRawFileName;

        //private void CreateOptimizedArray()
        //{
        //    mDrawSource = CodecFactory.Instance.GetCodec(filePath).ToSampleSource().ToMono();
        //    long offset = 0;
        //    long numSamples = mDrawSource.Length;
        //    int x = 0;
        //    int y = 0;
        //    //Nth item holds maxVal, N+1th item holds minVal so allocate an array of double size
        //    mOptimizedArray = new float[((numSamples / mThresholdSample) + 1) * 2];
        //    float[] data = new float[mThresholdSample];
        //    int samplesRead = 1;
        //    mDrawSource.Position = 0;
        //    string rawFilePath = System.Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + @"\SoundFactory\";
        //    if (!Directory.Exists(rawFilePath)) Directory.CreateDirectory(rawFilePath);
        //    mRawFileName = rawFilePath + Guid.NewGuid().ToString() + ".raw";
        //    FileStream rawFile = new FileStream(mRawFileName, FileMode.Create, FileAccess.ReadWrite);
        //    BinaryWriter bin = new BinaryWriter(rawFile);
        //    while (offset < numSamples && samplesRead > 0)
        //    {
        //        samplesRead = mDrawSource.Read(data, 0, mThresholdSample);
        //        if (samplesRead > 0) //for some files file length is wrong so samplesRead may become 0 even if we did not come to the end of the file
        //        {
        //            for (int i = 0; i < samplesRead; i++)
        //            {
        //                bin.Write(data[i]);
        //            }
        //            float maxVal = -1;
        //            float minVal = 1;
        //            // finds the max & min peaks for this pixel
        //            for (x = 0; x < samplesRead; x++)
        //            {
        //                maxVal = Math.Max(maxVal, data[x]);
        //                minVal = Math.Min(minVal, data[x]);
        //            }
        //            mOptimizedArray[y] = minVal;
        //            mOptimizedArray[y + 1] = maxVal;
        //            y += 2;
        //            offset += samplesRead;
        //            //mProgressStatus = (int)(((float)offset / numSamples) * 100);
        //        }
        //    }
        //}

        private Bitmap DrawWave(Pen pen, int w, int h)
        {
            Color defaultColor = pen.Color;
            long  numSamples   = mDrawSource.Length;

            int mSamplesPerPixel = (int)(mDrawSource.Length / w);

            int mDrawingStartOffset = 0;

            int    mPrevSamplesPerPixel = mSamplesPerPixel;
            Bitmap mBitmap = null;

            if (mBitmap == null || ((mBitmap.Width != w) | (mBitmap.Height != h)))
            {
                if (mBitmap != null)
                {
                    mBitmap.Dispose();
                }
                mBitmap = new Bitmap(w, h);
            }
            Graphics canvas = Graphics.FromImage(mBitmap);

            int   prevX    = 0;
            int   prevMaxY = 0;
            int   prevMinY = 0;
            float maxVal   = 0;
            float minVal   = 0;

            int i = 0;

            // index is how far to offset into the data array
            long index           = 0;
            int  maxSampleToShow = (int)Math.Min((mSamplesPerPixel * w) + mDrawingStartOffset, numSamples);

            int sampleCount = 0;
            int offsetIndex = 0;

            if (mSamplesPerPixel > mThresholdSample)
            {
                sampleCount = (int)(mSamplesPerPixel / mThresholdSample) * 2;
                offsetIndex = (int)Math.Floor((decimal)(mDrawingStartOffset / mThresholdSample)) * 2;
            }
            float[] data = new float[mSamplesPerPixel];
            mDrawSource.Position = mDrawingStartOffset;


            int x = 0;

            while (index < maxSampleToShow)
            {
                maxVal = -1;
                minVal = 1;
                int samplesRead = 0;
                if (mSamplesPerPixel > mThresholdSample)
                {
                    int startIndex = offsetIndex + (i * sampleCount);
                    int endIndex   = Math.Min(mOptimizedArray.Length - 1, startIndex + sampleCount - 1);
                    for (x = startIndex; x <= endIndex; x++)
                    {
                        maxVal = Math.Max(maxVal, mOptimizedArray[x]);
                        minVal = Math.Min(minVal, mOptimizedArray[x]);
                    }
                }
                else
                {
                    samplesRead = mDrawSource.Read(data, 0, data.Length);
                    // finds the max & min peaks for this pixel
                    for (x = 0; x < samplesRead; x++)
                    {
                        maxVal = Math.Max(maxVal, data[x]);
                        minVal = Math.Min(minVal, data[x]);
                    }
                }
                //8-bit samples are stored as unsigned bytes, ranging from 0 to 255.
                //16-bit samples are stored as 2's-complement signed integers, ranging from -32768 to 32767.
                // scales based on height of window
                int scaledMinVal = (int)(((minVal + 1) * h) / 2);
                int scaledMaxVal = (int)(((maxVal + 1) * h) / 2);

                // if the max/min are the same, then draw a line from the previous position,
                // otherwise we will not see anything


                if (prevX >= Math.Min(splitP1.X, splitP2.X) - 10 && prevX <= Math.Max(splitP1.X, splitP2.X) - 10)
                {
                    pen.Color = defaultColor;
                }
                else
                {
                    pen.Color = Color.Black;
                }
                if (scaledMinVal == scaledMaxVal)
                {
                    if (prevMaxY != 0)
                    {
                        canvas.DrawLine(pen, prevX, prevMaxY, i, scaledMaxVal);
                    }
                }
                else
                {
                    if (i > prevX)
                    {
                        if (prevMaxY < scaledMinVal)
                        {
                            canvas.DrawLine(pen, prevX, prevMaxY, i, scaledMinVal);
                        }
                        else
                        {
                            if (prevMinY > scaledMaxVal)
                            {
                                canvas.DrawLine(pen, prevX, prevMinY, i, scaledMaxVal);
                            }
                        }
                    }

                    canvas.DrawLine(pen, i, scaledMinVal, i, scaledMaxVal);
                }

                prevX    = i;
                prevMaxY = scaledMaxVal;
                prevMinY = scaledMinVal;

                i    += 1;
                index = (i * mSamplesPerPixel) + mDrawingStartOffset;
            }

            return(mBitmap);
        }
예제 #30
0
        public List<Onset> Detect(ISampleSource audio)
        {
            _onsets.Clear();
            _completed = 0;
            _sliceCount = 0;
            _onsets = new List<float>();
            _amplitudes = new List<float>();
            var onsets = new List<Onset>();

            //init detection specific variables
            int sliceSampleSize = (int)Math.Ceiling(_options.SliceLength * audio.WaveFormat.SampleRate); //the size of each slice's sample
            int slicePaddingSize = (int)Math.Ceiling(_options.SlicePaddingLength * audio.WaveFormat.SampleRate);
            _sliceCount = (int)Math.Ceiling((float)audio.Length/audio.WaveFormat.Channels / sliceSampleSize); //the number of slices needed
            var samples = (int)audio.Length / audio.WaveFormat.Channels;

            //init parallel specific variables
            var pOptions = new ParallelOptions();
            if (_options.MaxDegreeOfParallelism != -1) pOptions.MaxDegreeOfParallelism = _options.MaxDegreeOfParallelism;
            ParallelLoopState loopState;

            List<Wav> wavSlices = new List<Wav>();
            for (int i = 0; i < _sliceCount; i++)
            {
                int baseStart = i * sliceSampleSize;
                int adjustedStart = (baseStart - sliceSampleSize > 0) ? baseStart - slicePaddingSize : 0;
                int count = (sliceSampleSize + slicePaddingSize + baseStart > samples) ? samples - adjustedStart : sliceSampleSize + (baseStart - adjustedStart) + slicePaddingSize;
                float delay = (float)adjustedStart / audio.WaveFormat.SampleRate;
                float[] buffer = new float[count * audio.WaveFormat.Channels];
                audio.SetPosition(TimeConverter.SampleSourceTimeConverter.ToTimeSpan(audio.WaveFormat, adjustedStart * audio.WaveFormat.Channels));
                audio.Read(buffer, 0, count * audio.WaveFormat.Channels);
                wavSlices.Add(new Wav(buffer, audio.WaveFormat.SampleRate, count, audio.WaveFormat.Channels) {
                    Delay = delay,
                    Padding = ((delay > 0) ? slicePaddingSize : 0) / audio.WaveFormat.SampleRate
                });
            }

            int bucketSize = 5;
            int bucketcount = (int)Math.Ceiling((double)wavSlices.Count / bucketSize);
            MemoryAllocator _allocator = new MemoryAllocator();

            for (int i = 0; i < bucketcount; i++)
            {
                _allocator.Reset();
                int count = bucketSize;
                if ((i + 1) * bucketSize > wavSlices.Count) count = wavSlices.Count - i * bucketSize;

                if (count < 0) continue;

                List<Wav> parallel = wavSlices.GetRange(i * bucketSize, count);
                var ploopResult = Parallel.ForEach(parallel, pOptions, (w, state) => GetOnsets(w, _allocator));
                if (!ploopResult.IsCompleted) throw new Exception();
            }

            onsets = _onsets.Zip(_amplitudes, (onset, amplitude) => new Onset { OnsetTime = onset, OnsetAmplitude = amplitude }).ToList();
            onsets = onsets.OrderBy(f => f.OnsetTime).ToList();

            float prev = 0;
            float combine = 0.03f;
            var ret = new List<Onset>();
            for (int i = 0; i < onsets.Count; i++)
            {
                if (onsets[i].OnsetTime - prev < _options.MinimumTimeDelta / 1000.0f)
                    continue;
                prev = onsets[i].OnsetTime;
                ret.Add(onsets[i]);
            }
            return ret;
        }