Fix segment fault issue for 10 bit.

xiaoxial · xiaoxial · commit 29bdb3a4d248 · 2022-12-23T10:29:17.000+08:00
We need to consider the size of a pixel when do memcpy.

Signed-off-by: Xiaoxia Liang &lt;xiaoxia.liang@intel.com&gt;
diff --git a/Library/Raisr.cpp b/Library/Raisr.cpp
@@ -627,7 +627,7 @@ static void CTCountOfBitsChangedSegment_AVX2(float *LRImage, float *HRImage, con
             else
             {
                 unsigned short *out = (unsigned short *)outImage;
-                out[(startRow + r) * outImageCols + c] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));
+                out[(startRow + r) * outImageCols / sizeof(unsigned short) + c] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));
             }
         }
     }
@@ -670,7 +670,7 @@ static void CTCountOfBitsChangedSegment(DT *LRImage, DT *HRImage, const int rows
             else
             {
                 unsigned short *out = (unsigned short *)outImage;
-                out[(startRow + r) * outImageCols + c] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));
+                out[(startRow + r) * outImageCols / sizeof(unsigned short) + c] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));
             }
         }
     }
@@ -808,6 +808,8 @@ RNLERRORTYPE processSegment(VideoDataType *srcY, VideoDataType *final_outY, Blen
 {
     VideoDataType *inY;
     VideoDataType *outY;
+    int pix_bytes = int((gBitDepth + 7) / 8);
+
     for (int passIdx = 0; passIdx < gPasses; passIdx++)
     {
 #ifdef MEASURE_TIME
@@ -846,7 +848,7 @@ RNLERRORTYPE processSegment(VideoDataType *srcY, VideoDataType *final_outY, Blen
         // the step of gIppCtx.segZones[passIdx][threadIdx].inYUpscaled is equal to the outY->width 
         const int rows = outY->height;
         const int cols = outY->width;
-        const int step = outY->width;
+        const int step = outY->width * pix_bytes;
 
         // 1. Prepare cheap up-scaled 32f data
         IppStatus status = ippStsNoErr;
@@ -887,7 +889,7 @@ RNLERRORTYPE processSegment(VideoDataType *srcY, VideoDataType *final_outY, Blen
             ippiConvert_8u32f_C1R(pDst, cols,
                                   pSeg32f, cols * sizeof(float), {(int)cols, segRows});
         else
-            ippiConvert_16u32f_C1R((Ipp16u *)pDst, cols,
+            ippiConvert_16u32f_C1R((Ipp16u *)pDst, step,
                                   pSeg32f, cols * sizeof(float), {(int)cols, segRows});
 
         // 2. Run hashing
@@ -900,24 +902,24 @@ RNLERRORTYPE processSegment(VideoDataType *srcY, VideoDataType *final_outY, Blen
         {
             // it needs to do memcpy line by line when the line size of outY->pData is not equal to pDst's line size.
             if (step == outY->step) {
-                memcpy(outY->pData, pDst, outY->step * gLoopMargin + gLoopMargin);
+                memcpy(outY->pData, pDst, outY->step * gLoopMargin + gLoopMargin * pix_bytes);
             } else {
                 for (int i = 0; i < gLoopMargin; i++) {
                      memcpy(outY->pData + i * outY->step, pDst + i * step, step);
                 }
-                memcpy(outY->pData + gLoopMargin * outY->step, pDst + gLoopMargin * step, gLoopMargin);
+                memcpy(outY->pData + gLoopMargin * outY->step, pDst + gLoopMargin * step, gLoopMargin * pix_bytes);
             }
         }
         if (endRow == rows)
         {
             if (step == outY->step) {
-                memcpy(outY->pData + (rows - gLoopMargin) * step - gLoopMargin,
-                       pDst + (segRows - gLoopMargin) * step - gLoopMargin,
-                       outY->step * gLoopMargin + gLoopMargin);
+                memcpy(outY->pData + (rows - gLoopMargin) * step - gLoopMargin * pix_bytes,
+                       pDst + (segRows - gLoopMargin) * step - gLoopMargin * pix_bytes,
+                       outY->step * gLoopMargin + gLoopMargin * pix_bytes);
             } else {
-                memcpy(outY->pData + (rows - gLoopMargin - 1) * outY->step +  outY->width - gLoopMargin,
-                       pDst + (segRows - gLoopMargin) * step - gLoopMargin,
-                       gLoopMargin);
+                memcpy(outY->pData + (rows - gLoopMargin - 1) * outY->step +  (outY->width - gLoopMargin) * pix_bytes,
+                       pDst + (segRows - gLoopMargin) * step - gLoopMargin * pix_bytes,
+                       gLoopMargin * pix_bytes);
 
                 for (int i = gLoopMargin; i > 0; i--) {
                      memcpy(outY->pData + (rows - i) * outY->step,
@@ -1030,22 +1032,22 @@ RNLERRORTYPE processSegment(VideoDataType *srcY, VideoDataType *final_outY, Blen
                             else
                             {
                                 unsigned short *out = (unsigned short *)outY->pData;
-                                out[r * outY->step + c + pix] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));
+                                out[r * outY->step / sizeof(unsigned short) + c + pix] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));
                             }
                         }
                     }
                 }
             }
             // Copy right border pixels for this row and left border pixels for next row
             if (step == outY->step) {
-                memcpy(outY->pData + r * step - gLoopMargin, pDst + rOffset * step - gLoopMargin, 2 * gLoopMargin);
+                memcpy(outY->pData + r * step - gLoopMargin * pix_bytes, pDst + rOffset * step - gLoopMargin * pix_bytes, 2 * gLoopMargin * pix_bytes);
             } else {
-                memcpy(outY->pData + (r -1 ) * outY->step + outY->width - gLoopMargin,
-                       pDst + rOffset * step - gLoopMargin,
-                       gLoopMargin);
+                memcpy(outY->pData + (r -1 ) * outY->step + (outY->width - gLoopMargin) * pix_bytes,
+                       pDst + rOffset * step - gLoopMargin * pix_bytes,
+                       gLoopMargin * pix_bytes);
                 memcpy(outY->pData + r * outY->step,
                        pDst + rOffset * step,
-                       gLoopMargin);
+                       gLoopMargin * pix_bytes);
             }
         }
         // 3. Run CT-Blending
diff --git a/Library/Raisr_AVX256.cpp b/Library/Raisr_AVX256.cpp
@@ -147,7 +147,7 @@ static void CTCountOfBitsChangedSegment_AVX256_32f(float *LRImage, float *HRImag
                 val_epu16 = _mm256_packus_epi32(val_epi32,val_epi32);
                 perm_epu = _mm256_permute4x64_epi64(val_epu16, 0x88);
                 unsigned short *out = (unsigned short *)outImage;
-                _mm_storeu_si128((__m128i *) &out[(startRow + r) * outImageCols + c], _mm256_extractf128_si256(perm_epu, 0));
+                _mm_storeu_si128((__m128i *) &out[(startRow + r) * outImageCols / sizeof(unsigned short) + c], _mm256_extractf128_si256(perm_epu, 0));
             }
         }
 
@@ -174,7 +174,7 @@ static void CTCountOfBitsChangedSegment_AVX256_32f(float *LRImage, float *HRImag
             }
             else {
                 unsigned short *out = (unsigned short *)outImage;
-                out[(startRow + r) * outImageCols + c] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));
+                out[(startRow + r) * outImageCols / sizeof(unsigned short) + c] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -627,7 +627,7 @@ static void CTCountOfBitsChangedSegment_AVX2(float LRImage, float HRImage, con`
`627`	`627`	`else`
`628`	`628`	`{`
`629`	`629`	`unsigned short out = (unsigned short )outImage;`
`630`		`- out[(startRow + r) * outImageCols + c] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));`
	`630`	`+ out[(startRow + r) * outImageCols / sizeof(unsigned short) + c] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));`
`631`	`631`	`}`
`632`	`632`	`}`
`633`	`633`	`}`
`@@ -670,7 +670,7 @@ static void CTCountOfBitsChangedSegment(DT LRImage, DT HRImage, const int rows`
`670`	`670`	`else`
`671`	`671`	`{`
`672`	`672`	`unsigned short out = (unsigned short )outImage;`
`673`		`- out[(startRow + r) * outImageCols + c] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));`
	`673`	`+ out[(startRow + r) * outImageCols / sizeof(unsigned short) + c] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));`
`674`	`674`	`}`
`675`	`675`	`}`
`676`	`676`	`}`
`@@ -808,6 +808,8 @@ RNLERRORTYPE processSegment(VideoDataType srcY, VideoDataType final_outY, Blen`
`808`	`808`	`{`
`809`	`809`	`VideoDataType *inY;`
`810`	`810`	`VideoDataType *outY;`
	`811`	`+ int pix_bytes = int((gBitDepth + 7) / 8);`
	`812`	`+`
`811`	`813`	`for (int passIdx = 0; passIdx < gPasses; passIdx++)`
`812`	`814`	`{`
`813`	`815`	`#ifdef MEASURE_TIME`
`@@ -846,7 +848,7 @@ RNLERRORTYPE processSegment(VideoDataType srcY, VideoDataType final_outY, Blen`
`846`	`848`	`// the step of gIppCtx.segZones[passIdx][threadIdx].inYUpscaled is equal to the outY->width`
`847`	`849`	`const int rows = outY->height;`
`848`	`850`	`const int cols = outY->width;`
`849`		`- const int step = outY->width;`
	`851`	`+ const int step = outY->width * pix_bytes;`
`850`	`852`
`851`	`853`	`// 1. Prepare cheap up-scaled 32f data`
`852`	`854`	`IppStatus status = ippStsNoErr;`
`@@ -887,7 +889,7 @@ RNLERRORTYPE processSegment(VideoDataType srcY, VideoDataType final_outY, Blen`
`887`	`889`	`ippiConvert_8u32f_C1R(pDst, cols,`
`888`	`890`	`pSeg32f, cols * sizeof(float), {(int)cols, segRows});`
`889`	`891`	`else`
`890`		`- ippiConvert_16u32f_C1R((Ipp16u *)pDst, cols,`
	`892`	`+ ippiConvert_16u32f_C1R((Ipp16u *)pDst, step,`
`891`	`893`	`pSeg32f, cols * sizeof(float), {(int)cols, segRows});`
`892`	`894`
`893`	`895`	`// 2. Run hashing`
`@@ -900,24 +902,24 @@ RNLERRORTYPE processSegment(VideoDataType srcY, VideoDataType final_outY, Blen`
`900`	`902`	`{`
`901`	`903`	`// it needs to do memcpy line by line when the line size of outY->pData is not equal to pDst's line size.`
`902`	`904`	`if (step == outY->step) {`
`903`		`- memcpy(outY->pData, pDst, outY->step * gLoopMargin + gLoopMargin);`
	`905`	`+ memcpy(outY->pData, pDst, outY->step * gLoopMargin + gLoopMargin * pix_bytes);`
`904`	`906`	`} else {`
`905`	`907`	`for (int i = 0; i < gLoopMargin; i++) {`
`906`	`908`	`memcpy(outY->pData + i * outY->step, pDst + i * step, step);`
`907`	`909`	`}`
`908`		`- memcpy(outY->pData + gLoopMargin * outY->step, pDst + gLoopMargin * step, gLoopMargin);`
	`910`	`+ memcpy(outY->pData + gLoopMargin * outY->step, pDst + gLoopMargin * step, gLoopMargin * pix_bytes);`
`909`	`911`	`}`
`910`	`912`	`}`
`911`	`913`	`if (endRow == rows)`
`912`	`914`	`{`
`913`	`915`	`if (step == outY->step) {`
`914`		`- memcpy(outY->pData + (rows - gLoopMargin) * step - gLoopMargin,`
`915`		`- pDst + (segRows - gLoopMargin) * step - gLoopMargin,`
`916`		`- outY->step * gLoopMargin + gLoopMargin);`
	`916`	`+ memcpy(outY->pData + (rows - gLoopMargin) * step - gLoopMargin * pix_bytes,`
	`917`	`+ pDst + (segRows - gLoopMargin) * step - gLoopMargin * pix_bytes,`
	`918`	`+ outY->step * gLoopMargin + gLoopMargin * pix_bytes);`
`917`	`919`	`} else {`
`918`		`- memcpy(outY->pData + (rows - gLoopMargin - 1) * outY->step + outY->width - gLoopMargin,`
`919`		`- pDst + (segRows - gLoopMargin) * step - gLoopMargin,`
`920`		`- gLoopMargin);`
	`920`	`+ memcpy(outY->pData + (rows - gLoopMargin - 1) * outY->step + (outY->width - gLoopMargin) * pix_bytes,`
	`921`	`+ pDst + (segRows - gLoopMargin) * step - gLoopMargin * pix_bytes,`
	`922`	`+ gLoopMargin * pix_bytes);`
`921`	`923`
`922`	`924`	`for (int i = gLoopMargin; i > 0; i--) {`
`923`	`925`	`memcpy(outY->pData + (rows - i) * outY->step,`
`@@ -1030,22 +1032,22 @@ RNLERRORTYPE processSegment(VideoDataType srcY, VideoDataType final_outY, Blen`
`1030`	`1032`	`else`
`1031`	`1033`	`{`
`1032`	`1034`	`unsigned short out = (unsigned short )outY->pData;`
`1033`		`- out[r * outY->step + c + pix] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));`
	`1035`	`+ out[r * outY->step / sizeof(unsigned short) + c + pix] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));`
`1034`	`1036`	`}`
`1035`	`1037`	`}`
`1036`	`1038`	`}`
`1037`	`1039`	`}`
`1038`	`1040`	`}`
`1039`	`1041`	`// Copy right border pixels for this row and left border pixels for next row`
`1040`	`1042`	`if (step == outY->step) {`
`1041`		`- memcpy(outY->pData + r * step - gLoopMargin, pDst + rOffset * step - gLoopMargin, 2 * gLoopMargin);`
	`1043`	`+ memcpy(outY->pData + r * step - gLoopMargin * pix_bytes, pDst + rOffset * step - gLoopMargin * pix_bytes, 2 * gLoopMargin * pix_bytes);`
`1042`	`1044`	`} else {`
`1043`		`- memcpy(outY->pData + (r -1 ) * outY->step + outY->width - gLoopMargin,`
`1044`		`- pDst + rOffset * step - gLoopMargin,`
`1045`		`- gLoopMargin);`
	`1045`	`+ memcpy(outY->pData + (r -1 ) * outY->step + (outY->width - gLoopMargin) * pix_bytes,`
	`1046`	`+ pDst + rOffset * step - gLoopMargin * pix_bytes,`
	`1047`	`+ gLoopMargin * pix_bytes);`
`1046`	`1048`	`memcpy(outY->pData + r * outY->step,`
`1047`	`1049`	`pDst + rOffset * step,`
`1048`		`- gLoopMargin);`
	`1050`	`+ gLoopMargin * pix_bytes);`
`1049`	`1051`	`}`
`1050`	`1052`	`}`
`1051`	`1053`	`// 3. Run CT-Blending`
Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ static void CTCountOfBitsChangedSegment_AVX256_32f(float LRImage, float HRImag`
`147`	`147`	`val_epu16 = _mm256_packus_epi32(val_epi32,val_epi32);`
`148`	`148`	`perm_epu = _mm256_permute4x64_epi64(val_epu16, 0x88);`
`149`	`149`	`unsigned short out = (unsigned short )outImage;`
`150`		`- _mm_storeu_si128((__m128i ) &out[(startRow + r) outImageCols + c], _mm256_extractf128_si256(perm_epu, 0));`
	`150`	`+ _mm_storeu_si128((__m128i ) &out[(startRow + r) outImageCols / sizeof(unsigned short) + c], _mm256_extractf128_si256(perm_epu, 0));`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`
`@@ -174,7 +174,7 @@ static void CTCountOfBitsChangedSegment_AVX256_32f(float LRImage, float HRImag`
`174`	`174`	`}`
`175`	`175`	`else {`
`176`	`176`	`unsigned short out = (unsigned short )outImage;`
`177`		`- out[(startRow + r) * outImageCols + c] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));`
	`177`	`+ out[(startRow + r) * outImageCols / sizeof(unsigned short) + c] = (unsigned short)(val < gMin16bit ? gMin16bit : (val > gMax16bit ? gMax16bit : val));`
`178`	`178`	`}`
`179`	`179`	`}`
`180`	`180`	`}`