# HG changeset patch
# User Mahesh Pittala
# Date 1526553420 -19800
#      Thu May 17 16:07:00 2018 +0530
# Branch stable
# Node ID d3d9943b60cf058c1b22ab7afb5c0f79b98b9769
# Parent  3cef29225ef431c820c8e5593b00c3c225bfffdc
Fix VBV Lookahead in analysis load to achieve target bitrate

Details:
If save and the load encodes have the same max CU size then number of CTU rows
will be doubled and total number of CTU's are 4 times compared to
analysis save encode so copying one CTU's vbv cost to 4 CTU's in load and one
vbv row's satdcost to 2 consecutive rows(cost is multiplied by 2 here)

diff -r 3cef29225ef4 -r d3d9943b60cf source/encoder/encoder.cpp
--- a/source/encoder/encoder.cpp        Thu May 17 12:18:34 2018 +0530
+++ b/source/encoder/encoder.cpp        Thu May 17 16:07:00 2018 +0530
@@ -1233,26 +1233,27 @@
                             int vbvCount = m_param->lookaheadDepth + 
m_param->bframes + 2;
                             for (int index = 0; index < vbvCount; index++)
                             {
-                                
pic_out->analysisData.lookahead.plannedSatd[index] = 
outFrame->m_lowres.plannedSatd[index] * factor;
+                                
pic_out->analysisData.lookahead.plannedSatd[index] = 
outFrame->m_lowres.plannedSatd[index];
                                 
pic_out->analysisData.lookahead.plannedType[index] = 
outFrame->m_lowres.plannedType[index];
                             }
                             for (uint32_t index = 0; index < 
pic_out->analysisData.numCuInHeight; index++)
                             {
-                                
outFrame->m_analysisData.lookahead.intraSatdForVbv[index] = 
outFrame->m_encData->m_rowStat[index].intraSatdForVbv * factor;
-                                
outFrame->m_analysisData.lookahead.satdForVbv[index] = 
outFrame->m_encData->m_rowStat[index].satdForVbv * factor;
+                                
outFrame->m_analysisData.lookahead.intraSatdForVbv[index] = 
outFrame->m_encData->m_rowStat[index].intraSatdForVbv;
+                                
outFrame->m_analysisData.lookahead.satdForVbv[index] = 
outFrame->m_encData->m_rowStat[index].satdForVbv;
                             }
                             pic_out->analysisData.lookahead.intraSatdForVbv = 
outFrame->m_analysisData.lookahead.intraSatdForVbv;
                             pic_out->analysisData.lookahead.satdForVbv = 
outFrame->m_analysisData.lookahead.satdForVbv;
                             for (uint32_t index = 0; index < 
pic_out->analysisData.numCUsInFrame; index++)
                             {
-                                
outFrame->m_analysisData.lookahead.intraVbvCost[index] = 
outFrame->m_encData->m_cuStat[index].intraVbvCost * factor;
-                                
outFrame->m_analysisData.lookahead.vbvCost[index] = 
outFrame->m_encData->m_cuStat[index].vbvCost * factor;
+                                
outFrame->m_analysisData.lookahead.intraVbvCost[index] = 
outFrame->m_encData->m_cuStat[index].intraVbvCost;
+                                
outFrame->m_analysisData.lookahead.vbvCost[index] = 
outFrame->m_encData->m_cuStat[index].vbvCost;
                             }
                             pic_out->analysisData.lookahead.intraVbvCost = 
outFrame->m_analysisData.lookahead.intraVbvCost;
                             pic_out->analysisData.lookahead.vbvCost = 
outFrame->m_analysisData.lookahead.vbvCost;
                         }
                     }
                     writeAnalysisFile(&pic_out->analysisData, 
*outFrame->m_encData);
+                    pic_out->analysisData.saveParam = 
pic_out->analysisData.saveParam;
                     if (m_param->bUseAnalysisFile)
                         freeAnalysis(&pic_out->analysisData);
                 }
