mfc.c

三星 s3c6400测试代码

{
	*uBitBufEndAddr = oMfc.m_uStreamBufEndAddr[uProcessIdx];
}

void MFC_SetDecRotEn(bool isRotEn)
{
	u32 uDecRotEnBit = (isRotEn) ? (1<<4) : (0<<4); 
	u32 uRegData;
	uRegData =mfcInp32(DEC_PIC_ROT_MODE);
    mfcOutp32(DEC_PIC_ROT_MODE, uRegData&(0x0f)|uDecRotEnBit);
}

void MFC_SetDecRotationMode(bool horMirEn, bool verMirEn, u32 rotDeg)
{	
	u32 uHorMirMode = (horMirEn == true) ? (1<<3) : (0<<3);
	u32 uVerMirMode = (verMirEn == true) ? (1<<2) : (0<<2);
	u32 uRotAng = 
		(rotDeg == 0) ? (0<<0) :
		(rotDeg == 90) ? (1<<0) :
		(rotDeg == 180) ? (2<<0) :
		(rotDeg == 270) ? (3<<0) : (0<<0);
		
	u32 uRegData;

	Assert(rotDeg == 0 || rotDeg == 90 || rotDeg == 180 || rotDeg == 270);

	uRegData = mfcInp32(DEC_PIC_ROT_MODE);
    mfcOutp32(DEC_PIC_ROT_MODE, uRegData&(1<<4)|uHorMirMode|uVerMirMode|uRotAng);
}

void MFC_SetDecRotationMode1(bool decRotEn, bool horMirEn, bool verMirEn, u32 rotDeg)
{	
	u32 uHorMirMode = (horMirEn == true) ? (1<<3) : (0<<3);
	u32 uVerMirMode = (verMirEn == true) ? (1<<2) : (0<<2);
	u32 uRotAng = 
		(rotDeg == 0) ? (0<<0) :
		(rotDeg == 90) ? (1<<0) :
		(rotDeg == 180) ? (2<<0) :
		(rotDeg == 270) ? (3<<0) : (0<<0);
    u32 decRotEnBit = (decRotEn == true) ? (1<<4) : (0<<4);

	Assert(rotDeg == 0 || rotDeg == 90 || rotDeg == 180 || rotDeg == 270);

    mfcOutp32(DEC_PIC_ROT_MODE, decRotEnBit|uHorMirMode|uVerMirMode|uRotAng);
}

void MFC_SetEncRotEn(bool isRotEn)
{
	u32 uEncRotEnBit = (isRotEn) ? (1<<4) : (0<<4); 
	u32 uRegData;
	uRegData = mfcInp32(ENC_PIC_ROT_MODE);
    mfcOutp32(ENC_PIC_ROT_MODE, uRegData&(0x0f)|uEncRotEnBit);
}

void MFC_SetEncRotationMode(bool horMirEn, bool verMirEn, u32 rotDeg)
{	
	u32 uHorMirMode = (horMirEn == true) ? (1<<3) : (0<<3);
	u32 uVerMirMode = (verMirEn == true) ? (1<<2) : (0<<2);
	u32 uRotAng = 
		(rotDeg == 0) ? (0<<0) :
		(rotDeg == 90) ? (1<<0) :
		(rotDeg == 180) ? (2<<0) :
		(rotDeg == 270) ? (3<<0) : (0<<0);
		
	u32 uRegData;

	Assert(rotDeg == 0 || rotDeg == 90 || rotDeg == 180 || rotDeg == 270);

	uRegData = mfcInp32(ENC_PIC_ROT_MODE);
    mfcOutp32(ENC_PIC_ROT_MODE, uRegData&(1<<4)|uHorMirMode|uVerMirMode|uRotAng);
}

void MFC_SetEncRotationMode1(bool encRotEn, bool horMirEn, bool verMirEn, u32 rotDeg)
{
	u32 uHorMirMode = (horMirEn == true) ? (1<<3) : (0<<3);
	u32 uVerMirMode = (verMirEn == true) ? (1<<2) : (0<<2);
	u32 uRotAng = 
		(rotDeg == 0) ? (0<<0) :
		(rotDeg == 90) ? (1<<0) :
		(rotDeg == 180) ? (2<<0) :
		(rotDeg == 270) ? (3<<0) : (0<<0);
    u32 encRotEnBit = (encRotEn == true) ? (1<<4) : (0<<4);

	Assert(rotDeg == 0 || rotDeg == 90 || rotDeg == 180 || rotDeg == 270);

    mfcOutp32(ENC_PIC_ROT_MODE, encRotEnBit|uHorMirMode|uVerMirMode|uRotAng);
}

