cameradriver.h

三星2440原版bsp

//
// 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.
//
#ifndef __NULL_DD
#define __NULL_DD

#include <windows.h>
#include "Cs.h"
#include "Csmedia.h"
#include "image_cfg.h"
//#include "drv_glob.h"
#include "i2c.h"
#include "camif.h"
#include "cam.h"
#include "helper.h"
#include <camera.h>
#include <ceddk.h>

#ifndef DEBUG
#define DEBUG                // always turn on debug output
#endif // DEBUG

#ifdef DEBUG

#define DEBUGMASK(bit)       (1 << (bit))

#define MASK_ERROR           DEBUGMASK(0)
#define MASK_WARN            DEBUGMASK(1)
#define MASK_INIT            DEBUGMASK(2)
#define MASK_FUNCTION        DEBUGMASK(3)
#define MASK_IOCTL           DEBUGMASK(4)
#define MASK_DEVICE          DEBUGMASK(5)

#define PIN_REG_PATH         TEXT("Software\\Microsoft\\DirectX\\DirectShow\\Capture")

#ifdef CAMINTERFACE
DBGPARAM dpCurSettings = {
    _T("Null_CAM"), 
    {
        _T("Errors"), _T("Warnings"), _T("Init"), _T("Function"), 
        _T("Ioctl"), _T("Device"), _T("Activity"), _T(""),
        _T(""),_T(""),_T(""),_T(""),
        _T(""),_T(""),_T(""),_T("") 
    },
    MASK_ERROR | MASK_WARN | MASK_INIT 
}; 
#else
extern DBGPARAM dpCurSettings;
#endif

#define ZONE_ERROR           DEBUGZONE(0)
#define ZONE_WARN            DEBUGZONE(1)
#define ZONE_INIT            DEBUGZONE(2)
#define ZONE_FUNCTION        DEBUGZONE(3)
#define ZONE_IOCTL           DEBUGZONE(4)
#define ZONE_DEVICE          DEBUGZONE(5)

#endif

#define dim(x)               (sizeof(x) / sizeof(x[0]))

#define SAFEDELETE( pointer ) \
    if ( NULL != pointer )    \
    {                         \
        delete pointer;       \
        pointer = NULL;       \
    }

#define MAX_SUPPORTED_PINS        3
#define MAX_PINNAME_LENGTH       10
#define MAX_VIDEO_FORMAT         10
#define NUM_VIDEOPROCAMP_ITEMS   10
#define NUM_CAMERACONTROL_ITEMS   8
#define NUM_PROPERTY_ITEMS       NUM_VIDEOPROCAMP_ITEMS + NUM_CAMERACONTROL_ITEMS

#define UINT	unsigned int
// CAPTURE and STILL are required pin types. PREVIEW is optional, so list it last.
enum
{
    CAPTURE = 0,
    STILL,
    PREVIEW
};

static const WCHAR g_wszPinNames[MAX_SUPPORTED_PINS][MAX_PINNAME_LENGTH] = { L"Capture"
                                                                            ,L"Still"
                                                                            ,L"Preview"
                                                                            };

static const WCHAR g_wszPinDeviceNames[MAX_SUPPORTED_PINS][MAX_PINNAME_LENGTH] = {L"PIN1:",
                                                                                  L"PIN1:",
                                                                                  L"PIN1:"};

typedef struct _Supported_Video_Formats
{
    GUID                categoryGUID;
    ULONG               ulAvailFormats;
    PCS_DATARANGE_VIDEO pCsDataRangeVideo[ MAX_VIDEO_FORMAT ];
} PINVIDEOFORMAT, * PPINVIDEOFORMAT;

typedef struct _Dev_Property 
{
    ULONG                     ulDefaultValue;
    ULONG                     ulCurrentValue;
    ULONG                     ulFlags;
    ULONG                     ulCapabilities;
    PCSPROPERTY_VALUES        pCsPropValues;
    PCSPROPERTY_STEPPING_LONG pRangeNStep;
    BOOL                      fGetSupported;
    BOOL                      fSetSupported;
} DEV_PROPERTY, * PDEV_PROPERTY;

typedef struct _Video_Control_Caps
{
    ULONG ulVideoControlCaps;
} VIDCONTROLCAPS, *PVIDCONTROLCAPS;

class CPinDevice;

typedef struct _StreamInstances
{
    ULONG        ulCInstances;
    CSSTATE      CsPrevState;
    CPinDevice * pPinDev;
} STREAM_INSTANCES, * PSTREAM_INSTANCES;