@@ -3411,6 +3412,21 @@
         X265_FREAD(analysis->lookahead.vbvCost, sizeof(uint32_t), 
analysis->numCUsInFrame, m_analysisFileIn, picData->lookahead.vbvCost);
         X265_FREAD(analysis->lookahead.satdForVbv, sizeof(uint32_t), 
analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.satdForVbv);
         X265_FREAD(analysis->lookahead.intraSatdForVbv, sizeof(uint32_t), 
analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.intraSatdForVbv);
+
+        int vbvCount = m_param->lookaheadDepth + m_param->bframes + 2;
+        for (int index = 0; index < vbvCount; index++)
+            analysis->lookahead.plannedSatd[index] = 
picData->lookahead.plannedSatd[index] * (2 * m_param->scaleFactor);
+
+        for (uint32_t i = 0; i < analysis->numCuInHeight; i++)
+        {
+            analysis->lookahead.satdForVbv[i] = 
analysis->lookahead.satdForVbv[i] * (2* m_param->scaleFactor);
+            analysis->lookahead.intraSatdForVbv[i] = 
analysis->lookahead.intraSatdForVbv[i] * (2 * m_param->scaleFactor);
+        }
+        for (uint32_t i = 0; i < analysis->numCUsInFrame; i++)
+        {
+            analysis->lookahead.vbvCost[i] = analysis->lookahead.vbvCost[i] * 
(2 * m_param->scaleFactor);
+            analysis->lookahead.intraVbvCost[i] = 
analysis->lookahead.intraVbvCost[i] * (2 * m_param->scaleFactor);
+        }
     }
     if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == 