void MFC_GetEncReconFrameIndex(s32* uEncPicFrmIdx)
{
	*uEncPicFrmIdx = mfcInp32(RET_ENC_PIC_INDEX);
}

void MFC_ClearPending(MFC_INT_FLAG eIntFlag)
{
	mfcOutp32(INT_REASON, 0);
	mfcOutp32(BITS_INT_CLEAR, 1);
}

void MFC_SetUnmask(MFC_INT_FLAG eIntFlag)
{
	u32 uIntDisenBit =
		(eIntFlag == INT_MFC_DNLOAD_DONE) ? INT_DNLOAD_DONE_BIT :
		(eIntFlag == INT_MFC_SEQ_INIT) ? INT_SEQ_INIT_BIT :
		(eIntFlag == INT_MFC_SEQ_END) ? INT_SEQ_END_BIT :
		(eIntFlag == INT_MFC_PIC_RUN) ? INT_PIC_RUN_BIT :
		(eIntFlag == INT_MFC_SET_FRAME_BUF) ? INT_SET_FRAME_BUF :
		(eIntFlag == INT_MFC_ENC_HEADER) ? INT_ENC_HEADER :
		(eIntFlag == INT_MFC_ENC_PARA_SET) ? INT_ENC_PARA_SET :
		(eIntFlag == INT_MFC_DEC_PARA_SET) ? INT_DEC_PARA_SET :	
		(eIntFlag == INT_MFC_BIT_BUF_EMPTY) ? INT_BIT_BUF_EMPTY_BIT :
		(eIntFlag == INT_MFC_BIT_BUF_FULL) ? INT_BIT_BUF_FULL_BIT : 
		(eIntFlag == INT_MFC_ALL) ? INT_ALL_BIT : (0<<0);
	u32 uRegData;
	uRegData = mfcInp32(INT_ENABLE);
	mfcOutp32(INT_ENABLE, uRegData|uIntDisenBit);
}

void MFC_SetMask(MFC_INT_FLAG eIntFlag)
{
	u32 uIntEnBit =
		(eIntFlag == INT_MFC_DNLOAD_DONE) ? INT_DNLOAD_DONE_BIT :
		(eIntFlag == INT_MFC_SEQ_INIT) ? INT_SEQ_INIT_BIT :
		(eIntFlag == INT_MFC_SEQ_END) ? INT_SEQ_END_BIT :
		(eIntFlag == INT_MFC_PIC_RUN) ? INT_PIC_RUN_BIT :
		(eIntFlag == INT_MFC_SET_FRAME_BUF) ? INT_SET_FRAME_BUF :
		(eIntFlag == INT_MFC_ENC_HEADER) ? INT_ENC_HEADER :
		(eIntFlag == INT_MFC_ENC_PARA_SET) ? INT_ENC_PARA_SET :
		(eIntFlag == INT_MFC_DEC_PARA_SET) ? INT_DEC_PARA_SET :				
		(eIntFlag == INT_MFC_BIT_BUF_EMPTY) ? INT_BIT_BUF_EMPTY_BIT :
		(eIntFlag == INT_MFC_BIT_BUF_FULL) ? INT_BIT_BUF_FULL_BIT : 
		(eIntFlag == INT_MFC_ALL) ? INT_ALL_BIT : (0<<0);
	u32 uRegData;
	uRegData = mfcInp32(INT_ENABLE);
	mfcOutp32(INT_ENABLE, uRegData&~uIntEnBit);
}

void MFC_GetIntFlag(MFC_INT_FLAG* eIntFlag)
{
	u32 uIdx;
	u32 uRegData;
	uRegData = mfcInp32(INT_REASON);

	for (uIdx=0; uIdx<16; uIdx++)
	{
		if (uIdx > 7 && uIdx <14)
			continue;
		if (uRegData & (1<<uIdx))		
			break;
	}

	*eIntFlag = 
		(uIdx == 0) ? INT_MFC_DNLOAD_DONE :
		(uIdx == 1) ? INT_MFC_SEQ_INIT :
		(uIdx == 2) ? INT_MFC_SEQ_END :
		(uIdx == 3) ? INT_MFC_PIC_RUN :
		(uIdx == 4) ? INT_MFC_SET_FRAME_BUF :
		(uIdx == 5) ? INT_MFC_ENC_HEADER :
		(uIdx == 6) ? INT_MFC_ENC_PARA_SET :
		(uIdx == 7) ? INT_MFC_DEC_PARA_SET :	
		(uIdx == 14) ? INT_MFC_BIT_BUF_EMPTY : 
		(uIdx == 15) ? INT_MFC_BIT_BUF_FULL : (MFC_INT_FLAG)0xffff;
	
}

