openh264 帧间预测编码过程源码分析

已于 2024-06-18 20:35:31 修改
阅读量482 收藏 7
点赞数 6
分类专栏： # openh264 文章标签： openh264 h264 帧间预测编码 预测编码 webrtc RTC 视频编解码
于 2024-06-17 16:14:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanceyxin/article/details/139746578
版权

openh264

OpenH264 是一个开源的 H.264 编码和解码器，由思科系统开发并维护。它专为实时应用程序如 WebRTC 设计，提供了从基础到高级特性的广泛支持。OpenH264 的编码器支持从 Constrained Baseline Profile 到 5.2 级别，允许任意分辨率的编码，不限于 16x16 的倍数，并且具有自适应量化或恒定量化的速率控制、多切片选项、多线程自动用于多切片等特性。此外，它还支持高达 4 层的时序可伸缩性、单一输入的 4 种空间分辨率的 Spatial Simulcast、长期参考帧（LTR）、内存管理控制操作（MMCO）等功能。

帧间预测编码

视频帧间预测编码（Inter-frame prediction coding）是视频压缩技术中的一种关键方法，主要用于减少视频序列中时间维度上的冗余。这种编码方式依赖于视频帧之间的空间相关性，通过预测和补偿来减少数据量，从而实现高效的视频压缩。

帧间预测编码是视频编码中非常有效的技术，广泛应用于各种视频编码标准，如H.264/AVC、H.265/HEVC、VP9和AV1等。通过减少时间冗余，帧间预测编码显著提高了视频数据的压缩率，同时保持了视频质量。

帧间预测的核心技术主要包括以下几个方面：

  1. 运动估计（Motion Estimation, ME）:

    • 运动估计是指在参考帧中搜索与当前块最匹配的区域，以确定最佳匹配块的位置。

  2. 运动补偿（Motion Compensation, MC）:

    • 运动补偿使用运动估计得到的运动向量来预测当前块，通过补偿先前图像的抽样点来生成当前图像块的预测值。

  3. 宏块（Macroblock, MB）和子宏块（Sub-Macroblock）的树状结构分块:

    • H.264 支持多种宏块分割方式，如16x16、16x8、8x16和8x8，以及更细致的子宏块分割，如8x8、8x4、4x8和4x4。

  4. 多参考帧预测:

    • 特别是在B帧中，可以使用两个方向的参考帧（List0和List1）进行双向预测。

  5. 亚像素精度的运动估计:

    • 除了整像素精度外，H.264还支持1/2像素和1/4像素的亚像素插值，以提高预测精度。

  6. 快速搜索算法:

    • 为了减少计算复杂度，使用快速搜索算法来确定最佳匹配块。

  7. 运动向量的编码:

    • 运动向量的编码通常涉及编码运动向量与预测值的差值（MVD），而不是直接编码运动向量本身。

  8. 预测模式的选择:

    • H.264定义了多种预测模式，包括直接模式、双向模式、List0和List1模式等。

  9. 参考帧管理:

    • 管理参考帧以确保解码器能够正确地重建预测图像。

  10. 变换/量化编码和熵编码:

    • 这些步骤与帧内编码相同或相似，用于进一步压缩预测残差。

帧间预测通过这些技术有效地减少了视频序列中的时间冗余，提高了压缩效率。

openh264 帧间预测编码过程

  1. 帧间预测过程函数关系图：
    在这里插入图片描述

  2. 帧间预测函数模块流程：
    在这里插入图片描述

  3. 关键模块说明：

  • 通过API 函数EncodeFrame完成具体的编码过程，可执行程序封装该函数进行编码；
  • 通过二维数组g_pWelsSliceCoding[2][2]来完成具体的I 帧、P 帧，以及变化片数和非变化片数编码；
  • 在非变化片数帧间编码过程中，在WelsMdInterMbLoop函数中循环处理每个宏块；
  • 在变化片数帧间编码过程中，在 WelsMdInterMbLoopOverDynamicSlice函数中循环处理每个宏块；
  • pfInterMd函数指针指向具体的增强层WelsMdInterMbEnhancelayer或基本层WelsMdInterMb帧间预测过程；
  • 在基本层预测过程中，WelsMdInterSecondaryModesEnc函数完成二级帧间预测过程编码；
  • 在增强层预测过程中，WelsMdSpatialelInterMbIlfmdNoilp函数完成具体的预测过程编码；
  1. 帧间预测过程核心函数介绍：
  • WelsMdInterMbLoopOverDynamicSlice 函数
  • 用于动态切片的宏块编码过程，循环处理每个 MB；