X265_TYPE_I)
     {
@@ -3663,21 +3679,71 @@
 
     int numPartitions = analysis->numPartitions;
     int numCUsInFrame = analysis->numCUsInFrame;
+    int numCuInHeight = analysis->numCuInHeight;
     /* Allocate memory for scaled resoultion's numPartitions and 
numCUsInFrame*/
     analysis->numPartitions = m_param->num4x4Partitions;
     analysis->numCUsInFrame = cuLoc.heightInCU * cuLoc.widthInCU;
+    analysis->numCuInHeight = cuLoc.heightInCU;
 
     /* Memory is allocated for inter and intra analysis data based on the 
slicetype */
     allocAnalysis(analysis);
 
     analysis->numPartitions = numPartitions * factor;
     analysis->numCUsInFrame = numCUsInFrame;
+    analysis->numCuInHeight = numCuInHeight;
     if (m_param->bDisableLookahead && m_rateControl->m_isVbv)
     {
-        X265_FREAD(analysis->lookahead.intraVbvCost, sizeof(uint32_t), 
analysis->numCUsInFrame, m_analysisFileIn, picData->lookahead.intraVbvCost);
-        X265_FREAD(analysis->lookahead.vbvCost, sizeof(uint32_t), 
analysis->numCUsInFrame, m_analysisFileIn, picData->lookahead.vbvCost);
-        X265_FREAD(analysis->lookahead.satdForVbv, sizeof(uint32_t), 
analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.satdForVbv);
-        X265_FREAD(analysis->lookahead.intraSatdForVbv, sizeof(uint32_t), 
analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.intraSatdForVbv);
+        uint32_t width = analysis->numCUsInFrame / analysis->numCuInHeight;
+        bool skipLastRow = (analysis->numCuInHeight * 2) > cuLoc.heightInCU;
+        bool skipLastCol = (width * 2) > cuLoc.widthInCU;
+        uint32_t *intraVbvCostBuf = NULL, *vbvCostBuf = NULL, *satdForVbvBuf = 
NULL, *intraSatdForVbvBuf = NULL;
+        intraVbvCostBuf = X265_MALLOC(uint32_t, analysis->numCUsInFrame);
+        vbvCostBuf = X265_MALLOC(uint32_t, analysis->numCUsInFrame);
+        satdForVbvBuf = X265_MALLOC(uint32_t, analysis->numCuInHeight);
+        intraSatdForVbvBuf = X265_MALLOC(uint32_t, analysis->numCuInHeight);
+
+        X265_FREAD(intraVbvCostBuf, sizeof(uint32_t), analysis->numCUsInFrame, 
m_analysisFileIn, picData->lookahead.intraVbvCost);
+        X265_FREAD(vbvCostBuf, sizeof(uint32_t), analysis->numCUsInFrame, 
m_analysisFileIn, picData->lookahead.vbvCost);
+        X265_FREAD(satdForVbvBuf, sizeof(uint32_t), analysis->numCuInHeight, 
m_analysisFileIn, picData->lookahead.satdForVbv);
+        X265_FREAD(intraSatdForVbvBuf, sizeof(uint32_t), 
analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.intraSatdForVbv);
+
+        int k = 0;
+        for (uint32_t i = 0; i < analysis->numCuInHeight; i++)
+        {
+            analysis->lookahead.satdForVbv[m_param->scaleFactor * i] = 
satdForVbvBuf[i] * m_param->scaleFactor;
+            analysis->lookahead.intraSatdForVbv[m_param->scaleFactor * i] = 
intraSatdForVbvBuf[i] * m_param->scaleFactor;
+            if (!(i == (analysis->numCuInHeight - 1) && skipLastRow))
+            {
+                analysis->lookahead.satdForVbv[(m_param->scaleFactor * i) + 1] 
= satdForVbvBuf[i] * m_param->scaleFactor;
+                analysis->lookahead.intraSatdForVbv[(m_param->scaleFactor * i) 
+ 1] = intraSatdForVbvBuf[i] * m_param->scaleFactor;
+            }
+
+            for (uint32_t j = 0; j < width; j++, k++)
+            {
+                analysis->lookahead.vbvCost[(i * m_param->scaleFactor * 
cuLoc.widthInCU) + (j * m_param->scaleFactor)] = vbvCostBuf[k];
+                analysis->lookahead.intraVbvCost[(i * m_param->scaleFactor * 
cuLoc.widthInCU) + (j * m_param->scaleFactor)] = intraVbvCostBuf[k];
+
+                if (!(j == (width - 1) && skipLastCol))
+                {
+                    analysis->lookahead.vbvCost[(i * m_param->scaleFactor * 
cuLoc.widthInCU) + (j * m_param->scaleFactor) + 1] = vbvCostBuf[k];
+                    analysis->lookahead.intraVbvCost[(i * m_param->scaleFactor 
* cuLoc.widthInCU) + (j * m_param->scaleFactor) + 1] = intraVbvCostBuf[k];
+                }
+                if (!(i == (analysis->numCuInHeight - 1) && skipLastRow))
+                {
+                    analysis->lookahead.vbvCost[(i * m_param->scaleFactor * 
cuLoc.widthInCU) + cuLoc.widthInCU + (j * m_param->scaleFactor)] = 
vbvCostBuf[k];
+                    analysis->lookahead.intraVbvCost[(i * m_param->scaleFactor 
* cuLoc.widthInCU) + cuLoc.widthInCU + (j * m_param->scaleFactor)] = 
intraVbvCostBuf[k];
+                    if (!(j == (width - 1) && skipLastCol))
+                    {
+                        analysis->lookahead.vbvCost[(i * m_param->scaleFactor 
* cuLoc.widthInCU) + cuLoc.widthInCU + (j * m_param->scaleFactor) + 1] = 
vbvCostBuf[k];
+                        analysis->lookahead.intraVbvCost[(i * 
m_param->scaleFactor * cuLoc.widthInCU) + cuLoc.widthInCU + (j * 
m_param->scaleFactor) + 1] = intraVbvCostBuf[k];
+                    }
+                }
+            }
+        }
+        X265_FREE(satdForVbvBuf);
+        X265_FREE(intraSatdForVbvBuf);
+        X265_FREE(intraVbvCostBuf);
+        X265_FREE(vbvCostBuf);
     }
 
     if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == 
X265_TYPE_I)
@@ -3912,6 +3978,7 @@
     /* Restore to the current encode's numPartitions and numCUsInFrame */
     analysis->numPartitions = m_param->num4x4Partitions;
     analysis->numCUsInFrame = cuLoc.heightInCU * cuLoc.widthInCU;
+    analysis->numCuInHeight = cuLoc.heightInCU;
 #undef X265_FREAD
 }
 
@@ -3944,23 +4011,23 @@
     }\
     count++;\
 
-    x265_analysis_validate saveParam = analysis->saveParam;
+    x265_analysis_validate *saveParam = &analysis->saveParam;
     FILE*     fileOffset = NULL;
     int       readValue = 0;
     int       count = 0;
 