void MFC_ResetStreamBufInEncoding(void)
{
	u32 uRegData;

	uRegData = mfcInp32(STREAM_BUF_CTRL);
	mfcOutp32(STREAM_BUF_CTRL, uRegData&~(0x3<<2)|RESET_BUF_AT_EVERY_ENCODING);
}

void MFC_SetFlushingStreamBufModeInEncoding(void)
{
	u32 uRegData;

	uRegData = mfcInp32(STREAM_BUF_CTRL);
	mfcOutp32(STREAM_BUF_CTRL, uRegData&~(0x3<<2)|FLUSH_BUF_IN_ENCODING);
}

void MFC_SetNoFlushingStreamBufModeInEncoding(void)
{
	u32 uRegData;

	uRegData = mfcInp32(STREAM_BUF_CTRL);
	mfcOutp32(STREAM_BUF_CTRL, uRegData&~(0x3<<2)|NOT_FLUSH_BUF_IN_ENCODING);
}

bool MFC_IsMoreStreamNeeded(u32 uProcessIdx, u32 uSzOfCriterion)
{
	u32 uRdPtr;
	u32 uWrPtr;
	
	MFC_GetRdPtr(uProcessIdx, &uRdPtr);
	MFC_GetWrPtr(uProcessIdx, &uWrPtr);	
	
	if ( ((uWrPtr > uRdPtr) && (uWrPtr - uRdPtr < uSzOfCriterion)) ||
		 ((uWrPtr <= uRdPtr) && (uWrPtr + uSzOfCriterion < uRdPtr)) )
	{				
		return true;
	}
	else
	{
		return false;
	}

}

void MFC_GetFrameDelayCount(u32 uProcessIdx, u32* uDelayCount)
{
	*uDelayCount = oMfc.m_uFrameDelayCount[uProcessIdx];
}

void MFC_SetWordData(u32 uAddr, u32 uWordData)
{
	u32 uRegData;
	u32 uTemp, i;
	u32 uRes = uAddr%4;

	if (uRes == 0)
	{
		Outp32(uAddr, uWordData);
	}
	else
	{
		uRegData = mfcInp32(uAddr-uRes);
//		DbgMfc("before: uRegData=0x%x\n",uRegData);
		uRegData &= ((2<<(uRes*8))-1);
//		DbgMfc("after: uRegData=0x%x\n",uRegData);
		
		for (i=uRes; i<4; i++)
		{
			uTemp = (uWordData>>(8*(i-uRes)))&0xff;
			uRegData |= uTemp<<(8*i);
		}
		Outp32(uAddr-uRes, uRegData);
//		DbgMfc("1:uRegData=0x%x\n",uRegData);
		
		uRegData = 0;
		for (i=0; i<uRes; i++)
		{
			uTemp = (uWordData>>(8*(4-uRes+i)))&0xff;
			uRegData |= uTemp<<(8*i);
		}
		Outp32(uAddr+4-uRes, uRegData);
//		DbgMfc("2:uRegData=0x%x\n",uRegData);
	}
}

void MFC_GetDecErrorMbNum(u32* uErrMbNum)
{
	*uErrMbNum = mfcInp32(RET_DEC_PIC_ERR_MB_NUM);
}

// true: I picture, false: P picture
void MFC_IsEncIntraPic(bool* bIsIpicture)
{
	u32 uPicType;
	uPicType = mfcInp32(RET_ENC_PIC_TYPE);
	*bIsIpicture = (uPicType & 0x1) ? false : true;
}

bool MFC_GetEncPicSliceNum(u32 uProcessIdx, u32* uSliceNum)
{
	if (oMfc.m_bSliceInfoReport[uProcessIdx])
	{
	#ifdef DBG_MFC
		u32 i, uSlicePtr;
	#endif
		*uSliceNum = mfcInp32(RET_ENC_PIC_SLICE_NUM);
	#ifdef DBG_MFC
		for (i=0; i< *uSliceNum; i++)
		{
			uSlicePtr = mfcInp32(oMfc.m_uParameterBufStartAddr+0x1200+i*4);
			DbgMfc("[%2d] 0x%x\n", i, uSlicePtr);
		}
	#endif
		return true;
	}
	else
	{
		*uSliceNum = 0;
		return false;
	}
}

