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