[x265] [PATCH] Expose WeightParam, analysis_inter_data, analysis_intra_data and analysisDistortionData structures in API
aasaipriya at multicorewareinc.com
aasaipriya at multicorewareinc.com
Fri Jul 20 10:53:09 CEST 2018
# HG changeset patch
# User Aasaipriya Chandran <aasaipriya at multicorewareinc.com>
# Date 1532075633 -19800
# Fri Jul 20 14:03:53 2018 +0530
# Node ID 9694dfbe83ac404bce0c88ca19ed06decd93c71d
# Parent fb1530b0e1b4ebd179b8098015213baeeb37c8d2
Expose WeightParam, analysis_inter_data, analysis_intra_data and analysisDistortionData structures in API
diff -r fb1530b0e1b4 -r 9694dfbe83ac source/common/framedata.h
--- a/source/common/framedata.h Fri Jul 20 14:20:22 2018 +0530
+++ b/source/common/framedata.h Fri Jul 20 14:03:53 2018 +0530
@@ -179,42 +179,5 @@
inline CUData* getPicCTU(uint32_t ctuAddr) { return &m_picCTU[ctuAddr]; }
};
-/* Stores intra analysis data for a single frame. This struct needs better packing */
-struct analysis_intra_data
-{
- uint8_t* depth;
- uint8_t* modes;
- char* partSizes;
- uint8_t* chromaModes;
-};
-
-/* Stores inter analysis data for a single frame */
-struct analysis_inter_data
-{
- int32_t* ref;
- uint8_t* depth;
- uint8_t* modes;
- uint8_t* partSize;
- uint8_t* mergeFlag;
- uint8_t* interDir;
- uint8_t* mvpIdx[2];
- int8_t* refIdx[2];
- MV* mv[2];
- int64_t* sadCost;
-};
-
-struct analysisDistortionData
-{
- sse_t* distortion;
- sse_t* ctuDistortion;
- double* scaledDistortion;
- double averageDistortion;
- double sdDistortion;
- uint32_t highDistortionCtuCount;
- uint32_t lowDistortionCtuCount;
- double* offset;
- double* threshold;
-};
-
}
#endif // ifndef X265_FRAMEDATA_H
diff -r fb1530b0e1b4 -r 9694dfbe83ac source/encoder/analysis.cpp
--- a/source/encoder/analysis.cpp Fri Jul 20 14:20:22 2018 +0530
+++ b/source/encoder/analysis.cpp Fri Jul 20 14:03:53 2018 +0530
@@ -37,7 +37,7 @@
using namespace X265_NS;
/* An explanation of rate distortion levels (--rd-level)
- *
+ *
* rd-level 0 generates no recon per CU (NO RDO or Quant)
*
* sa8d selection between merge / skip / inter / intra and split
@@ -70,6 +70,12 @@
* rd-level 5,6 does RDO for each inter mode
*/
+#define COPY_TO_MV(s1, s2, d1, d2)\
+ {\
+ d1 = s1; \
+ d2 = s2; \
+ }
+
Analysis::Analysis()
{
m_reuseInterDataCTU = NULL;
@@ -190,7 +196,7 @@
if (m_param->analysisMultiPassRefine && m_param->rc.bStatRead && (m_slice->m_sliceType != I_SLICE))
{
int numPredDir = m_slice->isInterP() ? 1 : 2;
- m_reuseInterDataCTU = (analysis_inter_data*)m_frame->m_analysisData.interData;
+ m_reuseInterDataCTU = m_frame->m_analysisData.interData;
for (int dir = 0; dir < numPredDir; dir++)
{
m_reuseMv[dir] = &m_reuseInterDataCTU->mv[dir][ctu.m_cuAddr * ctu.m_numPartitions];
@@ -204,7 +210,7 @@
if ((m_param->analysisSave || m_param->analysisLoad) && m_slice->m_sliceType != I_SLICE && m_param->analysisReuseLevel > 1 && m_param->analysisReuseLevel < 10)
{
int numPredDir = m_slice->isInterP() ? 1 : 2;
- m_reuseInterDataCTU = (analysis_inter_data*)m_frame->m_analysisData.interData;
+ m_reuseInterDataCTU = m_frame->m_analysisData.interData;
m_reuseRef = &m_reuseInterDataCTU->ref [ctu.m_cuAddr * X265_MAX_PRED_MODE_PER_CTU * numPredDir];
m_reuseDepth = &m_reuseInterDataCTU->depth[ctu.m_cuAddr * ctu.m_numPartitions];
m_reuseModes = &m_reuseInterDataCTU->modes[ctu.m_cuAddr * ctu.m_numPartitions];
@@ -221,7 +227,7 @@
if (m_slice->m_sliceType == I_SLICE)
{
- analysis_intra_data* intraDataCTU = (analysis_intra_data*)m_frame->m_analysisData.intraData;
+ x265_analysis_intra_data* intraDataCTU = m_frame->m_analysisData.intraData;
if (m_param->analysisLoad && m_param->analysisReuseLevel > 1)
{
memcpy(ctu.m_cuDepth, &intraDataCTU->depth[ctu.m_cuAddr * numPartition], sizeof(uint8_t) * numPartition);
@@ -240,7 +246,7 @@
if (bCopyAnalysis)
{
- analysis_inter_data* interDataCTU = (analysis_inter_data*)m_frame->m_analysisData.interData;
+ x265_analysis_inter_data* interDataCTU = m_frame->m_analysisData.interData;
int posCTU = ctu.m_cuAddr * numPartition;
memcpy(ctu.m_cuDepth, &interDataCTU->depth[posCTU], sizeof(uint8_t) * numPartition);
memcpy(ctu.m_predMode, &interDataCTU->modes[posCTU], sizeof(uint8_t) * numPartition);
@@ -250,7 +256,7 @@
if ((m_slice->m_sliceType == P_SLICE || m_param->bIntraInBFrames) && !m_param->bMVType)
{
- analysis_intra_data* intraDataCTU = (analysis_intra_data*)m_frame->m_analysisData.intraData;
+ x265_analysis_intra_data* intraDataCTU = m_frame->m_analysisData.intraData;
memcpy(ctu.m_lumaIntraDir, &intraDataCTU->modes[posCTU], sizeof(uint8_t) * numPartition);
memcpy(ctu.m_chromaIntraDir, &intraDataCTU->chromaModes[posCTU], sizeof(uint8_t) * numPartition);
}
@@ -276,14 +282,14 @@
}
else if ((m_param->analysisLoad && m_param->analysisReuseLevel == 10) || ((m_param->bMVType == AVC_INFO) && m_param->analysisReuseLevel >= 7 && ctu.m_numPartitions <= 16))
{
- analysis_inter_data* interDataCTU = (analysis_inter_data*)m_frame->m_analysisData.interData;
+ x265_analysis_inter_data* interDataCTU = m_frame->m_analysisData.interData;
int posCTU = ctu.m_cuAddr * numPartition;
memcpy(ctu.m_cuDepth, &interDataCTU->depth[posCTU], sizeof(uint8_t) * numPartition);
memcpy(ctu.m_predMode, &interDataCTU->modes[posCTU], sizeof(uint8_t) * numPartition);
memcpy(ctu.m_partSize, &interDataCTU->partSize[posCTU], sizeof(uint8_t) * numPartition);
if ((m_slice->m_sliceType == P_SLICE || m_param->bIntraInBFrames) && !(m_param->bMVType == AVC_INFO))
{
- analysis_intra_data* intraDataCTU = (analysis_intra_data*)m_frame->m_analysisData.intraData;
+ x265_analysis_intra_data* intraDataCTU = m_frame->m_analysisData.intraData;
memcpy(ctu.m_lumaIntraDir, &intraDataCTU->modes[posCTU], sizeof(uint8_t) * numPartition);
memcpy(ctu.m_chromaIntraDir, &intraDataCTU->chromaModes[posCTU], sizeof(uint8_t) * numPartition);
}
@@ -2455,13 +2461,15 @@
PredictionUnit pu(mode.cu, cuGeom, part);
if ((m_param->analysisLoad && m_param->analysisReuseLevel == 10) || (m_param->bMVType == AVC_INFO && m_param->analysisReuseLevel >= 7))
{
- analysis_inter_data* interDataCTU = (analysis_inter_data*)m_frame->m_analysisData.interData;
+ x265_analysis_inter_data* interDataCTU = m_frame->m_analysisData.interData;
int cuIdx = (mode.cu.m_cuAddr * parentCTU.m_numPartitions) + cuGeom.absPartIdx;
mode.cu.m_mergeFlag[pu.puAbsPartIdx] = interDataCTU->mergeFlag[cuIdx + part];
mode.cu.setPUInterDir(interDataCTU->interDir[cuIdx + part], pu.puAbsPartIdx, part);
for (int list = 0; list < m_slice->isInterB() + 1; list++)
{
- mode.cu.setPUMv(list, interDataCTU->mv[list][cuIdx + part], pu.puAbsPartIdx, part);
+ MV dst; x265_analysis_MV src = interDataCTU->mv[list][cuIdx + part];
+ COPY_TO_MV(src.x, src.y, dst.x, dst.y);
+ mode.cu.setPUMv(list, dst, pu.puAbsPartIdx, part);
mode.cu.setPURefIdx(list, interDataCTU->refIdx[list][cuIdx + part], pu.puAbsPartIdx, part);
mode.cu.m_mvpIdx[list][pu.puAbsPartIdx] = interDataCTU->mvpIdx[list][cuIdx + part];
}
@@ -2483,7 +2491,10 @@
if (m_param->interRefine != 1)
mvp = mode.amvpCand[list][ref][mode.cu.m_mvpIdx[list][pu.puAbsPartIdx]];
else
- mvp = interDataCTU->mv[list][cuIdx + part];
+ {
+ x265_analysis_MV src = interDataCTU->mv[list][cuIdx + part];
+ COPY_TO_MV(src.x, src.y, mvp.x, mvp.y);
+ }
if (m_param->mvRefine || m_param->interRefine == 1)
{
MV outmv;
@@ -3021,8 +3032,9 @@
for (int32_t i = 0; i < numPredDir; i++)
{
int* ref = &m_reuseRef[i * m_frame->m_analysisData.numPartitions * m_frame->m_analysisData.numCUsInFrame];
+ x265_analysis_MV src = m_reuseMv[i][cuGeom.absPartIdx]; MV dst = bestME[i].mv;
bestME[i].ref = ref[cuGeom.absPartIdx];
- bestME[i].mv = m_reuseMv[i][cuGeom.absPartIdx];
+ COPY_TO_MV(src.x, src.y, dst.x, dst.y);
bestME[i].mvpIdx = m_reuseMvpIdx[i][cuGeom.absPartIdx];
}
}
@@ -3085,9 +3097,10 @@
MotionData* bestME = interMode.bestME[part];
for (int32_t i = 0; i < numPredDir; i++)
{
+ x265_analysis_MV src = m_reuseMv[i][cuGeom.absPartIdx]; MV dst = bestME[i].mv;
int* ref = &m_reuseRef[i * m_frame->m_analysisData.numPartitions * m_frame->m_analysisData.numCUsInFrame];
bestME[i].ref = ref[cuGeom.absPartIdx];
- bestME[i].mv = m_reuseMv[i][cuGeom.absPartIdx];
+ COPY_TO_MV(src.x, src.y, dst.x, dst.y);
bestME[i].mvpIdx = m_reuseMvpIdx[i][cuGeom.absPartIdx];
}
}
@@ -3562,7 +3575,7 @@
if (m_param->analysisMultiPassDistortion && m_param->rc.bStatRead)
{
- analysisDistortionData* distortionData = (analysisDistortionData*)m_frame->m_analysisData.distortionData;
+ 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)
&& distortionData->highDistortionCtuCount && distortionData->lowDistortionCtuCount)
qp += distortionData->offset[ctu.m_cuAddr];
diff -r fb1530b0e1b4 -r 9694dfbe83ac source/encoder/analysis.h
--- a/source/encoder/analysis.h Fri Jul 20 14:20:22 2018 +0530
+++ b/source/encoder/analysis.h Fri Jul 20 14:03:53 2018 +0530
@@ -123,13 +123,13 @@
protected:
/* Analysis data for save/load mode, writes/reads data based on absPartIdx */
- analysis_inter_data* m_reuseInterDataCTU;
- int32_t* m_reuseRef;
- uint8_t* m_reuseDepth;
- uint8_t* m_reuseModes;
- uint8_t* m_reusePartSize;
- uint8_t* m_reuseMergeFlag;
- MV* m_reuseMv[2];
+ x265_analysis_inter_data* m_reuseInterDataCTU;
+ int32_t* m_reuseRef;
+ uint8_t* m_reuseDepth;
+ uint8_t* m_reuseModes;
+ uint8_t* m_reusePartSize;
+ uint8_t* m_reuseMergeFlag;
+ x265_analysis_MV* m_reuseMv[2];
uint8_t* m_reuseMvpIdx[2];
uint32_t m_splitRefIdx[4];
diff -r fb1530b0e1b4 -r 9694dfbe83ac source/encoder/api.cpp
--- a/source/encoder/api.cpp Fri Jul 20 14:20:22 2018 +0530
+++ b/source/encoder/api.cpp Fri Jul 20 14:03:53 2018 +0530
@@ -406,14 +406,16 @@
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;
+ analysis->interData = NULL;
+ analysis->intraData = NULL;
+ 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);
+ x265_analysis_distortion_data *distortionData = analysis->distortionData;
+ CHECKED_MALLOC_ZERO(distortionData, x265_analysis_distortion_data, 1);
CHECKED_MALLOC_ZERO(distortionData->distortion, sse_t, analysis->numPartitions * analysis->numCUsInFrame);
if (param->rc.bStatRead)
{
@@ -434,14 +436,14 @@
//Allocate memory for weightParam pointer
if (!(param->bMVType == AVC_INFO))
- CHECKED_MALLOC_ZERO(analysis->wt, WeightParam, numPlanes * numDir);
+ CHECKED_MALLOC_ZERO(analysis->wt, x265_weight_param, 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);
+ x265_analysis_intra_data *intraData = analysis->intraData;
+ CHECKED_MALLOC_ZERO(intraData, x265_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);
@@ -449,15 +451,15 @@
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);
+ x265_analysis_inter_data *interData = analysis->interData;
+ CHECKED_MALLOC_ZERO(interData, x265_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);
+ CHECKED_MALLOC_ZERO(interData->mv[0], x265_analysis_MV, analysis->numPartitions * analysis->numCUsInFrame);
+ CHECKED_MALLOC_ZERO(interData->mv[1], x265_analysis_MV, analysis->numPartitions * analysis->numCUsInFrame);
if (param->analysisReuseLevel > 4)
{
@@ -506,13 +508,13 @@
//Free memory for distortionData pointers
if (analysis->distortionData)
{
- X265_FREE(((analysisDistortionData*)analysis->distortionData)->distortion);
+ X265_FREE((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)->ctuDistortion);
+ X265_FREE((analysis->distortionData)->scaledDistortion);
+ X265_FREE((analysis->distortionData)->offset);
+ X265_FREE((analysis->distortionData)->threshold);
}
X265_FREE(analysis->distortionData);
}
@@ -527,10 +529,10 @@
//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)->depth);
+ X265_FREE((analysis->intraData)->modes);
+ X265_FREE((analysis->intraData)->partSizes);
+ X265_FREE((analysis->intraData)->chromaModes);
X265_FREE(analysis->intraData);
analysis->intraData = NULL;
}
@@ -538,26 +540,26 @@
//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]);
+ X265_FREE((analysis->interData)->depth);
+ X265_FREE((analysis->interData)->modes);
+ X265_FREE((analysis->interData)->mvpIdx[0]);
+ X265_FREE((analysis->interData)->mvpIdx[1]);
+ X265_FREE((analysis->interData)->mv[0]);
+ X265_FREE((analysis->interData)->mv[1]);
if (param->analysisReuseLevel > 4)
{
- X265_FREE(((analysis_inter_data*)analysis->interData)->mergeFlag);
- X265_FREE(((analysis_inter_data*)analysis->interData)->partSize);
+ X265_FREE((analysis->interData)->mergeFlag);
+ X265_FREE((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);
+ X265_FREE((analysis->interData)->interDir);
+ X265_FREE((analysis->interData)->sadCost);
for (int dir = 0; dir < numDir; dir++)
{
- X265_FREE(((analysis_inter_data*)analysis->interData)->refIdx[dir]);
+ X265_FREE((analysis->interData)->refIdx[dir]);
if (analysis->modeFlag[dir] != NULL)
{
X265_FREE(analysis->modeFlag[dir]);
@@ -566,7 +568,7 @@
}
}
else
- X265_FREE(((analysis_inter_data*)analysis->interData)->ref);
+ X265_FREE((analysis->interData)->ref);
X265_FREE(analysis->interData);
analysis->interData = NULL;
}
diff -r fb1530b0e1b4 -r 9694dfbe83ac source/encoder/encoder.cpp
--- a/source/encoder/encoder.cpp Fri Jul 20 14:20:22 2018 +0530
+++ b/source/encoder/encoder.cpp Fri Jul 20 14:03:53 2018 +0530
@@ -546,8 +546,8 @@
curFrame->m_analysisData.numPartitions = m_param->num4x4Partitions;
int num16x16inCUWidth = m_param->maxCUSize >> 4;
uint32_t ctuAddr, offset, cuPos;
- analysis_intra_data * intraData = (analysis_intra_data *)curFrame->m_analysisData.intraData;
- analysis_intra_data * srcIntraData = (analysis_intra_data *)analysis_data->intraData;
+ x265_analysis_intra_data * intraData = curFrame->m_analysisData.intraData;
+ x265_analysis_intra_data * srcIntraData = analysis_data->intraData;
for (int i = 0; i < mbImageHeight; i++)
{
for (int j = 0; j < mbImageWidth; j++)
@@ -576,8 +576,8 @@
curFrame->m_analysisData.numPartitions = m_param->num4x4Partitions;
int num16x16inCUWidth = m_param->maxCUSize >> 4;
uint32_t ctuAddr, offset, cuPos;
- analysis_inter_data * interData = (analysis_inter_data *)curFrame->m_analysisData.interData;
- analysis_inter_data * srcInterData = (analysis_inter_data*)analysis_data->interData;
+ x265_analysis_inter_data * interData = curFrame->m_analysisData.interData;
+ x265_analysis_inter_data * srcInterData = analysis_data->interData;
for (int i = 0; i < mbImageHeight; i++)
{
for (int j = 0; j < mbImageWidth; j++)
@@ -652,8 +652,8 @@
curFrame->m_analysisData.numPartitions = m_param->num4x4Partitions;
size_t count = 0;
- analysis_intra_data * currIntraData = (analysis_intra_data *)curFrame->m_analysisData.intraData;
- analysis_intra_data * intraData = (analysis_intra_data *)analysis_data->intraData;
+ x265_analysis_intra_data * currIntraData = curFrame->m_analysisData.intraData;
+ x265_analysis_intra_data * intraData = analysis_data->intraData;
for (uint32_t d = 0; d < cuBytes; d++)
{
int bytes = curFrame->m_analysisData.numPartitions >> ((intraData)->depth[d] * 2);
@@ -673,14 +673,14 @@
curFrame->m_analysisData.numPartitions = m_param->num4x4Partitions;
size_t count = 0;
- analysis_inter_data * currInterData = (analysis_inter_data *)curFrame->m_analysisData.interData;
- analysis_inter_data * interData = (analysis_inter_data *)analysis_data->interData;
+ x265_analysis_inter_data * currInterData = curFrame->m_analysisData.interData;
+ x265_analysis_inter_data * interData = analysis_data->interData;
for (uint32_t d = 0; d < cuBytes; d++)
{
int bytes = curFrame->m_analysisData.numPartitions >> ((interData)->depth[d] * 2);
memset(&(currInterData)->depth[count], (interData)->depth[d], bytes);
memset(&(currInterData)->modes[count], (interData)->modes[d], bytes);
- memcpy(&(currInterData)->sadCost[count], &((analysis_inter_data*)analysis_data->interData)->sadCost[d], bytes);
+ memcpy(&(currInterData)->sadCost[count], &(analysis_data->interData)->sadCost[d], bytes);
if (m_param->analysisReuseLevel > 4)
{
memset(&(currInterData)->partSize[count], (interData)->partSize[d], bytes);
@@ -3203,8 +3203,8 @@
if (m_param->bUseAnalysisFile)
fseeko(m_analysisFileIn, totalConsumedBytes + paramBytes, SEEK_SET);
const x265_analysis_data *picData = &(picIn->analysisData);
- analysis_intra_data *intraPic = (analysis_intra_data *)picData->intraData;
- analysis_inter_data *interPic = (analysis_inter_data *)picData->interData;
+ x265_analysis_intra_data *intraPic = picData->intraData;
+ x265_analysis_inter_data *interPic = picData->interData;
int poc; uint32_t frameRecordSize;
X265_FREAD(&frameRecordSize, sizeof(uint32_t), 1, m_analysisFileIn, &(picData->frameRecordSize));
@@ -3305,22 +3305,22 @@
if (partSizes[d] == SIZE_NxN)
partSizes[d] = SIZE_2Nx2N;
}
- memset(&((analysis_intra_data *)analysis->intraData)->depth[count], depthBuf[d], bytes);
- memset(&((analysis_intra_data *)analysis->intraData)->chromaModes[count], modeBuf[d], bytes);
- memset(&((analysis_intra_data *)analysis->intraData)->partSizes[count], partSizes[d], bytes);
+ memset(&(analysis->intraData)->depth[count], depthBuf[d], bytes);
+ memset(&(analysis->intraData)->chromaModes[count], modeBuf[d], bytes);
+ memset(&(analysis->intraData)->partSizes[count], partSizes[d], bytes);
count += bytes;
}
if (!m_param->scaleFactor)
{
- X265_FREAD(((analysis_intra_data *)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFileIn, intraPic->modes);
+ X265_FREAD((analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFileIn, intraPic->modes);
}
else
{
uint8_t *tempLumaBuf = X265_MALLOC(uint8_t, analysis->numCUsInFrame * scaledNumPartition);
X265_FREAD(tempLumaBuf, sizeof(uint8_t), analysis->numCUsInFrame * scaledNumPartition, m_analysisFileIn, intraPic->modes);
for (uint32_t ctu32Idx = 0, cnt = 0; ctu32Idx < analysis->numCUsInFrame * scaledNumPartition; ctu32Idx++, cnt += factor)
- memset(&((analysis_intra_data *)analysis->intraData)->modes[cnt], tempLumaBuf[ctu32Idx], factor);
+ memset(&(analysis->intraData)->modes[cnt], tempLumaBuf[ctu32Idx], factor);
X265_FREE(tempLumaBuf);
}
X265_FREE(tempBuf);
@@ -3390,36 +3390,36 @@
int bytes = analysis->numPartitions >> (depthBuf[d] * 2);
if (m_param->scaleFactor && modeBuf[d] == MODE_INTRA && depthBuf[d] == 0)
depthBuf[d] = 1;
- memset(&((analysis_inter_data *)analysis->interData)->depth[count], depthBuf[d], bytes);
- memset(&((analysis_inter_data *)analysis->interData)->modes[count], modeBuf[d], bytes);
+ memset(&(analysis->interData)->depth[count], depthBuf[d], bytes);
+ memset(&(analysis->interData)->modes[count], modeBuf[d], bytes);
if (m_param->analysisReuseLevel > 4)
{
if (m_param->scaleFactor && modeBuf[d] == MODE_INTRA && partSize[d] == SIZE_NxN)
partSize[d] = SIZE_2Nx2N;
- memset(&((analysis_inter_data *)analysis->interData)->partSize[count], partSize[d], bytes);
+ memset(&(analysis->interData)->partSize[count], partSize[d], bytes);
int numPU = (modeBuf[d] == MODE_INTRA) ? 1 : nbPartsTable[(int)partSize[d]];
for (int pu = 0; pu < numPU; pu++)
{
if (pu) d++;
- ((analysis_inter_data *)analysis->interData)->mergeFlag[count + pu] = mergeFlag[d];
+ (analysis->interData)->mergeFlag[count + pu] = mergeFlag[d];
if (m_param->analysisReuseLevel == 10)
{
- ((analysis_inter_data *)analysis->interData)->interDir[count + pu] = interDir[d];
+ (analysis->interData)->interDir[count + pu] = interDir[d];
for (uint32_t i = 0; i < numDir; i++)
{
- ((analysis_inter_data *)analysis->interData)->mvpIdx[i][count + pu] = mvpIdx[i][d];
- ((analysis_inter_data *)analysis->interData)->refIdx[i][count + pu] = refIdx[i][d];
+ (analysis->interData)->mvpIdx[i][count + pu] = mvpIdx[i][d];
+ (analysis->interData)->refIdx[i][count + pu] = refIdx[i][d];
if (m_param->scaleFactor)
{
mv[i][d].x *= (int16_t)m_param->scaleFactor;
mv[i][d].y *= (int16_t)m_param->scaleFactor;
}
- memcpy(&((analysis_inter_data *)analysis->interData)->mv[i][count + pu], &mv[i][d], sizeof(MV));
+ memcpy(&(analysis->interData)->mv[i][count + pu], &mv[i][d], sizeof(MV));
}
}
}
if (m_param->analysisReuseLevel == 10 && bIntraInInter)
- memset(&((analysis_intra_data *)analysis->intraData)->chromaModes[count], chromaDir[d], bytes);
+ memset(&(analysis->intraData)->chromaModes[count], chromaDir[d], bytes);
}
count += bytes;
}
@@ -3438,20 +3438,20 @@
{
if (!m_param->scaleFactor)
{
- X265_FREAD(((analysis_intra_data *)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFileIn, intraPic->modes);
+ X265_FREAD((analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFileIn, intraPic->modes);
}
else
{
uint8_t *tempLumaBuf = X265_MALLOC(uint8_t, analysis->numCUsInFrame * scaledNumPartition);
X265_FREAD(tempLumaBuf, sizeof(uint8_t), analysis->numCUsInFrame * scaledNumPartition, m_analysisFileIn, intraPic->modes);
for (uint32_t ctu32Idx = 0, cnt = 0; ctu32Idx < analysis->numCUsInFrame * scaledNumPartition; ctu32Idx++, cnt += factor)
- memset(&((analysis_intra_data *)analysis->intraData)->modes[cnt], tempLumaBuf[ctu32Idx], factor);
+ memset(&(analysis->intraData)->modes[cnt], tempLumaBuf[ctu32Idx], factor);
X265_FREE(tempLumaBuf);
}
}
}
else
- X265_FREAD(((analysis_inter_data *)analysis->interData)->ref, sizeof(int32_t), analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir, m_analysisFileIn, interPic->ref);
+ X265_FREAD((analysis->interData)->ref, sizeof(int32_t), analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir, m_analysisFileIn, interPic->ref);
consumedBytes += frameRecordSize;
if (numDir == 1)
@@ -3482,8 +3482,8 @@
fseeko(m_analysisFileIn, totalConsumedBytes + paramBytes, SEEK_SET);
const x265_analysis_data *picData = &(picIn->analysisData);
- analysis_intra_data *intraPic = (analysis_intra_data *)picData->intraData;
- analysis_inter_data *interPic = (analysis_inter_data *)picData->interData;
+ x265_analysis_intra_data *intraPic = picData->intraData;
+ x265_analysis_inter_data *interPic = picData->interData;
int poc; uint32_t frameRecordSize;
X265_FREAD(&frameRecordSize, sizeof(uint32_t), 1, m_analysisFileIn, &(picData->frameRecordSize));
@@ -3629,9 +3629,9 @@
for (int numCTU = 0; numCTU < numCTUCopied; numCTU++)
{
- memset(&((analysis_intra_data *)analysis->intraData)->depth[count], depthBuf[d], bytes);
- memset(&((analysis_intra_data *)analysis->intraData)->chromaModes[count], modeBuf[d], bytes);
- memset(&((analysis_intra_data *)analysis->intraData)->partSizes[count], partSizes[d], bytes);
+ memset(&(analysis->intraData)->depth[count], depthBuf[d], bytes);
+ memset(&(analysis->intraData)->chromaModes[count], modeBuf[d], bytes);
+ memset(&(analysis->intraData)->partSizes[count], partSizes[d], bytes);
count += bytes;
d += getCUIndex(&cuLoc, &count, bytes, 1);
}
@@ -3645,7 +3645,7 @@
uint32_t cnt = 0;
for (uint32_t ctu32Idx = 0; ctu32Idx < analysis->numCUsInFrame * scaledNumPartition; ctu32Idx++)
{
- memset(&((analysis_intra_data *)analysis->intraData)->modes[cnt], tempLumaBuf[ctu32Idx], factor);
+ memset(&(analysis->intraData)->modes[cnt], tempLumaBuf[ctu32Idx], factor);
cnt += factor;
ctu32Idx += getCUIndex(&cuLoc, &cnt, factor, 0);
}
@@ -3728,10 +3728,10 @@
for (int numCTU = 0; numCTU < numCTUCopied; numCTU++)
{
- memset(&((analysis_inter_data *)analysis->interData)->depth[count], writeDepth, bytes);
- memset(&((analysis_inter_data *)analysis->interData)->modes[count], modeBuf[d], bytes);
+ memset(&(analysis->interData)->depth[count], writeDepth, bytes);
+ memset(&(analysis->interData)->modes[count], modeBuf[d], bytes);
if (m_param->analysisReuseLevel == 10 && bIntraInInter)
- memset(&((analysis_intra_data *)analysis->intraData)->chromaModes[count], chromaDir[d], bytes);
+ memset(&(analysis->intraData)->chromaModes[count], chromaDir[d], bytes);
if (m_param->analysisReuseLevel > 4)
{
@@ -3742,7 +3742,7 @@
int partitionSize = partSize[d];
if (isScaledMaxCUSize && partSize[d] != SIZE_2Nx2N)
partitionSize = getPuShape(&puOrient, partSize[d], numCTU);
- memset(&((analysis_inter_data *)analysis->interData)->partSize[count], partitionSize, bytes);
+ memset(&(analysis->interData)->partSize[count], partitionSize, bytes);
int numPU = (modeBuf[d] == MODE_INTRA) ? 1 : nbPartsTable[(int)partSize[d]];
for (int pu = 0; pu < numPU; pu++)
{
@@ -3758,18 +3758,18 @@
if (puOrient.isAmp && pu)
d++;
- ((analysis_inter_data *)analysis->interData)->mergeFlag[count + pu] = mergeFlag[d];
+ (analysis->interData)->mergeFlag[count + pu] = mergeFlag[d];
if (m_param->analysisReuseLevel == 10)
{
- ((analysis_inter_data *)analysis->interData)->interDir[count + pu] = interDir[d];
+ (analysis->interData)->interDir[count + pu] = interDir[d];
MV mvCopy[2];
for (uint32_t i = 0; i < numDir; i++)
{
- ((analysis_inter_data *)analysis->interData)->mvpIdx[i][count + pu] = mvpIdx[i][d];
- ((analysis_inter_data *)analysis->interData)->refIdx[i][count + pu] = refIdx[i][d];
+ (analysis->interData)->mvpIdx[i][count + pu] = mvpIdx[i][d];
+ (analysis->interData)->refIdx[i][count + pu] = refIdx[i][d];
mvCopy[i].x = mv[i][d].x * (int16_t)m_param->scaleFactor;
mvCopy[i].y = mv[i][d].y * (int16_t)m_param->scaleFactor;
- memcpy(&((analysis_inter_data *)analysis->interData)->mv[i][count + pu], &mvCopy[i], sizeof(MV));
+ memcpy(&(analysis->interData)->mv[i][count + pu], &mvCopy[i], sizeof(MV));
}
}
d = restoreD; // Restore d value after copying each of the 4 64x64 CTUs
@@ -3810,7 +3810,7 @@
uint32_t cnt = 0;
for (uint32_t ctu32Idx = 0; ctu32Idx < analysis->numCUsInFrame * scaledNumPartition; ctu32Idx++)
{
- memset(&((analysis_intra_data *)analysis->intraData)->modes[cnt], tempLumaBuf[ctu32Idx], factor);
+ memset(&(analysis->intraData)->modes[cnt], tempLumaBuf[ctu32Idx], factor);
cnt += factor;
ctu32Idx += getCUIndex(&cuLoc, &cnt, factor, 0);
}
@@ -3818,7 +3818,7 @@
}
}
else
- X265_FREAD(((analysis_inter_data *)analysis->interData)->ref, sizeof(int32_t), analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir, m_analysisFileIn, interPic->ref);
+ X265_FREAD((analysis->interData)->ref, sizeof(int32_t), analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir, m_analysisFileIn, interPic->ref);
consumedBytes += frameRecordSize;
if (numDir == 1)
@@ -4078,9 +4078,9 @@
depthBuf = tempBuf;
distortionBuf = tempdistBuf;
x265_analysis_data *analysisData = (x265_analysis_data*)analysis;
- analysis_intra_data *intraData = (analysis_intra_data *)analysisData->intraData;
- analysis_inter_data *interData = (analysis_inter_data *)analysisData->interData;
- analysisDistortionData *distortionData = (analysisDistortionData *)analysisData->distortionData;
+ x265_analysis_intra_data *intraData = analysisData->intraData;
+ x265_analysis_inter_data *interData = analysisData->interData;
+ x265_analysis_distortion_data *distortionData = analysisData->distortionData;
size_t count = 0;
uint32_t ctuCount = 0;
@@ -4147,15 +4147,15 @@
size_t bytes = analysis->numPartitions >> (depthBuf[d] * 2);
for (int i = 0; i < numDir; i++)
{
- int32_t* ref = &((analysis_inter_data*)analysis->interData)->ref[i * analysis->numPartitions * analysis->numCUsInFrame];
+ int32_t* ref = &(analysis->interData)->ref[i * analysis->numPartitions * analysis->numCUsInFrame];
for (size_t j = count, k = 0; k < bytes; j++, k++)
{
- memcpy(&((analysis_inter_data*)analysis->interData)->mv[i][j], MVBuf[i] + d, sizeof(MV));
- memcpy(&((analysis_inter_data*)analysis->interData)->mvpIdx[i][j], mvpBuf[i] + d, sizeof(uint8_t));
+ memcpy(&(analysis->interData)->mv[i][j], MVBuf[i] + d, sizeof(MV));
+ memcpy(&(analysis->interData)->mvpIdx[i][j], mvpBuf[i] + d, sizeof(uint8_t));
memcpy(&ref[j], refBuf + (i * depthBytes) + d, sizeof(int32_t));
}
}
- memset(&((analysis_inter_data *)analysis->interData)->modes[count], modeBuf[d], bytes);
+ memset(&(analysis->interData)->modes[count], modeBuf[d], bytes);
count += bytes;
}
@@ -4219,7 +4219,7 @@
uint8_t partSize = 0;
CUData* ctu = curEncData.getPicCTU(cuAddr);
- analysis_intra_data* intraDataCTU = (analysis_intra_data*)analysis->intraData;
+ x265_analysis_intra_data* intraDataCTU = analysis->intraData;
for (uint32_t absPartIdx = 0; absPartIdx < ctu->m_numPartitions; depthBytes++)
{
@@ -4247,8 +4247,8 @@
uint8_t partSize = 0;
CUData* ctu = curEncData.getPicCTU(cuAddr);
- analysis_inter_data* interDataCTU = (analysis_inter_data*)analysis->interData;
- analysis_intra_data* intraDataCTU = (analysis_intra_data*)analysis->intraData;
+ x265_analysis_inter_data* interDataCTU = analysis->interData;
+ x265_analysis_intra_data* intraDataCTU = analysis->intraData;
for (uint32_t absPartIdx = 0; absPartIdx < ctu->m_numPartitions; depthBytes++)
{
@@ -4281,7 +4281,9 @@
{
interDataCTU->mvpIdx[dir][depthBytes] = ctu->m_mvpIdx[dir][puabsPartIdx];
interDataCTU->refIdx[dir][depthBytes] = ctu->m_refIdx[dir][puabsPartIdx];
- interDataCTU->mv[dir][depthBytes] = ctu->m_mv[dir][puabsPartIdx];
+ interDataCTU->mv[dir][depthBytes].x = ctu->m_mv[dir][puabsPartIdx].x;
+ interDataCTU->mv[dir][depthBytes].y = ctu->m_mv[dir][puabsPartIdx].y;
+ interDataCTU->mv[dir][depthBytes].word = ctu->m_mv[dir][puabsPartIdx].word;
}
}
}
@@ -4339,35 +4341,35 @@
if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == X265_TYPE_I)
{
- X265_FWRITE(((analysis_intra_data*)analysis->intraData)->depth, sizeof(uint8_t), depthBytes, m_analysisFileOut);
- X265_FWRITE(((analysis_intra_data*)analysis->intraData)->chromaModes, sizeof(uint8_t), depthBytes, m_analysisFileOut);
- X265_FWRITE(((analysis_intra_data*)analysis->intraData)->partSizes, sizeof(char), depthBytes, m_analysisFileOut);
- X265_FWRITE(((analysis_intra_data*)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFileOut);
+ X265_FWRITE((analysis->intraData)->depth, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->intraData)->chromaModes, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->intraData)->partSizes, sizeof(char), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFileOut);
}
else
{
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->depth, sizeof(uint8_t), depthBytes, m_analysisFileOut);
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->modes, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->interData)->depth, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->interData)->modes, sizeof(uint8_t), depthBytes, m_analysisFileOut);
if (m_param->analysisReuseLevel > 4)
{
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->partSize, sizeof(uint8_t), depthBytes, m_analysisFileOut);
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->mergeFlag, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->interData)->partSize, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->interData)->mergeFlag, sizeof(uint8_t), depthBytes, m_analysisFileOut);
if (m_param->analysisReuseLevel == 10)
{
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->interDir, sizeof(uint8_t), depthBytes, m_analysisFileOut);
- if (bIntraInInter) X265_FWRITE(((analysis_intra_data*)analysis->intraData)->chromaModes, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->interData)->interDir, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ if (bIntraInInter) X265_FWRITE((analysis->intraData)->chromaModes, sizeof(uint8_t), depthBytes, m_analysisFileOut);
for (uint32_t dir = 0; dir < numDir; dir++)
{
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->mvpIdx[dir], sizeof(uint8_t), depthBytes, m_analysisFileOut);
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->refIdx[dir], sizeof(int8_t), depthBytes, m_analysisFileOut);
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->mv[dir], sizeof(MV), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->interData)->mvpIdx[dir], sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->interData)->refIdx[dir], sizeof(int8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->interData)->mv[dir], sizeof(MV), depthBytes, m_analysisFileOut);
}
if (bIntraInInter)
- X265_FWRITE(((analysis_intra_data*)analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFileOut);
+ X265_FWRITE((analysis->intraData)->modes, sizeof(uint8_t), analysis->numCUsInFrame * analysis->numPartitions, m_analysisFileOut);
}
}
if (m_param->analysisReuseLevel != 10)
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->ref, sizeof(int32_t), analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir, m_analysisFileOut);
+ X265_FWRITE((analysis->interData)->ref, sizeof(int32_t), analysis->numCUsInFrame * X265_MAX_PRED_MODE_PER_CTU * numDir, m_analysisFileOut);
}
#undef X265_FWRITE
@@ -4386,10 +4388,9 @@
uint32_t depthBytes = 0;
x265_analysis_data *analysisData = (x265_analysis_data*)analysis;
- analysis_intra_data *intraData = (analysis_intra_data *)analysisData->intraData;
- analysis_inter_data *interData = (analysis_inter_data *)analysisData->interData;
- analysisDistortionData *distortionData = (analysisDistortionData *)analysisData->distortionData;
-
+ x265_analysis_intra_data *intraData = analysisData->intraData;
+ x265_analysis_inter_data *interData = analysisData->interData;
+ x265_analysis_distortion_data *distortionData = analysisData->distortionData;
for (uint32_t cuAddr = 0; cuAddr < analysis->numCUsInFrame; cuAddr++)
{
@@ -4412,8 +4413,8 @@
if (curEncData.m_slice->m_sliceType != I_SLICE)
{
int32_t* ref[2];
- ref[0] = ((analysis_inter_data*)analysis->interData)->ref;
- ref[1] = &((analysis_inter_data*)analysis->interData)->ref[analysis->numPartitions * analysis->numCUsInFrame];
+ ref[0] = (analysis->interData)->ref;
+ ref[1] = &(analysis->interData)->ref[analysis->numPartitions * analysis->numCUsInFrame];
depthBytes = 0;
for (uint32_t cuAddr = 0; cuAddr < analysis->numCUsInFrame; cuAddr++)
{
@@ -4424,13 +4425,17 @@
for (uint32_t absPartIdx = 0; absPartIdx < ctu->m_numPartitions; depthBytes++)
{
depth = ctu->m_cuDepth[absPartIdx];
- interData->mv[0][depthBytes] = ctu->m_mv[0][absPartIdx];
+ interData->mv[0][depthBytes].x = ctu->m_mv[0][absPartIdx].x;
+ interData->mv[0][depthBytes].y = ctu->m_mv[0][absPartIdx].y;
+ interData->mv[0][depthBytes].word = ctu->m_mv[0][absPartIdx].word;
interData->mvpIdx[0][depthBytes] = ctu->m_mvpIdx[0][absPartIdx];
ref[0][depthBytes] = ctu->m_refIdx[0][absPartIdx];
predMode = ctu->m_predMode[absPartIdx];
if (ctu->m_refIdx[1][absPartIdx] != -1)
{
- interData->mv[1][depthBytes] = ctu->m_mv[1][absPartIdx];
+ interData->mv[1][depthBytes].x = ctu->m_mv[1][absPartIdx].x;
+ interData->mv[1][depthBytes].y = ctu->m_mv[1][absPartIdx].y;
+ interData->mv[1][depthBytes].word = ctu->m_mv[1][absPartIdx].word;
interData->mvpIdx[1][depthBytes] = ctu->m_mvpIdx[1][absPartIdx];
ref[1][depthBytes] = ctu->m_refIdx[1][absPartIdx];
predMode = 4; // used as indiacator if the block is coded as bidir
@@ -4459,11 +4464,11 @@
X265_FWRITE(&analysis->poc, sizeof(uint32_t), 1, m_analysisFileOut);
if (curEncData.m_slice->m_sliceType == I_SLICE)
{
- X265_FWRITE(((analysis_intra_data*)analysis->intraData)->depth, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->intraData)->depth, sizeof(uint8_t), depthBytes, m_analysisFileOut);
}
else
{
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->depth, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->interData)->depth, sizeof(uint8_t), depthBytes, m_analysisFileOut);
}
X265_FWRITE(distortionData->distortion, sizeof(sse_t), depthBytes, m_analysisFileOut);
if (curEncData.m_slice->m_sliceType != I_SLICE)
@@ -4471,12 +4476,12 @@
int numDir = curEncData.m_slice->m_sliceType == P_SLICE ? 1 : 2;
for (int i = 0; i < numDir; i++)
{
- int32_t* ref = &((analysis_inter_data*)analysis->interData)->ref[i * analysis->numPartitions * analysis->numCUsInFrame];
+ int32_t* ref = &(analysis->interData)->ref[i * analysis->numPartitions * analysis->numCUsInFrame];
X265_FWRITE(interData->mv[i], sizeof(MV), depthBytes, m_analysisFileOut);
X265_FWRITE(interData->mvpIdx[i], sizeof(uint8_t), depthBytes, m_analysisFileOut);
X265_FWRITE(ref, sizeof(int32_t), depthBytes, m_analysisFileOut);
}
- X265_FWRITE(((analysis_inter_data*)analysis->interData)->modes, sizeof(uint8_t), depthBytes, m_analysisFileOut);
+ X265_FWRITE((analysis->interData)->modes, sizeof(uint8_t), depthBytes, m_analysisFileOut);
}
#undef X265_FWRITE
}
diff -r fb1530b0e1b4 -r 9694dfbe83ac source/encoder/search.cpp
--- a/source/encoder/search.cpp Fri Jul 20 14:20:22 2018 +0530
+++ b/source/encoder/search.cpp Fri Jul 20 14:03:53 2018 +0530
@@ -2178,12 +2178,12 @@
PredictionUnit pu(cu, cuGeom, puIdx);
m_me.setSourcePU(*interMode.fencYuv, pu.ctuAddr, pu.cuAbsPartIdx, pu.puAbsPartIdx, pu.width, pu.height, m_param->searchMethod, m_param->subpelRefine, bChromaMC);
useAsMVP = false;
- analysis_inter_data* interDataCTU = NULL;
+ x265_analysis_inter_data* interDataCTU = NULL;
int cuIdx;
cuIdx = (interMode.cu.m_cuAddr * m_param->num4x4Partitions) + cuGeom.absPartIdx;
if (m_param->analysisReuseLevel == 10 && m_param->interRefine > 1)
{
- interDataCTU = (analysis_inter_data*)m_frame->m_analysisData.interData;
+ interDataCTU = m_frame->m_analysisData.interData;
if ((cu.m_predMode[pu.puAbsPartIdx] == interDataCTU->modes[cuIdx + pu.puAbsPartIdx])
&& (cu.m_partSize[pu.puAbsPartIdx] == interDataCTU->partSize[cuIdx + pu.puAbsPartIdx])
&& !(interDataCTU->mergeFlag[cuIdx + puIdx])
@@ -2225,7 +2225,9 @@
MV mvmin, mvmax, outmv, mvp;
if (useAsMVP)
{
- mvp = interDataCTU->mv[list][cuIdx + puIdx];
+ mvp.x = interDataCTU->mv[list][cuIdx + puIdx].x;
+ mvp.y = interDataCTU->mv[list][cuIdx + puIdx].y;
+ mvp.word = interDataCTU->mv[list][cuIdx + puIdx].word;
mvpIdx = interDataCTU->mvpIdx[list][cuIdx + puIdx];
}
else
diff -r fb1530b0e1b4 -r 9694dfbe83ac source/x265.h
--- a/source/x265.h Fri Jul 20 14:20:22 2018 +0530
+++ b/source/x265.h Fri Jul 20 14:03:53 2018 +0530
@@ -26,11 +26,16 @@
#define X265_H
#include <stdint.h>
#include <stdio.h>
+#include <stdbool.h>
#include "x265_config.h"
#ifdef __cplusplus
extern "C" {
#endif
+#if _MSC_VER
+#pragma warning(disable: 4201) // non-standard extension used (nameless struct/union)
+#endif
+
/* x265_encoder:
* opaque handler for encoder */
typedef struct x265_encoder x265_encoder;
@@ -127,25 +132,85 @@
int chunkEnd;
}x265_analysis_validate;
+/* Stores intra analysis data for a single frame. This struct needs better packing */
+typedef struct x265_analysis_intra_data
+{
+ uint8_t* depth;
+ uint8_t* modes;
+ char* partSizes;
+ uint8_t* chromaModes;
+}x265_analysis_intra_data;
+
+typedef struct x265_analysis_MV
+{
+ union{
+ struct { int16_t x, y; };
+
+ int32_t word;
+ };
+}x265_analysis_MV;
+
+/* Stores inter analysis data for a single frame */
+typedef struct x265_analysis_inter_data
+{
+ int32_t* ref;
+ uint8_t* depth;
+ uint8_t* modes;
+ uint8_t* partSize;
+ uint8_t* mergeFlag;
+ uint8_t* interDir;
+ uint8_t* mvpIdx[2];
+ int8_t* refIdx[2];
+ x265_analysis_MV* mv[2];
+ int64_t* sadCost;
+}x265_analysis_inter_data;
+
+typedef struct x265_weight_param
+{
+ uint32_t log2WeightDenom;
+ int inputWeight;
+ int inputOffset;
+ bool bPresentFlag;
+}x265_weight_param;
+
+#if X265_DEPTH < 10
+typedef uint32_t sse_t;
+#else
+typedef uint64_t sse_t;
+#endif
+
+typedef struct x265_analysis_distortion_data
+{
+ sse_t* distortion;
+ sse_t* ctuDistortion;
+ double* scaledDistortion;
+ double averageDistortion;
+ double sdDistortion;
+ uint32_t highDistortionCtuCount;
+ uint32_t lowDistortionCtuCount;
+ double* offset;
+ double* threshold;
+}x265_analysis_distortion_data;
+
/* Stores all analysis data for a single frame */
typedef struct x265_analysis_data
{
- int64_t satdCost;
- uint32_t frameRecordSize;
- uint32_t poc;
- uint32_t sliceType;
- uint32_t numCUsInFrame;
- uint32_t numPartitions;
- uint32_t depthBytes;
- int bScenecut;
- void* wt;
- void* interData;
- void* intraData;
- uint32_t numCuInHeight;
- x265_lookahead_data lookahead;
- uint8_t* modeFlag[2];
- x265_analysis_validate saveParam;
- void* distortionData;
+ int64_t satdCost;
+ uint32_t frameRecordSize;
+ uint32_t poc;
+ uint32_t sliceType;
+ uint32_t numCUsInFrame;
+ uint32_t numPartitions;
+ uint32_t depthBytes;
+ int bScenecut;
+ x265_weight_param* wt;
+ x265_analysis_inter_data* interData;
+ x265_analysis_intra_data* intraData;
+ uint32_t numCuInHeight;
+ x265_lookahead_data lookahead;
+ uint8_t* modeFlag[2];
+ x265_analysis_validate saveParam;
+ x265_analysis_distortion_data* distortionData;
} x265_analysis_data;
/* cu statistics */
@@ -1756,7 +1821,7 @@
/* x265_build_info:
* 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);
-------------- next part --------------
A non-text attachment was scrubbed...
Name: x265_4.patch
Type: text/x-patch
Size: 53527 bytes
Desc: not available
URL: <http://mailman.videolan.org/pipermail/x265-devel/attachments/20180720/4f85ff1e/attachment-0001.bin>
More information about the x265-devel
mailing list