601cman.c

视频601芯片的驱动源码,你可以完全掌控该芯片了,对于其它多媒体芯片的设计具有参考价值

		case BW_STAT_RDY_VXDMSG:
			BwStatRdyCallBack = (BWSTATRDYPROC)pProc;
			return OK;

		case FF_UPDATE_VXDMSG:
			FastForwardUpdateCallBack = (FFUPDATEPROC)pProc;
			return OK;

		case REW_UPDATE_VXDMSG:
			RewindUpdateCallBack = (REWUPDATEPROC)pProc;
			return OK;

		default:
			break;
	}

	return FAILURE;

}

// -------------------------------------------------------------------------
// 
// ServiceThread
//
// -------------------------------------------------------------------------
DWORD ServiceThread(PVOID pThreadParam)
{
	DWORD	cbBytesReturned;



	inBuf[0] = RPmanAPC;
	if ( !DeviceIoControl(hDevice, APC_INIT_VXDMSG,
               &inBuf, sizeof(PVOID),
               &RetInfo, sizeof(RetInfo),
               &cbBytesReturned, NULL) )
		return CMAN_APC_INIT_ERR;
	pBWStatusFlg = (int *)RetInfo[0];
	pVitcCode = (DWORD *)RetInfo[1];
	pVITCinfo = (VITCINFO *)RetInfo[2];

	while(1)
		SleepEx(-1,TRUE);

	return 0;	// never returns
}

// -------------------------------------------------------------------------
//
// 	RPmanAPC
//
// -------------------------------------------------------------------------
DWORD WINAPI RPmanAPC(DWORD param)
{

	switch(param)
	{
		case BW_STAT_RDY_VXDMSG:
			BWCcnt++;			// Bump up the thread count for record
			BWCalculation();
			if (BwStatRdyCallBack != NULL && 
				init_rec.scene_detection_p &&
				out_rec.scene_change_p)
			{
				BwStatRdyCallBack(out_rec.scene_change_p); 
				out_rec.scene_change_p = 0;
			}
			break;

		case INT_HALT_VXDMSG:
			// Call the Application Callback function !
			if (IntHaltCallBack != NULL)
				IntHaltCallBack(*p601RTErr);
			if (*p601RTErr == CMAN_INT_NORMAL_EXIT)
				pEV601Info->VlabErr = OK;		// 601test likes OK better
			else
				pEV601Info->VlabErr = *p601RTErr;		

			break;

		case VITC_UPDATE_VXDMSG:
			// Call the VITC Display Callback function !
			if (VitcUpdateCallBack != NULL)
				VitcUpdateCallBack(pVITCinfo, 0);
			break;

		case FF_UPDATE_VXDMSG:
			// Call the Fast Forware Display Callback function !
			if (FastForwardUpdateCallBack != NULL)
				FastForwardUpdateCallBack(pVITCinfo, 0);
			break;

		case REW_UPDATE_VXDMSG:
			// Call the Rewind Display Callback function !
			if (RewindUpdateCallBack != NULL)
				RewindUpdateCallBack(pVITCinfo, 0);
			break;
	}
	return OK;
}

//----------------------------------------------------------------------------
//  FUNCTION: HwConfig()
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI HwConfig()
{
	Error	* pErr;	

	pErr = HwConfig4Diag(S_VIDEO);

	return (pErr->HwConfig4DiagErr);
}

//----------------------------------------------------------------------------
//  FUNCTION: VideoIOConfig()
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI VideoIOConfig(	int Vformat,
									int VideoInType, 
									int VideoOutType, 
									int VCRmode)
{
	Error  * pErr;

	CapVideo.VideoFormat = Vformat;
	CapVideo.VideoSrc = VideoInType;
	CapVideo.VideoOut = VideoOutType;
	// Hard coded to square pixel for now !
	CapVideo.PixelType = NONSQ_PIXEL;
	// VCR mode or not
	CapVideo.VCRmode = VCRmode;


	pErr = BashBoard(Vformat, 
					   VideoInType, 
					   VideoOutType, 
					   VCRmode, 
					   S_Capture, 
					   Def_FIFO_Thre);
	if (pErr != NULL)
		return 	FAILURE;

    return OK;
}


