camera.cpp

2443 wince5.0 bsp, source code

#endif	

	Delay(10);

	// Camera clock on
	CamClockOn(TRUE);
	
	Delay(100);
}


DWORD CameraCaptureThread(void)
{
	unsigned char tmp=0;
	static unsigned int time,old_time;
	static unsigned int cam_intr;
	
	DWORD	dwCause;					// LJY PWR040613

	//dwDisplayTimeout = INFINITE;

	SetProcPermissions((DWORD)-1);
	
	while(TRUE)
	{
		RETAILMSG(0,(TEXT("[CAM_HW] InterruptThread : Waiting For a Single Object\n\r")));
		
		dwCause = WaitForSingleObject(CameraEvent, dwDisplayTimeout);
		
		RETAILMSG(MSG_EN_1,(_T("CameraCaptureThread(%d)++\r\n"), frame_count));

#if 0
		if (frame_count <= 2) {
			//frame_count++;
			// Enable camera interrupt
			s2443INT->INTSUBMSK &= ~(( 1 << IRQ_SUB_CAM_P )|( 1 << IRQ_SUB_CAM_C ));
			s2443INT->INTMSK &= ~( 1 << IRQ_CAM );
			
			continue;
		}
#endif
		
		if (dwCause == WAIT_OBJECT_0) // LJY PWR
		{
			Lock();

			__try
			{

				if (s2443INT->INTSUBMSK & ( 1 << IRQ_SUB_CAM_C ))
				{
					frame_count++;
					cam_intr |= ( 1 << IRQ_SUB_CAM_C );
				    
				    s2443INT->SUBSRCPND  =  (1<<IRQ_SUB_CAM_C);
		            s2443INT->INTSUBMSK &= ~(1<<IRQ_SUB_CAM_C);
					//RETAILMSG(1,(_T("CAM_C, ts %d\r\n"), GetTickCount()));
				}

				if (s2443INT->INTSUBMSK & ( 1 << IRQ_SUB_CAM_P ))
				{
					cam_intr |= ( 1 << IRQ_SUB_CAM_P );
					
					s2443INT->SUBSRCPND  =  (1<<IRQ_SUB_CAM_P);
		            s2443INT->INTSUBMSK &= ~(1<<IRQ_SUB_CAM_P);
					//RETAILMSG(1,(_T("CAM_P, ts %d\r\n"), GetTickCount()));
				}

				if (((s2443INT->INTSUBMSK & ( 1 << IRQ_SUB_CAM_C )) == 0) && ((s2443INT->INTSUBMSK & ( 1 << IRQ_SUB_CAM_P )) == 0))
				{
					RETAILMSG(MSG_EN_1,(_T("[CAM]NOP\r\n")));					
				}
				
				
				InterruptDone(g_CamSysIntr);				
			
				//time = GetTickCount();
				//RETAILMSG(1,(TEXT("+time:%d\r\n"),(time - old_time)));

				//RETAILMSG(1,(TEXT("INTERRUPT\n")));
				// Handle any interrupts on the input source
				if (cam_intr & ( 1 << IRQ_SUB_CAM_P ))
				{
					//RETAILMSG(1,(TEXT("PREVIEW INTERRUPT\n")));
					// display the image	
					if (DRIVER_PREVIEW_ENABLE == 1)
						Display_Cam_Image(g_PreviewPos_X,g_PreviewPos_Y,g_PreviewSize_Width, g_PreviewSize_Height, PORT_A);
					
					if( DRIVER_MSDMA_ENABLE == 2)
					{
						DRIVER_MSDMA_ENABLE = 0;		
						Camif_Capture(CAPTURE_ON, CAPTURE_ON);						
					}
					Buffer_preview_info_update();
					cam_intr &= ~( 1 << IRQ_SUB_CAM_P );
				}
					
				if (cam_intr & ( 1 << IRQ_SUB_CAM_C ))
				{
					//RETAILMSG(1,(TEXT("CODEC INTERRUPT\n")));
					Buffer_codec_info_update();
					if (DRIVER_MSDMA_ENABLE == 1)		// MSDMA Mode
					{
						Display_Cam_Image_CODEC(sCAMINFO.nDestWidth,sCAMINFO.nDestHeight);					
						SetMSDMAView(sCAMINFO.nDestWidth, sCAMINFO.nDestHeight,  g_PreviewSize_Width, g_PreviewSize_Height);						
						DRIVER_MSDMA_ENABLE = 2;						
					}
					cam_intr &= ~( 1 << IRQ_SUB_CAM_C );
				}

				// Enable camera interrupt
				//s2443INT->INTSUBMSK &= ~(( 1 << IRQ_SUB_CAM_P )|( 1 << IRQ_SUB_CAM_C ));
				//s2443INT->INTMSK &= ~( 1 << IRQ_CAM );

				//old_time = GetTickCount();
				//RETAILMSG(1,(TEXT("-time:%d\r\n"),(old_time-time)));

			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
				RETAILMSG(PM_MSG, (TEXT("Camera.DLL:InterruptThread() - EXCEPTION: %d"), GetExceptionCode()));
			}
				
			Unlock();
			
		}
		/*else if (dwCause == WAIT_TIMEOUT)
		{
			Lock();
			
			RETAILMSG(PM_MSG,(_T("[CAM_HW] InterruptThread Timeout : %d msec\r\n"), dwDisplayTimeout));
			
			dwDisplayTimeout = INFINITE;				// reset timeout until Camera Interrupt occurs
			bIdlePwrDown = TRUE;					// Codec is off

			CamInterface_PowerDown();
			RETAILMSG(PM_MSG, (TEXT("[CAM_HW] InterruptThread : bIdlePwrDown = TRUE\r\n")));

			Unlock();
		}*/
		else
		{
			RETAILMSG(PM_MSG, (TEXT("[CAM_HW] InterruptThread : Exit %d, Cause %d\r\n"), GetLastError(), dwCause));
		}
	}

	return 0;
}



