207 lines
11 KiB
C#
207 lines
11 KiB
C#
// Copyright (c) 2010-2014 SharpDX - Alexandre Mutel
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
// THE SOFTWARE.
|
|
using System;
|
|
using SharpDX.Multimedia;
|
|
|
|
namespace SharpDX.XAPO
|
|
{
|
|
/// <summary>
|
|
/// Base AudioProcessor class that implements methods from <see cref="AudioProcessor"/>. This class is
|
|
/// also providing its parameter through a generic.
|
|
/// </summary>
|
|
/// <typeparam name="T">type of the parameter for this AudioProcessor</typeparam>
|
|
public abstract partial class AudioProcessorBase<T> : CallbackBase, AudioProcessor, ParameterProvider where T : struct
|
|
{
|
|
private RegistrationProperties _registrationProperies;
|
|
private T _parameters;
|
|
|
|
private WaveFormat _inputFormatLocked;
|
|
private WaveFormat _outputFormatLocked;
|
|
private int _maxFrameCountLocked;
|
|
|
|
///<summary>
|
|
/// Return parameters
|
|
///</summary>
|
|
public virtual T Parameters
|
|
{
|
|
get { return _parameters; }
|
|
set { _parameters = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the input format locked.
|
|
/// </summary>
|
|
/// <value>The input format locked.</value>
|
|
protected WaveFormat InputFormatLocked
|
|
{
|
|
get { return _inputFormatLocked; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the output format locked.
|
|
/// </summary>
|
|
/// <value>The output format locked.</value>
|
|
protected WaveFormat OutputFormatLocked
|
|
{
|
|
get { return _outputFormatLocked; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the max frame count locked.
|
|
/// </summary>
|
|
/// <value>The max frame count locked.</value>
|
|
protected int MaxFrameCountLocked
|
|
{
|
|
get { return _maxFrameCountLocked; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the registration properties of an XAPO.
|
|
/// </summary>
|
|
/// <returns> a <see cref="SharpDX.XAPO.RegistrationProperties"/> structure containing the registration properties the XAPO was created with; use XAPOFree to free the structure.</returns>
|
|
/// <unmanaged>HRESULT IXAPO::GetRegistrationProperties([Out] XAPO_REGISTRATION_PROPERTIES** ppRegistrationProperties)</unmanaged>
|
|
public RegistrationProperties RegistrationProperties
|
|
{
|
|
get { return _registrationProperies; }
|
|
protected set { _registrationProperies = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Queries if a specific input format is supported for a given output format.
|
|
/// </summary>
|
|
/// <param name="outputFormat">Output format.</param>
|
|
/// <param name="requestedInputFormat">Input format to check for being supported.</param>
|
|
/// <param name="supportedInputFormat"> If not NULL, and the input format is not supported for the given output format, ppSupportedInputFormat returns a pointer to the closest input format that is supported. Use {{XAPOFree}} to free the returned structure. </param>
|
|
/// <returns>No documentation.</returns>
|
|
/// <unmanaged>HRESULT IXAPO::IsInputFormatSupported([None] const WAVEFORMATEX* pOutputFormat,[None] const WAVEFORMATEX* pRequestedInputFormat,[Out, Optional] WAVEFORMATEX** ppSupportedInputFormat)</unmanaged>
|
|
public bool IsInputFormatSupported(WaveFormat outputFormat, WaveFormat requestedInputFormat, out WaveFormat supportedInputFormat)
|
|
{
|
|
supportedInputFormat = requestedInputFormat;
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Queries if a specific output format is supported for a given input format.
|
|
/// </summary>
|
|
/// <param name="inputFormat">[in] Input format. </param>
|
|
/// <param name="requestedOutputFormat">[in] Output format to check for being supported. </param>
|
|
/// <param name="supportedOutputFormat">[out] If not NULL and the output format is not supported for the given input format, ppSupportedOutputFormat returns a pointer to the closest output format that is supported. Use {{XAPOFree}} to free the returned structure. </param>
|
|
/// <returns>No documentation.</returns>
|
|
/// <unmanaged>HRESULT IXAPO::IsOutputFormatSupported([None] const WAVEFORMATEX* pInputFormat,[None] const WAVEFORMATEX* pRequestedOutputFormat,[Out, Optional] WAVEFORMATEX** ppSupportedOutputFormat)</unmanaged>
|
|
public bool IsOutputFormatSupported(WaveFormat inputFormat, WaveFormat requestedOutputFormat, out WaveFormat supportedOutputFormat)
|
|
{
|
|
supportedOutputFormat = requestedOutputFormat;
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Performs any effect-specific initialization.
|
|
/// </summary>
|
|
/// <param name="stream"> Effect-specific initialization parameters, may be NULL if DataByteSize is 0. </param>
|
|
/// <returns>No documentation.</returns>
|
|
/// <unmanaged>HRESULT IXAPO::Initialize([In, Buffer, Optional] const void* pData,[None] UINT32 DataByteSize)</unmanaged>
|
|
public void Initialize(DataStream stream)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets variables dependent on frame history.
|
|
/// </summary>
|
|
/// <unmanaged>void IXAPO::Reset()</unmanaged>
|
|
public void Reset()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called by XAudio2 to lock the input and output configurations of an XAPO allowing it to
|
|
/// do any final initialization before {{Process}} is called on the realtime thread.
|
|
/// </summary>
|
|
/// <param name="inputLockedParameters"> Array of input <see cref="SharpDX.XAPO.LockParameters"/> structures.pInputLockedParameters may be NULL if InputLockedParameterCount is 0, otherwise it must have InputLockedParameterCount elements.</param>
|
|
/// <param name="outputLockedParameters"> Array of output <see cref="SharpDX.XAPO.LockParameters"/> structures.pOutputLockedParameters may be NULL if OutputLockedParameterCount is 0, otherwise it must have OutputLockedParameterCount elements.</param>
|
|
/// <returns>No documentation.</returns>
|
|
/// <unmanaged>HRESULT IXAPO::LockForProcess([None] UINT32 InputLockedParameterCount,[In, Buffer, Optional] const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pInputLockedParameters,[None] UINT32 OutputLockedParameterCount,[In, Buffer, Optional] const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pOutputLockedParameters)</unmanaged>
|
|
public void LockForProcess(LockParameters[] inputLockedParameters, LockParameters[] outputLockedParameters)
|
|
{
|
|
_inputFormatLocked = inputLockedParameters[0].Format;
|
|
_outputFormatLocked = outputLockedParameters[0].Format;
|
|
_maxFrameCountLocked = inputLockedParameters[0].MaxFrameCount;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deallocates variables that were allocated with the {{LockForProcess}} method.
|
|
/// </summary>
|
|
/// <unmanaged>void IXAPO::UnlockForProcess()</unmanaged>
|
|
public void UnlockForProcess()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Runs the XAPO's digital signal processing (DSP) code on the given input and output buffers.
|
|
/// </summary>
|
|
/// <param name="inputProcessParameters">[in] Input array of <see cref="SharpDX.XAPO.BufferParameters"/> structures. </param>
|
|
/// <param name="outputProcessParameters">[in, out] Output array of <see cref="SharpDX.XAPO.BufferParameters"/> structures. On input, the value of <see cref="SharpDX.XAPO.BufferParameters"/>.ValidFrameCount indicates the number of frames that the XAPO should write to the output buffer. On output, the value of <see cref="SharpDX.XAPO.BufferParameters"/>.ValidFrameCount indicates the actual number of frames written. </param>
|
|
/// <param name="isEnabled"> TRUE to process normally; FALSE to process thru. See Remarks for additional information. </param>
|
|
/// <unmanaged>void IXAPO::Process([None] UINT32 InputProcessParameterCount,[In, Buffer, Optional] const XAPO_PROCESS_BUFFER_PARAMETERS* pInputProcessParameters,[None] UINT32 OutputProcessParameterCount,[InOut, Buffer, Optional] XAPO_PROCESS_BUFFER_PARAMETERS* pOutputProcessParameters,[None] BOOL IsEnabled)</unmanaged>
|
|
public abstract void Process(BufferParameters[] inputProcessParameters, BufferParameters[] outputProcessParameters, bool isEnabled);
|
|
|
|
/// <summary>
|
|
/// Returns the number of input frames required to generate the given number of output frames.
|
|
/// </summary>
|
|
/// <param name="outputFrameCount">The number of output frames desired.</param>
|
|
/// <returns>No documentation.</returns>
|
|
/// <unmanaged>UINT32 IXAPO::CalcInputFrames([None] UINT32 OutputFrameCount)</unmanaged>
|
|
public int CalcInputFrames(int outputFrameCount)
|
|
{
|
|
return outputFrameCount;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the number of output frames that will be generated from a given number of input frames.
|
|
/// </summary>
|
|
/// <param name="inputFrameCount">The number of input frames.</param>
|
|
/// <returns>No documentation.</returns>
|
|
/// <unmanaged>UINT32 IXAPO::CalcOutputFrames([None] UINT32 InputFrameCount)</unmanaged>
|
|
public int CalcOutputFrames(int inputFrameCount)
|
|
{
|
|
return inputFrameCount;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets effect-specific parameters.
|
|
/// </summary>
|
|
/// <param name="parameters"> Effect-specific parameter block. </param>
|
|
/// <unmanaged>void IXAPOParameters::SetParameters([In, Buffer] const void* pParameters,[None] UINT32 ParameterByteSize)</unmanaged>
|
|
/* public void SetParameters(IntPtr arametersRef, int parameterByteSize) */
|
|
void ParameterProvider.SetParameters(DataStream parameters)
|
|
{
|
|
Utilities.Read(parameters.PositionPointer, ref _parameters);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the current values for any effect-specific parameters.
|
|
/// </summary>
|
|
/// <param name="parameters">[in, out] Receives an effect-specific parameter block. </param>
|
|
/// <unmanaged>void IXAPOParameters::GetParameters([Out, Buffer] void* pParameters,[None] UINT32 ParameterByteSize)</unmanaged>
|
|
void ParameterProvider.GetParameters(DataStream parameters)
|
|
{
|
|
Utilities.Write(parameters.PositionPointer, ref _parameters);
|
|
}
|
|
}
|
|
} |