x265-1.7版本-encoder/slicetype.h注释

注:问号以及未注释部分 会在x265-1.8版本内更新

/*****************************************************************************
 * Copyright (C) 2013 x265 project
 *
 * Authors: Steve Borho 
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
 *
 * This program is also available under a commercial proprietary license.
 * For more information, contact us at license @ x265.com.
 *****************************************************************************/

#ifndef X265_SLICETYPE_H
#define X265_SLICETYPE_H

#include "common.h"
#include "slice.h"
#include "motion.h"
#include "piclist.h"
#include "threadpool.h"

namespace x265 {
// private namespace

struct Lowres;
class Frame;
class Lookahead;

#define LOWRES_COST_MASK  ((1 << 14) - 1)
#define LOWRES_COST_SHIFT 14

/* Thread local data for lookahead tasks */
struct LookaheadTLD //只在Lookahead中应用 用于多线程数据存储
{
    MotionEstimate  me;         //在estimateCUCost 用于运动矢量搜索的
    ReferencePlanes weightedRef;//标记参考帧信息,指示wbuffer[4]
    pixel*          wbuffer[4]; //这里需要申请4个buffer,存放加权的参考帧信息,这里申请的空间大小同lowres类的buf,因为将要通过4 hpel下采样得到4份1/2亮度
    int             widthInCU;  //Lowres 1/2 采样视频帧一行有多少个8x8块
    int             heightInCU; //Lowres 1/2 采样视频帧一列有多少个8x8块
    int             ncu;        //等于(widthInCU - 2) * (heightInCU - 2)
    int             paddedLines;//buf行数

#if DETAILED_CU_STATS           //统计信息
    int64_t         batchElapsedTime;  
    int64_t         coopSliceElapsedTime;
    uint64_t        countBatches;
    uint64_t        countCoopSlices;
#endif
    /** 函数功能    :初始化LookaheadTLD  初始化搜索算法、创建待搜索块的缓存
    * \返回值       :null */
    LookaheadTLD()
    {
        me.setQP(X265_LOOKAHEAD_QP);               //建立当前qp下的MVD占用的cost:λ*bits = 2^(qp/6-2) * s_bitsizes[i]
        me.init(X265_HEX_SEARCH, 1, X265_CSP_I400);//初始化搜索算法、创建待搜索块的缓存
        for (int i = 0; i < 4; i++)
            wbuffer[i] = NULL;
        widthInCU = heightInCU = ncu = paddedLines = 0;

#if DETAILED_CU_STATS
        batchElapsedTime = 0;
        coopSliceElapsedTime = 0;
        countBatches = 0;
        countCoopSlices = 0;
#endif
    }
    /** 函数功能: 初始化宽高信息
    /*  调用范围: 只在Lookahead::create()函数中被调用
    * \参数 w   : lowres 8x8宽度中个数
    * \参数 h   : lowres 8x8高度中个数
    * \参数 n   : 等于(m_8x8Width - 2) * (m_8x8Height - 2)
    * \返回值       :null */
    void init(int w, int h, int n)
    {
        widthInCU = w;
        heightInCU = h;
        ncu = n;
    }

    ~LookaheadTLD() { X265_FREE(wbuffer[0]); }

    /** 函数功能: 初始化m_lowres中的qpCuTreeOffset等信息,获取整帧的像素和和AC能量。
    /*  调用范围: 只在PreLookaheadGroup::processTasks函数中被调用
    * \参数 curFrame   : 当前帧(含有原始帧数据)
    * \参数 param      : 编码器配置的参数
    /* Find the total AC energy of each block in all planes */
    void calcAdaptiveQuantFrame(Frame *curFrame, x265_param* param);
    /** 函数功能       : 计算当前1/2下采样帧的intra SATD值以及最优intra模式
    /*  调用范围       : 只在PreLookaheadGroup::processTasks函数中被调用
    * \参数 fenc       : 当前帧(经过1/2下采样后的数据)
    *   返回值         : null **/
    void lowresIntraEstimate(Lowres& fenc);
    /** 函数功能             : 判断当前两帧是否进行加权 ,结果存储在weightedRef.isWeighted
    /*  调用范围             : 只在CostEstimateGroup::estimateFrameCost函数中被调用
    * \参数 fenc             :当前帧
    * \参数 ref              :前向帧
    * \返回                  :NULL */
    void weightsAnalyse(Lowres& fenc, Lowres& ref);

protected:

    /** 函数功能: acEnergyVar将元素和和平方和累加到当前帧中的m_lowres  返回当前块YUV的Σ(x^2) - (Σx * Σx)/n。
    /*  调用范围: 只在LookaheadTLD::calcAdaptiveQuantFrame函数中被调用
    * \参数 curFrame   : 当前帧(含有原始帧数据)
    * \参数 blockX     : 当前16x16的左偏移量(单位像素)
    * \参数 blockY     : 当前16x16的下偏移量(单位像素)
    * \参数 csp        : 数据格式,1 为420格式
    /* Find the total AC energy of each block in all planes */
    uint32_t acEnergyCu(Frame* curFrame, uint32_t blockX, uint32_t blockY, int csp);
    /** 函数功能             :计算两帧(wp.bPresentFlag 为 ref是否加权)之间的SATD值
    /*  调用范围             :只在LookaheadTLD::weightsAnalyse函数中被调用
    * \参数 fenc             :当前帧
    * \参数 ref              :前向帧
    * \返回                  :两帧(wp.bPresentFlag 为 ref是否加权)之间的SATD值 */
    uint32_t weightCostLuma(Lowres& fenc, Lowres& ref, WeightParam& wp);
    /** 函数功能             :申请存储空间并初始化weightedRef
    /*  调用范围             :只在LookaheadTLD::weightsAnalyse函数中被调用
    * \参数 fenc             :当前帧
    * \返回                  :内存申请成功为true 失败为false */
    bool     allocWeightedRef(Lowres& fenc);
};

class Lookahead : public JobProvider //用于帧类型决策以及framecost计算  只在Encoder类中应用
{
public:

    PicList       m_inputQueue;      //存储所有输入原始帧(指针)(帧类型未决策) 按照帧序号排序,next指的就是下一相邻帧号的帧  在addpicture中pushback 在slicetypeDecide()中pop input pictures in order received 
    PicList       m_outputQueue;     //存储所有帧类型已经决策的帧 (序号按照编码序号排序),next指的就是下一个要编码的帧 在slicetypeDecide()中pushback 在getDecidedPicture()中pop pictures to be encoded, in encode order
    Lock          m_inputLock;       //处理多线程的锁 acquire();和release()控制当前临街资源
    Lock          m_outputLock;      //处理多线程的锁 acquire();和release()控制当前临街资源

    /* pre-lookahead */
    int           m_fullQueueSize;   //等于m_param->lookaheadDepth值(当其读完全部视频帧时,将其设置为1)
    bool          m_isActive;        //表示当前lookachead是否触发,初始化为true,在stopjobs中置为false
    bool          m_sliceTypeBusy;   //表示当前是否在进行帧类型决策(保证系统中只有一个线程在进行帧类型决策) ,初始为false 在Lookahead::findJob前后更新,运行前为true,运行后置为false
    bool          m_bAdaptiveQuant;     //标记是否应用自适应量化
    bool          m_outputSignalRequired;//与event m_outputSignal;配套使用,初始化为false  true表示需要完成sliceDecide,在Lookahead::findJob中完成sliceDecide置为false并触发m_outputSignal,说明完成sliceDecide
                                         //在Lookahead::getDecidedPicture()函数中会进行检测并阻塞

    bool          m_bBatchMotionSearch; //如果应用bFrameAdaptive = 2并且内核数大于4 ,则为true  功能:用于判断是否执行 计算等间隔framecost并发执行
    bool          m_bBatchFrameCosts;   //如果应用bFrameAdaptive = 2并且内核数大于12 ,则为true  功能:用于多线程计算frame cost 内核数大于12个才持续使用多线程计算
    Event         m_outputSignal;       //当需要编码帧的帧类型决策完毕触发,未完成则等待

    LookaheadTLD* m_tld;             //空间大小为内核数+1  numTLD = 1 + (m_pool ? m_pool->m_numWorkers : 0); 例如当前为4核,则申请空间大小为5(0,1,2,3分别表示具体某个核,4表示当前线程)
    x265_param*   m_param;           //配置参数
    Lowres*       m_lastNonB;        //记录最近的非B帧位置
    int*          m_scratch;         // temp buffer for cutree propagate 用于临时存放传播cost  存储空间大小:1/2 采样视频帧一行8x8块个数 
    