// Only for inter dynamic slicing
int32_t WelsMdInterMbLoopOverDynamicSlice (sWelsEncCtx* pEncCtx, SSlice* pSlice, void* pWelsMd,
    const int32_t kiSliceFirstMbXY) {
  SWelsMD* pMd          = (SWelsMD*)pWelsMd;
  SBitStringAux* pBs    = pSlice->pSliceBsa;
  SDqLayer* pCurLayer   = pEncCtx->pCurDqLayer;
  SSliceCtx* pSliceCtx  = &pCurLayer->sSliceEncCtx;
  SMbCache* pMbCache    = &pSlice->sMbCacheInfo;
  SMB* pMbList          = pCurLayer->sMbDataP;
  SMB* pCurMb           = NULL;
  int32_t iNumMbCoded   = 0;
  const int32_t kiTotalNumMb = pCurLayer->iMbWidth * pCurLayer->iMbHeight;
  int32_t iNextMbIdx = kiSliceFirstMbXY;
  int32_t iCurMbIdx = -1;
  const int32_t kiMvdInterTableStride = pEncCtx->iMvdCostTableStride;
  uint16_t* pMvdCostTable = &pEncCtx->pMvdCostTable[pEncCtx->iMvdCostTableSize];
  const int32_t kiSliceIdx = pSlice->iSliceIdx;
  const int32_t kiPartitionId = (kiSliceIdx % pEncCtx->iActiveThreadsNum);
  const uint8_t kuiChromaQpIndexOffset = pCurLayer->sLayerInfo.pPpsP->uiChromaQpIndexOffset;
  int32_t iEncReturn = ENC_RETURN_SUCCESS;

  SDynamicSlicingStack sDss;
  if (pEncCtx->pSvcParam->iEntropyCodingModeFlag) {
    WelsInitSliceCabac (pEncCtx, pSlice);
    sDss.iStartPos = sDss.iCurrentPos = 0;
    sDss.pRestoreBuffer = pEncCtx->pDynamicBsBuffer[kiPartitionId];
  } else {
    sDss.iStartPos = BsGetBitsPos (pBs);
  }
  pSlice->iMbSkipRun = 0;
  for (;;) {
    //DYNAMIC_SLICING_ONE_THREAD - MultiD
    //stack pBs pointer
    pEncCtx->pFuncList->pfStashMBStatus (&sDss, pSlice, pSlice->iMbSkipRun);

    //point to current pMb
    iCurMbIdx = iNextMbIdx;
    pCurMb = &pMbList[ iCurMbIdx ];

    //step(1): set QP for the current MB
    pEncCtx->pFuncList->pfRc.pfWelsRcMbInit (pEncCtx, pCurMb, pSlice);
    // if already reaches the largest number of slices, set QPs to the upper bound
    if (pSlice->bDynamicSlicingSliceSizeCtrlFlag) {
      //a clearer logic may be:
      //if there is no need from size control from the pSlice size, the QP will be decided by RC; else it will be set to the max QP
      //    however, there are some parameter updating in the rc_mb_init() function, so it cannot be skipped?
      pCurMb->uiLumaQp = pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId].iMaxQp;
      pCurMb->uiChromaQp = g_kuiChromaQpTable[CLIP3_QP_0_51 (pCurMb->uiLumaQp + kuiChromaQpIndexOffset)];
    }

    //step (2). save some vale for future use, initial pWelsMd
    WelsMdIntraInit (pEncCtx, pCurMb, pMbCache, kiSliceFirstMbXY);
    WelsMdInterInit (pEncCtx, pSlice, pCurMb, kiSliceFirstMbXY);

TRY_REENCODING:
    WelsInitInterMDStruc (pCurMb, pMvdCostTable, kiMvdInterTableStride, pMd);
    pEncCtx->pFuncList->pfInterMd (pEncCtx, pMd, pSlice, pCurMb, pMbCache);
    //mb_qp

    //step (4): save from the MD process from future use
    WelsMdInterSaveSadAndRefMbType ((pCurLayer->pDecPic->uiRefMbType), pMbCache, pCurMb, pMd);

    pEncCtx->pFuncList->pfMdBackgroundInfoUpdate (pCurLayer, pCurMb, pMbCache->bCollocatedPredFlag,
        pEncCtx->pRefPic->iPictureType);

    //step (5): update cache
    UpdateNonZeroCountCache (pCurMb, pMbCache);

    //step (6): begin to write bit stream; if the pSlice size is controlled, the writing may be skipped



    iEncReturn = pEncCtx->pFuncList->pfWelsSpatialWriteMbSyn (pEncCtx, pSlice, pCurMb);
    if (iEncReturn == ENC_RETURN_VLCOVERFLOWFOUND  && (pCurMb->uiLumaQp < 50)) {
      pSlice->iMbSkipRun = pEncCtx->pFuncList->pfStashPopMBStatus (&sDss, pSlice);
      UpdateQpForOverflow (pCurMb, kuiChromaQpIndexOffset);
      goto TRY_REENCODING;
    }
    if (ENC_RETURN_SUCCESS != iEncReturn)
      return iEncReturn;


    //DYNAMIC_SLICING_ONE_THREAD - MultiD
    sDss.iCurrentPos = pEncCtx->pFuncList->pfGetBsPosition (pSlice);
    if (DynSlcJudgeSliceBoundaryStepBack (pEncCtx, pSlice, pSliceCtx, pCurMb, &sDss)) {
      pSlice->iMbSkipRun = pEncCtx->pFuncList->pfStashPopMBStatus (&sDss, pSlice);
      pCurLayer->LastCodedMbIdxOfPartition[kiPartitionId] = iCurMbIdx -
          1; // update LastCodedMbIdxOfPartition, need to -1 due to stepping back
      ++ pCurLayer->NumSliceCodedOfPartition[kiPartitionId];

      break;
    }

    //step (7): reconstruct current MB
    pCurMb->uiSliceIdc = kiSliceIdx;
    OutputPMbWithoutConstructCsRsNoCopy (pEncCtx, pCurLayer, pSlice, pCurMb);

#if defined(MB_TYPES_CHECK)
    WelsCountMbType (pEncCtx->sPerInfo.iMbCount, P_SLICE, pCurMb);
#endif//MB_TYPES_CHECK

    //step (8): update status and other parameters
    pEncCtx->pFuncList->pfRc.pfWelsRcMbInfoUpdate (pEncCtx, pCurMb, pMd->iCostLuma, pSlice);

    /*judge if all pMb in cur pSlice has been encoded*/
    ++ iNumMbCoded;
    iNextMbIdx = WelsGetNextMbOfSlice (pCurLayer, iCurMbIdx);
    //whether all of MB in current pSlice encoded or not
    if (iNextMbIdx == -1 || iNextMbIdx >= kiTotalNumMb || iNumMbCoded >= kiTotalNumMb) {
      pCurLayer->LastCodedMbIdxOfPartition[kiPartitionId] = iCurMbIdx;
      ++ pCurLayer->NumSliceCodedOfPartition[kiPartitionId];

      break;
    }
  }

  if (pSlice->iMbSkipRun) {
    BsWriteUE (pBs, pSlice->iMbSkipRun);
  }

  return iEncReturn;
}

}//namespace WelsEnc
  • WelsMdInterMbLoop函数
  • 用于固定切片的宏块编码过程，循环处理每个 MB；
