mfc.c

三星 s3c6400测试代码

	oMfc.m_uStride[uProcessIdx] = uStride;
	oMfc.m_uHeight[uProcessIdx] = uHeight;
	
	for (i=0; i<uFrameBufNum; i++)
	{
		oMfc.m_uFrameAddrY[uProcessIdx][i] = uBufAddr;		
		k = uStride * uHeight;
		uBufAddr += k;

		oMfc.m_uFrameAddrCb[uProcessIdx][i] = oMfc.m_uFrameAddrY[uProcessIdx][i] + k;		
		k = (uStride * uHeight) / 4;
		uBufAddr += k;
		
		oMfc.m_uFrameAddrCr[uProcessIdx][i] = oMfc.m_uFrameAddrCb[uProcessIdx][i] + k;		
		uBufAddr += k;
	}
	oMfc.m_uLastFrameBufEndAddr[uProcessIdx] = uBufAddr;
}

void MFC_InitEncFrameBuffer(u32 uProcessIdx, u32 uRefFrameNum, u32 uWidth, u32 uHeight, u32 uRefFrameBufStAddr)
{
	u32 uStride = (uWidth%16 == 0) ? uWidth : (uWidth+15)/16*16;
	u32 uNewHeight = (uHeight%16 == 0) ? uHeight : (uHeight+15)/16*16;	
	u32 k, uBufAddr, i;

	oMfc.m_uStride[uProcessIdx] = uStride;
	oMfc.m_uHeight[uProcessIdx] = uNewHeight;

	uBufAddr = uRefFrameBufStAddr;
	
	// Reference + Reconstruct frame buffer setting
	for (i=0; i<uRefFrameNum; i++)
	{
		oMfc.m_uFrameAddrY[uProcessIdx][i] = uBufAddr;
		k = uStride * uNewHeight;
		uBufAddr += k;

		oMfc.m_uFrameAddrCb[uProcessIdx][i] = oMfc.m_uFrameAddrY[uProcessIdx][i] + k;
		k = (uStride * uNewHeight) / 4;
		uBufAddr += k;
		
		oMfc.m_uFrameAddrCr[uProcessIdx][i] = oMfc.m_uFrameAddrCb[uProcessIdx][i] + k;
		uBufAddr += k;
	}

	oMfc.m_uLastFrameBufEndAddr[uProcessIdx] = uBufAddr;
}


void MFC_ClearFrameBuffer(u32 uProcessIdx, u32 uFrameIdx)
{
	u32 uStride = oMfc.m_uStride[uProcessIdx];
	u32 uHeight = oMfc.m_uHeight[uProcessIdx];
	u32 i;

	Assert(uFrameIdx<MAX_DEC_FRAME);	

	for (i=0; i<uStride*uHeight/4; i++)
		Outp32(oMfc.m_uFrameAddrY[uProcessIdx][uFrameIdx]+i*4, 0);
	for (i=0; i<uStride*uHeight/16; i++)
		Outp32(oMfc.m_uFrameAddrCb[uProcessIdx][uFrameIdx]+i*4, 0x80808080);
	for (i=0; i<uStride*uHeight/16; i++)
		Outp32(oMfc.m_uFrameAddrCr[uProcessIdx][uFrameIdx]+i*4, 0x80808080);

}

void MFC_GetFrameCount(u32* uFrameNum)
{
	*uFrameNum = mfcInp32(RET_PIC_FRAME_NUM);
}


void MFC_GetCurPc(u32* uCurProgCnt)
{
	*uCurProgCnt = mfcInp32(BITS_CUR_PC);
}

void MFC_GetAddrOfYFrame(u32 uProcessIdx, u32 idx, u32* addrY)
{
	Assert(idx<MAX_DEC_FRAME);
	*addrY = oMfc.m_uFrameAddrY[uProcessIdx][idx];
}

void MFC_SetFrameAddr(u32 uProcessIdx, u32 uFrameIdx, u32 uAddrY, u32 uAddrCb, u32 uAddrCr)
{
	oMfc.m_uFrameAddrY[uProcessIdx][uFrameIdx] = uAddrY;
	oMfc.m_uFrameAddrCb[uProcessIdx][uFrameIdx] = uAddrCb;
	oMfc.m_uFrameAddrCr[uProcessIdx][uFrameIdx] = uAddrCr;	
}

