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