// for inter non-dynamic pSlice
int32_t WelsMdInterMbLoop (sWelsEncCtx* pEncCtx, SSlice* pSlice, void* pWelsMd, const int32_t kiSliceFirstMbXY) {
  SWelsMD* pMd          = (SWelsMD*)pWelsMd;
  SBitStringAux* pBs    = pSlice->pSliceBsa;
  SDqLayer* pCurLayer   = pEncCtx->pCurDqLayer;
  SMbCache* pMbCache    = &pSlice->sMbCacheInfo;
  SMB* pMbList          = pCurLayer->sMbDataP;
  SMB* pCurMb           = NULL;
  int32_t iNumMbCoded   = 0;
  int32_t iNextMbIdx    = kiSliceFirstMbXY;
  int32_t iCurMbIdx     = -1;
  const int32_t kiTotalNumMb = pCurLayer->iMbWidth * pCurLayer->iMbHeight;
  const int32_t kiMvdInterTableStride = pEncCtx->iMvdCostTableStride;
  uint16_t* pMvdCostTable = &pEncCtx->pMvdCostTable[pEncCtx->iMvdCostTableSize];
  const int32_t kiSliceIdx = pSlice->iSliceIdx;
  const uint8_t kuiChromaQpIndexOffset = pCurLayer->sLayerInfo.pPpsP->uiChromaQpIndexOffset;
  int32_t iEncReturn = ENC_RETURN_SUCCESS;
  SDynamicSlicingStack sDss;
  if (pEncCtx->pSvcParam->iEntropyCodingModeFlag) {
    WelsInitSliceCabac (pEncCtx, pSlice);
    sDss.pRestoreBuffer = NULL;
    sDss.iStartPos = sDss.iCurrentPos = 0;
  }
  pSlice->iMbSkipRun = 0;
  for (;;) {
    if (!pEncCtx->pSvcParam->iEntropyCodingModeFlag)
      pEncCtx->pFuncList->pfStashMBStatus (&sDss, pSlice, pSlice->iMbSkipRun);
    //point to current pMb
    iCurMbIdx = iNextMbIdx;
    pCurMb = &pMbList[ iCurMbIdx ];


    //step(1): set QP for the current MB
    pEncCtx->pFuncList->pfRc.pfWelsRcMbInit (pEncCtx, pCurMb, pSlice);

    //step (2). save some vale for future use, initial pWelsMd
    WelsMdIntraInit (pEncCtx, pCurMb, pMbCache, kiSliceFirstMbXY);
    WelsMdInterInit (pEncCtx, pSlice, pCurMb, kiSliceFirstMbXY);

TRY_REENCODING:
    WelsInitInterMDStruc (pCurMb, pMvdCostTable, kiMvdInterTableStride, pMd);
    pEncCtx->pFuncList->pfInterMd (pEncCtx, pMd, pSlice, pCurMb, pMbCache);
    //mb_qp

    //step (4): save from the MD process from future use
    WelsMdInterSaveSadAndRefMbType ((pCurLayer->pDecPic->uiRefMbType), pMbCache, pCurMb, pMd);

    pEncCtx->pFuncList->pfMdBackgroundInfoUpdate (pCurLayer, pCurMb, pMbCache->bCollocatedPredFlag,
        pEncCtx->pRefPic->iPictureType);

    //step (5): update cache
    UpdateNonZeroCountCache (pCurMb, pMbCache);

    //step (6): begin to write bit stream; if the pSlice size is controlled, the writing may be skipped

    iEncReturn = pEncCtx->pFuncList->pfWelsSpatialWriteMbSyn (pEncCtx, pSlice, pCurMb);
    if (!pEncCtx->pSvcParam->iEntropyCodingModeFlag) {
      if (iEncReturn == ENC_RETURN_VLCOVERFLOWFOUND && (pCurMb->uiLumaQp < 50)) {
        pSlice->iMbSkipRun = pEncCtx->pFuncList->pfStashPopMBStatus (&sDss, pSlice);
        UpdateQpForOverflow (pCurMb, kuiChromaQpIndexOffset);
        goto TRY_REENCODING;
      }
    }
    if (ENC_RETURN_SUCCESS != iEncReturn)
      return iEncReturn;


    //step (7): reconstruct current MB
    pCurMb->uiSliceIdc = kiSliceIdx;
    OutputPMbWithoutConstructCsRsNoCopy (pEncCtx, pCurLayer, pSlice, pCurMb);

#if defined(MB_TYPES_CHECK)
    WelsCountMbType (pEncCtx->sPerInfo.iMbCount, P_SLICE, pCurMb);
#endif//MB_TYPES_CHECK

    //step (8): update status and other parameters
    pEncCtx->pFuncList->pfRc.pfWelsRcMbInfoUpdate (pEncCtx, pCurMb, pMd->iCostLuma, pSlice);

    /*judge if all pMb in cur pSlice has been encoded*/
    ++ iNumMbCoded;
    iNextMbIdx = WelsGetNextMbOfSlice (pCurLayer, iCurMbIdx);
    //whether all of MB in current pSlice encoded or not
    if (iNextMbIdx == -1 || iNextMbIdx >= kiTotalNumMb || iNumMbCoded >= kiTotalNumMb) {
      break;
    }
  }

  if (pSlice->iMbSkipRun) {
    BsWriteUE (pBs, pSlice->iMbSkipRun);
  }

  return iEncReturn;
}
  • WelsMdInterMb函数
  • 基本层的预测编码的核心实现函数，主要用模式决策等过程；
void WelsMdInterMb (sWelsEncCtx* pEncCtx, SWelsMD* pWelsMd, SSlice* pSlice, SMB* pCurMb, SMbCache* pUnused) {
  SDqLayer* pCurDqLayer             = pEncCtx->pCurDqLayer;
  SMbCache* pMbCache                = &pSlice->sMbCacheInfo;
  const uint32_t kuiNeighborAvail   = pCurMb->uiNeighborAvail;
  const int32_t kiMbWidth           = pCurDqLayer->iMbWidth;
  const  SMB* top_mb                = pCurMb - kiMbWidth;
  const bool bMbLeftAvailPskip      = ((kuiNeighborAvail & LEFT_MB_POS) ? IS_SKIP ((pCurMb - 1)->uiMbType) : false);
  const bool bMbTopAvailPskip       = ((kuiNeighborAvail & TOP_MB_POS) ? IS_SKIP (top_mb->uiMbType) : false);
  const bool bMbTopLeftAvailPskip   = ((kuiNeighborAvail & TOPLEFT_MB_POS) ? IS_SKIP ((top_mb - 1)->uiMbType) : false);
  const bool bMbTopRightAvailPskip = ((kuiNeighborAvail & TOPRIGHT_MB_POS) ? IS_SKIP ((top_mb + 1)->uiMbType) : false);
  bool bTrySkip = bMbLeftAvailPskip || bMbTopAvailPskip || bMbTopLeftAvailPskip || bMbTopRightAvailPskip;
  bool bKeepSkip = bMbLeftAvailPskip && bMbTopAvailPskip && bMbTopRightAvailPskip;
  bool bSkip = false;

  //try BGD skip
  if (pEncCtx->pFuncList->pfInterMdBackgroundDecision (pEncCtx, pWelsMd, pSlice, pCurMb, pMbCache, &bKeepSkip)) {
    return;
  }

  //try static or scrolled Pskip
  if (pEncCtx->pFuncList->pfSCDPSkipDecision (pEncCtx, pWelsMd, pSlice, pCurMb, pMbCache)) {
    return;
  }

  //step 1: try SKIP
  bSkip = WelsMdInterJudgePskip (pEncCtx, pWelsMd, pSlice, pCurMb, pMbCache, bTrySkip);

  if (bSkip) {
    if (bKeepSkip) {
      WelsMdInterDecidedPskip (pEncCtx,  pSlice,  pCurMb, pMbCache);
      return;
    }
  } else {
    PredictSad (pMbCache->sMvComponents.iRefIndexCache, pMbCache->iSadCost, 0, &pWelsMd->iSadPredMb);

    //step 2: P_16x16
    pWelsMd->iCostLuma = WelsMdP16x16 (pEncCtx->pFuncList, pCurDqLayer, pWelsMd, pSlice, pCurMb);
    pCurMb->uiMbType = MB_TYPE_16x16;
  }

  WelsMdInterSecondaryModesEnc (pEncCtx, pWelsMd, pSlice, pCurMb, pMbCache, bSkip);
}
  • WelsMdInterSecondaryModesEnc函数
  • 基本层帧间二级模式的编码实现函数，主要用与判断出了 skip 和 p16x16 块类型之外的模式决策；