void Virtual_Alloc()
{

	PBYTE pVirtPreviewAddr = NULL;
	PBYTE pVirtCodecAddr = NULL;
	PBYTE pVirtMSDMAAddr = NULL;	
    DMA_ADAPTER_OBJECT Adapter1, Adapter2;

    memset(&Adapter1, 0, sizeof(DMA_ADAPTER_OBJECT));
    Adapter1.InterfaceType = Internal;
    Adapter1.ObjectSize = sizeof(DMA_ADAPTER_OBJECT);

    memset(&Adapter2, 0, sizeof(DMA_ADAPTER_OBJECT));
    Adapter2.InterfaceType = Internal;
    Adapter2.ObjectSize = sizeof(DMA_ADAPTER_OBJECT);

    // Allocate a block of virtual memory (physically contiguous) for the DMA buffers.
    //
    pVirtPreviewAddr = (PBYTE)HalAllocateCommonBuffer(&Adapter1, Preview_Mem_Size, &g_PhysPreviewAddr, FALSE);
    if (pVirtPreviewAddr == NULL)
    {
        RETAILMSG(TRUE, (TEXT("Camera:Virtual_Alloc() - Failed to allocate DMA buffer for Preview.\r\n")));
    }

    pVirtCodecAddr = (PBYTE)HalAllocateCommonBuffer(&Adapter2, Codec_Mem_Size, &g_PhysCodecAddr, FALSE);
    if (pVirtCodecAddr == NULL)
    {
        RETAILMSG(TRUE, (TEXT("Camera:Virtual_Alloc() - Failed to allocate DMA buffer for Codec.\r\n")));
    }

    pVirtMSDMAAddr = (PBYTE)HalAllocateCommonBuffer(&Adapter2, 
					(CAM_SRC_VSIZE*CAM_SRC_HSIZE)+(CAM_SRC_VSIZE*CAM_SRC_HSIZE*2/4), &g_PhysMSDMAAddr, FALSE);

    if (pVirtMSDMAAddr == NULL)
    {
        RETAILMSG(TRUE, (TEXT("Camera:Virtual_Alloc() - Failed to allocate DMA buffer for Codec.\r\n")));
    }


    // GPIO Virtual alloc
	s2443IOP = (volatile S3C2443_IOPORT_REG *) VirtualAlloc(0,sizeof(S3C2443_IOPORT_REG),MEM_RESERVE, PAGE_NOACCESS);
	if(s2443IOP == NULL) {
		RETAILMSG(1,(TEXT("For s2443IOP: VirtualAlloc failed!\r\n")));
	}
	else {
		if(!VirtualCopy((PVOID)s2443IOP,(PVOID)(S3C2443_BASE_REG_PA_IOPORT >> 8),sizeof(S3C2443_IOPORT_REG),PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE )) {
			RETAILMSG(1,(TEXT("For s2443IOP: VirtualCopy failed!\r\n")));
		}
	}
	
    // Camera Virtual alloc
	s2443CAM = (volatile S3C2443_CAM_REG *) VirtualAlloc(0,sizeof(S3C2443_CAM_REG),MEM_RESERVE, PAGE_NOACCESS);
	if(s2443CAM == NULL) {
		RETAILMSG(1,(TEXT("For s2443CAM: VirtualAlloc failed!\r\n")));
	}
	else {
		if(!VirtualCopy((PVOID)s2443CAM,(PVOID)(S3C2443_BASE_REG_PA_CAM >> 8),sizeof(S3C2443_CAM_REG),PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE )) {
			RETAILMSG(1,(TEXT("For s2443CAM: VirtualCopy failed!\r\n")));
		}
	}

	// Interrupt Virtual alloc
	s2443INT = (volatile S3C2443_INTR_REG *) VirtualAlloc(0,sizeof(S3C2443_INTR_REG),MEM_RESERVE, PAGE_NOACCESS);
	if(s2443INT == NULL) {
		RETAILMSG(1,(TEXT("For s2443INT: VirtualAlloc failed!\r\n")));
	}
	else {
		if(!VirtualCopy((PVOID)s2443INT,(PVOID)(S3C2443_BASE_REG_PA_INTR >> 8),sizeof(S3C2443_INTR_REG),PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE )) {
			RETAILMSG(1,(TEXT("For s2443INT: VirtualCopy failed!\r\n")));
		}
	}
	// PWM clock Virtual alloc
	s2443PWR = (volatile S3C2443_CLKPWR_REG *) VirtualAlloc(0,sizeof(S3C2443_CLKPWR_REG),MEM_RESERVE, PAGE_NOACCESS);
	if(s2443PWR == NULL) {
		RETAILMSG(1,(TEXT("For s2443PWR: VirtualAlloc failed!\r\n")));
	}
	else {
		if(!VirtualCopy((PVOID)s2443PWR,(PVOID)(S3C2443_BASE_REG_PA_CLOCK_POWER >>8),sizeof(S3C2443_CLKPWR_REG),PAGE_PHYSICAL | PAGE_READWRITE | PAGE_NOCACHE )) {
			RETAILMSG(1,(TEXT("For s2443PWR: VirtualCopy failed!\r\n")));
		}
	}
	
    //InitializeCriticalSection(&m_Lock);
    
    
    pCIS->pIORegs = s2443IOP;
	pCIS->pCAMRegs = s2443CAM;
	pCIS->pINTRegs = s2443INT;
	pCIS->pPWRRegs = s2443PWR;

	
}

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(%d,%d,%d,%d)\r\n"),pos_x,pos_y,size_x,size_y));
	