void MFC_GetEncMbBit(u32 uFreeMemStAddr, u32 uNumOfMbInWidth, u32 uNumOfMbInHeight)
{
	u32 uAddr;
	u32 uData;
	u16 uData16;
	u32 i=0;
	u32 uMbX, uMbY;

	for (uMbY=0; uMbY<uNumOfMbInHeight; uMbY++)
	{
		DbgMfc("[%2d] ", uMbY);
		for (uMbX=0; uMbX<uNumOfMbInWidth; uMbX++)
		{
			uAddr = oMfc.m_uParameterBufStartAddr + (uMbY*64 + uMbX) * 2;  // 16 bit
			uAddr = (uAddr/4)*4; // multiple of 4
			uData = mfcInp32(uAddr);
			uData16 = (uMbX%2 == 0) ? (uData >> 16) & 0xffff : uData & 0xffff;
			DbgMfc("%4d ", uData16);
			*(u16*)(uFreeMemStAddr+i*2) = uData16;
			i++;
		}
		DbgMfc("\n");
	}
}

void MFC_SetEncHeaderCode(MFC_ENC_HEADER_CODE eEncHeaderCode)
{
	u32 uHeaderCode;
	
	switch(eEncHeaderCode)
	{
		// MPEG-4
		case VOL_HEADER:
			uHeaderCode = 0;
			break;
		case VO_HEADER:
			uHeaderCode = 1;
			break;
		case VOS_HEADER:
			uHeaderCode = 2;
			break;
		case GOV_HEADER:
			uHeaderCode = 3;
			break;
		// H.264	
		case SPS_RBSP:
			uHeaderCode = 0;
			break;
		case PPS_RBSP:
			uHeaderCode = 1;
			break;
		default:
			Assert(0);
	}
	mfcOutp32(ENC_HEADER_CODE, uHeaderCode);
}

void MFC_GetEncHeaderCode(u32 uProcessIdx, MFC_ENC_HEADER_CODE* eEncHeaderCode)
{
	u32 uHeaderCode;

	uHeaderCode = mfcInp32(ENC_HEADER_CODE);

	if (oMfc.m_eCodecMode[uProcessIdx] == MP4_ENC)
	{
		*eEncHeaderCode = 
			(uHeaderCode == 0) ? VOL_HEADER :
			(uHeaderCode == 1) ? VO_HEADER :
			(uHeaderCode == 2) ? VOS_HEADER : GOV_HEADER;
	}
	else if (oMfc.m_eCodecMode[uProcessIdx] == AVC_ENC)
	{
		*eEncHeaderCode = (uHeaderCode == 0) ? SPS_RBSP : PPS_RBSP;
	}
	else
	{
		Assert(0);
	}
	
}

void MFC_SetDecParaSetType(MFC_PARA_SET_TYPE eParaSetType)
{
	u32 uParaSetType = (eParaSetType == SEQ_PARA_SET) ? 0 : 1;

	mfcOutp32(DEC_PARA_SET_TYPE, uParaSetType);	
}

void MFC_GetDecParaSetType(MFC_PARA_SET_TYPE* eParaSetType)
{
	u32 uParaSetType;

	uParaSetType = mfcInp32(DEC_PARA_SET_TYPE);	
	*eParaSetType = (uParaSetType == 0) ? SEQ_PARA_SET : PIC_PARA_SET;	
}

void MFC_SetDecParaSetSize(u32 uRbspBytes)
{
	Assert(uRbspBytes < 512);
	mfcOutp32(DEC_PARA_SET_SIZE, uRbspBytes);
}

void MFC_SetEncParaSetType(MFC_PARA_SET_TYPE eParaSetType)
{
	u32 uParaSetType = (eParaSetType == SEQ_PARA_SET) ? 0 : 1;

	mfcOutp32(ENC_PARA_SET_TYPE, uParaSetType);	
}

void MFC_GetEncParaSetType(MFC_PARA_SET_TYPE* eParaSetType)
{
	u32 uParaSetType;

	uParaSetType = mfcInp32(ENC_PARA_SET_TYPE);	
	*eParaSetType = (uParaSetType == 0) ? SEQ_PARA_SET : PIC_PARA_SET;	
}

void MFC_GetEncParaSetSize(u32* uRbspBytes)
{
	*uRbspBytes = mfcInp32(RET_ENC_PARA_SET_SIZE);
	Assert(*uRbspBytes < 512);
}

void MFC_GetFirmwareVersion(u32* uVersion)
{
	u32 uRegData;

	uRegData = mfcInp32(RET_GET_FW_VER);
	Assert(((uRegData>>16)&0xffff) == 0xf202); // product number
	*uVersion = uRegData&0xffff; // versino number (0xMmrr for M.m.rr)
}

void MFC_NotifyNoMoreStream(u32 uProcessIdx)
{
	Assert(uProcessIdx<MAX_PROCESS_NUM);
	
	oMfc.m_bIsNoMoreStream[uProcessIdx] = true;
	MFC_SetBitstreamEndFlag(true);
}

void MFC_GetNoM