/// <summary>
/// Gets the audio session specified by an audio session number.
/// </summary>
/// <param name="index">The session number. If there are n sessions, the sessions are numbered from 0 to n – 1. To get the number of sessions, call the GetCount method.</param>
/// <returns>The <see cref="AudioSessionControl"/> of the specified session number.</returns>
public AudioSessionControl GetSession(int index)
{
AudioSessionControl session;
CoreAudioAPIException.Try(GetSessionNative(index, out session), InterfaceName, "GetSession");
return(session);
}
/// <summary>
/// Retrieves an audio endpoint device that is identified by an endpoint ID string.
/// </summary>
/// <param name="id">Endpoint ID. The caller typically obtains this string from the <see cref="MMDevice.DeviceID"/> property or any method of the <see cref="IMMNotificationClient"/>.</param>
/// <returns><see cref="MMDevice"/> instance for specified device.</returns>
public MMDevice GetDevice(string id)
{
IntPtr ptr;
CoreAudioAPIException.Try(GetDeviceNative(id, out ptr), InterfaceName, "GetDevice");
return(new MMDevice(ptr));
}
/// <summary>
/// Retrieves a pointer to the next available space in the rendering endpoint buffer into
/// which the caller can write a data packet.
/// </summary>
/// <param name="numFramesRequested">
/// The number of audio frames in the data packet that the caller plans to write to the requested space in the buffer.
/// If the call succeeds, the size of the buffer area pointed to by return value matches the size specified in
/// <paramref name="numFramesRequested" />.
/// </param>
/// <returns>
/// A pointer variable into which the method writes the starting address of the buffer area into which the caller
/// will write the data packet.
/// </returns>
public IntPtr GetBuffer(int numFramesRequested)
{
IntPtr ptr;
CoreAudioAPIException.Try(GetBufferNative(numFramesRequested, out ptr), InterfaceName, "GetBuffer");
return(ptr);
}
/// <summary>
/// Queries the audio endpoint device for its
/// hardware-supported functions.
/// </summary>
/// <returns>A hardware support mask that indicates the hardware capabilities of the audio endpoint device.</returns>
public EndpointHardwareSupportFlags QueryHardwareSupport()
{
EndpointHardwareSupportFlags res;
CoreAudioAPIException.Try(QueryHardwareSupportNative(out res), InterfaceName, "QueryHardwareSupport");
return(res);
}
/// <summary>
/// Gets the peak sample value for the channels in the audio stream.
/// </summary>
/// <returns>
/// The peak sample value for the audio stream. The peak value is a number in the normalized range from 0.0 to
/// 1.0.
/// </returns>
public float GetPeakValue()
{
float peak;
CoreAudioAPIException.Try(GetPeakValueNative(out peak), InterfaceName, "GetPeakValue");
return(peak);
}
/// <summary>
/// The GetNextPacketSize method retrieves the number of frames in the next data packet in
/// the capture endpoint buffer.
/// For more information, see <see href="http://msdn.microsoft.com/en-us/library/dd370860(v=vs.85).aspx"/>.
/// </summary>
/// <returns>The number of the audio frames in the next capture packet.</returns>
public int GetNextPacketSize()
{
int t;
CoreAudioAPIException.Try(GetNextPacketSizeNative(out t), InterfaceName, "GetNextPacketSize");
return(t);
}
/// <summary>
/// Gets the muting state of the audio stream that enters or leaves the
/// audio endpoint device.
/// </summary>
/// <returns>If the method returns <c>true, the stream is muted. If <c>false</c>, the stream is not muted.</c></returns>
public bool GetMute()
{
NativeBool result;
CoreAudioAPIException.Try(GetMuteNative(out result), C, "GetMute");
return(result);
}
/// <summary>
/// Gets the volume level, in decibels, of the specified
/// channel in the audio stream that enters or leaves the audio endpoint device.
/// </summary>
/// <param name="channel">
/// The channel number. If the audio stream contains n channels, the channels are numbered from 0 to
/// n–1.
/// </param>
/// <returns>
/// Volume level in decibels. To get the range of volume levels obtained from this
/// method, call the <see cref="GetVolumeRange" /> method.
/// </returns>
public float GetChannelVolumeLevel(int channel)
{
float result;
CoreAudioAPIException.Try(GetChannelVolumeLevelNative(channel, out result), C, "GetChannelVolumeLevel");
return(result);
}
/// <summary>
/// Queries the audio endpoint device for its
/// hardware-supported functions.
/// </summary>
/// <returns>A hardware support mask that indicates the hardware capabilities of the audio endpoint device.</returns>
public EndpointHardwareSupportFlags QueryHardwareSupport()
{
EndpointHardwareSupportFlags result;
CoreAudioAPIException.Try(QueryHardwareSupportNative(out result), C, "QueryHardWareSupport");
return(result);
}
/// <summary>
/// Gets the master volume level of the audio stream
/// that enters or leaves the audio endpoint device. The volume level is expressed as a
/// normalized, audio-tapered value in the range from 0.0 to 1.0.
/// </summary>
/// <returns>
/// Volume level. The level is expressed as a normalized value in the range from
/// 0.0 to 1.0.
/// </returns>
public float GetMasterVolumeLevelScalar()
{
float result;
CoreAudioAPIException.Try(GetMasterVolumeLevelScalarNative(out result), C, "GetMasterVolumeLevelScalar");
return(result);
}
/// <summary>
/// Gets the peak sample values for all the channels in the
/// audio stream.
/// <seealso cref="MeteringChannelCount" />
/// </summary>
/// <param name="channelCount">
/// The channel count. This parameter also specifies the number of elements in the returned
/// array. If the specified count does not match the number of channels in the stream, the method returns error code
/// <see cref="HResult.E_INVALIDARG" />.
/// </param>
/// <returns>
/// An array of peak sample values. he array contains one element for each channel in the stream. The peak values
/// are numbers in the normalized range from 0.0 to 1.0.
/// </returns>
public float[] GetChannelsPeakValues(int channelCount)
{
float[] val;
CoreAudioAPIException.Try(GetChannelsPeakValuesNative(channelCount, out val), InterfaceName,
"GetChannelsPeakValues");
return(val);
}
/// <summary>
/// Retrieves the stream format that the audio engine uses for its
/// internal processing of shared-mode streams.
/// </summary>
/// <remarks>
/// For more information, see
/// <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/dd370872(v=vs.85).aspx" />.
/// </remarks>
/// <returns>The mix format that the audio engine uses for its internal processing of shared-mode streams.</returns>
public WaveFormat GetMixFormat()
{
WaveFormat waveFormat;
CoreAudioAPIException.Try(GetMixFormatNative(out waveFormat), InterfaceName, "GetMixFormat");
return(waveFormat);
}
/// <summary>
/// The <see cref="GetCount"/> method retrieves a count of the devices in the device collection.
/// </summary>
/// <returns>The number of devices in the device collection.</returns>
public int GetCount()
{
int count = 0;
CoreAudioAPIException.Try(GetCountNative(out count), "IMMDeviceCollection", "GetCount");
return(count);
}
/// <summary>
/// Retrieves the maximum latency for the current stream and can
/// be called any time after the stream has been initialized.
/// </summary>
/// <remarks>
/// Rendering clients can use this latency value to compute the minimum amount of data that
/// they can write during any single processing pass. To write less than this minimum is to
/// risk introducing glitches into the audio stream. For more information, see
/// <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/dd370874(v=vs.85).aspx" />.
/// </remarks>
/// <returns>A value representing the latency. The time is expressed in 100-nanosecond units.</returns>
public long GetStreamLatency()
{
long latency;
CoreAudioAPIException.Try(GetStreamLatencyNative(out latency), InterfaceName, "GetStreamLatency");
return(latency);
}
/// <summary>
/// Retrieves the number of frames of padding in the endpoint
/// buffer.
/// </summary>
/// <returns>The frame count (the number of audio frames of padding in the buffer).</returns>
/// <remarks>
/// The size of one frame = <c>(number of bits per sample)/8 * (number of channels)</c>
/// </remarks>
public int GetCurrentPadding()
{
int padding;
CoreAudioAPIException.Try(GetCurrentPaddingNative(out padding), InterfaceName, "GetCurrentPadding");
return(padding);
}
/// <summary>
/// Initializes the audio stream.
/// </summary>
/// <param name="shareMode">
/// The sharing mode for the connection. Through this parameter, the client tells the audio engine
/// whether it wants to share the audio endpoint device with other clients.
/// </param>
/// <param name="streamFlags">Flags to control creation of the stream.</param>
/// <param name="hnsBufferDuration">
/// The buffer capacity as a time value (expressed in 100-nanosecond units). This parameter
/// contains the buffer size that the caller requests for the buffer that the audio application will share with the
/// audio engine (in shared mode) or with the endpoint device (in exclusive mode). If the call succeeds, the method
/// allocates a buffer that is a least this large.
/// </param>
/// <param name="hnsPeriodicity">
/// The device period. This parameter can be nonzero only in exclusive mode. In shared mode,
/// always set this parameter to 0. In exclusive mode, this parameter specifies the requested scheduling period for
/// successive buffer accesses by the audio endpoint device. If the requested device period lies outside the range that
/// is set by the device's minimum period and the system's maximum period, then the method clamps the period to that
/// range. If this parameter is 0, the method sets the device period to its default value. To obtain the default device
/// period, call the <see cref="GetDevicePeriodNative" /> method. If the
/// <see cref="AudioClientStreamFlags.StreamFlagsEventCallback" /> stream flag is set and
/// <see cref="AudioClientShareMode.Exclusive" /> is set as the <paramref name="shareMode" />, then
/// <paramref name="hnsPeriodicity" /> must be nonzero and equal to <paramref name="hnsBufferDuration" />.
/// </param>
/// <param name="waveFormat">
/// The format descriptor. For more information, see
/// <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/dd370875(v=vs.85).aspx" />.
/// </param>
/// <param name="audioSessionGuid">
/// A value that identifies the audio session that the stream belongs to. If the
/// <see cref="Guid" /> identifies a session that has been previously opened, the method adds the stream to that
/// session. If the GUID does not identify an existing session, the method opens a new session and adds the stream to
/// that session. The stream remains a member of the same session for its lifetime. Use <see cref="Guid.Empty" /> to
/// use the default session.
/// </param>
/// <remarks>
/// For more information, see
/// <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/dd370875(v=vs.85).aspx" />.
/// </remarks>
public void Initialize(AudioClientShareMode shareMode, AudioClientStreamFlags streamFlags,
long hnsBufferDuration, long hnsPeriodicity, WaveFormat waveFormat, Guid audioSessionGuid)
{
CoreAudioAPIException.Try(
InitializeNative(shareMode, streamFlags, hnsBufferDuration, hnsPeriodicity, waveFormat, audioSessionGuid),
InterfaceName, "Initialize");
}
/// <summary>
/// Returns the size (maximum capacity) of the endpoint buffer.
/// </summary>
/// <returns>The number of audio frames that the buffer can hold.</returns>
/// <remarks>
/// The size of one frame = <c>(number of bits per sample)/8 * (number of channels)</c>
/// </remarks>
/// <returns>HRESULT</returns>
public int GetBufferSize()
{
int bufferSize;
CoreAudioAPIException.Try(GetBufferSizeNative(out bufferSize), InterfaceName, "GetBufferSize");
return(bufferSize);
}
/// <summary>
/// Gets the number of channels in the audio stream that enters
/// or leaves the audio endpoint device.
/// </summary>
/// <returns>The number of channels in the audio stream.</returns>
public int GetChannelCount()
{
int result;
CoreAudioAPIException.Try(GetChannelCountNative(out result), C, "GetChannelCount");
return(result);
}
/// <summary>
/// The <see cref="ItemAtNative"/> method retrieves a pointer to the specified item in the device collection.
/// </summary>
/// <param name="deviceIndex">The device number. If the collection contains n devices, the devices are numbered 0 to n– 1.</param>
/// <returns>The <see cref="MMDevice"/> object of the specified item in the device collection.</returns>
public MMDevice ItemAt(int deviceIndex)
{
IntPtr device;
CoreAudioAPIException.Try(ItemAtNative(deviceIndex, out device), "IMMDeviceCollection", "Item");
return(new MMDevice(device));
}
/// <summary>
/// Accesses additional services from the audio client object.
/// </summary>
/// <param name="riid">
/// The interface ID for the requested service. For a list of all available values, see
/// <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/dd370873(v=vs.85).aspx" />.
/// </param>
/// <returns>
/// A pointer into which the method writes the address of an instance of the requested interface.
/// Through this method, the caller obtains a counted reference to the interface. The caller is responsible for
/// releasing the interface, when it is no longer needed, by calling the interface's Release method.
/// </returns>
/// <remarks>
/// For more information, see
/// <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/dd370873(v=vs.85).aspx" />.
/// </remarks>
public IntPtr GetService(Guid riid)
{
IntPtr ptr;
CoreAudioAPIException.Try(GetServiceNative(riid, out ptr), InterfaceName, "GetService");
return(ptr);
}
/// <summary>
/// Creates a COM object with the specified interface.
/// </summary>
/// <param name="iid">The interface identifier. This parameter is a reference to a GUID that identifies the interface that the caller requests be activated. The caller will use this interface to communicate with the COM object.</param>
/// <param name="context">The execution context in which the code that manages the newly created object will run. </param>
/// <param name="activationParams">Use <see cref="IntPtr.Zero"/> as the default value. See http://msdn.microsoft.com/en-us/library/windows/desktop/dd371405%28v=vs.85%29.aspx for more details.</param>
/// <returns>A pointer variable into which the method writes the address of the interface specified by parameter <paramref name="iid"/>.</returns>
public IntPtr Activate(Guid iid, CLSCTX context, IntPtr activationParams)
{
IntPtr ptr;
CoreAudioAPIException.Try(ActivateNative(iid, context, activationParams, out ptr), InterfaceName, "Activate");
return(ptr);
}
/// <summary>
/// Generates a collection of audio endpoint devices that meet the specified criteria.
/// </summary>
/// <param name="dataFlow">The data-flow direction for the endpoint device.</param>
/// <param name="stateMask">The state or states of the endpoints that are to be included in the collection.</param>
/// <returns><see cref="MMDeviceCollection"/> which contains the enumerated devices.</returns>
public MMDeviceCollection EnumAudioEndpoints(DataFlow dataFlow, DeviceState stateMask)
{
IntPtr pcollection;
CoreAudioAPIException.Try(EnumAudioEndpointsNative(dataFlow, stateMask, out pcollection), InterfaceName,
"EnumAudioEndpoints");
return(new MMDeviceCollection(pcollection));
}
/// <summary>
/// Retrieves a simple audio volume control.
/// </summary>
/// <param name="crossProcessSession">Specifies whether the request is for a cross-process session. Set to TRUE if the session is cross-process. Set to FALSE if the session is not cross-process.</param>
/// <param name="audioSessionGuid">If the GUID does not identify a session that has been previously opened, the call opens a new but empty session. If the value is Guid.Empty, the method assigns the stream to the default session.</param>
/// <returns><see cref="SimpleAudioVolume"/> instance.</returns>
public SimpleAudioVolume GetSimpleAudioVolume(Guid audioSessionGuid, bool crossProcessSession)
{
SimpleAudioVolume v;
CoreAudioAPIException.Try(GetSimpleAudioVolumeNative(audioSessionGuid, crossProcessSession, out v),
"IAudioSessionManager", "GetSimpleAudioVolume");
return(v);
}
/// <summary>
/// Retrieves an audio session control.
/// </summary>
/// <param name="audioSessionGuid">If the GUID does not identify a session that has been previously opened, the call opens a new but empty session. If the value is Guid.Empty, the method assigns the stream to the default session.</param>
/// <param name="streamFlags">Specifies the status of the flags for the audio stream.</param>
/// <returns><see cref="AudioSessionControl"/> instance.</returns>
public AudioSessionControl GetAudioSessionControl(Guid audioSessionGuid, int streamFlags)
{
AudioSessionControl sessionControl;
CoreAudioAPIException.Try(GetAudioSessionControlNative(audioSessionGuid, streamFlags, out sessionControl),
"IAudioSessionManager", "GetAudioSessionControl");
return(sessionControl);
}
/// <summary>
/// Returns the default audio endpoint for the specified data-flow direction and role.
/// </summary>
/// <param name="dataFlow">The data-flow direction for the endpoint device.</param>
/// <param name="role">The role of the endpoint device.</param>
/// <returns><see cref="MMDevice"/> instance of the endpoint object for the default audio endpoint device.</returns>
public MMDevice GetDefaultAudioEndpoint(DataFlow dataFlow, Role role)
{
IntPtr ptr;
CoreAudioAPIException.Try(GetDefaultAudioEndpointNative(dataFlow, role, out ptr), InterfaceName,
"GetDefaultAudioEndpoint");
return(new MMDevice(ptr));
}
/// <summary>
/// Gets a pointer to the audio session enumerator object.
/// </summary>
/// <returns>a session enumerator object that the client can use to enumerate audio sessions on the audio device.</returns>
/// <remarks>The client is responsible for releasing the returned <see cref="AudioSessionEnumerator"/>.</remarks>
public AudioSessionEnumerator GetSessionEnumerator()
{
AudioSessionEnumerator sessionEnumerator;
CoreAudioAPIException.Try(GetSessionEnumeratorNative(out sessionEnumerator), InterfaceName,
"GetSessionEnumerator");
return(sessionEnumerator);
}
/// <summary>
/// Gets the number of channels in the audio stream that
/// are monitored by peak meters.
/// </summary>
/// <returns>The number of channels.</returns>
public int GetMeteringChannelCount()
{
int channelCount;
CoreAudioAPIException.Try(GetMeteringChannelCountNative(out channelCount), InterfaceName,
"GetMeteringChannelCount");
return(channelCount);
}
/// <summary>
/// Deletes the registration of a client's
/// notification callback interface that the client registered in a previous call to the
/// <see cref="RegisterControlChangeNotify" /> method.
/// </summary>
/// <param name="notify">
/// The callback instance to unregister. The client passed this same object to the endpoint volume
/// object in the previous call to the <see cref="RegisterControlChangeNotify" /> method.
/// </param>
public void UnregisterControlChangeNotify(IAudioEndpointVolumeCallback notify)
{
if (notify == null)
{
throw new ArgumentNullException("notify");
}
CoreAudioAPIException.Try(UnregisterControlChangeNotifyNative(notify), C, "UnregisterControlChangeNotify");
}
/// <summary>
/// Retrieves an interface to the device's property store.
/// </summary>
/// <param name="storageAccess">The storage-access mode. This parameter specifies whether to open the property store in read mode, write mode, or read/write mode.</param>
/// <returns><see cref="PropertyStore"/> for the <see cref="MMDevice"/>.</returns>
public PropertyStore OpenPropertyStore(StorageAccess storageAccess)
{
IntPtr propstorePtr;
CoreAudioAPIException.Try(OpenPropertyStoreNative(storageAccess, out propstorePtr),
"IMMDevice", "OpenPropertyStore");
return(new PropertyStore(propstorePtr));
}
/// <summary>
/// Registers the application to receive a notification when a session is created.
/// </summary>
/// <param name="sessionNotification">The application's implementation of the <see cref="IAudioSessionNotification"/> interface.</param>
/// <remarks>
/// Use the <see cref="AudioSessionNotification"/> class as the default implementation for the <paramref name="sessionNotification"/> parameter.
///
/// <c>Note:</c> Make sure to call the <see cref="RegisterSessionNotification"/> from an MTA-Thread. Also make sure to enumerate all sessions after calling this method.
/// </remarks>
public void RegisterSessionNotification(IAudioSessionNotification sessionNotification)
{
if (Thread.CurrentThread.GetApartmentState() != ApartmentState.MTA)
{
throw new InvalidOperationException("RegisterSessionNotification has to be called from an MTA-Thread.");
}
CoreAudioAPIException.Try(RegisterSessionNotificationNative(sessionNotification), InterfaceName,
"RegisterSessionNotification");
}
