[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