FFmpeg的HEVC解码器源代码学习笔记-2

最新推荐文章于 2024-05-03 15:00:50 发布
最新推荐文章于 2024-05-03 15:00:50 发布
阅读量756 收藏 9
点赞数 11
分类专栏： HEVC/VVC技术 FFmpeg HEVC/VVC视频编码论文 文章标签： ffmpeg 学习 笔记 h.264 h.265 c++ h.266
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxwtiancai/article/details/136162038
版权

摘要

这篇主要厘清FFmpeg如何调用多种视频编解码代码进行解码的主要函数调用逻辑

背景

FFmpeg作为一个视频编解码开源框架，被企业和个人广泛使用，但是一直不清楚他是怎么调用多种编解码器的，由于现在想做一个HEVC的码流分析器，需要了解FFmpeg对265码流解析的具体过程，今天按照官方提供的解码样例代码，整理一下FFmpeg是如何从外部包装代码到指定编解码代码实现解码流程的，主要以HEVC的解码过程为例。

// 从上至下进行调用
avcodec_receive_frame
decode_receive_frame_internal
decode_simple_receive_frame
decode_simple_internal
// 从这里开始使用decode函数指针指向hevc_decode_frame
avctx->codec->decode(avctx, frame, &got_frame, pkt);//函数指针指向hevc_decode_frame()，也即调用的hevc_decode_frame；
decode_nal_units
decode_nal_unit
ctb_addr_ts = hls_slice_data(s);
// 从这里开始进入解码，前面的函数主要是解析功能
s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
hls_decode_entry
hls_coding_quadtree
hls_coding_unit
hls_prediction_unit
hls_transform_tree
hls_transform_unit
ff_hevc_hls_residual_coding

整理流程中，才发现PU不是获得残差信息，PU只是获取到预测角度，运动矢量等信息，而实际计算残差信号也是在TU中计算的，TU里面才真正根据PU的信息获取到残差信号。
之前一直以为先PU计算得到了残差数据，然后传递给TU，TU直接对残差数据进行DCT变换后进行cabac编码了，我就说为什么hevc解码的时候，是先解码PU，再解码TU。
按照我之前的理解先PU获取残差数据，再TU变换编码，应该先idct TU里面的数据，再解码出残差信号。
特意回去看了一下HM的编码代码，再TU的编码函数中，找到了如下代码：

