Pushed to default. On Mon, Jul 15, 2019 at 4:21 PM Akil <[email protected]> wrote:
> # HG changeset patch > # User Akil Ayyappan<[email protected]> > # Date 1562928744 -19800 > # Fri Jul 12 16:22:24 2019 +0530 > # Node ID 62f3bd2fedbaa2f888f1bc9e4423df751c4ab944 > # Parent 147fb92c5ed50365a69959e6832b1d8368f0ea87 > AQ: New AQ mode with Variance and Edge information > > diff -r 147fb92c5ed5 -r 62f3bd2fedba doc/reST/cli.rst > --- a/doc/reST/cli.rst Mon Jul 08 10:39:27 2019 +0530 > +++ b/doc/reST/cli.rst Fri Jul 12 16:22:24 2019 +0530 > @@ -1,3 +1,4 @@ > + > ********************* > Command Line Options > ********************* > @@ -1645,7 +1646,7 @@ > ignored. Slower presets will generally achieve better compression > efficiency (and generate smaller bitstreams). Default disabled. > > -.. option:: --aq-mode <0|1|2|3> > +.. option:: --aq-mode <0|1|2|3|4> > > Adaptive Quantization operating mode. Raise or lower per-block > quantization based on complexity analysis of the source image. The > @@ -1659,6 +1660,7 @@ > 3. AQ enabled with auto-variance and bias to dark scenes. This is > recommended for 8-bit encodes or low-bitrate 10-bit encodes, to > prevent color banding/blocking. > + 4. AQ enabled with auto-variance and edge information. > > .. option:: --aq-strength <float> > > diff -r 147fb92c5ed5 -r 62f3bd2fedba source/CMakeLists.txt > --- a/source/CMakeLists.txt Mon Jul 08 10:39:27 2019 +0530 > +++ b/source/CMakeLists.txt Fri Jul 12 16:22:24 2019 +0530 > @@ -29,7 +29,7 @@ > option(STATIC_LINK_CRT "Statically link C runtime for release builds" OFF) > mark_as_advanced(FPROFILE_USE FPROFILE_GENERATE NATIVE_BUILD) > # X265_BUILD must be incremented each time the public API is changed > -set(X265_BUILD 177) > +set(X265_BUILD 178) > configure_file("${PROJECT_SOURCE_DIR}/x265.def.in" > "${PROJECT_BINARY_DIR}/x265.def") > configure_file("${PROJECT_SOURCE_DIR}/x265_config.h.in" > diff -r 147fb92c5ed5 -r 62f3bd2fedba source/common/lowres.cpp > --- a/source/common/lowres.cpp Mon Jul 08 10:39:27 2019 +0530 > +++ b/source/common/lowres.cpp Fri Jul 12 16:22:24 2019 +0530 > @@ -80,6 +80,7 @@ > CHECKED_MALLOC_ZERO(qpCuTreeOffset, double, cuCountFullRes); > if (qgSize == 8) > CHECKED_MALLOC_ZERO(invQscaleFactor8x8, int, cuCount); > + CHECKED_MALLOC_ZERO(edgeInclined, int, cuCountFullRes); > } > > if (origPic->m_param->bAQMotion) > @@ -231,6 +232,7 @@ > X265_FREE(qpCuTreeOffset); > X265_FREE(propagateCost); > X265_FREE(invQscaleFactor8x8); > + X265_FREE(edgeInclined); > X265_FREE(qpAqMotionOffset); > X265_FREE(blockVariance); > if (maxAQDepth > 0) > diff -r 147fb92c5ed5 -r 62f3bd2fedba source/common/lowres.h > --- a/source/common/lowres.h Mon Jul 08 10:39:27 2019 +0530 > +++ b/source/common/lowres.h Fri Jul 12 16:22:24 2019 +0530 > @@ -220,6 +220,8 @@ > uint64_t wp_ssd[3]; // This is different than SSDY, this is > sum(pixel^2) - sum(pixel)^2 for entire frame > uint64_t wp_sum[3]; > double frameVariance; > + int* edgeInclined; > + > > /* cutree intermediate data */ > PicQPAdaptationLayer* pAQLayer; > diff -r 147fb92c5ed5 -r 62f3bd2fedba source/common/param.cpp > --- a/source/common/param.cpp Mon Jul 08 10:39:27 2019 +0530 > +++ b/source/common/param.cpp Fri Jul 12 16:22:24 2019 +0530 > @@ -1546,7 +1546,7 @@ > "Lookahead depth must be less than 256"); > CHECK(param->lookaheadSlices > 16 || param->lookaheadSlices < 0, > "Lookahead slices must between 0 and 16"); > - CHECK(param->rc.aqMode < X265_AQ_NONE || X265_AQ_AUTO_VARIANCE_BIASED > < param->rc.aqMode, > + CHECK(param->rc.aqMode < X265_AQ_NONE || X265_AQ_EDGE < > param->rc.aqMode, > "Aq-Mode is out of range"); > CHECK(param->rc.aqStrength < 0 || param->rc.aqStrength > 3, > "Aq-Strength is out of range"); > diff -r 147fb92c5ed5 -r 62f3bd2fedba source/encoder/slicetype.cpp > --- a/source/encoder/slicetype.cpp Mon Jul 08 10:39:27 2019 +0530 > +++ b/source/encoder/slicetype.cpp Fri Jul 12 16:22:24 2019 +0530 > @@ -85,6 +85,140 @@ > > } // end anonymous namespace > > +void edgeFilter(Frame *curFrame, pixel *pic1, pixel *pic2, pixel *pic3, > intptr_t stride, int height, int width) > +{ > + pixel *src = (pixel*)curFrame->m_fencPic->m_picOrg[0]; > + pixel *edgePic = pic1 + curFrame->m_fencPic->m_lumaMarginY * stride + > curFrame->m_fencPic->m_lumaMarginX; > + pixel *refPic = pic2 + curFrame->m_fencPic->m_lumaMarginY * stride + > curFrame->m_fencPic->m_lumaMarginX; > + pixel *edgeTheta = pic3 + curFrame->m_fencPic->m_lumaMarginY * stride > + curFrame->m_fencPic->m_lumaMarginX; > + > + for (int i = 0; i < height; i++) > + { > + memcpy(edgePic, src, width * sizeof(pixel)); > + memcpy(refPic, src, width * sizeof(pixel)); > + src += stride; > + edgePic += stride; > + refPic += stride; > + } > + > + //Applying Gaussian filter on the picture > + src = (pixel*)curFrame->m_fencPic->m_picOrg[0]; > + refPic = pic2 + curFrame->m_fencPic->m_lumaMarginY * stride + > curFrame->m_fencPic->m_lumaMarginX; > + pixel pixelValue = 0; > + > + for (int rowNum = 0; rowNum < height; rowNum++) > + { > + for (int colNum = 0; colNum < width; colNum++) > + { > + if ((rowNum >= 2) && (colNum >= 2) && (rowNum != height - 2) > && (colNum != width - 2)) //Ignoring the border pixels of the picture > + { > + /* 5x5 Gaussian filter > + [2 4 5 4 2] > + 1 [4 9 12 9 4] > + --- [5 12 15 12 5] > + 159 [4 9 12 9 4] > + [2 4 5 4 2]*/ > + > + const intptr_t rowOne = (rowNum - 2)*stride, colOne = > colNum - 2; > + const intptr_t rowTwo = (rowNum - 1)*stride, colTwo = > colNum - 1; > + const intptr_t rowThree = rowNum * stride, colThree = > colNum; > + const intptr_t rowFour = (rowNum + 1)*stride, colFour = > colNum + 1; > + const intptr_t rowFive = (rowNum + 2)*stride, colFive = > colNum + 2; > + const intptr_t index = (rowNum*stride) + colNum; > + > + pixelValue = ((2 * src[rowOne + colOne] + 4 * src[rowOne > + colTwo] + 5 * src[rowOne + colThree] + 4 * src[rowOne + colFour] + 2 * > src[rowOne + colFive] + > + 4 * src[rowTwo + colOne] + 9 * src[rowTwo + colTwo] + > 12 * src[rowTwo + colThree] + 9 * src[rowTwo + colFour] + 4 * src[rowTwo + > colFive] + > + 5 * src[rowThree + colOne] + 12 * src[rowThree + > colTwo] + 15 * src[rowThree + colThree] + 12 * src[rowThree + colFour] + 5 > * src[rowThree + colFive] + > + 4 * src[rowFour + colOne] + 9 * src[rowFour + colTwo] > + 12 * src[rowFour + colThree] + 9 * src[rowFour + colFour] + 4 * > src[rowFour + colFive] + > + 2 * src[rowFive + colOne] + 4 * src[rowFive + colTwo] > + 5 * src[rowFive + colThree] + 4 * src[rowFive + colFour] + 2 * > src[rowFive + colFive]) / 159); > + refPic[index] = pixelValue; > + } > + } > + } > + > +#if HIGH_BIT_DEPTH //10-bit build > + float_t threshold = 1023; > + pixel whitePixel = 1023; > +#else > + float_t threshold = 255; > + pixel whitePixel = 255; > +#endif > +#define PI 3.14159265 > + > + float_t gradientH = 0, gradientV = 0, radians = 0, theta = 0; > + float_t gradientMagnitude = 0; > + pixel blackPixel = 0; > + edgePic = pic1 + curFrame->m_fencPic->m_lumaMarginY * stride + > curFrame->m_fencPic->m_lumaMarginX; > + //Applying Sobel filter on the gaussian filtered picture > + for (int rowNum = 0; rowNum < height; rowNum++) > + { > + for (int colNum = 0; colNum < width; colNum++) > + { > + edgeTheta[(rowNum*stride) + colNum] = 0; > + if ((rowNum != 0) && (colNum != 0) && (rowNum != height - 1) > && (colNum != width - 1)) //Ignoring the border pixels of the picture > + { > + /*Horizontal and vertical gradients > + [ -3 0 3 ] [-3 -10 -3 ] > + gH = [ -10 0 10] gV = [ 0 0 0 ] > + [ -3 0 3 ] [ 3 10 3 ]*/ > + > + const intptr_t rowOne = (rowNum - 1)*stride, colOne = > colNum -1; > + const intptr_t rowTwo = rowNum * stride, colTwo = colNum; > + const intptr_t rowThree = (rowNum + 1)*stride, colThree = > colNum + 1; > + const intptr_t index = (rowNum*stride) + colNum; > + > + gradientH = (float_t)(-3 * refPic[rowOne + colOne] + 3 * > refPic[rowOne + colThree] - 10 * refPic[rowTwo + colOne] + 10 * > refPic[rowTwo + colThree] - 3 * refPic[rowThree + colOne] + 3 * > refPic[rowThree + colThree]); > + gradientV = (float_t)(-3 * refPic[rowOne + colOne] - 10 * > refPic[rowOne + colTwo] - 3 * refPic[rowOne + colThree] + 3 * > refPic[rowThree + colOne] + 10 * refPic[rowThree + colTwo] + 3 * > refPic[rowThree + colThree]); > + > + gradientMagnitude = sqrtf(gradientH * gradientH + > gradientV * gradientV); > + radians = atan2(gradientV, gradientH); > + theta = (float_t)((radians * 180) / PI); > + if (theta < 0) > + theta = 180 + theta; > + edgeTheta[(rowNum*stride) + colNum] = (pixel)theta; > + > + edgePic[index] = gradientMagnitude >= threshold ? > whitePixel : blackPixel; > + } > + } > + } > +} > + > +//Find the angle of a block by averaging the pixel angles > +inline void findAvgAngle(const pixel* block, intptr_t stride, uint32_t > size, uint32_t &angle) > +{ > + int sum = 0; > + for (uint32_t y = 0; y < size; y++) > + { > + for (uint32_t x = 0; x < size; x++) > + { > + sum += block[x]; > + } > + block += stride; > + } > + angle = sum / (size*size); > +} > + > +uint32_t LookaheadTLD::edgeDensityCu(Frame* curFrame,pixel *edgeImage, > pixel *edgeTheta, uint32_t &avgAngle, uint32_t blockX, uint32_t blockY, > uint32_t qgSize) > +{ > + intptr_t srcStride = curFrame->m_fencPic->m_stride; > + intptr_t blockOffsetLuma = blockX + (blockY * srcStride); > + int plane = 0; // Sobel filter is applied only on Y component > + uint32_t var; > + > + if (qgSize == 8) > + { > + findAvgAngle(edgeTheta + blockOffsetLuma, srcStride, qgSize, > avgAngle); > + var = acEnergyVar(curFrame, primitives.cu[BLOCK_8x8].var(edgeImage > + blockOffsetLuma, srcStride), 6, plane); > + } > + else > + { > + findAvgAngle(edgeTheta + blockOffsetLuma, srcStride, 16, > avgAngle); > + var = acEnergyVar(curFrame, primitives.cu[BLOCK_16x16].var(edgeImage > + blockOffsetLuma, srcStride), 8, plane); > + } > + x265_emms(); > + return var; > +} > + > /* Find the total AC energy of each block in all planes */ > uint32_t LookaheadTLD::acEnergyCu(Frame* curFrame, uint32_t blockX, > uint32_t blockY, int csp, uint32_t qgSize) > { > @@ -342,20 +476,55 @@ > } > else > { > - int blockXY = 0; > +#define AQ_EDGE_BIAS 0.5 > +#define EDGE_INCLINATION 45 > + uint32_t numCuInHeight = (maxRow + param->maxCUSize - 1) / > param->maxCUSize; > + int maxHeight = numCuInHeight * param->maxCUSize; > + intptr_t stride = curFrame->m_fencPic->m_stride; > + pixel *edgePic = X265_MALLOC(pixel, stride * (maxHeight + > (curFrame->m_fencPic->m_lumaMarginY * 2))); > + pixel *gaussianPic = X265_MALLOC(pixel, stride * (maxHeight + > (curFrame->m_fencPic->m_lumaMarginY * 2))); > + pixel *thetaPic = X265_MALLOC(pixel, stride * (maxHeight + > (curFrame->m_fencPic->m_lumaMarginY * 2))); > + memset(edgePic, 0, stride * (maxHeight + > (curFrame->m_fencPic->m_lumaMarginY * 2)) * sizeof(pixel)); > + memset(gaussianPic, 0, stride * (maxHeight + > (curFrame->m_fencPic->m_lumaMarginY * 2)) * sizeof(pixel)); > + memset(thetaPic, 0, stride * (maxHeight + > (curFrame->m_fencPic->m_lumaMarginY * 2)) * sizeof(pixel)); > + if (param->rc.aqMode == X265_AQ_EDGE) > + edgeFilter(curFrame, edgePic, gaussianPic, thetaPic, > stride, maxRow, maxCol); > + > + int blockXY = 0, inclinedEdge = 0; > double avg_adj_pow2 = 0, avg_adj = 0, qp_adj = 0; > double bias_strength = 0.f; > double strength = 0.f; > - if (param->rc.aqMode == X265_AQ_AUTO_VARIANCE || > param->rc.aqMode == X265_AQ_AUTO_VARIANCE_BIASED) > + if (param->rc.aqMode == X265_AQ_AUTO_VARIANCE || > param->rc.aqMode == X265_AQ_AUTO_VARIANCE_BIASED || param->rc.aqMode == > X265_AQ_EDGE) > { > double bit_depth_correction = 1.f / (1 << (2 * > (X265_DEPTH - 8))); > - > for (int blockY = 0; blockY < maxRow; blockY += loopIncr) > { > for (int blockX = 0; blockX < maxCol; blockX += > loopIncr) > { > - uint32_t energy = acEnergyCu(curFrame, blockX, > blockY, param->internalCsp, param->rc.qgSize); > - qp_adj = pow(energy * bit_depth_correction + 1, > 0.1); > + uint32_t energy, edgeDensity, avgAngle; > + energy = acEnergyCu(curFrame, blockX, blockY, > param->internalCsp, param->rc.qgSize); > + if (param->rc.aqMode == X265_AQ_EDGE) > + { > + pixel *edgeImage = edgePic + > curFrame->m_fencPic->m_lumaMarginY * stride + > curFrame->m_fencPic->m_lumaMarginX; > + pixel *edgeTheta = thetaPic + > curFrame->m_fencPic->m_lumaMarginY * stride + > curFrame->m_fencPic->m_lumaMarginX; > + edgeDensity = edgeDensityCu(curFrame, > edgeImage, edgeTheta, avgAngle, blockX, blockY, param->rc.qgSize); > + if (edgeDensity) > + { > + qp_adj = pow(edgeDensity * > bit_depth_correction + 1, 0.1); > + //Increasing the QP of a block if its > edge orientation lies around the multiples of 45 degree > + if ((avgAngle >= EDGE_INCLINATION - 15 && > avgAngle <= EDGE_INCLINATION + 15) || (avgAngle >= EDGE_INCLINATION + 75 && > avgAngle <= EDGE_INCLINATION + 105)) > + > curFrame->m_lowres.edgeInclined[blockXY] = 1; > + else > + > curFrame->m_lowres.edgeInclined[blockXY] = 0; > + } > + else > + { > + qp_adj = pow(energy * > bit_depth_correction + 1, 0.1); > + curFrame->m_lowres.edgeInclined[blockXY] > = 0; > + } > + } > + else > + qp_adj = pow(energy * bit_depth_correction + > 1, 0.1); > curFrame->m_lowres.qpCuTreeOffset[blockXY] = > qp_adj; > avg_adj += qp_adj; > avg_adj_pow2 += qp_adj * qp_adj; > @@ -371,6 +540,9 @@ > else > strength = param->rc.aqStrength * 1.0397f; > > + X265_FREE(edgePic); > + X265_FREE(gaussianPic); > + X265_FREE(thetaPic); > blockXY = 0; > for (int blockY = 0; blockY < maxRow; blockY += loopIncr) > { > @@ -386,6 +558,15 @@ > qp_adj = > curFrame->m_lowres.qpCuTreeOffset[blockXY]; > qp_adj = strength * (qp_adj - avg_adj); > } > + else if (param->rc.aqMode == X265_AQ_EDGE) > + { > + inclinedEdge = > curFrame->m_lowres.edgeInclined[blockXY]; > + qp_adj = > curFrame->m_lowres.qpCuTreeOffset[blockXY]; > + if(inclinedEdge && (qp_adj - avg_adj > 0)) > + qp_adj = ((strength + AQ_EDGE_BIAS) * (qp_adj > - avg_adj)); > + else > + qp_adj = strength * (qp_adj - avg_adj); > + } > else > { > uint32_t energy = acEnergyCu(curFrame, blockX, > blockY, param->internalCsp, param->rc.qgSize); > diff -r 147fb92c5ed5 -r 62f3bd2fedba source/encoder/slicetype.h > --- a/source/encoder/slicetype.h Mon Jul 08 10:39:27 2019 +0530 > +++ b/source/encoder/slicetype.h Fri Jul 12 16:22:24 2019 +0530 > @@ -92,6 +92,7 @@ > protected: > > uint32_t acEnergyCu(Frame* curFrame, uint32_t blockX, uint32_t > blockY, int csp, uint32_t qgSize); > + uint32_t edgeDensityCu(Frame*curFrame, pixel *edgeImage, pixel > *edgeTheta, uint32_t &avgAngle, uint32_t blockX, uint32_t blockY, uint32_t > qgSize); > uint32_t lumaSumCu(Frame* curFrame, uint32_t blockX, uint32_t blockY, > uint32_t qgSize); > uint32_t weightCostLuma(Lowres& fenc, Lowres& ref, WeightParam& wp); > bool allocWeightedRef(Lowres& fenc); > diff -r 147fb92c5ed5 -r 62f3bd2fedba source/test/regression-tests.txt > --- a/source/test/regression-tests.txt Mon Jul 08 10:39:27 2019 +0530 > +++ b/source/test/regression-tests.txt Fri Jul 12 16:22:24 2019 +0530 > @@ -154,6 +154,7 @@ > BasketballDrive_1920x1080_50.y4m, --preset medium --no-open-gop --keyint > 50 --min-keyint 50 --radl 2 --vbv-maxrate 5000 --vbv-bufsize 5000 > big_buck_bunny_360p24.y4m, --bitrate 500 --fades > 720p50_parkrun_ter.y4m,--preset medium --bitrate 400 --hme > +ducks_take_off_420_1_720p50.y4m,--preset medium --aq-mode 4 --crf 22 > --no-cutree > > # Main12 intraCost overflow bug test > 720p50_parkrun_ter.y4m,--preset medium > diff -r 147fb92c5ed5 -r 62f3bd2fedba source/x265.h > --- a/source/x265.h Mon Jul 08 10:39:27 2019 +0530 > +++ b/source/x265.h Fri Jul 12 16:22:24 2019 +0530 > @@ -561,6 +561,7 @@ > #define X265_AQ_VARIANCE 1 > #define X265_AQ_AUTO_VARIANCE 2 > #define X265_AQ_AUTO_VARIANCE_BIASED 3 > +#define X265_AQ_EDGE 4 > #define x265_ADAPT_RD_STRENGTH 4 > #define X265_REFINE_INTER_LEVELS 3 > /* NOTE! For this release only X265_CSP_I420 and X265_CSP_I444 are > supported */ > diff -r 147fb92c5ed5 -r 62f3bd2fedba source/x265cli.h > --- a/source/x265cli.h Mon Jul 08 10:39:27 2019 +0530 > +++ b/source/x265cli.h Fri Jul 12 16:22:24 2019 +0530 > @@ -554,7 +554,7 @@ > " - 0 : Disabled.\n" > " - 1 : Store/Load ctu > distortion to/from the file specified in analysis-save/load.\n" > " Default 0 - Disabled\n"); > - H0(" --aq-mode <integer> Mode for Adaptive Quantization - > 0:none 1:uniform AQ 2:auto variance 3:auto variance with bias to dark > scenes. Default %d\n", param->rc.aqMode); > + H0(" --aq-mode <integer> Mode for Adaptive Quantization - > 0:none 1:uniform AQ 2:auto variance 3:auto variance with bias to dark > scenes 4:auto variance with edge information. Default %d\n", > param->rc.aqMode); > H0(" --[no-]hevc-aq Mode for HEVC Adaptive > Quantization. Default %s\n", OPT(param->rc.hevcAq)); > H0(" --aq-strength <float> Reduces blocking and blurring in > flat and textured areas (0 to 3.0). Default %.2f\n", param->rc.aqStrength); > H0(" --qp-adaptation-range <float> Delta QP range by QP adaptation > based on a psycho-visual model (1.0 to 6.0). Default %.2f\n", > param->rc.qpAdaptationRange); > > On Mon, Jul 15, 2019 at 11:53 AM chen <[email protected]> wrote: > >> Thank you. >> >> for constant, I explain a little more >> we may declare >> const intptr_t row_n2 = (rowNum - 2)*stride; >> >> Now, >> >> src[(rowNum - 2)*stride + (colNum - 2)] >> src[(rowNum - 2)*stride + (colNum - 1)] >> >> ==> >> >> src[row_n2 + (colNum - 2)] >> src[row_n2 + (colNum - 1)] >> >> a little better to read. >> >> At 2019-07-15 13:58:53, "Akil" <[email protected]> wrote: >> >> Thanks for your suggestions, Chen. Have added the matrix in comments. >> That should make the code more readable. Regarding the last point, I think >> (rowNum+X)*stride >> cannot be replaced by a constant since it tends to change every time. >> >> On Fri, Jul 12, 2019 at 7:27 AM chen <[email protected]> wrote: >> >>> >>> On Wed, Jul 10, 2019 at 3:41 PM Akil <[email protected]> wrote: >>> >>>> # HG changeset patch >>>> # User Akil Ayyappan<[email protected]> >>>> # Date 1561035091 -19800 >>>> # Thu Jun 20 18:21:31 2019 +0530 >>>> # Node ID d25c33cc2b748401c5e908af445a0a110e26c3cf >>>> # Parent 4f6dde51a5db4f9229bddb60db176f16ac98f505 >>>> AQ: New AQ mode with Variance and Edge information >>>> >>>> >>>> + //Applying Gaussian filter on the picture >>>> + src = (pixel*)curFrame->m_fencPic->m_picOrg[0]; >>>> + refPic = pic2 + curFrame->m_fencPic->m_lumaMarginY * stride + >>>> curFrame->m_fencPic->m_lumaMarginX; >>>> + pixel pixelValue = 0; >>>> + for (int rowNum = 0; rowNum < height; rowNum++) >>>> + { >>>> + for (int colNum = 0; colNum < width; colNum++) >>>> + { >>>> + if ((rowNum >= 2) && (colNum >= 2) && (rowNum != height - >>>> 2) && (colNum != width - 2)) //Ignoring the border pixels of the picture >>>> + { >>>> + pixelValue = ((2 * src[(rowNum - 2)*stride + (colNum - >>>> 2)] + 4 * src[(rowNum - 2)*stride + (colNum - 1)] + 5 * src[(rowNum - >>>> 2)*stride + (colNum)] + 4 * src[(rowNum - 2)*stride + (colNum + 1)] + 2 * >>>> src[(rowNum - 2)*stride + (colNum + 2)] + >>>> + 4 * src[(rowNum - 1)*stride + (colNum - 2)] + 9 * >>>> src[(rowNum - 1)*stride + (colNum - 1)] + 12 * src[(rowNum - 1)*stride + >>>> (colNum)] + 9 * src[(rowNum - 1)*stride + (colNum + 1)] + 4 * src[(rowNum - >>>> 1)*stride + (colNum + 2)] + >>>> + 5 * src[(rowNum)*stride + (colNum - 2)] + 12 * >>>> src[(rowNum)*stride + (colNum - 1)] + 15 * src[(rowNum)*stride + (colNum)] >>>> + 12 * src[(rowNum)*stride + (colNum + 1)] + 5 * src[(rowNum)*stride + >>>> (colNum + 2)] + >>>> + 4 * src[(rowNum + 1)*stride + (colNum - 2)] + 9 * >>>> src[(rowNum + 1)*stride + (colNum - 1)] + 12 * src[(rowNum + 1)*stride + >>>> (colNum)] + 9 * src[(rowNum + 1)*stride + (colNum + 1)] + 4 * src[(rowNum + >>>> 1)*stride + (colNum + 2)] + >>>> + 2 * src[(rowNum + 2)*stride + (colNum - 2)] + 4 * >>>> src[(rowNum + 2)*stride + (colNum - 1)] + 5 * src[(rowNum + 2)*stride + >>>> (colNum)] + 4 * src[(rowNum + 2)*stride + (colNum + 1)] + 2 * src[(rowNum + >>>> 2)*stride + (colNum + 2)]) / 159); >>>> + refPic[(rowNum*stride) + colNum] = pixelValue; >>>> + } >>>> + } >>>> + } >>>> >>>> Could you please modify a little? >>>> Ident or give coif matrix as comment, it will be more readable >>>> moreover, (rowNum+X)*stride can be replace by constant, it does not >>>> affect compiled code performance but help human read code. >>>> >>>> _______________________________________________ >>> x265-devel mailing list >>> [email protected] >>> https://mailman.videolan.org/listinfo/x265-devel >>> >> >> >> -- >> *Regards,* >> *Akil R* >> >> _______________________________________________ >> x265-devel mailing list >> [email protected] >> https://mailman.videolan.org/listinfo/x265-devel >> > > > -- > *Regards,* > *Akil R* > _______________________________________________ > x265-devel mailing list > [email protected] > https://mailman.videolan.org/listinfo/x265-devel > -- Regards, Aruna
_______________________________________________ x265-devel mailing list [email protected] https://mailman.videolan.org/listinfo/x265-devel
