[x265] [PATCH] Create API function for allocating and freeing x265_analysis_data
Ashok Kumar Mishra
ashok at multicorewareinc.com
Fri Jul 20 17:25:59 CEST 2018
On Fri, Jul 20, 2018 at 2:22 PM, <aasaipriya at multicorewareinc.com> wrote:
> # HG changeset patch
> # User Aasaipriya Chandran <aasaipriya at multicorewareinc.com>
> # Date 1532076622 -19800
> # Fri Jul 20 14:20:22 2018 +0530
> # Node ID fb1530b0e1b4ebd179b8098015213baeeb37c8d2
> # Parent e2759ae31c3638518d4a6358a884f569efae1298
> Create API function for allocating and freeing x265_analysis_data.
> 1. Merge the two overloaded functions existed for allocAnalysis and moved
> as API function - x265_alloc_analysis_data
> 2. Merge the two overloaded functions existed for freeAnalysis and moved
> as API function - x265_free_analysis_data
> 3. Bump up the build number as new API functions are added
> 4. Update the document
>
> diff -r e2759ae31c36 -r fb1530b0e1b4 doc/reST/api.rst
> --- a/doc/reST/api.rst Thu Jul 19 12:25:26 2018 +0530
> +++ b/doc/reST/api.rst Fri Jul 20 14:20:22 2018 +0530
> @@ -223,6 +223,18 @@
> * returns negative on error, 0 access unit were output.*/
> int x265_set_analysis_data(x265_encoder *encoder,
> x265_analysis_data *analysis_data, int poc, uint32_t cuBytes);
>
> +**x265_alloc_analysis_data()** may be used to allocate memory for the
> x265_analysis_data::
> +
> + /* x265_alloc_analysis_data:
> + * Allocate memory for the x265_analysis_data object's internal
> structures. */
> + void x265_alloc_analysis_data(x265_param *param,
> x265_analysis_data* analysis);
> +
> +**x265_free_analysis_data()** may be used to free memory for the
> x265_analysis_data::
> +
> + /* x265_free_analysis_data:
> + * Free the allocated memory for x265_analysis_data object's
> internal structures. */
> + void x265_free_analysis_data(x265_param *param, x265_analysis_data*
> analysis);
> +
> Pictures
> ========
>
> diff -r e2759ae31c36 -r fb1530b0e1b4 source/CMakeLists.txt
> --- a/source/CMakeLists.txt Thu Jul 19 12:25:26 2018 +0530
> +++ b/source/CMakeLists.txt Fri Jul 20 14:20:22 2018 +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 162)
> +set(X265_BUILD 163)
> configure_file("${PROJECT_SOURCE_DIR}/x265.def.in"
> "${PROJECT_BINARY_DIR}/x265.def")
> configure_file("${PROJECT_SOURCE_DIR}/x265_config.h.in"
> diff -r e2759ae31c36 -r fb1530b0e1b4 source/encoder/api.cpp
> --- a/source/encoder/api.cpp Thu Jul 19 12:25:26 2018 +0530
> +++ b/source/encoder/api.cpp Fri Jul 20 14:20:22 2018 +0530
> @@ -403,6 +403,175 @@
> return -1;
> }
>
> +void x265_alloc_analysis_data(x265_param *param, x265_analysis_data*
> analysis)
> +{
> + X265_CHECK(analysis->sliceType, "invalid slice type\n");
> + analysis->interData = analysis->intraData = analysis->distortionData
> = NULL;
> + bool isVbv = param->rc.vbvMaxBitrate > 0 && param->rc.vbvBufferSize >
> 0;
> + int numDir = 2; //irrespective of P or B slices set direction as 2
> + uint32_t numPlanes = param->internalCsp == X265_CSP_I400 ? 1 : 3;
> +
> + //Allocate memory for distortionData pointer
> + analysisDistortionData *distortionData = (analysisDistortionData*)
> analysis->distortionData;
> + CHECKED_MALLOC_ZERO(distortionData, analysisDistortionData, 1);
> + CHECKED_MALLOC_ZERO(distortionData->distortion, sse_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> + if (param->rc.bStatRead)
> + {
> + CHECKED_MALLOC_ZERO(distortionData->ctuDistortion, sse_t,
> analysis->numCUsInFrame);
> + CHECKED_MALLOC_ZERO(distortionData->scaledDistortion, double,
> analysis->numCUsInFrame);
> + CHECKED_MALLOC_ZERO(distortionData->offset, double,
> analysis->numCUsInFrame);
> + CHECKED_MALLOC_ZERO(distortionData->threshold, double,
> analysis->numCUsInFrame);
> + }
> + analysis->distortionData = distortionData;
> +
> + if (param->bDisableLookahead && isVbv)
> + {
> + CHECKED_MALLOC_ZERO(analysis->lookahead.intraSatdForVbv,
> uint32_t, analysis->numCuInHeight);
> + CHECKED_MALLOC_ZERO(analysis->lookahead.satdForVbv, uint32_t,
> analysis->numCuInHeight);
> + CHECKED_MALLOC_ZERO(analysis->lookahead.intraVbvCost, uint32_t,
> analysis->numCUsInFrame);
> + CHECKED_MALLOC_ZERO(analysis->lookahead.vbvCost, uint32_t,
> analysis->numCUsInFrame);
> + }
> +
> + //Allocate memory for weightParam pointer
> + if (!(param->bMVType == AVC_INFO))
> + CHECKED_MALLOC_ZERO(analysis->wt, WeightParam, numPlanes *
> numDir);
> +
> + if (param->analysisReuseLevel < 2)
> + return;
> +
> + //Allocate memory for intraData pointer
> + analysis_intra_data *intraData = (analysis_intra_data*)
> analysis->intraData;
> + CHECKED_MALLOC_ZERO(intraData, analysis_intra_data, 1);
> + CHECKED_MALLOC(intraData->depth, uint8_t, analysis->numPartitions *
> analysis->numCUsInFrame);
> + CHECKED_MALLOC(intraData->modes, uint8_t, analysis->numPartitions *
> analysis->numCUsInFrame);
> + CHECKED_MALLOC(intraData->partSizes, char, analysis->numPartitions *
> analysis->numCUsInFrame);
> + CHECKED_MALLOC(intraData->chromaModes, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> + analysis->intraData = intraData;
> +
> + //Allocate memory for interData pointer based on ReuseLevels
> + analysis_inter_data *interData = (analysis_inter_data*)
> analysis->interData;
> + CHECKED_MALLOC_ZERO(interData, analysis_inter_data, 1);
> + CHECKED_MALLOC(interData->depth, uint8_t, analysis->numPartitions *
> analysis->numCUsInFrame);
> + CHECKED_MALLOC(interData->modes, uint8_t, analysis->numPartitions *
> analysis->numCUsInFrame);
> +
> + CHECKED_MALLOC_ZERO(interData->mvpIdx[0], uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> + CHECKED_MALLOC_ZERO(interData->mvpIdx[1], uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> + CHECKED_MALLOC_ZERO(interData->mv[0], MV, analysis->numPartitions *
> analysis->numCUsInFrame);
> + CHECKED_MALLOC_ZERO(interData->mv[1], MV, analysis->numPartitions *
> analysis->numCUsInFrame);
> +
> + if (param->analysisReuseLevel > 4)
> + {
> + CHECKED_MALLOC(interData->partSize, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> + CHECKED_MALLOC_ZERO(interData->mergeFlag, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> + }
> + if (param->analysisReuseLevel >= 7)
> + {
> + CHECKED_MALLOC(interData->interDir, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> + CHECKED_MALLOC(interData->sadCost, int64_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> + for (int dir = 0; dir < numDir; dir++)
> + {
> + CHECKED_MALLOC(interData->refIdx[dir], int8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> + CHECKED_MALLOC_ZERO(analysis->modeFlag[dir], uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> + }
> + }
> + else
> + {
> + if (param->analysisMultiPassRefine || param->
> analysisMultiPassDistortion){
> + CHECKED_MALLOC_ZERO(interData->ref, int32_t, 2 *
> analysis->numPartitions * analysis->numCUsInFrame);
> + }
> + else
> + CHECKED_MALLOC_ZERO(interData->ref, int32_t,
> analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir);
> + }
> + analysis->interData = interData;
> +
> + return;
> +
> +fail:
> + x265_free_analysis_data(param, analysis);
> +}
> +
> +void x265_free_analysis_data(x265_param *param, x265_analysis_data*
> analysis)
> +{
> + bool isVbv = param->rc.vbvMaxBitrate > 0 && param->rc.vbvBufferSize >
> 0;
> +
> + //Free memory for Lookahead pointers
> + if (param->bDisableLookahead && isVbv)
> + {
> + X265_FREE(analysis->lookahead.satdForVbv);
> + X265_FREE(analysis->lookahead.intraSatdForVbv);
> + X265_FREE(analysis->lookahead.vbvCost);
> + X265_FREE(analysis->lookahead.intraVbvCost);
> + }
> +
> + //Free memory for distortionData pointers
> + if (analysis->distortionData)
> + {
> + X265_FREE(((analysisDistortionData*)analysis->distortionData)->
> distortion);
> + if (param->rc.bStatRead)
> + {
> + X265_FREE(((analysisDistortionData*)
> analysis->distortionData)->ctuDistortion);
> + X265_FREE(((analysisDistortionData*)
> analysis->distortionData)->scaledDistortion);
> + X265_FREE(((analysisDistortionData*)
> analysis->distortionData)->offset);
> + X265_FREE(((analysisDistortionData*)
> analysis->distortionData)->threshold);
> + }
> + X265_FREE(analysis->distortionData);
> + }
> +
> + /* Early exit freeing weights alone if level is 1 (when there is no
> analysis inter/intra) */
> + if (analysis->wt && !(param->bMVType == AVC_INFO))
> + X265_FREE(analysis->wt);
> +
> + if (param->analysisReuseLevel < 2)
> + return;
> +
> + //Free memory for intraData pointers
> + if (analysis->intraData)
> + {
> + X265_FREE(((analysis_intra_data*)analysis->intraData)->depth);
> + X265_FREE(((analysis_intra_data*)analysis->intraData)->modes);
> + X265_FREE(((analysis_intra_data*)analysis->intraData)->
> partSizes);
> + X265_FREE(((analysis_intra_data*)analysis->intraData)->
> chromaModes);
> + X265_FREE(analysis->intraData);
> + analysis->intraData = NULL;
> + }
> +
> + //Free interData pointers
> + if (analysis->interData)
> + {
> + X265_FREE(((analysis_inter_data*)analysis->interData)->depth);
> + X265_FREE(((analysis_inter_data*)analysis->interData)->modes);
> + X265_FREE(((analysis_inter_data*)analysis->interData)->
> mvpIdx[0]);
> + X265_FREE(((analysis_inter_data*)analysis->interData)->
> mvpIdx[1]);
> + X265_FREE(((analysis_inter_data*)analysis->interData)->mv[0]);
> + X265_FREE(((analysis_inter_data*)analysis->interData)->mv[1]);
> +
> + if (param->analysisReuseLevel > 4)
> + {
> + X265_FREE(((analysis_inter_data*)analysis->interData)->
> mergeFlag);
> + X265_FREE(((analysis_inter_data*)analysis->interData)->
> partSize);
> + }
> + if (param->analysisReuseLevel >= 7)
> + {
> + int numDir = 2;
> + X265_FREE(((analysis_inter_data*)analysis->interData)->
> interDir);
> + X265_FREE(((analysis_inter_data*)analysis->interData)->
> sadCost);
> + for (int dir = 0; dir < numDir; dir++)
> + {
> + X265_FREE(((analysis_inter_data*)analysis->interData)->
> refIdx[dir]);
> + if (analysis->modeFlag[dir] != NULL)
> + {
> + X265_FREE(analysis->modeFlag[dir]);
> + analysis->modeFlag[dir] = NULL;
> + }
> + }
> + }
> + else
> + X265_FREE(((analysis_inter_data*)analysis->interData)->ref);
> + X265_FREE(analysis->interData);
> + analysis->interData = NULL;
> + }
> +}
> +
> void x265_cleanup(void)
> {
> BitCost::destroy();
> diff -r e2759ae31c36 -r fb1530b0e1b4 source/encoder/encoder.cpp
> --- a/source/encoder/encoder.cpp Thu Jul 19 12:25:26 2018 +0530
> +++ b/source/encoder/encoder.cpp Fri Jul 20 14:20:22 2018 +0530
> @@ -641,7 +641,7 @@
> curFrame->m_analysisData = (*analysis_data);
> curFrame->m_analysisData.numCUsInFrame = widthInCU * heightInCU;
> curFrame->m_analysisData.numPartitions =
> m_param->num4x4Partitions;
> - allocAnalysis(&curFrame->m_analysisData);
> + x265_alloc_analysis_data(m_param, &curFrame->m_analysisData);
> if (m_param->maxCUSize == 16)
> {
> if (analysis_data->sliceType == X265_TYPE_IDR ||
> analysis_data->sliceType == X265_TYPE_I)
> @@ -901,7 +901,7 @@
> if (m_exportedPic)
> {
> if (!m_param->bUseAnalysisFile && m_param->analysisSave)
> - freeAnalysis(&m_exportedPic->m_analysisData);
> + x265_free_analysis_data(m_param, &m_exportedPic->m_
> analysisData);
> ATOMIC_DEC(&m_exportedPic->m_countRefEncoders);
> m_exportedPic = NULL;
> m_dpb->recycleUnreferenced();
> @@ -1209,7 +1209,7 @@
>
> /* Free up pic_in->analysisData since it has already been
> used */
> if ((m_param->analysisLoad && !m_param->analysisSave) ||
> (m_param->bMVType && slice->m_sliceType != I_SLICE))
> - freeAnalysis(&outFrame->m_analysisData);
> + x265_free_analysis_data(m_param,
> &outFrame->m_analysisData);
>
> if (pic_out)
> {
> @@ -1248,6 +1248,7 @@
> pic_out->analysisData.intraData =
> outFrame->m_analysisData.intraData;
> pic_out->analysisData.modeFlag[0] =
> outFrame->m_analysisData.modeFlag[0];
> pic_out->analysisData.modeFlag[1] =
> outFrame->m_analysisData.modeFlag[1];
> + pic_out->analysisData.distortionData =
> outFrame->m_analysisData.distortionData;
> if (m_param->bDisableLookahead)
> {
> int factor = 1;
> @@ -1286,7 +1287,7 @@
> writeAnalysisFile(&pic_out->analysisData,
> *outFrame->m_encData);
> pic_out->analysisData.saveParam =
> pic_out->analysisData.saveParam;
> if (m_param->bUseAnalysisFile)
> - freeAnalysis(&pic_out->analysisData);
> + x265_free_analysis_data(m_param,
> &pic_out->analysisData);
> }
> }
> if (m_param->rc.bStatWrite && (m_param->analysisMultiPassRefine
> || m_param->analysisMultiPassDistortion))
> @@ -1298,10 +1299,10 @@
> pic_out->analysisData.intraData =
> outFrame->m_analysisData.intraData;
> pic_out->analysisData.distortionData =
> outFrame->m_analysisData.distortionData;
> }
> - writeAnalysisFile(&outFrame->m_analysisData,
> *outFrame->m_encData, outFrame->m_lowres.sliceType);
> + writeAnalysisFileRefine(&outFrame->m_analysisData,
> *outFrame->m_encData);
> }
> if (m_param->analysisMultiPassRefine || m_param->
> analysisMultiPassDistortion)
> - freeAnalysis(&outFrame->m_analysisData,
> outFrame->m_lowres.sliceType);
> + x265_free_analysis_data(m_param,
> &outFrame->m_analysisData);
> if (m_param->internalCsp == X265_CSP_I400)
> {
> if (slice->m_sliceType == P_SLICE)
> @@ -1410,7 +1411,7 @@
> uint32_t heightInCU = (m_param->sourceHeight +
> m_param->maxCUSize - 1) >> m_param->maxLog2CUSize;
> frameEnc->m_analysisData.numCUsInFrame = widthInCU *
> heightInCU;
> frameEnc->m_analysisData.numPartitions =
> m_param->num4x4Partitions;
> - allocAnalysis(&frameEnc->m_analysisData,
> frameEnc->m_lowres.sliceType);
> + x265_alloc_analysis_data(m_param,
> &frameEnc->m_analysisData);
> frameEnc->m_analysisData.poc = frameEnc->m_poc;
> if (m_param->rc.bStatRead)
> readAnalysisFile(&frameEnc->m_analysisData,
> frameEnc->m_poc, frameEnc->m_lowres.sliceType);
> @@ -1555,7 +1556,7 @@
> analysis->numCUsInFrame = numCUsInFrame;
> analysis->numCuInHeight = heightInCU;
> analysis->numPartitions = m_param->num4x4Partitions;
> - allocAnalysis(analysis);
> + x265_alloc_analysis_data(m_param, analysis);
> }
> /* determine references, setup RPS, etc */
> m_dpb->prepareEncode(frameEnc);
> @@ -3181,232 +3182,6 @@
>
> }
>
> -void Encoder::allocAnalysis(x265_analysis_data* analysis)
> -{
> - X265_CHECK(analysis->sliceType, "invalid slice type\n");
> - analysis->interData = analysis->intraData = NULL;
> - if (m_param->bDisableLookahead && m_rateControl->m_isVbv)
> - {
> - CHECKED_MALLOC_ZERO(analysis->lookahead.intraSatdForVbv,
> uint32_t, analysis->numCuInHeight);
> - CHECKED_MALLOC_ZERO(analysis->lookahead.satdForVbv, uint32_t,
> analysis->numCuInHeight);
> - CHECKED_MALLOC_ZERO(analysis->lookahead.intraVbvCost, uint32_t,
> analysis->numCUsInFrame);
> - CHECKED_MALLOC_ZERO(analysis->lookahead.vbvCost, uint32_t,
> analysis->numCUsInFrame);
> - }
> - if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType ==
> X265_TYPE_I)
> - {
> - if (m_param->analysisReuseLevel < 2)
> - return;
> -
> - analysis_intra_data *intraData = (analysis_intra_data*)
> analysis->intraData;
> - CHECKED_MALLOC_ZERO(intraData, analysis_intra_data, 1);
> - CHECKED_MALLOC(intraData->depth, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC(intraData->modes, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC(intraData->partSizes, char,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC(intraData->chromaModes, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - analysis->intraData = intraData;
> - }
> - else
> - {
> - int numDir = analysis->sliceType == X265_TYPE_P ? 1 : 2;
> - uint32_t numPlanes = m_param->internalCsp == X265_CSP_I400 ? 1 :
> 3;
> - if (!(m_param->bMVType == AVC_INFO))
> - CHECKED_MALLOC_ZERO(analysis->wt, WeightParam, numPlanes *
> numDir);
> - if (m_param->analysisReuseLevel < 2)
> - return;
> -
> - analysis_inter_data *interData = (analysis_inter_data*)
> analysis->interData;
> - CHECKED_MALLOC_ZERO(interData, analysis_inter_data, 1);
> - CHECKED_MALLOC(interData->depth, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC(interData->modes, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - if (m_param->analysisReuseLevel > 4)
> - {
> - CHECKED_MALLOC(interData->partSize, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC_ZERO(interData->mergeFlag, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - }
> - if (m_param->analysisReuseLevel >= 7)
> - {
> - CHECKED_MALLOC(interData->interDir, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC(interData->sadCost, int64_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - for (int dir = 0; dir < numDir; dir++)
> - {
> - CHECKED_MALLOC(interData->mvpIdx[dir], uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC(interData->refIdx[dir], int8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC(interData->mv[dir], MV,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC_ZERO(analysis->modeFlag[dir], uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - }
> - /* Allocate intra in inter */
> - if (analysis->sliceType == X265_TYPE_P ||
> m_param->bIntraInBFrames)
> - {
> - analysis_intra_data *intraData = (analysis_intra_data*)
> analysis->intraData;
> - CHECKED_MALLOC_ZERO(intraData, analysis_intra_data, 1);
> - CHECKED_MALLOC(intraData->modes, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC(intraData->chromaModes, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - analysis->intraData = intraData;
> - }
> - }
> - else
> - CHECKED_MALLOC_ZERO(interData->ref, int32_t,
> analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir);
> -
> - analysis->interData = interData;
> - }
> - return;
> -
> -fail:
> - freeAnalysis(analysis);
> - m_aborted = true;
> -}
> -void Encoder::freeAnalysis(x265_analysis_data* analysis)
> -{
> - if (m_param->bDisableLookahead && m_rateControl->m_isVbv)
> - {
> - X265_FREE(analysis->lookahead.satdForVbv);
> - X265_FREE(analysis->lookahead.intraSatdForVbv);
> - X265_FREE(analysis->lookahead.vbvCost);
> - X265_FREE(analysis->lookahead.intraVbvCost);
> - }
> - /* Early exit freeing weights alone if level is 1 (when there is no
> analysis inter/intra) */
> - if (analysis->sliceType > X265_TYPE_I && analysis->wt &&
> !(m_param->bMVType == AVC_INFO))
> - X265_FREE(analysis->wt);
> - if (m_param->analysisReuseLevel < 2)
> - return;
> -
> - if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType ==
> X265_TYPE_I)
> - {
> - if (analysis->intraData)
> - {
> - X265_FREE(((analysis_intra_data*)analysis->intraData)->
> depth);
> - X265_FREE(((analysis_intra_data*)analysis->intraData)->
> modes);
> - X265_FREE(((analysis_intra_data*)analysis->intraData)->
> partSizes);
> - X265_FREE(((analysis_intra_data*)analysis->intraData)->
> chromaModes);
> - X265_FREE(analysis->intraData);
> - analysis->intraData = NULL;
> - }
> - }
> - else
> - {
> - if (analysis->intraData)
> - {
> - X265_FREE(((analysis_intra_data*)analysis->intraData)->
> modes);
> - X265_FREE(((analysis_intra_data*)analysis->intraData)->
> chromaModes);
> - X265_FREE(analysis->intraData);
> - analysis->intraData = NULL;
> - }
> - if (analysis->interData)
> - {
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> depth);
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> modes);
> - if (m_param->analysisReuseLevel > 4)
> - {
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> mergeFlag);
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> partSize);
> - }
> - if (m_param->analysisReuseLevel >= 7)
> - {
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> interDir);
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> sadCost);
> - int numDir = analysis->sliceType == X265_TYPE_P ? 1 : 2;
> - for (int dir = 0; dir < numDir; dir++)
> - {
> - X265_FREE(((analysis_inter_
> data*)analysis->interData)->mvpIdx[dir]);
> - X265_FREE(((analysis_inter_
> data*)analysis->interData)->refIdx[dir]);
> - X265_FREE(((analysis_inter_
> data*)analysis->interData)->mv[dir]);
> - if (analysis->modeFlag[dir] != NULL)
> - {
> - X265_FREE(analysis->modeFlag[dir]);
> - analysis->modeFlag[dir] = NULL;
> - }
> - }
> - }
> - else
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> ref);
> -
> - X265_FREE(analysis->interData);
> - analysis->interData = NULL;
> - }
> - }
> -}
> -
> -void Encoder::allocAnalysis(x265_analysis_data* analysis, int sliceType)
> -{
> - analysis->interData = analysis->intraData = analysis->distortionData
> = NULL;
> -
> - analysisDistortionData *distortionData = (analysisDistortionData*)
> analysis->distortionData;
> - CHECKED_MALLOC_ZERO(distortionData, analysisDistortionData, 1);
> - CHECKED_MALLOC_ZERO(distortionData->distortion, sse_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - if (m_param->rc.bStatRead)
> - {
> - CHECKED_MALLOC_ZERO(distortionData->ctuDistortion, sse_t,
> analysis->numCUsInFrame);
> - CHECKED_MALLOC_ZERO(distortionData->scaledDistortion, double,
> analysis->numCUsInFrame);
> - CHECKED_MALLOC_ZERO(distortionData->offset, double,
> analysis->numCUsInFrame);
> - CHECKED_MALLOC_ZERO(distortionData->threshold, double,
> analysis->numCUsInFrame);
> - }
> - analysis->distortionData = distortionData;
> -
> - if (IS_X265_TYPE_I(sliceType))
> - {
> - analysis_intra_data *intraData = (analysis_intra_data*)
> analysis->intraData;
> - CHECKED_MALLOC_ZERO(intraData, analysis_intra_data, 1);
> - CHECKED_MALLOC(intraData->depth, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - analysis->intraData = intraData;
> - }
> - else
> - {
> - analysis_inter_data *interData = (analysis_inter_data*)
> analysis->interData;
> - CHECKED_MALLOC_ZERO(interData, analysis_inter_data, 1);
> - CHECKED_MALLOC_ZERO(interData->depth, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC(interData->modes, uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC_ZERO(interData->mvpIdx[0], uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC_ZERO(interData->mvpIdx[1], uint8_t,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC_ZERO(interData->mv[0], MV,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC_ZERO(interData->mv[1], MV,
> analysis->numPartitions * analysis->numCUsInFrame);
> - CHECKED_MALLOC_ZERO(interData->ref, int32_t, 2 *
> analysis->numPartitions * analysis->numCUsInFrame);
> - analysis->interData = interData;
> - }
> - return;
> -
> -fail:
> - freeAnalysis(analysis, sliceType);
> - m_aborted = true;
> -}
> -
> -void Encoder::freeAnalysis(x265_analysis_data* analysis, int sliceType)
> -{
> - if (analysis->distortionData)
> - {
> - X265_FREE(((analysisDistortionData*)analysis->distortionData)->
> distortion);
> - if (m_param->rc.bStatRead)
> - {
> - X265_FREE(((analysisDistortionData*)
> analysis->distortionData)->ctuDistortion);
> - X265_FREE(((analysisDistortionData*)
> analysis->distortionData)->scaledDistortion);
> - X265_FREE(((analysisDistortionData*)
> analysis->distortionData)->offset);
> - X265_FREE(((analysisDistortionData*)
> analysis->distortionData)->threshold);
> - }
> - X265_FREE(analysis->distortionData);
> - }
> - if (IS_X265_TYPE_I(sliceType))
> - {
> - if (analysis->intraData)
> - {
> - X265_FREE(((analysis_intra_data*)analysis->intraData)->
> depth);
> - X265_FREE(analysis->intraData);
> - }
> - }
> - else
> - {
> - if (analysis->interData)
> - {
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> mvpIdx[0]);
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> mvpIdx[1]);
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> mv[0]);
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> mv[1]);
> - X265_FREE(((analysis_inter_data*)analysis->interData)->ref);
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> depth);
> - X265_FREE(((analysis_inter_data*)analysis->interData)->
> modes);
> - X265_FREE(analysis->interData);
> - }
> - }
> -}
> -
> void Encoder::readAnalysisFile(x265_analysis_data* analysis, int curPoc,
> const x265_picture* picIn, int paramBytes)
> {
> #define X265_FREAD(val, size, readSize, fileOffset, src)\
> @@ -3417,7 +3192,7 @@
> else if (fread(val, size, readSize, fileOffset) != readSize)\
> {\
> x265_log(NULL, X265_LOG_ERROR, "Error reading analysis data\n");\
> - freeAnalysis(analysis);\
> + x265_free_analysis_data(m_param, analysis);\
> m_aborted = true;\
> return;\
> }\
> @@ -3452,7 +3227,7 @@
> if (poc != curPoc || feof(m_analysisFileIn))
> {
> x265_log(NULL, X265_LOG_WARNING, "Error reading analysis
> data: Cannot find POC %d\n", curPoc);
> - freeAnalysis(analysis);
> + x265_free_analysis_data(m_param, analysis);
> return;
> }
> }
> @@ -3476,7 +3251,7 @@
> if (m_param->scaleFactor)
> analysis->numPartitions *= factor;
> /* Memory is allocated for inter and intra analysis data based on the
> slicetype */
> - allocAnalysis(analysis);
> + x265_alloc_analysis_data(m_param, analysis);
> if (m_param->bDisableLookahead && m_rateControl->m_isVbv)
> {
> size_t vbvCount = m_param->lookaheadDepth + m_param->bframes + 2;
> @@ -3695,7 +3470,7 @@
> else if (fread(val, size, readSize, fileOffset) != readSize)\
> {\
> x265_log(NULL, X265_LOG_ERROR, "Error reading analysis data\n");\
> - freeAnalysis(analysis);\
> + x265_free_analysis_data(m_param, analysis);\
> m_aborted = true;\
> return;\
> }\
> @@ -3731,7 +3506,7 @@
> if (poc != curPoc || feof(m_analysisFileIn))
> {
> x265_log(NULL, X265_LOG_WARNING, "Error reading analysis
> data: Cannot find POC %d\n", curPoc);
> - freeAnalysis(analysis);
> + x265_free_analysis_data(m_param, analysis);
> return;
> }
> }
> @@ -3761,7 +3536,7 @@
> analysis->numCuInHeight = cuLoc.heightInCU;
>
> /* Memory is allocated for inter and intra analysis data based on the
> slicetype */
> - allocAnalysis(analysis);
> + x265_alloc_analysis_data(m_param, analysis);
>
> analysis->numPartitions = numPartitions * factor;
> analysis->numCUsInFrame = numCUsInFrame;
> @@ -4275,7 +4050,7 @@
> if (fread(val, size, readSize, fileOffset) != readSize)\
> {\
> x265_log(NULL, X265_LOG_ERROR, "Error reading analysis 2 pass
> data\n"); \
> - freeAnalysis(analysis, sliceType); \
> + x265_alloc_analysis_data(m_param, analysis); \
> m_aborted = true; \
> return; \
> }\
> @@ -4289,7 +4064,7 @@
> if (poc != curPoc || feof(m_analysisFileIn))
> {
> x265_log(NULL, X265_LOG_WARNING, "Error reading analysis 2 pass
> data: Cannot find POC %d\n", curPoc);
> - freeAnalysis(analysis, sliceType);
> + x265_free_analysis_data(m_param, analysis);
> return;
> }
> /* Now arrived at the right frame, read the record */
> @@ -4405,7 +4180,7 @@
> if (fwrite(val, size, writeSize, fileOffset) < writeSize)\
> {\
> x265_log(NULL, X265_LOG_ERROR, "Error writing analysis data\n");\
> - freeAnalysis(analysis);\
> + x265_free_analysis_data(m_param, analysis);\
> m_aborted = true;\
> return;\
> }\
> @@ -4598,13 +4373,13 @@
> #undef X265_FWRITE
> }
>
> -void Encoder::writeAnalysisFile(x265_analysis_data* analysis, FrameData
> &curEncData, int slicetype)
> +void Encoder::writeAnalysisFileRefine(x265_analysis_data* analysis,
> FrameData &curEncData)
> {
> #define X265_FWRITE(val, size, writeSize, fileOffset)\
> if (fwrite(val, size, writeSize, fileOffset) < writeSize)\
> {\
> x265_log(NULL, X265_LOG_ERROR, "Error writing analysis 2 pass
> data\n"); \
> - freeAnalysis(analysis, slicetype); \
> + x265_free_analysis_data(m_param, analysis); \
> m_aborted = true; \
> return; \
> }\
> diff -r e2759ae31c36 -r fb1530b0e1b4 source/encoder/encoder.h
> --- a/source/encoder/encoder.h Thu Jul 19 12:25:26 2018 +0530
> +++ b/source/encoder/encoder.h Fri Jul 20 14:20:22 2018 +0530
> @@ -275,14 +275,6 @@
>
> void updateVbvPlan(RateControl* rc);
>
> - void allocAnalysis(x265_analysis_data* analysis);
> -
> - void allocAnalysis(x265_analysis_data* analysis, int sliceType);
> -
> - void freeAnalysis(x265_analysis_data* analysis);
> -
> - void freeAnalysis(x265_analysis_data* analysis, int sliceType);
> -
> void readAnalysisFile(x265_analysis_data* analysis, int poc, int
> sliceType);
>
> void readAnalysisFile(x265_analysis_data* analysis, int poc, const
> x265_picture* picIn, int paramBytes);
> @@ -295,7 +287,7 @@
>
> void writeAnalysisFile(x265_analysis_data* analysis, FrameData
> &curEncData);
>
> - void writeAnalysisFile(x265_analysis_data* analysis, FrameData
> &curEncData, int slicetype);
> + void writeAnalysisFileRefine(x265_analysis_data* analysis, FrameData
> &curEncData);
>
> void finishFrameStats(Frame* pic, FrameEncoder *curEncoder,
> x265_frame_stats* frameStats, int inPoc);
>
> diff -r e2759ae31c36 -r fb1530b0e1b4 source/x265.h
> --- a/source/x265.h Thu Jul 19 12:25:26 2018 +0530
> +++ b/source/x265.h Fri Jul 20 14:20:22 2018 +0530
> @@ -1757,6 +1757,14 @@
> * A static string describing the compiler and target architecture */
> X265_API extern const char *x265_build_info_str;
>
> +/* x265_alloc_analysis_data:
> +* Allocate memory for the x265_analysis_data object's internal
> structures. */
> +void x265_alloc_analysis_data(x265_param *param, x265_analysis_data*
> analysis);
> +
> +/*
> +* Free the allocated memory for x265_analysis_data object's internal
> structures. */
> +void x265_free_analysis_data(x265_param *param, x265_analysis_data*
> analysis);
> +
> /* Force a link error in the case of linking against an incompatible API
> version.
> * Glue #defines exist to force correct macro expansion; the final output
> of the macro
> * is x265_encoder_open_##X265_BUILD (for purposes of dlopen). */
>
> _______________________________________________
> x265-devel mailing list
> x265-devel at videolan.org
> https://mailman.videolan.org/listinfo/x265-devel
>
>
Thank you. Pushed to default.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.videolan.org/pipermail/x265-devel/attachments/20180720/e2215f60/attachment-0001.html>
More information about the x265-devel
mailing list