Void TEncSearch::xIntraCodingTUBlock(       TComYuv*    pcOrgYuv,
                                            TComYuv*    pcPredYuv,
                                            TComYuv*    pcResiYuv,
                                            Pel         resiLuma[NUMBER_OF_STORED_RESIDUAL_TYPES][MAX_CU_SIZE * MAX_CU_SIZE],
                                      const Bool        checkCrossCPrediction,
                                            Distortion& ruiDist,
                                      const ComponentID compID,
                                            TComTU&     rTu
                                      DEBUG_STRING_FN_DECLARE(sDebug)
                                           ,Int         default0Save1Load2
                                     )
{
  if (!rTu.ProcessComponentSection(compID))
  {
    return;
  }
  const Bool           bIsLuma          = isLuma(compID);
  const TComRectangle &rect             = rTu.getRect(compID);
        TComDataCU    *pcCU             = rTu.getCU();
  const UInt           uiAbsPartIdx     = rTu.GetAbsPartIdxTU();
  const TComSPS       &sps              = *(pcCU->getSlice()->getSPS());

  const UInt           uiTrDepth        = rTu.GetTransformDepthRelAdj(compID);
  const UInt           uiFullDepth      = rTu.GetTransformDepthTotal();
  const UInt           uiLog2TrSize     = rTu.GetLog2LumaTrSize();
  const ChromaFormat   chFmt            = pcOrgYuv->getChromaFormat();
  const ChannelType    chType           = toChannelType(compID);
  const Int            bitDepth         = sps.getBitDepth(chType);

  const UInt           uiWidth          = rect.width;
  const UInt           uiHeight         = rect.height;
  const UInt           uiStride         = pcOrgYuv ->getStride (compID);
        Pel           *piOrg            = pcOrgYuv ->getAddr( compID, uiAbsPartIdx );
        Pel           *piPred           = pcPredYuv->getAddr( compID, uiAbsPartIdx );
        Pel           *piResi           = pcResiYuv->getAddr( compID, uiAbsPartIdx );
        Pel           *piReco           = pcPredYuv->getAddr( compID, uiAbsPartIdx );
  const UInt           uiQTLayer        = sps.getQuadtreeTULog2MaxSize() - uiLog2TrSize;
        Pel           *piRecQt          = m_pcQTTempTComYuv[ uiQTLayer ].getAddr( compID, uiAbsPartIdx );
  const UInt           uiRecQtStride    = m_pcQTTempTComYuv[ uiQTLayer ].getStride(compID);
  const UInt           uiZOrder         = pcCU->getZorderIdxInCtu() + uiAbsPartIdx;
        Pel           *piRecIPred       = pcCU->getPic()->getPicYuvRec()->getAddr( compID, pcCU->getCtuRsAddr(), uiZOrder );
        UInt           uiRecIPredStride = pcCU->getPic()->getPicYuvRec()->getStride  ( compID );
        TCoeff        *pcCoeff          = m_ppcQTTempCoeff[compID][uiQTLayer] + rTu.getCoefficientOffset(compID);
        Bool           useTransformSkip = pcCU->getTransformSkip(uiAbsPartIdx, compID);

#if ADAPTIVE_QP_SELECTION
        TCoeff        *pcArlCoeff       = m_ppcQTTempArlCoeff[compID][ uiQTLayer ] + rTu.getCoefficientOffset(compID);
#endif

  const UInt           uiChPredMode     = pcCU->getIntraDir( chType, uiAbsPartIdx );
  const UInt           partsPerMinCU    = 1<<(2*(sps.getMaxTotalCUDepth() - sps.getLog2DiffMaxMinCodingBlockSize()));
  const UInt           uiChCodedMode    = (uiChPredMode==DM_CHROMA_IDX && !bIsLuma) ? pcCU->getIntraDir(CHANNEL_TYPE_LUMA, getChromasCorrespondingPULumaIdx(uiAbsPartIdx, chFmt, partsPerMinCU)) : uiChPredMode;
  const UInt           uiChFinalMode    = ((chFmt == CHROMA_422)       && !bIsLuma) ? g_chroma422IntraAngleMappingTable[uiChCodedMode] : uiChCodedMode;

  const Int            blkX                                 = g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
  const Int            blkY                                 = g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
  const Int            bufferOffset                         = blkX + (blkY * MAX_CU_SIZE);
        Pel  *const    encoderLumaResidual                  = resiLuma[RESIDUAL_ENCODER_SIDE ] + bufferOffset;
        Pel  *const    reconstructedLumaResidual            = resiLuma[RESIDUAL_RECONSTRUCTED] + bufferOffset;
  const Bool           bUseCrossCPrediction                 = isChroma(compID) && (uiChPredMode == DM_CHROMA_IDX) && checkCrossCPrediction;
  const Bool           bUseReconstructedResidualForEstimate = m_pcEncCfg->getUseReconBasedCrossCPredictionEstimate();
        Pel *const     lumaResidualForEstimate              = bUseReconstructedResidualForEstimate ? reconstructedLumaResidual : encoderLumaResidual;

#if DEBUG_STRING
  const Int debugPredModeMask=DebugStringGetPredModeMask(MODE_INTRA);
#endif

  //===== init availability pattern =====
  DEBUG_STRING_NEW(sTemp)

#if !DEBUG_STRING
  if( default0Save1Load2 != 2 )
#endif
  {
    const Bool bUseFilteredPredictions=TComPrediction::filteringIntraReferenceSamples(compID, uiChFinalMode, uiWidth, uiHeight, chFmt, sps.getSpsRangeExtension().getIntraSmoothingDisabledFlag());

    initIntraPatternChType( rTu, compID, bUseFilteredPredictions DEBUG_STRING_PASS_INTO(sDebug) );
    // 这里写明了是在此处获取预测信号
    //===== get prediction signal =====
    predIntraAng( compID, uiChFinalMode, piOrg, uiStride, piPred, uiStride, rTu, bUseFilteredPredictions );

    // save prediction
    if( default0Save1Load2 == 1 )
    {
      Pel*  pPred   = piPred;
      Pel*  pPredBuf = m_pSharedPredTransformSkip[compID];
      Int k = 0;
      for( UInt uiY = 0; uiY < uiHeight; uiY++ )
      {
        for( UInt uiX = 0; uiX < uiWidth; uiX++ )
        {
          pPredBuf[ k ++ ] = pPred[ uiX ];
        }
        pPred += uiStride;
      }
    }
  }
#if !DEBUG_STRING
  else
  {
    // load prediction
    Pel*  pPred   = piPred;
    Pel*  pPredBuf = m_pSharedPredTransformSkip[compID];
    Int k = 0;
    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
    {
      for( UInt uiX = 0; uiX < uiWidth; uiX++ )
      {
        pPred[ uiX ] = pPredBuf[ k ++ ];
      }
      pPred += uiStride;
    }
  }
#endif
  // 这里写明了是在此处计算预测残差信号，如果需要修改JND的阈值，也应该在这，之前经常修改这个位置，当时居然后没有意识到这个问题。
  //===== get residual signal =====
  {
    // get residual
    Pel*  pOrg    = piOrg;
    Pel*  pPred   = piPred;
    Pel*  pResi   = piResi;

    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
    {
      for( UInt uiX = 0; uiX < uiWidth; uiX++ )
      {
        pResi[ uiX ] = pOrg[ uiX ] - pPred[ uiX ];
      }

      pOrg  += uiStride;
      pResi += uiStride;
      pPred += uiStride;
    }
  }

  if (pcCU->getSlice()->getPPS()->getPpsRangeExtension().getCrossComponentPredictionEnabledFlag())
  {
    if (bUseCrossCPrediction)
    {
      if (xCalcCrossComponentPredictionAlpha( rTu, compID, lumaResidualForEstimate, piResi, uiWidth, uiHeight, MAX_CU_SIZE, uiStride ) == 0)
      {
        return;
      }
      TComTrQuant::crossComponentPrediction ( rTu, compID, reconstructedLumaResidual, piResi, piResi, uiWidth, uiHeight, MAX_CU_SIZE, uiStride, uiStride, false );
    }
    else if (isLuma(compID) && !bUseReconstructedResidualForEstimate)
    {
      xStoreCrossComponentPredictionResult( encoderLumaResidual, piResi, rTu, 0, 0, MAX_CU_SIZE, uiStride );
    }
  }

  //===== transform and quantization =====
  //--- init rate estimation arrays for RDOQ ---
  if( useTransformSkip ? m_pcEncCfg->getUseRDOQTS() : m_pcEncCfg->getUseRDOQ() )
  {
    COEFF_SCAN_TYPE scanType = COEFF_SCAN_TYPE(pcCU->getCoefScanIdx(uiAbsPartIdx, uiWidth, uiHeight, compID));
    m_pcEntropyCoder->estimateBit( m_pcTrQuant->m_pcEstBitsSbac, uiWidth, uiHeight, chType, scanType );
  }

  //--- transform and quantization ---
  TCoeff uiAbsSum = 0;
  if (bIsLuma)
  {
    pcCU       ->setTrIdxSubParts ( uiTrDepth, uiAbsPartIdx, uiFullDepth );
  }

  const QpParam cQP(*pcCU, compID);

#if RDOQ_CHROMA_LAMBDA
  m_pcTrQuant->selectLambda     (compID);
#endif

  m_pcTrQuant->transformNxN     ( rTu, compID, piResi, uiStride, pcCoeff,
#if ADAPTIVE_QP_SELECTION
    pcArlCoeff,
#endif
    uiAbsSum, cQP
    );

  //--- inverse transform ---

#if DEBUG_STRING
  if ( (uiAbsSum > 0) || (DebugOptionList::DebugString_InvTran.getInt()&debugPredModeMask) )
#else
  if ( uiAbsSum > 0 )
#endif
  {
    m_pcTrQuant->invTransformNxN ( rTu, compID, piResi, uiStride, pcCoeff, cQP DEBUG_STRING_PASS_INTO_OPTIONAL(&sDebug, (DebugOptionList::DebugString_InvTran.getInt()&debugPredModeMask)) );
  }
  else
  {
    Pel* pResi = piResi;
    memset( pcCoeff, 0, sizeof( TCoeff ) * uiWidth * uiHeight );
    for( UInt uiY = 0; uiY < uiHeight; uiY++ )
    {
      memset( pResi, 0, sizeof( Pel ) * uiWidth );
      pResi += uiStride;
    }
  }


  //===== reconstruction =====
  {
    Pel* pPred      = piPred;
    Pel* pResi      = piResi;
    Pel* pReco      = piReco;
    Pel* pRecQt     = piRecQt;
    Pel* pRecIPred  = piRecIPred;

    if (pcCU->getSlice()->getPPS()->getPpsRangeExtension().getCrossComponentPredictionEnabledFlag())
    {
      if (bUseCrossCPrediction)
      {
        TComTrQuant::crossComponentPrediction( rTu, compID, reconstructedLumaResidual, piResi, piResi, uiWidth, uiHeight, MAX_CU_SIZE, uiStride, uiStride, true );
      }
      else if (isLuma(compID))
      {
        xStoreCrossComponentPredictionResult( reconstructedLumaResidual, piResi, rTu, 0, 0, MAX_CU_SIZE, uiStride );
      }
    }

 #if DEBUG_STRING
    std::stringstream ss(stringstream::out);
    const Bool bDebugPred=((DebugOptionList::DebugString_Pred.getInt()&debugPredModeMask) && DEBUG_STRING_CHANNEL_CONDITION(compID));
    const Bool bDebugResi=((DebugOptionList::DebugString_Resi.getInt()&debugPredModeMask) && DEBUG_STRING_CHANNEL_CONDITION(compID));
    const Bool bDebugReco=((DebugOptionList::DebugString_Reco.getInt()&debugPredModeMask) && DEBUG_STRING_CHANNEL_CONDITION(compID));

    if (bDebugPred || bDebugResi || bDebugReco)
    {
      ss << "###: " << "CompID: " << compID << " pred mode (ch/fin): " << uiChPredMode << "/" << uiChFinalMode << " absPartIdx: " << rTu.GetAbsPartIdxTU() << "\n";
      for( UInt uiY = 0; uiY < uiHeight; uiY++ )
      {
        ss << "###: ";
        if (bDebugPred)
        {
          ss << " - pred: ";
          for( UInt uiX = 0; uiX < uiWidth; uiX++ )
          {
            ss << pPred[ uiX ] << ", ";
          }
        }
        if (bDebugResi)
        {
          ss << " - resi: ";
        }
        for( UInt uiX = 0; uiX < uiWidth; uiX++ )
        {
          if (bDebugResi)
          {
            ss << pResi[ uiX ] << ", ";
          }
          pReco    [ uiX ] = Pel(ClipBD<Int>( Int(pPred[uiX]) + Int(pResi[uiX]), bitDepth ));
          pRecQt   [ uiX ] = pReco[ uiX ];
          pRecIPred[ uiX ] = pReco[ uiX ];
        }
        if (bDebugReco)
        {
          ss << " - reco: ";
          for( UInt uiX = 0; uiX < uiWidth; uiX++ )
          {
            ss << pReco[ uiX ] << ", ";
          }
        }
        pPred     += uiStride;
        pResi     += uiStride;
        pReco     += uiStride;
        pRecQt    += uiRecQtStride;
        pRecIPred += uiRecIPredStride;
        ss << "\n";
      }
      DEBUG_STRING_APPEND(sDebug, ss.str())
    }
    else
#endif
    {

      for( UInt uiY = 0; uiY < uiHeight; uiY++ )
      {
        for( UInt uiX = 0; uiX < uiWidth; uiX++ )
        {
          pReco    [ uiX ] = Pel(ClipBD<Int>( Int(pPred[uiX]) + Int(pResi[uiX]), bitDepth ));
          pRecQt   [ uiX ] = pReco[ uiX ];
          pRecIPred[ uiX ] = pReco[ uiX ];
        }
        pPred     += uiStride;
        pResi     += uiStride;
        pReco     += uiStride;
        pRecQt    += uiRecQtStride;
        pRecIPred += uiRecIPredStride;
      }
    }
  }

  //===== update distortion =====
  ruiDist += m_pcRdCost->getDistPart( bitDepth, piReco, uiStride, piOrg, uiStride, uiWidth, uiHeight, compID );
}

