public static AcmDriver AddLocalDriver(string driverFile) { IntPtr intPtr = NativeMethods.LoadLibrary(driverFile); if (intPtr == IntPtr.Zero) { throw new ArgumentException("Failed to load driver file"); } IntPtr procAddress = NativeMethods.GetProcAddress(intPtr, "DriverProc"); if (procAddress == IntPtr.Zero) { NativeMethods.FreeLibrary(intPtr); throw new ArgumentException("Failed to discover DriverProc"); } IntPtr hAcmDriver; MmResult mmResult = AcmInterop.acmDriverAdd(out hAcmDriver, intPtr, procAddress, 0, AcmDriverAddFlags.Function); if (mmResult != MmResult.NoError) { NativeMethods.FreeLibrary(intPtr); throw new MmException(mmResult, "acmDriverAdd"); } AcmDriver acmDriver = new AcmDriver(hAcmDriver); if (string.IsNullOrEmpty(acmDriver.details.longName)) { acmDriver.details.longName = "Local driver: " + Path.GetFileName(driverFile); acmDriver.localDllHandle = intPtr; } return(acmDriver); }
/// <summary> /// Suggests an appropriate PCM format that the compressed format can be converted /// to in one step /// </summary> /// <param name="compressedFormat">The compressed format</param> /// <returns>The PCM format</returns> // Token: 0x060007D0 RID: 2000 RVA: 0x00016DD0 File Offset: 0x00014FD0 public static WaveFormat SuggestPcmFormat(WaveFormat compressedFormat) { WaveFormat waveFormat = new WaveFormat(compressedFormat.SampleRate, 16, compressedFormat.Channels); MmException.Try(AcmInterop.acmFormatSuggest(IntPtr.Zero, compressedFormat, waveFormat, Marshal.SizeOf(waveFormat), AcmFormatSuggestFlags.FormatTag), "acmFormatSuggest"); return(waveFormat); }
/// <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); IntPtr sourceFormatPointer = WaveFormat.MarshalToPtr(sourceFormat); IntPtr destFormatPointer = WaveFormat.MarshalToPtr(destFormat); try { MmException.Try(AcmInterop.acmStreamOpen2(out streamHandle, IntPtr.Zero, sourceFormatPointer, destFormatPointer, null, IntPtr.Zero, IntPtr.Zero, AcmStreamOpenFlags.NonRealTime), "acmStreamOpen"); } finally { Marshal.FreeHGlobal(sourceFormatPointer); Marshal.FreeHGlobal(destFormatPointer); } int destBufferSize = SourceToDest(sourceBufferSize); streamHeader = new AcmStreamHeader(streamHandle, sourceBufferSize, destBufferSize); driverHandle = IntPtr.Zero; } catch { // suppress the finalise and clean up resources Dispose(); throw; } }
/// <summary> /// Frees resources associated with this ACM Stream /// </summary> protected virtual void Dispose(bool disposing) { if (disposing) { // Free other state (managed objects). if (streamHeader != null) { streamHeader.Dispose(); streamHeader = null; } } // Free your own state (unmanaged objects). if (streamHandle != IntPtr.Zero) { MmResult result = AcmInterop.acmStreamClose(streamHandle, 0); streamHandle = IntPtr.Zero; if (result != MmResult.NoError) { throw new MmException(result, "acmStreamClose"); } } // Set large fields to null. if (driverHandle != IntPtr.Zero) { AcmInterop.acmDriverClose(driverHandle, 0); driverHandle = IntPtr.Zero; } }
/// <summary> /// Creates a new ACM Driver object /// </summary> /// <param name="hAcmDriver">Driver handle</param> private AcmDriver(IntPtr hAcmDriver) { driverId = hAcmDriver; details = new AcmDriverDetails(); details.structureSize = System.Runtime.InteropServices.Marshal.SizeOf(details); MmException.Try(AcmInterop.acmDriverDetails(hAcmDriver, ref details, 0), "acmDriverDetails"); }
/// <summary> /// Opens this driver /// </summary> public void Open() { if (driverHandle == IntPtr.Zero) { MmException.Try(AcmInterop.acmDriverOpen(out driverHandle, DriverId, 0), "acmDriverOpen"); } }
/// <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(16384, sourceFormat.AverageBytesPerSecond); sourceBufferSize -= (sourceBufferSize % sourceFormat.BlockAlign); MmException.Try(AcmInterop.acmStreamOpen(out streamHandle, IntPtr.Zero, sourceFormat, destFormat, null, 0, 0, AcmStreamOpenFlags.NonRealTime), "acmStreamOpen"); // horrible stuff due to wierd Marshalling issues /* * IntPtr sourceFormatPointer = WaveFormat.MarshalToPtr(sourceFormat); * IntPtr destFormatPointer = WaveFormat.MarshalToPtr(destFormat); * MmResult result = AcmInterop.acmStreamOpen2(out streamHandle, IntPtr.Zero, sourceFormatPointer, destFormatPointer, null, 0, 0, AcmStreamOpenFlags.NonRealTime); * Marshal.FreeHGlobal(sourceFormatPointer); * Marshal.FreeHGlobal(destFormatPointer); * MmException.Try(result, "acmStreamOpen");*/ streamHeader = new AcmStreamHeader(streamHandle, sourceBufferSize, SourceToDest(sourceBufferSize)); driverHandle = IntPtr.Zero; } catch { // suppress the finalise and clean up resources Dispose(); throw; } }
private AcmDriver(IntPtr hAcmDriver) { this.driverId = hAcmDriver; this.details = default(AcmDriverDetails); this.details.structureSize = Marshal.SizeOf(this.details); MmException.Try(AcmInterop.acmDriverDetails(hAcmDriver, ref this.details, 0), "acmDriverDetails"); }
/// <summary> /// Attempts to add a new ACM driver from a file /// </summary> /// <param name="driverFile">Full path of the .acm or dll file containing the driver</param> /// <returns>Handle to the driver</returns> public static AcmDriver AddLocalDriver(string driverFile) { IntPtr handle = NativeMethods.LoadLibrary(driverFile); if (handle == IntPtr.Zero) { throw new ArgumentException("Failed to load driver file"); } var driverProc = NativeMethods.GetProcAddress(handle, "DriverProc"); if (driverProc == IntPtr.Zero) { NativeMethods.FreeLibrary(handle); throw new ArgumentException("Failed to discover DriverProc"); } IntPtr driverHandle; var result = AcmInterop.acmDriverAdd(out driverHandle, handle, driverProc, 0, AcmDriverAddFlags.Function); if (result != MmResult.NoError) { NativeMethods.FreeLibrary(handle); throw new MmException(result, "acmDriverAdd"); } var driver = new AcmDriver(driverHandle); // long name seems to be missing when we use acmDriverAdd if (string.IsNullOrEmpty(driver.details.longName)) { driver.details.longName = "Local driver: " + Path.GetFileName(driverFile); driver.localDllHandle = handle; } return(driver); }
/// <summary> /// Gets a list of the ACM Drivers installed /// </summary> public static IEnumerable <AcmDriver> EnumerateAcmDrivers() { drivers = new List <AcmDriver>(); MmException.Try( AcmInterop.acmDriverEnum(new AcmInterop.AcmDriverEnumCallback(DriverEnumCallback), IntPtr.Zero, 0), "acmDriverEnum"); return(drivers); }
/// <summary> /// Closes this driver /// </summary> public void Close() { if (driverHandle != IntPtr.Zero) { MmException.Try(AcmInterop.acmDriverClose(driverHandle, 0), "acmDriverClose"); driverHandle = IntPtr.Zero; } }
// Token: 0x060007DA RID: 2010 RVA: 0x00016FCC File Offset: 0x000151CC private void Prepare() { this.streamHeader.cbStruct = Marshal.SizeOf(this.streamHeader); this.streamHeader.sourceBufferLength = this.sourceBuffer.Length; this.streamHeader.sourceBufferPointer = this.hSourceBuffer.AddrOfPinnedObject(); this.streamHeader.destBufferLength = this.destBuffer.Length; this.streamHeader.destBufferPointer = this.hDestBuffer.AddrOfPinnedObject(); MmException.Try(AcmInterop.acmStreamPrepareHeader(this.streamHandle, this.streamHeader, 0), "acmStreamPrepareHeader"); }
private void Prepare() { streamHeader.cbStruct = 84;// 21 int sized params; streamHeader.sourceBufferLength = sourceBuffer.Length; streamHeader.sourceBufferPointer = hSourceBuffer.AddrOfPinnedObject(); streamHeader.destBufferLength = destBuffer.Length; streamHeader.destBufferPointer = hDestBuffer.AddrOfPinnedObject(); MmException.Try(AcmInterop.acmStreamPrepareHeader(streamHandle, streamHeader, 0), "acmStreamPrepareHeader"); }
/// <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> // Token: 0x060007CD RID: 1997 RVA: 0x00016CE4 File Offset: 0x00014EE4 public AcmStream(IntPtr driverId, WaveFormat sourceFormat, WaveFilter waveFilter) { int num = Math.Max(16384, sourceFormat.AverageBytesPerSecond); this.sourceFormat = sourceFormat; num -= num % sourceFormat.BlockAlign; MmException.Try(AcmInterop.acmDriverOpen(out this.driverHandle, driverId, 0), "acmDriverOpen"); MmException.Try(AcmInterop.acmStreamOpen(out this.streamHandle, this.driverHandle, sourceFormat, sourceFormat, waveFilter, IntPtr.Zero, IntPtr.Zero, AcmStreamOpenFlags.NonRealTime), "acmStreamOpen"); this.streamHeader = new AcmStreamHeader(this.streamHandle, num, this.SourceToDest(num)); }
/// <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> /// Returns the number of source bytes for a given number of destination bytes /// </summary> /// <param name="dest">Number of destination bytes</param> /// <returns>Number of source bytes</returns> public int DestToSource(int dest) { if (dest == 0) // zero is an invalid parameter to acmStreamSize { return(0); } int convertedBytes; MmException.Try(AcmInterop.acmStreamSize(streamHandle, dest, out convertedBytes, AcmStreamSizeFlags.Destination), "acmStreamSize"); return(convertedBytes); }
/// <summary> /// Returns the number of source bytes for a given number of destination bytes /// </summary> /// <param name="dest">Number of destination bytes</param> /// <returns>Number of source bytes</returns> // Token: 0x060007CF RID: 1999 RVA: 0x00016DA4 File Offset: 0x00014FA4 public int DestToSource(int dest) { if (dest == 0) { return(0); } int result; MmException.Try(AcmInterop.acmStreamSize(this.streamHandle, dest, out result, AcmStreamSizeFlags.Destination), "acmStreamSize"); return(result); }
/// <summary> /// Removes a driver previously added using AddLocalDriver /// </summary> /// <param name="localDriver">Local driver to remove</param> public static void RemoveLocalDriver(AcmDriver localDriver) { if (localDriver.localDllHandle == IntPtr.Zero) { throw new ArgumentException("Please pass in the AcmDriver returned by the AddLocalDriver method"); } var removeResult = AcmInterop.acmDriverRemove(localDriver.driverId, 0); // gets stored as a driver Id NativeMethods.FreeLibrary(localDriver.localDllHandle); MmException.Try(removeResult, "acmDriverRemove"); }
/// <summary> /// Returns the number of output bytes for a given number of input bytes /// </summary> /// <param name="source">Number of input bytes</param> /// <returns>Number of output bytes</returns> public int SourceToDest(int source) { if (source == 0) // zero is an invalid parameter to acmStreamSize { return(0); } int convertedBytes; MmException.Try(AcmInterop.acmStreamSize(streamHandle, source, out convertedBytes, AcmStreamSizeFlags.Source), "acmStreamSize"); return(convertedBytes); }
/// <summary> /// Returns the number of output bytes for a given number of input bytes /// </summary> /// <param name="source">Number of input bytes</param> /// <returns>Number of output bytes</returns> // Token: 0x060007CE RID: 1998 RVA: 0x00016D74 File Offset: 0x00014F74 public int SourceToDest(int source) { if (source == 0) { return(0); } int result2; MmResult result = AcmInterop.acmStreamSize(this.streamHandle, source, out result2, AcmStreamSizeFlags.Source); MmException.Try(result, "acmStreamSize"); return(result2); }
// Token: 0x060007DB RID: 2011 RVA: 0x00017060 File Offset: 0x00015260 private void Unprepare() { this.streamHeader.sourceBufferLength = this.sourceBuffer.Length; this.streamHeader.sourceBufferPointer = this.hSourceBuffer.AddrOfPinnedObject(); this.streamHeader.destBufferLength = this.destBuffer.Length; this.streamHeader.destBufferPointer = this.hDestBuffer.AddrOfPinnedObject(); MmResult mmResult = AcmInterop.acmStreamUnprepareHeader(this.streamHandle, this.streamHeader, 0); if (mmResult != MmResult.NoError) { throw new MmException(mmResult, "acmStreamUnprepareHeader"); } }
/// <summary> /// Show Format Choose Dialog /// </summary> /// <param name="ownerWindowHandle">Owner window handle, can be null</param> /// <param name="windowTitle">Window title</param> /// <param name="enumFlags">Enumeration flags. None to get everything</param> /// <param name="enumFormat">Enumeration format. Only needed with certain enumeration flags</param> /// <param name="selectedFormat">The selected format</param> /// <param name="selectedFormatDescription">Textual description of the selected format</param> /// <param name="selectedFormatTagDescription">Textual description of the selected format tag</param> /// <returns>True if a format was selected</returns> public static bool ShowFormatChooseDialog( IntPtr ownerWindowHandle, string windowTitle, AcmFormatEnumFlags enumFlags, WaveFormat enumFormat, out WaveFormat selectedFormat, out string selectedFormatDescription, out string selectedFormatTagDescription) { AcmFormatChoose formatChoose = new AcmFormatChoose(); formatChoose.structureSize = Marshal.SizeOf(formatChoose); formatChoose.styleFlags = AcmFormatChooseStyleFlags.None; formatChoose.ownerWindowHandle = ownerWindowHandle; int maxFormatSize = 200; // guess formatChoose.selectedWaveFormatPointer = Marshal.AllocHGlobal(maxFormatSize); formatChoose.selectedWaveFormatByteSize = maxFormatSize; formatChoose.title = windowTitle; formatChoose.name = null; formatChoose.formatEnumFlags = enumFlags;//AcmFormatEnumFlags.None; formatChoose.waveFormatEnumPointer = IntPtr.Zero; if (enumFormat != null) { IntPtr enumPointer = Marshal.AllocHGlobal(Marshal.SizeOf(enumFormat)); Marshal.StructureToPtr(enumFormat, enumPointer, false); formatChoose.waveFormatEnumPointer = enumPointer; } formatChoose.instanceHandle = IntPtr.Zero; formatChoose.templateName = null; MmResult result = AcmInterop.acmFormatChoose(ref formatChoose); selectedFormat = null; selectedFormatDescription = null; selectedFormatTagDescription = null; if (result == MmResult.NoError) { selectedFormat = WaveFormat.MarshalFromPtr(formatChoose.selectedWaveFormatPointer); selectedFormatDescription = formatChoose.formatDescription; selectedFormatTagDescription = formatChoose.formatTagDescription; } Marshal.FreeHGlobal(formatChoose.waveFormatEnumPointer); Marshal.FreeHGlobal(formatChoose.selectedWaveFormatPointer); if (result != MmResult.AcmCancelled && result != MmResult.NoError) { throw new MmException(result, "acmFormatChoose"); } return(result == MmResult.NoError); }
private void Unprepare() { streamHeader.sourceBufferLength = sourceBuffer.Length; streamHeader.sourceBufferPointer = hSourceBuffer.AddrOfPinnedObject(); streamHeader.destBufferLength = destBuffer.Length; streamHeader.destBufferPointer = hDestBuffer.AddrOfPinnedObject(); MmResult result = AcmInterop.acmStreamUnprepareHeader(streamHandle, streamHeader, 0); if (result != MmResult.NoError) { //if (result == MmResult.AcmHeaderUnprepared) throw new MmException(result, "acmStreamUnprepareHeader"); } }
/// <summary> /// Suggests an appropriate PCM format that the compressed format can be converted /// to in one step /// </summary> /// <param name="compressedFormat">The compressed format</param> /// <returns>The PCM format</returns> public static WaveFormat SuggestPcmFormat(WaveFormat compressedFormat) { // create a PCM format WaveFormat suggestedFormat = new WaveFormat(compressedFormat.SampleRate, 16, compressedFormat.Channels); MmException.Try(AcmInterop.acmFormatSuggest(IntPtr.Zero, compressedFormat, suggestedFormat, Marshal.SizeOf(suggestedFormat), AcmFormatSuggestFlags.FormatTag), "acmFormatSuggest"); /*IntPtr suggestedFormatPointer = WaveFormat.MarshalToPtr(suggestedFormat); * IntPtr compressedFormatPointer = WaveFormat.MarshalToPtr(compressedFormat); * MmResult result = AcmInterop.acmFormatSuggest2(IntPtr.Zero, compressedFormatPointer, suggestedFormatPointer, Marshal.SizeOf(suggestedFormat), AcmFormatSuggestFlags.FormatTag); * suggestedFormat = WaveFormat.MarshalFromPtr(suggestedFormatPointer); * Marshal.FreeHGlobal(suggestedFormatPointer); * Marshal.FreeHGlobal(compressedFormatPointer); * MmException.Try(result, "acmFormatSuggest");*/ return(suggestedFormat); }
// Token: 0x060007DD RID: 2013 RVA: 0x000170EC File Offset: 0x000152EC public int Convert(int bytesToConvert, out int sourceBytesConverted) { this.Prepare(); try { this.streamHeader.sourceBufferLength = bytesToConvert; this.streamHeader.sourceBufferLengthUsed = bytesToConvert; AcmStreamConvertFlags streamConvertFlags = this.firstTime ? (AcmStreamConvertFlags.BlockAlign | AcmStreamConvertFlags.Start) : AcmStreamConvertFlags.BlockAlign; MmException.Try(AcmInterop.acmStreamConvert(this.streamHandle, this.streamHeader, streamConvertFlags), "acmStreamConvert"); this.firstTime = false; sourceBytesConverted = this.streamHeader.sourceBufferLengthUsed; } finally { this.Unprepare(); } return(this.streamHeader.destBufferLengthUsed); }
public IEnumerable <AcmFormat> GetFormats(AcmFormatTag formatTag) { if (this.driverHandle == IntPtr.Zero) { throw new InvalidOperationException("Driver must be opened first"); } this.tempFormatsList = new List <AcmFormat>(); AcmFormatDetails acmFormatDetails = default(AcmFormatDetails); acmFormatDetails.structSize = Marshal.SizeOf(acmFormatDetails); acmFormatDetails.waveFormatByteSize = 1024; acmFormatDetails.waveFormatPointer = Marshal.AllocHGlobal(acmFormatDetails.waveFormatByteSize); acmFormatDetails.formatTag = (int)formatTag.FormatTag; MmResult result = AcmInterop.acmFormatEnum(this.driverHandle, ref acmFormatDetails, new AcmInterop.AcmFormatEnumCallback(this.AcmFormatEnumCallback), IntPtr.Zero, AcmFormatEnumFlags.None); Marshal.FreeHGlobal(acmFormatDetails.waveFormatPointer); MmException.Try(result, "acmFormatEnum"); return(this.tempFormatsList); }
/// <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> // Token: 0x060007CC RID: 1996 RVA: 0x00016C38 File Offset: 0x00014E38 public AcmStream(WaveFormat sourceFormat, WaveFormat destFormat) { try { this.streamHandle = IntPtr.Zero; this.sourceFormat = sourceFormat; int num = Math.Max(65536, sourceFormat.AverageBytesPerSecond); num -= num % sourceFormat.BlockAlign; MmException.Try(AcmInterop.acmStreamOpen(out this.streamHandle, IntPtr.Zero, sourceFormat, destFormat, null, IntPtr.Zero, IntPtr.Zero, AcmStreamOpenFlags.NonRealTime), "acmStreamOpen"); int destBufferLength = this.SourceToDest(num); this.streamHeader = new AcmStreamHeader(this.streamHandle, num, destBufferLength); this.driverHandle = IntPtr.Zero; } catch { this.Dispose(); throw; } }
public static bool ShowFormatChooseDialog(IntPtr ownerWindowHandle, string windowTitle, AcmFormatEnumFlags enumFlags, WaveFormat enumFormat, out WaveFormat selectedFormat, out string selectedFormatDescription, out string selectedFormatTagDescription) { AcmFormatChoose acmFormatChoose = default(AcmFormatChoose); acmFormatChoose.structureSize = Marshal.SizeOf(acmFormatChoose); acmFormatChoose.styleFlags = AcmFormatChooseStyleFlags.None; acmFormatChoose.ownerWindowHandle = ownerWindowHandle; int num = 200; acmFormatChoose.selectedWaveFormatPointer = Marshal.AllocHGlobal(num); acmFormatChoose.selectedWaveFormatByteSize = num; acmFormatChoose.title = windowTitle; acmFormatChoose.name = null; acmFormatChoose.formatEnumFlags = enumFlags; acmFormatChoose.waveFormatEnumPointer = IntPtr.Zero; if (enumFormat != null) { IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(enumFormat)); Marshal.StructureToPtr(enumFormat, intPtr, false); acmFormatChoose.waveFormatEnumPointer = intPtr; } acmFormatChoose.instanceHandle = IntPtr.Zero; acmFormatChoose.templateName = null; MmResult mmResult = AcmInterop.acmFormatChoose(ref acmFormatChoose); selectedFormat = null; selectedFormatDescription = null; selectedFormatTagDescription = null; if (mmResult == MmResult.NoError) { selectedFormat = WaveFormat.MarshalFromPtr(acmFormatChoose.selectedWaveFormatPointer); selectedFormatDescription = acmFormatChoose.formatDescription; selectedFormatTagDescription = acmFormatChoose.formatTagDescription; } Marshal.FreeHGlobal(acmFormatChoose.waveFormatEnumPointer); Marshal.FreeHGlobal(acmFormatChoose.selectedWaveFormatPointer); if (mmResult != MmResult.AcmCancelled && mmResult != MmResult.NoError) { throw new MmException(mmResult, "acmFormatChoose"); } return(mmResult == MmResult.NoError); }
public int Convert(int bytesToConvert, out int sourceBytesConverted) { Prepare(); try { streamHeader.sourceBufferLength = bytesToConvert; streamHeader.sourceBufferLengthUsed = bytesToConvert; AcmStreamConvertFlags flags = firstTime ? (AcmStreamConvertFlags.Start | AcmStreamConvertFlags.BlockAlign) : AcmStreamConvertFlags.BlockAlign; MmException.Try(AcmInterop.acmStreamConvert(streamHandle, streamHeader, flags), "acmStreamConvert"); firstTime = false; System.Diagnostics.Debug.Assert(streamHeader.destBufferLength == destBuffer.Length, "Codecs should not change dest buffer length"); sourceBytesConverted = streamHeader.sourceBufferLengthUsed; } finally { Unprepare(); } return(streamHeader.destBufferLengthUsed); }
/// <summary> /// Gets all the supported formats for a given format tag /// </summary> /// <param name="formatTag">Format tag</param> /// <returns>Supported formats</returns> public IEnumerable <AcmFormat> GetFormats(AcmFormatTag formatTag) { if (driverHandle == IntPtr.Zero) { throw new InvalidOperationException("Driver must be opened first"); } tempFormatsList = new List <AcmFormat>(); AcmFormatDetails formatDetails = new AcmFormatDetails(); formatDetails.structSize = Marshal.SizeOf(formatDetails); formatDetails.waveFormatByteSize = MaxFormatSize; // formatTag.FormatSize doesn't work; formatDetails.waveFormatPointer = Marshal.AllocHGlobal(formatDetails.waveFormatByteSize); formatDetails.formatTag = (int)formatTag.FormatTag; // (int)WaveFormatEncoding.Unknown MmResult result = AcmInterop.acmFormatEnum(driverHandle, ref formatDetails, AcmFormatEnumCallback, IntPtr.Zero, AcmFormatEnumFlags.None); Marshal.FreeHGlobal(formatDetails.waveFormatPointer); MmException.Try(result, "acmFormatEnum"); return(tempFormatsList); }