/**********************************************************************/ /*************** MTK CONFIDENTIAL ****************/ /*************** ****************/ /*************** Description : MT8118 MTKPrintf ****************/ /*************** Procedure ****************/ /*************** ****************/ /*************** Company : MediaTek Inc. ****************/ /*************** Programmer : Ted Hu ****************/ /**********************************************************************/ #define _VDEC_VERIFY_MAIN_C_ //#include "drv_config.h" //#include "x_ckgen.h" //#include "x_debug.h" #include "vdec_verify_file_common.h" #include "vdec_verify_filesetting.h" //#include "vdec_ide.h" #include "vdec_verify_mm_map.h" #include "vdec_verify_mpv_prov.h" #include "vdec_verify_vdec.h" #include "vdec_verify_vdecode.h" #include "../hal/vdec_hal_if_common.h" #include "vdec_verify_vparser_rm.h" #include "vdec_verify_vparser_vp6.h" #if (!CONFIG_DRV_LINUX) #include #include #include #endif #include #include #include #include #include #include #include #include extern int rand(void); #ifdef SATA_HDD_FS_SUPPORT #include "sata_fs_io.h" //#include "usb_io.h" #endif //#include "x_hal_ic.h" //#include "x_hal_1176.h" void vVDecGconEnable(void); void vVDecClockSelect(void); void vDrmaBusySet(UINT32 u4InstID); BOOL _fgSemaCreated[2] = {FALSE, FALSE}; BOOL _fgMemAllocate = FALSE; // ********************************************************************* // Function : void vVDecReDecSetting(UINT32 u4InstID) // Description : System entry point // Parameter : None // Return : None // ********************************************************************* void vVDecReDecSetting(UINT32 u4InstID, UINT32 u4ReDecPicNum, UINT32 u4ReDecTimes) { #ifdef REDEC _u4ReDecPicNum[u4InstID] = u4ReDecPicNum; _u4ReDecNum[u4InstID] = u4ReDecTimes; #endif } extern char strSrcFileNameExt_FileList[]; extern char strRMSrcFileName[]; extern char strGoldenFileNameExt_FileList[]; extern char strRMGoldenFileName[]; BOOL fgVDecVerify_PrepareInfo_RM(UINT32 u4InstID) { BOOL fgOpen; char strMessage[512]; char strEmuFileName[512]; //Read RM Frame Info from PC _tInFileInfo[u4InstID].fgGetFileInfo = TRUE; _tInFileInfo[u4InstID].pucTargetAddr = _pucRMFrmInfoBuf[u4InstID]; _tInFileInfo[u4InstID].u4TargetSz = RM_FRMINFO_SZ; _tInFileInfo[u4InstID].u4FileLength = 0; _tInFileInfo[u4InstID].u4FileOffset = 0; sprintf(strMessage, "%s: ", _bFileStr1[u4InstID][RM_FRMINFO_INDEX]); vVDecOutputDebugString(strMessage); fgOpen = fgOpenFile(u4InstID, _bFileStr1[u4InstID][RM_FRMINFO_INDEX], "r+b", &_tInFileInfo[u4InstID]); if (fgOpen == FALSE) { vVDecOutputDebugString("Open bit-stream fail\n"); strcpy(_tFileListRecInfo[u4InstID].bFileName, _FileList_Rec[u4InstID]); sprintf(strMessage, "%s", "Open bit-stream fail\n"); fgWrMsg2PC(strMessage, strlen(strMessage), 8, &_tFileListRecInfo[u4InstID]); return FALSE; } if (_u4StartCompPicNum[u4InstID] > 0) { _u4FileCnt[u4InstID] = u4RM_FindIPic(u4InstID, _u4StartCompPicNum[u4InstID]); _u4StartCompPicNum[u4InstID] = _u4FileCnt[u4InstID]; } #ifdef RM_CRCCHECK_ENABLE sprintf(strEmuFileName, "%s/%s%07d%s", _bFileStr1[u4InstID][RM_GOLDENPATH_INDEX], strRMGoldenFileName, _u4FileCnt[u4InstID], strGoldenFileNameExt_FileList); #else //RM_CRCCHECK_ENABLE { UINT32 u4PicCnt = _u4FileCnt[u4InstID]; if (u4PicCnt / 5000 > 0) { sprintf(strEmuFileName, "%s%05d/%s%07d%s", _bFileStr1[u4InstID][RM_GOLDENPATH_INDEX], u4PicCnt / 5000 * 5000, strRMGoldenFileName, _u4FileCnt[u4InstID], strGoldenFileNameExt_FileList); } else { //sprintf(strEmuFileName, "%s/%s%07d%s", _bFileStr1[u4InstID][RM_GOLDENPATH_INDEX], sprintf(strEmuFileName, "%s%s%07d%s", _bFileStr1[u4InstID][RM_GOLDENPATH_INDEX], strRMGoldenFileName, _u4FileCnt[u4InstID], strGoldenFileNameExt_FileList); } } #endif //RM_CRCCHECK_ENABLE //Update File Name #ifdef SATA_HDD_FS_SUPPORT { UINT32 u4PicCnt = _u4FileCnt[u4InstID]; if (u4PicCnt / 5000 > 0) { sprintf(_bFileStr1[u4InstID][1], "%s%05d/%s%07d%s", _bFileStr1[u4InstID][RM_SOURCEPATH_INDEX], u4PicCnt / 5000 * 5000, strRMSrcFileName, _u4FileCnt[u4InstID], strSrcFileNameExt_FileList); } else { //sprintf(strEmuFileName, "%s/%s%07d%s", _bFileStr1[u4InstID][RM_SOURCEPATH_INDEX], sprintf(_bFileStr1[u4InstID][1], "%s%s%07d%s", _bFileStr1[u4InstID][RM_SOURCEPATH_INDEX], strRMSrcFileName, _u4FileCnt[u4InstID], strSrcFileNameExt_FileList); } } #else //SATA_HDD_FS_SUPPORT sprintf(_bFileStr1[u4InstID][1], "%s\\%s%07d%s", _bFileStr1[u4InstID][RM_SOURCEPATH_INDEX], strRMSrcFileName, _u4FileCnt[u4InstID], strSrcFileNameExt_FileList); #endif //SATA_HDD_FS_SUPPORT #ifdef RM_ATSPEED_TEST_ENABLE //AU Info _tInFileInfo[u4InstID].fgGetFileInfo = TRUE; _tInFileInfo[u4InstID].pucTargetAddr = _pucRMAULikeBuf[u4InstID]; _tInFileInfo[u4InstID].u4TargetSz = RM_AULIKEBUF_SZ; _tInFileInfo[u4InstID].u4FileLength = 0; _tInFileInfo[u4InstID].u4FileOffset = 0; sprintf(strMessage, "%s: ", _bFileStr1[u4InstID][RM_AUFIFO_INDEX]); vVDecOutputDebugString(strMessage); fgOpen = fgOpenFile(u4InstID, _bFileStr1[u4InstID][RM_AUFIFO_INDEX], "r+b", &_tInFileInfo[u4InstID]); if (fgOpen == FALSE) { vVDecOutputDebugString("Open bit-stream fail\n"); strcpy(_tFileListRecInfo[u4InstID].bFileName, _FileList_Rec[u4InstID]); sprintf(strMessage, "%s", "Open bit-stream fail\n"); fgWrMsg2PC(strMessage, strlen(strMessage), 8, &_tFileListRecInfo[u4InstID]); return FALSE; } //Checksum Info #if 1 _tInFileInfo[u4InstID].fgGetFileInfo = TRUE; _tInFileInfo[u4InstID].pucTargetAddr = _pucRMChecksumBuf[u4InstID]; _tInFileInfo[u4InstID].u4TargetSz = RM_CHECKSUM_BUFFER_SZ; _tInFileInfo[u4InstID].u4FileLength = 0; _tInFileInfo[u4InstID].u4FileOffset = 0; sprintf(strMessage, "%s: ", _bFileStr1[u4InstID][RM_SUMINFO_INDEX]); vVDecOutputDebugString(strMessage); fgOpen = fgOpenFile(u4InstID, _bFileStr1[u4InstID][RM_SUMINFO_INDEX], "r+b", &_tInFileInfo[u4InstID]); if (fgOpen == FALSE) { vVDecOutputDebugString("Open bit-stream fail\n"); strcpy(_tFileListRecInfo[u4InstID].bFileName, _FileList_Rec[u4InstID]); sprintf(strMessage, "%s", "Open bit-stream fail\n"); fgWrMsg2PC(strMessage, strlen(strMessage), 8, &_tFileListRecInfo[u4InstID]); return FALSE; } #endif //0 #endif //RM_ATSPEED_TEST_ENABLE #ifndef RM_CRCCHECKFLOW_SUPPORT #ifndef RM_ATSPEED_TEST_ENABLE //Read RM Goldem from PC _tInFileInfo[u4InstID].fgGetFileInfo = TRUE; _tInFileInfo[u4InstID].pucTargetAddr = _pucRMGoldenDataBuf[u4InstID]; _tInFileInfo[u4InstID].u4TargetSz = RM_GOLDENDATA_SZ; _tInFileInfo[u4InstID].u4FileLength = 0; _tInFileInfo[u4InstID].u4FileOffset = 0; sprintf(strMessage, "%s: ", _bFileStr1[u4InstID][5]); vVDecOutputDebugString(strMessage); //fgOpen = fgOpenFile(u4InstID, _bFileStr1[u4InstID][5],"r+b", &_tInFileInfo[u4InstID]); fgOpen = fgOpenFile(u4InstID, strEmuFileName, "r+b", &_tInFileInfo[u4InstID]); if (fgOpen == FALSE) { vVDecOutputDebugString("Open bit-stream fail\n"); strcpy(_tFileListRecInfo[u4InstID].bFileName, _FileList_Rec[u4InstID]); sprintf(strMessage, "%s", "Open bit-stream fail\n"); fgWrMsg2PC(strMessage, strlen(strMessage), 8, &_tFileListRecInfo[u4InstID]); return FALSE; } #endif //#ifndef RM_ATSPEED_TEST_ENABLE #endif //RM_CRCCHECKFLOW_SUPPORT #ifdef RM_CRCCHECKFLOW_SUPPORT #ifdef RM_CRCCHECK_ENABLE //Only for CRC Check if (fgRMCheckCRCResult) { _tInFileInfo[u4InstID].fgGetFileInfo = TRUE; _tInFileInfo[u4InstID].pucTargetAddr = _pucRMCRCResultBuf[u4InstID]; _tInFileInfo[u4InstID].u4TargetSz = RM_CRCRESULT_SZ; _tInFileInfo[u4InstID].u4FileLength = 0; _tInFileInfo[u4InstID].u4FileOffset = 0; sprintf(strMessage, "%s: ", _bFileStr1[u4InstID][RM_CRCINFO_INDEX]); vVDecOutputDebugString(strMessage); fgOpen = fgOpenFile(u4InstID, _bFileStr1[u4InstID][RM_CRCINFO_INDEX], "r+b", &_tInFileInfo[u4InstID]); if (fgOpen == FALSE) { vVDecOutputDebugString("Open bit-stream fail\n"); strcpy(_tFileListRecInfo[u4InstID].bFileName, _FileList_Rec[u4InstID]); sprintf(strMessage, "%s", "Open bit-stream fail\n"); fgWrMsg2PC(strMessage, strlen(strMessage), 8, &_tFileListRecInfo[u4InstID]); return FALSE; } } #endif //RM_CRCCHECK_ENABLE #endif //RM_CRCCHECKFLOW_SUPPORT return TRUE; } // ********************************************************************* // Function : void vVDecVerifyThread(UINT32 u4InstID) // Description : System entry point // Parameter : None // Return : None // ********************************************************************* #if MEM_ALLOCATE_IOREMAP #define VDEC_CACHE_PROC (0) #else #define VDEC_CACHE_PROC (1) #endif #if (VDEC_CACHE_PROC) #include #endif extern volatile BOOL g_fgAllocate[2]; UINT32 u4BitStreamLengthH264 = 0; extern UINT32 g_u4AllocSize; char gpfH264LogFileBuffer[4096]; unsigned int gH264logbufferOffset = 0; int gfpH264log = -1; #define H264LOGFILENAME "/mnt/sdcard/H264RISCLog.txt" #define OUTPUT_USB_FILE 0 #ifdef VDEC_VP8_VERIFY_CODE extern void vChkVDec_Webp_Row_Mode(UINT32 u4InstID); extern void vVerInitVDec(UINT32 u4InstID); extern void vVParserProc(UINT32 u4InstID); extern void vVDecProc(UINT32 u4InstID); extern UINT32 vVerVP8DecEndProc_MB_ROW_START(UINT32 u4InstID); extern void vVParserProc(UINT32 u4InstID); extern void vVDecProc(UINT32 u4InstID); extern UINT32 vVerVP8DecEndProc_MB_ROW_START(UINT32 u4InstID); #else extern int vdecwriteFile(int fp, char *buf, int writelen); extern int vdeccloseFile(int fp); #endif int vVDecVerifyThread(void *vpdata) { VDEC_PARAM_T *pparam = vpdata; UINT32 u4InstID; UINT32 u4WmvMode; BOOL fgOpen, fgExistVerifyLoop; BOOL fgMVCType; BOOL fgInit; char strMessage[512]; CHAR strVP6SizeFile[ 512]; u4InstID = pparam->u4InstanceId; _fgMVCType = pparam->fgMVCType; // u4WmvMode = pparam->u4Mode; u4WmvMode = 1;//(UINT32) ppv_param[1]; /* 1: VP6 adobe mode; 0: Open source or multi-stream. */ #if VDEC_CACHE_PROC UINT32 u4FifoDataSize = 0; UINT32 u4MappedVFifoSa = 0; //struct device rDev; #endif { struct device_node *node = NULL; node = of_find_compatible_node(NULL, NULL, "mediatek,VDEC"); VA_VDEC_BASE = (ULONG)of_iomap(node, 0); printk("VA_VDEC_BASE is 0x%lx \n", VA_VDEC_BASE); } { struct device_node *node = NULL; node = of_find_compatible_node(NULL, NULL, "mediatek,VDEC_GCON"); VA_VDEC_GCON_BASE = (ULONG)of_iomap(node, 0); printk("VA_VDEC_GCON_BASE is 0x%lx \n", VA_VDEC_GCON_BASE); } g_fgAllocate[0] = FALSE; g_fgAllocate[1] = FALSE; g_u4AllocSize = 0; printk("u4InstID = %d,u4WmvMode = %d mvc = %d\n", u4InstID, u4WmvMode, _fgMVCType); fgExistVerifyLoop = FALSE; if (u4WmvMode > 0) { _u4WmvMode[u4InstID] = 1; _u4AdobeMode[u4InstID] = 1; } else { _u4WmvMode[u4InstID] = 0; _u4AdobeMode[u4InstID] = 0; } if (_fgMVCType) { _fgMVCBaseGo = FALSE; if (u4InstID == 1) { _fgMVCResReady[0] = FALSE; _fgMVCResReady[1] = FALSE; } while ((u4InstID == 0) && (!_fgMVCBaseGo)) { msleep(5); } } vVDecGconEnable(); #if (CONFIG_DRV_FPGA_BOARD) #else vVDecClockSelect(); #endif vMemoryAllocate(u4InstID); #if VDEC_DRAM_BUSY_TEST vDrmaBusySet(u4InstID); #endif #ifdef SATA_HDD_READ_SUPPORT #ifndef SATA_HDD_FS_SUPPORT fgInitHDDFileAccess(u4InstID); #else //FS mount fgHDDFsMount(0); #endif #endif #if OUTPUT_USB_FILE if (-1 == gfpH264log) { gfpH264log = vdecopenFile((char *)H264LOGFILENAME, O_CREAT | O_WRONLY, 0); if (gfpH264log == -1) { printk("Fs open file fail %d\n", gfpH264log); } else { gH264logbufferOffset = 0; printk("Create H264Log file --> %d \n", gfpH264log); } } #endif #ifdef IDE_READ_SUPPORT _DmxIdeReset(); #endif #ifdef BARREL2_THREAD_SUPPORT if (!_fgSemaCreated[u4InstID]) { VERIFY(x_sema_create(&_ahVDecEndSema[u4InstID], X_SEMA_TYPE_BINARY, X_SEMA_STATE_UNLOCK) == OSR_OK); _fgSemaCreated[u4InstID] = TRUE; } #endif _u4StartCompPicNum[u4InstID] = 0; _u4EndCompPicNum[u4InstID] = 0xffffffff; _u4DumpRegPicNum[u4InstID] = 0xffffffff; _u4MaxReDecBistreamCnt[u4InstID] = 0; #ifdef REDEC //_u4ReDecNum[u4InstID] = 0; //_u4ReDecPicNum[u4InstID] = 0; _u4ReDecCnt[u4InstID] = 0; #endif _u4RedecBistreamCnt[u4InstID] = 0xffffffff; _u4FileCnt[u4InstID] = 0; _u4FileListIdx[u4InstID] = 0; _u4FilePos[u4InstID] = 0; #ifdef WMV_CRC_COMPOSITE_CHECK_ENABLE _u4CRCCnt[u4InstID] = 0; #endif #ifdef VERIFICATION_DOWN_SCALE _fgVDSCLEnableRandomTest[u4InstID] = TRUE; _fgVDSCLEnableLumaKeyTest[u4InstID] = FALSE; #endif #ifdef BARREL2_SUPPORT _u4BSID[u4InstID] = 1; #else _u4BSID[u4InstID] = 0; #endif #if VDEC_DDR3_SUPPORT _u2AddressSwapMode[u4InstID] = ADDRSWAP_DDR3; #else _u2AddressSwapMode[u4InstID] = ADDRSWAP_OFF; #endif fgInit = TRUE; _u4PowerTestInit[u4InstID] = 0; _tFileListInfo[u4InstID].i4FileId = 0xFFFFFFFFFFFFFFFF; while (fgVdecReadFileName(u4InstID, &_tFileListInfo[u4InstID], &_tFileListRecInfo[u4InstID], &_u4StartCompPicNum[u4InstID], &_u4EndCompPicNum[u4InstID], &_u4DumpRegPicNum[u4InstID])) { LOOP: _u4SkipFrameCnt[u4InstID] = 0; _u4PicCnt[u4InstID] = 0; _u4FileCnt[u4InstID] = 0; if (fgExistVerifyLoop) { break; } if (fgInit == TRUE) { if (_u4CodecVer[u4InstID] != VDEC_H265) { _u4StartCompPicNum[u4InstID] = 0; } fgInit = FALSE; } #if VDEC_TEST_ADDSWAP _u2AddressSwapMode[u4InstID] = (UINT16)(((UINT32) rand()) % 8); while (_u2AddressSwapMode[u4InstID] == 3 || _u2AddressSwapMode[u4InstID] == 7) { _u2AddressSwapMode[u4InstID] = (UINT16)(((UINT32) rand()) % 8); } printk("[VDEC] Address Swap Mode = %d\n", _u2AddressSwapMode[u4InstID]); #endif #if VDEC_FIELD_COMPACT _u2AddressSwapMode[u4InstID] = 8; printk("[VDEC] Address Swap Mode = %d, Field Compact Enable\n", _u2AddressSwapMode[u4InstID]); #endif if (!fgVDecAllocWorkBuffer(u4InstID)) { printk("[VDEC]Memory alloc failed\n"); break; } #if ((CONFIG_CHIP_VER_CURR >= CONFIG_CHIP_VER_MT8560) && (!CONFIG_DRV_FPGA_BOARD)) vVDecSetVldMcClk(u4InstID, _u4CodecVer[u4InstID]); #endif #ifdef VDEC_VIDEOCODEC_RM fgOpen = fgVDecVerify_PrepareInfo_RM(u4InstID); if (fgOpen == FALSE) { continue; } #endif //VDEC_VIDEOCODEC_RM #ifdef LETTERBOX_SUPPORT if (_u4CodecVer[u4InstID] == VDEC_H264) { VDEC_INFO_VERIFY_FILE_INFO_T tInFileInfo; tInFileInfo.fgGetFileInfo = TRUE; tInFileInfo.pucTargetAddr = (UCHAR *) _pucSettingFileSa[u4InstID]; tInFileInfo.u4TargetSz = (UINT32) FILE_LIST_SZ; tInFileInfo.u4FileLength = 0; tInFileInfo.u4FileOffset = 0; sprintf(strMessage, "%s: ", _bFileStr1[u4InstID][12]); vVDecOutputDebugString(strMessage); printk("=====> Setting File Name = %s < ===== \n", strMessage); fgOpen = fgOpenFile(u4InstID, _bFileStr1[u4InstID][12], "r+b", &tInFileInfo); if (fgOpen == FALSE) { vVDecOutputDebugString("Open setting file fail\n"); strcpy(_tFileListRecInfo[u4InstID].bFileName, _FileList_Rec[u4InstID]); sprintf(strMessage, "%s", "Open setting file fail\n"); fgWrMsg2PC(strMessage, strlen(strMessage), 8, &_tFileListRecInfo[u4InstID]); vVDecFreeWorkBuffer(u4InstID); continue; } _pcLBDSettingFile[u4InstID] = (char *)_pucSettingFileSa[u4InstID]; tInFileInfo.fgGetFileInfo = TRUE; tInFileInfo.pucTargetAddr = (UCHAR *) _pucGoldenFileSa[u4InstID]; tInFileInfo.u4TargetSz = (UINT32) FILE_LIST_SZ; tInFileInfo.u4FileLength = 0; tInFileInfo.u4FileOffset = 0; sprintf(strMessage, "%s: ", _bFileStr1[u4InstID][13]); vVDecOutputDebugString(strMessage); printk("=====> Golden File Name = %s < ===== \n", strMessage); fgOpen = fgOpenFile(u4InstID, _bFileStr1[u4InstID][13], "r+b", &tInFileInfo); if (fgOpen == FALSE) { vVDecOutputDebugString("Open golden file fail\n"); strcpy(_tFileListRecInfo[u4InstID].bFileName, _FileList_Rec[u4InstID]); sprintf(strMessage, "%s", "Open golden file fail\n"); fgWrMsg2PC(strMessage, strlen(strMessage), 8, &_tFileListRecInfo[u4InstID]); vVDecFreeWorkBuffer(u4InstID); continue; } _pcLBDGoldenFile[u4InstID] = (char *)_pucGoldenFileSa[u4InstID]; } #endif #ifdef RING_VFIFO_SUPPORT _u4LoadBitstreamCnt[u4InstID] = 0; #endif _tInFileInfo[u4InstID].fgGetFileInfo = TRUE; #ifdef RM_RINGVIFO_FLOW _tInFileInfo[u4InstID].pucTargetAddr = (UCHAR *) _pucRMRingWorkBuf[u4InstID]; _tInFileInfo[u4InstID].u4TargetSz = (UINT32) RM_RINGFLOW_TEMPFIFO_SZ; #else //RM_RINGVIFO_FLOW _tInFileInfo[u4InstID].pucTargetAddr = _pucVFifo[u4InstID]; _tInFileInfo[u4InstID].u4TargetSz = V_FIFO_SZ; #endif //RM_RINGVIFO_FLOW _tInFileInfo[u4InstID].u4FileLength = 0; _tInFileInfo[u4InstID].u4FileOffset = 0; sprintf(strMessage, "%s: ", _bFileStr1[u4InstID][1]); vVDecOutputDebugString(strMessage); printk("=====> Test File Name = %s < ===== \n", strMessage); fgOpen = fgOpenFile(u4InstID, _bFileStr1[u4InstID][1], "r+b", &_tInFileInfo[u4InstID]); //Load bitstream //6589NEW (4) error concealment test only #ifdef MPEG4_6589_ERROR_CONCEAL _u4TotalBitstreamLen[u4InstID] = _tInFileInfo[u4InstID].u4FileLength; #endif if (_tInFileInfo[u4InstID].u4FileLength > V_FIFO_SZ) { printk("=====>The Vfifo size is not enough!. \n"); printk("=====>The file's size is 0x%.8x bytes\n", _tInFileInfo[u4InstID].u4FileLength); //continue; } #ifdef RING_VFIFO_SUPPORT _u4LoadBitstreamCnt[u4InstID]++; #endif if (fgOpen == FALSE) { vVDecOutputDebugString("Open bit-stream fail\n"); strcpy(_tFileListRecInfo[u4InstID].bFileName, _FileList_Rec[u4InstID]); sprintf(strMessage, "%s", "Open bit-stream fail\n"); fgWrMsg2PC(strMessage, strlen(strMessage), 8, &_tFileListRecInfo[u4InstID]); #ifdef VDEC_VP8_VERIFY_CODE //vVDecFreeWorkBuffer(u4InstID); #else vVDecFreeWorkBuffer(u4InstID); #endif continue; } else { if ((u4InstID == 1) && _ucMVCType[1]) { _fgMVCReady[0] = TRUE; _fgMVCReady[1] = FALSE; } } //Copy for Temp Buf to VFIFO #ifdef RM_RINGVIFO_FLOW { UINT32 u4VFifoWPtr = (UINT32) _pucVFifo[u4InstID]; UINT32 u4VFIFOSa = (UINT32) _pucVFifo[u4InstID]; UINT32 u4VFIFOSz = (UINT32) V_FIFO_SZ; UINT32 u4TempVFIFOSa = (UINT32) _pucRMRingWorkBuf[u4InstID]; UINT32 u4CopySize = _tInFileInfo[u4InstID].u4FileLength; UINT32 u4RemSz = 0; #ifdef RM_ATSPEED_TEST_ENABLE _tVerMpvDecPrm[u4InstID].SpecDecPrm.rVDecRMDecPrm.u4RMFIFORPtr = (UINT32) _pucRMAULikeBuf[u4InstID]; #else //RM_ATSPEED_TEST_ENABLE _tVerMpvDecPrm[u4InstID].SpecDecPrm.rVDecRMDecPrm.u4RMFIFORPtr = (UINT32) _pucVFifo[u4InstID]; #endif //RM_ATSPEED_TEST_ENABLE if ((u4VFifoWPtr + _tInFileInfo[u4InstID].u4FileLength) < (UINT32)(u4VFIFOSa + u4VFIFOSz)) { memcpy((void *)(u4VFifoWPtr), (void *)u4TempVFIFOSa, u4CopySize); _tVerMpvDecPrm[u4InstID].SpecDecPrm.rVDecRMDecPrm.u4RMVFIFOWPtr = u4VFIFOSa + u4CopySize; } else { u4CopySize = u4VFIFOSa + u4VFIFOSz - u4VFifoWPtr; u4RemSz = _tInFileInfo[u4InstID].u4FileLength - u4CopySize; memcpy((void *)(u4VFifoWPtr), (void *)u4TempVFIFOSa, u4CopySize); memcpy((void *)(u4VFIFOSa), (void *)(u4TempVFIFOSa + u4CopySize), u4RemSz); _tVerMpvDecPrm[u4InstID].SpecDecPrm.rVDecRMDecPrm.u4RMVFIFOWPtr = u4VFIFOSa + u4RemSz; } } #endif //RM_RINGVIFO_FLOW if ((_u4CodecVer[u4InstID] == VDEC_H264) || (_u4CodecVer[u4InstID] == VDEC_MPEG4)) { vAddStartCode2Dram(_pucVFifo[u4InstID] + _tInFileInfo[u4InstID].u4FileLength); } #if VDEC_CACHE_PROC // update physical memory { if (_u4CodecVer[u4InstID] == VDEC_H264) { u4FifoDataSize = _tInFileInfo[u4InstID].u4FileLength + 4; } else { u4FifoDataSize = _tInFileInfo[u4InstID].u4FileLength; } printk("vVDecVerifyThread, update cache to physical mem, addr:0x%x, size:0x%x\n", _pucVFifo[u4InstID], u4FifoDataSize); // tmp: //u4FifoDataSize = V_FIFO_SZ; u4MappedVFifoSa = dma_map_single(NULL, (UINT32)(_pucVFifo[u4InstID]), u4FifoDataSize, DMA_TO_DEVICE); } #endif strcpy(_tFileListRecInfo[u4InstID].bFileName, _FileList_Rec[u4InstID]); sprintf(strMessage, "The bitstream file length / real returns is %d/%d (0x%.8x/0x%.8x)\n", _tInFileInfo[u4InstID].u4FileLength, _tInFileInfo[u4InstID].u4RealGetBytes, _tInFileInfo[u4InstID].u4FileLength, _tInFileInfo[u4InstID].u4RealGetBytes); fgWrMsg2PC(strMessage, strlen(strMessage), 8, &_tFileListRecInfo[u4InstID]); u4BitStreamLengthH264 = _tInFileInfo[u4InstID].u4RealGetBytes; if (_u4CodecVer[u4InstID] == VDEC_VP6) { _rSizeFileInfo.fgGetFileInfo = TRUE; _rSizeFileInfo.pucTargetAddr = _pucSizeFileBuf[u4InstID]; _rSizeFileInfo.u4TargetSz = 1024 * 400;; _rSizeFileInfo.u4FileLength = 0; sprintf(strVP6SizeFile, "%s.size", _bFileStr1[u4InstID][1]); fgOpenFile(u4InstID, strVP6SizeFile, "r+b", &_rSizeFileInfo); if (fgOpen == FALSE) { sprintf(strMessage, "%s", "Open VP6 size fail\n"); fgWrMsg2PC(strMessage, strlen(strMessage), 8, &_tFileListRecInfo[u4InstID]); continue; } if (0 == _u1AlphaBitstream[u4InstID]) { //_fgVP6CRCExist[u4InstID] = fgVP6CRCPatternExist(u4InstID); _fgVP6CRCExist[u4InstID] = 0; } else { _fgVP6CRCExist[u4InstID] = 0; _u4AdobeMode[u4InstID] = 0; } _fgVP6SmallFlolder[u4InstID] = fgVP6SmallFolder(u4InstID); printk(" _fgVP6CRCExist[%u]=%d, _fgVP6SmallFlolder[%u]=%d\n", u4InstID, _fgVP6CRCExist[u4InstID], u4InstID, _fgVP6SmallFlolder[u4InstID]); } // main decoding loop #if VDEC_VP8_WEBP_SUPPORT_ME2_INTEGRATION #ifdef VDEC_VP8_VERIFY_CODE vVerInitVDec(0); vVParserProc(0); vVDecProc(0); while (1) { UINT32 u4RetValue = vVerVP8DecEndProc_MB_ROW_START(0); if (u4RetValue == vVerResult_MB_ROW_DONE) { //printk("======== MB ROW DONE!! ========\n"); } else if (u4RetValue == vVerResult_FRAME_DONE) { printk("======== FRAME DONE!! ========\n"); break; } else { printk("[ERROR]======== decode timeout!! ========\n"); break; } } vChkVDec_Webp_Row_Mode(0); continue; #else break; #endif #else vMpvPlay(u4InstID); #endif #if VDEC_CACHE_PROC printk("vVDecVerifyThread, unmap physical mem, addr:0x%x, size:0x%x\n", _pucVFifo[u4InstID], u4FifoDataSize); dma_unmap_single(NULL, u4MappedVFifoSa, u4FifoDataSize, DMA_TO_DEVICE); #endif _u4StartCompPicNum[u4InstID] = 0; #ifdef VDEC_VP8_VERIFY_CODE //vVDecFreeWorkBuffer(u4InstID); #else if (_u4CodecVer[u4InstID] == VDEC_H265) { vVDecFreeWorkBuffer(u4InstID); } #endif if (_u4DumpRegPicNum[u4InstID] == 99999) { goto LOOP; } } #if VDEC_VP8_WEBP_SUPPORT_ME2_INTEGRATION #else #ifdef PCFILE_WRITE if (_tInFileInfo[u4InstID].pFile) { fclose(_tInFileInfo[u4InstID].pFile); } #endif vVerifyVDecIsrStop(u4InstID); vMemoryFree(u4InstID); if (-1 != gfpH264log) { if (gH264logbufferOffset > 0) { vdecwriteFile(gfpH264log, gpfH264LogFileBuffer, gH264logbufferOffset); } vdeccloseFile(gfpH264log); printk("close H264 log file\n"); } #ifdef SATA_HDD_READ_SUPPORT #ifdef SATA_HDD_FS_SUPPORT if (_tFileListInfo[u4InstID].i4FileId != 0xFFFFFFFFFFFFFFFF) { // fgHDDFsCloseFile(u4InstID); // temp avoid system crash _tFileListInfo[u4InstID].i4FileId = 0xFFFFFFFFFFFFFFFF; } //FS mount fgHDDFsUnMount(0); #endif #endif #endif return 0; } void vSecBSVerifyThread(void *param_array) { #ifdef BARREL2_THREAD_SUPPORT void **ppv_param = (void **)param_array ; UINT32 u4InstID = (UINT32) ppv_param[0]; UINT32 u4SecBSSpec = (UINT32) ppv_param[1]; if (u4SecBSSpec == 0) { VDEC_INFO_WMV_BS_INIT_PRM_T rWmvBSInitPrm; _pucSecVFifo[u4InstID] = (UCHAR *)x_alloc_aligned_nc_mem(1024 * 1024, 1024); x_memset(_pucSecVFifo[u4InstID], 0x73, 1024 * 1024); rWmvBSInitPrm.u4VFifoSa = (UINT32)_pucSecVFifo[u4InstID]; rWmvBSInitPrm.u4VFifoEa = (UINT32)_pucSecVFifo[u4InstID] + 1024 * 1024; rWmvBSInitPrm.u4ReadPointer = (UINT32)_pucSecVFifo[u4InstID]; rWmvBSInitPrm.u4WritePointer = 0xFFFFFFFF; //(UINT32)_pucSecVFifo[u4InstID] + 1024*1024; if (_i4CodecVersion[u4InstID] == VC1) { i4VDEC_HAL_WMV_InitBarrelShifter(1 , u4InstID, &rWmvBSInitPrm, TRUE); } else { i4VDEC_HAL_WMV_InitBarrelShifter(1 , u4InstID, &rWmvBSInitPrm, FALSE); } while (1) { u4VDEC_HAL_WMV_ShiftGetBitStream(1, u4InstID, random(32)); u4VDEC_HAL_WMV_ShiftGetBitStream(1, u4InstID, random(32)); u4VDEC_HAL_WMV_ShiftGetBitStream(1, u4InstID, random(32)); u4VDEC_HAL_WMV_ShiftGetBitStream(1, u4InstID, random(32)); x_thread_delay(1); } } else if (u4SecBSSpec == 1) { VDEC_INFO_H264_BS_INIT_PRM_T rH264BSInitPrm; if (!_fgSemaCreated[u4InstID]) { VERIFY(x_sema_create(&_ahVDecEndSema[u4InstID], X_SEMA_TYPE_BINARY, X_SEMA_STATE_UNLOCK) == OSR_OK); _fgSemaCreated[u4InstID] = TRUE; } _pucSecVFifo[u4InstID] = (UCHAR *)x_alloc_aligned_nc_mem(1024 * 1024, 1024); x_memset(_pucSecVFifo[u4InstID], 0x73, 1024 * 1024); rH264BSInitPrm.u4VFifoSa = (UINT32)_pucSecVFifo[u4InstID]; rH264BSInitPrm.u4VFifoEa = (UINT32)_pucSecVFifo[u4InstID] + 1024 * 1024; rH264BSInitPrm.u4VLDRdPtr = (UINT32)_pucSecVFifo[u4InstID]; rH264BSInitPrm.u4VLDWrPtr = 0xFFFFFFFF;//(UINT32)_pucSecVFifo[u4InstID] + 1024*1024; i4VDEC_HAL_H264_InitBarrelShifter(1, u4InstID, &rH264BSInitPrm); while (1) { VERIFY(x_sema_lock(_ahVDecEndSema[u4InstID], X_SEMA_OPTION_WAIT) == OSR_OK); u4VDEC_HAL_H264_ShiftGetBitStream(1, u4InstID, random(32)); u4VDEC_HAL_H264_ShiftGetBitStream(1, u4InstID, random(32)); u4VDEC_HAL_H264_ShiftGetBitStream(1, u4InstID, random(32)); u4VDEC_HAL_H264_ShiftGetBitStream(1, u4InstID, random(32)); VERIFY(x_sema_unlock(_ahVDecEndSema[u4InstID]) == OSR_OK); x_thread_delay(1); } } #endif } void vVDecGconEnable(void) { i4VDEC_HAL_Common_Gcon_Enable(); } void vVDecClockSelect(void) { i4VDEC_HAL_Common_Init(0); } void vDrmaBusySet(UINT32 u4InstID) { i4VDEC_HAL_Dram_Busy(0, PHYSICAL((UINT32)(_pucDramBusy[u4InstID])), 0x10000); } void vDrmaBusyOff(UINT32 u4InstID) { i4VDEC_HAL_Dram_Busy_Off(0, PHYSICAL((UINT32)(_pucDramBusy[u4InstID])), 0x10000); }