//	if (port)
	{
		temp = (s2443CAM->CIPRSTATUS>>26)&3;

		if(DRIVER_MSDMA_ENABLE == 0)
			temp = (temp + 2) % 4;				
		else
			temp = (temp + 3) % 4;				
			

		
		switch (temp)
		{
		case 0:
			buffer_rgb = (U8 *)s2443CAM->CIPRCLRSA1;
			break;
		case 1:
			buffer_rgb = (U8 *)s2443CAM->CIPRCLRSA2;
			break;
		case 2:
			buffer_rgb = (U8 *)s2443CAM->CIPRCLRSA3;
			break;
		case 3:
			buffer_rgb = (U8 *)s2443CAM->CIPRCLRSA4;
			break;
		default :
			buffer_rgb = (U8 *)s2443CAM->CIPRCLRSA1;
			break;
		}
	}
	RETAILMSG(MSG_EN_1,(_T("preview buf index = %d\r\n"), temp));

	
	buffer_rgb += VIRTUAL_OFFSET;

//	time = GetTickCount();
//	RETAILMSG(1,(TEXT("+:%d\r\n"),(time - old_time)));


#if 1
SetKMode(TRUE);
	for (y=0; y<size_y; y++) // YCbCr 4:2:0 format
	{
		//memcpy((void *)(FRAMEBUF_BASE+0x5e00+y*240*2),(void *)buffer_rgb,(QCIF_XSIZE)*2);
		memcpy((void *)(IMAGE_FRAMEBUFFER_UA_BASE+ (LCD_XSIZE_TFT*2*pos_y + pos_x*2) + y*LCD_XSIZE_TFT*2),(void *)buffer_rgb,(size_x)*2);
		buffer_rgb += (size_x*2);
	}