void MFC_GetDecReconFrameIndex(u32 uProcessIdx, s32* uDecFrmIdx)
{
	*uDecFrmIdx = mfcInp32(RET_DEC_PIC_INDEX);
}

bool MFC_IsCmdFinished(void)
{
	u32 uRegData;
	uRegData = mfcInp32(RET_SEQ_SUCCESS);
	return (uRegData == 0) ? false : true;
}

void MFC_GetWrPtr(u32 uRunIdx, u32* uWrPtr)
{
	Assert(uRunIdx<MAX_PROCESS_NUM);
	*uWrPtr = mfcInp32(oMfc.m_uBitWrPtr[uRunIdx]);
}

void MFC_GetRdPtr(u32 uRunIdx, u32* uRdPtr)
{
	Assert(uRunIdx<MAX_PROCESS_NUM);
	*uRdPtr = mfcInp32(oMfc.m_uBitRdPtr[uRunIdx]);
}

void MFC_SetRdPtr(u32 uProcessIdx, u32 uRdPtr)
{
	Assert(uProcessIdx<MAX_PROCESS_NUM);
	mfcOutp32(oMfc.m_uBitRdPtr[uProcessIdx], uRdPtr);
}

void MFC_SetWrPtr(u32 uProcessIdx, u32 uWrPtr)
{
	Assert(uProcessIdx<MAX_PROCESS_NUM);
	mfcOutp32(oMfc.m_uBitWrPtr[uProcessIdx], uWrPtr);
}

void MFC_GetWrPtr2(u32 uRunIdx, u32* uWrPtr)
{
	Assert(uRunIdx<MAX_PROCESS_NUM);
	*uWrPtr = mfcInp32(BITS_WR_PTR0);

}

void MFC_GetRdPtr2(u32 uRunIdx, u32* uRdPtr)
{
	Assert(uRunIdx<MAX_PROCESS_NUM);
	 *uRdPtr = mfcInp32(BITS_RD_PTR0);
}

void MFC_SetWrPtr2(u32 uProcessIdx, u32 uWrPtr)
{
	Assert(uProcessIdx<MAX_PROCESS_NUM);
	mfcOutp32(BITS_WR_PTR0, uWrPtr);
}

void MFC_SetRdPtr2(u32 uProcessIdx, u32 uRdPtr)
{
	Assert(uProcessIdx<MAX_PROCESS_NUM);
	mfcOutp32(BITS_RD_PTR0, uRdPtr);
}

void MFC_GetCodecModeByName(const char* fileExt, bool bIsDec, MFC_CODEC_MODE* eCodecMode)
{
	int nMode;
	
	if (fileExt[0] == 'M' && fileExt[1] == '4' && fileExt[2] == 'V')
		nMode = 0;
	else if (fileExt[0] == 'm' && fileExt[1] == '4' && fileExt[2] == 'v')
		nMode = 0;
	else if (fileExt[0] == 'm' && fileExt[1] == 'p' && fileExt[2] == '4')
		nMode = 0;
	else if (fileExt[0] == 'M' && fileExt[1] == 'P' && fileExt[2] == '4')
		nMode = 0;
	else if (fileExt[0] == 'c' && fileExt[1] == 'm' && fileExt[2] == 'p')
		nMode = 0;
	else if (fileExt[0] == 'C' && fileExt[1] == 'M' && fileExt[2] == 'P')
		nMode = 0;		
	else if (fileExt[0] == '2' && fileExt[1] == '6' && fileExt[2] == '3')
		nMode = 0;
	else if (fileExt[1] == 0)
		nMode = 0;
	else if (fileExt[0] == 'j' && fileExt[1] == 's' && fileExt[2] == 'v')
		nMode = 1;
	else if (fileExt[0] == 'J' && fileExt[1] == 'S' && fileExt[2] == 'V')
		nMode = 1;
	else if (fileExt[0] == '2' && fileExt[1] == '6' && fileExt[2] == '4')
		nMode = 1;
	else if (fileExt[0] == '2' && fileExt[1] == '6' && fileExt[2] == 'l')
		nMode = 1;
	else if (fileExt[0] == 'h' && fileExt[1] == '2' && fileExt[2] == '6' && fileExt[3] == '4')
		nMode = 1;		
	else if (fileExt[0] == 'r' && fileExt[1] == 'c' && fileExt[2] == 'v')
		nMode = 2;
	else if (fileExt[0] == 'R' && fileExt[1] == 'C' && fileExt[2] == 'V')
		nMode = 2;			
	else
		nMode = 0;
	
	Assert(nMode >= 0 && nMode < 3);
	if (bIsDec) // for decoding
		*eCodecMode = (nMode == 0) ? MP4_DEC : (nMode == 1) ? AVC_DEC : VC1_DEC;
	else // for encoding
		*eCodecMode = (nMode == 0) ? MP4_ENC : (nMode == 1) ? AVC_ENC : (MFC_CODEC_MODE)0xff;
}

