Mercurial > x265
changeset 11955:a3334a263d26 draft
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.
| author | Aruna Matheswaran <aruna@multicorewareinc.com> |
|---|---|
| date | Thu, 21 Dec 2017 15:26:55 +0530 |
| parents | 37f6c378ac90 |
| children | 95fc0c4f03db |
| files | doc/reST/cli.rst source/CMakeLists.txt source/common/cudata.cpp source/common/param.cpp source/encoder/analysis.cpp source/encoder/api.cpp source/encoder/encoder.cpp source/encoder/encoder.h source/encoder/frameencoder.cpp source/encoder/search.cpp source/encoder/slicetype.cpp source/test/regression-tests.txt source/x265.cpp source/x265.h source/x265cli.h |
| diffstat | 15 files changed, 199 insertions(+-), 175 deletions(-) [+] |
line wrap: on
line diff
--- 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 @@ Analysis re-use options, to improve perf 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>
--- 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(NATIVE_BUILD "Target the build CP 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"
--- 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 @@ uint32_t CUData::getInterMergeCandidates 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 CUData::getPMV(InterNeighbourMV *nei 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;
--- 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 @@ void x265_param_default(x265_param* para 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 @@ int x265_param_parse(x265_param* p, cons 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 @@ int x265_param_parse(x265_param* p, cons } } 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 @@ int x265_check_params(x265_param* param) "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 @@ char *x265_param2string(x265_param* p, i 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 @@ char *x265_param2string(x265_param* p, i 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);
--- 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 @@ Mode& Analysis::compressCTU(CUData& ctu, } } - 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 @@ Mode& Analysis::compressCTU(CUData& ctu, 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 @@ Mode& Analysis::compressCTU(CUData& ctu, 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 @@ Mode& Analysis::compressCTU(CUData& ctu, } 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 @@ Mode& Analysis::compressCTU(CUData& ctu, /* 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 @@ uint64_t Analysis::compressIntraCU(const } /* 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 @@ SplitData Analysis::compressInterCU_rd0_ 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 @@ SplitData Analysis::compressInterCU_rd5_ 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 @@ void Analysis::checkInter_rd0_4(Mode& in 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 @@ void Analysis::checkInter_rd0_4(Mode& in } 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 @@ void Analysis::checkInter_rd5_6(Mode& in 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 @@ void Analysis::checkInter_rd5_6(Mode& in /* 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;
--- 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 @@ void x265_picture_init(x265_param *param 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;
--- 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 @@ Encoder::Encoder() 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 @@ void Encoder::create() 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 @@ void Encoder::destroy() 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 @@ void Encoder::destroy() { 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 @@ void Encoder::destroy() 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 @@ int Encoder::encode(const x265_picture* 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 @@ int Encoder::encode(const x265_picture* /* 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 @@ int Encoder::encode(const x265_picture* 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 @@ int Encoder::encode(const x265_picture* } /* 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 @@ int Encoder::encode(const x265_picture* 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 @@ int Encoder::encode(const x265_picture* 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 @@ int Encoder::encode(const x265_picture* } /* 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 @@ void Encoder::configure(x265_param *p) 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 @@ void Encoder::configure(x265_param *p) { 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 @@ void Encoder::configure(x265_param *p) 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 @@ void Encoder::configure(x265_param *p) 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 @@ void Encoder::configure(x265_param *p) 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 @@ void Encoder::configure(x265_param *p) } } /* 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 @@ void Encoder::readAnalysisFile(x265_anal 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 @@ void Encoder::readAnalysisFile(x265_anal /* 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 @@ void Encoder::readAnalysisFile(x265_anal 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 @@ void Encoder::readAnalysisFile(x265_anal 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 @@ void Encoder::readAnalysisFile(x265_anal 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 @@ void Encoder::readAnalysisFile(x265_anal { 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 @@ void Encoder::readAnalysisFile(x265_anal 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 @@ void Encoder::readAnalysisFile(x265_anal { 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 @@ void Encoder::readAnalysisFile(x265_anal } } 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 @@ void Encoder::writeAnalysisFile(x265_ana 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
--- 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 @@ public: 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;
--- 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 @@ void FrameEncoder::threadMain() 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 @@ void FrameEncoder::compressFrame() 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 @@ void FrameEncoder::compressFrame() 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 @@ void FrameEncoder::compressFrame() 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 @@ void FrameEncoder::compressFrame() 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 @@ void FrameEncoder::processRowEncoder(int /* 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;
--- 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 @@ void Search::singleMotionEstimation(Sear 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 @@ void Search::predInterSearch(Mode& inter 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 @@ void Search::predInterSearch(Mode& inter 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())
--- 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 @@ void Lookahead::destroy() /* 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 @@ Frame* Lookahead::getDecidedPicture() 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 @@ void Lookahead::getEstimatedPictureCost( 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 @@ void Lookahead::slicetypeDecide() { 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 @@ void Lookahead::slicetypeDecide() 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++)
--- 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,--prese 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_422.yuv, 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 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 u 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 me 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
--- 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 @@ int main(int argc, char **argv) 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;
--- 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 @@ typedef struct x265_picture * 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 @@ typedef enum #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 @@ typedef struct x265_param * 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 @@ typedef struct x265_param 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 @@ typedef struct x265_param * 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()
--- 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 @@ static const struct option long_options[ { "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 @@ static void showHelp(x265_param *param) 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"