[x265] [PATCH 1 of 3 x265] De-couple analysis reuse levels of --analysis-save and --analysis-load
Aruna Matheswaran
aruna at multicorewareinc.com
Mon Jan 13 07:40:45 CET 2020
On Mon, Jan 13, 2020 at 11:47 AM Kavitha Sampath <
kavitha at multicorewareinc.com> wrote:
>
> Patch looks good to me. Just a couple of comments.
>
> On Fri, Jan 10, 2020 at 5:22 PM Aruna Matheswaran <
> aruna at multicorewareinc.com> wrote:
>
>> # HG changeset patch
>> # User Aruna Matheswaran <aruna at multicorewareinc.com>
>> # Date 1578655868 -19800
>> # Fri Jan 10 17:01:08 2020 +0530
>> # Node ID a28fd843b302128cff31172fe140aac19f93ce80
>> # Parent 4fcd8f1701a6dd7a502c4e48f04a27bb397664cf
>> De-couple analysis reuse levels of --analysis-save and --analysis-load.
>>
>> Currently, analysis reuse level of the load encode has to be the same as
>> that of
>> the reuse level of the save encode. This commit de-couples the reuse level
>> constraints and let the load encode re-use a subset of the available
>> analysis
>> info.
>>
>> Two CLI and x265_param options are introduced to get the desired reuse
>> level
>> during save and load.
>>
>> The existing option --analysis-reuse-level is deprecated.
>>
>> diff -r 4fcd8f1701a6 -r a28fd843b302 doc/reST/cli.rst
>> --- a/doc/reST/cli.rst Fri Jan 10 14:16:04 2020 +0530
>> +++ b/doc/reST/cli.rst Fri Jan 10 17:01:08 2020 +0530
>> @@ -918,12 +918,14 @@
>> 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>
>> -
>> - Amount of information stored/reused in
>> :option:`--analysis-reuse-mode` is distributed across levels.
>> +.. option:: --analysis-save-reuse-level <1..10>,
>> --analysis-load-reuse-level <1..10>
>> +
>> + :option:`--analysis-save-reuse-level` denotes the amount of
>> information stored during :option:`--analysis-save` and
>> + :option:`--analysis-load-reuse-level` denotes the amount of
>> information reused during :option:`--analysis-load`.
>> Higher the value, higher the information stored/reused, faster
>> the encode. Default 5.
>
>
>> - Note that --analysis-reuse-level must be paired with
>> analysis-reuse-mode.
>> + Note that :option:`--analysis-save-reuse-level` and
>> :option:`--analysis-load-reuse-level` must be paired
>> + with :option:`--analysis-save` and :option:`--analysis-load`
>> respectively.
>>
>> +--------------+------------------------------------------+
>> | Level | Description |
>> diff -r 4fcd8f1701a6 -r a28fd843b302 source/CMakeLists.txt
>> --- a/source/CMakeLists.txt Fri Jan 10 14:16:04 2020 +0530
>> +++ b/source/CMakeLists.txt Fri Jan 10 17:01:08 2020 +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 186)
>> +set(X265_BUILD 187)
>> configure_file("${PROJECT_SOURCE_DIR}/x265.def.in"
>> "${PROJECT_BINARY_DIR}/x265.def")
>> configure_file("${PROJECT_SOURCE_DIR}/x265_config.h.in"
>> diff -r 4fcd8f1701a6 -r a28fd843b302 source/common/param.cpp
>> --- a/source/common/param.cpp Fri Jan 10 14:16:04 2020 +0530
>> +++ b/source/common/param.cpp Fri Jan 10 17:01:08 2020 +0530
>> @@ -321,7 +321,9 @@
>> param->bAQMotion = 0;
>> param->bHDROpt = 0; /*DEPRECATED*/
>> param->bHDR10Opt = 0;
>> - param->analysisReuseLevel = 5;
>> + param->analysisReuseLevel = 0; /*DEPRECATED*/
>> + param->analysisSaveReuseLevel = 0;
>> + param->analysisLoadReuseLevel = 0;
>> param->toneMapFile = NULL;
>> param->bDhdr10opt = 0;
>> param->dolbyProfile = 0;
>> @@ -1221,7 +1223,14 @@
>> OPT("multi-pass-opt-distortion") p->analysisMultiPassDistortion
>> = atobool(value);
>> OPT("aq-motion") p->bAQMotion = atobool(value);
>> OPT("dynamic-rd") p->dynamicRd = atof(value);
>> - OPT("analysis-reuse-level") p->analysisReuseLevel = atoi(value);
>> + OPT("analysis-reuse-level")
>> + {
>> + p->analysisReuseLevel = atoi(value);
>> + p->analysisSaveReuseLevel = atoi(value);
>> + p->analysisLoadReuseLevel = atoi(value);
>> + }
>> + OPT("analysis-save-reuse-level") p->analysisSaveReuseLevel =
>> atoi(value);
>> + OPT("analysis-load-reuse-level") p->analysisLoadReuseLevel =
>> atoi(value);
>> OPT("ssim-rd")
>> {
>> int bval = atobool(value);
>> @@ -1264,7 +1273,7 @@
>> }
>> else if (strcmp(strdup(value), "off") == 0)
>> {
>> - p->bAnalysisType = NO_INFO;
>> + p->bAnalysisType = DEFAULT;
>> }
>> else
>> {
>> @@ -1700,8 +1709,10 @@
>> "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->analysisSave || param->analysisLoad) &&
>> (param->analysisReuseLevel < 1 || param->analysisReuseLevel > 10),
>> - "Invalid analysis refine level. Value must be between 1 and 10
>> (inclusive)");
>> + CHECK(param->analysisSave && (param->analysisSaveReuseLevel < 1 ||
>> param->analysisSaveReuseLevel > 10),
>> + "Invalid analysis save refine level. Value must be between 1 and
>> 10 (inclusive)");
>> + CHECK(param->analysisLoad && (param->analysisLoadReuseLevel < 1 ||
>> param->analysisLoadReuseLevel > 10),
>> + "Invalid analysis load refine level. Value must be between 1 and
>> 10 (inclusive)");
>> CHECK(param->analysisLoad && (param->mvRefine < 1 || param->mvRefine
>> > 3),
>> "Invalid mv refinement level. Value must be between 1 and 3
>> (inclusive)");
>> CHECK(param->scaleFactor > 2, "Invalid scale-factor. Supports factor
>> <= 2");
>> @@ -2164,6 +2175,8 @@
>> if (p->analysisLoad)
>> s += sprintf(s, " analysis-load");
>> s += sprintf(s, " analysis-reuse-level=%d", p->analysisReuseLevel);
>> + s += sprintf(s, " analysis-save-reuse-level=%d",
>> p->analysisSaveReuseLevel);
>> + s += sprintf(s, " analysis-load-reuse-level=%d",
>> p->analysisLoadReuseLevel);
>> s += sprintf(s, " scale-factor=%d", p->scaleFactor);
>> s += sprintf(s, " refine-intra=%d", p->intraRefine);
>> s += sprintf(s, " refine-inter=%d", p->interRefine);
>> @@ -2482,6 +2495,8 @@
>> dst->bHDROpt = src->bHDROpt; /*DEPRECATED*/
>> dst->bHDR10Opt = src->bHDR10Opt;
>> dst->analysisReuseLevel = src->analysisReuseLevel;
>> + dst->analysisSaveReuseLevel = src->analysisSaveReuseLevel;
>> + dst->analysisLoadReuseLevel = src->analysisLoadReuseLevel;
>> dst->bLimitSAO = src->bLimitSAO;
>> if (src->toneMapFile) dst->toneMapFile = strdup(src->toneMapFile);
>> else dst->toneMapFile = NULL;
>> diff -r 4fcd8f1701a6 -r a28fd843b302 source/encoder/analysis.cpp
>> --- a/source/encoder/analysis.cpp Fri Jan 10 14:16:04 2020 +0530
>> +++ b/source/encoder/analysis.cpp Fri Jan 10 17:01:08 2020 +0530
>> @@ -202,14 +202,17 @@
>> m_reuseDepth = &m_reuseInterDataCTU->depth[ctu.m_cuAddr *
>> ctu.m_numPartitions];
>> }
>>
>> - if ((m_param->analysisSave || m_param->analysisLoad) &&
>> m_slice->m_sliceType != I_SLICE && m_param->analysisReuseLevel > 1 &&
>> m_param->analysisReuseLevel < 10)
>> + int reuseLevel = X265_MAX(m_param->analysisSaveReuseLevel,
>> m_param->analysisLoadReuseLevel);
>> + if ((m_param->analysisSave || m_param->analysisLoad) &&
>> m_slice->m_sliceType != I_SLICE && reuseLevel > 1 && reuseLevel < 10)
>> {
>> int numPredDir = m_slice->isInterP() ? 1 : 2;
>> m_reuseInterDataCTU = m_frame->m_analysisData.interData;
>> - m_reuseRef = &m_reuseInterDataCTU->ref [ctu.m_cuAddr *
>> X265_MAX_PRED_MODE_PER_CTU * numPredDir];
>> + if (((m_param->analysisSaveReuseLevel > 1) &&
>> (m_param->analysisSaveReuseLevel < 7)) ||
>> + ((m_param->analysisLoadReuseLevel > 1) &&
>> (m_param->analysisLoadReuseLevel < 7)))
>> + 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)
>> + if (reuseLevel > 4)
>> {
>> m_reusePartSize =
>> &m_reuseInterDataCTU->partSize[ctu.m_cuAddr * ctu.m_numPartitions];
>> m_reuseMergeFlag =
>> &m_reuseInterDataCTU->mergeFlag[ctu.m_cuAddr * ctu.m_numPartitions];
>> @@ -223,7 +226,7 @@
>> if (m_slice->m_sliceType == I_SLICE)
>> {
>> x265_analysis_intra_data* intraDataCTU =
>> m_frame->m_analysisData.intraData;
>> - if (m_param->analysisLoad && m_param->analysisReuseLevel > 1)
>> + if (m_param->analysisLoadReuseLevel > 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);
>> @@ -234,9 +237,9 @@
>> }
>> else
>> {
>> - bool bCopyAnalysis = ((m_param->analysisLoad &&
>> m_param->analysisReuseLevel == 10) || (m_param->bAnalysisType == AVC_INFO
>> && m_param->analysisReuseLevel >= 7 && ctu.m_numPartitions <= 16));
>> - bool BCompressInterCUrd0_4 = (m_param->bAnalysisType == AVC_INFO
>> && m_param->analysisReuseLevel >= 7 && m_param->rdLevel <= 4);
>> - bool BCompressInterCUrd5_6 = (m_param->bAnalysisType == AVC_INFO
>> && m_param->analysisReuseLevel >= 7 && m_param->rdLevel >= 5 &&
>> m_param->rdLevel <= 6);
>> + bool bCopyAnalysis = ((m_param->analysisLoadReuseLevel == 10) ||
>> (m_param->bAnalysisType == AVC_INFO && m_param->analysisLoadReuseLevel >= 7
>> && ctu.m_numPartitions <= 16));
>> + bool BCompressInterCUrd0_4 = (m_param->bAnalysisType == AVC_INFO
>> && m_param->analysisLoadReuseLevel >= 7 && m_param->rdLevel <= 4);
>> + bool BCompressInterCUrd5_6 = (m_param->bAnalysisType == AVC_INFO
>> && m_param->analysisLoadReuseLevel >= 7 && m_param->rdLevel >= 5 &&
>> m_param->rdLevel <= 6);
>>
> [KS] Can you rename these 2 bool variables? they do not follow the
> convention. I know your didn't was not the cause but can you fix?
>
[AM] Sure, will change.
> bCopyAnalysis = bCopyAnalysis || BCompressInterCUrd0_4 ||
>> BCompressInterCUrd5_6;
>>
>> if (bCopyAnalysis)
>> @@ -275,8 +278,8 @@
>> /* generate residual for entire CTU at once and copy to
>> reconPic */
>> encodeResidue(ctu, cuGeom);
>> }
>> - else if ((m_param->analysisLoad && m_param->analysisReuseLevel
>> == 10 && (!(m_param->bAnalysisType == HEVC_INFO) || m_slice->m_sliceType !=
>> P_SLICE)) ||
>> - ((m_param->bAnalysisType == AVC_INFO) &&
>> m_param->analysisReuseLevel >= 7 && ctu.m_numPartitions <= 16))
>> + else if ((m_param->analysisLoadReuseLevel == 10 &&
>> (!(m_param->bAnalysisType == HEVC_INFO) || m_slice->m_sliceType !=
>> P_SLICE)) ||
>> + ((m_param->bAnalysisType == AVC_INFO) &&
>> m_param->analysisLoadReuseLevel >= 7 && ctu.m_numPartitions <= 16))
>> {
>> x265_analysis_inter_data* interDataCTU =
>> m_frame->m_analysisData.interData;
>> int posCTU = ctu.m_cuAddr * numPartition;
>> @@ -456,7 +459,7 @@
>> int bestCUQP = qp;
>> int lambdaQP = lqp;
>> bool doQPRefine = (bDecidedDepth && depth <=
>> m_slice->m_pps->maxCuDQPDepth) || (!bDecidedDepth && depth ==
>> m_slice->m_pps->maxCuDQPDepth);
>> - if (m_param->analysisReuseLevel >= 7)
>> + if (m_param->analysisLoadReuseLevel >= 7)
>> doQPRefine = false;
>> if (doQPRefine)
>> {
>> @@ -1164,7 +1167,7 @@
>> SplitData splitCUData;
>>
>> bool bHEVCBlockAnalysis = (m_param->bAnalysisType == AVC_INFO &&
>> cuGeom.numPartitions > 16);
>> - bool bRefineAVCAnalysis = (m_param->analysisReuseLevel == 7 &&
>> (m_modeFlag[0] || m_modeFlag[1]));
>> + bool bRefineAVCAnalysis = (m_param->analysisLoadReuseLevel == 7 &&
>> (m_modeFlag[0] || m_modeFlag[1]));
>> bool bNooffloading = !(m_param->bAnalysisType == AVC_INFO);
>>
>> if (bHEVCBlockAnalysis || bRefineAVCAnalysis || bNooffloading)
>> @@ -1259,7 +1262,7 @@
>> mightSplit &= !bDecidedDepth;
>> }
>> }
>> - if ((m_param->analysisLoad && m_param->analysisReuseLevel > 1 &&
>> m_param->analysisReuseLevel != 10))
>> + if ((m_param->analysisLoadReuseLevel > 1 &&
>> m_param->analysisLoadReuseLevel != 10))
>> {
>> if (mightNotSplit && depth ==
>> m_reuseDepth[cuGeom.absPartIdx])
>> {
>> @@ -1273,7 +1276,7 @@
>> if (m_param->rdLevel)
>> skipModes = m_param->bEnableEarlySkip &&
>> md.bestMode;
>> }
>> - if (m_param->analysisReuseLevel > 4 &&
>> m_reusePartSize[cuGeom.absPartIdx] == SIZE_2Nx2N)
>> + if (m_param->analysisLoadReuseLevel > 4 &&
>> m_reusePartSize[cuGeom.absPartIdx] == SIZE_2Nx2N)
>> {
>> if (m_reuseModes[cuGeom.absPartIdx] != MODE_INTRA
>> && m_reuseModes[cuGeom.absPartIdx] != 4)
>> {
>> @@ -1300,7 +1303,8 @@
>> }
>> }
>> /* Step 1. Evaluate Merge/Skip candidates for likely early-outs,
>> if skip mode was not set above */
>> - if ((mightNotSplit && depth >= minDepth && !md.bestMode &&
>> !bCtuInfoCheck) || (m_param->bAnalysisType == AVC_INFO &&
>> m_param->analysisReuseLevel == 7 && (m_modeFlag[0] || m_modeFlag[1]))) /*
>> TODO: Re-evaluate if analysis load/save still works */
>> + if ((mightNotSplit && depth >= minDepth && !md.bestMode &&
>> !bCtuInfoCheck) || (m_param->bAnalysisType == AVC_INFO &&
>> m_param->analysisLoadReuseLevel == 7 && (m_modeFlag[0] || m_modeFlag[1])))
>> + /* TODO: Re-evaluate if analysis load/save still works */
>> {
>> /* Compute Merge Cost */
>> md.pred[PRED_MERGE].cu.initSubCU(parentCTU, cuGeom, qp);
>> @@ -1310,7 +1314,7 @@
>> skipModes = (m_param->bEnableEarlySkip || m_refineLevel
>> == 2)
>> && md.bestMode && md.bestMode->cu.isSkipped(0); // TODO:
>> sa8d threshold per depth
>> }
>> - if (md.bestMode && m_param->bEnableRecursionSkip &&
>> !bCtuInfoCheck && !(m_param->bAnalysisType == AVC_INFO &&
>> m_param->analysisReuseLevel == 7 && (m_modeFlag[0] || m_modeFlag[1])))
>> + if (md.bestMode && m_param->bEnableRecursionSkip &&
>> !bCtuInfoCheck && !(m_param->bAnalysisType == AVC_INFO &&
>> m_param->analysisLoadReuseLevel == 7 && (m_modeFlag[0] || m_modeFlag[1])))
>> {
>> skipRecursion = md.bestMode->cu.isSkipped(0);
>> if (mightSplit && depth >= minDepth && !skipRecursion)
>> @@ -1321,7 +1325,7 @@
>> skipRecursion = complexityCheckCU(*md.bestMode);
>> }
>> }
>> - if (m_param->bAnalysisType == AVC_INFO && md.bestMode &&
>> cuGeom.numPartitions <= 16 && m_param->analysisReuseLevel == 7)
>> + if (m_param->bAnalysisType == AVC_INFO && md.bestMode &&
>> cuGeom.numPartitions <= 16 && m_param->analysisLoadReuseLevel == 7)
>> skipRecursion = true;
>> /* Step 2. Evaluate each of the 4 split sub-blocks in series */
>> if (mightSplit && !skipRecursion)
>> @@ -1378,7 +1382,7 @@
>> splitPred->sa8dCost =
>> m_rdCost.calcRdSADCost((uint32_t)splitPred->distortion,
>> splitPred->sa8dBits);
>> }
>> /* If analysis mode is simple do not Evaluate other modes */
>> - if (m_param->bAnalysisType == AVC_INFO &&
>> m_param->analysisReuseLevel == 7)
>> + if (m_param->bAnalysisType == AVC_INFO &&
>> m_param->analysisLoadReuseLevel == 7)
>> {
>> if (m_slice->m_sliceType == P_SLICE)
>> {
>> @@ -1857,7 +1861,7 @@
>> SplitData splitCUData;
>>
>> bool bHEVCBlockAnalysis = (m_param->bAnalysisType == AVC_INFO &&
>> cuGeom.numPartitions > 16);
>> - bool bRefineAVCAnalysis = (m_param->analysisReuseLevel == 7 &&
>> (m_modeFlag[0] || m_modeFlag[1]));
>> + bool bRefineAVCAnalysis = (m_param->analysisLoadReuseLevel == 7 &&
>> (m_modeFlag[0] || m_modeFlag[1]));
>> bool bNooffloading = !(m_param->bAnalysisType == AVC_INFO);
>>
>> if (bHEVCBlockAnalysis || bRefineAVCAnalysis || bNooffloading)
>> @@ -1953,7 +1957,7 @@
>> mightSplit &= !bDecidedDepth;
>> }
>> }
>> - if (m_param->analysisLoad && m_param->analysisReuseLevel > 1 &&
>> m_param->analysisReuseLevel != 10)
>> + if (m_param->analysisLoadReuseLevel > 1 &&
>> m_param->analysisLoadReuseLevel != 10)
>> {
>> if (mightNotSplit && depth ==
>> m_reuseDepth[cuGeom.absPartIdx])
>> {
>> @@ -1971,7 +1975,7 @@
>> if (m_param->bEnableRecursionSkip && depth &&
>> m_modeDepth[depth - 1].bestMode)
>> skipRecursion = md.bestMode &&
>> !md.bestMode->cu.getQtRootCbf(0);
>> }
>> - if (m_param->analysisReuseLevel > 4 &&
>> m_reusePartSize[cuGeom.absPartIdx] == SIZE_2Nx2N)
>> + if (m_param->analysisLoadReuseLevel > 4 &&
>> m_reusePartSize[cuGeom.absPartIdx] == SIZE_2Nx2N)
>> skipRectAmp = true && !!md.bestMode;
>> }
>> }
>> @@ -1999,7 +2003,7 @@
>> }
>> /* Step 1. Evaluate Merge/Skip candidates for likely early-outs
>> */
>> if ((mightNotSplit && !md.bestMode && !bCtuInfoCheck) ||
>> - (m_param->bAnalysisType == AVC_INFO &&
>> m_param->analysisReuseLevel == 7 && (m_modeFlag[0] || m_modeFlag[1])))
>> + (m_param->bAnalysisType == AVC_INFO &&
>> m_param->analysisLoadReuseLevel == 7 && (m_modeFlag[0] || m_modeFlag[1])))
>> {
>> md.pred[PRED_SKIP].cu.initSubCU(parentCTU, cuGeom, qp);
>> md.pred[PRED_MERGE].cu.initSubCU(parentCTU, cuGeom, qp);
>> @@ -2014,7 +2018,7 @@
>> if (m_param->bEnableRecursionSkip && depth &&
>> m_modeDepth[depth - 1].bestMode)
>> skipRecursion = md.bestMode &&
>> !md.bestMode->cu.getQtRootCbf(0);
>> }
>> - if (m_param->bAnalysisType == AVC_INFO && md.bestMode &&
>> cuGeom.numPartitions <= 16 && m_param->analysisReuseLevel == 7)
>> + if (m_param->bAnalysisType == AVC_INFO && md.bestMode &&
>> cuGeom.numPartitions <= 16 && m_param->analysisLoadReuseLevel == 7)
>> skipRecursion = true;
>> // estimate split cost
>> /* Step 2. Evaluate each of the 4 split sub-blocks in series */
>> @@ -2068,7 +2072,7 @@
>> checkDQPForSplitPred(*splitPred, cuGeom);
>> }
>> /* If analysis mode is simple do not Evaluate other modes */
>> - if (m_param->bAnalysisType == AVC_INFO &&
>> m_param->analysisReuseLevel == 7)
>> + if (m_param->bAnalysisType == AVC_INFO &&
>> m_param->analysisLoadReuseLevel == 7)
>> {
>> if (m_slice->m_sliceType == P_SLICE)
>> {
>> @@ -2461,7 +2465,7 @@
>> for (uint32_t part = 0; part < numPU; part++)
>> {
>> PredictionUnit pu(mode.cu, cuGeom, part);
>> - if ((m_param->analysisLoad &&
>> m_param->analysisReuseLevel == 10) || (m_param->bAnalysisType == AVC_INFO
>> && m_param->analysisReuseLevel >= 7))
>> + if (m_param->analysisLoadReuseLevel == 10 ||
>> (m_param->bAnalysisType == AVC_INFO && m_param->analysisLoadReuseLevel >=
>> 7))
>> {
>> x265_analysis_inter_data* interDataCTU =
>> m_frame->m_analysisData.interData;
>> int cuIdx = (mode.cu.m_cuAddr *
>> parentCTU.m_numPartitions) + cuGeom.absPartIdx;
>> @@ -2552,7 +2556,7 @@
>> checkDQPForSplitPred(*md.bestMode, cuGeom);
>> }
>>
>> - if (m_param->bAnalysisType == AVC_INFO &&
>> m_param->analysisReuseLevel == 7)
>> + if (m_param->bAnalysisType == AVC_INFO &&
>> m_param->analysisLoadReuseLevel == 7)
>> {
>> for (int list = 0; list < m_slice->isInterB() + 1; list++)
>> {
>> @@ -2607,7 +2611,7 @@
>> if (m_slice->m_pps->bUseDQP && nextDepth <=
>> m_slice->m_pps->maxCuDQPDepth)
>> nextQP = setLambdaFromQP(parentCTU,
>> calculateQpforCuSize(parentCTU, childGeom));
>>
>> - int lamdaQP = (m_param->analysisReuseLevel >= 7) ?
>> nextQP : lqp;
>> + int lamdaQP = (m_param->analysisLoadReuseLevel >= 7) ?
>> nextQP : lqp;
>>
>> if (split)
>> m_param->rdLevel > 4 ?
>> compressInterCU_rd5_6(parentCTU, childGeom, nextQP) :
>> compressInterCU_rd0_4(parentCTU, childGeom, nextQP);
>> @@ -3013,7 +3017,7 @@
>> interMode.cu.setPredModeSubParts(MODE_INTER);
>> int numPredDir = m_slice->isInterP() ? 1 : 2;
>>
>> - if (m_param->analysisLoad && m_reuseInterDataCTU &&
>> m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
>> + if (m_param->analysisLoadReuseLevel > 1 &&
>> m_param->analysisLoadReuseLevel != 10 && m_reuseInterDataCTU)
>> {
>> int refOffset = cuGeom.geomRecurId * 16 * numPredDir + partSize
>> * numPredDir * 2;
>> int index = 0;
>> @@ -3056,7 +3060,7 @@
>> }
>> interMode.sa8dCost =
>> m_rdCost.calcRdSADCost((uint32_t)interMode.distortion, interMode.sa8dBits);
>>
>> - if (m_param->analysisSave && m_reuseInterDataCTU &&
>> m_param->analysisReuseLevel > 1)
>> + if (m_param->analysisSaveReuseLevel > 1 && m_reuseInterDataCTU)
>> {
>> int refOffset = cuGeom.geomRecurId * 16 * numPredDir + partSize
>> * numPredDir * 2;
>> int index = 0;
>> @@ -3078,7 +3082,7 @@
>> interMode.cu.setPredModeSubParts(MODE_INTER);
>> int numPredDir = m_slice->isInterP() ? 1 : 2;
>>
>> - if (m_param->analysisLoad && m_reuseInterDataCTU &&
>> m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel != 10)
>> + if (m_param->analysisLoadReuseLevel > 1 &&
>> m_param->analysisLoadReuseLevel != 10 && m_reuseInterDataCTU)
>> {
>> int refOffset = cuGeom.geomRecurId * 16 * numPredDir + partSize
>> * numPredDir * 2;
>> int index = 0;
>> @@ -3113,7 +3117,7 @@
>> /* predInterSearch sets interMode.sa8dBits, but this is ignored */
>> encodeResAndCalcRdInterCU(interMode, cuGeom);
>>
>> - if (m_param->analysisSave && m_reuseInterDataCTU &&
>> m_param->analysisReuseLevel > 1)
>> + if (m_param->analysisSaveReuseLevel > 1 && m_reuseInterDataCTU)
>> {
>> int refOffset = cuGeom.geomRecurId * 16 * numPredDir + partSize
>> * numPredDir * 2;
>> int index = 0;
>> @@ -3612,7 +3616,7 @@
>> qp += distortionData->offset[ctu.m_cuAddr];
>> }
>>
>> - if (m_param->analysisLoad && m_param->analysisReuseLevel == 10 &&
>> m_param->rc.cuTree)
>> + if (m_param->analysisLoadReuseLevel == 10 && m_param->rc.cuTree)
>> {
>> int cuIdx = (ctu.m_cuAddr * ctu.m_numPartitions) +
>> cuGeom.absPartIdx;
>> if (ctu.m_slice->m_sliceType == I_SLICE)
>> diff -r 4fcd8f1701a6 -r a28fd843b302 source/encoder/api.cpp
>> --- a/source/encoder/api.cpp Fri Jan 10 14:16:04 2020 +0530
>> +++ b/source/encoder/api.cpp Fri Jan 10 17:01:08 2020 +0530
>> @@ -771,6 +771,12 @@
>> int numDir = 2; //irrespective of P or B slices set direction as 2
>> uint32_t numPlanes = param->internalCsp == X265_CSP_I400 ? 1 : 3;
>>
>> + int maxReuseLevel = X265_MAX(param->analysisSaveReuseLevel,
>> param->analysisLoadReuseLevel);
>> + int minReuseLevel = (param->analysisSaveReuseLevel &&
>> param->analysisLoadReuseLevel) ?
>> + X265_MIN(param->analysisSaveReuseLevel,
>> param->analysisLoadReuseLevel) : maxReuseLevel;
>> +
>> + bool isMultiPassOpt = param->analysisMultiPassRefine ||
>> param->analysisMultiPassDistortion;
>> +
>> #if X265_DEPTH < 10 && (LINKED_10BIT || LINKED_12BIT)
>> uint32_t numCUs_sse_t = param->internalBitDepth > 8 ?
>> analysis->numCUsInFrame << 1 : analysis->numCUsInFrame;
>> #elif X265_DEPTH >= 10 && LINKED_8BIT
>> @@ -778,7 +784,7 @@
>> #else
>> uint32_t numCUs_sse_t = analysis->numCUsInFrame;
>> #endif
>> - if (param->analysisMultiPassRefine ||
>> param->analysisMultiPassDistortion || param->ctuDistortionRefine)
>> + if (isMultiPassOpt || param->ctuDistortionRefine)
>> {
>> //Allocate memory for distortionData pointer
>> CHECKED_MALLOC_ZERO(distortionData,
>> x265_analysis_distortion_data, 1);
>> @@ -792,7 +798,7 @@
>> analysis->distortionData = distortionData;
>> }
>>
>> - if (param->bDisableLookahead && isVbv)
>> + if (!isMultiPassOpt && param->bDisableLookahead && isVbv)
>> {
>> CHECKED_MALLOC_ZERO(analysis->lookahead.intraSatdForVbv,
>> uint32_t, analysis->numCuInHeight);
>> CHECKED_MALLOC_ZERO(analysis->lookahead.satdForVbv, uint32_t,
>> analysis->numCuInHeight);
>> @@ -801,20 +807,23 @@
>> }
>>
>> //Allocate memory for weightParam pointer
>> - if (!(param->bAnalysisType == AVC_INFO))
>> + if (!isMultiPassOpt && !(param->bAnalysisType == AVC_INFO))
>> CHECKED_MALLOC_ZERO(analysis->wt, x265_weight_param, numPlanes *
>> numDir);
>>
>> - if (param->analysisReuseLevel < 2)
>> + if (maxReuseLevel < 2)
>> return;
>>
>> //Allocate memory for intraData pointer
>> CHECKED_MALLOC_ZERO(intraData, x265_analysis_intra_data, 1);
>> CHECKED_MALLOC(intraData->depth, uint8_t, analysis->numPartitions *
>> analysis->numCUsInFrame);
>> - CHECKED_MALLOC_ZERO(intraData->modes, uint8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> - CHECKED_MALLOC_ZERO(intraData->partSizes, char,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> - CHECKED_MALLOC_ZERO(intraData->chromaModes, uint8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> - if (param->rc.cuTree)
>> - CHECKED_MALLOC_ZERO(intraData->cuQPOff, int8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> + if (!isMultiPassOpt)
>> + {
>> + CHECKED_MALLOC_ZERO(intraData->modes, uint8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> + CHECKED_MALLOC_ZERO(intraData->partSizes, char,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> + CHECKED_MALLOC_ZERO(intraData->chromaModes, uint8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> + if (param->rc.cuTree)
>> + CHECKED_MALLOC_ZERO(intraData->cuQPOff, int8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> + }
>> analysis->intraData = intraData;
>>
>> //Allocate memory for interData pointer based on ReuseLevels
>> @@ -822,19 +831,19 @@
>> CHECKED_MALLOC(interData->depth, uint8_t, analysis->numPartitions *
>> analysis->numCUsInFrame);
>> CHECKED_MALLOC_ZERO(interData->modes, uint8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>>
>> - if (param->rc.cuTree)
>> + if (param->rc.cuTree && !isMultiPassOpt)
>> CHECKED_MALLOC_ZERO(interData->cuQPOff, int8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> CHECKED_MALLOC_ZERO(interData->mvpIdx[0], uint8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> CHECKED_MALLOC_ZERO(interData->mvpIdx[1], uint8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> CHECKED_MALLOC_ZERO(interData->mv[0], x265_analysis_MV,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> CHECKED_MALLOC_ZERO(interData->mv[1], x265_analysis_MV,
>> analysis->numPartitions * analysis->numCUsInFrame);
>>
>> - if (param->analysisReuseLevel > 4)
>> + if (maxReuseLevel > 4)
>> {
>> CHECKED_MALLOC_ZERO(interData->partSize, uint8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> CHECKED_MALLOC_ZERO(interData->mergeFlag, uint8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> }
>> - if (param->analysisReuseLevel >= 7)
>> + if (maxReuseLevel >= 7)
>> {
>> CHECKED_MALLOC_ZERO(interData->interDir, uint8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> CHECKED_MALLOC_ZERO(interData->sadCost, int64_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> @@ -844,14 +853,13 @@
>> CHECKED_MALLOC_ZERO(analysis->modeFlag[dir], uint8_t,
>> analysis->numPartitions * analysis->numCUsInFrame);
>> }
>> }
>> - else
>> + if ((minReuseLevel >= 2) && (minReuseLevel <= 6))
>> {
>> - if (param->analysisMultiPassRefine ||
>> param->analysisMultiPassDistortion){
>> - CHECKED_MALLOC_ZERO(interData->ref, int32_t, 2 *
>> analysis->numPartitions * analysis->numCUsInFrame);
>> - }
>> - else
>> - CHECKED_MALLOC_ZERO(interData->ref, int32_t,
>> analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir);
>> + CHECKED_MALLOC_ZERO(interData->ref, int32_t,
>> analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir);
>> }
>> + if (isMultiPassOpt)
>> + CHECKED_MALLOC_ZERO(interData->ref, int32_t, 2 *
>> analysis->numPartitions * analysis->numCUsInFrame);
>> +
>> analysis->interData = interData;
>>
>> return;
>> @@ -862,10 +870,15 @@
>>
>> void x265_free_analysis_data(x265_param *param, x265_analysis_data*
>> analysis)
>> {
>> + int maxReuseLevel = X265_MAX(param->analysisSaveReuseLevel,
>> param->analysisLoadReuseLevel);
>> + int minReuseLevel = (param->analysisSaveReuseLevel &&
>> param->analysisLoadReuseLevel) ?
>> + X265_MIN(param->analysisSaveReuseLevel,
>> param->analysisLoadReuseLevel) : maxReuseLevel;
>> +
>> bool isVbv = param->rc.vbvMaxBitrate > 0 && param->rc.vbvBufferSize
>> > 0;
>> + bool isMultiPassOpt = param->analysisMultiPassRefine ||
>> param->analysisMultiPassDistortion;
>>
>> //Free memory for Lookahead pointers
>> - if (param->bDisableLookahead && isVbv)
>> + if (!isMultiPassOpt && param->bDisableLookahead && isVbv)
>> {
>> X265_FREE(analysis->lookahead.satdForVbv);
>> X265_FREE(analysis->lookahead.intraSatdForVbv);
>> @@ -887,21 +900,24 @@
>> }
>>
>> /* Early exit freeing weights alone if level is 1 (when there is no
>> analysis inter/intra) */
>> - if (analysis->wt && !(param->bAnalysisType == AVC_INFO))
>> + if (!isMultiPassOpt && analysis->wt && !(param->bAnalysisType ==
>> AVC_INFO))
>> X265_FREE(analysis->wt);
>>
>> - if (param->analysisReuseLevel < 2)
>> + if (maxReuseLevel < 2)
>> return;
>>
>> //Free memory for intraData pointers
>> if (analysis->intraData)
>> {
>> X265_FREE((analysis->intraData)->depth);
>> - X265_FREE((analysis->intraData)->modes);
>> - X265_FREE((analysis->intraData)->partSizes);
>> - X265_FREE((analysis->intraData)->chromaModes);
>> - if (param->rc.cuTree)
>> - X265_FREE((analysis->intraData)->cuQPOff);
>> + if (!isMultiPassOpt)
>> + {
>> + X265_FREE((analysis->intraData)->modes);
>> + X265_FREE((analysis->intraData)->partSizes);
>> + X265_FREE((analysis->intraData)->chromaModes);
>> + if (param->rc.cuTree)
>> + X265_FREE((analysis->intraData)->cuQPOff);
>> + }
>> X265_FREE(analysis->intraData);
>> analysis->intraData = NULL;
>> }
>> @@ -911,19 +927,19 @@
>> {
>> X265_FREE((analysis->interData)->depth);
>> X265_FREE((analysis->interData)->modes);
>> - if (param->rc.cuTree)
>> + if (!isMultiPassOpt && param->rc.cuTree)
>> X265_FREE((analysis->interData)->cuQPOff);
>> X265_FREE((analysis->interData)->mvpIdx[0]);
>> X265_FREE((analysis->interData)->mvpIdx[1]);
>> X265_FREE((analysis->interData)->mv[0]);
>> X265_FREE((analysis->interData)->mv[1]);
>>
>> - if (param->analysisReuseLevel > 4)
>> + if (maxReuseLevel > 4)
>> {
>> X265_FREE((analysis->interData)->mergeFlag);
>> X265_FREE((analysis->interData)->partSize);
>> }
>> - if (param->analysisReuseLevel >= 7)
>> + if (maxReuseLevel >= 7)
>> {
>> int numDir = 2;
>> X265_FREE((analysis->interData)->interDir);
>> @@ -932,13 +948,13 @@
>> {
>> X265_FREE((analysis->interData)->refIdx[dir]);
>> if (analysis->modeFlag[dir] != NULL)
>> - {
>> + {
>> X265_FREE(analysis->modeFlag[dir]);
>> analysis->modeFlag[dir] = NULL;
>> }
>> }
>> }
>> - else
>> + if (((minReuseLevel >= 2) && (minReuseLevel <= 6)) ||
>> isMultiPassOpt)
>> X265_FREE((analysis->interData)->ref);
>> X265_FREE(analysis->interData);
>> analysis->interData = NULL;
>> diff -r 4fcd8f1701a6 -r a28fd843b302 source/encoder/encoder.cpp
>> --- a/source/encoder/encoder.cpp Fri Jan 10 14:16:04 2020 +0530
>> +++ b/source/encoder/encoder.cpp Fri Jan 10 17:01:08 2020 +0530
>> @@ -650,7 +650,7 @@
>> if (analysis_data->sliceType == X265_TYPE_IDR ||
>> analysis_data->sliceType == X265_TYPE_I)
>> {
>> curFrame->m_analysisData.sliceType = X265_TYPE_I;
>> - if (m_param->analysisReuseLevel < 7)
>> + if (m_param->analysisLoadReuseLevel < 7)
>> return -1;
>> curFrame->m_analysisData.numPartitions =
>> m_param->num4x4Partitions;
>> int num16x16inCUWidth = m_param->maxCUSize >> 4;
>> @@ -680,7 +680,7 @@
>> else
>> {
>> uint32_t numDir = analysis_data->sliceType == X265_TYPE_P ? 1 :
>> 2;
>> - if (m_param->analysisReuseLevel < 7)
>> + if (m_param->analysisLoadReuseLevel < 7)
>> return -1;
>> curFrame->m_analysisData.numPartitions =
>> m_param->num4x4Partitions;
>> int num16x16inCUWidth = m_param->maxCUSize >> 4;
>> @@ -722,7 +722,7 @@
>> (interData)->mvpIdx[k][cuPos + cuOffset] =
>> (srcInterData)->mvpIdx[k][(mbIndex * 16) + cuOffset];
>> (interData)->refIdx[k][cuPos + cuOffset] =
>> (srcInterData)->refIdx[k][(mbIndex * 16) + cuOffset];
>> memcpy(&(interData)->mv[k][cuPos +
>> cuOffset], &(srcInterData)->mv[k][(mbIndex * 16) + cuOffset], sizeof(MV));
>> - if (m_param->analysisReuseLevel == 7 &&
>> numPU == PU_2Nx2N &&
>> + if (m_param->analysisLoadReuseLevel == 7 &&
>> numPU == PU_2Nx2N &&
>> ((interData)->depth[cuPos + cuOffset] ==
>> (m_param->maxCUSize >> 5)))
>> {
>> int mv_x = (interData)->mv[k][cuPos +
>> cuOffset].x;
>> @@ -756,7 +756,7 @@
>> if (analysis_data->sliceType == X265_TYPE_IDR ||
>> analysis_data->sliceType == X265_TYPE_I)
>> {
>> curFrame->m_analysisData.sliceType = X265_TYPE_I;
>> - if (m_param->analysisReuseLevel < 2)
>> + if (m_param->analysisLoadReuseLevel < 2)
>> return -1;
>>
>> curFrame->m_analysisData.numPartitions =
>> m_param->num4x4Partitions;
>> @@ -777,7 +777,7 @@
>> else
>> {
>> uint32_t numDir = analysis_data->sliceType ==
>> X265_TYPE_P ? 1 : 2;
>> - if (m_param->analysisReuseLevel < 2)
>> + if (m_param->analysisLoadReuseLevel < 2)
>> return -1;
>>
>> curFrame->m_analysisData.numPartitions =
>> m_param->num4x4Partitions;
>> @@ -790,7 +790,7 @@
>> memset(&(currInterData)->depth[count],
>> (interData)->depth[d], bytes);
>> memset(&(currInterData)->modes[count],
>> (interData)->modes[d], bytes);
>> memcpy(&(currInterData)->sadCost[count],
>> &(analysis_data->interData)->sadCost[d], bytes);
>> - if (m_param->analysisReuseLevel > 4)
>> + if (m_param->analysisLoadReuseLevel > 4)
>> {
>> memset(&(currInterData)->partSize[count],
>> (interData)->partSize[d], bytes);
>> int numPU =
>> nbPartsTable[(interData)->partSize[d]];
>> @@ -798,7 +798,7 @@
>> {
>> if (pu) d++;
>> (currInterData)->mergeFlag[count + pu] =
>> (interData)->mergeFlag[d];
>> - if (m_param->analysisReuseLevel >= 7)
>> + if (m_param->analysisLoadReuseLevel >= 7)
>> {
>> (currInterData)->interDir[count + pu] =
>> (interData)->interDir[d];
>> for (uint32_t i = 0; i < numDir; i++)
>> @@ -806,7 +806,7 @@
>> (currInterData)->mvpIdx[i][count +
>> pu] = (interData)->mvpIdx[i][d];
>> (currInterData)->refIdx[i][count +
>> pu] = (interData)->refIdx[i][d];
>> memcpy(&(currInterData)->mv[i][count
>> + pu], &(interData)->mv[i][d], sizeof(MV));
>> - if (m_param->analysisReuseLevel == 7
>> && numPU == PU_2Nx2N && m_param->num4x4Partitions <= 16)
>> + if (m_param->analysisLoadReuseLevel
>> == 7 && numPU == PU_2Nx2N && m_param->num4x4Partitions <= 16)
>> {
>> int mv_x =
>> (currInterData)->mv[i][count + pu].x;
>> int mv_y =
>> (currInterData)->mv[i][count + pu].y;
>> @@ -3577,10 +3577,46 @@
>> p->rc.rfConstantMin = 0;
>> }
>>
>> - if (!(p->bAnalysisType == HEVC_INFO) && (p->analysisLoad ||
>> p->analysisSave) && p->rc.cuTree && p->analysisReuseLevel < 10)
>> - {
>> - x265_log(p, X265_LOG_WARNING, "cu-tree works only with analysis
>> reuse level 10, Disabling cu-tree\n");
>> - p->rc.cuTree = 0;
>> + if (p->analysisSaveReuseLevel && !p->analysisSave)
>> + {
>> + x265_log(p, X265_LOG_WARNING, "analysis-save-reuse-level can be
>> set only when analysis-save is enabled."
>> + " Resetting analysis-save-reuse-level to 0.\n");
>> + p->analysisSaveReuseLevel = 0;
>> + }
>> +
>> + if (p->analysisLoadReuseLevel && !p->analysisLoad)
>> + {
>> + x265_log(p, X265_LOG_WARNING, "analysis-load-reuse-level can be
>> set only when analysis-load is enabled."
>> + " Resetting analysis-load-reuse-level to 0.\n");
>> + p->analysisLoadReuseLevel = 0;
>> + }
>> +
>> + if (p->analysisSave && !p->analysisSaveReuseLevel)
>> + {
>> + x265_log(p, X265_LOG_WARNING, "analysis-save-reuse-level must be
>> set when analysis-save is enabled."
>> + " Setting analysis-save-reuse-level to 5.\n");
>> + p->analysisSaveReuseLevel = 5;
>> + }
>> +
>> + if (p->analysisLoad && !p->analysisLoadReuseLevel)
>> + {
>> + x265_log(p, X265_LOG_WARNING, "analysis-load-reuse-level must be
>> set when analysis-load is enabled."
>> + " Setting analysis-load-reuse-level to 5.\n");
>> + p->analysisLoadReuseLevel = 5;
>> + }
>>
> [KS] X265 check fails if reuse-level is 0 (default). Never reaches this
> point. Hence this patch makes it mandatory for the users to set reuse level
> along with save/load option.
>
[AM] Okay, will update the check condition to accept
analysis-save/load-reuse-level 0.
>
> + if ((p->bAnalysisType == DEFAULT) && p->rc.cuTree)
>> + {
>> + if (p->analysisSaveReuseLevel && p->analysisSaveReuseLevel < 10)
>> + {
>> + x265_log(p, X265_LOG_WARNING, "cu-tree works only with
>> analysis-save-reuse-level 10, Disabling cu-tree\n");
>> + p->rc.cuTree = 0;
>> + }
>> + if (p->analysisLoadReuseLevel && p->analysisLoadReuseLevel < 10)
>> + {
>> + x265_log(p, X265_LOG_WARNING, "cu-tree works only with
>> analysis-load-reuse-level 10, Disabling cu-tree\n");
>> + p->rc.cuTree = 0;
>> + }
>> }
>>
>> if ((p->analysisLoad || p->analysisSave) &&
>> (p->bDistributeModeAnalysis || p->bDistributeMotionEstimation))
>> @@ -3602,45 +3638,37 @@
>> {
>> p->scaleFactor = 0;
>> }
>> - else if ((!p->analysisLoad && !p->analysisSave) ||
>> (p->analysisReuseLevel > 6 && p->analysisReuseLevel != 10))
>> + else if ((p->analysisSaveReuseLevel > 6 &&
>> p->analysisSaveReuseLevel != 10) || (p->analysisLoadReuseLevel > 6 &&
>> p->analysisLoadReuseLevel != 10))
>> {
>> - x265_log(p, X265_LOG_WARNING, "Input scaling works with
>> analysis load/save and analysis-reuse-level 1-6 and 10. Disabling
>> scale-factor.\n");
>> + x265_log(p, X265_LOG_WARNING, "Input scaling works with
>> analysis-save/load and analysis-save/load-reuse-level 1-6 and 10. Disabling
>> scale-factor.\n");
>> p->scaleFactor = 0;
>> }
>> }
>>
>> - if (p->intraRefine)
>> - {
>> - if (!p->analysisLoad || p->analysisReuseLevel < 10)
>> - {
>> - x265_log(p, X265_LOG_WARNING, "Intra refinement requires
>> analysis load, analysis-reuse-level 10. Disabling intra refine.\n");
>> - p->intraRefine = 0;
>> - }
>> - }
>> -
>> - if (p->interRefine)
>> - {
>> - if (!p->analysisLoad || p->analysisReuseLevel < 10)
>> - {
>> - x265_log(p, X265_LOG_WARNING, "Inter refinement requires
>> analysis load, analysis-reuse-level 10. Disabling inter refine.\n");
>> - p->interRefine = 0;
>> - }
>> - }
>> -
>> - if (p->bDynamicRefine)
>> - {
>> - if (!p->analysisLoad || p->analysisReuseLevel < 10)
>> - {
>> - x265_log(p, X265_LOG_WARNING, "Dynamic refinement requires
>> analysis load, analysis-reuse-level 10. Disabling dynamic refine.\n");
>> - p->bDynamicRefine = 0;
>> - }
>> + if (p->intraRefine && p->analysisLoadReuseLevel &&
>> p->analysisLoadReuseLevel < 10)
>> + {
>> + x265_log(p, X265_LOG_WARNING, "Intra refinement requires
>> analysis load, analysis-load-reuse-level 10. Disabling intra refine.\n");
>> + p->intraRefine = 0;
>> + }
>> +
>> + if (p->interRefine && p->analysisLoadReuseLevel &&
>> p->analysisLoadReuseLevel < 10)
>> + {
>> + x265_log(p, X265_LOG_WARNING, "Inter refinement requires
>> analysis load, analysis-load-reuse-level 10. Disabling inter refine.\n");
>> + p->interRefine = 0;
>> + }
>> +
>> + if (p->bDynamicRefine && p->analysisLoadReuseLevel &&
>> p->analysisLoadReuseLevel < 10)
>> + {
>> + x265_log(p, X265_LOG_WARNING, "Dynamic refinement requires
>> analysis load, analysis-load-reuse-level 10. Disabling dynamic refine.\n");
>> + p->bDynamicRefine = 0;
>> +
>> if (p->interRefine)
>> {
>> x265_log(p, X265_LOG_WARNING, "Inter refine cannot be used
>> with dynamic refine. Disabling refine-inter.\n");
>> p->interRefine = 0;
>> }
>> }
>> - if (p->scaleFactor && p->analysisLoad && !p->interRefine &&
>> !p->bDynamicRefine && p->analysisReuseLevel == 10)
>> + if (p->scaleFactor && !p->interRefine && !p->bDynamicRefine &&
>> p->analysisLoadReuseLevel == 10)
>> {
>> x265_log(p, X265_LOG_WARNING, "Inter refinement 0 is not
>> supported with scaling and analysis-reuse-level=10. Enabling refine-inter
>> 1.\n");
>> p->interRefine = 1;
>> @@ -4205,7 +4233,7 @@
>> {
>> if (m_param->bAnalysisType == HEVC_INFO)
>> return;
>> - if (m_param->analysisReuseLevel < 2)
>> + if (m_param->analysisLoadReuseLevel < 2)
>> return;
>>
>> uint8_t *tempBuf = NULL, *depthBuf = NULL, *modeBuf = NULL,
>> *partSizes = NULL;
>> @@ -4265,7 +4293,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_analysisFileIn, (picIn->analysisData.wt));
>> - if (m_param->analysisReuseLevel < 2)
>> + if (m_param->analysisLoadReuseLevel < 2)
>> return;
>>
>> uint8_t *tempBuf = NULL, *depthBuf = NULL, *modeBuf = NULL,
>> *partSize = NULL, *mergeFlag = NULL;
>> @@ -4274,9 +4302,9 @@
>> int8_t* refIdx[2];
>> int8_t* cuQPBuf = NULL;
>>
>> - int numBuf = m_param->analysisReuseLevel > 4 ? 4 : 2;
>> + int numBuf = m_param->analysisLoadReuseLevel > 4 ? 4 : 2;
>> bool bIntraInInter = false;
>> - if (m_param->analysisReuseLevel == 10)
>> + if (m_param->analysisLoadReuseLevel == 10)
>> {
>> numBuf++;
>> bIntraInInter = (analysis->sliceType == X265_TYPE_P ||
>> m_param->bIntraInBFrames);
>> @@ -4299,14 +4327,14 @@
>> X265_FREAD(modeBuf, sizeof(uint8_t), depthBytes,
>> m_analysisFileIn, interPic->modes);
>> if (m_param->rc.cuTree) { X265_FREAD(cuQPBuf,
>> sizeof(int8_t), depthBytes, m_analysisFileIn, interPic->cuQPOff); }
>>
>> - if (m_param->analysisReuseLevel > 4)
>> + if (m_param->analysisLoadReuseLevel > 4)
>> {
>> partSize = modeBuf + depthBytes;
>> mergeFlag = partSize + depthBytes;
>> 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)
>> + if (m_param->analysisLoadReuseLevel == 10)
>> {
>> interDir = mergeFlag + depthBytes;
>> X265_FREAD(interDir, sizeof(uint8_t), depthBytes,
>> m_analysisFileIn, interPic->interDir);
>> @@ -4337,7 +4365,7 @@
>> memset(&(analysis->interData)->modes[count], modeBuf[d],
>> bytes);
>> if (m_param->rc.cuTree)
>> memset(&(analysis->interData)->cuQPOff[count],
>> cuQPBuf[d], bytes);
>> - if (m_param->analysisReuseLevel > 4)
>> + if (m_param->analysisLoadReuseLevel > 4)
>> {
>> if (m_param->scaleFactor && modeBuf[d] == MODE_INTRA
>> && partSize[d] == SIZE_NxN)
>> partSize[d] = SIZE_2Nx2N;
>> @@ -4347,7 +4375,7 @@
>> {
>> if (pu) d++;
>> (analysis->interData)->mergeFlag[count + pu] =
>> mergeFlag[d];
>> - if (m_param->analysisReuseLevel == 10)
>> + if (m_param->analysisLoadReuseLevel == 10)
>> {
>> (analysis->interData)->interDir[count + pu]
>> = interDir[d];
>> for (uint32_t i = 0; i < numDir; i++)
>> @@ -4363,7 +4391,7 @@
>> }
>> }
>> }
>> - if (m_param->analysisReuseLevel == 10 &&
>> bIntraInInter)
>> + if (m_param->analysisLoadReuseLevel == 10 &&
>> bIntraInInter)
>>
>> memset(&(analysis->intraData)->chromaModes[count], chromaDir[d], bytes);
>> }
>> count += bytes;
>> @@ -4373,7 +4401,7 @@
>> X265_FREE(cuQPBuf);
>> X265_FREE(tempBuf);
>> }
>> - if (m_param->analysisReuseLevel == 10)
>> + if (m_param->analysisLoadReuseLevel == 10)
>> {
>> if (m_param->bAnalysisType != HEVC_INFO)
>> {
>> @@ -4556,7 +4584,7 @@
>>
>> if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType ==
>> X265_TYPE_I)
>> {
>> - if (m_param->analysisReuseLevel < 2)
>> + if (m_param->analysisLoadReuseLevel < 2)
>> return;
>>
>> uint8_t *tempBuf = NULL, *depthBuf = NULL, *modeBuf = NULL,
>> *partSizes = NULL;
>> @@ -4625,7 +4653,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_analysisFileIn, (picIn->analysisData.wt));
>> - if (m_param->analysisReuseLevel < 2)
>> + if (m_param->analysisLoadReuseLevel < 2)
>> return;
>>
>> uint8_t *tempBuf = NULL, *depthBuf = NULL, *modeBuf = NULL,
>> *partSize = NULL, *mergeFlag = NULL;
>> @@ -4634,9 +4662,9 @@
>> int8_t* refIdx[2];
>> int8_t* cuQPBuf = NULL;
>>
>> - int numBuf = m_param->analysisReuseLevel > 4 ? 4 : 2;
>> + int numBuf = m_param->analysisLoadReuseLevel > 4 ? 4 : 2;
>> bool bIntraInInter = false;
>> - if (m_param->analysisReuseLevel == 10)
>> + if (m_param->analysisLoadReuseLevel == 10)
>> {
>> numBuf++;
>> bIntraInInter = (analysis->sliceType == X265_TYPE_P ||
>> m_param->bIntraInBFrames);
>> @@ -4652,13 +4680,13 @@
>> 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->rc.cuTree) { X265_FREAD(cuQPBuf, sizeof(int8_t),
>> depthBytes, m_analysisFileIn, interPic->cuQPOff); }
>> - if (m_param->analysisReuseLevel > 4)
>> + if (m_param->analysisLoadReuseLevel > 4)
>> {
>> partSize = modeBuf + depthBytes;
>> mergeFlag = partSize + depthBytes;
>> 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)
>> + if (m_param->analysisLoadReuseLevel == 10)
>> {
>> interDir = mergeFlag + depthBytes;
>> X265_FREAD(interDir, sizeof(uint8_t), depthBytes,
>> m_analysisFileIn, interPic->interDir);
>> @@ -4702,10 +4730,10 @@
>> memset(&(analysis->interData)->modes[count], modeBuf[d],
>> bytes);
>> if (m_param->rc.cuTree)
>> memset(&(analysis->interData)->cuQPOff[count],
>> cuQPBuf[d], bytes);
>> - if (m_param->analysisReuseLevel == 10 && bIntraInInter)
>> + if (m_param->analysisLoadReuseLevel == 10 &&
>> bIntraInInter)
>> memset(&(analysis->intraData)->chromaModes[count],
>> chromaDir[d], bytes);
>>
>> - if (m_param->analysisReuseLevel > 4)
>> + if (m_param->analysisLoadReuseLevel > 4)
>> {
>> puOrientation puOrient;
>> puOrient.init();
>> @@ -4731,7 +4759,7 @@
>> d++;
>>
>> (analysis->interData)->mergeFlag[count + pu] =
>> mergeFlag[d];
>> - if (m_param->analysisReuseLevel == 10)
>> + if (m_param->analysisLoadReuseLevel == 10)
>> {
>> (analysis->interData)->interDir[count + pu]
>> = interDir[d];
>> MV mvCopy[2];
>> @@ -4766,7 +4794,7 @@
>> X265_FREE(cuQPBuf);
>> X265_FREE(tempBuf);
>>
>> - if (m_param->analysisReuseLevel == 10)
>> + if (m_param->analysisLoadReuseLevel == 10)
>> {
>> for (uint32_t i = 0; i < numDir; i++)
>> {
>> @@ -4855,7 +4883,6 @@
>>
>> X265_PARAM_VALIDATE(saveParam->intraRefresh, sizeof(int), 1,
>> &m_param->bIntraRefresh, intra-refresh);
>> X265_PARAM_VALIDATE(saveParam->maxNumReferences, sizeof(int), 1,
>> &m_param->maxNumReferences, ref);
>> - X265_PARAM_VALIDATE(saveParam->analysisReuseLevel, sizeof(int), 1,
>> &m_param->analysisReuseLevel, analysis-reuse-level);
>> X265_PARAM_VALIDATE(saveParam->keyframeMax, sizeof(int), 1,
>> &m_param->keyframeMax, keyint);
>> X265_PARAM_VALIDATE(saveParam->keyframeMin, sizeof(int), 1,
>> &m_param->keyframeMin, min-keyint);
>> X265_PARAM_VALIDATE(saveParam->openGOP, sizeof(int), 1,
>> &m_param->bOpenGOP, open-gop);
>> @@ -4871,6 +4898,7 @@
>> int sourceHeight, sourceWidth;
>> if (writeFlag)
>> {
>> + X265_PARAM_VALIDATE(saveParam->analysisReuseLevel, sizeof(int),
>> 1, &m_param->analysisSaveReuseLevel, analysis - save - reuse - level);
>> sourceHeight = m_param->sourceHeight -
>> m_conformanceWindow.bottomOffset;
>> sourceWidth = m_param->sourceWidth -
>> m_conformanceWindow.rightOffset;
>> X265_PARAM_VALIDATE(saveParam->sourceWidth, sizeof(int), 1,
>> &sourceWidth, res-width);
>> @@ -4880,10 +4908,35 @@
>> else
>> {
>> fileOffset = m_analysisFileIn;
>> +
>> + int saveLevel = 0;
>> + bool isIncompatibleReuseLevel = false;
>> + int loadLevel = m_param->analysisLoadReuseLevel;
>> +
>> + X265_FREAD(&saveLevel, sizeof(int), 1, m_analysisFileIn,
>> &(saveParam->analysisReuseLevel));
>> +
>> + if (loadLevel == 10 && saveLevel != 10)
>> + isIncompatibleReuseLevel = true;
>> + else if (((loadLevel >= 7) && (loadLevel <= 9)) && ((saveLevel <
>> 7) || (saveLevel > 9)))
>> + isIncompatibleReuseLevel = true;
>> + else if ((loadLevel == 5 || loadLevel == 6) && ((saveLevel != 5)
>> && (saveLevel != 6)))
>> + isIncompatibleReuseLevel = true;
>> + else if ((loadLevel >= 2 && loadLevel <= 4) && (saveLevel < 2 ||
>> saveLevel > 6))
>> + isIncompatibleReuseLevel = true;
>> + else if (!saveLevel)
>> + isIncompatibleReuseLevel = true;
>> +
>> + if (isIncompatibleReuseLevel)
>> + {
>> + x265_log(NULL, X265_LOG_ERROR, "Error reading analysis data.
>> Incompatible reuse-levels.\n");
>> + m_aborted = true;
>> + return -1;
>> + }
>> +
>> bool error = false;
>> int curSourceHeight = m_param->sourceHeight -
>> m_conformanceWindow.bottomOffset;
>> int curSourceWidth = m_param->sourceWidth -
>> m_conformanceWindow.rightOffset;
>> -
>> +
>> X265_FREAD(&sourceWidth, sizeof(int), 1, m_analysisFileIn,
>> &(saveParam->sourceWidth));
>> X265_FREAD(&sourceHeight, sizeof(int), 1, m_analysisFileIn,
>> &(saveParam->sourceHeight));
>> X265_FREAD(&readValue, sizeof(int), 1, m_analysisFileIn,
>> &(saveParam->maxCUSize));
>> @@ -5205,7 +5258,7 @@
>> analysis->frameRecordSize += analysis->numCUsInFrame *
>> sizeof(sse_t);
>> }
>>
>> - if (m_param->analysisReuseLevel > 1)
>> + if (m_param->analysisSaveReuseLevel > 1)
>> {
>>
>> if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType
>> == X265_TYPE_I)
>> @@ -5258,14 +5311,14 @@
>> interDataCTU->depth[depthBytes] = depth;
>>
>> predMode = ctu->m_predMode[absPartIdx];
>> - if (m_param->analysisReuseLevel != 10 &&
>> ctu->m_refIdx[1][absPartIdx] != -1)
>> + if (m_param->analysisSaveReuseLevel != 10 &&
>> ctu->m_refIdx[1][absPartIdx] != -1)
>> predMode = 4; // used as indicator if the block
>> is coded as bidir
>>
>> interDataCTU->modes[depthBytes] = predMode;
>> if (m_param->rc.cuTree)
>> interDataCTU->cuQPOff[depthBytes] =
>> (int8_t)(ctu->m_qpAnalysis[absPartIdx] - baseQP);
>>
>> - if (m_param->analysisReuseLevel > 4)
>> + if (m_param->analysisSaveReuseLevel > 4)
>> {
>> partSize = ctu->m_partSize[absPartIdx];
>> interDataCTU->partSize[depthBytes] = partSize;
>> @@ -5278,7 +5331,7 @@
>> if (puIdx) depthBytes++;
>> interDataCTU->mergeFlag[depthBytes] =
>> ctu->m_mergeFlag[puabsPartIdx];
>>
>> - if (m_param->analysisReuseLevel == 10)
>> + if (m_param->analysisSaveReuseLevel == 10)
>> {
>> interDataCTU->interDir[depthBytes] =
>> ctu->m_interDir[puabsPartIdx];
>> for (uint32_t dir = 0; dir < numDir;
>> dir++)
>> @@ -5289,12 +5342,12 @@
>> }
>> }
>> }
>> - if (m_param->analysisReuseLevel == 10 &&
>> bIntraInInter)
>> + if (m_param->analysisSaveReuseLevel == 10 &&
>> bIntraInInter)
>> intraDataCTU->chromaModes[depthBytes] =
>> ctu->m_chromaIntraDir[absPartIdx];
>> }
>> absPartIdx += ctu->m_numPartitions >> (depth * 2);
>> }
>> - if (m_param->analysisReuseLevel == 10 && bIntraInInter)
>> + if (m_param->analysisSaveReuseLevel == 10 &&
>> bIntraInInter)
>> memcpy(&intraDataCTU->modes[ctu->m_cuAddr *
>> ctu->m_numPartitions], ctu->m_lumaIntraDir, sizeof(uint8_t)*
>> ctu->m_numPartitions);
>> }
>> }
>> @@ -5309,10 +5362,10 @@
>> analysis->frameRecordSize += depthBytes * 2;
>> if (m_param->rc.cuTree)
>> analysis->frameRecordSize += (sizeof(int8_t) * depthBytes);
>> - if (m_param->analysisReuseLevel > 4)
>> + if (m_param->analysisSaveReuseLevel > 4)
>> analysis->frameRecordSize += (depthBytes * 2);
>>
>> - if (m_param->analysisReuseLevel == 10)
>> + if (m_param->analysisSaveReuseLevel == 10)
>> {
>> /* Add Size of interDir, mvpIdx, refIdx, mv, luma and
>> chroma modes */
>> analysis->frameRecordSize += depthBytes;
>> @@ -5344,7 +5397,7 @@
>> if (analysis->sliceType > X265_TYPE_I)
>> X265_FWRITE((WeightParam*)analysis->wt, sizeof(WeightParam),
>> numPlanes * numDir, m_analysisFileOut);
>>
>> - if (m_param->analysisReuseLevel < 2)
>> + if (m_param->analysisSaveReuseLevel < 2)
>> return;
>>
>> if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType ==
>> X265_TYPE_I)
>> @@ -5362,11 +5415,11 @@
>> X265_FWRITE((analysis->interData)->modes, sizeof(uint8_t),
>> depthBytes, m_analysisFileOut);
>> if (m_param->rc.cuTree)
>> X265_FWRITE((analysis->interData)->cuQPOff, sizeof(int8_t),
>> depthBytes, m_analysisFileOut);
>> - if (m_param->analysisReuseLevel > 4)
>> + if (m_param->analysisSaveReuseLevel > 4)
>> {
>> X265_FWRITE((analysis->interData)->partSize,
>> sizeof(uint8_t), depthBytes, m_analysisFileOut);
>> X265_FWRITE((analysis->interData)->mergeFlag,
>> sizeof(uint8_t), depthBytes, m_analysisFileOut);
>> - if (m_param->analysisReuseLevel == 10)
>> + if (m_param->analysisSaveReuseLevel == 10)
>> {
>> X265_FWRITE((analysis->interData)->interDir,
>> sizeof(uint8_t), depthBytes, m_analysisFileOut);
>> if (bIntraInInter)
>> X265_FWRITE((analysis->intraData)->chromaModes, sizeof(uint8_t),
>> depthBytes, m_analysisFileOut);
>> @@ -5380,7 +5433,7 @@
>> X265_FWRITE((analysis->intraData)->modes,
>> sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions,
>> m_analysisFileOut);
>> }
>> }
>> - if (m_param->analysisReuseLevel != 10)
>> + if (m_param->analysisSaveReuseLevel != 10)
>> X265_FWRITE((analysis->interData)->ref, sizeof(int32_t),
>> analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir,
>> m_analysisFileOut);
>>
>> }
>> diff -r 4fcd8f1701a6 -r a28fd843b302 source/encoder/search.cpp
>> --- a/source/encoder/search.cpp Fri Jan 10 14:16:04 2020 +0530
>> +++ b/source/encoder/search.cpp Fri Jan 10 17:01:08 2020 +0530
>> @@ -2208,7 +2208,7 @@
>> x265_analysis_inter_data* interDataCTU = NULL;
>> int cuIdx;
>> cuIdx = (interMode.cu.m_cuAddr * m_param->num4x4Partitions) +
>> cuGeom.absPartIdx;
>> - if (m_param->analysisReuseLevel == 10 && m_param->interRefine >
>> 1)
>> + if (m_param->analysisLoadReuseLevel == 10 &&
>> m_param->interRefine > 1)
>> {
>> interDataCTU = m_frame->m_analysisData.interData;
>> if ((cu.m_predMode[pu.puAbsPartIdx] ==
>> interDataCTU->modes[cuIdx + pu.puAbsPartIdx])
>> @@ -2227,7 +2227,7 @@
>>
>> cu.getNeighbourMV(puIdx, pu.puAbsPartIdx,
>> interMode.interNeighbours);
>> /* Uni-directional prediction */
>> - if ((m_param->analysisLoad && m_param->analysisReuseLevel > 1 &&
>> m_param->analysisReuseLevel != 10)
>> + if ((m_param->analysisLoadReuseLevel > 1 &&
>> m_param->analysisLoadReuseLevel != 10)
>> || (m_param->analysisMultiPassRefine &&
>> m_param->rc.bStatRead) || (m_param->bAnalysisType == AVC_INFO) ||
>> (useAsMVP))
>> {
>> for (int list = 0; list < numPredDir; list++)
>> diff -r 4fcd8f1701a6 -r a28fd843b302 source/x265.h
>> --- a/source/x265.h Fri Jan 10 14:16:04 2020 +0530
>> +++ b/source/x265.h Fri Jan 10 17:01:08 2020 +0530
>> @@ -320,7 +320,7 @@
>>
>> typedef enum
>> {
>> - NO_INFO = 0,
>> + DEFAULT = 0,
>> AVC_INFO = 1,
>> HEVC_INFO = 2,
>> }AnalysisRefineType;
>> @@ -1656,7 +1656,7 @@
>>
>> /* A value between 1 and 10 (both inclusive) determines the level of
>> * information stored/reused in analysis save/load. Higher the refine
>> - * level higher the information stored/reused. Default is 5 */
>> + * level higher the information stored/reused. Default is 5. Now
>> deprecated. */
>> int analysisReuseLevel;
>>
>> /* Limit Sample Adaptive Offset filter computation by early
>> terminating SAO
>> @@ -1867,6 +1867,16 @@
>> * Auto-enabled when max-cll, max-fall, or mastering display info is
>> specified.
>> * Default is disabled */
>> int bEmitHDR10SEI;
>> +
>> + /* A value between 1 and 10 (both inclusive) determines the level of
>> + * analysis information stored in analysis-save. Higher the refine
>> level higher
>> + * the information stored. Default is 5 */
>> + int analysisSaveReuseLevel;
>> +
>> + /* A value between 1 and 10 (both inclusive) determines the level of
>> + * analysis information reused in analysis-load. Higher the refine
>> level higher
>> + * the information reused. Default is 5 */
>> + int analysisLoadReuseLevel;
>> } x265_param;
>>
>> /* x265_param_alloc:
>> diff -r 4fcd8f1701a6 -r a28fd843b302 source/x265cli.h
>> --- a/source/x265cli.h Fri Jan 10 14:16:04 2020 +0530
>> +++ b/source/x265cli.h Fri Jan 10 17:01:08 2020 +0530
>> @@ -275,7 +275,9 @@
>> { "no-multi-pass-opt-rps", no_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-reuse-level", required_argument, NULL, 0 }, /*
>> DEPRECATED */
>> + { "analysis-save-reuse-level", required_argument, NULL, 0 },
>> + { "analysis-load-reuse-level", required_argument, NULL, 0 },
>> { "analysis-save", required_argument, NULL, 0 },
>> { "analysis-load", required_argument, NULL, 0 },
>> { "scale-factor", required_argument, NULL, 0 },
>> @@ -553,7 +555,9 @@
>> 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(" --analysis-reuse-level <1..10> Level of analysis reuse
>> indicates amount of info stored/reused in save/load mode, 1:least..10:most.
>> Now deprecated. Default %d\n", param->analysisReuseLevel);
>> + H0(" --analysis-save-reuse-level <1..10> Indicates the amount of
>> analysis info stored in save mode, 1:least..10:most. Default %d\n",
>> param->analysisSaveReuseLevel);
>> + H0(" --analysis-load-reuse-level <1..10> Indicates the amount of
>> analysis info reused in load mode, 1:least..10:most. Default %d\n",
>> param->analysisLoadReuseLevel);
>> H0(" --refine-analysis-type <string> Reuse anlaysis
>> information received through API call. Supported options are avc and hevc.
>> Default disabled - %d\n", param->bAnalysisType);
>> 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..4> Enable intra refinement for
>> encode that uses analysis-load.\n"
>> _______________________________________________
>> x265-devel mailing list
>> x265-devel at videolan.org
>> https://mailman.videolan.org/listinfo/x265-devel
>>
>
>
> --
> Regards,
> Kavitha
> _______________________________________________
> x265-devel mailing list
> x265-devel at videolan.org
> https://mailman.videolan.org/listinfo/x265-devel
>
--
Regards,
*Aruna Matheswaran,*
Video Codec Engineer,
Media & AI analytics BU,
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.videolan.org/pipermail/x265-devel/attachments/20200113/0031cce5/attachment-0001.html>
More information about the x265-devel
mailing list