//----------------------------------------------------------------------------
//  FUNCTION: VideoCroppingConfig()
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI VideoCroppingConfig(int Vstart,
										int Vend, 
										int Hstart, 
										int Hend)
{
	Error  * pErr;

	// Check the range of the parameters for the croping 
	// registers
	if (Vstart > 0x3FF || Vstart < 0)
		return FAILURE;
	if (Vend > 0x3FF || Vend < 0)
		return FAILURE;
	if (Hstart > 0x3FF || Hstart < 0)
		return FAILURE;
	if (Hend > 0x3FF || Hend < 0)
		return FAILURE;

	 
	// Assign croping values to a set of internal variable 
	// used by wavelet_init().
	vstart = Vstart;
	vend = Vend;
	hstart = Hstart;
	hend = Hend;

	pErr = BashBoard(	CapVideo.VideoFormat, 
						CapVideo.VideoSrc, 
						CapVideo.VideoOut, 
						CapVideo.VCRmode, 
						S_Capture,
						Def_FIFO_Thre);
	if (pErr != NULL)
		return 	FAILURE;

    return OK;
}


//----------------------------------------------------------------------------
//  FUNCTION: SetCaptureCfg()
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI SetCaptureCfg(CaptureCfg * pEncCfg)
{

	if (CapPlyBkState != S_Stop)
		return	CMAN_ILLEGAL_COMMAND_ERR;

    dsp_bpp = 0xFF * (pEncCfg->BitPerPixel /16.0);
	InitBWCalculator(pEncCfg);

    return OK;
}


//----------------------------------------------------------------------------
//  FUNCTION: SetPlayBackCfg()
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI SetPlayBackCfg(float *pBetaGain)
{
	if (CapPlyBkState != S_Stop)
		return	CMAN_ILLEGAL_COMMAND_ERR;


    return OK;
}

//----------------------------------------------------------------------------
//  FUNCTION: FastForward()
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI FastForward()
{
	if (CapPlyBkState != S_Stop)
		return	CMAN_ILLEGAL_COMMAND_ERR;

	BashBoard( CapVideo.VideoFormat, 
						CapVideo.VideoSrc, 
						CapVideo.VideoOut, 
						CapVideo.VCRmode, 
						S_PlayBack,
						Def_FIFO_Thre);

	RetInfo[0] = 0;
    if ( ! DeviceIoControl(hDevice, FF_VXDMSG,
               inBuf, sizeof(PVOID), (LPVOID)RetInfo, sizeof(RetInfo),
               &cbBytesReturned, NULL)
	   )
			return CMAN_VXD_IFACE_ERR;

	if (RetInfo[0])
			return CMAN_START_FF_ERR;
	else
			CapPlyBkState = S_PlayBackFF;		

    return OK;
}

//----------------------------------------------------------------------------
//  FUNCTION: FastForwardPause()
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI FastForwardPause(int command)
{
	DWORD VxDmsg;

	switch(command)
	{
		case A_Pause_On:
			if 	( CapPlyBkState != S_PlayBackFF &&
				  CapPlyBkState != S_PlayBackFFResume 					
				)
				return	CMAN_ILLEGAL_COMMAND_ERR;
			VxDmsg = FF_PAUSE_VXDMSG;
			break;
		case A_Pause_Off:
			if ( CapPlyBkState != S_PlayBackPause)
				return	CMAN_ILLEGAL_COMMAND_ERR;
			VxDmsg = FF_RESUME_VXDMSG;
			break;
		default:
			return	CMAN_PARAM_ERR;
	}

	RetInfo[0] = 0;
    if ( ! DeviceIoControl(hDevice, VxDmsg,
               inBuf, sizeof(PVOID), (LPVOID)RetInfo, sizeof(RetInfo),
               &cbBytesReturned, NULL)
	   )
			return CMAN_VXD_IFACE_ERR;

	if (RetInfo[0])
	{
		return 	(command == A_Pause_On)
				? CMAN_FF_PAUSE_ERR
				: CMAN_FF_RESUME_ERR;
	}
	else
	{
		CapPlyBkState = (command == A_Pause_On)
					? S_PlayBackFFPause
					: S_PlayBackFFResume;
	}

    return OK;
}

//----------------------------------------------------------------------------
//  FUNCTION: Rewind()
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI Rewind()
{

	if (CapPlyBkState != S_Stop)
		return	CMAN_ILLEGAL_COMMAND_ERR;

	BashBoard( CapVideo.VideoFormat, 
						CapVideo.VideoSrc, 
						CapVideo.VideoOut, 
						CapVideo.VCRmode, 
						S_PlayBack,
						Def_FIFO_Thre);

	RetInfo[0] = 0;
    if ( ! DeviceIoControl(hDevice, REW_VXDMSG,
               inBuf, sizeof(PVOID), (LPVOID)RetInfo, sizeof(RetInfo),
               &cbBytesReturned, NULL)
	   )
			return CMAN_VXD_IFACE_ERR;

	if (RetInfo[0])
			return CMAN_START_REW_ERR;
	else
			CapPlyBkState = S_PlayBackREW;		

    return OK;
}

