ReadSamples() public method

Reads decoded samples from the current logical stream
public ReadSamples ( float buffer, int offset, int count ) : int
buffer float The buffer to write the samples to
offset int The offset into the buffer to write the samples to
count int The number of samples to write
return int
コード例 #1
0
    public void Mix(float[] data, int channels, float volume)
    {
        if (reader.SampleRate == 44100 && reader.Channels == channels)
        {
            float[] ndata = new float[data.Length];
            int     read  = reader.ReadSamples(ndata, 0, ndata.Length);
            for (int i = 0; i < read; i++)
            {
                float b = ndata[i] * volume;
                float a = data[i];
                data[i] = a + b - a * b;
            }
        }
        else if (reader.SampleRate == 44100)
        {
            float[] ndata = new float[data.Length / channels * reader.Channels];
            int     read  = reader.ReadSamples(ndata, 0, ndata.Length) / reader.Channels;

            for (int i = 0; i < read; i++)
            {
                for (int c = 0; c < channels; c++)
                {
                    float b = ndata[i * reader.Channels + c % reader.Channels] * volume;
                    float a = data[i * channels + c];
                    data[i * channels + c] = a + b - a * b;
                }
            }
        }
        else
        {
            Debug.Log("OnlyPlay 44100,now rate is" + reader.SampleRate);
        }
    }
コード例 #2
0
ファイル: ALUtils.cs プロジェクト: rhynodegreat/Pencil.Gaming
		private static void LoadOgg(VorbisReader vorbis, out byte[] data, out ALFormat format, out uint sampleRate, out TimeSpan len) {
			sampleRate = (uint)vorbis.SampleRate;
			format = vorbis.Channels == 1 ? ALFormat.Mono16 : ALFormat.Stereo16;
			len = vorbis.TotalTime;

			float[] buffer = new float[vorbis.SampleRate / 10 * vorbis.Channels];
			List<byte> bytes = new List<byte>((int)(vorbis.SampleRate * vorbis.Channels * 2 * len.TotalSeconds));
			int count = 0;
			while ((count = vorbis.ReadSamples(buffer, 0, buffer.Length)) > 0) {
				for (int i = 0; i < count; i++) {
					int temp = (int)(short.MaxValue * buffer [i]);
					if (temp > short.MaxValue) {
						temp = short.MaxValue;
					} else if (temp < short.MinValue) {
						temp = short.MinValue;
					}
					short tempBytes = (short)temp;
					byte byte1 = (byte)((tempBytes >> 8) & 0x00FF);
					byte byte2 = (byte)((tempBytes >> 0) & 0x00FF);

					// Little endian
					bytes.Add(byte2);
					bytes.Add(byte1);
				}
			}
			// TODO: Add better implementation so that there's no need for array copying
			data = bytes.ToArray();
		}
コード例 #3
0
        private static PCMData ReadAll(VorbisReader vorbisStream)
        {
            PCMData pcm;
            pcm.ChannelCount = (short)vorbisStream.Channels;
            pcm.SampleRate = vorbisStream.SampleRate;

            var samples = new List<float>();

            var buffer = new float[DefaultBufferSize];
            int samplesRead = 0;
            while ((samplesRead = vorbisStream.ReadSamples(buffer, 0, buffer.Length)) > 0)
            {
                if (samplesRead != buffer.Length)
                {
                    Array.Resize(ref buffer, samplesRead);
                }
                samples.AddRange(buffer);
                buffer = new float[DefaultBufferSize];
            }

            var samplesArray = samples.ToArray();
            pcm.Data = new byte[samplesArray.Length * SampleSizeBytes];
            Buffer.BlockCopy(samplesArray, 0, pcm.Data, 0, pcm.Data.Length);

            return pcm;
        }
コード例 #4
0
ファイル: OggReader.cs プロジェクト: Iandika/Cgen.Audio
        /// <summary>
        /// Reads a block of audio samples from the current stream and writes the data to given sample.
        /// </summary>
        /// <param name="samples">The sample array to fill.</param>
        /// <param name="count">The maximum number of samples to read.</param>
        /// <returns>The number of samples actually read.</returns>
        public override long Read(short[] samples, long count)
        {
            float[] buffer = new float[count];
            int     read   = _reader.ReadSamples(buffer, 0, (int)count);

            CastBuffer(buffer, samples, read);

            return(read);
        }
