/// <summary> /// Creates a new Wave input stream /// </summary> /// <param name="deviceNumber">The device to open - 0 is default</param> /// <param name="desiredFormat">The PCM format to record in</param> /// <param name="callbackWindow">If this parameter is non-null, the Wave In Messages /// will be sent to the message loop of the supplied control. This is considered a /// safer way to use the waveIn functionality</param> public WaveInStream(int deviceNumber, WaveFormat desiredFormat, Control callbackWindow) { waveFormat = desiredFormat; callback = Callback; if (callbackWindow == null) { MmException.Try( WaveInterop.waveInOpen(out waveInHandle, (IntPtr) deviceNumber, desiredFormat, callback, IntPtr.Zero, WaveInterop.CallbackFunction), "waveInOpen"); } else { waveInWindow = new WaveWindowNative(callback); MmException.Try( WaveInterop.waveInOpenWindow(out waveInHandle, (IntPtr) deviceNumber, desiredFormat, callbackWindow.Handle, IntPtr.Zero, WaveInterop.CallbackWindow), "waveInOpen"); waveInWindow.AssignHandle(callbackWindow.Handle); } // Default to three buffers of 100ms each int bufferSize = desiredFormat.AverageBytesPerSecond/10; numBuffers = 3; buffers = new WaveInBuffer[numBuffers]; for (int n = 0; n < numBuffers; n++) { buffers[n] = new WaveInBuffer(waveInHandle, bufferSize); } }
/// <summary> /// WaveStream to resample using the DMO Resampler /// </summary> /// <param name="inputProvider">Input Stream</param> /// <param name="outputFormat">Desired Output Format</param> public ResamplerDmoStream(IWaveProvider inputProvider, WaveFormat outputFormat) { this.inputProvider = inputProvider; inputStream = inputProvider as WaveStream; this.outputFormat = outputFormat; resampler = new Resampler(); if (!resampler.MediaObject.SupportsInputWaveFormat(0, inputStream.WaveFormat)) { throw new ArgumentException("Unsupported Input Stream format", "inputStream"); } resampler.MediaObject.SetInputWaveFormat(0, inputStream.WaveFormat); if (!resampler.MediaObject.SupportsOutputWaveFormat(0, outputFormat)) { throw new ArgumentException("Unsupported Output Stream format", "outputStream"); } resampler.MediaObject.SetOutputWaveFormat(0, outputFormat); if (inputStream != null) { position = InputToOutputPosition(inputStream.Position); } inputMediaBuffer = new MediaBuffer(inputProvider.WaveFormat.AverageBytesPerSecond); outputBuffer = new DmoOutputDataBuffer(outputFormat.AverageBytesPerSecond); }
/// <summary> /// Creates a new 32 bit WaveMixerStream /// </summary> public WaveMixerStream32() { autoStop = true; waveFormat = WaveFormat.CreateIeeeFloatWaveFormat(44100, 2); bytesPerSample = 4; inputStreams = new List<WaveStream>(); }
/// <summary> /// Prepares a Wave input device for recording /// </summary> public WaveIn(WaveCallbackInfo callbackInfo) { DeviceNumber = 0; WaveFormat = new WaveFormat(8000, 16, 1); BufferMilliseconds = 100; NumberOfBuffers = 3; callback = Callback; this.callbackInfo = callbackInfo; callbackInfo.Connect(callback); }
/// <summary> /// Create a new WaveFormat conversion stream /// </summary> /// <param name="targetFormat">Desired output format</param> /// <param name="sourceStream">Source stream</param> public WaveFormatConversionStream(WaveFormat targetFormat, WaveStream sourceStream) { this.sourceStream = sourceStream; this.targetFormat = targetFormat; conversionStream = new AcmStream(sourceStream.WaveFormat, targetFormat); // work out how many bytes the entire input stream will convert to length = SourceToDest((int) sourceStream.Length); blockAlign = SourceToDest(sourceStream.BlockAlign); position = 0; }
/// <summary> /// Creates a new ACM stream to convert one format to another, using a /// specified driver identified and wave filter /// </summary> /// <param name="driverId">the driver identifier</param> /// <param name="sourceFormat">the source format</param> /// <param name="waveFilter">the wave filter</param> public AcmStream(IntPtr driverId, WaveFormat sourceFormat, WaveFilter waveFilter) { int sourceBufferSize = Math.Max(16384, sourceFormat.AverageBytesPerSecond); this.sourceFormat = sourceFormat; sourceBufferSize -= (sourceBufferSize%sourceFormat.BlockAlign); MmException.Try(AcmInterop.acmDriverOpen(out driverHandle, driverId, 0), "acmDriverOpen"); MmException.Try(AcmInterop.acmStreamOpen(out streamHandle, driverHandle, sourceFormat, sourceFormat, waveFilter, IntPtr.Zero, IntPtr.Zero, AcmStreamOpenFlags.NonRealTime), "acmStreamOpen"); streamHeader = new AcmStreamHeader(streamHandle, sourceBufferSize, SourceToDest(sourceBufferSize)); }
/// <summary> /// Creates a new WaveFloatTo16Provider /// </summary> /// <param name="sourceProvider">the source provider</param> public WaveFloatTo16Provider(IWaveProvider sourceProvider) { if (sourceProvider.WaveFormat.Encoding != WaveFormatEncoding.IeeeFloat) throw new ApplicationException("Only PCM supported"); if (sourceProvider.WaveFormat.BitsPerSample != 32) throw new ApplicationException("Only 32 bit audio supported"); waveFormat = new WaveFormat(sourceProvider.WaveFormat.SampleRate, 16, sourceProvider.WaveFormat.Channels); this.sourceProvider = sourceProvider; volume = 1.0f; }
/// <summary> /// Creates a new Wave32To16Stream /// </summary> /// <param name="sourceStream">the source stream</param> public Wave32To16Stream(WaveStream sourceStream) { if (sourceStream.WaveFormat.Encoding != WaveFormatEncoding.IeeeFloat) throw new ApplicationException("Only 32 bit Floating point supported"); if (sourceStream.WaveFormat.BitsPerSample != 32) throw new ApplicationException("Only 32 bit Floating point supported"); waveFormat = new WaveFormat(sourceStream.WaveFormat.SampleRate, 16, sourceStream.WaveFormat.Channels); volume = 1.0f; this.sourceStream = sourceStream; length = sourceStream.Length/2; position = sourceStream.Position/2; }
/// <summary> /// Creates a new Wave16toFloatProvider /// </summary> /// <param name="sourceProvider">the source provider</param> public Wave16ToFloatProvider(IWaveProvider sourceProvider) { if (sourceProvider.WaveFormat.Encoding != WaveFormatEncoding.Pcm) throw new ApplicationException("Only PCM supported"); if (sourceProvider.WaveFormat.BitsPerSample != 16) throw new ApplicationException("Only 16 bit audio supported"); waveFormat = WaveFormat.CreateIeeeFloatWaveFormat(sourceProvider.WaveFormat.SampleRate, sourceProvider.WaveFormat.Channels); this.sourceProvider = sourceProvider; volume = 1.0f; }
/// <summary> /// Creates a WaveFormat with custom members /// </summary> /// <param name="tag">The encoding</param> /// <param name="sampleRate">Sample Rate</param> /// <param name="channels">Number of channels</param> /// <param name="averageBytesPerSecond">Average Bytes Per Second</param> /// <param name="blockAlign">Block Align</param> /// <param name="bitsPerSample">Bits Per Sample</param> /// <returns></returns> public static WaveFormat CreateCustomFormat(WaveFormatEncoding tag, int sampleRate, int channels, int averageBytesPerSecond, int blockAlign, int bitsPerSample) { var waveFormat = new WaveFormat(); waveFormat.waveFormatTag = tag; waveFormat.channels = (short) channels; waveFormat.sampleRate = sampleRate; waveFormat.averageBytesPerSecond = averageBytesPerSecond; waveFormat.blockAlign = (short) blockAlign; waveFormat.bitsPerSample = (short) bitsPerSample; waveFormat.extraSize = 0; return waveFormat; }
/// <summary> /// WaveFileWriter that actually writes to a stream /// </summary> /// <param name="outStream">Stream to be written to</param> /// <param name="format">Wave format to use</param> public WaveFileWriter(Stream outStream, WaveFormat format) { this.outStream = outStream; writer = new BinaryWriter(outStream, Encoding.ASCII); writer.Write(Encoding.ASCII.GetBytes("RIFF")); writer.Write(0); // placeholder writer.Write(Encoding.ASCII.GetBytes("WAVEfmt ")); this.format = format; format.Serialize(writer); CreateFactChunk(); WriteDataChunkHeader(); }
internal MmResult WaveOutOpen(out IntPtr waveOutHandle, int deviceNumber, WaveFormat waveFormat, WaveInterop.WaveCallback callback) { MmResult result; if (Strategy == WaveCallbackStrategy.FunctionCallback) { result = WaveInterop.waveOutOpen(out waveOutHandle, (IntPtr) deviceNumber, waveFormat, callback, IntPtr.Zero, WaveInterop.CallbackFunction); } else { result = WaveInterop.waveOutOpenWindow(out waveOutHandle, (IntPtr) deviceNumber, waveFormat, Handle, IntPtr.Zero, WaveInterop.CallbackWindow); } return result; }
/// <summary> /// Creates a new mono waveprovider based on a stereo input /// </summary> /// <param name="sourceProvider">Stereo 16 bit PCM input</param> public StereoToMonoProvider16(IWaveProvider sourceProvider) { if (sourceProvider.WaveFormat.Encoding != WaveFormatEncoding.Pcm) { throw new ArgumentException("Source must be PCM"); } if (sourceProvider.WaveFormat.Channels != 2) { throw new ArgumentException("Source must be stereo"); } if (sourceProvider.WaveFormat.BitsPerSample != 16) { throw new ArgumentException("Source must be 16 bit"); } this.sourceProvider = sourceProvider; outputFormat = new WaveFormat(sourceProvider.WaveFormat.SampleRate, 1); }
/// <summary> /// Selects the sample convertor based on the input WaveFormat and the output ASIOSampleTtype. /// </summary> /// <param name="waveFormat">The wave format.</param> /// <param name="asioType">The type.</param> /// <returns></returns> public static SampleConvertor SelectSampleConvertor(WaveFormat waveFormat, ASIOSampleType asioType) { SampleConvertor convertor = null; bool is2Channels = waveFormat.Channels == 2; if (waveFormat.BitsPerSample != 16 && waveFormat.BitsPerSample != 32) { throw new ArgumentException(String.Format("WaveFormat BitsPerSample {0} is not yet supported", waveFormat.BitsPerSample)); } // TODO : IMPLEMENTS OTHER CONVERTOR TYPES switch (asioType) { case ASIOSampleType.ASIOSTInt32LSB: switch (waveFormat.BitsPerSample) { case 16: convertor = (is2Channels) ? ConvertorShortToInt2Channels : (SampleConvertor) ConvertorShortToIntGeneric; break; case 32: convertor = (is2Channels) ? ConvertorFloatToInt2Channels : (SampleConvertor) ConvertorFloatToIntGeneric; break; } break; case ASIOSampleType.ASIOSTInt16LSB: switch (waveFormat.BitsPerSample) { case 16: convertor = (is2Channels) ? ConvertorShortToShort2Channels : (SampleConvertor) ConvertorShortToShortGeneric; break; case 32: convertor = (is2Channels) ? ConvertorFloatToShort2Channels : (SampleConvertor) ConvertorFloatToShortGeneric; break; } break; default: throw new ArgumentException( String.Format("ASIO Buffer Type {0} is not yet supported. ASIO Int32 buffer is only supported.", Enum.GetName(typeof (ASIOSampleType), asioType))); } return convertor; }
/// <summary> /// Initializes a new instance of the DMO MP3 Frame decompressor /// </summary> /// <param name="sourceFormat"></param> public DmoMp3FrameDecompressor(WaveFormat sourceFormat) { mp3Decoder = new WindowsMediaMp3Decoder(); if (!mp3Decoder.MediaObject.SupportsInputWaveFormat(0, sourceFormat)) { throw new ArgumentException("Unsupported input format"); } mp3Decoder.MediaObject.SetInputWaveFormat(0, sourceFormat); pcmFormat = new WaveFormat(sourceFormat.SampleRate, sourceFormat.Channels); // 16 bit if (!mp3Decoder.MediaObject.SupportsOutputWaveFormat(0, pcmFormat)) { throw new ArgumentException(String.Format("Unsupported output format {0}", pcmFormat)); } mp3Decoder.MediaObject.SetOutputWaveFormat(0, pcmFormat); // a second is more than enough to decompress a frame at a time inputMediaBuffer = new MediaBuffer(sourceFormat.AverageBytesPerSecond); outputBuffer = new DmoOutputDataBuffer(pcmFormat.AverageBytesPerSecond); }
/// <summary> /// Creates a new stereo waveprovider based on a mono input /// </summary> /// <param name="sourceProvider">Mono 16 bit PCM input</param> public MonoToStereoProvider16(IWaveProvider sourceProvider) { if (sourceProvider.WaveFormat.Encoding != WaveFormatEncoding.Pcm) { throw new ArgumentException("Source must be PCM"); } if (sourceProvider.WaveFormat.Channels != 1) { throw new ArgumentException("Source must be Mono"); } if (sourceProvider.WaveFormat.BitsPerSample != 16) { throw new ArgumentException("Source must be 16 bit"); } this.sourceProvider = sourceProvider; outputFormat = new WaveFormat(sourceProvider.WaveFormat.SampleRate, 2); RightVolume = 1.0f; LeftVolume = 1.0f; }
/// <summary> /// Creates a new WaveChannel32 /// </summary> /// <param name="sourceStream">the source stream</param> /// <param name="volume">stream volume (1 is 0dB)</param> /// <param name="pan">pan control (-1 to 1)</param> public WaveChannel32(WaveStream sourceStream, float volume, float pan) { PadWithZeroes = true; if (sourceStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm) throw new ApplicationException("Only PCM supported"); if (sourceStream.WaveFormat.BitsPerSample != 16) throw new ApplicationException("Only 16 bit audio supported"); // always outputs stereo 32 bit waveFormat = WaveFormat.CreateIeeeFloatWaveFormat(sourceStream.WaveFormat.SampleRate, 2); destBytesPerSample = 8; // includes stereo factoring this.sourceStream = sourceStream; this.volume = volume; this.pan = pan; sourceBytesPerSample = sourceStream.WaveFormat.Channels*sourceStream.WaveFormat.BitsPerSample/8; length = SourceToDest(sourceStream.Length); position = 0; }
/// <summary> /// Creates a new ACM stream to convert one format to another. Note that /// not all conversions can be done in one step /// </summary> /// <param name="sourceFormat">The source audio format</param> /// <param name="destFormat">The destination audio format</param> public AcmStream(WaveFormat sourceFormat, WaveFormat destFormat) { try { streamHandle = IntPtr.Zero; this.sourceFormat = sourceFormat; int sourceBufferSize = Math.Max(65536, sourceFormat.AverageBytesPerSecond); sourceBufferSize -= (sourceBufferSize%sourceFormat.BlockAlign); MmException.Try( AcmInterop.acmStreamOpen(out streamHandle, IntPtr.Zero, sourceFormat, destFormat, null, IntPtr.Zero, IntPtr.Zero, AcmStreamOpenFlags.NonRealTime), "acmStreamOpen"); int destBufferSize = SourceToDest(sourceBufferSize); streamHeader = new AcmStreamHeader(streamHandle, sourceBufferSize, destBufferSize); driverHandle = IntPtr.Zero; } catch { // suppress the finalise and clean up resources Dispose(); throw; } }
/// <summary> /// Initialize for playing the specified wave stream /// </summary> /// <param name="waveStream">IWaveProvider to play</param> public void Init(IWaveProvider waveStream) { long latencyRefTimes = latencyMilliseconds*10000; outputFormat = waveStream.WaveFormat; // first attempt uses the WaveFormat from the WaveStream WaveFormatExtensible closestSampleRateFormat; if (!audioClient.IsFormatSupported(shareMode, outputFormat, out closestSampleRateFormat)) { // Use closesSampleRateFormat (in sharedMode, it equals usualy to the audioClient.MixFormat) // See documentation : http://msdn.microsoft.com/en-us/library/ms678737(VS.85).aspx // They say : "In shared mode, the audio engine always supports the mix format" // The MixFormat is more likely to be a WaveFormatExtensible. if (closestSampleRateFormat == null) { WaveFormat correctSampleRateFormat = audioClient.MixFormat; /*WaveFormat.CreateIeeeFloatWaveFormat( audioClient.MixFormat.SampleRate, audioClient.MixFormat.Channels);*/ if (!audioClient.IsFormatSupported(shareMode, correctSampleRateFormat)) { // Iterate from Worst to Best Format WaveFormatExtensible[] bestToWorstFormats = { new WaveFormatExtensible( outputFormat.SampleRate, 32, outputFormat.Channels), new WaveFormatExtensible( outputFormat.SampleRate, 24, outputFormat.Channels), new WaveFormatExtensible( outputFormat.SampleRate, 16, outputFormat.Channels), }; // Check from best Format to worst format ( Float32, Int24, Int16 ) for (int i = 0; i < bestToWorstFormats.Length; i++) { correctSampleRateFormat = bestToWorstFormats[i]; if (audioClient.IsFormatSupported(shareMode, correctSampleRateFormat)) { break; } correctSampleRateFormat = null; } // If still null, then test on the PCM16, 2 channels if (correctSampleRateFormat == null) { // Last Last Last Chance (Thanks WASAPI) correctSampleRateFormat = new WaveFormatExtensible(outputFormat.SampleRate, 16, 2); if (!audioClient.IsFormatSupported(shareMode, correctSampleRateFormat)) { throw new NotSupportedException("Can't find a supported format to use"); } } } outputFormat = correctSampleRateFormat; } else { outputFormat = closestSampleRateFormat; } // just check that we can make it. using (new ResamplerDmoStream(waveStream, outputFormat)) { } dmoResamplerNeeded = true; } else { dmoResamplerNeeded = false; } sourceStream = waveStream; // If using EventSync, setup is specific with shareMode if (isUsingEventSync) { // Init Shared or Exclusive if (shareMode == AudioClientShareMode.Shared) { // With EventCallBack and Shared, both latencies must be set to 0 audioClient.Initialize(shareMode, AudioClientStreamFlags.EventCallback, 0, 0, outputFormat, Guid.Empty); // Get back the effective latency from AudioClient latencyMilliseconds = (int) (audioClient.StreamLatency/10000); } else { // With EventCallBack and Exclusive, both latencies must equals audioClient.Initialize(shareMode, AudioClientStreamFlags.EventCallback, latencyRefTimes, latencyRefTimes, outputFormat, Guid.Empty); } // Create the Wait Event Handle frameEventWaitHandle = new EventWaitHandle(false, EventResetMode.AutoReset); audioClient.SetEventHandle(frameEventWaitHandle); } else { // Normal setup for both sharedMode audioClient.Initialize(shareMode, AudioClientStreamFlags.None, latencyRefTimes, 0, outputFormat, Guid.Empty); } // Get the RenderClient renderClient = audioClient.AudioRenderClient; }
/// <summary> /// Writes a wave file, including a cues chunk /// </summary> public CueWaveFileWriter(string fileName, WaveFormat waveFormat) : base(fileName, waveFormat) { }
/// <summary> /// Opens MP3 from a stream rather than a file /// Will not dispose of this stream itself /// </summary> /// <param name="inputStream"></param> public Mp3FileReader(Stream inputStream) { // Calculated as a double to minimize rounding errors double bitRate; mp3Stream = inputStream; id3v2Tag = Id3v2Tag.ReadTag(mp3Stream); dataStartPosition = mp3Stream.Position; var mp3Frame = new Mp3Frame(mp3Stream); sampleRate = mp3Frame.SampleRate; frameLengthInBytes = mp3Frame.FrameLength; bitRate = mp3Frame.BitRate; xingHeader = XingHeader.LoadXingHeader(mp3Frame); // If the header exists, we can skip over it when decoding the rest of the file if (xingHeader != null) dataStartPosition = mp3Stream.Position; mp3DataLength = mp3Stream.Length - dataStartPosition; // try for an ID3v1 tag as well mp3Stream.Position = mp3Stream.Length - 128; var tag = new byte[128]; mp3Stream.Read(tag, 0, 3); if (tag[0] == 'T' && tag[1] == 'A' && tag[2] == 'G') { id3v1Tag = tag; mp3DataLength -= 128; } mp3Stream.Position = dataStartPosition; CreateTableOfContents(); tocIndex = 0; // [Bit rate in Kilobits/sec] = [Length in kbits] / [time in seconds] // = [Length in bits ] / [time in milliseconds] // Note: in audio, 1 kilobit = 1000 bits. bitRate = (mp3DataLength*8.0/TotalSeconds()); mp3Stream.Position = dataStartPosition; Mp3WaveFormat = new Mp3WaveFormat(sampleRate, mp3Frame.ChannelMode == ChannelMode.Mono ? 1 : 2, frameLengthInBytes, (int) bitRate); decompressor = new AcmMp3FrameDecompressor(Mp3WaveFormat); // new DmoMp3FrameDecompressor(this.Mp3WaveFormat); waveFormat = decompressor.OutputFormat; bytesPerSample = (decompressor.OutputFormat.BitsPerSample)/8*decompressor.OutputFormat.Channels; // no MP3 frames have more than 1152 samples in them // some MP3s I seem to get double decompressBuffer = new byte[1152*bytesPerSample*2]; }
/// <summary> /// Creates a new buffered WaveProvider /// </summary> /// <param name="waveFormat">WaveFormat</param> public BufferedWaveProvider(WaveFormat waveFormat) { this.waveFormat = waveFormat; queue = new Queue<AudioBuffer>(); MaxQueuedBuffers = 100; }
/// <summary> /// Initialises to play /// </summary> /// <param name="waveProvider"></param> public void Init(IWaveProvider waveProvider) { sourceStream = waveProvider; waveFormat = waveProvider.WaveFormat; // Select the correct sample convertor from WaveFormat -> ASIOFormat convertor = ASIOSampleConvertor.SelectSampleConvertor(waveFormat, driver.Capabilities.OutputChannelInfos[0].type); if (!driver.IsSampleRateSupported(waveFormat.SampleRate)) { throw new ArgumentException("SampleRate is not supported. TODO, implement Resampler"); } if (driver.Capabilities.SampleRate != waveFormat.SampleRate) { driver.SetSampleRate(waveFormat.SampleRate); } // Plug the callback driver.FillBufferCalback = driver_BufferUpdate; // Used Prefered size of ASIO Buffer nbSamples = driver.CreateBuffers(waveFormat.Channels, false); // make a buffer big enough to read enough from the sourceStream to fill the ASIO buffers waveBuffer = new byte[nbSamples*waveFormat.Channels*waveFormat.BitsPerSample/8]; }
/// <summary> /// Set output type to the specified wave format /// n.b. may need to set input type first /// </summary> /// <param name="outputStreamIndex">Output stream index</param> /// <param name="waveFormat">Wave format</param> public void SetOutputWaveFormat(int outputStreamIndex, WaveFormat waveFormat) { DmoMediaType mediaType = CreateDmoMediaTypeForWaveFormat(waveFormat); bool succeeded = SetOutputType(outputStreamIndex, mediaType, DmoSetTypeFlags.None); DmoInterop.MoFreeMediaType(ref mediaType); if (!succeeded) { throw new ArgumentException("Media Type not supported"); } }
/// <summary> /// Tests if the specified Wave Format is supported for output /// n.b. may need to set the input type first /// </summary> /// <param name="outputStreamIndex">Output stream index</param> /// <param name="waveFormat">Wave format</param> /// <returns>True if supported</returns> public bool SupportsOutputWaveFormat(int outputStreamIndex, WaveFormat waveFormat) { DmoMediaType mediaType = CreateDmoMediaTypeForWaveFormat(waveFormat); bool supported = SetOutputType(outputStreamIndex, mediaType, DmoSetTypeFlags.DMO_SET_TYPEF_TEST_ONLY); DmoInterop.MoFreeMediaType(ref mediaType); return supported; }
/// <summary> /// Add a new input to the mixer /// </summary> /// <param name="waveStream">The wave input to add</param> public void AddInputStream(WaveStream waveStream) { if (waveStream.WaveFormat.Encoding != WaveFormatEncoding.IeeeFloat) throw new ArgumentException("Must be IEEE floating point", "waveStream.WaveFormat"); if (waveStream.WaveFormat.BitsPerSample != 32) throw new ArgumentException("Only 32 bit audio currently supported", "waveStream.WaveFormat"); if (inputStreams.Count == 0) { // first one - set the format int sampleRate = waveStream.WaveFormat.SampleRate; int channels = waveStream.WaveFormat.Channels; waveFormat = WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, channels); } else { if (!waveStream.WaveFormat.Equals(waveFormat)) throw new ArgumentException("All incoming channels must have the same format", "inputStreams.WaveFormat"); } lock (this) { inputStreams.Add(waveStream); length = Math.Max(length, waveStream.Length); // get to the right point in this input file Position = Position; } }
public AcmMp3FrameDecompressor(WaveFormat sourceFormat) { pcmFormat = AcmStream.SuggestPcmFormat(sourceFormat); conversionStream = new AcmStream(sourceFormat, pcmFormat); }
public static extern MmResult waveOutOpenWindow(out IntPtr hWaveOut, IntPtr uDeviceID, WaveFormat lpFormat, IntPtr callbackWindowHandle, IntPtr dwInstance, int dwFlags);
public static extern MmResult waveOutOpen(out IntPtr hWaveOut, IntPtr uDeviceID, WaveFormat lpFormat, WaveCallback dwCallback, IntPtr dwInstance, int dwFlags);
/// <summary> /// Helper function to make a DMO Media Type to represent a particular WaveFormat /// </summary> private DmoMediaType CreateDmoMediaTypeForWaveFormat(WaveFormat waveFormat) { var mediaType = new DmoMediaType(); int waveFormatExSize = Marshal.SizeOf(waveFormat); // 18 + waveFormat.ExtraSize; DmoInterop.MoInitMediaType(ref mediaType, waveFormatExSize); mediaType.SetWaveFormat(waveFormat); return mediaType; }