H.265之三 -帧内预测（4）

最新推荐文章于 2022-03-06 15:02:29 发布
最新推荐文章于 2022-03-06 15:02:29 发布
阅读量1.1k 收藏
点赞数
分类专栏： H.265

本文主要把实现亮度分量帧内预测的主函数的大体框架通过代码注释的方式介绍一下。

Void 
TEncSearch::estIntraPredQT( TComDataCU* pcCU, 
                           TComYuv*    pcOrgYuv, 
                           TComYuv*    pcPredYuv, 
                           TComYuv*    pcResiYuv, 
                           TComYuv*    pcRecoYuv,
                           UInt&       ruiDistC,
                           Bool        bLumaOnly )
{
  UInt    uiDepth        = pcCU->getDepth(0); //!< 当前CU的深度
  UInt    uiNumPU        = pcCU->getNumPartInter(); //!< 当前CU的分割模式，(SIZE_2Nx2N:1, SIZE_2NxN:2, SIZE_Nx2N:2, SIZE_NxN:4 ... )
  UInt    uiInitTrDepth  = pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1; //!< 用于计算变换的深度，实际深度为该值+uiDepth
  UInt    uiWidth        = pcCU->getWidth (0) >> uiInitTrDepth; //!< 当前PU的宽度，如果又分成4个子块，则宽度除以2
  UInt    uiHeight       = pcCU->getHeight(0) >> uiInitTrDepth; //!< 当前PU的高度，如果又分成4个子块，则高度除以2
  UInt    uiQNumParts    = pcCU->getTotalNumPart() >> 2; // 最小的分区是4x4大小的块，这里计算出以该4x4块为单位的分割数，这么做便于计算当前CU的Zorder坐标
  UInt    uiWidthBit     = pcCU->getIntraSizeIdx(0);
  UInt    uiOverallDistY = 0;
  UInt    uiOverallDistC = 0;
  UInt    CandNum;
  Double  CandCostList[ FAST_UDI_MAX_RDMODE_NUM ];
  
  //===== set QP and clear Cbf =====
  if ( pcCU->getSlice()->getPPS()->getUseDQP() == true)
  {
    pcCU->setQPSubParts( pcCU->getQP(0), 0, uiDepth );
  }
  else
  {
    pcCU->setQPSubParts( pcCU->getSlice()->getSliceQp(), 0, uiDepth );
  }
  
  //===== loop over partitions =====
  UInt uiPartOffset = 0; //!< 用于记录当前PU的Zorder坐标
  for( UInt uiPU = 0; uiPU < uiNumPU; uiPU++, uiPartOffset += uiQNumParts ) //!< 对当前CU中的每个PU进行遍历
  {
    //===== init pattern for luma prediction =====
    Bool bAboveAvail = false;
    Bool bLeftAvail  = false;
    pcCU->getPattern()->initPattern   ( pcCU, uiInitTrDepth, uiPartOffset ); // set parameters from CU data for accessing neighbouring pixels
 // set luma parameters from CU data for accessing ADI data //!< 主要获取当前PU的邻域可用性，对参考样点进行设置及滤波
    pcCU->getPattern()->initAdiPattern( pcCU, uiPartOffset, uiInitTrDepth, m_piYuvExt, m_iYuvExtStride, m_iYuvExtHeight, bAboveAvail, bLeftAvail );
    
    //===== determine set of modes to be tested (using prediction signal only) =====
    Int numModesAvailable     = 35; //total number of Intra modes
    Pel* piOrg         = pcOrgYuv ->getLumaAddr( uiPU, uiWidth );
    Pel* piPred        = pcPredYuv->getLumaAddr( uiPU, uiWidth );
    UInt uiStride      = pcPredYuv->getStride();
    UInt uiRdModeList[FAST_UDI_MAX_RDMODE_NUM];
    Int numModesForFullRD = g_aucIntraModeNumFast[ uiWidthBit ]; //!< MPM数目
    //!< g_aucIntraModeNumFast[] = {3, 8, 8, 3, 3, 3, 3}; 2x2, 4x4, 8x8, 16x16, 32x32, 64x64, 128x128
    Bool doFastSearch = (numModesForFullRD != numModesAvailable); //!< 此处doFastSearch恒为真
    if (doFastSearch)
    {
      assert(numModesForFullRD < numModesAvailable);

      for( Int i=0; i < numModesForFullRD; i++ ) 
      {
        CandCostList[ i ] = MAX_DOUBLE;
      }
      CandNum = 0;
      
      for( Int modeIdx = 0; modeIdx < numModesAvailable; modeIdx++ ) //!< 遍历35种帧内预测模式
      {
        UInt uiMode = modeIdx;
  //! 调用亮度帧内预测函数
        predIntraLumaAng( pcCU->getPattern(), uiMode, piPred, uiStride, uiWidth, uiHeight, pcCU, bAboveAvail, bLeftAvail );
        
        // use hadamard transform here
        UInt uiSad = m_pcRdCost->calcHAD( piOrg, uiStride, piPred, uiStride, uiWidth, uiHeight );
        
        UInt   iModeBits = xModeBitsIntra( pcCU, uiMode, uiPU, uiPartOffset, uiDepth, uiInitTrDepth );
        Double cost      = (Double)uiSad + (Double)iModeBits * m_pcRdCost->getSqrtLambda();
        
        CandNum += xUpdateCandList( uiMode, cost, numModesForFullRD, uiRdModeList, CandCostList );
      }
    
#if FAST_UDI_USE_MPM // UDI---Unified Directional Intra
      Int uiPreds[3] = {-1, -1, -1};
      Int iMode = -1;  //!< 如果三个MPMs的前两个相同，则iMode=1，否则iMode=2
      Int numCand = pcCU->getIntraDirLumaPredictor( uiPartOffset, uiPreds, &iMode ); //!< 获取亮度帧内预测模式的三个MPMs
      if( iMode >= 0 ) //!< iMode = 1 or 2，因此，numCand会被重新赋值为iMode
      {
        numCand = iMode;
      }
      
      for( Int j=0; j < numCand; j++)

      {
        Bool mostProbableModeIncluded = false;
        Int mostProbableMode = uiPreds[j]; //!< 取出MPM
        
        for( Int i=0; i < numModesForFullRD; i++)
        {
          mostProbableModeIncluded |= (mostProbableMode == uiRdModeList[i]); //!< 检查MPMs是否被uiRdModeList所包含
        }
        if (!mostProbableModeIncluded)  //!< 如果没被包含，则将该MPM包含到uiRdModeList里
        {
          uiRdModeList[numModesForFullRD++] = mostProbableMode;
        }
      }
#endif // FAST_UDI_USE_MPM
    } //!< if (doFastSearch)
    else
    {
      for( Int i=0; i < numModesForFullRD; i++)
      {
        uiRdModeList[i] = i;
      }
    }
    
    //===== check modes (using r-d costs) =====
 //! 帧内预测模式最佳值的确定主要有以下几个步骤：1. 对numModesForFullRD种预测模式进行遍历，即对每种模式计算出
 //! 对应的RD costs，但该步骤中，并不会把一个CU的所有分割都算一遍，而仅仅对于至多深度为1的分割进行遍历，这么做
 //! 大大减少了运算量，提高速度；2. 在第1个步骤中，会粗略得到最佳预测模式（在HM9.0中会得到包括次优解在内的两个
 //! 预测模式），存储下来，以供第3步使用；3. 在第2步的基础上，对最佳（及次优）预测模式的所有分割模式遍历一遍，
 //! 得到最终的最佳结果
#if HHI_RQT_INTRA_SPEEDUP_MOD
    UInt   uiSecondBestMode  = MAX_UINT;
    Double dSecondBestPUCost = MAX_DOUBLE;
#endif
    
    UInt    uiBestPUMode  = 0; //!< 存放最佳预测模式
    UInt    uiBestPUDistY = 0; //!< 存放最佳预测模式对应的亮度失真值
    UInt    uiBestPUDistC = 0; //!< 存放最佳预测模式对应的色度失真值
    Double  dBestPUCost   = MAX_DOUBLE;  //!< 存放最佳预测模式对应的总代价
    for( UInt uiMode = 0; uiMode < numModesForFullRD; uiMode++ ) //!< 遍历存储在uiRdModeList里的模式
    {
      // set luma prediction mode
      UInt uiOrgMode = uiRdModeList[uiMode];
      
      pcCU->setLumaIntraDirSubParts ( uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );
      
      // set context models
      if( m_bUseSBACRD )
      {
        m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
      }
      
      // determine residual for partition
      UInt   uiPUDistY = 0;  //!< 存放当前预测模式对应的亮度失真值
      UInt   uiPUDistC = 0;  //!< 存放当前预测模式对应的色度失真值
      Double dPUCost   = 0.0; //!< 存放当前预测模式对应的代价
#if HHI_RQT_INTRA_SPEEDUP //! 注意这个函数倒数第二个参数，此时为true
      xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, true, dPUCost );
#else
      xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, dPUCost );
#endif
      
      // check r-d cost
      if( dPUCost < dBestPUCost ) //!< 更新最佳预测模式相关参数
      {
#if HHI_RQT_INTRA_SPEEDUP_MOD
        uiSecondBestMode  = uiBestPUMode;
        dSecondBestPUCost = dBestPUCost;
#endif
        uiBestPUMode  = uiOrgMode;
        uiBestPUDistY = uiPUDistY;
        uiBestPUDistC = uiPUDistC;
        dBestPUCost   = dPUCost;
        
        xSetIntraResultQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcRecoYuv );
        
        UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
        ::memcpy( m_puhQTTempTrIdx,  pcCU->getTransformIdx()       + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        ::memcpy( m_puhQTTempCbf[0], pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        ::memcpy( m_puhQTTempCbf[1], pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        ::memcpy( m_puhQTTempCbf[2], pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        ::memcpy( m_puhQTTempTransformSkipFlag[0], pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        ::memcpy( m_puhQTTempTransformSkipFlag[1], pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        ::memcpy( m_puhQTTempTransformSkipFlag[2], pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
      }
#if HHI_RQT_INTRA_SPEEDUP_MOD
      else if( dPUCost < dSecondBestPUCost )
      {
        uiSecondBestMode  = uiOrgMode;
        dSecondBestPUCost = dPUCost;
      }
#endif
    } // Mode loop
    
#if HHI_RQT_INTRA_SPEEDUP
#if HHI_RQT_INTRA_SPEEDUP_MOD
    for( UInt ui =0; ui < 2; ++ui )
#endif
    {
#if HHI_RQT_INTRA_SPEEDUP_MOD
      UInt uiOrgMode   = ui ? uiSecondBestMode  : uiBestPUMode;
      if( uiOrgMode == MAX_UINT )
      {
        break;
      }
#else
      UInt uiOrgMode = uiBestPUMode; //!<　设置模式为最佳预测模式
#endif
      
      pcCU->setLumaIntraDirSubParts ( uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );
      
      // set context models
      if( m_bUseSBACRD )
      {
        m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
      }
      
      // determine residual for partition
      UInt   uiPUDistY = 0;
      UInt   uiPUDistC = 0;
      Double dPUCost   = 0.0;
   //! 注意该函数倒数第二个参数，此时为false
      xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, false, dPUCost );
      
      // check r-d cost
      if( dPUCost < dBestPUCost )
      {
        uiBestPUMode  = uiOrgMode;
        uiBestPUDistY = uiPUDistY;
        uiBestPUDistC = uiPUDistC;
        dBestPUCost   = dPUCost;
        
        xSetIntraResultQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcRecoYuv );
        
        UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
        ::memcpy( m_puhQTTempTrIdx,  pcCU->getTransformIdx()       + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        ::memcpy( m_puhQTTempCbf[0], pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        ::memcpy( m_puhQTTempCbf[1], pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        ::memcpy( m_puhQTTempCbf[2], pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        ::memcpy( m_puhQTTempTransformSkipFlag[0], pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        ::memcpy( m_puhQTTempTransformSkipFlag[1], pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        ::memcpy( m_puhQTTempTransformSkipFlag[2], pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
      }
    } // Mode loop
#endif
    
    //--- update overall distortion ---
    uiOverallDistY += uiBestPUDistY;
    uiOverallDistC += uiBestPUDistC;
    
    //--- update transform index and cbf ---
    UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
    ::memcpy( pcCU->getTransformIdx()       + uiPartOffset, m_puhQTTempTrIdx,  uiQPartNum * sizeof( UChar ) );
    ::memcpy( pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, m_puhQTTempCbf[0], uiQPartNum * sizeof( UChar ) );
    ::memcpy( pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, m_puhQTTempCbf[1], uiQPartNum * sizeof( UChar ) );
    ::memcpy( pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, m_puhQTTempCbf[2], uiQPartNum * sizeof( UChar ) );
    ::memcpy( pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, m_puhQTTempTransformSkipFlag[0], uiQPartNum * sizeof( UChar ) );
    ::memcpy( pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, m_puhQTTempTransformSkipFlag[1], uiQPartNum * sizeof( UChar ) );
    ::memcpy( pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, m_puhQTTempTransformSkipFlag[2], uiQPartNum * sizeof( UChar ) );
    //--- set reconstruction for next intra prediction blocks ---
    if( uiPU != uiNumPU - 1 )
    {
      Bool bSkipChroma  = false;
      Bool bChromaSame  = false;
      UInt uiLog2TrSize = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> ( pcCU->getDepth(0) + uiInitTrDepth ) ] + 2;
      if( !bLumaOnly && uiLog2TrSize == 2 )
      {
        assert( uiInitTrDepth  > 0 );
        bSkipChroma  = ( uiPU != 0 );
        bChromaSame  = true;
      }
      
      UInt    uiCompWidth   = pcCU->getWidth ( 0 ) >> uiInitTrDepth;
      UInt    uiCompHeight  = pcCU->getHeight( 0 ) >> uiInitTrDepth;
      UInt    uiZOrder      = pcCU->getZorderIdxInCU() + uiPartOffset;
      Pel*    piDes         = pcCU->getPic()->getPicYuvRec()->getLumaAddr( pcCU->getAddr(), uiZOrder );
      UInt    uiDesStride   = pcCU->getPic()->getPicYuvRec()->getStride();
      Pel*    piSrc         = pcRecoYuv->getLumaAddr( uiPartOffset );
      UInt    uiSrcStride   = pcRecoYuv->getStride();
      for( UInt uiY = 0; uiY < uiCompHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
      {
        for( UInt uiX = 0; uiX < uiCompWidth; uiX++ )
        {
          piDes[ uiX ] = piSrc[ uiX ];
        }
      }
      if( !bLumaOnly && !bSkipChroma )
      {
        if( !bChromaSame )
        {
          uiCompWidth   >>= 1;
          uiCompHeight  >>= 1;
        }
        piDes         = pcCU->getPic()->getPicYuvRec()->getCbAddr( pcCU->getAddr(), uiZOrder );
        uiDesStride   = pcCU->getPic()->getPicYuvRec()->getCStride();
        piSrc         = pcRecoYuv->getCbAddr( uiPartOffset );
        uiSrcStride   = pcRecoYuv->getCStride();
        for( UInt uiY = 0; uiY < uiCompHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
        {
          for( UInt uiX = 0; uiX < uiCompWidth; uiX++ )
          {
            piDes[ uiX ] = piSrc[ uiX ];
          }
        }
        piDes         = pcCU->getPic()->getPicYuvRec()->getCrAddr( pcCU->getAddr(), uiZOrder );
        piSrc         = pcRecoYuv->getCrAddr( uiPartOffset );
        for( UInt uiY = 0; uiY < uiCompHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
        {
          for( UInt uiX = 0; uiX < uiCompWidth; uiX++ )
          {
            piDes[ uiX ] = piSrc[ uiX ];
          }
        }
      }
    }
    
    //=== update PU data ====
    pcCU->setLumaIntraDirSubParts     ( uiBestPUMode, uiPartOffset, uiDepth + uiInitTrDepth );
    pcCU->copyToPic                   ( uiDepth, uiPU, uiInitTrDepth );
  } // PU loop
  
  
  if( uiNumPU > 1 )
  { // set Cbf for all blocks
    UInt uiCombCbfY = 0;
    UInt uiCombCbfU = 0;
    UInt uiCombCbfV = 0;
    UInt uiPartIdx  = 0;
    for( UInt uiPart = 0; uiPart < 4; uiPart++, uiPartIdx += uiQNumParts )
    {
      uiCombCbfY |= pcCU->getCbf( uiPartIdx, TEXT_LUMA,     1 );
      uiCombCbfU |= pcCU->getCbf( uiPartIdx, TEXT_CHROMA_U, 1 );
      uiCombCbfV |= pcCU->getCbf( uiPartIdx, TEXT_CHROMA_V, 1 );
    }
    for( UInt uiOffs = 0; uiOffs < 4 * uiQNumParts; uiOffs++ )
    {
      pcCU->getCbf( TEXT_LUMA     )[ uiOffs ] |= uiCombCbfY;
      pcCU->getCbf( TEXT_CHROMA_U )[ uiOffs ] |= uiCombCbfU;
      pcCU->getCbf( TEXT_CHROMA_V )[ uiOffs ] |= uiCombCbfV;
    }
  }
  
  //===== reset context models =====
  if(m_bUseSBACRD)
  {
    m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
  }
  
  //===== set distortion (rate and r-d costs are determined later) =====
  ruiDistC                   = uiOverallDistC;
  pcCU->getTotalDistortion() = uiOverallDistY + uiOverallDistC;
}
转自（ http://blog.csdn.net/hevc_cjl/article/details/8200793）

shtiny
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
h265官方文档__T-REC-H.265-201504-I!!PDF-E.pdf
10-14
1. **更高的压缩效率**：H.265采用了更复杂的编码算法，如更精细的块划分（最小至4x4像素）、更灵活的运动补偿预测、多模式熵编码等，使得在相同的视频质量下，码率可减少大约50%，这对于高清和超高清视频的传输尤其...
T-REC-H.265-201906-PDF.zip
12-15
3. **多参考帧预测**：H.265支持更多的参考帧用于预测，可以更准确地估计运动信息，从而提高编码效率。 4. **高动态范围（HDR）支持**：相较于H.264仅支持标准动态范围（SDR）视频，H.265增加了对HDR的支持，使得...
H.264压缩技术之总览（Overview）——Matlab源码解析
lmboss的博客
03-06 5026
Chapter1：H.264压缩技术之总览(Overview)——Matlab源码解析
VVC学习之五：帧内预测——MPM列表建立
Aidoneus_y
05-15 1774
getIntraMPMs()为命名空间PU下的函数，用于获取帧内预测MPM，一共三类：传统预测MPM，多参考行预测MPM，ISP预测MPM。 int PU::getIntraMPMs( const PredictionUnit &pu, unsigned* mpm, const ChannelType &channelType /*= CHANNEL_TYPE_LUMA*/ ) {...
HEVC学习（六） —— 帧内预测系列之四
sunnydreamrain的专栏
12-12 2290
本文主要把实现亮度分量帧内预测的主函数的大体框架通过代码注释的方式介绍一下。   [cpp] view plaincopy Void    TEncSearch::estIntraPredQT( TComDataCU* pcCU,                               TComYuv*    pcOrgYuv,
HEVC核心编码技术之二.帧内预测
北雨南萍
06-16 6182
Overview of the High Efficiency Video Coding(HEVC) Standard之四 G. 帧内预测 Intrapicture Prediction Fig. 6. Modes and directional orientations for intrapicture prediction. Intrapicture prediction
H.266/VVC-VTM代码学习-帧内预测12-编码端获取MPM列表getIntraMPMs函数
liaojq2020的博客
11-17 529
H.266/VVC专栏传送 上一篇：H.266/VVC-VTM代码学习-帧内预测11-编码端亮度块模式选择estIntraPredLumaQT函数 下一篇：持续创作中… 目录H.266/VVC专栏传送前言一、函数代码二、逻辑结构1.初始化2.A、B模式相同时3.A、B模式不同时(1) A、B不同但都为角度模式(2) A、B不同且至少一个角度模式 前言 VTM是H.266/VVC视频编码标准的参考软件，研究VTM代码给研究人员解释了VVC编码标准的详细标准规范与细节。 本文是笔者对VTM代码的一点学习记录，成
T-REC-H.265-201304-I!!PDF-E_hevc_rec_h265标准_h265_
10-03
H.265采用了更多样化的预测模式，包括基于帧内预测（Intra Prediction）和帧间预测（Inter Prediction）。帧内预测增加了新的方向模式，而帧间预测引入了多参考帧和运动补偿预测，进一步提升了预测精度。 3. **...
H.265帧内预测文档
09-05
H.265帧内预测总结文档，对H.265帧内预测方式及运动矢量处理做一些详细总结
h.264和mpeg-4视频压缩--欧阳合译中文清晰版（1）
09-15
《H.264与MPEG-4视频压缩——欧阳合译中文清晰版》是一部针对视频编码技术的重要著作，尤其适合那些对视频压缩技术感兴趣的学习者。本资源分为三个部分，全面介绍了这两种主流的视频编码标准，是学习视频处理领域的...
matlab 编写的H.264编解码
07-03
H.264 编解码的一个简单实现 实现了帧内 帧间编码
H.264源码（for MATLAB）
09-18
包含可在MATLAB中使用的H.264编解码源码，以及两篇相关文献资料。
H.265 最新参考源码
04-02
H.265官方参考源码，win下vs2008打开编译即可
HEVC/H.265测试模型
04-29
HEVC/H.265测试模型的最新版本—HM3.0，是学习新一代视频编码技术的必备资源，希望对相关人员有所帮助。
基于图像块的运动估计matlab代码
04-14
基于图像块的运动估计matlab代码
干货 |　H.265技术在短视频的应用及未来前景
cizhunuo5038的博客
10-26 595
作者：姜生。现担任PPTV&苏宁体育编解码内核开发高级技术经理。图像编解码、高性能计算出身；从事H.264 decoder 开发与优化， H.265 编码器开发与优化。10年以上音视频媒体开发经验。目前负责H.265 e...
【HEVC】目前H265分析软件推荐
Ant for life.
04-11 7625
1，Codecvisa：http://codecian.com/ 国产软件，从最早的H264visa发展至今，感觉从刚开始的玩票，发展到今天专业级别的商业软件，值得支持。 软件试用版30天试用，20帧限制。 优点：QT开发，跨平台 缺点：性能，功能，风格，专业程度和真正大牛级别的商业软件相比还是有距离。 2，Elecard HEVC Analyzer：http://www.eleca
H.265与H.264的差异详解
热门推荐
北雨南萍
09-03 3万+
目录： 1.编解码框架差异 2.压缩性能比较 3.各模块技术差异汇总 4.块划分结构 5.帧内预测 6.帧间预测 7.去块滤波 8.SAO滤波 9.Tile 10.WPP 11.Dependent slice 12.其他技术   1.    H.264与H.265的主要差异 H.265仍然采用混合编解码，编解码结构域H.264基本一致， 主要的不同在于： Ø 
H.265：高清视频的最佳选择
weixin_30907523的博客
01-14 949
H.265技术经过2年发展,我们认为H.265高清监控产品市场化才真正开始。那么H.265的到来，大家又对该技术真正了解多少呢?下面就让我们一起来了解该技术。... HEVC/H.265标准于2013年2月被国际电联(ITU)正式批准通过，由于它特有技术优势，一经推出就受到市场高度关注。高清网络监控紧跟在视频编码技术应用前沿，一直都希望尽早将该技术产品化，艾普视达一直致力于在数...
(eWiley) H.264 & MPEG-4 Video Compression节选中文文档
04-12
(eWiley) H.264 & MPEG-4 Video Compression节选中文文档

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值