コード例 #5
0
ファイル: OggAudioSource.cs プロジェクト: killowatt/Dunamis
        public OggAudioSource(Stream file, bool streaming = true)
        {
            Streaming = streaming;
            _fileStream = file;

            _reader = new VorbisReader(file, false);
            _sampleRate = _reader.SampleRate;
            _format = (_reader.Channels == 2 ? ALFormat.Stereo16 : ALFormat.Mono16);

            if(!Streaming)
            {
                _data = new short[_reader.TotalSamples];
                float[] samples = new float[_reader.TotalSamples];
                _reader.ReadSamples(samples, 0, (int)_reader.TotalSamples);
                CastSamples(ref samples, ref _data, samples.Length);
            }
        }
コード例 #6
0
ファイル: AudioManager.cs プロジェクト: Zoxive/TrueCraft
 private SoundEffect LoadOgg(Stream stream)
 {
     using (var reader = new VorbisReader(stream, false))
     {
         float[] _buffer = new float[reader.TotalSamples];
         byte[] buffer = new byte[reader.TotalSamples * 2];
         reader.ReadSamples(_buffer, 0, _buffer.Length);
         for (int i = 0; i < _buffer.Length; i++)
         {
             short val = (short)Math.Max(Math.Min(short.MaxValue * _buffer[i], short.MaxValue), short.MinValue);
             var decoded = BitConverter.GetBytes(val);
             buffer[i * 2] = decoded[0];
             buffer[i * 2 + 1] = decoded[1];
         }
         return new SoundEffect(buffer, reader.SampleRate, reader.Channels == 1 ? AudioChannels.Mono : AudioChannels.Stereo);
     }
 }
コード例 #7
0
ファイル: OggDecoder.cs プロジェクト: tzachshabtay/MonoAGS
		public ISoundData Decode(Stream stream)
		{
			VorbisReader reader = null;
			try
			{
				reader = new VorbisReader (stream, false);

				int channels = reader.Channels;
				const int BITS_PER_SAMPLE = 16;
				int sampleRate = reader.SampleRate;

				//Code from: https://github.com/AdamsLair/duality/blob/a911c46b6bc830c05d3bb1202f8e7060543eaefa/Duality/Audio/OggVorbis.cs
				List<float[]> allBuffers = new List<float[]>();
				bool eof = false;
				int totalSamplesRead = 0;
				int dataRead = 0;
				while (!eof)
				{
					float[] buffer = new float[DEFAULT_BUFFER_SIZE];
					int bufferSamplesRead = 0;
					while(bufferSamplesRead < buffer.Length)
					{
						int samplesRead;
						lock (_readMutex)
						{
							samplesRead = reader.ReadSamples(buffer, dataRead, buffer.Length - dataRead);
						}
						if (samplesRead > 0)
						{
							bufferSamplesRead += samplesRead;
						}
						else
						{
							eof = true;
							break;
						}
					}
					allBuffers.Add(buffer);
					totalSamplesRead += bufferSamplesRead;
				}

				if (totalSamplesRead > 0)
				{
					short[] data = new short[totalSamplesRead];
					int offset = 0;
					for (int i = 0; i < allBuffers.Count; i++)
					{
						int len = Math.Min(totalSamplesRead - offset, allBuffers[i].Length);
						castBuffer(allBuffers[i], data, offset, len);
						offset += len;
					}
					return new SoundData(channels, BITS_PER_SAMPLE, sampleRate, data, Marshal.SizeOf(typeof(short)) * data.Length);
				}
				else
				{
					Debug.WriteLine("OggDecoder: No samples found in ogg file");
					return null;
				}
			}
			catch (InvalidDataException e)
			{
				Debug.WriteLine("OggDecoder: Failed to read ogg. " + e.ToString());
				return null;
			}
			finally
			{
				if (reader != null) reader.Dispose();
			}
		}