SetKMode(FALSE);

#endif


//	old_time = GetTickCount();
//	RETAILMSG(1,(TEXT("-:%d\r\n"),(old_time - time)));

}

void Display_Cam_Image2(U32 size_x, U32 size_y, U8 port)
{
	U8 *buffer_rgb;
	U32 x, 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(MSG_EN_1,(_T("Display_Cam_Image()\r\n")));
	
//	if (port)
	{
		temp = (s2443CAM->CIPRSTATUS>>26)&3;
		temp = (temp + 2) % 4;
		
		switch (temp)
		{
		case 0:
			buffer_rgb = (U8 *)s2443CAM->CIPRCLRSA1;
			break;
		case 1:
			buffer_rgb = (U8 *)s2443CAM->CIPRCLRSA2;
			break;
		case 2:
			buffer_rgb = (U8 *)s2443CAM->CIPRCLRSA3;
			break;
		case 3:
			buffer_rgb = (U8 *)s2443CAM->CIPRCLRSA4;
			break;
		default :
			buffer_rgb = (U8 *)s2443CAM->CIPRCLRSA1;
			break;
		}
	}
	RETAILMSG(MSG_EN_1,(_T("preview buf index = %d\r\n"), temp));

	RETAILMSG(MSG_EN_1,(_T("buffer_rgb = 0x%x\r\n"), buffer_rgb));

	
	buffer_rgb += VIRTUAL_OFFSET;

	RETAILMSG(MSG_EN_1,(_T("buffer_rgb = 0x%x\r\n"), buffer_rgb));

//	time = GetTickCount();
//	RETAILMSG(1,(TEXT("+:%d\r\n"),(time - old_time)));


#if 1
SetKMode(TRUE);
      for(y=0;y<240;y++)
      	{
		for (x=0; x<320; x++) // YCbCr 4:2:0 format
	{
		*(U16*)((U8*)(IMAGE_FRAMEBUFFER_UA_BASE+y*2+240*(319-x)*2))=*(U16*)((U8*)(buffer_rgb+y*320*2+x*2));
		//memcpy((U8 *)(FRAMEBUF_BASE + (y*2)+240*(319-x)*2),(U8 *)(buffer_rgb+y*320*2+x*2),2);
	}
      	}
SetKMode(FALSE);

#endif

}

void Display_Cam_Image_CODEC(U32 size_x, U32 size_y)
{
	//RETAILMSG(1,(TEXT("codec %x  %d\r\n"),(BYTE*)(g_PhysMSDMAAddr.LowPart), g_CodecFrameSize));
	SetKMode(TRUE);
	memcpy((BYTE*)(g_PhysMSDMAAddr.LowPart + VIRTUAL_ADDR_OFFSET), (BYTE*)y_address, g_CodecFrameSize);
	SetKMode(FALSE);

#if 0
		UINT x,y;
		UINT addr = g_PhysMSDMAAddr.LowPart + VIRTUAL_ADDR_OFFSET;
	       //g_PreviewPos_X,g_PreviewPos_Y,g_PreviewSize_Width, g_PreviewSize_Height
	       DRIVER_PREVIEW_ENABLE = 0;
		SetKMode(TRUE);
	      for(y=0;y<180;y++)
	      	{
			for (x=0; x<240; x++) // YCbCr 4:2:0 format
			{
			*(U16*)((U8*)(IMAGE_FRAMEBUFFER_UA_BASE+y*2*320+x*2))=*((U8*)(y_address+y*352+x));
			}
	      	}
		SetKMode(FALSE);

#endif	
}

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")));
		return TRUE;
	case DLL_THREAD_ATTACH:
		DEBUGMSG(ZONE_THREAD,(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: