What's New In XACT

This document describes new features of this Microsoft Cross-Platform Audio Creation Tool (XACT) release.

New Features In This Release

Content Creation Updates

ADPCM Compression

You can now apply the ADPCM compression format in a compression preset. This will allow ADPCM compression of wave files as they are built into wave banks. For more information, see Compression Presets and ADPCM Compression.

Miscellaneous Updates

• You may now attach and detach RPCs and DSPs to sounds by right-clicking on either the sound or the RPC/DSP, selecting "Attach/Detach..." and manipulating the list that appears.
• An Update Source Path command has been added to wave banks to point XACT wave banks at new file locations in the event that wave files in a project are moved on disk.
• Play events now have a PlayRelease property that can sustain a stopped looping wave until completion of the current loop.
• Auditioning controls have been updated to allow for more specific Play and Stop controls.

Engine Updates

• The X3DAudio library now supports two output formats: Stereo and 5.1.
• The ChannelCount parameter of XACT3DApply has been removed.

New Features in Previous Releases

3D Audio

XACT now features X3DAudio functionality to provide calculation of 3D audio DSP effects. These effects can be calculated by calling the XACT3DCalculate function and applied to cues using the XACT3DApply function.

DSP Effect Presets

Digital Signal Processing (DSP) Presets are now available in XACT. Currently, only one preset type, Reverb, is available.

To get started using DSP Presets in your project, see XACT DSP Presets.

COM Support in XACT

The runtime XACT engine is now implemented as a COM object (IXACTEngine) with the CLSID CLSID_XACTEngine (defined in xact.h).

In addition, if the DirectX SDK is installed on a system, there is an auditioning version of the XACT engine available with the CLSID CLSID_XACTAuditionEngine.

Both COM objects provide a single public interface: IXACTEngine (defined in xact.h). There is no difference between the public interfaces provided by the two COM objects, and they can be used in exactly the same way by client code.

The XACT engine's COM support provides the following:

• Support for both COM threading models (apartment-threaded and multi-threaded).
• Support for defining the required COM GUIDs in any of the 3 usual ways: by including the xact.h header with the INITGUID macro defined, by linking the client program with a GUID library (XactGuids.lib), or by using the __uuidof keyword.
• Support for both C and C++ client code.
• Reference counting, which facilitates passing XACT engine pointers to different parts of the client code.
• Use of more than one instance of the runtime XACT engine (e.g. a game's menu system might use its own XACT engine object without interacting with the game's main XACT object).

The XACT engine's COM support is intentionally limited in the following ways:

• Only in-proc usage is supported. XACT is intended for use within a single process, so there is no marshalling of XACT method calls across process or machine boundaries.
• OLE automation is not supported; there is no type library and no support for the IDispatch interface.
• Only one instance of the auditioning version of the XACT engine can be created.

Using the XACT Engine COM Object

Here is sample code showing standard COM object creation:

#define _WIN32_DCOM
#include <windows.h>
#include <xact.h>
 
void main()
{
    IXACTEngine* pXact = NULL;
    XACT_RUNTIME_PARAMETERS xactParameters;
    // TODO: Set up xactParameters as desired
 
    HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); //you may also use COINIT_APARTMENTTHREADED
 
    if (SUCCEEDED(hr))
    {
        hr = CoCreateInstance(__uuidof(XACTEngine), NULL, CLSCTX_INPROC_SERVER, __uuidof(IXACTEngine), (void**)&pXact);
    }
 
    if (SUCCEEDED(hr))
    {
        hr = pXact->Initialize(&xactParameters);
    }
 
    // TODO: Call all top-level XACT functions via the pXact pointer
 
    if (pXact)
    {
        pXact->ShutDown();
        pXact->Release();
    }
 
    CoUninitialize();
}

Alternatively, you can use the XACTCreateEngine function to create an instance of the XACT engine. Regardless of the method you choose, you must call CoInitializeEx before attempting to create an instance of an IXACTEngine.