-    X265_PARAM_VALIDATE(saveParam.maxNumReferences, sizeof(int), 1, 
&m_param->maxNumReferences);
-    X265_PARAM_VALIDATE(saveParam.analysisReuseLevel, sizeof(int), 1, 
&m_param->analysisReuseLevel);
-    X265_PARAM_VALIDATE(saveParam.scaleFactor, sizeof(int), 1, 
&m_param->scaleFactor);
-    X265_PARAM_VALIDATE(saveParam.keyframeMax, sizeof(int), 1, 
&m_param->keyframeMax);
-    X265_PARAM_VALIDATE(saveParam.keyframeMin, sizeof(int), 1, 
&m_param->keyframeMin);
-    X265_PARAM_VALIDATE(saveParam.openGOP, sizeof(int), 1, &m_param->bOpenGOP);
-    X265_PARAM_VALIDATE(saveParam.bframes, sizeof(int), 1, &m_param->bframes);
-    X265_PARAM_VALIDATE(saveParam.bPyramid, sizeof(int), 1, 
&m_param->bBPyramid);
+    X265_PARAM_VALIDATE(saveParam->maxNumReferences, sizeof(int), 1, 
&m_param->maxNumReferences);
+    X265_PARAM_VALIDATE(saveParam->analysisReuseLevel, sizeof(int), 1, 
&m_param->analysisReuseLevel);
+    X265_PARAM_VALIDATE(saveParam->scaleFactor, sizeof(int), 1, 
&m_param->scaleFactor);
+    X265_PARAM_VALIDATE(saveParam->keyframeMax, sizeof(int), 1, 
&m_param->keyframeMax);
+    X265_PARAM_VALIDATE(saveParam->keyframeMin, sizeof(int), 1, 
&m_param->keyframeMin);
+    X265_PARAM_VALIDATE(saveParam->openGOP, sizeof(int), 1, 
&m_param->bOpenGOP);
+    X265_PARAM_VALIDATE(saveParam->bframes, sizeof(int), 1, &m_param->bframes);
+    X265_PARAM_VALIDATE(saveParam->bPyramid, sizeof(int), 1, 
&m_param->bBPyramid);
     /* Enable m_saveCTUSize if the save and load encodes have the same maxCU 
size */
     if (writeFlag)
     {
-        X265_PARAM_VALIDATE(saveParam.maxCUSize, sizeof(int), 1, 
&m_param->maxCUSize);
+        X265_PARAM_VALIDATE(saveParam->maxCUSize, sizeof(int), 1, 
&m_param->maxCUSize);
     }
     else
     {
@@ -3971,7 +4038,7 @@
             m_aborted = true;
         }
         else if (!m_param->bUseAnalysisFile)
-            readValue = saveParam.maxCUSize;
+            readValue = saveParam->maxCUSize;
 
         m_saveCTUSize = 0;
         if (m_param->scaleFactor && g_log2Size[m_param->maxCUSize] == 
g_log2Size[readValue])
@@ -3983,10 +4050,10 @@
         }
         count++;
     }
-    X265_PARAM_VALIDATE(saveParam.minCUSize, sizeof(int), 1, 
&m_param->minCUSize);
-    X265_PARAM_VALIDATE(saveParam.radl, sizeof(int), 1, &m_param->radl);
-    X265_PARAM_VALIDATE(saveParam.lookaheadDepth, sizeof(int), 1, 
&m_param->lookaheadDepth);
-    X265_PARAM_VALIDATE(saveParam.gopLookahead, sizeof(int), 1, 
&m_param->gopLookahead);
+    X265_PARAM_VALIDATE(saveParam->minCUSize, sizeof(int), 1, 
&m_param->minCUSize);
+    X265_PARAM_VALIDATE(saveParam->radl, sizeof(int), 1, &m_param->radl);
+    X265_PARAM_VALIDATE(saveParam->lookaheadDepth, sizeof(int), 1, 
&m_param->lookaheadDepth);
+    X265_PARAM_VALIDATE(saveParam->gopLookahead, sizeof(int), 1, 
&m_param->gopLookahead);
     return (count * sizeof(int));
 #undef X265_PARAM_VALIDATE
 }