void WelsMdInterSecondaryModesEnc (sWelsEncCtx* pEncCtx, SWelsMD* pWelsMd, SSlice* pSlice, SMB* pCurMb,
                                   SMbCache* pMbCache, const bool bSkip) {
  //step 2: Intra
  const bool kbTrySkip = pEncCtx->pFuncList->pfFirstIntraMode (pEncCtx, pWelsMd, pCurMb, pMbCache);
  if (kbTrySkip)
    return;

  if (bSkip) {
    WelsMdInterDecidedPskip (pEncCtx,  pSlice,  pCurMb, pMbCache);
  } else {
    //Step 3: SubP16 MD
    pEncCtx->pFuncList->pfSetScrollingMv (pEncCtx->pVaa, pWelsMd); //SCC
    pEncCtx->pFuncList->pfInterFineMd (pEncCtx, pWelsMd, pSlice, pCurMb, pWelsMd->iCostLuma);

    //refinement for inter type
    WelsMdInterMbRefinement (pEncCtx, pWelsMd, pCurMb, pMbCache);

    //step 7: invoke encoding
    WelsMdInterEncode (pEncCtx, pSlice, pCurMb, pMbCache);

    //step 8: double check Pskip
    WelsMdInterDoubleCheckPskip (pCurMb, pMbCache);
  }
}
  • WelsMdSpatialelInterMbIlfmdNoilp函数
  • 增强层的预测编码的核心实现函数，主要用模式决策等过程；