    int           m_histogram[X265_BFRAME_MAX + 1];//统计信息,用于统计GOP中B或者b帧数个数
    int           m_lastKeyframe;   //标记当前前一个关键帧位置,初始化为-maxKeyframe, 保证第一帧是关键帧
    int           m_8x8Width;       //lowres 8x8宽度中个数
    int           m_8x8Height;      //lowres 8x8高度中个数
    int           m_8x8Blocks;      //等于(m_8x8Width - 2) * (m_8x8Height - 2)
    int           m_numCoopSlices;  //每帧有几条slice 默认1
    int           m_numRowsPerSlice;//每行中有几行8x8块  默认m_8x8Height
    bool          m_filled;//当前buf是否已满,初始为false 当(curFrame.m_poc >= m_param->lookaheadDepth + 2 + m_param->bframes)时为true  当已经读完所有原始帧的时候为true, 一旦满了将一直是满的状态

    /** 函数功能             : 初始化信息
    /*  调用范围             : 只在主线程Encoder::create()中应用
    * \参数 param            : 配置参数
    * \参数 pool             : NAMA模式下的线程池
    * \返回                  : null * */
    Lookahead(x265_param *param, ThreadPool *pool);

#if DETAILED_CU_STATS                          //统计信息
    int64_t       m_slicetypeDecideElapsedTime;
    int64_t       m_preLookaheadElapsedTime;
    uint64_t      m_countSlicetypeDecide;
    uint64_t      m_countPreLookahead;
    void          getWorkerStats(int64_t& batchElapsedTime, uint64_t& batchCount, int64_t& coopSliceElapsedTime, uint64_t& coopSliceCount);
#endif

    /** 函数功能             : 申请空间
    /*  调用范围             : 只在主线程Encoder::create()中应用
    * \返回                  : 成为为true 失败为fasle * */
    bool    create();
    /** 函数功能             : 释放内存
    /*  调用范围             : 只在主线程Encoder::destroy()中应用
    * \返回                  : null* */
    void    destroy();
    /** 函数功能             : 关闭帧类型决策任务,如果有任务在执行,则等待完毕,再停止任务
    /*  调用范围             : 只在主线程Encoder::stopJobs()中应用
    * \返回                  : null* */
    void    stopJobs();

    /** 函数功能             : 向输入列表中添加原始帧准备帧类型决策,在buffer满时,触发帧类型决策
    /*  调用范围             : 只在主线程Encoder中应用
    * \参数 curFrame         : 传入的原始帧
    * \参数 sliceType        : 1pass 中为AUTO 2pass中为具体的帧类型
    * \返回                  : null * */
    void    addPicture(Frame&, int sliceType);
    /** 函数功能             : 当前已经读取原始帧完毕,往后不用再继续读取,告知lookahead已满
    /*  调用范围             : 只在主线程Encoder::encode中应用
    * \返回                  : null * */
    void    flush();
    /** 函数功能             : 只在主线程Encoder中应用,获取已经得到帧类型的原始帧
    /*  调用范围             : 只在Encoder::encode函数中被调用
    * \返回                  : 返回当前帧类型决策完毕的待编码帧 * */
    Frame*  getDecidedPicture();
    /** 函数功能             : 获取当前帧每个CTU行对应下采样帧的每个8x8的块cost的累计值
    /*  调用范围             : 只在Encoder::encode函数中被调用
    * \参数 curFrame         : 传入的原始帧
    * \返回                  : null * */
    void    getEstimatedPictureCost(Frame *pic);


protected:

    /** 函数功能             : 触发帧类型决策(在threadMain()主动发起,在getDecidedPicture()被动发起,因为当前发现帧类型不可用,被动发起)
    /*  调用范围             : 只在WorkerThread::threadMain()(在addPicture中触发执行)和Lookahead::getDecidedPicture()函数中被调用
    * \返回                  : null * */
    void    findJob(int workerThreadID);
    /** 函数功能             : 获取帧类型并计算frame-cost
    /*  调用范围             : 只在Lookahead::findJob函数中被调用
    * \返回                  : null * */
    void    slicetypeDecide();
    /** 函数功能             : 获取当前GOP的帧类型,获取可参考帧的qpCuTreeOffset值
    /*  调用范围             : 只在sliceTypeDecide函数中被调用 (一般只在1pass中进入)
    * \参数 frames           : 当前搜索的frames列表
    * \参数 bKeyframe        : 是否是IDR帧检测
    * \返回                  : null * */
    void    slicetypeAnalyse(Lowres **frames, bool bKeyframe);
    /** 函数功能             : 判断当前是否场景切换(是否需要将p1帧类型设置为I帧)
    /*  调用范围             : 只在Lookahead::slicetypeAnalyse函数中被调用
    * \参数 frames           : 当前搜索的frames列表
    * \参数 p0               : 前一帧 注:p0 p1 相邻
    * \参数 p1               : 后一帧
    * \参数 bRealScenecut    : 当前是否是真正的场景切换判断,而不是预分析
    * \参数 numFrames        : 列表中原始帧个数
    * \参数 maxSearch        : lookachead最大的搜索帧数
    * \返回                  : 返回当前是否场景切换(是否需要将其帧类型设置为I帧) * */
    /* called by slicetypeAnalyse() to make slice decisions */
    bool    scenecut(Lowres **frames, int p0, int p1, bool bRealScenecut, int numFrames, int maxSearch);
    /** 函数功能             : 判断当前是否场景切换(是否需要将其帧类型设置为I帧)
    /*  调用范围             : 只在Lookahead::scenecut函数中被调用
    * \参数 frames           : 当前搜索的frames列表
    * \参数 p0               : 当前帧 注:p0 p1 不相邻 p1是p0后面某一帧
    * \参数 p1               : 后一帧
    * \参数 bRealScenecut    : 当前是否是真正的场景切换判断,而不是预分析
    * \返回                  : 返回当前是否场景切换(是否需要将其帧类型设置为I帧) * */
    bool    scenecutInternal(Lowres **frames, int p0, int p1, bool bRealScenecut);
    /** 函数功能             : 计算当前搜索长度下的最优帧类型路径
    /*  调用范围             : 只在Lookahead::slicetypeAnalyse函数中被调用
    * \参数 frames           : 当前搜索的frames列表
    * \参数 length           : 当前搜索frame列表的长度 (1~length)
    * \参数 *best_paths      : 存储最优帧类型路径
    * \返回                  : null * */
    void    slicetypePath(Lowres **frames, int length, char(*best_paths)[X265_LOOKAHEAD_MAX + 1]);
    /** 函数功能             : 计算当前PB帧设置的frame cost 累加值
    /*  调用范围             : 只在Lookahead::slicetypePath函数中被调用
    * \参数 frames           : 当前搜索的frames列表
    * \参数 path             : 当前frame列表的帧类型:如BPBBBPxxxx(x:暂未制定类型 第一个x前一定是P)
    * \参数 threshold        : 当前最优的framecost
    * \返回                  : 返回当前PB帧设置的frame cost 累加值 * */
    int64_t slicetypePathCost(Lowres **frames, char *path, int64_t threshold);
    /** 函数功能             : 如果当前帧号b是B帧直接返回其framecost:costEstAq (qpAqOffset加权)否则,重新计算framecost  经过qpCuTreeOffset加权后的数据
    /*  调用范围             : 只在Lookahead::vbvLookahead函数中被调用
    * \参数 frames           : 当前搜索的frames列表
    * \参数 p0               : 前向帧
    * \参数 p1               : 后向帧
    * \参数 b                : 当前帧号
    * \返回                  : 返回重新计算的framecost* */
    int64_t vbvFrameCost(Lowres **frames, int p0, int p1, int b);
    /** 函数功能             : 重新计算framecost经过qpCuTreeOffset加权后的数据并吧相应信息存储到第一个GOP中,并将相应的B帧设置为参考B帧
    /*  调用范围             : 只在slicetypeAnalyse函数中被调用
    * \参数 frames           : 当前搜索的frames列表
    * \参数 numframes        : frames列表帧数
    * \参数 keyframe         : 是否是IDR帧检测
    * \返回                  : null * */
    void    vbvLookahead(Lowres **frames, int numFrames, int keyframes);

    /* called by slicetypeAnalyse() to effect cuTree adjustments to adaptive
     * quant offsets */
    /** 函数功能             : 计算可参考帧的qpCuTreeOffset值
    /*  调用范围             : 只在slicetypeAnalyse函数中被调用
    * \参数 frames           : 当前搜索的frames列表
    * \参数 numframes        : frames列表帧数
    * \参数 bIntra           : 是否是IDR帧检测
    * \返回                  : null * */
    void    cuTree(Lowres **frames, int numframes, bool bintra);
    /** 函数功能             : 计算当前编码帧每个8x8块对应参考块的传播cost、如果当前编码帧是可被参考帧计算其qpCuTreeOffset值
    /*  调用范围             : 只在Lookahead::cuTree函数中被调用
    * \参数 frames           : 当前搜索的frames列表
    * \参数 averageDuration  : 平均每帧的播放时长 单位秒
    * \参数 p0               : 前向帧
    * \参数 p1               : 后向帧
    * \参数 b                : 当前帧号
    * \参数 referenced       : 当前计算的b号帧是否是可被参考的
    * \返回                  : null * */
    void    estimateCUPropagate(Lowres **frames, double average_duration, int p0, int p1, int b, int referenced);
    /** 函数功能             : 计算参考帧qpCuTreeOffset值
    /*  调用范围             : 只在Lookahead::cuTree和Lookahead::estimateCUPropagate函数中被调用
    * \参数 frames           : 当前搜索的frames列表
    * \参数 averageDuration  : 平均每帧的播放时长 单位秒
    * \参数 ref0Distance     : 如果是双向参考则为0,如果当前为单向参考则为当前帧号-前向参考帧号
    * \返回                  : null * */
    void    cuTreeFinish(Lowres *frame, double averageDuration, int ref0Distance);