void MFC_GetSrcPicSize(u32 uIdx, u32* uWidth, u32* uHeight)
{
	*uWidth = oMfc.m_uPicX[uIdx];
	*uHeight = oMfc.m_uPicY[uIdx];
}

void MFC_GetFrameSize(u32 uIdx, u32* uStride, u32* uHeight)
{
	*uStride = oMfc.m_uStride[uIdx];
	*uHeight = oMfc.m_uHeight[uIdx];
}

// 0 : IPPP... (only first picture is I)
// 1 : IIII... (no P picture)
// 2 : IPIP...
// 3 : IPPIPPIPP...
void MFC_SetEncGopNum(u32 uGopPicNum)
{
	Assert(uGopPicNum <= 60);
	mfcOutp32(ENC_SEQ_GOP_NUM,  uGopPicNum);
}

void MFC_SetEncCodStd(u32 uCodStd)
{
	Assert(uCodStd <= 2);
	mfcOutp32(ENC_SEQ_COD_STD, uCodStd);
}

void MFC_SetEncSrcFormat(u32 uWidth, u32 uHeight, u32 uFrameRate)
{
	Assert(uWidth<1024);
	Assert(uHeight<1024);
	Assert(uFrameRate<64);
	mfcOutp32(ENC_SEQ_SRC_SIZE, (uWidth << 10) | uHeight);
	mfcOutp32(ENC_SEQ_SRC_FRAME_RATE, uFrameRate);
}

void MFC_SetEncPicQs(MFC_CODEC_MODE eCodecMode, u32 uPicQuantStep)
{
	Assert(((eCodecMode == MP4_ENC) && (uPicQuantStep >= 1) && (uPicQuantStep <= 31))
		|| ((eCodecMode == AVC_ENC) && (uPicQuantStep <= 51)) );
	mfcOutp32(ENC_PIC_QS, uPicQuantStep);
}

void MFC_SetEnc264Parameter(
	int uChromaQpOffset, 
	u32 uConstIntraFlag, 
	u32 uDisableDeblk,
	int uDeblkAlphaOffset,
	int uDeblkBetaOffset)
{
	u32 uChroma;
	u32 uDeblkA;
	u32 uDeblkB;

	Assert((uChromaQpOffset >= -12) && (uChromaQpOffset <= 12));
	Assert(uConstIntraFlag < 2);
	Assert(uDisableDeblk < 3);
	Assert((uDeblkAlphaOffset >= -6) && (uDeblkAlphaOffset <= 6));
	Assert((uDeblkBetaOffset >= -6) && (uDeblkBetaOffset <= 6));

	uChroma = (uChromaQpOffset < 0) ? uChromaQpOffset+32 : uChromaQpOffset;
	uDeblkA = (uDeblkAlphaOffset < 0) ? uDeblkAlphaOffset+16 : uDeblkAlphaOffset;
	uDeblkB = (uDeblkBetaOffset < 0) ? uDeblkBetaOffset+16 : uDeblkBetaOffset;
	
	mfcOutp32(ENC_SEQ_264_PARA, 
		(uDeblkB << 12) | 
		(uDeblkA << 8) | 
		(uDisableDeblk << 6) | 
		(uConstIntraFlag << 5) | 
		uChroma);
}