# HG changeset patch
# User Mahesh Pittala
# Date 1526553420 -19800
#      Thu May 17 16:07:00 2018 +0530
# Branch stable
# Node ID d3d9943b60cf058c1b22ab7afb5c0f79b98b9769
# Parent  3cef29225ef431c820c8e5593b00c3c225bfffdc
Fix VBV Lookahead in analysis load to achieve target bitrate

Details:
If save and the load encodes have the same max CU size then number of CTU rows
will be doubled and total number of CTU's are 4 times compared to
analysis save encode so copying one CTU's vbv cost to 4 CTU's in load and one
vbv row's satdcost to 2 consecutive rows(cost is multiplied by 2 here)

diff -r 3cef29225ef4 -r d3d9943b60cf source/encoder/encoder.cpp
--- a/source/encoder/encoder.cpp	Thu May 17 12:18:34 2018 +0530
+++ b/source/encoder/encoder.cpp	Thu May 17 16:07:00 2018 +0530
@@ -1233,26 +1233,27 @@
                             int vbvCount = m_param->lookaheadDepth + m_param->bframes + 2;
                             for (int index = 0; index < vbvCount; index++)
                             {
-                                pic_out->analysisData.lookahead.plannedSatd[index] = outFrame->m_lowres.plannedSatd[index] * factor;
+                                pic_out->analysisData.lookahead.plannedSatd[index] = outFrame->m_lowres.plannedSatd[index];
                                 pic_out->analysisData.lookahead.plannedType[index] = outFrame->m_lowres.plannedType[index];
                             }
                             for (uint32_t index = 0; index < pic_out->analysisData.numCuInHeight; index++)
                             {
-                                outFrame->m_analysisData.lookahead.intraSatdForVbv[index] = outFrame->m_encData->m_rowStat[index].intraSatdForVbv * factor;
-                                outFrame->m_analysisData.lookahead.satdForVbv[index] = outFrame->m_encData->m_rowStat[index].satdForVbv * factor;
+                                outFrame->m_analysisData.lookahead.intraSatdForVbv[index] = outFrame->m_encData->m_rowStat[index].intraSatdForVbv;
+                                outFrame->m_analysisData.lookahead.satdForVbv[index] = outFrame->m_encData->m_rowStat[index].satdForVbv;
                             }
                             pic_out->analysisData.lookahead.intraSatdForVbv = outFrame->m_analysisData.lookahead.intraSatdForVbv;
                             pic_out->analysisData.lookahead.satdForVbv = outFrame->m_analysisData.lookahead.satdForVbv;
                             for (uint32_t index = 0; index < pic_out->analysisData.numCUsInFrame; index++)
                             {
-                                outFrame->m_analysisData.lookahead.intraVbvCost[index] = outFrame->m_encData->m_cuStat[index].intraVbvCost * factor;
-                                outFrame->m_analysisData.lookahead.vbvCost[index] = outFrame->m_encData->m_cuStat[index].vbvCost * factor;
+                                outFrame->m_analysisData.lookahead.intraVbvCost[index] = outFrame->m_encData->m_cuStat[index].intraVbvCost;
+                                outFrame->m_analysisData.lookahead.vbvCost[index] = outFrame->m_encData->m_cuStat[index].vbvCost;
                             }
                             pic_out->analysisData.lookahead.intraVbvCost = outFrame->m_analysisData.lookahead.intraVbvCost;
                             pic_out->analysisData.lookahead.vbvCost = outFrame->m_analysisData.lookahead.vbvCost;
                         }
                     }
                     writeAnalysisFile(&pic_out->analysisData, *outFrame->m_encData);
+                    pic_out->analysisData.saveParam = pic_out->analysisData.saveParam;
                     if (m_param->bUseAnalysisFile)
                         freeAnalysis(&pic_out->analysisData);
                 }
@@ -3411,6 +3412,21 @@
         X265_FREAD(analysis->lookahead.vbvCost, sizeof(uint32_t), analysis->numCUsInFrame, m_analysisFileIn, picData->lookahead.vbvCost);
         X265_FREAD(analysis->lookahead.satdForVbv, sizeof(uint32_t), analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.satdForVbv);
         X265_FREAD(analysis->lookahead.intraSatdForVbv, sizeof(uint32_t), analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.intraSatdForVbv);