コード例 #8
0
ファイル: AudioSource.cs プロジェクト: Insane-96/aiv-vorbis
		private void Streamer (object arg)
		{
			string fileName = (string)arg;

			VorbisReader vreader = new VorbisReader (fileName);

			// 3 seconds buffering
			int bufLen = vreader.Channels * vreader.SampleRate * 3;
			float[] buffer = new float[bufLen];

			if (this.bufferIds == null) {
				this.bufferIds = AL.GenBuffers (3);
				AudioDevice.CheckError ("allocating OpenAL buffers for streaming");
			}

			ALFormat format = vreader.Channels == 2 ? ALFormat.StereoFloat32Ext : ALFormat.MonoFloat32Ext;

			// buffer data
			int i;
			for (i = 0; i < bufferIds.Length; i++) {
				int count = vreader.ReadSamples (buffer, 0, bufLen);
				// end of the stream ?
				if (count == 0) {
					if (!this.streamLooping)
						break;
					vreader.DecodedPosition = 0;
					count = vreader.ReadSamples (buffer, 0, bufLen);
				}
				AL.BufferData<float> (this.bufferIds [i], format, buffer, count * sizeof(float), vreader.SampleRate);
				AudioDevice.CheckError ("loading data in OpenAL buffer for streaming");
			}
			AL.SourceQueueBuffers (this.audioSourceId, i, bufferIds);

			AL.SourcePlay (this.audioSourceId);

			while (true) {
				Thread.Sleep (30);
				int processed = 0;
				AL.GetSource (this.audioSourceId, ALGetSourcei.BuffersProcessed, out processed);
				while (processed > 0) {
					int bufferId = AL.SourceUnqueueBuffer (this.audioSourceId);
					int count = vreader.ReadSamples (buffer, 0, bufLen);
					// end of the straem ?
					if (count == 0) {
						if (!this.streamLooping) {
							this.Stop ();
							// to reset status
							AL.Source (this.audioSourceId, ALSourcei.Buffer, 0);
							return;
						}
						vreader.DecodedPosition = 0;
						count = vreader.ReadSamples (buffer, 0, bufLen);
					}
					AL.BufferData<float> (bufferId, format, buffer, count * sizeof(float), vreader.SampleRate);
					AudioDevice.CheckError ("loading data in OpenAL buffer for streaming");
					AL.SourceQueueBuffer (this.audioSourceId, bufferId);
					processed--;
				}
			}
		}
コード例 #9
0
    void loadData()
    {
        if (filepath != string.Empty && File.Exists(filepath))
        {
#if BASS_AUDIO
            long        trackLengthInBytes = Bass.BASS_ChannelGetLength(handle);
            const float FRAME_TIME         = 0.002f;
            long        frameLengthInBytes = Bass.BASS_ChannelSeconds2Bytes(handle, FRAME_TIME);
            int         NumFrames          = (int)System.Math.Round(1f * trackLengthInBytes / frameLengthInBytes);

            _data = new float[NumFrames * 2];

            float[] levels = new float[2];
            for (int i = 0; i < _data.Length && !stop; i += 2)
            {
                Bass.BASS_ChannelGetLevel(handle, levels, FRAME_TIME, BASSLevel.BASS_LEVEL_STEREO);
                float average = (levels[0] + levels[1]) / 2.0f;
                _data[i]     = -average;
                _data[i + 1] = average;
            }
#else
            byte[]  bytes      = File.ReadAllBytes(filepath);
            float[] sampleData = new float[0];
            switch (Path.GetExtension(filepath))
            {
            case (".ogg"):
                NVorbis.VorbisReader vorbis = new NVorbis.VorbisReader(filepath);
                vorbis.ClipSamples = false;

                _data = new float[vorbis.TotalSamples * vorbis.Channels];

                //vorbis.ReadSamples(_data, 0, _data.Length);

                int count = 0;
                while ((count += vorbis.ReadSamples(_data, count, 16000)) > 0 && !stop)
                {
                }

                break;

            case (".wav"):
                WAV wav = new WAV(bytes);
                sampleData = NAudioPlayer.InterleaveChannels(wav);
                break;

            case (".mp3"):
                NAudioPlayer.WAVFromMp3Data(bytes, out sampleData);
                break;

            default:
                return;
            }
#endif
            if (!stop)
            {
#if !BASS_AUDIO
                _data = sampleData;
#endif

                Debug.Log("Sample length: " + _data.Length);
            }
            else
            {
                _data = new float[0];
            }
        }
    }