New SDCAVAD sample.

1 files changed, 808 insertions, 0 deletions

diff --git a/audio/SoundWire/Samples/SdcaVad/SdcaVCodec/device.cpp b/audio/SoundWire/Samples/SdcaVad/SdcaVCodec/device.cpp
new file mode 100644
index 00000000..e4805669
--- /dev/null
+++ b/audio/SoundWire/Samples/SdcaVad/SdcaVCodec/device.cpp
@@ -0,0 +1,808 @@
+/*++
+
+    THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
+    KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
+    PURPOSE.
+
+Module Name:
+
+    Device.cpp
+
+Abstract:
+
+    Plug and Play module. This file contains routines to handle pnp requests.
+
+Environment:
+
+    Kernel mode
+
+--*/
+
+#include "private.h"
+#include <devguid.h>
+#include "stdunk.h"
+#include <ks.h>
+#include <mmsystem.h>
+#include <ksmedia.h>
+#include "streamengine.h"
+#include "CircuitHelper.h"
+
+#ifndef __INTELLISENSE__
+#include "device.tmh"
+#endif
+
+UNICODE_STRING g_RegistryPath = {0};      // This is used to store the registry settings path for the driver
+
+__drv_requiresIRQL(PASSIVE_LEVEL)
+PAGED_CODE_SEG
+NTSTATUS CopyRegistrySettingsPath
+(
+    _In_ PUNICODE_STRING RegistryPath
+)
+/*++
+
+Routine Description:
+
+Copies the following registry path to a global variable.
+
+\REGISTRY\MACHINE\SYSTEM\ControlSetxxx\Services\<driver>\Parameters
+
+Arguments:
+
+RegistryPath - Registry path passed to DriverEntry
+
+Returns:
+
+NTSTATUS - SUCCESS if able to configure the framework
+
+--*/
+
+{
+    PAGED_CODE();
+
+    // Initializing the unicode string, so that if it is not allocated it will not be deallocated too.
+    RtlInitUnicodeString(&g_RegistryPath, NULL);
+
+    g_RegistryPath.MaximumLength = RegistryPath->Length + sizeof(WCHAR);
+
+    g_RegistryPath.Buffer = (PWCH)ExAllocatePool2(POOL_FLAG_PAGED, g_RegistryPath.MaximumLength, DRIVER_TAG);
+
+    if (g_RegistryPath.Buffer == NULL)
+    {
+        return STATUS_INSUFFICIENT_RESOURCES;
+    }
+
+    // ExAllocatePool2 zeros memory.
+
+    RtlAppendUnicodeToString(&g_RegistryPath, RegistryPath->Buffer);
+
+    return STATUS_SUCCESS;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+Codec_EvtBusDeviceAdd(
+    _In_    WDFDRIVER        Driver,
+    _Inout_ PWDFDEVICE_INIT  DeviceInit
+    )
+/*++
+Routine Description:
+
+    EvtDeviceAdd is called by the framework in response to AddDevice
+    call from the PnP manager. We create and initialize a device object to
+    represent a new instance of the device. All the software resources
+    should be allocated in this callback.
+
+Arguments:
+
+    Driver - Handle to a framework driver object created in DriverEntry
+
+    DeviceInit - Pointer to a framework-allocated WDFDEVICE_INIT structure.
+
+Return Value:
+
+    NTSTATUS
+
+--*/
+{
+    PAGED_CODE();
+
+    NTSTATUS status = STATUS_SUCCESS;
+
+    //
+    // Allow ACX to add any pre-requirement it needs on this device.
+    //
+    ACX_DEVICEINIT_CONFIG devInitCfg;
+    ACX_DEVICEINIT_CONFIG_INIT(&devInitCfg);
+    RETURN_NTSTATUS_IF_FAILED(AcxDeviceInitInitialize(DeviceInit, &devInitCfg));
+    
+    //
+    // Initialize the pnpPowerCallbacks structure.  Callback events for PNP
+    // and Power are specified here.  If you don't supply any callbacks,
+    // the Framework will take appropriate default actions based on whether
+    // DeviceInit is initialized to be an FDO, a PDO or a filter device
+    // object.
+    //
+    WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
+    WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
+    pnpPowerCallbacks.EvtDevicePrepareHardware = Codec_EvtDevicePrepareHardware;
+    pnpPowerCallbacks.EvtDeviceReleaseHardware = Codec_EvtDeviceReleaseHardware;
+    WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
+
+    //
+    // Specify the type of context needed. 
+    // Use default locking, i.e., none.
+    //
+    WDF_OBJECT_ATTRIBUTES attributes;
+    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, CODEC_DEVICE_CONTEXT);
+    attributes.EvtCleanupCallback = Codec_EvtDeviceContextCleanup;
+    
+    //
+    // Create the device.
+    //
+    WDFDEVICE device = NULL;
+    RETURN_NTSTATUS_IF_FAILED(WdfDeviceCreate(&DeviceInit, &attributes, &device));
+
+    //
+    // Init Codec's device context.
+    //
+    PCODEC_DEVICE_CONTEXT devCtx;
+    devCtx = GetCodecDeviceContext(device);
+    ASSERT(devCtx != NULL);
+    devCtx->Render = NULL;
+    devCtx->Capture = NULL;
+
+    //
+    // Assume XU lower filter driver is not present
+    //
+    devCtx->SdcaXuData.bSdcaXu = FALSE;
+    
+    //
+    // Allow ACX to add any post-requirement it needs on this device.
+    //
+    ACX_DEVICE_CONFIG devCfg;
+    ACX_DEVICE_CONFIG_INIT(&devCfg);
+    RETURN_NTSTATUS_IF_FAILED(AcxDeviceInitialize(device, &devCfg));
+
+    //
+    // Tell the framework to set the SurpriseRemovalOK in the DeviceCaps so
+    // that you don't get the popup in usermode (on Win2K) when you surprise
+    // remove the device.
+    //
+    WDF_DEVICE_PNP_CAPABILITIES pnpCaps;
+    WDF_DEVICE_PNP_CAPABILITIES_INIT(&pnpCaps);
+    pnpCaps.SurpriseRemovalOK = WdfTrue;
+    WdfDeviceSetPnpCapabilities(device, &pnpCaps);
+
+    //
+    // Get SDCA XU filter interface
+    //
+    RETURN_NTSTATUS_IF_FAILED_UNLESS_ALLOWED(Codec_GetSdcaXu(device), STATUS_NOT_SUPPORTED);
+
+    if (devCtx->SdcaXuData.bSdcaXu)
+    {
+        RETURN_NTSTATUS_IF_FAILED(Codec_SetSdcaXuHwConfig(device));
+    }
+
+    RETURN_NTSTATUS_IF_FAILED(Codec_AddRenderComposites(device));
+
+    RETURN_NTSTATUS_IF_FAILED(Codec_AddCaptureComposites(device));
+
+    //
+    // Add a render device and a capture device. 
+    //
+    RETURN_NTSTATUS_IF_FAILED(CodecR_AddRenders(Driver, device));
+
+    //
+    // Add a render device and a capture device. 
+    //
+    RETURN_NTSTATUS_IF_FAILED(CodecC_AddCaptures(Driver, device));
+
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+Codec_EvtDevicePrepareHardware(
+    _In_ WDFDEVICE      Device,
+    _In_ WDFCMRESLIST   ResourceList,
+    _In_ WDFCMRESLIST   ResourceListTranslated
+)
+/*++
+
+Routine Description:
+
+    In this callback, the driver does whatever is necessary to make the
+    hardware ready to use.  
+
+Arguments:
+
+    Device - handle to a device
+
+Return Value:
+
+    NT status value
+
+--*/
+{
+    
+    UNREFERENCED_PARAMETER(ResourceList);
+    UNREFERENCED_PARAMETER(ResourceListTranslated);
+
+    PAGED_CODE();
+
+    DrvLogEnter(g_SDCAVCodecLog);
+
+    NTSTATUS status = STATUS_SUCCESS;
+    
+    PCODEC_DEVICE_CONTEXT devCtx;
+    devCtx = GetCodecDeviceContext(Device);
+    ASSERT(devCtx != NULL);
+
+
+    RETURN_NTSTATUS_IF_FAILED(Codec_SetPowerPolicy(Device));
+    
+    //
+    // Add static circuit to device's list.
+    //
+    ASSERT(devCtx->Render);
+    RETURN_NTSTATUS_IF_FAILED(AcxDeviceAddCircuit(Device, devCtx->Render));
+
+    ASSERT(devCtx->Capture);
+    RETURN_NTSTATUS_IF_FAILED(AcxDeviceAddCircuit(Device, devCtx->Capture));
+    
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+Codec_EvtDeviceReleaseHardware(
+    _In_ WDFDEVICE      Device,
+    _In_ WDFCMRESLIST   ResourceListTranslated
+)
+/*++
+
+Routine Description:
+
+    In this callback, the driver releases the h/w resources allocated in the 
+    prepare h/w callback.
+
+Arguments:
+
+    Device - handle to a device
+
+Return Value:
+
+    NT status value
+
+--*/
+{
+    PAGED_CODE();
+
+    NTSTATUS status = STATUS_SUCCESS;
+
+    UNREFERENCED_PARAMETER(Device);
+    UNREFERENCED_PARAMETER(ResourceListTranslated);
+
+    PCODEC_DEVICE_CONTEXT devCtx;
+    devCtx = GetCodecDeviceContext(Device);
+    ASSERT(devCtx != NULL);
+
+    
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+Codec_SetPowerPolicy(
+    _In_ WDFDEVICE      Device
+)
+{
+    PAGED_CODE();
+
+    NTSTATUS status = STATUS_SUCCESS;
+
+    DrvLogEnter(g_SDCAVCodecLog);
+
+    WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS idleSettings;
+    //WDF_DEVICE_POWER_POLICY_WAKE_SETTINGS wakeSettings;
+
+    //
+    // Init the idle policy structure.
+    //
+    //WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_INIT(&idleSettings, IdleCanWakeFromS0);
+    WDF_DEVICE_POWER_POLICY_IDLE_SETTINGS_INIT(&idleSettings, IdleCannotWakeFromS0);
+    idleSettings.IdleTimeout = 10000; // 10-sec
+
+    RETURN_NTSTATUS_IF_FAILED(WdfDeviceAssignS0IdleSettings(Device, &idleSettings));
+
+    return status;
+}
+
+#pragma code_seg()
+
+DEFINE_GUID(CODEC_CIRCUIT_RENDER_GUID, 
+0xfd4b6e78, 0x51e0, 0x4aa6, 0x90, 0x98, 0xbb, 0xcb, 0x70, 0x89, 0xcb, 0x6a);
+
+DEFINE_GUID(EXTENSION_CIRCUIT_RENDER_GUID, 
+0x656ab905, 0x55fb, 0x4b08, 0xb6, 0x01, 0xd7, 0xf0, 0xc1, 0xce, 0x36, 0x2c);
+
+// {17F5B19F-C2C7-4B53-AFB9-49A0283D0DCE}
+DEFINE_GUID(DSP_CIRCUIT_SPEAKER_GUID,
+    0x17f5b19f, 0xc2c7, 0x4b53, 0xaf, 0xb9, 0x49, 0xa0, 0x28, 0x3d, 0xd, 0xce);
+
+DEFINE_GUID(CODEC_CIRCUIT_CAPTURE_GUID,
+0x67ec5936, 0xa395, 0x4e93, 0xbe, 0x8a, 0xfc, 0xed, 0xe3, 0x1b, 0xad, 0x40);
+
+DEFINE_GUID(EXTENSION_CIRCUIT_CAPTURE_GUID,
+0x44c69385, 0xa012, 0x405f, 0x8a, 0x9a, 0x7b, 0x44, 0x29, 0x71, 0xc8, 0x50);
+
+// {6F9EACF7-CD2D-4030-9E49-7CC4ADEFF192}
+DEFINE_GUID(DSP_CIRCUIT_MICROPHONE_GUID,
+    0x6f9eacf7, 0xcd2d, 0x4030, 0x9e, 0x49, 0x7c, 0xc4, 0xad, 0xef, 0xf1, 0x92);
+
+DEFINE_GUID(SYSTEM_CONTAINER_GUID,
+0x00000000, 0x0000, 0x0000, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
+
+
+#define DSP_FACTORY_URI L"acpi:obj-path:\\_SB.PC00.HDAS"
+
+#define RENDER_CIRCUIT_UNIQUE_ID L"{613fd364-64bb-4b69-99bc-5b075ea9756b}"
+#define RENDER_CIRCUIT_FRIENDLY_NAME L"Speaker-360"
+#define RENDER_CIRCUIT_NAME L"Speaker"
+#define CAPTURE_CIRCUIT_UNIQUE_ID L"{3A509246-5902-4AA2-9E06-C7C8D10461C3}"
+#define CAPTURE_CIRCUIT_FRIENDLY_NAME L"Microphone-360"
+#define CAPTURE_CIRCUIT_NAME L"Microphone"
+
+#define CIRCUIT_RENDER_VENDOR_BLOB "Streaming_Speaker"
+#define CIRCUIT_CAPTURE_VENDOR_BLOB "Streaming_MicrophoneArray"
+
+__drv_requiresIRQL(PASSIVE_LEVEL)
+PAGED_CODE_SEG
+NTSTATUS 
+Codec_AddRenderComposites(_In_ WDFDEVICE Device)
+{
+    NTSTATUS status = STATUS_SUCCESS;
+
+    UNREFERENCED_PARAMETER(Device);
+
+    PAGED_CODE();
+
+    RETURN_NTSTATUS_IF_FAILED(Codec_AddComposites(Device, CompositeType_RENDER));
+
+    return status;
+}
+
+__drv_requiresIRQL(PASSIVE_LEVEL)
+PAGED_CODE_SEG
+NTSTATUS 
+Codec_AddCaptureComposites(_In_ WDFDEVICE Device)
+{
+    NTSTATUS status = STATUS_SUCCESS;
+
+    UNREFERENCED_PARAMETER(Device);
+
+    PAGED_CODE();
+
+    RETURN_NTSTATUS_IF_FAILED(Codec_AddComposites(Device, CompositeType_CAPTURE));
+
+    return status;
+}
+
+__drv_requiresIRQL(PASSIVE_LEVEL)
+PAGED_CODE_SEG
+NTSTATUS 
+Codec_AddComposites(_In_ WDFDEVICE Device, _In_ CompositeType compositeType)
+{
+    PAGED_CODE(); 
+
+    NTSTATUS status = STATUS_SUCCESS;
+
+    DrvLogEnter(g_SDCAVCodecLog);
+
+    UNICODE_STRING circuit_IDs[] = {
+        { sizeof(RENDER_CIRCUIT_UNIQUE_ID) - sizeof(WCHAR), sizeof(RENDER_CIRCUIT_UNIQUE_ID), RENDER_CIRCUIT_UNIQUE_ID },
+        { sizeof(CAPTURE_CIRCUIT_UNIQUE_ID) - sizeof(WCHAR), sizeof(CAPTURE_CIRCUIT_UNIQUE_ID), CAPTURE_CIRCUIT_UNIQUE_ID}
+    };
+
+    UNICODE_STRING circuit_friendly_names[] = {
+        { sizeof(RENDER_CIRCUIT_FRIENDLY_NAME) - sizeof(WCHAR), sizeof(RENDER_CIRCUIT_FRIENDLY_NAME), RENDER_CIRCUIT_FRIENDLY_NAME },
+        { sizeof(CAPTURE_CIRCUIT_FRIENDLY_NAME) - sizeof(WCHAR), sizeof(CAPTURE_CIRCUIT_FRIENDLY_NAME), CAPTURE_CIRCUIT_FRIENDLY_NAME}
+    };
+
+    UNICODE_STRING circuit_names[] = {
+        { sizeof(RENDER_CIRCUIT_NAME) - sizeof(WCHAR), sizeof(RENDER_CIRCUIT_NAME), RENDER_CIRCUIT_NAME },
+        { sizeof(CAPTURE_CIRCUIT_NAME) - sizeof(WCHAR), sizeof(CAPTURE_CIRCUIT_NAME), CAPTURE_CIRCUIT_NAME}
+    };
+
+    UNICODE_STRING codec_circuit_uris[] = {
+        { sizeof(RENDER_CIRCUIT_URI) - sizeof(WCHAR), sizeof(RENDER_CIRCUIT_URI), RENDER_CIRCUIT_URI },
+        { sizeof(CAPTURE_CIRCUIT_URI) - sizeof(WCHAR), sizeof(CAPTURE_CIRCUIT_URI), CAPTURE_CIRCUIT_URI}
+    };
+
+    UNICODE_STRING extension_circuit_uris[] = {
+        { sizeof(EXT_RENDER_CIRCUIT_URI) - sizeof(WCHAR), sizeof(EXT_RENDER_CIRCUIT_URI), EXT_RENDER_CIRCUIT_URI },
+        { sizeof(EXT_CAPTURE_CIRCUIT_URI) - sizeof(WCHAR), sizeof(EXT_CAPTURE_CIRCUIT_URI), EXT_CAPTURE_CIRCUIT_URI}
+    };
+
+    GUID dsp_circuit_guids[] = {
+        DSP_CIRCUIT_SPEAKER_GUID,
+        DSP_CIRCUIT_MICROPHONE_GUID
+    };
+
+    UNICODE_STRING dsp_factory_uris[] = {
+        { sizeof(DSP_FACTORY_URI) - sizeof(WCHAR), sizeof(DSP_FACTORY_URI), DSP_FACTORY_URI },
+        { sizeof(DSP_FACTORY_URI) - sizeof(WCHAR), sizeof(DSP_FACTORY_URI), DSP_FACTORY_URI}
+    };
+
+    const char* dsp_factory_vendor_blobs[] = {
+        CIRCUIT_RENDER_VENDOR_BLOB,
+        CIRCUIT_CAPTURE_VENDOR_BLOB
+    };
+
+    PCODEC_DEVICE_CONTEXT deviceCtx = NULL;
+    deviceCtx = GetCodecDeviceContext(Device);
+    ASSERT(deviceCtx);
+
+    //
+    // May be called again for rebalance
+    // Add composites only once
+    //
+    RETURN_NTSTATUS_IF_TRUE(0 != deviceCtx->refComposite[compositeType], STATUS_SUCCESS);
+
+    //
+    // Object bag
+    //
+    // This obj-bag config setting is shared by all composite/circuit templates.
+    ACX_OBJECTBAG_CONFIG objBagCfg;
+    ACX_OBJECTBAG_CONFIG_INIT(&objBagCfg);
+
+    WDF_OBJECT_ATTRIBUTES attributes;
+    WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
+    attributes.ParentObject = AcxGetManager(NULL);
+
+    ACXOBJECTBAG objBag = NULL;
+    RETURN_NTSTATUS_IF_FAILED(AcxObjectBagCreate(&attributes, &objBagCfg, &objBag));
+    auto objBag_scope = scope_exit([&objBag]() {
+        if (objBag != NULL)
+        {
+            WdfObjectDelete(objBag);
+        }
+    });
+
+    //
+    // Add a test unsigned int 4 bytes to the object bag
+    //
+    RETURN_NTSTATUS_IF_FAILED(ObjBagAddTestUI4(objBag, 0));
+
+    //
+    // Add unique circuit ID to the object bag
+    // This unique Id will be picked up by DSP circuit
+    //
+    DECLARE_CONST_ACXOBJECTBAG_SYSTEM_PROPERTY_NAME(UniqueID);
+    GUID uniqueID = { 0 };
+    RETURN_NTSTATUS_IF_FAILED(RtlGUIDFromString(&circuit_IDs[compositeType], &uniqueID));
+
+    RETURN_NTSTATUS_IF_FAILED(AcxObjectBagAddGuid(objBag, &UniqueID, uniqueID));
+
+    RETURN_NTSTATUS_IF_FAILED(ObjBagAddUnicodeStrings(objBag, circuit_friendly_names[compositeType], circuit_names[compositeType]));
+
+    RETURN_NTSTATUS_IF_FAILED(ObjBagAddEndpointId(objBag, 9));
+
+    RETURN_NTSTATUS_IF_FAILED(ObjBagAddDataPortNumber(objBag, 9));
+
+    //
+    // Composite template.
+    //
+    ULONG circuitsInTemplate = 0;
+    ACXCIRCUITTEMPLATE circuits[3] = { 0 };
+    ACX_COMPOSITE_TEMPLATE_CONFIG compositeCfg;
+    ACX_COMPOSITE_TEMPLATE_CONFIG_INIT(&compositeCfg);
+    compositeCfg.Properties = objBag;
+    compositeCfg.Flags |= AcxCompositeTemplateConfigSingleton;
+
+    ACXCOMPOSITETEMPLATE composite = NULL;
+    RETURN_NTSTATUS_IF_FAILED(AcxCompositeTemplateCreate(WdfGetDriver(),
+        &attributes,
+        &compositeCfg,
+        &composite));
+
+    auto composite_scope = scope_exit([&composite]() {
+        WdfObjectDelete(composite);
+        composite = NULL;
+        });
+
+    objBag = NULL;
+
+    // This attribute setting is shared by all the circuit templates.
+    WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
+    attributes.ParentObject = composite;
+
+    // Codec template.
+    RETURN_NTSTATUS_IF_FAILED(AcxObjectBagCreate(&attributes, &objBagCfg, &objBag));
+
+    RETURN_NTSTATUS_IF_FAILED(ObjBagAddTestUI4(objBag, 2));
+
+    ACX_CIRCUIT_TEMPLATE_CONFIG circuitCfg1;
+    ACX_CIRCUIT_TEMPLATE_CONFIG_INIT(&circuitCfg1);
+    circuitCfg1.CircuitProperties = objBag;
+    circuitCfg1.CircuitUri = &codec_circuit_uris[compositeType];
+
+    ULONG codecIndex = circuitsInTemplate;
+    RETURN_NTSTATUS_IF_FAILED(AcxCircuitTemplateCreate(WdfGetDriver(),
+        &attributes,
+        &circuitCfg1,
+        &circuits[circuitsInTemplate++]));
+
+    objBag = NULL;
+
+    // XU template.
+    //
+    // Check if XU is present
+    // and compose with Xu circuit
+    //
+    if (deviceCtx->SdcaXuData.bSdcaXu)
+    {
+        RETURN_NTSTATUS_IF_FAILED(AcxObjectBagCreate(&attributes, &objBagCfg, &objBag));
+
+        RETURN_NTSTATUS_IF_FAILED(ObjBagAddTestUI4(objBag, 2));
+
+        ACX_CIRCUIT_TEMPLATE_CONFIG circuitCfg2;
+        ACX_CIRCUIT_TEMPLATE_CONFIG_INIT(&circuitCfg2);
+        circuitCfg2.CircuitProperties = objBag;
+        circuitCfg2.CircuitUri = &extension_circuit_uris[compositeType];
+
+        RETURN_NTSTATUS_IF_FAILED(AcxCircuitTemplateCreate(WdfGetDriver(),
+            &attributes,
+            &circuitCfg2,
+            &circuits[circuitsInTemplate++]));
+
+        objBag = NULL;
+    }
+
+    // Dsp template.
+    RETURN_NTSTATUS_IF_FAILED(AcxObjectBagCreate(&attributes, &objBagCfg, &objBag));
+
+    RETURN_NTSTATUS_IF_FAILED(ObjBagAddTestUI4(objBag, 3));
+
+    RETURN_NTSTATUS_IF_FAILED(ObjBagAddCircuitId(objBag, dsp_circuit_guids[compositeType]));
+
+    RETURN_NTSTATUS_IF_FAILED(ObjBagAddBlob(objBag, dsp_factory_vendor_blobs[compositeType]));
+
+    ACX_CIRCUIT_TEMPLATE_CONFIG circuitCfg3;
+    ACX_CIRCUIT_TEMPLATE_CONFIG_INIT(&circuitCfg3);
+    circuitCfg3.CircuitProperties = objBag;
+    circuitCfg3.FactoryUri = &dsp_factory_uris[compositeType];
+    circuitCfg3.Flags |= AcxCircuitTemplateCircuitOnDemand;
+
+    RETURN_NTSTATUS_IF_FAILED(AcxCircuitTemplateCreate(WdfGetDriver(),
+        &attributes,
+        &circuitCfg3,
+        &circuits[circuitsInTemplate++]));
+
+    objBag = NULL;
+    objBag_scope.release();
+
+    RETURN_NTSTATUS_IF_FAILED(AcxCompositeTemplateAssignCircuits(composite, circuits, circuitsInTemplate));
+
+    // Select the core circuit.
+    AcxCompositeTemplateSetCoreCircuit(composite, circuits[codecIndex]);
+
+    // Final step.                                              
+    RETURN_NTSTATUS_IF_FAILED(AcxManagerAddCompositeTemplate(AcxGetManager(NULL), composite));
+
+    deviceCtx->Composite[compositeType] = composite;
+    composite_scope.release();
+
+    deviceCtx->refComposite[compositeType]++;
+    
+    return status;
+}
+
+#pragma code_seg()
+NTSTATUS 
+Codec_RemoveComposites(_In_ WDFDEVICE Device)
+{
+    NTSTATUS status = STATUS_SUCCESS;
+
+    PCODEC_DEVICE_CONTEXT deviceCtx = NULL;
+    deviceCtx = GetCodecDeviceContext(Device);
+    ASSERT(deviceCtx);
+
+    for (ULONG compositeType = CompositeType_RENDER; compositeType <= CompositeType_CAPTURE; )
+    {
+        if (deviceCtx->refComposite[compositeType])
+        {
+            deviceCtx->refComposite[compositeType]--;
+            if (deviceCtx->refComposite[compositeType] == 0)
+            {
+                if (deviceCtx->Composite[compositeType] != NULL)
+                {
+                    RETURN_NTSTATUS_IF_FAILED(AcxManagerRemoveCompositeTemplate(AcxGetManager(NULL), deviceCtx->Composite[compositeType]));
+
+                    WdfObjectDelete(deviceCtx->Composite[compositeType]);
+                    deviceCtx->Composite[compositeType] = NULL;
+                }
+            }
+        }
+
+        compositeType++;
+    }
+    
+    return status;
+}
+
+#pragma code_seg()
+VOID
+Codec_EvtDeviceContextCleanup(
+    _In_ WDFOBJECT      WdfDevice
+   )
+/*++
+
+Routine Description:
+
+    In this callback, it cleans up device context.
+
+Arguments:
+
+    WdfDevice - WDF device object
+
+Return Value:
+
+    NULL
+
+--*/
+{
+    WDFDEVICE               device;
+    PCODEC_DEVICE_CONTEXT   devCtx;
+
+
+    device = (WDFDEVICE)WdfDevice;
+    devCtx = GetCodecDeviceContext(device);
+    ASSERT(devCtx != NULL);
+    
+    Codec_RemoveComposites(device);
+
+    if (devCtx->SdcaXuData.XUEntities)
+    {
+        ExFreePoolWithTag(devCtx->SdcaXuData.XUEntities, DRIVER_TAG);
+        devCtx->SdcaXuData.numXUEntities = 0;
+    }
+    if (devCtx->SdcaXuData.InterruptInfo)
+    {
+        ExFreePoolWithTag(devCtx->SdcaXuData.InterruptInfo, DRIVER_TAG);
+        devCtx->SdcaXuData.InterruptInfo = NULL;
+    }
+}
+
+#pragma code_seg()
+VOID
+Codec_EvtStreamDestroy(
+    _In_ WDFOBJECT Object
+    )
+{
+    PCODEC_STREAM_CONTEXT ctx;
+    CStreamEngine * streamEngine = NULL;
+
+    ctx = GetCodecStreamContext((ACXSTREAM)Object);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+    ctx->StreamEngine = NULL;
+    delete streamEngine;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+Codec_EvtStreamGetHwLatency(
+    _In_ ACXSTREAM Stream,
+    _Out_ ULONG * FifoSize,
+    _Out_ ULONG * Delay
+)
+{
+    PCODEC_STREAM_CONTEXT ctx;
+    CStreamEngine * streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetCodecStreamContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->GetHWLatency(FifoSize, Delay);
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+Codec_EvtStreamPrepareHardware(
+    _In_ ACXSTREAM Stream
+    )
+{
+    PCODEC_STREAM_CONTEXT ctx;
+    CStreamEngine * streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetCodecStreamContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->PrepareHardware();
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+Codec_EvtStreamReleaseHardware(
+    _In_ ACXSTREAM Stream
+    )
+{
+    PCODEC_STREAM_CONTEXT ctx;
+    CStreamEngine * streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetCodecStreamContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->ReleaseHardware();
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+Codec_EvtStreamRun(
+    _In_ ACXSTREAM Stream
+    )
+{
+    PCODEC_STREAM_CONTEXT ctx;
+    CStreamEngine * streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetCodecStreamContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->Run();
+}
+
+
+PAGED_CODE_SEG
+NTSTATUS
+Codec_EvtStreamPause(
+    _In_ ACXSTREAM Stream
+    )
+{
+    PCODEC_STREAM_CONTEXT ctx;
+    CStreamEngine * streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetCodecStreamContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->Pause();
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+Codec_EvtStreamAssignDrmContentId(
+    _In_ ACXSTREAM      Stream,
+    _In_ ULONG          DrmContentId,
+    _In_ PACXDRMRIGHTS  DrmRights
+    )
+{
+    PCODEC_STREAM_CONTEXT ctx;
+    CStreamEngine * streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetCodecStreamContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->AssignDrmContentId(DrmContentId, DrmRights);
+}
+
+