Updated for "Windows 10 Anniversary Update" (Version 1607)

1 files changed, 966 insertions, 0 deletions

diff --git a/AVStream/avscamera/sys/Device.cpp b/AVStream/avscamera/sys/Device.cpp
new file mode 100644
index 00000000..107cdafc
--- /dev/null
+++ b/AVStream/avscamera/sys/Device.cpp
@@ -0,0 +1,966 @@
+/**************************************************************************
+
+    A/V Stream Camera Sample
+
+    Copyright (c) 2001, Microsoft Corporation.
+
+    File:
+
+        device.cpp
+
+    Abstract:
+
+    This file contains the implementation of CCaptureDevice.
+
+    CCaptureDevice is the base device class object.  It handles basic PnP
+    requests and constructs the filter factories.  
+
+    History:
+
+        created 3/9/2001
+
+**************************************************************************/
+
+#include "Common.h"
+
+/**************************************************************************
+
+    PAGEABLE CODE
+
+**************************************************************************/
+
+/////
+/// Structures...
+//// Profile 0
+static KSCAMERA_PROFILE_MEDIAINFO s_Profile0_PreviewMediaInfo[] =
+{
+    //{ resolution }, {  fps   }, Flags, Data0, Data1, Data2, Data 3
+    { { 1920, 1080 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { { 1280,  720 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { {  640,  360 }, {  30, 1 },     0,     0,     0,     0,     0 },
+};
+
+static KSCAMERA_PROFILE_MEDIAINFO s_Profile0_RecordMediaInfo[] =
+{
+    //{ resolution }, {  fps   }, Flags, Data0, Data1, Data2, Data 3
+    { { 3840, 2160 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { { 1920, 1080 }, { 120, 1 },     0,     0,     0,     0,     0 },
+    { { 1920, 1080 }, {  90, 1 },     0,     0,     0,     0,     0 },
+    { { 1920, 1080 }, {  60, 1 },     0,     0,     0,     0,     0 },
+    { { 1920, 1080 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { { 1280,  720 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { {  640,  360 }, {  30, 1 },     0,     0,     0,     0,     0 },
+};
+
+static KSCAMERA_PROFILE_MEDIAINFO s_Profile0_PhotoMediaInfo[] =
+{
+    //{ resolution }, {  fps   }, Flags, Data0, Data1, Data2, Data 3
+    { { 1920, 1080 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { { 1280,  720 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { {  640,  360 }, {  30, 1 },     0,     0,     0,     0,     0 }
+};
+
+
+//// Profile 1
+static KSCAMERA_PROFILE_MEDIAINFO s_Profile1_PreviewMediaInfo[] =
+{
+    //{ resolution }, {  fps   }, Flags, Data0, Data1, Data2, Data 3
+    { { 1920, 1080 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { { 1280,  720 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { {  640,  360 }, {  30, 1 },     0,     0,     0,     0,     0 }
+};
+
+static KSCAMERA_PROFILE_MEDIAINFO s_Profile1_PhotoMediaInfo[] =
+{
+    //{ resolution }, {  fps   }, Flags, Data0, Data1, Data2, Data 3
+    { { 7680, 4320 }, {   0, 1 },     0,     0,     0,     0,     0 },
+    { { 3840, 2160 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { { 1920, 1080 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { { 1280,  720 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { {  640,  360 }, {  30, 1 },     0,     0,     0,     0,     0 }
+};
+
+//// Profile 2
+static KSCAMERA_PROFILE_MEDIAINFO s_Profile2_PreviewMediaInfo[] =
+{
+    //{ resolution }, {  fps   }, Flags, Data0, Data1, Data2, Data 3
+    { { 1920, 1080 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { { 1280,  720 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { {  640,  360 }, {  30, 1 },     0,     0,     0,     0,     0 }
+};
+
+static KSCAMERA_PROFILE_MEDIAINFO s_Profile2_RecordMediaInfo[] =
+{
+    //{ resolution }, {  fps   }, Flags, Data0, Data1, Data2, Data 3
+    { { 1920, 1080 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { { 1280,  720 }, {  30, 1 },     0,     0,     0,     0,     0 },
+    { {  640,  360 }, {  30, 1 },     0,     0,     0,     0,     0 }
+};
+
+static KSCAMERA_PROFILE_PININFO s_Profile0_PinInfo[] =
+{
+    { {STATIC_PINNAME_VIDEO_PREVIEW}, 0,0, ARRAYSIZE(s_Profile0_PreviewMediaInfo), s_Profile0_PreviewMediaInfo },
+    { {STATIC_PINNAME_VIDEO_CAPTURE}, 0,0, ARRAYSIZE(s_Profile0_RecordMediaInfo),  s_Profile0_RecordMediaInfo },
+    { {STATIC_PINNAME_IMAGE},         0,0, ARRAYSIZE(s_Profile0_PhotoMediaInfo),   s_Profile0_PhotoMediaInfo }
+};
+
+static KSCAMERA_PROFILE_PININFO s_Profile1_PinInfo[] =
+{
+    { {STATIC_PINNAME_VIDEO_PREVIEW}, 0,0, ARRAYSIZE(s_Profile1_PreviewMediaInfo), s_Profile1_PreviewMediaInfo },
+    { {STATIC_PINNAME_IMAGE},         0,0, ARRAYSIZE(s_Profile1_PhotoMediaInfo),   s_Profile1_PhotoMediaInfo }
+};
+
+static KSCAMERA_PROFILE_PININFO s_Profile2_PinInfo[] =
+{
+    { {STATIC_PINNAME_VIDEO_PREVIEW}, 0,0, ARRAYSIZE(s_Profile2_PreviewMediaInfo), s_Profile2_PreviewMediaInfo },
+    { {STATIC_PINNAME_VIDEO_CAPTURE}, 0,0, ARRAYSIZE(s_Profile2_RecordMediaInfo),  s_Profile2_RecordMediaInfo }
+};
+
+static KSCAMERA_PROFILE_INFO s_Profiles[] =
+{
+    { {STATIC_KSCAMERAPROFILE_BalancedVideoAndPhoto}, 0, ARRAYSIZE(s_Profile0_PinInfo), s_Profile0_PinInfo },
+    { {STATIC_KSCAMERAPROFILE_HighQualityPhoto},      0, ARRAYSIZE(s_Profile1_PinInfo), s_Profile1_PinInfo },
+    { {STATIC_KSCAMERAPROFILE_VideoRecording},        0, ARRAYSIZE(s_Profile2_PinInfo), s_Profile2_PinInfo }
+};
+
+// The front camera is concurrent with the rear camera, so the front camera concurrency
+// has the back camera's reference GUID and vice versa.
+static KSCAMERA_PROFILE_CONCURRENCYINFO s_Profile2_ConcurrencyInfoFront[] =
+{
+    { {STATIC_RearCamera_Filter}, 0, 1, &s_Profiles[2] }
+};
+
+static KSCAMERA_PROFILE_CONCURRENCYINFO s_Profile2_ConcurrencyInfoBack[] =
+{
+    { {STATIC_FrontCamera_Filter}, 0, 1, &s_Profiles[2] }
+};
+
+const UINT32 s_ProfileCount = 3;
+
+UINT32
+InitializeDeviceProfiles(
+    _In_    BOOL fFrontCamera,
+    _Outptr_result_maybenull_
+    PKSDEVICE_PROFILE_INFO *ppDeviceProfiles
+)
+{
+    UINT32                  uiProfileCount = 0;
+    PKSDEVICE_PROFILE_INFO  pDeviceProfiles = NULL;
+
+    pDeviceProfiles = (PKSDEVICE_PROFILE_INFO)ExAllocatePoolWithTag( PagedPool, sizeof(KSDEVICE_PROFILE_INFO) * ARRAYSIZE(s_Profiles) , 'fpSC');
+    if( !pDeviceProfiles )
+    {
+        // Can't publish, we're out of memory, silently fail here.
+        *ppDeviceProfiles = nullptr;
+        goto Exit;
+    }
+
+    for (UINT32 i = 0; i < ARRAYSIZE(s_Profiles); i++)
+    {
+        pDeviceProfiles[i].Type = KSDEVICE_PROFILE_TYPE_CAMERA;
+        pDeviceProfiles[i].Size = sizeof(KSDEVICE_PROFILE_INFO);
+        pDeviceProfiles[i].Camera.Info = s_Profiles[i];
+        pDeviceProfiles[i].Camera.Reserved = 0;
+        pDeviceProfiles[i].Camera.ConcurrencyCount = 0;
+        pDeviceProfiles[i].Camera.Concurrency = NULL;
+    }
+
+    pDeviceProfiles[2].Camera.ConcurrencyCount = 1;
+    if (fFrontCamera)
+    {
+        pDeviceProfiles[2].Camera.Concurrency = (PKSCAMERA_PROFILE_CONCURRENCYINFO)&s_Profile2_ConcurrencyInfoFront;
+    }
+    else
+    {
+        pDeviceProfiles[2].Camera.Concurrency = (PKSCAMERA_PROFILE_CONCURRENCYINFO)&s_Profile2_ConcurrencyInfoBack;
+    }
+
+    uiProfileCount = ARRAYSIZE(s_Profiles);
+    *ppDeviceProfiles = pDeviceProfiles;
+    pDeviceProfiles = NULL;
+
+Exit:
+    return uiProfileCount;
+}
+
+#ifdef ALLOC_PRAGMA
+#pragma code_seg("PAGE")
+#endif // ALLOC_PRAGMA
+
+CCaptureDevice::
+CCaptureDevice (
+    _In_ PKSDEVICE Device
+)
+    : m_Device (Device)
+    , m_FilterDescriptorCount(0)
+    , m_Sensor(nullptr)
+    , m_Context(nullptr)
+{
+    PAGED_CODE();
+}
+
+CCaptureDevice::
+~CCaptureDevice()
+{
+    PAGED_CODE();
+
+    if( m_Sensor )
+    {
+        for( size_t i=0; i<m_FilterDescriptorCount; i++ )
+        {
+            SAFE_DELETE( m_Sensor[i] );
+        }
+
+        SAFE_DELETE_ARRAY( m_Sensor );
+    }
+}
+
+NTSTATUS
+CCaptureDevice::
+Initialize()
+{
+    PAGED_CODE();
+
+    m_Sensor = new (NonPagedPoolNx, 'iveD') CSensor *[m_FilterDescriptorCount];
+
+    if( !m_Sensor )
+    {
+        return STATUS_INSUFFICIENT_RESOURCES;
+    }
+    return STATUS_SUCCESS;
+}
+
+ULONG
+CCaptureDevice::
+GetFilterIndex(PKSFILTER Filter)
+{
+    PAGED_CODE();
+    ULONG i;
+
+    for( i=0; i<m_FilterDescriptorCount; i++ )
+    {
+        if( Filter->Descriptor->ReferenceGuid &&
+            IsEqualGUID(*(m_Context[i].Descriptor->ReferenceGuid), *Filter->Descriptor->ReferenceGuid))
+        {
+            break;
+        }
+    }
+
+    //  This is a complete failure.  We really need to bail.
+    NT_ASSERT(i<m_FilterDescriptorCount);
+
+    return i;
+}
+
+NTSTATUS
+CCaptureDevice::
+Prepare()
+{
+    PAGED_CODE();
+
+    NTSTATUS Status = Initialize();
+
+    if( !NT_SUCCESS(Status) )
+    {
+        return Status;
+    }
+
+    //
+    // Add the item to the object bag if we were successful.
+    // Whenever the device goes away, the bag is cleaned up and
+    // we will be freed.
+    //
+    // For backwards compatibility with DirectX 8.0, we must grab
+    // the device mutex before doing this.  For Windows XP, this is
+    // not required, but it is still safe.
+    //
+    PKSDEVICE Device = m_Device;
+    LockDevice Lock(Device);
+
+    Status = KsAddItemToObjectBag (
+                 Device -> Bag,
+                 reinterpret_cast <PVOID> (this),
+                 reinterpret_cast <PFNKSFREE> (CCaptureDevice::Cleanup)
+             );
+
+    if( NT_SUCCESS (Status) )
+    {
+        Device->Context=this;
+    }
+    return Status;
+}
+
+NTSTATUS
+CCaptureDevice::
+DispatchCreate (
+    _In_ PKSDEVICE Device
+)
+
+/*++
+
+Routine Description:
+
+    Create the capture device.  This is the creation dispatch for the
+    capture device.
+
+Arguments:
+
+    Device -
+        The AVStream device being created.
+
+Return Value:
+
+    Success / Failure
+
+--*/
+
+{
+    PAGED_CODE();
+
+    DBG_ENTER("()");
+
+    CCaptureDevice *CapDevice = new (NonPagedPoolNx, 'eviD') CCaptureDevice (Device);
+    if( !CapDevice)
+    {
+        //
+        //  Return failure if we couldn't create the device.
+        //
+        return STATUS_INSUFFICIENT_RESOURCES;
+    }
+
+    NTSTATUS Status = CapDevice->Prepare();
+    if (!NT_SUCCESS (Status))
+    {
+        //  Init failure.
+        delete CapDevice;
+    }
+
+    DBG_LEAVE("()");
+    return Status;
+}
+
+//
+// DispatchStart():
+//
+// This is the Pnp Start dispatch for the capture device.  It simply
+// bridges to PnpStart() in the context of the CCaptureDevice.
+//
+NTSTATUS
+CCaptureDevice::
+DispatchStart (
+    _In_ PKSDEVICE Device,
+    _In_ PIRP Irp,
+    _In_ PCM_RESOURCE_LIST TranslatedResourceList,
+    _In_ PCM_RESOURCE_LIST UntranslatedResourceList
+)
+{
+    PAGED_CODE();
+
+    DBG_ENTER("()");
+
+    NTSTATUS Status =
+        Recast(Device)->
+        PnpStart (
+            TranslatedResourceList,
+            UntranslatedResourceList
+        );
+
+    DBG_LEAVE("()=0x%08X", Status);
+    return Status;
+}
+
+//
+// DispatchStop():
+//
+// This is the Pnp stop dispatch for the capture device.  It simply
+// bridges to PnpStop() in the context of the CCaptureDevice.
+//
+void
+CCaptureDevice::
+DispatchStop (
+    _In_ PKSDEVICE Device,
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+
+    DBG_ENTER("()");
+    Recast(Device)->PnpStop(Irp);
+    DBG_LEAVE("()");
+}
+
+NTSTATUS
+CCaptureDevice::
+DispatchPostStart(
+    _In_ PKSDEVICE Device
+)
+{
+    PAGED_CODE();
+
+    DBG_ENTER("()");
+
+    NTSTATUS Status =
+        Recast(Device)->PnpPostStart();
+
+    DBG_LEAVE("()=0x%08X", Status);
+    return Status;
+}
+
+NTSTATUS
+CCaptureDevice::
+DispatchQueryStop(
+    _In_ PKSDEVICE Device,
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+
+    DBG_ENTER("()");
+
+    NTSTATUS Status =
+        Recast(Device)->PnpQueryStop(Irp);
+
+    DBG_LEAVE("()=0x%08X", Status);
+    return Status;
+}
+
+void
+CCaptureDevice::
+DispatchCancelStop(
+    _In_ PKSDEVICE Device,
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+
+    DBG_ENTER("()");
+    Recast(Device)->PnpCancelStop(Irp);
+    DBG_LEAVE("()");
+}
+
+NTSTATUS
+CCaptureDevice::
+DispatchQueryRemove(
+    _In_ PKSDEVICE Device,
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+
+    DBG_ENTER("()");
+
+    NTSTATUS Status =
+        Recast(Device)->PnpQueryRemove(Irp);
+
+    DBG_LEAVE("()=0x%08X", Status);
+    return Status;
+}
+
+void
+CCaptureDevice::
+DispatchCancelRemove(
+    _In_ PKSDEVICE Device,
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+
+    DBG_ENTER("()");
+    Recast(Device)->PnpCancelRemove(Irp);
+    DBG_LEAVE("()");
+}
+
+void
+CCaptureDevice::
+DispatchRemove(
+    _In_ PKSDEVICE Device,
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+
+    DBG_ENTER("()");
+    Recast(Device)->PnpRemove(Irp);
+    DBG_LEAVE("()");
+}
+
+void
+CCaptureDevice::
+DispatchSurpriseRemoval(
+    _In_ PKSDEVICE Device,
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+
+    DBG_ENTER("()");
+    Recast(Device)->PnpSurpriseRemoval(Irp);
+    DBG_LEAVE("()");
+}
+
+NTSTATUS
+CCaptureDevice::
+DispatchQueryCapabilities(
+    _In_ PKSDEVICE Device,
+    _In_ PIRP Irp,
+    _Inout_ PDEVICE_CAPABILITIES Capabilities
+)
+{
+    PAGED_CODE();
+
+    DBG_ENTER("()");
+
+    NTSTATUS Status =
+        Recast(Device)->
+        PnpQueryCapabilities( Irp, Capabilities );
+
+    DBG_LEAVE("()=0x%08X", Status);
+    return Status;
+}
+
+
+//  Make Power callbacks non-pageable.
+#ifdef ALLOC_PRAGMA
+#pragma code_seg()
+#endif // ALLOC_PRAGMA
+
+NTSTATUS
+CCaptureDevice::
+DispatchQueryPower(
+    _In_ PKSDEVICE Device,
+    _In_ PIRP Irp,
+    _In_ DEVICE_POWER_STATE DeviceTo,
+    _In_ DEVICE_POWER_STATE DeviceFrom,
+    _In_ SYSTEM_POWER_STATE SystemTo,
+    _In_ SYSTEM_POWER_STATE SystemFrom,
+    _In_ POWER_ACTION Action
+)
+{
+    //  If this device supports the the DO_POWER_INRUSH flag, this function
+    //  can be called at DISPATCH.
+
+    DBG_ENTER("()");
+    NTSTATUS Status =
+        Recast(Device)->
+        PnpQueryPower(
+            Irp,
+            DeviceTo,
+            DeviceFrom,
+            SystemTo,
+            SystemFrom,
+            Action );
+
+    DBG_LEAVE("()=0x%08X", Status);
+    return Status;
+}
+
+void
+CCaptureDevice::
+DispatchSetPower(
+    _In_ PKSDEVICE Device,
+    _In_ PIRP Irp,
+    _In_ DEVICE_POWER_STATE To,
+    _In_ DEVICE_POWER_STATE From
+)
+{
+    //  If this device supports the the DO_POWER_INRUSH flag, this function
+    //  can be called at DISPATCH.
+
+    DBG_ENTER("()");
+    Recast(Device)->
+    PnpSetPower( Irp, To, From );
+    DBG_LEAVE("()");
+}
+
+#ifdef ALLOC_PRAGMA
+#pragma code_seg("PAGE")
+#endif // ALLOC_PRAGMA
+
+NTSTATUS
+CCaptureDevice::
+DispatchQueryInterface(
+    _In_ PKSDEVICE Device,
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+
+    DBG_ENTER("()");
+
+    NTSTATUS Status =
+        Recast(Device)->
+        PnpQueryInterface(Irp);
+
+    DBG_LEAVE("()=0x%08X", Status);
+    return Status;
+}
+
+
+/*************************************************/
+
+
+NTSTATUS
+CCaptureDevice::
+PnpStart (
+    _In_ PCM_RESOURCE_LIST TranslatedResourceList,
+    _In_ PCM_RESOURCE_LIST UntranslatedResourceList
+)
+
+/*++
+
+Routine Description:
+
+    Called at Pnp start.  We start up our  hardware simulation.
+
+Arguments:
+
+    TranslatedResourceList -
+        The translated resource list from Pnp
+
+    UntranslatedResourceList -
+        The untranslated resource list from Pnp
+
+Return Value:
+
+    Success / Failure
+
+--*/
+
+{
+
+    PAGED_CODE();
+
+    //
+    // Normally, we'd do things here like parsing the resource lists and
+    // connecting our interrupt.  Since this is a simulation, there isn't
+    // much to parse.  The parsing and connection should be the same as
+    // any WDM driver.  The sections that will differ are illustrated below
+    // in setting up a simulated DMA.
+    //
+
+    NTSTATUS Status = STATUS_SUCCESS;
+
+    //
+    // By PnP, it's possible to receive multiple starts without an intervening
+    // stop (to reevaluate resources, for example).  Thus, we only perform
+    // creations of the simulation on the initial start and ignore any
+    // subsequent start.  Hardware drivers with resources should evaluate
+    // resources and make changes on 2nd start.
+    //
+    // Walk the list of descriptors and enumerate the h/w sims described.
+    //
+
+    if (!m_Device -> Started)
+    {
+        // Create the Filter for the device
+        for( size_t i=0; i<m_FilterDescriptorCount; i++ )
+        {
+            PKSFILTERFACTORY FilterFactory=nullptr;
+            IFFAILED_EXIT(
+                KsCreateFilterFactory( m_Device->FunctionalDeviceObject,
+                                       m_Context[i].Descriptor,
+                                       m_Context[i].Name,
+                                       NULL,
+                                       KSCREATE_ITEM_FREEONSTOP,
+                                       NULL,
+                                       NULL,
+                                       &FilterFactory )
+            );
+
+            // Set primary camera to its interface, this allows device to be queried by GUID
+            if( FilterFactory )
+            {
+                PKSDEVICE_PROFILE_INFO pDeviceProfiles = nullptr;
+                UINT32 uiProfileCount = 0;
+                PUNICODE_STRING SymbolicLinkName = KsFilterFactoryGetSymbolicLink(FilterFactory);
+                BOOL fFrontCamera = FALSE;
+                ACPI_PLD_V2_BUFFER pld = {0};
+                pld.Revision = 2;
+                pld.Panel = m_Context[i].AcpiPosition;
+                pld.Rotation = m_Context[i].AcpiRotation;
+                static
+                const
+                GUID FFC_Filter = {STATIC_FrontCamera_Filter};
+
+                IFFAILED_EXIT(
+                    IoSetDeviceInterfacePropertyData(SymbolicLinkName,
+                                                     &DEVPKEY_Device_PhysicalDeviceLocation,
+                                                     LOCALE_NEUTRAL,
+                                                     PLUGPLAY_PROPERTY_PERSISTENT,
+                                                     DEVPROP_TYPE_BINARY,
+                                                     sizeof(ACPI_PLD_BUFFER),
+                                                     (PVOID)&pld)
+                );
+
+                if( m_Context[i].Descriptor->ReferenceGuid &&
+                    IsEqualGUID(*(m_Context[i].Descriptor->ReferenceGuid), FFC_Filter))
+                {
+                    fFrontCamera = TRUE;
+                }
+
+                // Publish our profile here.
+                uiProfileCount = InitializeDeviceProfiles(fFrontCamera, &pDeviceProfiles);
+                if( uiProfileCount > 0 )
+                {
+                    if( NT_SUCCESS(KsInitializeDeviceProfile(FilterFactory)) )
+                    {
+                        for( UINT32 j=0; j<uiProfileCount; j++ )
+                        {
+                            if( !NT_SUCCESS(KsPublishDeviceProfile(FilterFactory, &pDeviceProfiles[j])) )
+                            {
+                                // Bail...
+                                break;
+                            }
+                        }
+                        if( !NT_SUCCESS(KsPersistDeviceProfile(FilterFactory)) )
+                        {
+                            // Trace here?
+                        }
+                    }
+
+                    ExFreePool(pDeviceProfiles);
+                    pDeviceProfiles = NULL;
+                }
+            }
+
+            //  On a real device this object would be constructed whenever the sensor hardware is ready...
+            m_Sensor[i] = CreateSensor( m_Context[i].Descriptor );
+            if( !m_Sensor[i] )
+            {
+                Status = STATUS_INSUFFICIENT_RESOURCES;
+                break;
+            }
+
+            IFFAILED_EXIT(m_Sensor[i]->Initialize());
+
+            m_Sensor[i]->SetMountingOrientation( m_Context[i].AcpiRotation );
+        }
+    }
+
+done:
+    if( !NT_SUCCESS(Status) )
+    {
+        //  Free any sensor objects we created during this failed attempt.
+        for( size_t i=0; i<m_FilterDescriptorCount; i++ )
+        {
+            SAFE_DELETE( m_Sensor[i] );
+        }
+    }
+    return Status;
+}
+
+CSensor *
+CCaptureDevice::
+CreateSensor(
+    _In_    const KSFILTER_DESCRIPTOR  *Descriptors
+)
+{
+    PAGED_CODE();
+
+    return new (NonPagedPoolNx, 'sneS') CSensorSimulation( this, Descriptors );
+}
+
+PDEVICE_OBJECT
+CCaptureDevice::
+GetDeviceObject()
+/*++
+
+Routine Description:
+
+    Return the pointer to the FDO for our device.
+
+Arguments:
+
+    [none]
+
+Return Value:
+
+    PDEVICE_OBJECT
+
+--*/
+{
+    PAGED_CODE();
+
+    return m_Device->FunctionalDeviceObject;
+}
+
+/*************************************************/
+
+
+void
+CCaptureDevice::
+PnpStop (
+    _In_ PIRP Irp
+)
+
+/*++
+
+Routine Description:
+
+    This is the pnp stop dispatch for the capture device.  It releases any
+    adapter object previously allocated by IoGetDmaAdapter during Pnp Start.
+
+Arguments:
+
+    None
+
+Return Value:
+
+    None
+
+--*/
+
+{
+    UNREFERENCED_PARAMETER(Irp);
+    PAGED_CODE();
+
+    if (m_DmaAdapterObject)
+    {
+        //
+        // Return the DMA adapter back to the system.
+        //
+        m_DmaAdapterObject -> DmaOperations ->
+        PutDmaAdapter (m_DmaAdapterObject);
+
+        m_DmaAdapterObject = NULL;
+    }
+}
+
+NTSTATUS
+CCaptureDevice::
+PnpPostStart()
+{
+    PAGED_CODE();
+    return STATUS_SUCCESS;
+}
+
+NTSTATUS
+CCaptureDevice::
+PnpQueryStop(
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+    UNREFERENCED_PARAMETER(Irp);
+    return STATUS_SUCCESS;
+}
+
+void
+CCaptureDevice::
+PnpCancelStop(
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+    UNREFERENCED_PARAMETER(Irp);
+}
+
+NTSTATUS
+CCaptureDevice::
+PnpQueryRemove(
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+    UNREFERENCED_PARAMETER(Irp);
+    return STATUS_SUCCESS;
+}
+
+void
+CCaptureDevice::
+PnpCancelRemove(
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+    UNREFERENCED_PARAMETER(Irp);
+}
+
+void
+CCaptureDevice::
+PnpRemove(
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+    UNREFERENCED_PARAMETER(Irp);
+}
+
+void
+CCaptureDevice::
+PnpSurpriseRemoval(
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+    UNREFERENCED_PARAMETER(Irp);
+}
+
+NTSTATUS
+CCaptureDevice::
+PnpQueryCapabilities(
+    _In_ PIRP Irp,
+    _Inout_ PDEVICE_CAPABILITIES Capabilities
+)
+{
+    PAGED_CODE();
+    UNREFERENCED_PARAMETER(Irp);
+    UNREFERENCED_PARAMETER(Capabilities);
+    return STATUS_SUCCESS;
+}
+
+//  Make Power callbacks non-pageable.
+#ifdef ALLOC_PRAGMA
+#pragma code_seg()
+#endif // ALLOC_PRAGMA
+
+NTSTATUS
+CCaptureDevice::
+PnpQueryPower(
+    _In_ PIRP Irp,
+    _In_ DEVICE_POWER_STATE DeviceTo,
+    _In_ DEVICE_POWER_STATE DeviceFrom,
+    _In_ SYSTEM_POWER_STATE SystemTo,
+    _In_ SYSTEM_POWER_STATE SystemFrom,
+    _In_ POWER_ACTION Action
+)
+{
+    UNREFERENCED_PARAMETER(Irp);
+    UNREFERENCED_PARAMETER(DeviceTo);
+    UNREFERENCED_PARAMETER(DeviceFrom);
+    UNREFERENCED_PARAMETER(SystemTo);
+    UNREFERENCED_PARAMETER(SystemFrom);
+    UNREFERENCED_PARAMETER(Action);
+    return STATUS_SUCCESS;
+}
+
+void
+CCaptureDevice::
+PnpSetPower(
+    _In_ PIRP Irp,
+    _In_ DEVICE_POWER_STATE To,
+    _In_ DEVICE_POWER_STATE From
+)
+{
+    UNREFERENCED_PARAMETER(Irp);
+    UNREFERENCED_PARAMETER(To);
+    UNREFERENCED_PARAMETER(From);
+}
+
+#ifdef ALLOC_PRAGMA
+#pragma code_seg("PAGE")
+#endif // ALLOC_PRAGMA
+
+NTSTATUS
+CCaptureDevice::
+PnpQueryInterface(
+    _In_ PIRP Irp
+)
+{
+    PAGED_CODE();
+    UNREFERENCED_PARAMETER(Irp);
+    return STATUS_SUCCESS;
+}
+
+/*************************************************/
+