void MFC_SetEncYuvFileCfg(
	u32 uProcessIdx,
	const char* pFileName,
	u32 uNumOfFrame,
	u32 uWidth,
	u32 uHeight,
	u32 uFrameRate)
{
	Assert(uWidth < 1024);
	Assert(uHeight < 1024);
	Assert(uFrameRate < 64);
	
	strncpy(oMfc.m_EncCfg[uProcessIdx].SrcFileName, pFileName, 255);
	oMfc.m_EncCfg[uProcessIdx].NumOfFrame = uNumOfFrame;
	oMfc.m_EncCfg[uProcessIdx].PicX = uWidth;
	oMfc.m_EncCfg[uProcessIdx].PicY = uHeight;
	oMfc.m_EncCfg[uProcessIdx].FrameRate = uFrameRate;
}

void MFC_SetEncGoldenFileCfg(u32 uProcessIdx, const char* pGoldenYuvName, const char* pGoldenStreamName)
{
	strncpy(oMfc.m_EncCfg[uProcessIdx].GoldenYuvFileName, pGoldenYuvName, 255);
	strncpy(oMfc.m_EncCfg[uProcessIdx].GoldenStreamFileName, pGoldenStreamName, 255);
	DbgMfc("gs=%s\n",oMfc.m_EncCfg[uProcessIdx].GoldenStreamFileName);
	DbgMfc("gy=%s\n",oMfc.m_EncCfg[uProcessIdx].GoldenYuvFileName);
}

void MFC_SetEncSliceCfg(
	u32 uProcessIdx,
	u32 uSliceMode,
	u32 uSliceSizeMode,
	u32 uSliceSizeNum)
{
	Assert(uSliceMode < 2);
	Assert(uSliceSizeMode < 2);
	Assert(uSliceSizeNum < 65536);
	
	// Slice structure
	oMfc.m_EncCfg[uProcessIdx].SliceMode = uSliceMode; // (0 : one slice, 1 : multiple slice)
	oMfc.m_EncCfg[uProcessIdx].SliceSizeMode = uSliceSizeMode; // (0 : slice bit number, 1 : slice mb number)
	oMfc.m_EncCfg[uProcessIdx].SliceSizeNum = uSliceSizeNum;    // (bit count or mb number)
}

void MFC_SetEncErrResilienceCfg(u32 uProcessIdx, u32 uIntraRefreshNum)
{
	Assert(uIntraRefreshNum < 65536);
	// error resilience
	oMfc.m_EncCfg[uProcessIdx].IntraRefreshNum = uIntraRefreshNum; // Intra MB Refresh (0 - None, 1 ~ MbNum-1)
}

void MFC_SetEncMpeg4Cfg(
	u32 uProcessIdx,
	u32 uDataPartEn,
	u32 uRevVlcEn,
	u32 uIntraDcVlcThr,
	u32 uVopQuant,
	u32 uGopPicNum)
{
	Assert(uDataPartEn < 2);
	Assert(uRevVlcEn < 2);
	Assert(uIntraDcVlcThr < 8);
	Assert(uVopQuant < 32);
	Assert(uGopPicNum < 61);
	
	oMfc.m_EncCfg[uProcessIdx].VerId = 2;
	oMfc.m_EncCfg[uProcessIdx].DataPartEn = uDataPartEn;
	oMfc.m_EncCfg[uProcessIdx].RevVlcEn = uRevVlcEn;
	oMfc.m_EncCfg[uProcessIdx].IntraDcVlcThr = uIntraDcVlcThr;
	oMfc.m_EncCfg[uProcessIdx].ShortVideoHeader = 0;  // if 0, MPEG4

	oMfc.m_EncCfg[uProcessIdx].VopQuant = uVopQuant;
	oMfc.m_EncCfg[uProcessIdx].GopPicNum = uGopPicNum;    // (0 : IPPPPPP..., 1 : all I, 3 : I,P,P,I,)
}

