?? camera.cpp
字號(hào):
#include <windows.h>
#include <nkintr.h>
#include <oalintr.h>
//#include <p2.h>
#include <pm.h>
#include "pmplatform.h"
#include "s2440.h"
#include "camif.h"
#include "camera.h"
#define MSG_EN_1 0
#define MSG_EN_2 0
//#define RETAILMSG(a,b) RETAILMSG(1,b)
#define DOTNET_DRIVER 1 // 0:PPC, 1:CE.NET
#define CAPTURE_TIME 30
#define DISPLAY_SCHEDULE 0
#define U8 unsigned char
#define U16 unsigned short
#define U32 unsigned int
#define PORT_A 1
#define PORT_B 0
// Added 25 May 2004 for debug
#ifdef DEBUG
#define ZONE_INIT 1
#define ZONE_THREAD 1
#endif
#define YCbCrtoR(Y,Cb,Cr) (1000*Y + 1540*(Cr-128))/1000
#define YCbCrtoG(Y,Cb,Cr) (1000*Y - 459*(Cb-128) - 183*(Cr-128))/1000
#define YCbCrtoB(Y,Cb,Cr) (1000*Y + 1856*(Cb-128))/1000
volatile IOPreg *s2440IOP = (IOPreg *)IOP_BASE;
volatile CAMreg *s2440CAM = (CAMreg *)CAM_BASE;
volatile INTreg *s2440INT = (INTreg *)INT_BASE;
volatile CLKPWRreg *s2440PWR = (CLKPWRreg *)CLKPWR_BASE;
volatile IICreg *s2440IIC = (IICreg *)IIC_BASE;;
unsigned int DisplayTime = INFINITE;
//unsigned char DisplayEnable=0;
unsigned char buffer_num=0xff; // ping pong buffer
unsigned char image_size = 2; // 1: QCIF, 2:CIF (default)
//#define DRIVER_PREVIEW_ENABLE 2 // 0: onTimeTek, 1: Preview, 2:Samsung Camcorder
unsigned char DRIVER_PREVIEW_ENABLE = 2; // 0: onTimeTek, 1: Preview, 2:Samsung Camcorder
unsigned int frame_count=0; // for MPEG4
DWORD Tick_GET_FRAME_CUR;
DWORD Tick_GET_FRAME_PREV;
DWORD Tick_COPY_FRAME;
HANDLE CameraThread;
HANDLE CameraEvent;
static BOOL mInitialized = FALSE;
unsigned char codec_flag=0;
unsigned char rgb_flag=0;
unsigned int y_address,cb_address,cr_address;
unsigned int rgb_address;
extern void Camera_Initialize();
extern volatile IOPreg *s2440IOP;
extern volatile IICreg *s2440IIC;
extern void ReadCameraProductID(void);
void Virtual_Alloc(); // Virtual allocation
void Camera_Clock(unsigned char divide); // set default value
void Camif_Capture(int cap_a, int cap_b); // A port, B port
void Display_Cam_Image(U32 pos_x, U32 pos_y, U32 size_x, U32 size_y, U8 port);
void Copy_Cam_Image(U8 * pBufOut, U32 size_x, U32 size_y, U8 port);
void Samsung_camcoder(U8 *pBufOut);
void Samsung_camcoder_pr(U8 *pBufOut);
void Buffer_codec_info_update();
void Buffer_preview_info_update();
BOOL Cam_Init();
BOOL CamClockOn(BOOL bOnOff);
//void CamCaptureStart(U32 mode);
void CamInit(U32 CoDstWidth, U32 CoDstHeight, U32 PrDstWidth, U32 PrDstHeight,
U32 WinHorOffset, U32 WinVerOffset, U32 CoFrameBuffer, U32 PrFrameBuffer);
DWORD CameraCaptureThread(void);
BOOL InitInterruptThread();
CEDEVICE_POWER_STATE m_Dx;
#ifdef DEBUG
DBGPARAM dpCurSettings = {
TEXT("CAMERA"), {
TEXT("0"),TEXT("1"),TEXT("2"),TEXT("3"),
TEXT("4"),TEXT("5"),TEXT("6"),TEXT("7"),
TEXT("8"),TEXT("9"),TEXT("10"),TEXT("11"),
TEXT("12"),TEXT("Function"),TEXT("Init"),TEXT("Error")},
0x8000 // Errors only, by default
};
#endif
static void Delay(USHORT count)
{
volatile int i, j = 0;
volatile static int loop = S2440FCLK/100000;
for(;count > 0;count--)
for(i=0;i < loop; i++) { j++; }
}
/********************************************************
CalculateBurstSize - Calculate the busrt lengths
Description:
- dstHSize: the number of the byte of H Size.
*/
void CalculateBurstSize(unsigned int hSize,unsigned int *mainBurstSize,unsigned int *remainedBurstSize)
{
unsigned int tmp;
tmp=(hSize/4)%16;
switch(tmp) {
case 0:
*mainBurstSize=16;
*remainedBurstSize=16;
break;
case 4:
*mainBurstSize=16;
*remainedBurstSize=4;
break;
case 8:
*mainBurstSize=16;
*remainedBurstSize=8;
break;
default:
tmp=(hSize/4)%8;
switch(tmp) {
case 0:
*mainBurstSize=8;
*remainedBurstSize=8;
break;
case 4:
*mainBurstSize=8;
*remainedBurstSize=4;
default:
*mainBurstSize=4;
tmp=(hSize/4)%4;
*remainedBurstSize= (tmp) ? tmp: 4;
break;
}
break;
}
}
/********************************************************
CalculatePrescalerRatioShift - none
Description:
- none
*/
void CalculatePrescalerRatioShift(unsigned int SrcSize, unsigned int DstSize, unsigned int *ratio,unsigned int *shift)
{
if(SrcSize>=64*DstSize) {
// Uart_Printf("ERROR: out of the prescaler range: SrcSize/DstSize = %d(< 64)\r\n",SrcSize/DstSize);
while(1);
}
else if(SrcSize>=32*DstSize) {
*ratio=32;
*shift=5;
}
else if(SrcSize>=16*DstSize) {
*ratio=16;
*shift=4;
}
else if(SrcSize>=8*DstSize) {
*ratio=8;
*shift=3;
}
else if(SrcSize>=4*DstSize) {
*ratio=4;
*shift=2;
}
else if(SrcSize>=2*DstSize) {
*ratio=2;
*shift=1;
}
else {
*ratio=1;
*shift=0;
}
}
void Camera_Clock(unsigned char divide)
{
unsigned int camclk;
// Set camera clock for camera processor
s2440PWR->rCAMDIVN = (s2440PWR->rCAMDIVN & ~(0x1f)) | (1<<4) | (divide & 0xf); // CAMCLK is divided..
camclk = 48000000/(((s2440PWR->rCAMDIVN&0xf) + 1)*2);
RETAILMSG(1,(TEXT("CAM clock:%d\r\n"),camclk));
}
/*
void CamCaptureStart(unsigned int mode)
{
if(mode&CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT) {
s2440CAM->rCICOSCCTRL|=CAM_CODEC_SACLER_START_BIT;
}
if(mode&CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT) {
s2440CAM->rCIPRSCCTRL|=CAM_PVIEW_SACLER_START_BIT;
}
s2440CAM->rCIIMGCPT|=(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT|mode);
}
*/
void Camif_Capture(int cap_a, int cap_b)
{
//RETAILMSG(1,(_T("Camif_Capture(%d, %d)\r\n"), cap_a, cap_b));
// S3C2440A
s2440CAM->rCIIMGCPT &= ~(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT);
if(cap_b == CAPTURE_ON)
{
//Codec capture start
s2440CAM->rCICOSCCTRL |=(CAM_CODEC_SACLER_START_BIT);
s2440CAM->rCIIMGCPT |=(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT)|(CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT);
}
else if (cap_b == CAPTURE_OFF)
{
s2440CAM->rCICOSCCTRL &= ~(CAM_CODEC_SACLER_START_BIT);
s2440CAM->rCIIMGCPT &= ~(CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT);
}
if(cap_a == CAPTURE_ON)
{
// Preview capture Start
s2440CAM->rCIPRSCCTRL |=(CAM_PVIEW_SACLER_START_BIT);
s2440CAM->rCIIMGCPT |=(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT)|(CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT);
}
else if (cap_a == CAPTURE_OFF)
{
s2440CAM->rCIPRSCCTRL &= ~(CAM_PVIEW_SACLER_START_BIT);
s2440CAM->rCIIMGCPT &= ~(CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT);
}
if ((cap_a == CAPTURE_ON) || (cap_b == CAPTURE_ON))
{
s2440CAM->rCIIMGCPT |= (CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT);
}
}
DWORD CameraCaptureThread(void)
{
unsigned char tmp=0;
static unsigned int time,old_time;
static unsigned int cam_intr;
while(1)
{
WaitForSingleObject(CameraEvent, DisplayTime);
//RETAILMSG(MSG_EN_1,(_T("CameraCaptureThread(%d)++\r\n"), frame_count));
//RETAILMSG(1,(_T("CameraCaptureThread(%d)++\r\n"), frame_count));
#if 0
if (frame_count <= 2) {
frame_count++;
// Enable camera interrupt
s2440INT->rINTSUBMSK &= ~(BIT_SUB_CAM_P|BIT_SUB_CAM_C);
s2440INT->rINTMSK &= ~BIT_CAM;
continue;
}
#endif
//if( DisplayEnable )
{
frame_count++;
if (s2440INT->rINTSUBMSK & BIT_SUB_CAM_C)
{
cam_intr = BIT_SUB_CAM_C;
//RETAILMSG(1,(_T("CAM_C, ts %d\r\n"), GetTickCount()));
}
else if (s2440INT->rINTSUBMSK & BIT_SUB_CAM_P)
{
cam_intr = BIT_SUB_CAM_P;
//RETAILMSG(1,(_T("CAM_P, ts %d\r\n"), GetTickCount()));
}
// EINT20 to measure time
// s2440IOP->rGPGDAT |= (1<<12);
// time = GetTickCount();
// RETAILMSG(1,(TEXT("+time:%d\r\n"),(time - old_time)));
// delay for capture
//Sleep(CAPTURE_TIME); // polling mode
//liudiping
// display the image
//if ((DRIVER_PREVIEW_ENABLE == 1) & (cam_intr == BIT_SUB_CAM_P))
{
//RETAILMSG(1,(TEXT("-------------------\r\n")));
Display_Cam_Image(64, 64, QCIF_XSIZE, QCIF_YSIZE, PORT_A);
//Display_Cam_Image(0,0, QCIF_XSIZE, QCIF_YSIZE, PORT_A);
}
//else if (DRIVER_PREVIEW_ENABLE == 2)
if (cam_intr == BIT_SUB_CAM_C)
{
Buffer_codec_info_update();
}
if (cam_intr == BIT_SUB_CAM_P)
{
Buffer_preview_info_update();
}
// Enable camera interrupt
s2440INT->rINTSUBMSK &= ~(BIT_SUB_CAM_P|BIT_SUB_CAM_C);
s2440INT->rINTMSK &= ~BIT_CAM;
/*
if (DRIVER_PREVIEW_ENABLE == 1)
Camif_Capture(CAPTURE_ON, CAPTURE_OFF);
else if (DRIVER_PREVIEW_ENABLE == 2)
Camif_Capture(CAPTURE_OFF, CAPTURE_ON);
*/
// EINT20 to measure time
// s2440IOP->rGPGDAT &= ~(1<<12);
// old_time = GetTickCount();
// RETAILMSG(1,(TEXT("-time:%d\r\n"),(old_time-time)));
}
}
}
void Virtual_Alloc()
{
// GPIO Virtual alloc
s2440IOP = (volatile IOPreg *) VirtualAlloc(0,sizeof(IOPreg),MEM_RESERVE, PAGE_NOACCESS);
if(s2440IOP == NULL) {
RETAILMSG(1,(TEXT("For s2440IOP: VirtualAlloc failed!\r\n")));
}
else {
if(!VirtualCopy((PVOID)s2440IOP,(PVOID)(IOP_BASE),sizeof(IOPreg),PAGE_READWRITE | PAGE_NOCACHE )) {
RETAILMSG(1,(TEXT("For s2440IOP: VirtualCopy failed!\r\n")));
}
}
// IIC Virtual alloc
s2440IIC = (volatile IICreg *) VirtualAlloc(0,sizeof(IICreg),MEM_RESERVE, PAGE_NOACCESS);
if(s2440IIC == NULL) {
RETAILMSG(1,(TEXT("For s2440IIC: VirtualAlloc failed!\r\n")));
}
else {
if(!VirtualCopy((PVOID)s2440IIC,(PVOID)(IIC_BASE),sizeof(IICreg),PAGE_READWRITE | PAGE_NOCACHE )) {
RETAILMSG(1,(TEXT("For s2440IIC: VirtualCopy failed!\r\n")));
}
}
// Camera Virtual alloc
s2440CAM = (volatile CAMreg *) VirtualAlloc(0,sizeof(CAMreg),MEM_RESERVE, PAGE_NOACCESS);
if(s2440CAM == NULL) {
RETAILMSG(1,(TEXT("For s2440CAM: VirtualAlloc failed!\r\n")));
}
else {
if(!VirtualCopy((PVOID)s2440CAM,(PVOID)(CAM_BASE),sizeof(CAMreg),PAGE_READWRITE | PAGE_NOCACHE )) {
RETAILMSG(1,(TEXT("For s2440CAM: VirtualCopy failed!\r\n")));
}
}
// Interrupt Virtual alloc
s2440INT = (volatile INTreg *) VirtualAlloc(0,sizeof(INTreg),MEM_RESERVE, PAGE_NOACCESS);
if(s2440INT == NULL) {
RETAILMSG(1,(TEXT("For s2440INT: VirtualAlloc failed!\r\n")));
}
else {
if(!VirtualCopy((PVOID)s2440INT,(PVOID)(INT_BASE),sizeof(INTreg),PAGE_READWRITE | PAGE_NOCACHE )) {
RETAILMSG(1,(TEXT("For s2440INT: VirtualCopy failed!\r\n")));
}
}
// PWM clock Virtual alloc
s2440PWR = (volatile CLKPWRreg *) VirtualAlloc(0,sizeof(CLKPWRreg),MEM_RESERVE, PAGE_NOACCESS);
if(s2440PWR == NULL) {
RETAILMSG(1,(TEXT("For s2440PWR: VirtualAlloc failed!\r\n")));
}
else {
if(!VirtualCopy((PVOID)s2440PWR,(PVOID)(CLKPWR_BASE),sizeof(CLKPWRreg),PAGE_READWRITE | PAGE_NOCACHE )) {
RETAILMSG(1,(TEXT("For s2440PWR: VirtualCopy failed!\r\n")));
}
}
}
void Display_Cam_Image(U32 pos_x, U32 pos_y, U32 size_x, U32 size_y, U8 port)
{
U8 *buffer_rgb;
U32 y;
int temp;
//unsigned short *ptr = (unsigned short *)(FRAMEBUF_BASE+0x5dc0);
static unsigned short transfer_data[QCIF_XSIZE*QCIF_YSIZE];
static unsigned int time,old_time;
//RETAILMSG(1,(_T("Display_Cam_Image()\r\n")));
// if (port)
{
temp = (s2440CAM->rCIPRSTATUS>>26)&3;
temp = (temp + 2) % 4;
switch (temp)
{
case 0:
buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA1;
break;
case 1:
buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA2;
break;
case 2:
buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA3;
break;
case 3:
buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA4;
break;
default :
buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA1;
break;
}
}
RETAILMSG(MSG_EN_1,(_T("preview buf index = %d\r\n"), temp));
#if (DOTNET_DRIVER)
SetKMode(TRUE);
#endif
buffer_rgb += VIRTUAL_OFFSET;
// time = GetTickCount();
// RETAILMSG(1,(TEXT("+:%d\r\n"),(time - old_time)));
#if 1
for (y=0;y<(size_y-2);y++) // YCbCr 4:2:0 format
{
//memcpy((void *)(FRAMEBUF_BASE+0x5e00+y*240*2),(void *)buffer_rgb,(QCIF_XSIZE)*2);
memcpy((void *)(FRAMEBUF_BASE+ (240*pos_y + pos_x) + y*240*2),(void *)buffer_rgb,(QCIF_XSIZE)*2);
//memcpy((void *)(FRAMEBUF_BASE+ (640*pos_y + pos_x) + y*640*2),(void *)buffer_rgb,(QCIF_XSIZE)*2);
buffer_rgb += (QCIF_XSIZE*2);
}
#endif
#if (DOTNET_DRIVER)
SetKMode(FALSE);
#endif
// old_time = GetTickCount();
// RETAILMSG(1,(TEXT("-:%d\r\n"),(old_time - time)));
}
BOOL WINAPI
DllEntry(HANDLE hinstDLL,
DWORD dwReason,
LPVOID /* lpvReserved */)
{
switch(dwReason)
{
case DLL_PROCESS_ATTACH:
DEBUGREGISTER((HINSTANCE)hinstDLL);
DEBUGMSG(ZONE_INIT,(TEXT("CAMERA: DLL_PROCESS_ATTACH\r\n")));
//liudiping
//RETAILMSG(1,(TEXT("CAMERA: DLL_PROCESS_ATTACH\r\n")));
return TRUE;
case DLL_THREAD_ATTACH:
DEBUGMSG(ZONE_THREAD,(TEXT("CAMERA: DLL_THREAD_ATTACH\r\n")));
//RETAILMSG(1,(TEXT("CAMERA: DLL_THREAD_ATTACH\r\n")));
break;
case DLL_THREAD_DETACH:
DEBUGMSG(ZONE_THREAD,(TEXT("CAMERA: DLL_THREAD_DETACH\r\n")));
break;
case DLL_PROCESS_DETACH:
DEBUGMSG(ZONE_INIT,(TEXT("CAMERA: DLL_PROCESS_DETACH\r\n")));
break;
#ifdef UNDER_CE
case DLL_PROCESS_EXITING:
DEBUGMSG(ZONE_INIT,(TEXT("CAMERA: DLL_PROCESS_EXITING\r\n")));
break;
case DLL_SYSTEM_STARTED:
DEBUGMSG(ZONE_INIT,(TEXT("CAMERA: DLL_SYSTEM_STARTED\r\n")));
break;
#endif
?? 快捷鍵說明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號(hào)
Ctrl + =
減小字號(hào)
Ctrl + -