[x265] [PATCH] rename options related to analysis-mode, improve docs
kavitha at multicorewareinc.com
kavitha at multicorewareinc.com
Wed Jun 21 08:52:29 CEST 2017
# HG changeset patch
# User Kavitha Sampath <kavitha at multicorewareinc.com>
# Date 1498019633 -19800
# Wed Jun 21 10:03:53 2017 +0530
# Node ID edbdfb8e8eea64e74089c153b3b4abbb3d105de6
# Parent 40dbeef1d8b59452ac0898621a75f02a576b0c30
rename options related to analysis-mode, improve docs
diff -r 40dbeef1d8b5 -r edbdfb8e8eea doc/reST/cli.rst
--- a/doc/reST/cli.rst Tue Jun 13 14:00:40 2017 +0530
+++ b/doc/reST/cli.rst Wed Jun 21 10:03:53 2017 +0530
@@ -849,33 +849,31 @@
Analysis re-use options, to improve performance when encoding the same
sequence multiple times (presumably at varying bitrates). The encoder
-will not reuse analysis if the resolution and slice type parameters do
-not match.
-
-.. option:: --analysis-mode <string|int>
-
- Specify whether analysis information of each frame is output by encoder
- or input for reuse. By reading the analysis data writen by an
- earlier encode of the same sequence, substantial redundant work may
- be avoided.
-
- The following data may be stored and reused:
- I frames - split decisions and luma intra directions of all CUs.
- P/B frames - motion vectors are dumped at each depth for all CUs.
+will not reuse analysis if slice type parameters do not match.
+
+.. option:: --analysis-reuse-mode <string|int>
+
+ This option allows reuse of analysis information from first pass to second pass.
+ :option:`--analysis-reuse-mode save` specifies that encoder outputs analysis information of each frame.
+ :option:`--analysis-reuse-mode load` specifies that encoder reuses analysis information from first pass.
+ There is no benefit using load mode without running encoder in save mode. Analysis data from save mode is
+ written to a file specified by :option:`--analysis-reuse-file`. The amount of analysis data stored/reused
+ is determined by :option:`--analysis-reuse-level`. By reading the analysis data writen by an earlier encode
+ of the same sequence, substantial redundant work may be avoided. Requires cutree, pmode to be off. Default 0.
**Values:** off(0), save(1): dump analysis data, load(2): read analysis data
-.. option:: --analysis-file <filename>
-
- Specify a filename for analysis data (see :option:`--analysis-mode`)
+.. option:: --analysis-reuse-file <filename>
+
+ Specify a filename for analysis data (see :option:`--analysis-reuse-mode`)
If no filename is specified, x265_analysis.dat is used.
-.. option:: --refine-level <1..10>
-
- Amount of information stored/reused in :option:`--analysis-mode` is distributed across levels.
+.. option:: --analysis-reuse-level <1..10>
+
+ Amount of information stored/reused in :option:`--analysis-reuse-mode` is distributed across levels.
Higher the value, higher the information stored/reused, faster the encode. Default 5.
- Note that --refine-level must be paired with analysis-mode.
+ Note that --analysis-reuse-level must be paired with analysis-reuse-mode.
+--------+-----------------------------------------+
| Level | Description |
@@ -888,10 +886,11 @@
+--------+-----------------------------------------+
| 10 | Level 5 + Full CU analysis-info |
+--------+-----------------------------------------+
+
.. option:: --scale-factor
Factor by which input video is scaled down for analysis save mode.
- This option should be coupled with analysis-mode option, --refine-level 10.
+ This option should be coupled with analysis-reuse-mode option, --analysis-reuse-level 10.
The ctu size of load should be double the size of save. Default 0.
.. option:: --refine-intra
diff -r 40dbeef1d8b5 -r edbdfb8e8eea source/CMakeLists.txt
--- a/source/CMakeLists.txt Tue Jun 13 14:00:40 2017 +0530
+++ b/source/CMakeLists.txt Wed Jun 21 10:03:53 2017 +0530
@@ -29,7 +29,7 @@
option(STATIC_LINK_CRT "Statically link C runtime for release builds" OFF)
mark_as_advanced(FPROFILE_USE FPROFILE_GENERATE NATIVE_BUILD)
# X265_BUILD must be incremented each time the public API is changed
-set(X265_BUILD 127)
+set(X265_BUILD 128)
configure_file("${PROJECT_SOURCE_DIR}/x265.def.in"
"${PROJECT_BINARY_DIR}/x265.def")
configure_file("${PROJECT_SOURCE_DIR}/x265_config.h.in"
diff -r 40dbeef1d8b5 -r edbdfb8e8eea source/common/cudata.cpp
--- a/source/common/cudata.cpp Tue Jun 13 14:00:40 2017 +0530
+++ b/source/common/cudata.cpp Wed Jun 21 10:03:53 2017 +0530
@@ -1622,7 +1622,7 @@
dir |= (1 << list);
candMvField[count][list].mv = colmv;
candMvField[count][list].refIdx = refIdx;
- if (m_encData->m_param->scaleFactor && m_encData->m_param->analysisMode == X265_ANALYSIS_SAVE && m_log2CUSize[0] < 4)
+ if (m_encData->m_param->scaleFactor && m_encData->m_param->analysisReuseMode == X265_ANALYSIS_SAVE && m_log2CUSize[0] < 4)
{
MV dist(MAX_MV, MAX_MV);
candMvField[count][list].mv = dist;
@@ -1787,7 +1787,7 @@
int curRefPOC = m_slice->m_refPOCList[picList][refIdx];
int curPOC = m_slice->m_poc;
- if (m_encData->m_param->scaleFactor && m_encData->m_param->analysisMode == X265_ANALYSIS_SAVE && (m_log2CUSize[0] < 4))
+ if (m_encData->m_param->scaleFactor && m_encData->m_param->analysisReuseMode == X265_ANALYSIS_SAVE && (m_log2CUSize[0] < 4))
{
MV dist(MAX_MV, MAX_MV);
pmv[numMvc++] = amvpCand[num++] = dist;
diff -r 40dbeef1d8b5 -r edbdfb8e8eea source/common/param.cpp
--- a/source/common/param.cpp Tue Jun 13 14:00:40 2017 +0530
+++ b/source/common/param.cpp Wed Jun 21 10:03:53 2017 +0530
@@ -195,10 +195,10 @@
param->rdPenalty = 0;
param->psyRd = 2.0;
param->psyRdoq = 0.0;
- param->analysisMode = 0;
+ param->analysisReuseMode = 0;
param->analysisMultiPassRefine = 0;
param->analysisMultiPassDistortion = 0;
- param->analysisFileName = NULL;
+ param->analysisReuseFileName = NULL;
param->bIntraInBFrames = 0;
param->bLossless = 0;
param->bCULossless = 0;
@@ -272,7 +272,7 @@
param->bOptCUDeltaQP = 0;
param->bAQMotion = 0;
param->bHDROpt = 0;
- param->analysisRefineLevel = 5;
+ param->analysisReuseLevel = 5;
param->toneMapFile = NULL;
param->bDhdr10opt = 0;
@@ -836,7 +836,7 @@
p->rc.bStrictCbr = atobool(value);
p->rc.pbFactor = 1.0;
}
- OPT("analysis-mode") p->analysisMode = parseName(value, x265_analysis_names, bError);
+ OPT("analysis-reuse-mode") p->analysisReuseMode = parseName(value, x265_analysis_names, bError);
OPT("sar")
{
p->vui.aspectRatioIdc = parseName(value, x265_sar_names, bError);
@@ -915,7 +915,7 @@
OPT("scaling-list") p->scalingLists = strdup(value);
OPT2("pools", "numa-pools") p->numaPools = strdup(value);
OPT("lambda-file") p->rc.lambdaFileName = strdup(value);
- OPT("analysis-file") p->analysisFileName = strdup(value);
+ OPT("analysis-reuse-file") p->analysisReuseFileName = strdup(value);
OPT("qg-size") p->rc.qgSize = atoi(value);
OPT("master-display") p->masteringDisplayColorVolume = strdup(value);
OPT("max-cll") bError |= sscanf(value, "%hu,%hu", &p->maxCLL, &p->maxFALL) != 2;
@@ -948,7 +948,7 @@
OPT("multi-pass-opt-distortion") p->analysisMultiPassDistortion = atobool(value);
OPT("aq-motion") p->bAQMotion = atobool(value);
OPT("dynamic-rd") p->dynamicRd = atof(value);
- OPT("refine-level") p->analysisRefineLevel = atoi(value);
+ OPT("analysis-reuse-level") p->analysisReuseLevel = atoi(value);
OPT("ssim-rd")
{
int bval = atobool(value);
@@ -1299,9 +1299,9 @@
"Constant QP is incompatible with 2pass");
CHECK(param->rc.bStrictCbr && (param->rc.bitrate <= 0 || param->rc.vbvBufferSize <=0),
"Strict-cbr cannot be applied without specifying target bitrate or vbv bufsize");
- CHECK(param->analysisMode && (param->analysisMode < X265_ANALYSIS_OFF || param->analysisMode > X265_ANALYSIS_LOAD),
+ CHECK(param->analysisReuseMode && (param->analysisReuseMode < X265_ANALYSIS_OFF || param->analysisReuseMode > X265_ANALYSIS_LOAD),
"Invalid analysis mode. Analysis mode 0: OFF 1: SAVE : 2 LOAD");
- CHECK(param->analysisMode && (param->analysisRefineLevel < 1 || param->analysisRefineLevel > 10),
+ CHECK(param->analysisReuseMode && (param->analysisReuseLevel < 1 || param->analysisReuseLevel > 10),
"Invalid analysis refine level. Value must be between 1 and 10 (inclusive)");
CHECK(param->scaleFactor > 2, "Invalid scale-factor. Supports factor <= 2");
CHECK(param->rc.qpMax < QP_MIN || param->rc.qpMax > QP_MAX_MAX,
@@ -1558,7 +1558,7 @@
s += sprintf(s, " psy-rd=%.2f", p->psyRd);
s += sprintf(s, " psy-rdoq=%.2f", p->psyRdoq);
BOOL(p->bEnableRdRefine, "rd-refine");
- s += sprintf(s, " analysis-mode=%d", p->analysisMode);
+ s += sprintf(s, " analysis-reuse-mode=%d", p->analysisReuseMode);
BOOL(p->bLossless, "lossless");
s += sprintf(s, " cbqpoffs=%d", p->cbQpOffset);
s += sprintf(s, " crqpoffs=%d", p->crQpOffset);
@@ -1653,7 +1653,7 @@
BOOL(p->bEmitHDRSEI, "hdr");
BOOL(p->bHDROpt, "hdr-opt");
BOOL(p->bDhdr10opt, "dhdr10-opt");
- s += sprintf(s, " refine-level=%d", p->analysisRefineLevel);
+ s += sprintf(s, " analysis-reuse-level=%d", p->analysisReuseLevel);
s += sprintf(s, " scale-factor=%d", p->scaleFactor);
s += sprintf(s, " refine-intra=%d", p->intraRefine);
s += sprintf(s, " refine-inter=%d", p->interRefine);
diff -r 40dbeef1d8b5 -r edbdfb8e8eea source/encoder/analysis.cpp
--- a/source/encoder/analysis.cpp Tue Jun 13 14:00:40 2017 +0530
+++ b/source/encoder/analysis.cpp Wed Jun 21 10:03:53 2017 +0530
@@ -203,19 +203,19 @@
}
}
- if (m_param->analysisMode && m_slice->m_sliceType != I_SLICE && m_param->analysisRefineLevel > 1 && m_param->analysisRefineLevel < 10)
+ if (m_param->analysisReuseMode && m_slice->m_sliceType != I_SLICE && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel < 10)
{
int numPredDir = m_slice->isInterP() ? 1 : 2;
m_reuseInterDataCTU = (analysis_inter_data*)m_frame->m_analysisData.interData;
m_reuseRef = &m_reuseInterDataCTU->ref[ctu.m_cuAddr * X265_MAX_PRED_MODE_PER_CTU * numPredDir];
m_reuseDepth = &m_reuseInterDataCTU->depth[ctu.m_cuAddr * ctu.m_numPartitions];
m_reuseModes = &m_reuseInterDataCTU->modes[ctu.m_cuAddr * ctu.m_numPartitions];
- if (m_param->analysisRefineLevel > 4)
+ if (m_param->analysisReuseLevel > 4)
{
m_reusePartSize = &m_reuseInterDataCTU->partSize[ctu.m_cuAddr * ctu.m_numPartitions];
m_reuseMergeFlag = &m_reuseInterDataCTU->mergeFlag[ctu.m_cuAddr * ctu.m_numPartitions];
}
- if (m_param->analysisMode == X265_ANALYSIS_SAVE)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_SAVE)
for (int i = 0; i < X265_MAX_PRED_MODE_PER_CTU * numPredDir; i++)
m_reuseRef[i] = -1;
}
@@ -224,7 +224,7 @@
if (m_slice->m_sliceType == I_SLICE)
{
analysis_intra_data* intraDataCTU = (analysis_intra_data*)m_frame->m_analysisData.intraData;
- if (m_param->analysisMode == X265_ANALYSIS_LOAD && m_param->analysisRefineLevel > 1)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->analysisReuseLevel > 1)
{
memcpy(ctu.m_cuDepth, &intraDataCTU->depth[ctu.m_cuAddr * numPartition], sizeof(uint8_t) * numPartition);
memcpy(ctu.m_lumaIntraDir, &intraDataCTU->modes[ctu.m_cuAddr * numPartition], sizeof(uint8_t) * numPartition);
@@ -250,7 +250,7 @@
/* generate residual for entire CTU at once and copy to reconPic */
encodeResidue(ctu, cuGeom);
}
- else if (m_param->analysisMode == X265_ANALYSIS_LOAD && m_param->analysisRefineLevel == 10)
+ else if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->analysisReuseLevel == 10)
{
analysis_inter_data* interDataCTU = (analysis_inter_data*)m_frame->m_analysisData.interData;
int posCTU = ctu.m_cuAddr * numPartition;
@@ -432,7 +432,7 @@
int lambdaQP = lqp;
bool doQPRefine = (bDecidedDepth && depth <= m_slice->m_pps->maxCuDQPDepth) || (!bDecidedDepth && depth == m_slice->m_pps->maxCuDQPDepth);
- if (m_param->analysisRefineLevel == 10)
+ if (m_param->analysisReuseLevel == 10)
doQPRefine = false;
if (doQPRefine)
@@ -604,7 +604,7 @@
}
/* Save Intra CUs TU depth only when analysis mode is OFF */
- if ((m_limitTU & X265_TU_LIMIT_NEIGH) && cuGeom.log2CUSize >= 4 && !m_param->analysisMode)
+ if ((m_limitTU & X265_TU_LIMIT_NEIGH) && cuGeom.log2CUSize >= 4 && !m_param->analysisReuseMode)
{
CUData* ctu = md.bestMode->cu.m_encData->getPicCTU(parentCTU.m_cuAddr);
int8_t maxTUDepth = -1;
@@ -1200,7 +1200,7 @@
mightSplit &= !bDecidedDepth;
}
}
- if (m_param->analysisMode == X265_ANALYSIS_LOAD && m_param->analysisRefineLevel > 1 && m_param->analysisRefineLevel != 10)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
{
if (mightNotSplit && depth == m_reuseDepth[cuGeom.absPartIdx])
{
@@ -1214,7 +1214,7 @@
if (m_param->rdLevel)
skipModes = m_param->bEnableEarlySkip && md.bestMode;
}
- if (m_param->analysisRefineLevel > 4 && m_reusePartSize[cuGeom.absPartIdx] == SIZE_2Nx2N)
+ if (m_param->analysisReuseLevel > 4 && m_reusePartSize[cuGeom.absPartIdx] == SIZE_2Nx2N)
{
if (m_reuseModes[cuGeom.absPartIdx] != MODE_INTRA && m_reuseModes[cuGeom.absPartIdx] != 4)
{
@@ -1829,7 +1829,7 @@
mightSplit &= !bDecidedDepth;
}
}
- if (m_param->analysisMode == X265_ANALYSIS_LOAD && m_param->analysisRefineLevel > 1 && m_param->analysisRefineLevel != 10)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
{
if (mightNotSplit && depth == m_reuseDepth[cuGeom.absPartIdx])
{
@@ -1847,7 +1847,7 @@
if (m_param->bEnableRecursionSkip && depth && m_modeDepth[depth - 1].bestMode)
skipRecursion = md.bestMode && !md.bestMode->cu.getQtRootCbf(0);
}
- if (m_param->analysisRefineLevel > 4 && m_reusePartSize[cuGeom.absPartIdx] == SIZE_2Nx2N)
+ if (m_param->analysisReuseLevel > 4 && m_reusePartSize[cuGeom.absPartIdx] == SIZE_2Nx2N)
skipRectAmp = true && !!md.bestMode;
}
}
@@ -2261,7 +2261,7 @@
for (uint32_t part = 0; part < numPU; part++)
{
PredictionUnit pu(mode.cu, cuGeom, part);
- if (m_param->analysisRefineLevel == 10)
+ if (m_param->analysisReuseLevel == 10)
{
analysis_inter_data* interDataCTU = (analysis_inter_data*)m_frame->m_analysisData.interData;
int cuIdx = (mode.cu.m_cuAddr * parentCTU.m_numPartitions) + cuGeom.absPartIdx;
@@ -2363,7 +2363,7 @@
if (m_slice->m_pps->bUseDQP && nextDepth <= m_slice->m_pps->maxCuDQPDepth)
nextQP = setLambdaFromQP(parentCTU, calculateQpforCuSize(parentCTU, childGeom));
- int lamdaQP = m_param->analysisRefineLevel == 10 ? nextQP : lqp;
+ int lamdaQP = m_param->analysisReuseLevel == 10 ? nextQP : lqp;
if (split)
m_param->rdLevel > 4 ? compressInterCU_rd5_6(parentCTU, childGeom, nextQP) : compressInterCU_rd0_4(parentCTU, childGeom, nextQP);
@@ -2686,7 +2686,7 @@
interMode.cu.setPredModeSubParts(MODE_INTER);
int numPredDir = m_slice->isInterP() ? 1 : 2;
- if (m_param->analysisMode == X265_ANALYSIS_LOAD && m_reuseInterDataCTU && m_param->analysisRefineLevel > 1 && m_param->analysisRefineLevel != 10)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_reuseInterDataCTU && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
{
int refOffset = cuGeom.geomRecurId * 16 * numPredDir + partSize * numPredDir * 2;
int index = 0;
@@ -2728,7 +2728,7 @@
}
interMode.sa8dCost = m_rdCost.calcRdSADCost((uint32_t)interMode.distortion, interMode.sa8dBits);
- if (m_param->analysisMode == X265_ANALYSIS_SAVE && m_reuseInterDataCTU && m_param->analysisRefineLevel > 1)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_SAVE && m_reuseInterDataCTU && m_param->analysisReuseLevel > 1)
{
int refOffset = cuGeom.geomRecurId * 16 * numPredDir + partSize * numPredDir * 2;
int index = 0;
@@ -2750,7 +2750,7 @@
interMode.cu.setPredModeSubParts(MODE_INTER);
int numPredDir = m_slice->isInterP() ? 1 : 2;
- if (m_param->analysisMode == X265_ANALYSIS_LOAD && m_reuseInterDataCTU && m_param->analysisRefineLevel > 1 && m_param->analysisRefineLevel != 10)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_reuseInterDataCTU && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
{
int refOffset = cuGeom.geomRecurId * 16 * numPredDir + partSize * numPredDir * 2;
int index = 0;
@@ -2784,7 +2784,7 @@
/* predInterSearch sets interMode.sa8dBits, but this is ignored */
encodeResAndCalcRdInterCU(interMode, cuGeom);
- if (m_param->analysisMode == X265_ANALYSIS_SAVE && m_reuseInterDataCTU && m_param->analysisRefineLevel > 1)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_SAVE && m_reuseInterDataCTU && m_param->analysisReuseLevel > 1)
{
int refOffset = cuGeom.geomRecurId * 16 * numPredDir + partSize * numPredDir * 2;
int index = 0;
diff -r 40dbeef1d8b5 -r edbdfb8e8eea source/encoder/api.cpp
--- a/source/encoder/api.cpp Tue Jun 13 14:00:40 2017 +0530
+++ b/source/encoder/api.cpp Wed Jun 21 10:03:53 2017 +0530
@@ -351,7 +351,7 @@
pic->userSEI.payloads = NULL;
pic->userSEI.numPayloads = 0;
- if (param->analysisMode)
+ if (param->analysisReuseMode)
{
uint32_t widthInCU = (param->sourceWidth + param->maxCUSize - 1) >> param->maxLog2CUSize;
uint32_t heightInCU = (param->sourceHeight + param->maxCUSize - 1) >> param->maxLog2CUSize;
diff -r 40dbeef1d8b5 -r edbdfb8e8eea source/encoder/encoder.cpp
--- a/source/encoder/encoder.cpp Tue Jun 13 14:00:40 2017 +0530
+++ b/source/encoder/encoder.cpp Wed Jun 21 10:03:53 2017 +0530
@@ -347,12 +347,12 @@
initRefIdx();
- if (m_param->analysisMode)
+ if (m_param->analysisReuseMode)
{
- const char* name = m_param->analysisFileName;
+ const char* name = m_param->analysisReuseFileName;
if (!name)
name = defaultAnalysisFileName;
- const char* mode = m_param->analysisMode == X265_ANALYSIS_LOAD ? "rb" : "wb";
+ const char* mode = m_param->analysisReuseMode == X265_ANALYSIS_LOAD ? "rb" : "wb";
m_analysisFile = x265_fopen(name, mode);
if (!m_analysisFile)
{
@@ -363,7 +363,7 @@
if (m_param->analysisMultiPassRefine || m_param->analysisMultiPassDistortion)
{
- const char* name = m_param->analysisFileName;
+ const char* name = m_param->analysisReuseFileName;
if (!name)
name = defaultAnalysisFileName;
if (m_param->rc.bStatWrite)
@@ -486,7 +486,7 @@
{
int bError = 1;
fclose(m_analysisFileOut);
- const char* name = m_param->analysisFileName;
+ const char* name = m_param->analysisReuseFileName;
if (!name)
name = defaultAnalysisFileName;
char* temp = strcatFilename(name, ".temp");
@@ -506,7 +506,7 @@
/* release string arguments that were strdup'd */
free((char*)m_param->rc.lambdaFileName);
free((char*)m_param->rc.statFileName);
- free((char*)m_param->analysisFileName);
+ free((char*)m_param->analysisReuseFileName);
free((char*)m_param->scalingLists);
free((char*)m_param->csvfn);
free((char*)m_param->numaPools);
@@ -598,7 +598,7 @@
if (m_exportedPic)
{
- if (!m_param->bUseAnalysisFile && m_param->analysisMode == X265_ANALYSIS_SAVE)
+ if (!m_param->bUseAnalysisFile && m_param->analysisReuseMode == X265_ANALYSIS_SAVE)
freeAnalysis(&m_exportedPic->m_analysisData);
ATOMIC_DEC(&m_exportedPic->m_countRefEncoders);
m_exportedPic = NULL;
@@ -766,7 +766,7 @@
/* In analysisSave mode, x265_analysis_data is allocated in pic_in and inFrame points to this */
/* Load analysis data before lookahead->addPicture, since sliceType has been decided */
- if (m_param->analysisMode == X265_ANALYSIS_LOAD)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD)
{
/* readAnalysisFile reads analysis data for the frame and allocates memory based on slicetype */
readAnalysisFile(&inFrame->m_analysisData, inFrame->m_poc, pic_in);
@@ -833,7 +833,7 @@
x265_frame_stats* frameData = NULL;
/* Free up pic_in->analysisData since it has already been used */
- if (m_param->analysisMode == X265_ANALYSIS_LOAD)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD)
freeAnalysis(&outFrame->m_analysisData);
if (pic_out)
@@ -859,7 +859,7 @@
}
/* Dump analysis data from pic_out to file in save mode and free */
- if (m_param->analysisMode == X265_ANALYSIS_SAVE)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_SAVE)
{
pic_out->analysisData.poc = pic_out->poc;
pic_out->analysisData.sliceType = pic_out->sliceType;
@@ -1097,7 +1097,7 @@
frameEnc->m_dts = frameEnc->m_reorderedPts;
/* Allocate analysis data before encode in save mode. This is allocated in frameEnc */
- if (m_param->analysisMode == X265_ANALYSIS_SAVE)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_SAVE)
{
x265_analysis_data* analysis = &frameEnc->m_analysisData;
analysis->poc = frameEnc->m_poc;
@@ -2242,23 +2242,23 @@
p->rc.rfConstantMin = 0;
}
- if (p->analysisMode && (p->bDistributeModeAnalysis || p->bDistributeMotionEstimation))
+ if (p->analysisReuseMode && (p->bDistributeModeAnalysis || p->bDistributeMotionEstimation))
{
x265_log(p, X265_LOG_WARNING, "Analysis load/save options incompatible with pmode/pme, Disabling pmode/pme\n");
p->bDistributeMotionEstimation = p->bDistributeModeAnalysis = 0;
}
- if (p->analysisMode && p->rc.cuTree)
+ if (p->analysisReuseMode && p->rc.cuTree)
{
x265_log(p, X265_LOG_WARNING, "Analysis load/save options works only with cu-tree off, Disabling cu-tree\n");
p->rc.cuTree = 0;
}
- if (p->analysisMode && (p->analysisMultiPassRefine || p->analysisMultiPassDistortion))
+ if (p->analysisReuseMode && (p->analysisMultiPassRefine || p->analysisMultiPassDistortion))
{
x265_log(p, X265_LOG_WARNING, "Cannot use Analysis load/save option and multi-pass-opt-analysis/multi-pass-opt-distortion together,"
"Disabling Analysis load/save and multi-pass-opt-analysis/multi-pass-opt-distortion\n");
- p->analysisMode = p->analysisMultiPassRefine = p->analysisMultiPassDistortion = 0;
+ p->analysisReuseMode = p->analysisMultiPassRefine = p->analysisMultiPassDistortion = 0;
}
if (p->scaleFactor)
{
@@ -2266,27 +2266,27 @@
{
p->scaleFactor = 0;
}
- else if (!p->analysisMode || p->analysisRefineLevel < 10)
+ else if (!p->analysisReuseMode || p->analysisReuseLevel < 10)
{
- x265_log(p, X265_LOG_WARNING, "Input scaling works with analysis-mode, refine-level 10. Disabling scale-factor.\n");
+ x265_log(p, X265_LOG_WARNING, "Input scaling works with analysis-reuse-mode, analysis-reuse-level 10. Disabling scale-factor.\n");
p->scaleFactor = 0;
}
}
if (p->intraRefine)
{
- if (p->analysisMode!= X265_ANALYSIS_LOAD || p->analysisRefineLevel < 10 || !p->scaleFactor)
+ if (p->analysisReuseMode!= X265_ANALYSIS_LOAD || p->analysisReuseLevel < 10 || !p->scaleFactor)
{
- x265_log(p, X265_LOG_WARNING, "Intra refinement requires analysis load, refine-level 10, scale factor. Disabling intra refine.\n");
+ x265_log(p, X265_LOG_WARNING, "Intra refinement requires analysis load, analysis-reuse-level 10, scale factor. Disabling intra refine.\n");
p->intraRefine = 0;
}
}
if (p->interRefine)
{
- if (p->analysisMode != X265_ANALYSIS_LOAD || p->analysisRefineLevel < 10 || !p->scaleFactor)
+ if (p->analysisReuseMode != X265_ANALYSIS_LOAD || p->analysisReuseLevel < 10 || !p->scaleFactor)
{
- x265_log(p, X265_LOG_WARNING, "Inter refinement requires analysis load, refine-level 10, scale factor. Disabling inter refine.\n");
+ x265_log(p, X265_LOG_WARNING, "Inter refinement requires analysis load, analysis-reuse-level 10, scale factor. Disabling inter refine.\n");
p->interRefine = 0;
}
}
@@ -2299,9 +2299,9 @@
if (p->mvRefine)
{
- if (p->analysisMode != X265_ANALYSIS_LOAD || p->analysisRefineLevel < 10 || !p->scaleFactor)
+ if (p->analysisReuseMode != X265_ANALYSIS_LOAD || p->analysisReuseLevel < 10 || !p->scaleFactor)
{
- x265_log(p, X265_LOG_WARNING, "MV refinement requires analysis load, refine-level 10, scale factor. Disabling MV refine.\n");
+ x265_log(p, X265_LOG_WARNING, "MV refinement requires analysis load, analysis-reuse-level 10, scale factor. Disabling MV refine.\n");
p->mvRefine = 0;
}
}
@@ -2395,7 +2395,7 @@
m_conformanceWindow.bottomOffset = 0;
m_conformanceWindow.leftOffset = 0;
/* set pad size if width is not multiple of the minimum CU size */
- if (p->scaleFactor == 2 && ((p->sourceWidth / 2) & (p->minCUSize - 1)) && p->analysisMode == X265_ANALYSIS_LOAD)
+ if (p->scaleFactor == 2 && ((p->sourceWidth / 2) & (p->minCUSize - 1)) && p->analysisReuseMode == X265_ANALYSIS_LOAD)
{
uint32_t rem = (p->sourceWidth / 2) & (p->minCUSize - 1);
uint32_t padsize = p->minCUSize - rem;
@@ -2584,7 +2584,7 @@
}
}
/* set pad size if height is not multiple of the minimum CU size */
- if (p->scaleFactor == 2 && ((p->sourceHeight / 2) & (p->minCUSize - 1)) && p->analysisMode == X265_ANALYSIS_LOAD)
+ if (p->scaleFactor == 2 && ((p->sourceHeight / 2) & (p->minCUSize - 1)) && p->analysisReuseMode == X265_ANALYSIS_LOAD)
{
uint32_t rem = (p->sourceHeight / 2) & (p->minCUSize - 1);
uint32_t padsize = p->minCUSize - rem;
@@ -2647,7 +2647,7 @@
analysis->interData = analysis->intraData = NULL;
if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == X265_TYPE_I)
{
- if (m_param->analysisRefineLevel < 2)
+ if (m_param->analysisReuseLevel < 2)
return;
analysis_intra_data *intraData = (analysis_intra_data*)analysis->intraData;
@@ -2663,20 +2663,20 @@
int numDir = analysis->sliceType == X265_TYPE_P ? 1 : 2;
uint32_t numPlanes = m_param->internalCsp == X265_CSP_I400 ? 1 : 3;
CHECKED_MALLOC_ZERO(analysis->wt, WeightParam, numPlanes * numDir);
- if (m_param->analysisRefineLevel < 2)
+ if (m_param->analysisReuseLevel < 2)
return;
analysis_inter_data *interData = (analysis_inter_data*)analysis->interData;
CHECKED_MALLOC_ZERO(interData, analysis_inter_data, 1);
CHECKED_MALLOC(interData->depth, uint8_t, analysis->numPartitions * analysis->numCUsInFrame);
CHECKED_MALLOC(interData->modes, uint8_t, analysis->numPartitions * analysis->numCUsInFrame);
- if (m_param->analysisRefineLevel > 4)
+ if (m_param->analysisReuseLevel > 4)
{
CHECKED_MALLOC(interData->partSize, uint8_t, analysis->numPartitions * analysis->numCUsInFrame);
CHECKED_MALLOC(interData->mergeFlag, uint8_t, analysis->numPartitions * analysis->numCUsInFrame);
}
- if (m_param->analysisRefineLevel == 10)
+ if (m_param->analysisReuseLevel == 10)
{
CHECKED_MALLOC(interData->interDir, uint8_t, analysis->numPartitions * analysis->numCUsInFrame);
for (int dir = 0; dir < numDir; dir++)
@@ -2713,7 +2713,7 @@
/* Early exit freeing weights alone if level is 1 (when there is no analysis inter/intra) */
if (analysis->sliceType > X265_TYPE_I && analysis->wt)
X265_FREE(analysis->wt);
- if (m_param->analysisRefineLevel < 2)
+ if (m_param->analysisReuseLevel < 2)
return;
if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == X265_TYPE_I)
@@ -2741,12 +2741,12 @@
{
X265_FREE(((analysis_inter_data*)analysis->interData)->depth);
X265_FREE(((analysis_inter_data*)analysis->interData)->modes);
- if (m_param->analysisRefineLevel > 4)
+ if (m_param->analysisReuseLevel > 4)
{
X265_FREE(((analysis_inter_data*)analysis->interData)->mergeFlag);
X265_FREE(((analysis_inter_data*)analysis->interData)->partSize);
}
- if (m_param->analysisRefineLevel == 10)
+ if (m_param->analysisReuseLevel == 10)
{
X265_FREE(((analysis_inter_data*)analysis->interData)->interDir);
int numDir = analysis->sliceType == X265_TYPE_P ? 1 : 2;
@@ -2901,7 +2901,7 @@
if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == X265_TYPE_I)
{
- if (m_param->analysisRefineLevel < 2)
+ if (m_param->analysisReuseLevel < 2)
return;
uint8_t *tempBuf = NULL, *depthBuf = NULL, *modeBuf = NULL, *partSizes = NULL;
@@ -2953,7 +2953,7 @@
uint32_t numDir = analysis->sliceType == X265_TYPE_P ? 1 : 2;
uint32_t numPlanes = m_param->internalCsp == X265_CSP_I400 ? 1 : 3;
X265_FREAD((WeightParam*)analysis->wt, sizeof(WeightParam), numPlanes * numDir, m_analysisFile, (picIn->analysisData.wt));
- if (m_param->analysisRefineLevel < 2)
+ if (m_param->analysisReuseLevel < 2)
return;
uint8_t *tempBuf = NULL, *depthBuf = NULL, *modeBuf = NULL, *partSize = NULL, *mergeFlag = NULL;
@@ -2961,9 +2961,9 @@
MV* mv[2];
int8_t* refIdx[2];
- int numBuf = m_param->analysisRefineLevel > 4 ? 4 : 2;
+ int numBuf = m_param->analysisReuseLevel > 4 ? 4 : 2;
bool bIntraInInter = false;
- if (m_param->analysisRefineLevel == 10)
+ if (m_param->analysisReuseLevel == 10)
{
numBuf++;
bIntraInInter = (analysis->sliceType == X265_TYPE_P || m_param->bIntraInBFrames);
@@ -2977,14 +2977,14 @@
X265_FREAD(depthBuf, sizeof(uint8_t), depthBytes, m_analysisFile, interPic->depth);
X265_FREAD(modeBuf, sizeof(uint8_t), depthBytes, m_analysisFile, interPic->modes);
- if (m_param->analysisRefineLevel > 4)
+ if (m_param->analysisReuseLevel > 4)
{
partSize = modeBuf + depthBytes;
mergeFlag = partSize + depthBytes;
X265_FREAD(partSize, sizeof(uint8_t), depthBytes, m_analysisFile, interPic->partSize);
X265_FREAD(mergeFlag, sizeof(uint8_t), depthBytes, m_analysisFile, interPic->mergeFlag);
- if (m_param->analysisRefineLevel == 10)
+ if (m_param->analysisReuseLevel == 10)
{
interDir = mergeFlag + depthBytes;
X265_FREAD(interDir, sizeof(uint8_t), depthBytes, m_analysisFile, interPic->interDir);
@@ -3013,7 +3013,7 @@
depthBuf[d] = 1;
memset(&((analysis_inter_data *)analysis->interData)->depth[count], depthBuf[d], bytes);
memset(&((analysis_inter_data *)analysis->interData)->modes[count], modeBuf[d], bytes);
- if (m_param->analysisRefineLevel > 4)
+ if (m_param->analysisReuseLevel > 4)
{
if (m_param->scaleFactor && modeBuf[d] == MODE_INTRA && partSize[d] == SIZE_NxN)
partSize[d] = SIZE_2Nx2N;
@@ -3023,7 +3023,7 @@
{
if (pu) d++;
((analysis_inter_data *)analysis->interData)->mergeFlag[count + pu] = mergeFlag[d];
- if (m_param->analysisRefineLevel == 10)
+ if (m_param->analysisReuseLevel == 10)
{
((analysis_inter_data *)analysis->interData)->interDir[count + pu] = interDir[d];
for (uint32_t i = 0; i < numDir; i++)
@@ -3039,7 +3039,7 @@
}
}
}
- if (m_param->analysisRefineLevel == 10 && bIntraInInter)
+ if (m_param->analysisReuseLevel == 10 && bIntraInInter)
memset(&((analysis_intra_data *)analysis->intraData)->chromaModes[count], chromaDir[d], bytes);
}
count += bytes;
@@ -3047,7 +3047,7 @@
X265_FREE(tempBuf);
- if (m_param->analysisRefineLevel == 10)
+ if (m_param->analysisReuseLevel == 10)
{
for (uint32_t i = 0; i < numDir; i++)
{
@@ -3232,7 +3232,7 @@
analysis->frameRecordSize += sizeof(WeightParam) * numPlanes * numDir;
}
- if (m_param->analysisRefineLevel > 1)
+ if (m_param->analysisReuseLevel > 1)
{
if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == X265_TYPE_I)
{
@@ -3280,12 +3280,12 @@
interDataCTU->depth[depthBytes] = depth;
predMode = ctu->m_predMode[absPartIdx];
- if (m_param->analysisRefineLevel != 10 && ctu->m_refIdx[1][absPartIdx] != -1)
+ if (m_param->analysisReuseLevel != 10 && ctu->m_refIdx[1][absPartIdx] != -1)
predMode = 4; // used as indiacator if the block is coded as bidir
interDataCTU->modes[depthBytes] = predMode;
- if (m_param->analysisRefineLevel > 4)
+ if (m_param->analysisReuseLevel > 4)
{
partSize = ctu->m_partSize[absPartIdx];
interDataCTU->partSize[depthBytes] = partSize;
@@ -3298,7 +3298,7 @@
if (puIdx) depthBytes++;
interDataCTU->mergeFlag[depthBytes] = ctu->m_mergeFlag[puabsPartIdx];
- if (m_param->analysisRefineLevel == 10)
+ if (m_param->analysisReuseLevel == 10)
{
interDataCTU->interDir[depthBytes] = ctu->m_interDir[puabsPartIdx];
for (uint32_t dir = 0; dir < numDir; dir++)
@@ -3309,12 +3309,12 @@
}
}
}
- if (m_param->analysisRefineLevel == 10 && bIntraInInter)
+ if (m_param->analysisReuseLevel == 10 && bIntraInInter)
intraDataCTU->chromaModes[depthBytes] = ctu->m_chromaIntraDir[absPartIdx];
}
absPartIdx += ctu->m_numPartitions >> (depth * 2);
}
- if (m_param->analysisRefineLevel == 10 && bIntraInInter)
+ if (m_param->analysisReuseLevel == 10 && bIntraInInter)
memcpy(&intraDataCTU->modes[ctu->m_cuAddr * ctu->m_numPartitions], ctu->m_lumaIntraDir, sizeof(uint8_t)* ctu->m_numPartitions);
}
}
@@ -3325,10 +3325,10 @@
{
/* Add sizeof depth, modes, partSize, mergeFlag */
analysis->frameRecordSize += depthBytes * 2;
- if (m_param->analysisRefineLevel > 4)
+ if (m_param->analysisReuseLevel > 4)
analysis->frameRecordSize += (depthBytes * 2);
- if (m_param->analysisRefineLevel == 10)
+ if (m_param->analysisReuseLevel == 10)
{
/* Add Size of interDir, mvpIdx, refIdx, mv, luma and chroma modes */
analysis->frameRecordSize += depthBytes;
@@ -3358,7 +3358,7 @@
if (analysis->sliceType > X265_TYPE_I)
X265_FWRITE((WeightParam*)analysis->wt, sizeof(WeightParam), numPlanes * numDir, m_analysisFile);
- if (m_param->analysisRefineLevel < 2)
+ if (m_param->analysisReuseLevel < 2)
return;
if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == X265_TYPE_I)
@@ -3372,11 +3372,11 @@
{
X265_FWRITE(((analysis_inter_data*)analysis->interData)->depth, sizeof(uint8_t), depthBytes, m_analysisFile);
X265_FWRITE(((analysis_inter_data*)analysis->interData)->modes, sizeof(uint8_t), depthBytes, m_analysisFile);
- if (m_param->analysisRefineLevel > 4)
+ if (m_param->analysisReuseLevel > 4)
{
X265_FWRITE(((analysis_inter_data*)analysis->interData)->partSize, sizeof(uint8_t), depthBytes, m_analysisFile);
X265_FWRITE(((analysis_inter_data*)analysis->interData)->mergeFlag, sizeof(uint8_t), depthBytes, m_analysisFile);
- if (m_param->analysisRefineLevel == 10)
+ if (m_param->analysisReuseLevel == 10)
{
X265_FWRITE(((analysis_inter_data*)analysis->interData)->interDir, sizeof(uint8_t), depthBytes, m_analysisFile);
if (bIntraInInter) X265_FWRITE(((analysis_intra_data*)analysis->intraData)->chromaModes, sizeof(uint8_t), depthBytes, m_analysisFile);
@@ -3390,7 +3390,7 @@
X265_FWRITE(((analysis_intra_data*)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFile);
}
}
- if (m_param->analysisRefineLevel != 10)
+ if (m_param->analysisReuseLevel != 10)
X265_FWRITE(((analysis_inter_data*)analysis->interData)->ref, sizeof(int32_t), analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir, m_analysisFile);
}
diff -r 40dbeef1d8b5 -r edbdfb8e8eea source/encoder/frameencoder.cpp
--- a/source/encoder/frameencoder.cpp Tue Jun 13 14:00:40 2017 +0530
+++ b/source/encoder/frameencoder.cpp Wed Jun 21 10:03:53 2017 +0530
@@ -388,7 +388,7 @@
bool bUseWeightB = slice->m_sliceType == B_SLICE && slice->m_pps->bUseWeightedBiPred;
WeightParam* reuseWP = NULL;
- if (m_param->analysisMode && (bUseWeightP || bUseWeightB))
+ if (m_param->analysisReuseMode && (bUseWeightP || bUseWeightB))
reuseWP = (WeightParam*)m_frame->m_analysisData.wt;
if (bUseWeightP || bUseWeightB)
@@ -397,7 +397,7 @@
m_cuStats.countWeightAnalyze++;
ScopedElapsedTime time(m_cuStats.weightAnalyzeTime);
#endif
- if (m_param->analysisMode == X265_ANALYSIS_LOAD)
+ if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD)
{
for (int list = 0; list < slice->isInterB() + 1; list++)
{
@@ -436,7 +436,7 @@
slice->m_refReconPicList[l][ref] = slice->m_refFrameList[l][ref]->m_reconPic;
m_mref[l][ref].init(slice->m_refReconPicList[l][ref], w, *m_param);
}
- if (m_param->analysisMode == X265_ANALYSIS_SAVE && (bUseWeightP || bUseWeightB))
+ if (m_param->analysisReuseMode == X265_ANALYSIS_SAVE && (bUseWeightP || bUseWeightB))
{
for (int i = 0; i < (m_param->internalCsp != X265_CSP_I400 ? 3 : 1); i++)
*(reuseWP++) = slice->m_weightPredTable[l][0][i];
diff -r 40dbeef1d8b5 -r edbdfb8e8eea source/encoder/search.cpp
--- a/source/encoder/search.cpp Tue Jun 13 14:00:40 2017 +0530
+++ b/source/encoder/search.cpp Wed Jun 21 10:03:53 2017 +0530
@@ -2073,7 +2073,7 @@
int mvpIdx = selectMVP(interMode.cu, pu, amvp, list, ref);
MV mvmin, mvmax, outmv, mvp = amvp[mvpIdx];
- if (!m_param->analysisMode) /* Prevents load/save outputs from diverging if lowresMV is not available */
+ if (!m_param->analysisReuseMode) /* Prevents load/save outputs from diverging if lowresMV is not available */
{
MV lmv = getLowresMV(interMode.cu, pu, list, ref);
if (lmv.notZero())
@@ -2161,7 +2161,7 @@
cu.getNeighbourMV(puIdx, pu.puAbsPartIdx, interMode.interNeighbours);
/* Uni-directional prediction */
- if ((m_param->analysisMode == X265_ANALYSIS_LOAD && m_param->analysisRefineLevel > 1 && m_param->analysisRefineLevel != 10)
+ if ((m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
|| (m_param->analysisMultiPassRefine && m_param->rc.bStatRead))
{
for (int list = 0; list < numPredDir; list++)
@@ -2297,7 +2297,7 @@
int mvpIdx = selectMVP(cu, pu, amvp, list, ref);
MV mvmin, mvmax, outmv, mvp = amvp[mvpIdx];
- if (!m_param->analysisMode) /* Prevents load/save outputs from diverging when lowresMV is not available */
+ if (!m_param->analysisReuseMode) /* Prevents load/save outputs from diverging when lowresMV is not available */
{
MV lmv = getLowresMV(cu, pu, list, ref);
if (lmv.notZero())
diff -r 40dbeef1d8b5 -r edbdfb8e8eea source/encoder/slicetype.cpp
--- a/source/encoder/slicetype.cpp Tue Jun 13 14:00:40 2017 +0530
+++ b/source/encoder/slicetype.cpp Wed Jun 21 10:03:53 2017 +0530
@@ -893,7 +893,7 @@
if (m_param->rc.cuTree && !m_param->rc.bStatRead)
/* update row satds based on cutree offsets */
curFrame->m_lowres.satdCost = frameCostRecalculate(frames, p0, p1, b);
- else if (m_param->analysisMode != X265_ANALYSIS_LOAD || m_param->scaleFactor)
+ else if (m_param->analysisReuseMode != X265_ANALYSIS_LOAD || m_param->scaleFactor)
{
if (m_param->rc.aqMode)
curFrame->m_lowres.satdCost = curFrame->m_lowres.costEstAq[b - p0][p1 - b];
diff -r 40dbeef1d8b5 -r edbdfb8e8eea source/x265.cpp
--- a/source/x265.cpp Tue Jun 13 14:00:40 2017 +0530
+++ b/source/x265.cpp Wed Jun 21 10:03:53 2017 +0530
@@ -580,9 +580,9 @@
x265_picture pic_orig, pic_out;
x265_picture *pic_in = &pic_orig;
- /* Allocate recon picture if analysisMode is enabled */
+ /* Allocate recon picture if analysisReuseMode is enabled */
std::priority_queue<int64_t>* pts_queue = cliopt.output->needPTS() ? new std::priority_queue<int64_t>() : NULL;
- x265_picture *pic_recon = (cliopt.recon || !!param->analysisMode || pts_queue || reconPlay || param->csvLogLevel) ? &pic_out : NULL;
+ x265_picture *pic_recon = (cliopt.recon || !!param->analysisReuseMode || pts_queue || reconPlay || param->csvLogLevel) ? &pic_out : NULL;
uint32_t inFrameCount = 0;
uint32_t outFrameCount = 0;
x265_nal *p_nal;
diff -r 40dbeef1d8b5 -r edbdfb8e8eea source/x265.h
--- a/source/x265.h Tue Jun 13 14:00:40 2017 +0530
+++ b/source/x265.h Wed Jun 21 10:03:53 2017 +0530
@@ -301,15 +301,15 @@
* to allow the encoder to determine base QP */
int forceqp;
- /* If param.analysisMode is X265_ANALYSIS_OFF this field is ignored on input
+ /* If param.analysisReuseMode is X265_ANALYSIS_OFF this field is ignored on input
* and output. Else the user must call x265_alloc_analysis_data() to
* allocate analysis buffers for every picture passed to the encoder.
*
- * On input when param.analysisMode is X265_ANALYSIS_LOAD and analysisData
+ * On input when param.analysisReuseMode is X265_ANALYSIS_LOAD and analysisData
* member pointers are valid, the encoder will use the data stored here to
* reduce encoder work.
*
- * On output when param.analysisMode is X265_ANALYSIS_SAVE and analysisData
+ * On output when param.analysisReuseMode is X265_ANALYSIS_SAVE and analysisData
* member pointers are valid, the encoder will write output analysis into
* this data structure */
x265_analysis_data analysisData;
@@ -1107,10 +1107,10 @@
* buffers. if X265_ANALYSIS_LOAD, read analysis information into analysis
* buffer and use this analysis information to reduce the amount of work
* the encoder must perform. Default X265_ANALYSIS_OFF */
- int analysisMode;
+ int analysisReuseMode;
- /* Filename for analysisMode save/load. Default name is "x265_analysis.dat" */
- const char* analysisFileName;
+ /* Filename for analysisReuseMode save/load. Default name is "x265_analysis.dat" */
+ const char* analysisReuseFileName;
/*== Rate Control ==*/
@@ -1426,9 +1426,9 @@
int bHDROpt;
/* A value between 1 and 10 (both inclusive) determines the level of
- * information stored/reused in save/load analysis-mode. Higher the refine
- * level higher the informtion stored/reused. Default is 5 */
- int analysisRefineLevel;
+ * information stored/reused in save/load analysis-reuse-mode. Higher the refine
+ * level higher the information stored/reused. Default is 5 */
+ int analysisReuseLevel;
/* Limit Sample Adaptive Offset filter computation by early terminating SAO
* process based on inter prediction mode, CTU spatial-domain correlations,
diff -r 40dbeef1d8b5 -r edbdfb8e8eea source/x265cli.h
--- a/source/x265cli.h Tue Jun 13 14:00:40 2017 +0530
+++ b/source/x265cli.h Wed Jun 21 10:03:53 2017 +0530
@@ -248,9 +248,9 @@
{ "no-slow-firstpass", no_argument, NULL, 0 },
{ "multi-pass-opt-rps", no_argument, NULL, 0 },
{ "no-multi-pass-opt-rps", no_argument, NULL, 0 },
- { "analysis-mode", required_argument, NULL, 0 },
- { "analysis-file", required_argument, NULL, 0 },
- { "refine-level", required_argument, NULL, 0 },
+ { "analysis-reuse-mode", required_argument, NULL, 0 },
+ { "analysis-reuse-file", required_argument, NULL, 0 },
+ { "analysis-reuse-level", required_argument, NULL, 0 },
{ "scale-factor", required_argument, NULL, 0 },
{ "refine-intra", no_argument, NULL, 0 },
{ "no-refine-intra",no_argument, NULL, 0 },
@@ -444,9 +444,9 @@
H0(" --[no-]analyze-src-pics Motion estimation uses source frame planes. Default disable\n");
H0(" --[no-]slow-firstpass Enable a slow first pass in a multipass rate control mode. Default %s\n", OPT(param->rc.bEnableSlowFirstPass));
H0(" --[no-]strict-cbr Enable stricter conditions and tolerance for bitrate deviations in CBR mode. Default %s\n", OPT(param->rc.bStrictCbr));
- H0(" --analysis-mode <string|int> save - Dump analysis info into file, load - Load analysis buffers from the file. Default %d\n", param->analysisMode);
- H0(" --analysis-file <filename> Specify file name used for either dumping or reading analysis data.\n");
- H0(" --refine-level <1..10> Level of analysis refinement indicates amount of info stored/reused in save/load mode, 1:least....10:most. Default %d\n", param->analysisRefineLevel);
+ H0(" --analysis-reuse-mode <string|int> save - Dump analysis info into file, load - Load analysis buffers from the file. Default %d\n", param->analysisReuseMode);
+ H0(" --analysis-reuse-file <filename> Specify file name used for either dumping or reading analysis data. Deault x265_analysis.dat\n");
+ H0(" --analysis-reuse-level <1..10> Level of analysis reuse indicates amount of info stored/reused in save/load mode, 1:least..10:most. Default %d\n", param->analysisReuseLevel);
H0(" --scale-factor <int> Specify factor by which input video is scaled down for analysis save mode. Default %d\n", param->scaleFactor);
H0(" --[no-]refine-intra Enable intra refinement for load mode. Default %s\n", OPT(param->intraRefine));
H0(" --[no-]refine-inter Enable inter refinement for load mode. Default %s\n", OPT(param->interRefine));
More information about the x265-devel
mailing list