//
// MD for enhancement layers
//
void WelsMdSpatialelInterMbIlfmdNoilp (sWelsEncCtx* pEncCtx, SWelsMD* pWelsMd, SSlice* pSlice,
                                       SMB* pCurMb, const Mb_Type kuiRefMbType) {
  SDqLayer* pCurDqLayer = pEncCtx->pCurDqLayer;
  SMbCache* pMbCache = &pSlice->sMbCacheInfo;

  const uint32_t kuiNeighborAvail = pCurMb->uiNeighborAvail;
  const int32_t kiMbWidth = pCurDqLayer->iMbWidth;
  const  SMB* kpTopMb = pCurMb - kiMbWidth;
  const bool kbMbLeftAvailPskip = ((kuiNeighborAvail & LEFT_MB_POS) ? IS_SKIP ((pCurMb - 1)->uiMbType) : false);
  const bool kbMbTopAvailPskip  = ((kuiNeighborAvail & TOP_MB_POS) ? IS_SKIP (kpTopMb->uiMbType) : false);
  const bool kbMbTopLeftAvailPskip  = ((kuiNeighborAvail & TOPLEFT_MB_POS) ? IS_SKIP ((kpTopMb - 1)->uiMbType) : false);
  const bool kbMbTopRightAvailPskip = ((kuiNeighborAvail & TOPRIGHT_MB_POS) ? IS_SKIP ((kpTopMb + 1)->uiMbType) : false);

  bool bTrySkip  = kbMbLeftAvailPskip | kbMbTopAvailPskip | kbMbTopLeftAvailPskip | kbMbTopRightAvailPskip;
  bool bKeepSkip = kbMbLeftAvailPskip & kbMbTopAvailPskip & kbMbTopRightAvailPskip;
  bool bSkip = false;

  if (pEncCtx->pFuncList->pfInterMdBackgroundDecision (pEncCtx, pWelsMd, pSlice, pCurMb, pMbCache, &bKeepSkip)) {
    return;
  }

  //step 1: try SKIP
  bSkip = WelsMdInterJudgePskip (pEncCtx, pWelsMd, pSlice, pCurMb, pMbCache, bTrySkip);

  if (bSkip && bKeepSkip) {
    WelsMdInterDecidedPskip (pEncCtx,  pSlice,  pCurMb, pMbCache);
    return;
  }

  if (! IS_SVC_INTRA (kuiRefMbType)) {
    if (!bSkip) {
      PredictSad (pMbCache->sMvComponents.iRefIndexCache, pMbCache->iSadCost, 0, &pWelsMd->iSadPredMb);

      //step 2: P_16x16
      pWelsMd->iCostLuma = WelsMdP16x16 (pEncCtx->pFuncList, pCurDqLayer, pWelsMd, pSlice, pCurMb);
      pCurMb->uiMbType = MB_TYPE_16x16;
    }

    WelsMdInterSecondaryModesEnc (pEncCtx, pWelsMd, pSlice, pCurMb, pMbCache, bSkip);
  } else { //BLMODE == SVC_INTRA
    //initial prediction memory for I_16x16
    const int32_t kiCostI16x16 = WelsMdI16x16 (pEncCtx->pFuncList, pEncCtx->pCurDqLayer, pMbCache, pWelsMd->iLambda);
    if (bSkip && (pWelsMd->iCostLuma <= kiCostI16x16)) {
      WelsMdInterDecidedPskip (pEncCtx,  pSlice,  pCurMb, pMbCache);
    } else {
      pWelsMd->iCostLuma = kiCostI16x16;
      pCurMb->uiMbType = MB_TYPE_INTRA16x16;

      WelsMdIntraSecondaryModesEnc (pEncCtx, pWelsMd, pCurMb, pMbCache);
    }
  }
}
码流怪侠
关注
专栏目录
【openh264】编码器 编码 SPS NALU 的流程
突围
04-24 376
调用路径 G:\LAS\A264\cc_openh264\meson_x86_vs2022\codec\console\enc\src\welsenc.cpp svc 核心编码： WelsWriteOneSPS 的调用 写入所有的SPS writing parasets for simulcast avc :WriteSavcParaset G:\LAS\A264\cc_openh264\meson_x86_vs2022\codec\encoder\core\src\enc.
【openh264】编码参数
突围
03-04 433
VideoEncoder.cpp VideoEncoder.cpp //获取默认参数 ppEncoder->GetDefaultParams(&paramExt); ECOMPLEXITY_MODE complexityMode = HIGH_COMPLEXITY; RC_MODES rc_mode = RC_BITRATE_MODE; bool bEnableAdaptiveQuant = false; //TODO 这里暂时写死,需要外.
openh264(openh264.lib)
09-21
vs2013编译的openh264库，和源文件。自己可以提取出来用。包括openh264v1.0 和openh264v1.5
H.264/AVC 帧间预测
houxiaoni01的博客
08-20 742
在早前介绍MPEG-2的时候，就介绍过帧间预测，它是从过去编码后重构的相邻帧（参考帧）的样本，预测当前帧（待编码帧）样本的过程。这一过程分为三个步骤： （1）在参考帧中，找出与待编码帧图块的最佳匹配块，所谓最佳匹配块，即这两个图块的差值最小。在数学上，通常用图块中样本值差值的绝对值，也即AE（absolute difference）来表示，进一步也可用SAE，也即绝对值误差之和来表示。在查找最佳匹...
OpenH264：实时视频编解码的利器
gitblog_00736的博客
08-08 459
OpenH264：实时视频编解码的利器 openh264Open Source H.264 Codec 项目地址:https://gitcode.com/gh_mirrors/op/openh264 项目介绍 OpenH264 是一个支持 H.264 编码和解码的音视频编解码库，适用于实时应用场景，如 WebRTC。该项目由 Cisco 开发并维护，旨在提供一个高效、稳定的 H.264 编解码解...
H.264 入门篇 - 12 (帧间预测 - MVP 求解)
StephenZhou
10-16 3420
H.264 利用相邻帧之间的相似性，用参考帧(可能多参考帧)和目标帧之间，以宏块为基本单位进行帧间预测在帧间预测编码模式下，每个块都有一个或两个 mv 需要编码。当采用小尺寸编码时，一个宏块内需要编码的 mv 也越多，所需比特额越多。同时，mv 有两个值并且以1/4像素为单位，这也就意味着mv的数值还不小，因此有必要对 mv 进行压缩。H.264 标准利用mv 的相关性对当前块 mv 进行预测，只对实际 mv 与预测 mv（mvp）的差值 mvd 进行编码。
视频编解码 — 帧间预测
11-23 2634
2、宏块大小16x16,先不划分宏块，直接使用16X16大小的块，在参考帧中进行运动搜索，得到运动矢量和预测块，通过MVP求得MVD，通过预测块得到残差块，并求得残差块的SATD值（残差块经过Hadamard变换之后求得绝对值再求和），估计MVD的编码后占用的字节数，将两个值加起来作为cost16x16。当前编码块的左边块，右边块，左上角块，右上角块的的运动矢量。搜索起始点作为六边形中心点，求得中心点左上角像素的预测块的SAD，之后对六边形角上的点做同样的操作求得SAD，得到最小的SAD，为最佳匹配点。
H.264 入门篇 - 07 (帧间预测 - 解码图像缓存 DPB)
StephenZhou
10-15 2434
当解码器收到一个IDR帧时会立即将DPB清空，因为H.264协议规定一个IDR帧之后的任何帧都不会引用该IDR之前的任何帧，所以DPB中的数据已失效，可以清空。在做视频解码时，需要将最近的若干幅参考帧缓存起来，这个缓冲区就叫做 DPB。解码已经完成的图像被缓存在 DPB 中，供后续帧用作参考图像，因此，解码器需要按照一定的规则对DPB中的图像进行管理。滑动窗 是以 DPB 可以存放的帧数为窗口，随着当前解码的图像，以先入先出的方式，将新的解码图像移入，将超出窗口的解码图像移出。
openh264源码
07-05
1. 编码流程：OpenH264的编码过程包括帧类型选择、宏块分割、熵编码和比特流生成等步骤。首先，根据场景变化选择I、P或B帧；接着，对图像进行宏块级别的预测和变换；然后，通过熵编码优化比特使用；最后，将编码结果...
openh264编码知识.pdf
08-09
在H264编码过程中，帧的显示顺序与编码顺序可能不同，通过DTS（解码时间戳）和PTS（显示时间戳）来管理。DTS指示解码时机，PTS指示显示时机。这些时间戳由编码器生成，确保视频流按正确的顺序处理和呈现。 参考帧...
官方openH264编译时使用的源码
09-22
- **WebRTC**：Web Real-Time Communication，一种在浏览器间进行实时通信的技术，openH264为其提供H.264编码和解码功能，支持高质量的视频通话。 - **RTSP/RTMP流媒体**：openH264也可以用于服务器端的视频流编码，...
openh264:开源H.264编解码器-Open source
03-25
OpenH264 OpenH264是一个编解码器库，支持H.264编码和解码。 它适用于WebRTC等实时应用程序。 有关更多详细信息，请参见 。 编码器功能 受限基线配置文件，最高级别为5.2（最大帧大小为36864宏块） 任意分辨率，不受限于16x16的倍数 具有自适应量化或恒定量化的速率控制 切片选项：每帧1个切片，每帧N个切片，每个切片N个宏块或每个切片N个字节 多个线程自动用于多个切片 二元层次结构中的时间可伸缩性最多可达到4层 通过单个输入即可同时进行多达4种分辨率的Simulcast AVC 通过单个输入即可同时播出高达4种分辨率的空间 长期参考（LTR）帧 内存管理控制操作（MMCO） 参考图片列表修改 用于帧间预测的单个参考帧 使用LTR和/或3-4个时间层时的多个参考帧 周期性和按需即时解码器刷新（IDR）帧插入 动态更改比特率，帧率和分辨率 附件B字节流输出
思科的H.264编码器OpenH264.zip
07-17
OpenH264 是思科公司发布的一个开源的 H.264 编码和解码器。编码器特性Constrained Baseline Profile up to Level 5.2 (4096x2304)Arbitrary resolution, not constrained to multiples of 16x16Rate control with adaptive quantization, or constant quantizationSlice options: 1 slice per frame, N slices per frame, N macroblocks per slice, or N bytes per sliceMultiple threads automatically used for multiple slicesTemporal scalability up to 4 layers in a dyadic hierarchySpatial simulcast up to 4 resolutions from a single inputLong Term Reference (LTR) framesMemory Management Control Operation (MMCO)Reference picture list modificationSingle reference frame for inter predictionMultiple reference frames when using LTR and/or 3-4 temporal layersPeriodic and on-demand Instantaneous Decoder Refresh (IDR) frame insertionDynamic changes to bit rate, frame rate, and resolutionAnnex B byte stream outputYUV 4:2:0 planar input解码器特性Constrained Baseline Profile up to Level 5.2 (4096x2304)Arbitrary resolution, not constrained to multiples of 16x16Single thread for all slicesLong Term Reference (LTR) framesMemory Management Control Operation (MMCO)Reference picture list modificationMultiple reference frames when specified in Sequence Parameter Set (SPS)Annex B byte stream inputYUV 4:2:0 planar output支持的操作系统Windows 64-bit and 32-bit (initial release is only 32-bit, 64-bit will follow soon)Mac OS X 64-bit (initial release does not include this target, will follow soon)Linux 64-bit and 32-bit (initial release is only 32-bit, 64-bit will follow soon)Android 32-bit (initial release does not include this target, will follow soon)iOS 64-bit and 32-bit (not supported yet, may be added in the future)支持的处理器Intel x86 optionally with MMX/SSE (no AVX yet, help is welcome)ARMv7 optionally with NEON (initial release does not include this target, will follow later)Any architecture using C/C fallback functions 标签：OpenH264
openh264-master
05-19
H264源代码程序，亲测好用呦。。 H.264 的功能分为两层，即视频编码层（VCL）和网络提取层（NAL，Network Abstraction Layer）。VCL 数据即编码处理的输出，它表示被压缩编码后的视频数据序列。在 VCL 数据传输或存储之前，这些编码的 VCL 数据，先被映射或封装进 NAL 单元中。 每个 NAL 单元包括一个原始字节序列负荷（RBSP）、一组对应于视频编码数据的 NAL 头信息。
OpenH264
热门推荐
chinabinlang的专栏
11-17 2万+
Contents Encoder Interface Usage: 2 Step#1: create and destroy the encoder 2 Step#2: initialize the encoder 2 Step#3: invoker the encoding 2 Step#4: control the encoding 3 Encoder Option List: 4
开源项目推荐：OpenH264——高效可靠的H.264编码解码库
gitblog_00051的博客
05-09 846
开源项目推荐：OpenH264——高效可靠的H.264编码解码库 openh264Open Source H.264 Codec 项目地址:https://gitcode.com/gh_mirrors/op/openh264 项目介绍 OpenH264是一个强大的开源H.264编解码库，专为实时应用程序如WebRTC设计。其由思科系统开发并维护，并提供了从基础到高级特性的广泛支持，旨在满足各种复...
openh264初探
David的博客
03-14 328
【代码】openh264初探。
openh264使用指南
bjrxyz的专栏
10-25 1万+
openh264使用指南概述目前openh264官网只有一些问答，关键的开发资料全在github页的的wiki页面(https://github.com/cisco/openh264/wiki)同样官方的二进制库也在github页的release页面上提供下载(https://github.com/cisco/openh264/releases)此文章所述皆为windows平台，其他平台使用类似。此
openh264 编码器源码分析：WelsCodeOneSlice 函数
想都是问题，做才有答案～～
06-13 826
openh264 编码器源码分析：WelsCodeOneSlice 函数
通过 OpenH264 启用 H.264 编码
最新发布
09-12
OpenH264 是一个开源的 H.264 视频编码库，它提供了一种高效的方式来启用 H.264 编码。H.264 是一种广泛应用于视频压缩的标准，支持高清晰度和更高效的比特率利用。下面是启用 OpenH264 进行 H.264 编码的基本步骤： 1. **下载和集成**：首先，你需要从 OpenH264 的 GitHub 仓库 (https://github.com/cisco/openh264) 下载源代码并将其集成到你的项目中。 2. **配置编译选项**：在构建过程中，确保包含必要的编译标志，如 `-DHAVE_LIBopenh264=ON` 或 `-DWITH_OPENH264=ON`，以便编译时链接 OpenH264 库。 3. **初始化编码器**：在程序中，创建 `AVCodecContext` 对象，并设置其编码器类型为 `AV_CODEC_ID_H264`。例如： ```cpp AVCodec *codec = avcodec_find_encoder(AV_CODEC_ID_H264); if (!codec) { // 处理找不到编码器的情况 } AVCodecContext *ctx = avcodec_alloc_context3(codec); ctx->codec_id = AV_CODEC_ID_H264; ``` 4. **初始化帧**：创建帧结构体 `AVFrame`，用于存储视频数据，并设置编码参数。 5. **编码过程**：调用 `avcodec_encode_video2()` 函数来进行实际的编码操作，传入编码上下文、帧指针以及编码参数。 ```cpp int ret; while ((ret = avcodec_encode_video2(ctx, outbuf, &frame, frame_flags)) >= 0) { // 编码成功，处理编码后的数据 } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码流怪侠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值