    /** 函数功能             : 如果当前是B帧直接返回其framecost:costEstAq (qpAqOffset加权)否则,重新计算framecost  经过qpCuTreeOffset加权后的数据
    /*  调用范围             : 只在Lookahead::getEstimatedPictureCost和Lookahead::vbvFrameCost函数中被调用
    * \参数 frames           : 当前搜索的frames列表
    * \参数 p0               : 前向帧
    * \参数 p1               : 后向帧
    * \参数 b                : 当前帧号
    * \返回                  : 返回重新计算的framecost* */
    /* called by getEstimatedPictureCost() to finalize cuTree costs */
    int64_t frameCostRecalculate(Lowres **frames, int p0, int p1, int b);
};

class PreLookaheadGroup : public BondedTaskGroup //只在void Lookahead::slicetypeDecide()中被应用
{
public:

    Frame* m_preframes[X265_LOOKAHEAD_MAX];     //存储当前没有初始化的帧
    Lookahead& m_lookahead;                     //当前的lookachead

    PreLookaheadGroup(Lookahead& l) : m_lookahead(l) {}

    /** 函数功能             : 初始化lowres并进行下采样、扩边、计算pCuTreeOffset等信息,获取整帧的像素和和AC能量、计算当前1/2下采样帧的intra SATD值以及最优intra模式、并行处理
    /*  调用范围             : 只在WorkerThread::threadMain()和sliceTypeDecide函数中被调用
    * \参数 workerThreadID   : 当前运行的内核号
    * \返回                  : null * */
    void processTasks(int workerThreadID);

protected:

    PreLookaheadGroup& operator=(const PreLookaheadGroup&);
};

class CostEstimateGroup : public BondedTaskGroup //多线程计算帧间的framecost
{
public:

    Lookahead& m_lookahead;  //指向当前调用它的Lookahead
    Lowres**   m_frames;     //一个frame指针列表  1/2 下采样视频
    bool       m_batchMode;  //是否进行并发计算framecost 在add函数中置为true

    CostEstimateGroup(Lookahead& l, Lowres** f) : m_lookahead(l), m_frames(f), m_batchMode(false) {} //初始化

    /* Cooperative cost estimate using multiple slices of downscaled frame */
    struct Coop
    {
        int  p0, b, p1;        //p0 前向帧  p1 后向帧  b当前帧 (前向帧、后向帧并不是单指前一帧后一帧),如(p0,b,p1)= (5,6,7),(p0,b,p1)= (8,10,11)
        bool bDoSearch[2];     //分别表示P0是否需要搜索,p1是否需要搜索
    } m_coop;                  //lookachead 多slice时应用

    enum { MAX_COOP_SLICES = 32 }; //lookachead中多slice配置中的最大slice个数
    struct Slice
    {
        int  costEst;          //存储相应slice之间的(SATD+mvcost+4)的累加和
        int  costEstAq;        //存储相应slice之间的(SATD+mvcost+4)加权的累加和
        int  intraMbs;         //存储相应slice之间的intra块最优个数
    } m_slice[MAX_COOP_SLICES];//存储lookachead 中一帧所有slice

    /** 函数功能             :单线程计算当前帧与前后参考帧之间的最优frame cost
    /*  调用范围             :只在slicetypeDecide()、vbvFrameCost、slicetypeAnalyse、scenecutInternal、slicetypePathCost和cuTree函数中被调用
    * \参数 p0               :前向帧
    * \参数 p1               :后向帧
    * \参数 b                :当前帧号
    * \参数 bIntraPenalty    :会加上intra带来的编码代价;其中在slicetypeAnalyse会传入ture(也可能为false)并且bFrameAdaptive == X265_B_ADAPT_FAST,其它为false 
    * \返回                  :当前帧与前后参考帧之间的最优frame cost* */
    int64_t singleCost(int p0, int p1, int b, bool intraPenalty = false);