//----------------------------------------------------------------------------
//  FUNCTION: GetVITC()
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI GetVITC()
{


    return OK;
}

//----------------------------------------------------------------------------
//  FUNCTION: 	Open601File()
//
//	Open a 601 file.
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI Open601File(char * FileName)
{

	inBuf[0] = FileName;
	RetInfo[0] = 0;
    if ( ! DeviceIoControl(hDevice, OPEN_FILE_VXDMSG,
               inBuf, sizeof(PVOID), (LPVOID)RetInfo, sizeof(RetInfo),
               &cbBytesReturned, NULL)
	   )
		return CMAN_VXD_IFACE_ERR;

	if (RetInfo[0])
		return CMAN_FILE_OPEN_ERR;
	else
    	return SUCCESS;
}

//----------------------------------------------------------------------------
//  FUNCTION: Close601File()
//
//	Close the 601 file.
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI Close601File()
{

	inBuf[0] = 0;
	RetInfo[0] = 0;
	if ( ! DeviceIoControl(hDevice, CLOSE_FILE_VXDMSG,
               inBuf, sizeof(PVOID), (LPVOID)RetInfo, sizeof(RetInfo),
               &cbBytesReturned, NULL)
	   )
		return CMAN_VXD_IFACE_ERR;

	if (RetInfo[0])
		return CMAN_FILE_CLOSE_ERR;
	else
    	return SUCCESS;
}


// -------------------------------------------------------------------------
//
// 	DumpCap2MemData
//
// -------------------------------------------------------------------------
DLLEXPORT int	DumpCap2MemData(char * fname)
{

	inBuf[0] = fname;
	RetInfo[0] = 0;
    if ( ! DeviceIoControl(hDevice, MEM_CAP_DATA_DUMP_VXDMSG,
               inBuf, sizeof(PVOID), (LPVOID)RetInfo, sizeof(RetInfo),
               &cbBytesReturned, NULL)
	   )
			return -1;

	return 0;
}


// -------------------------------------------------------------------------
//
// 	LoadCapData2Mem
//
// -------------------------------------------------------------------------
DLLEXPORT int	LoadCapData2Mem(char * fname)
{

	inBuf[0] = fname;
	RetInfo[0] = 0;
    if ( ! DeviceIoControl(hDevice, MEM_CAP_DATA_LOAD_VXDMSG,
               inBuf, sizeof(PVOID), (LPVOID)RetInfo, sizeof(RetInfo),
               &cbBytesReturned, NULL)
	   )
			return -1;

	return 0;
}



//----------------------------------------------------------------------------
//  FUNCTION: EV601Diag()
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI HwDiag()
{


    return OK;
}

//----------------------------------------------------------------------------
//  FUNCTION: CapturePause()
//----------------------------------------------------------------------------
DLLEXPORT int WINAPI CapturePause(int command)
{
	DWORD VxDmsg;

	switch(command)
	{
		case A_Pause_On:
			if 	( CapPlyBkState != S_Capture &&
				  CapPlyBkState != S_CaptureResume 					
				)
				return	CMAN_ILLEGAL_COMMAND_ERR;
			VxDmsg = CAPTURE_PAUSE_VXDMSG;
			break;
		case A_Pause_Off:
			if ( CapPlyBkState != S_CapturePause)
				return	CMAN_ILLEGAL_COMMAND_ERR;
			VxDmsg = CAPTURE_RESUME_VXDMSG;
			break;
		default:
			return	CMAN_PARAM_ERR;
	}

	RetInfo[0] = 0;
    if ( ! DeviceIoControl(hDevice, VxDmsg,
               inBuf, sizeof(PVOID), (LPVOID)RetInfo, sizeof(RetInfo),
               &cbBytesReturned, NULL)
	   )
			return CMAN_VXD_IFACE_ERR;

	if (RetInfo[0])
	{
		return 	(command == A_Pause_On)
				? CMAN_CAP_PAUSE_ERR
				: CMAN_CAP_RESUME_ERR;
	}
	else
	{
		CapPlyBkState = (command == A_Pause_On)
					? S_CapturePause
					: S_CaptureResume;
	}