/// <summary> /// Gets the current overall volume level of the voice. /// </summary> /// <param name="volume"> /// Returns the current overall volume level of the voice. See Remarks for more information on volume /// levels. /// </param> /// <returns>HRESULT</returns> /// <remarks> /// The master volume level is applied at different times depending on the type of voice. /// For submix and mastering voices the volume level is applied just before the voice's built in filter and effect /// chain is applied. /// For source voices the master volume level is applied after the voice's filter and effect /// chain is applied. Volume levels are expressed as floating-point amplitude multipliers /// between -2^24 and 2^24, with a maximum /// gain of 144.5 dB. A volume level of 1.0 means there is no attenuation or gain and 0 means silence. /// Negative levels can be used to invert the audio's phase. /// </remarks> public unsafe int GetVolumeNative(out float volume) { fixed(void *p = &volume) { return(InteropCalls.CallI(UnsafeBasePtr, p, ((void **)(*(void **)UnsafeBasePtr))[13])); } }
/// <summary> /// Creates and configures a source voice. For more information see /// http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.ixaudio2.ixaudio2.createsourcevoice(v=vs.85).aspx. /// </summary> /// <param name="pSourceVoice">If successful, returns a pointer to the new <see cref="XAudio2SourceVoice" /> object.</param> /// <param name="sourceFormat"> /// Pointer to a <see cref="WaveFormat" />. The following formats are supported: /// <ul> /// <li>8-bit (unsigned) integer PCM</li><li>16-bit integer PCM (optimal format for XAudio2)</li> /// <li>20-bit integer PCM (either in 24 or 32 bit containers)</li> /// <li>24-bit integer PCM (either in 24 or 32 bit containers)</li><li>32-bit integer PCM</li> /// <li>32-bit float PCM (preferred format after 16-bit integer)</li> /// </ul> /// The number of channels in a source voice must be less than or equal to <see cref="MaxAudioChannels" />. The sample /// rate of a source voice must be between <see cref="MinimumSampleRate" /> and <see cref="MaximumSampleRate" />. /// </param> /// <param name="flags"> /// <see cref="VoiceFlags" /> that specify the behavior of the source voice. A flag can be /// <see cref="VoiceFlags.None" /> or a combination of one or more of the following. /// Possible values are <see cref="VoiceFlags.NoPitch" />, <see cref="VoiceFlags.NoSampleRateConversition" /> and /// <see cref="VoiceFlags.UseFilter" />. <see cref="VoiceFlags.Music" /> is not supported on Windows. /// </param> /// <param name="maxFrequencyRatio"> /// Highest allowable frequency ratio that can be set on this voice. The value for this /// argument must be between <see cref="MinFrequencyRatio" /> and <see cref="MaxFrequencyRatio" />. /// </param> /// <param name="voiceCallback"> /// Client-provided callback interface, <see cref="IXAudio2VoiceCallback" />. This parameter is /// optional and can be null. /// </param> /// <param name="sendList"> /// List of <see cref="VoiceSends" /> structures that describe the set of destination voices for the /// source voice. If <paramref name="sendList" /> is NULL, the send list defaults to a single output to the first mastering /// voice created. /// </param> /// <param name="effectChain"> /// List of <see cref="EffectChain" /> structures that describe an effect chain to use in the /// source voice. This parameter is optional and can be null. /// </param> /// <returns>HRESULT</returns> public override unsafe int CreateSourceVoiceNative( out IntPtr pSourceVoice, IntPtr sourceFormat, VoiceFlags flags, float maxFrequencyRatio, IXAudio2VoiceCallback voiceCallback, VoiceSends?sendList, //out EffectChain?effectChain ) { VoiceSends value0 = sendList.HasValue ? sendList.Value : new VoiceSends(); EffectChain value1 = effectChain.HasValue ? effectChain.Value : new EffectChain(); IntPtr p = IntPtr.Zero; if (voiceCallback != null) { p = Marshal.GetComInterfaceForObject(voiceCallback, typeof(IXAudio2VoiceCallback)); p = Utils.Utils.GetComInterfaceForObjectWithAdjustedVtable(p, 7, 3); } fixed(void *ptr = &pSourceVoice) { return(InteropCalls.CallI(UnsafeBasePtr, ptr, sourceFormat, flags, maxFrequencyRatio, p.ToPointer(), sendList.HasValue ? &value0 : (void *)IntPtr.Zero, effectChain.HasValue ? &value1 : (void *)IntPtr.Zero, ((void **)(*(void **)UnsafeBasePtr))[8])); } }
/// <summary> /// Sets the volume levels for the voice, per channel. This method is valid only for source and submix voices, because /// mastering voices do not specify volume per channel. /// </summary> /// <param name="channelCount">Number of channels in the voice.</param> /// <param name="volumes"> /// Array containing the new volumes of each channel in the voice. The array must have /// <paramref name="channelCount" /> elements. See Remarks for more information on volume levels. /// </param> /// <param name="operationSet"> /// Identifies this call as part of a deferred batch. For more information see /// http://msdn.microsoft.com/en-us/library/windows/desktop/ee415807(v=vs.85).aspx. /// </param> /// <returns>HRESULT</returns> /// <remarks> /// The master volume level is applied at different times depending on the type of voice. /// For submix and mastering voices the volume level is applied just before the voice's built in filter and effect /// chain is applied. /// For source voices the master volume level is applied after the voice's filter and effect /// chain is applied. Volume levels are expressed as floating-point amplitude multipliers /// between -2^24 and 2^24, with a maximum /// gain of 144.5 dB. A volume level of 1.0 means there is no attenuation or gain and 0 means silence. /// Negative levels can be used to invert the audio's phase. /// </remarks> public unsafe int SetChannelVolumesNative(int channelCount, float[] volumes, int operationSet) { fixed(void *p = &volumes[0]) { return(InteropCalls.CallI(UnsafeBasePtr, channelCount, p, operationSet, ((void **)(*(void **)UnsafeBasePtr))[14])); } }
/// <summary> /// Returns the number of available audio output devices. /// </summary> /// <param name="deviceCount">Number of available audio output devices.</param> /// <returns>HRESULT</returns> public unsafe int GetDeviceCountNative(out int deviceCount) { fixed(void *p = &deviceCount) { return(InteropCalls.CallI(UnsafeBasePtr, p, ((void **)(*(void **)UnsafeBasePtr))[3])); } }
/// <summary> /// Removes an <see cref="IXAudio2EngineCallback" /> from the <see cref="XAudio2" /> engine callback list. /// </summary> /// <param name="callback"> /// <see cref="IXAudio2EngineCallback" /> object to remove from the <see cref="XAudio2" /> engine /// callback list. If the given interface is present more than once in the list, only the first instance in the list /// will be removed. /// </param> public override unsafe void UnregisterForCallbacks(IXAudio2EngineCallback callback) { IntPtr ptr = IntPtr.Zero; if (callback != null) { ptr = Marshal.GetComInterfaceForObject(callback, typeof(IXAudio2EngineCallback)); ptr = Utils.Utils.GetComInterfaceForObjectWithAdjustedVtable(ptr, 3, 3); } try { InteropCalls.CallI(UnsafeBasePtr, (void *)ptr, ((void **)(*(void **)UnsafeBasePtr))[7]); } finally { if (ptr != IntPtr.Zero) { //while patching the IUnknown-members out of the vtable, we've made a backup of the release pointer, //which gets called here -> the Marshal.Release method would call any function on index 2 of the vtable //we've patched there Utils.Utils.Release(ptr); //Marshal.Release(ptr); } } }
/// <summary> /// Returns the volume levels for the voice, per channel. /// These settings are applied after the effect chain is applied. /// This method is valid only for source and submix voices, because mastering voices do not specify volume per channel. /// </summary> /// <param name="channelCount">Confirms the channel count of the voice.</param> /// <param name="volumes"> /// Returns the current volume level of each channel in the voice. The array must have at least /// <paramref name="channelCount" /> elements. /// See remarks for more information on volume levels. /// </param> /// <returns>HRESULT</returns> /// <remarks> /// The master volume level is applied at different times depending on the type of voice. /// For submix and mastering voices the volume level is applied just before the voice's built in filter and effect /// chain is applied. /// For source voices the master volume level is applied after the voice's filter and effect /// chain is applied. Volume levels are expressed as floating-point amplitude multipliers /// between -2^24 and 2^24, with a maximum /// gain of 144.5 dB. A volume level of 1.0 means there is no attenuation or gain and 0 means silence. /// Negative levels can be used to invert the audio's phase. /// </remarks> public unsafe int GetChannelVolumesNative(int channelCount, float[] volumes) { fixed(void *p = &volumes[0]) { return(InteropCalls.CallI(UnsafeBasePtr, channelCount, p, ((void **)(*(void **)UnsafeBasePtr))[15])); } }
/// <summary> /// Creates and configures a mastering voice. /// </summary> /// <param name="pMasteringVoice">If successful, returns a pointer to the new <see cref="XAudio2MasteringVoice" /> object.</param> /// <param name="inputChannels"> /// Number of channels the mastering voice expects in its input audio. <paramref name="inputChannels" /> must be less than /// or equal to <see cref="MaxAudioChannels" />. /// You can set InputChannels to <see cref="DefaultChannels" />, which causes XAudio2 to try to detect the system /// speaker configuration setup. /// </param> /// <param name="inputSampleRate"> /// Sample rate of the input audio data of the mastering voice. This rate must be a multiple of /// <see cref="QuantumDenominator" />. <paramref name="inputSampleRate" /> must be between <see cref="MinimumSampleRate" /> /// and <see cref="MaximumSampleRate" />. /// You can set InputSampleRate to <see cref="DefaultSampleRate" />, with the default being determined by the current /// platform. /// </param> /// <param name="flags">Flags that specify the behavior of the mastering voice. Must be 0.</param> /// <param name="deviceId"> /// Identifier of the device to receive the output audio. Specifying the default value of 0 (zero) /// causes XAudio2 to select the global default audio device. /// </param> /// <param name="effectChain"> /// <see cref="EffectChain" /> structure that describes an effect chain to use in the mastering /// voice, or NULL to use no effects. /// </param> /// <param name="streamCategory"><b>Not valid for XAudio 2.7.</b></param> /// <returns>HRESULT</returns> public override unsafe int CreateMasteringVoiceNative(out IntPtr pMasteringVoice, int inputChannels, int inputSampleRate, int flags, object deviceId, EffectChain?effectChain, AudioStreamCategory streamCategory) { if (!(deviceId is int)) { throw new ArgumentException("DeviceId has to be an integer.", "deviceId"); } var device = (int)deviceId; EffectChain value1 = effectChain.HasValue ? effectChain.Value : new EffectChain(); fixed(void *ptr = &pMasteringVoice) { return(InteropCalls.CallI( UnsafeBasePtr, ptr, inputChannels, inputSampleRate, flags, device, effectChain.HasValue ? &value1 : (void *)IntPtr.Zero, //streamCategory, ((void **)(*(void **)UnsafeBasePtr))[10])); } }
/// <summary> /// Gets the voice's filter parameters. /// </summary> /// <param name="filterParameters"> /// <see cref="CSCore.XAudio2.FilterParameters" /> structure containing the filter /// information. /// </param> /// <returns>HRESULT</returns> public unsafe int GetFilterParametersNative(out FilterParameters filterParameters) { filterParameters = default(FilterParameters); fixed(void *p = &filterParameters) { return(InteropCalls.CallI(UnsafeBasePtr, p, ((void **)(*(void **)UnsafeBasePtr))[9])); } }
/// <summary> /// Sets the filter parameters on one of this voice's sends. /// </summary> /// <param name="destinationVoice">The destination voice of the send whose filter parameters will be set.</param> /// <param name="filterParameters"> /// <see cref="CSCore.XAudio2.FilterParameters" /> structure containing the filter /// information. /// </param> /// <param name="operationSet"> /// Identifies this call as part of a deferred batch. For more information see /// http://msdn.microsoft.com/en-us/library/windows/desktop/ee415807(v=vs.85).aspx. /// </param> /// <returns>HRESULT</returns> public unsafe int SetOutputFilterParametersNative(XAudio2Voice destinationVoice, FilterParameters filterParameters, int operationSet) { IntPtr pVoice = destinationVoice == null ? IntPtr.Zero : destinationVoice.BasePtr; return(InteropCalls.CallI(UnsafeBasePtr, (void *)pVoice, &filterParameters, operationSet, ((void **)(*(void **)UnsafeBasePtr))[10])); }
/// <summary> /// <b>XAudio2.8 only:</b> Returns the channel mask for this voice. /// </summary> /// <param name="channelMask"> /// Returns the channel mask for this voice. This corresponds to the /// <see cref="WaveFormatExtensible.ChannelMask" /> member of the <see cref="WaveFormatExtensible" /> class. /// </param> /// <returns>HRESULT</returns> public unsafe int GetChannelMaskNative(out ChannelMask channelMask) { if (Version != XAudio2Version.XAudio2_8) throw new InvalidOperationException("The Channelmask of a mastering voice is only available using XAudio2.8."); fixed(void *p = &channelMask) { return(InteropCalls.CallI(UnsafeBasePtr, p, ((void **)(*(void **)UnsafeBasePtr))[19])); } }
/// <summary> /// Adds an <see cref="IXAudio2EngineCallback" /> from the <see cref="XAudio2" /> engine callback list. /// </summary> /// <param name="callback"> /// <see cref="IXAudio2EngineCallback" /> object to add to the <see cref="XAudio2" /> engine /// callback list. /// </param> /// <returns>HRESULT</returns> public override unsafe int RegisterForCallbacksNative(IXAudio2EngineCallback callback) { IntPtr ptr = IntPtr.Zero; if (callback != null) { ptr = Marshal.GetComInterfaceForObject(callback, typeof(IXAudio2EngineCallback)); ptr = Utils.Utils.GetComInterfaceForObjectWithAdjustedVtable(ptr, 3, 3); } return(InteropCalls.CallI(UnsafeBasePtr, ptr.ToPointer(), ((void **)(*(void **)UnsafeBasePtr))[6])); }
/// <summary> /// Gets the volume level of each channel of the final output for the voice. These channels are mapped to the input /// channels of a specified destination voice. /// </summary> /// <param name="destinationVoice">The destination <see cref="XAudio2Voice" /> to retrieve the output matrix for.</param> /// <param name="sourceChannels"> /// Confirms the output channel count of the voice. This is the number of channels that are /// produced by the last effect in the chain. /// </param> /// <param name="destinationChannels">Confirms the input channel count of the destination voice.</param> /// <param name="levelMatrix"> /// Array of [SourceChannels × DestinationChannels] volume levels sent to the destination voice. /// The level sent from source channel S to destination channel D is specified in the form levelMatrix[SourceChannels × /// D + S]. /// For more details see /// http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.ixaudio2voice.ixaudio2voice.getoutputmatrix(v=vs.85).aspx. /// </param> /// <returns>HRESULT</returns> public unsafe int GetOutputMatrixNative(XAudio2Voice destinationVoice, int sourceChannels, int destinationChannels, float[] levelMatrix) { IntPtr pVoice = destinationVoice == null ? IntPtr.Zero : destinationVoice.BasePtr; fixed(void *p = &levelMatrix[0]) { return(InteropCalls.CallI(UnsafeBasePtr, (void *)pVoice, sourceChannels, destinationChannels, p, ((void **)(*(void **)UnsafeBasePtr))[17])); } }
/// <summary> /// Designates a new set of submix or mastering voices to receive the output of the voice. /// </summary> /// <param name="voiceSends"> /// VoiceSends structure which contains Output voices. If <paramref name="voiceSends" /> is null, the voice will send /// its output to the current mastering voice. All of the voices in a send list must have the same input sample rate. /// </param> /// <returns>HRESULT</returns> public unsafe int SetOutputVoicesNative(VoiceSends?voiceSends) { VoiceSends value; if (voiceSends.HasValue) { value = voiceSends.Value; } return(InteropCalls.CallI(UnsafeBasePtr, voiceSends.HasValue ? &value : (void *)IntPtr.Zero, ((void **)(*(void **)UnsafeBasePtr))[1])); }
/// <summary> /// Returns the filter parameters from one of this voice's sends. /// </summary> /// <param name="destinationVoice">The destination voice of the send whose filter parameters will be read.</param> /// <param name="filterParameters"> /// <see cref="CSCore.XAudio2.FilterParameters" /> structure containing the filter /// information. /// </param> /// <returns>HRESULT</returns> public unsafe int GetOutputFilterParametersNative(XAudio2Voice destinationVoice, out FilterParameters filterParameters) { filterParameters = default(FilterParameters); IntPtr pVoice = destinationVoice == null ? IntPtr.Zero : destinationVoice.BasePtr; fixed(void *p = &filterParameters) { return(InteropCalls.CallI(UnsafeBasePtr, (void *)pVoice, p, ((void **)(*(void **)UnsafeBasePtr))[11])); } }
/// <summary> /// Replaces the effect chain of the voice. /// </summary> /// <param name="effectChain"> /// Describes the new effect chain to use. /// If null is passed, the current effect chain is removed. /// </param> /// <returns>HRESULT</returns> public unsafe int SetEffectChainNative(EffectChain?effectChain) { var ptr = (void *)IntPtr.Zero; //check whether null is passed -> if null is passed, the chain will be removed if (effectChain.HasValue) { EffectChain value = effectChain.Value; ptr = &value; } return(InteropCalls.CallI(UnsafeBasePtr, ptr, ((void **)(*(void **)UnsafeBasePtr))[2])); }
/// <summary> /// Creates and configures a source voice. For more information see /// http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.ixaudio2.ixaudio2.createsourcevoice(v=vs.85).aspx. /// </summary> /// <param name="pSourceVoice">If successful, returns a pointer to the new <see cref="XAudio2SourceVoice" /> object.</param> /// <param name="sourceFormat"> /// Pointer to a <see cref="WaveFormat" />. The following formats are supported: /// <ul> /// <li>8-bit (unsigned) integer PCM</li><li>16-bit integer PCM (optimal format for XAudio2)</li> /// <li>20-bit integer PCM (either in 24 or 32 bit containers)</li> /// <li>24-bit integer PCM (either in 24 or 32 bit containers)</li><li>32-bit integer PCM</li> /// <li>32-bit float PCM (preferred format after 16-bit integer)</li> /// </ul> /// The number of channels in a source voice must be less than or equal to <see cref="MaxAudioChannels" />. The sample /// rate of a source voice must be between <see cref="MinimumSampleRate" /> and <see cref="MaximumSampleRate" />. /// </param> /// <param name="flags"> /// <see cref="VoiceFlags" /> that specify the behavior of the source voice. A flag can be /// <see cref="VoiceFlags.None" /> or a combination of one or more of the following. /// Possible values are <see cref="VoiceFlags.NoPitch" />, <see cref="VoiceFlags.NoSampleRateConversition" /> and /// <see cref="VoiceFlags.UseFilter" />. <see cref="VoiceFlags.Music" /> is not supported on Windows. /// </param> /// <param name="maxFrequencyRatio"> /// Highest allowable frequency ratio that can be set on this voice. The value for this /// argument must be between <see cref="MinFrequencyRatio" /> and <see cref="MaxFrequencyRatio" />. /// </param> /// <param name="voiceCallback"> /// Client-provided callback interface, <see cref="IXAudio2VoiceCallback" />. This parameter is /// optional and can be null. /// </param> /// <param name="sendList"> /// List of <see cref="VoiceSends" /> structures that describe the set of destination voices for the /// source voice. If <paramref name="sendList" /> is NULL, the send list defaults to a single output to the first mastering /// voice created. /// </param> /// <param name="effectChain"> /// List of <see cref="EffectChain" /> structures that describe an effect chain to use in the /// source voice. This parameter is optional and can be null. /// </param> /// <returns>HRESULT</returns> public override unsafe int CreateSourceVoiceNative( out IntPtr pSourceVoice, IntPtr sourceFormat, VoiceFlags flags, float maxFrequencyRatio, IXAudio2VoiceCallback voiceCallback, VoiceSends?sendList, //out EffectChain?effectChain ) { VoiceSends value0 = sendList.HasValue ? sendList.Value : new VoiceSends(); EffectChain value1 = effectChain.HasValue ? effectChain.Value : new EffectChain(); IntPtr p = IntPtr.Zero; if (voiceCallback != null) { p = Marshal.GetComInterfaceForObject(voiceCallback, typeof(IXAudio2VoiceCallback)); p = Utils.CSCoreUtils.GetComInterfaceForObjectWithAdjustedVtable(p, 7, 3); } try { fixed(void *ptr = &pSourceVoice) { return(InteropCalls.CallI(UnsafeBasePtr, ptr, sourceFormat, flags, maxFrequencyRatio, p.ToPointer(), sendList.HasValue ? &value0 : (void *)IntPtr.Zero, effectChain.HasValue ? &value1 : (void *)IntPtr.Zero, ((void **)(*(void **)UnsafeBasePtr))[5])); } } finally { if (p != IntPtr.Zero) { //while patching the IUnknown-members out of the vtable, we've made a backup of the release pointer, //which gets called here -> the Marshal.Release method would call any function on index 2 of the vtable //we've patched there Utils.CSCoreUtils.Release(p); //Marshal.Release(p); } } }
/// <summary> /// Returns information about an audio output device. /// </summary> /// <param name="deviceIndex"> /// Index of the device to be queried. This value must be less than the count returned by /// <see cref="GetDeviceCount" />. /// </param> /// <param name="deviceDetails"><see cref="DeviceDetails" /> structure.</param> /// <returns>HRESULT</returns> public unsafe int GetDeviceDetailsNative(int deviceIndex, out DeviceDetails deviceDetails) { var ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(DeviceDetails))); try { deviceDetails = default(DeviceDetails); int result = InteropCalls.CallI(UnsafeBasePtr, deviceIndex, ptr.ToPointer(), ((void **)(*(void **)UnsafeBasePtr))[4]); deviceDetails = (DeviceDetails)Marshal.PtrToStructure(ptr, typeof(DeviceDetails)); return(result); } finally { Marshal.FreeHGlobal(ptr); } }
/// <summary> /// Creates and configures a submix voice. /// </summary> /// <param name="pSubmixVoice">On success, returns a pointer to the new <see cref="XAudio2SubmixVoice" /> object.</param> /// <param name="inputChannels"> /// Number of channels in the input audio data of the submix voice. The /// <paramref name="inputChannels" /> must be less than or equal to <see cref="MaxAudioChannels" />. /// </param> /// <param name="inputSampleRate"> /// Sample rate of the input audio data of submix voice. This rate must be a multiple of /// <see cref="QuantumDenominator" />. InputSampleRate must be between <see cref="MinimumSampleRate" /> and /// <see cref="MaximumSampleRate" />. /// </param> /// <param name="flags"> /// Flags that specify the behavior of the submix voice. It can be <see cref="VoiceFlags.None" /> or /// <see cref="VoiceFlags.UseFilter" />. /// </param> /// <param name="processingStage"> /// An arbitrary number that specifies when this voice is processed with respect to other /// submix voices, if the XAudio2 engine is running other submix voices. The voice is processed after all other voices /// that include a smaller <paramref name="processingStage" /> value and before all other voices that include a larger /// <paramref name="processingStage" /> value. Voices that include the same <paramref name="processingStage" /> value are /// processed in any order. A submix voice cannot send to another submix voice with a lower or equal /// <paramref name="processingStage" /> value. This prevents audio being lost due to a submix cycle. /// </param> /// <param name="sendList"> /// List of <see cref="VoiceSends" /> structures that describe the set of destination voices for the /// submix voice. If <paramref name="sendList" /> is NULL, the send list will default to a single output to the first /// mastering voice created. /// </param> /// <param name="effectChain"> /// List of <see cref="EffectChain" /> structures that describe an effect chain to use in the /// submix voice. This parameter is optional and can be null. /// </param> /// <returns>HRESULT</returns> public override unsafe int CreateSubmixVoiceNative(out IntPtr pSubmixVoice, int inputChannels, int inputSampleRate, VoiceFlags flags, int processingStage, VoiceSends?sendList, EffectChain?effectChain) { VoiceSends value0 = sendList.HasValue ? sendList.Value : new VoiceSends(); EffectChain value1 = effectChain.HasValue ? effectChain.Value : new EffectChain(); fixed(void *ptr = &pSubmixVoice) { return(InteropCalls.CallI(UnsafeBasePtr, ptr, inputChannels, inputSampleRate, flags, processingStage, sendList.HasValue ? &value0 : (void *)IntPtr.Zero, effectChain.HasValue ? &value1 : (void *)IntPtr.Zero, ((void **)(*(void **)UnsafeBasePtr))[9])); } }
/// <summary> /// Creates and configures a mastering voice. /// </summary> /// <param name="pMasteringVoice">If successful, returns a pointer to the new <see cref="XAudio2MasteringVoice" /> object.</param> /// <param name="inputChannels"> /// Number of channels the mastering voice expects in its input audio. <paramref name="inputChannels" /> must be less than /// or equal to <see cref="MaxAudioChannels" />. /// You can set InputChannels to <see cref="DefaultChannels" />, which causes XAudio2 to try to detect the system /// speaker configuration setup. /// </param> /// <param name="inputSampleRate"> /// Sample rate of the input audio data of the mastering voice. This rate must be a multiple of /// <see cref="QuantumDenominator" />. <paramref name="inputSampleRate" /> must be between <see cref="MinimumSampleRate" /> /// and <see cref="MaximumSampleRate" />. /// You can set InputSampleRate to <see cref="DefaultSampleRate" />, with the default being determined by the current /// platform. /// </param> /// <param name="flags">Flags that specify the behavior of the mastering voice. Must be 0.</param> /// <param name="deviceId"> /// Identifier of the device to receive the output audio. Specifying the default value of NULL /// causes XAudio2 to select the global default audio device. /// </param> /// <param name="effectChain"> /// <see cref="EffectChain" /> structure that describes an effect chain to use in the mastering /// voice, or NULL to use no effects. /// </param> /// <param name="streamCategory">The audio stream category to use for this mastering voice.</param> /// <returns>HRESULT</returns> public override unsafe int CreateMasteringVoiceNative(out IntPtr pMasteringVoice, int inputChannels, int inputSampleRate, int flags, object deviceId, EffectChain?effectChain, AudioStreamCategory streamCategory) { if (deviceId != null && !(deviceId is string)) { throw new ArgumentException("DeviceId has to be a string.", "deviceId"); } var device = deviceId as string; IntPtr pdeviceId = IntPtr.Zero; try { EffectChain value1 = effectChain ?? new EffectChain(); if (device != null) { pdeviceId = Marshal.StringToHGlobalUni(device); fixed(void *ptr = &pMasteringVoice) { return(InteropCalls.CallI( UnsafeBasePtr, ptr, inputChannels, inputSampleRate, flags, (void *)pdeviceId, effectChain.HasValue ? &value1 : (void *)IntPtr.Zero, streamCategory, ((void **)(*(void **)UnsafeBasePtr))[7])); } } finally { if (pdeviceId != IntPtr.Zero) Marshal.FreeHGlobal(pdeviceId); } }
/// <summary> /// Returns information about the creation flags, input channels, and sample rate of a voice. /// </summary> /// <param name="voiceDetails"><see cref="CSCore.XAudio2.VoiceDetails" /> object containing information about the voice.</param> /// <returns>HRESULT</returns> public unsafe int GetVoiceDetailsNative(out VoiceDetails voiceDetails) { voiceDetails = default(VoiceDetails); int result; if (_version == XAudio2Version.XAudio2_7) { var t = new VoiceDetails.VoiceDetails27(); result = InteropCalls.CallI(UnsafeBasePtr, &t, ((void **)(*(void **)UnsafeBasePtr))[0]); voiceDetails = VoiceDetails.FromNativeVoiceDetailsObject(t); } else if (_version == XAudio2Version.XAudio2_8) { var t = new VoiceDetails.VoiceDetails28(); result = InteropCalls.CallI(UnsafeBasePtr, &t, ((void **)(*(void **)UnsafeBasePtr))[0]); voiceDetails = VoiceDetails.FromNativeVoiceDetailsObject(t); } else { throw new Exception("Invalid XAudio2 version."); } return(result); }
/// <summary> /// Sets the overall volume level for the voice. /// </summary> /// <param name="volume">Overall volume level to use. See Remarks for more information on volume levels.</param> /// <param name="operationSet"> /// Identifies this call as part of a deferred batch. For more information see /// http://msdn.microsoft.com/en-us/library/windows/desktop/ee415807(v=vs.85).aspx. /// </param> /// <returns>HRESULT</returns> /// <remarks> /// The master volume level is applied at different times depending on the type of voice. /// For submix and mastering voices the volume level is applied just before the voice's built in filter and effect /// chain is applied. /// For source voices the master volume level is applied after the voice's filter and effect /// chain is applied. Volume levels are expressed as floating-point amplitude multipliers /// between -2^24 and 2^24, with a maximum /// gain of 144.5 dB. A volume level of 1.0 means there is no attenuation or gain and 0 means silence. /// Negative levels can be used to invert the audio's phase. /// </remarks> public unsafe int SetVolumeNative(float volume, int operationSet) { return(InteropCalls.CallI(UnsafeBasePtr, volume, operationSet, ((void **)(*(void **)UnsafeBasePtr))[12])); }
/// <summary> /// Sets XAudio2 parameters and prepares XAudio2 for use. /// </summary> /// <param name="flags">Flags that specify the behavior of the XAudio2 object. This value must be 0.</param> /// <param name="processor"> /// Specifies which CPU to use. Use <see cref="XAudio2Processor.XAudio27DefaultProcessor" /> as default value. /// </param> /// <returns>HRESULT</returns> public unsafe int InitializeNative(int flags, XAudio2Processor processor) { return(InteropCalls.CallI(UnsafeBasePtr, flags, processor, ((void **)(*(void **)UnsafeBasePtr))[5])); }
/// <summary> /// Atomically applies a set of operations that are tagged with a given identifier. /// </summary> /// <param name="operationSet"> /// Identifier of the set of operations to be applied. To commit all pending operations, pass /// <see cref="CommitAll" />. /// </param> /// <returns>HRESULT</returns> public override unsafe int CommitChangesNative(int operationSet) { return(InteropCalls.CallI(UnsafeBasePtr, operationSet, ((void **)(*(void **)UnsafeBasePtr))[13])); }
/// <summary> /// Sets the voice's filter parameters. /// </summary> /// <param name="filterParameters"> /// <see cref="CSCore.XAudio2.FilterParameters" /> structure containing the filter /// information. /// </param> /// <param name="operationSet"> /// Identifies this call as part of a deferred batch. For more information see /// http://msdn.microsoft.com/en-us/library/windows/desktop/ee415807(v=vs.85).aspx. /// </param> /// <returns>HRESULT</returns> public unsafe int SetFilterParametersNative(FilterParameters filterParameters, int operationSet) { return(InteropCalls.CallI(UnsafeBasePtr, &filterParameters, operationSet, ((void **)(*(void **)UnsafeBasePtr))[8])); }
/// <summary> /// Returns the current effect-specific parameters of a given effect in the voice's effect chain. /// </summary> /// <param name="effectIndex">Zero-based index of an effect within the voice's effect chain.</param> /// <param name="effectParameters">Returns the current values of the effect-specific parameters.</param> /// <param name="parametersByteSize">Size of the <paramref name="effectParameters" /> array in bytes.</param> /// <returns>HRESULT</returns> public unsafe int GetEffectParametersNative(int effectIndex, IntPtr effectParameters, int parametersByteSize) { return(InteropCalls.CallI(UnsafeBasePtr, effectIndex, effectParameters.ToPointer(), parametersByteSize, ((void **)(*(void **)UnsafeBasePtr))[7])); }
/// <summary> /// Sets parameters for a given effect in the voice's effect chain. /// </summary> /// <param name="effectIndex">Zero-based index of an effect within the voice's effect chain.</param> /// <param name="effectParameters"> New values of the effect-specific parameters. </param> /// <param name="parametersByteSize">Size of the <paramref name="effectParameters" /> array in bytes.</param> /// <param name="operationSet"> /// Identifies this call as part of a deferred batch. For more information see /// http://msdn.microsoft.com/en-us/library/windows/desktop/ee415807(v=vs.85).aspx. /// </param> /// <returns>HRESULT</returns> public unsafe int SetEffectParametersNative(int effectIndex, IntPtr effectParameters, int parametersByteSize, int operationSet) { return(InteropCalls.CallI(UnsafeBasePtr, effectIndex, effectParameters, parametersByteSize, operationSet, ((void **)(*(void **)UnsafeBasePtr))[6])); }
/// <summary> /// Disables the effect at a given position in the effect chain of the voice. /// </summary> /// <param name="effectIndex">Zero-based index of an effect in the effect chain of the voice.</param> /// <param name="operationSet"> /// Identifies this call as part of a deferred batch. For more information see /// http://msdn.microsoft.com/en-us/library/windows/desktop/ee415807(v=vs.85).aspx. /// </param> /// <returns>HRESULT</returns> public unsafe int DisableEffectNative(int effectIndex, int operationSet) { return(InteropCalls.CallI(UnsafeBasePtr, effectIndex, operationSet, ((void **)(*(void **)UnsafeBasePtr))[4])); }
/// <summary> /// Stops consumption of audio by the current voice. /// </summary> /// <param name="flags"> /// Flags that control how the voice is stopped. Can be <see cref="SourceVoiceStopFlags.None" /> or /// <see cref="SourceVoiceStopFlags.PlayTails" />. /// </param> /// <param name="operationSet"> /// Identifies this call as part of a deferred batch. For more details see /// http://msdn.microsoft.com/en-us/library/windows/desktop/ee415807(v=vs.85).aspx. /// </param> /// <returns>HRESULT</returns> public unsafe int StopNative(SourceVoiceStopFlags flags, int operationSet) { return(InteropCalls.CallI(UnsafeBasePtr, flags, operationSet, ((void **)(*(void **)UnsafeBasePtr))[20])); }
/// <summary> /// Starts consumption and processing of audio by the voice. Delivers the result to any connected submix or mastering /// voices, or to the output device. /// </summary> /// <param name="flags">Flags that control how the voice is started. Must be 0.</param> /// <param name="operationSet"> /// Identifies this call as part of a deferred batch. For more details see /// http://msdn.microsoft.com/en-us/library/windows/desktop/ee415807(v=vs.85).aspx. /// </param> /// <returns>HRESULT</returns> public unsafe int StartNative(int flags, int operationSet) { return(InteropCalls.CallI(UnsafeBasePtr, flags, operationSet, ((void **)(*(void **)UnsafeBasePtr))[19])); }
/// <summary> /// Starts the audio processing thread. /// </summary> /// <returns>HRESULT</returns> public override unsafe int StartEngineNative() { return(InteropCalls.CallI(UnsafeBasePtr, ((void **)(*(void **)UnsafeBasePtr))[11])); }