/* * Copyright (c) 2017-2020, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ //! //! \file codechal_decode_vc1_g12.cpp //! \brief Implements the decode interface extension for Gen12 VC1. //! \details Implements all functions required by CodecHal for Gen12 VC1 decoding. //! #include "codeckrnheader.h" #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE) #include "igcodeckrn_g12.h" #endif #include "codechal_decode_vc1_g12.h" #include "codechal_secure_decode_interface.h" #include "mhw_vdbox_mfx_g12_X.h" #include "codechal_mmc_decode_vc1_g12.h" #include "mhw_render_g12_X.h" #include "hal_oca_interface.h" MOS_STATUS CodechalDecodeVc1G12::InitMmcState() { #ifdef _MMC_SUPPORTED m_mmc = MOS_New(CodechalMmcDecodeVc1G12, m_hwInterface, this); CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc); #endif return MOS_STATUS_SUCCESS; } MOS_STATUS CodechalDecodeVc1G12::AllocateStandard( CodechalSetting * settings) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_DECODE_FUNCTION_ENTER; CODECHAL_DECODE_CHK_NULL_RETURN(settings); CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeVc1::AllocateStandard(settings)); #ifdef _MMC_SUPPORTED // Disable Decode MMC for IGFX if (!MEDIA_IS_SKU(m_hwInterface->GetSkuTable(), FtrFlatPhysCCS)) { m_mmc->SetMmcDisabled(); } // To WA invalid aux data caused HW issue when MMC on if (m_mmc->IsMmcEnabled() && (MEDIA_IS_WA(m_waTable, Wa_1408785368) || MEDIA_IS_WA(m_waTable, Wa_22010493002))) { //Add HUC STATE Commands MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams; m_hwInterface->GetHucStateCommandSize( CODECHAL_DECODE_MODE_VC1VLD, &m_HucStateCmdBufferSizeNeeded, &m_HucPatchListSizeNeeded, &stateCmdSizeParams); } #endif if ( MOS_VE_SUPPORTED(m_osInterface)) { static_cast(m_mfxInterface)->DisableScalabilitySupport(); //single pipe VE initialize m_veState = (PCODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE)); CODECHAL_DECODE_CHK_NULL_RETURN(m_veState); CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_InitInterface(m_osInterface, m_veState)); } return eStatus; } MOS_STATUS CodechalDecodeVc1G12::SetGpuCtxCreatOption( CodechalSetting *codecHalSetting) { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_DECODE_FUNCTION_ENTER; if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface)) { CodechalDecode::SetGpuCtxCreatOption(codecHalSetting); } else { m_gpuCtxCreatOpt = MOS_New(MOS_GPUCTX_CREATOPTIONS_ENHANCED); bool sfcInUse = (codecHalSetting->sfcInUseHinted && codecHalSetting->downsamplingHinted && (MEDIA_IS_SKU(m_skuTable, FtrSFCPipe) && !MEDIA_IS_SKU(m_skuTable, FtrDisableVDBox2SFC))); CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_ConstructParmsForGpuCtxCreation( m_veState, (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt, sfcInUse)); m_videoContext = MOS_GPU_CONTEXT_VIDEO; } return eStatus; } MOS_STATUS CodechalDecodeVc1G12::SetFrameStates() { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_DECODE_FUNCTION_ENTER; CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeVc1::SetFrameStates()); if (MOS_VE_SUPPORTED(m_osInterface) && !MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface)) { MOS_VIRTUALENGINE_SET_PARAMS vesetParams; MOS_ZeroMemory(&vesetParams, sizeof(vesetParams)); vesetParams.bSFCInUse = false; vesetParams.bNeedSyncWithPrevious = true; vesetParams.bSameEngineAsLastSubmission = false; CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_SetHintParams(m_veState, &vesetParams)); } #ifdef _MMC_SUPPORTED bool isBPicture = m_mfxInterface->IsVc1BPicture( m_vc1PicParams->CurrPic, m_vc1PicParams->picture_fields.is_first_field, m_vc1PicParams->picture_fields.picture_type); bool isOverlapSmoothingFilter = false; isOverlapSmoothingFilter |= m_vc1PicParams->sequence_fields.AdvancedProfileFlag && m_vc1PicParams->sequence_fields.overlap; isOverlapSmoothingFilter |= !(isBPicture || (m_vc1PicParams->pic_quantizer_fields.pic_quantizer_scale < 9) || !m_vc1PicParams->sequence_fields.overlap); isOverlapSmoothingFilter |= m_intelEntrypointInUse && (m_mode == CODECHAL_DECODE_MODE_VC1VLD) && m_vc1PicParams->conditional_overlap_flag; //For VC1 frame with overlap smoothing filter enabled, force to post-deblock if MMC on if (m_mmc && m_mmc->IsMmcEnabled() && isOverlapSmoothingFilter) { m_deblockingEnabled = true; } #endif return eStatus; } MOS_STATUS CodechalDecodeVc1G12::DecodeStateLevel() { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_DECODE_FUNCTION_ENTER; #ifdef _MMC_SUPPORTED // To make sure aux table is clear when MMC off(IGFX) // Can not clear aux table for DGFX because of stolen memory if (!m_mmc->IsMmcEnabled() && !Mos_ResourceIsNull(&m_destSurface.OsResource) && m_destSurface.OsResource.bConvertedFromDDIResource) { if (m_secureDecoder && m_secureDecoder->IsAuxDataInvalid(&m_destSurface.OsResource)) { // Not use CODECHAL_DECODE_CHK_STATUS_RETURN() here to avoid adding local variable // Error can still be caught by CODECHAL_DECODE_CHK_STATUS_RETURN() in InitAuxSurface CODECHAL_DECODE_VERBOSEMESSAGE("Clear CCS for secure decode before frame %d submission", m_frameNum); CODECHAL_DECODE_CHK_STATUS_RETURN(m_secureDecoder->InitAuxSurface(&m_destSurface.OsResource, false, true)); } else { CODECHAL_DECODE_VERBOSEMESSAGE("Clear CCS by Huc Copy before frame %d submission", m_frameNum); CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast(m_mmc)->ClearAuxSurf( this, m_miInterface, &m_destSurface.OsResource, m_veState)); } } #endif PCODEC_REF_LIST *vc1RefList; vc1RefList = &(m_vc1RefList[0]); uint8_t destIdx = m_vc1PicParams->CurrPic.FrameIdx; uint8_t fwdRefIdx = (uint8_t)m_vc1PicParams->ForwardRefIdx; uint8_t bwdRefIdx = (uint8_t)m_vc1PicParams->BackwardRefIdx; bool isIPicture = m_mfxInterface->IsVc1IPicture( m_vc1PicParams->CurrPic, m_vc1PicParams->picture_fields.is_first_field, m_vc1PicParams->picture_fields.picture_type) ? true : false; bool isPPicture = m_mfxInterface->IsVc1PPicture( m_vc1PicParams->CurrPic, m_vc1PicParams->picture_fields.is_first_field, m_vc1PicParams->picture_fields.picture_type) ? true : false; bool isBPicture = m_mfxInterface->IsVc1BPicture( m_vc1PicParams->CurrPic, m_vc1PicParams->picture_fields.is_first_field, m_vc1PicParams->picture_fields.picture_type) ? true : false; PMOS_SURFACE destSurface; PMOS_RESOURCE fwdRefSurface, bwdRefSurface; if (m_unequalFieldWaInUse && CodecHal_PictureIsField(m_vc1PicParams->CurrPic)) { destSurface = &(m_unequalFieldSurface[vc1RefList[destIdx]->dwUnequalFieldSurfaceIdx]); fwdRefSurface = &(m_unequalFieldSurface[vc1RefList[fwdRefIdx]->dwUnequalFieldSurfaceIdx].OsResource); bwdRefSurface = &(m_unequalFieldSurface[vc1RefList[bwdRefIdx]->dwUnequalFieldSurfaceIdx].OsResource); // Overwrite the actual surface height with the coded height and width of the frame // for VC1 since it's possible for a VC1 frame to change size during playback destSurface->dwWidth = m_width; destSurface->dwHeight = m_height; } else { destSurface = &m_destSurface; fwdRefSurface = &(vc1RefList[fwdRefIdx]->resRefPic); bwdRefSurface = &(vc1RefList[bwdRefIdx]->resRefPic); } // WA for SP/MP short format if (m_shortFormatInUse && !m_vc1PicParams->sequence_fields.AdvancedProfileFlag) { CODECHAL_DECODE_CHK_STATUS_RETURN(ConstructBistreamBuffer()); } MOS_COMMAND_BUFFER cmdBuffer; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0)); auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex); HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters); MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams; MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS)); forceWakeupParams.bMFXPowerWellControl = true; forceWakeupParams.bMFXPowerWellControlMask = true; forceWakeupParams.bHEVCPowerWellControl = false; forceWakeupParams.bHEVCPowerWellControlMask = true; CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd( &cmdBuffer, &forceWakeupParams)); MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams; pipeModeSelectParams.Mode = m_mode; pipeModeSelectParams.bStreamOutEnabled = m_streamOutEnabled; pipeModeSelectParams.bPostDeblockOutEnable = m_deblockingEnabled; pipeModeSelectParams.bPreDeblockOutEnable = !m_deblockingEnabled; pipeModeSelectParams.bShortFormatInUse = m_shortFormatInUse; pipeModeSelectParams.bVC1OddFrameHeight = m_vc1OddFrameHeight; MHW_VDBOX_SURFACE_PARAMS surfaceParams; MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams)); surfaceParams.Mode = m_mode; surfaceParams.psSurface = destSurface; MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams; pipeBufAddrParams.Mode = m_mode; if (m_deblockingEnabled) { pipeBufAddrParams.psPostDeblockSurface = destSurface; } else { pipeBufAddrParams.psPreDeblockSurface = destSurface; } #ifdef _MMC_SUPPORTED CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(&pipeBufAddrParams)); #endif // when there is not a forward or backward reference, // the index is set to the destination frame index m_presReferences[CodechalDecodeFwdRefTop] = m_presReferences[CodechalDecodeFwdRefBottom] = fwdRefSurface; m_presReferences[CodechalDecodeBwdRefTop] = m_presReferences[CodechalDecodeBwdRefBottom] = bwdRefSurface; // special case for second fields if (!m_vc1PicParams->picture_fields.is_first_field && !m_mfxInterface->IsVc1IPicture( m_vc1PicParams->CurrPic, m_vc1PicParams->picture_fields.is_first_field, m_vc1PicParams->picture_fields.picture_type)) { if (m_vc1PicParams->picture_fields.top_field_first) { m_presReferences[CodechalDecodeFwdRefTop] = &destSurface->OsResource; } else { m_presReferences[CodechalDecodeFwdRefBottom] = &destSurface->OsResource; } } // set all ref pic addresses to valid addresses for error concealment purpose for (uint32_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_NON_AVC; i++) { if (m_presReferences[i] == nullptr && MEDIA_IS_WA(m_waTable, WaDummyReference) && !Mos_ResourceIsNull(&m_dummyReference.OsResource)) { m_presReferences[i] = &m_dummyReference.OsResource; } } CODECHAL_DECODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(pipeBufAddrParams.presReferences, sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_NON_AVC, m_presReferences, sizeof(PMOS_RESOURCE) * CODEC_MAX_NUM_REF_FRAME_NON_AVC)); pipeBufAddrParams.presMfdDeblockingFilterRowStoreScratchBuffer = &m_resMfdDeblockingFilterRowStoreScratchBuffer; if (m_streamOutEnabled) { pipeBufAddrParams.presStreamOutBuffer = &(m_streamOutBuffer[m_streamOutCurrBufIdx]); } #ifdef _MMC_SUPPORTED CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->CheckReferenceList(&pipeBufAddrParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetRefrenceSync(m_disableDecodeSyncLock, m_disableLockForTranscode)); #endif CODECHAL_DEBUG_TOOL( for (int i = 0; i < CODEC_MAX_NUM_REF_FRAME_NON_AVC; i++) { if (pipeBufAddrParams.presReferences[i]) { MOS_SURFACE dstSurface; MOS_ZeroMemory(&dstSurface, sizeof(MOS_SURFACE)); dstSurface.Format = Format_NV12; dstSurface.OsResource = *(pipeBufAddrParams.presReferences[i]); CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo( m_osInterface, &dstSurface)); m_debugInterface->m_refIndex = (uint16_t)i; std::string refSurfName = "RefSurf[" + std::to_string(static_cast(m_debugInterface->m_refIndex)) + "]"; CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface( &dstSurface, CodechalDbgAttr::attrDecodeReferenceSurfaces, refSurfName.data())); } } ) MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams; MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams)); indObjBaseAddrParams.Mode = m_mode; if (m_shortFormatInUse && !m_vc1PicParams->sequence_fields.AdvancedProfileFlag) { indObjBaseAddrParams.dwDataSize = m_dataSize + CODECHAL_DECODE_VC1_STUFFING_BYTES; indObjBaseAddrParams.presDataBuffer = &m_resPrivateBistreamBuffer; } else { indObjBaseAddrParams.dwDataSize = m_dataSize; indObjBaseAddrParams.presDataBuffer = &m_resDataBuffer; } MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS bspBufBaseAddrParams; MOS_ZeroMemory(&bspBufBaseAddrParams, sizeof(bspBufBaseAddrParams)); bspBufBaseAddrParams.presBsdMpcRowStoreScratchBuffer = &m_resBsdMpcRowStoreScratchBuffer; if (m_vc1PicParams->raw_coding.bitplane_present || m_shortFormatInUse) { bspBufBaseAddrParams.presBitplaneBuffer = &m_resBitplaneBuffer; } MHW_VDBOX_VC1_PRED_PIPE_PARAMS vc1PredPipeParams; vc1PredPipeParams.pVc1PicParams = m_vc1PicParams; vc1PredPipeParams.ppVc1RefList = vc1RefList; MHW_VDBOX_VC1_PIC_STATE vc1PicState; vc1PicState.pVc1PicParams = m_vc1PicParams; vc1PicState.Mode = m_mode; vc1PicState.ppVc1RefList = vc1RefList; vc1PicState.wPrevAnchorPictureTFF = m_prevAnchorPictureTff; vc1PicState.bPrevEvenAnchorPictureIsP = m_prevEvenAnchorPictureIsP; vc1PicState.bPrevOddAnchorPictureIsP = m_prevOddAnchorPictureIsP; if (m_shortFormatInUse) { // WA for WMP. WMP does not provide REFDIST for I/P pictures correctly if (m_vc1PicParams->sequence_fields.AdvancedProfileFlag && CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && (isIPicture || isPPicture) && m_vc1PicParams->reference_fields.reference_distance_flag) { if (m_vc1PicParams->picture_fields.is_first_field) { CODECHAL_DECODE_CHK_STATUS_RETURN(ParsePictureHeader()); m_referenceDistance = m_vc1PicParams->reference_fields.reference_distance; } else { m_vc1PicParams->reference_fields.reference_distance = m_referenceDistance; } } // WA for WMP. WMP does not provide BFRACTION correctly. So parse picture header to get BFRACTION if (isBPicture) { if (m_vc1PicParams->picture_fields.is_first_field) { CODECHAL_DECODE_CHK_STATUS_RETURN(ParsePictureHeader()); } } } MHW_VDBOX_VC1_DIRECTMODE_PARAMS vc1DirectmodeParams; if (m_mode == CODECHAL_DECODE_MODE_VC1VLD) { uint8_t dmvBufferIdx = (m_vc1PicParams->CurrPic.PicFlags == PICTURE_BOTTOM_FIELD) ? CODECHAL_DECODE_VC1_DMV_ODD : CODECHAL_DECODE_VC1_DMV_EVEN; vc1DirectmodeParams.presDmvReadBuffer = &m_resVc1BsdMvData[dmvBufferIdx]; vc1DirectmodeParams.presDmvWriteBuffer = &m_resVc1BsdMvData[dmvBufferIdx]; } CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, !m_olpNeeded)); if (m_statusQueryReportingEnabled) { CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer)); } if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && m_vc1PicParams->picture_fields.picture_type == vc1SkippedFrame) { // no further picture level commands needed for skipped frames m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0); return eStatus; } CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(&cmdBuffer, &pipeModeSelectParams)); #ifdef _MMC_SUPPORTED CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetSurfaceState(&surfaceParams)); #endif CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(&cmdBuffer, &surfaceParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(&cmdBuffer, &pipeBufAddrParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(&cmdBuffer, &indObjBaseAddrParams)); if (m_mode == CODECHAL_DECODE_MODE_VC1VLD) { CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxBspBufBaseAddrCmd(&cmdBuffer, &bspBufBaseAddrParams)); } CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxVc1PredPipeCmd(&cmdBuffer, &vc1PredPipeParams)); if (m_intelEntrypointInUse || m_mode == CODECHAL_DECODE_MODE_VC1IT) { CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxVc1LongPicCmd(&cmdBuffer, &vc1PicState)); } else if (m_shortFormatInUse) { CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1ShortPicCmd(&cmdBuffer, &vc1PicState)); } else { CODECHAL_DECODE_ASSERTMESSAGE("Unsupported decode mode."); eStatus = MOS_STATUS_UNKNOWN; return eStatus; } if (m_mode == CODECHAL_DECODE_MODE_VC1VLD) { CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxVc1DirectmodeCmd(&cmdBuffer, &vc1DirectmodeParams)); } m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0); return eStatus; } MOS_STATUS CodechalDecodeVc1G12::DecodePrimitiveLevelVLD() { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_DECODE_FUNCTION_ENTER; MOS_SYNC_PARAMS syncParams; // static VC1 slice parameters MHW_VDBOX_VC1_SLICE_STATE vc1SliceState; vc1SliceState.presDataBuffer = &m_resDataBuffer; uint16_t frameFieldHeightInMb; CodecHal_GetFrameFieldHeightInMb( m_vc1PicParams->CurrPic, m_picHeightInMb, frameFieldHeightInMb); CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface); MOS_COMMAND_BUFFER cmdBuffer; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0)); if (m_incompletePicture) { MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams; MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS)); forceWakeupParams.bMFXPowerWellControl = true; forceWakeupParams.bMFXPowerWellControlMask = true; forceWakeupParams.bHEVCPowerWellControl = false; forceWakeupParams.bHEVCPowerWellControlMask = true; CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd( &cmdBuffer, &forceWakeupParams)); } if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && m_vc1PicParams->picture_fields.picture_type == vc1SkippedFrame) { if (!bSkipFrameReported) { MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData; MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData)); userFeatureWriteData.Value.i32Data = true; userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_SKIP_FRAME_IN_USE_ID; MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext); bSkipFrameReported = true; } CODECHAL_DECODE_CHK_STATUS_RETURN(HandleSkipFrame()); goto submit; } else { PCODEC_VC1_SLICE_PARAMS slc = m_vc1SliceParams; bool firstValidSlice = true; int prevValidSlc = 0; for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++) { m_vldSliceRecord[slcCount].dwSliceYOffset = slc->slice_vertical_position; m_vldSliceRecord[slcCount].dwNextSliceYOffset = frameFieldHeightInMb; // init to last slice int32_t lLength = slc->slice_data_size >> 3; int32_t lOffset = slc->macroblock_offset >> 3; CodechalResLock ResourceLock(m_osInterface, &m_resDataBuffer); auto buf = (uint8_t*)ResourceLock.Lock(CodechalResLock::readOnly); if(buf != nullptr) { buf += slc->slice_data_offset; } if (lOffset > 3 && buf != nullptr && m_vc1PicParams->sequence_fields.AdvancedProfileFlag) { int i = 0; int j = 0; for (i = 0, j = 0; i < lOffset - 1; i++, j++) { if (!buf[j] && !buf[j + 1] && buf[j + 2] == 3 && buf[j + 3] < 4) { i++, j += 2; } } if (i == lOffset - 1) { if (!buf[j] && !buf[j + 1] && buf[j + 2] == 3 && buf[j + 3] < 4) { buf[j + 2] = 0; j++; } j++; } lOffset = (8 * j + slc->macroblock_offset % 8)>>3; } // Check that the slice data does not overrun the bitstream buffer size if ((slc->slice_data_offset + lLength) > m_dataSize) { lLength = m_dataSize - slc->slice_data_offset; if (lLength < 0) { lLength = 0; } } // Error handling for garbage data if (slc->slice_data_offset > m_dataSize) { slc++; m_vldSliceRecord[slcCount].dwSkip = true; continue; } // Check offset not larger than slice length, can have slice length of 0 if (lOffset > lLength) { slc++; m_vldSliceRecord[slcCount].dwSkip = true; continue; } // Check that the slices do not overlap, else do not send the lower slice if (!firstValidSlice && (m_vldSliceRecord[slcCount].dwSliceYOffset <= m_vldSliceRecord[prevValidSlc].dwSliceYOffset)) { slc++; m_vldSliceRecord[slcCount].dwSkip = true; continue; } if (firstValidSlice) { // Ensure that the first slice starts from 0 m_vldSliceRecord[slcCount].dwSliceYOffset = 0; slc->slice_vertical_position = 0; } else { // Set next slice start Y offset of previous slice m_vldSliceRecord[prevValidSlc].dwNextSliceYOffset = m_vldSliceRecord[slcCount].dwSliceYOffset; } if (m_shortFormatInUse) { if (m_vc1PicParams->sequence_fields.AdvancedProfileFlag) { if ((slc->macroblock_offset >> 3) < CODECHAL_DECODE_VC1_SC_PREFIX_LENGTH) { slc++; m_vldSliceRecord[slcCount].dwSkip = true; continue; } // set macroblock_offset of the first slice to 0 to avoid crash if (slcCount == 0) { slc->macroblock_offset = CODECHAL_DECODE_VC1_SC_PREFIX_LENGTH << 3; } lOffset = CODECHAL_DECODE_VC1_SC_PREFIX_LENGTH; } else // Simple Profile or Main Profile { { lOffset = CODECHAL_DECODE_VC1_STUFFING_BYTES - 1; lLength += CODECHAL_DECODE_VC1_STUFFING_BYTES; slc->macroblock_offset += CODECHAL_DECODE_VC1_STUFFING_BYTES << 3; slc->macroblock_offset &= (~0x7); // Clear bit offset of first MB for short format } } } m_vldSliceRecord[slcCount].dwOffset = lOffset; m_vldSliceRecord[slcCount].dwLength = lLength - lOffset; firstValidSlice = false; prevValidSlc = slcCount; slc++; } if (m_shortFormatInUse && m_vc1PicParams->sequence_fields.AdvancedProfileFlag) { CODECHAL_DECODE_CHK_STATUS_RETURN(GetSliceMbDataOffset()); } // Reset slc pointer slc -= m_numSlices; //------------------------------------ // Fill BSD Object Commands //------------------------------------ for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++) { if (m_vldSliceRecord[slcCount].dwSkip) { slc++; continue; } vc1SliceState.pSlc = slc; vc1SliceState.dwOffset = m_vldSliceRecord[slcCount].dwOffset; vc1SliceState.dwLength = m_vldSliceRecord[slcCount].dwLength; vc1SliceState.dwNextVerticalPosition = m_vldSliceRecord[slcCount].dwNextSliceYOffset; CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1BsdObjectCmd(&cmdBuffer, &vc1SliceState)); slc++; } // Free VLD slice record MOS_ZeroMemory(m_vldSliceRecord, (m_numSlices * sizeof(CODECHAL_VC1_VLD_SLICE_RECORD))); } // Check if destination surface needs to be synchronized if (m_unequalFieldWaInUse && CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && !m_vc1PicParams->picture_fields.is_first_field) { MHW_MI_FLUSH_DW_PARAMS flushDwParams; MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams)); } else { // Check if destination surface needs to be synchronized syncParams = g_cInitSyncParams; syncParams.GpuContext = m_videoContext; syncParams.presSyncResource = &m_destSurface.OsResource; syncParams.bReadOnly = false; syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock; syncParams.bDisableLockForTranscode = m_disableLockForTranscode; if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic) || m_vc1PicParams->picture_fields.is_first_field) { CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams)); // Update the resource tag (s/w tag) for On-Demand Sync m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams); } MHW_MI_FLUSH_DW_PARAMS flushDwParams; MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams)); // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag if (m_osInterface->bTagResourceSync && !(CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && m_vc1PicParams->picture_fields.is_first_field)) { CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams)); } } submit: if (m_statusQueryReportingEnabled) { CodechalDecodeStatusReport decodeStatusReport; decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber; decodeStatusReport.m_currDecodedPic = m_vc1PicParams->CurrPic; if (m_olpNeeded) { CODECHAL_DEBUG_TOOL( decodeStatusReport.m_currDeblockedPic.FrameIdx = (uint8_t)m_vc1PicParams->DeblockedPicIdx; decodeStatusReport.m_currDeblockedPic.PicFlags = PICTURE_FRAME;) decodeStatusReport.m_deblockedPicResOlp = m_deblockSurface.OsResource; } else { decodeStatusReport.m_currDeblockedPic = m_vc1PicParams->CurrPic; } decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE; decodeStatusReport.m_currDecodedPicRes = m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx]->resRefPic; CODECHAL_DEBUG_TOOL( decodeStatusReport.m_secondField = (m_vc1PicParams->picture_fields.is_first_field == 1) ? false : true; decodeStatusReport.m_olpNeeded = m_olpNeeded; decodeStatusReport.m_frameType = m_perfType;) CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(decodeStatusReport, &cmdBuffer)); } #if (_DEBUG || _RELEASE_INTERNAL) uint32_t curIdx = (GetDecodeStatusBuf()->m_currIndex + CODECHAL_DECODE_STATUS_NUM - 1) % CODECHAL_DECODE_STATUS_NUM; uint32_t frameCrcOffset = curIdx * sizeof(CodechalDecodeStatus) + GetDecodeStatusBuf()->m_decFrameCrcOffset + sizeof(uint32_t) * 2; std::vector vSemaResource{GetDecodeStatusBuf()->m_statusBuffer}; m_debugInterface->DetectCorruptionHw(m_hwInterface, &m_frameCountTypeBuf, curIdx, frameCrcOffset, vSemaResource, &cmdBuffer, m_frameNum); #endif CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr)); m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0); CODECHAL_DEBUG_TOOL( CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer( &cmdBuffer, CODECHAL_NUM_MEDIA_STATES, "_DEC")); //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands( // m_debugInterface, // &cmdBuffer)); ) if ( MOS_VE_SUPPORTED(m_osInterface)) { CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, false); } if (m_huCCopyInUse) { syncParams = g_cInitSyncParams; syncParams.GpuContext = m_videoContextForWa; syncParams.presSyncResource = &m_resSyncObjectWaContextInUse; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams)); syncParams = g_cInitSyncParams; syncParams.GpuContext = m_videoContext; syncParams.presSyncResource = &m_resSyncObjectWaContextInUse; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams)); m_huCCopyInUse = false; } HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface); CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw)); CODECHAL_DEBUG_TOOL( m_mmc->UpdateUserFeatureKey(&m_destSurface);) if (m_unequalFieldWaInUse && CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && !m_vc1PicParams->picture_fields.is_first_field) { CODECHAL_DECODE_CHK_NULL_RETURN(m_vc1RefList); uint32_t destFrameIdx = m_vc1PicParams->CurrPic.FrameIdx; CODECHAL_DECODE_CHK_STATUS_RETURN(FormatUnequalFieldPicture( m_unequalFieldSurface[m_vc1RefList[destFrameIdx]->dwUnequalFieldSurfaceIdx], m_destSurface, true, m_videoContextUsesNullHw ? true : false)); } if (m_olpNeeded) { if (!bOlpReported) { MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData; MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData)); userFeatureWriteData.Value.i32Data = m_olpNeeded; userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_OLP_IN_USE_ID; MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext); bOlpReported = true; } CODECHAL_DECODE_CHK_STATUS_RETURN(PerformVc1Olp()); } else { if (m_statusQueryReportingEnabled) { CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_videoContextUsesNullHw)); } } // Needs to be re-set for Linux buffer re-use scenarios m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx]->resRefPic = m_destSurface.OsResource; // Send the signal to indicate decode completion, in case On-Demand Sync is not present if (!(CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && m_vc1PicParams->picture_fields.is_first_field)) { MOS_SYNC_PARAMS syncParams; syncParams = g_cInitSyncParams; syncParams.GpuContext = m_videoContext; syncParams.presSyncResource = &m_destSurface.OsResource; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams)); if (m_olpNeeded) { syncParams = g_cInitSyncParams; syncParams.GpuContext = m_renderContext; syncParams.presSyncResource = &m_deblockSurface.OsResource; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams)); } } m_olpNeeded = false; return eStatus; } MOS_STATUS CodechalDecodeVc1G12::DecodePrimitiveLevelIT() { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_DECODE_FUNCTION_ENTER; MOS_SYNC_PARAMS syncParams; PCODEC_VC1_MB_PARAMS mb = m_vc1MbParams; MHW_VDBOX_VC1_MB_STATE vc1MbState; MOS_ZeroMemory(&vc1MbState, sizeof(vc1MbState)); // static VC1 MB parameters vc1MbState.presDataBuffer = &m_resDataBuffer; vc1MbState.pVc1PicParams = m_vc1PicParams; vc1MbState.pWaTable = m_waTable; vc1MbState.pDeblockDataBuffer = m_deblockDataBuffer; vc1MbState.dwDataSize = m_dataSize; vc1MbState.wPicWidthInMb = m_picWidthInMb; vc1MbState.wPicHeightInMb = m_picHeightInMb; vc1MbState.PicFlags = m_vc1PicParams->CurrPic.PicFlags; vc1MbState.bFieldPolarity = m_fieldPolarity; uint16_t frameFieldHeightInMb; CodecHal_GetFrameFieldHeightInMb( m_vc1PicParams->CurrPic, m_picHeightInMb, frameFieldHeightInMb); CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface); MOS_COMMAND_BUFFER cmdBuffer; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0)); if (m_incompletePicture) { MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams; MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS)); forceWakeupParams.bMFXPowerWellControl = true; forceWakeupParams.bMFXPowerWellControlMask = true; forceWakeupParams.bHEVCPowerWellControl = false; forceWakeupParams.bHEVCPowerWellControlMask = true; CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd( &cmdBuffer, &forceWakeupParams)); } CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(&cmdBuffer, &m_itObjectBatchBuffer)); CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_LockBb(m_osInterface, &m_itObjectBatchBuffer)); PMHW_BATCH_BUFFER batchBuffer = &m_itObjectBatchBuffer; uint32_t mbAddress = 0; uint32_t mbCount; for (mbCount = 0; mbCount < m_numMacroblocks; mbCount++) { vc1MbState.pMb = mb + mbCount; // Skipped MBs before current MB uint16_t skippedMBs = (mbCount) ? (mb[mbCount].mb_address - mb[mbCount - 1].mb_address - 1) : (mb[mbCount].mb_address); while (skippedMBs--) { vc1MbState.bMbHorizOrigin = (uint8_t)(mbAddress % m_picWidthInMb); vc1MbState.bMbVertOrigin = (uint8_t)(mbAddress / m_picWidthInMb); vc1MbState.bSkipped = true; CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1ItObjectCmd(batchBuffer, &vc1MbState)); mbAddress++; } // Current MB if (mbCount + 1 == m_numMacroblocks) { vc1MbState.dwLength = m_dataSize - mb[mbCount].data_offset; } else { vc1MbState.dwLength = mb[mbCount + 1].data_offset - mb[mbCount].data_offset; } vc1MbState.bMbHorizOrigin = mb[mbCount].mb_address % m_picWidthInMb; vc1MbState.bMbVertOrigin = mb[mbCount].mb_address / m_picWidthInMb; vc1MbState.dwOffset = (vc1MbState.dwLength) ? mb[mbCount].data_offset : 0; vc1MbState.bSkipped = false; if (m_vc1PicParams->entrypoint_fields.loopfilter) { eStatus = MOS_SecureMemcpy(vc1MbState.DeblockData, CODEC_NUM_BLOCK_PER_MB, m_deblockDataBuffer + CODEC_NUM_BLOCK_PER_MB * mb[mbCount].mb_address, CODEC_NUM_BLOCK_PER_MB); if (eStatus != MOS_STATUS_SUCCESS) { CODECHAL_DECODE_ASSERTMESSAGE("Failed to copy memory."); m_olpNeeded = false; return eStatus; } } if (!mb[mbCount].mb_type.intra_mb) { if (mb[mbCount].mb_type.motion_forward || mb[mbCount].mb_type.motion_backward) { PackMotionVectors( &vc1MbState, (short *)mb[mbCount].motion_vector, (short *)vc1MbState.PackedLumaMvs, (short *)&vc1MbState.PackedChromaMv); } else { mb[mbCount].mb_type.motion_forward = 1; MOS_ZeroMemory(vc1MbState.PackedLumaMvs, sizeof(vc1MbState.PackedLumaMvs)); // MV's of zero vc1MbState.bMotionSwitch = 0; } } CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1ItObjectCmd(batchBuffer, &vc1MbState)); mbAddress = mb[mbCount].mb_address; } m_fieldPolarity = vc1MbState.bFieldPolarity; // skipped MBs at the end uint16_t skippedMBs = m_picWidthInMb * frameFieldHeightInMb - mb[mbCount - 1].mb_address - 1; while (skippedMBs--) { vc1MbState.bSkipped = true; CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVc1ItObjectCmd(batchBuffer, &vc1MbState)); } CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(nullptr, &m_itObjectBatchBuffer)); CODECHAL_DEBUG_TOOL( CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch( batchBuffer, CODECHAL_NUM_MEDIA_STATES, "_DEC")); ) CODECHAL_DECODE_CHK_STATUS_RETURN(Mhw_UnlockBb(m_osInterface, &m_itObjectBatchBuffer, true)); // Check if destination surface needs to be synchronized if (m_unequalFieldWaInUse && CodecHal_PictureIsField(m_vc1PicParams->CurrPic)) { if (!m_vc1PicParams->picture_fields.is_first_field) { MHW_MI_FLUSH_DW_PARAMS flushDwParams; MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams)); } } else { syncParams = g_cInitSyncParams; syncParams.GpuContext = m_videoContext; syncParams.presSyncResource = &m_destSurface.OsResource; syncParams.bReadOnly = false; syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock; syncParams.bDisableLockForTranscode = m_disableLockForTranscode; if (!CodecHal_PictureIsField(m_vc1PicParams->CurrPic) || m_vc1PicParams->picture_fields.is_first_field) { CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams)); // Update the resource tag (s/w tag) for On-Demand Sync m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams); } MHW_MI_FLUSH_DW_PARAMS flushDwParams; MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams)); // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag if (m_osInterface->bTagResourceSync && !(CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && m_vc1PicParams->picture_fields.is_first_field)) { CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams)); } } if (m_statusQueryReportingEnabled) { CodechalDecodeStatusReport decodeStatusReport; decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber; decodeStatusReport.m_currDecodedPic = m_vc1PicParams->CurrPic; if (m_olpNeeded) { CODECHAL_DEBUG_TOOL( decodeStatusReport.m_currDeblockedPic.FrameIdx = (uint8_t)m_vc1PicParams->DeblockedPicIdx; decodeStatusReport.m_currDeblockedPic.PicFlags = PICTURE_FRAME;) decodeStatusReport.m_deblockedPicResOlp = m_deblockSurface.OsResource; } else { decodeStatusReport.m_currDeblockedPic = m_vc1PicParams->CurrPic; } decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE; decodeStatusReport.m_currDecodedPicRes = m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx]->resRefPic; CODECHAL_DEBUG_TOOL( decodeStatusReport.m_secondField = (m_vc1PicParams->picture_fields.is_first_field == 1) ? false : true; decodeStatusReport.m_olpNeeded = m_olpNeeded; decodeStatusReport.m_frameType = m_perfType;) CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(decodeStatusReport, &cmdBuffer)); } CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr)); m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0); CODECHAL_DEBUG_TOOL( CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer( &cmdBuffer, CODECHAL_NUM_MEDIA_STATES, "_DEC")); //CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands( // m_debugInterface, // &cmdBuffer)); ) if ( MOS_VE_SUPPORTED(m_osInterface)) { CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, false); } if (m_huCCopyInUse) { syncParams = g_cInitSyncParams; syncParams.GpuContext = m_videoContextForWa; syncParams.presSyncResource = &m_resSyncObjectWaContextInUse; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams)); syncParams = g_cInitSyncParams; syncParams.GpuContext = m_videoContext; syncParams.presSyncResource = &m_resSyncObjectWaContextInUse; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams)); m_huCCopyInUse = false; } HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface); CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw)); CODECHAL_DEBUG_TOOL( m_mmc->UpdateUserFeatureKey(&m_destSurface);) if (m_unequalFieldWaInUse && CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && !m_vc1PicParams->picture_fields.is_first_field) { CODECHAL_DECODE_CHK_NULL_RETURN(m_vc1RefList); uint32_t destFrameIdx = m_vc1PicParams->CurrPic.FrameIdx; CODECHAL_DECODE_CHK_STATUS_RETURN(FormatUnequalFieldPicture( m_unequalFieldSurface[m_vc1RefList[destFrameIdx]->dwUnequalFieldSurfaceIdx], m_destSurface, true, m_videoContextUsesNullHw ? true : false)); } if (m_olpNeeded) { CODECHAL_DECODE_CHK_STATUS_RETURN(PerformVc1Olp()); } else { if (m_statusQueryReportingEnabled) { CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_videoContextUsesNullHw)); } } // Needs to be re-set for Linux buffer re-use scenarios m_vc1RefList[m_vc1PicParams->CurrPic.FrameIdx]->resRefPic = m_destSurface.OsResource; // Send the signal to indicate decode completion, in case On-Demand Sync is not present if (!(CodecHal_PictureIsField(m_vc1PicParams->CurrPic) && m_vc1PicParams->picture_fields.is_first_field)) { MOS_SYNC_PARAMS syncParams; syncParams = g_cInitSyncParams; syncParams.GpuContext = m_videoContext; syncParams.presSyncResource = &m_destSurface.OsResource; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams)); if (m_olpNeeded) { syncParams = g_cInitSyncParams; syncParams.GpuContext = m_renderContext; syncParams.presSyncResource = &m_deblockSurface.OsResource; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams)); } } m_olpNeeded = false; return eStatus; } MOS_STATUS CodechalDecodeVc1G12::HandleSkipFrame() { MOS_COMMAND_BUFFER cmdBuffer; MHW_MI_FLUSH_DW_PARAMS flushDwParams; MHW_GENERIC_PROLOG_PARAMS genericPrologParams; MOS_SURFACE srcSurface; uint8_t fwdRefIdx; uint32_t surfaceSize; MOS_SYNC_PARAMS syncParams; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_DECODE_FUNCTION_ENTER; fwdRefIdx = (uint8_t)m_vc1PicParams->ForwardRefIdx; MOS_ZeroMemory(&srcSurface, sizeof(MOS_SURFACE)); srcSurface.Format = Format_NV12; srcSurface.OsResource = m_vc1RefList[fwdRefIdx]->resRefPic; CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(m_osInterface, &srcSurface)); CODECHAL_DECODE_CHK_NULL_RETURN(srcSurface.OsResource.pGmmResInfo); surfaceSize = ((srcSurface.OsResource.pGmmResInfo->GetArraySize()) > 1) ? ((uint32_t)(srcSurface.OsResource.pGmmResInfo->GetQPitchPlanar(GMM_PLANE_Y) * srcSurface.OsResource.pGmmResInfo->GetRenderPitch())) : (uint32_t)(srcSurface.OsResource.pGmmResInfo->GetSizeMainSurface()); if (m_hwInterface->m_noHuC) { CodechalDataCopyParams dataCopyParams; MOS_ZeroMemory(&dataCopyParams, sizeof(CodechalDataCopyParams)); dataCopyParams.srcResource = &srcSurface.OsResource; dataCopyParams.srcSize = surfaceSize; dataCopyParams.srcOffset = srcSurface.dwOffset; dataCopyParams.dstResource = &m_destSurface.OsResource; dataCopyParams.dstSize = surfaceSize; dataCopyParams.dstOffset = m_destSurface.dwOffset; CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->CopyDataSourceWithDrv(&dataCopyParams)); } else { m_huCCopyInUse = true; syncParams = g_cInitSyncParams; syncParams.GpuContext = m_videoContext; syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams)); syncParams = g_cInitSyncParams; syncParams.GpuContext = m_videoContextForWa; syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContextForWa)); m_osInterface->pfnResetOsStates(m_osInterface); CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0)); CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, false)); CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy( &cmdBuffer, // pCmdBuffer &srcSurface.OsResource, // presSrc &m_destSurface.OsResource, // presDst surfaceSize, // u32CopyLength srcSurface.dwOffset, // u32CopyInputOffset m_destSurface.dwOffset)); // u32CopyOutputOffset #ifdef _MMC_SUPPORTED auto mmc = static_cast(m_mmc); CODECHAL_DECODE_CHK_STATUS_RETURN(mmc->CopyAuxSurfForSkip(&cmdBuffer, &srcSurface.OsResource, &m_destSurface.OsResource)); #endif syncParams = g_cInitSyncParams; syncParams.GpuContext = m_videoContextForWa; syncParams.presSyncResource = &m_destSurface.OsResource; syncParams.bReadOnly = false; syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock; syncParams.bDisableLockForTranscode = m_disableLockForTranscode; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams)); // Update the resource tag (s/w tag) for On-Demand Sync m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams); // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag if (m_osInterface->bTagResourceSync) { CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource( &cmdBuffer, &syncParams)); } MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd( &cmdBuffer, &flushDwParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd( &cmdBuffer, nullptr)); m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0); if ( MOS_VE_SUPPORTED(m_osInterface)) { CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, false); } CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContext)); } return (MOS_STATUS)eStatus; } MOS_STATUS CodechalDecodeVc1G12::PerformVc1Olp() { MOS_STATUS eStatus = MOS_STATUS_SUCCESS; CODECHAL_DECODE_FUNCTION_ENTER; MhwRenderInterface *renderEngineInterface = m_hwInterface->GetRenderInterface(); PMHW_KERNEL_STATE kernelState = &m_olpKernelState; PMHW_STATE_HEAP_INTERFACE stateHeapInterface = renderEngineInterface->m_stateHeapInterface; CODECHAL_DECODE_CHK_NULL_RETURN(stateHeapInterface); MOS_SYNC_PARAMS syncParams; syncParams = g_cInitSyncParams; syncParams.GpuContext = m_videoContext; syncParams.presSyncResource = &m_resSyncObject; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams)); syncParams = g_cInitSyncParams; syncParams.GpuContext = m_renderContext; syncParams.presSyncResource = &m_resSyncObject; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams)); // Initialize DSH kernel region m_osInterface->pfnSetGpuContext(m_osInterface, m_renderContext); m_osInterface->pfnResetOsStates(m_osInterface); m_osInterface->pfnSetPerfTag( m_osInterface, (uint16_t)(((m_mode << 4) & 0xF0) | OLP_TYPE)); m_osInterface->pfnResetPerfBufferID(m_osInterface); CodecHalGetResourceInfo(m_osInterface, &m_deblockSurface); // DstSurface CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnRequestSshSpaceForCmdBuf( stateHeapInterface, kernelState->KernelParams.iBTCount)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace( stateHeapInterface, kernelState, false, m_olpDshSize, false, m_decodeStatusBuf.m_swStoreData)); MHW_INTERFACE_DESCRIPTOR_PARAMS idParams; MOS_ZeroMemory(&idParams, sizeof(idParams)); idParams.pKernelState = kernelState; CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSetInterfaceDescriptor( stateHeapInterface, 1, &idParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(SetCurbeOlp()); // Send HW commands (including SSH) MOS_COMMAND_BUFFER cmdBuffer; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0)); MHW_PIPE_CONTROL_PARAMS pipeControlParams; MOS_ZeroMemory(&pipeControlParams, sizeof(pipeControlParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->GetDefaultSSEuSetting(CODECHAL_MEDIA_STATE_OLP, false, false, false)); CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking( &cmdBuffer, true)); if (renderEngineInterface->GetL3CacheConfig()->bL3CachingEnabled) { CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->SetL3Cache(&cmdBuffer)); } CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->EnablePreemption(&cmdBuffer)); CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddPipelineSelectCmd(&cmdBuffer, false)); CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSetBindingTable( stateHeapInterface, kernelState)); // common function for codec needed when we make change for AVC MHW_RCS_SURFACE_PARAMS surfaceParamsSrc; MOS_ZeroMemory(&surfaceParamsSrc, sizeof(surfaceParamsSrc)); surfaceParamsSrc.dwNumPlanes = 2; // Y, UV surfaceParamsSrc.psSurface = &m_destSurface; surfaceParamsSrc.psSurface->dwDepth = 1; // depth needs to be 0 for codec 2D surface // Y Plane surfaceParamsSrc.dwBindingTableOffset[MHW_Y_PLANE] = CODECHAL_DECODE_VC1_OLP_SRC_Y; surfaceParamsSrc.ForceSurfaceFormat[MHW_Y_PLANE] = MHW_GFX3DSTATE_SURFACEFORMAT_R8_UNORM; // UV Plane surfaceParamsSrc.dwBindingTableOffset[MHW_U_PLANE] = CODECHAL_DECODE_VC1_OLP_SRC_UV; surfaceParamsSrc.ForceSurfaceFormat[MHW_U_PLANE] = MHW_GFX3DSTATE_SURFACEFORMAT_R16_UINT; surfaceParamsSrc.dwBaseAddrOffset[MHW_U_PLANE] = m_destSurface.dwPitch * MOS_ALIGN_FLOOR(m_destSurface.UPlaneOffset.iYOffset, MOS_YTILE_H_ALIGNMENT); surfaceParamsSrc.dwHeightToUse[MHW_U_PLANE] = surfaceParamsSrc.psSurface->dwHeight / 2; surfaceParamsSrc.dwYOffset[MHW_U_PLANE] = (m_destSurface.UPlaneOffset.iYOffset % MOS_YTILE_H_ALIGNMENT); surfaceParamsSrc.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC].Value; #ifdef _MMC_SUPPORTED if (m_mmc) { CODECHAL_SURFACE_CODEC_PARAMS srcSurfaceParam = {}; srcSurfaceParam.psSurface = &m_destSurface; CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetSurfaceParams(&srcSurfaceParam)); } #endif MHW_RCS_SURFACE_PARAMS surfaceParamsDst; MOS_ZeroMemory(&surfaceParamsDst, sizeof(surfaceParamsDst)); surfaceParamsDst = surfaceParamsSrc; surfaceParamsDst.bIsWritable = true; surfaceParamsDst.psSurface = &m_deblockSurface; surfaceParamsDst.psSurface->dwDepth = 1; // depth needs to be 0 for codec 2D surface surfaceParamsDst.dwBindingTableOffset[MHW_Y_PLANE] = CODECHAL_DECODE_VC1_OLP_DST_Y; surfaceParamsDst.dwBindingTableOffset[MHW_U_PLANE] = CODECHAL_DECODE_VC1_OLP_DST_UV; surfaceParamsDst.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_POST_DEBLOCKING_CODEC].Value; #ifdef _MMC_SUPPORTED if (m_mmc) { CODECHAL_SURFACE_CODEC_PARAMS dstSurfaceParam = {}; dstSurfaceParam.psSurface = &m_deblockSurface; CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetSurfaceParams(&dstSurfaceParam)); } #endif CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSetSurfaceState( stateHeapInterface, kernelState, &cmdBuffer, 1, &surfaceParamsSrc)); CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSetSurfaceState( stateHeapInterface, kernelState, &cmdBuffer, 1, &surfaceParamsDst)); MHW_STATE_BASE_ADDR_PARAMS stateBaseAddrParams; MOS_ZeroMemory(&stateBaseAddrParams, sizeof(stateBaseAddrParams)); MOS_RESOURCE *dsh = nullptr, *ish = nullptr; CODECHAL_DECODE_CHK_NULL_RETURN(dsh = kernelState->m_dshRegion.GetResource()); CODECHAL_DECODE_CHK_NULL_RETURN(ish = kernelState->m_ishRegion.GetResource()); stateBaseAddrParams.presDynamicState = dsh; stateBaseAddrParams.dwDynamicStateSize = kernelState->m_dshRegion.GetHeapSize(); stateBaseAddrParams.presInstructionBuffer = ish; stateBaseAddrParams.dwInstructionBufferSize = kernelState->m_ishRegion.GetHeapSize(); stateBaseAddrParams.mocs4GeneralState = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index; stateBaseAddrParams.mocs4DynamicState = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index; stateBaseAddrParams.mocs4SurfaceState = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index; stateBaseAddrParams.mocs4IndirectObjectBuffer = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index; stateBaseAddrParams.mocs4StatelessDataport = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index; CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddStateBaseAddrCmd(&cmdBuffer, &stateBaseAddrParams)); MHW_VFE_PARAMS_G12 vfeParams= {}; vfeParams.pKernelState = kernelState; CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaVfeCmd(&cmdBuffer, &vfeParams)); MHW_CURBE_LOAD_PARAMS curbeLoadParams; MOS_ZeroMemory(&curbeLoadParams, sizeof(curbeLoadParams)); curbeLoadParams.pKernelState = kernelState; CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaCurbeLoadCmd(&cmdBuffer, &curbeLoadParams)); MHW_ID_LOAD_PARAMS idLoadParams; MOS_ZeroMemory(&idLoadParams, sizeof(idLoadParams)); idLoadParams.pKernelState = kernelState; idLoadParams.dwNumKernelsLoaded = 1; CODECHAL_DECODE_CHK_STATUS_RETURN(renderEngineInterface->AddMediaIDLoadCmd(&cmdBuffer, &idLoadParams)); CODECHAL_DEBUG_TOOL( CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion( CODECHAL_MEDIA_STATE_OLP, MHW_DSH_TYPE, kernelState)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion( CODECHAL_MEDIA_STATE_OLP, MHW_SSH_TYPE, kernelState)); ) CODECHAL_DECODE_VC1_OLP_PARAMS vc1OlpParams; vc1OlpParams.pCmdBuffer = &cmdBuffer; vc1OlpParams.pPipeControlParams = &pipeControlParams; vc1OlpParams.pStateBaseAddrParams = &stateBaseAddrParams; vc1OlpParams.pVfeParams = &vfeParams; vc1OlpParams.pCurbeLoadParams = &curbeLoadParams; vc1OlpParams.pIdLoadParams = &idLoadParams; CODECHAL_DECODE_CHK_STATUS_RETURN(AddVc1OlpCmd(&vc1OlpParams)); // Check if destination surface needs to be synchronized, before command buffer submission syncParams = g_cInitSyncParams; syncParams.GpuContext = m_renderContext; syncParams.presSyncResource = &m_deblockSurface.OsResource; syncParams.bReadOnly = false; syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock; syncParams.bDisableLockForTranscode = m_disableLockForTranscode; CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams)); // Update the resource tag (s/w tag) for On-Demand Sync m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams); // Update GPU Sync tag for on demand synchronization if (m_osInterface->bTagResourceSync) { pipeControlParams.dwFlushMode = MHW_FLUSH_WRITE_CACHE; CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddPipeControl(&cmdBuffer, nullptr, &pipeControlParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams)); } CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnSubmitBlocks( stateHeapInterface, kernelState)); CODECHAL_DECODE_CHK_STATUS_RETURN(stateHeapInterface->pfnUpdateGlobalCmdBufId( stateHeapInterface)); // Add PipeControl to invalidate ISP and MediaState to avoid PageFault issue // This code is temporal and it will be moved to batch buffer end in short MOS_ZeroMemory(&pipeControlParams, sizeof(pipeControlParams)); pipeControlParams.dwFlushMode = MHW_FLUSH_WRITE_CACHE; pipeControlParams.bGenericMediaStateClear = true; pipeControlParams.bIndirectStatePointersDisable = true; pipeControlParams.bDisableCSStall = false; CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddPipeControl(&cmdBuffer, nullptr, &pipeControlParams)); CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr)); // To clear the SSEU values in the hw interface struct, so next kernel can be programmed correctly CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->UpdateSSEuForCmdBuffer(&cmdBuffer, false, true)); m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0); CODECHAL_DEBUG_TOOL( CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer( &cmdBuffer, CODECHAL_MEDIA_STATE_OLP, "_DEC")); ) if ( MOS_VE_SUPPORTED(m_osInterface)) { CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, false); } CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_renderContextUsesNullHw)); if (m_statusQueryReportingEnabled) { CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_renderContextUsesNullHw)); } m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContext); return eStatus; } CodechalDecodeVc1G12::CodechalDecodeVc1G12( CodechalHwInterface *hwInterface, CodechalDebugInterface* debugInterface, PCODECHAL_STANDARD_INFO standardInfo) : CodechalDecodeVc1(hwInterface, debugInterface, standardInfo) { CODECHAL_DECODE_FUNCTION_ENTER; CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(hwInterface); CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface); m_osInterface->pfnVirtualEngineSupported(m_osInterface, true, true); m_olpCurbeStaticDataLength = CODECHAL_DECODE_VC1_CURBE_SIZE_OLP; uint32_t kuid = 0; MOS_STATUS eStatus = MOS_STATUS_SUCCESS; #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE) eStatus = CodecHalGetKernelBinaryAndSize( (uint8_t *)IGCODECKRN_G12, IDR_CODEC_AllVC1_NV12, &m_olpKernelBase, &m_olpKernelSize); #endif CODECHAL_DECODE_ASSERT(eStatus == MOS_STATUS_SUCCESS); hwInterface->GetStateHeapSettings()->dwNumSyncTags = CODECHAL_DECODE_VC1_NUM_SYNC_TAGS; hwInterface->GetStateHeapSettings()->dwIshSize = MOS_ALIGN_CEIL(m_olpKernelSize, (1 << MHW_KERNEL_OFFSET_SHIFT)); hwInterface->GetStateHeapSettings()->dwDshSize = CODECHAL_DECODE_VC1_INITIAL_DSH_SIZE; } CodechalDecodeVc1G12::~CodechalDecodeVc1G12() { CODECHAL_DECODE_FUNCTION_ENTER; if (m_veState != nullptr) { MOS_FreeMemAndSetNull(m_veState); m_veState = nullptr; } } void CodechalDecodeVc1G12::CalcRequestedSpace( uint32_t &requestedSize, uint32_t &additionalSizeNeeded, uint32_t &requestedPatchListSize) { CODECHAL_DECODE_FUNCTION_ENTER; requestedSize = m_commandBufferSizeNeeded + m_HucStateCmdBufferSizeNeeded + (m_standardDecodeSizeNeeded * (m_decodeParams.m_numSlices + 1)); requestedPatchListSize = m_commandPatchListSizeNeeded + m_HucPatchListSizeNeeded + (m_standardDecodePatchListSizeNeeded * (m_decodeParams.m_numSlices + 1)); additionalSizeNeeded = COMMAND_BUFFER_RESERVED_SPACE; }