后面将继续厘清整体的解码流程，再整理解码流程的过程中发现了很多在以前只关注编码流程中没有意识到的问题。

xxwtiancai
关注
  • 11
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
H.265/HEVC的源代码
12-24
H.265/HEVC的C语言源代码，版本10。内涵H.265的编码器和解码器及其编码的主函数。
HEVC最新官方源代码HM15.0
11-22
HEVC(H.265)最新官方源代码HM15.0
20240503安装HEVC解码器播放H265格式的8K视频
最新发布
南岭笑笑生之家
05-03 2229
但是如果机器硬件支持【杜比视界】的话，在安装 Dolby Vision UWP（https://www.chiphell.com/thread-2136981-1-1.html） 之后，目前尝试的只有 Windows 自带的 【电影和电视】 能够正常支持。该编码器已经被许多播放器或转换器如Handbrake和FFmpeg采用和使用，这表明如果你需要免费的Windows 10上的H.265视频扩展，它应该被添加到你的列表中-因为有许多程序证明它是可靠的，对你有用。
HEVC源代码分析（一）--词法分析
shakingWaves的专栏
11-08 2608
一、      HEVC源代码词法分析 (一)HM中词法分析部分涉及TAppCommon和TAppEncoder两个“包”（在此处是两个项目，姑且按照面向对象的习惯称它为“Package”）。 (二)类图 （1）、如何查看类图 在解决方案资源管理器中选中一个含有类的头文件或源文件,然后点击上面的按钮"查看类关系图",就可以打开一个新的窗口,里面会显示所有的类以及每个类有哪些成员,还有类
[Windows] 视频解码工具——HEVC
Chj1319261607的博客
09-28 5040
[Windows] 视频解码工具——HEVC
FFmpeg的HEVC解码器源代码简单分析：概述
热门推荐
雷霄骅(leixiaohua1020)的专栏
06-08 2万+
从这篇文章开始，简单分析记录FFmpeg中libavcodec的HEVC（H.265）解码器（HEVC Decoder）的源代码。本文综述整个解码器的框架，后续几篇文章再对解码器的内部模块进行分析。
ffmpeg解码器
02-06
在"simplest_ffmpeg_decode"这个例子中，我们可以假设它包含了一个简单的FFmpeg解码示例，可能是一个命令行脚本或者源代码，演示了如何使用FFmpeg库从H.264编码的视频中解码出YUV帧。通过学习这个示例，开发者可以更...
HEVC视频扩展-播放此视频需要新的编解码器 安装包（免费）
03-02
当你的电脑尝试播放一个使用HEVC编码的视频文件时，如果系统中没有安装支持HEVC的编解码器，就会出现“播放此视频需要新的编解码器”的提示。这是因为你的媒体播放器无法识别并处理这种编码格式的视频流，所以需要...
QT学习笔记-初识FFmpeg
03-27
### QT学习笔记-初识FFmpeg #### 一、FFmpeg简介 ##### 1.1 什么是FFmpeg FFmpeg是一套开源的计算机程序，它主要用于记录、转换数字音频、视频，并能将其转化为流的形式。FFmpeg采用了LGPL或GPL许可证，这使得它...
FFmpeg源代码结构图 - 解码.rar
05-08
这个"FFmpeg源代码结构图 - 解码.rar"文件很可能包含了一个关于FFmpeg解码流程的详细图示和相关文档，如"FFmpeg源代码结构图 - 解码.docx"以及可能的阅读指南"read.txt"。 FFmpeg的解码过程通常分为以下几个关键...
最新HEVC解码插件。
04-10
2014年4月份发布的最新的Elecard的HEVC解码插件。
HEVC/H265 最新源码
05-21
HEVC 最新版本代码已经在VS2010，VS2008 编译通过
H265（HEVC） 官方源码 HM15
05-07
这是HEVC 官方源代码15版本,32位win7下使用VS2010编译成功，其他的操作系统和编译器没有尝试，请大家帮忙补充。
HEVC/h.265视频编码解码
12-09
最新的HEVC视频编码，可直接使用VS打开运行，自带配置文件
高清 HEVC（h265）视频文件
09-05
提供需要HEVC（H.265）调试视频朋友们，而且还是美女呀
ffmpeg4.2.4-rtmp-hevc-src-linux
12-01
压缩包中的"ffmpeg-4.2.4_hevc_rtmp_src"很可能是源代码的修改版，包含了构建和运行FFmpeg所需的所有文件。为了使用这个定制版的FFmpeg，你需要按照以下步骤操作： 1. 解压源代码。 2. 配置编译选项，可能需要添加...
FFmpeg的HEVC解码器源代码学习笔记-1
xxwtiancai的博客
02-17 1143
一直想写一个HEVC的码流解析工具，看了雷神264码流解析工具，本来想尝试模仿写一个相似的265码流分析工具，但是发现265的解码过程和结构体和264的不太一样，很多结构体并没有完全暴露出来，没有想到很好的方法获得量化参数，运动向量等这些信息。想着从头学习一下ffmpeg中的265解码函数，再来获取解码后的量化参数，运动向量等一系列信息，再做码流分析。这里主要学习HEVC的解析函数代码众所周知，解码器是标准的，因此只要按照官方给定的解码流程对码流进行解码就能正常解码。
雷霄骅——FFmpeg视频解码器
12-28
在课程中，学生将通过编写实际代码，学习如何结合FFmpeg的解码功能和SDL的图形显示能力，构建一个基本的本地视频播放器。这有助于理解多媒体处理的核心概念，并为更复杂的项目打下基础。 总的来说，FFmpeg视频解码...
ffmpeg-3.4.8-rtmp-hevc-src-linux.zip
11-17
在你提供的资料中，`ffmpeg-3.4.8-rtmp-hevc-src-linux.zip` 是一个针对Linux平台的FFmpeg源码包，已经过修改以支持RTMP协议下的H265（HEVC）编码视频的推流和拉流。这意味着你可以使用这个源码构建适用于你的特定...
ffmpeg解码hevc命令
10-26
要使用FFmpeg解码hevc，你需要使用以下命令： ``` ffmpeg -i input_file.hevc output_file.mp4 ``` 其中，input_file.hevc是你要解码的hevc视频文件，output_file.mp4是你要输出的文件名和格式。你可以将输出文件的格式更改为其他格式，例如.avi或.mov等。此外，你还可以使用其他选项来调整输出文件的质量和大小。例如，你可以使用-crf选项来设置输出文件的质量，例如： ``` ffmpeg -i input_file.hevc -c:v libx264 -crf 23 output_file.mp4 ``` 这将使用libx264编码器将hevc文件转换为mp4格式，并将输出文件的质量设置为23。你可以根据需要调整-crf值以获得所需的质量和文件大小。请注意，这个命令只是一个示例，你需要根据你的具体情况进行调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值