+
+        int vbvCount = m_param->lookaheadDepth + m_param->bframes + 2;
+        for (int index = 0; index < vbvCount; index++)
+            analysis->lookahead.plannedSatd[index] = picData->lookahead.plannedSatd[index] * (2 * m_param->scaleFactor);
+
+        for (uint32_t i = 0; i < analysis->numCuInHeight; i++)
+        {
+            analysis->lookahead.satdForVbv[i] = analysis->lookahead.satdForVbv[i] * (2* m_param->scaleFactor);
+            analysis->lookahead.intraSatdForVbv[i] = analysis->lookahead.intraSatdForVbv[i] * (2 * m_param->scaleFactor);
+        }
+        for (uint32_t i = 0; i < analysis->numCUsInFrame; i++)
+        {
+            analysis->lookahead.vbvCost[i] = analysis->lookahead.vbvCost[i] * (2 * m_param->scaleFactor);
+            analysis->lookahead.intraVbvCost[i] = analysis->lookahead.intraVbvCost[i] * (2 * m_param->scaleFactor);
+        }
     }
     if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == X265_TYPE_I)
     {
@@ -3663,21 +3679,71 @@
 
     int numPartitions = analysis->numPartitions;
     int numCUsInFrame = analysis->numCUsInFrame;
+    int numCuInHeight = analysis->numCuInHeight;
     /* Allocate memory for scaled resoultion's numPartitions and numCUsInFrame*/
     analysis->numPartitions = m_param->num4x4Partitions;
     analysis->numCUsInFrame = cuLoc.heightInCU * cuLoc.widthInCU;
+    analysis->numCuInHeight = cuLoc.heightInCU;
 
     /* Memory is allocated for inter and intra analysis data based on the slicetype */
     allocAnalysis(analysis);
 
     analysis->numPartitions = numPartitions * factor;
     analysis->numCUsInFrame = numCUsInFrame;
+    analysis->numCuInHeight = numCuInHeight;
     if (m_param->bDisableLookahead && m_rateControl->m_isVbv)
     {
-        X265_FREAD(analysis->lookahead.intraVbvCost, sizeof(uint32_t), analysis->numCUsInFrame, m_analysisFileIn, picData->lookahead.intraVbvCost);
-        X265_FREAD(analysis->lookahead.vbvCost, sizeof(uint32_t), analysis->numCUsInFrame, m_analysisFileIn, picData->lookahead.vbvCost);
-        X265_FREAD(analysis->lookahead.satdForVbv, sizeof(uint32_t), analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.satdForVbv);
-        X265_FREAD(analysis->lookahead.intraSatdForVbv, sizeof(uint32_t), analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.intraSatdForVbv);
+        uint32_t width = analysis->numCUsInFrame / analysis->numCuInHeight;
+        bool skipLastRow = (analysis->numCuInHeight * 2) > cuLoc.heightInCU;
+        bool skipLastCol = (width * 2) > cuLoc.widthInCU;
+        uint32_t *intraVbvCostBuf = NULL, *vbvCostBuf = NULL, *satdForVbvBuf = NULL, *intraSatdForVbvBuf = NULL;
+        intraVbvCostBuf = X265_MALLOC(uint32_t, analysis->numCUsInFrame);
+        vbvCostBuf = X265_MALLOC(uint32_t, analysis->numCUsInFrame);
+        satdForVbvBuf = X265_MALLOC(uint32_t, analysis->numCuInHeight);
+        intraSatdForVbvBuf = X265_MALLOC(uint32_t, analysis->numCuInHeight);
+
+        X265_FREAD(intraVbvCostBuf, sizeof(uint32_t), analysis->numCUsInFrame, m_analysisFileIn, picData->lookahead.intraVbvCost);
+        X265_FREAD(vbvCostBuf, sizeof(uint32_t), analysis->numCUsInFrame, m_analysisFileIn, picData->lookahead.vbvCost);
+        X265_FREAD(satdForVbvBuf, sizeof(uint32_t), analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.satdForVbv);
+        X265_FREAD(intraSatdForVbvBuf, sizeof(uint32_t), analysis->numCuInHeight, m_analysisFileIn, picData->lookahead.intraSatdForVbv);
+
+        int k = 0;
+        for (uint32_t i = 0; i < analysis->numCuInHeight; i++)
+        {
+            analysis->lookahead.satdForVbv[m_param->scaleFactor * i] = satdForVbvBuf[i] * m_param->scaleFactor;
+            analysis->lookahead.intraSatdForVbv[m_param->scaleFactor * i] = intraSatdForVbvBuf[i] * m_param->scaleFactor;
+            if (!(i == (analysis->numCuInHeight - 1) && skipLastRow))
+            {
+                analysis->lookahead.satdForVbv[(m_param->scaleFactor * i) + 1] = satdForVbvBuf[i] * m_param->scaleFactor;
+                analysis->lookahead.intraSatdForVbv[(m_param->scaleFactor * i) + 1] = intraSatdForVbvBuf[i] * m_param->scaleFactor;
+            }
+
+            for (uint32_t j = 0; j < width; j++, k++)
+            {
+                analysis->lookahead.vbvCost[(i * m_param->scaleFactor * cuLoc.widthInCU) + (j * m_param->scaleFactor)] = vbvCostBuf[k];
+                analysis->lookahead.intraVbvCost[(i * m_param->scaleFactor * cuLoc.widthInCU) + (j * m_param->scaleFactor)] = intraVbvCostBuf[k];
+
+                if (!(j == (width - 1) && skipLastCol))
+                {
+                    analysis->lookahead.vbvCost[(i * m_param->scaleFactor * cuLoc.widthInCU) + (j * m_param->scaleFactor) + 1] = vbvCostBuf[k];
+                    analysis->lookahead.intraVbvCost[(i * m_param->scaleFactor * cuLoc.widthInCU) + (j * m_param->scaleFactor) + 1] = intraVbvCostBuf[k];
+                }
+                if (!(i == (analysis->numCuInHeight - 1) && skipLastRow))
+                {
+                    analysis->lookahead.vbvCost[(i * m_param->scaleFactor * cuLoc.widthInCU) + cuLoc.widthInCU + (j * m_param->scaleFactor)] = vbvCostBuf[k];
+                    analysis->lookahead.intraVbvCost[(i * m_param->scaleFactor * cuLoc.widthInCU) + cuLoc.widthInCU + (j * m_param->scaleFactor)] = intraVbvCostBuf[k];
+                    if (!(j == (width - 1) && skipLastCol))
+                    {
+                        analysis->lookahead.vbvCost[(i * m_param->scaleFactor * cuLoc.widthInCU) + cuLoc.widthInCU + (j * m_param->scaleFactor) + 1] = vbvCostBuf[k];
+                        analysis->lookahead.intraVbvCost[(i * m_param->scaleFactor * cuLoc.widthInCU) + cuLoc.widthInCU + (j * m_param->scaleFactor) + 1] = intraVbvCostBuf[k];
+                    }
+                }
+            }
+        }
+        X265_FREE(satdForVbvBuf);
+        X265_FREE(intraSatdForVbvBuf);
+        X265_FREE(intraVbvCostBuf);
+        X265_FREE(vbvCostBuf);
     }
 
     if (analysis->sliceType == X265_TYPE_IDR || analysis->sliceType == X265_TYPE_I)
@@ -3912,6 +3978,7 @@
     /* Restore to the current encode's numPartitions and numCUsInFrame */
     analysis->numPartitions = m_param->num4x4Partitions;
     analysis->numCUsInFrame = cuLoc.heightInCU * cuLoc.widthInCU;
+    analysis->numCuInHeight = cuLoc.heightInCU;
 #undef X265_FREAD
 }
 
