text: /*
  * Copyright (c) 2018-2021, 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     decode_hevc_pipeline.cpp
  //! \brief    Defines the interface for hevc decode pipeline
  //!
  #include "decode_hevc_pipeline.h"
  #include "decode_utils.h"
  #include "codechal_setting.h"
  #include "decode_hevc_phase_s2l.h"
  #include "decode_hevc_phase_long.h"
  #include "decode_hevc_phase_front_end.h"
  #include "decode_hevc_phase_back_end.h"
  #include "decode_hevc_phase_real_tile.h"
  #include "decode_hevc_feature_manager.h"
  #include "decode_hevc_downsampling_packet.h"
  
  namespace decode {
  
  HevcPipeline::HevcPipeline(CodechalHwInterface *hwInterface, CodechalDebugInterface *debugInterface)
      : DecodePipeline(hwInterface, debugInterface)
  {
  }
  
  MOS_STATUS HevcPipeline::Initialize(void *settings)
  {
      DECODE_FUNC_CALL();
      DECODE_CHK_STATUS(DecodePipeline::Initialize(settings));
  
      auto *codecSettings = (CodechalSetting*)settings;
      DECODE_CHK_NULL(codecSettings);
      m_shortFormatInUse  = (codecSettings->shortFormatInUse) ? true : false;
  
      // Create basic GPU context
      DecodeScalabilityPars scalPars;
      MOS_ZeroMemory(&scalPars, sizeof(scalPars));
      DECODE_CHK_STATUS(m_mediaContext->SwitchContext(VdboxDecodeFunc, &scalPars, &m_scalability));
      m_decodeContext = m_osInterface->pfnGetGpuContext(m_osInterface);
  
      m_basicFeature = dynamic_cast<HevcBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
      DECODE_CHK_NULL(m_basicFeature);
  
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::Uninitialize()
  {
      DECODE_FUNC_CALL();
      DECODE_CHK_STATUS(DestoryPhaseList());
      return DecodePipeline::Uninitialize();
  }
  
  MOS_STATUS HevcPipeline::UserFeatureReport()
  {
      DECODE_FUNC_CALL();
      DECODE_CHK_STATUS(DecodePipeline::UserFeatureReport());
  
  #if (_DEBUG || _RELEASE_INTERNAL)
      WriteUserFeature(__MEDIA_USER_FEATURE_VALUE_APOGEIOS_HEVCD_ENABLE_ID, 1, m_osInterface->pOsContext);
  #endif
  
  #ifdef _MMC_SUPPORTED
      CODECHAL_DEBUG_TOOL(
          if (m_mmcState != nullptr)
          {
              m_mmcState->UpdateUserFeatureKey(&(m_basicFeature->m_destSurface));
          }
          );
  #endif
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::Execute()
  {
      DECODE_FUNC_CALL();
  
  #if (_DEBUG || _RELEASE_INTERNAL)
      if (GetDecodeMode() == realTileDecodeMode)
      {
          m_rtFrameCount++;
      }
      else if (GetDecodeMode() == virtualTileDecodeMode)
      {
          m_vtFrameCount++;
      }
      else if (GetDecodeMode() == separateTileDecodeMode)
      {
          m_spFrameCount++;
      }
  #endif
  
      for (auto &phase : m_phaseList)
      {
          DECODE_ASSERT(phase != nullptr);
          if (phase->RequiresContextSwitch())
          {
              // switch context
              DecodeScalabilityOption *scalabOption = phase->GetDecodeScalabilityOption();
              DECODE_CHK_NULL(scalabOption);
              DECODE_CHK_STATUS(m_mediaContext->SwitchContext(VdboxDecodeFunc, *scalabOption, &m_scalability));
              if (scalabOption->IsScalabilityOptionMatched(m_scalabOption))
              {
                  m_decodeContext = m_osInterface->pfnGetGpuContext(m_osInterface);
              }
          }
  
          StateParams stateProperty;
          stateProperty.currentPipe        = phase->GetPipe();
          stateProperty.currentPass        = phase->GetPass();
          stateProperty.pipeIndexForSubmit = phase->GetPipe() + 1;
          stateProperty.componentState     = phase;
          DECODE_CHK_STATUS(ActivatePacket(phase->GetPktId(), phase->ImmediateSubmit(), stateProperty));
  
          if (phase->ImmediateSubmit())
          {
              m_scalability->SetPassNumber(phase->GetPass() + 1);
              DECODE_CHK_STATUS(ExecuteActivePackets());
          }
      }
  
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::CreateFeatureManager()
  {
      DECODE_FUNC_CALL();
      m_featureManager = MOS_New(DecodeHevcFeatureManager, m_allocator, m_hwInterface);
      DECODE_CHK_NULL(m_featureManager);
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::CreateSubPackets(DecodeSubPacketManager& subPacketManager, CodechalSetting &codecSettings)
  {
      DECODE_FUNC_CALL();
  
      DECODE_CHK_STATUS(DecodePipeline::CreateSubPackets(subPacketManager, codecSettings));
  
  #ifdef _DECODE_PROCESSING_SUPPORTED
      HevcDownSamplingPkt *downSamplingPkt = MOS_New(HevcDownSamplingPkt, this, m_hwInterface);
      DECODE_CHK_NULL(downSamplingPkt);
      DECODE_CHK_STATUS(subPacketManager.Register(
                          DecodePacketId(this, downSamplingSubPacketId), *downSamplingPkt));
  #endif
  
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::InitContexOption(HevcScalabilityPars& scalPars)
  {
      scalPars.usingHcp = true;
      scalPars.enableVE = MOS_VE_SUPPORTED(m_osInterface);
      scalPars.disableScalability = m_hwInterface->IsDisableScalability();
  #if (_DEBUG || _RELEASE_INTERNAL)
      if (m_osInterface->bHcpDecScalabilityMode == MOS_SCALABILITY_ENABLE_MODE_FALSE)
      {
          scalPars.disableScalability = true;
      }
      else if (m_osInterface->bHcpDecScalabilityMode == MOS_SCALABILITY_ENABLE_MODE_USER_FORCE)
      {
          scalPars.disableScalability = false;
      }
      scalPars.modeSwithThreshold1 =
          ReadUserFeature(__MEDIA_USER_FEATURE_VALUE_HCP_DECODE_MODE_SWITCH_THRESHOLD1_ID, m_osInterface->pOsContext).u32Data;
      scalPars.modeSwithThreshold2 =
          ReadUserFeature(__MEDIA_USER_FEATURE_VALUE_HCP_DECODE_MODE_SWITCH_THRESHOLD2_ID, m_osInterface->pOsContext).u32Data;
      scalPars.forceMultiPipe =
          ReadUserFeature(__MEDIA_USER_FEATURE_VALUE_HCP_DECODE_ALWAYS_FRAME_SPLIT_ID, m_osInterface->pOsContext).u32Data ?
          true : false;
  #endif
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::InitDecodeMode(ScalabilityMode scalabMode, HevcBasicFeature &basicFeature)
  {
      if (scalabMode == scalabilityVirtualTileMode)
      {
          m_decodeMode = virtualTileDecodeMode;
      }
      else if (scalabMode == scalabilityRealTileMode)
      {
          m_decodeMode = realTileDecodeMode;
      }
      else
      {
          PCODEC_HEVC_PIC_PARAMS picParams = basicFeature.m_hevcPicParams;
          DECODE_CHK_NULL(picParams);
  
          if (picParams->tiles_enabled_flag &&
              (basicFeature.m_isSCCIBCMode || basicFeature.m_isSCCPLTMode || basicFeature.m_isWPPMode))
          {
              m_decodeMode = separateTileDecodeMode;
          }
          else
          {
              m_decodeMode = baseDecodeMode;
          }
      }
  
      return MOS_STATUS_SUCCESS;
  }
  
  template<typename T>
  MOS_STATUS HevcPipeline::CreatePhase(uint8_t pass, uint8_t pipe, uint8_t activePipeNum)
  {
      DECODE_FUNC_CALL();
      T *phase = MOS_New(T, *this, m_scalabOption);
      DECODE_CHK_NULL(phase);
      DECODE_CHK_STATUS(phase->Initialize(pass, pipe, activePipeNum));
      m_phaseList.push_back(phase);
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::CreatePhaseList(HevcBasicFeature &basicFeature, const ScalabilityMode scalabMode, const uint8_t numPipe)
  {
      DECODE_FUNC_CALL();
      DECODE_ASSERT(m_phaseList.empty());
  
      if (m_shortFormatInUse)
      {
          DECODE_CHK_STATUS(CreatePhase<HevcPhaseS2L>());
      }
  
      if (scalabMode == scalabilityVirtualTileMode)
      {
          DECODE_CHK_STATUS(CreatePhase<HevcPhaseFrontEnd>());
          for (uint8_t i = 0; i < numPipe; i++)
          {
              DECODE_CHK_STATUS(CreatePhase<HevcPhaseBackEnd>(0, i, numPipe));
          }
      }
      else if (scalabMode == scalabilityRealTileMode)
      {
          PCODEC_HEVC_PIC_PARAMS picParams = basicFeature.m_hevcPicParams;
          DECODE_CHK_NULL(picParams);
          uint8_t pass = 0;
          uint8_t pipe = 0;
          uint8_t activePipeNum = numPipe;
          uint32_t numTileCol = picParams->num_tile_columns_minus1 + 1;
          for (uint32_t i = 0; i < numTileCol; i++)
          {
              DECODE_CHK_STATUS(CreatePhase<HevcPhaseRealTile>(pass, pipe, activePipeNum));
              pipe++;
              if (pipe >= numPipe)
              {
                  pipe = 0;
                  pass++;
                  uint32_t remainingCols = numTileCol - i - 1;
                  activePipeNum = (remainingCols >= numPipe) ? numPipe : remainingCols;
              }
          }
      }
      else
      {
          DECODE_CHK_STATUS(CreatePhase<HevcPhaseLong>());
      }
  
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::DestoryPhaseList()
  {
      for (auto &phase : m_phaseList)
      {
          MOS_Delete(phase);
      }
      m_phaseList.clear();
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::StoreDestToRefList(HevcBasicFeature &basicFeature)
  {
      DECODE_CHK_NULL(basicFeature.m_hevcPicParams);
      DECODE_CHK_STATUS(basicFeature.m_refFrames.UpdateCurResource(
          *basicFeature.m_hevcPicParams, false));
      return MOS_STATUS_SUCCESS;
  }
  
  #if (_DEBUG || _RELEASE_INTERNAL)
  MOS_STATUS HevcPipeline::HwStatusCheck(const DecodeStatusMfx &status)
  {
      DECODE_FUNC_CALL();
  
      // Check HuC_status2 Imem loaded bit, if 0, return error
      if (m_shortFormatInUse &&
          ((status.m_hucErrorStatus2 >> 32) && (m_hwInterface->GetHucInterface()->GetHucStatus2ImemLoadedMask()) == 0))
      {
          if (!m_reportHucStatus)
          {
              WriteUserFeature(__MEDIA_USER_FEATURE_VALUE_HUC_LOAD_STATUS_ID, 1, m_osInterface->pOsContext);
              m_reportHucStatus = true;
          }
          DECODE_ASSERTMESSAGE("Huc IMEM Loaded fails");
          return MOS_STATUS_UNKNOWN;
      }
      return MOS_STATUS_SUCCESS;
  }
  #endif
  
  bool HevcPipeline::IsShortFormat()
  {
      return m_shortFormatInUse;
  }
  
  HevcPipeline::HevcDecodeMode HevcPipeline::GetDecodeMode()
  {
      return m_decodeMode;
  }
  
  bool HevcPipeline::IsFESeparateSubmission()
  {
      return m_scalabOption.IsFESeparateSubmission();
  }
  
  MHW_BATCH_BUFFER* HevcPipeline::GetSliceLvlCmdBuffer()
  {
      if (m_secondLevelBBArray == nullptr)
      {
          return nullptr;
      }
      return m_secondLevelBBArray->Peek();
  }
  
  #if USE_CODECHAL_DEBUG_TOOL
  MOS_STATUS HevcPipeline::DumpIQParams(
      PCODECHAL_HEVC_IQ_MATRIX_PARAMS matrixData)
  {
      CODECHAL_DEBUG_FUNCTION_ENTER;
  
      if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrIqParams))
      {
          return MOS_STATUS_SUCCESS;
      }
  
      CODECHAL_DEBUG_CHK_NULL(matrixData);
  
      std::ostringstream oss;
      oss.setf(std::ios::showbase | std::ios::uppercase);
  
      uint32_t idx;
      uint32_t idx2;
      // 4x4 block
      for (idx2 = 0; idx2 < 6; idx2++)
      {
          oss << "Qmatrix_HEVC_ucScalingLists0[" << std::dec << +idx2 << "]:" << std::endl;
  
          oss << "ucScalingLists0[" << +idx2 << "]:";
          for (uint8_t i = 0; i < 16; i++)
              oss << std::hex << +matrixData->ucScalingLists0[idx2][i] << " ";
          oss << std::endl;
      }
  
      // 8x8 block
      for (idx2 = 0; idx2 < 6; idx2++)
      {
          oss << "ucScalingLists1[" << std::dec << +idx2 << "]:" << std::endl;
  
          for (idx = 0; idx < 64; idx += 8)
          {
              oss << "ucScalingLists1[" << std::dec << +idx / 8 << "]:" << std::endl;
              for (uint8_t i = 0; i < 8; i++)
                  oss << std::hex << +matrixData->ucScalingLists1[idx2][idx + i] << " ";
              oss << std::endl;
          }
      }
  
      // 16x16 block
      for (idx2 = 0; idx2 < 6; idx2++)
      {
          oss << "ucScalingLists2[" << std::dec << +idx2 << "]:" << std::endl;
  
          for (idx = 0; idx < 64; idx += 8)
          {
              oss << "ucScalingLists2[" << std::dec << +idx / 8 << "]:" << std::endl;
              for (uint8_t i = 0; i < 8; i++)
                  oss << std::hex << +matrixData->ucScalingLists2[idx2][idx + i] << " ";
              oss << std::endl;
          }
      }
      // 32x32 block
      for (idx2 = 0; idx2 < 2; idx2++)
      {
          oss << "ucScalingLists3[" << std::dec << +idx2 << "]:" << std::endl;
  
          for (idx = 0; idx < 64; idx += 8)
          {
              oss << "ucScalingLists3[" << std::dec << +idx / 8 << "]:" << std::endl;
              for (uint8_t i = 0; i < 8; i++)
                  oss << std::hex << +matrixData->ucScalingLists3[idx2][idx + i] << " ";
              oss << std::endl;
          }
      }
  
      //DC16x16 block
      oss << "ucScalingListDCCoefSizeID2: ";
      for (uint8_t i = 0; i < 6; i++)
          oss << std::hex << +matrixData->ucScalingListDCCoefSizeID2[i] << " ";
  
      oss << std::endl;
  
      //DC32x32 block
  
      oss << "ucScalingListDCCoefSizeID3: ";
      oss << +matrixData->ucScalingListDCCoefSizeID3[0] << " " << +matrixData->ucScalingListDCCoefSizeID3[1] << std::endl;
  
      const char *fileName = m_debugInterface->CreateFileName(
          "_DEC",
          CodechalDbgBufferType::bufIqParams,
          CodechalDbgExtType::txt);
  
      std::ofstream ofs(fileName, std::ios::out);
      ofs << oss.str();
      ofs.close();
  
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::DumpPicParams(
      PCODEC_HEVC_PIC_PARAMS     picParams,
      PCODEC_HEVC_EXT_PIC_PARAMS extPicParams,
      PCODEC_HEVC_SCC_PIC_PARAMS sccPicParams)
  {
      CODECHAL_DEBUG_FUNCTION_ENTER;
  
      if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
      {
          return MOS_STATUS_SUCCESS;
      }
  
      CODECHAL_DEBUG_CHK_NULL(picParams);
  
      std::ostringstream oss;
      oss.setf(std::ios::showbase | std::ios::uppercase);
      oss.setf(std::ios::hex, std::ios::basefield);
  
      oss << "PicWidthInMinCbsY: " << +picParams->PicWidthInMinCbsY << std::endl;
      oss << "PicHeightInMinCbsY: " << +picParams->PicHeightInMinCbsY << std::endl;
      //wFormatAndSequenceInfoFlags
      oss << "chroma_format_idc: " << +picParams->chroma_format_idc << std::endl;
      oss << "separate_colour_plane_flag: " << +picParams->separate_colour_plane_flag << std::endl;
      oss << "bit_depth_luma_minus8: " << +picParams->bit_depth_luma_minus8 << std::endl;
      oss << "bit_depth_chroma_minus8: " << +picParams->bit_depth_chroma_minus8 << std::endl;
      oss << "log2_max_pic_order_cnt_lsb_minus4: " << +picParams->log2_max_pic_order_cnt_lsb_minus4 << std::endl;
      oss << "NoPicReorderingFlag: " << +picParams->NoPicReorderingFlag << std::endl;
      oss << "ReservedBits1: " << +picParams->ReservedBits1 << std::endl;
      oss << "wFormatAndSequenceInfoFlags: " << +picParams->wFormatAndSequenceInfoFlags << std::endl;
      oss << "CurrPic FrameIdx: " << +picParams->CurrPic.FrameIdx << std::endl;
      oss << "CurrPic PicFlags: " << +picParams->CurrPic.PicFlags << std::endl;
      oss << "sps_max_dec_pic_buffering_minus1: " << +picParams->sps_max_dec_pic_buffering_minus1 << std::endl;
      oss << "log2_min_luma_coding_block_size_minus3: " << +picParams->log2_min_luma_coding_block_size_minus3 << std::endl;
      oss << "log2_diff_max_min_luma_coding_block_size: " << +picParams->log2_diff_max_min_luma_coding_block_size << std::endl;
      oss << "log2_min_transform_block_size_minus2: " << +picParams->log2_min_transform_block_size_minus2 << std::endl;
      oss << "log2_diff_max_min_transform_block_size: " << +picParams->log2_diff_max_min_transform_block_size << std::endl;
      oss << "max_transform_hierarchy_depth_intra: " << +picParams->max_transform_hierarchy_depth_intra << std::endl;
      oss << "max_transform_hierarchy_depth_inter: " << +picParams->max_transform_hierarchy_depth_inter << std::endl;
      oss << "num_short_term_ref_pic_sets: " << +picParams->num_short_term_ref_pic_sets << std::endl;
      oss << "num_long_term_ref_pic_sps: " << +picParams->num_long_term_ref_pic_sps << std::endl;
      oss << "num_ref_idx_l0_default_active_minus1: " << +picParams->num_ref_idx_l0_default_active_minus1 << std::endl;
      oss << "num_ref_idx_l1_default_active_minus1: " << +picParams->num_ref_idx_l1_default_active_minus1 << std::endl;
      oss << "init_qp_minus26: " << +picParams->init_qp_minus26 << std::endl;
      oss << "ucNumDeltaPocsOfRefRpsIdx: " << +picParams->ucNumDeltaPocsOfRefRpsIdx << std::endl;
      oss << "wNumBitsForShortTermRPSInSlice: " << +picParams->wNumBitsForShortTermRPSInSlice << std::endl;
      oss << "ReservedBits2: " << +picParams->ReservedBits2 << std::endl;
      //dwCodingParamToolFlags
      oss << "scaling_list_enabled_flag: " << +picParams->scaling_list_enabled_flag << std::endl;
      oss << "amp_enabled_flag: " << +picParams->amp_enabled_flag << std::endl;
      oss << "sample_adaptive_offset_enabled_flag: " << +picParams->sample_adaptive_offset_enabled_flag << std::endl;
      oss << "pcm_enabled_flag: " << +picParams->pcm_enabled_flag << std::endl;
      oss << "pcm_sample_bit_depth_luma_minus1: " << +picParams->pcm_sample_bit_depth_luma_minus1 << std::endl;
      oss << "pcm_sample_bit_depth_chroma_minus1: " << +picParams->pcm_sample_bit_depth_chroma_minus1 << std::endl;
      oss << "log2_min_pcm_luma_coding_block_size_minus3: " << +picParams->log2_min_pcm_luma_coding_block_size_minus3 << std::endl;
      oss << "log2_diff_max_min_pcm_luma_coding_block_size: " << +picParams->log2_diff_max_min_pcm_luma_coding_block_size << std::endl;
      oss << "pcm_loop_filter_disabled_flag: " << +picParams->pcm_loop_filter_disabled_flag << std::endl;
      oss << "long_term_ref_pics_present_flag: " << +picParams->long_term_ref_pics_present_flag << std::endl;
      oss << "sps_temporal_mvp_enabled_flag: " << +picParams->sps_temporal_mvp_enabled_flag << std::endl;
      oss << "strong_intra_smoothing_enabled_flag: " << +picParams->strong_intra_smoothing_enabled_flag << std::endl;
      oss << "dependent_slice_segments_enabled_flag: " << +picParams->dependent_slice_segments_enabled_flag << std::endl;
      oss << "output_flag_present_flag: " << +picParams->output_flag_present_flag << std::endl;
      oss << "num_extra_slice_header_bits: " << +picParams->num_extra_slice_header_bits << std::endl;
      oss << "sign_data_hiding_enabled_flag: " << +picParams->sign_data_hiding_enabled_flag << std::endl;
      oss << "cabac_init_present_flag: " << +picParams->cabac_init_present_flag << std::endl;
      oss << "ReservedBits3: " << +picParams->ReservedBits3 << std::endl;
      oss << "dwCodingParamToolFlags: " << +picParams->dwCodingParamToolFlags << std::endl;
      //dwCodingSettingPicturePropertyFlags
      oss << "constrained_intra_pred_flag: " << +picParams->constrained_intra_pred_flag << std::endl;
      oss << "transform_skip_enabled_flag: " << +picParams->transform_skip_enabled_flag << std::endl;
      oss << "cu_qp_delta_enabled_flag: " << +picParams->cu_qp_delta_enabled_flag << std::endl;
      oss << "diff_cu_qp_delta_depth: " << +picParams->diff_cu_qp_delta_depth << std::endl;
      oss << "pps_slice_chroma_qp_offsets_present_flag: " << +picParams->pps_slice_chroma_qp_offsets_present_flag << std::endl;
      oss << "weighted_pred_flag: " << +picParams->weighted_pred_flag << std::endl;
      oss << "weighted_bipred_flag: " << +picParams->weighted_bipred_flag << std::endl;
      oss << "transquant_bypass_enabled_flag: " << +picParams->transquant_bypass_enabled_flag << std::endl;
      oss << "tiles_enabled_flag: " << +picParams->tiles_enabled_flag << std::endl;
      oss << "entropy_coding_sync_enabled_flag: " << +picParams->entropy_coding_sync_enabled_flag << std::endl;
      oss << "uniform_spacing_flag: " << +picParams->uniform_spacing_flag << std::endl;
      oss << "loop_filter_across_tiles_enabled_flag: " << +picParams->loop_filter_across_tiles_enabled_flag << std::endl;
      oss << "pps_loop_filter_across_slices_enabled_flag: " << +picParams->pps_loop_filter_across_slices_enabled_flag << std::endl;
      oss << "deblocking_filter_override_enabled_flag: " << +picParams->deblocking_filter_override_enabled_flag << std::endl;
      oss << "pps_deblocking_filter_disabled_flag: " << +picParams->pps_deblocking_filter_disabled_flag << std::endl;
      oss << "lists_modification_present_flag: " << +picParams->lists_modification_present_flag << std::endl;
      oss << "slice_segment_header_extension_present_flag: " << +picParams->slice_segment_header_extension_present_flag << std::endl;
      oss << "IrapPicFlag: " << +picParams->IrapPicFlag << std::endl;
      oss << "IdrPicFlag: " << +picParams->IdrPicFlag << std::endl;
      oss << "IntraPicFlag: " << +picParams->IntraPicFlag << std::endl;
      oss << "ReservedBits4: " << +picParams->ReservedBits4 << std::endl;
      oss << "dwCodingSettingPicturePropertyFlags: " << +picParams->dwCodingSettingPicturePropertyFlags << std::endl;
      oss << "pps_cb_qp_offset: " << +picParams->pps_cb_qp_offset << std::endl;
      oss << "pps_cr_qp_offset: " << +picParams->pps_cr_qp_offset << std::endl;
      oss << "num_tile_columns_minus1: " << +picParams->num_tile_columns_minus1 << std::endl;
      oss << "num_tile_rows_minus1: " << +picParams->num_tile_rows_minus1 << std::endl;
      //Dump column width
      oss << "column_width_minus1[19]:";
      for (uint8_t i = 0; i < 19; i++)
          oss << picParams->column_width_minus1[i] << " ";
      oss << std::endl;
  
      //Dump row height
      oss << "row_height_minus1[21]:";
      for (uint8_t i = 0; i < 21; i++)
          oss << picParams->row_height_minus1[i] << " ";
      oss << std::endl;
  
      oss << "pps_beta_offset_div2: " << +picParams->pps_beta_offset_div2 << std::endl;
      oss << "pps_tc_offset_div2: " << +picParams->pps_tc_offset_div2 << std::endl;
      oss << "log2_parallel_merge_level_minus2: " << +picParams->log2_parallel_merge_level_minus2 << std::endl;
      oss << "CurrPicOrderCntVal: " << +picParams->CurrPicOrderCntVal << std::endl;
  
      oss.setf(std::ios::dec, std::ios::basefield);
      //Dump RefFrameList[15]
      for (uint8_t i = 0; i < 15; ++i)
      {
          oss << "RefFrameList[" << +i << "].FrameIdx:" << +picParams->RefFrameList[i].FrameIdx << std::endl;
          oss << "RefFrameList[" << +i << "].PicFlags:" << +picParams->RefFrameList[i].PicFlags << std::endl;
      }
  
      //Dump POC List
      oss << "PicOrderCntValList[15]:";
      for (uint8_t i = 0; i < 15; i++)
          oss << std::hex << picParams->PicOrderCntValList[i] << " ";
      oss << std::endl;
  
      //Dump Ref RefPicSetStCurrBefore List
      oss << "RefPicSetStCurrBefore[8]:";
      for (uint8_t i = 0; i < 8; i++)
          oss << +picParams->RefPicSetStCurrBefore[i] << " ";
      oss << std::endl;
  
      //Dump Ref RefPicSetStCurrAfter List
      oss << "RefPicSetStCurrAfter[16]:";
      for (uint8_t i = 0; i < 8; i++)
          oss << +picParams->RefPicSetStCurrAfter[i] << " ";
      oss << std::endl;
  
      //Dump Ref PicSetStCurr List
      oss << "RefPicSetLtCurr[16]:";
      for (uint8_t i = 0; i < 8; i++)
          oss << +picParams->RefPicSetLtCurr[i] << " ";
      oss << std::endl;
  
      //Dump Ref RefPicSetStCurrBefore List with POC
      oss << "POC of RefPicSetStCurrBefore[8]: ";
      for (uint8_t i = 0; i < 8; i++)
          oss << +picParams->PicOrderCntValList[picParams->RefPicSetStCurrBefore[i]%15] << " ";
      oss << std::endl;
  
      //Dump Ref RefPicSetStCurrAfter List with POC
      oss << "POC of RefPicSetStCurrAfter[16]:";
      for (uint8_t i = 0; i < 8; i++)
          oss << +picParams->PicOrderCntValList[picParams->RefPicSetStCurrAfter[i]%15] << " ";
      oss << std::endl;
  
      //Dump Ref PicSetStCurr List with POC
      oss << "POC of RefPicSetLtCurr[16]: ";
      for (uint8_t i = 0; i < 8; i++)
          oss << +picParams->PicOrderCntValList[picParams->RefPicSetLtCurr[i]%15] << " ";
      oss << std::endl;
  
      oss << "RefFieldPicFlag: " << +picParams->RefFieldPicFlag << std::endl;
      oss << "RefBottomFieldFlag: " << +picParams->RefBottomFieldFlag << std::endl;
      oss << "StatusReportFeedbackNumber: " << +picParams->StatusReportFeedbackNumber << std::endl;
  
      if (extPicParams)
      {
          //PicRangeExtensionFlags
          oss << "transform_skip_rotation_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.transform_skip_rotation_enabled_flag << std::endl;
          oss << "transform_skip_context_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.transform_skip_context_enabled_flag << std::endl;
          oss << "implicit_rdpcm_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.implicit_rdpcm_enabled_flag << std::endl;
          oss << "explicit_rdpcm_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.explicit_rdpcm_enabled_flag << std::endl;
          oss << "extended_precision_processing_flag: " << +extPicParams->PicRangeExtensionFlags.fields.extended_precision_processing_flag << std::endl;
          oss << "intra_smoothing_disabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.intra_smoothing_disabled_flag << std::endl;
          oss << "high_precision_offsets_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.high_precision_offsets_enabled_flag << std::endl;
          oss << "persistent_rice_adaptation_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.persistent_rice_adaptation_enabled_flag << std::endl;
          oss << "cabac_bypass_alignment_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.cabac_bypass_alignment_enabled_flag << std::endl;
          oss << "cross_component_prediction_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.cross_component_prediction_enabled_flag << std::endl;
          oss << "chroma_qp_offset_list_enabled_flag: " << +extPicParams->PicRangeExtensionFlags.fields.chroma_qp_offset_list_enabled_flag << std::endl;
          oss << "BitDepthLuma16: " << +extPicParams->PicRangeExtensionFlags.fields.BitDepthLuma16 << std::endl;
          oss << "BitDepthChroma16: " << +extPicParams->PicRangeExtensionFlags.fields.BitDepthChroma16 << std::endl;
          oss << "diff_cu_chroma_qp_offset_depth: " << +extPicParams->diff_cu_chroma_qp_offset_depth << std::endl;
          oss << "chroma_qp_offset_list_len_minus1: " << +extPicParams->chroma_qp_offset_list_len_minus1 << std::endl;
          oss << "log2_sao_offset_scale_luma: " << +extPicParams->log2_sao_offset_scale_luma << std::endl;
          oss << "log2_sao_offset_scale_chroma: " << +extPicParams->log2_sao_offset_scale_chroma << std::endl;
          oss << "log2_max_transform_skip_block_size_minus2: " << +extPicParams->log2_max_transform_skip_block_size_minus2 << std::endl;
  
          //Dump cb_qp_offset_list[6]
          oss << "cb_qp_offset_list[6]: ";
          for (uint8_t i = 0; i < 6; i++)
              oss << +extPicParams->cb_qp_offset_list[i] << " ";
          oss << std::endl;
  
          //Dump cr_qp_offset_list[6]
          oss << "cr_qp_offset_list[6]: ";
          for (uint8_t i = 0; i < 6; i++)
              oss << +extPicParams->cr_qp_offset_list[i] << " ";
          oss << std::endl;
  
          //Dump scc pic parameters
          if(sccPicParams)
          {
              oss << "pps_curr_pic_ref_enabled_flag: " << +sccPicParams->PicSCCExtensionFlags.fields.pps_curr_pic_ref_enabled_flag<< std::endl;
              oss << "palette_mode_enabled_flag: " << +sccPicParams->PicSCCExtensionFlags.fields.palette_mode_enabled_flag << std::endl;
              oss << "motion_vector_resolution_control_idc: " << +sccPicParams->PicSCCExtensionFlags.fields.motion_vector_resolution_control_idc << std::endl;
              oss << "intra_boundary_filtering_disabled_flag: " << +sccPicParams->PicSCCExtensionFlags.fields.intra_boundary_filtering_disabled_flag << std::endl;
              oss << "residual_adaptive_colour_transform_enabled_flag: " << +sccPicParams->PicSCCExtensionFlags.fields.residual_adaptive_colour_transform_enabled_flag << std::endl;
              oss << "pps_slice_act_qp_offsets_present_flag: " << +sccPicParams->PicSCCExtensionFlags.fields.pps_slice_act_qp_offsets_present_flag << std::endl;
              oss << "palette_max_size: " << +sccPicParams->palette_max_size << std::endl;
              oss << "delta_palette_max_predictor_size: " << +sccPicParams->delta_palette_max_predictor_size << std::endl;
              oss << "PredictorPaletteSize: " << +sccPicParams->PredictorPaletteSize << std::endl;
  
              for(uint8_t i = 0; i < 128; i++)
              {
                  oss << "PredictorPaletteEntries[0][" << +i << "]: " << +sccPicParams->PredictorPaletteEntries[0][i] << std::endl;
                  oss << "PredictorPaletteEntries[1][" << +i << "]: " << +sccPicParams->PredictorPaletteEntries[1][i] << std::endl;
                  oss << "PredictorPaletteEntries[2][" << +i << "]: " << +sccPicParams->PredictorPaletteEntries[2][i] << std::endl;
              }
  
              oss << "pps_act_y_qp_offset_plus5: " << +sccPicParams->pps_act_y_qp_offset_plus5 << std::endl;
              oss << "pps_act_cb_qp_offset_plus5: " << +sccPicParams->pps_act_y_qp_offset_plus5 << std::endl;
              oss << "pps_act_cr_qp_offset_plus3: " << +sccPicParams->pps_act_y_qp_offset_plus5 << std::endl;
          }
      }
  
      const char *fileName = m_debugInterface->CreateFileName(
          "_DEC",
          CodechalDbgBufferType::bufPicParams,
          CodechalDbgExtType::txt);
  
      std::ofstream ofs(fileName, std::ios::out);
      ofs << oss.str();
      ofs.close();
  
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::DumpSliceParams(
      PCODEC_HEVC_SLICE_PARAMS     sliceParams,
      PCODEC_HEVC_EXT_SLICE_PARAMS extSliceParams,
      uint32_t                     numSlices,
      bool                         shortFormatInUse)
  {
      CODECHAL_DEBUG_FUNCTION_ENTER;
      if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
      {
          return MOS_STATUS_SUCCESS;
      }
  
      CODECHAL_DEBUG_CHK_NULL(sliceParams);
  
      PCODEC_HEVC_SLICE_PARAMS     hevcSliceControl    = nullptr;
      PCODEC_HEVC_EXT_SLICE_PARAMS hevcExtSliceControl = nullptr;
  
      std::ostringstream oss;
      oss.setf(std::ios::showbase | std::ios::uppercase);
  
      for (uint16_t j = 0; j < numSlices; j++)
      {
          hevcSliceControl = &sliceParams[j];
          if (extSliceParams)
          {
              hevcExtSliceControl = &extSliceParams[j];
          }
  
          oss << "====================================================================================================" << std::endl;
          oss << "Data for Slice number = " << +j << std::endl;
          oss << "slice_data_size: " << +hevcSliceControl->slice_data_size << std::endl;
          oss << "slice_data_offset: " << +hevcSliceControl->slice_data_offset << std::endl;
  
          if (!shortFormatInUse)
          {
              //Dump Long format specific
              oss << "ByteOffsetToSliceData: " << +hevcSliceControl->ByteOffsetToSliceData << std::endl;
              oss << "slice_segment_address: " << +hevcSliceControl->slice_segment_address << std::endl;
  
              //Dump RefPicList[2][15]
              for (uint8_t i = 0; i < 15; ++i)
              {
                  oss << "RefPicList[0][" << +i << "]";
                  oss << ".FrameIdx: " << +hevcSliceControl->RefPicList[0][i].FrameIdx << std::endl;
                  oss << "RefPicList[0][" << +i << "]";
                  oss << ".PicFlags: " << +hevcSliceControl->RefPicList[0][i].PicFlags << std::endl;
              }
              for (uint8_t i = 0; i < 15; ++i)
              {
                  oss << "RefPicList[1][" << +i << "]";
                  oss << ".FrameIdx: " << +hevcSliceControl->RefPicList[1][i].FrameIdx << std::endl;
                  oss << "RefPicList[1][" << +i << "]";
                  oss << ".PicFlags: " << +hevcSliceControl->RefPicList[1][i].PicFlags << std::endl;
              }
  
              oss << "last_slice_of_pic: " << +hevcSliceControl->LongSliceFlags.fields.LastSliceOfPic << std::endl;
              oss << "dependent_slice_segment_flag: " << +hevcSliceControl->LongSliceFlags.fields.dependent_slice_segment_flag << std::endl;
              oss << "slice_type: " << +hevcSliceControl->LongSliceFlags.fields.slice_type << std::endl;
              oss << "color_plane_id: " << +hevcSliceControl->LongSliceFlags.fields.color_plane_id << std::endl;
              oss << "slice_sao_luma_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_sao_luma_flag << std::endl;
              oss << "slice_sao_chroma_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_sao_chroma_flag << std::endl;
              oss << "mvd_l1_zero_flag: " << +hevcSliceControl->LongSliceFlags.fields.mvd_l1_zero_flag << std::endl;
              oss << "cabac_init_flag: " << +hevcSliceControl->LongSliceFlags.fields.cabac_init_flag << std::endl;
              oss << "slice_temporal_mvp_enabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag << std::endl;
              oss << "slice_deblocking_filter_disabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_deblocking_filter_disabled_flag << std::endl;
              oss << "collocated_from_l0_flag: " << +hevcSliceControl->LongSliceFlags.fields.collocated_from_l0_flag << std::endl;
              oss << "slice_loop_filter_across_slices_enabled_flag: " << +hevcSliceControl->LongSliceFlags.fields.slice_loop_filter_across_slices_enabled_flag << std::endl;
              oss << "reserved: " << +hevcSliceControl->LongSliceFlags.fields.reserved << std::endl;
              oss << "collocated_ref_idx: " << +hevcSliceControl->collocated_ref_idx << std::endl;
              oss << "num_ref_idx_l0_active_minus1: " << +hevcSliceControl->num_ref_idx_l0_active_minus1 << std::endl;
              oss << "num_ref_idx_l1_active_minus1: " << +hevcSliceControl->num_ref_idx_l1_active_minus1 << std::endl;
              oss << "slice_qp_delta: " << +hevcSliceControl->slice_qp_delta << std::endl;
              oss << "slice_cb_qp_offset: " << +hevcSliceControl->slice_cb_qp_offset << std::endl;
              oss << "slice_cr_qp_offset: " << +hevcSliceControl->slice_cr_qp_offset << std::endl;
              oss << "slice_beta_offset_div2: " << +hevcSliceControl->slice_beta_offset_div2 << std::endl;
              oss << "slice_tc_offset_div2: " << +hevcSliceControl->slice_tc_offset_div2 << std::endl;
              oss << "luma_log2_weight_denom: " << +hevcSliceControl->luma_log2_weight_denom << std::endl;
              oss << "delta_chroma_log2_weight_denom: " << +hevcSliceControl->delta_chroma_log2_weight_denom << std::endl;
  
              //Dump luma_offset[2][15]
              for (uint8_t i = 0; i < 15; i++)
              {
                  oss << "luma_offset_l0[" << +i << "]: " << (extSliceParams ? +hevcExtSliceControl->luma_offset_l0[i] : +hevcSliceControl->luma_offset_l0[i]) << std::endl;
                  oss << "luma_offset_l1[" << +i << "]: " << (extSliceParams ? +hevcExtSliceControl->luma_offset_l1[i] : +hevcSliceControl->luma_offset_l1[i]) << std::endl;
              }
              //Dump delta_luma_weight[2][15]
              for (uint8_t i = 0; i < 15; i++)
              {
                  oss << "delta_luma_weight_l0[" << +i << "]: " << +hevcSliceControl->delta_luma_weight_l0[i] << std::endl;
                  oss << "delta_luma_weight_l1[" << +i << "]: " << +hevcSliceControl->delta_luma_weight_l1[i] << std::endl;
              }
              //Dump chroma_offset[2][15][2]
              for (uint8_t i = 0; i < 15; i++)
              {
                  oss << "ChromaOffsetL0[" << +i << "][0]: " << (extSliceParams ? +hevcExtSliceControl->ChromaOffsetL0[i][0] : +hevcSliceControl->ChromaOffsetL0[i][0]) << std::endl;
  
                  oss << "ChromaOffsetL0[" << +i << "][1]: " << (extSliceParams ? +hevcExtSliceControl->ChromaOffsetL0[i][1] : +hevcSliceControl->ChromaOffsetL0[i][1]) << std::endl;
  
                  oss << "ChromaOffsetL1[" << +i << "][0]: " << (extSliceParams ? +hevcExtSliceControl->ChromaOffsetL1[i][0] : +hevcSliceControl->ChromaOffsetL1[i][0]) << std::endl;
  
                  oss << "ChromaOffsetL1[" << +i << "][1]: " << (extSliceParams ? +hevcExtSliceControl->ChromaOffsetL1[i][1] : +hevcSliceControl->ChromaOffsetL1[i][1]) << std::endl;
              }
              //Dump delta_chroma_weight[2][15][2]
              for (uint8_t i = 0; i < 15; i++)
              {
                  oss << "delta_chroma_weight_l0[" << +i << "][0]: " << +hevcSliceControl->delta_chroma_weight_l0[i][0] << std::endl;
                  oss << "delta_chroma_weight_l0[" << +i << "][1]: " << +hevcSliceControl->delta_chroma_weight_l0[i][1] << std::endl;
                  oss << "delta_chroma_weight_l1[" << +i << "][0]: " << +hevcSliceControl->delta_chroma_weight_l1[i][0] << std::endl;
                  oss << "delta_chroma_weight_l1[" << +i << "][1]: " << +hevcSliceControl->delta_chroma_weight_l1[i][1] << std::endl;
              }
  
              oss << "five_minus_max_num_merge_cand: " << +hevcSliceControl->five_minus_max_num_merge_cand << std::endl;
              oss << "num_entry_point_offsets: " << +hevcSliceControl->num_entry_point_offsets << std::endl;
              oss << "EntryOffsetToSubsetArray: " << +hevcSliceControl->EntryOffsetToSubsetArray << std::endl;
  
              if (extSliceParams)
              {
                  oss << "cu_chroma_qp_offset_enabled_flag: " << +hevcExtSliceControl->cu_chroma_qp_offset_enabled_flag << std::endl;
  
                  //Dump scc slice parameters
                  oss << "slice_act_y_qp_offset: " << +hevcExtSliceControl->slice_act_y_qp_offset<< std::endl;
                  oss << "slice_act_cb_qp_offset: " << +hevcExtSliceControl->slice_act_cb_qp_offset << std::endl;
                  oss << "slice_act_cr_qp_offset: " << +hevcExtSliceControl->slice_act_cr_qp_offset << std::endl;
                  oss << "use_integer_mv_flag: " << +hevcExtSliceControl->use_integer_mv_flag << std::endl;
              }
          }
      }
  
      const char *fileName = m_debugInterface->CreateFileName(
          "_DEC",
          CodechalDbgBufferType::bufSlcParams,
          CodechalDbgExtType::txt);
  
      std::ofstream ofs;
      ofs.open(fileName, std::ios::out);
      ofs << oss.str();
      ofs.close();
  
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::DumpSubsetsParams(PCODEC_HEVC_SUBSET_PARAMS subsetsParams)
  {
      CODECHAL_DEBUG_FUNCTION_ENTER;
      if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSubsetsParams))
      {
          return MOS_STATUS_SUCCESS;
      }
  
      if(subsetsParams)
      {
          std::ostringstream oss;
          oss.setf(std::ios::showbase | std::ios::uppercase);
  
          for(uint16_t i = 0; i < 440; i++)
          {
              oss << "entry_point_offset_minus1[" << +i << "]: " << +subsetsParams->entry_point_offset_minus1[i]<< std::endl;
          }
  
          //create the file
          const char *fileName = m_debugInterface->CreateFileName(
          "_DEC",
          CodechalDbgBufferType::bufSubsetsParams,
          CodechalDbgExtType::txt);
  
          std::ofstream ofs(fileName, std::ios::out);
          ofs << oss.str();
          ofs.close();
      }
      return MOS_STATUS_SUCCESS;
  }
  
  MOS_STATUS HevcPipeline::DumpSecondLevelBatchBuffer()
  {
      DECODE_FUNC_CALL();
  
      PMHW_BATCH_BUFFER batchBuffer = GetSliceLvlCmdBuffer();
      DECODE_CHK_NULL(batchBuffer);
  
      batchBuffer->iLastCurrent = batchBuffer->iSize * batchBuffer->count;
      batchBuffer->dwOffset     = 0;
      DECODE_CHK_STATUS(m_debugInterface->Dump2ndLvlBatch(
                          batchBuffer,
                          CODECHAL_NUM_MEDIA_STATES,
                          "_DEC"));
      return MOS_STATUS_SUCCESS;
  }
  #endif
  
  }
  