[x265] [PATCH] analysis: Enable analysis save and load in a single run
aruna at multicorewareinc.com
aruna at multicorewareinc.com
Fri Dec 22 09:37:39 CET 2017
# HG changeset patch
# User Aruna Matheswaran <aruna at multicorewareinc.com>
# Date 1513850215 -19800
# Thu Dec 21 15:26:55 2017 +0530
# Node ID a3334a263d26920696091ccfcfe8e0db8be16364
# Parent 37f6c378ac90adf355bac51185a82b2917057107
analysis: Enable analysis save and load in a single run.
This patch does the following,
1. Deprecates the cli option --analysis-reuse-mode and introduces two new cli
options --analysis-save <filename> and --analysis-load <filename>.
2. Deprecates the param analysisReuseMode and introduces two new param options
analysisSave and analysisLoad.
diff -r 37f6c378ac90 -r a3334a263d26 doc/reST/cli.rst
--- a/doc/reST/cli.rst Thu Dec 14 16:53:44 2017 +0530
+++ b/doc/reST/cli.rst Thu Dec 21 15:26:55 2017 +0530
@@ -863,21 +863,22 @@
sequence multiple times (presumably at varying bitrates). The encoder
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-save <filename>
+
+ Encoder outputs analysis information of each frame. Analysis data from save mode is
+ written to the file specified. Requires cutree, pmode to be off. Default disabled.
+
+.. option:: --analysis-load <filename>
+
+ Encoder reuses analysis information from the file specified. 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 disabled.
+
+ The amount of analysis data stored/reused is determined by :option:`--analysis-reuse-level`.
.. option:: --analysis-reuse-file <filename>
- Specify a filename for analysis data (see :option:`--analysis-reuse-mode`)
+ Specify a filename for `multi-pass-opt-analysis` and `multi-pass-opt-distortion`.
If no filename is specified, x265_analysis.dat is used.
.. option:: --analysis-reuse-level <1..10>
diff -r 37f6c378ac90 -r a3334a263d26 source/CMakeLists.txt
--- a/source/CMakeLists.txt Thu Dec 14 16:53:44 2017 +0530
+++ b/source/CMakeLists.txt Thu Dec 21 15:26:55 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 148)
+set(X265_BUILD 149)
configure_file("${PROJECT_SOURCE_DIR}/x265.def.in"
"${PROJECT_BINARY_DIR}/x265.def")
configure_file("${PROJECT_SOURCE_DIR}/x265_config.h.in"
diff -r 37f6c378ac90 -r a3334a263d26 source/common/cudata.cpp
--- a/source/common/cudata.cpp Thu Dec 14 16:53:44 2017 +0530
+++ b/source/common/cudata.cpp Thu Dec 21 15:26:55 2017 +0530
@@ -1626,7 +1626,7 @@
dir |= (1 << list);
candMvField[count][list].mv = colmv;
candMvField[count][list].refIdx = refIdx;
- if (m_encData->m_param->scaleFactor && m_encData->m_param->analysisReuseMode == X265_ANALYSIS_SAVE && m_log2CUSize[0] < 4)
+ if (m_encData->m_param->scaleFactor && m_encData->m_param->analysisSave && m_log2CUSize[0] < 4)
{
MV dist(MAX_MV, MAX_MV);
candMvField[count][list].mv = dist;
@@ -1791,7 +1791,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->analysisReuseMode == X265_ANALYSIS_SAVE && (m_log2CUSize[0] < 4))
+ if (m_encData->m_param->scaleFactor && m_encData->m_param->analysisSave && (m_log2CUSize[0] < 4))
{
MV dist(MAX_MV, MAX_MV);
pmv[numMvc++] = amvpCand[num++] = dist;
diff -r 37f6c378ac90 -r a3334a263d26 source/common/param.cpp
--- a/source/common/param.cpp Thu Dec 14 16:53:44 2017 +0530
+++ b/source/common/param.cpp Thu Dec 21 15:26:55 2017 +0530
@@ -197,10 +197,12 @@
param->rdPenalty = 0;
param->psyRd = 2.0;
param->psyRdoq = 0.0;
- param->analysisReuseMode = 0;
+ param->analysisReuseMode = 0; /*DEPRECATED*/
param->analysisMultiPassRefine = 0;
param->analysisMultiPassDistortion = 0;
param->analysisReuseFileName = NULL;
+ param->analysisSave = NULL;
+ param->analysisLoad = NULL;
param->bIntraInBFrames = 0;
param->bLossless = 0;
param->bCULossless = 0;
@@ -850,7 +852,7 @@
p->rc.bStrictCbr = atobool(value);
p->rc.pbFactor = 1.0;
}
- OPT("analysis-reuse-mode") p->analysisReuseMode = parseName(value, x265_analysis_names, bError);
+ OPT("analysis-reuse-mode") p->analysisReuseMode = parseName(value, x265_analysis_names, bError); /*DEPRECATED*/
OPT("sar")
{
p->vui.aspectRatioIdc = parseName(value, x265_sar_names, bError);
@@ -1006,6 +1008,8 @@
}
}
OPT("gop-lookahead") p->gopLookahead = atoi(value);
+ OPT("analysis-save") p->analysisSave = strdup(value);
+ OPT("analysis-load") p->analysisLoad = strdup(value);
else
return X265_PARAM_BAD_NAME;
}
@@ -1344,9 +1348,7 @@
"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->analysisReuseMode && (param->analysisReuseMode < X265_ANALYSIS_OFF || param->analysisReuseMode > X265_ANALYSIS_LOAD),
- "Invalid analysis mode. Analysis mode 0: OFF 1: SAVE : 2 LOAD");
- CHECK(param->analysisReuseMode && (param->analysisReuseLevel < 1 || param->analysisReuseLevel > 10),
+ CHECK((param->analysisSave || param->analysisLoad) && (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,
@@ -1618,7 +1620,6 @@
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-reuse-mode=%d", p->analysisReuseMode);
BOOL(p->bLossless, "lossless");
s += sprintf(s, " cbqpoffs=%d", p->cbQpOffset);
s += sprintf(s, " crqpoffs=%d", p->crQpOffset);
@@ -1716,6 +1717,8 @@
BOOL(p->bEmitHDRSEI, "hdr");
BOOL(p->bHDROpt, "hdr-opt");
BOOL(p->bDhdr10opt, "dhdr10-opt");
+ s += sprintf(s, " analysis-save=%s", p->analysisSave);
+ s += sprintf(s, " analysis-load=%s", p->analysisLoad);
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);
diff -r 37f6c378ac90 -r a3334a263d26 source/encoder/analysis.cpp
--- a/source/encoder/analysis.cpp Thu Dec 14 16:53:44 2017 +0530
+++ b/source/encoder/analysis.cpp Thu Dec 21 15:26:55 2017 +0530
@@ -207,11 +207,11 @@
}
}
- if (m_param->analysisReuseMode && m_slice->m_sliceType != I_SLICE && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel < 10)
+ if ((m_param->analysisSave || m_param->analysisLoad) && 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_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->analysisReuseLevel > 4)
@@ -219,7 +219,7 @@
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->analysisReuseMode == X265_ANALYSIS_SAVE)
+ if (m_param->analysisSave && !m_param->analysisLoad)
for (int i = 0; i < X265_MAX_PRED_MODE_PER_CTU * numPredDir; i++)
m_reuseRef[i] = -1;
}
@@ -228,7 +228,7 @@
if (m_slice->m_sliceType == I_SLICE)
{
analysis_intra_data* intraDataCTU = (analysis_intra_data*)m_frame->m_analysisData.intraData;
- if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->analysisReuseLevel > 1)
+ if (m_param->analysisLoad && 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);
@@ -239,7 +239,7 @@
}
else
{
- bool bCopyAnalysis = ((m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->analysisReuseLevel == 10) || (m_param->bMVType && m_param->analysisReuseLevel >= 7 && ctu.m_numPartitions <= 16));
+ bool bCopyAnalysis = ((m_param->analysisLoad && m_param->analysisReuseLevel == 10) || (m_param->bMVType && m_param->analysisReuseLevel >= 7 && ctu.m_numPartitions <= 16));
bool BCompressInterCUrd0_4 = (m_param->bMVType && m_param->analysisReuseLevel >= 7 && m_param->rdLevel <= 4);
bool BCompressInterCUrd5_6 = (m_param->bMVType && m_param->analysisReuseLevel >= 7 && m_param->rdLevel >= 5 && m_param->rdLevel <= 6);
bCopyAnalysis = bCopyAnalysis || BCompressInterCUrd0_4 || BCompressInterCUrd5_6;
@@ -280,7 +280,7 @@
/* generate residual for entire CTU at once and copy to reconPic */
encodeResidue(ctu, cuGeom);
}
- else if ((m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->analysisReuseLevel == 10) || ((m_param->bMVType == AVC_INFO) && m_param->analysisReuseLevel >= 7 && ctu.m_numPartitions <= 16))
+ else if ((m_param->analysisLoad && m_param->analysisReuseLevel == 10) || ((m_param->bMVType == AVC_INFO) && m_param->analysisReuseLevel >= 7 && ctu.m_numPartitions <= 16))
{
analysis_inter_data* interDataCTU = (analysis_inter_data*)m_frame->m_analysisData.interData;
int posCTU = ctu.m_cuAddr * numPartition;
@@ -651,7 +651,7 @@
}
/* Save Intra CUs TU depth only when analysis mode is OFF */
- if ((m_limitTU & X265_TU_LIMIT_NEIGH) && cuGeom.log2CUSize >= 4 && !m_param->analysisReuseMode)
+ if ((m_limitTU & X265_TU_LIMIT_NEIGH) && cuGeom.log2CUSize >= 4 && (!m_param->analysisSave && !m_param->analysisLoad))
{
CUData* ctu = md.bestMode->cu.m_encData->getPicCTU(parentCTU.m_cuAddr);
int8_t maxTUDepth = -1;
@@ -1263,7 +1263,7 @@
mightSplit &= !bDecidedDepth;
}
}
- if ((m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10))
+ if ((m_param->analysisLoad && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10))
{
if (mightNotSplit && depth == m_reuseDepth[cuGeom.absPartIdx])
{
@@ -1957,7 +1957,7 @@
mightSplit &= !bDecidedDepth;
}
}
- if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
+ if (m_param->analysisLoad && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
{
if (mightNotSplit && depth == m_reuseDepth[cuGeom.absPartIdx])
{
@@ -2890,7 +2890,7 @@
interMode.cu.setPredModeSubParts(MODE_INTER);
int numPredDir = m_slice->isInterP() ? 1 : 2;
- if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_reuseInterDataCTU && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
+ if (m_param->analysisLoad && m_reuseInterDataCTU && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
{
int refOffset = cuGeom.geomRecurId * 16 * numPredDir + partSize * numPredDir * 2;
int index = 0;
@@ -2932,7 +2932,7 @@
}
interMode.sa8dCost = m_rdCost.calcRdSADCost((uint32_t)interMode.distortion, interMode.sa8dBits);
- if (m_param->analysisReuseMode == X265_ANALYSIS_SAVE && m_reuseInterDataCTU && m_param->analysisReuseLevel > 1)
+ if (m_param->analysisSave && m_reuseInterDataCTU && m_param->analysisReuseLevel > 1)
{
int refOffset = cuGeom.geomRecurId * 16 * numPredDir + partSize * numPredDir * 2;
int index = 0;
@@ -2954,7 +2954,7 @@
interMode.cu.setPredModeSubParts(MODE_INTER);
int numPredDir = m_slice->isInterP() ? 1 : 2;
- if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_reuseInterDataCTU && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
+ if (m_param->analysisLoad && m_reuseInterDataCTU && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
{
int refOffset = cuGeom.geomRecurId * 16 * numPredDir + partSize * numPredDir * 2;
int index = 0;
@@ -2988,7 +2988,7 @@
/* predInterSearch sets interMode.sa8dBits, but this is ignored */
encodeResAndCalcRdInterCU(interMode, cuGeom);
- if (m_param->analysisReuseMode == X265_ANALYSIS_SAVE && m_reuseInterDataCTU && m_param->analysisReuseLevel > 1)
+ if (m_param->analysisSave && m_reuseInterDataCTU && m_param->analysisReuseLevel > 1)
{
int refOffset = cuGeom.geomRecurId * 16 * numPredDir + partSize * numPredDir * 2;
int index = 0;
diff -r 37f6c378ac90 -r a3334a263d26 source/encoder/api.cpp
--- a/source/encoder/api.cpp Thu Dec 14 16:53:44 2017 +0530
+++ b/source/encoder/api.cpp Thu Dec 21 15:26:55 2017 +0530
@@ -398,7 +398,7 @@
pic->userSEI.payloads = NULL;
pic->userSEI.numPayloads = 0;
- if (param->analysisReuseMode || (param->bMVType == AVC_INFO))
+ if ((param->analysisSave || param->analysisLoad) || (param->bMVType == AVC_INFO))
{
uint32_t widthInCU = (param->sourceWidth + param->maxCUSize - 1) >> param->maxLog2CUSize;
uint32_t heightInCU = (param->sourceHeight + param->maxCUSize - 1) >> param->maxLog2CUSize;
diff -r 37f6c378ac90 -r a3334a263d26 source/encoder/encoder.cpp
--- a/source/encoder/encoder.cpp Thu Dec 14 16:53:44 2017 +0530
+++ b/source/encoder/encoder.cpp Thu Dec 21 15:26:55 2017 +0530
@@ -77,7 +77,6 @@
m_param = NULL;
m_latestParam = NULL;
m_threadPool = NULL;
- m_analysisFile = NULL;
m_analysisFileIn = NULL;
m_analysisFileOut = NULL;
m_offsetEmergency = NULL;
@@ -343,16 +342,28 @@
if (!m_lookahead->create())
m_aborted = true;
initRefIdx();
- if (m_param->analysisReuseMode && m_param->bUseAnalysisFile)
+ if (m_param->analysisSave && m_param->bUseAnalysisFile)
{
- const char* name = m_param->analysisReuseFileName;
- if (!name)
- name = defaultAnalysisFileName;
- const char* mode = m_param->analysisReuseMode == X265_ANALYSIS_LOAD ? "rb" : "wb";
- m_analysisFile = x265_fopen(name, mode);
- if (!m_analysisFile)
+ char* temp = strcatFilename(m_param->analysisSave, ".temp");
+ if (!temp)
+ m_aborted = true;
+ else
+ {
+ m_analysisFileOut = x265_fopen(temp, "wb");
+ X265_FREE(temp);
+ }
+ if (!m_analysisFileOut)
{
- x265_log_file(NULL, X265_LOG_ERROR, "Analysis load/save: failed to open file %s\n", name);
+ x265_log_file(NULL, X265_LOG_ERROR, "Analysis save: failed to open file %s.temp\n", m_param->analysisSave);
+ m_aborted = true;
+ }
+ }
+ if (m_param->analysisLoad && m_param->bUseAnalysisFile)
+ {
+ m_analysisFileIn = x265_fopen(m_param->analysisLoad, "rb");
+ if (!m_analysisFileIn)
+ {
+ x265_log_file(NULL, X265_LOG_ERROR, "Analysis load: failed to open file %s\n", m_param->analysisLoad);
m_aborted = true;
}
}
@@ -718,9 +729,6 @@
X265_FREE(m_offsetEmergency);
- if (m_analysisFile)
- fclose(m_analysisFile);
-
if (m_latestParam != NULL && m_latestParam != m_param)
{
if (m_latestParam->scalingLists != m_param->scalingLists)
@@ -735,7 +743,7 @@
{
int bError = 1;
fclose(m_analysisFileOut);
- const char* name = m_param->analysisReuseFileName;
+ const char* name = m_param->analysisSave ? m_param->analysisSave : m_param->analysisReuseFileName;
if (!name)
name = defaultAnalysisFileName;
char* temp = strcatFilename(name, ".temp");
@@ -763,6 +771,8 @@
free((char*)m_param->numaPools);
free((char*)m_param->masteringDisplayColorVolume);
free((char*)m_param->toneMapFile);
+ free((char*)m_param->analysisSave);
+ free((char*)m_param->analysisLoad);
PARAM_NS::x265_param_free(m_param);
}
}
@@ -849,7 +859,7 @@
if (m_exportedPic)
{
- if (!m_param->bUseAnalysisFile && m_param->analysisReuseMode == X265_ANALYSIS_SAVE)
+ if (!m_param->bUseAnalysisFile && m_param->analysisSave)
freeAnalysis(&m_exportedPic->m_analysisData);
ATOMIC_DEC(&m_exportedPic->m_countRefEncoders);
m_exportedPic = NULL;
@@ -1034,7 +1044,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->analysisReuseMode == X265_ANALYSIS_LOAD)
+ if (m_param->analysisLoad)
{
/* readAnalysisFile reads analysis data for the frame and allocates memory based on slicetype */
readAnalysisFile(&inFrame->m_analysisData, inFrame->m_poc, pic_in);
@@ -1119,7 +1129,7 @@
x265_frame_stats* frameData = NULL;
/* Free up pic_in->analysisData since it has already been used */
- if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD || (m_param->bMVType && slice->m_sliceType != I_SLICE))
+ if ((m_param->analysisLoad && !m_param->analysisSave) || (m_param->bMVType && slice->m_sliceType != I_SLICE))
freeAnalysis(&outFrame->m_analysisData);
if (pic_out)
@@ -1145,7 +1155,7 @@
}
/* Dump analysis data from pic_out to file in save mode and free */
- if (m_param->analysisReuseMode == X265_ANALYSIS_SAVE)
+ if (m_param->analysisSave)
{
pic_out->analysisData.poc = pic_out->poc;
pic_out->analysisData.sliceType = pic_out->sliceType;
@@ -1354,7 +1364,7 @@
slice->m_maxNumMergeCand = m_param->maxNumMergeCand;
slice->m_endCUAddr = slice->realEndAddress(m_sps.numCUsInFrame * m_param->num4x4Partitions);
}
- if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->bDisableLookahead)
+ if (m_param->analysisLoad && m_param->bDisableLookahead)
{
frameEnc->m_dts = frameEnc->m_analysisData.lookahead.dts;
if (m_rateControl->m_isVbv)
@@ -1423,7 +1433,7 @@
frameEnc->m_encData->m_slice->m_iNumRPSInSPS = m_sps.spsrpsNum;
curEncoder->m_rce.encodeOrder = frameEnc->m_encodeOrder = m_encodedFrameNum++;
- if (m_param->analysisReuseMode != X265_ANALYSIS_LOAD || !m_param->bDisableLookahead)
+ if (!m_param->analysisLoad || !m_param->bDisableLookahead)
{
if (m_bframeDelay)
{
@@ -1438,7 +1448,7 @@
}
/* Allocate analysis data before encode in save mode. This is allocated in frameEnc */
- if (m_param->analysisReuseMode == X265_ANALYSIS_SAVE)
+ if (m_param->analysisSave && !m_param->analysisLoad)
{
x265_analysis_data* analysis = &frameEnc->m_analysisData;
analysis->poc = frameEnc->m_poc;
@@ -2623,23 +2633,24 @@
p->rc.rfConstantMin = 0;
}
- if (p->analysisReuseMode && (p->bDistributeModeAnalysis || p->bDistributeMotionEstimation))
+ if ((p->analysisLoad || p->analysisSave) && (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->analysisReuseMode && p->rc.cuTree)
+ if ((p->analysisLoad || p->analysisSave) && 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->analysisReuseMode && (p->analysisMultiPassRefine || p->analysisMultiPassDistortion))
+ if ((p->analysisLoad || p->analysisSave) && (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->analysisReuseMode = p->analysisMultiPassRefine = p->analysisMultiPassDistortion = 0;
+ p->analysisSave = p->analysisLoad = NULL;
+ p->analysisMultiPassRefine = p->analysisMultiPassDistortion = 0;
}
if (p->scaleFactor)
{
@@ -2647,16 +2658,16 @@
{
p->scaleFactor = 0;
}
- else if (!p->analysisReuseMode || p->analysisReuseLevel < 10)
+ else if ((!p->analysisLoad && !p->analysisSave) || p->analysisReuseLevel < 10)
{
- x265_log(p, X265_LOG_WARNING, "Input scaling works with analysis-reuse-mode, analysis-reuse-level 10. Disabling scale-factor.\n");
+ x265_log(p, X265_LOG_WARNING, "Input scaling works with analysis load/save, analysis-reuse-level 10. Disabling scale-factor.\n");
p->scaleFactor = 0;
}
}
if (p->intraRefine)
{
- if (p->analysisReuseMode!= X265_ANALYSIS_LOAD || p->analysisReuseLevel < 10 || !p->scaleFactor)
+ if (!p->analysisLoad || p->analysisReuseLevel < 10 || !p->scaleFactor)
{
x265_log(p, X265_LOG_WARNING, "Intra refinement requires analysis load, analysis-reuse-level 10, scale factor. Disabling intra refine.\n");
p->intraRefine = 0;
@@ -2665,7 +2676,7 @@
if (p->interRefine)
{
- if (p->analysisReuseMode != X265_ANALYSIS_LOAD || p->analysisReuseLevel < 10 || !p->scaleFactor)
+ if (!p->analysisLoad || p->analysisReuseLevel < 10 || !p->scaleFactor)
{
x265_log(p, X265_LOG_WARNING, "Inter refinement requires analysis load, analysis-reuse-level 10, scale factor. Disabling inter refine.\n");
p->interRefine = 0;
@@ -2680,7 +2691,7 @@
if (p->mvRefine)
{
- if (p->analysisReuseMode != X265_ANALYSIS_LOAD || p->analysisReuseLevel < 10 || !p->scaleFactor)
+ if (!p->analysisLoad || p->analysisReuseLevel < 10 || !p->scaleFactor)
{
x265_log(p, X265_LOG_WARNING, "MV refinement requires analysis load, analysis-reuse-level 10, scale factor. Disabling MV refine.\n");
p->mvRefine = 0;
@@ -2781,7 +2792,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->analysisReuseMode == X265_ANALYSIS_LOAD)
+ if (p->scaleFactor == 2 && ((p->sourceWidth / 2) & (p->minCUSize - 1)) && p->analysisLoad)
{
uint32_t rem = (p->sourceWidth / 2) & (p->minCUSize - 1);
uint32_t padsize = p->minCUSize - rem;
@@ -2970,7 +2981,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->analysisReuseMode == X265_ANALYSIS_LOAD)
+ if (p->scaleFactor == 2 && ((p->sourceHeight / 2) & (p->minCUSize - 1)) && p->analysisLoad)
{
uint32_t rem = (p->sourceHeight / 2) & (p->minCUSize - 1);
uint32_t padsize = p->minCUSize - rem;
@@ -3268,30 +3279,30 @@
static uint64_t totalConsumedBytes = 0;
uint32_t depthBytes = 0;
if (m_param->bUseAnalysisFile)
- fseeko(m_analysisFile, totalConsumedBytes, SEEK_SET);
+ fseeko(m_analysisFileIn, totalConsumedBytes, SEEK_SET);
const x265_analysis_data *picData = &(picIn->analysisData);
analysis_intra_data *intraPic = (analysis_intra_data *)picData->intraData;
analysis_inter_data *interPic = (analysis_inter_data *)picData->interData;
int poc; uint32_t frameRecordSize;
- X265_FREAD(&frameRecordSize, sizeof(uint32_t), 1, m_analysisFile, &(picData->frameRecordSize));
- X265_FREAD(&depthBytes, sizeof(uint32_t), 1, m_analysisFile, &(picData->depthBytes));
- X265_FREAD(&poc, sizeof(int), 1, m_analysisFile, &(picData->poc));
+ X265_FREAD(&frameRecordSize, sizeof(uint32_t), 1, m_analysisFileIn, &(picData->frameRecordSize));
+ X265_FREAD(&depthBytes, sizeof(uint32_t), 1, m_analysisFileIn, &(picData->depthBytes));
+ X265_FREAD(&poc, sizeof(int), 1, m_analysisFileIn, &(picData->poc));
if (m_param->bUseAnalysisFile)
{
uint64_t currentOffset = totalConsumedBytes;
/* Seeking to the right frame Record */
- while (poc != curPoc && !feof(m_analysisFile))
+ while (poc != curPoc && !feof(m_analysisFileIn))
{
currentOffset += frameRecordSize;
- fseeko(m_analysisFile, currentOffset, SEEK_SET);
- X265_FREAD(&frameRecordSize, sizeof(uint32_t), 1, m_analysisFile, &(picData->frameRecordSize));
- X265_FREAD(&depthBytes, sizeof(uint32_t), 1, m_analysisFile, &(picData->depthBytes));
- X265_FREAD(&poc, sizeof(int), 1, m_analysisFile, &(picData->poc));
+ fseeko(m_analysisFileIn, currentOffset, SEEK_SET);
+ X265_FREAD(&frameRecordSize, sizeof(uint32_t), 1, m_analysisFileIn, &(picData->frameRecordSize));
+ X265_FREAD(&depthBytes, sizeof(uint32_t), 1, m_analysisFileIn, &(picData->depthBytes));
+ X265_FREAD(&poc, sizeof(int), 1, m_analysisFileIn, &(picData->poc));
}
- if (poc != curPoc || feof(m_analysisFile))
+ if (poc != curPoc || feof(m_analysisFileIn))
{
x265_log(NULL, X265_LOG_WARNING, "Error reading analysis data: Cannot find POC %d\n", curPoc);
freeAnalysis(analysis);
@@ -3302,15 +3313,15 @@
/* Now arrived at the right frame, read the record */
analysis->poc = poc;
analysis->frameRecordSize = frameRecordSize;
- X265_FREAD(&analysis->sliceType, sizeof(int), 1, m_analysisFile, &(picData->sliceType));
- X265_FREAD(&analysis->bScenecut, sizeof(int), 1, m_analysisFile, &(picData->bScenecut));
- X265_FREAD(&analysis->satdCost, sizeof(int64_t), 1, m_analysisFile, &(picData->satdCost));
- X265_FREAD(&analysis->numCUsInFrame, sizeof(int), 1, m_analysisFile, &(picData->numCUsInFrame));
- X265_FREAD(&analysis->numPartitions, sizeof(int), 1, m_analysisFile, &(picData->numPartitions));
+ X265_FREAD(&analysis->sliceType, sizeof(int), 1, m_analysisFileIn, &(picData->sliceType));
+ X265_FREAD(&analysis->bScenecut, sizeof(int), 1, m_analysisFileIn, &(picData->bScenecut));
+ X265_FREAD(&analysis->satdCost, sizeof(int64_t), 1, m_analysisFileIn, &(picData->satdCost));
+ X265_FREAD(&analysis->numCUsInFrame, sizeof(int), 1, m_analysisFileIn, &(picData->numCUsInFrame));
+ X265_FREAD(&analysis->numPartitions, sizeof(int), 1, m_analysisFileIn, &(picData->numPartitions));
if (m_param->bDisableLookahead)
{
- X265_FREAD(&analysis->numCuInHeight, sizeof(uint32_t), 1, m_analysisFile, &(picData->numCuInHeight));
- X265_FREAD(&analysis->lookahead, sizeof(x265_lookahead_data), 1, m_analysisFile, &(picData->lookahead));
+ X265_FREAD(&analysis->numCuInHeight, sizeof(uint32_t), 1, m_analysisFileIn, &(picData->numCuInHeight));
+ X265_FREAD(&analysis->lookahead, sizeof(x265_lookahead_data), 1, m_analysisFileIn, &(picData->lookahead));
}
int scaledNumPartition = analysis->numPartitions;
int factor = 1 << m_param->scaleFactor;
@@ -3321,10 +3332,10 @@
allocAnalysis(analysis);
if (m_param->bDisableLookahead && m_rateControl->m_isVbv)
{
- X265_FREAD(analysis->lookahead.intraVbvCost, sizeof(uint32_t), analysis->numCUsInFrame, m_analysisFile, picData->lookahead.intraVbvCost);
- X265_FREAD(analysis->lookahead.vbvCost, sizeof(uint32_t), analysis->numCUsInFrame, m_analysisFile, picData->lookahead.vbvCost);
- X265_FREAD(analysis->lookahead.satdForVbv, sizeof(uint32_t), analysis->numCuInHeight, m_analysisFile, picData->lookahead.satdForVbv);
- X265_FREAD(analysis->lookahead.intraSatdForVbv, sizeof(uint32_t), analysis->numCuInHeight, m_analysisFile, picData->lookahead.intraSatdForVbv);
+ X265_FREAD(analysis->lookahead.intraVbvCost, sizeof(uint32_t), analysis->numCUsInFrame, m_analysisFileIn, picData->lookahead.intraVbvCost);
+ X265_FREAD(analysis->lookahead.vbvCost, sizeof(uint32_t), analysis->numCUsInFrame, m_analysisFileIn, picData->lookahead.vbvCost);
+ X265_FREAD(analysis->lookahead.satdForVbv, sizeof(uint32_t), analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.satdForVbv);
+ X265_FREAD(analysis->lookahead.intraSatdForVbv, sizeof(uint32_t), analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.intraSatdForVbv);
}
if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == X265_TYPE_I)
{
@@ -3338,9 +3349,9 @@
modeBuf = tempBuf + depthBytes;
partSizes = tempBuf + 2 * depthBytes;
- X265_FREAD(depthBuf, sizeof(uint8_t), depthBytes, m_analysisFile, intraPic->depth);
- X265_FREAD(modeBuf, sizeof(uint8_t), depthBytes, m_analysisFile, intraPic->chromaModes);
- X265_FREAD(partSizes, sizeof(uint8_t), depthBytes, m_analysisFile, intraPic->partSizes);
+ X265_FREAD(depthBuf, sizeof(uint8_t), depthBytes, m_analysisFileIn, intraPic->depth);
+ X265_FREAD(modeBuf, sizeof(uint8_t), depthBytes, m_analysisFileIn, intraPic->chromaModes);
+ X265_FREAD(partSizes, sizeof(uint8_t), depthBytes, m_analysisFileIn, intraPic->partSizes);
size_t count = 0;
for (uint32_t d = 0; d < depthBytes; d++)
@@ -3361,12 +3372,12 @@
if (!m_param->scaleFactor)
{
- X265_FREAD(((analysis_intra_data *)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFile, intraPic->modes);
+ X265_FREAD(((analysis_intra_data *)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFileIn, intraPic->modes);
}
else
{
uint8_t *tempLumaBuf = X265_MALLOC(uint8_t, analysis->numCUsInFrame * scaledNumPartition);
- X265_FREAD(tempLumaBuf, sizeof(uint8_t), analysis->numCUsInFrame * scaledNumPartition, m_analysisFile, intraPic->modes);
+ X265_FREAD(tempLumaBuf, sizeof(uint8_t), analysis->numCUsInFrame * scaledNumPartition, m_analysisFileIn, intraPic->modes);
for (uint32_t ctu32Idx = 0, cnt = 0; ctu32Idx < analysis->numCUsInFrame * scaledNumPartition; ctu32Idx++, cnt += factor)
memset(&((analysis_intra_data *)analysis->intraData)->modes[cnt], tempLumaBuf[ctu32Idx], factor);
X265_FREE(tempLumaBuf);
@@ -3379,7 +3390,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));
+ X265_FREAD((WeightParam*)analysis->wt, sizeof(WeightParam), numPlanes * numDir, m_analysisFileIn, (picIn->analysisData.wt));
if (m_param->analysisReuseLevel < 2)
return;
@@ -3401,33 +3412,33 @@
depthBuf = tempBuf;
modeBuf = tempBuf + depthBytes;
- X265_FREAD(depthBuf, sizeof(uint8_t), depthBytes, m_analysisFile, interPic->depth);
- X265_FREAD(modeBuf, sizeof(uint8_t), depthBytes, m_analysisFile, interPic->modes);
+ X265_FREAD(depthBuf, sizeof(uint8_t), depthBytes, m_analysisFileIn, interPic->depth);
+ X265_FREAD(modeBuf, sizeof(uint8_t), depthBytes, m_analysisFileIn, interPic->modes);
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);
+ X265_FREAD(partSize, sizeof(uint8_t), depthBytes, m_analysisFileIn, interPic->partSize);
+ X265_FREAD(mergeFlag, sizeof(uint8_t), depthBytes, m_analysisFileIn, interPic->mergeFlag);
if (m_param->analysisReuseLevel == 10)
{
interDir = mergeFlag + depthBytes;
- X265_FREAD(interDir, sizeof(uint8_t), depthBytes, m_analysisFile, interPic->interDir);
+ X265_FREAD(interDir, sizeof(uint8_t), depthBytes, m_analysisFileIn, interPic->interDir);
if (bIntraInInter)
{
chromaDir = interDir + depthBytes;
- X265_FREAD(chromaDir, sizeof(uint8_t), depthBytes, m_analysisFile, intraPic->chromaModes);
+ X265_FREAD(chromaDir, sizeof(uint8_t), depthBytes, m_analysisFileIn, intraPic->chromaModes);
}
for (uint32_t i = 0; i < numDir; i++)
{
mvpIdx[i] = X265_MALLOC(uint8_t, depthBytes);
refIdx[i] = X265_MALLOC(int8_t, depthBytes);
mv[i] = X265_MALLOC(MV, depthBytes);
- X265_FREAD(mvpIdx[i], sizeof(uint8_t), depthBytes, m_analysisFile, interPic->mvpIdx[i]);
- X265_FREAD(refIdx[i], sizeof(int8_t), depthBytes, m_analysisFile, interPic->refIdx[i]);
- X265_FREAD(mv[i], sizeof(MV), depthBytes, m_analysisFile, interPic->mv[i]);
+ X265_FREAD(mvpIdx[i], sizeof(uint8_t), depthBytes, m_analysisFileIn, interPic->mvpIdx[i]);
+ X265_FREAD(refIdx[i], sizeof(int8_t), depthBytes, m_analysisFileIn, interPic->refIdx[i]);
+ X265_FREAD(mv[i], sizeof(MV), depthBytes, m_analysisFileIn, interPic->mv[i]);
}
}
}
@@ -3486,12 +3497,12 @@
{
if (!m_param->scaleFactor)
{
- X265_FREAD(((analysis_intra_data *)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFile, intraPic->modes);
+ X265_FREAD(((analysis_intra_data *)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFileIn, intraPic->modes);
}
else
{
uint8_t *tempLumaBuf = X265_MALLOC(uint8_t, analysis->numCUsInFrame * scaledNumPartition);
- X265_FREAD(tempLumaBuf, sizeof(uint8_t), analysis->numCUsInFrame * scaledNumPartition, m_analysisFile, intraPic->modes);
+ X265_FREAD(tempLumaBuf, sizeof(uint8_t), analysis->numCUsInFrame * scaledNumPartition, m_analysisFileIn, intraPic->modes);
for (uint32_t ctu32Idx = 0, cnt = 0; ctu32Idx < analysis->numCUsInFrame * scaledNumPartition; ctu32Idx++, cnt += factor)
memset(&((analysis_intra_data *)analysis->intraData)->modes[cnt], tempLumaBuf[ctu32Idx], factor);
X265_FREE(tempLumaBuf);
@@ -3499,7 +3510,7 @@
}
}
else
- X265_FREAD(((analysis_inter_data *)analysis->interData)->ref, sizeof(int32_t), analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir, m_analysisFile, interPic->ref);
+ X265_FREAD(((analysis_inter_data *)analysis->interData)->ref, sizeof(int32_t), analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir, m_analysisFileIn, interPic->ref);
consumedBytes += frameRecordSize;
if (numDir == 1)
@@ -3774,51 +3785,51 @@
if (!m_param->bUseAnalysisFile)
return;
- X265_FWRITE(&analysis->frameRecordSize, sizeof(uint32_t), 1, m_analysisFile);
- X265_FWRITE(&depthBytes, sizeof(uint32_t), 1, m_analysisFile);
- X265_FWRITE(&analysis->poc, sizeof(int), 1, m_analysisFile);
- X265_FWRITE(&analysis->sliceType, sizeof(int), 1, m_analysisFile);
- X265_FWRITE(&analysis->bScenecut, sizeof(int), 1, m_analysisFile);
- X265_FWRITE(&analysis->satdCost, sizeof(int64_t), 1, m_analysisFile);
- X265_FWRITE(&analysis->numCUsInFrame, sizeof(int), 1, m_analysisFile);
- X265_FWRITE(&analysis->numPartitions, sizeof(int), 1, m_analysisFile);
+ X265_FWRITE(&analysis->frameRecordSize, sizeof(uint32_t), 1, m_analysisFileOut);
+ X265_FWRITE(&depthBytes, sizeof(uint32_t), 1, m_analysisFileOut);
+ X265_FWRITE(&analysis->poc, sizeof(int), 1, m_analysisFileOut);
+ X265_FWRITE(&analysis->sliceType, sizeof(int), 1, m_analysisFileOut);
+ X265_FWRITE(&analysis->bScenecut, sizeof(int), 1, m_analysisFileOut);
+ X265_FWRITE(&analysis->satdCost, sizeof(int64_t), 1, m_analysisFileOut);
+ X265_FWRITE(&analysis->numCUsInFrame, sizeof(int), 1, m_analysisFileOut);
+ X265_FWRITE(&analysis->numPartitions, sizeof(int), 1, m_analysisFileOut);
if (analysis->sliceType > X265_TYPE_I)
- X265_FWRITE((WeightParam*)analysis->wt, sizeof(WeightParam), numPlanes * numDir, m_analysisFile);
+ X265_FWRITE((WeightParam*)analysis->wt, sizeof(WeightParam), numPlanes * numDir, m_analysisFileOut);
if (m_param->analysisReuseLevel < 2)
return;
if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == X265_TYPE_I)
{
- X265_FWRITE(((analysis_intra_data*)analysis->intraData)->depth, sizeof(uint8_t), depthBytes, m_analysisFile);
- X265_FWRITE(((analysis_intra_data*)analysis->intraData)->chromaModes, sizeof(uint8_t), depthBytes, m_analysisFile);
- X265_FWRITE(((analysis_intra_data*)analysis->intraData)->partSizes, sizeof(char), depthBytes, m_analysisFile);
- X265_FWRITE(((analysis_intra_data*)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFile);
+ X265_FWRITE(((analysis_intra_data*)analysis->intraData)->depth, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE(((analysis_intra_data*)analysis->intraData)->chromaModes, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE(((analysis_intra_data*)analysis->intraData)->partSizes, sizeof(char), depthBytes, m_analysisFileOut);
+ X265_FWRITE(((analysis_intra_data*)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFileOut);
}
else
{
- 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);
+ X265_FWRITE(((analysis_inter_data*)analysis->interData)->depth, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE(((analysis_inter_data*)analysis->interData)->modes, sizeof(uint8_t), depthBytes, m_analysisFileOut);
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);
+ X265_FWRITE(((analysis_inter_data*)analysis->interData)->partSize, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE(((analysis_inter_data*)analysis->interData)->mergeFlag, sizeof(uint8_t), depthBytes, m_analysisFileOut);
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);
+ X265_FWRITE(((analysis_inter_data*)analysis->interData)->interDir, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ if (bIntraInInter) X265_FWRITE(((analysis_intra_data*)analysis->intraData)->chromaModes, sizeof(uint8_t), depthBytes, m_analysisFileOut);
for (uint32_t dir = 0; dir < numDir; dir++)
{
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->mvpIdx[dir], sizeof(uint8_t), depthBytes, m_analysisFile);
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->refIdx[dir], sizeof(int8_t), depthBytes, m_analysisFile);
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->mv[dir], sizeof(MV), depthBytes, m_analysisFile);
+ X265_FWRITE(((analysis_inter_data*)analysis->interData)->mvpIdx[dir], sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE(((analysis_inter_data*)analysis->interData)->refIdx[dir], sizeof(int8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE(((analysis_inter_data*)analysis->interData)->mv[dir], sizeof(MV), depthBytes, m_analysisFileOut);
}
if (bIntraInInter)
- X265_FWRITE(((analysis_intra_data*)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFile);
+ X265_FWRITE(((analysis_intra_data*)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFileOut);
}
}
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);
+ X265_FWRITE(((analysis_inter_data*)analysis->interData)->ref, sizeof(int32_t), analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir, m_analysisFileOut);
}
#undef X265_FWRITE
diff -r 37f6c378ac90 -r a3334a263d26 source/encoder/encoder.h
--- a/source/encoder/encoder.h Thu Dec 14 16:53:44 2017 +0530
+++ b/source/encoder/encoder.h Thu Dec 21 15:26:55 2017 +0530
@@ -130,7 +130,6 @@
FrameEncoder* m_frameEncoder[X265_MAX_FRAME_THREADS];
DPB* m_dpb;
Frame* m_exportedPic;
- FILE* m_analysisFile;
FILE* m_analysisFileIn;
FILE* m_analysisFileOut;
x265_param* m_param;
diff -r 37f6c378ac90 -r a3334a263d26 source/encoder/frameencoder.cpp
--- a/source/encoder/frameencoder.cpp Thu Dec 14 16:53:44 2017 +0530
+++ b/source/encoder/frameencoder.cpp Thu Dec 21 15:26:55 2017 +0530
@@ -335,7 +335,7 @@
while (!m_frame->m_ctuInfo)
m_frame->m_copied.wait();
}
- if ((m_param->bMVType == AVC_INFO) && !m_param->analysisReuseMode && !(IS_X265_TYPE_I(m_frame->m_lowres.sliceType)))
+ if ((m_param->bMVType == AVC_INFO) && !m_param->analysisSave && !m_param->analysisLoad && !(IS_X265_TYPE_I(m_frame->m_lowres.sliceType)))
{
while (((m_frame->m_analysisData.interData == NULL && m_frame->m_analysisData.intraData == NULL) || (uint32_t)m_frame->m_poc != m_frame->m_analysisData.poc))
m_frame->m_copyMVType.wait();
@@ -430,7 +430,7 @@
bool bUseWeightB = slice->m_sliceType == B_SLICE && slice->m_pps->bUseWeightedBiPred;
WeightParam* reuseWP = NULL;
- if (m_param->analysisReuseMode && (bUseWeightP || bUseWeightB))
+ if (m_param->analysisLoad && (bUseWeightP || bUseWeightB))
reuseWP = (WeightParam*)m_frame->m_analysisData.wt;
if (bUseWeightP || bUseWeightB)
@@ -439,7 +439,7 @@
m_cuStats.countWeightAnalyze++;
ScopedElapsedTime time(m_cuStats.weightAnalyzeTime);
#endif
- if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD)
+ if (m_param->analysisLoad)
{
for (int list = 0; list < slice->isInterB() + 1; list++)
{
@@ -466,6 +466,8 @@
else
slice->disableWeights();
+ if (m_param->analysisSave && (bUseWeightP || bUseWeightB))
+ reuseWP = (WeightParam*)m_frame->m_analysisData.wt;
// Generate motion references
int numPredDir = slice->isInterP() ? 1 : slice->isInterB() ? 2 : 0;
for (int l = 0; l < numPredDir; l++)
@@ -478,7 +480,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->analysisReuseMode == X265_ANALYSIS_SAVE && (bUseWeightP || bUseWeightB))
+ if (m_param->analysisSave && (bUseWeightP || bUseWeightB))
{
for (int i = 0; i < (m_param->internalCsp != X265_CSP_I400 ? 3 : 1); i++)
*(reuseWP++) = slice->m_weightPredTable[l][0][i];
@@ -1411,7 +1413,7 @@
/* TODO: use defines from slicetype.h for lowres block size */
uint32_t block_y = (ctu->m_cuPelY >> m_param->maxLog2CUSize) * noOfBlocks;
uint32_t block_x = (ctu->m_cuPelX >> m_param->maxLog2CUSize) * noOfBlocks;
- if (m_param->analysisReuseMode != X265_ANALYSIS_LOAD || !m_param->bDisableLookahead)
+ if (!m_param->analysisLoad || !m_param->bDisableLookahead)
{
cuStat.vbvCost = 0;
cuStat.intraVbvCost = 0;
diff -r 37f6c378ac90 -r a3334a263d26 source/encoder/search.cpp
--- a/source/encoder/search.cpp Thu Dec 14 16:53:44 2017 +0530
+++ b/source/encoder/search.cpp Thu Dec 21 15:26:55 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->analysisReuseMode) /* Prevents load/save outputs from diverging if lowresMV is not available */
+ if (!m_param->analysisSave && !m_param->analysisLoad) /* 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->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
+ if ((m_param->analysisLoad && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
|| (m_param->analysisMultiPassRefine && m_param->rc.bStatRead) || (m_param->bMVType == AVC_INFO))
{
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->analysisReuseMode) /* Prevents load/save outputs from diverging when lowresMV is not available */
+ if (!m_param->analysisSave && !m_param->analysisLoad) /* Prevents load/save outputs from diverging when lowresMV is not available */
{
MV lmv = getLowresMV(cu, pu, list, ref);
if (lmv.notZero())
diff -r 37f6c378ac90 -r a3334a263d26 source/encoder/slicetype.cpp
--- a/source/encoder/slicetype.cpp Thu Dec 14 16:53:44 2017 +0530
+++ b/source/encoder/slicetype.cpp Thu Dec 21 15:26:55 2017 +0530
@@ -746,7 +746,7 @@
/* Called by API thread */
void Lookahead::addPicture(Frame& curFrame, int sliceType)
{
- if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->bDisableLookahead)
+ if (m_param->analysisLoad && m_param->bDisableLookahead)
{
if (!m_filled)
m_filled = true;
@@ -847,7 +847,7 @@
return out;
}
- if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->bDisableLookahead)
+ if (m_param->analysisLoad && m_param->bDisableLookahead)
return NULL;
findJob(-1); /* run slicetypeDecide() if necessary */
@@ -906,13 +906,13 @@
default:
return;
}
- if (m_param->analysisReuseMode != X265_ANALYSIS_LOAD || !m_param->bDisableLookahead)
+ if (!m_param->analysisLoad || !m_param->bDisableLookahead)
{
X265_CHECK(curFrame->m_lowres.costEst[b - p0][p1 - b] > 0, "Slice cost not estimated\n")
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->analysisReuseMode != X265_ANALYSIS_LOAD || m_param->scaleFactor)
+ else if (!m_param->analysisLoad || m_param->scaleFactor)
{
if (m_param->rc.aqMode)
curFrame->m_lowres.satdCost = curFrame->m_lowres.costEstAq[b - p0][p1 - b];
@@ -1056,7 +1056,7 @@
{
slicetypeAnalyse(frames, false);
bool bIsVbv = m_param->rc.vbvBufferSize > 0 && m_param->rc.vbvMaxBitrate > 0;
- if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->scaleFactor && bIsVbv)
+ if (m_param->analysisLoad && m_param->scaleFactor && bIsVbv)
{
int numFrames;
for (numFrames = 0; numFrames < maxSearch; numFrames++)
@@ -1252,7 +1252,7 @@
frames[j + 1] = NULL;
slicetypeAnalyse(frames, true);
bool bIsVbv = m_param->rc.vbvBufferSize > 0 && m_param->rc.vbvMaxBitrate > 0;
- if (m_param->analysisReuseMode == X265_ANALYSIS_LOAD && m_param->scaleFactor && bIsVbv)
+ if (m_param->analysisLoad && m_param->scaleFactor && bIsVbv)
{
int numFrames;
for (numFrames = 0; numFrames < maxSearch; numFrames++)
diff -r 37f6c378ac90 -r a3334a263d26 source/test/regression-tests.txt
--- a/source/test/regression-tests.txt Thu Dec 14 16:53:44 2017 +0530
+++ b/source/test/regression-tests.txt Thu Dec 21 15:26:55 2017 +0530
@@ -18,17 +18,17 @@
BasketballDrive_1920x1080_50.y4m,--preset faster --aq-strength 2 --merange 190 --slices 3
BasketballDrive_1920x1080_50.y4m,--preset medium --ctu 16 --max-tu-size 8 --subme 7 --qg-size 16 --cu-lossless --tu-inter-depth 3 --limit-tu 1
BasketballDrive_1920x1080_50.y4m,--preset medium --keyint -1 --nr-inter 100 -F4 --no-sao
-BasketballDrive_1920x1080_50.y4m,--preset medium --no-cutree --analysis-reuse-mode=save --analysis-reuse-level 2 --bitrate 7000 --limit-modes::--preset medium --no-cutree --analysis-reuse-mode=load --analysis-reuse-level 2 --bitrate 7000 --limit-modes
+BasketballDrive_1920x1080_50.y4m,--preset medium --no-cutree --analysis-save x265_analysis.dat --analysis-reuse-level 2 --bitrate 7000 --limit-modes::--preset medium --no-cutree --analysis-load x265_analysis.dat --analysis-reuse-level 2 --bitrate 7000 --limit-modes
BasketballDrive_1920x1080_50.y4m,--preset slow --nr-intra 100 -F4 --aq-strength 3 --qg-size 16 --limit-refs 1
BasketballDrive_1920x1080_50.y4m,--preset slower --lossless --chromaloc 3 --subme 0 --limit-tu 4
-BasketballDrive_1920x1080_50.y4m,--preset slower --no-cutree --analysis-reuse-mode=save --analysis-reuse-level 10 --bitrate 7000 --limit-tu 0::--preset slower --no-cutree --analysis-reuse-mode=load --analysis-reuse-level 10 --bitrate 7000 --limit-tu 0
+BasketballDrive_1920x1080_50.y4m,--preset slower --no-cutree --analysis-save x265_analysis.dat --analysis-reuse-level 10 --bitrate 7000 --limit-tu 0::--preset slower --no-cutree --analysis-load x265_analysis.dat --analysis-reuse-level 10 --bitrate 7000 --limit-tu 0
BasketballDrive_1920x1080_50.y4m,--preset veryslow --crf 4 --cu-lossless --pmode --limit-refs 1 --aq-mode 3 --limit-tu 3
-BasketballDrive_1920x1080_50.y4m,--preset veryslow --no-cutree --analysis-reuse-mode=save --bitrate 7000 --tskip-fast --limit-tu 4::--preset veryslow --no-cutree --analysis-reuse-mode=load --bitrate 7000 --tskip-fast --limit-tu 4
+BasketballDrive_1920x1080_50.y4m,--preset veryslow --no-cutree --analysis-save x265_analysis.dat --bitrate 7000 --tskip-fast --limit-tu 4::--preset veryslow --no-cutree --analysis-load x265_analysis.dat --bitrate 7000 --tskip-fast --limit-tu 4
BasketballDrive_1920x1080_50.y4m,--preset veryslow --recon-y4m-exec "ffplay -i pipe:0 -autoexit"
Coastguard-4k.y4m,--preset ultrafast --recon-y4m-exec "ffplay -i pipe:0 -autoexit"
Coastguard-4k.y4m,--preset superfast --tune grain --overscan=crop
Coastguard-4k.y4m,--preset superfast --tune grain --pme --aq-strength 2 --merange 190
-Coastguard-4k.y4m,--preset veryfast --no-cutree --analysis-reuse-mode=save --analysis-reuse-level 1 --bitrate 15000::--preset veryfast --no-cutree --analysis-reuse-mode=load --analysis-reuse-level 1 --bitrate 15000
+Coastguard-4k.y4m,--preset veryfast --no-cutree --analysis-save x265_analysis.dat --analysis-reuse-level 1 --bitrate 15000::--preset veryfast --no-cutree --analysis-load x265_analysis.dat --analysis-reuse-level 1 --bitrate 15000
Coastguard-4k.y4m,--preset medium --rdoq-level 1 --tune ssim --no-signhide --me umh --slices 2
Coastguard-4k.y4m,--preset slow --tune psnr --cbqpoffs -1 --crqpoffs 1 --limit-refs 1
CrowdRun_1920x1080_50_10bit_422.yuv,--preset ultrafast --weightp --tune zerolatency --qg-size 16
@@ -52,7 +52,7 @@
DucksAndLegs_1920x1080_60_10bit_444.yuv,--preset veryfast --weightp --nr-intra 1000 -F4
DucksAndLegs_1920x1080_60_10bit_444.yuv,--preset medium --nr-inter 500 -F4 --no-psy-rdoq
DucksAndLegs_1920x1080_60_10bit_444.yuv,--preset slower --no-weightp --rdoq-level 0 --limit-refs 3 --tu-inter-depth 4 --limit-tu 3
-DucksAndLegs_1920x1080_60_10bit_422.yuv,--preset fast --no-cutree --analysis-reuse-mode=save --bitrate 3000 --early-skip --tu-inter-depth 3 --limit-tu 1::--preset fast --no-cutree --analysis-reuse-mode=load --bitrate 3000 --early-skip --tu-inter-depth 3 --limit-tu 1
+DucksAndLegs_1920x1080_60_10bit_422.yuv,--preset fast --no-cutree --analysis-save x265_analysis.dat --bitrate 3000 --early-skip --tu-inter-depth 3 --limit-tu 1::--preset fast --no-cutree --analysis-load x265_analysis.dat --bitrate 3000 --early-skip --tu-inter-depth 3 --limit-tu 1
FourPeople_1280x720_60.y4m,--preset superfast --no-wpp --lookahead-slices 2
FourPeople_1280x720_60.y4m,--preset veryfast --aq-mode 2 --aq-strength 1.5 --qg-size 8
FourPeople_1280x720_60.y4m,--preset medium --qp 38 --no-psy-rd
@@ -69,8 +69,8 @@
KristenAndSara_1280x720_60.y4m,--preset slower --pmode --max-tu-size 8 --limit-refs 0 --limit-modes --limit-tu 1
NebutaFestival_2560x1600_60_10bit_crop.yuv,--preset superfast --tune psnr
NebutaFestival_2560x1600_60_10bit_crop.yuv,--preset medium --tune grain --limit-refs 2
-NebutaFestival_2560x1600_60_10bit_crop.yuv,--preset slow --no-cutree --analysis-reuse-mode=save --rd 5 --analysis-reuse-level 10 --bitrate 9000::--preset slow --no-cutree --analysis-reuse-mode=load --rd 5 --analysis-reuse-level 10 --bitrate 9000
-News-4k.y4m,--preset ultrafast --no-cutree --analysis-reuse-mode=save --analysis-reuse-level 2 --bitrate 15000::--preset ultrafast --no-cutree --analysis-reuse-mode=load --analysis-reuse-level 2 --bitrate 15000
+NebutaFestival_2560x1600_60_10bit_crop.yuv,--preset slow --no-cutree --analysis-save x265_analysis.dat --rd 5 --analysis-reuse-level 10 --bitrate 9000::--preset slow --no-cutree --analysis-load x265_analysis.dat --rd 5 --analysis-reuse-level 10 --bitrate 9000
+News-4k.y4m,--preset ultrafast --no-cutree --analysis-save x265_analysis.dat --analysis-reuse-level 2 --bitrate 15000::--preset ultrafast --no-cutree --analysis-load x265_analysis.dat --analysis-reuse-level 2 --bitrate 15000
News-4k.y4m,--preset superfast --lookahead-slices 6 --aq-mode 0
News-4k.y4m,--preset superfast --slices 4 --aq-mode 0
News-4k.y4m,--preset medium --tune ssim --no-sao --qg-size 16
@@ -125,7 +125,7 @@
old_town_cross_444_720p50.y4m,--preset superfast --weightp --min-cu 16 --limit-modes
old_town_cross_444_720p50.y4m,--preset veryfast --qp 1 --tune ssim
old_town_cross_444_720p50.y4m,--preset faster --rd 1 --tune zero-latency
-old_town_cross_444_720p50.y4m,--preset fast --no-cutree --analysis-reuse-mode=save --analysis-reuse-level 1 --bitrate 3000 --early-skip::--preset fast --no-cutree --analysis-reuse-mode=load --analysis-reuse-level 1 --bitrate 3000 --early-skip
+old_town_cross_444_720p50.y4m,--preset fast --no-cutree --analysis-save pass1_analysis.dat --analysis-reuse-level 1 --bitrate 3000 --early-skip::--preset fast --no-cutree --analysis-load pass1_analysis.dat --analysis-save pass2_analysis.dat --analysis-reuse-level 1 --bitrate 3000 --early-skip::--preset fast --no-cutree --analysis-load pass2_analysis.dat --analysis-reuse-level 1 --bitrate 3000 --early-skip
old_town_cross_444_720p50.y4m,--preset medium --keyint -1 --no-weightp --ref 6
old_town_cross_444_720p50.y4m,--preset slow --rdoq-level 1 --early-skip --ref 7 --no-b-pyramid
old_town_cross_444_720p50.y4m,--preset slower --crf 4 --cu-lossless
@@ -151,6 +151,7 @@
Kimono1_1920x1080_24_400.yuv,--preset veryslow --crf 4 --cu-lossless --slices 2 --limit-refs 3 --limit-modes
Kimono1_1920x1080_24_400.yuv,--preset placebo --ctu 32 --max-tu-size 8 --limit-tu 2
big_buck_bunny_360p24.y4m, --keyint 60 --min-keyint 40 --gop-lookahead 14
+
# Main12 intraCost overflow bug test
720p50_parkrun_ter.y4m,--preset medium
diff -r 37f6c378ac90 -r a3334a263d26 source/x265.cpp
--- a/source/x265.cpp Thu Dec 14 16:53:44 2017 +0530
+++ b/source/x265.cpp Thu Dec 21 15:26:55 2017 +0530
@@ -585,9 +585,9 @@
x265_picture pic_orig, pic_out;
x265_picture *pic_in = &pic_orig;
- /* Allocate recon picture if analysisReuseMode is enabled */
+ /* Allocate recon picture if analysis save/load 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->analysisReuseMode || pts_queue || reconPlay || param->csvLogLevel) ? &pic_out : NULL;
+ x265_picture *pic_recon = (cliopt.recon || param->analysisSave || param->analysisLoad || pts_queue || reconPlay || param->csvLogLevel) ? &pic_out : NULL;
uint32_t inFrameCount = 0;
uint32_t outFrameCount = 0;
x265_nal *p_nal;
diff -r 37f6c378ac90 -r a3334a263d26 source/x265.h
--- a/source/x265.h Thu Dec 14 16:53:44 2017 +0530
+++ b/source/x265.h Thu Dec 21 15:26:55 2017 +0530
@@ -327,15 +327,15 @@
* to allow the encoder to determine base QP */
int forceqp;
- /* 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.
+ /* If param.analysisLoad and param.analysisSave are disabled, 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.analysisReuseMode is X265_ANALYSIS_LOAD and analysisData
+ * On input when param.analysisLoad is enabled and analysisData
* member pointers are valid, the encoder will use the data stored here to
* reduce encoder work.
*
- * On output when param.analysisReuseMode is X265_ANALYSIS_SAVE and analysisData
+ * On output when param.analysisSave is enabled and analysisData
* member pointers are valid, the encoder will write output analysis into
* this data structure */
x265_analysis_data analysisData;
@@ -484,11 +484,6 @@
#define X265_EXTENDED_SAR 255 /* aspect ratio explicitly specified as width:height */
-/* Analysis options */
-#define X265_ANALYSIS_OFF 0
-#define X265_ANALYSIS_SAVE 1
-#define X265_ANALYSIS_LOAD 2
-
typedef struct x265_cli_csp
{
int planes;
@@ -1129,13 +1124,13 @@
* Default disabled */
int bEnableRdRefine;
- /* If X265_ANALYSIS_SAVE, write per-frame analysis information into analysis
- * 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 */
+ /* If save, write per-frame analysis information into analysis buffers.
+ * If load, read analysis information into analysis buffer and use this
+ * analysis information to reduce the amount of work the encoder must perform.
+ * Default disabled. Now deprecated*/
int analysisReuseMode;
- /* Filename for analysisReuseMode save/load. Default name is "x265_analysis.dat" */
+ /* Filename for multi-pass-opt-analysis/distortion. Default name is "x265_analysis.dat" */
const char* analysisReuseFileName;
/*== Rate Control ==*/
@@ -1455,7 +1450,7 @@
int bHDROpt;
/* A value between 1 and 10 (both inclusive) determines the level of
- * information stored/reused in save/load analysis-reuse-mode. Higher the refine
+ * information stored/reused in analysis save/load. Higher the refine
* level higher the information stored/reused. Default is 5 */
int analysisReuseLevel;
@@ -1539,7 +1534,16 @@
* within this from the gop boundary set by keyint, the GOP will be extented until such a point,
* otherwise the GOP will be terminated as set by keyint*/
int gopLookahead;
+
+ /*Write per-frame analysis information into analysis buffers. Default disabled. */
+ const char* analysisSave;
+
+ /* Read analysis information into analysis buffer and use this analysis information
+ * to reduce the amount of work the encoder must perform. Default disabled. */
+ const char* analysisLoad;
+
} x265_param;
+
/* x265_param_alloc:
* Allocates an x265_param instance. The returned param structure is not
* special in any way, but using this method together with x265_param_free()
diff -r 37f6c378ac90 -r a3334a263d26 source/x265cli.h
--- a/source/x265cli.h Thu Dec 14 16:53:44 2017 +0530
+++ b/source/x265cli.h Thu Dec 21 15:26:55 2017 +0530
@@ -254,9 +254,11 @@
{ "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-reuse-mode", required_argument, NULL, 0 },
- { "analysis-reuse-file", required_argument, NULL, 0 },
+ { "analysis-reuse-mode", required_argument, NULL, 0 }, /* DEPRECATED */
+ { "analysis-reuse-file", required_argument, NULL, 0 },
{ "analysis-reuse-level", required_argument, NULL, 0 },
+ { "analysis-save", required_argument, NULL, 0 },
+ { "analysis-load", required_argument, NULL, 0 },
{ "scale-factor", required_argument, NULL, 0 },
{ "refine-intra", required_argument, NULL, 0 },
{ "refine-inter", required_argument, NULL, 0 },
@@ -465,18 +467,19 @@
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-reuse-mode <string|int> save - Dump analysis info into file, load - Load analysis buffers from the file. Default %d\n", param->analysisReuseMode);
+ H0(" --analysis-save <filename> Dump analysis info into the specified file. Default Disabled\n");
+ H0(" --analysis-load <filename> Load analysis buffers from the file specified. Default Disabled\n");
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(" --refine-mv-type <string> Reuse MV information received through API call. Supported option is avc. Default disabled - %d\n", param->bMVType);
H0(" --scale-factor <int> Specify factor by which input video is scaled down for analysis save mode. Default %d\n", param->scaleFactor);
- H0(" --refine-intra <0..3> Enable intra refinement for encode that uses analysis-reuse-mode=load.\n"
+ H0(" --refine-intra <0..3> Enable intra refinement for encode that uses analysis-load.\n"
" - 0 : Forces both mode and depth from the save encode.\n"
" - 1 : Functionality of (0) + evaluate all intra modes at min-cu-size's depth when current depth is one smaller than min-cu-size's depth.\n"
" - 2 : Functionality of (1) + irrespective of size evaluate all angular modes when the save encode decides the best mode as angular.\n"
" - 3 : Functionality of (1) + irrespective of size evaluate all intra modes.\n"
" Default:%d\n", param->intraRefine);
- H0(" --refine-inter <0..3> Enable inter refinement for encode that uses analysis-reuse-mode=load.\n"
+ H0(" --refine-inter <0..3> Enable inter refinement for encode that uses analysis-load.\n"
" - 0 : Forces both mode and depth from the save encode.\n"
" - 1 : Functionality of (0) + evaluate all inter modes at min-cu-size's depth when current depth is one smaller than\n"
" min-cu-size's depth. When save encode decides the current block as skip(for all sizes) evaluate skip/merge.\n"
-------------- next part --------------
A non-text attachment was scrubbed...
Name: x265_clone.patch
Type: text/x-patch
Size: 67973 bytes
Desc: not available
URL: <http://mailman.videolan.org/pipermail/x265-devel/attachments/20171222/5cc7ee0c/attachment-0001.bin>
More information about the x265-devel
mailing list