@@ -3944,23 +4011,23 @@
     }\
     count++;\
 
-    x265_analysis_validate saveParam = analysis->saveParam;
+    x265_analysis_validate *saveParam = &analysis->saveParam;
     FILE*     fileOffset = NULL;
     int       readValue = 0;
     int       count = 0;
 
-    X265_PARAM_VALIDATE(saveParam.maxNumReferences, sizeof(int), 1, &m_param->maxNumReferences);
-    X265_PARAM_VALIDATE(saveParam.analysisReuseLevel, sizeof(int), 1, &m_param->analysisReuseLevel);
-    X265_PARAM_VALIDATE(saveParam.scaleFactor, sizeof(int), 1, &m_param->scaleFactor);
-    X265_PARAM_VALIDATE(saveParam.keyframeMax, sizeof(int), 1, &m_param->keyframeMax);
-    X265_PARAM_VALIDATE(saveParam.keyframeMin, sizeof(int), 1, &m_param->keyframeMin);
-    X265_PARAM_VALIDATE(saveParam.openGOP, sizeof(int), 1, &m_param->bOpenGOP);
-    X265_PARAM_VALIDATE(saveParam.bframes, sizeof(int), 1, &m_param->bframes);
-    X265_PARAM_VALIDATE(saveParam.bPyramid, sizeof(int), 1, &m_param->bBPyramid);
+    X265_PARAM_VALIDATE(saveParam->maxNumReferences, sizeof(int), 1, &m_param->maxNumReferences);
+    X265_PARAM_VALIDATE(saveParam->analysisReuseLevel, sizeof(int), 1, &m_param->analysisReuseLevel);
+    X265_PARAM_VALIDATE(saveParam->scaleFactor, sizeof(int), 1, &m_param->scaleFactor);
+    X265_PARAM_VALIDATE(saveParam->keyframeMax, sizeof(int), 1, &m_param->keyframeMax);
+    X265_PARAM_VALIDATE(saveParam->keyframeMin, sizeof(int), 1, &m_param->keyframeMin);
+    X265_PARAM_VALIDATE(saveParam->openGOP, sizeof(int), 1, &m_param->bOpenGOP);
+    X265_PARAM_VALIDATE(saveParam->bframes, sizeof(int), 1, &m_param->bframes);
+    X265_PARAM_VALIDATE(saveParam->bPyramid, sizeof(int), 1, &m_param->bBPyramid);
     /* Enable m_saveCTUSize if the save and load encodes have the same maxCU size */
     if (writeFlag)
     {
-        X265_PARAM_VALIDATE(saveParam.maxCUSize, sizeof(int), 1, &m_param->maxCUSize);
+        X265_PARAM_VALIDATE(saveParam->maxCUSize, sizeof(int), 1, &m_param->maxCUSize);
     }
     else
     {
@@ -3971,7 +4038,7 @@
             m_aborted = true;
         }
         else if (!m_param->bUseAnalysisFile)
