[x265] [PATCH 2/3] Memory Leak Fix: Part 2
chen
chenm003 at 163.com
Mon Nov 11 04:21:48 UTC 2024
Hi Jean-Baptiste,
Thank for the comment.
Agree with you, the hard coded max string size is not good idea.
However, it is workaround for current Zone design, in the Zone code, we memcpy struct directly, it made two problems
1) pointer overwrite/lost (memory leak)
2) infinite recursion design (param->zone[X]->zone[Y]->zone[Z] ...), necessary memcpy other than struct information copy
In above reason, suggest use fixed length string until we improve Zone design.
Regards,
Chen
2024-11-10 18:53:25，"Jean-Baptiste Kempf" <jb at videolan.org>
Hard coding a max string size is pretty bad and will fail.
On Sun, 10 Nov 2024, at 06:40, Pavan Tarun Chakka Venkata wrote:
From e33b7bc78be5d49dd510435981231a63f1c76aec Mon Sep 17 00:00:00 2001
From: Min Chen <chenm003 at 163.com>
Date: Sat, 9 Nov 2024 12:58:49 +0530
Subject: [PATCH 2/3] Memory Leak Fix: Part 2
---
source/CMakeLists.txt | 2 +-
source/abrEncApp.cpp | 9 +-
source/common/param.cpp | 140 ++++++++++++++++---------------
source/common/temporalfilter.cpp | 7 ++
source/common/temporalfilter.h | 2 +-
source/common/threadpool.cpp | 4 +-
source/encoder/analysis.cpp | 6 +-
source/encoder/api.cpp | 17 +++-
source/encoder/encoder.cpp | 111 +++++++++++-------------
source/encoder/encoder.h | 1 +
source/encoder/frameencoder.cpp | 12 ++-
source/encoder/framefilter.cpp | 8 +-
source/encoder/ratecontrol.cpp | 4 +-
source/encoder/search.cpp | 4 +-
source/encoder/slicetype.cpp | 16 ++--
source/x265.cpp | 24 ++++--
source/x265.h | 28 ++++---
source/x265cli.cpp | 7 +-
source/x265cli.h | 8 +-
19 files changed, 210 insertions(+), 200 deletions(-)
diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
index 310683909..14f6ccc49 100755
--- a/source/CMakeLists.txt
+++ b/source/CMakeLists.txt
@@ -31,7 +31,7 @@ option(NATIVE_BUILD "Target the build CPU" OFF)
option(STATIC_LINK_CRT "Statically link C and C++ runtimes 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 213)
+set(X265_BUILD 214)
configure_file("${PROJECT_SOURCE_DIR}/x265.def.in"
"${PROJECT_BINARY_DIR}/x265.def")
configure_file("${PROJECT_SOURCE_DIR}/x265_config.h.in"
diff --git a/source/abrEncApp.cpp b/source/abrEncApp.cpp
index ebdd3b3ba..a56e14cde 100644
--- a/source/abrEncApp.cpp
+++ b/source/abrEncApp.cpp
@@ -282,8 +282,8 @@ namespace X265_NS {
m_param->analysisLoadReuseLevel = m_cliopt.loadLevel;
m_param->analysisSaveReuseLevel = m_cliopt.saveLevel;
- m_param->analysisSave = m_cliopt.saveLevel ? "save.dat" : NULL;
- m_param->analysisLoad = m_cliopt.loadLevel ? "load.dat" : NULL;
+ strcpy(m_param->analysisSave, m_cliopt.saveLevel ? "save.dat" : "");
+ strcpy(m_param->analysisLoad, m_cliopt.loadLevel ? "load.dat" : "");
m_param->bUseAnalysisFile = 0;
if (m_cliopt.loadLevel)
@@ -599,7 +599,7 @@ ret:
x265_picture* pic_recon;
x265_picture pic_out[MAX_LAYERS];
- pic_recon = (m_cliopt.recon[0] || m_param->analysisSave || m_param->analysisLoad || pts_queue || reconPlay || m_param->csvLogLevel) ? pic_out : NULL;
+ pic_recon = (m_cliopt.recon[0] || strlen(m_param->analysisSave) || strlen(m_param->analysisLoad) || pts_queue || reconPlay || m_param->csvLogLevel) ? pic_out : NULL;
uint32_t inFrameCount = 0;
uint32_t outFrameCount = 0;
x265_nal *p_nal;
@@ -895,7 +895,7 @@ ret:
delete reconPlay;
api->encoder_get_stats(m_encoder, &stats, sizeof(stats));
- if (m_param->csvfn && !b_ctrl_c)
+ if (strlen(m_param->csvfn) && !b_ctrl_c)
#if ENABLE_LIBVMAF
api->vmaf_encoder_log(m_encoder, m_cliopt.argCnt, m_cliopt.argString, m_cliopt.param, vmafdata);
#else
@@ -919,7 +919,6 @@ ret:
if (b_ctrl_c)
general_log(m_param, NULL, X265_LOG_INFO, "aborted at input frame %d, output frame %d in %s\n",
m_cliopt.seek + inFrameCount, stats.encodedPictureCount, profileName);
- if(m_param->numaPools) free((char*)m_param->numaPools);
api->param_free(m_param);
X265_FREE(errorBuf);
diff --git a/source/common/param.cpp b/source/common/param.cpp
index 1beb3c056..010721315 100755
--- a/source/common/param.cpp
+++ b/source/common/param.cpp
@@ -94,6 +94,7 @@ namespace X265_NS {
x265_param *x265_param_alloc()
{
x265_param* param = (x265_param*)x265_malloc(sizeof(x265_param));
+ memset(param, 0, sizeof(x265_param));
#ifdef SVT_HEVC
param->svtHevcParam = (EB_H265_ENC_CONFIGURATION*)x265_malloc(sizeof(EB_H265_ENC_CONFIGURATION));
#endif
@@ -151,8 +152,8 @@ void x265_param_default(x265_param* param)
param->logLevel = X265_LOG_INFO;
param->csvLogLevel = 0;
- param->csvfn = NULL;
- param->rc.lambdaFileName = NULL;
+ param->csvfn[0] = 0;
+ param->rc.lambdaFileName[0] = 0;
param->bLogCuStats = 0;
param->decodedPictureHashSEI = 0;
@@ -279,9 +280,9 @@ void x265_param_default(x265_param* param)
param->analysisReuseMode = 0; /*DEPRECATED*/
param->analysisMultiPassRefine = 0;
param->analysisMultiPassDistortion = 0;
- param->analysisReuseFileName = NULL;
- param->analysisSave = NULL;
- param->analysisLoad = NULL;
+ param->analysisReuseFileName[0] = 0;
+ param->analysisSave[0] = 0;
+ param->analysisLoad[0] = 0;
param->bIntraInBFrames = 1;
param->bLossless = 0;
param->bCULossless = 0;
@@ -317,8 +318,8 @@ void x265_param_default(x265_param* param)
param->rc.bStatRead = 0;
param->rc.bStatWrite = 0;
param->rc.dataShareMode = X265_SHARE_MODE_FILE;
- param->rc.statFileName = NULL;
- param->rc.sharedMemName = NULL;
+ param->rc.statFileName[0] = 0;
+ param->rc.sharedMemName[0] = 0;
param->rc.bEncFocusedFramesOnly = 0;
param->rc.complexityBlur = 20;
param->rc.qblur = 0.5;
@@ -362,7 +363,7 @@ void x265_param_default(x265_param* param)
param->maxLuma = PIXEL_MAX;
param->log2MaxPocLsb = 8;
param->maxSlices = 1;
- param->videoSignalTypePreset = NULL;
+ param->videoSignalTypePreset[0] = 0;
/*Conformance window*/
param->confWinRightOffset = 0;
@@ -379,7 +380,7 @@ void x265_param_default(x265_param* param)
param->analysisReuseLevel = 0; /*DEPRECATED*/
param->analysisSaveReuseLevel = 0;
param->analysisLoadReuseLevel = 0;
- param->toneMapFile = NULL;
+ param->toneMapFile[0] = 0;
param->bDhdr10opt = 0;
param->dolbyProfile = 0;
param->bCTUInfo = 0;
@@ -396,7 +397,7 @@ void x265_param_default(x265_param* param)
param->bDisableLookahead = 0;
param->bCopyPicToFrame = 1;
param->maxAUSizeFactor = 1;
- param->naluFile = NULL;
+ param->naluFile[0] = 0;
/* DCT Approximations */
param->bLowPassDct = 0;
@@ -842,7 +843,7 @@ int x265_zone_param_parse(x265_param* p, const char* name, const char* value)
p->rdoqLevel = 0;
}
OPT("b-intra") p->bIntraInBFrames = atobool(value);
- OPT("scaling-list") p->scalingLists = strdup(value);
+ OPT("scaling-list") snprintf(p->scalingLists, X265_MAX_STRING_SIZE, "%s", value);
OPT("crf")
{
p->rc.rfConstant = atof(value);
@@ -1294,13 +1295,13 @@ int x265_param_parse(x265_param* p, const char* name, const char* value)
p->rc.bStatRead = pass & 2;
p->rc.dataShareMode = X265_SHARE_MODE_FILE;
}
- OPT("stats") p->rc.statFileName = strdup(value);
- OPT("scaling-list") p->scalingLists = strdup(value);
- OPT2("pools", "numa-pools") p->numaPools = strdup(value);
- OPT("lambda-file") p->rc.lambdaFileName = strdup(value);
- OPT("analysis-reuse-file") p->analysisReuseFileName = strdup(value);
+ OPT("stats") snprintf(p->rc.statFileName, X265_MAX_STRING_SIZE, "%s", value);
+ OPT("scaling-list") snprintf(p->scalingLists, X265_MAX_STRING_SIZE, "%s", value);
+ OPT2("pools", "numa-pools") snprintf(p->numaPools, X265_MAX_STRING_SIZE, "%s", value);
+ OPT("lambda-file") snprintf(p->rc.lambdaFileName, X265_MAX_STRING_SIZE, "%s", value);
+ OPT("analysis-reuse-file") snprintf(p->analysisReuseFileName, X265_MAX_STRING_SIZE, "%s", value);
OPT("qg-size") p->rc.qgSize = atoi(value);
- OPT("master-display") p->masteringDisplayColorVolume = strdup(value);
+ OPT("master-display") snprintf(p->masteringDisplayColorVolume, X265_MAX_STRING_SIZE, "%s", value);
OPT("max-cll") bError |= sscanf(value, "%hu,%hu", &p->maxCLL, &p->maxFALL) != 2;
OPT("min-luma") p->minLuma = (uint16_t)atoi(value);
OPT("max-luma") p->maxLuma = (uint16_t)atoi(value);
@@ -1312,7 +1313,7 @@ int x265_param_parse(x265_param* p, const char* name, const char* value)
if (bExtraParams)
{
if (0) ;
- OPT("csv") p->csvfn = strdup(value);
+ OPT("csv") snprintf(p->csvfn, X265_MAX_STRING_SIZE, "%s", value);
OPT("csv-log-level") p->csvLogLevel = atoi(value);
OPT("qpmin") p->rc.qpMin = atoi(value);
OPT("analyze-src-pics") p->bSourceReferenceEstimation = atobool(value);
@@ -1357,7 +1358,7 @@ int x265_param_parse(x265_param* p, const char* name, const char* value)
OPT("hdr-opt") p->bHDR10Opt = atobool(value); /*DEPRECATED*/
OPT("hdr10-opt") p->bHDR10Opt = atobool(value);
OPT("limit-sao") p->bLimitSAO = atobool(value);
- OPT("dhdr10-info") p->toneMapFile = strdup(value);
+ OPT("dhdr10-info") snprintf(p->toneMapFile, X265_MAX_STRING_SIZE, "%s", value);
OPT("dhdr10-opt") p->bDhdr10opt = atobool(value);
OPT("idr-recovery-sei") p->bEmitIDRRecoverySEI = atobool(value);
OPT("const-vbv") p->rc.bEnableConstVbv = atobool(value);
@@ -1374,15 +1375,15 @@ int x265_param_parse(x265_param* p, const char* name, const char* value)
OPT("copy-pic") p->bCopyPicToFrame = atobool(value);
OPT("refine-analysis-type")
{
- if (strcmp(strdup(value), "avc") == 0)
+ if (strcmp((value), "avc") == 0)
{
p->bAnalysisType = AVC_INFO;
}
- else if (strcmp(strdup(value), "hevc") == 0)
+ else if (strcmp((value), "hevc") == 0)
{
p->bAnalysisType = HEVC_INFO;
}
- else if (strcmp(strdup(value), "off") == 0)
+ else if (strcmp((value), "off") == 0)
{
p->bAnalysisType = DEFAULT;
}
@@ -1392,8 +1393,8 @@ int x265_param_parse(x265_param* p, const char* name, const char* value)
}
}
OPT("gop-lookahead") p->gopLookahead = atoi(value);
- OPT("analysis-save") p->analysisSave = strdup(value);
- OPT("analysis-load") p->analysisLoad = strdup(value);
+ OPT("analysis-save") snprintf(p->analysisSave, X265_MAX_STRING_SIZE, "%s", value);
+ OPT("analysis-load") snprintf(p->analysisLoad, X265_MAX_STRING_SIZE, "%s", value);
OPT("radl") p->radl = atoi(value);
OPT("max-ausize-factor") p->maxAUSizeFactor = atof(value);
OPT("dynamic-refine") p->bDynamicRefine = atobool(value);
@@ -1402,7 +1403,7 @@ int x265_param_parse(x265_param* p, const char* name, const char* value)
OPT("pic-struct") p->pictureStructure = atoi(value);
OPT("chunk-start") p->chunkStart = atoi(value);
OPT("chunk-end") p->chunkEnd = atoi(value);
- OPT("nalu-file") p->naluFile = strdup(value);
+ OPT("nalu-file") snprintf(p->naluFile, X265_MAX_STRING_SIZE, "%s", value);
OPT("dolby-vision-profile")
{
if (atof(value) < 10)
@@ -1478,7 +1479,7 @@ int x265_param_parse(x265_param* p, const char* name, const char* value)
OPT("vbv-live-multi-pass") p->bliveVBV2pass = atobool(value);
OPT("min-vbv-fullness") p->minVbvFullness = atof(value);
OPT("max-vbv-fullness") p->maxVbvFullness = atof(value);
- OPT("video-signal-type-preset") p->videoSignalTypePreset = strdup(value);
+ OPT("video-signal-type-preset") snprintf(p->videoSignalTypePreset, X265_MAX_STRING_SIZE, "%s", value);
OPT("eob") p->bEnableEndOfBitstream = atobool(value);
OPT("eos") p->bEnableEndOfSequence = atobool(value);
/* Film grain characterstics model filename */
@@ -1866,11 +1867,11 @@ 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->analysisSave && (param->analysisSaveReuseLevel < 0 || param->analysisSaveReuseLevel > 10),
+ CHECK(strlen(param->analysisSave) && (param->analysisSaveReuseLevel < 0 || param->analysisSaveReuseLevel > 10),
"Invalid analysis save refine level. Value must be between 1 and 10 (inclusive)");
- CHECK(param->analysisLoad && (param->analysisLoadReuseLevel < 0 || param->analysisLoadReuseLevel > 10),
+ CHECK(strlen(param->analysisLoad) && (param->analysisLoadReuseLevel < 0 || param->analysisLoadReuseLevel > 10),
"Invalid analysis load refine level. Value must be between 1 and 10 (inclusive)");
- CHECK(param->analysisLoad && (param->mvRefine < 1 || param->mvRefine > 3),
+ CHECK(strlen(param->analysisLoad) && (param->mvRefine < 1 || param->mvRefine > 3),
"Invalid mv refinement level. Value must be between 1 and 3 (inclusive)");
CHECK(param->scaleFactor > 2, "Invalid scale-factor. Supports factor <= 2");
CHECK(param->rc.qpMax < QP_MIN || param->rc.qpMax > QP_MAX_MAX,
@@ -1948,7 +1949,7 @@ int x265_check_params(x265_param* param)
"SEA motion search does not support resolutions greater than 480p in 32 bit build");
#endif
- if (param->masteringDisplayColorVolume || param->maxFALL || param->maxCLL)
+ if (strlen(param->masteringDisplayColorVolume) || param->maxFALL || param->maxCLL)
param->bEmitHDR10SEI = 1;
bool isSingleSEI = (param->bRepeatHeaders
@@ -1958,8 +1959,8 @@ int x265_check_params(x265_param* param)
|| param->bEmitIDRRecoverySEI
|| !!param->interlaceMode
|| param->preferredTransferCharacteristics > 1
- || param->toneMapFile
- || param->naluFile);
+ || strlen(param->toneMapFile)
+ || strlen(param->naluFile));
if (!isSingleSEI && param->bSingleSeiNal)
{
@@ -1990,7 +1991,7 @@ int x265_check_params(x265_param* param)
CHECK((param->internalCsp != X265_CSP_I420), "Alpha encode supported only with i420a colorspace");
CHECK((param->internalBitDepth > 10), "BitDepthConstraint must be 8 and 10 for Scalable main profile");
CHECK((param->analysisMultiPassDistortion || param->analysisMultiPassRefine), "Alpha encode doesnot support multipass feature");
- CHECK((param->analysisSave || param->analysisLoad), "Alpha encode doesnot support analysis save and load feature");
+ CHECK((strlen(param->analysisSave) || strlen(param->analysisLoad)), "Alpha encode doesnot support analysis save and load feature");
}
#endif
#if ENABLE_MULTIVIEW
@@ -1999,7 +2000,7 @@ int x265_check_params(x265_param* param)
{
CHECK(param->internalBitDepth != 8, "BitDepthConstraint must be 8 for Multiview main profile");
CHECK(param->analysisMultiPassDistortion || param->analysisMultiPassRefine, "Multiview encode doesnot support multipass feature");
- CHECK(param->analysisSave || param->analysisLoad, "Multiview encode doesnot support analysis save and load feature");
+ CHECK(strlen(param->analysisSave) || strlen(param->analysisLoad), "Multiview encode doesnot support analysis save and load feature");
}
#endif
#if ENABLE_SCC_EXT
@@ -2202,11 +2203,11 @@ char *x265_param2string(x265_param* p, int padx, int pady)
{
char *buf, *s;
size_t bufSize = 4000 + p->rc.zoneCount * 64;
- if (p->numaPools)
+ if (strlen(p->numaPools))
bufSize += strlen(p->numaPools);
- if (p->masteringDisplayColorVolume)
+ if (strlen(p->masteringDisplayColorVolume))
bufSize += strlen(p->masteringDisplayColorVolume);
- if (p->videoSignalTypePreset)
+ if (strlen(p->videoSignalTypePreset))
bufSize += strlen(p->videoSignalTypePreset);
buf = s = X265_MALLOC(char, bufSize);
@@ -2217,7 +2218,7 @@ char *x265_param2string(x265_param* p, int padx, int pady)
s += snprintf(s, bufSize - (s - buf), "cpuid=%d", p->cpuid);
s += snprintf(s, bufSize - (s - buf), " frame-threads=%d", p->frameNumThreads);
- if (p->numaPools)
+ if (strlen(p->numaPools))
s += snprintf(s, bufSize - (s - buf), " numa-pools=%s", p->numaPools);
BOOL(p->bEnableWavefront, "wpp");
BOOL(p->bDistributeModeAnalysis, "pmode");
@@ -2225,7 +2226,7 @@ char *x265_param2string(x265_param* p, int padx, int pady)
BOOL(p->bEnablePsnr, "psnr");
BOOL(p->bEnableSsim, "ssim");
s += snprintf(s, bufSize - (s - buf), " log-level=%d", p->logLevel);
- if (p->csvfn)
+ if (strlen(p->csvfn))
s += snprintf(s, bufSize - (s - buf), " csv csv-log-level=%d", p->csvLogLevel);
s += snprintf(s, bufSize - (s - buf), " bitdepth=%d", p->internalBitDepth);
s += snprintf(s, bufSize - (s - buf), " input-csp=%d", p->internalCsp);
@@ -2402,7 +2403,7 @@ char *x265_param2string(x265_param* p, int padx, int pady)
s += snprintf(s, bufSize - (s - buf), " left=%d top=%d right=%d bottom=%d",
p->vui.defDispWinLeftOffset, p->vui.defDispWinTopOffset,
p->vui.defDispWinRightOffset, p->vui.defDispWinBottomOffset);
- if (p->masteringDisplayColorVolume)
+ if (strlen(p->masteringDisplayColorVolume))
s += snprintf(s, bufSize - (s - buf), " master-display=%s", p->masteringDisplayColorVolume);
if (p->bEmitCLL)
s += snprintf(s, bufSize - (s - buf), " cll=%hu,%hu", p->maxCLL, p->maxFALL);
@@ -2422,9 +2423,9 @@ char *x265_param2string(x265_param* p, int padx, int pady)
BOOL(p->bHDR10Opt, "hdr10-opt");
BOOL(p->bDhdr10opt, "dhdr10-opt");
BOOL(p->bEmitIDRRecoverySEI, "idr-recovery-sei");
- if (p->analysisSave)
+ if (strlen(p->analysisSave))
s += snprintf(s, bufSize - (s - buf), " analysis-save");
- if (p->analysisLoad)
+ if (strlen(p->analysisLoad))
s += snprintf(s, bufSize - (s - buf), " analysis-load");
s += snprintf(s, bufSize - (s - buf), " analysis-reuse-level=%d", p->analysisReuseLevel);
s += snprintf(s, bufSize - (s - buf), " analysis-save-reuse-level=%d", p->analysisSaveReuseLevel);
@@ -2474,7 +2475,7 @@ char *x265_param2string(x265_param* p, int padx, int pady)
bool parseLambdaFile(x265_param* param)
{
- if (!param->rc.lambdaFileName)
+ if (!strlen(param->rc.lambdaFileName))
return false;
FILE *lfn = x265_fopen(param->rc.lambdaFileName, "r");
@@ -2692,8 +2693,8 @@ void x265_copy_params(x265_param* dst, x265_param* src)
dst->mcstfFrameRange = src->mcstfFrameRange;
dst->cpuid = src->cpuid;
dst->frameNumThreads = src->frameNumThreads;
- if (src->numaPools) dst->numaPools = strdup(src->numaPools);
- else dst->numaPools = NULL;
+ if (strlen(src->numaPools)) snprintf(dst->numaPools, X265_MAX_STRING_SIZE, "%s", src->numaPools);
+ else dst->numaPools[0] = 0;
dst->bEnableWavefront = src->bEnableWavefront;
dst->bDistributeModeAnalysis = src->bDistributeModeAnalysis;
@@ -2703,8 +2704,8 @@ void x265_copy_params(x265_param* dst, x265_param* src)
dst->bEnableSsim = src->bEnableSsim;
dst->logLevel = src->logLevel;
dst->csvLogLevel = src->csvLogLevel;
- if (src->csvfn) dst->csvfn = strdup(src->csvfn);
- else dst->csvfn = NULL;
+ if (strlen(src->csvfn)) snprintf(dst->csvfn, X265_MAX_STRING_SIZE, "%s", src->csvfn);
+ else dst->csvfn[0] = 0;
dst->internalBitDepth = src->internalBitDepth;
dst->sourceBitDepth = src->sourceBitDepth;
dst->internalCsp = src->internalCsp;
@@ -2754,8 +2755,8 @@ void x265_copy_params(x265_param* dst, x265_param* src)
dst->bEnableTransformSkip = src->bEnableTransformSkip;
dst->noiseReductionInter = src->noiseReductionInter;
dst->noiseReductionIntra = src->noiseReductionIntra;
- if (src->scalingLists) dst->scalingLists = strdup(src->scalingLists);
- else dst->scalingLists = NULL;
+ if (strlen(src->scalingLists)) snprintf(dst->scalingLists, X265_MAX_STRING_SIZE, "%s", src->scalingLists);
+ else dst->scalingLists[0] = 0;
dst->bEnableStrongIntraSmoothing = src->bEnableStrongIntraSmoothing;
dst->bEnableConstrainedIntra = src->bEnableConstrainedIntra;
dst->maxNumMergeCand = src->maxNumMergeCand;
@@ -2797,8 +2798,8 @@ void x265_copy_params(x265_param* dst, x265_param* src)
dst->psyRdoq = src->psyRdoq;
dst->bEnableRdRefine = src->bEnableRdRefine;
dst->analysisReuseMode = src->analysisReuseMode;
- if (src->analysisReuseFileName) dst->analysisReuseFileName=strdup(src->analysisReuseFileName);
- else dst->analysisReuseFileName = NULL;
+ if (strlen(src->analysisReuseFileName)) snprintf(dst->analysisReuseFileName, X265_MAX_STRING_SIZE, "%s", src->analysisReuseFileName);
+ else dst->analysisReuseFileName[0] = 0;
dst->bLossless = src->bLossless;
dst->cbQpOffset = src->cbQpOffset;
dst->crQpOffset = src->crQpOffset;
@@ -2827,10 +2828,10 @@ void x265_copy_params(x265_param* dst, x265_param* src)
dst->rc.bStatWrite = src->rc.bStatWrite;
dst->rc.bStatRead = src->rc.bStatRead;
dst->rc.dataShareMode = src->rc.dataShareMode;
- if (src->rc.statFileName) dst->rc.statFileName=strdup(src->rc.statFileName);
- else dst->rc.statFileName = NULL;
- if (src->rc.sharedMemName) dst->rc.sharedMemName = strdup(src->rc.sharedMemName);
- else dst->rc.sharedMemName = NULL;
+ if (strlen(src->rc.statFileName)) snprintf(dst->rc.statFileName, X265_MAX_STRING_SIZE, "%s", src->rc.statFileName);
+ else dst->rc.statFileName[0] = 0;
+ if (strlen(src->rc.sharedMemName)) snprintf(dst->rc.sharedMemName, X265_MAX_STRING_SIZE, "%s", src->rc.sharedMemName);
+ else dst->rc.sharedMemName[0] = 0;
dst->rc.qblur = src->rc.qblur;
dst->rc.complexityBlur = src->rc.complexityBlur;
dst->rc.bEnableSlowFirstPass = src->rc.bEnableSlowFirstPass;
@@ -2864,8 +2865,8 @@ void x265_copy_params(x265_param* dst, x265_param* src)
else
dst->rc.zones = NULL;
- if (src->rc.lambdaFileName) dst->rc.lambdaFileName = strdup(src->rc.lambdaFileName);
- else dst->rc.lambdaFileName = NULL;
+ if (strlen(src->rc.lambdaFileName)) snprintf(dst->rc.lambdaFileName, X265_MAX_STRING_SIZE, "%s", src->rc.lambdaFileName);
+ else dst->rc.lambdaFileName[0] = 0;
dst->rc.bStrictCbr = src->rc.bStrictCbr;
dst->rc.qgSize = src->rc.qgSize;
dst->rc.bEnableGrain = src->rc.bEnableGrain;
@@ -2896,8 +2897,8 @@ void x265_copy_params(x265_param* dst, x265_param* src)
dst->vui.defDispWinRightOffset = src->vui.defDispWinRightOffset;
dst->vui.defDispWinTopOffset = src->vui.defDispWinTopOffset;
- if (src->masteringDisplayColorVolume) dst->masteringDisplayColorVolume=strdup( src->masteringDisplayColorVolume);
- else dst->masteringDisplayColorVolume = NULL;
+ if (strlen(src->masteringDisplayColorVolume)) snprintf(dst->masteringDisplayColorVolume, X265_MAX_STRING_SIZE, "%s", src->masteringDisplayColorVolume);
+ else dst->masteringDisplayColorVolume[0] = 0;
dst->maxLuma = src->maxLuma;
dst->minLuma = src->minLuma;
dst->bEmitCLL = src->bEmitCLL;
@@ -2926,8 +2927,8 @@ void x265_copy_params(x265_param* dst, x265_param* src)
dst->analysisSaveReuseLevel = src->analysisSaveReuseLevel;
dst->analysisLoadReuseLevel = src->analysisLoadReuseLevel;
dst->bLimitSAO = src->bLimitSAO;
- if (src->toneMapFile) dst->toneMapFile = strdup(src->toneMapFile);
- else dst->toneMapFile = NULL;
+ if (strlen(src->toneMapFile)) snprintf(dst->toneMapFile, X265_MAX_STRING_SIZE, "%s", src->toneMapFile);
+ else dst->toneMapFile[0] = 0;
dst->bDhdr10opt = src->bDhdr10opt;
dst->bCTUInfo = src->bCTUInfo;
dst->bUseRcStats = src->bUseRcStats;
@@ -2949,10 +2950,10 @@ void x265_copy_params(x265_param* dst, x265_param* src)
dst->vbvEndFrameAdjust = src->vbvEndFrameAdjust;
dst->bAnalysisType = src->bAnalysisType;
dst->bCopyPicToFrame = src->bCopyPicToFrame;
- if (src->analysisSave) dst->analysisSave=strdup(src->analysisSave);
- else dst->analysisSave = NULL;
- if (src->analysisLoad) dst->analysisLoad=strdup(src->analysisLoad);
- else dst->analysisLoad = NULL;
+ if (strlen(src->analysisSave)) snprintf(dst->analysisSave, X265_MAX_STRING_SIZE, "%s", src->analysisSave);
+ else dst->analysisSave[0] = 0;
+ if (strlen(src->analysisLoad)) snprintf(dst->analysisLoad, X265_MAX_STRING_SIZE, "%s", src->analysisLoad);
+ else dst->analysisLoad[0] = 0;
dst->gopLookahead = src->gopLookahead;
dst->radl = src->radl;
dst->selectiveSAO = src->selectiveSAO;
@@ -2962,8 +2963,8 @@ void x265_copy_params(x265_param* dst, x265_param* src)
dst->bSingleSeiNal = src->bSingleSeiNal;
dst->chunkStart = src->chunkStart;
dst->chunkEnd = src->chunkEnd;
- if (src->naluFile) dst->naluFile=strdup(src->naluFile);
- else dst->naluFile = NULL;
+ if (src->naluFile) snprintf(dst->naluFile, X265_MAX_STRING_SIZE, "%s", src->naluFile);
+ else dst->naluFile[0] = 0;
dst->scaleFactor = src->scaleFactor;
dst->ctuDistortionRefine = src->ctuDistortionRefine;
dst->bEnableHRDConcatFlag = src->bEnableHRDConcatFlag;
@@ -3001,8 +3002,8 @@ void x265_copy_params(x265_param* dst, x265_param* src)
dst->bEnableSCC = src->bEnableSCC;
#endif
- if (src->videoSignalTypePreset) dst->videoSignalTypePreset = strdup(src->videoSignalTypePreset);
- else dst->videoSignalTypePreset = NULL;
+ if (strlen(src->videoSignalTypePreset)) snprintf(dst->videoSignalTypePreset, X265_MAX_STRING_SIZE, "%s", src->videoSignalTypePreset);
+ else dst->videoSignalTypePreset[0] = 0;
#ifdef SVT_HEVC
memcpy(dst->svtHevcParam, src->svtHevcParam, sizeof(EB_H265_ENC_CONFIGURATION));
#endif
@@ -3236,6 +3237,7 @@ int svt_param_parse(x265_param* param, const char* name, const char* value)
svtHevcParam->logicalProcessors = atoi(temp1);
}
}
+ free(pools);
}
OPT("high-tier") svtHevcParam->tier = x265_atobool(value, bError);
OPT("qpmin") svtHevcParam->minQpAllowed = atoi(value);
diff --git a/source/common/temporalfilter.cpp b/source/common/temporalfilter.cpp
index 215feaa0f..75b7f2188 100644
--- a/source/common/temporalfilter.cpp
+++ b/source/common/temporalfilter.cpp
@@ -153,6 +153,13 @@ TemporalFilter::TemporalFilter()
m_motionVectorFactor = 16;
}
+TemporalFilter::~TemporalFilter()
+{
+ if (m_metld)
+ delete m_metld;
+ predPUYuv.destroy();
+}
+
void TemporalFilter::init(const x265_param* param)
{
m_param = param;
diff --git a/source/common/temporalfilter.h b/source/common/temporalfilter.h
index 723644633..bc7109b40 100644
--- a/source/common/temporalfilter.h
+++ b/source/common/temporalfilter.h
@@ -118,7 +118,7 @@ namespace X265_NS {
{
public:
TemporalFilter();
- ~TemporalFilter() {}
+ ~TemporalFilter();
void init(const x265_param* param);
diff --git a/source/common/threadpool.cpp b/source/common/threadpool.cpp
index ab6bd0d43..b3505e5c0 100644
--- a/source/common/threadpool.cpp
+++ b/source/common/threadpool.cpp
@@ -302,7 +302,7 @@ ThreadPool* ThreadPool::allocThreadPools(x265_param* p, int& numPools, bool isTh
* For windows because threads can't be allocated to live across sockets
* changing the default behavior to be per-socket pools -- FIXME */
#if defined(_WIN32_WINNT) && _WIN32_WINNT >= _WIN32_WINNT_WIN7 || HAVE_LIBNUMA
- if (!p->numaPools || (strcmp(p->numaPools, "NULL") == 0 || strcmp(p->numaPools, "*") == 0 || strcmp(p->numaPools, "") == 0))
+ if (!strlen(p->numaPools) || (strcmp(p->numaPools, "NULL") == 0 || strcmp(p->numaPools, "*") == 0 || strcmp(p->numaPools, "") == 0))
{
char poolString[50] = "";
for (int i = 0; i < numNumaNodes; i++)
@@ -317,7 +317,7 @@ ThreadPool* ThreadPool::allocThreadPools(x265_param* p, int& numPools, bool isTh
x265_param_parse(p, "pools", poolString);
}
#endif
- if (p->numaPools && *p->numaPools)
+ if (strlen(p->numaPools))
{
const char *nodeStr = p->numaPools;
for (int i = 0; i < numNumaNodes; i++)
diff --git a/source/encoder/analysis.cpp b/source/encoder/analysis.cpp
index 6c72283f3..da5aeca77 100644
--- a/source/encoder/analysis.cpp
+++ b/source/encoder/analysis.cpp
@@ -203,7 +203,7 @@ Mode& Analysis::compressCTU(CUData& ctu, Frame& frame, const CUGeom& cuGeom, con
}
int reuseLevel = X265_MAX(m_param->analysisSaveReuseLevel, m_param->analysisLoadReuseLevel);
- if ((m_param->analysisSave || m_param->analysisLoad) && m_slice->m_sliceType != I_SLICE && reuseLevel > 1 && reuseLevel < 10)
+ if ((strlen(m_param->analysisSave) || strlen(m_param->analysisLoad)) && m_slice->m_sliceType != I_SLICE && reuseLevel > 1 && reuseLevel < 10)
{
int numPredDir = m_slice->isInterP() ? 1 : 2;
m_reuseInterDataCTU = m_frame->m_analysisData.interData;
@@ -217,7 +217,7 @@ Mode& Analysis::compressCTU(CUData& ctu, Frame& frame, const CUGeom& cuGeom, con
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->analysisSave && !m_param->analysisLoad)
+ if (strlen(m_param->analysisSave) && !strlen(m_param->analysisLoad))
for (int i = 0; i < X265_MAX_PRED_MODE_PER_CTU * numPredDir; i++)
m_reuseRef[i] = -1;
}
@@ -4130,7 +4130,7 @@ int Analysis::calculateQpforCuSize(const CUData& ctu, const CUGeom& cuGeom, int3
double qp = baseQp >= 0 ? baseQp : curEncData.m_cuStat[ctu.m_cuAddr].baseQp;
bool bCuTreeOffset = IS_REFERENCED(m_frame) && m_param->rc.cuTree && !complexCheck;
- if ((m_param->analysisMultiPassDistortion && m_param->rc.bStatRead) || (m_param->ctuDistortionRefine && m_param->analysisLoad))
+ if ((m_param->analysisMultiPassDistortion && m_param->rc.bStatRead) || (m_param->ctuDistortionRefine && strlen(m_param->analysisLoad)))
{
x265_analysis_distortion_data* distortionData = m_frame->m_analysisData.distortionData;
if ((distortionData->threshold[ctu.m_cuAddr] < 0.9 || distortionData->threshold[ctu.m_cuAddr] > 1.1)
diff --git a/source/encoder/api.cpp b/source/encoder/api.cpp
index 5d2a951e5..abcb2113c 100644
--- a/source/encoder/api.cpp
+++ b/source/encoder/api.cpp
@@ -204,6 +204,8 @@ x265_encoder *x265_encoder_open(x265_param *p)
}
}
+ // Need free zone because follow up Memcpy will broken all of pointer
+ x265_zone_free(zoneParam);
memcpy(zoneParam, param, sizeof(x265_param));
for (int i = 0; i < param->rc.zonefileCount; i++)
{
@@ -211,7 +213,7 @@ x265_encoder *x265_encoder_open(x265_param *p)
}
/* Try to open CSV file handle */
- if (encoder->m_param->csvfn)
+ if (strlen(encoder->m_param->csvfn))
{
encoder->m_param->csvfpt = x265_csvlog_open(encoder->m_param);
if (!encoder->m_param->csvfpt)
@@ -221,6 +223,7 @@ x265_encoder *x265_encoder_open(x265_param *p)
}
}
+ encoder->m_templateParam = param;
encoder->m_latestParam = latestParam;
encoder->m_zoneParam = zoneParam;
x265_copy_params(latestParam, param);
@@ -309,7 +312,7 @@ int x265_encoder_reconfig(x265_encoder* enc, x265_param* param_in)
return -1;
x265_param save;
Encoder* encoder = static_cast<Encoder*>(enc);
- if (encoder->m_param->csvfn == NULL && param_in->csvfpt != NULL)
+ if (strlen(encoder->m_param->csvfn) && param_in->csvfpt != NULL)
encoder->m_param->csvfpt = param_in->csvfpt;
if (encoder->m_latestParam->forceFlush != param_in->forceFlush)
return encoder->reconfigureParam(encoder->m_latestParam, param_in);
@@ -327,18 +330,20 @@ int x265_encoder_reconfig(x265_encoder* enc, x265_param* param_in)
{
/* reconfigure failed, recover saved param set */
x265_copy_params(encoder->m_latestParam, &save);
+ x265_zone_free(&save);
ret = -1;
}
else
{
encoder->configure(encoder->m_latestParam);
- if (encoder->m_latestParam->scalingLists && encoder->m_latestParam->scalingLists != encoder->m_param->scalingLists)
+ if (strlen(encoder->m_latestParam->scalingLists) && strcmp(encoder->m_latestParam->scalingLists, encoder->m_param->scalingLists))
{
if (encoder->m_param->bRepeatHeaders)
{
if (encoder->m_scalingList.parseScalingList(encoder->m_latestParam->scalingLists))
{
x265_copy_params(encoder->m_latestParam, &save);
+ x265_zone_free(&save);
return -1;
}
encoder->m_scalingList.setupQuantMatrices(encoder->m_param->internalCsp);
@@ -347,6 +352,7 @@ int x265_encoder_reconfig(x265_encoder* enc, x265_param* param_in)
{
x265_log(encoder->m_param, X265_LOG_ERROR, "Repeat headers is turned OFF, cannot reconfigure scalinglists\n");
x265_copy_params(encoder->m_latestParam, &save);
+ x265_zone_free(&save);
return -1;
}
}
@@ -373,6 +379,7 @@ int x265_encoder_reconfig(x265_encoder* enc, x265_param* param_in)
/* Zones support modifying num of Refs. Requires determining level at each zone start*/
if (encoder->m_param->rc.zonefileCount)
determineLevel(*encoder->m_latestParam, encoder->m_vps);
+ x265_zone_free(&save);
return ret;
}
@@ -1009,7 +1016,7 @@ void x265_picture_init(x265_param *param, x265_picture *pic)
pic->picStruct = 0;
pic->vbvEndFlag = 0;
- if ((param->analysisSave || param->analysisLoad) || (param->bAnalysisType == AVC_INFO))
+ if ((strlen(param->analysisSave) || strlen(param->analysisLoad)) || (param->bAnalysisType == AVC_INFO))
{
uint32_t widthInCU = (param->sourceWidth + param->maxCUSize - 1) >> param->maxLog2CUSize;
uint32_t heightInCU = (param->sourceHeight + param->maxCUSize - 1) >> param->maxLog2CUSize;
@@ -1041,6 +1048,8 @@ void x265_zone_free(x265_param *param)
{
for (int i = 0; i < param->rc.zonefileCount; i++)
x265_free(param->rc.zones[i].zoneParam);
+ param->rc.zonefileCount = 0;
+ param->rc.zoneCount = 0;
x265_free(param->rc.zones);
}
}
diff --git a/source/encoder/encoder.cpp b/source/encoder/encoder.cpp
index 5f784e72b..d1d12e91c 100644
--- a/source/encoder/encoder.cpp
+++ b/source/encoder/encoder.cpp
@@ -138,6 +138,7 @@ Encoder::Encoder()
m_outputCount = 0;
m_param = NULL;
m_latestParam = NULL;
+ m_templateParam = NULL;
m_threadPool = NULL;
m_analysisFileIn = NULL;
m_analysisFileOut = NULL;
@@ -255,7 +256,7 @@ void Encoder::create()
p->bEnableWavefront = 0;
}
- bool allowPools = !p->numaPools || strcmp(p->numaPools, "none");
+ bool allowPools = !strlen(p->numaPools) || strcmp(p->numaPools, "none");
// Trim the thread pool if --wpp, --pme, and --pmode are disabled
if (!p->bEnableWavefront && !p->bDistributeModeAnalysis && !p->bDistributeMotionEstimation && !p->lookaheadSlices)
@@ -336,7 +337,7 @@ void Encoder::create()
m_aborted = true;
return;
}
- else if (!m_param->scalingLists || !strcmp(m_param->scalingLists, "off"))
+ else if (!strlen(m_param->scalingLists) || !strcmp(m_param->scalingLists, "off"))
m_scalingList.m_bEnabled = false;
else if (!strcmp(m_param->scalingLists, "default"))
m_scalingList.setDefaultScalingList();
@@ -478,7 +479,7 @@ void Encoder::create()
m_aborted = true;
initRefIdx();
- if (m_param->analysisSave && m_param->bUseAnalysisFile)
+ if (strlen(m_param->analysisSave) && m_param->bUseAnalysisFile)
{
char* temp = strcatFilename(m_param->analysisSave, ".temp");
if (!temp)
@@ -498,7 +499,7 @@ void Encoder::create()
if (m_param->analysisMultiPassRefine || m_param->analysisMultiPassDistortion)
{
const char* name = m_param->analysisReuseFileName;
- if (!name)
+ if (!strlen(name))
name = defaultAnalysisFileName;
if (m_param->rc.bStatWrite)
{
@@ -550,7 +551,7 @@ void Encoder::create()
m_nalList.m_annexB = !!m_param->bAnnexB;
- if (m_param->naluFile)
+ if (strlen(m_param->naluFile))
{
m_naluFile = x265_fopen(m_param->naluFile, "r");
if (!m_naluFile)
@@ -951,19 +952,16 @@ void Encoder::destroy()
if (m_latestParam != NULL && m_latestParam != m_param)
{
- if (m_latestParam->scalingLists != m_param->scalingLists)
- free((char*)m_latestParam->scalingLists);
- if (m_latestParam->numaPools != m_param->numaPools)
- free((char*)m_latestParam->numaPools);
-
PARAM_NS::x265_param_free(m_latestParam);
}
if (m_zoneParam != NULL && m_zoneParam != m_param) {
- if (m_zoneParam->numaPools != m_param->numaPools)
- free((char*)m_zoneParam->numaPools);
-
PARAM_NS::x265_param_free(m_zoneParam);
}
+ if (m_templateParam != NULL && m_templateParam != m_param) {
+ // TODO: we don't free zone here because it is overwrite into m_zoneParam in x265_encoder_open
+ m_templateParam->rc.zonefileCount = m_templateParam->rc.zoneCount = 0;
+ PARAM_NS::x265_param_free(m_templateParam);
+ }
if (m_analysisFileIn)
fclose(m_analysisFileIn);
@@ -971,8 +969,8 @@ void Encoder::destroy()
{
int bError = 1;
fclose(m_analysisFileOut);
- const char* name = m_param->analysisSave ? m_param->analysisSave : m_param->analysisReuseFileName;
- if (!name)
+ const char* name = strlen(m_param->analysisSave) ? m_param->analysisSave : m_param->analysisReuseFileName;
+ if (!strlen(name))
name = defaultAnalysisFileName;
char* temp = strcatFilename(name, ".temp");
if (temp)
@@ -1000,19 +998,6 @@ void Encoder::destroy()
{
if (m_param->csvfpt)
fclose(m_param->csvfpt);
- /* release string arguments that were strdup'd */
- free((char*)m_param->rc.lambdaFileName);
- free((char*)m_param->rc.statFileName);
- free((char*)m_param->rc.sharedMemName);
- free((char*)m_param->analysisReuseFileName);
- free((char*)m_param->scalingLists);
- free((char*)m_param->csvfn);
- 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);
- free((char*)m_param->videoSignalTypePreset);
PARAM_NS::x265_param_free(m_param);
}
}
@@ -1509,7 +1494,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture* pic_out)
if (*m_exportedPic)
{
- if (!m_param->bUseAnalysisFile && m_param->analysisSave)
+ if (!m_param->bUseAnalysisFile && strlen(m_param->analysisSave))
x265_free_analysis_data(m_param, &m_exportedPic[0]->m_analysisData);
for (int i = 0; i < m_param->numLayers; i++)
@@ -1801,7 +1786,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture* pic_out)
/* In analysisSave mode, x265_analysis_data is allocated in inputPic and inFrame points to this */
/* Load analysis data before lookahead->addPicture, since sliceType has been decided */
- if (m_param->analysisLoad)
+ if (strlen(m_param->analysisLoad))
{
/* reads analysis data for the frame and allocates memory based on slicetype */
static int paramBytes = CONF_OFFSET_BYTES;
@@ -1992,7 +1977,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture* pic_out)
x265_frame_stats* frameData = NULL;
/* Free up inputPic->analysisData since it has already been used */
- if ((m_param->analysisLoad && !m_param->analysisSave) || ((m_param->bAnalysisType == AVC_INFO) && slice->m_sliceType != I_SLICE))
+ if ((strlen(m_param->analysisLoad) && !strlen(m_param->analysisSave)) || ((m_param->bAnalysisType == AVC_INFO) && slice->m_sliceType != I_SLICE))
x265_free_analysis_data(m_param, &outFrame->m_analysisData);
if (pic_out)
{
@@ -2020,7 +2005,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture* pic_out)
}
/* Dump analysis data from pic_out to file in save mode and free */
- if (m_param->analysisSave)
+ if (strlen(m_param->analysisSave))
{
pic_out[sLayer].analysisData.poc = pic_out[sLayer].poc;
pic_out[sLayer].analysisData.sliceType = pic_out[sLayer].sliceType;
@@ -2140,7 +2125,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture* pic_out)
if ((m_outputCount + 1) >= m_param->chunkStart)
finishFrameStats(outFrame, curEncoder, frameData, m_pocLast, sLayer);
- if (m_param->analysisSave)
+ if (strlen(m_param->analysisSave))
{
pic_out[sLayer].analysisData.frameBits = frameData->bits;
if (!slice->isIntra())
@@ -2334,7 +2319,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture* pic_out)
int baseViewType = frameEnc[0]->m_lowres.sliceType;
frameEnc[layer]->m_encData->m_slice->m_origSliceType = IS_X265_TYPE_B(baseViewType) ? B_SLICE : (baseViewType == X265_TYPE_P) ? P_SLICE : I_SLICE;
}
- if (m_param->analysisLoad && m_param->bDisableLookahead)
+ if (strlen(m_param->analysisLoad) && m_param->bDisableLookahead)
{
frameEnc[0]->m_dts = frameEnc[0]->m_analysisData.lookahead.dts;
frameEnc[0]->m_reorderedPts = frameEnc[0]->m_analysisData.lookahead.reorderedPts;
@@ -2409,7 +2394,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture* pic_out)
curEncoder->m_rce.encodeOrder = frameEnc[0]->m_encodeOrder = m_encodedFrameNum++;
- if (!m_param->analysisLoad || !m_param->bDisableLookahead)
+ if (!strlen(m_param->analysisLoad) || !m_param->bDisableLookahead)
{
if (m_bframeDelay)
{
@@ -2424,7 +2409,7 @@ int Encoder::encode(const x265_picture* pic_in, x265_picture* pic_out)
}
/* Allocate analysis data before encode in save mode. This is allocated in frameEnc[0] */
- if (m_param->analysisSave && !m_param->analysisLoad)
+ if (strlen(m_param->analysisSave) && !strlen(m_param->analysisLoad))
{
x265_analysis_data* analysis = &frameEnc[0]->m_analysisData;
analysis->poc = frameEnc[0]->m_poc;
@@ -2618,8 +2603,8 @@ int Encoder::reconfigureParam(x265_param* encParam, x265_param* param)
encParam->bEnableRectInter = param->bEnableRectInter;
encParam->maxNumMergeCand = param->maxNumMergeCand;
encParam->bIntraInBFrames = param->bIntraInBFrames;
- if (param->scalingLists && !encParam->scalingLists)
- encParam->scalingLists = strdup(param->scalingLists);
+ if (strlen(param->scalingLists) && !strlen(encParam->scalingLists))
+ snprintf(encParam->scalingLists, X265_MAX_STRING_SIZE, "%s", param->scalingLists);
encParam->rc.aqMode = param->rc.aqMode;
encParam->rc.aqStrength = param->rc.aqStrength;
@@ -3442,7 +3427,7 @@ void Encoder::getStreamHeaders(NALList& list, Entropy& sbacCoder, Bitstream& bs)
cllsei.writeSEImessages(bs, m_sps, NAL_UNIT_PREFIX_SEI, list, m_param->bSingleSeiNal);
}
- if (m_param->masteringDisplayColorVolume)
+ if (strlen(m_param->masteringDisplayColorVolume))
{
SEIMasteringDisplayColorVolume mdsei;
if (mdsei.parse(m_param->masteringDisplayColorVolume))
@@ -3785,8 +3770,8 @@ void Encoder::configureZone(x265_param *p, x265_param *zone)
p->bEnableRectInter = zone->bEnableRectInter;
p->maxNumMergeCand = zone->maxNumMergeCand;
p->bIntraInBFrames = zone->bIntraInBFrames;
- if (zone->scalingLists)
- p->scalingLists = strdup(zone->scalingLists);
+ if (strlen(zone->scalingLists))
+ snprintf(p->scalingLists, X265_MAX_STRING_SIZE, "%s", zone->scalingLists);
p->rc.aqMode = zone->rc.aqMode;
p->rc.aqStrength = zone->rc.aqStrength;
@@ -3883,15 +3868,15 @@ void Encoder::configureVideoSignalTypePreset(x265_param* p)
p->bEmitHDR10SEI = 1;
if (!strcmp(colorVolume, "P3D65x1000n0005"))
{
- p->masteringDisplayColorVolume = strdup("G(13250,34500)B(7500,3000)R(34000,16000)WP(15635,16450)L(10000000,5)");
+ snprintf(p->masteringDisplayColorVolume, X265_MAX_STRING_SIZE, "G(13250,34500)B(7500,3000)R(34000,16000)WP(15635,16450)L(10000000,5)");
}
else if (!strcmp(colorVolume, "P3D65x4000n005"))
{
- p->masteringDisplayColorVolume = strdup("G(13250,34500)B(7500,3000)R(34000,16000)WP(15635,16450)L(40000000,50)");
+ snprintf(p->masteringDisplayColorVolume, X265_MAX_STRING_SIZE, "G(13250,34500)B(7500,3000)R(34000,16000)WP(15635,16450)L(40000000,50)");
}
else if (!strcmp(colorVolume, "BT2100x108n0005"))
{
- p->masteringDisplayColorVolume = strdup("G(8500,39850)B(6550,2300)R(34000,146000)WP(15635,16450)L(10000000,1)");
+ snprintf(p->masteringDisplayColorVolume, X265_MAX_STRING_SIZE, "G(8500,39850)B(6550,2300)R(34000,146000)WP(15635,16450)L(10000000,1)");
}
else
{
@@ -4107,37 +4092,37 @@ void Encoder::configure(x265_param *p)
p->rc.rfConstantMin = 0;
}
- if (p->analysisSaveReuseLevel && !p->analysisSave)
+ if (p->analysisSaveReuseLevel && !strlen(p->analysisSave))
{
x265_log(p, X265_LOG_WARNING, "analysis-save-reuse-level can be set only when analysis-save is enabled."
" Resetting analysis-save-reuse-level to 0.\n");
p->analysisSaveReuseLevel = 0;
}
- if (p->analysisLoadReuseLevel && !p->analysisLoad)
+ if (p->analysisLoadReuseLevel && !strlen(p->analysisLoad))
{
x265_log(p, X265_LOG_WARNING, "analysis-load-reuse-level can be set only when analysis-load is enabled."
" Resetting analysis-load-reuse-level to 0.\n");
p->analysisLoadReuseLevel = 0;
}
- if (p->analysisSave && !p->analysisSaveReuseLevel)
+ if (strlen(p->analysisSave) && !p->analysisSaveReuseLevel)
p->analysisSaveReuseLevel = 5;
- if (p->analysisLoad && !p->analysisLoadReuseLevel)
+ if (strlen(p->analysisLoad) && !p->analysisLoadReuseLevel)
p->analysisLoadReuseLevel = 5;
- if ((p->analysisLoad || p->analysisSave) && (p->bDistributeModeAnalysis || p->bDistributeMotionEstimation))
+ if ((strlen(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->analysisLoad || p->analysisSave) && (p->analysisMultiPassRefine || p->analysisMultiPassDistortion))
+ if ((strlen(p->analysisLoad) || strlen(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->analysisSave = p->analysisLoad = NULL;
+ p->analysisSave[0] = p->analysisLoad[0] = 0;
p->analysisMultiPassRefine = p->analysisMultiPassDistortion = 0;
}
if (p->scaleFactor)
@@ -4190,12 +4175,12 @@ void Encoder::configure(x265_param *p)
if (p->ctuDistortionRefine == CTU_DISTORTION_INTERNAL)
{
- if (!p->analysisLoad && !p->analysisSave)
+ if (!strlen(p->analysisLoad) && !strlen(p->analysisSave))
{
x265_log(p, X265_LOG_WARNING, "refine-ctu-distortion 1 requires analysis save/load. Disabling refine-ctu-distortion\n");
p->ctuDistortionRefine = 0;
}
- if (p->scaleFactor && p->analysisLoad)
+ if (p->scaleFactor && strlen(p->analysisLoad))
{
x265_log(p, X265_LOG_WARNING, "refine-ctu-distortion 1 cannot be enabled along with multi resolution analysis refinement. Disabling refine-ctu-distortion\n");
p->ctuDistortionRefine = 0;
@@ -4317,7 +4302,7 @@ void Encoder::configure(x265_param *p)
p->bEnableTSkipFast &= p->bEnableTransformSkip;
p->bLimitSAO &= p->bEnableSAO;
- if (m_param->bUseAnalysisFile && m_param->analysisLoad && (p->confWinRightOffset || p->confWinBottomOffset))
+ if (m_param->bUseAnalysisFile && strlen(m_param->analysisLoad) && (p->confWinRightOffset || p->confWinBottomOffset))
x265_log(p, X265_LOG_WARNING, "It is recommended not to set conformance window offset in file based analysis-load."
" Offsets are shared in the analysis file already.\n");
/* initialize the conformance window */
@@ -4328,7 +4313,7 @@ void Encoder::configure(x265_param *p)
m_conformanceWindow.leftOffset = 0;
uint32_t padsize = 0;
- if (m_param->analysisLoad && m_param->bUseAnalysisFile)
+ if (strlen(m_param->analysisLoad) && m_param->bUseAnalysisFile)
{
m_analysisFileIn = x265_fopen(m_param->analysisLoad, "rb");
if (!m_analysisFileIn)
@@ -4459,19 +4444,19 @@ void Encoder::configure(x265_param *p)
m_param->bEnableFrameDuplication = 0;
}
#ifdef ENABLE_HDR10_PLUS
- if (m_param->bDhdr10opt && m_param->toneMapFile == NULL)
+ if (m_param->bDhdr10opt && strlen(m_param->toneMapFile) == 0)
{
x265_log(p, X265_LOG_WARNING, "Disabling dhdr10-opt. dhdr10-info must be enabled.\n");
m_param->bDhdr10opt = 0;
}
- if (m_param->toneMapFile)
+ if (strlen(m_param->toneMapFile))
{
if (!x265_fopen(p->toneMapFile, "r"))
{
x265_log(p, X265_LOG_ERROR, "Unable to open tone-map file.\n");
m_bToneMap = 0;
- m_param->toneMapFile = NULL;
+ m_param->toneMapFile[0] = 0;
m_aborted = true;
}
else
@@ -4480,11 +4465,11 @@ void Encoder::configure(x265_param *p)
else
m_bToneMap = 0;
#else
- if (m_param->toneMapFile)
+ if (strlen(m_param->toneMapFile))
{
x265_log(p, X265_LOG_WARNING, "--dhdr10-info disabled. Enable HDR10_PLUS in cmake.\n");
m_bToneMap = 0;
- m_param->toneMapFile = NULL;
+ m_param->toneMapFile[0] = 0;
}
else if (m_param->bDhdr10opt)
{
@@ -4648,10 +4633,10 @@ void Encoder::configure(x265_param *p)
}
}
- if (p->videoSignalTypePreset) // Default disabled.
+ if (strlen(p->videoSignalTypePreset)) // Default disabled.
configureVideoSignalTypePreset(p);
- if (m_param->toneMapFile || p->bHDR10Opt || p->bEmitHDR10SEI)
+ if (strlen(m_param->toneMapFile) || p->bHDR10Opt || p->bEmitHDR10SEI)
{
if (!p->bRepeatHeaders)
{
@@ -6281,6 +6266,8 @@ void Encoder::readUserSeiFile(x265_sei_payload& seiMsg, int curPoc)
x265_log(m_param, X265_LOG_WARNING, "SEI message for frame %d is not inserted. Will support only PREFIX SEI messages.\n", poc);
break;
}
+ if (base64Decode)
+ free(base64Decode);
}
}
diff --git a/source/encoder/encoder.h b/source/encoder/encoder.h
index 6289779e7..95c73de8a 100644
--- a/source/encoder/encoder.h
+++ b/source/encoder/encoder.h
@@ -209,6 +209,7 @@ public:
x265_param* m_param;
x265_param* m_latestParam; // Holds latest param during a reconfigure
x265_param* m_zoneParam;
+ x265_param* m_templateParam;
RateControl* m_rateControl;
Lookahead* m_lookahead;
AdaptiveFrameDuplication* m_dupBuffer[DUP_BUFFER]; // picture buffer of size 2
diff --git a/source/encoder/frameencoder.cpp b/source/encoder/frameencoder.cpp
index b6f2d6ed1..95eef813b 100644
--- a/source/encoder/frameencoder.cpp
+++ b/source/encoder/frameencoder.cpp
@@ -109,8 +109,6 @@ void FrameEncoder::destroy()
if (m_param->bEnableTemporalFilter)
{
- delete m_frameEncTF->m_metld;
-
for (int i = 0; i < (m_frameEncTF->m_range << 1); i++)
m_frameEncTF->destroyRefPicInfo(&m_mcstfRefList[i]);
@@ -368,7 +366,7 @@ void FrameEncoder::threadMain()
while (!m_frame[0]->m_ctuInfo)
m_frame[0]->m_copied.wait();
}
- if ((m_param->bAnalysisType == AVC_INFO) && !m_param->analysisSave && !m_param->analysisLoad && !(IS_X265_TYPE_I(m_frame[0]->m_lowres.sliceType)))
+ if ((m_param->bAnalysisType == AVC_INFO) && !strlen(m_param->analysisSave) && !strlen(m_param->analysisLoad) && !(IS_X265_TYPE_I(m_frame[0]->m_lowres.sliceType)))
{
while (((m_frame[0]->m_analysisData.interData == NULL && m_frame[0]->m_analysisData.intraData == NULL) || (uint32_t)m_frame[0]->m_poc != m_frame[0]->m_analysisData.poc))
m_frame[0]->m_copyMVType.wait();
@@ -555,7 +553,7 @@ void FrameEncoder::compressFrame(int layer)
m_cuStats.countWeightAnalyze++;
ScopedElapsedTime time(m_cuStats.weightAnalyzeTime);
#endif
- if (m_param->analysisLoad)
+ if (strlen(m_param->analysisLoad))
{
for (int list = 0; list < slice->isInterB() + 1; list++)
{
@@ -580,7 +578,7 @@ void FrameEncoder::compressFrame(int layer)
else
slice->disableWeights();
- if (m_param->analysisSave && (bUseWeightP || bUseWeightB))
+ if (strlen(m_param->analysisSave) && (bUseWeightP || bUseWeightB))
reuseWP = (WeightParam*)m_frame[layer]->m_analysisData.wt;
// Generate motion references
int numPredDir = slice->isInterP() ? 1 : slice->isInterB() ? 2 : 0;
@@ -594,7 +592,7 @@ void FrameEncoder::compressFrame(int layer)
slice->m_refReconPicList[l][ref] = slice->m_refFrameList[l][ref]->m_reconPic[0];
m_mref[l][ref].init(slice->m_refReconPicList[l][ref], w, *m_param);
}
- if (m_param->analysisSave && (bUseWeightP || bUseWeightB))
+ if (strlen(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];
@@ -1656,7 +1654,7 @@ void FrameEncoder::processRowEncoder(int intRow, ThreadLocalData& tld, int layer
/* 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->analysisLoad || !m_param->bDisableLookahead)
+ if (!strlen(m_param->analysisLoad) || !m_param->bDisableLookahead)
{
cuStat.vbvCost = 0;
cuStat.intraVbvCost = 0;
diff --git a/source/encoder/framefilter.cpp b/source/encoder/framefilter.cpp
index 71dc42b2c..b58799afd 100644
--- a/source/encoder/framefilter.cpp
+++ b/source/encoder/framefilter.cpp
@@ -162,11 +162,9 @@ void FrameFilter::destroy()
if (m_parallelFilter)
{
- if (m_useSao)
- {
- for(int row = 0; row < m_numRows; row++)
- m_parallelFilter[row].m_sao.destroy((row == 0 ? 1 : 0));
- }
+ // NOTE: don't check m_useSao because it is dynamic controllable
+ for(int row = 0; row < m_numRows; row++)
+ m_parallelFilter[row].m_sao.destroy((row == 0 ? 1 : 0));
delete[] m_parallelFilter;
m_parallelFilter = NULL;
diff --git a/source/encoder/ratecontrol.cpp b/source/encoder/ratecontrol.cpp
index e46896987..5908992ce 100644
--- a/source/encoder/ratecontrol.cpp
+++ b/source/encoder/ratecontrol.cpp
@@ -496,7 +496,7 @@ bool RateControl::init(const SPS& sps)
{
/* If the user hasn't defined the stat filename, use the default value */
const char *fileName = m_param->rc.statFileName;
- if (!fileName)
+ if (!strlen(fileName))
fileName = s_defaultStatFileName;
/* Load stat file and init 2pass algo */
if (m_param->rc.bStatRead)
@@ -3329,7 +3329,7 @@ void RateControl::terminate()
void RateControl::destroy()
{
const char *fileName = m_param->rc.statFileName;
- if (!fileName)
+ if (!strlen(fileName))
fileName = s_defaultStatFileName;
if (m_statFileOut)
diff --git a/source/encoder/search.cpp b/source/encoder/search.cpp
index e398843a8..2a324700d 100644
--- a/source/encoder/search.cpp
+++ b/source/encoder/search.cpp
@@ -2135,7 +2135,7 @@ void Search::singleMotionEstimation(Search& master, Mode& interMode, const Predi
bool bLowresMVP = false;
MV mvmin, mvmax, outmv, mvp = amvp[mvpIdx], mvp_lowres;
- if (!m_param->analysisSave && !m_param->analysisLoad) /* Prevents load/save outputs from diverging if lowresMV is not available */
+ if (!strlen(m_param->analysisSave) && !strlen(m_param->analysisLoad)) /* Prevents load/save outputs from diverging if lowresMV is not available */
{
MV lmv = getLowresMV(interMode.cu, pu, list, ref);
int layer = m_param->numViews > 1 ? m_frame->m_viewId : (m_param->numScalableLayers > 1) ? m_frame->m_sLayerId : 0;
@@ -2476,7 +2476,7 @@ void Search::predInterSearch(Mode& interMode, const CUGeom& cuGeom, bool bChroma
MV mvmin, mvmax, outmv, mvp = amvp[mvpIdx], mvp_lowres;
bool bLowresMVP = false;
- if (!m_param->analysisSave && !m_param->analysisLoad) /* Prevents load/save outputs from diverging when lowresMV is not available */
+ if (!strlen(m_param->analysisSave) && !strlen(m_param->analysisLoad)) /* Prevents load/save outputs from diverging when lowresMV is not available */
{
MV lmv = getLowresMV(cu, pu, list, ref);
int layer = m_param->numViews > 1 ? m_frame->m_viewId : (m_param->numScalableLayers > 1) ? m_frame->m_sLayerId : 0;
diff --git a/source/encoder/slicetype.cpp b/source/encoder/slicetype.cpp
index 046cf1596..f44c11ac4 100644
--- a/source/encoder/slicetype.cpp
+++ b/source/encoder/slicetype.cpp
@@ -1194,7 +1194,7 @@ void Lookahead::destroy()
/* Called by API thread */
void Lookahead::addPicture(Frame& curFrame, int sliceType)
{
- if (m_param->analysisLoad && m_param->bDisableLookahead)
+ if (strlen(m_param->analysisLoad) && m_param->bDisableLookahead)
{
if (!m_filled)
m_filled = true;
@@ -1295,7 +1295,7 @@ Frame* Lookahead::getDecidedPicture()
return out;
}
- if (m_param->analysisLoad && m_param->bDisableLookahead)
+ if (strlen(m_param->analysisLoad) && m_param->bDisableLookahead)
return NULL;
findJob(-1); /* run slicetypeDecide() if necessary */
@@ -1365,14 +1365,14 @@ void Lookahead::getEstimatedPictureCost(Frame *curFrame)
default:
return;
}
- if (!curFrame->m_param->analysisLoad || !curFrame->m_param->bDisableLookahead)
+ if (!strlen(curFrame->m_param->analysisLoad) || !curFrame->m_param->bDisableLookahead)
{
X265_CHECK(curFrame->m_lowres.costEst[b - p0][p1 - b] > 0, "Slice cost not estimated\n")
if (curFrame->m_param->rc.cuTree && !curFrame->m_param->rc.bStatRead)
/* update row satds based on cutree offsets */
curFrame->m_lowres.satdCost = frameCostRecalculate(frames, p0, p1, b);
- else if (!curFrame->m_param->analysisLoad || curFrame->m_param->scaleFactor || curFrame->m_param->bAnalysisType == HEVC_INFO)
+ else if (!strlen(curFrame->m_param->analysisLoad) || curFrame->m_param->scaleFactor || curFrame->m_param->bAnalysisType == HEVC_INFO)
{
if (curFrame->m_param->rc.aqMode)
curFrame->m_lowres.satdCost = curFrame->m_lowres.costEstAq[b - p0][p1 - b];
@@ -1909,7 +1909,7 @@ void Lookahead::slicetypeDecide()
if (!m_param->rc.bStatRead)
slicetypeAnalyse(frames, false);
bool bIsVbv = m_param->rc.vbvBufferSize > 0 && m_param->rc.vbvMaxBitrate > 0;
- if ((m_param->analysisLoad && m_param->scaleFactor && bIsVbv) || m_param->bliveVBV2pass)
+ if ((strlen(m_param->analysisLoad) && m_param->scaleFactor && bIsVbv) || m_param->bliveVBV2pass)
{
int numFrames;
for (numFrames = 0; numFrames < maxSearch; numFrames++)
@@ -1923,7 +1923,7 @@ void Lookahead::slicetypeDecide()
}
int bframes, brefs;
- if (!m_param->analysisLoad || m_param->bAnalysisType == HEVC_INFO)
+ if (!strlen(m_param->analysisLoad) || m_param->bAnalysisType == HEVC_INFO)
{
bool isClosedGopRadl = m_param->radl && (m_param->keyframeMax != m_param->keyframeMin);
for (bframes = 0, brefs = 0;; bframes++)
@@ -2340,7 +2340,7 @@ void Lookahead::slicetypeDecide()
if (!m_param->rc.bStatRead)
slicetypeAnalyse(frames, true);
bool bIsVbv = m_param->rc.vbvBufferSize > 0 && m_param->rc.vbvMaxBitrate > 0;
- if ((m_param->analysisLoad && m_param->scaleFactor && bIsVbv) || m_param->bliveVBV2pass)
+ if ((strlen(m_param->analysisLoad) && m_param->scaleFactor && bIsVbv) || m_param->bliveVBV2pass)
{
int numFrames;
for (numFrames = 0; numFrames < maxSearch; numFrames++)
@@ -2485,7 +2485,7 @@ void Lookahead::slicetypeDecide()
if (!m_param->rc.bStatRead)
slicetypeAnalyse(frames, true);
bool bIsVbv = m_param->rc.vbvBufferSize > 0 && m_param->rc.vbvMaxBitrate > 0;
- if ((m_param->analysisLoad && m_param->scaleFactor && bIsVbv) || m_param->bliveVBV2pass)
+ if ((strlen(m_param->analysisLoad) && m_param->scaleFactor && bIsVbv) || m_param->bliveVBV2pass)
{
int numFrames;
for (numFrames = 0; numFrames < maxSearch; numFrames++)
diff --git a/source/x265.cpp b/source/x265.cpp
index c9d2513e2..f392d27bf 100644
--- a/source/x265.cpp
+++ b/source/x265.cpp
@@ -154,6 +154,9 @@ static bool parseAbrConfig(FILE* abrConfig, CLIOptions cliopt[], uint8_t numEnco
char line[1024];
char* argLine;
+ char **argv = (char**)alloca(256 * sizeof(char *));
+ char *strPool = (char*)alloca(256 * X265_MAX_STRING_SIZE * sizeof(char));
+ int strPoolSize = 256 * X265_MAX_STRING_SIZE;
for (uint32_t i = 0; i < numEncodes; i++)
{
if (fgets(line, sizeof(line), abrConfig) == NULL) {
@@ -168,7 +171,6 @@ static bool parseAbrConfig(FILE* abrConfig, CLIOptions cliopt[], uint8_t numEnco
char* start = strchr(argLine, ' ');
while (isspace((unsigned char)*start)) start++;
int argc = 0;
- char **argv = (char**)malloc(256 * sizeof(char *));
// Adding a dummy string to avoid file parsing error
argv[argc++] = (char *)"x265";
@@ -193,15 +195,18 @@ static bool parseAbrConfig(FILE* abrConfig, CLIOptions cliopt[], uint8_t numEnco
}
else
{
- cliopt[i].encName = strdup(head[0]);
+ snprintf(cliopt[i].encName, X265_MAX_STRING_SIZE, "%s", head[0]);
cliopt[i].loadLevel = atoi(head[1]);
- cliopt[i].reuseName = strdup(head[2]);
+ snprintf(cliopt[i].reuseName, X265_MAX_STRING_SIZE, "%s", head[2]);
}
char* token = strtok(start, " ");
while (token)
{
- argv[argc++] = strdup(token);
+ argv[argc++] = strPool;
+ strPool += strlen(token);
+ strPoolSize -= strlen(token);
+ strcpy(argv[argc++], token);
token = strtok(NULL, " ");
}
argv[argc] = NULL;
@@ -213,6 +218,7 @@ static bool parseAbrConfig(FILE* abrConfig, CLIOptions cliopt[], uint8_t numEnco
exit(1);
}
}
+ X265_CHECK(strPoolSize >= 0, "string pool broken!");
return true;
}
@@ -319,11 +325,11 @@ int main(int argc, char **argv)
if (abrEnc->m_passEnc[idx]->m_ret)
{
if (isAbrLadder)
- x265_log(NULL, X265_LOG_INFO, "Error generating ABR-ladder \n");
- ret = abrEnc->m_passEnc[idx]->m_ret;
- threadsActive = 0;
- break;
- }
+ x265_log(NULL, X265_LOG_INFO, "Error generating ABR-ladder \n");
+ ret = abrEnc->m_passEnc[idx]->m_ret;
+ threadsActive = 0;
+ break;
+ }
}
}
diff --git a/source/x265.h b/source/x265.h
index 13c4a47e2..671e196f6 100644
--- a/source/x265.h
+++ b/source/x265.h
@@ -36,6 +36,8 @@ extern "C" {
#pragma warning(disable: 4201) // non-standard extension used (nameless struct/union)
#endif
+#define X265_MAX_STRING_SIZE (256)
+
/* x265_encoder:
* opaque handler for encoder */
typedef struct x265_encoder x265_encoder;
@@ -1141,7 +1143,7 @@ typedef struct x265_param
*
* Frame encoders are distributed between the available thread pools, and
* the encoder will never generate more thread pools than frameNumThreads */
- const char* numaPools;
+ char numaPools[X265_MAX_STRING_SIZE];
/* Enable wavefront parallel processing, greatly increases parallelism for
* less than 1% compression efficiency loss. Requires a thread pool, enabled
@@ -1185,7 +1187,7 @@ typedef struct x265_param
* per-slice statistics to this log file in encode order. Otherwise the
* encoder will emit per-stream statistics into the log file when
* x265_encoder_log is called (presumably at the end of the encode) */
- const char* csvfn;
+ char csvfn[X265_MAX_STRING_SIZE];
/*== Internal Picture Specification ==*/
@@ -1465,7 +1467,7 @@ typedef struct x265_param
* - all other strings indicate a filename containing custom scaling lists
* in the HM format. The encode will fail if the file is not parsed
* correctly. Custom lists must be signaled in the SPS. */
- const char *scalingLists;
+ char scalingLists[X265_MAX_STRING_SIZE];
/*== Intra Coding Tools ==*/
@@ -1650,7 +1652,7 @@ typedef struct x265_param
int analysisReuseMode;
/* Filename for multi-pass-opt-analysis/distortion. Default name is "x265_analysis.dat" */
- const char* analysisReuseFileName;
+ char analysisReuseFileName[X265_MAX_STRING_SIZE];
/*== Rate Control ==*/
@@ -1767,7 +1769,7 @@ typedef struct x265_param
/* Filename of the 2pass output/input stats file, if unspecified the
* encoder will default to using x265_2pass.log */
- const char* statFileName;
+ char statFileName[X265_MAX_STRING_SIZE];
/* temporally blur quants */
double qblur;
@@ -1791,7 +1793,7 @@ typedef struct x265_param
* are separated by comma, space or newline. Text after a hash (#) is
* ignored. The lambda tables are process-global, so these new lambda
* values will affect all encoders in the same process */
- const char* lambdaFileName;
+ char lambdaFileName[X265_MAX_STRING_SIZE];
/* Enable stricter conditions to check bitrate deviations in CBR mode. May compromise
* quality to maintain bitrate adherence */
@@ -1828,7 +1830,7 @@ typedef struct x265_param
int dataShareMode;
/* Unique shared memory name. Required if the shared memory mode enabled. NULL by default */
- const char* sharedMemName;
+ char sharedMemName[X265_MAX_STRING_SIZE];
} rc;
@@ -1933,7 +1935,7 @@ typedef struct x265_param
* are unsigned 16bit integers and %u are unsigned 32bit integers. The SEI
* includes X,Y display primaries for RGB channels, white point X,Y and
* max,min luminance values. */
- const char* masteringDisplayColorVolume;
+ char masteringDisplayColorVolume[X265_MAX_STRING_SIZE];
/* Maximum Content light level(MaxCLL), specified as integer that indicates the
* maximum pixel intensity level in units of 1 candela per square metre of the
@@ -2022,7 +2024,7 @@ typedef struct x265_param
int bLimitSAO;
/* File containing the tone mapping information */
- const char* toneMapFile;
+ char toneMapFile[X265_MAX_STRING_SIZE];
/* Insert tone mapping information only for IDR frames and when the
* tone mapping information changes. */
@@ -2098,11 +2100,11 @@ typedef struct x265_param
int gopLookahead;
/*Write per-frame analysis information into analysis buffers. Default disabled. */
- const char* analysisSave;
+ char analysisSave[X265_MAX_STRING_SIZE];
/* 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;
+ char analysisLoad[X265_MAX_STRING_SIZE];
/*Number of RADL pictures allowed in front of IDR*/
int radl;
@@ -2134,7 +2136,7 @@ typedef struct x265_param
* Default 0 (disabled). */
int chunkEnd;
/* File containing base64 encoded SEI messages in POC order */
- const char* naluFile;
+ char naluFile[X265_MAX_STRING_SIZE];
/* Generate bitstreams confirming to the specified dolby vision profile,
* note that 0x7C01 makes RPU appear to be an unspecified NAL type in
@@ -2295,7 +2297,7 @@ typedef struct x265_param
* precedence than individual VUI parameters. If any individual VUI option is specified
* together with this, which changes the values set corresponding to the system-id
* or color-volume, it will be discarded. */
- const char* videoSignalTypePreset;
+ char videoSignalTypePreset[X265_MAX_STRING_SIZE];
/* Flag indicating whether the encoder should emit an End of Bitstream
* NAL at the end of bitstream. Default false */
diff --git a/source/x265cli.cpp b/source/x265cli.cpp
index 12df761cc..fd82ebd22 100755
--- a/source/x265cli.cpp
+++ b/source/x265cli.cpp
@@ -555,7 +555,6 @@ namespace X265_NS {
showHelp(globalParam);
}
- globalParam->rc.zones[zonefileCount].zoneParam = api->param_alloc();
if (!globalParam->rc.zones[zonefileCount].zoneParam)
{
x265_log(NULL, X265_LOG_ERROR, "param alloc failed\n");
@@ -1131,6 +1130,7 @@ namespace X265_NS {
}
rewind(zoneFile);
+ char **args = (char**)alloca(256 * sizeof(char *));
param->rc.zones = X265_MALLOC(x265_zone, param->rc.zonefileCount);
for (int i = 0; i < param->rc.zonefileCount; i++)
{
@@ -1148,7 +1148,6 @@ namespace X265_NS {
start++;
param->rc.zones[i].startFrame = atoi(argLine);
int argCount = 0;
- char **args = (char**)malloc(256 * sizeof(char *));
// Adding a dummy string to avoid file parsing error
args[argCount++] = (char *)"x265";
char* token = strtok(start, " ");
@@ -1354,6 +1353,7 @@ namespace X265_NS {
rewind(multiViewConfig);
int linenum = 0;
int numInput = 0;
+ char** args = (char**)malloc(256 * sizeof(char*));
while (fgets(line, sizeof(line), multiViewConfig))
{
if (*line == '#' || (strcmp(line, "\r\n") == 0))
@@ -1365,7 +1365,6 @@ namespace X265_NS {
char* start = strchr(argLine, '-');
int argCount = 0;
char flag[] = "true";
- char** args = (char**)malloc(256 * sizeof(char*));
//Adding a dummy string to avoid file parsing error
args[argCount++] = (char*)"x265";
char* token = strtok(start, " ");
@@ -1467,10 +1466,12 @@ namespace X265_NS {
{
if (api)
api->param_free(param);
+ free(args);
exit(1);
}
linenum++;
}
+ free(args);
if (numInput != (param->format ? 1 : param->numViews))
{
x265_log(NULL, X265_LOG_WARNING, "Number of Input files does not match with the given format <%d>\n", param->format);
diff --git a/source/x265cli.h b/source/x265cli.h
index 3df0fa7a6..aaa385cb4 100644
--- a/source/x265cli.h
+++ b/source/x265cli.h
@@ -434,8 +434,8 @@ static const struct option long_options[] =
/* ABR ladder settings */
bool isAbrLadderConfig;
bool enableScaler;
- char* encName;
- char* reuseName;
+ char encName[X265_MAX_STRING_SIZE];
+ char reuseName[X265_MAX_STRING_SIZE];
uint32_t encId;
int refId;
uint32_t loadLevel;
@@ -471,8 +471,8 @@ static const struct option long_options[] =
bDither = false;
isAbrLadderConfig = false;
enableScaler = false;
- encName = NULL;
- reuseName = NULL;
+ encName[0] = 0;
+ reuseName[0] = 0;
encId = 0;
refId = -1;
loadLevel = 0;
--
2.41.0.windows.1
_______________________________________________
x265-devel mailing list
x265-devel at videolan.org
https://mailman.videolan.org/listinfo/x265-devel
Attachments:
0002-Memory-Leak-Fix-Part2.patch
--
Jean-Baptiste Kempf - President
+33 672 704 734
https://jbkempf.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.videolan.org/pipermail/x265-devel/attachments/20241111/c9ff1648/attachment-0001.htm>
More information about the x265-devel
mailing list