Merge develop changes prior to upcoming WDK release (May 2024)

21 files changed, 9373 insertions, 0 deletions

diff --git a/audio/Acx/Samples/Common/CaptureCircuit.cpp b/audio/Acx/Samples/Common/CaptureCircuit.cpp
new file mode 100644
index 00000000..ba205a90
--- /dev/null
+++ b/audio/Acx/Samples/Common/CaptureCircuit.cpp
@@ -0,0 +1,799 @@
+/*++
+
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+    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:
+
+    CaptureCircuit.cpp
+
+Abstract:
+
+    Capture Circuit. This file contains routines to create and handle
+    capture circuit.
+
+Environment:
+
+    Kernel mode
+
+--*/
+
+#include "private.h"
+#include "public.h"
+#include <ks.h>
+#include <mmsystem.h>
+#include <ksmedia.h>
+#include "AudioFormats.h"
+#include "streamengine.h"
+#include "cpp_utils.h"
+#include "circuithelper.h"
+
+#ifndef __INTELLISENSE__
+#include "captureCircuit.tmh"
+#endif
+
+//
+// Controls how the custom name of the bridge pin is read.
+//
+BOOL g_UseCustomInfName = TRUE;
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecC_EvtAcxPinSetDataFormat(
+    _In_    ACXPIN          Pin,
+    _In_    ACXDATAFORMAT   DataFormat
+)
+/*++
+
+Routine Description:
+
+    This ACX pin callback sets the device/mixed format.
+
+Return Value:
+
+    NTSTATUS
+
+--*/
+{
+    UNREFERENCED_PARAMETER(Pin);
+    UNREFERENCED_PARAMETER(DataFormat);
+
+    PAGED_CODE();
+
+    // NOTE: update device/mixed format here.
+
+    return STATUS_NOT_SUPPORTED;
+}
+
+///////////////////////////////////////////////////////////
+//
+// For more information on volume element see: https://docs.microsoft.com/en-us/windows-hardware/drivers/audio/ksnodetype-volume
+//
+_Use_decl_annotations_
+NTSTATUS
+CodecC_EvtVolumeAssignLevelCallback(
+    _In_    ACXVOLUME   Volume,
+    _In_    ULONG       Channel,
+    _In_    LONG        VolumeLevel
+)
+{
+    PAGED_CODE();
+
+    ASSERT(Volume);
+    PVOLUME_ELEMENT_CONTEXT volumeCtx = GetVolumeElementContext(Volume);
+    ASSERT(volumeCtx);
+
+    if (Channel != ALL_CHANNELS_ID)
+    {
+        volumeCtx->VolumeLevel[Channel] = VolumeLevel;
+    }
+    else
+    {
+        for (ULONG i = 0; i < MAX_CHANNELS; ++i)
+        {
+            volumeCtx->VolumeLevel[i] = VolumeLevel;
+        }
+    }
+
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+NTSTATUS
+CodecC_EvtVolumeRetrieveLevelCallback(
+    _In_    ACXVOLUME   Volume,
+    _In_    ULONG       Channel,
+    _Out_   LONG *      VolumeLevel
+)
+{
+    PAGED_CODE();
+
+    ASSERT(Volume);
+    PVOLUME_ELEMENT_CONTEXT volumeCtx = GetVolumeElementContext(Volume);
+    ASSERT(volumeCtx);
+
+    if (Channel == ALL_CHANNELS_ID)
+    {
+        Channel = 0;
+    }
+
+    *VolumeLevel = volumeCtx->VolumeLevel[Channel];
+
+    return STATUS_SUCCESS;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecC_CreateVolumeElement(
+    _In_    ACXCIRCUIT  Circuit,
+    _Out_   ACXVOLUME* Element
+)
+/*++
+
+Routine Description:
+
+    This routine creates a volume element.
+
+Return Value:
+
+    NT status value
+--*/
+{
+    NTSTATUS                        status = STATUS_SUCCESS;
+    WDF_OBJECT_ATTRIBUTES           attributes;
+    ACX_VOLUME_CALLBACKS            volumeCallbacks;
+    ACX_VOLUME_CONFIG               volumeCfg;
+    VOLUME_ELEMENT_CONTEXT *        volumeCtx;
+
+    PAGED_CODE();
+
+    //
+    // The driver uses this DDI to assign its volume element callbacks.
+    //
+    ACX_VOLUME_CALLBACKS_INIT(&volumeCallbacks);
+    volumeCallbacks.EvtAcxVolumeAssignLevel = CodecC_EvtVolumeAssignLevelCallback;
+    volumeCallbacks.EvtAcxVolumeRetrieveLevel = CodecC_EvtVolumeRetrieveLevelCallback;
+
+    //
+    // Create Volume element
+    //
+    ACX_VOLUME_CONFIG_INIT(&volumeCfg);
+    volumeCfg.ChannelsCount = MAX_CHANNELS;
+    volumeCfg.Minimum = VOLUME_LEVEL_MINIMUM;
+    volumeCfg.Maximum = VOLUME_LEVEL_MAXIMUM;
+    volumeCfg.SteppingDelta = VOLUME_STEPPING;
+    volumeCfg.Callbacks = &volumeCallbacks;
+
+    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, VOLUME_ELEMENT_CONTEXT);
+    attributes.ParentObject = Circuit;
+
+    RETURN_NTSTATUS_IF_FAILED(AcxVolumeCreate(Circuit, &attributes, &volumeCfg, Element));
+
+    ASSERT(*Element != nullptr);
+    volumeCtx = GetVolumeElementContext(*Element);
+    ASSERT(volumeCtx);
+
+    //
+    // (max + min)/2 puts it in the middle of the valid range, divide that by the stepping to get the nearest
+    // valid step, multiply that by stepping to put it back at a level value.
+    //
+    volumeCtx->VolumeLevel[0] = (VOLUME_LEVEL_MAXIMUM + VOLUME_LEVEL_MINIMUM) / 2 / VOLUME_STEPPING * VOLUME_STEPPING;
+    volumeCtx->VolumeLevel[1] = (VOLUME_LEVEL_MAXIMUM + VOLUME_LEVEL_MINIMUM) / 2 / VOLUME_STEPPING * VOLUME_STEPPING;
+
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecC_EvtAcxPinRetrieveName(
+    _In_    ACXPIN              Pin,
+    _Out_   PUNICODE_STRING     Name
+)
+/*++
+
+Routine Description:
+
+    If g_UseCustomInfName is false then the ACX
+    pin callback EvtAcxPinRetrieveName calls this
+    function in order to retrieve the pin name. 
+
+Return Value:
+
+    NTSTATUS
+
+--*/
+{
+    UNREFERENCED_PARAMETER(Pin);
+
+    PAGED_CODE();
+
+    return RtlUnicodeStringPrintf(Name, L"CustomName2");
+}
+
+VOID
+CodecC_EvtPinContextCleanup(
+    _In_ WDFOBJECT      WdfPin
+)
+/*++
+
+Routine Description:
+
+    In this callback, it cleans up pin context.
+
+Arguments:
+
+    WdfDevice - WDF device object
+
+Return Value:
+
+    nullptr
+
+--*/
+{
+    UNREFERENCED_PARAMETER(WdfPin);
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecC_CircuitCleanup(
+    _In_ ACXCIRCUIT Circuit
+)
+{
+    PCODEC_CAPTURE_CIRCUIT_CONTEXT  circuitCtx;
+
+    PAGED_CODE();
+
+    //
+    // Remove the static capture circuit.
+    //
+    circuitCtx = GetCaptureCircuitContext(Circuit);
+    ASSERT(circuitCtx != nullptr);
+
+    return STATUS_SUCCESS;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecC_AddStaticCapture(
+    _In_ WDFDEVICE              Device,
+    _In_ const GUID *           ComponentGuid,
+    _In_ const GUID *           MicCustomName,
+    _In_ const UNICODE_STRING * CircuitName
+)
+/*++
+
+Routine Description:
+
+    Creates the static capture circuit (pictured below)
+    and adds it to the device context. This is called
+    when a new device is detected and the AddDevice
+    call is made by the pnp manager.
+
+    ******************************************************
+    * Capture Circuit                                    *
+    *                                                    *
+    *              +-----------------------+             *
+    *              |                       |             *
+    *              |    +-------------+    |             *
+    * Host  ------>|    | Volume Node |    |---> Bridge  *
+    * Pin          |    +-------------+    |      Pin    *
+    *              |                       |             *
+    *              +-----------------------+             *
+    *                                                    *
+    ******************************************************
+
+Return Value:
+
+    NTSTATUS
+
+--*/
+{
+    NTSTATUS                        status = STATUS_SUCCESS;
+    PCODEC_DEVICE_CONTEXT           devCtx;
+    PCAPTURE_DEVICE_CONTEXT         captureDevCtx;
+    ACXCIRCUIT                      captureCircuit = nullptr;
+    WDF_OBJECT_ATTRIBUTES           attributes;
+
+    PAGED_CODE();
+
+    devCtx = GetCodecDeviceContext(Device);
+    ASSERT(devCtx != nullptr);
+
+    //
+    // Alloc audio context to current device.
+    //
+    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, CAPTURE_DEVICE_CONTEXT);
+    RETURN_NTSTATUS_IF_FAILED(WdfObjectAllocateContext(Device, &attributes, (PVOID*)&captureDevCtx));
+    ASSERT(captureDevCtx);
+
+    //
+    // Create a capture circuit associated with this child device.
+    //
+    RETURN_NTSTATUS_IF_FAILED(CodecC_CreateCaptureCircuit(Device, ComponentGuid, MicCustomName, CircuitName, &captureCircuit));
+
+    devCtx->Capture = captureCircuit;
+
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+Capture_AllocateSupportedFormats(
+    _In_                                   WDFDEVICE        Device,
+    _In_reads_bytes_(CodecCapturePinCount) ACXPIN           Pin[],
+    _In_                                   ACXCIRCUIT       Circuit,
+    _In_                                   size_t           CodecCapturePinCount
+)
+{
+    UNREFERENCED_PARAMETER(CodecCapturePinCount);
+
+    NTSTATUS status = STATUS_SUCCESS;
+    ACXDATAFORMAT formatPcm44100c1;
+    ACXDATAFORMAT formatPcm48000c1;
+    ACXDATAFORMATLIST formatList;
+
+    WDF_OBJECT_ATTRIBUTES attributes;
+    WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
+
+    ///////////////////////////////////////////////////////////
+    //
+    // Allocate the formats this circuit supports.
+    //
+
+    RETURN_NTSTATUS_IF_FAILED(AllocateFormat(Pcm44100c1, Circuit, Device, &formatPcm44100c1));
+    RETURN_NTSTATUS_IF_FAILED(AllocateFormat(Pcm48000c1, Circuit, Device, &formatPcm48000c1));
+
+    ///////////////////////////////////////////////////////////
+    //
+    // Define supported formats for the host pin.
+    //
+
+    //
+    // The raw processing mode list is associated with each single circuit
+    // by ACX. A driver uses this DDI to retrieve the built-in raw
+    // data-format list.
+    //
+    RETURN_NTSTATUS_IF_TRUE(CodecCaptureHostPin >= CodecCapturePinCount, STATUS_INVALID_PARAMETER);
+    formatList = AcxPinGetRawDataFormatList(Pin[CodecCaptureHostPin]);
+    RETURN_NTSTATUS_IF_TRUE(formatList == nullptr, STATUS_INSUFFICIENT_RESOURCES);
+
+    //
+    // The driver uses this DDI to add data formats to the raw
+    // processing mode list associated with the current circuit.
+    //
+    RETURN_NTSTATUS_IF_FAILED(AcxDataFormatListAddDataFormat(formatList, formatPcm44100c1));
+    RETURN_NTSTATUS_IF_FAILED(AcxDataFormatListAddDataFormat(formatList, formatPcm48000c1));
+
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecC_CreateCaptureCircuit(
+    _In_     WDFDEVICE              Device,
+    _In_     const GUID *           ComponentGuid,
+    _In_     const GUID *           MicCustomName,
+    _In_     const UNICODE_STRING * CircuitName,
+    _Out_    ACXCIRCUIT*            Circuit
+)
+/*++
+
+Routine Description:
+
+    This routine builds the CODEC capture circuit.
+
+Return Value:
+
+    NT status value
+
+--*/
+{
+    NTSTATUS                        status;
+    WDF_OBJECT_ATTRIBUTES           attributes;
+    ACXCIRCUIT                      circuit;
+    CODEC_CAPTURE_CIRCUIT_CONTEXT*  circuitCtx;
+    ACXPIN                          pin[CodecCapturePinCount];
+
+    PAGED_CODE();
+
+    //
+    // Init output value.
+    //
+    *Circuit = nullptr;
+
+    ///////////////////////////////////////////////////////////
+    //
+    // Create a circuit.
+    //
+    {
+        PACXCIRCUIT_INIT                circuitInit = nullptr;
+        ACX_CIRCUIT_PNPPOWER_CALLBACKS  powerCallbacks;
+
+        //
+        // The driver uses this DDI to allocate an ACXCIRCUIT_INIT
+        // structure. This opaque structure is used when creating
+        // a standalone audio circuit representing an audio device. 
+        //
+        circuitInit = AcxCircuitInitAllocate(Device);
+
+        //
+        // A driver uses this DDI to free the allocated
+        // ACXCIRCUIT_INIT structure when an error is detected.
+        // Normally the structures is deleted/cleared by ACX when
+        // an ACX circuit is created successfully.
+        //
+        auto circuitInitScope = scope_exit([&circuitInit]() {
+            if (circuitInit) {
+                AcxCircuitInitFree(circuitInit);
+            }
+            });
+
+        //
+        // The driver uses this DDI to specify the Component ID
+        // of the ACX circuit. This ID is a guid that uniquely
+        // identifies the circuit instance (vendor specific).
+        //
+        AcxCircuitInitSetComponentId(circuitInit, ComponentGuid);
+
+        //
+        // The driver uses this DDI to specify the circuit name.
+        // For standalone circuits, this is the audio device name
+        // which is used by clients to open handles to the audio devices.
+        //
+        (VOID)AcxCircuitInitAssignName(circuitInit, CircuitName);
+
+        //
+        // The driver uses this DDI to specify the circuit type. The
+        // circuit type can be AcxCircuitTypeRender, AcxCircuitTypeCapture,
+        // AcxCircuitTypeOther, or AcxCircuitTypeMaximum (for validation). 
+        //
+        AcxCircuitInitSetCircuitType(circuitInit, AcxCircuitTypeCapture);
+
+        //
+        // The driver uses this DDI to assign its (if any) power callbacks.
+        //
+        ACX_CIRCUIT_PNPPOWER_CALLBACKS_INIT(&powerCallbacks);
+        powerCallbacks.EvtAcxCircuitPowerUp = CodecC_EvtCircuitPowerUp;
+        powerCallbacks.EvtAcxCircuitPowerDown = CodecC_EvtCircuitPowerDown;
+        AcxCircuitInitSetAcxCircuitPnpPowerCallbacks(circuitInit, &powerCallbacks);
+
+        //
+        // The driver uses this DDI to register for a stream-create callback.
+        //
+        RETURN_NTSTATUS_IF_FAILED(AcxCircuitInitAssignAcxCreateStreamCallback(circuitInit, CodecC_EvtCircuitCreateStream));
+
+        //
+        // The driver uses this DDI to create a new ACX circuit.
+        //
+        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, CODEC_CAPTURE_CIRCUIT_CONTEXT);
+        RETURN_NTSTATUS_IF_FAILED(AcxCircuitCreate(Device, &attributes, &circuitInit, &circuit));
+
+        circuitInitScope.release();
+
+        circuitCtx = GetCaptureCircuitContext(circuit);
+        ASSERT(circuitCtx);
+    }
+
+    //
+    // Post circuit creation initialization.
+    //
+
+    ///////////////////////////////////////////////////////////
+    //
+    // Create volume element.
+    //
+    {
+        ACXELEMENT elements[CaptureElementCount] = { 0 };
+
+        RETURN_NTSTATUS_IF_FAILED(CodecC_CreateVolumeElement(circuit, (ACXVOLUME*)&elements[CaptureVolumeIndex]));
+
+        //
+        // Saving the volume element in the circuit context.
+        //
+        circuitCtx->VolumeElement = (ACXVOLUME)elements[CaptureVolumeIndex];
+
+        //
+        // The driver uses this DDI post circuit creation to add ACXELEMENTs.
+        //
+        RETURN_NTSTATUS_IF_FAILED(AcxCircuitAddElements(circuit, elements, SIZEOF_ARRAY(elements)));
+    }
+
+    ///////////////////////////////////////////////////////////
+    //
+    // Create the pins for the circuit. 
+    //
+    {
+        ACX_PIN_CALLBACKS               pinCallbacks;
+        ACX_PIN_CONFIG                  pinCfg;
+        CODEC_PIN_CONTEXT*              pinCtx;
+
+        ///////////////////////////////////////////////////////////
+        //
+        // Create capture streaming pin.
+        //
+        ACX_PIN_CALLBACKS_INIT(&pinCallbacks);
+        pinCallbacks.EvtAcxPinSetDataFormat = CodecC_EvtAcxPinSetDataFormat;
+
+        ACX_PIN_CONFIG_INIT(&pinCfg);
+        pinCfg.Type = AcxPinTypeSource;
+        pinCfg.Communication = AcxPinCommunicationSink;
+        pinCfg.Category = &KSCATEGORY_AUDIO;
+        pinCfg.PinCallbacks = &pinCallbacks;
+
+        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, CODEC_PIN_CONTEXT);
+        attributes.EvtCleanupCallback = CodecC_EvtPinContextCleanup;
+        attributes.ParentObject = circuit;
+
+        //
+        // The driver uses this DDI to create one or more pins on the circuits.
+        //
+        RETURN_NTSTATUS_IF_FAILED(AcxPinCreate(circuit, &attributes, &pinCfg, &(pin[CodecCaptureHostPin])));
+
+        ASSERT(pin[CodecCaptureHostPin] != nullptr);
+        pinCtx = GetCodecPinContext(pin[CodecCaptureHostPin]);
+        ASSERT(pinCtx);
+        pinCtx->CodecPinType = CodecPinTypeHost;
+
+        ///////////////////////////////////////////////////////////
+        //
+        // Create capture endpoint pin. 
+        //
+        ACX_PIN_CALLBACKS_INIT(&pinCallbacks);
+        ACX_PIN_CONFIG_INIT(&pinCfg);
+
+        pinCfg.Type = AcxPinTypeSink;
+        pinCfg.Communication = AcxPinCommunicationNone;
+        pinCfg.Category = &KSNODETYPE_MICROPHONE;
+        pinCfg.PinCallbacks = &pinCallbacks;
+
+        // Specify how to read the custom name.
+        if (g_UseCustomInfName)
+        {
+            pinCfg.Name = MicCustomName;
+        }
+        else
+        {
+            pinCallbacks.EvtAcxPinRetrieveName = CodecC_EvtAcxPinRetrieveName;
+        }
+        g_UseCustomInfName = !g_UseCustomInfName;
+
+        WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
+        attributes.ParentObject = circuit;
+
+        //
+        // The driver uses this DDI to create one or more pins on the circuits.
+        //
+        RETURN_NTSTATUS_IF_FAILED(AcxPinCreate(circuit, &attributes, &pinCfg, &(pin[CodecCaptureBridgePin])));
+
+        ASSERT(pin[CodecCaptureBridgePin] != nullptr);
+    }
+
+    ///////////////////////////////////////////////////////////
+    //
+    // Add audio jack to bridge pin. 
+    // For more information on audio jack see: https://docs.microsoft.com/en-us/windows/win32/api/devicetopology/ns-devicetopology-ksjack_description
+    //
+    {
+        ACX_JACK_CONFIG                 jackCfg;
+        ACXJACK                         jack;
+        PJACK_CONTEXT                   jackCtx;
+
+        ACX_JACK_CONFIG_INIT(&jackCfg);
+        jackCfg.Description.ChannelMapping = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
+        jackCfg.Description.Color = RGB(0, 0, 0);
+        jackCfg.Description.ConnectionType = AcxConnTypeAtapiInternal;
+        jackCfg.Description.GeoLocation = AcxGeoLocFront;
+        jackCfg.Description.GenLocation = AcxGenLocPrimaryBox;
+        jackCfg.Description.PortConnection = AcxPortConnIntegratedDevice;
+
+        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, JACK_CONTEXT);
+        attributes.ParentObject = pin[CodecCaptureBridgePin];
+
+        RETURN_NTSTATUS_IF_FAILED(AcxJackCreate(pin[CodecCaptureBridgePin], &attributes, &jackCfg, &jack));
+
+        ASSERT(jack != nullptr);
+
+        jackCtx = GetJackContext(jack);
+        ASSERT(jackCtx);
+        jackCtx->Dummy = 0;
+
+        RETURN_NTSTATUS_IF_FAILED(AcxPinAddJacks(pin[CodecCaptureBridgePin], &jack, 1));
+    }
+
+    RETURN_NTSTATUS_IF_FAILED(Capture_AllocateSupportedFormats(Device, pin, circuit, CodecCapturePinCount));
+
+    ///////////////////////////////////////////////////////////
+    //
+    // The driver uses this DDI post circuit creation to add ACXPINs.
+    //
+    RETURN_NTSTATUS_IF_FAILED(AcxCircuitAddPins(circuit, pin, CodecCapturePinCount));
+
+    //
+    // Set output value.
+    //
+    *Circuit = circuit;
+
+    //
+    // Done. 
+    //
+    status = STATUS_SUCCESS;
+
+    return status;
+}
+
+_Use_decl_annotations_
+NTSTATUS
+CodecC_EvtCircuitPowerUp(
+    _In_ WDFDEVICE  Device,
+    _In_ ACXCIRCUIT Circuit,
+    _In_ WDF_POWER_DEVICE_STATE PreviousState
+)
+{
+    UNREFERENCED_PARAMETER(Device);
+    UNREFERENCED_PARAMETER(Circuit);
+    UNREFERENCED_PARAMETER(PreviousState);
+
+    PAGED_CODE();
+
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+NTSTATUS
+CodecC_EvtCircuitPowerDown(
+    _In_ WDFDEVICE  Device,
+    _In_ ACXCIRCUIT Circuit,
+    _In_ WDF_POWER_DEVICE_STATE TargetState
+)
+{
+    UNREFERENCED_PARAMETER(Device);
+    UNREFERENCED_PARAMETER(Circuit);
+    UNREFERENCED_PARAMETER(TargetState);
+
+    PAGED_CODE();
+
+    return STATUS_SUCCESS;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecC_EvtCircuitCreateStream(
+    _In_    WDFDEVICE       Device,
+    _In_    ACXCIRCUIT      Circuit,
+    _In_    ACXPIN          Pin,
+    _In_    PACXSTREAM_INIT StreamInit,
+    _In_    ACXDATAFORMAT   StreamFormat,
+    _In_    const GUID    * SignalProcessingMode,
+    _In_    ACXOBJECTBAG    VarArguments
+)
+/*++
+
+Routine Description:
+
+    This routine creates a stream for the specified circuit.
+
+Return Value:
+
+    NT status value
+
+--*/
+{
+    NTSTATUS                        status;
+    PCAPTURE_DEVICE_CONTEXT         devCtx;
+    WDF_OBJECT_ATTRIBUTES           attributes;
+    ACXSTREAM                       stream;
+    STREAMENGINE_CONTEXT *          streamCtx;
+    ACX_STREAM_CALLBACKS            streamCallbacks;
+    ACX_RT_STREAM_CALLBACKS         rtCallbacks;
+    CCaptureStreamEngine *          streamEngine = nullptr;
+    CODEC_CAPTURE_CIRCUIT_CONTEXT * circuitCtx;
+    CODEC_PIN_CONTEXT *             pinCtx;
+
+    auto streamEngineScope = scope_exit([&streamEngine]() {
+
+        if (streamEngine)
+        {
+            delete streamEngine;
+        }
+
+        });
+
+    PAGED_CODE();
+    UNREFERENCED_PARAMETER(SignalProcessingMode);
+    UNREFERENCED_PARAMETER(VarArguments);
+
+    ASSERT(IsEqualGUID(*SignalProcessingMode, AUDIO_SIGNALPROCESSINGMODE_RAW));
+
+    devCtx = GetCaptureDeviceContext(Device);
+    ASSERT(devCtx != nullptr);
+
+    circuitCtx = GetCaptureCircuitContext(Circuit);
+    ASSERT(circuitCtx != nullptr);
+
+    pinCtx = GetCodecPinContext(Pin);
+    ASSERT(pinCtx != nullptr);
+
+    //
+    // Init streaming callbacks.
+    //
+    ACX_STREAM_CALLBACKS_INIT(&streamCallbacks);
+    streamCallbacks.EvtAcxStreamPrepareHardware = EvtStreamPrepareHardware;
+    streamCallbacks.EvtAcxStreamReleaseHardware = EvtStreamReleaseHardware;
+    streamCallbacks.EvtAcxStreamRun = EvtStreamRun;
+    streamCallbacks.EvtAcxStreamPause = EvtStreamPause;
+
+    RETURN_NTSTATUS_IF_FAILED(AcxStreamInitAssignAcxStreamCallbacks(StreamInit, &streamCallbacks));
+
+    //
+    // Init RT streaming callbacks.
+    //
+    ACX_RT_STREAM_CALLBACKS_INIT(&rtCallbacks);
+    rtCallbacks.EvtAcxStreamGetHwLatency = EvtStreamGetHwLatency;
+    rtCallbacks.EvtAcxStreamAllocateRtPackets = EvtStreamAllocateRtPackets;
+    rtCallbacks.EvtAcxStreamFreeRtPackets = EvtStreamFreeRtPackets;
+    rtCallbacks.EvtAcxStreamGetCapturePacket = CodecC_EvtStreamGetCapturePacket;
+    rtCallbacks.EvtAcxStreamGetCurrentPacket = EvtStreamGetCurrentPacket;
+    rtCallbacks.EvtAcxStreamGetPresentationPosition = EvtStreamGetPresentationPosition;
+
+    RETURN_NTSTATUS_IF_FAILED(AcxStreamInitAssignAcxRtStreamCallbacks(StreamInit, &rtCallbacks));
+
+    //
+    // Buffer notifications are supported.
+    //
+    AcxStreamInitSetAcxRtStreamSupportsNotifications(StreamInit);
+
+    //
+    // Create the stream.
+    //
+    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, STREAMENGINE_CONTEXT);
+    attributes.EvtDestroyCallback = EvtStreamDestroy;
+    RETURN_NTSTATUS_IF_FAILED(AcxRtStreamCreate(Device, Circuit, &attributes, &StreamInit, &stream));
+
+    streamCtx = GetStreamEngineContext(stream);
+    ASSERT(streamCtx);
+
+    //
+    // Create the virtual streaming engine which will control
+    // streaming logic for the capture circuit. 
+    //
+    streamEngine = new (POOL_FLAG_NON_PAGED, DeviceDriverTag) CCaptureStreamEngine(stream, StreamFormat);
+    RETURN_NTSTATUS_IF_TRUE(streamEngine == nullptr, STATUS_INSUFFICIENT_RESOURCES);
+
+    streamCtx->StreamEngine = (PVOID)streamEngine;
+ 
+    streamEngine = nullptr;
+
+    //
+    // Done. 
+    //
+    status = STATUS_SUCCESS;
+
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecC_EvtStreamGetCapturePacket(
+    _In_ ACXSTREAM          Stream,
+    _Out_ ULONG           * LastCapturePacket,
+    _Out_ ULONGLONG       * QPCPacketStart,
+    _Out_ BOOLEAN         * MoreData
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CCaptureStreamEngine* streamEngine = nullptr;
+
+    PAGED_CODE();
+
+    ctx = GetStreamEngineContext(Stream);
+
+    streamEngine = static_cast<CCaptureStreamEngine*>(ctx->StreamEngine);
+
+    return streamEngine->GetCapturePacket(LastCapturePacket, QPCPacketStart, MoreData);
+}
+
+
diff --git a/audio/Acx/Samples/Common/CircuitHelper.cpp b/audio/Acx/Samples/Common/CircuitHelper.cpp
new file mode 100644
index 00000000..bfff74b2
--- /dev/null
+++ b/audio/Acx/Samples/Common/CircuitHelper.cpp
@@ -0,0 +1,620 @@
+/*++
+
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+    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:
+
+    CircuitHelper.cpp
+
+Abstract:
+
+   This module contains helper functions for circuits.
+
+Environment:
+
+    Kernel mode
+
+--*/
+
+#include "private.h"
+#include "public.h"
+#include "CircuitHelper.h"
+
+#ifndef __INTELLISENSE__
+#include "CircuitHelper.tmh"
+#endif
+
+const ULONG _DSP_STREAM_PROPERTY_UI4_VALUE = 1;
+
+PAGED_CODE_SEG
+NTSTATUS AllocateFormat(
+    _In_ KSDATAFORMAT_WAVEFORMATEXTENSIBLE      WaveFormat,
+    _In_ ACXCIRCUIT                             Circuit,
+    _In_ WDFDEVICE                              Device,
+    _Out_ ACXDATAFORMAT*                        Format
+)
+{
+    PAGED_CODE();
+
+    NTSTATUS status = STATUS_SUCCESS;
+
+    WDF_OBJECT_ATTRIBUTES attributes;
+    WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
+
+    ACX_DATAFORMAT_CONFIG formatCfg;
+    ACX_DATAFORMAT_CONFIG_INIT_KS(&formatCfg, &WaveFormat);
+    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, FORMAT_CONTEXT);
+    attributes.ParentObject = Circuit;
+
+    //
+    // Creates an ACXDATAFORMAT handle for the given wave format.
+    //
+    RETURN_NTSTATUS_IF_FAILED(AcxDataFormatCreate(Device, &attributes, &formatCfg, Format));
+
+    ASSERT((*Format) != NULL);
+    FORMAT_CONTEXT* formatCtx;
+    formatCtx = GetFormatContext(*Format);
+    ASSERT(formatCtx);
+    UNREFERENCED_PARAMETER(formatCtx);
+
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS CreateStreamBridge(
+    _In_ ACX_STREAM_BRIDGE_CONFIG StreamCfg,
+    _In_ ACXCIRCUIT Circuit,
+    _In_ ACXPIN Pin,
+    _In_ DSP_PIN_CONTEXT* PinCtx,
+    _In_ BOOL Render)
+{
+    PAGED_CODE();
+
+    NTSTATUS status = STATUS_SUCCESS;
+
+    WDF_OBJECT_ATTRIBUTES attributes;
+    WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
+
+    attributes.ParentObject = Pin;
+
+    ACX_OBJECTBAG_CONFIG objBagCfg;
+    ACXOBJECTBAG objBag = NULL;
+    ACX_OBJECTBAG_CONFIG_INIT(&objBagCfg);
+    WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
+    attributes.ParentObject = Circuit;
+    RETURN_NTSTATUS_IF_FAILED(AcxObjectBagCreate(&attributes, &objBagCfg, &objBag));
+
+    DECLARE_CONST_ACXOBJECTBAG_DRIVER_PROPERTY_NAME(msft, TestUI4);
+    RETURN_NTSTATUS_IF_FAILED(AcxObjectBagAddUI4(objBag, &TestUI4, _DSP_STREAM_PROPERTY_UI4_VALUE));
+
+    //
+    // Add a stream BRIDGE.
+    //
+    PCGUID inModes[] = {
+        &AUDIO_SIGNALPROCESSINGMODE_RAW,
+        &AUDIO_SIGNALPROCESSINGMODE_DEFAULT,
+    };
+
+    if (Render)
+    {
+        StreamCfg.InModesCount = SIZEOF_ARRAY(inModes);
+        StreamCfg.InModes = inModes;
+    }
+
+    //
+    // Do not specify InModes for capture - this will prevent the ACX framework from adding created streams to this stream
+    // bridge automatically. We want to add the stream bridges manually since we don't want KWS streams added.
+    //
+    StreamCfg.OutMode = &AUDIO_SIGNALPROCESSINGMODE_RAW;
+    StreamCfg.OutStreamVarArguments = objBag;
+
+    //
+    // Uncomment this line to reverse the change-state sequence notifications.
+    //
+    // streamCfg.Flags       |= AcxStreamBridgeInvertChangeStateSequence;
+
+    ACXSTREAMBRIDGE streamBridge = NULL;
+    RETURN_NTSTATUS_IF_FAILED(AcxStreamBridgeCreate(Circuit, &attributes, &StreamCfg, &streamBridge));
+
+    if (!Render)
+    {
+        PinCtx->HostStreamBridge = streamBridge;
+    }
+
+    RETURN_NTSTATUS_IF_FAILED(AcxPinAddStreamBridges(Pin, &streamBridge, 1));
+
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS ConnectRenderCircuitElements(
+    _In_ ACXAUDIOENGINE                          AudioEngineElement,
+    _In_ ACXCIRCUIT                              Circuit
+)
+{
+    PAGED_CODE();
+
+    NTSTATUS status = STATUS_SUCCESS;
+
+    //
+    // Explicitly connect the circuit/elements. Note that driver doesn't 
+    // need to perform this step when circuit/elements are connected in the 
+    // same order as they were added to the circuit. By default ACX connects
+    // the elements starting from the sink circuit pin and ending with the 
+    // source circuit pin for both render and capture devices.
+    //
+    //                           Circuit layout
+    //              -----------------------------------------
+    //              |                                       |
+    //              |        --------------------           |
+    //     Host -0->|-----1->|                  |-0-------->|-3-> Bridge Pin
+    //              |        |  Audio Engine    |           |
+    //  Offload -1->|-----2->|      Node        |-3--|      |
+    //              |        |------------------|    |      |
+    //              |                                |      |
+    // Loopback <-2-|<------------------------------ |      |
+    //              |                                       |
+    //              |                                       |
+    //              |---------------------------------------|
+    //
+
+    ACX_CONNECTION connections[4];
+
+    ACX_CONNECTION_INIT(&connections[0], Circuit, AudioEngineElement);
+    connections[0].FromPin.Id = RenderHostPin;
+    connections[0].ToPin.Id = 1;
+
+    ACX_CONNECTION_INIT(&connections[1], Circuit, AudioEngineElement);
+    connections[1].FromPin.Id = RenderOffloadPin;
+    connections[1].ToPin.Id = 2;
+
+    ACX_CONNECTION_INIT(&connections[2], AudioEngineElement, Circuit);
+    connections[2].ToPin.Id = RenderLoopbackPin;
+    connections[2].FromPin.Id = 3;
+
+    ACX_CONNECTION_INIT(&connections[3], AudioEngineElement, Circuit);
+    connections[3].ToPin.Id = RenderBridgePin;
+    connections[3].FromPin.Id = 0;
+
+    //
+    // Add the connections linking circuit to elements.
+    //
+    RETURN_NTSTATUS_IF_FAILED(AcxCircuitAddConnections(Circuit, connections, SIZEOF_ARRAY(connections)));
+
+    return status;
+
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+Codec_GetModeFromAttributeList(
+    _In_    const PKSMULTIPLE_ITEM  Attributes,
+    _In_    ULONG                   AttributesSize,
+    _Out_   GUID                  * SignalProcessingMode
+    )
+{
+    NTSTATUS        status          = STATUS_NO_MORE_ENTRIES;
+    PKSATTRIBUTE    attributeHeader = NULL;
+    PAGED_CODE();
+    *SignalProcessingMode = AUDIO_SIGNALPROCESSINGMODE_DEFAULT;
+    
+    status = FindKsAttributeById(Attributes, 
+                                 AttributesSize, 
+                                 &KSATTRIBUTEID_AUDIOSIGNALPROCESSING_MODE,
+                                 sizeof(KSATTRIBUTE_AUDIOSIGNALPROCESSING_MODE),
+                                 &attributeHeader);
+    if (!NT_SUCCESS(status))
+    {
+        goto exit;
+    }
+   
+    ASSERT(attributeHeader->Attribute == KSATTRIBUTEID_AUDIOSIGNALPROCESSING_MODE);
+    ASSERT(attributeHeader->Size == sizeof(KSATTRIBUTE_AUDIOSIGNALPROCESSING_MODE));
+    
+    KSATTRIBUTE_AUDIOSIGNALPROCESSING_MODE* signalProcessingModeAttribute;
+    signalProcessingModeAttribute = (KSATTRIBUTE_AUDIOSIGNALPROCESSING_MODE*)attributeHeader;
+    *SignalProcessingMode = signalProcessingModeAttribute->SignalProcessingMode;
+    status = STATUS_SUCCESS;
+exit:
+    return status;
+}
+
+struct AFX_FIND_KSATTRIBUTE_BY_ID
+{
+    const _GUID *   Id;
+    ULONG           Size;
+    PKSATTRIBUTE    Attribute;
+};
+
+PAGED_CODE_SEG
+NTSTATUS
+FindKsAttributeByIdVisitor(
+    _In_  PKSATTRIBUTE  AttributeHeader,
+    _In_  PVOID         Context,
+    _Out_ BOOLEAN     * bContinue
+    )
+{
+    NTSTATUS status = STATUS_SUCCESS;
+    AFX_FIND_KSATTRIBUTE_BY_ID * ctx = (AFX_FIND_KSATTRIBUTE_BY_ID *)Context;
+    PAGED_CODE();
+    // Default: continue searching.
+    *bContinue = TRUE;
+    
+    if (IsEqualGUIDAligned(AttributeHeader->Attribute, *ctx->Id))
+    {
+        // Validate its size. 
+        if (AttributeHeader->Size < ctx->Size)
+        {
+            status = STATUS_INVALID_PARAMETER;
+            goto exit;
+        }
+            
+        ctx->Attribute = AttributeHeader; 
+        *bContinue = FALSE;
+    }
+exit:
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+FindKsAttributeById(
+    _In_  const PKSMULTIPLE_ITEM Attributes,
+    _In_  ULONG                  AttributesSize,
+    _In_  const _GUID *          AttributeId,
+    _In_  ULONG                  AttributeSize,
+    _Out_ PKSATTRIBUTE         * AttributeHeader
+    )
+{
+    PAGED_CODE();
+    NTSTATUS status;
+    AFX_FIND_KSATTRIBUTE_BY_ID ctx = {0}; 
+    *AttributeHeader = NULL;
+    ctx.Id          = AttributeId;
+    ctx.Size        = AttributeSize;
+    status = TraverseKsAttributeList(Attributes, AttributesSize, FindKsAttributeByIdVisitor, &ctx);
+    if (!NT_SUCCESS(status))
+    {
+        goto exit;
+    }
+    if (ctx.Attribute == NULL)
+    {
+        status = STATUS_NO_MORE_ENTRIES;
+        goto exit;
+    }
+    *AttributeHeader = ctx.Attribute;
+exit:
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+TraverseKsAttributeList(
+    _In_ const PKSMULTIPLE_ITEM         Attributes,
+    _In_ ULONG                          AttributesSize,
+    _In_ PFN_KSATTRIBUTES_VISITOR       Visitor,
+    _In_ PVOID                          Context
+    )
+{
+    PAGED_CODE();
+    NTSTATUS        status          = STATUS_SUCCESS;
+    ULONG           cbRemaining     = 0;
+    PKSATTRIBUTE    attributeHeader = NULL;
+    ASSERT(Visitor);
+    //
+    // Note: multiple-item ptr must have a FILE_QUAD_ALIGNMENT only in relation to the Pin's format size.
+    // I.e., it is not guaranteed that the attributes are FILE_QUAD_ALIGNMENT in memory, unless the caller reallocates
+    // them before calling this function (which is currently not done by anyone in any driver/sample).
+    // 
+    //ASSERT((ULONG_PTR)Attributes == (((ULONG_PTR)Attributes + FILE_QUAD_ALIGNMENT) & ~FILE_QUAD_ALIGNMENT));
+    if (AttributesSize < sizeof(KSMULTIPLE_ITEM))
+    {
+        status = STATUS_INVALID_PARAMETER;
+        goto exit;
+    }
+    if (Attributes->Size < sizeof(KSMULTIPLE_ITEM))
+    {
+        status = STATUS_INVALID_PARAMETER;
+        goto exit;
+    }
+    if (AttributesSize < Attributes->Size)
+    {
+        status = STATUS_INVALID_PARAMETER;
+        goto exit;
+    }
+    
+    cbRemaining = Attributes->Size;
+    //
+    // Init ptr / size of attributes of list.
+    //
+    cbRemaining -= sizeof(KSMULTIPLE_ITEM);
+    attributeHeader = (PKSATTRIBUTE)(Attributes + 1);
+    for (ULONG i = 0; i < Attributes->Count; i++)
+    {
+        BOOLEAN bContinue   = TRUE;
+        size_t  cbAttribute = 0;
+        
+        if (cbRemaining < sizeof(KSATTRIBUTE))
+        {
+            status = STATUS_INVALID_PARAMETER;
+            goto exit;
+        }
+        if (attributeHeader->Size < sizeof(KSATTRIBUTE))
+        {
+            status = STATUS_INVALID_PARAMETER;
+            goto exit;
+        }
+        if (cbRemaining < attributeHeader->Size)
+        {
+            status = STATUS_INVALID_PARAMETER;
+            goto exit;
+        }
+        //
+        // Invoke the descriptor enumeration routine.
+        //
+        status = Visitor(attributeHeader, Context, &bContinue);
+        if (!NT_SUCCESS(status))
+        {
+            goto exit;
+        }
+        
+        if (!bContinue)
+        {
+            break;
+        }
+        //
+        // Adjust pointer and buffer size to next attribute (QWORD aligned)
+        //
+        cbAttribute = CODEC_ALIGN_SIZE_UP_CONSTANT(attributeHeader->Size, FILE_QUAD_ALIGNMENT);
+        if (cbRemaining < cbAttribute)
+        {
+            //
+            // Out of buffer, check if this was the last attribute.
+            //
+            if (i + 1 != Attributes->Count)
+            {
+                //
+                // This was not the last attribute, nevertheless there is no more buffer, error out.
+                //
+                status = STATUS_INVALID_PARAMETER;
+                goto exit;
+            }
+            // This was the final attribute. Exit loop with success status.
+            break;
+        }
+        // Check next attribute.
+        attributeHeader = (PKSATTRIBUTE)(((PBYTE)attributeHeader) + cbAttribute);
+        cbRemaining -= (ULONG)cbAttribute;
+    }
+    // Normalize success code.
+    status = STATUS_SUCCESS;
+exit:
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtJackRetrievePresence(
+    _In_    ACXJACK     Jack,
+    _In_    PBOOLEAN    IsConnected
+)
+{
+    PAGED_CODE();
+
+    UNREFERENCED_PARAMETER(Jack);
+    UNREFERENCED_PARAMETER(IsConnected);
+
+    NTSTATUS                status = STATUS_SUCCESS;
+
+    //
+    // Because this is a sample we always return true (jack is present). A real driver should check
+    // if the device is actually present before returning true. 
+    //
+    *IsConnected = true;
+
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+CreateAudioJack(
+    _In_ ULONG                          ChannelMapping,
+    _In_ ULONG                          Color,
+    _In_ ACX_JACK_CONNECTION_TYPE       ConnectionType,
+    _In_ ACX_JACK_GEO_LOCATION          GeoLocation,
+    _In_ ACX_JACK_GEN_LOCATION          GenLocation,
+    _In_ ACX_JACK_PORT_CONNECTION       PortConnection,
+    _In_ ULONG                          Flags,
+    _In_ ACXPIN                         BridgePin
+    )
+{
+    PAGED_CODE();
+
+    NTSTATUS status = STATUS_SUCCESS;
+    ACX_JACK_CONFIG jackCfg;
+    ACXJACK jack;
+    PJACK_CONTEXT jackCtx;
+    ACX_JACK_CALLBACKS jackCallbacks;
+
+    WDF_OBJECT_ATTRIBUTES attributes;
+    WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
+
+    ACX_JACK_CONFIG_INIT(&jackCfg);
+    jackCfg.Description.ChannelMapping = ChannelMapping;
+    jackCfg.Description.Color = Color;
+    jackCfg.Description.ConnectionType = ConnectionType;
+    jackCfg.Description.GeoLocation = GeoLocation;
+    jackCfg.Description.GenLocation = GenLocation;
+    jackCfg.Description.PortConnection = PortConnection;
+    jackCfg.Flags = Flags;
+
+    ACX_JACK_CALLBACKS_INIT(&jackCallbacks);
+    jackCallbacks.EvtAcxJackRetrievePresenceState = EvtJackRetrievePresence;
+    jackCfg.Callbacks = &jackCallbacks;
+
+    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, JACK_CONTEXT);
+    attributes.ParentObject = BridgePin;
+
+    status = AcxJackCreate(BridgePin, &attributes, &jackCfg, &jack);
+    if (!NT_SUCCESS(status))
+    {
+        goto exit;
+    }
+
+    ASSERT(jack != nullptr);
+
+    jackCtx = GetJackContext(jack);
+    ASSERT(jackCtx);
+    jackCtx->Dummy = 0;
+
+    status = AcxPinAddJacks(BridgePin, &jack, 1);
+
+exit:
+    return status;
+}
+
+PAGED_CODE_SEG
+VOID
+CpuResourcesCallbackHelper
+( 
+    _In_    WDFOBJECT    Object,
+    _In_    WDFREQUEST   Request,
+    _In_    ACXELEMENT   Element
+)
+{
+    NTSTATUS                    ntStatus = STATUS_NOT_SUPPORTED;
+    ULONG_PTR                   outDataCb = 0;
+    ACX_REQUEST_PARAMETERS      params;
+    ULONG                       minSize = sizeof(ULONG);
+
+    PAGED_CODE();
+
+    ACX_REQUEST_PARAMETERS_INIT(&params);
+    AcxRequestGetParameters(Request, &params);
+
+    if ((params.Type != AcxRequestTypeProperty) ||
+        (params.Parameters.Property.ItemType != AcxItemTypeElement))
+    {
+        // Return to acx
+        (VOID) AcxCircuitDispatchAcxRequest((ACXCIRCUIT)Object, Request);
+        Request = NULL;
+        goto exit; 
+    }
+
+    if (Element == NULL)
+    {
+        ntStatus = STATUS_NOT_SUPPORTED;
+        goto exit;
+    }
+
+    ULONG elementId = params.Parameters.Property.ItemId;
+    ULONG currentElementId = AcxElementGetId(Element);
+    ULONG valueCb = params.Parameters.Property.ValueCb;
+
+    if (valueCb != 0)
+    {
+        if (params.Parameters.Property.Value == NULL)
+        {
+            ntStatus = STATUS_BUFFER_TOO_SMALL;
+            goto exit;
+        }
+    }
+
+    //
+    // Check to see if the current node is the peakmeter node, if not then return the call to ACX
+    //
+    if (elementId != currentElementId)
+    {
+        (VOID) AcxCircuitDispatchAcxRequest((ACXCIRCUIT)Object, Request);
+        Request = NULL;
+        goto exit; 
+    }
+
+    if (params.Parameters.Property.Verb == AcxPropertyVerbGet)
+    {
+
+        if (valueCb == 0)
+        {
+            outDataCb = minSize;
+            ntStatus = STATUS_BUFFER_OVERFLOW;
+            goto exit;
+        }
+        else if (valueCb < minSize)
+        {
+            outDataCb = 0;
+            ntStatus = STATUS_BUFFER_TOO_SMALL;
+            goto exit;
+        }
+        else
+        {
+            *((PULONG)params.Parameters.Property.Value) = KSAUDIO_CPU_RESOURCES_NOT_HOST_CPU;
+            params.Parameters.Property.ValueCb = sizeof(ULONG);
+            outDataCb = params.Parameters.Property.ValueCb;
+            ntStatus = STATUS_SUCCESS;
+        }
+    }
+    else if (params.Parameters.Property.Verb == AcxPropertyVerbBasicSupport)
+    {
+        if ((valueCb != sizeof(ULONG)) && (valueCb != sizeof(KSPROPERTY_DESCRIPTION)))
+        {
+            outDataCb = minSize;
+            ntStatus = STATUS_BUFFER_OVERFLOW;
+            goto exit;
+        }
+
+        if (valueCb >= sizeof(KSPROPERTY_DESCRIPTION))
+        {
+            // if return buffer can hold a KSPROPERTY_DESCRIPTION, return it
+            //
+            PKSPROPERTY_DESCRIPTION PropDesc = (PKSPROPERTY_DESCRIPTION)params.Parameters.Property.Value;
+
+            PropDesc->AccessFlags = KSPROPERTY_TYPE_BASICSUPPORT | KSPROPERTY_TYPE_GET;
+            PropDesc->DescriptionSize = sizeof(KSPROPERTY_DESCRIPTION);
+            PropDesc->PropTypeSet.Set = KSPROPTYPESETID_General;
+            PropDesc->PropTypeSet.Id = VT_UI4;
+            PropDesc->PropTypeSet.Flags = 0;
+            PropDesc->MembersListCount = 0;
+            PropDesc->Reserved = 0;
+            outDataCb = sizeof(KSPROPERTY_DESCRIPTION);
+            ntStatus = STATUS_SUCCESS;
+        }
+        else if (valueCb >= sizeof(ULONG))
+        {
+            // if return buffer can hold a ULONG, return the access flags
+            //
+            *((PULONG)params.Parameters.Property.Value) = KSPROPERTY_TYPE_BASICSUPPORT | KSPROPERTY_TYPE_GET;
+            outDataCb = minSize;
+            ntStatus = STATUS_SUCCESS; 
+        }
+        else if (valueCb > 0)
+        {
+            outDataCb = 0;
+            ntStatus = STATUS_BUFFER_TOO_SMALL;
+        }
+        else
+        {
+            outDataCb = minSize;
+            ntStatus = STATUS_BUFFER_OVERFLOW;
+        }
+    }
+    else
+    {
+        //
+        // Just give it back to ACX. After this call the request is gone.
+        //
+        (VOID) AcxCircuitDispatchAcxRequest((ACXCIRCUIT)Object, Request);
+        Request = NULL;
+        goto exit; 
+    }
+
+exit:
+    if (Request != NULL)
+    {
+        WdfRequestCompleteWithInformation(Request, ntStatus, outDataCb);
+    }
+} // EvtAudioCpuResourcesCallback
diff --git a/audio/Acx/Samples/Common/CircuitHelper.h b/audio/Acx/Samples/Common/CircuitHelper.h
new file mode 100644
index 00000000..58938153
--- /dev/null
+++ b/audio/Acx/Samples/Common/CircuitHelper.h
@@ -0,0 +1,135 @@
+/*++
+
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+    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:
+
+    CircuitHelper.h
+
+Abstract:
+
+   This module contains helper functions for endpoints.
+
+Environment:
+
+    Kernel mode
+
+--*/
+
+// size_t
+// __inline
+// CODEC_ALIGN_SIZE_DOWN_CONSTANT(
+//     IN size_t Length,
+//     IN size_t AlignTo
+//     )
+#define CODEC_ALIGN_SIZE_DOWN_CONSTANT(Length, AlignTo) ((Length) & ~((AlignTo)-1))
+
+#define CODEC_ALIGN_SIZE_DOWN CODEC_ALIGN_SIZE_DOWN_CONSTANT
+
+// size_t
+// __inline
+// CODEC_ALIGN_SIZE_UP_CONSTANT(
+//     IN size_t Length,
+//     IN size_t AlignTo
+//     )
+#define CODEC_ALIGN_SIZE_UP_CONSTANT(Length, AlignTo) CODEC_ALIGN_SIZE_DOWN_CONSTANT((Length) + (AlignTo)-1, (AlignTo))
+
+#define CODEC_ALIGN_SIZE_UP CODEC_ALIGN_SIZE_UP_CONSTANT
+
+PAGED_CODE_SEG
+NTSTATUS
+Codec_GetModeFromAttributeList(
+    _In_    const PKSMULTIPLE_ITEM  Attributes,
+    _In_    ULONG                   AttributesSize,
+    _Out_   GUID                  * SignalProcessingMode
+    );
+
+//
+// Enumeration visitor callback.
+//
+typedef
+NTSTATUS
+(EVT_KSATTRIBUTES_VISITOR)(
+    _In_  PKSATTRIBUTE  AttributeHeader,
+    _In_  PVOID         Context,
+    _Out_ BOOLEAN     * bContinue
+    );
+
+typedef EVT_KSATTRIBUTES_VISITOR *PFN_KSATTRIBUTES_VISITOR;
+
+static
+PAGED_CODE_SEG
+EVT_KSATTRIBUTES_VISITOR FindKsAttributeByIdVisitor;
+
+PAGED_CODE_SEG
+NTSTATUS
+FindKsAttributeById(
+    _In_  const PKSMULTIPLE_ITEM Attributes,
+    _In_  ULONG                  AttributesSize,
+    _In_  const _GUID *          AttributeId,
+    _In_  ULONG                  AttributeSize,
+    _Out_ PKSATTRIBUTE         * AttributeHeader
+    );
+
+PAGED_CODE_SEG
+NTSTATUS
+TraverseKsAttributeList(
+    _In_ const PKSMULTIPLE_ITEM         Attributes,
+    _In_ ULONG                          AttributesSize,
+    _In_ PFN_KSATTRIBUTES_VISITOR       Visitor,
+    _In_ PVOID                          Context
+    );
+
+PAGED_CODE_SEG
+NTSTATUS AllocateFormat(
+    _In_ KSDATAFORMAT_WAVEFORMATEXTENSIBLE      WaveFormat,
+    _In_ ACXCIRCUIT                             Circuit,
+    _In_ WDFDEVICE                              Device,
+    _Out_ ACXDATAFORMAT*                        Format
+);
+
+PAGED_CODE_SEG
+NTSTATUS CreateStreamBridge(
+    _In_ ACX_STREAM_BRIDGE_CONFIG                   StreamCfg,
+    _In_ ACXCIRCUIT                                 Circuit,
+    _In_ ACXPIN                                     Pin,
+    _In_ DSP_PIN_CONTEXT*                           PinCtx,
+    _In_ BOOL                                       Render
+);
+
+PAGED_CODE_SEG
+NTSTATUS ConnectRenderCircuitElements(
+    _In_ ACXAUDIOENGINE                          AudioEngineElement,
+    _In_ ACXCIRCUIT                              Circuit
+);
+
+PAGED_CODE_SEG
+NTSTATUS CreateAudioJack(
+    _In_ ULONG                          ChannelMapping,
+    _In_ ULONG                          Color,
+    _In_ ACX_JACK_CONNECTION_TYPE       ConnectionType,
+    _In_ ACX_JACK_GEO_LOCATION          GeoLocation,
+    _In_ ACX_JACK_GEN_LOCATION          GenLocation,
+    _In_ ACX_JACK_PORT_CONNECTION       PortConnection,
+    _In_ ULONG                          Flags,
+    _In_ ACXPIN                         BridgePin
+);
+
+PAGED_CODE_SEG
+NTSTATUS EvtJackRetrievePresence(
+    _In_    ACXJACK     Jack,
+    _In_    PBOOLEAN    IsConnected
+);
+
+PAGED_CODE_SEG
+VOID CpuResourcesCallbackHelper( 
+    _In_    WDFOBJECT    Object,
+    _In_    WDFREQUEST   Request,
+    _In_    ACXELEMENT   Element
+);
+
diff --git a/audio/Acx/Samples/Common/KeywordDetector.cpp b/audio/Acx/Samples/Common/KeywordDetector.cpp
new file mode 100644
index 00000000..f3476745
--- /dev/null
+++ b/audio/Acx/Samples/Common/KeywordDetector.cpp
@@ -0,0 +1,484 @@
+/*++
+
+    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:
+
+    KeywordDetector.cpp
+
+Abstract:
+
+    Sample keyword detector management.
+
+Environment:
+
+    Kernel mode
+
+--*/
+
+#include "private.h"
+#include "public.h"
+#include <ks.h>
+#include <mmsystem.h>
+#include <ksmedia.h>
+#include "streamengine.h"
+#include "KeywordDetector.h"
+
+PAGED_CODE_SEG
+CKeywordDetector::CKeywordDetector()
+    :
+    m_streamRunning(FALSE),
+    m_qpcStartCapture(0),
+    m_nLastQueuedPacket(-1),
+    m_SoundDetectorArmed1(FALSE),
+    m_SoundDetectorArmed2(FALSE),
+    m_SoundDetectorData1(0),
+    m_SoundDetectorData2(0),
+    m_ullKeywordStartTimestamp(0),
+    m_ullKeywordStopTimestamp(0)
+{
+    PAGED_CODE();
+
+    // Initialize our pool of packets and the list structures
+    KeInitializeSpinLock(&PacketPoolSpinLock);
+    KeInitializeSpinLock(&PacketFifoSpinLock);
+    ResetFifo();
+}
+
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSTATUS CKeywordDetector::ReadKeywordTimestampRegistry()
+{
+    PAGED_CODE();
+
+    NTSTATUS                    ntStatus;
+    PDRIVER_OBJECT              DriverObject;
+    HANDLE                      DriverKey;
+
+    RTL_QUERY_REGISTRY_TABLE    paramTable[] = {
+        // QueryRoutine     Flags                                           Name                                EntryContext                    DefaultType                                                     DefaultData                         DefaultLength
+        { NULL,   RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_TYPECHECK, L"KeywordDetectorStartTimestamp",   &m_ullKeywordStartTimestamp,    (REG_QWORD << RTL_QUERY_REGISTRY_TYPECHECK_SHIFT) | REG_QWORD,  &m_ullKeywordStartTimestamp,        sizeof(ULONGLONG) },
+        { NULL,   RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_TYPECHECK, L"KeywordDetectorStopTimestamp",    &m_ullKeywordStopTimestamp,     (REG_QWORD << RTL_QUERY_REGISTRY_TYPECHECK_SHIFT) | REG_QWORD,  &m_ullKeywordStopTimestamp,         sizeof(ULONGLONG) },
+        { NULL,   0,                                                        NULL,                               NULL,                           0,                                                              NULL,                               0 }
+    };
+
+    DriverObject = WdfDriverWdmGetDriverObject(WdfGetDriver());
+    DriverKey = NULL;
+    ntStatus = IoOpenDriverRegistryKey(DriverObject, 
+                                 DriverRegKeyParameters,
+                                 KEY_READ,
+                                 0,
+                                 &DriverKey);
+
+    if (!NT_SUCCESS(ntStatus))
+    {
+        return ntStatus;
+    }
+
+    ntStatus = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
+                                  (PCWSTR) DriverKey,
+                                  &paramTable[0],
+                                  NULL,
+                                  NULL);
+    if (DriverKey)
+    {
+        ZwClose(DriverKey);
+    }
+
+    return ntStatus;
+}
+
+
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSTATUS CKeywordDetector::ResetDetector(_In_ GUID eventId)
+{
+    PAGED_CODE();
+
+    if (eventId == CONTOSO_KEYWORD1)
+    {
+        m_SoundDetectorData1 = 0;
+        m_SoundDetectorArmed1 = FALSE;
+    }
+    else if(eventId == CONTOSO_KEYWORD2)
+    {
+        m_SoundDetectorData2 = 0;
+        m_SoundDetectorArmed2 = FALSE;
+    }
+    else if(eventId == GUID_NULL)
+    {
+        // When DownloadDetectorData is called to set the pattern for multiple keywords
+        // at once, all keyword detectors must be reset. Also used during keyword detector
+        // initialization and cleanup to restore it back to initial state and power down.
+        m_SoundDetectorData1 = 0;
+        m_SoundDetectorArmed1 = FALSE;
+        m_SoundDetectorData2 = 0;
+        m_SoundDetectorArmed2 = FALSE;
+    }
+    else
+    {
+        return STATUS_INVALID_PARAMETER;
+    }
+
+    return STATUS_SUCCESS;
+}
+
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSTATUS CKeywordDetector::DownloadDetectorData(_In_ GUID eventId, _In_ LONGLONG Data)
+{
+    PAGED_CODE();
+
+    // reset the detector for this event Id
+    ResetDetector(eventId);
+
+    // In this example, the driver supports detection data 
+    // set with a single call for both detectors, or each
+    // detector set individually.
+    if (eventId == CONTOSO_KEYWORD1)
+    {
+        m_SoundDetectorData1 = Data;
+    }
+    else if(eventId == CONTOSO_KEYWORD2)
+    {
+        m_SoundDetectorData2 = Data;
+    }
+    else if(eventId == GUID_NULL)
+    {
+        // in this simplified example "Data" is set on both detectors,
+        // however in a real system "Data" could be a data structure which
+        // contains different values for each detector.
+        m_SoundDetectorData1 = m_SoundDetectorData2 = Data;
+    }
+    else
+    {
+        return STATUS_INVALID_PARAMETER;
+    }
+
+    return STATUS_SUCCESS;
+}
+
+// The following function is only applicable to single keyword detection systems,
+// and assumes keyword detector #1.
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSTATUS CKeywordDetector::GetDetectorData(_In_ GUID eventId, _Out_ LONGLONG *Data)
+{
+    PAGED_CODE();
+
+    if (eventId == CONTOSO_KEYWORD1)
+    {
+        *Data = m_SoundDetectorData1;
+    }
+    else if(eventId == CONTOSO_KEYWORD2)
+    {
+        *Data = m_SoundDetectorData2;
+    }
+    else
+    {
+        return STATUS_INVALID_PARAMETER;
+    }
+
+
+    return STATUS_SUCCESS;
+}
+
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+ULONGLONG CKeywordDetector::GetStartTimestamp()
+{
+    PAGED_CODE();
+
+    return m_ullKeywordStartTimestamp;
+}
+
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+ULONGLONG CKeywordDetector::GetStopTimestamp()
+{
+    PAGED_CODE();
+
+    return m_ullKeywordStopTimestamp;
+}
+
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+VOID CKeywordDetector::ResetFifo()
+{
+    PAGED_CODE();
+
+    m_qpcStartCapture = 0;
+    m_nLastQueuedPacket = (-1);
+    InitializeListHead(&PacketPoolHead);
+    InitializeListHead(&PacketFifoHead);
+
+    for (int i = 0; i < ARRAYSIZE(PacketPool); i++)
+    {
+        InsertTailList(&PacketPoolHead, &PacketPool[i].ListEntry);
+    }
+    return;
+}
+
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSTATUS CKeywordDetector::SetArmed(_In_ GUID eventId, _In_ BOOLEAN Arm)
+{
+    PAGED_CODE();
+
+    BOOL previousArming = FALSE;
+    NTSTATUS ntStatus = STATUS_SUCCESS;
+
+    // the previous state is "armed" if either detector is armed.
+    // this reflects the fact that both detectors are sharing the
+    // same stream.
+    previousArming = m_SoundDetectorArmed1 || m_SoundDetectorArmed2;
+
+    if (eventId == CONTOSO_KEYWORD1)
+    {
+        m_SoundDetectorArmed1 = Arm;
+    }
+    else if(eventId == CONTOSO_KEYWORD2)
+    {
+        m_SoundDetectorArmed2 = Arm;
+    }
+    else
+    {
+        return STATUS_INVALID_PARAMETER;
+    }
+
+    if (Arm && !previousArming && m_qpcStartCapture == 0)
+    {
+        StartBufferingStream();
+    }
+    else if (!Arm && previousArming && !m_streamRunning)
+    {
+        // if it's not actively streaming and everything has been disarmed,
+        // then stop buffering.
+        ResetFifo();
+    }
+
+    return ntStatus;
+}
+
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSTATUS CKeywordDetector::GetArmed(_In_ GUID eventId, _Out_ BOOLEAN *Arm)
+{
+    PAGED_CODE();
+    NTSTATUS ntStatus = STATUS_SUCCESS;
+
+    if (eventId == CONTOSO_KEYWORD1)
+    {
+        *Arm = m_SoundDetectorArmed1;
+    }
+    else if(eventId == CONTOSO_KEYWORD2)
+    {
+        *Arm = m_SoundDetectorArmed2;
+    }
+    else
+    {
+        return STATUS_INVALID_PARAMETER;
+    }
+
+    return ntStatus;
+}
+
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+VOID CKeywordDetector::Run()
+{
+    PAGED_CODE();
+
+    if (m_qpcStartCapture == 0)
+    {
+        StartBufferingStream();
+    }
+
+    m_streamRunning = TRUE;
+}
+
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+VOID CKeywordDetector::Stop()
+{
+    PAGED_CODE();
+
+    ResetFifo();
+    m_streamRunning = FALSE;
+}
+
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+VOID CKeywordDetector::StartBufferingStream()
+{
+    LARGE_INTEGER qpc;
+    LARGE_INTEGER qpcFrequency;
+
+    PAGED_CODE();
+
+    qpc = KeQueryPerformanceCounter(&qpcFrequency);
+    m_qpcStartCapture = qpc.QuadPart;
+    m_qpcFrequency = qpcFrequency.QuadPart;
+
+    return;
+}
+
+PAGED_CODE_SEG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+VOID CKeywordDetector::NotifyDetection()
+{
+    PAGED_CODE();
+
+    // A detection will only happen if armed and the
+    // stream is already running. If there isn't a client
+    // running, then set the stream start time to align
+    // with this detection.
+    if (!m_streamRunning)
+    {
+        StartBufferingStream();
+
+        // The following code is for testing purposes only.
+        // m_qpcFrequency is defined to be the number of ticks in 1 second.
+        // Use the stream start time (the current time retrieved in StartBufferStream) to 
+        // mark when the keyword ended, and the start time minus 1 second worth of ticks
+        // to mark when the keyword started. Also, adjust the stream start time to align
+        // to this new keyword start time, so that the simulated stream contains the full keyword.
+
+        m_ullKeywordStopTimestamp = m_qpcStartCapture; // stop time is the current time
+        m_qpcStartCapture = m_qpcStartCapture - m_qpcFrequency; // buffer start time is 1 second ago
+        m_ullKeywordStartTimestamp = m_qpcStartCapture; // buffer start time = keyword start time
+
+    }
+    else
+    {
+        // The following code is for testing purposes only.
+        // If the stream is running, we cannot modify qpcStartCapture to be in
+        // the past, so instead make the keyword start & stop times fit within the
+        // time period that the keyword has been running. If it has been running
+        // for more than 1 second, then set the keyword start time to be 1 second back
+        // into the stream, as though we just figured out there was a keyword there.
+        // If it has been running less than one second, then the keyword size ends
+        // up being however long the stream has been running. 
+
+        LARGE_INTEGER qpc;
+        qpc = KeQueryPerformanceCounter(NULL);
+
+        m_ullKeywordStopTimestamp = qpc.QuadPart; // stop time is the current time
+
+        if (m_qpcStartCapture < (qpc.QuadPart - m_qpcFrequency))
+        {
+            m_ullKeywordStartTimestamp = (qpc.QuadPart - m_qpcFrequency); 
+        }
+        else
+        {
+            m_ullKeywordStartTimestamp = m_qpcStartCapture;
+        }
+
+    }
+
+    return;
+}
+
+_IRQL_requires_min_(DISPATCH_LEVEL)
+VOID CKeywordDetector::DpcRoutine(_In_ LONGLONG PerformanceCounter, _In_ LONGLONG PerformanceFrequency)
+{
+    LONGLONG currentPacket;
+    LONGLONG packetsToQueue;
+
+    // TODO: the timer only runs when the stream is open, but really for KWS it should be building up a collection of burst data
+    // in the queue from 1.5 sec before the trigger happens. Is there some way to simulate that behavior here? Without doing that,
+    // there isn't really a burst that happens, just a trickle because while the timestamps will be right, the queue won't contain
+    // anything until the timer fires at the normal rate.
+
+    if (m_qpcStartCapture <= 0)
+    {
+        return;
+    }
+
+    currentPacket = (PerformanceCounter - m_qpcStartCapture) * (SamplesPerSecond / SamplesPerPacket) / PerformanceFrequency;
+    packetsToQueue = currentPacket - m_nLastQueuedPacket;
+
+    while (packetsToQueue > 0)
+    {
+        LIST_ENTRY*     packetListEntry;
+        PACKET_ENTRY*   packetEntry;
+
+        do
+        {
+            packetListEntry = ExInterlockedRemoveHeadList(&PacketPoolHead, &PacketPoolSpinLock);
+            if (packetListEntry != NULL) break;
+
+            // Pool is empty, no room to buffer more, an overrun is occurring. Drop and reuse the
+            // oldest packet from head of fifo.
+
+            // Since the pool is empty, the fifo should be full. However, although unlikely, the
+            // driver might empty the fifo before this routine removes a packet. In that case, the
+            // pool should have packets available again. Therefore this is a retry loop.
+            packetListEntry = ExInterlockedRemoveHeadList(&PacketFifoHead, &PacketFifoSpinLock);
+            if (packetListEntry != NULL) break;
+        } while (TRUE);
+
+        packetEntry = CONTAINING_RECORD(packetListEntry, PACKET_ENTRY, ListEntry);
+
+        packetEntry->PacketNumber = ++m_nLastQueuedPacket;
+        packetEntry->QpcWhenSampled = m_qpcStartCapture + (packetEntry->PacketNumber * PerformanceFrequency * SamplesPerPacket / SamplesPerSecond);
+
+        // TODO: this should really put something real in the buffer. Use the sine tone generator maybe?
+        RtlZeroMemory(&packetEntry->Samples[0], sizeof(packetEntry->Samples));
+
+        ExInterlockedInsertTailList(&PacketFifoHead, packetListEntry, &PacketFifoSpinLock);
+
+        packetsToQueue -= 1;
+    }
+}
+
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSTATUS CKeywordDetector::GetReadPacket
+(
+    _In_ ULONG PacketCount,
+    _In_ ULONG PacketSize,
+    _Out_writes_(PacketSize) PVOID *Packets,
+    _Out_ ULONG *PacketNumber,
+    _Out_ ULONG64 *PerformanceCounterValue,
+    _Out_ BOOLEAN *MoreData
+)
+{
+    NTSTATUS ntStatus;
+    BYTE *packetData;
+    PACKET_ENTRY *packetEntry;
+    LIST_ENTRY *packetListEntry = NULL;
+
+    packetListEntry = ExInterlockedRemoveHeadList(&PacketFifoHead, &PacketFifoSpinLock);
+    if (packetListEntry == NULL)
+    {
+        ntStatus = STATUS_DEVICE_NOT_READY;
+        goto Exit;
+    }
+    packetEntry = CONTAINING_RECORD(packetListEntry, PACKET_ENTRY, ListEntry);
+
+    ntStatus = RtlLongLongToULong(packetEntry->PacketNumber, PacketNumber);
+    if (!NT_SUCCESS(ntStatus))
+    {
+        goto Exit;
+    }
+
+    packetData = (PBYTE) Packets[(*PacketNumber) % PacketCount];
+
+    *PerformanceCounterValue = packetEntry->QpcWhenSampled;
+    *MoreData = !IsListEmpty(&PacketFifoHead);
+
+    // TODO: the packet size here needs to line up to the packet size allocated.
+    // Also, handle the first packet offset
+    RtlCopyMemory(packetData, packetEntry->Samples, min(sizeof(packetEntry->Samples), PacketSize));
+
+Exit:
+    if (packetListEntry != NULL)
+    {
+        ExInterlockedInsertTailList(&PacketPoolHead, packetListEntry, &PacketPoolSpinLock);
+    }
+
+    return ntStatus;
+}
diff --git a/audio/Acx/Samples/Common/KeywordDetector.h b/audio/Acx/Samples/Common/KeywordDetector.h
new file mode 100644
index 00000000..2d5293b8
--- /dev/null
+++ b/audio/Acx/Samples/Common/KeywordDetector.h
@@ -0,0 +1,145 @@
+/*++
+
+Copyright (c) Microsoft Corporation All Rights Reserved
+
+Module Name:
+
+    KeywordDetector.h
+
+Abstract:
+
+    Sample Keyword Detector.
+
+
+--*/
+
+#pragma once
+
+typedef struct
+{
+    SOUNDDETECTOR_PATTERNHEADER Header;
+    LONGLONG                    ContosoDetectorConfigurationData;
+} CONTOSO_KEYWORDCONFIGURATION;
+
+typedef struct
+{
+    SOUNDDETECTOR_PATTERNHEADER Header;
+    LONGLONG                    ContosoDetectorResultData;
+    ULONGLONG                   KeywordStartTimestamp;
+    ULONGLONG                   KeywordStopTimestamp;
+    GUID                        EventId;
+} CONTOSO_KEYWORDDETECTIONRESULT;
+
+DEFINE_GUID(CONTOSO_KEYWORDCONFIGURATION_IDENTIFIER2,
+0x207f3d0c, 0x5c79, 0x496f, 0xa9, 0x4c, 0xd3, 0xd2, 0x93, 0x4d, 0xbf, 0xa9);
+
+// {A537F559-2D67-463B-B10E-BEB750A21F31}
+DEFINE_GUID(CONTOSO_KEYWORD1,
+0xa537f559, 0x2d67, 0x463b, 0xb1, 0xe, 0xbe, 0xb7, 0x50, 0xa2, 0x1f, 0x31);
+// {655E417A-80A5-4A77-B3F1-512EAF67ABCF}
+DEFINE_GUID(CONTOSO_KEYWORD2,
+0x655e417a, 0x80a5, 0x4a77, 0xb3, 0xf1, 0x51, 0x2e, 0xaf, 0x67, 0xab, 0xcf);
+
+#define KEYWORDDETECTOR_POOLTAG 'KWS0'
+
+class CKeywordDetector
+{
+public:
+    PAGED_CODE_SEG
+    CKeywordDetector();
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS ResetDetector(_In_ GUID eventId);
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS DownloadDetectorData(_In_ GUID eventId, _In_ LONGLONG Data);
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS GetDetectorData(_In_ GUID eventId, _Out_ LONGLONG *Data);
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    ULONGLONG GetStartTimestamp();
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    ULONGLONG GetStopTimestamp();
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS SetArmed(_In_ GUID eventId, _In_ BOOLEAN Arm);
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    VOID NotifyDetection();
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS GetArmed(_In_ GUID eventId, _Out_ BOOLEAN *Arm);
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    VOID Run();
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    VOID Stop();
+
+    _IRQL_requires_min_(DISPATCH_LEVEL)
+    VOID DpcRoutine(_In_ LONGLONG PerformanceCounter, _In_ LONGLONG PerformanceFrequency);
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    NTSTATUS GetReadPacket(_In_ ULONG PacketCount, _In_  ULONG PacketSize, _Out_writes_(PacketSize) PVOID *Packets, _Out_ ULONG *PacketNumber, _Out_ ULONGLONG *PerformanceCount, _Out_ BOOLEAN *MoreData);
+
+private:
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    VOID ResetFifo();
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS ReadKeywordTimestampRegistry();
+
+    _IRQL_requires_max_(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    VOID StartBufferingStream();
+
+    // The Contoso keyword detector processes 10ms packets of 16KHz 16-bit PCM
+    // audio samples
+    static const int SamplesPerSecond = 16000;
+    static const int SamplesPerPacket = (10 * SamplesPerSecond / 1000);
+
+    typedef struct
+    {
+        LIST_ENTRY  ListEntry;
+        LONGLONG    PacketNumber;
+        LONGLONG    QpcWhenSampled;
+        UINT16      Samples[SamplesPerPacket];
+    } PACKET_ENTRY;
+
+    BOOLEAN         m_streamRunning;
+
+    BOOLEAN         m_SoundDetectorArmed1;
+    BOOLEAN         m_SoundDetectorArmed2;
+    LONGLONG        m_SoundDetectorData1;
+    LONGLONG        m_SoundDetectorData2;
+
+    LONGLONG        m_qpcStartCapture;
+    LONGLONG        m_qpcFrequency;
+    LONGLONG        m_nLastQueuedPacket;
+
+    ULONGLONG       m_ullKeywordStartTimestamp;
+    ULONGLONG       m_ullKeywordStopTimestamp;
+
+    KSPIN_LOCK      PacketPoolSpinLock;
+    LIST_ENTRY      PacketPoolHead;
+    PACKET_ENTRY    PacketPool[1 * SamplesPerSecond / SamplesPerPacket];    // Enough storage for 1 second of audio data
+
+    KSPIN_LOCK      PacketFifoSpinLock;
+    LIST_ENTRY      PacketFifoHead;
+
+};
+
diff --git a/audio/Acx/Samples/Common/NewDelete.cpp b/audio/Acx/Samples/Common/NewDelete.cpp
new file mode 100644
index 00000000..583d36c5
--- /dev/null
+++ b/audio/Acx/Samples/Common/NewDelete.cpp
@@ -0,0 +1,91 @@
+/*++
+    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:
+    newdelete.cpp
+Abstract:
+    Contains overloaded placement new and delete operators
+Environment:
+    Kernel mode
+--*/
+
+#include "private.h"
+#include "NewDelete.h"
+
+/*****************************************************************************
+ * ::new(POOL_FLAGS)
+ *****************************************************************************
+ * New function for creating objects with a specified pool flags.
+ */
+PVOID operator new(
+    _In_ size_t size,
+    _In_ POOL_FLAGS poolFlags
+)
+{
+    PVOID result = ExAllocatePool2(poolFlags, size, 'wNwS');
+
+    return result;
+}
+
+/*****************************************************************************
+ * ::new(POOL_FLAGS, TAG)
+ *****************************************************************************
+ * New function for creating objects with specified pool flags and allocation tag.
+ */
+PVOID operator new(
+    _In_ size_t size,
+    _In_ POOL_FLAGS poolFlags,
+    _In_ ULONG tag
+)
+{
+    PVOID result = ExAllocatePool2(poolFlags, size, tag);
+
+    return result;
+}
+
+void __cdecl operator delete(PVOID buffer)
+{
+    if (buffer)
+    {
+        ExFreePool(buffer);
+    }
+}
+
+void __cdecl operator delete(PVOID buffer, ULONG tag)
+{
+    if (buffer)
+    {
+        ExFreePoolWithTag(buffer, tag);
+    }
+}
+
+void __cdecl operator delete(_Pre_maybenull_ __drv_freesMem(Mem) PVOID buffer, _In_ size_t cbSize)
+{
+    UNREFERENCED_PARAMETER(cbSize);
+
+    if (buffer)
+    {
+        ExFreePool(buffer);
+    }
+}
+
+void __cdecl operator delete[](_Pre_maybenull_ __drv_freesMem(Mem) PVOID buffer)
+{
+    if (buffer)
+    {
+        ExFreePool(buffer);
+    }
+}
+
+void __cdecl operator delete[](_Pre_maybenull_ __drv_freesMem(Mem) PVOID buffer, _In_ size_t cbSize)
+{
+    UNREFERENCED_PARAMETER(cbSize);
+
+    if (buffer)
+    {
+        ExFreePool(buffer);
+    }
+}
+
diff --git a/audio/Acx/Samples/Common/NewDelete.h b/audio/Acx/Samples/Common/NewDelete.h
new file mode 100644
index 00000000..fb660ff9
--- /dev/null
+++ b/audio/Acx/Samples/Common/NewDelete.h
@@ -0,0 +1,58 @@
+/*++
+Copyright (c) Microsoft Corporation.  All rights reserved.
+    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:
+    NewDelete.h
+Abstract:
+    Contains overloaded placement new and delete operators
+Environment:
+    Kernel mode
+--*/
+
+/*****************************************************************************
+ * ::new(POOL_FLAGS)
+ *****************************************************************************
+ * New function for creating objects with a specified pool flags.
+ */
+PVOID operator new(
+    _In_ size_t size,
+    _In_ POOL_FLAGS poolFlags
+);
+
+/*****************************************************************************
+ * ::new(POOL_FLAGS, TAG)
+ *****************************************************************************
+ * New function for creating objects with specified pool flags and allocation tag.
+ */
+PVOID operator new(
+    _In_ size_t size,
+    _In_ POOL_FLAGS poolFlags,
+    _In_ ULONG tag
+);
+
+/*****************************************************************************
+ * ::delete()
+ *****************************************************************************
+ * Delete function.
+ */
+void __cdecl operator delete(PVOID buffer);
+
+/*****************************************************************************
+ * ::delete()
+ *****************************************************************************
+ * Delete function.
+ */
+void __cdecl operator delete(PVOID buffer, ULONG tag);
+
+void __cdecl operator delete[](PVOID pVoid, _In_ size_t cbSize);
+
+void __cdecl operator delete(_Pre_maybenull_ __drv_freesMem(Mem) PVOID buffer, _In_ size_t cbSize);
+
+void __cdecl operator delete[](_Pre_maybenull_ __drv_freesMem(Mem) PVOID buffer);
+
+void __cdecl operator delete[](_Pre_maybenull_ __drv_freesMem(Mem) PVOID buffer, _In_ size_t cbSize);
+
+
diff --git a/audio/Acx/Samples/Common/Private.h b/audio/Acx/Samples/Common/Private.h
new file mode 100644
index 00000000..da89ef78
--- /dev/null
+++ b/audio/Acx/Samples/Common/Private.h
@@ -0,0 +1,922 @@
+/*++
+
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+    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:
+
+    Private.h
+
+Abstract:
+
+    Contains structure definitions and function prototypes private to
+    the Common library.
+
+Environment:
+
+    Kernel mode
+
+--*/
+
+#ifndef _PRIVATE_H_
+#define _PRIVATE_H_
+
+
+#include <wdm.h>
+#include <windef.h>
+#include "cpp_utils.h"
+#include <mmsystem.h>
+#include <ks.h>
+#include <ksmedia.h>
+#include "NewDelete.h"
+
+/* make prototypes usable from C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <initguid.h>
+#include <ntddk.h>
+#include <ntstrsafe.h>
+#include <ntintsafe.h>
+#include "Trace.h"
+
+#include <wdf.h>
+#include <acx.h>
+
+#define PAGED_CODE_SEG __declspec(code_seg("PAGE"))
+#define INIT_CODE_SEG __declspec(code_seg("INIT"))
+
+extern const GUID DSP_CIRCUIT_SPEAKER_GUID;
+extern const GUID DSP_CIRCUIT_MICROPHONE_GUID;
+extern const GUID DSP_CIRCUIT_UNIVERSALJACK_RENDER_GUID;
+extern const GUID DSP_CIRCUIT_UNIVERSALJACK_CAPTURE_GUID;
+
+/////////////////////////////////////////////////////////
+//
+// Driver wide definitions
+//
+
+// Copied from cfgmgr32.h
+#if !defined(MAX_DEVICE_ID_LEN)
+#define MAX_DEVICE_ID_LEN 200
+#endif
+
+// Number of millisecs per sec. 
+#define MS_PER_SEC 1000
+
+// Number of hundred nanosecs per sec. 
+#define HNS_PER_SEC 10000000
+
+#define REQUEST_TIMEOUT_SECONDS 5
+
+#undef MIN
+#undef MAX
+#define MIN(a,b) ((a) > (b) ? (b) : (a))
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+
+#ifndef BOOL
+typedef int BOOL;
+#endif
+
+#ifndef SIZEOF_ARRAY
+#define SIZEOF_ARRAY(ar)        (sizeof(ar)/sizeof((ar)[0]))
+#endif // !defined(SIZEOF_ARRAY)
+
+#ifndef RGB
+#define RGB(r, g, b) (DWORD)(r << 16 | g << 8 | b)
+#endif
+
+#define ALL_CHANNELS_ID             UINT32_MAX
+#define MAX_CHANNELS                2
+    
+//
+// Ks support.
+//
+#define KSPROPERTY_TYPE_ALL         KSPROPERTY_TYPE_BASICSUPPORT | \
+                                        KSPROPERTY_TYPE_GET | \
+                                        KSPROPERTY_TYPE_SET
+
+//
+// Define struct to hold signal processing mode and corresponding
+// list of supported formats. 
+//
+typedef struct
+{
+    GUID SignalProcessingMode;
+    KSDATAFORMAT_WAVEFORMATEXTENSIBLE* FormatList;
+    ULONG FormatListCount;
+} SUPPORTED_FORMATS_LIST;
+
+//
+// Define CAPTURE device context.
+//
+typedef struct _CAPTURE_DEVICE_CONTEXT {
+    ACXCIRCUIT      Circuit;
+    BOOLEAN         FirstTimePrepareHardware;
+} CAPTURE_DEVICE_CONTEXT, * PCAPTURE_DEVICE_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(CAPTURE_DEVICE_CONTEXT, GetCaptureDeviceContext)
+
+//
+// Define RENDER device context.
+//
+typedef struct _RENDER_DEVICE_CONTEXT {
+    ACXCIRCUIT      Circuit;
+    BOOLEAN         FirstTimePrepareHardware;
+} RENDER_DEVICE_CONTEXT, * PRENDER_DEVICE_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(RENDER_DEVICE_CONTEXT, GetRenderDeviceContext)
+
+//
+// Define circuit/stream element context.
+//
+typedef struct _ELEMENT_CONTEXT {
+    BOOLEAN         Dummy;
+} ELEMENT_CONTEXT, *PELEMENT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(ELEMENT_CONTEXT, GetElementContext)
+    
+//
+// Define circuit/stream element context.
+//
+typedef struct _MUTE_ELEMENT_CONTEXT {
+    BOOL            MuteState[MAX_CHANNELS]; 
+} MUTE_ELEMENT_CONTEXT, *PMUTE_ELEMENT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(MUTE_ELEMENT_CONTEXT, GetMuteElementContext)
+
+//
+// Define circuit/stream element context.
+//
+typedef struct _VOLUME_ELEMENT_CONTEXT {
+    LONG            VolumeLevel[MAX_CHANNELS];
+} VOLUME_ELEMENT_CONTEXT, *PVOLUME_ELEMENT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(VOLUME_ELEMENT_CONTEXT, GetVolumeElementContext)
+
+#define VOLUME_STEPPING         0x8000
+#define VOLUME_LEVEL_MAXIMUM    0x00000000
+#define VOLUME_LEVEL_MINIMUM    (-96 * 0x10000)
+    
+//
+// Define mute timer context.
+//
+typedef struct _MUTE_TIMER_CONTEXT {
+    ACXELEMENT      MuteElement;
+    ACXEVENT        Event;
+} MUTE_TIMER_CONTEXT, *PMUTE_TIMER_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(MUTE_TIMER_CONTEXT, GetMuteTimerContext)
+
+//
+// Define format context.
+//
+typedef struct _FORMAT_CONTEXT {
+    BOOLEAN         Dummy;
+} FORMAT_CONTEXT, *PFORMAT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(FORMAT_CONTEXT, GetFormatContext)
+
+//
+// Define jack context.
+//
+typedef struct _JACK_CONTEXT {
+    ULONG Dummy;
+} JACK_CONTEXT, * PJACK_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(JACK_CONTEXT, GetJackContext)
+
+//
+// Define audio engine context.
+//
+typedef struct _ENGINE_CONTEXT {
+    ACXDATAFORMAT   MixFormat;
+} ENGINE_CONTEXT, * PENGINE_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(ENGINE_CONTEXT, GetEngineContext)
+
+//
+// Define stream audio engine context.
+//
+typedef struct _STREAMAUDIOENGINE_CONTEXT {
+    BOOLEAN         Dummy;
+} STREAMAUDIOENGINE_CONTEXT, * PSTREAMAUDIOENGINE_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(STREAMAUDIOENGINE_CONTEXT, GetStreamAudioEngineContext)
+
+//
+// Define keyword spotter context
+//
+typedef struct _KEYWORDSPOTTER_CONTEXT {
+    ACXPNPEVENT Event;
+    PVOID       KeywordDetector;
+} KEYWORDSPOTTER_CONTEXT, * PKEYWORDSPOTTER_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(KEYWORDSPOTTER_CONTEXT, GetKeywordSpotterContext)
+
+//
+// Define pnp event context.
+//
+typedef struct _PNPEVENT_CONTEXT {
+    BOOLEAN         Dummy;
+} PNPEVENT_CONTEXT, * PPNPEVENT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(PNPEVENT_CONTEXT, GetPnpEventContext)
+
+//
+// Define peakmeter element context.
+//
+typedef struct _PEAKMETER_ELEMENT_CONTEXT {
+    LONG            PeakMeterLevel[MAX_CHANNELS];
+} PEAKMETER_ELEMENT_CONTEXT, * PPEAKMETER_ELEMENT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(PEAKMETER_ELEMENT_CONTEXT, GetPeakMeterElementContext)
+
+//
+// Define DSP circuit's peakmeter element context.
+//
+typedef struct _DSP_PEAKMETER_ELEMENT_CONTEXT
+{
+    PVOID peakMeter;
+} DSP_PEAKMETER_ELEMENT_CONTEXT, *PDSP_PEAKMETER_ELEMENT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(DSP_PEAKMETER_ELEMENT_CONTEXT, GetDspPeakMeterElementContext)
+
+//
+// Define stream engine context.
+//
+typedef struct _STREAMENGINE_CONTEXT {
+    PVOID                   StreamEngine;
+} STREAMENGINE_CONTEXT, * PSTREAMENGINE_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(STREAMENGINE_CONTEXT, GetStreamEngineContext)
+
+#define PEAKMETER_STEPPING_DELTA    0x1000
+#define PEAKMETER_MAXIMUM           LONG_MAX
+#define PEAKMETER_MINIMUM           LONG_MIN
+
+/////////////////////////////////////////////////////////////
+// Codec driver defintions
+//
+
+typedef enum _CODEC_PIN_TYPE {
+    CodecPinTypeHost,
+    CodecPinTypeOffload,
+    CodecPinTypeLoopback,
+    CodecPinTypeKeyword,
+    CodecPinTypeDevice
+} CODEC_PIN_TYPE, * PCODEC_PIN_TYPE;
+
+typedef struct _CODEC_PIN_CONTEXT {
+    CODEC_PIN_TYPE  CodecPinType;
+} CODEC_PIN_CONTEXT, * PCODEC_PIN_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(CODEC_PIN_CONTEXT, GetCodecPinContext)
+
+///////////////////////////////////////////////////////////
+// Dsp driver definitions
+//
+
+typedef enum {
+    CaptureHostPin = 0,
+    CaptureBridgePin = 1,
+    CaptureKWSPin = 2,
+    CapturePinCount = 3
+} CAPTURE_PIN_TYPE;
+
+typedef enum {
+    RenderHostPin = 0,
+    RenderOffloadPin = 1,
+    RenderLoopbackPin = 2,
+    RenderBridgePin = 3,
+    RenderPinCount = 4
+} RENDER_PIN_TYPE;
+
+typedef struct _DSP_PIN_CONTEXT {
+    ACXTARGETCIRCUIT        TargetCircuit;
+    ULONG                   TargetPinId;
+    RENDER_PIN_TYPE         RenderPinType;
+    CAPTURE_PIN_TYPE        CapturePinType;
+
+    // The stream bridge below will only be valid for the Capture circuit Bridge Pin
+
+    // Host stream bridge will be used to ensure host stream creations are passed
+    // to the downlevel circuits. Since the HostStreamBridge won't have InModes set,
+    // the ACX framework will not add streams automatically. We will add streams for
+    // non KWS pin.
+    ACXSTREAMBRIDGE         HostStreamBridge;
+} DSP_PIN_CONTEXT, * PDSP_PIN_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(DSP_PIN_CONTEXT, GetDspPinContext)
+
+/////////////////////////////////////////////////////////////
+// Multicircuit Dsp driver definitions
+//
+
+//
+// Circuit context for multi circuit dsp circuits.
+//
+typedef struct _DSP_CIRCUIT_CONTEXT
+{
+    ACXAUDIOENGINE AudioEngineElement;
+    ACXPEAKMETER PeakMeterElement;
+    PVOID peakMeter;
+    ACXKEYWORDSPOTTER KeywordSpotter;
+    BOOLEAN IsRenderCircuit;
+} DSP_CIRCUIT_CONTEXT, *PDSP_CIRCUIT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(DSP_CIRCUIT_CONTEXT, GetDspCircuitContext)
+
+typedef struct _DSP_ENGINE_CONTEXT
+{
+    ACXDATAFORMAT MixFormat;
+    BOOLEAN GFxEnabled;
+} DSP_ENGINE_CONTEXT, *PDSP_ENGINE_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(DSP_ENGINE_CONTEXT, GetDspEngineContext)
+
+typedef struct _DSP_STREAMAUDIOENGINE_CONTEXT
+{
+    BOOLEAN LFxEnabled;
+} DSP_STREAMAUDIOENGINE_CONTEXT, *PDSP_STREAMAUDIOENGINE_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(DSP_STREAMAUDIOENGINE_CONTEXT, GetDspStreamAudioEngineContext)
+
+/////////////////////////////////////////////////////////
+//
+// Codec Render (speaker) definitions
+//
+
+//
+// Define render circuit context.
+//
+typedef struct _CODEC_RENDER_CIRCUIT_CONTEXT {
+    ACXVOLUME       VolumeElement;
+    ACXMUTE         MuteElement;
+    ACXPEAKMETER    PeakMeterElement;
+    ACXAUDIOENGINE  AudioEngineElement;
+} CODEC_RENDER_CIRCUIT_CONTEXT, * PCODEC_RENDER_CIRCUIT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(CODEC_RENDER_CIRCUIT_CONTEXT, GetRenderCircuitContext)
+
+typedef enum {
+    CodecRenderHostPin = 0,
+    CodecRenderBridgePin = 1,
+    CodecRenderPinCount = 2
+} CODEC_RENDER_PINS;
+
+typedef enum {
+    RenderVolumeIndex = 0,
+    RenderMuteIndex = 1,
+    RenderElementCount = 2
+} CODEC_RENDER_ELEMENTS;
+
+// Render callbacks.
+
+EVT_ACX_CIRCUIT_CREATE_STREAM       CodecR_EvtCircuitCreateStream;
+EVT_ACX_CIRCUIT_POWER_UP            CodecR_EvtCircuitPowerUp;
+EVT_ACX_CIRCUIT_POWER_DOWN          CodecR_EvtCircuitPowerDown;
+EVT_ACX_STREAM_SET_RENDER_PACKET    CodecR_EvtStreamSetRenderPacket;
+EVT_ACX_STREAM_GET_CAPTURE_PACKET   CodecR_EvtStreamGetLoopbackPacket;
+EVT_ACX_PIN_SET_DATAFORMAT          CodecR_EvtAcxPinSetDataFormat;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP      CodecR_EvtPinContextCleanup;
+EVT_ACX_MUTE_ASSIGN_STATE           CodecR_EvtMuteAssignState;
+EVT_ACX_MUTE_RETRIEVE_STATE         CodecR_EvtMuteRetrieveState;
+EVT_ACX_VOLUME_ASSIGN_LEVEL         CodecR_EvtVolumeAssignLevel;
+EVT_ACX_VOLUME_RETRIEVE_LEVEL       CodecR_EvtVolumeRetrieveLevel;
+EVT_ACX_PEAKMETER_RETRIEVE_LEVEL    CodecR_EvtPeakMeterRetrieveLevelCallback;
+EVT_ACX_RAMPED_VOLUME_ASSIGN_LEVEL              CodecR_EvtRampedVolumeAssignLevel;
+EVT_ACX_AUDIOENGINE_RETRIEVE_BUFFER_SIZE_LIMITS CodecR_EvtAcxAudioEngineRetrieveBufferSizeLimits;
+EVT_ACX_AUDIOENGINE_RETRIEVE_EFFECTS_STATE      CodecR_EvtAcxAudioEngineRetrieveEffectsState;
+EVT_ACX_AUDIOENGINE_ASSIGN_EFFECTS_STATE        CodecR_EvtAcxAudioEngineAssignEffectsState;
+EVT_ACX_AUDIOENGINE_ASSIGN_ENGINE_FORMAT        CodecR_EvtAcxAudioEngineAssignEngineDeviceFormat;
+EVT_ACX_AUDIOENGINE_RETRIEVE_ENGINE_FORMAT      CodecR_EvtAcxAudioEngineRetrieveEngineMixFormat;
+EVT_ACX_STREAMAUDIOENGINE_RETRIEVE_EFFECTS_STATE            CodecR_EvtAcxStreamAudioEngineRetrieveEffectsState;
+EVT_ACX_STREAMAUDIOENGINE_ASSIGN_EFFECTS_STATE              CodecR_EvtAcxStreamAudioEngineAssignEffectsState;
+EVT_ACX_STREAMAUDIOENGINE_RETRIEVE_PRESENTATION_POSITION    CodecR_EvtAcxStreamAudioEngineRetrievePresentationPosition;
+EVT_ACX_STREAMAUDIOENGINE_ASSIGN_CURRENT_WRITE_POSITION     CodecR_EvtAcxStreamAudioEngineAssignCurrentWritePosition;
+EVT_ACX_STREAMAUDIOENGINE_RETRIEVE_LINEAR_BUFFER_POSITION   CodecR_EvtAcxStreamAudioEngineRetrieveLinearBufferPosition;
+EVT_ACX_STREAMAUDIOENGINE_ASSIGN_LAST_BUFFER_POSITION       CodecR_EvtAcxStreamAudioEngineAssignLastBufferPosition;
+EVT_ACX_STREAMAUDIOENGINE_ASSIGN_LOOPBACK_PROTECTION        CodecR_EvtAcxStreamAudioEngineAssignLoopbackProtection;
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecR_CreateRenderCircuit(
+    _In_     WDFDEVICE              Device,
+    _In_     const GUID *           ComponentGuid,
+    _In_     const UNICODE_STRING * CircuitName,
+    _Out_    ACXCIRCUIT *           Circuit
+);
+
+/////////////////////////////////////////////////////////
+//
+// Codec Capture (microphone) definitions
+//
+
+//
+// Define capture circuit context.
+//
+typedef struct _CODEC_CAPTURE_CIRCUIT_CONTEXT {
+    ACXVOLUME           BoostElement;
+    ACXVOLUME           VolumeElement;
+    ACXKEYWORDSPOTTER   KeywordSpotter;
+} CODEC_CAPTURE_CIRCUIT_CONTEXT, * PCODEC_CAPTURE_CIRCUIT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(CODEC_CAPTURE_CIRCUIT_CONTEXT, GetCaptureCircuitContext)
+
+typedef enum {
+    CodecCaptureHostPin = 0,
+    CodecCaptureBridgePin = 1,
+    CodecCapturePinCount = 2
+} CODEC_CAPTURE_PINS;
+
+typedef enum {
+    CaptureVolumeIndex = 0,
+    CaptureElementCount = 1
+} CAPTURE_ELEMENTS;
+
+// Capture callbacks.
+
+EVT_ACX_CIRCUIT_CREATE_STREAM       CodecC_EvtCircuitCreateStream;
+EVT_ACX_CIRCUIT_POWER_UP            CodecC_EvtCircuitPowerUp;
+EVT_ACX_CIRCUIT_POWER_DOWN          CodecC_EvtCircuitPowerDown;
+EVT_ACX_VOLUME_ASSIGN_LEVEL         CodecC_EvtVolumeAssignLevelCallback;
+EVT_ACX_VOLUME_RETRIEVE_LEVEL       CodecC_EvtVolumeRetrieveLevelCallback;
+EVT_ACX_VOLUME_ASSIGN_LEVEL         CodecC_EvtBoostAssignLevelCallback;
+EVT_ACX_VOLUME_RETRIEVE_LEVEL       CodecC_EvtBoostRetrieveLevelCallback;
+EVT_ACX_STREAM_GET_CAPTURE_PACKET   CodecC_EvtStreamGetCapturePacket;
+EVT_ACX_PIN_SET_DATAFORMAT          CodecC_EvtAcxPinSetDataFormat;
+EVT_ACX_PIN_RETRIEVE_NAME           CodecC_EvtAcxPinRetrieveName;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP      CodecC_EvtPinContextCleanup;
+EVT_ACX_KEYWORDSPOTTER_RETRIEVE_ARM     CodecC_EvtAcxKeywordSpotterRetrieveArm;
+EVT_ACX_KEYWORDSPOTTER_ASSIGN_ARM       CodecC_EvtAcxKeywordSpotterAssignArm;
+EVT_ACX_KEYWORDSPOTTER_ASSIGN_PATTERNS  CodecC_EvtAcxKeywordSpotterAssignPatterns;
+EVT_ACX_KEYWORDSPOTTER_ASSIGN_RESET     CodecC_EvtAcxKeywordSpotterAssignReset;
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecC_CreateCaptureCircuit(
+    _In_     WDFDEVICE              Device,
+    _In_     const GUID *           ComponentGuid,
+    _In_     const GUID *           MicCustomName,
+    _In_     const UNICODE_STRING * CircuitName,
+    _Out_    ACXCIRCUIT *           Circuit
+);
+
+/////////////////////////////////////////////////////////
+//
+// MicArray definitions
+//
+
+//
+// Define MicArray circuit context.
+//
+typedef struct _MICARRAY_CIRCUIT_CONTEXT {
+    ACXMUTE             MuteElement;
+    ACXVOLUME           VolumeElement;
+    ACXPEAKMETER        PeakMeterElement;
+    ACXKEYWORDSPOTTER   KeywordSpotter;
+} MICARRAY_CIRCUIT_CONTEXT, * PMICARRAY_CIRCUIT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(MICARRAY_CIRCUIT_CONTEXT, GetMicArrayCircuitContext)
+
+typedef enum {
+    MicArrayVolumeIndex = 0,
+    MicArrayMuteIndex = 1,
+    MicArrayPeakmeterIndex = 2,
+    MicArrayKWSIndex = 3,
+    MicArrayElementCount = 4
+} MICARRAY_ELEMENTS;
+
+// MicArray callbacks.
+
+EVT_ACX_MUTE_ASSIGN_STATE           MicArray_EvtMuteAssignState;
+EVT_ACX_MUTE_RETRIEVE_STATE         MicArray_EvtMuteRetrieveState;
+EVT_ACX_PEAKMETER_RETRIEVE_LEVEL    MicArray_EvtPeakMeterRetrieveLevelCallback;
+EVT_ACX_CIRCUIT_CREATE_STREAM       MicArray_EvtCircuitCreateStream;
+EVT_ACX_CIRCUIT_POWER_UP            MicArray_EvtCircuitPowerUp;
+EVT_ACX_CIRCUIT_POWER_DOWN          MicArray_EvtCircuitPowerDown;
+EVT_ACX_VOLUME_ASSIGN_LEVEL         MicArray_EvtVolumeAssignLevelCallback;
+EVT_ACX_VOLUME_RETRIEVE_LEVEL       MicArray_EvtVolumeRetrieveLevelCallback;
+EVT_ACX_STREAM_GET_CAPTURE_PACKET   MicArray_EvtStreamGetCapturePacket;
+EVT_ACX_PIN_SET_DATAFORMAT          MicArray_EvtAcxPinSetDataFormat;
+EVT_ACX_PIN_RETRIEVE_NAME           MicArray_EvtAcxPinRetrieveName;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP      MicArray_EvtPinContextCleanup;
+EVT_ACX_KEYWORDSPOTTER_RETRIEVE_ARM     MicArray_EvtAcxKeywordSpotterRetrieveArm;
+EVT_ACX_KEYWORDSPOTTER_ASSIGN_ARM       MicArray_EvtAcxKeywordSpotterAssignArm;
+EVT_ACX_KEYWORDSPOTTER_ASSIGN_PATTERNS  MicArray_EvtAcxKeywordSpotterAssignPatterns;
+EVT_ACX_KEYWORDSPOTTER_ASSIGN_RESET     MicArray_EvtAcxKeywordSpotterAssignReset;
+EVT_ACX_PIN_CONNECTED                   MicArray_EvtPinConnected;
+EVT_ACX_PIN_DISCONNECTED                MicArray_EvtPinDisconnected;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP          MicArray_EvtDeviceContextCleanup;
+EVT_ACX_OBJECT_PROCESS_REQUEST          MicArray_EvtPinProposeDataFormat2Callback;
+EVT_ACX_OBJECT_PREPROCESS_REQUEST       MicArray_EvtAudioCpuResourcesCallback;
+
+PAGED_CODE_SEG
+NTSTATUS
+MicArray_CreateCaptureCircuit(
+    _In_     WDFDEVICE        Device,
+    _In_     GUID             ComponentGuid,
+    _In_     GUID             MicCustomName,
+    _In_     UNICODE_STRING   CircuitName,
+    _Out_    ACXCIRCUIT *     Circuit
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+MicArray_SetPowerPolicy(
+    _In_ WDFDEVICE            Device
+);
+
+/////////////////////////////////////////////////////////
+//
+// Microphone (external: headphone) definitions
+//
+
+//
+// Define MicrophoneHp circuit context.
+//
+typedef struct _MICROPHONEHP_CIRCUIT_CONTEXT {
+    ACXMUTE             MuteElement;
+    ACXVOLUME           VolumeElement;
+    ACXPEAKMETER        PeakMeterElement;
+} MICROPHONEHP_CIRCUIT_CONTEXT, * PMICROPHONEHP_CIRCUIT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(MICROPHONEHP_CIRCUIT_CONTEXT, GetMicrophoneHpCircuitContext)
+
+typedef enum {
+    MicrophoneHpVolumeIndex = 0,
+    MicrophoneHpMuteIndex = 1,
+    MicrophoneHpPeakmeterIndex = 2,
+    MicrophoneHpElementCount = 3
+} MICROPHONEHP_ELEMENTS;
+
+// MicrophoneHp callbacks.
+
+EVT_ACX_MUTE_ASSIGN_STATE           MicrophoneHp_EvtMuteAssignState;
+EVT_ACX_MUTE_RETRIEVE_STATE         MicrophoneHp_EvtMuteRetrieveState;
+EVT_ACX_PEAKMETER_RETRIEVE_LEVEL    MicrophoneHp_EvtPeakMeterRetrieveLevelCallback;
+EVT_ACX_CIRCUIT_CREATE_STREAM       MicrophoneHp_EvtCircuitCreateStream;
+EVT_ACX_CIRCUIT_POWER_UP            MicrophoneHp_EvtCircuitPowerUp;
+EVT_ACX_CIRCUIT_POWER_DOWN          MicrophoneHp_EvtCircuitPowerDown;
+EVT_ACX_VOLUME_ASSIGN_LEVEL         MicrophoneHp_EvtVolumeAssignLevelCallback;
+EVT_ACX_VOLUME_RETRIEVE_LEVEL       MicrophoneHp_EvtVolumeRetrieveLevelCallback;
+EVT_ACX_STREAM_GET_CAPTURE_PACKET   MicrophoneHp_EvtStreamGetCapturePacket;
+EVT_ACX_PIN_SET_DATAFORMAT          MicrophoneHp_EvtAcxPinSetDataFormat;
+EVT_ACX_PIN_RETRIEVE_NAME           MicrophoneHp_EvtAcxPinRetrieveName;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP      MicrophoneHp_EvtPinContextCleanup;
+EVT_ACX_PIN_CONNECTED               MicrophoneHp_EvtPinConnected;
+EVT_ACX_PIN_DISCONNECTED            MicrophoneHp_EvtPinDisconnected;
+EVT_ACX_OBJECT_PREPROCESS_REQUEST   MicrophoneHp_EvtAudioCpuResourcesCallback;
+
+PAGED_CODE_SEG
+NTSTATUS
+MicrophoneHp_CreateCaptureCircuit(
+    _In_     WDFDEVICE        Device,
+    _In_     GUID             ComponentGuid,
+    _In_     GUID             MicCustomName,
+    _In_     UNICODE_STRING   CircuitName,
+    _Out_    ACXCIRCUIT *     Circuit
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+MicrophoneHp_SetPowerPolicy(
+    _In_ WDFDEVICE            Device
+);
+
+/////////////////////////////////////////////////////////
+//
+// Speaker definitions
+//
+
+//
+// Define circuit context for Speaker and SpeakerHp. 
+//
+typedef struct _DSP_RENDER_CIRCUIT_CONTEXT {
+    ACXPEAKMETER    PeakMeterElement;
+    ACXAUDIOENGINE  AudioEngineElement;
+    PVOID           PeakMeter;
+} DSP_RENDER_CIRCUIT_CONTEXT, * PDSP_RENDER_CIRCUIT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(DSP_RENDER_CIRCUIT_CONTEXT, GetSpeakerCircuitContext)
+
+// Speaker callbacks.
+
+EVT_ACX_CIRCUIT_CREATE_STREAM       Speaker_EvtCircuitCreateStream;
+EVT_ACX_CIRCUIT_POWER_UP            Speaker_EvtCircuitPowerUp;
+EVT_ACX_CIRCUIT_POWER_DOWN          Speaker_EvtCircuitPowerDown;
+EVT_ACX_STREAM_SET_RENDER_PACKET    Speaker_EvtStreamSetRenderPacket;
+EVT_ACX_STREAM_GET_CAPTURE_PACKET   Speaker_EvtStreamGetLoopbackPacket;
+EVT_ACX_PIN_SET_DATAFORMAT          Speaker_EvtAcxPinSetDataFormat;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP      Speaker_EvtPinContextCleanup;
+EVT_ACX_PIN_CONNECTED               Speaker_EvtPinConnected;
+EVT_ACX_PIN_DISCONNECTED            Speaker_EvtPinDisconnected;
+
+//Render Audio Engine callbacks.
+
+EVT_ACX_MUTE_ASSIGN_STATE           Speaker_EvtMuteAssignState;
+EVT_ACX_MUTE_RETRIEVE_STATE         Speaker_EvtMuteRetrieveState;
+EVT_ACX_VOLUME_RETRIEVE_LEVEL       Speaker_EvtVolumeRetrieveLevel;
+EVT_ACX_PEAKMETER_RETRIEVE_LEVEL    Speaker_EvtPeakMeterRetrieveLevelCallback;
+EVT_ACX_RAMPED_VOLUME_ASSIGN_LEVEL              Speaker_EvtRampedVolumeAssignLevel;
+EVT_ACX_AUDIOENGINE_RETRIEVE_BUFFER_SIZE_LIMITS Speaker_EvtAcxAudioEngineRetrieveBufferSizeLimits;
+EVT_ACX_AUDIOENGINE_RETRIEVE_EFFECTS_STATE      Speaker_EvtAcxAudioEngineRetrieveEffectsState;
+EVT_ACX_AUDIOENGINE_ASSIGN_EFFECTS_STATE        Speaker_EvtAcxAudioEngineAssignEffectsState;
+EVT_ACX_AUDIOENGINE_ASSIGN_ENGINE_FORMAT        Speaker_EvtAcxAudioEngineAssignEngineDeviceFormat;
+EVT_ACX_AUDIOENGINE_RETRIEVE_ENGINE_FORMAT      Speaker_EvtAcxAudioEngineRetrieveEngineMixFormat;
+EVT_ACX_STREAMAUDIOENGINE_RETRIEVE_EFFECTS_STATE            Speaker_EvtAcxStreamAudioEngineRetrieveEffectsState;
+EVT_ACX_STREAMAUDIOENGINE_ASSIGN_EFFECTS_STATE              Speaker_EvtAcxStreamAudioEngineAssignEffectsState;
+EVT_ACX_STREAMAUDIOENGINE_RETRIEVE_PRESENTATION_POSITION    Speaker_EvtAcxStreamAudioEngineRetrievePresentationPosition;
+EVT_ACX_STREAMAUDIOENGINE_ASSIGN_CURRENT_WRITE_POSITION     Speaker_EvtAcxStreamAudioEngineAssignCurrentWritePosition;
+EVT_ACX_STREAMAUDIOENGINE_RETRIEVE_LINEAR_BUFFER_POSITION   Speaker_EvtAcxStreamAudioEngineRetrieveLinearBufferPosition;
+EVT_ACX_STREAMAUDIOENGINE_ASSIGN_LAST_BUFFER_POSITION       Speaker_EvtAcxStreamAudioEngineAssignLastBufferPosition;
+EVT_ACX_STREAMAUDIOENGINE_ASSIGN_LOOPBACK_PROTECTION        Speaker_EvtAcxStreamAudioEngineAssignLoopbackProtection;
+
+PAGED_CODE_SEG
+NTSTATUS
+Speaker_SetPowerPolicy(
+    _In_ WDFDEVICE      Device
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+Speaker_CreateRenderCircuit(
+    _In_     WDFDEVICE        Device,
+    _In_     GUID             ComponentGuid,
+    _In_     UNICODE_STRING   CircuitName,
+    _In_     BOOLEAN          IsHeadphones,
+    _Out_    ACXCIRCUIT *     Circuit
+);
+
+/////////////////////////////////////////////////////////
+//
+// HDMI definitions
+//
+
+//
+// Define HDMI circuit context.
+//
+typedef struct _DSP_HDMI_CIRCUIT_CONTEXT {
+    ACXVOLUME           VolumeElement;
+    ACXMUTE             MuteElement;
+    ACXPEAKMETER        PeakmeterElement;
+} DSP_HDMI_CIRCUIT_CONTEXT, * PDSP_HDMI_CIRCUIT_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(DSP_HDMI_CIRCUIT_CONTEXT, GetHDMICircuitContext)
+
+typedef enum {
+    HDMIVolumeIndex = 0,
+    HDMIMuteIndex = 1,
+    HDMIPeakmeterIndex = 2,
+    HDMIElementCount = 3
+} HDMI_ELEMENTS;
+
+typedef enum {
+    HDMIHostPin = 0,
+    HDMILoopbackPin = 1,
+    HDMIBridgePin = 2,
+    HDMIPinCount = 3
+} HDMI_PIN_TYPE;
+
+typedef struct _HDMI_PIN_CONTEXT {
+    ACXTARGETCIRCUIT        TargetCircuit;
+    ULONG                   TargetPinId;
+    HDMI_PIN_TYPE           PinType;
+    CAPTURE_PIN_TYPE        CapturePinType;
+} HDMI_PIN_CONTEXT, * PHDMI_PIN_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(HDMI_PIN_CONTEXT, GetHDMIPinContext)
+
+typedef struct _HDMI_STREAM_CONTEXT {
+    HDMI_PIN_TYPE           PinType;
+    CAPTURE_PIN_TYPE        CapturePinType;
+} HDMI_STREAM_CONTEXT, *    PHDMI_STREAM_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(HDMI_STREAM_CONTEXT, GetHDMIStreamContext)
+
+// HDMI callbacks.
+EVT_ACX_CIRCUIT_CREATE_STREAM       HDMI_EvtCircuitCreateStream;
+EVT_ACX_CIRCUIT_POWER_UP            HDMI_EvtCircuitPowerUp;
+EVT_ACX_CIRCUIT_POWER_DOWN          HDMI_EvtCircuitPowerDown;
+EVT_ACX_STREAM_SET_RENDER_PACKET    HDMI_EvtStreamSetRenderPacket;
+EVT_ACX_STREAM_GET_CAPTURE_PACKET   HDMI_EvtStreamGetLoopbackPacket;
+EVT_ACX_PIN_SET_DATAFORMAT          HDMI_EvtAcxPinSetDataFormat;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP      HDMI_EvtPinContextCleanup;
+EVT_ACX_PIN_CONNECTED               HDMI_EvtPinConnected;
+EVT_ACX_PIN_DISCONNECTED            HDMI_EvtPinDisconnected;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP      HDMI_EvtDeviceContextCleanup;
+EVT_ACX_MUTE_ASSIGN_STATE           HDMI_EvtMuteAssignState;
+EVT_ACX_MUTE_RETRIEVE_STATE         HDMI_EvtMuteRetrieveState;
+EVT_ACX_VOLUME_ASSIGN_LEVEL         HDMI_EvtRampedVolumeAssignLevel;
+EVT_ACX_VOLUME_RETRIEVE_LEVEL       HDMI_EvtVolumeRetrieveLevel;
+EVT_ACX_PEAKMETER_RETRIEVE_LEVEL    HDMI_EvtPeakMeterRetrieveLevelCallback;
+EVT_ACX_OBJECT_PREPROCESS_REQUEST   HDMI_EvtAudioCpuResourcesCallback;
+
+PAGED_CODE_SEG
+NTSTATUS
+HDMI_SetPowerPolicy(
+    _In_ WDFDEVICE      Device
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+HDMI_CreateRenderCircuit(
+    _In_     WDFDEVICE        Device,
+    _In_     GUID             ComponentGuid,
+    _In_     UNICODE_STRING   CircuitName,
+    _Out_    ACXCIRCUIT *     Circuit
+);
+
+/////////////////////////////////////////////////////////
+//
+// Multi circuit codec Render (speaker) definitions
+//
+
+// Uses the same circuit context, render pin, and render element definitions as Codec Render.
+
+// Render callbacks.
+EVT_ACX_CIRCUIT_CREATE_STREAM       RenderMC_EvtCircuitCreateStream;
+EVT_ACX_CIRCUIT_POWER_UP            RenderMC_EvtCircuitPowerUp;
+EVT_ACX_CIRCUIT_POWER_DOWN          RenderMC_EvtCircuitPowerDown;
+EVT_ACX_PIN_SET_DATAFORMAT          RenderMC_EvtAcxPinSetDataFormat;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP      RenderMC_EvtPinContextCleanup;
+EVT_ACX_MUTE_ASSIGN_STATE           RenderMC_EvtMuteAssignState;
+EVT_ACX_MUTE_RETRIEVE_STATE         RenderMC_EvtMuteRetrieveState;
+EVT_ACX_VOLUME_RETRIEVE_LEVEL       RenderMC_EvtVolumeRetrieveLevel;
+EVT_ACX_RAMPED_VOLUME_ASSIGN_LEVEL  RenderMC_EvtRampedVolumeAssignLevel;
+
+PAGED_CODE_SEG
+NTSTATUS
+RenderMC_CreateRenderCircuit(
+    _In_     WDFDEVICE              Device,
+    _In_     const GUID *           ComponentGuid,
+    _In_     const UNICODE_STRING * CircuitName,
+    _In_     const UNICODE_STRING * Uri,
+    _Out_    ACXCIRCUIT *           Circuit
+);
+
+/////////////////////////////////////////////////////////
+//
+// Multi circuit codec Capture (microphone) definitions
+//
+
+// Uses the same circuit context, render pin, and render element definitions as Codec Capture.
+
+// Capture callbacks.
+EVT_ACX_CIRCUIT_CREATE_STREAM       CaptureMC_EvtCircuitCreateStream;
+EVT_ACX_CIRCUIT_POWER_UP            CaptureMC_EvtCircuitPowerUp;
+EVT_ACX_CIRCUIT_POWER_DOWN          CaptureMC_EvtCircuitPowerDown;
+EVT_ACX_STREAM_GET_CAPTURE_PACKET   CaptureMC_EvtStreamGetCapturePacket;
+EVT_ACX_PIN_SET_DATAFORMAT          CaptureMC_EvtAcxPinSetDataFormat;
+EVT_ACX_PIN_RETRIEVE_NAME           CaptureMC_EvtAcxPinRetrieveName;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP      CaptureMC_EvtPinContextCleanup;
+
+PAGED_CODE_SEG
+NTSTATUS
+CaptureMC_CreateCaptureCircuit(
+    _In_     WDFDEVICE              Device,
+    _In_     const GUID *           ComponentGuid,
+    _In_     const GUID *           MicCustomName,
+    _In_     const UNICODE_STRING * CircuitName,
+    _In_     const UNICODE_STRING * Uri,
+    _Out_    ACXCIRCUIT *           Circuit
+);
+
+/////////////////////////////////////////////////////////
+//
+// Multi circuit dsp Render (speaker) definitions
+//
+
+// Uses the same circuit context, render pin, and render element definitions as Codec Render.
+
+// Render callbacks.
+EVT_ACX_CIRCUIT_COMPOSITE_CIRCUIT_INITIALIZE RenderMCDsp_EvtCircuitCompositeCircuitInitialize;
+EVT_ACX_CIRCUIT_COMPOSITE_INITIALIZE RenderMCDsp_EvtCircuitCompositeInitialize;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP      RenderMCDsp_EvtCircuitContextCleanup;
+EVT_WDF_DEVICE_PREPARE_HARDWARE     RenderMCDsp_EvtDevicePrepareHardware;
+EVT_WDF_DEVICE_RELEASE_HARDWARE     RenderMCDsp_EvtDeviceReleaseHardware;
+EVT_WDF_DEVICE_SELF_MANAGED_IO_INIT RenderMCDsp_EvtDeviceSelfManagedIoInit;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP      RenderMCDsp_EvtDeviceContextCleanup;
+EVT_ACX_CIRCUIT_CREATE_STREAM       RenderMCDsp_EvtCircuitCreateStream;
+EVT_ACX_CIRCUIT_POWER_UP            RenderMCDsp_EvtCircuitPowerUp;
+EVT_ACX_CIRCUIT_POWER_DOWN          RenderMCDsp_EvtCircuitPowerDown;
+EVT_ACX_STREAM_SET_RENDER_PACKET    RenderMCDsp_EvtStreamSetRenderPacket;
+EVT_ACX_PIN_SET_DATAFORMAT          RenderMCDsp_EvtAcxPinSetDataFormat;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP      RenderMCDsp_EvtPinContextCleanup;
+EVT_ACX_PIN_CONNECTED               RenderMCDsp_EvtPinConnected;
+EVT_ACX_PIN_DISCONNECTED            RenderMCDsp_EvtPinDisconnected;
+
+// Render Audio Engine
+EVT_ACX_MUTE_ASSIGN_STATE DspR_EvtMuteAssignState;
+EVT_ACX_MUTE_RETRIEVE_STATE DspR_EvtMuteRetrieveState;
+EVT_ACX_VOLUME_RETRIEVE_LEVEL DspR_EvtVolumeRetrieveLevel;
+EVT_ACX_PEAKMETER_RETRIEVE_LEVEL DspR_EvtPeakMeterRetrieveLevelCallback;
+EVT_ACX_RAMPED_VOLUME_ASSIGN_LEVEL DspR_EvtRampedVolumeAssignLevel;
+EVT_ACX_AUDIOENGINE_RETRIEVE_BUFFER_SIZE_LIMITS DspR_EvtAcxAudioEngineRetrieveBufferSizeLimits;
+EVT_ACX_AUDIOENGINE_RETRIEVE_EFFECTS_STATE DspR_EvtAcxAudioEngineRetrieveEffectsState;
+EVT_ACX_AUDIOENGINE_ASSIGN_EFFECTS_STATE DspR_EvtAcxAudioEngineAssignEffectsState;
+EVT_ACX_AUDIOENGINE_RETRIEVE_ENGINE_FORMAT DspR_EvtAcxAudioEngineRetrieveEngineMixFormat;
+EVT_ACX_AUDIOENGINE_ASSIGN_ENGINE_FORMAT DspR_EvtAcxAudioEngineAssignEngineDeviceFormat;
+EVT_ACX_STREAMAUDIOENGINE_RETRIEVE_EFFECTS_STATE DspR_EvtAcxStreamAudioEngineRetrieveEffectsState;
+EVT_ACX_STREAMAUDIOENGINE_ASSIGN_EFFECTS_STATE DspR_EvtAcxStreamAudioEngineAssignEffectsState;
+EVT_ACX_STREAMAUDIOENGINE_RETRIEVE_PRESENTATION_POSITION DspR_EvtAcxStreamAudioEngineRetrievePresentationPosition;
+EVT_ACX_STREAMAUDIOENGINE_ASSIGN_CURRENT_WRITE_POSITION DspR_EvtAcxStreamAudioEngineAssignCurrentWritePosition;
+EVT_ACX_STREAMAUDIOENGINE_RETRIEVE_LINEAR_BUFFER_POSITION DspR_EvtAcxStreamAudioEngineRetrieveLinearBufferPosition;
+EVT_ACX_STREAMAUDIOENGINE_ASSIGN_LAST_BUFFER_POSITION DspR_EvtAcxStreamAudioEngineAssignLastBufferPosition;
+EVT_ACX_STREAMAUDIOENGINE_ASSIGN_LOOPBACK_PROTECTION DspR_EvtAcxStreamAudioEngineAssignLoopbackProtection;
+
+PAGED_CODE_SEG
+NTSTATUS
+RenderMCDsp_SetPowerPolicy(
+    _In_ WDFDEVICE            Device
+);
+
+PAGED_CODE_SEG
+NTSTATUS CreateRenderCircuit(
+    _In_ PACXCIRCUIT_INIT                   CircuitInit,
+    _In_ UNICODE_STRING                     CircuitName,
+    _In_ WDFDEVICE                          Device,
+    _Out_ ACXCIRCUIT*                       Circuit
+);
+
+PAGED_CODE_SEG
+NTSTATUS CreateRenderMCDspPin(
+    _In_ ACX_PIN_TYPE                           PinType,
+    _In_ ACXCIRCUIT                             Circuit,
+    _In_ ACX_PIN_COMMUNICATION                  Communication,
+    _In_ const GUID*                            Category,
+    _In_ ACX_PIN_CALLBACKS*                     PinCallbacks,
+    _In_ bool                                   Mic,
+    _Out_ ACXPIN*                               Pin
+);
+
+PAGED_CODE_SEG
+NTSTATUS CreateAudioEngine(
+    _In_ ACXCIRCUIT                             Circuit,
+    _In_reads_(PinCount) ACXPIN*                Pins,
+    _In_ ULONG                                  PinCount,
+    _Out_ ACXAUDIOENGINE*                       AudioEngineElement
+);
+
+/////////////////////////////////////////////////////////
+//
+// Multi circuit dsp Capture (microphone) definitions
+//
+
+// Uses the same circuit context, capture pin and capture element definitions as Codec Capture.
+
+// Capture callbacks.
+EVT_ACX_CIRCUIT_COMPOSITE_CIRCUIT_INITIALIZE CaptureMCDsp_EvtCircuitCompositeCircuitInitialize;
+EVT_ACX_CIRCUIT_COMPOSITE_INITIALIZE CaptureMCDsp_EvtCircuitCompositeInitialize;
+EVT_WDF_DEVICE_PREPARE_HARDWARE         CaptureMCDsp_EvtDevicePrepareHardware;
+EVT_WDF_DEVICE_RELEASE_HARDWARE         CaptureMCDsp_EvtDeviceReleaseHardware;
+EVT_WDF_DEVICE_SELF_MANAGED_IO_INIT     CaptureMCDsp_EvtDeviceSelfManagedIoInit;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP          CaptureMCDsp_EvtDeviceContextCleanup;
+EVT_ACX_CIRCUIT_CREATE_STREAM           CaptureMCDsp_EvtCircuitCreateStream;
+EVT_ACX_CIRCUIT_POWER_UP                CaptureMCDsp_EvtCircuitPowerUp;
+EVT_ACX_CIRCUIT_POWER_DOWN              CaptureMCDsp_EvtCircuitPowerDown;
+EVT_ACX_STREAM_GET_CAPTURE_PACKET       CaptureMCDsp_EvtStreamGetCapturePacket;
+EVT_ACX_PIN_SET_DATAFORMAT              CaptureMCDsp_EvtAcxPinSetDataFormat;
+EVT_WDF_DEVICE_CONTEXT_CLEANUP          CaptureMCDsp_EvtPinContextCleanup;
+EVT_ACX_PIN_CONNECTED                   CaptureMCDsp_EvtPinConnected;
+EVT_ACX_PIN_DISCONNECTED                CaptureMCDsp_EvtPinDisconnected;
+
+PAGED_CODE_SEG
+NTSTATUS
+CaptureMCDsp_SetPowerPolicy(
+    _In_ WDFDEVICE            Device
+);
+
+PAGED_CODE_SEG
+NTSTATUS CreateCaptureCircuit(
+    _In_ PACXCIRCUIT_INIT                   CircuitInit,
+    _In_ UNICODE_STRING                     CircuitName,
+    _In_ WDFDEVICE                          Device,
+    _Out_ ACXCIRCUIT*                       Circuit
+);
+
+PAGED_CODE_SEG
+NTSTATUS CreateCaptureMCDspPin(
+    _In_ ACX_PIN_TYPE                           PinType,
+    _In_ ACXCIRCUIT                             Circuit,
+    _In_ ACX_PIN_COMMUNICATION                  Communication,
+    _In_ const GUID*                            Category,
+    _In_ ACX_PIN_CALLBACKS*                     PinCallbacks,
+    _In_ bool                                   Mic,
+    _Out_ ACXPIN*                               Pin
+);
+
+/* make internal prototypes usable from C++ */
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif // _PRIVATE_H_
diff --git a/audio/Acx/Samples/Common/RenderCircuit.cpp b/audio/Acx/Samples/Common/RenderCircuit.cpp
new file mode 100644
index 00000000..2f5abd13
--- /dev/null
+++ b/audio/Acx/Samples/Common/RenderCircuit.cpp
@@ -0,0 +1,807 @@
+/*++
+
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+    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:
+
+    RenderCircuit.cpp
+
+Abstract:
+
+    Render Circuit. This file contains routines to create and handle
+    render circuit with no offload.
+
+Environment:
+
+    Kernel mode
+
+--*/
+
+#include "private.h"
+#include "public.h"
+#include <ks.h>
+#include <mmsystem.h>
+#include <ksmedia.h>
+#include "AudioFormats.h"
+#include "streamengine.h"
+#include "cpp_utils.h"
+#include "circuithelper.h"
+
+#ifndef __INTELLISENSE__
+#include "renderCircuit.tmh"
+#endif
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecR_EvtAcxPinSetDataFormat(
+    _In_    ACXPIN          Pin,
+    _In_    ACXDATAFORMAT   DataFormat
+)
+/*++
+
+Routine Description:
+
+    This ACX pin callback sets the device/mixed format. 
+
+Return Value:
+
+    NTSTATUS
+
+--*/
+{
+    UNREFERENCED_PARAMETER(Pin);
+    UNREFERENCED_PARAMETER(DataFormat);
+
+    PAGED_CODE();
+
+    // NOTE: update device/mixed format here.
+
+    return STATUS_NOT_SUPPORTED;
+}
+
+///////////////////////////////////////////////////////////
+//
+// For more information on mute element see: https://docs.microsoft.com/en-us/windows-hardware/drivers/audio/ksnodetype-mute
+//
+_Use_decl_annotations_
+NTSTATUS
+NTAPI
+CodecR_EvtMuteAssignState(
+    _In_ ACXMUTE    Mute,
+    _In_ ULONG      Channel,
+    _In_ ULONG      State
+)
+{
+    PMUTE_ELEMENT_CONTEXT muteCtx;
+    ULONG                       i;
+
+    PAGED_CODE();
+
+    muteCtx = GetMuteElementContext(Mute);
+    ASSERT(muteCtx);
+
+    //
+    // Use first channel for all channels setting.
+    //
+    if (Channel != ALL_CHANNELS_ID)
+    {
+        muteCtx->MuteState[Channel] = State;
+    }
+    else
+    {
+        for (i = 0; i < MAX_CHANNELS; ++i)
+        {
+            muteCtx->MuteState[i] = State;
+        }
+    }
+
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+NTSTATUS
+NTAPI
+CodecR_EvtMuteRetrieveState(
+    _In_  ACXMUTE   Mute,
+    _In_  ULONG     Channel,
+    _Out_ ULONG *   State
+)
+{
+    PMUTE_ELEMENT_CONTEXT muteCtx;
+
+    PAGED_CODE();
+
+    muteCtx = GetMuteElementContext(Mute);
+    ASSERT(muteCtx);
+
+    //
+    // Use first channel for all channels setting.
+    //
+    if (Channel != ALL_CHANNELS_ID)
+    {
+        *State = muteCtx->MuteState[Channel];
+    }
+    else
+    {
+        *State = muteCtx->MuteState[0];
+    }
+
+    return STATUS_SUCCESS;
+}
+
+///////////////////////////////////////////////////////////
+//
+// For more information on volume element see: https://docs.microsoft.com/en-us/windows-hardware/drivers/audio/ksnodetype-volume
+//
+_Use_decl_annotations_
+NTSTATUS
+NTAPI
+CodecR_EvtRampedVolumeAssignLevel(
+    _In_ ACXVOLUME              Volume,
+    _In_ ULONG                  Channel,
+    _In_ LONG                   VolumeLevel,
+    _In_ ACX_VOLUME_CURVE_TYPE  CurveType,
+    _In_ ULONGLONG              CurveDuration
+)
+{
+    PVOLUME_ELEMENT_CONTEXT         volumeCtx;
+    ULONG                           i;
+
+    PAGED_CODE();
+
+    UNREFERENCED_PARAMETER(CurveType);
+    UNREFERENCED_PARAMETER(CurveDuration);
+
+    volumeCtx = GetVolumeElementContext(Volume);
+    ASSERT(volumeCtx);
+
+    if (Channel != ALL_CHANNELS_ID)
+    {
+        volumeCtx->VolumeLevel[Channel] = VolumeLevel;
+    }
+    else
+    {
+        for (i = 0; i < MAX_CHANNELS; ++i)
+        {
+            volumeCtx->VolumeLevel[i] = VolumeLevel;
+        }
+    }
+
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+NTSTATUS
+NTAPI
+CodecR_EvtVolumeRetrieveLevel(
+    _In_  ACXVOLUME Volume,
+    _In_  ULONG     Channel,
+    _Out_ LONG *    VolumeLevel
+)
+{
+    PVOLUME_ELEMENT_CONTEXT   volumeCtx;
+
+    PAGED_CODE();
+
+    volumeCtx = GetVolumeElementContext(Volume);
+    ASSERT(volumeCtx);
+
+    if (Channel != ALL_CHANNELS_ID)
+    {
+        *VolumeLevel = volumeCtx->VolumeLevel[Channel];
+    }
+    else
+    {
+        *VolumeLevel = volumeCtx->VolumeLevel[0];
+    }
+
+    return STATUS_SUCCESS;
+}
+
+VOID
+CodecR_EvtPinContextCleanup(
+    _In_ WDFOBJECT      WdfPin
+)
+/*++
+
+Routine Description:
+
+    In this callback, it cleans up pin context.
+
+Arguments:
+
+    WdfDevice - WDF device object
+
+Return Value:
+
+    nullptr
+
+--*/
+{
+
+    UNREFERENCED_PARAMETER(WdfPin);
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecR_AddStaticRender(
+    _In_ WDFDEVICE              Device,
+    _In_ const GUID *           ComponentGuid,
+    _In_ const UNICODE_STRING * CircuitName
+)
+/*++
+
+Routine Description:
+
+    Creates the static render circuit (pictured below) and
+    adds it to the device context. This is called when a
+    new device is detected and the AddDevice call is made
+    by the pnp manager.
+
+    ***************************************************************************
+    * Render Circuit                                                          *
+    *                                                                         *
+    *              +--------------------------------------------+             *
+    *              |                                            |             *
+    *              |    +-------------+      +-------------+    |             *
+    * Host  ------>|    | Volume Node |      |  Mute Node  |    |---> Bridge  *
+    * Pin          |    +-------------+      +-------------+    |      Pin    *
+    *              |                                            |             *
+    *              +--------------------------------------------+             *
+    *                                                                         *
+    ***************************************************************************
+
+Return Value:
+
+    NTSTATUS
+
+--*/
+{
+    NTSTATUS                        status = STATUS_SUCCESS;
+    PCODEC_DEVICE_CONTEXT           devCtx;
+    PRENDER_DEVICE_CONTEXT          renderDevCtx;
+    ACXCIRCUIT                      renderCircuit = nullptr;
+    WDF_OBJECT_ATTRIBUTES           attributes;
+
+    PAGED_CODE();
+
+    devCtx = GetCodecDeviceContext(Device);
+    ASSERT(devCtx != nullptr);
+
+    //
+    // Alloc audio context to current device.
+    //
+    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, RENDER_DEVICE_CONTEXT);
+    RETURN_NTSTATUS_IF_FAILED(WdfObjectAllocateContext(Device, &attributes, (PVOID*)&renderDevCtx));
+    ASSERT(renderDevCtx);
+
+    //
+    // Create a render circuit associated with this child device.
+    //
+    RETURN_NTSTATUS_IF_FAILED(CodecR_CreateRenderCircuit(Device, ComponentGuid, CircuitName, &renderCircuit));
+
+    devCtx->Render = renderCircuit;
+
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+Render_AllocateSupportedFormats(
+    _In_                                  WDFDEVICE        Device,
+    _In_reads_bytes_(CodecRenderPinCount) ACXPIN           Pin[],
+    _In_                                  ACXCIRCUIT       Circuit,
+    _In_                                  size_t           CodecRenderPinCount
+)
+{
+    UNREFERENCED_PARAMETER(CodecRenderPinCount);
+
+    NTSTATUS status = STATUS_SUCCESS;
+    ACXDATAFORMAT formatPcm44100c2;
+    ACXDATAFORMAT formatPcm48000c2;
+    ACXDATAFORMATLIST formatList;
+
+    WDF_OBJECT_ATTRIBUTES attributes;
+    WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
+
+    ///////////////////////////////////////////////////////////
+    //
+    // Allocate the formats this circuit supports.
+    //
+
+    RETURN_NTSTATUS_IF_FAILED(AllocateFormat(Pcm44100c2, Circuit, Device, &formatPcm44100c2));
+    RETURN_NTSTATUS_IF_FAILED(AllocateFormat(Pcm48000c2, Circuit, Device, &formatPcm48000c2));
+
+    ///////////////////////////////////////////////////////////
+    //
+    // Define supported formats for the host pin.
+    //
+
+    //
+    // The raw processing mode list is associated with each single circuit
+    // by ACX. The driver uses this DDI to retrieve the built-in raw
+    // data-format list.
+    //
+    RETURN_NTSTATUS_IF_TRUE(CodecRenderHostPin >= CodecRenderPinCount, STATUS_INVALID_PARAMETER);
+    formatList = AcxPinGetRawDataFormatList(Pin[CodecRenderHostPin]);
+    RETURN_NTSTATUS_IF_TRUE(formatList == nullptr, STATUS_INSUFFICIENT_RESOURCES);
+
+    //
+    // The driver uses this DDI to add data formats to the raw
+    // processing mode list associated with the current circuit.
+    //
+    RETURN_NTSTATUS_IF_FAILED(AcxDataFormatListAddDataFormat(formatList, formatPcm44100c2));
+    RETURN_NTSTATUS_IF_FAILED(AcxDataFormatListAddDataFormat(formatList, formatPcm48000c2));
+
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecR_CreateRenderCircuit(
+    _In_     WDFDEVICE              Device,
+    _In_     const GUID *           ComponentGuid,
+    _In_     const UNICODE_STRING * CircuitName,
+    _Out_    ACXCIRCUIT*            Circuit
+)
+/*++
+
+Routine Description:
+
+    This routine builds the CODEC render circuit.
+
+Return Value:
+
+    NT status value
+
+--*/
+{
+    NTSTATUS                        status = STATUS_SUCCESS;
+    WDF_OBJECT_ATTRIBUTES           attributes;
+    ACXCIRCUIT                      circuit;
+    CODEC_RENDER_CIRCUIT_CONTEXT*   circuitCtx;
+    ACXPIN                          pin[CodecRenderPinCount];
+
+    PAGED_CODE();
+
+    //
+    // Init output value.
+    //
+    *Circuit = nullptr;
+
+    ///////////////////////////////////////////////////////////
+    //
+    // Create a circuit.
+    //
+    {
+        PACXCIRCUIT_INIT                circuitInit = nullptr;
+        ACX_CIRCUIT_PNPPOWER_CALLBACKS  powerCallbacks;
+
+        //
+        // The driver uses this DDI to allocate an ACXCIRCUIT_INIT
+        // structure. This opaque structure is used when creating
+        // a standalone audio circuit representing an audio device. 
+        //
+        circuitInit = AcxCircuitInitAllocate(Device);
+
+        //
+        // The driver uses this DDI to free the allocated
+        // ACXCIRCUIT_INIT structure when an error is detected.
+        // Normally the structures is deleted/cleared by ACX when
+        // an ACX circuit is created successfully.
+        //
+        auto circuitInitScope = scope_exit([&circuitInit]() {
+            if (circuitInit) {
+                AcxCircuitInitFree(circuitInit);
+            }
+            });
+
+        //
+        // The driver uses this DDI to specify the Component ID
+        // of the ACX circuit. This ID is a guid that uniquely
+        // identifies the circuit instance (vendor specific).
+        //
+        AcxCircuitInitSetComponentId(circuitInit, ComponentGuid);
+
+        //
+        // The driver uses this DDI to specify the circuit name.
+        // For standalone circuits, this is the audio device name
+        // which is used by clients to open handles to the audio devices.
+        //
+        (VOID)AcxCircuitInitAssignName(circuitInit, CircuitName);
+
+        //
+        // The driver uses this DDI to specify the circuit type. The
+        // circuit type can be AcxCircuitTypeRender, AcxCircuitTypeCapture,
+        // AcxCircuitTypeOther, or AcxCircuitTypeMaximum (for validation). 
+        //
+        AcxCircuitInitSetCircuitType(circuitInit, AcxCircuitTypeRender);
+
+        //
+        // The driver uses this DDI to assign its (if any) power callbacks.
+        //
+        ACX_CIRCUIT_PNPPOWER_CALLBACKS_INIT(&powerCallbacks);
+        powerCallbacks.EvtAcxCircuitPowerUp = CodecR_EvtCircuitPowerUp;
+        powerCallbacks.EvtAcxCircuitPowerDown = CodecR_EvtCircuitPowerDown;
+        AcxCircuitInitSetAcxCircuitPnpPowerCallbacks(circuitInit, &powerCallbacks);
+
+        //
+        // The driver uses this DDI to register for a stream-create callback.
+        //
+        RETURN_NTSTATUS_IF_FAILED(AcxCircuitInitAssignAcxCreateStreamCallback(circuitInit, CodecR_EvtCircuitCreateStream));
+
+        //
+        // The driver uses this DDI to create a new ACX circuit.
+        //
+        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, CODEC_RENDER_CIRCUIT_CONTEXT);
+        RETURN_NTSTATUS_IF_FAILED(AcxCircuitCreate(Device, &attributes, &circuitInit, &circuit));
+
+        circuitInitScope.release();
+
+        circuitCtx = GetRenderCircuitContext(circuit);
+        ASSERT(circuitCtx);
+    }
+
+    //
+    // Post circuit creation initialization.
+    //
+
+    ///////////////////////////////////////////////////////////
+    //
+    // Create mute and volume elements.
+    //
+    {
+        ACXELEMENT elements[RenderElementCount] = { 0 };
+
+        //
+        // The driver uses this DDI to assign its volume element callbacks.
+        //
+        ACX_VOLUME_CALLBACKS volumeCallbacks;
+        ACX_VOLUME_CALLBACKS_INIT(&volumeCallbacks);
+        volumeCallbacks.EvtAcxRampedVolumeAssignLevel = CodecR_EvtRampedVolumeAssignLevel;
+        volumeCallbacks.EvtAcxVolumeRetrieveLevel = CodecR_EvtVolumeRetrieveLevel;
+
+        //
+        // Create Volume element
+        //
+        ACX_VOLUME_CONFIG volumeCfg;
+        ACX_VOLUME_CONFIG_INIT(&volumeCfg);
+        volumeCfg.ChannelsCount = MAX_CHANNELS;
+        volumeCfg.Minimum = VOLUME_LEVEL_MINIMUM;
+        volumeCfg.Maximum = VOLUME_LEVEL_MAXIMUM;
+        volumeCfg.SteppingDelta = VOLUME_STEPPING;
+        volumeCfg.Name = &KSAUDFNAME_VOLUME_CONTROL;
+        volumeCfg.Callbacks = &volumeCallbacks;
+
+        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, VOLUME_ELEMENT_CONTEXT);
+        attributes.ParentObject = circuit;
+
+        RETURN_NTSTATUS_IF_FAILED(AcxVolumeCreate(circuit, &attributes, &volumeCfg, (ACXVOLUME*)&elements[RenderVolumeIndex]));
+
+        //
+        // The driver uses this DDI to assign its mute element callbacks.
+        //
+        ACX_MUTE_CALLBACKS muteCallbacks;
+        ACX_MUTE_CALLBACKS_INIT(&muteCallbacks);
+        muteCallbacks.EvtAcxMuteAssignState = CodecR_EvtMuteAssignState;
+        muteCallbacks.EvtAcxMuteRetrieveState = CodecR_EvtMuteRetrieveState;
+
+        //
+        // Create Mute element
+        //
+        ACX_MUTE_CONFIG muteCfg;
+        ACX_MUTE_CONFIG_INIT(&muteCfg);
+        muteCfg.ChannelsCount = MAX_CHANNELS;
+        muteCfg.Name = &KSAUDFNAME_WAVE_MUTE;
+        muteCfg.Callbacks = &muteCallbacks;
+
+        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, MUTE_ELEMENT_CONTEXT);
+        attributes.ParentObject = circuit;
+
+        RETURN_NTSTATUS_IF_FAILED(AcxMuteCreate(circuit, &attributes, &muteCfg, (ACXMUTE*)&elements[RenderMuteIndex]));
+
+        //
+        // Saving the volume and mute elements in the circuit context.
+        //
+        circuitCtx->VolumeElement = (ACXVOLUME)elements[RenderVolumeIndex];
+        circuitCtx->MuteElement = (ACXMUTE)elements[RenderMuteIndex];
+
+        //
+        // The driver uses this DDI post circuit creation to add ACXELEMENTs.
+        //
+        RETURN_NTSTATUS_IF_FAILED(AcxCircuitAddElements(circuit, elements, SIZEOF_ARRAY(elements)));
+    } 
+
+    ///////////////////////////////////////////////////////////
+    //
+    // Create the pins for the circuit. 
+    //
+    {
+        ACX_PIN_CONFIG                  pinCfg;
+        CODEC_PIN_CONTEXT*              pinCtx;
+        ACX_PIN_CALLBACKS               pinCallbacks;
+
+        ///////////////////////////////////////////////////////////
+        //
+        // Create Render Pin. 
+        //
+
+        ACX_PIN_CALLBACKS_INIT(&pinCallbacks);
+        pinCallbacks.EvtAcxPinSetDataFormat = CodecR_EvtAcxPinSetDataFormat;
+
+        ACX_PIN_CONFIG_INIT(&pinCfg);
+        pinCfg.Type = AcxPinTypeSink;
+        pinCfg.Communication = AcxPinCommunicationSink;
+        pinCfg.Category = &KSCATEGORY_AUDIO;
+        pinCfg.PinCallbacks = &pinCallbacks;
+
+        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, CODEC_PIN_CONTEXT);
+        attributes.EvtCleanupCallback = CodecR_EvtPinContextCleanup;
+        attributes.ParentObject = circuit;
+
+        //
+        // The driver uses this DDI to create one or more pins on the circuits.
+        //
+        RETURN_NTSTATUS_IF_FAILED(AcxPinCreate(circuit, &attributes, &pinCfg, &pin[CodecRenderHostPin]));
+
+        ASSERT(pin[CodecRenderHostPin] != nullptr);
+        pinCtx = GetCodecPinContext(pin[CodecRenderHostPin]);
+        ASSERT(pinCtx);
+        pinCtx->CodecPinType = CodecPinTypeHost;
+
+        ///////////////////////////////////////////////////////////
+        //
+        // Create Device Bridge Pin.
+        //
+
+        ACX_PIN_CONFIG_INIT(&pinCfg);
+        pinCfg.Type = AcxPinTypeSource;
+        pinCfg.Communication = AcxPinCommunicationNone;
+        pinCfg.Category = &KSNODETYPE_SPEAKER;
+
+        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, CODEC_PIN_CONTEXT);
+        attributes.EvtCleanupCallback = CodecR_EvtPinContextCleanup;
+        attributes.ParentObject = circuit;
+
+        //
+        // The driver uses this DDI to create one or more pins on the circuits.
+        //
+        RETURN_NTSTATUS_IF_FAILED(AcxPinCreate(circuit, &attributes, &pinCfg, &pin[CodecRenderBridgePin]));
+
+        ASSERT(pin[CodecRenderBridgePin] != nullptr);
+        pinCtx = GetCodecPinContext(pin[CodecRenderBridgePin]);
+        ASSERT(pinCtx);
+        pinCtx->CodecPinType = CodecPinTypeDevice;
+    }
+
+    ///////////////////////////////////////////////////////////
+    //
+    // Add audio jack to bridge pin. 
+    // For more information on audio jack see: https://docs.microsoft.com/en-us/windows/win32/api/devicetopology/ns-devicetopology-ksjack_description
+    //
+    {
+        ACX_JACK_CONFIG                 jackCfg;
+        ACXJACK                         jack;
+        PJACK_CONTEXT                   jackCtx;
+
+        ACX_JACK_CONFIG_INIT(&jackCfg);
+        jackCfg.Description.ChannelMapping = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
+        jackCfg.Description.Color = RGB(0, 0, 0);
+        jackCfg.Description.ConnectionType = AcxConnTypeAtapiInternal;
+        jackCfg.Description.GeoLocation = AcxGeoLocFront;
+        jackCfg.Description.GenLocation = AcxGenLocPrimaryBox;
+        jackCfg.Description.PortConnection = AcxPortConnIntegratedDevice;
+
+        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, JACK_CONTEXT);
+        attributes.ParentObject = pin[CodecRenderBridgePin];
+
+        RETURN_NTSTATUS_IF_FAILED(AcxJackCreate(pin[CodecRenderBridgePin], &attributes, &jackCfg, &jack));
+
+        ASSERT(jack != nullptr);
+
+        jackCtx = GetJackContext(jack);
+        ASSERT(jackCtx);
+        jackCtx->Dummy = 0;
+
+        RETURN_NTSTATUS_IF_FAILED(AcxPinAddJacks(pin[CodecRenderBridgePin], &jack, 1));
+    }
+
+    RETURN_NTSTATUS_IF_FAILED(Render_AllocateSupportedFormats(Device, pin, circuit, CodecRenderPinCount));
+
+    ///////////////////////////////////////////////////////////
+    //
+    // The driver uses this DDI post circuit creation to add ACXPINs.
+    //
+    RETURN_NTSTATUS_IF_FAILED(AcxCircuitAddPins(circuit, pin, CodecRenderPinCount));
+
+    //
+    // Set output value.
+    //
+    *Circuit = circuit;
+
+    //
+    // Done. 
+    //
+    status = STATUS_SUCCESS;
+
+    return status;
+}
+
+_Use_decl_annotations_
+NTSTATUS
+CodecR_EvtCircuitPowerUp(
+    _In_ WDFDEVICE  Device,
+    _In_ ACXCIRCUIT Circuit,
+    _In_ WDF_POWER_DEVICE_STATE PreviousState
+)
+{
+    UNREFERENCED_PARAMETER(Device);
+    UNREFERENCED_PARAMETER(Circuit);
+    UNREFERENCED_PARAMETER(PreviousState);
+
+    PAGED_CODE();
+
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+NTSTATUS
+CodecR_EvtCircuitPowerDown(
+    _In_ WDFDEVICE  Device,
+    _In_ ACXCIRCUIT Circuit,
+    _In_ WDF_POWER_DEVICE_STATE TargetState
+)
+{
+    UNREFERENCED_PARAMETER(Device);
+    UNREFERENCED_PARAMETER(Circuit);
+    UNREFERENCED_PARAMETER(TargetState);
+
+    PAGED_CODE();
+
+    return STATUS_SUCCESS;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecR_EvtCircuitCreateStream(
+    _In_    WDFDEVICE       Device,
+    _In_    ACXCIRCUIT      Circuit,
+    _In_    ACXPIN          Pin,
+    _In_    PACXSTREAM_INIT StreamInit,
+    _In_    ACXDATAFORMAT   StreamFormat,
+    _In_    const GUID*     SignalProcessingMode,
+    _In_    ACXOBJECTBAG    VarArguments
+)
+/*++
+
+Routine Description:
+
+    This routine creates a stream for the specified circuit.
+
+Return Value:
+
+    NT status value
+
+--*/
+{
+    NTSTATUS                        status;
+    PRENDER_DEVICE_CONTEXT          devCtx;
+    WDF_OBJECT_ATTRIBUTES           attributes;
+    ACXSTREAM                       stream;
+    STREAMENGINE_CONTEXT *          streamCtx;
+    ACX_STREAM_CALLBACKS            streamCallbacks;
+    ACX_RT_STREAM_CALLBACKS         rtCallbacks;
+    CRenderStreamEngine*            renderStreamEngine = nullptr;
+    CODEC_PIN_TYPE                  codecPinType;
+    PCODEC_PIN_CONTEXT              pinCtx;
+    ACX_PIN_TYPE                    pinType;
+    CODEC_RENDER_CIRCUIT_CONTEXT*   circuitCtx;
+
+    auto streamEngineScope = scope_exit([&renderStreamEngine]() {
+
+        delete renderStreamEngine;
+
+        });
+
+    PAGED_CODE();
+    UNREFERENCED_PARAMETER(SignalProcessingMode);
+    UNREFERENCED_PARAMETER(VarArguments);
+
+    ASSERT(IsEqualGUID(*SignalProcessingMode, AUDIO_SIGNALPROCESSINGMODE_RAW));
+
+    ASSERT(Circuit != nullptr);
+    circuitCtx = GetRenderCircuitContext(Circuit);
+    ASSERT(circuitCtx);
+
+    devCtx = GetRenderDeviceContext(Device);
+    ASSERT(devCtx != nullptr);
+    UNREFERENCED_PARAMETER(devCtx);
+
+    pinCtx = GetCodecPinContext(Pin);
+    codecPinType = pinCtx->CodecPinType;
+
+    pinType = AcxPinGetType(Pin);
+
+    //
+    // Init streaming callbacks.
+    //
+    ACX_STREAM_CALLBACKS_INIT(&streamCallbacks);
+    streamCallbacks.EvtAcxStreamPrepareHardware = EvtStreamPrepareHardware;
+    streamCallbacks.EvtAcxStreamReleaseHardware = EvtStreamReleaseHardware;
+    streamCallbacks.EvtAcxStreamRun = EvtStreamRun;
+    streamCallbacks.EvtAcxStreamPause = EvtStreamPause;
+
+    RETURN_NTSTATUS_IF_FAILED(AcxStreamInitAssignAcxStreamCallbacks(StreamInit, &streamCallbacks));
+
+    //
+    // Init RT streaming callbacks.
+    //
+    ACX_RT_STREAM_CALLBACKS_INIT(&rtCallbacks);
+    rtCallbacks.EvtAcxStreamGetHwLatency = EvtStreamGetHwLatency;
+    rtCallbacks.EvtAcxStreamAllocateRtPackets = EvtStreamAllocateRtPackets;
+    rtCallbacks.EvtAcxStreamFreeRtPackets = EvtStreamFreeRtPackets;
+    rtCallbacks.EvtAcxStreamSetRenderPacket = CodecR_EvtStreamSetRenderPacket;
+    rtCallbacks.EvtAcxStreamGetCurrentPacket = EvtStreamGetCurrentPacket;
+    rtCallbacks.EvtAcxStreamGetPresentationPosition = EvtStreamGetPresentationPosition;
+
+    RETURN_NTSTATUS_IF_FAILED(AcxStreamInitAssignAcxRtStreamCallbacks(StreamInit, &rtCallbacks));
+
+    //
+    // Buffer notifications are supported.
+    //
+    AcxStreamInitSetAcxRtStreamSupportsNotifications(StreamInit);
+
+    //
+    // Create the stream.
+    //
+    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, STREAMENGINE_CONTEXT);
+    attributes.EvtDestroyCallback = EvtStreamDestroy;
+    RETURN_NTSTATUS_IF_FAILED(AcxRtStreamCreate(Device, Circuit, &attributes, &StreamInit, &stream));
+
+    //
+    // Create the virtual streaming engine which will control
+    // streaming logic for the render circuit.
+    //
+    renderStreamEngine = new (POOL_FLAG_NON_PAGED, DeviceDriverTag) CRenderStreamEngine(stream, StreamFormat, FALSE, NULL);
+    RETURN_NTSTATUS_IF_TRUE(renderStreamEngine == nullptr, STATUS_INSUFFICIENT_RESOURCES);
+
+    streamCtx = GetStreamEngineContext(stream);
+    ASSERT(streamCtx);
+    streamCtx->StreamEngine = (PVOID)renderStreamEngine;
+
+    renderStreamEngine = nullptr;
+
+    //
+    // Done. 
+    //
+    status = STATUS_SUCCESS;
+
+    return status;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+CodecR_EvtStreamSetRenderPacket(
+    _In_ ACXSTREAM          Stream,
+    _In_ ULONG              Packet,
+    _In_ ULONG              Flags,
+    _In_ ULONG              EosPacketLength
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CRenderStreamEngine* streamEngine = nullptr;
+
+    PAGED_CODE();
+
+    ctx = GetStreamEngineContext(Stream);
+
+    streamEngine = static_cast<CRenderStreamEngine*>(ctx->StreamEngine);
+
+    return streamEngine->SetRenderPacket(Packet, Flags, EosPacketLength);
+}
+
diff --git a/audio/Acx/Samples/Common/SamplesCommon.vcxproj b/audio/Acx/Samples/Common/SamplesCommon.vcxproj
new file mode 100644
index 00000000..0932d59a
--- /dev/null
+++ b/audio/Acx/Samples/Common/SamplesCommon.vcxproj
@@ -0,0 +1,179 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{6A946D59-6690-4ED0-A77D-7D4C3D4B3241}</ProjectGuid>
+    <TemplateGuid>{497e31cb-056b-4f31-abb8-447fd55ee5a5}</TemplateGuid>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <MinimumVisualStudioVersion>12.0</MinimumVisualStudioVersion>
+    <Configuration>Debug</Configuration>
+    <RootNamespace>SamplesCommon</RootNamespace>
+    <WindowsTargetPlatformVersion>$(LatestTargetPlatformVersion)</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>WindowsKernelModeDriver10.0</PlatformToolset>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <DriverType>KMDF</DriverType>
+    <DriverTargetPlatform>Windows Driver</DriverTargetPlatform>
+    <KMDF_VERSION_MAJOR>1</KMDF_VERSION_MAJOR>
+    <KMDF_VERSION_MINOR>31</KMDF_VERSION_MINOR>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>WindowsKernelModeDriver10.0</PlatformToolset>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <DriverType>KMDF</DriverType>
+    <DriverTargetPlatform>Windows Driver</DriverTargetPlatform>
+    <KMDF_VERSION_MAJOR>1</KMDF_VERSION_MAJOR>
+    <KMDF_VERSION_MINOR>31</KMDF_VERSION_MINOR>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>WindowsKernelModeDriver10.0</PlatformToolset>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <DriverType>KMDF</DriverType>
+    <DriverTargetPlatform>Windows Driver</DriverTargetPlatform>
+    <KMDF_VERSION_MAJOR>1</KMDF_VERSION_MAJOR>
+    <KMDF_VERSION_MINOR>31</KMDF_VERSION_MINOR>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <TargetVersion>Windows10</TargetVersion>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>WindowsKernelModeDriver10.0</PlatformToolset>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <DriverType>KMDF</DriverType>
+    <DriverTargetPlatform>Windows Driver</DriverTargetPlatform>
+    <KMDF_VERSION_MAJOR>1</KMDF_VERSION_MAJOR>
+    <KMDF_VERSION_MINOR>31</KMDF_VERSION_MINOR>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
+    <OutDir>$(IntDir)</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
+    <OutDir>$(IntDir)</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
+    <OutDir>$(IntDir)</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
+    <OutDir>$(IntDir)</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WppEnabled>true</WppEnabled>
+      <WppRecorderEnabled>true</WppRecorderEnabled>
+      <WppScanConfigurationData Condition="'%(ClCompile.ScanConfigurationData)' == ''">trace_macros.h</WppScanConfigurationData>
+      <WppKernelMode>true</WppKernelMode>
+      <AdditionalIncludeDirectories>$(SDK_INC_PATH);$(DDK_INC_PATH)\acx\km\1.1;..\inc;..\shared;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>ACX_VERSION_MAJOR=1;ACX_VERSION_MINOR=1;KMDF_VERSION_MAJOR=1;KMDF_VERSION_MINOR=31;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <DriverSign>
+      <FileDigestAlgorithm>sha256</FileDigestAlgorithm>
+    </DriverSign>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WppEnabled>true</WppEnabled>
+      <WppRecorderEnabled>true</WppRecorderEnabled>
+      <WppScanConfigurationData Condition="'%(ClCompile.ScanConfigurationData)' == ''">trace_macros.h</WppScanConfigurationData>
+      <WppKernelMode>true</WppKernelMode>
+      <AdditionalIncludeDirectories>$(SDK_INC_PATH);$(DDK_INC_PATH)\acx\km\1.1;..\inc;..\shared;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>ACX_VERSION_MAJOR=1;ACX_VERSION_MINOR=1;KMDF_VERSION_MAJOR=1;KMDF_VERSION_MINOR=31;KMDF_VERSION_MINOR=31;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <DriverSign>
+      <FileDigestAlgorithm>sha256</FileDigestAlgorithm>
+    </DriverSign>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <ClCompile>
+      <WppEnabled>true</WppEnabled>
+      <WppRecorderEnabled>true</WppRecorderEnabled>
+      <WppScanConfigurationData Condition="'%(ClCompile.ScanConfigurationData)' == ''">trace_macros.h</WppScanConfigurationData>
+      <WppKernelMode>true</WppKernelMode>
+      <AdditionalIncludeDirectories>$(SDK_INC_PATH);$(DDK_INC_PATH)\acx\km\1.1;..\inc;..\shared;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>ACX_VERSION_MAJOR=1;ACX_VERSION_MINOR=1;KMDF_VERSION_MAJOR=1;KMDF_VERSION_MINOR=31;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <DriverSign>
+      <FileDigestAlgorithm>sha256</FileDigestAlgorithm>
+    </DriverSign>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <ClCompile>
+      <WppEnabled>true</WppEnabled>
+      <WppRecorderEnabled>true</WppRecorderEnabled>
+      <WppScanConfigurationData Condition="'%(ClCompile.ScanConfigurationData)' == ''">trace_macros.h</WppScanConfigurationData>
+      <WppKernelMode>true</WppKernelMode>
+      <AdditionalIncludeDirectories>$(SDK_INC_PATH);$(DDK_INC_PATH)\acx\km\1.1;..\inc;..\shared;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>ACX_VERSION_MAJOR=1;ACX_VERSION_MINOR=1;KMDF_VERSION_MAJOR=1;KMDF_VERSION_MINOR=31;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <DriverSign>
+      <FileDigestAlgorithm>sha256</FileDigestAlgorithm>
+    </DriverSign>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <FilesToPackage Include="$(TargetPath)" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="NewDelete.h" />
+    <ClInclude Include="CircuitHelper.h" />
+    <ClInclude Include="KeywordDetector.h" />
+    <ClInclude Include="Private.h" />
+    <ClInclude Include="Public.h" />
+    <ClInclude Include="SaveData.h" />
+    <ClInclude Include="SimPeakMeter.h" />
+    <ClInclude Include="StreamEngine.h" />
+    <ClInclude Include="ToneGenerator.h" />
+    <ClInclude Include="Trace.h" />
+    <ClInclude Include="Trace_macros.h" />
+    <ClInclude Include="WaveReader.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="NewDelete.cpp" />
+    <ClCompile Include="captureCircuit.cpp" />
+    <ClCompile Include="CircuitHelper.cpp" />
+    <ClCompile Include="KeywordDetector.cpp" />
+    <ClCompile Include="renderCircuit.cpp" />
+    <ClCompile Include="SaveData.cpp" />
+    <ClCompile Include="SimPeakMeter.cpp" />
+    <ClCompile Include="StreamEngine.cpp" />
+    <ClCompile Include="ToneGenerator.cpp" />
+    <ClCompile Include="WaveReader.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
diff --git a/audio/Acx/Samples/Common/SaveData.cpp b/audio/Acx/Samples/Common/SaveData.cpp
new file mode 100644
index 00000000..72e98850
--- /dev/null
+++ b/audio/Acx/Samples/Common/SaveData.cpp
@@ -0,0 +1,1103 @@
+/*++
+
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+    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:
+
+    SaveData.cpp
+
+Abstract:
+
+    Implementation of data saving class for ACX driver samples.
+
+    To save the playback data to disk, this class maintains a circular data
+    buffer, associated frame structures and worker items to save frames to
+    disk.
+    Each frame structure represents a portion of buffer. When that portion
+    of frame is full, a workitem is scheduled to save it to disk.
+
+
+
+--*/
+#pragma warning (disable : 4127)
+#pragma warning (disable : 26165)
+
+
+#include "private.h"
+#include <devguid.h>
+#include <ks.h>
+#include <mmsystem.h>
+#include <ksmedia.h>
+#include "savedata.h"
+#include <ntstrsafe.h>   // This is for using RtlStringCbPrintf
+
+#define SAVEDATA_POOLTAG  'TDVS'
+#define SAVEDATA_POOLTAG1 '1DVS'
+#define SAVEDATA_POOLTAG2 '2DVS'
+#define SAVEDATA_POOLTAG3 '3DVS'
+#define SAVEDATA_POOLTAG4 '4DVS'
+#define SAVEDATA_POOLTAG5 '5DVS'
+#define SAVEDATA_POOLTAG6 '6DVS'
+#define SAVEDATA_POOLTAG7 '7DVS'
+
+//=============================================================================
+// Defines
+//=============================================================================
+#define RIFF_TAG                    0x46464952;
+#define WAVE_TAG                    0x45564157;
+#define FMT__TAG                    0x20746D66;
+#define DATA_TAG                    0x61746164;
+
+#define DEFAULT_FRAME_COUNT         4
+#define DEFAULT_FRAME_SIZE          PAGE_SIZE * 4 
+#define DEFAULT_BUFFER_SIZE         DEFAULT_FRAME_SIZE * DEFAULT_FRAME_COUNT
+
+#define DEFAULT_FILE_FOLDER1        L"\\DriverData\\Audio_Samples"
+#define DEFAULT_FILE_FOLDER2        L"\\DriverData\\Audio_Samples\\AudioCodec"
+#define DEFAULT_FILE_NAME           L"\\DriverData\\Audio_Samples\\AudioCodec\\STREAM"
+#define OFFLOAD_FILE_NAME           L"OFFLOAD"
+#define HOST_FILE_NAME              L"HOST"
+
+#define MAX_WORKER_ITEM_COUNT       15
+
+
+PSAVEWORKER_PARAM       CSaveData::m_pWorkItems = NULL;
+PDEVICE_OBJECT          CSaveData::m_pDeviceObject = NULL;
+
+//=============================================================================
+// Statics
+//=============================================================================
+ULONG CSaveData::m_ulStreamId = 0;
+ULONG CSaveData::m_ulOffloadStreamId = 0;
+
+//=============================================================================
+// CSaveData
+//=============================================================================
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CSaveData::CSaveData()
+:   m_pDataBuffer(NULL),
+    m_FileHandle(NULL),
+    m_ulFrameCount(DEFAULT_FRAME_COUNT),
+    m_ulBufferSize(DEFAULT_BUFFER_SIZE),
+    m_ulFrameSize(DEFAULT_FRAME_SIZE),
+    m_ulBufferOffset(0),
+    m_ulFrameIndex(0),
+    m_fFrameUsed(NULL),
+    m_waveFormat(NULL),
+    m_pFilePtr(NULL),
+    m_fWriteDisabled(FALSE),
+    m_bInitialized(FALSE)
+{
+    PAGED_CODE();
+
+    m_FileHeader.dwRiff           = RIFF_TAG;
+    m_FileHeader.dwFileSize       = 0;
+    m_FileHeader.dwWave           = WAVE_TAG;
+    m_FileHeader.dwFormat         = FMT__TAG;
+    m_FileHeader.dwFormatLength   = sizeof(WAVEFORMATEX);
+
+    m_DataHeader.dwData           = DATA_TAG;
+    m_DataHeader.dwDataLength     = 0;
+
+    RtlZeroMemory(&m_objectAttributes, sizeof(m_objectAttributes));
+} // CSaveData
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CSaveData::~CSaveData()
+{
+    PAGED_CODE();
+    Cleanup();
+} // CSaveData
+
+void
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CSaveData::Cleanup
+(
+    void
+)
+{
+    PAGED_CODE();
+
+    // Update the wave header in data file with real file size.
+    //
+    if(m_pFilePtr)
+    {
+        // RIFF header, whose size is the whole file size minus RIFF header.
+        m_FileHeader.dwFileSize =
+            (DWORD)m_pFilePtr->QuadPart - 2 * sizeof(DWORD);
+        // The data length is the size of all the audio that was written.
+        // It gets calculated by taking:
+        m_DataHeader.dwDataLength = (DWORD)m_pFilePtr->QuadPart -   // the whole file size,
+            sizeof(m_FileHeader) -                                  // minus the file header,
+            m_FileHeader.dwFormatLength -                           // minus the format,
+            sizeof(m_DataHeader);                                   // minus the data header itself.
+
+        if (STATUS_SUCCESS == KeWaitForSingleObject
+            (
+                &m_FileSync,
+                Executive,
+                KernelMode,
+                FALSE,
+                NULL
+            ))
+        {
+            if (NT_SUCCESS(FileOpen(FALSE)))
+            {
+                FileWriteHeader();
+
+                FileClose();
+            }
+
+            KeReleaseMutex(&m_FileSync, FALSE);
+        }
+
+        m_FileHeader.dwRiff           = RIFF_TAG;
+        m_FileHeader.dwFileSize       = 0;
+        m_FileHeader.dwWave           = WAVE_TAG;
+        m_FileHeader.dwFormat         = FMT__TAG;
+        m_FileHeader.dwFormatLength   = sizeof(WAVEFORMATEX);
+        
+        m_DataHeader.dwData           = DATA_TAG;
+        m_DataHeader.dwDataLength     = 0;
+        m_pFilePtr = NULL;
+    }
+
+    if (m_waveFormat)
+    {
+        ExFreePoolWithTag(m_waveFormat, SAVEDATA_POOLTAG1);
+        m_waveFormat = NULL;
+    }
+
+    if (m_fFrameUsed)
+    {
+        ExFreePoolWithTag(m_fFrameUsed, SAVEDATA_POOLTAG2);
+        m_fFrameUsed = NULL;
+    }
+
+    if (m_FileName.Buffer)
+    {
+        ExFreePoolWithTag(m_FileName.Buffer, SAVEDATA_POOLTAG3);
+        m_FileName.Buffer = NULL;
+    }
+
+    if (m_pDataBuffer)
+    {
+        ExFreePoolWithTag(m_pDataBuffer, SAVEDATA_POOLTAG4);
+        m_pDataBuffer = NULL;
+    }
+}
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+void
+CSaveData::DestroyWorkItems
+(
+    void
+)
+{
+    PAGED_CODE();
+
+    if (m_pWorkItems)
+    {
+        for (int i = 0; i < MAX_WORKER_ITEM_COUNT; i++)
+        {
+            if (m_pWorkItems[i].WorkItem!=NULL)
+            {
+                IoFreeWorkItem(m_pWorkItems[i].WorkItem);
+                m_pWorkItems[i].WorkItem = NULL;
+            }
+        }
+        ExFreePoolWithTag(m_pWorkItems, SAVEDATA_POOLTAG);
+        m_pWorkItems = NULL;
+    }
+
+} // DestroyWorkItems
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+void
+CSaveData::Disable
+(
+    _In_ BOOL                  fDisable
+)
+{
+    PAGED_CODE();
+
+    m_fWriteDisabled = fDisable;
+} // Disable
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CSaveData::FileClose(void)
+{
+    PAGED_CODE();
+
+    NTSTATUS                    ntStatus = STATUS_SUCCESS;
+
+    if (m_FileHandle)
+    {
+        ntStatus = ZwClose(m_FileHandle);
+        m_FileHandle = NULL;
+    }
+
+    return ntStatus;
+} // FileClose
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CSaveData::FileOpen
+(
+    _In_  BOOL                  fOverWrite
+)
+{
+    PAGED_CODE();
+
+    NTSTATUS                    ntStatus = STATUS_SUCCESS;
+    IO_STATUS_BLOCK             ioStatusBlock;
+
+    if( FALSE == m_bInitialized )
+    {
+        return STATUS_UNSUCCESSFUL;
+    }
+
+    if(!m_FileHandle)
+    {
+        ntStatus =
+            ZwCreateFile
+            (
+                &m_FileHandle,
+                GENERIC_WRITE | SYNCHRONIZE,
+                &m_objectAttributes,
+                &ioStatusBlock,
+                NULL,
+                FILE_ATTRIBUTE_NORMAL,
+                0,
+                fOverWrite ? FILE_OVERWRITE_IF : FILE_OPEN_IF,
+                FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
+                NULL,
+                0
+            );
+    }
+
+    return ntStatus;
+} // FileOpen
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CSaveData::FileWrite
+(
+    _In_reads_bytes_(ulDataSize)    PBYTE   pData,
+    _In_                            ULONG   ulDataSize
+)
+{
+    PAGED_CODE();
+
+    ASSERT(pData);
+    ASSERT(m_pFilePtr);
+
+    NTSTATUS                    ntStatus;
+
+    if (m_FileHandle)
+    {
+        IO_STATUS_BLOCK         ioStatusBlock;
+
+        ntStatus = ZwWriteFile( m_FileHandle,
+                                NULL,
+                                NULL,
+                                NULL,
+                                &ioStatusBlock,
+                                pData,
+                                ulDataSize,
+                                m_pFilePtr,
+                                NULL);
+
+        if (NT_SUCCESS(ntStatus))
+        {
+            ASSERT(ioStatusBlock.Information == ulDataSize);
+
+            m_pFilePtr->QuadPart += ulDataSize;
+        }
+    }
+    else
+    {
+        ntStatus = STATUS_INVALID_HANDLE;
+    }
+
+    return ntStatus;
+} // FileWrite
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CSaveData::FileWriteHeader(void)
+{
+    PAGED_CODE();
+
+    NTSTATUS                    ntStatus;
+
+    if (m_FileHandle && m_waveFormat)
+    {
+        IO_STATUS_BLOCK         ioStatusBlock;
+
+        m_pFilePtr->QuadPart = 0;
+
+        m_FileHeader.dwFormatLength = (m_waveFormat->wFormatTag == WAVE_FORMAT_PCM) ?
+                                        sizeof( PCMWAVEFORMAT ) :
+                                        sizeof( WAVEFORMATEX ) + m_waveFormat->cbSize;
+
+        ntStatus = ZwWriteFile( m_FileHandle,
+                                NULL,
+                                NULL,
+                                NULL,
+                                &ioStatusBlock,
+                                &m_FileHeader,
+                                sizeof(m_FileHeader),
+                                m_pFilePtr,
+                                NULL);
+
+        if (NT_SUCCESS(ntStatus))
+        {
+            m_pFilePtr->QuadPart += sizeof(m_FileHeader);
+
+            ntStatus = ZwWriteFile( m_FileHandle,
+                                    NULL,
+                                    NULL,
+                                    NULL,
+                                    &ioStatusBlock,
+                                    m_waveFormat,
+                                    m_FileHeader.dwFormatLength,
+                                    m_pFilePtr,
+                                    NULL);
+        }
+
+        if (NT_SUCCESS(ntStatus))
+        {
+            m_pFilePtr->QuadPart += m_FileHeader.dwFormatLength;
+
+            ntStatus = ZwWriteFile( m_FileHandle,
+                                    NULL,
+                                    NULL,
+                                    NULL,
+                                    &ioStatusBlock,
+                                    &m_DataHeader,
+                                    sizeof(m_DataHeader),
+                                    m_pFilePtr,
+                                    NULL);
+        }
+
+        if (NT_SUCCESS(ntStatus))
+        {
+            m_pFilePtr->QuadPart += sizeof(m_DataHeader);
+        }
+    }
+    else
+    {
+        ntStatus = STATUS_INVALID_HANDLE;
+    }
+
+
+    return ntStatus;
+} // FileWriteHeader
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CSaveData::SetDeviceObject
+(
+    _In_  PDEVICE_OBJECT        DeviceObject
+)
+{
+    PAGED_CODE();
+
+    ASSERT(DeviceObject);
+
+    NTSTATUS                    ntStatus = STATUS_SUCCESS;
+    
+    m_pDeviceObject = DeviceObject;
+    return ntStatus;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+PDEVICE_OBJECT
+CSaveData::GetDeviceObject
+(
+    void
+)
+{
+    PAGED_CODE();
+
+    return m_pDeviceObject;
+}
+
+//=============================================================================
+_Use_decl_annotations_
+PSAVEWORKER_PARAM
+CSaveData::GetNewWorkItem
+(
+    void
+)
+{
+    LARGE_INTEGER               timeOut = { 0 };
+    NTSTATUS                    ntStatus;
+
+    for (int i = 0; i < MAX_WORKER_ITEM_COUNT; i++)
+    {
+        ntStatus =
+            KeWaitForSingleObject
+            (
+                &m_pWorkItems[i].EventDone,
+                Executive,
+                KernelMode,
+                FALSE,
+                &timeOut
+            );
+        if (STATUS_SUCCESS == ntStatus)
+        {
+            if (m_pWorkItems[i].WorkItem)
+                return &(m_pWorkItems[i]);
+            else
+                return NULL;
+        }
+    }
+
+    return NULL;
+} // GetNewWorkItem
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CSaveData::Initialize
+(
+    _In_ BOOL       _bOffloaded
+)
+{
+    PAGED_CODE();
+
+    NTSTATUS            ntStatus = STATUS_SUCCESS;
+    WCHAR               szTemp[MAX_PATH];
+    size_t              cLen = 0;
+    IO_STATUS_BLOCK     ioStatusBlock = {0};
+    HANDLE              fileHandle;
+    OBJECT_ATTRIBUTES   objectAttributes;
+    UNICODE_STRING      fileName;
+
+    if (_bOffloaded)
+    {
+        m_ulOffloadStreamId++;
+    }
+    else
+    {
+        m_ulStreamId++;
+    }
+
+    RtlInitUnicodeString(&fileName, DEFAULT_FILE_FOLDER1);
+    InitializeObjectAttributes(
+            &objectAttributes,
+            &fileName,
+            OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
+            NULL,
+            NULL);
+
+    // Create the folder.
+    ntStatus = ZwCreateFile(
+            &fileHandle,
+            0,
+            &objectAttributes,
+            &ioStatusBlock,
+            NULL,
+            FILE_ATTRIBUTE_NORMAL,
+            0,
+            FILE_OPEN_IF,
+            FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
+            NULL,
+            0);
+
+    if (NT_SUCCESS(ntStatus))
+    {
+        ZwClose(fileHandle);
+        fileHandle = NULL;
+
+        RtlInitUnicodeString(&fileName, DEFAULT_FILE_FOLDER2);
+        InitializeObjectAttributes(
+                &objectAttributes,
+                &fileName,
+                OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
+                NULL,
+                NULL);
+
+        // Create the folder.
+        ntStatus = ZwCreateFile(
+                &fileHandle,
+                0,
+                &objectAttributes,
+                &ioStatusBlock,
+                NULL,
+                FILE_ATTRIBUTE_NORMAL,
+                0,
+                FILE_OPEN_IF,
+                FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
+                NULL,
+                0);
+
+        if (NT_SUCCESS(ntStatus))
+        {
+            ZwClose(fileHandle);
+            fileHandle = NULL;
+        }
+    }
+
+    if (NT_SUCCESS(ntStatus))
+    {
+        // Allocate data file name.
+        //
+        RtlStringCchPrintfW(szTemp, MAX_PATH, L"%s_%s_%d.wav", DEFAULT_FILE_NAME, _bOffloaded ? OFFLOAD_FILE_NAME : HOST_FILE_NAME, _bOffloaded ? m_ulOffloadStreamId : m_ulStreamId);
+        m_FileName.Length = 0;
+        ntStatus = RtlStringCchLengthW (szTemp, sizeof(szTemp)/sizeof(szTemp[0]), &cLen);
+    }
+
+    if (NT_SUCCESS(ntStatus))
+    {
+        m_FileName.MaximumLength = (USHORT)((cLen * sizeof(WCHAR)) + sizeof(WCHAR));//convert to wchar and add room for NULL
+        m_FileName.Buffer = (PWSTR)
+            ExAllocatePool2
+            (
+                POOL_FLAG_PAGED,
+                m_FileName.MaximumLength,
+                SAVEDATA_POOLTAG3
+            );
+        if (!m_FileName.Buffer)
+        {
+            ntStatus = STATUS_INSUFFICIENT_RESOURCES;
+        }
+    }
+
+    // Allocate memory for data buffer.
+    //
+    if (NT_SUCCESS(ntStatus))
+    {
+        RtlStringCbCopyW(m_FileName.Buffer, m_FileName.MaximumLength, szTemp);
+        m_FileName.Length = (USHORT)wcslen(m_FileName.Buffer) * sizeof(WCHAR);
+
+        m_pDataBuffer = (PBYTE)
+            ExAllocatePool2
+            (
+                POOL_FLAG_NON_PAGED,
+                m_ulBufferSize,
+                SAVEDATA_POOLTAG4
+            );
+        if (!m_pDataBuffer)
+        {
+            ntStatus = STATUS_INSUFFICIENT_RESOURCES;
+        }
+    }
+
+    // Allocate memory for frame usage flags and m_pFilePtr.
+    //
+    if (NT_SUCCESS(ntStatus))
+    {
+        m_fFrameUsed = (PBOOL)
+            ExAllocatePool2
+            (
+                POOL_FLAG_NON_PAGED,
+                m_ulFrameCount * sizeof(BOOL) +
+                sizeof(LARGE_INTEGER),
+                SAVEDATA_POOLTAG2
+            );
+        if (!m_fFrameUsed)
+        {
+            ntStatus = STATUS_INSUFFICIENT_RESOURCES;
+        }
+    }
+
+    // Initialize the spinlock to synchronize access to the frames
+    //
+    KeInitializeSpinLock ( &m_FrameInUseSpinLock ) ;
+
+    // Initialize the file mutex
+    //
+    KeInitializeMutex( &m_FileSync, 1 ) ;
+
+    // Open the data file.
+    //
+    if (NT_SUCCESS(ntStatus))
+    {
+        // m_fFrameUsed has additional memory to hold m_pFilePtr
+        //
+        m_pFilePtr = (PLARGE_INTEGER)
+            (((PBYTE) m_fFrameUsed) + m_ulFrameCount * sizeof(BOOL));
+
+        // Create data file.
+        InitializeObjectAttributes
+        (
+            &m_objectAttributes,
+            &m_FileName,
+            OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
+            NULL,
+            NULL
+        );
+
+        m_bInitialized = TRUE;
+
+        // Write wave header information to data file.
+        ntStatus = KeWaitForSingleObject
+            (
+                &m_FileSync,
+                Executive,
+                KernelMode,
+                FALSE,
+                NULL
+            );
+
+        if (STATUS_SUCCESS == ntStatus)
+        {
+            ntStatus = FileOpen(TRUE);
+            if (NT_SUCCESS(ntStatus))
+            {
+                ntStatus = FileWriteHeader();
+
+                FileClose();
+            }
+
+            KeReleaseMutex( &m_FileSync, FALSE );
+        }
+    }
+
+    return ntStatus;
+} // Initialize
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CSaveData::InitializeWorkItems
+(
+    _In_  PDEVICE_OBJECT        DeviceObject
+)
+{
+    PAGED_CODE();
+
+    ASSERT(DeviceObject);
+
+    NTSTATUS                    ntStatus = STATUS_SUCCESS;
+
+    if (m_pWorkItems != NULL)
+    {
+        return ntStatus;
+    }
+
+    m_pWorkItems = (PSAVEWORKER_PARAM)
+        ExAllocatePool2
+        (
+            POOL_FLAG_NON_PAGED,
+            sizeof(SAVEWORKER_PARAM) * MAX_WORKER_ITEM_COUNT,
+            SAVEDATA_POOLTAG
+        );
+    if (m_pWorkItems)
+    {
+        for (int i = 0; i < MAX_WORKER_ITEM_COUNT; i++)
+        {
+
+            m_pWorkItems[i].WorkItem = IoAllocateWorkItem(DeviceObject);
+            if(m_pWorkItems[i].WorkItem == NULL)
+            {
+              return STATUS_INSUFFICIENT_RESOURCES;
+            }
+            KeInitializeEvent
+            (
+                &m_pWorkItems[i].EventDone,
+                NotificationEvent,
+                TRUE
+            );
+        }
+    }
+    else
+    {
+        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
+    }
+
+    return ntStatus;
+} // InitializeWorkItems
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+VOID
+SaveFrameWorkerCallback
+(
+    _In_        PDEVICE_OBJECT         pDeviceObject, 
+    _In_opt_    PVOID                  Context
+)
+{
+    UNREFERENCED_PARAMETER(pDeviceObject);
+
+    PAGED_CODE();
+
+    ASSERT(Context);
+
+    PSAVEWORKER_PARAM           pParam = (PSAVEWORKER_PARAM) Context;
+    PCSaveData                  pSaveData;
+    
+    if (NULL == pParam)
+    {
+        // This is completely unexpected, assert here.
+        //
+        ASSERT(pParam);
+        return;
+    }
+
+    ASSERT(pParam->pSaveData);
+    ASSERT(pParam->pSaveData->m_fFrameUsed);
+
+    if (pParam->WorkItem)
+    {
+        pSaveData = pParam->pSaveData;
+
+        if (STATUS_SUCCESS == KeWaitForSingleObject
+            (
+                &pSaveData->m_FileSync,
+                Executive,
+                KernelMode,
+                FALSE,
+                NULL
+            ))
+        {
+            if (NT_SUCCESS(pSaveData->FileOpen(FALSE)))
+            { 
+                pSaveData->FileWrite(pParam->pData, pParam->ulDataSize);
+                pSaveData->FileClose();
+            }
+            InterlockedExchange( (LONG *)&(pSaveData->m_fFrameUsed[pParam->ulFrameNo]), FALSE );
+
+            KeReleaseMutex( &pSaveData->m_FileSync, FALSE );
+        }
+    }
+
+    KeSetEvent(&pParam->EventDone, 0, FALSE);
+} // SaveFrameWorkerCallback
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CSaveData::SetDataFormat
+(
+    _In_ PKSDATAFORMAT          pDataFormat
+)
+{
+    PAGED_CODE();
+    NTSTATUS                    ntStatus = STATUS_SUCCESS;
+ 
+    ASSERT(pDataFormat);
+
+    PWAVEFORMATEX pwfx = NULL;
+
+    if (IsEqualGUIDAligned(pDataFormat->Specifier,
+        KSDATAFORMAT_SPECIFIER_DSOUND))
+    {
+        pwfx =
+            &(((PKSDATAFORMAT_DSOUND) pDataFormat)->BufferDesc.WaveFormatEx);
+    }
+    else if (IsEqualGUIDAligned(pDataFormat->Specifier,
+        KSDATAFORMAT_SPECIFIER_WAVEFORMATEX))
+    {
+        pwfx = &((PKSDATAFORMAT_WAVEFORMATEX) pDataFormat)->WaveFormatEx;
+    }
+
+    if (pwfx)
+    {
+        // Free the previously allocated waveformat
+        if (m_waveFormat)
+        {
+            ExFreePoolWithTag(m_waveFormat, SAVEDATA_POOLTAG1);
+        }
+
+        m_waveFormat = (PWAVEFORMATEX)
+            ExAllocatePool2
+            (
+                POOL_FLAG_NON_PAGED,
+                (pwfx->wFormatTag == WAVE_FORMAT_PCM) ?
+                sizeof( PCMWAVEFORMAT ) :
+                sizeof( WAVEFORMATEX ) + pwfx->cbSize,
+                SAVEDATA_POOLTAG1
+            );
+
+        if(m_waveFormat)
+        {
+            RtlCopyMemory( m_waveFormat,
+                           pwfx,
+                           (pwfx->wFormatTag == WAVE_FORMAT_PCM) ?
+                           sizeof( PCMWAVEFORMAT ) :
+                           sizeof( WAVEFORMATEX ) + pwfx->cbSize);
+        }
+        else
+        {
+            ntStatus = STATUS_INSUFFICIENT_RESOURCES;
+        }
+    }
+    return ntStatus;
+} // SetDataFormat
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CSaveData::SetMaxWriteSize
+(
+    _In_ ULONG ulMaxWriteSize
+)
+{
+    PAGED_CODE();
+    
+    NTSTATUS    ntStatus    = STATUS_SUCCESS;
+    ULONG       bufferSize  = 0;
+    PBYTE       buffer      = NULL;
+ 
+    // 
+    // Compute new buffer size.
+    //
+    ntStatus = RtlULongMult(ulMaxWriteSize, DEFAULT_FRAME_COUNT, &bufferSize);
+    if (!NT_SUCCESS(ntStatus))
+    {
+        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
+        goto Done;
+    }
+
+    //
+    // Alloc memory for buffer.
+    //
+    buffer = (PBYTE)
+        ExAllocatePool2
+        (
+            POOL_FLAG_NON_PAGED,
+            bufferSize,
+            SAVEDATA_POOLTAG4
+        );
+    if (!buffer)
+    {
+        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
+        goto Done;
+    }
+
+    //
+    // Free old one.
+    //
+    if (m_pDataBuffer)
+    {
+        ExFreePoolWithTag(m_pDataBuffer, SAVEDATA_POOLTAG4);
+        m_pDataBuffer = NULL;
+    }
+
+    //
+    // Init new buffer settings.
+    //
+    m_pDataBuffer  = buffer;
+    m_ulBufferSize = bufferSize;
+    m_ulFrameSize  = ulMaxWriteSize;
+    
+    ntStatus = STATUS_SUCCESS;
+
+Done:
+    return ntStatus;
+} // SetDataFormat
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+void
+CSaveData::ReadData
+(
+    _Inout_updates_bytes_all_(ulByteCount)  PBYTE   pBuffer,
+    _In_                                    ULONG   ulByteCount
+)
+{
+    UNREFERENCED_PARAMETER(pBuffer);
+    UNREFERENCED_PARAMETER(ulByteCount);
+
+    PAGED_CODE();
+
+    // Not implemented yet.
+} // ReadData
+
+//=============================================================================
+_Use_decl_annotations_
+void
+CSaveData::SaveFrame
+(
+    _In_ ULONG                  ulFrameNo,
+    _In_ ULONG                  ulDataSize
+)
+{
+    PSAVEWORKER_PARAM           pParam = NULL;
+
+    pParam = GetNewWorkItem();
+    if (pParam)
+    {
+        pParam->pSaveData = this;
+        pParam->ulFrameNo = ulFrameNo;
+        pParam->ulDataSize = ulDataSize;
+        pParam->pData = m_pDataBuffer + ulFrameNo * m_ulFrameSize;
+        KeResetEvent(&pParam->EventDone);
+        IoQueueWorkItem(pParam->WorkItem, SaveFrameWorkerCallback,
+                        CriticalWorkQueue, (PVOID)pParam);
+    }
+} // SaveFrame
+
+//=============================================================================
+void
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CSaveData::WaitAllWorkItems
+(
+    void
+)
+{
+    PAGED_CODE();
+
+    // Save the last partially-filled frame
+    if (m_ulBufferOffset > m_ulFrameIndex * m_ulFrameSize)
+    {
+        ULONG size;
+        
+        size = m_ulBufferOffset - m_ulFrameIndex * m_ulFrameSize;
+        SaveFrame(m_ulFrameIndex, size);
+    }
+    
+    for (int i = 0; i < MAX_WORKER_ITEM_COUNT; i++)
+    {
+        KeWaitForSingleObject
+        (
+            &(m_pWorkItems[i].EventDone),
+            Executive,
+            KernelMode,
+            FALSE,
+            NULL
+        );
+    }
+} // WaitAllWorkItems
+
+//=============================================================================
+_Use_decl_annotations_
+void
+CSaveData::WriteData
+(
+    _In_reads_bytes_(ulByteCount)   PBYTE   pBuffer,
+    _In_                            ULONG   ulByteCount
+)
+{
+    ASSERT(pBuffer);
+
+    BOOL                        fSaveFrame = FALSE;
+    ULONG                       ulSaveFrameIndex = 0;
+    KIRQL                       oldIrql;
+
+    // If stream writing is disabled, then exit.
+    //
+    if (m_fWriteDisabled)
+    {
+        return;
+    }
+
+    if( 0 == ulByteCount )
+    {
+        return;
+    }
+
+    // The logic below assumes that write size is <= than frame size.
+    if (ulByteCount > m_ulFrameSize)
+    {
+        ulByteCount = m_ulFrameSize;
+    }
+        
+    // Check to see if this frame is available.
+    KeAcquireSpinLock(&m_FrameInUseSpinLock, &oldIrql);
+    if (!m_fFrameUsed[m_ulFrameIndex])
+    {
+        KeReleaseSpinLock(&m_FrameInUseSpinLock, oldIrql );
+
+        ULONG ulWriteBytes = ulByteCount;
+
+        if( (m_ulBufferSize - m_ulBufferOffset) < ulWriteBytes )
+        {
+            ulWriteBytes = m_ulBufferSize - m_ulBufferOffset;
+        }
+
+        RtlCopyMemory(m_pDataBuffer + m_ulBufferOffset, pBuffer, ulWriteBytes);
+        m_ulBufferOffset += ulWriteBytes;
+
+        // Check to see if we need to save this frame
+        if (m_ulBufferOffset >= ((m_ulFrameIndex + 1) * m_ulFrameSize))
+        {
+            fSaveFrame = TRUE;
+        }
+
+        // Loop the buffer, if we reached the end.
+        if (m_ulBufferOffset == m_ulBufferSize)
+        {
+            fSaveFrame = TRUE;
+            m_ulBufferOffset = 0;
+        }
+
+        if (fSaveFrame)
+        {
+            InterlockedExchange( (LONG *)&(m_fFrameUsed[m_ulFrameIndex]), TRUE );
+            ulSaveFrameIndex = m_ulFrameIndex;
+            m_ulFrameIndex = (m_ulFrameIndex + 1) % m_ulFrameCount;
+        }
+
+        // Write the left over if the next frame is available.
+        if (ulWriteBytes != ulByteCount)
+        {
+            KeAcquireSpinLock(&m_FrameInUseSpinLock, &oldIrql );
+            if (!m_fFrameUsed[m_ulFrameIndex])
+            {
+                KeReleaseSpinLock(&m_FrameInUseSpinLock, oldIrql );
+                RtlCopyMemory
+                (
+                    m_pDataBuffer + m_ulBufferOffset,
+                    pBuffer + ulWriteBytes,
+                    ulByteCount - ulWriteBytes
+                );
+                
+                m_ulBufferOffset += ulByteCount - ulWriteBytes;
+            }
+            else
+            {
+                KeReleaseSpinLock(&m_FrameInUseSpinLock, oldIrql);
+            }
+        }
+
+        if (fSaveFrame)
+        {
+            SaveFrame(ulSaveFrameIndex, m_ulFrameSize);
+        }
+    }
+    else
+    {
+        KeReleaseSpinLock(&m_FrameInUseSpinLock, oldIrql );
+    }
+
+} // WriteData
+
+
diff --git a/audio/Acx/Samples/Common/SaveData.h b/audio/Acx/Samples/Common/SaveData.h
new file mode 100644
index 00000000..9138352f
--- /dev/null
+++ b/audio/Acx/Samples/Common/SaveData.h
@@ -0,0 +1,259 @@
+/*++
+
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+    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:
+
+    SaveData.h
+
+Abstract:
+
+    Declaration of data saving class for ACX driver samples. This class supplies services
+to save data to disk.
+
+
+--*/
+
+#pragma once
+
+//-----------------------------------------------------------------------------
+//  Forward declaration
+//-----------------------------------------------------------------------------
+class CSaveData;
+typedef CSaveData *PCSaveData;
+
+
+//-----------------------------------------------------------------------------
+//  Structs
+//-----------------------------------------------------------------------------
+
+// Parameter to workitem.
+#include <pshpack1.h>
+typedef struct _SAVEWORKER_PARAM {
+    PIO_WORKITEM     WorkItem;
+    ULONG            ulFrameNo;
+    ULONG            ulDataSize;
+    PBYTE            pData;
+    PCSaveData       pSaveData;
+    KEVENT           EventDone;
+} SAVEWORKER_PARAM;
+typedef SAVEWORKER_PARAM *PSAVEWORKER_PARAM;
+#include <poppack.h>
+
+// wave file header.
+#include <pshpack1.h>
+typedef struct _OUTPUT_FILE_HEADER
+{
+    DWORD           dwRiff;
+    DWORD           dwFileSize;
+    DWORD           dwWave;
+    DWORD           dwFormat;
+    DWORD           dwFormatLength;
+} OUTPUT_FILE_HEADER;
+typedef OUTPUT_FILE_HEADER *POUTPUT_FILE_HEADER;
+
+typedef struct _OUTPUT_DATA_HEADER
+{
+    DWORD           dwData;
+    DWORD           dwDataLength;
+} OUTPUT_DATA_HEADER;
+typedef OUTPUT_DATA_HEADER *POUTPUT_DATA_HEADER;
+
+#include <poppack.h>
+
+//-----------------------------------------------------------------------------
+//  Classes
+//-----------------------------------------------------------------------------
+
+///////////////////////////////////////////////////////////////////////////////
+// CSaveData
+//   Saves the wave data to disk.
+//
+__drv_maxIRQL(PASSIVE_LEVEL)
+PAGED_CODE_SEG
+IO_WORKITEM_ROUTINE SaveFrameWorkerCallback;
+
+class CSaveData
+{
+protected:
+    UNICODE_STRING              m_FileName;         // DataFile name.
+    HANDLE                      m_FileHandle;       // DataFile handle.
+    PBYTE                       m_pDataBuffer;      // Data buffer.
+    ULONG                       m_ulBufferSize;     // Total buffer size.
+
+    ULONG                       m_ulFrameIndex;     // Current Frame.
+    ULONG                       m_ulFrameCount;     // Frame count.
+    ULONG                       m_ulFrameSize;
+    ULONG                       m_ulBufferOffset;   // index in buffer.
+    PBOOL                       m_fFrameUsed;       // Frame usage table.
+    KSPIN_LOCK                  m_FrameInUseSpinLock; // Spinlock for synch.
+    KMUTEX                      m_FileSync;         // Synchronizes file access
+
+    OBJECT_ATTRIBUTES           m_objectAttributes; // Used for opening file.
+
+    OUTPUT_FILE_HEADER          m_FileHeader;
+    PWAVEFORMATEX               m_waveFormat;
+    OUTPUT_DATA_HEADER          m_DataHeader;
+    PLARGE_INTEGER              m_pFilePtr;
+
+    static PDEVICE_OBJECT       m_pDeviceObject;
+    static ULONG                m_ulStreamId;
+    static ULONG                m_ulOffloadStreamId;
+    static PSAVEWORKER_PARAM    m_pWorkItems;
+
+    BOOL                        m_fWriteDisabled;
+
+    BOOL                        m_bInitialized;
+
+public:
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    CSaveData();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    ~CSaveData();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    void
+    Cleanup(
+        void
+        );
+
+    static
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS             
+    InitializeWorkItems(
+        _In_  PDEVICE_OBJECT    DeviceObject
+        );
+
+    static
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    void
+    DestroyWorkItems(
+        void
+        );
+    
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    void
+    Disable(
+        _In_ BOOL               fDisable
+        );
+    
+    static
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    PSAVEWORKER_PARAM
+    GetNewWorkItem(
+        void
+        );
+    
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    Initialize(
+        _In_ BOOL               _bOffloaded
+        );
+	
+    static
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    SetDeviceObject(
+	    _In_  PDEVICE_OBJECT    DeviceObject
+	    );
+	
+    static
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    PDEVICE_OBJECT
+    GetDeviceObject(
+	    void
+	    );
+    
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    void
+    ReadData(
+        _Inout_updates_bytes_all_(ulByteCount)  PBYTE   pBuffer,
+        _In_                                    ULONG   ulByteCount
+        );
+    
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    SetDataFormat(
+        _In_  PKSDATAFORMAT     pDataFormat
+        );
+    
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    SetMaxWriteSize(
+        _In_  ULONG             ulMaxWriteSize
+        );  
+    
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    void
+    WaitAllWorkItems(
+        void
+        );
+
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    void
+    WriteData(
+        _In_reads_bytes_(ulByteCount)   PBYTE   pBuffer,
+        _In_                            ULONG   ulByteCount
+        );
+
+private:
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    FileClose(
+        void
+        );
+    
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    FileOpen(
+        _In_  BOOL              fOverWrite
+        );
+    
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    FileWrite(
+        _In_reads_bytes_(ulDataSize)    PBYTE   pData,
+        _In_                            ULONG   ulDataSize
+        );
+    
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    FileWriteHeader(
+        void
+        );
+
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    void
+    SaveFrame(
+        _In_ ULONG              ulFrameNo,
+        _In_ ULONG              ulDataSize
+        );
+
+    friend
+    IO_WORKITEM_ROUTINE         SaveFrameWorkerCallback;
+};
+typedef CSaveData *PCSaveData;
+
diff --git a/audio/Acx/Samples/Common/SimPeakMeter.cpp b/audio/Acx/Samples/Common/SimPeakMeter.cpp
new file mode 100644
index 00000000..0dfbd4e5
--- /dev/null
+++ b/audio/Acx/Samples/Common/SimPeakMeter.cpp
@@ -0,0 +1,106 @@
+/*++
+
+    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:
+
+    SimPeakMeter.cpp
+
+Abstract:
+
+    Virtual Peakmeter - aggregates all streams
+
+Environment:
+
+    Kernel mode
+
+--*/
+
+#include "private.h"
+#include "SimPeakMeter.h"
+
+#ifndef __INTELLISENSE__
+#include "SimPeakMeter.tmh"
+#endif
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CSimPeakMeter::CSimPeakMeter()
+{
+    PAGED_CODE();
+    m_NumStreams = 0;
+    m_PeakMeterIndex = 0;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CSimPeakMeter::~CSimPeakMeter()
+{
+    PAGED_CODE();
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+LONG CSimPeakMeter::GetValue(ULONG Channel)
+{
+    PAGED_CODE();
+
+    // Ignore channel
+    UNREFERENCED_PARAMETER(Channel);
+
+#define PEAKMETER_VALUE_FULL        (PEAKMETER_MAXIMUM / PEAKMETER_STEPPING_DELTA * PEAKMETER_STEPPING_DELTA)
+#define PEAKMETER_VALUE_HALF        (PEAKMETER_MAXIMUM / 2 / PEAKMETER_STEPPING_DELTA * PEAKMETER_STEPPING_DELTA)
+#define PEAKMETER_VALUE_QUARTER     (PEAKMETER_MAXIMUM / 4 / PEAKMETER_STEPPING_DELTA * PEAKMETER_STEPPING_DELTA)
+#define PEAKMETER_VALUE_ONE_EIGTH   (PEAKMETER_MAXIMUM / 8 / PEAKMETER_STEPPING_DELTA * PEAKMETER_STEPPING_DELTA)
+
+    LONG PeakMeterValues[] = {
+    PEAKMETER_VALUE_ONE_EIGTH,
+    PEAKMETER_VALUE_QUARTER,
+    PEAKMETER_VALUE_HALF,
+    PEAKMETER_VALUE_FULL,
+    PEAKMETER_VALUE_HALF,
+    PEAKMETER_VALUE_QUARTER
+    };
+
+    if (m_NumStreams)
+    {
+        LONG pmi = InterlockedIncrement(&m_PeakMeterIndex);
+        if (pmi == ARRAYSIZE(PeakMeterValues))
+        {
+            pmi = 0;
+            InterlockedExchange(&m_PeakMeterIndex, 0);
+        }
+
+        return PeakMeterValues[pmi];
+    }
+
+    //
+    // No active streams. Peak meter = 0
+    //
+    return 0;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS CSimPeakMeter::StartStream()
+{
+    PAGED_CODE();
+    InterlockedIncrement(&m_NumStreams);
+
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS CSimPeakMeter::StopStream()
+{
+    PAGED_CODE();
+
+    ASSERT(m_NumStreams);
+    InterlockedDecrement(&m_NumStreams);
+
+    return STATUS_SUCCESS;
+}
diff --git a/audio/Acx/Samples/Common/SimPeakMeter.h b/audio/Acx/Samples/Common/SimPeakMeter.h
new file mode 100644
index 00000000..7203f299
--- /dev/null
+++ b/audio/Acx/Samples/Common/SimPeakMeter.h
@@ -0,0 +1,51 @@
+/*++
+
+    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:
+
+    SimPeakMeter.h
+
+Abstract:
+
+    Virtual Peakmeter - aggregates all streams
+
+Environment:
+
+    Kernel mode
+
+--*/
+
+#pragma once
+
+class CSimPeakMeter
+{
+public:
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    CSimPeakMeter();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    ~CSimPeakMeter();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    LONG GetValue(_In_ ULONG Channel);
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS StartStream();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS StopStream();
+
+private:
+    LONG m_NumStreams;
+    LONG m_PeakMeterIndex;
+};
+
diff --git a/audio/Acx/Samples/Common/StreamEngine.cpp b/audio/Acx/Samples/Common/StreamEngine.cpp
new file mode 100644
index 00000000..be90bac6
--- /dev/null
+++ b/audio/Acx/Samples/Common/StreamEngine.cpp
@@ -0,0 +1,1345 @@
+/*++
+
+    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:
+
+    StreamEngine.cpp
+
+Abstract:
+
+    Virtual Streaming Engine - this module controls streaming logic for
+    the device.
+
+Environment:
+
+    Kernel mode
+
+--*/
+
+#include "private.h"
+#include "public.h"
+#include <devguid.h>
+#include <ks.h>
+#include <mmsystem.h>
+#include <ksmedia.h>
+#include "streamengine.h"
+
+#ifndef __INTELLISENSE__
+#include "streamengine.tmh"
+#endif
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CStreamEngine::CStreamEngine(
+    _In_ ACXSTREAM Stream,
+    _In_ ACXDATAFORMAT StreamFormat,
+    _In_ BOOL Offload,
+    _In_opt_ CSimPeakMeter *CircuitPeakmeter
+)
+    : m_PacketsCount(0),
+    m_PacketSize(0),
+    m_FirstPacketOffset(0),
+    m_NotificationTimer(NULL),
+    m_CurrentState(AcxStreamStateStop),
+    m_CurrentPacket(0),
+    m_Position(0),
+    m_Stream(Stream),
+    m_StreamFormat(StreamFormat),
+    m_StartTime(0),
+    m_StartPosition(0),
+    m_GlitchAdjust(0),
+    m_ToneFrequency(DEFAULT_FREQUENCY),
+    m_Offload(Offload),
+    m_pCircuitPeakmeter(CircuitPeakmeter)
+{
+    PAGED_CODE();
+
+    KeQueryPerformanceCounter(&m_PerformanceCounterFrequency);
+    RtlZeroMemory(m_Packets, sizeof(m_Packets));
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CStreamEngine::~CStreamEngine()
+{
+    PAGED_CODE();
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CStreamEngine::AllocateRtPackets(
+    _In_    ULONG           PacketCount,
+    _In_    ULONG           PacketSize,
+    _Out_   PACX_RTPACKET* Packets
+)
+{
+    NTSTATUS status = STATUS_SUCCESS;
+    PACX_RTPACKET packets = NULL;
+    PVOID packetBuffer = NULL;
+    ULONG i;
+    ULONG packetAllocSizeInPages = 0;
+    ULONG packetAllocSizeInBytes = 0;
+    ULONG firstPacketOffset = 0;
+    size_t packetsSize = 0;
+
+    PAGED_CODE();
+
+    if (PacketCount > MAX_PACKET_COUNT)
+    {
+        ASSERT(FALSE);
+        status = STATUS_INVALID_PARAMETER;
+        goto exit;
+    }
+
+    status = RtlSizeTMult(PacketCount, sizeof(ACX_RTPACKET), &packetsSize);
+    if (!NT_SUCCESS(status))
+    {
+        ASSERT(FALSE);
+        goto exit;
+    }
+
+    packets = (PACX_RTPACKET)ExAllocatePool2(POOL_FLAG_NON_PAGED, packetsSize, DeviceDriverTag);
+    if (!packets)
+    {
+        status = STATUS_NO_MEMORY;
+        ASSERT(FALSE);
+        goto exit;
+    }
+
+    //
+    // We need to allocate page-aligned buffers, to ensure no kernel memory leaks
+    // to user space. Round up the packet size to page aligned, then calculate
+    // the first packet's buffer offset so packet 0 ends on a page boundary and
+    // packet 1 begins on a page boundary.
+    //
+    status = RtlULongAdd(PacketSize, PAGE_SIZE - 1, &packetAllocSizeInPages);
+    if (!NT_SUCCESS(status))
+    {
+        ASSERT(FALSE);
+        goto exit;
+    }
+    packetAllocSizeInPages = packetAllocSizeInPages / PAGE_SIZE;
+    packetAllocSizeInBytes = PAGE_SIZE * packetAllocSizeInPages;
+    firstPacketOffset = packetAllocSizeInBytes - PacketSize;
+
+    for (i = 0; i < PacketCount; ++i)
+    {
+        PMDL pMdl = NULL;
+
+        ACX_RTPACKET_INIT(&packets[i]);
+
+        packetBuffer = ExAllocatePool2(POOL_FLAG_NON_PAGED, packetAllocSizeInBytes, DeviceDriverTag);
+        if (packetBuffer == NULL)
+        {
+            status = STATUS_NO_MEMORY;
+            goto exit;
+        }
+
+        pMdl = IoAllocateMdl(packetBuffer, packetAllocSizeInBytes, FALSE, TRUE, NULL);
+        if (pMdl == NULL)
+        {
+            status = STATUS_NO_MEMORY;
+            goto exit;
+        }
+
+        MmBuildMdlForNonPagedPool(pMdl);
+
+        WDF_MEMORY_DESCRIPTOR_INIT_MDL(&((packets)[i].RtPacketBuffer), pMdl, packetAllocSizeInBytes);
+
+        packets[i].RtPacketSize = PacketSize;
+        if (i == 0)
+        {
+            packets[i].RtPacketOffset = firstPacketOffset;
+        }
+        else
+        {
+            packets[i].RtPacketOffset = 0;
+        }
+        m_Packets[i] = packetBuffer;
+
+        packetBuffer = NULL;
+    }
+
+    *Packets = packets;
+    packets = NULL;
+    m_PacketsCount = PacketCount;
+    m_PacketSize = PacketSize;
+    m_FirstPacketOffset = firstPacketOffset;
+
+exit:
+    if (packetBuffer)
+    {
+        ExFreePoolWithTag(packetBuffer, DeviceDriverTag);
+    }
+    if (packets)
+    {
+        FreeRtPackets(packets, PacketCount);
+    }
+    return status;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+VOID
+CStreamEngine::FreeRtPackets(
+    _Frees_ptr_ PACX_RTPACKET   Packets,
+    _In_        ULONG           PacketCount
+)
+{
+    ULONG i;
+    PVOID buffer;
+
+    PAGED_CODE();
+
+    for (i = 0; i < PacketCount; ++i)
+    {
+        if (Packets[i].RtPacketBuffer.u.MdlType.Mdl)
+        {
+            buffer = MmGetMdlVirtualAddress(Packets[i].RtPacketBuffer.u.MdlType.Mdl);
+            IoFreeMdl(Packets[i].RtPacketBuffer.u.MdlType.Mdl);
+            ExFreePool(buffer);
+        }
+    }
+
+    ExFreePool(Packets);
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CStreamEngine::PrepareHardware()
+{
+    NTSTATUS                status = STATUS_UNSUCCESSFUL;
+    WDF_TIMER_CONFIG        timerConfig;
+    WDF_OBJECT_ATTRIBUTES   timerAttributes;
+    PSTREAM_TIMER_CONTEXT   timerCtx;
+
+    PAGED_CODE();
+
+    //
+    // If already in this state, do nothing.
+    //
+    if (m_CurrentState == AcxStreamStatePause)
+    {
+        // Nothing to do.
+        status = STATUS_SUCCESS;
+        goto exit;
+    }
+
+    if (m_CurrentState != AcxStreamStateStop)
+    {
+        // Error out.
+        status = STATUS_INVALID_STATE_TRANSITION;
+        goto exit;
+    }
+
+    //
+    // Stop to Pause.
+    //
+    WDF_TIMER_CONFIG_INIT(&timerConfig, CStreamEngine::s_EvtStreamPassCallback);
+    timerConfig.AutomaticSerialization = TRUE;
+    timerConfig.UseHighResolutionTimer = WdfTrue;
+    timerConfig.Period = 0;
+
+    WDF_OBJECT_ATTRIBUTES_INIT(&timerAttributes);
+    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&timerAttributes, STREAM_TIMER_CONTEXT);
+    timerAttributes.ParentObject = m_Stream;
+
+    status = WdfTimerCreate(&timerConfig, &timerAttributes, &m_NotificationTimer);
+    if (!NT_SUCCESS(status))
+    {
+        goto exit;
+    }
+
+    timerCtx = GetStreamTimerContext(m_NotificationTimer);
+    timerCtx->StreamEngine = this;
+
+    m_CurrentState = AcxStreamStatePause;
+    status = STATUS_SUCCESS;
+
+exit:
+    return status;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CStreamEngine::ReleaseHardware()
+{
+    PAGED_CODE();
+
+    //
+    // If already in this state, do nothing.
+    //
+    if (m_CurrentState == AcxStreamStateStop)
+    {
+        // Nothing to do.
+        goto exit;
+    }
+
+    //
+    // Just assert we are in the correct state. 
+    // On the way down we always want to succeed.
+    //
+    ASSERT(m_CurrentState == AcxStreamStatePause);
+
+    //
+    // Pause to Stop.
+    //
+    if (m_NotificationTimer)
+    {
+        WdfTimerStop(m_NotificationTimer, TRUE);
+        WdfObjectDelete(m_NotificationTimer);
+        m_NotificationTimer = NULL;
+    }
+
+    KeFlushQueuedDpcs();
+
+    m_Position = 0;
+    m_GlitchAdjust = 0;
+    m_CurrentPacket = 0;
+
+    m_CurrentState = AcxStreamStateStop;
+
+exit:
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CStreamEngine::Pause()
+{
+    NTSTATUS status = STATUS_UNSUCCESSFUL;
+
+    PAGED_CODE();
+
+    if (m_CurrentState == AcxStreamStatePause)
+    {
+        // Nothing to do.
+        status = STATUS_SUCCESS;
+        goto exit;
+    }
+
+    if (m_CurrentState != AcxStreamStateRun)
+    {
+        // Error out.
+        status = STATUS_INVALID_STATE_TRANSITION;
+        goto exit;
+    }
+
+    m_PeakMeter.StopStream();
+    if (m_pCircuitPeakmeter)
+    {
+        m_pCircuitPeakmeter->StopStream();
+    }
+
+    //
+    // Run to Pause.
+    //
+    WdfTimerStop(m_NotificationTimer, TRUE);
+
+    // Save the position we paused at.
+    UpdatePosition();
+
+    m_CurrentState = AcxStreamStatePause;
+    status = STATUS_SUCCESS;
+
+exit:
+    return status;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CStreamEngine::Run()
+{
+    NTSTATUS status = STATUS_UNSUCCESSFUL;
+
+    PAGED_CODE();
+
+    if (m_CurrentState == AcxStreamStateRun)
+    {
+        // Nothing to do.
+        status = STATUS_SUCCESS;
+        goto exit;
+    }
+
+    if (m_CurrentState != AcxStreamStatePause)
+    {
+        status = STATUS_INVALID_STATE_TRANSITION;
+        goto exit;
+    }
+
+    m_PeakMeter.StartStream();
+    if (m_pCircuitPeakmeter)
+    {
+        m_pCircuitPeakmeter->StartStream();
+    }
+
+    //
+    // Pause to Run.
+    //
+    // Save the time and position - if we ran and paused previously, the StartTime and StartPosition will allow
+    // us to continue scheduling packet completions correctly, while still reporting absolute position from the
+    // start of the stream.
+    //
+    m_StartTime = KSCONVERT_PERFORMANCE_TIME(m_PerformanceCounterFrequency.QuadPart, KeQueryPerformanceCounter(NULL));
+    m_StartPosition = m_Position;
+
+    // Reset time we've lost to glitches
+    m_GlitchAdjust = 0;
+
+    ScheduleNextPass();
+
+    m_CurrentState = AcxStreamStateRun;
+    status = STATUS_SUCCESS;
+
+exit:
+    return status;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CStreamEngine::GetPresentationPosition(
+    _Out_   PULONGLONG      PositionInBlocks,
+    _Out_   PULONGLONG      QPCPosition
+)
+{
+    ULONG blockAlign;
+    LARGE_INTEGER qpc;
+
+    PAGED_CODE();
+
+    blockAlign = AcxDataFormatGetBlockAlign(m_StreamFormat);
+
+    // Update the position based on the current time
+    UpdatePosition();
+    qpc = KeQueryPerformanceCounter(NULL);
+
+    *PositionInBlocks = m_Position / blockAlign;
+    *QPCPosition = (ULONGLONG)qpc.QuadPart;
+
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CStreamEngine::GetLinearBufferPosition(
+    _Out_   PULONGLONG      Position
+)
+{
+    UNREFERENCED_PARAMETER(Position);
+    PAGED_CODE();
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CStreamEngine::SetCurrentWritePosition(
+    _In_   ULONG      Position
+)
+{
+    UNREFERENCED_PARAMETER(Position);
+    PAGED_CODE();
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CStreamEngine::SetLastBufferPosition(
+    _In_   ULONG      Position
+)
+{
+    UNREFERENCED_PARAMETER(Position);
+    PAGED_CODE();
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CStreamEngine::AssignDrmContentId(
+    ULONG          DrmContentId,
+    PACXDRMRIGHTS  DrmRights
+)
+{
+    PAGED_CODE();
+
+    UNREFERENCED_PARAMETER(DrmContentId);
+    UNREFERENCED_PARAMETER(DrmRights);
+    
+    //
+    // At this point the driver should enforce the new DrmRights.
+    //
+    // HDMI render: if DigitalOutputDisable or CopyProtect is true, enable HDCP.
+    // 
+    // From MSDN:
+    //
+    // This sample doesn't forward protected content, but if your driver uses 
+    // lower layer drivers or a different stack to properly work, please see the 
+    // following info from MSDN:
+    //
+    // "Before allowing protected content to flow through a data path, the system
+    // verifies that the data path is secure. To do so, the system authenticates
+    // each module in the data path beginning at the upstream end of the data path
+    // and moving downstream. As each module is authenticated, that module gives
+    // the system information about the next module in the data path so that it
+    // can also be authenticated. To be successfully authenticated, a module's 
+    // binary file must be signed as DRM-compliant.
+    //
+    // Two adjacent modules in the data path can communicate with each other in 
+    // one of several ways. If the upstream module calls the downstream module 
+    // through IoCallDriver, the downstream module is part of a WDM driver. In 
+    // this case, the upstream module calls the AcxDrmForwardContentToDeviceObject
+    // function to provide the system with the device object representing the 
+    // downstream module. (If the two modules communicate through the downstream
+    // module's content handlers, the upstream module calls AcxDrmAddContentHandlers
+    // instead.)
+    //
+    // For more information, see MSDN's DRM Functions and Interfaces.
+    //
+
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CStreamEngine::GetHWLatency(
+    _Out_   ULONG* FifoSize,
+    _Out_   ULONG* Delay
+)
+{
+    PAGED_CODE();
+
+    *FifoSize = 128;
+    *Delay = 0;
+
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CSimPeakMeter *
+CStreamEngine::GetPeakMeter()
+{
+    PAGED_CODE();
+
+    return &m_PeakMeter;
+}
+
+_Use_decl_annotations_
+VOID
+CStreamEngine::s_EvtStreamPassCallback(
+    _In_    WDFTIMER        Timer
+)
+{
+    CStreamEngine* This;
+    PSTREAM_TIMER_CONTEXT timerCtx;
+
+    // Get our stream engine pointer from the timer context
+    timerCtx = GetStreamTimerContext(Timer);
+    This = timerCtx->StreamEngine;
+
+    // Call the StreamPassCallback for the engine
+    This->StreamPassCallback();
+}
+
+// This is run every time the stream timer fires
+_Use_decl_annotations_
+VOID
+CStreamEngine::StreamPassCallback()
+{
+    ULONGLONG completedPacket;
+    ULONGLONG qpcCompleted;
+
+    // Process the packet (e.g. save render to file/generate capture data)
+    ProcessPacket();
+
+    // We've completed a packet! Increment our currently active packet
+    completedPacket = (ULONG)InterlockedIncrement((LONG*)&m_CurrentPacket) - 1;
+    // Save the time at which we moved to the next packet
+    qpcCompleted = (ULONGLONG)KeQueryPerformanceCounter(NULL).QuadPart;
+
+    InterlockedExchange64(&m_LastPacketStart.QuadPart, m_CurrentPacketStart.QuadPart);
+    InterlockedExchange64(&m_CurrentPacketStart.QuadPart, qpcCompleted);
+
+    // Tell ACX we've completed the packet.
+    (void)AcxRtStreamNotifyPacketComplete(m_Stream, completedPacket, qpcCompleted);
+
+    // Schedule when our new current packet will finish
+    ScheduleNextPass();
+}
+
+_Use_decl_annotations_
+VOID
+CStreamEngine::ScheduleNextPass()
+{
+    LONGLONG delay = 0;
+    ULONG bytesPerSecond;
+    ULONGLONG nextPacket = 0;
+    ULONGLONG nextPacketStartPosition = 0;
+    ULONGLONG nextPacketPositionFromLastPause = 0;
+    ULONGLONG nextPacketTimeFromLastPauseHns = 0;
+    ULONGLONG nextPacketTime = 0;
+    ULONGLONG currentTime;
+    BOOLEAN inTimerQueue = FALSE;
+
+    // Get the number of bytes per second from our stored stream format
+    bytesPerSecond = GetBytesPerSecond();
+
+    // Calculate the absolute position of the beginning of the next packet from the beginning of the stream
+    nextPacket = m_CurrentPacket + 1;
+    nextPacketStartPosition = nextPacket * m_PacketSize;
+
+    // Adjust next packet position to account for the last time we resumed from Pause
+    nextPacketPositionFromLastPause = nextPacketStartPosition - m_StartPosition;
+
+    // Convert from bytes to HNS (to prevent truncation, multiply first then divide)
+    nextPacketTimeFromLastPauseHns = nextPacketPositionFromLastPause * HNS_PER_SEC / bytesPerSecond;
+
+    // Next packet time is Time @ resume from Pause, offset for lost time due to glitch, with next packet time added
+    nextPacketTime = m_StartTime + m_GlitchAdjust + nextPacketTimeFromLastPauseHns;
+
+    currentTime = KSCONVERT_PERFORMANCE_TIME(m_PerformanceCounterFrequency.QuadPart, KeQueryPerformanceCounter(NULL));
+
+    // Determine how long we want to wait, in HNS. Negative since it's a relative wait
+    delay = -(LONGLONG)(nextPacketTime - currentTime);
+
+    // If the delay isn't negative, this means we lost some time (e.g. broken into kernel debugger). Update
+    // our glitch adjust to account for that lost time, and attempt to schedule again
+    if (delay >= 0)
+    {
+        // Glitch!!!
+        // Update the glitch adjustment and set the new delay.
+        m_GlitchAdjust += delay;
+
+        StreamPassCallback();
+
+        return;
+    }
+
+    // Start the timer for our next pass! Note the timer isn't periodic.
+    inTimerQueue = WdfTimerStart(m_NotificationTimer, delay);
+
+    // We shouldn't be scheduling our next pass if the timer was previously still pending
+    ASSERT(inTimerQueue == FALSE);
+}
+
+_Use_decl_annotations_
+VOID
+CStreamEngine::UpdatePosition()
+{
+    ULONGLONG currentTime;
+    ULONG bytesPerSecond;
+
+    if (m_CurrentState != AcxStreamStateRun)
+    {
+        return;
+    }
+    bytesPerSecond = GetBytesPerSecond();
+    currentTime = KSCONVERT_PERFORMANCE_TIME(m_PerformanceCounterFrequency.QuadPart, KeQueryPerformanceCounter(NULL));
+
+    // Update position
+    m_Position = m_StartPosition - m_GlitchAdjust + (currentTime - m_StartTime) * bytesPerSecond / HNS_PER_SEC;
+}
+
+_Use_decl_annotations_
+ULONG
+CStreamEngine::GetBytesPerSecond()
+{
+    ULONG bytesPerSecond;
+
+    bytesPerSecond = AcxDataFormatGetAverageBytesPerSec(m_StreamFormat);
+
+    return bytesPerSecond;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CStreamEngine::GetCurrentPacket(
+    _Out_   PULONG          CurrentPacket
+)
+{
+    ULONG currentPacket;
+    PAGED_CODE();
+
+    currentPacket = (ULONG)InterlockedCompareExchange((LONG*)&m_CurrentPacket, -1, -1);
+
+    *CurrentPacket = currentPacket;
+
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CRenderStreamEngine::CRenderStreamEngine(
+    _In_    ACXSTREAM       Stream,
+    _In_    ACXDATAFORMAT   StreamFormat,
+    _In_    BOOL            Offload,
+    _In_    CSimPeakMeter * CircuitPeakmeter
+
+)
+    : CStreamEngine(Stream, StreamFormat, Offload, CircuitPeakmeter)
+{
+    PAGED_CODE();
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CRenderStreamEngine::~CRenderStreamEngine()
+{
+    PAGED_CODE();
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CRenderStreamEngine::PrepareHardware()
+{
+    NTSTATUS status = STATUS_SUCCESS;
+
+    PAGED_CODE();
+
+    status = CStreamEngine::PrepareHardware();
+    if (!NT_SUCCESS(status))
+    {
+        goto exit;
+    }
+
+    status = m_SaveData.SetDataFormat((PKSDATAFORMAT)AcxDataFormatGetKsDataFormat(m_StreamFormat));
+    if (!NT_SUCCESS(status))
+    {
+        status = STATUS_SUCCESS;
+        goto exit;
+    }
+
+    status = m_SaveData.Initialize(m_Offload);
+    if (!NT_SUCCESS(status))
+    {
+        status = STATUS_SUCCESS;
+        goto exit;
+    }
+
+    status = m_SaveData.SetMaxWriteSize(m_PacketSize * m_PacketsCount * 16);
+    if (!NT_SUCCESS(status))
+    {
+        status = STATUS_SUCCESS;
+        goto exit;
+    }
+
+exit:
+    return status;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CRenderStreamEngine::ReleaseHardware()
+{
+    PAGED_CODE();
+
+    m_SaveData.WaitAllWorkItems();
+    m_SaveData.Cleanup();
+
+    return CStreamEngine::ReleaseHardware();
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CRenderStreamEngine::AssignDrmContentId(
+    ULONG          DrmContentId,
+    PACXDRMRIGHTS  DrmRights
+    )
+{
+    PAGED_CODE();
+
+    UNREFERENCED_PARAMETER(DrmContentId);
+
+    //
+    // At this point the driver should enforce the new DrmRights.
+    // The sample driver handles DrmRights per stream basis, and 
+    // stops writing the stream to disk, if CopyProtect = TRUE.
+    //
+    // HDMI render: if DigitalOutputDisable or CopyProtect is true, enable HDCP.
+    // Loopback: if CopyProtect is true, disable loopback stream.
+    //
+    
+    //
+    // Sample writes each stream seperately to disk. If the rights for this
+    // stream indicates that the stream is CopyProtected, stop writing to disk.
+    //
+    m_SaveData.Disable(DrmRights->CopyProtect);
+
+    //
+    // From MSDN:
+    //
+    // This sample doesn't forward protected content, but if your driver uses 
+    // lower layer drivers or a different stack to properly work, please see the 
+    // following info from MSDN:
+    //
+    // "Before allowing protected content to flow through a data path, the system
+    // verifies that the data path is secure. To do so, the system authenticates
+    // each module in the data path beginning at the upstream end of the data path
+    // and moving downstream. As each module is authenticated, that module gives
+    // the system information about the next module in the data path so that it
+    // can also be authenticated. To be successfully authenticated, a module's 
+    // binary file must be signed as DRM-compliant.
+    //
+    // Two adjacent modules in the data path can communicate with each other in 
+    // one of several ways. If the upstream module calls the downstream module 
+    // through IoCallDriver, the downstream module is part of a WDM driver. In 
+    // this case, the upstream module calls the AcxDrmForwardContentToDeviceObject
+    // function to provide the system with the device object representing the 
+    // downstream module. (If the two modules communicate through the downstream
+    // module's content handlers, the upstream module calls AcxDrmAddContentHandlers
+    // instead.)
+    //
+    // For more information, see MSDN's DRM Functions and Interfaces.
+    //
+
+    return STATUS_SUCCESS;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CRenderStreamEngine::SetRenderPacket(
+    _In_    ULONG           Packet,
+    _In_    ULONG           Flags,
+    _In_    ULONG           EosPacketLength
+)
+{
+    NTSTATUS status = STATUS_SUCCESS;
+    ULONG currentPacket;
+
+    UNREFERENCED_PARAMETER(Flags);
+    UNREFERENCED_PARAMETER(EosPacketLength);
+
+    PAGED_CODE();
+
+    currentPacket = (ULONG)InterlockedCompareExchange((LONG*)&m_CurrentPacket, -1, -1);
+
+    if (Packet <= currentPacket)
+    {
+        //ASSERT(FALSE);
+        status = STATUS_DATA_LATE_ERROR;
+    }
+    else if (Packet > currentPacket + 1)
+    {
+        //ASSERT(FALSE);
+        status = STATUS_DATA_OVERRUN;
+    }
+
+    return status;
+}
+
+_Use_decl_annotations_
+VOID
+CRenderStreamEngine::ProcessPacket()
+{
+    ULONG currentPacket;
+    ULONG packetIndex;
+    PBYTE packetBuffer;
+
+    currentPacket = (ULONG)InterlockedCompareExchange((LONG*)&m_CurrentPacket, -1, -1);
+
+    packetIndex = currentPacket % m_PacketsCount;
+    packetBuffer = (PBYTE)m_Packets[packetIndex];
+    // Packet 0 starts at an offset if the size isn't a multiple of page_size
+    if (packetIndex == 0)
+    {
+        packetBuffer += m_FirstPacketOffset;
+    }
+
+    m_SaveData.WriteData(packetBuffer, m_PacketSize);
+}
+
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CCaptureStreamEngine::CCaptureStreamEngine(
+    _In_    ACXSTREAM       Stream,
+    _In_    ACXDATAFORMAT   StreamFormat
+)
+    : CStreamEngine(Stream, StreamFormat, FALSE, NULL),
+    m_EnableWaveCapture(0)
+{
+    PAGED_CODE();
+
+    m_CurrentPacketStart.QuadPart = 0;
+    m_LastPacketStart.QuadPart = 0;
+
+    RtlInitUnicodeString(&m_HostCaptureFileName, NULL);
+    RtlInitUnicodeString(&m_LoopbackCaptureFileName, NULL);
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CCaptureStreamEngine::~CCaptureStreamEngine()
+{
+    PAGED_CODE();
+
+    RtlFreeUnicodeString(&m_HostCaptureFileName);
+    RtlFreeUnicodeString(&m_LoopbackCaptureFileName);
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CCaptureStreamEngine::PrepareHardware()
+{
+    NTSTATUS                status = STATUS_SUCCESS;
+    PWAVEFORMATEXTENSIBLE   pwfext = NULL;
+
+    PAGED_CODE();
+
+    status = CStreamEngine::PrepareHardware();
+    if (!NT_SUCCESS(status))
+    {
+        goto exit;
+    }
+
+    (void)ReadRegistrySettings();
+
+    pwfext = (PWAVEFORMATEXTENSIBLE)AcxDataFormatGetWaveFormatExtensible(m_StreamFormat);
+    if (pwfext == NULL)
+    {
+        // Cannot initialize reader or generator with a format that's not understood
+        status = STATUS_NO_MATCH;
+        ASSERT(FALSE);
+        goto exit;
+    }
+
+    if (m_EnableWaveCapture)
+    {
+        status = m_WaveReader.Init(pwfext, &m_HostCaptureFileName);
+        if (!NT_SUCCESS(status))
+        {
+            m_EnableWaveCapture = FALSE;
+        }
+    }
+
+    if (!m_EnableWaveCapture)
+    {
+        status = m_ToneGenerator.Init(m_ToneFrequency, pwfext);
+    }
+
+exit:
+    return status;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CCaptureStreamEngine::ReleaseHardware()
+{
+    PAGED_CODE();
+
+    if (m_EnableWaveCapture)
+    {
+        m_WaveReader.WaitAllWorkItems();
+    }
+
+    return CStreamEngine::ReleaseHardware();
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CCaptureStreamEngine::GetCapturePacket(
+    _Out_   ULONG* LastCapturePacket,
+    _Out_   ULONGLONG* QPCPacketStart,
+    _Out_   BOOLEAN* MoreData
+)
+{
+    NTSTATUS status = STATUS_SUCCESS;
+    ULONG currentPacket;
+    LONGLONG qpcPacketStart;
+
+    PAGED_CODE();
+
+    currentPacket = (ULONG)InterlockedCompareExchange((LONG*)&m_CurrentPacket, -1, -1);
+    qpcPacketStart = InterlockedCompareExchange64(&m_LastPacketStart.QuadPart, -1, -1);
+
+    *LastCapturePacket = currentPacket - 1;
+    *QPCPacketStart = (ULONGLONG)qpcPacketStart;
+    *MoreData = FALSE;
+
+    return status;
+}
+
+_Use_decl_annotations_
+VOID
+CCaptureStreamEngine::ProcessPacket()
+{
+    ULONG currentPacket;
+    ULONG packetIndex;
+    PBYTE packetBuffer;
+
+    currentPacket = (ULONG)InterlockedCompareExchange((LONG*)&m_CurrentPacket, -1, -1);
+
+    packetIndex = currentPacket % m_PacketsCount;
+    packetBuffer = (PBYTE)m_Packets[packetIndex];
+
+    // Packet 0 starts at an offset if the size isn't a multiple of page_size
+    if (packetIndex == 0)
+    {
+        packetBuffer += m_FirstPacketOffset;
+    }
+
+    if (m_EnableWaveCapture)
+    {
+        m_WaveReader.ReadWaveData(packetBuffer, m_PacketSize);
+    }
+    else
+    {
+        m_ToneGenerator.GenerateSine(packetBuffer, m_PacketSize);
+    }
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CCaptureStreamEngine::ReadRegistrySettings()
+{
+    NTSTATUS                    status;
+    PDRIVER_OBJECT              DriverObject;
+    HANDLE                      DriverKey;
+
+    RTL_QUERY_REGISTRY_TABLE    paramTable[] = {
+        // QueryRoutine     Flags                                           Name                        EntryContext                  DefaultType                                                     DefaultData                   DefaultLength
+        { NULL,   RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_TYPECHECK, L"EnableWaveCapture",       &m_EnableWaveCapture,         (REG_DWORD << RTL_QUERY_REGISTRY_TYPECHECK_SHIFT) | REG_DWORD,  &m_EnableWaveCapture,         sizeof(DWORD) },
+        { NULL,   RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_TYPECHECK, L"HostCaptureFileName",     &m_HostCaptureFileName,       (REG_SZ << RTL_QUERY_REGISTRY_TYPECHECK_SHIFT) | REG_SZ,        &m_HostCaptureFileName,       sizeof(UNICODE_STRING) },
+        { NULL,   RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_TYPECHECK, L"LoopbackCaptureFileName", &m_LoopbackCaptureFileName,   (REG_SZ << RTL_QUERY_REGISTRY_TYPECHECK_SHIFT) | REG_SZ,        &m_LoopbackCaptureFileName,   sizeof(UNICODE_STRING) },
+        { NULL,   0,                                                        NULL,                       NULL,                         0,                                                              NULL,                         0 }
+    };
+
+    PAGED_CODE();
+
+    DriverObject = WdfDriverWdmGetDriverObject(WdfGetDriver());
+    DriverKey = NULL;
+    status = IoOpenDriverRegistryKey(DriverObject, 
+                                 DriverRegKeyParameters,
+                                 KEY_READ,
+                                 0,
+                                 &DriverKey);
+
+    if (!NT_SUCCESS(status))
+    {
+        ASSERT(FALSE);
+        goto exit;
+    }
+
+    status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
+                                  (PCWSTR) DriverKey,
+                                  &paramTable[0],
+                                  NULL,
+                                  NULL);
+
+    if (DriverKey)
+    {
+        ZwClose(DriverKey);
+    }
+
+exit:
+    if (!NT_SUCCESS(status))
+    {
+        m_EnableWaveCapture = FALSE;
+    }
+
+    return status;
+}
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CBufferedCaptureStreamEngine::CBufferedCaptureStreamEngine(
+    _In_ ACXSTREAM          Stream,
+    _In_ ACXDATAFORMAT      StreamFormat,
+    _In_ CKeywordDetector* KeywordDetector
+
+)
+    : CCaptureStreamEngine(Stream, StreamFormat),
+    m_KeywordDetector(KeywordDetector)
+{
+    PAGED_CODE();
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CBufferedCaptureStreamEngine::~CBufferedCaptureStreamEngine()
+{
+    PAGED_CODE();
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CBufferedCaptureStreamEngine::Pause()
+{
+    PAGED_CODE();
+
+    m_KeywordDetector->Stop();
+    return CCaptureStreamEngine::Pause();
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CBufferedCaptureStreamEngine::Run()
+{
+    PAGED_CODE();
+
+    m_KeywordDetector->Run();
+    return CCaptureStreamEngine::Run();
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS
+CBufferedCaptureStreamEngine::GetCapturePacket(
+    _Out_   ULONG* LastCapturePacket,
+    _Out_   ULONGLONG* QPCPacketStart,
+    _Out_   BOOLEAN* MoreData
+)
+{
+    PAGED_CODE();
+
+    // retrieve the packet from the fifo queue
+    return m_KeywordDetector->GetReadPacket(m_PacketsCount, m_PacketSize, m_Packets, LastCapturePacket, QPCPacketStart, MoreData);
+}
+
+_Use_decl_annotations_
+VOID
+CBufferedCaptureStreamEngine::ProcessPacket()
+{
+    LARGE_INTEGER qpc;
+    LARGE_INTEGER qpcFrequency;
+
+    qpc = KeQueryPerformanceCounter(&qpcFrequency);
+
+    // Add the next packet to the fifo queue
+    m_KeywordDetector->DpcRoutine(qpc.QuadPart, qpcFrequency.QuadPart);
+}
+
+//Streamengine callbacks
+
+VOID
+EvtStreamDestroy(
+    _In_ WDFOBJECT Object
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CStreamEngine* streamEngine = NULL;
+
+    ctx = GetStreamEngineContext((ACXSTREAM)Object);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+    ctx->StreamEngine = NULL;
+    delete streamEngine;
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamGetHwLatency(
+    _In_ ACXSTREAM Stream,
+    _Out_ ULONG* FifoSize,
+    _Out_ ULONG* Delay
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CStreamEngine* streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetStreamEngineContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->GetHWLatency(FifoSize, Delay);
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamAllocateRtPackets(
+    _In_ ACXSTREAM        Stream,
+    _In_ ULONG            PacketCount,
+    _In_ ULONG            PacketSize,
+    _Out_ PACX_RTPACKET* Packets
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CStreamEngine* streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetStreamEngineContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->AllocateRtPackets(PacketCount, PacketSize, Packets);
+}
+
+PAGED_CODE_SEG
+VOID
+EvtStreamFreeRtPackets(
+    _In_ ACXSTREAM     Stream,
+    _In_ PACX_RTPACKET Packets,
+    _In_ ULONG         PacketCount
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CStreamEngine* streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetStreamEngineContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->FreeRtPackets(Packets, PacketCount);
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamPrepareHardware(
+    _In_ ACXSTREAM Stream
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CStreamEngine* streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetStreamEngineContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->PrepareHardware();
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamReleaseHardware(
+    _In_ ACXSTREAM Stream
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CStreamEngine* streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetStreamEngineContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->ReleaseHardware();
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamRun(
+    _In_ ACXSTREAM Stream
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CStreamEngine* streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetStreamEngineContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->Run();
+}
+
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamPause(
+    _In_ ACXSTREAM Stream
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CStreamEngine* streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetStreamEngineContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->Pause();
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamAssignDrmContentId(
+    _In_ ACXSTREAM      Stream,
+    _In_ ULONG          DrmContentId,
+    _In_ PACXDRMRIGHTS  DrmRights
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CStreamEngine * streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetStreamEngineContext(Stream);
+
+    streamEngine = (CStreamEngine*)ctx->StreamEngine;
+
+    return streamEngine->AssignDrmContentId(DrmContentId, DrmRights);
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamGetCurrentPacket(
+    _In_ ACXSTREAM          Stream,
+    _Out_ PULONG            CurrentPacket
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CStreamEngine* streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetStreamEngineContext(Stream);
+
+    streamEngine = static_cast<CStreamEngine*>(ctx->StreamEngine);
+
+    return streamEngine->GetCurrentPacket(CurrentPacket);
+}
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamGetPresentationPosition(
+    _In_ ACXSTREAM          Stream,
+    _Out_ PULONGLONG        PositionInBlocks,
+    _Out_ PULONGLONG        QPCPosition
+)
+{
+    PSTREAMENGINE_CONTEXT ctx;
+    CStreamEngine* streamEngine = NULL;
+
+    PAGED_CODE();
+
+    ctx = GetStreamEngineContext(Stream);
+
+    streamEngine = static_cast<CStreamEngine*>(ctx->StreamEngine);
+
+    return streamEngine->GetPresentationPosition(PositionInBlocks, QPCPosition);
+}
+
diff --git a/audio/Acx/Samples/Common/StreamEngine.h b/audio/Acx/Samples/Common/StreamEngine.h
new file mode 100644
index 00000000..deeff95a
--- /dev/null
+++ b/audio/Acx/Samples/Common/StreamEngine.h
@@ -0,0 +1,449 @@
+#pragma once
+
+#include "savedata.h"
+#include "tonegenerator.h"
+#include "WaveReader.h"
+#include "SimPeakMeter.h"
+#include "keyworddetector.h"
+
+#define HNSTIME_PER_MILLISECOND 10000
+
+#define MAX_PACKET_COUNT 2
+
+#define DEFAULT_FREQUENCY 220
+#define LOOPBACK_FREQUENCY 500
+
+// Stream callbacks shared between Capture and Render
+
+VOID
+EvtStreamDestroy(
+    _In_ WDFOBJECT Object
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamGetHwLatency(
+    _In_ ACXSTREAM Stream,
+    _Out_ ULONG* FifoSize,
+    _Out_ ULONG* Delay
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamAllocateRtPackets(
+    _In_ ACXSTREAM Stream,
+    _In_ ULONG PacketCount,
+    _In_ ULONG PacketSize,
+    _Out_ PACX_RTPACKET* Packets
+);
+
+PAGED_CODE_SEG
+VOID
+EvtStreamFreeRtPackets(
+    _In_ ACXSTREAM Stream,
+    _In_ PACX_RTPACKET Packets,
+    _In_ ULONG PacketCount
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamPrepareHardware(
+    _In_ ACXSTREAM Stream
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamReleaseHardware(
+    _In_ ACXSTREAM Stream
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamRun(
+    _In_ ACXSTREAM Stream
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamPause(
+    _In_ ACXSTREAM Stream
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamAssignDrmContentId(
+    _In_ ACXSTREAM      Stream,
+    _In_ ULONG          DrmContentId,
+    _In_ PACXDRMRIGHTS  DrmRights
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamGetCurrentPacket(
+    _In_ ACXSTREAM          Stream,
+    _Out_ PULONG            CurrentPacket
+);
+
+PAGED_CODE_SEG
+NTSTATUS
+EvtStreamGetPresentationPosition(
+    _In_ ACXSTREAM          Stream,
+    _Out_ PULONGLONG        PositionInBlocks,
+    _Out_ PULONGLONG        QPCPosition
+);
+
+
+class CStreamEngine
+{
+public:
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    AllocateRtPackets(
+        _In_    ULONG           PacketCount,
+        _In_    ULONG           PacketSize,
+        _Out_   PACX_RTPACKET * Packets
+        );
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    VOID
+    FreeRtPackets(
+        _Frees_ptr_ PACX_RTPACKET   Packets,
+        _In_        ULONG           PacketCount
+        );
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    PrepareHardware();
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    ReleaseHardware();
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    Run();
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    Pause();
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    GetPresentationPosition(
+        _Out_   PULONGLONG      PositionInBlocks,
+        _Out_   PULONGLONG      QPCPosition
+        );
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    GetLinearBufferPosition(
+        _Out_   PULONGLONG  Position
+        );
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    SetCurrentWritePosition(
+        _In_    ULONG   Position
+        );
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    SetLastBufferPosition(
+        _In_    ULONG   Position
+        );
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    GetCurrentPacket(
+        _Out_ PULONG CurrentPacket
+        );
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    GetHWLatency(
+        _Out_   ULONG         * FifoSize, 
+        _Out_   ULONG         * Delay
+        );
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    AssignDrmContentId(
+        _In_ ULONG          DrmContentId,
+        _In_ PACXDRMRIGHTS  DrmRights
+        );
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    CSimPeakMeter *
+    GetPeakMeter();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    CStreamEngine(
+        _In_    ACXSTREAM       Stream, 
+        _In_    ACXDATAFORMAT   StreamFormat,
+        _In_    BOOL            Offload,
+        _In_opt_    CSimPeakMeter   *CircuitPeakmeter
+        );
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    ~CStreamEngine();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    VOID
+    SetFrequency(
+        _In_    DWORD           ToneFrequency 
+        )
+    {
+        PAGED_CODE();
+
+        m_ToneFrequency = ToneFrequency;
+    }
+
+protected:
+    PVOID               m_Packets[MAX_PACKET_COUNT];
+    ULONG               m_PacketsCount;
+    ULONG               m_PacketSize;
+    ULONG               m_FirstPacketOffset;
+    WDFTIMER            m_NotificationTimer;
+    ACX_STREAM_STATE    m_CurrentState;
+    ULONG               m_CurrentPacket;
+    ULONGLONG           m_Position;
+    ACXSTREAM           m_Stream;
+    ACXDATAFORMAT       m_StreamFormat;
+    ULONGLONG           m_StartTime;
+    ULONGLONG           m_StartPosition;
+    ULONGLONG           m_GlitchAdjust;
+    LARGE_INTEGER       m_PerformanceCounterFrequency;
+    LARGE_INTEGER       m_CurrentPacketStart;
+    LARGE_INTEGER       m_LastPacketStart;
+    DWORD               m_ToneFrequency;
+    BOOL                m_Offload;
+    CSimPeakMeter       m_PeakMeter;
+    CSimPeakMeter*      m_pCircuitPeakmeter;
+
+    static
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    _Function_class_(EVT_WDF_TIMER)
+    VOID s_EvtStreamPassCallback(
+        _In_    WDFTIMER        Timer
+        );
+
+    // This is run every time the stream timer fires
+    virtual
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    VOID
+    StreamPassCallback();
+
+    virtual
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    VOID
+    ScheduleNextPass();
+
+    virtual
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    VOID
+    UpdatePosition();
+
+    virtual
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    ULONG
+    GetBytesPerSecond();
+
+    virtual
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    VOID
+    ProcessPacket() = 0;
+};
+
+class CRenderStreamEngine : public CStreamEngine
+{
+public:
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    CRenderStreamEngine(
+        _In_    ACXSTREAM       Stream,
+        _In_    ACXDATAFORMAT   StreamFormat,
+        _In_    BOOL            Offload,
+        _In_    CSimPeakMeter   *CircuitPeakmeter
+        );
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    ~CRenderStreamEngine();
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    PrepareHardware();
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    ReleaseHardware();
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    AssignDrmContentId(
+        _In_ ULONG          DrmContentId,
+        _In_ PACXDRMRIGHTS  DrmRights
+        );
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    SetRenderPacket(
+        _In_    ULONG           Packet,
+        _In_    ULONG           Flags,
+        _In_    ULONG           EosPacketLength
+        );
+
+protected:
+    CSaveData m_SaveData;
+
+    virtual
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    VOID
+    ProcessPacket();
+
+};
+
+class CCaptureStreamEngine : public CStreamEngine
+{
+public:
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    CCaptureStreamEngine(
+        _In_    ACXSTREAM       Stream,
+        _In_    ACXDATAFORMAT   StreamFormat
+        );
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    ~CCaptureStreamEngine();
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    PrepareHardware();
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    ReleaseHardware();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    GetCapturePacket(
+        _Out_   ULONG         * LastCapturePacket,
+        _Out_   ULONGLONG     * QPCPacketStart,
+        _Out_   BOOLEAN       * MoreData
+        );
+
+protected:
+    ToneGenerator   m_ToneGenerator;
+    CWaveReader     m_WaveReader;
+    DWORD           m_EnableWaveCapture;
+    UNICODE_STRING  m_HostCaptureFileName;
+    UNICODE_STRING  m_LoopbackCaptureFileName;
+
+    virtual
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    VOID
+    ProcessPacket();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    ReadRegistrySettings();
+};
+
+class CBufferedCaptureStreamEngine : public CCaptureStreamEngine
+{
+public:
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    CBufferedCaptureStreamEngine(
+        _In_ ACXSTREAM          Stream,
+        _In_ ACXDATAFORMAT      StreamFormat,
+        _In_ CKeywordDetector * KeywordDetector
+        );
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    ~CBufferedCaptureStreamEngine();
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    Run();
+
+    virtual
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    Pause();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    GetCapturePacket(
+        _Out_   ULONG         * LastCapturePacket,
+        _Out_   ULONGLONG     * QPCPacketStart,
+        _Out_   BOOLEAN       * MoreData
+        );
+
+protected:
+    virtual
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    VOID
+    ProcessPacket();
+
+    CKeywordDetector * m_KeywordDetector;
+};
+
+// Define circuit/stream pin context.
+//
+typedef struct _STREAM_TIMER_CONTEXT {
+    CStreamEngine * StreamEngine;
+} STREAM_TIMER_CONTEXT, *PSTREAM_TIMER_CONTEXT;
+
+WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(STREAM_TIMER_CONTEXT, GetStreamTimerContext)
diff --git a/audio/Acx/Samples/Common/ToneGenerator.cpp b/audio/Acx/Samples/Common/ToneGenerator.cpp
new file mode 100644
index 00000000..fc30e3b2
--- /dev/null
+++ b/audio/Acx/Samples/Common/ToneGenerator.cpp
@@ -0,0 +1,297 @@
+/*++
+
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+    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:
+
+    ToneGenerator.cpp
+
+Abstract:
+
+    Implementation of sine wave generator for ACX driver samples
+
+
+--*/
+#include "private.h"
+#include "public.h"
+#include <devguid.h>
+#include <ks.h>
+#include <mmsystem.h>
+#include <ksmedia.h>
+#include "ToneGenerator.h"
+
+#define TONEGENERATOR_POOLTAG  'rGnT'
+
+const double TONE_AMPLITUDE = 0.5;  // Scalar value, should be between 0.0 - 1.0
+const double TWO_PI = M_PI * 2;
+
+DWORD g_DisableToneGenerator = 0;  // default is to generate tones.
+
+#define IF_FAILED_JUMP(result, tag) do {if (!NT_SUCCESS(result)) {goto tag;}} while(false)
+#define IF_TRUE_JUMP(result, tag) do {if (result) {goto tag;}} while(false)
+#define IF_TRUE_ACTION_JUMP(result, action, tag) do {if (result) {action; goto tag;}} while(false)
+
+//
+// Double to short conversion.
+//
+__drv_maxIRQL(DISPATCH_LEVEL)
+short ConvertToShort(double Value)
+{
+    return (short)(Value * _I16_MAX);
+};
+
+//
+// Double to char conversion.
+//
+__drv_maxIRQL(DISPATCH_LEVEL)
+unsigned char ConvertToUChar(double Value)
+{
+    const double F_127_5 = 127.5;
+    return (unsigned char)(Value * F_127_5 + F_127_5);
+};
+
+//
+// Ctor: basic init.
+//
+_Use_decl_annotations_
+PAGED_CODE_SEG
+ToneGenerator::ToneGenerator()
+: m_Frequency(0),
+  m_ChannelCount(0),
+  m_BitsPerSample(0),
+  m_SamplesPerSecond(0),
+  m_Mute(false),
+  m_PartialFrame(NULL),
+  m_PartialFrameBytes(0),
+  m_FrameSize(0)
+{
+    PAGED_CODE();
+
+    // Theta (double) and SampleIncrement (double) are init in the Init() method 
+    // after saving the floating point state. 
+}
+
+//
+// Dtor: free resources.
+//
+_Use_decl_annotations_
+PAGED_CODE_SEG
+ToneGenerator::~ToneGenerator()
+{
+    PAGED_CODE();
+
+    if (m_PartialFrame)
+    {
+        ExFreePoolWithTag(m_PartialFrame, TONEGENERATOR_POOLTAG);
+        m_PartialFrame = NULL;
+        m_PartialFrameBytes = 0;
+    }
+}
+
+// 
+// Init a new frame. 
+// Note: caller will save and restore the floatingpoint state.
+//
+#pragma warning(push)
+// Caller wraps this routine between KeSaveFloatingPointState/KeRestoreFloatingPointState calls.
+#pragma warning(disable: 28110)
+
+_Use_decl_annotations_
+VOID ToneGenerator::InitNewFrame
+(
+    _Out_writes_bytes_(FrameSize)    BYTE*  Frame, 
+    _In_                             DWORD  FrameSize
+)
+{
+    double sinValue = TONE_AMPLITUDE * sin( m_Theta );
+
+    if (FrameSize != (DWORD)m_ChannelCount * m_BitsPerSample/8)
+    {
+        ASSERT(FALSE);
+        RtlZeroMemory(Frame, FrameSize);
+        return;
+    }
+    
+    for(ULONG i = 0; i < m_ChannelCount; ++i)
+    {
+        if (m_BitsPerSample == 8)
+        {
+            unsigned char *dataBuffer = reinterpret_cast<unsigned char *>(Frame);
+             dataBuffer[i] = ConvertToUChar(sinValue);
+        }
+        else // 16 bits per sample
+        {
+            short *dataBuffer = reinterpret_cast<short *>(Frame);
+            dataBuffer[i] = ConvertToShort(sinValue);
+        }
+    }
+
+    m_Theta += m_SampleIncrement;
+    if (m_Theta >= TWO_PI)
+    {
+        m_Theta -= TWO_PI;
+    }
+}
+#pragma warning(pop)
+
+//
+// GenerateSamples()
+//
+//  Generate a sine wave that fits into the specified buffer.
+//
+//  Buffer - Buffer to hold the samples
+//  BufferLength - Length of the buffer.
+//
+//  Note: this function supports 16bit and 8bit samples only.
+//
+_Use_decl_annotations_
+void ToneGenerator::GenerateSine
+(
+    _Out_writes_bytes_(BufferLength) BYTE       *Buffer, 
+    _In_                             size_t      BufferLength
+)
+{
+    NTSTATUS        status;
+    KFLOATING_SAVE  saveData;
+    BYTE *          buffer;
+    size_t          length;
+    size_t          copyBytes;
+
+    // if muted, or tone generator disabled via registry,
+    // we deliver silence.
+    if (m_Mute || g_DisableToneGenerator)
+    {
+        goto ZeroBuffer;
+    }
+    
+    status = KeSaveFloatingPointState(&saveData);
+    if (!NT_SUCCESS(status))
+    {
+        goto ZeroBuffer;
+    }
+
+    buffer = Buffer;
+    length = BufferLength;
+
+    //
+    // Check if we have any residual frame bytes from the last time.
+    //
+    if (m_PartialFrameBytes)
+    {
+        ASSERT(m_FrameSize > m_PartialFrameBytes);
+        DWORD offset = m_FrameSize - m_PartialFrameBytes;
+        copyBytes = MIN(m_PartialFrameBytes, length);
+        RtlCopyMemory(buffer, m_PartialFrame + offset, copyBytes);
+        RtlZeroMemory(m_PartialFrame + offset, copyBytes);
+        length -= copyBytes;
+        buffer += copyBytes;
+        m_PartialFrameBytes = 0;
+    }
+    
+    IF_TRUE_JUMP(length == 0, Done);
+
+    //
+    // Copy all the aligned frames.
+    // 
+
+    size_t frames = length/m_FrameSize;
+
+    for (size_t i = 0; i < frames; ++i)
+    {
+        InitNewFrame(buffer, m_FrameSize);
+        buffer += m_FrameSize;
+        length -= m_FrameSize;
+    }
+
+    IF_TRUE_JUMP(length == 0, Done);
+    
+    //
+    // Copy any partial frame at the end.
+    //
+    ASSERT(m_FrameSize > length);
+    InitNewFrame(m_PartialFrame, m_FrameSize);
+    RtlCopyMemory(buffer, m_PartialFrame, length);
+    RtlZeroMemory(m_PartialFrame, length);
+    m_PartialFrameBytes = m_FrameSize - (DWORD)length;    
+    
+Done:
+    KeRestoreFloatingPointState(&saveData);
+    return;
+
+ZeroBuffer:
+    RtlZeroMemory(Buffer, BufferLength);
+    return;
+}
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS ToneGenerator::Init
+(
+    _In_    DWORD                   ToneFrequency, 
+    _In_    PWAVEFORMATEXTENSIBLE   WfExt
+)
+{
+    NTSTATUS        status      = STATUS_SUCCESS;
+    KFLOATING_SAVE  saveData;
+    
+    PAGED_CODE();
+
+    //
+    // This sample supports PCM 16bit formats only. 
+    //
+    if ((WfExt->Format.wFormatTag != WAVE_FORMAT_PCM &&
+        !(WfExt->Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
+          IsEqualGUIDAligned(WfExt->SubFormat, KSDATAFORMAT_SUBTYPE_PCM))) ||
+        (WfExt->Format.wBitsPerSample != 16 &&
+         WfExt->Format.wBitsPerSample != 8))
+    {
+        status = STATUS_NOT_SUPPORTED;
+    }
+    IF_FAILED_JUMP(status, Done);
+
+    //
+    // Save floating state (just in case).
+    //
+    status = KeSaveFloatingPointState(&saveData);
+    IF_FAILED_JUMP(status, Done);
+
+    //
+    // Basic init.
+    //
+    RtlZeroMemory(&m_Theta, sizeof(m_Theta));
+    m_Frequency         = ToneFrequency;
+    m_ChannelCount      = WfExt->Format.nChannels;      // # channels.
+    m_BitsPerSample     = WfExt->Format.wBitsPerSample; // bits per sample.
+    m_SamplesPerSecond  = WfExt->Format.nSamplesPerSec; // samples per sec.
+    m_Mute              = false;
+    m_SampleIncrement   = (m_Frequency * TWO_PI) / (double)m_SamplesPerSecond;
+    m_FrameSize         = (DWORD)m_ChannelCount * m_BitsPerSample/8;
+    ASSERT(m_FrameSize == WfExt->Format.nBlockAlign);
+    
+    //
+    // Restore floating state.
+    //
+    KeRestoreFloatingPointState(&saveData);
+
+    // 
+    // Allocate a buffer to hold a partial frame.
+    //
+    m_PartialFrame = (BYTE*)ExAllocatePool2(
+                                    POOL_FLAG_NON_PAGED,
+                                    m_FrameSize,
+                                    TONEGENERATOR_POOLTAG);
+
+    IF_TRUE_ACTION_JUMP(m_PartialFrame == NULL, status = STATUS_INSUFFICIENT_RESOURCES, Done);
+    
+    status = STATUS_SUCCESS;
+
+Done:
+    return status;
+}
+
+
diff --git a/audio/Acx/Samples/Common/ToneGenerator.h b/audio/Acx/Samples/Common/ToneGenerator.h
new file mode 100644
index 00000000..9de138f8
--- /dev/null
+++ b/audio/Acx/Samples/Common/ToneGenerator.h
@@ -0,0 +1,88 @@
+/*++
+
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+    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:
+
+    ToneGenerator.h
+
+Abstract:
+
+    Declaration of sine wave generator for ACX driver samples.
+
+
+--*/
+#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+#include <limits.h>
+
+class ToneGenerator
+{
+public:
+    DWORD           m_Frequency; 
+    WORD            m_ChannelCount; 
+    WORD            m_BitsPerSample;
+    DWORD           m_SamplesPerSecond;
+    double          m_Theta;
+    double          m_SampleIncrement;  
+    bool            m_Mute;
+    BYTE*           m_PartialFrame;
+    DWORD           m_PartialFrameBytes;
+    DWORD           m_FrameSize;
+
+public:
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    ToneGenerator();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    ~ToneGenerator();
+    
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS
+    Init
+    (
+        _In_    DWORD                   ToneFrequency, 
+        _In_    PWAVEFORMATEXTENSIBLE   WfExt
+    );
+    
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    VOID
+    GenerateSine
+    (
+        _Out_writes_bytes_(BufferLength) BYTE       *Buffer, 
+        _In_                             size_t      BufferLength
+    );
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    VOID
+    SetMute
+    (
+        _In_ bool Value
+    )
+    {
+        PAGED_CODE();
+
+        m_Mute = Value;
+    }
+
+private:
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    VOID InitNewFrame
+    (
+        _Out_writes_bytes_(FrameSize)   BYTE*  Frame, 
+        _In_                            DWORD  FrameSize
+    );
+};
+
+
diff --git a/audio/Acx/Samples/Common/Trace_macros.h b/audio/Acx/Samples/Common/Trace_macros.h
new file mode 100644
index 00000000..5291b391
--- /dev/null
+++ b/audio/Acx/Samples/Common/Trace_macros.h
@@ -0,0 +1,470 @@
+#pragma once
+
+#include <stdarg.h>         // for va_start, etc.
+
+#pragma region Tracing level definitions
+
+#if !defined(FAILED_NTSTATUS)
+#define FAILED_NTSTATUS(status) (((NTSTATUS)(status)) < 0)
+#endif
+
+#if !defined(SUCCEEDED_NTSTATUS)
+#define SUCCEEDED_NTSTATUS(status) (((NTSTATUS)(status)) >= 0)
+#endif
+
+//! Define shorter versions of the ETW trace levels
+#define LEVEL_CRITICAL  TRACE_LEVEL_CRITICAL
+#define LEVEL_ERROR     TRACE_LEVEL_ERROR
+#define LEVEL_WARNING   TRACE_LEVEL_WARNING
+#define LEVEL_INFO      TRACE_LEVEL_INFORMATION
+#define LEVEL_VERBOSE   TRACE_LEVEL_VERBOSE
+
+//! This is a special LEVEL that changes the trace macro level from ERROR to VERBOSE
+//! depending on whether the return value passed to the macro was non-zero or zero,
+//! respectively.
+#define LEVEL_COND 0xFF
+#pragma endregion
+
+//! Logger and Enabled that supports both level and flag.
+//! \link https://msdn.microsoft.com/en-us/library/windows/hardware/ff542492(v=vs.85).aspx
+#define WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS) WPP_LEVEL_LOGGER(FLAGS)
+#define WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS) (WPP_LEVEL_ENABLED(FLAGS) && (WPP_CONTROL(WPP_BIT_ ## FLAGS).Level >= LEVEL))
+
+//! This macro is to be used by the WPP custom macros below that want to do conditional
+//! logging based on return value. If LEVEL_VERBOSE is specified when calling a macro that
+//! uses this, the level will be set to LEVEL_INFO if return code is 0 or
+//! LEVEL_ERROR if the return code is not 0. This can be called in any PRE macro.
+//!
+//! The "LEVEL == LEVEL_COND" check generates a compiler warning that the "conditional
+//! expression is constant" so we explicitly disable that.
+#define WPP_CONDITIONAL_LEVEL_FLAGS_OVERRIDE(LEVEL, FLAGS, HR) \
+    BOOL bEnabled = WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS); \
+    __pragma(warning(push)) \
+    __pragma(warning(disable: 4127)) \
+    if (LEVEL == LEVEL_COND) \
+    { \
+        if (SUCCEEDED(HR)) \
+        { \
+            bEnabled = WPP_LEVEL_FLAGS_ENABLED(LEVEL_VERBOSE, FLAGS); \
+        } \
+        else \
+        { \
+            bEnabled = WPP_LEVEL_FLAGS_ENABLED(LEVEL_ERROR, FLAGS); \
+        } \
+    } \
+    __pragma(warning(pop))
+
+#define WPP_CONDITIONAL_LEVEL_FLAGS_OVERRIDE_NTSTATUS(LEVEL, FLAGS, STATUS) \
+    BOOLEAN bEnabled = WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS); \
+    __pragma(warning(push)) \
+    __pragma(warning(disable: 4127)) \
+    if (LEVEL == LEVEL_COND) \
+    { \
+        if (SUCCEEDED_NTSTATUS(STATUS)) \
+        { \
+            bEnabled = WPP_LEVEL_FLAGS_ENABLED(LEVEL_VERBOSE, FLAGS); \
+        } \
+        else \
+        { \
+            bEnabled = WPP_LEVEL_FLAGS_ENABLED(LEVEL_ERROR, FLAGS); \
+        } \
+    } \
+    __pragma(warning(pop))
+
+
+#define WPP_LEVEL_FLAGS_IFRLOG_ENABLED(LEVEL, FLAGS, IFRLOG) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+#define WPP_LEVEL_FLAGS_IFRLOG_LOGGER(LEVEL, FLAGS, IFRLOG) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+#define WPP_LEVEL_IFRLOG_FLAGS_ENABLED(LEVEL, IFRLOG, FLAGS) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+#define WPP_LEVEL_IFRLOG_FLAGS_LOGGER(LEVEL, IFRLOG, FLAGS) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#define WPP_LEVEL_FLAGS_HR_PRE(LEVEL, FLAGS, HR) { WPP_CONDITIONAL_LEVEL_FLAGS_OVERRIDE(LEVEL, FLAGS, HR)
+#define WPP_LEVEL_FLAGS_HR_POST(LEVEL, FLAGS, HR) ;}
+#define WPP_LEVEL_FLAGS_HR_ENABLED(LEVEL, FLAGS, HR) bEnabled
+#define WPP_LEVEL_FLAGS_HR_LOGGER(LEVEL, FLAGS, HR) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#define WPP_LEVEL_FLAGS_RETVAL_ENABLED(LEVEL, FLAGS, RETVAL) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+#define WPP_LEVEL_FLAGS_RETVAL_LOGGER(LEVEL, FLAGS, RETVAL) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#define WPP_LEVEL_FLAGS_FI_ENABLED(LEVEL, FLAGS, FI) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+#define WPP_LEVEL_FLAGS_FI_LOGGER(LEVEL, FLAGS, FI) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#define WPP_LEVEL_FLAGS_STATUS_PRE(LEVEL, FLAGS, STATUS) { WPP_CONDITIONAL_LEVEL_FLAGS_OVERRIDE_NTSTATUS(LEVEL, FLAGS, STATUS)
+#define WPP_LEVEL_FLAGS_STATUS_POST(LEVEL, FLAGS, STATUS) ;}
+#define WPP_LEVEL_FLAGS_STATUS_ENABLED(LEVEL, FLAGS, STATUS) bEnabled
+#define WPP_LEVEL_FLAGS_STATUS_LOGGER(LEVEL, FLAGS, STATUS) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#define WPP_LEVEL_FLAGS_RETSTATUS_PRE(LEVEL, FLAGS, RETSTATUS) do { NTSTATUS __statusRet = (RETSTATUS); if (FAILED_NTSTATUS(__statusRet)) {
+#define WPP_LEVEL_FLAGS_RETSTATUS_POST(LEVEL, FLAGS, RETSTATUS) ; return __statusRet; } } while (0, 0)
+#define WPP_LEVEL_FLAGS_RETSTATUS_ENABLED(LEVEL, FLAGS, RETSTATUS) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+#define WPP_LEVEL_FLAGS_RETSTATUS_LOGGER(LEVEL, FLAGS, RETSTATUS) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#define WPP_LEVEL_FLAGS_IFRLOG_RETSTATUS_PRE(LEVEL, FLAGS, IFRLOG, RETSTATUS) do { NTSTATUS __statusRet = (RETSTATUS); if (FAILED_NTSTATUS(__statusRet)) {
+#define WPP_LEVEL_FLAGS_IFRLOG_RETSTATUS_POST(LEVEL, FLAGS, IFRLOG, RETSTATUS) ; return __statusRet; } } while (0, 0)
+#define WPP_LEVEL_FLAGS_IFRLOG_RETSTATUS_ENABLED(LEVEL, FLAGS, IFRLOG, RETSTATUS) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+#define WPP_LEVEL_FLAGS_IFRLOG_RETSTATUS_LOGGER(LEVEL, FLAGS, IFRLOG, RETSTATUS) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#define WPP_LEVEL_FLAGS_IFRLOG_RETSTATUS_ALLOWEDSTATUS_PRE(LEVEL, FLAGS, IFRLOG, RETSTATUS, ALLOWEDSTATUS) do {\
+NTSTATUS __statusRet = (RETSTATUS);\
+if(__statusRet == ALLOWEDSTATUS)\
+{\
+    __statusRet = STATUS_SUCCESS;\
+}\
+if (FAILED_NTSTATUS(__statusRet)) {
+#define WPP_LEVEL_FLAGS_IFRLOG_RETSTATUS_ALLOWEDSTATUS_POST(LEVEL, FLAGS, IFRLOG, RETSTATUS, ALLOWEDSTATUS) ; return __statusRet; } } while (0, 0)
+#define WPP_LEVEL_FLAGS_IFRLOG_RETSTATUS_ALLOWEDSTATUS_ENABLED(LEVEL, FLAGS, IFRLOG, RETSTATUS, ALLOWEDSTATUS) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+#define WPP_LEVEL_FLAGS_IFRLOG_RETSTATUS_ALLOWEDSTATUS_LOGGER(LEVEL, FLAGS, IFRLOG, RETSTATUS, ALLOWEDSTATUS) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#define WPP_LEVEL_FLAGS_RETPTR_PRE(LEVEL, FLAGS, RETPTR) do { if ((RETPTR) == nullptr) {
+#define WPP_LEVEL_FLAGS_RETPTR_POST(LEVEL, FLAGS, RETPTR) ; return STATUS_INSUFFICIENT_RESOURCES; } } while (0, 0)
+#define WPP_LEVEL_FLAGS_RETPTR_ENABLED(LEVEL, FLAGS, RETPTR) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+#define WPP_LEVEL_FLAGS_RETPTR_LOGGER(LEVEL, FLAGS, RETPTR) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#define WPP_LEVEL_FLAGS_RETSTATUS_RETPTR_PRE(LEVEL, FLAGS, RETSTATUS, RETPTR) do { NTSTATUS __statusRet = (RETSTATUS); if ((RETPTR) == nullptr) {
+#define WPP_LEVEL_FLAGS_RETSTATUS_RETPTR_POST(LEVEL, FLAGS, RETSTATUS, RETPTR) ; return __statusRet; } } while (0, 0)
+#define WPP_LEVEL_FLAGS_RETSTATUS_RETPTR_ENABLED(LEVEL, FLAGS, RETSTATUS, RETPTR) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+#define WPP_LEVEL_FLAGS_RETSTATUS_RETPTR_LOGGER(LEVEL, FLAGS, RETSTATUS, RETPTR) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#define WPP_LEVEL_FLAGS_RETSTATUS_POSCOND_PRE(LEVEL, FLAGS, RETSTATUS, POSCOND) do { NTSTATUS __statusRet = (RETSTATUS); if ((POSCOND)) {
+#define WPP_LEVEL_FLAGS_RETSTATUS_POSCOND_POST(LEVEL, FLAGS, RETSTATUS, POSCOND) ; return __statusRet; } } while (0, 0)
+#define WPP_LEVEL_FLAGS_RETSTATUS_POSCOND_ENABLED(LEVEL, FLAGS, RETSTATUS, POSCOND) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+#define WPP_LEVEL_FLAGS_RETSTATUS_POSCOND_LOGGER(LEVEL, FLAGS, RETSTATUS, POSCOND) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#define WPP_LEVEL_FLAGS_IFRLOG_POSCOND_RETSTATUS_PRE(LEVEL, FLAGS, IFRLOG, POSCOND, RETSTATUS) do { NTSTATUS __statusRet = (RETSTATUS); if ((POSCOND)) {
+#define WPP_LEVEL_FLAGS_IFRLOG_POSCOND_RETSTATUS_POST(LEVEL, FLAGS, IFRLOG, POSCOND, RETSTATUS) ; return __statusRet; } } while (0, 0)
+#define WPP_LEVEL_FLAGS_IFRLOG_POSCOND_RETSTATUS_ENABLED(LEVEL, FLAGS, IFRLOG, POSCOND, RETSTATUS) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+#define WPP_LEVEL_FLAGS_IFRLOG_POSCOND_RETSTATUS_LOGGER(LEVEL, FLAGS, IFRLOG, POSCOND, RETSTATUS) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#define WPP_LEVEL_FLAGS_RETSTATUS_NEGCOND_PRE(LEVEL, FLAGS, RETSTATUS, NEGCOND) do { NTSTATUS __statusRet = (RETSTATUS); if (!(NEGCOND)) {
+#define WPP_LEVEL_FLAGS_RETSTATUS_NEGCOND_POST(LEVEL, FLAGS, RETSTATUS, NEGCOND) ; return __statusRet; } } while (0, 0)
+#define WPP_LEVEL_FLAGS_RETSTATUS_NEGCOND_ENABLED(LEVEL, FLAGS, RETSTATUS, NEGCOND) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+#define WPP_LEVEL_FLAGS_RETSTATUS_NEGCOND_LOGGER(LEVEL, FLAGS, RETSTATUS, NEGCOND) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+
+#pragma region IFR Enablement Macros
+
+// Opt-in to a WPP recorder feature that enables independent evaluation of conditions to decide if a
+// message needs to be sent to the recorder, an enabled session, or both.
+#define ENABLE_WPP_TRACE_FILTERING_WITH_WPP_RECORDER 1
+
+// Logger/Enabled macros used to decide if a message that is being sent to a custom recorder should
+// also go to an enabled session. These do not depend on the custom recorder itself, so just
+// delegate to the default.
+#define WPP_IFRLOG_LEVEL_FLAGS_LOGGER(IFRLOG, LEVEL, FLAGS) WPP_LEVEL_FLAGS_LOGGER(LEVEL, FLAGS)
+#define WPP_IFRLOG_LEVEL_FLAGS_ENABLED(IFRLOG, LEVEL, FLAGS) WPP_LEVEL_FLAGS_ENABLED(LEVEL, FLAGS)
+
+#define WPP_RECORDER_CONDITIONAL_LEVEL_FLAGS_OVERRIDE(LEVEL, FLAGS, HR) \
+    ((LEVEL == LEVEL_COND) ? \
+        (FAILED(HR) ? \
+                WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL_ERROR, FLAGS) : WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL_VERBOSE, FLAGS)) : \
+            WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS))
+
+#define WPP_RECORDER_CONDITIONAL_LEVEL_FLAGS_OVERRIDE_NTSTATUS(LEVEL, FLAGS, STATUS) \
+    ((LEVEL == LEVEL_COND) ? \
+        (FAILED_NTSTATUS(STATUS) ? \
+                WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL_ERROR, FLAGS) : WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL_VERBOSE, FLAGS)) : \
+            WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS))
+
+#define WPP_RECORDER_LEVEL_FLAGS_HR_ARGS(LEVEL, FLAGS, RETVAL) WPP_RECORDER_LEVEL_FLAGS_ARGS(LEVEL, FLAGS)
+#define WPP_RECORDER_LEVEL_FLAGS_HR_FILTER(LEVEL, FLAGS, RETVAL) WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS)
+
+#define WPP_RECORDER_LEVEL_FLAGS_RETVAL_ARGS(LEVEL, FLAGS, RETVAL) WPP_RECORDER_LEVEL_FLAGS_ARGS(LEVEL, FLAGS)
+#define WPP_RECORDER_LEVEL_FLAGS_RETVAL_FILTER(LEVEL, FLAGS, RETVAL) WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS)
+
+#define WPP_RECORDER_LEVEL_FLAGS_FI_ARGS(LEVEL, FLAGS, RETVAL) WPP_RECORDER_LEVEL_FLAGS_ARGS(LEVEL, FLAGS)
+#define WPP_RECORDER_LEVEL_FLAGS_FI_FILTER(LEVEL, FLAGS, RETVAL) WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS)
+
+#define WPP_RECORDER_LEVEL_FLAGS_STATUS_ARGS(LEVEL, FLAGS, STATUS) WPP_RECORDER_LEVEL_FLAGS_ARGS(LEVEL, FLAGS)
+#define WPP_RECORDER_LEVEL_FLAGS_STATUS_FILTER(LEVEL, FLAGS, STATUS) WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS)
+
+#define WPP_RECORDER_LEVEL_FLAGS_RETSTATUS_ARGS(LEVEL, FLAGS, RETSTATUS) WPP_RECORDER_LEVEL_FLAGS_ARGS(LEVEL, FLAGS)
+#define WPP_RECORDER_LEVEL_FLAGS_RETSTATUS_FILTER(LEVEL, FLAGS, RETSTATUS) WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS)
+
+#define WPP_RECORDER_LEVEL_FLAGS_IFRLOG_RETSTATUS_ARGS(LEVEL, FLAGS, IFRLOG, RETSTATUS) WPP_RECORDER_LEVEL_FLAGS_ARGS(LEVEL, FLAGS)
+#define WPP_RECORDER_LEVEL_FLAGS_IFRLOG_RETSTATUS_FILTER(LEVEL, FLAGS, IFRLOG, RETSTATUS) WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS)
+
+#define WPP_RECORDER_LEVEL_FLAGS_IFRLOG_RETSTATUS_ALLOWEDSTATUS_ARGS(LEVEL, FLAGS, IFRLOG, RETSTATUS, ALLOWEDSTATUS) WPP_RECORDER_LEVEL_FLAGS_ARGS(LEVEL, FLAGS)
+#define WPP_RECORDER_LEVEL_FLAGS_IFRLOG_RETSTATUS_ALLOWEDSTATUS_FILTER(LEVEL, FLAGS, IFRLOG, RETSTATUS, ALLOWEDSTATUS) WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS)
+
+#define WPP_RECORDER_LEVEL_FLAGS_RETPTR_ARGS(LEVEL, FLAGS, RETPTR) WPP_RECORDER_LEVEL_FLAGS_ARGS(LEVEL, FLAGS)
+#define WPP_RECORDER_LEVEL_FLAGS_RETPTR_FILTER(LEVEL, FLAGS, RETPTR) WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS)
+
+#define WPP_RECORDER_LEVEL_FLAGS_RETSTATUS_RETPTR_ARGS(LEVEL, FLAGS, RETSTATUS, RETPTR) WPP_RECORDER_LEVEL_FLAGS_ARGS(LEVEL, FLAGS)
+#define WPP_RECORDER_LEVEL_FLAGS_RETSTATUS_RETPTR_FILTER(LEVEL, FLAGS, RETSTATUS, RETPTR) WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS)
+
+#define WPP_RECORDER_LEVEL_FLAGS_RETSTATUS_POSCOND_ARGS(LEVEL, FLAGS, RETSTATUS, POSCOND) WPP_RECORDER_LEVEL_FLAGS_ARGS(LEVEL, FLAGS)
+#define WPP_RECORDER_LEVEL_FLAGS_RETSTATUS_POSCOND_FILTER(LEVEL, FLAGS, RETSTATUS, POSCOND) WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS)
+
+#define WPP_RECORDER_LEVEL_FLAGS_IFRLOG_POSCOND_RETSTATUS_ARGS(LEVEL, FLAGS, IFRLOG, RETSTATUS, POSCOND) WPP_RECORDER_LEVEL_FLAGS_ARGS(LEVEL, FLAGS)
+#define WPP_RECORDER_LEVEL_FLAGS_IFRLOG_POSCOND_RETSTATUS_FILTER(LEVEL, FLAGS, IFRLOG, RETSTATUS, POSCOND) WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS)
+
+#define WPP_RECORDER_LEVEL_FLAGS_RETSTATUS_NEGCOND_ARGS(LEVEL, FLAGS, RETSTATUS, NEGCOND) WPP_RECORDER_LEVEL_FLAGS_ARGS(LEVEL, FLAGS)
+#define WPP_RECORDER_LEVEL_FLAGS_RETSTATUS_NEGCOND_FILTER(LEVEL, FLAGS, RETSTATUS, NEGCOND) WPP_RECORDER_LEVEL_FLAGS_FILTER(LEVEL, FLAGS)
+#pragma endregion
+
+#pragma region Custom tracing macros
+
+// begin_wpp config
+// USEPREFIX(DrvLogCritical,  "%!STDPREFIX!CRIT: ");
+// USEPREFIX(DrvLogError,     "%!STDPREFIX!ERROR: ");
+// USEPREFIX(DrvLogWarning,   "%!STDPREFIX!WARN: ");
+// USEPREFIX(DrvLogInfo,      "%!STDPREFIX!INFO: ");
+// USEPREFIX(DrvLogVerbose,   "%!STDPREFIX!VERB: ");
+// USEPREFIX(DrvLogEnter,     "%!STDPREFIX!ENTER");
+// USEPREFIX(DrvLogExit,      "%!STDPREFIX!EXIT");
+// end_wpp
+
+// begin_wpp config
+// FUNC DrvLogCritical{LEVEL=TRACE_LEVEL_CRITICAL}(IFRLOG,FLAGS,MSG,...);
+// FUNC DrvLogError{LEVEL=TRACE_LEVEL_ERROR}(IFRLOG,FLAGS,MSG,...);
+// FUNC DrvLogWarning{LEVEL=TRACE_LEVEL_WARNING}(IFRLOG,FLAGS,MSG,...);
+// FUNC DrvLogInfo{LEVEL=TRACE_LEVEL_INFORMATION}(IFRLOG,FLAGS,MSG,...);
+// FUNC DrvLogEnter{LEVEL=TRACE_LEVEL_VERBOSE,FLAGS=FLAG_FUNCTION}(IFRLOG,...);
+// FUNC DrvLogVerbose{LEVEL=TRACE_LEVEL_VERBOSE}(IFRLOG,FLAGS,MSG,...);
+// FUNC DrvLogExit{LEVEL=TRACE_LEVEL_VERBOSE,FLAGS=FLAG_FUNCTION}(IFRLOG,...);
+// end_wpp
+
+
+#ifdef __INTELLISENSE__
+#define FLAG_DEVICE_ALL 0x01
+#define FLAG_FUNCTION   0x02
+#define FLAG_INFO       0x04
+#define FLAG_PNP        0x08
+#define FLAG_POWER      0x10
+#define FLAG_STREAM     0x20
+#define FLAG_INIT       0x40
+#define FLAG_DDI        0x80
+#define FLAG_GENERIC    0x100
+void DrvLogCritical(void* log, int flags, const WCHAR* fmt, ...);
+void DrvLogError(void* log, int flags, const WCHAR* fmt, ...);
+void DrvLogWarning(void* log, int flags, const WCHAR* fmt, ...);
+void DrvLogInfo(void* log, int flags, const WCHAR* fmt, ...);
+void DrvLogEnter(void* log, ...);
+void DrvLogVerbose(void* log, int flags, const WCHAR* fmt, ...);
+void DrvLogExit(void* log, ...);
+
+void RETURN_IF_FAILED(NTSTATUS status);
+void RETURN_NTSTATUS_IF_FAILED(NTSTATUS status);
+void RETURN_NTSTATUS_IF_FAILED_MSG(NTSTATUS status, const WCHAR* fmt, ...);
+void RETURN_NTSTATUS_IF_FAILED_UNLESS_ALLOWED(NTSTATUS returnStatus, NTSTATUS allowedStatus);
+void RETURN_NTSTATUS_IF_NULL_ALLOC(PVOID ptr);
+void RETURN_NTSTATUS_IF_NULL(PVOID ptr);
+void RETURN_NTSTATUS_IF_TRUE(BOOL condition, NTSTATUS status);
+void RETURN_NTSTATUS_IF_TRUE_MSG(BOOL condition, NTSTATUS status, const WCHAR* fmt, ...);
+void RETURN_NTSTATUS_IF_FALSE(BOOL condition, NTSTATUS status);
+void RETURN_NTSTATUS(NTSTATUS status);
+void RETURN_NTSTATUS_MSG(NTSTATUS status, const WCHAR* fmt, ...);
+#endif// __INTELLISENSE__
+
+//*********************************************************
+// MACRO: TRACE_METHOD_LINE
+//
+// begin_wpp config
+// FUNC TRACE_METHOD_LINE(LEVEL, FLAGS, MSG, ...);
+// USESUFFIX (TRACE_METHOD_LINE, ", this=0x%p", this);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_METHOD_ENTRY
+//
+// begin_wpp config
+// FUNC TRACE_METHOD_ENTRY(LEVEL, FLAGS);
+// USESUFFIX (TRACE_METHOD_ENTRY, "Enter, this=0x%p", this);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_METHOD_EXIT
+//
+// begin_wpp config
+// FUNC TRACE_METHOD_EXIT(LEVEL, FLAGS);
+// USESUFFIX (TRACE_METHOD_EXIT, "Exit, this=0x%p", this);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_METHOD_EXIT_HR
+//
+// begin_wpp config
+// FUNC TRACE_METHOD_EXIT_HR(LEVEL, FLAGS, HR);
+// USESUFFIX (TRACE_METHOD_EXIT_HR, "Exit, this=0x%p, hr=%!HRESULT!", this, HR);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_METHOD_EXIT_DWORD
+//
+// begin_wpp config
+// FUNC TRACE_METHOD_EXIT_DWORD(LEVEL, FLAGS, RETVAL);
+// USESUFFIX (TRACE_METHOD_EXIT_DWORD, "Exit, this=0x%p, ret=0x%08Ix ", this, RETVAL);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_METHOD_EXIT_PTR
+//
+// begin_wpp config
+// FUNC TRACE_METHOD_EXIT_PTR(LEVEL, FLAGS, RETVAL);
+// USESUFFIX (TRACE_METHOD_EXIT_PTR,"Exit, this=0x%p, retptr=0x%p", this, RETVAL);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_METHOD_EXIT_STATUS
+//
+// begin_wpp config
+// FUNC TRACE_METHOD_EXIT_STATUS(LEVEL, FLAGS, STATUS);
+// USESUFFIX (TRACE_METHOD_EXIT_STATUS, "Exit, this=0x%p, status=%!STATUS!", this, STATUS);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_FUNCTION_ENTRY
+//
+// begin_wpp config
+// FUNC TRACE_FUNCTION_ENTRY(LEVEL, FLAGS);
+// USESUFFIX (TRACE_FUNCTION_ENTRY, "Enter");
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_FUNCTION_EXIT
+//
+// begin_wpp config
+// FUNC TRACE_FUNCTION_EXIT(LEVEL, FLAGS);
+// USESUFFIX (TRACE_FUNCTION_EXIT, "Exit");
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_FUNCTION_EXIT_HR
+//
+// begin_wpp config
+// FUNC TRACE_FUNCTION_EXIT_HR(LEVEL, FLAGS, HR);
+// USESUFFIX (TRACE_FUNCTION_EXIT_HR, "Exit, hr=%!HRESULT!", HR);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_FUNCTION_EXIT_DWORD
+//
+// begin_wpp config
+// FUNC TRACE_FUNCTION_EXIT_DWORD(LEVEL, FLAGS, RETVAL);
+// USESUFFIX (TRACE_FUNCTION_EXIT_DWORD, "Exit, ret=0x%08Ix", RETVAL);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_FUNCTION_EXIT_PTR
+//
+// begin_wpp config
+// FUNC TRACE_FUNCTION_EXIT_PTR(LEVEL, FLAGS, RETVAL);
+// USESUFFIX (TRACE_FUNCTION_EXIT_PTR, "Exit, retptr=0x%p", RETVAL);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_FUNCTION_EXIT_STATUS
+//
+// begin_wpp config
+// FUNC TRACE_FUNCTION_EXIT_STATUS(LEVEL, FLAGS, STATUS);
+// USESUFFIX (TRACE_FUNCTION_EXIT_STATUS, "Exit, status=%!STATUS!", STATUS);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_LINE
+//
+// begin_wpp config
+// FUNC TRACE_LINE(LEVEL, FLAGS, MSG, ...);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_HRESULT
+//
+// begin_wpp config
+// FUNC TRACE_HRESULT(LEVEL, FLAGS, HR, MSG, ...);
+// USESUFFIX (TRACE_HRESULT, ", ret=%!HRESULT!", HR);
+// end_wpp
+
+//*********************************************************
+// MACRO: TRACE_FAILURE_INFO (WIL FailureInfo logging)
+// see: https://github.com/microsoft/wil/blob/master/include/wil/result_macros.h
+//
+// begin_wpp config
+// FUNC TRACE_FAILURE_INFO(LEVEL, FLAGS, FI);
+// USESUFFIX(TRACE_FAILURE_INFO, " [%04X] '%ws', hr=%!HRESULT! ['%s' (%u)]", FI.threadId, FI.pszMessage, FI.hr, FI.pszFile, FI.uLineNumber);
+// end_wpp
+
+// MACRO: RETURN_IF_FAILED
+//
+// begin_wpp config
+// FUNC RETURN_IF_FAILED{LEVEL=LEVEL_ERROR,FLAGS=FLAG_DEVICE_ALL,IFRLOG=g_AudioDspLog}(RETSTATUS);
+// USEPREFIX(RETURN_IF_FAILED, "%!STDPREFIX!ERROR:");
+// USESUFFIX(RETURN_IF_FAILED, " File:%s, Line:%d - status=%!STATUS!", __FILE__, __LINE__, __statusRet);
+// end_wpp
+
+
+// MACRO: RETURN_NTSTATUS_IF_FAILED
+//
+// begin_wpp config
+// FUNC RETURN_NTSTATUS_IF_FAILED{LEVEL=LEVEL_ERROR,FLAGS=FLAG_DEVICE_ALL,IFRLOG=g_AudioDspLog}(RETSTATUS);
+// USEPREFIX(RETURN_NTSTATUS_IF_FAILED, "%!STDPREFIX!ERROR:");
+// USESUFFIX(RETURN_NTSTATUS_IF_FAILED, " File:%s, Line:%d - status=%!STATUS!", __FILE__, __LINE__, __statusRet);
+// end_wpp
+
+// MACRO: RETURN_NTSTATUS_IF_FAILED_MSG
+//
+// begin_wpp config
+// FUNC RETURN_NTSTATUS_IF_FAILED_MSG{LEVEL=LEVEL_ERROR,FLAGS=FLAG_DEVICE_ALL,IFRLOG=g_AudioDspLog}(RETSTATUS, MSG, ...);
+// USEPREFIX(RETURN_NTSTATUS_IF_FAILED_MSG, "%!STDPREFIX!ERROR:");
+// USESUFFIX(RETURN_NTSTATUS_IF_FAILED_MSG, " - status=%!STATUS!",__statusRet);
+// end_wpp
+
+// MACRO: RETURN_NTSTATUS_IF_FAILED_UNLESS_ALLOWED
+//
+// begin_wpp config
+// FUNC RETURN_NTSTATUS_IF_FAILED_UNLESS_ALLOWED{LEVEL=LEVEL_ERROR,FLAGS=FLAG_DEVICE_ALL,IFRLOG=g_AudioDspLog}(RETSTATUS, ALLOWEDSTATUS);
+// USEPREFIX(RETURN_NTSTATUS_IF_FAILED_UNLESS_ALLOWED, "%!STDPREFIX!ERROR:");
+// USESUFFIX(RETURN_NTSTATUS_IF_FAILED_UNLESS_ALLOWED, " File:%s, Line:%d - status=%!STATUS!", __FILE__, __LINE__, __statusRet);
+// end_wpp
+
+// MACRO: RETURN_NTSTATUS_IF_NULL_ALLOC
+//
+// begin_wpp config
+// FUNC RETURN_NTSTATUS_IF_NULL_ALLOC{LEVEL=LEVEL_ERROR,FLAGS=DUMMY}(RETPTR);
+// USESUFFIX(RETURN_NTSTATUS_IF_NULL, "status=STATUS_INSUFFICIENT_RESOURCES");
+// end_wpp
+
+// MACRO: RETURN_NTSTATUS_IF_NULL
+//
+// begin_wpp config
+// FUNC RETURN_NTSTATUS_IF_NULL{LEVEL=LEVEL_ERROR,FLAGS=DUMMY}(RETSTATUS, RETPTR);
+// USESUFFIX(RETURN_NTSTATUS_IF_NULL, "status=%!STATUS!", __statusRet);
+// end_wpp
+
+// MACRO: RETURN_NTSTATUS_IF_TRUE
+//
+// begin_wpp config
+// FUNC RETURN_NTSTATUS_IF_TRUE{LEVEL=LEVEL_ERROR,FLAGS=FLAG_DEVICE_ALL,IFRLOG=g_AudioDspLog}(POSCOND, RETSTATUS);
+// USESUFFIX(RETURN_NTSTATUS_IF_TRUE, " File:%s, Line:%d - status=%!STATUS!", __FILE__, __LINE__, __statusRet);
+// end_wpp
+
+// MACRO: RETURN_NTSTATUS_IF_TRUE_MSG
+//
+// begin_wpp config
+// FUNC RETURN_NTSTATUS_IF_TRUE_MSG{LEVEL=LEVEL_ERROR,FLAGS=FLAG_DEVICE_ALL,IFRLOG=g_AudioDspLog}(POSCOND, RETSTATUS, MSG, ...);
+// USESUFFIX(RETURN_NTSTATUS_IF_TRUE_MSG, " - status=%!STATUS!", __statusRet);
+// end_wpp
+
+// MACRO: RETURN_NTSTATUS_IF_FALSE
+//
+// begin_wpp config
+// FUNC RETURN_NTSTATUS_IF_FALSE{LEVEL=LEVEL_ERROR,FLAGS=DUMMY}(RETSTATUS, NEGCOND);
+// USESUFFIX(RETURN_NTSTATUS_IF_FALSE, " File:%s, Line:%d - status=%!STATUS!", __FILE__, __LINE__, __statusRet);
+// end_wpp
+
+// MACRO: RETURN_NTSTATUS
+//
+// begin_wpp config
+// FUNC RETURN_NTSTATUS{LEVEL=LEVEL_ERROR,FLAGS=FLAG_DEVICE_ALL,IFRLOG=g_AudioDspLog}(RETSTATUS);
+// USESUFFIX(RETURN_NTSTATUS, " File:%s, Line:%d - status=%!STATUS!", __FILE__, __LINE__, __statusRet);
+// end_wpp
+
+// MACRO: RETURN_NTSTATUS_MSG
+//
+// begin_wpp config
+// FUNC RETURN_NTSTATUS_MSG{LEVEL=LEVEL_ERROR,FLAGS=FLAG_DEVICE_ALL,IFRLOG=g_AudioDspLog}(RETSTATUS, MSG, ...);
+// USESUFFIX(RETURN_NTSTATUS_MSG, " - status=%!STATUS!", __statusRet);
+// end_wpp
+
+#define W32
+#define WPP_CHECK_FOR_NULL_STRING  //to prevent exceptions due to NULL strings
+
+#pragma endregion
diff --git a/audio/Acx/Samples/Common/WaveReader.cpp b/audio/Acx/Samples/Common/WaveReader.cpp
new file mode 100644
index 00000000..4fa6eae9
--- /dev/null
+++ b/audio/Acx/Samples/Common/WaveReader.cpp
@@ -0,0 +1,769 @@
+/*++
+
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+    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:
+    WaveReader.cpp
+
+Abstract:
+    Implementation of wave file reader for ACX sample drivers.
+
+    To read data from disk, this class maintains a circular data buffer. This buffer is segmented into multiple chunks of 
+    big buffer (Though we only need two, so it is set to two now). Initially we fill first two chunks and once a chunk gets emptied 
+    by OS, we schedule a workitem to fill the next available chunk.
+
+
+--*/
+
+#pragma warning (disable : 4127)
+#pragma warning (disable : 26165)
+
+#include "private.h"
+#include <devguid.h>
+#include <ks.h>
+#include <mmsystem.h>
+#include <ksmedia.h>
+#include "WaveReader.h"
+
+#define FILE_NAME_BUFFER_TAG        'WRT1'
+#define WAVE_DATA_BUFFER_TAG        'WRT2'
+#define WORK_ITEM_BUFFER_TAG        'WRT3'
+
+#define MAX_READ_WORKER_ITEM_COUNT       15
+
+#define IF_FAILED_JUMP(result, tag) do {if (!NT_SUCCESS(result)) {goto tag;}} while(false)
+#define IF_TRUE_JUMP(result, tag) do {if (result) {goto tag;}} while(false)
+#define IF_TRUE_ACTION_JUMP(result, action, tag) do {if (result) {action; goto tag;}} while(false)
+
+PREADWORKER_PARAM       CWaveReader::m_pWorkItems = NULL;
+PDEVICE_OBJECT          CWaveReader::m_pDeviceObject = NULL;
+
+
+/*++
+
+Routine Description:
+    Ctor: basic init.
+
+--*/
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CWaveReader::CWaveReader()
+: m_ChannelCount(0),
+  m_BitsPerSample(0),
+  m_SamplesPerSecond(0),
+  m_Mute(false),
+  m_FileHandle(NULL)
+{
+    PAGED_CODE();
+    m_WaveDataQueue.pWavData = NULL;
+    KeInitializeMutex(&m_FileSync, 0);
+}
+
+/*++
+
+Routine Description:
+    Dtor: free resources.
+
+--*/
+_Use_decl_annotations_
+PAGED_CODE_SEG
+CWaveReader::~CWaveReader()
+{
+    PAGED_CODE();
+    if (STATUS_SUCCESS == KeWaitForSingleObject
+    (
+        &m_FileSync,
+        Executive,
+        KernelMode,
+        FALSE,
+        NULL
+    ))
+    {
+        if (m_WaveDataQueue.pWavData != NULL)
+        {
+            ExFreePoolWithTag(m_WaveDataQueue.pWavData, WAVE_DATA_BUFFER_TAG);
+            m_WaveDataQueue.pWavData = NULL;
+        }
+
+        FileClose();
+        KeReleaseMutex(&m_FileSync, FALSE);
+    }
+    
+}
+
+/*++
+
+Routine Description:
+    - Initializing the workitems. These workitems will be scheduled asynchronously by the OS. 
+    - When these work items will be scheduled the wave file will be read and the data 
+    - will be put inside the big chunks.
+
+Arguments:
+    Device object
+
+Return Value:
+    NT status code.
+
+--*/
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS CWaveReader::InitializeWorkItems(_In_ PDEVICE_OBJECT DeviceObject)
+{
+    PAGED_CODE();
+
+    ASSERT(DeviceObject);
+
+    NTSTATUS                    ntStatus = STATUS_SUCCESS;
+
+    if (m_pWorkItems != NULL)
+    {
+        return ntStatus;
+    }
+
+    m_pWorkItems = (PREADWORKER_PARAM)
+        ExAllocatePool2
+        (
+            POOL_FLAG_NON_PAGED,
+            sizeof(READWORKER_PARAM) * MAX_READ_WORKER_ITEM_COUNT,
+            'RDPT'
+        );
+    if (m_pWorkItems)
+    {
+        for (int i = 0; i < MAX_READ_WORKER_ITEM_COUNT; i++)
+        {
+
+            m_pWorkItems[i].WorkItem = IoAllocateWorkItem(DeviceObject);
+            if (m_pWorkItems[i].WorkItem == NULL)
+            {
+                return STATUS_INSUFFICIENT_RESOURCES;
+            }
+            KeInitializeEvent
+            (
+                &m_pWorkItems[i].EventDone,
+                NotificationEvent,
+                TRUE
+            );
+        }
+    }
+    else
+    {
+        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
+    }
+
+    return ntStatus;
+} 
+
+/*++
+
+Routine Description:
+- Wait for all the scheduled workitems to finish.
+
+--*/
+
+
+//=============================================================================
+_Use_decl_annotations_
+PAGED_CODE_SEG
+void CWaveReader::WaitAllWorkItems()
+{
+    PAGED_CODE();
+
+    for (int i = 0; i < MAX_READ_WORKER_ITEM_COUNT; i++)
+    {
+        KeWaitForSingleObject
+        (
+            &(m_pWorkItems[i].EventDone),
+            Executive,
+            KernelMode,
+            FALSE,
+            NULL
+        );
+    }
+} 
+
+/*++
+
+Routine Description:
+    - Deallocating the workitems. 
+
+--*/
+
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+VOID CWaveReader::DestroyWorkItems()
+{
+    PAGED_CODE();
+
+    if (m_pWorkItems)
+    {
+        for (int i = 0; i < MAX_READ_WORKER_ITEM_COUNT; i++)
+        {
+            if (m_pWorkItems[i].WorkItem != NULL)
+            {
+                IoFreeWorkItem(m_pWorkItems[i].WorkItem);
+                m_pWorkItems[i].WorkItem = NULL;
+            }
+        }
+        ExFreePoolWithTag(m_pWorkItems, WORK_ITEM_BUFFER_TAG);
+        m_pWorkItems = NULL;
+    }
+} 
+
+/*++
+
+Routine Description:
+    - Get a free work item to schedule a file read operation.
+
+--*/
+_Use_decl_annotations_
+PREADWORKER_PARAM CWaveReader::GetNewWorkItem()
+{
+    LARGE_INTEGER               timeOut = { 0 };
+    NTSTATUS                    ntStatus;
+
+    for (int i = 0; i < MAX_READ_WORKER_ITEM_COUNT; i++)
+    {
+        ntStatus =
+            KeWaitForSingleObject
+            (
+                &m_pWorkItems[i].EventDone,
+                Executive,
+                KernelMode,
+                FALSE,
+                &timeOut
+            );
+        if (STATUS_SUCCESS == ntStatus)
+        {
+            if (m_pWorkItems[i].WorkItem)
+                return &(m_pWorkItems[i]);
+            else
+                return NULL;
+        }
+    }
+
+    return NULL;
+} 
+
+/*++
+Routine Description:
+- This routine will enqueue a workitem for reading wave file and putting 
+- the data into the chunk buffer.
+
+Arguments:
+    Chunk descriptor for the chunk to be filled.
+--*/
+
+_Use_decl_annotations_
+VOID CWaveReader::ReadWavChunk(PCHUNKDESCRIPTOR pChunkDescriptor)
+{
+    PREADWORKER_PARAM           pParam = NULL;
+
+    pParam = GetNewWorkItem();
+    if (pParam)
+    {
+        pParam->PtrWaveReader = this;
+        pParam->PtrChunkDescriptor = pChunkDescriptor;
+        KeResetEvent(&pParam->EventDone);
+        IoQueueWorkItem(pParam->WorkItem, ReadFrameWorkerCallback,
+            DelayedWorkQueue, (PVOID)pParam);
+    }
+} 
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+IO_WORKITEM_ROUTINE ReadFrameWorkerCallback;
+/*
+Routine Description:
+- This routine will be called by the OS. It will fill the chunk buffer, defined by the chunk descriptor
+- If end of file is reached it will mark the end of file as true.
+
+Arguments:
+    pDeviceObject - Device object
+    Context       - pointer to reader worker params
+*/
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+VOID ReadFrameWorkerCallback
+(
+    _In_        PDEVICE_OBJECT         pDeviceObject,
+    _In_opt_    PVOID                  Context
+)
+{
+    PAGED_CODE();
+    UNREFERENCED_PARAMETER(pDeviceObject);
+    pWaveReader                 pWavRd;
+    PREADWORKER_PARAM           pParam = (PREADWORKER_PARAM)Context;
+
+    if (NULL == pParam)
+    {
+        // This is completely unexpected, assert here.
+        //
+        ASSERT(pParam);
+        goto exit;
+    }
+
+    pWavRd = pParam->PtrWaveReader;
+
+    if (pWavRd == NULL)
+    {
+        goto exit;
+    }
+    if (STATUS_SUCCESS == KeWaitForSingleObject
+    (
+        &pWavRd->m_FileSync,
+        Executive,
+        KernelMode,
+        FALSE,
+        NULL
+    )) 
+    {
+
+        NTSTATUS                    ntStatus = STATUS_SUCCESS;
+
+        ASSERT(Context);
+        
+        IO_STATUS_BLOCK             ioStatusBlock;
+
+        if (pParam->WorkItem)
+        {
+            if (pWavRd->m_WaveDataQueue.bEofReached || pWavRd->m_WaveDataQueue.pWavData == NULL)
+            {
+                KeReleaseMutex(&pWavRd->m_FileSync, FALSE);
+                goto exit;
+            }
+
+            if (pParam->PtrChunkDescriptor->pStartAddress != NULL)
+            {
+                ntStatus = ZwReadFile(pWavRd->m_FileHandle,
+                    NULL,
+                    NULL,
+                    NULL,
+                    &ioStatusBlock,
+                    pParam->PtrChunkDescriptor->pStartAddress,
+                    pParam->PtrChunkDescriptor->ulChunkLength,
+                    NULL,
+                    NULL);
+
+                pParam->PtrChunkDescriptor->bIsChunkEmpty = false;
+
+                if (ioStatusBlock.Information != pParam->PtrChunkDescriptor->ulChunkLength)
+                {
+                    pWavRd->m_WaveDataQueue.bEofReached = true;
+                }
+            }
+        }
+
+        KeReleaseMutex(&pWavRd->m_FileSync, FALSE);
+    }
+
+exit:
+    KeSetEvent(&pParam->EventDone, 0, FALSE);
+}
+
+/*++
+
+Routine Description:
+-   If all the chunks are empty this resturn true.
+
+--*/
+
+_Use_decl_annotations_
+bool CWaveReader::IsAllChunkEmpty()
+{
+    for (int i = 0; i < NUM_OF_CHUNK_FOR_FILE_READ; i++)
+    {
+        if (!m_WaveDataQueue.sChunkDescriptor[i].bIsChunkEmpty)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+/*++
+Routine Description:
+    - This routine does the actual copy of data from the chunk buffer to the buffer provided by OS.
+    - If it empties the current chunk buffer, then it sets it state to empty and then enqueue a workitem 
+    - to read data from the wave file and put it to the next available chunk buffer. 
+
+Arguments:
+    Buffer - Pointer to the OS buffer
+    BufferLength - Length of the data to be filled (in bytes)
+
+--*/
+_Use_decl_annotations_
+VOID CWaveReader::CopyDataFromRingBuffer
+(
+    _Out_writes_bytes_(BufferLength) BYTE       *Buffer,
+    _In_                             ULONG      BufferLength
+)
+{
+    if (IsAllChunkEmpty())
+    {
+        RtlZeroMemory(Buffer, BufferLength);
+    }
+    else
+    {
+        ULONG prevChunk = (m_WaveDataQueue.ulReadPtr*NUM_OF_CHUNK_FOR_FILE_READ )/ m_WaveDataQueue.ulLength;
+
+        /////////////////
+        BYTE       *currentBuf = Buffer;
+        ULONG       length = BufferLength;
+        while (length > 0)
+        {
+            ULONG runWrite = min(length, m_WaveDataQueue.ulLength - m_WaveDataQueue.ulReadPtr);
+            
+            // Copy the wave buffer data to OS buffer
+            RtlCopyMemory(currentBuf, m_WaveDataQueue.pWavData + m_WaveDataQueue.ulReadPtr, runWrite);
+            // Zero out the wave buffer, so that if wave end of file is reached we should copy only zeros
+            RtlZeroMemory(m_WaveDataQueue.pWavData + m_WaveDataQueue.ulReadPtr, runWrite);
+            // Update the read pointer
+            m_WaveDataQueue.ulReadPtr = (m_WaveDataQueue.ulReadPtr  + runWrite) % m_WaveDataQueue.ulLength;
+            currentBuf += runWrite;
+            length = length - runWrite;
+        }
+
+        ULONG curChunk = (m_WaveDataQueue.ulReadPtr*NUM_OF_CHUNK_FOR_FILE_READ) / m_WaveDataQueue.ulLength;
+
+        if (curChunk != prevChunk)
+        {
+            m_WaveDataQueue.currentExecutedChunk++;
+            // Schedule a workitem to read data from the wave file
+            ULONG chunkNo = m_WaveDataQueue.currentExecutedChunk % NUM_OF_CHUNK_FOR_FILE_READ;
+            m_WaveDataQueue.sChunkDescriptor[chunkNo].bIsChunkEmpty = true;
+            if (!m_WaveDataQueue.bEofReached)
+            {
+                ReadWavChunk(&m_WaveDataQueue.sChunkDescriptor[chunkNo]);
+            }
+        }
+    }
+}
+
+/*++
+Routine Description:
+    - Just a high level read buffer call.
+
+ Arguments:
+     Buffer - Pointer to the OS buffer
+     BufferLength - Length of the data to be filled (in bytes)
+--*/
+
+_Use_decl_annotations_
+VOID CWaveReader::ReadWaveData
+(
+    _Out_writes_bytes_(BufferLength) BYTE       *Buffer, 
+    _In_                             ULONG      BufferLength
+)
+{
+    if (m_Mute)
+    {
+        RtlZeroMemory(Buffer, BufferLength);
+    }
+    else
+    {
+        CopyDataFromRingBuffer(Buffer, BufferLength);
+    }
+}
+
+/*++
+Routine Description:
+- initialization for the wavereader member variables, 
+- Allocating memory for the 1 second buffer
+- Preread the one second buffer data, so that when OS comes to read the data we have it available in the memory.
+
+Arguments:
+    WfExt - Format which should be used for capture
+    fileNameString - name of the file to be read
+
+Return:
+    NTStatus
+--*/
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS CWaveReader::Init
+(
+    _In_    PWAVEFORMATEXTENSIBLE   WfExt,
+    _In_    PUNICODE_STRING puiFileName
+)
+{
+    PAGED_CODE();
+    NTSTATUS        ntStatus = STATUS_SUCCESS;
+    KFLOATING_SAVE  saveData;
+    
+    // Save floating state (just in case).
+    ntStatus = KeSaveFloatingPointState(&saveData);
+    if (!NT_SUCCESS(ntStatus))
+    {
+        return ntStatus;
+    }
+
+    //
+    // This sample supports PCM 16bit formats only. 
+    //
+    if ((WfExt->Format.wFormatTag != WAVE_FORMAT_PCM &&
+        !(WfExt->Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
+          IsEqualGUIDAligned(WfExt->SubFormat, KSDATAFORMAT_SUBTYPE_PCM))) ||
+        (WfExt->Format.wBitsPerSample != 16 &&
+         WfExt->Format.wBitsPerSample != 8))
+    {
+        ntStatus = STATUS_NOT_SUPPORTED;
+    }
+    IF_FAILED_JUMP(ntStatus, Done);
+
+    // Basic init.
+    m_ChannelCount      = WfExt->Format.nChannels;      // # channels.
+    m_BitsPerSample     = WfExt->Format.wBitsPerSample; // bits per sample.
+    m_SamplesPerSecond  = WfExt->Format.nSamplesPerSec; // samples per sec.
+    m_Mute              = false;
+
+    // Wave data queue initialization
+    m_WaveDataQueue.ulLength = WfExt->Format.nAvgBytesPerSec;
+    m_WaveDataQueue.bEofReached = false;
+    m_WaveDataQueue.ulReadPtr = 0;
+
+    // Mark all the chunk empty
+    for (int i = 0; i < NUM_OF_CHUNK_FOR_FILE_READ; i++)
+    {
+        m_WaveDataQueue.sChunkDescriptor[i].bIsChunkEmpty = true;
+    }
+
+    ntStatus = OpenWaveFile(puiFileName);
+    IF_FAILED_JUMP(ntStatus, Done);
+
+    ntStatus = AllocateBigBuffer();
+    IF_FAILED_JUMP(ntStatus, Done);
+
+    ntStatus = ReadHeaderAndFillBuffer();
+
+Done:
+    (void)KeRestoreFloatingPointState(&saveData);
+    return ntStatus;
+}
+
+/*++
+Routine Description:
+    This function read the wave header file and compare the header info with the
+    stream info. Currently we are using only number of channel, sampling frequency 
+    and bits per sample as the primary parameters for the wave file to compare against
+    stream params. If the params don't match we return success but streams zeros.
+
+Return:
+    NTStatus
+--*/
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS CWaveReader::ReadHeaderAndFillBuffer()
+{
+    PAGED_CODE();
+    NTSTATUS    ntStatus = STATUS_SUCCESS;
+    ntStatus = FileReadHeader();
+
+    if(NT_SUCCESS(ntStatus))
+    {
+        if (m_WaveHeader.numChannels != m_ChannelCount ||
+            m_WaveHeader.bitsPerSample != m_BitsPerSample ||
+            m_WaveHeader.sampleRate != m_SamplesPerSecond)
+        {
+            // If the wave file format don't match we wont treat this as error
+            // and we will stream zeros. So we return from here and will not read the 
+            // wave file and wont fill the buffers.
+            return STATUS_SUCCESS;
+        }
+    }
+
+    if (NT_SUCCESS(ntStatus))
+    {
+        // If the wave file format is same as the stream format we will stream the data 
+        //  else we will just stream zeros.
+        ReadWavChunk(&m_WaveDataQueue.sChunkDescriptor[0]); // Fill the first chunk
+        ReadWavChunk(&m_WaveDataQueue.sChunkDescriptor[1]);  // Fill the second chunk
+        // Set the current executed chunk to 1. Once OS finishs the data for the first chunk
+        // use the currentExecutedChunk to find the next chunk and schedule a workitem to fill the 
+        // data into the next chunk
+        m_WaveDataQueue.currentExecutedChunk = 1;   
+    }
+
+    return ntStatus;
+}
+
+/*++
+Routine Description:
+    This function allocates 1 second buffer.
+    Segments the buffer into multiple (currently two) chunks. Assigns the start pointer and length
+    for each chunk.
+
+Return:
+    NTStatus
+--*/
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS CWaveReader::AllocateBigBuffer()
+{
+    PAGED_CODE();
+    NTSTATUS    ntStatus = STATUS_SUCCESS;
+
+    m_WaveDataQueue.pWavData = (PBYTE)
+        ExAllocatePool2
+        (
+            POOL_FLAG_NON_PAGED,
+            m_WaveDataQueue.ulLength,
+            WAVE_DATA_BUFFER_TAG
+        );
+    if (!m_WaveDataQueue.pWavData)
+    {
+        ntStatus = STATUS_INSUFFICIENT_RESOURCES;
+    }
+    else
+    {
+        ULONG chunklLength = m_WaveDataQueue.ulLength / NUM_OF_CHUNK_FOR_FILE_READ;
+        for (int i = 0; i < NUM_OF_CHUNK_FOR_FILE_READ; i++)
+        {
+            m_WaveDataQueue.sChunkDescriptor[i].pStartAddress = m_WaveDataQueue.pWavData + chunklLength*i;
+            m_WaveDataQueue.sChunkDescriptor[i].ulChunkLength = chunklLength;
+        }
+    }
+    return ntStatus;
+}
+
+/*++
+Routine Description:
+    This function opens wave file.
+
+Arguments:
+    fileNameString - Name of the wave file
+
+Return:
+    NTStatus
+--*/
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS CWaveReader::OpenWaveFile(PUNICODE_STRING puiFileName)
+{
+    PAGED_CODE();
+    NTSTATUS    ntStatus = STATUS_SUCCESS;
+
+    if (NT_SUCCESS(ntStatus) && puiFileName->Buffer != NULL)
+    {
+        // Create data file.
+        InitializeObjectAttributes
+        (
+            &m_objectAttributes,
+            puiFileName,
+            OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
+            NULL,
+            NULL
+        );
+
+        // Open Wave File
+        ntStatus = FileOpen();
+    }
+
+    return ntStatus;
+}
+
+/*++
+Routine Description:
+    This function closes wave file handle.
+
+Return:
+    NTStatus
+--*/
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS CWaveReader::FileClose()
+{
+    PAGED_CODE();
+
+    NTSTATUS                    ntStatus = STATUS_SUCCESS;
+
+    if (m_FileHandle)
+    {
+        ntStatus = ZwClose(m_FileHandle);
+        m_FileHandle = NULL;
+    }
+
+    return ntStatus;
+} 
+
+/*++
+Routine Description:
+    Reads the wave file file header information
+
+Return:
+    NTStatus
+--*/
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS CWaveReader::FileReadHeader()
+{
+    PAGED_CODE();
+    NTSTATUS                    ntStatus = STATUS_SUCCESS;
+    IO_STATUS_BLOCK             ioStatusBlock;
+
+
+    ntStatus = ZwReadFile(m_FileHandle,
+                        NULL, 
+                        NULL, 
+                        NULL,
+                        &ioStatusBlock,
+                        &m_WaveHeader,
+                        sizeof(WAVEHEADER), 
+                        NULL, 
+                        NULL);
+
+    return ntStatus;
+}
+
+/*++
+Routine Description:
+    This function opens wave file.
+
+Return:
+    NTStatus
+--*/
+
+_Use_decl_annotations_
+PAGED_CODE_SEG
+NTSTATUS CWaveReader::FileOpen()
+{
+ 
+    PAGED_CODE();
+    NTSTATUS                    ntStatus = STATUS_SUCCESS;
+    IO_STATUS_BLOCK             ioStatusBlock;
+
+    if (!m_FileHandle)
+    {
+        ntStatus =
+            ZwCreateFile
+            (
+                &m_FileHandle,
+                GENERIC_READ,
+                &m_objectAttributes,
+                &ioStatusBlock,
+                NULL,
+                FILE_ATTRIBUTE_NORMAL,
+                FILE_SHARE_READ,
+                FILE_OPEN,
+                FILE_SYNCHRONOUS_IO_NONALERT,
+                NULL,
+                0
+            );
+    }
+
+    return ntStatus;
+} 
+
diff --git a/audio/Acx/Samples/Common/WaveReader.h b/audio/Acx/Samples/Common/WaveReader.h
new file mode 100644
index 00000000..08516be7
--- /dev/null
+++ b/audio/Acx/Samples/Common/WaveReader.h
@@ -0,0 +1,196 @@
+/*++
+
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+    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:
+
+    WaveReader.h
+
+Abstract:
+
+    Declaration of wave reader for ACX sample drivers.
+
+
+--*/
+#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+#include <limits.h>
+
+#define NUM_OF_CHUNK_FOR_FILE_READ 2
+
+class CWaveReader;
+
+// Wave header structure decleration 
+typedef CWaveReader *pWaveReader;
+typedef struct _WAVEHEADER
+{
+    BYTE chunkId[4];
+    ULONG chunkSize;
+    BYTE format[4];
+    BYTE subChunkId[4];
+    ULONG subChunkSize;
+    WORD audioFormat;
+    WORD numChannels;
+    ULONG sampleRate;
+    ULONG bytesPerSecond;
+    WORD blockAlign;
+    WORD bitsPerSample;
+    BYTE dataChunkId[4];
+    ULONG dataSize;
+}WAVEHEADER;
+
+typedef struct _CHUNKDESCRIPTOR
+{
+    PBYTE pStartAddress;        // Starting address of the chunk
+    ULONG ulChunkLength;        // Length of the chunk
+    bool  bIsChunkEmpty;        // If the chunk is empty
+}CHUNKDESCRIPTOR;
+typedef CHUNKDESCRIPTOR *PCHUNKDESCRIPTOR;
+
+/*
+    The idea here is to allocate one second long worth of buffer and divide it into NUM_OF_CHUNK_FOR_FILE_READ chunks.
+    In one file read operation we read and fill one chunk data . The chunk will be emptied every 10 ms by OS.
+    Once the OS empties one chunk data we schedule a workitem to read and fill next available chunk. 
+*/
+
+typedef struct _WAVEDATAQUEUE
+{
+    PBYTE pWavData;     // Pointer to the temporary buffer for reading one second worth of data from wave file
+    ULONG ulLength;     // length of pWavData in bytes
+    ULONG ulReadPtr;    // current reading position in pWavData in bytes
+    bool  bEofReached;  // This will be set once the eof is reached.
+    WORD  currentExecutedChunk;
+    CHUNKDESCRIPTOR sChunkDescriptor[NUM_OF_CHUNK_FOR_FILE_READ];
+}WAVEDATAQUEUE;
+typedef WAVEDATAQUEUE *PWAVEDATAQUEUE;
+
+// Parameter to workitem.
+#include <pshpack1.h>
+typedef struct _READWORKER_PARAM {
+    PIO_WORKITEM     WorkItem;      // Pointer to the workitem
+    KEVENT           EventDone;     // Used for synchronizing a workitem for scheduling. 
+    pWaveReader      PtrWaveReader;   // pointer to the wavereader class.
+    PCHUNKDESCRIPTOR PtrChunkDescriptor;   // chunk descriptor for the chunk, which needs to be filled after file read
+} READWORKER_PARAM;
+typedef READWORKER_PARAM *PREADWORKER_PARAM;
+#include <poppack.h>
+
+__drv_maxIRQL(PASSIVE_LEVEL)
+PAGED_CODE_SEG
+IO_WORKITEM_ROUTINE ReadFrameWorkerCallback;
+
+// Wave Reader class
+
+class CWaveReader
+{
+
+public:
+    HANDLE                      m_FileHandle;       // Wave File handle.
+    WORD                        m_ChannelCount;     // Number of Channels for the stream during stream init
+    WORD                        m_BitsPerSample;    // Number of Bits per sample for the stream during stream init
+    DWORD                       m_SamplesPerSecond; // Number of Sample per second for the stream during stream init
+    bool                        m_Mute;             // Capture Zero buffer if mute
+    OBJECT_ATTRIBUTES           m_objectAttributes; // Used for opening file.
+    WAVEDATAQUEUE               m_WaveDataQueue;    // Big buffer data object and its current state
+    KMUTEX                      m_FileSync;         // Synchronizes file access
+    WAVEHEADER                  m_WaveHeader;
+
+public:
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    CWaveReader();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    ~CWaveReader();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS Init
+    (
+        _In_ PWAVEFORMATEXTENSIBLE WfExt,
+        _In_ PUNICODE_STRING puiFileName
+    );
+
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    VOID ReadWaveData
+    (
+        _Out_writes_bytes_(BufferLength) BYTE  *Buffer,
+        _In_ ULONG      BufferLength
+    );
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    VOID SetMute(_In_ bool Value)
+    {
+        PAGED_CODE();
+
+        m_Mute = Value;
+    }
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    void WaitAllWorkItems();
+
+    // Static allocation totally related to the workitems for reading data from wavefile and putting it to chunk buffer
+    static PDEVICE_OBJECT       m_pDeviceObject;
+    static PREADWORKER_PARAM    m_pWorkItems;
+    PAGED_CODE_SEG
+    static NTSTATUS  InitializeWorkItems(_In_ PDEVICE_OBJECT  DeviceObject);
+
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    static PREADWORKER_PARAM GetNewWorkItem();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    static VOID DestroyWorkItems();
+
+private:
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    VOID ReadWavChunk(PCHUNKDESCRIPTOR PtrChunkDescriptor);
+
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    bool IsAllChunkEmpty();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS OpenWaveFile(PUNICODE_STRING puiFileName);
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS FileClose();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS FileReadHeader();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS FileOpen();
+
+    __drv_maxIRQL(DISPATCH_LEVEL)
+    VOID CopyDataFromRingBuffer
+    (
+        _Out_writes_bytes_(BufferLength) BYTE       *Buffer,
+        _In_                             ULONG      BufferLength
+    );
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS AllocateBigBuffer();
+
+    __drv_maxIRQL(PASSIVE_LEVEL)
+    PAGED_CODE_SEG
+    NTSTATUS ReadHeaderAndFillBuffer();
+
+    friend IO_WORKITEM_ROUTINE ReadFrameWorkerCallback;
+};
+
+