Subversion Repositories Games.Chess Giants

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

DEFINE_IID(IXAPO,           A90BC001, E897, E897, 55, E4, 9E, 47, 00, 00, 00, 00);

DEFINE_IID(IXAPOParameters, A90BC001, E897, E897, 55, E4, 9E, 47, 00, 00, 00, 01);

 

 

    #if defined(_XBOX)       // general windows and COM declarations

        #include <xtl.h>

        #include <xobjbase.h>

    #else

        #include <windows.h>

        #include <objbase.h>

    #endif

    #include "audiodefs.h"   // for WAVEFORMATEX etc.

 

    // XAPO error codes

    #define FACILITY_XAPO 0x897

    #define XAPO_E_FORMAT_UNSUPPORTED MAKE_HRESULT(SEVERITY_ERROR, FACILITY_XAPO, 0x01) // requested audio format unsupported

 

    // supported number of channels (samples per frame) range

    #define XAPO_MIN_CHANNELS 1

    #define XAPO_MAX_CHANNELS 64

 

    // supported framerate range

    #define XAPO_MIN_FRAMERATE 1000

    #define XAPO_MAX_FRAMERATE 200000

 

    // unicode string length, including terminator, used with XAPO_REGISTRATION_PROPERTIES

    #define XAPO_REGISTRATION_STRING_LENGTH 256

 

 

    // XAPO property flags, used with XAPO_REGISTRATION_PROPERTIES.Flags:

    // Number of channels of input and output buffers must match,

    // applies to XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.pFormat.

    #define XAPO_FLAG_CHANNELS_MUST_MATCH      0x00000001

 

    // Framerate of input and output buffers must match,

    // applies to XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.pFormat.

    #define XAPO_FLAG_FRAMERATE_MUST_MATCH     0x00000002

 

    // Bit depth of input and output buffers must match,

    // applies to XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.pFormat.

    // Container size of input and output buffers must also match if

    // XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.pFormat is WAVEFORMATEXTENSIBLE.

    #define XAPO_FLAG_BITSPERSAMPLE_MUST_MATCH 0x00000004

 

    // Number of input and output buffers must match,

    // applies to XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.

    //

    // Also, XAPO_REGISTRATION_PROPERTIES.MinInputBufferCount must

    // equal XAPO_REGISTRATION_PROPERTIES.MinOutputBufferCount and

    // XAPO_REGISTRATION_PROPERTIES.MaxInputBufferCount must equal

    // XAPO_REGISTRATION_PROPERTIES.MaxOutputBufferCount when used.

    #define XAPO_FLAG_BUFFERCOUNT_MUST_MATCH   0x00000008

 

    // XAPO must be run in-place.  Use this flag only if your DSP

    // implementation cannot process separate input and output buffers.

    // If set, the following flags must also be set:

    //     XAPO_FLAG_CHANNELS_MUST_MATCH

    //     XAPO_FLAG_FRAMERATE_MUST_MATCH

    //     XAPO_FLAG_BITSPERSAMPLE_MUST_MATCH

    //     XAPO_FLAG_BUFFERCOUNT_MUST_MATCH

    //     XAPO_FLAG_INPLACE_SUPPORTED

    //

    // Multiple input and output buffers may be used with in-place XAPOs,

    // though the input buffer count must equal the output buffer count.

    // When multiple input/output buffers are used, the XAPO may assume

    // input buffer [N] equals output buffer [N] for in-place processing.

    #define XAPO_FLAG_INPLACE_REQUIRED         0x00000020

 

    // XAPO may be run in-place.  If the XAPO is used in a chain

    // such that the requirements for XAPO_FLAG_INPLACE_REQUIRED are met,

    // XAudio2 will ensure the XAPO is run in-place.  If not met, XAudio2

    // will still run the XAPO albeit with separate input and output buffers.

    //

    // For example, consider an effect which may be ran in stereo->5.1 mode or

    // mono->mono mode.  When set to stereo->5.1, it will be run with separate

    // input and output buffers as format conversion is not permitted in-place.

    // However, if configured to run mono->mono, the same XAPO can be run

    // in-place.  Thus the same implementation may be conveniently reused

    // for various input/output configurations, while taking advantage of

    // in-place processing when possible.

    #define XAPO_FLAG_INPLACE_SUPPORTED        0x00000010

 

 

    #pragma pack(push, 1) // set packing alignment to ensure consistency across arbitrary build environments

 

 

    // XAPO registration properties, describes general XAPO characteristics, used with IXAPO::GetRegistrationProperties

    typedef struct XAPO_REGISTRATION_PROPERTIES {

        CLSID  clsid;                                          // COM class ID, used with CoCreate

        WCHAR  FriendlyName[XAPO_REGISTRATION_STRING_LENGTH];  // friendly name unicode string

        WCHAR  CopyrightInfo[XAPO_REGISTRATION_STRING_LENGTH]; // copyright information unicode string

        UINT32 MajorVersion;                                   // major version

        UINT32 MinorVersion;                                   // minor version

        UINT32 Flags;                                          // XAPO property flags, describes supported input/output configuration

        UINT32 MinInputBufferCount;                            // minimum number of input buffers required for processing, can be 0

        UINT32 MaxInputBufferCount;                            // maximum number of input buffers supported for processing, must be >= MinInputBufferCount

        UINT32 MinOutputBufferCount;                           // minimum number of output buffers required for processing, can be 0, must match MinInputBufferCount when XAPO_FLAG_BUFFERCOUNT_MUST_MATCH used

        UINT32 MaxOutputBufferCount;                           // maximum number of output buffers supported for processing, must be >= MinOutputBufferCount, must match MaxInputBufferCount when XAPO_FLAG_BUFFERCOUNT_MUST_MATCH used

    } XAPO_REGISTRATION_PROPERTIES;

 

 

    // LockForProcess buffer parameters:

    // Defines buffer parameters that remain constant while an XAPO is locked.

    // Used with IXAPO::LockForProcess.

    //

    // For CBR XAPOs, MaxFrameCount is the only number of frames

    // IXAPO::Process would have to handle for the respective buffer.

    typedef struct XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS {

        const WAVEFORMATEX* pFormat;       // buffer audio format

        UINT32              MaxFrameCount; // maximum number of frames in respective buffer that IXAPO::Process would have to handle, irrespective of dynamic variable settings, can be 0

    } XAPO_LOCKFORPROCESS_PARAMETERS;

 

    // Buffer flags:

    // Describes assumed content of the respective buffer.

    // Used with XAPO_PROCESS_BUFFER_PARAMETERS.BufferFlags.

    //

    // This meta-data can be used by an XAPO to implement

    // optimizations that require knowledge of a buffer's content.

    //

    // For example, XAPOs that always produce silent output from silent input

    // can check the flag on the input buffer to determine if any signal

    // processing is necessary.  If silent, the XAPO may simply set the flag

    // on the output buffer to silent and return, optimizing out the work of

    // processing silent data:  XAPOs that generate silence for any reason may

    // set the buffer's flag accordingly rather than writing out silent

    // frames to the buffer itself.

    //

    // The flags represent what should be assumed is in the respective buffer.

    // The flags may not reflect what is actually stored in memory.

    typedef enum XAPO_BUFFER_FLAGS {

        XAPO_BUFFER_SILENT, // silent data should be assumed, respective memory may be uninitialized

        XAPO_BUFFER_VALID,  // arbitrary data should be assumed (may or may not be silent frames), respective memory initialized

    } XAPO_BUFFER_FLAGS;

 

    // Process buffer parameters:

    // Defines buffer parameters that may change from one

    // processing pass to the next.  Used with IXAPO::Process.

    //

    // Note the byte size of the respective buffer must be at least:

    //      XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.MaxFrameCount * XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.pFormat->nBlockAlign

    //

    // Although the audio format and maximum size of the respective

    // buffer is locked (defined by XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS),

    // the actual memory address of the buffer given is permitted to change

    // from one processing pass to the next.

    //

    // For CBR XAPOs, ValidFrameCount is constant while locked and equals

    // the respective XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.MaxFrameCount.

    typedef struct XAPO_PROCESS_BUFFER_PARAMETERS {

        void*             pBuffer;         // audio data buffer, must be non-NULL

        XAPO_BUFFER_FLAGS BufferFlags;     // describes assumed content of pBuffer, does not affect ValidFrameCount

        UINT32            ValidFrameCount; // number of frames of valid data, must be within respective [0, XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.MaxFrameCount], always XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.MaxFrameCount for CBR/user-defined XAPOs, does not affect BufferFlags

    } XAPO_PROCESS_BUFFER_PARAMETERS;

 

 

    // Memory allocation macros that allow one module to allocate memory and

    // another to free it, by guaranteeing that the same heap manager is used

    // regardless of differences between build environments of the two modules.

    //

    // Used by IXAPO methods that must allocate arbitrary sized structures

    // such as WAVEFORMATEX that are subsequently returned to the application.

    #if defined(_XBOX)

        #define XAPO_ALLOC_ATTRIBUTES MAKE_XALLOC_ATTRIBUTES (      \

        #define XAPOAlloc(size) XMemAlloc(size, XAPO_ALLOC_ATTRIBUTES)

        #define XAPOFree(p)     XMemFree(p, XAPO_ALLOC_ATTRIBUTES)

    #else

        #define XAPOAlloc(size) CoTaskMemAlloc(size)

        #define XAPOFree(p)     CoTaskMemFree(p)

    #endif

 

 

    // IXAPO:

    // The only mandatory XAPO COM interface -- a thin wrapper that manages

    // DSP code, allowing it to be easily plugged into an XAudio2 effect chain.

    #undef INTERFACE

    #define INTERFACE IXAPO

    DECLARE_INTERFACE_(IXAPO, IUnknown) {

          ////

          // DESCRIPTION:

          //  Allocates a copy of the registration properties of the XAPO.

          //

          // PARAMETERS:

          //  ppRegistrationProperties - [out] receives pointer to copy of registration properties, use XAPOFree to free structure, left untouched on failure

          //

          // RETURN VALUE:

          //  COM error code

          ////

        STDMETHOD(GetRegistrationProperties) (THIS_ __deref_out XAPO_REGISTRATION_PROPERTIES** ppRegistrationProperties) PURE;

 

          ////

          // DESCRIPTION:

          //  Queries if an input/output configuration is supported.

          //

          // REMARKS:

          //  This method allows XAPOs to express dependency of input format

          //  with respect to output format.

          //

          //  If the input/output format pair configuration is unsupported,

          //  this method also determines the nearest input format supported.

          //  Nearest meaning closest bit depth, framerate, and channel count,

          //  in that order of importance.

          //

          //  The behaviour of this method should remain constant after the

          //  XAPO has been initialized.

          //

          // PARAMETERS:

          //  pOutputFormat          - [in]  output format known to be supported

          //  pRequestedInputFormat  - [in]  input format to examine

          //  ppSupportedInputFormat - [out] receives pointer to nearest input format supported if not NULL and input/output configuration unsupported, use XAPOFree to free structure, left untouched on any failure except XAPO_E_FORMAT_UNSUPPORTED

          //

          // RETURN VALUE:

          //  COM error code, including:

          //    S_OK                      - input/output configuration supported, ppSupportedInputFormat left untouched

          //    XAPO_E_FORMAT_UNSUPPORTED - input/output configuration unsupported, ppSupportedInputFormat receives pointer to nearest input format supported if not NULL

          //    E_INVALIDARG              - either audio format invalid, ppSupportedInputFormat left untouched

          ////

        STDMETHOD(IsInputFormatSupported) (THIS_ const WAVEFORMATEX* pOutputFormat, const WAVEFORMATEX* pRequestedInputFormat, __deref_opt_out WAVEFORMATEX** ppSupportedInputFormat) PURE;

 

          ////

          // DESCRIPTION:

          //  Queries if an input/output configuration is supported.

          //

          // REMARKS:

          //  This method allows XAPOs to express dependency of output format

          //  with respect to input format.

          //

          //  If the input/output format pair configuration is unsupported,

          //  this method also determines the nearest output format supported.

          //  Nearest meaning closest bit depth, framerate, and channel count,

          //  in that order of importance.

          //

          //  The behaviour of this method should remain constant after the

          //  XAPO has been initialized.

          //

          // PARAMETERS:

          //  pInputFormat            - [in]  input format known to be supported

          //  pRequestedOutputFormat  - [in]  output format to examine

          //  ppSupportedOutputFormat - [out] receives pointer to nearest output format supported if not NULL and input/output configuration unsupported, use XAPOFree to free structure, left untouched on any failure except XAPO_E_FORMAT_UNSUPPORTED

          //

          // RETURN VALUE:

          //  COM error code, including:

          //    S_OK                      - input/output configuration supported, ppSupportedOutputFormat left untouched

          //    XAPO_E_FORMAT_UNSUPPORTED - input/output configuration unsupported, ppSupportedOutputFormat receives pointer to nearest output format supported if not NULL

          //    E_INVALIDARG              - either audio format invalid, ppSupportedOutputFormat left untouched

          ////

        STDMETHOD(IsOutputFormatSupported) (THIS_ const WAVEFORMATEX* pInputFormat, const WAVEFORMATEX* pRequestedOutputFormat, __deref_opt_out WAVEFORMATEX** ppSupportedOutputFormat) PURE;

 

          ////

          // DESCRIPTION:

          //  Performs any effect-specific initialization if required.

          //

          // REMARKS:

          //  The contents of pData are defined by the XAPO.

          //  Immutable variables (constant during the lifespan of the XAPO)

          //  should be set once via this method.

          //  Once initialized, an XAPO cannot be initialized again.

          //

          //  An XAPO should be initialized before passing it to XAudio2

          //  as part of an effect chain.  XAudio2 will not call this method;

          //  it exists for future content-driven initialization by XACT.

          //

          // PARAMETERS:

          //  pData        - [in] effect-specific initialization parameters, may be NULL if DataByteSize == 0

          //  DataByteSize - [in] size of pData in bytes, may be 0 if DataByteSize is NULL

          //

          // RETURN VALUE:

          //  COM error code

          ////

        STDMETHOD(Initialize) (THIS_ __in_bcount_opt(DataByteSize) const void* pData, UINT32 DataByteSize) PURE;

 

          ////

          // DESCRIPTION:

          //  Resets variables dependent on frame history.

          //

          // REMARKS:

          //  All other variables remain unchanged, including variables set by

          //  IXAPOParameters::SetParameters.

          //

          //  For example, an effect with delay should zero out its delay line

          //  during this method, but should not reallocate anything as the

          //  XAPO remains locked with a constant input/output configuration.

          //

          //  XAudio2 calls this method only if the XAPO is locked.

          //  This method should not block as it is called from the

          //  realtime thread.

          //

          // PARAMETERS:

          //  void

          //

          // RETURN VALUE:

          //  void

          ////

        STDMETHOD_(void, Reset) (THIS) PURE;

 

          ////

          // DESCRIPTION:

          //  Locks the XAPO to a specific input/output configuration,

          //  allowing it to do any final initialization before Process

          //  is called on the realtime thread.

          //

          // REMARKS:

          //  Once locked, the input/output configuration and any other locked

          //  variables remain constant until UnlockForProcess is called.

          //

          //  XAPOs should assert the input/output configuration is supported

          //  and that any required effect-specific initialization is complete.

          //  IsInputFormatSupported, IsOutputFormatSupported, and Initialize

          //  should be called as necessary before this method is called.

          //

          //  All internal memory buffers required for Process should be

          //  allocated by the time this method returns successfully

          //  as Process is non-blocking and should not allocate memory.

          //

          //  Once locked, an XAPO cannot be locked again until

          //  UnLockForProcess is called.

          //

          // PARAMETERS:

          //  InputLockedParameterCount  - [in] number of input buffers, must be within [XAPO_REGISTRATION_PROPERTIES.MinInputBufferCount, XAPO_REGISTRATION_PROPERTIES.MaxInputBufferCount]

          //  pInputLockedParameters     - [in] array of input locked buffer parameter structures, may be NULL if InputLockedParameterCount == 0, otherwise must have InputLockedParameterCount elements

          //  OutputLockedParameterCount - [in] number of output buffers, must be within [XAPO_REGISTRATION_PROPERTIES.MinOutputBufferCount, XAPO_REGISTRATION_PROPERTIES.MaxOutputBufferCount], must match InputLockedParameterCount when XAPO_FLAG_BUFFERCOUNT_MUST_MATCH used

          //  pOutputLockedParameters    - [in] array of output locked buffer parameter structures, may be NULL if OutputLockedParameterCount == 0, otherwise must have OutputLockedParameterCount elements

          //

          // RETURN VALUE:

          //  COM error code

          ////

        STDMETHOD(LockForProcess) (THIS_ UINT32 InputLockedParameterCount, __in_ecount_opt(InputLockedParameterCount) const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pInputLockedParameters, UINT32 OutputLockedParameterCount, __in_ecount_opt(OutputLockedParameterCount) const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pOutputLockedParameters) PURE;

 

          ////

          // DESCRIPTION:

          //  Opposite of LockForProcess.  Variables allocated during

          //  LockForProcess should be deallocated by this method.

          //

          // REMARKS:

          //  Unlocking an XAPO allows an XAPO instance to be reused with

          //  different input/output configurations.

          //

          // PARAMETERS:

          //  void

          //

          // RETURN VALUE:

          //  void

          ////

        STDMETHOD_(void, UnlockForProcess) (THIS) PURE;

 

          ////

          // DESCRIPTION:

          //  Runs the XAPO's DSP code on the given input/output buffers.

          //

          // REMARKS:

          //  In addition to writing to the output buffers as appropriate,

          //  an XAPO must set the BufferFlags and ValidFrameCount members

          //  of all elements in pOutputProcessParameters accordingly.

          //

          //  ppInputProcessParameters will not necessarily be the same as

          //  ppOutputProcessParameters for in-place processing, rather

          //  the pBuffer members of each will point to the same memory.

          //

          //  Multiple input/output buffers may be used with in-place XAPOs,

          //  though the input buffer count must equal the output buffer count.

          //  When multiple input/output buffers are used with in-place XAPOs,

          //  the XAPO may assume input buffer [N] equals output buffer [N].

          //

          //  When IsEnabled is FALSE, the XAPO should process thru.

          //  Thru processing means an XAPO should not apply its normal

          //  processing to the given input/output buffers during Process.

          //  It should instead pass data from input to output with as little

          //  modification possible.  Effects that perform format conversion

          //  should continue to do so.  The effect must ensure transitions

          //  between normal and thru processing do not introduce

          //  discontinuities into the signal.

          //

          //  XAudio2 calls this method only if the XAPO is locked.

          //  This method should not block as it is called from the

          //  realtime thread.

          //

          // PARAMETERS:

          //  InputProcessParameterCount  - [in]     number of input buffers, matches respective InputLockedParameterCount parameter given to LockForProcess

          //  pInputProcessParameters     - [in]     array of input process buffer parameter structures, may be NULL if InputProcessParameterCount == 0, otherwise must have InputProcessParameterCount elements

          //  OutputProcessParameterCount - [in]     number of output buffers, matches respective OutputLockedParameterCount parameter given to LockForProcess

          //  pOutputProcessParameters    - [in/out] array of output process buffer parameter structures, may be NULL if OutputProcessParameterCount == 0, otherwise must have OutputProcessParameterCount elements

          //  IsEnabled                   - [in]     TRUE to process normally, FALSE to process thru

          //

          // RETURN VALUE:

          //  void

          ////

        STDMETHOD_(void, Process) (THIS_ UINT32 InputProcessParameterCount, __in_ecount_opt(InputProcessParameterCount) const XAPO_PROCESS_BUFFER_PARAMETERS* pInputProcessParameters, UINT32 OutputProcessParameterCount, __inout_ecount_opt(OutputProcessParameterCount) XAPO_PROCESS_BUFFER_PARAMETERS* pOutputProcessParameters, BOOL IsEnabled) PURE;

 

          ////

          // DESCRIPTION:

          //  Returns the number of input frames required to generate the

          //  requested number of output frames.

          //

          // REMARKS:

          //  XAudio2 may call this method to determine how many input frames

          //  an XAPO requires.  This is constant for locked CBR XAPOs;

          //  this method need only be called once while an XAPO is locked.

          //

          //  XAudio2 calls this method only if the XAPO is locked.

          //  This method should not block as it is called from the

          //  realtime thread.

          //

          // PARAMETERS:

          //  OutputFrameCount - [in] requested number of output frames, must be within respective [0, XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.MaxFrameCount], always XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.MaxFrameCount for CBR/user-defined XAPOs

          //

          // RETURN VALUE:

          //  number of input frames required

          ////

        STDMETHOD_(UINT32, CalcInputFrames) (THIS_ UINT32 OutputFrameCount) PURE;

 

          ////

          // DESCRIPTION:

          //  Returns the number of output frames generated for the

          //  requested number of input frames.

          //

          // REMARKS:

          //  XAudio2 may call this method to determine how many output frames

          //  an XAPO will generate.  This is constant for locked CBR XAPOs;

          //  this method need only be called once while an XAPO is locked.

          //

          //  XAudio2 calls this method only if the XAPO is locked.

          //  This method should not block as it is called from the

          //  realtime thread.

          //

          // PARAMETERS:

          //  InputFrameCount - [in] requested number of input frames, must be within respective [0, XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.MaxFrameCount], always XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS.MaxFrameCount for CBR/user-defined XAPOs

          //

          // RETURN VALUE:

          //  number of output frames generated

          ////

        STDMETHOD_(UINT32, CalcOutputFrames) (THIS_ UINT32 InputFrameCount) PURE;

    };

 

 

 

    // IXAPOParameters:

    // Optional XAPO COM interface that allows an XAPO to use

    // effect-specific parameters.

    #undef INTERFACE

    #define INTERFACE IXAPOParameters

    DECLARE_INTERFACE_(IXAPOParameters, IUnknown) {

          ////

          // DESCRIPTION:

          //  Sets effect-specific parameters.

          //

          // REMARKS:

          //  This method may only be called on the realtime thread;

          //  no synchronization between it and IXAPO::Process is necessary.

          //

          //  This method should not block as it is called from the

          //  realtime thread.

          //

          // PARAMETERS:

          //  pParameters       - [in] effect-specific parameter block, must be != NULL

          //  ParameterByteSize - [in] size of pParameters in bytes, must be > 0

          //

          // RETURN VALUE:

          //  void

          ////

        STDMETHOD_(void, SetParameters) (THIS_ __in_bcount(ParameterByteSize) const void* pParameters, UINT32 ParameterByteSize) PURE;

 

          ////

          // DESCRIPTION:

          //  Gets effect-specific parameters.

          //

          // REMARKS:

          //  Unlike SetParameters, XAudio2 does not call this method on the

          //  realtime thread.  Thus, the XAPO must protect variables shared

          //  with SetParameters/Process using appropriate synchronization.

          //

          // PARAMETERS:

          //  pParameters       - [out] receives effect-specific parameter block, must be != NULL

          //  ParameterByteSize - [in]  size of pParameters in bytes, must be > 0

          //

          // RETURN VALUE:

          //  void

          ////

        STDMETHOD_(void, GetParameters) (THIS_ __out_bcount(ParameterByteSize) void* pParameters, UINT32 ParameterByteSize) PURE;

    };

 

 

    // macros to allow XAPO interfaces to be used in C code

    #if !defined(__cplusplus)

        // IXAPO

        #define IXAPO_QueryInterface(This, riid, ppInterface) \

 

        #define IXAPO_AddRef(This) \

 

        #define IXAPO_Release(This) \

 

        #define IXAPO_GetRegistrationProperties(This, ppRegistrationProperties) \

 

        #define IXAPO_IsInputFormatSupported(This, pOutputFormat, pRequestedInputFormat, ppSupportedInputFormat) \

 

        #define IXAPO_IsOutputFormatSupported(This, pInputFormat, pRequestedOutputFormat, ppSupportedOutputFormat) \

 

        #define IXAPO_Initialize(This, pData, DataByteSize) \

 

        #define IXAPO_Reset(This) \

 

        #define IXAPO_LockForProcess(This, InputLockedParameterCount, pInputLockedParameters, OutputLockedParameterCount, pOutputLockedParameters) \

 

        #define IXAPO_UnlockForProcess(This) \

 

        #define IXAPO_Process(This, InputProcessParameterCount, pInputProcessParameters, OutputProcessParameterCount, pOutputProcessParameters, IsEnabled) \

 

        #define IXAPO_CalcInputFrames(This, OutputFrameCount) \

 

        #define IXAPO_CalcOutputFrames(This, InputFrameCount) \

 

 

        // IXAPOParameters

        #define IXAPOParameters_QueryInterface(This, riid, ppInterface) \

 

        #define IXAPOParameters_AddRef(This) \

 

        #define IXAPOParameters_Release(This) \

 

        #define IXAPOParameters_SetParameters(This, pParameters, ParameterByteSize) \

 

        #define IXAPOParameters_GetParameters(This, pParameters, ParameterByteSize) \

    #endif // !defined(__cplusplus)

 

 

    #pragma pack(pop) // revert packing alignment