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

74 阅读 0 评论 49 点赞
我是靠谱客的博主傻傻心情，最近开发中收集的这篇文章主要介绍x265-1.8版本-encoder/slicetype.h注释，觉得挺不错的，现在分享给大家，希望可以做个参考。
概述

注：问号以及未注释部分会在x265-1.9版本内更新
/*****************************************************************************
* Copyright (C) 2013 x265 project
*
* Authors: Steve Borho <steve@borho.org>
*
* 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_NS {
// private namespace
struct Lowres;
class Frame;
class Lookahead;
#define LOWRES_COST_MASK
((1 << 14) - 1)//最大的cost值
#define LOWRES_COST_SHIFT 14//移位个数 用于取当前cost是I P 还是B
/* 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, 一旦满了将一直是满的状态
bool
m_isSceneTransition;// 表示当前是否有场景帧
scenecut函数中：有置为ture 无置为false
初始化为false
/** 函数功能
： 初始化信息
/*
调用范围
： 只在主线程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
： 列表中原始帧个数
* 返回
： 返回当前是否场景切换（是否需要将其帧类型设置为I帧） * */
/* called by slicetypeAnalyse() to make slice decisions */
bool
scenecut(Lowres **frames, int p0, int p1, bool bRealScenecut, int numFrames);
/** 函数功能
： 判断当前是否场景切换（是否需要将其帧类型设置为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
：分别表示p0p1需不需要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