    /* Batch cost estimates, using one worker thread per estimateFrameCost() call */
    enum { MAX_BATCH_SIZE = 512 };//最大并发的个数 计算frmecost
    struct Estimate
    {
        int  p0, b, p1; //p0 前向帧  p1 后向帧  b当前帧 (前向帧、后向帧并不是单指前一帧后一帧),如(p0,b,p1)= (5,6,7),(p0,b,p1)= (8,10,11)
    } m_estimates[MAX_BATCH_SIZE]; //用于多线程并行处理,里面存储当前需要处理的帧号以及它的参考帧号
    /** 函数功能             : 添加任务,为后面并发执行做准备
    /*  调用范围             : 只在Lookahead::slicetypeAnalyse函数中被调用
    * \参数 p0               : 前向帧
    * \参数 p1               : 后向帧
    * \参数 b                : 当前帧号
    * \返回                  : null * */
    void add(int p0, int p1, int b);
    /** 函数功能             : 触发并发执行并一直等到所有任务执行完毕:计算每帧与其对应参考帧之间的帧间cost
    /*  调用范围             : 只在Lookahead::slicetypeAnalyse和CostEstimateGroup::add函数中被调用
    * \返回                  : null * */
    void finishBatch();

protected:

    static const int s_merange = 16;
    /** 函数功能             : 功能分两个只能执行其中一个:1. 获取取每个8x8块的帧间cost(SATD + mvcost + 4) 并 获取当前b帧在p0、p1参考帧下的最优帧cost inter(SATD+mvcost+4)*10/(13 +b)或者 intra (SATD+5+4) 
                                                        2. Lookachead 多slice并行,执行其中一条slice的每个8x8块的帧间cost(SATD + mvcost + 4)
    /*  调用范围             : 只在CostEstimateGroup::finishBatch()和CostEstimateGroup::estimateFrameCost函数中被调用 (分别执行1,2功能)
    * \返回                  : null * */
    void    processTasks(int workerThreadID);
    /** 函数功能             :获取取每个8x8块的帧间cost(SATD + mvcost + 4) 并 获取当前b帧在p0、p1参考帧下的最优帧cost inter(SATD+mvcost+4)*10/(13 +b)或者 intra (SATD+5+4)
    /*  调用范围             :只在CostEstimateGroup::singleCost和CostEstimateGroup::processTasks函数中被调用
    * \参数 tld              :当前线程的tld
    * \参数 p0               :前向帧
    * \参数 p1               :后向帧
    * \参数 b                :当前帧号
    * \参数 bIntraPenalty    :会加上intra带来的编码代价;在CostEstimateGroup::processTasks中为false 在调用CostEstimateGroup::singleCost中的slicetypeAnalyse会传入ture(也可能为false) 并且bFrameAdaptive == X265_B_ADAPT_FAST
    * \返回                  :当前b帧在p0、p1参考帧下的最优帧cost inter(SATD+mvcost+4)*10/(13 +b)或者 intra (SATD+5+4) * */
    int64_t estimateFrameCost(LookaheadTLD& tld, int p0, int p1, int b, bool intraPenalty);
    /** 函数功能             :获取每个8x8块的帧间cost(SATD + mvcost + 4)
    /*  调用范围             :只在 CostEstimateGroup::processTasks和CostEstimateGroup::estimateFrameCost函数中被调用 (一般只在CostEstimateGroup::estimateFrameCost)
    * \参数 tld              :当前线程先的tld
    * \参数 cuX              :当前帧的8x8 X坐标
    * \参数 cuY              :当前帧的8x8 Y坐标
    * \参数 p0               :前向帧
    * \参数 p1               :后向帧
    * \参数 b                :当前帧号
    * \参数 bDoSearch        :分别表示p0\p1需不需要search
    * \参数 lastRow          :是否是最后一行
    * \参数 slice            :在CostEstimateGroup::processTasks为相应slice  在CostEstimateGroup::estimateFrameCost为-1
    * \返回                  :null * */
    void    estimateCUCost(LookaheadTLD& tld, int cux, int cuy, int p0, int p1, int b, bool bDoSearch[2], bool lastRow, int slice);

    CostEstimateGroup& operator=(const CostEstimateGroup&); //运算符重载
};

}

#endif // ifndef X265_SLICETYPE_H


 

你可能感兴趣的:(x265代码注释)