void MFC_SetEnc263Cfg(
	u32 uProcessIdx,
	u32 uAnnexI,
	u32 uAnnexJ,
	u32 uAnnexK,
	u32 uAnnexT,
	u32 uVopQuant,
	u32 uGopPicNum)
{
	Assert(uAnnexI == 0); // advance intra coding
	Assert(uAnnexJ < 2); // deblocking filter
	Assert(uAnnexK < 2); // slice structure
	Assert(uAnnexT < 2); // modified quantization
	Assert(uVopQuant < 52);
	Assert(uGopPicNum < 61);
	
	oMfc.m_EncCfg[uProcessIdx].AnnexI = uAnnexI;
	oMfc.m_EncCfg[uProcessIdx].AnnexJ = uAnnexJ;
	oMfc.m_EncCfg[uProcessIdx].AnnexK = uAnnexK;
	oMfc.m_EncCfg[uProcessIdx].AnnexT = uAnnexT;
	oMfc.m_EncCfg[uProcessIdx].ShortVideoHeader = 1;  // if 1, H.263. if 0, MPEG4 

	oMfc.m_EncCfg[uProcessIdx].VopQuant = uVopQuant;
	oMfc.m_EncCfg[uProcessIdx].GopPicNum = uGopPicNum;   // (0 : forbidden, 1 : all I, 3 : I,P,P,I,)
}

void MFC_SetEnc264Cfg(
	u32 uProcessIdx,
	u32 uConstIntraPredFlag,
	u32 uDisableDeblk,
	int uDeblkOffsetA,
	int uDeblkOffsetB,
	int uChromaQpOffset,
	u32 uPicQpY,
	u32 uGopPicNum)
{
	Assert(uConstIntraPredFlag < 2);
	Assert(uDisableDeblk < 3);
	Assert(uDeblkOffsetA   >= -6 && uDeblkOffsetA <= 6);
	Assert(uDeblkOffsetB   >= -6 && uDeblkOffsetB <= 6);
	Assert(uChromaQpOffset   >= -12 && uChromaQpOffset <= 12);
	Assert(uPicQpY < 52);
	Assert(uGopPicNum < 61);
	
	oMfc.m_EncCfg[uProcessIdx].ConstIntraPredFlag = uConstIntraPredFlag;

	// deblocking filter
	oMfc.m_EncCfg[uProcessIdx].DisableDeblk = uDisableDeblk;
	oMfc.m_EncCfg[uProcessIdx].DeblkOffsetA = uDeblkOffsetA;
	oMfc.m_EncCfg[uProcessIdx].DeblkOffsetB = uDeblkOffsetB;
	oMfc.m_EncCfg[uProcessIdx].ChromaQpOffset = uChromaQpOffset;
	oMfc.m_EncCfg[uProcessIdx].PicQpY = uPicQpY;
	oMfc.m_EncCfg[uProcessIdx].GopPicNum = uGopPicNum;
}

void MFC_SetEnc264FmoCfg(u32 uProcessIdx, bool bFmoEnable, u32 uFmoType, u32 uNumOfSliceGroup)
{	
	if (bFmoEnable)
	{
		Assert(uFmoType < 2);
		Assert((uNumOfSliceGroup >= 2) && (uNumOfSliceGroup <= 8));	
	}
	else
	{
		Assert(uNumOfSliceGroup == 1);
	}
	
	oMfc.m_EncCfg[uProcessIdx].FmoEnable = (bFmoEnable) ? 1 : 0;
	oMfc.m_EncCfg[uProcessIdx].NumOfSliceGroup = uNumOfSliceGroup;
	oMfc.m_EncCfg[uProcessIdx].FmoType = uFmoType;
}

void MFC_SetEncRateCtrlCfg(u32 uProcessIdx, u32 uRcEnable, u32 uRcBitRate, u32 uRcInitDelay, u32 uRcBufSize)
{
	Assert(uRcEnable < 2);
	Assert(uRcBitRate < 32768);
	Assert(uRcInitDelay < 65536);
	// rate Control
	oMfc.m_EncCfg[uProcessIdx].RcEnable = uRcEnable;
	oMfc.m_EncCfg[uProcessIdx].RcBitRate = uRcBitRate;
	oMfc.m_EncCfg[uProcessIdx].RcInitDelay = uRcInitDelay;
	oMfc.m_EncCfg[uProcessIdx].RcBufSize = uRcBufSize;		
}


void MFC_GetStreamBufEndAddr(u32 uProcessIdx, u32* uBitBufEndAddr)