typedef struct _tagMsgQueueData
{
    	CS_MSGQUEUE_HEADER    CsMsgQueueHeader;
    	PCS_STREAM_DESCRIPTOR pStreamDescriptor;
	DWORD 					dwInfo;
} CCS_MSGQUEUE_BUFFER, * PCCS_MSGQUEUE_BUFFER;
typedef class CCameraDevice 
{
public:
    CCameraDevice( );

    ~CCameraDevice( );
    
    bool
    Initialize(
        PVOID context
        );

    bool
    BindApplicationProc(
        HANDLE
        );

    bool
    UnBindApplicationProc( );
    
    DWORD
    AdapterHandlePinRequests(
        __in_bcount(InBufLen) PUCHAR pInBuf,
        DWORD  InBufLen,
        __out_bcount(OutBufLen) PUCHAR pOutBuf,
        DWORD  OutBufLen,
        PDWORD pdwBytesTransferred
        );

    DWORD
    AdapterHandleVersion(
        __out_bcount(OutBufLen) PUCHAR pOutBuf,
        DWORD  OutBufLen,
        PDWORD pdwBytesTransferred
        );        

    DWORD
    AdapterHandleVidProcAmpRequests(
        __in_bcount(InBufLen) PUCHAR pInBuf,
        DWORD  InBufLen,
        __out_bcount(OutBufLen) PUCHAR pOutBuf,
        DWORD  OutBufLen,
        PDWORD pdwBytesTransferred 
        );

    DWORD
    AdapterHandleCamControlRequests(
        __in_bcount(InBufLen) PUCHAR pInBuf,
        DWORD  InBufLen,
        __out_bcount(OutBufLen) PUCHAR pOutBuf,
        DWORD  OutBufLen,
        PDWORD pdwBytesTransferred
        );

    DWORD
    AdapterHandleCompressionRequests(
        __in_bcount(InBufLen) PUCHAR pInBuf,
        DWORD  InBufLen,
        __out_bcount(OutBufLen) PUCHAR pOutBuf,
        DWORD  OutBufLen,
        PDWORD pdwBytesTransferred
        );

    DWORD
    AdapterHandleVideoControlRequests(
        __in_bcount(InBufLen) PUCHAR pInBuf,
        DWORD  InBufLen,
        __out_bcount(OutBufLen) PUCHAR pOutBuf,
        DWORD  OutBufLen,
        PDWORD pdwBytesTransferred
        );
    
    DWORD
    AdapterHandleDroppedFramesRequests(
        __in_bcount(InBufLen) PUCHAR pInBuf,
        DWORD  InBufLen,
        __out_bcount(OutBufLen) PUCHAR pOutBuf,
        DWORD  OutBufLen,
        PDWORD pdwBytesTransferred
        );
    
    LPVOID
    ValidateBuffer(
        __in_bcount(ulActualBufLen) LPVOID  lpBuff,
        ULONG   ulActualBufLen,
        ULONG   ulExpectedBuffLen,
        DWORD * dwError
        );
    
    bool
    AdapterCompareFormat(
        const ULONG                 ulPinId,
        const PCS_DATARANGE_VIDEO   pCsDataRangeVideoToCompare,
        PCS_DATARANGE_VIDEO       * ppCsDataRangeVideoMatched,
        bool                        fDetailedComparison
        );

    bool
    AdapterCompareFormat(
        const ULONG                            ulPinId,
        const PCS_DATAFORMAT_VIDEOINFOHEADER   pCsDataRangeVideoToCompare,
        PCS_DATARANGE_VIDEO                  * ppCsDataRangeVideoMatched,
        bool                                   fDetailedComparison
        );

    bool
    IsValidPin(
        ULONG ulPinId
        );

    bool
    GetPinFormat(
        ULONG                 ulPinId,
        ULONG                 ulIndex,
        PCS_DATARANGE_VIDEO * ppCsDataRangeVid
        );

    bool
    GetZoom(
        PULONG pulZoom 
        );

    bool
    GetBrightness(
        PULONG pulBrightness
        );

    bool
    IncrCInstances(
        ULONG        ulPinId,
        CPinDevice * pPinDev
        );

    bool
    DecrCInstances(
        ULONG ulPinId
        );

    bool
    PauseCaptureAndPreview( );

    bool
    RevertCaptureAndPreviewState( );
    void GetCurrentCBufferAddress(DWORD *pdwYAddress,
									DWORD *pdwCBAddress, DWORD *pdwCRAddress);
	void GetCurrentPBufferAddress(DWORD *pdwPAddress);

	void CameraDisable();
	void CameraEnable();

private:
    void
    GetBasicSupportInfo(
        __out_bcount(OutBufLen) PUCHAR        pOutBuf,
        DWORD         OutBufLen,
        PDWORD        pdwBytesTransferred,
        PDEV_PROPERTY pDevProp,
        PDWORD        pdwError
        );

    void
    GetDefaultValues(
        __out_bcount(OutBufLen) PUCHAR        pOutBuf,
        DWORD         OutBufLen,
        PDWORD        pdwBytesTransferred,
        PDEV_PROPERTY pDevProp,
        PDWORD        pdwError
        );

    bool
    AdapterCompareGUIDsAndFormatSize(
        const PCSDATARANGE DataRange1,
        const PCSDATARANGE DataRange2
        );

    CRITICAL_SECTION m_csDevice;        
    HANDLE           m_hStream;                        // Handle to the corresponding stream sub-device
    HANDLE           m_hCallerProcess;
    
    PINVIDEOFORMAT   m_PinVideoFormat[MAX_SUPPORTED_PINS];
    VIDCONTROLCAPS   m_PinVideoCaps[MAX_SUPPORTED_PINS];
    ULONG            m_ulCTypes;
    STREAM_INSTANCES m_StrmInstances[MAX_SUPPORTED_PINS];

    ULONG            m_ulPropSetSupported;             // Number of property item supported.
    CSPROPERTY_SET   m_VideoProcAmpSet;                // This is also the beginning of the property set table.
    CSPROPERTY_SET   m_CameraControlSet;

    //
    // Property items of what device supports 
    //
    CSPROPERTY_ITEM  m_VideoProcAmpItems[NUM_VIDEOPROCAMP_ITEMS];
    CSPROPERTY_ITEM  m_CameraControlItems[NUM_CAMERACONTROL_ITEMS];

    DEV_PROPERTY     m_DevProps[NUM_PROPERTY_ITEMS];
private:
	HANDLE          	m_hI2C;   	// I2C Bus Driver
	I2C_FASTCALL    	m_fc;     // I2C Fastcall driver-to-driver entrypoints

	PCIS_CONTEXT 	m_pCISContext;
	CAMINFO 		m_sCAMINFO;

	UINT 			m_nYAddress;
	UINT			m_nCBAddress;
	UINT 			m_nCRAddress;
	UINT			m_nRGBAddress;

	HANDLE 			m_hCameraEvent;
	HANDLE 			m_hCameraThread;

	///DWORD	m_dwDisplayTimeout;

	HRESULT CAMInitialize();	//To initialize the camera device
	BOOL InitInterruptThread();
	void Display_Cam_Image(UINT pos_x, UINT pos_y, UINT size_x, UINT size_y, UCHAR port);
	void Display_Cam_Image2(UINT size_x, UINT size_y, UCHAR port);

	void Buffer_codec_info_update();
	void Buffer_preview_info_update();
	HRESULT Virtual_Alloc();		//Map the SMDK2440X registers
	BOOL CamGpioInit();
	void Camera_Clock(unsigned char divide);

	BOOL CamClockOn(BOOL bOnOff);
	void CAM_WriteBlock(void);
	DWORD HW_WriteRegisters(PUCHAR pBuff, UCHAR StartReg, DWORD nRegs);
    DWORD HW_ReadRegisters(PUCHAR pBuff, UCHAR StartReg, DWORD nRegs);
	void Camera_Module_Reset();
	void CAM_IF_Reset();
	BOOL Cam_Init();
	void CalculatePrescalerRatioShift(unsigned int SrcSize, unsigned int DstSize,
		unsigned int *ratio,unsigned int *shift);
	void CalculateBurstSize(unsigned int hSize, unsigned int *mainBurstSize,
		unsigned int *remainedBurstSize);
	static DWORD WINAPI CameraCaptureThread(LPVOID lpParam);
	DWORD CameraThreadProc(LPVOID lpParam);

public:
	volatile S3C2440X_IOPORT_REG 	*m_rS2440IOP;
	volatile S3C2440X_CAM_REG 	*m_rS2440CAM;
	volatile S3C2440X_INTR_REG 	*m_rS2440INT;
	volatile S3C2440X_CLKPWR_REG *m_rS2440PWR;
	volatile S3C2440X_LCD_REG  	*m_rS2440LCD;


	DWORD 						m_dwFrameCount;
	static HANDLE 				m_hCodecData;
	static HANDLE					m_hPrevData;

	CRITICAL_SECTION			m_csIST;

	// PingPong Memory Physical Address
	PHYSICAL_ADDRESS 			m_lnPhysPreviewAddr;
	PHYSICAL_ADDRESS 			m_lnPhysCodecAddr;

	void Samsung_camcoder(UCHAR *pBufOut);
	void Samsung_camcoder_pr(UCHAR *pBufOut);
	void Camif_Capture(int cap_a, int cap_b);
	void Copy_Cam_Image(UCHAR *pBufOut, UINT size_x, UINT size_y, UCHAR port);
	void CamInit(UINT CoDstWidth, UINT CoDstHeight, UINT PrDstWidth, UINT PrDstHeight,
		UINT WinHorOffset, UINT WinVerOffset,  UINT CoFrameBuffer, UINT PrFrameBuffer);

} CAMERADEVICE, * PCAMERADEVICE;

typedef struct CCameraOpenHandle
{
    PCAMERADEVICE pCamDevice;
} CAMERAOPENHANDLE, * PCAMERAOPENHANDLE;

#endif // __NULL_DD