-            readValue = saveParam.maxCUSize;
+            readValue = saveParam->maxCUSize;
 
         m_saveCTUSize = 0;
         if (m_param->scaleFactor && g_log2Size[m_param->maxCUSize] == g_log2Size[readValue])
@@ -3983,10 +4050,10 @@
         }
         count++;
     }
-    X265_PARAM_VALIDATE(saveParam.minCUSize, sizeof(int), 1, &m_param->minCUSize);
-    X265_PARAM_VALIDATE(saveParam.radl, sizeof(int), 1, &m_param->radl);
-    X265_PARAM_VALIDATE(saveParam.lookaheadDepth, sizeof(int), 1, &m_param->lookaheadDepth);
-    X265_PARAM_VALIDATE(saveParam.gopLookahead, sizeof(int), 1, &m_param->gopLookahead);
+    X265_PARAM_VALIDATE(saveParam->minCUSize, sizeof(int), 1, &m_param->minCUSize);
+    X265_PARAM_VALIDATE(saveParam->radl, sizeof(int), 1, &m_param->radl);
+    X265_PARAM_VALIDATE(saveParam->lookaheadDepth, sizeof(int), 1, &m_param->lookaheadDepth);
+    X265_PARAM_VALIDATE(saveParam->gopLookahead, sizeof(int), 1, &m_param->gopLookahead);
     return (count * sizeof(int));
 #undef X265_PARAM_VALIDATE
 }
_______________________________________________
x265-devel mailing list
x265-devel@videolan.org
https://mailman.videolan.org/listinfo/x265-devel

Reply via email to