cameradevice.cpp
来自「该BSP是基于PXA270+WINCE的BSP」· C++ 代码 · 共 1,760 行 · 第 1/5 页
CPP
1,760 行
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
//
/**************************************************************************
** Copyright 2000-2004 Intel Corporation. All Rights Reserved.
**
** Portions of the source code contained or described herein and all documents
** related to such source code (Material) are owned by Intel Corporation
** or its suppliers or licensors and is licensed by Microsoft Corporation for distribution.
** Title to the Material remains with Intel Corporation or its suppliers and licensors.
** Use of the Materials is subject to the terms of the Microsoft license agreement which accompanied the Materials.
** No other license under any patent, copyright, trade secret or other intellectual
** property right is granted to or conferred upon you by disclosure or
** delivery of the Materials, either expressly, by implication, inducement,
** estoppel or otherwise
** Some portion of the Materials may be copyrighted by Microsoft Corporation.
**
********************************************************************************/
#include <windows.h>
#include <camera.h>
#include "CameraDriver.h"
#include "PinDriver.h"
#define EXTERN_PROP_VALUES
#include "adapterprops.h"
BOOL
ConvertStringToGuid(
LPCTSTR GuidString,
GUID * Guid
)
{
// ConvertStringToGuid
// this routine converts a string into a GUID and returns TRUE if the
// conversion was successful.
// Local variables.
UINT Data4[8];
int Count;
BOOL Ok = FALSE;
LPWSTR GuidFormat = L"{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}";
DEBUGCHK(Guid != NULL && GuidString != NULL);
__try
{
if (_stscanf(GuidString, GuidFormat, &Guid->Data1,
&Guid->Data2, &Guid->Data3, &Data4[0], &Data4[1], &Data4[2], &Data4[3],
&Data4[4], &Data4[5], &Data4[6], &Data4[7]) == 11)
{
for (Count = 0; Count < (sizeof(Data4) / sizeof(Data4[0])); Count++)
{
Guid->Data4[Count] = (UCHAR) Data4[Count];
}
}
Ok = TRUE;
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
}
return Ok;
}
CCameraDevice::CCameraDevice( )
{
InitializeCriticalSection( &m_csDevice );
m_hStream = NULL;
m_ulCTypes = 0;
memset( m_StrmInstances, 0x0, sizeof ( STREAM_INSTANCES ) * MAX_SUPPORTED_PINS );
memset( m_DevProps, 0x0, sizeof ( DEV_PROPERTY ) * NUM_PROPERTY_ITEMS );
memset( m_CameraHWVideoBuffers, 0x0, sizeof ( CAMERA_DMA_BUFFER_INFO ) * MAX_HW_FRAMES );
memset( &m_CameraHWStillBuffer, 0x0, sizeof ( CAMERA_DMA_BUFFER_INFO ) );
m_ulCurrentFrame = 0;
m_hCameraShutdownComplete = NULL;
m_bCameraHWRunning = false;
m_bNewFrameReady = false;
m_PowerState = D0;
}
CCameraDevice::~CCameraDevice( )
{
if(!IsListEmpty(&m_hCameraOpenHandles))
{
DEBUGMSG(1, (TEXT("~CCameraDevice: there are open handles\r\n")));
}
DeleteCriticalSection( &m_csDevice );
if ( NULL != m_hStream )
{
DeactivateDevice( m_hStream );
}
if (!DeAllocateHWBuffers(VIDEO_CAPTURE_BUFFER) || !DeAllocateHWBuffers(STILL_CAPTURE_BUFFER))
{
RETAILMSG(ZONE_ERROR, ( _T("CAM_DeInit: DeAllocateHWBuffers() failed\r\n") ) );
}
// Shutdown camera sensor h/w
CameraShutdown();
CloseHandle(m_hCameraShutdownComplete);
CameraDeinit();
}
bool
CCameraDevice::Initialize(
PVOID context
)
{
// Initialize Intel PXA27x camera interface h/w
m_pXllpCAMERA = (P_XLLP_Camera_Context_T)CameraInit(context);
if (!m_pXllpCAMERA)
{
RETAILMSG(ZONE_ERROR, ( _T("CAM_Init: CameraInit() failed\r\n") ) );
return false;
}
if (!AllocateHWBuffers(VIDEO_CAPTURE_BUFFER) || !AllocateHWBuffers(STILL_CAPTURE_BUFFER))
{
RETAILMSG(ZONE_ERROR, ( _T("CAM_Init: AllocateHWBuffers() failed\r\n") ) );
return false;
}
dwCameraDriverContext = reinterpret_cast<DWORD>( this );
// This callback function is used to signal the application that the video frame is now available.
pfnCameraHandleVideoFrame = CameraVideoFrameCallback;
// This callback function is used to signal the application that the still image is now available.
pfnCameraHandleStillFrame = CameraStillFrameCallback;
// This event is used to signal the application that the driver has completed the shutdown sequence.
m_hCameraShutdownComplete = CreateEvent(NULL, FALSE, FALSE, CAMERA_SHUTDOWN_COMPLETE);
m_hStream = ActivateDeviceEx( PIN_REG_PATH, NULL, 0, reinterpret_cast<LPVOID>( this ) );
if ( NULL == m_hStream )
{
RETAILMSG(ZONE_ERROR, ( _T("CAM_Init: ActivateDevice on Pin failed\r\n") ) );
return false;
}
m_ulCTypes = 2;
//VideoProcAmp
m_DevProps[ENUM_BRIGHTNESS].ulCurrentValue = BrightnessDefault;
m_DevProps[ENUM_BRIGHTNESS].ulDefaultValue = BrightnessDefault;
m_DevProps[ENUM_BRIGHTNESS].pRangeNStep = &BrightnessRangeAndStep[0];
m_DevProps[ENUM_BRIGHTNESS].ulFlags = CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL;
m_DevProps[ENUM_BRIGHTNESS].ulCapabilities = CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL|CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_BRIGHTNESS].fSetSupported = VideoProcAmpProperties[ENUM_BRIGHTNESS].SetSupported;
m_DevProps[ENUM_BRIGHTNESS].fGetSupported = VideoProcAmpProperties[ENUM_BRIGHTNESS].GetSupported;
m_DevProps[ENUM_BRIGHTNESS].pCsPropValues = &BrightnessValues;
m_DevProps[ENUM_CONTRAST].ulCurrentValue = ContrastDefault;
m_DevProps[ENUM_CONTRAST].ulDefaultValue = ContrastDefault;
m_DevProps[ENUM_CONTRAST].pRangeNStep = &ContrastRangeAndStep[0];
m_DevProps[ENUM_CONTRAST].ulFlags = CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL;
m_DevProps[ENUM_CONTRAST].ulCapabilities = CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL|CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_CONTRAST].fSetSupported = VideoProcAmpProperties[ENUM_CONTRAST].SetSupported;
m_DevProps[ENUM_CONTRAST].fGetSupported = VideoProcAmpProperties[ENUM_CONTRAST].GetSupported;
m_DevProps[ENUM_CONTRAST].pCsPropValues = &ContrastValues;
m_DevProps[ENUM_HUE].ulCurrentValue = HueDefault;
m_DevProps[ENUM_HUE].ulDefaultValue = HueDefault;
m_DevProps[ENUM_HUE].pRangeNStep = &HueRangeAndStep[0];
m_DevProps[ENUM_HUE].ulFlags = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_HUE].ulCapabilities = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_HUE].fSetSupported = VideoProcAmpProperties[ENUM_HUE].SetSupported;
m_DevProps[ENUM_HUE].fGetSupported = VideoProcAmpProperties[ENUM_HUE].GetSupported;
m_DevProps[ENUM_HUE].pCsPropValues = &HueValues;
m_DevProps[ENUM_SATURATION].ulCurrentValue = SaturationDefault;
m_DevProps[ENUM_SATURATION].ulDefaultValue = SaturationDefault;
m_DevProps[ENUM_SATURATION].pRangeNStep = &SaturationRangeAndStep[0];
m_DevProps[ENUM_SATURATION].ulFlags = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_SATURATION].ulCapabilities = CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL|CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_SATURATION].fSetSupported = VideoProcAmpProperties[ENUM_SATURATION].SetSupported;
m_DevProps[ENUM_SATURATION].fGetSupported = VideoProcAmpProperties[ENUM_SATURATION].GetSupported;
m_DevProps[ENUM_SATURATION].pCsPropValues = &SaturationValues;
m_DevProps[ENUM_SHARPNESS].ulCurrentValue = SharpnessDefault;
m_DevProps[ENUM_SHARPNESS].ulDefaultValue = SharpnessDefault;
m_DevProps[ENUM_SHARPNESS].pRangeNStep = &SharpnessRangeAndStep[0];
m_DevProps[ENUM_SHARPNESS].ulFlags = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_SHARPNESS].ulCapabilities = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_SHARPNESS].fSetSupported = VideoProcAmpProperties[ENUM_SHARPNESS].SetSupported;
m_DevProps[ENUM_SHARPNESS].fGetSupported = VideoProcAmpProperties[ENUM_SHARPNESS].GetSupported;
m_DevProps[ENUM_SHARPNESS].pCsPropValues = &SharpnessValues;
m_DevProps[ENUM_GAMMA].ulCurrentValue = GammaDefault;
m_DevProps[ENUM_GAMMA].ulDefaultValue = GammaDefault;
m_DevProps[ENUM_GAMMA].pRangeNStep = &GammaRangeAndStep[0];
m_DevProps[ENUM_GAMMA].ulFlags = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_GAMMA].ulCapabilities = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_GAMMA].fSetSupported = VideoProcAmpProperties[ENUM_GAMMA].SetSupported;
m_DevProps[ENUM_GAMMA].fGetSupported = VideoProcAmpProperties[ENUM_GAMMA].GetSupported;
m_DevProps[ENUM_GAMMA].pCsPropValues = &GammaValues;
m_DevProps[ENUM_COLORENABLE].ulCurrentValue = ColorEnableDefault;
m_DevProps[ENUM_COLORENABLE].ulDefaultValue = ColorEnableDefault;
m_DevProps[ENUM_COLORENABLE].pRangeNStep = &ColorEnableRangeAndStep[0];
m_DevProps[ENUM_COLORENABLE].ulFlags = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_COLORENABLE].ulCapabilities = CSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL|CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_COLORENABLE].fSetSupported = VideoProcAmpProperties[ENUM_COLORENABLE].SetSupported;
m_DevProps[ENUM_COLORENABLE].fGetSupported = VideoProcAmpProperties[ENUM_COLORENABLE].GetSupported;
m_DevProps[ENUM_COLORENABLE].pCsPropValues = &ColorEnableValues;
m_DevProps[ENUM_WHITEBALANCE].ulCurrentValue = WhiteBalanceDefault;
m_DevProps[ENUM_WHITEBALANCE].ulDefaultValue = WhiteBalanceDefault;
m_DevProps[ENUM_WHITEBALANCE].pRangeNStep = &WhiteBalanceRangeAndStep[0];
m_DevProps[ENUM_WHITEBALANCE].ulFlags = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_WHITEBALANCE].ulCapabilities = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_WHITEBALANCE].fSetSupported = VideoProcAmpProperties[ENUM_WHITEBALANCE].SetSupported;
m_DevProps[ENUM_WHITEBALANCE].fGetSupported = VideoProcAmpProperties[ENUM_WHITEBALANCE].GetSupported;
m_DevProps[ENUM_WHITEBALANCE].pCsPropValues = &WhiteBalanceValues;
m_DevProps[ENUM_BACKLIGHT_COMPENSATION].ulCurrentValue = BackLightCompensationDefault;
m_DevProps[ENUM_BACKLIGHT_COMPENSATION].ulDefaultValue = BackLightCompensationDefault;
m_DevProps[ENUM_BACKLIGHT_COMPENSATION].pRangeNStep = &BackLightCompensationRangeAndStep[0];
m_DevProps[ENUM_BACKLIGHT_COMPENSATION].ulFlags = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_BACKLIGHT_COMPENSATION].ulCapabilities = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_BACKLIGHT_COMPENSATION].fSetSupported = VideoProcAmpProperties[ENUM_BACKLIGHT_COMPENSATION].SetSupported;
m_DevProps[ENUM_BACKLIGHT_COMPENSATION].fGetSupported = VideoProcAmpProperties[ENUM_BACKLIGHT_COMPENSATION].GetSupported;
m_DevProps[ENUM_BACKLIGHT_COMPENSATION].pCsPropValues = &BackLightCompensationValues;
m_DevProps[ENUM_GAIN].ulCurrentValue = GainDefault;
m_DevProps[ENUM_GAIN].ulDefaultValue = GainDefault;
m_DevProps[ENUM_GAIN].pRangeNStep = &GainRangeAndStep[0];
m_DevProps[ENUM_GAIN].ulFlags = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_GAIN].ulCapabilities = CSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
m_DevProps[ENUM_GAIN].fSetSupported = VideoProcAmpProperties[ENUM_GAIN].SetSupported;
m_DevProps[ENUM_GAIN].fGetSupported = VideoProcAmpProperties[ENUM_GAIN].GetSupported;
m_DevProps[ENUM_GAIN].pCsPropValues = &GainValues;
//CameraControl
m_DevProps[ENUM_PAN].ulCurrentValue = PanDefault;
m_DevProps[ENUM_PAN].ulDefaultValue = PanDefault;
m_DevProps[ENUM_PAN].pRangeNStep = &PanRangeAndStep[0];
m_DevProps[ENUM_PAN].ulFlags = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
m_DevProps[ENUM_PAN].ulCapabilities = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL|CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
m_DevProps[ENUM_PAN].fSetSupported = VideoProcAmpProperties[ENUM_PAN-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
m_DevProps[ENUM_PAN].fGetSupported = VideoProcAmpProperties[ENUM_PAN-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
m_DevProps[ENUM_PAN].pCsPropValues = &PanValues;
m_DevProps[ENUM_TILT].ulCurrentValue = TiltDefault;
m_DevProps[ENUM_TILT].ulDefaultValue = TiltDefault;
m_DevProps[ENUM_TILT].pRangeNStep = &TiltRangeAndStep[0];
m_DevProps[ENUM_TILT].ulFlags = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
m_DevProps[ENUM_TILT].ulCapabilities = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL|CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
m_DevProps[ENUM_TILT].fSetSupported = VideoProcAmpProperties[ENUM_TILT-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
m_DevProps[ENUM_TILT].fGetSupported = VideoProcAmpProperties[ENUM_TILT-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
m_DevProps[ENUM_TILT].pCsPropValues = &TiltValues;
m_DevProps[ENUM_ROLL].ulCurrentValue = RollDefault;
m_DevProps[ENUM_ROLL].ulDefaultValue = RollDefault;
m_DevProps[ENUM_ROLL].pRangeNStep = &RollRangeAndStep[0];
m_DevProps[ENUM_ROLL].ulFlags = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
m_DevProps[ENUM_ROLL].ulCapabilities = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL|CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
m_DevProps[ENUM_ROLL].fSetSupported = VideoProcAmpProperties[ENUM_ROLL-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
m_DevProps[ENUM_ROLL].fGetSupported = VideoProcAmpProperties[ENUM_ROLL-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
m_DevProps[ENUM_ROLL].pCsPropValues = &RollValues;
m_DevProps[ENUM_ZOOM].ulCurrentValue = ZoomDefault;
m_DevProps[ENUM_ZOOM].ulDefaultValue = ZoomDefault;
m_DevProps[ENUM_ZOOM].pRangeNStep = &ZoomRangeAndStep[0];
m_DevProps[ENUM_ZOOM].ulFlags = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
m_DevProps[ENUM_ZOOM].ulCapabilities = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL|CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
m_DevProps[ENUM_ZOOM].fSetSupported = VideoProcAmpProperties[ENUM_ZOOM-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
m_DevProps[ENUM_ZOOM].fGetSupported = VideoProcAmpProperties[ENUM_ZOOM-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
m_DevProps[ENUM_ZOOM].pCsPropValues = &ZoomValues;
m_DevProps[ENUM_IRIS].ulCurrentValue = IrisDefault;
m_DevProps[ENUM_IRIS].ulDefaultValue = IrisDefault;
m_DevProps[ENUM_IRIS].pRangeNStep = &IrisRangeAndStep[0];
m_DevProps[ENUM_IRIS].ulFlags = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
m_DevProps[ENUM_IRIS].ulCapabilities = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL|CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
m_DevProps[ENUM_IRIS].fSetSupported = VideoProcAmpProperties[ENUM_IRIS-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
m_DevProps[ENUM_IRIS].fGetSupported = VideoProcAmpProperties[ENUM_IRIS-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
m_DevProps[ENUM_IRIS].pCsPropValues = &IrisValues;
m_DevProps[ENUM_EXPOSURE].ulCurrentValue = ExposureDefault;
m_DevProps[ENUM_EXPOSURE].ulDefaultValue = ExposureDefault;
m_DevProps[ENUM_EXPOSURE].pRangeNStep = &ExposureRangeAndStep[0];
m_DevProps[ENUM_EXPOSURE].ulFlags = CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
m_DevProps[ENUM_EXPOSURE].ulCapabilities = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL|CSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
m_DevProps[ENUM_EXPOSURE].fSetSupported = VideoProcAmpProperties[ENUM_EXPOSURE-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
m_DevProps[ENUM_EXPOSURE].fGetSupported = VideoProcAmpProperties[ENUM_EXPOSURE-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
m_DevProps[ENUM_EXPOSURE].pCsPropValues = &ExposureValues;
m_DevProps[ENUM_FOCUS].ulCurrentValue = FocusDefault;
m_DevProps[ENUM_FOCUS].ulDefaultValue = FocusDefault;
m_DevProps[ENUM_FOCUS].pRangeNStep = &FocusRangeAndStep[0];
m_DevProps[ENUM_FOCUS].ulFlags = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;
m_DevProps[ENUM_FOCUS].ulCapabilities = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;
m_DevProps[ENUM_FOCUS].fSetSupported = VideoProcAmpProperties[ENUM_FOCUS-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
m_DevProps[ENUM_FOCUS].fGetSupported = VideoProcAmpProperties[ENUM_FOCUS-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
m_DevProps[ENUM_FOCUS].pCsPropValues = &FocusValues;
m_DevProps[ENUM_FLASH].ulCurrentValue = FlashDefault;
m_DevProps[ENUM_FLASH].ulDefaultValue = FlashDefault;
m_DevProps[ENUM_FLASH].pRangeNStep = &FlashRangeAndStep[0];
m_DevProps[ENUM_FLASH].ulFlags = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;
m_DevProps[ENUM_FLASH].ulCapabilities = CSPROPERTY_CAMERACONTROL_FLAGS_MANUAL;
m_DevProps[ENUM_FLASH].fSetSupported = VideoProcAmpProperties[ENUM_FLASH-NUM_VIDEOPROCAMP_ITEMS].SetSupported;
m_DevProps[ENUM_FLASH].fGetSupported = VideoProcAmpProperties[ENUM_FLASH-NUM_VIDEOPROCAMP_ITEMS].GetSupported;
m_DevProps[ENUM_FLASH].pCsPropValues = &FlashValues;
// Initially, open list is empty
InitializeListHead(&m_hCameraOpenHandles);
// Platform sensor specific init
return CameraInitPdd(reinterpret_cast<LPVOID>(this)) ? true : false;
}
PCAMERAOPENHANDLE
CCameraDevice::BindApplicationProc( )
{
HANDLE hCurrentProc = NULL;
CAMERAOPENHANDLE * pCamOpenHandle = NULL;
PLIST_ENTRY pEntry = m_hCameraOpenHandles.Flink;
DEBUGMSG( ZONE_FUNCTION, ( _T("CAM_Open: Bind application to camera device\r\n") ) );
EnterCriticalSection(&m_csDevice);
hCurrentProc = GetOwnerProcess();
while ( pEntry != &m_hCameraOpenHandles ) {
pCamOpenHandle = CONTAINING_RECORD( pEntry, CAMERAOPENHANDLE, lList);
if(pCamOpenHandle->hCallerProcess == hCurrentProc)
{
⌨️ 快捷键说明
复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?