/*****************************************************************************

 * Copyright (C) 2013-2020 MulticoreWare, Inc

 *

 * Authors: Steve Borho <steve@borho.org>

 *          Min Chen <chenm003@163.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.

 *

 * This program is also available under a commercial proprietary license.

 * For more information, contact us at license @ x265.com.

 *****************************************************************************/

#include "common.h"

#include "picyuv.h"

#include "slice.h"

#include "primitives.h"

using namespace X265_NS;

PicYuv::PicYuv()

{

    m_picBuf[0] = NULL;

    m_picBuf[1] = NULL;

    m_picBuf[2] = NULL;

    m_picOrg[0] = NULL;

    m_picOrg[1] = NULL;

    m_picOrg[2] = NULL;

    m_cuOffsetY = NULL;

    m_cuOffsetC = NULL;

    m_buOffsetY = NULL;

    m_buOffsetC = NULL;

    m_maxLumaLevel = 0;

    m_avgLumaLevel = 0;

    m_maxChromaULevel = 0;

    m_avgChromaULevel = 0;

    m_maxChromaVLevel = 0;

    m_avgChromaVLevel = 0;

#if (X265_DEPTH > 8)

    m_minLumaLevel = 0xFFFF;

    m_minChromaULevel = 0xFFFF;

    m_minChromaVLevel = 0xFFFF;

#else

    m_minLumaLevel = 0xFF;

    m_minChromaULevel = 0xFF;

    m_minChromaVLevel = 0xFF;

#endif

    m_stride = 0;

    m_strideC = 0;

    m_hChromaShift = 0;

    m_vChromaShift = 0;

}

bool PicYuv::create(x265_param* param, bool picAlloc, pixel *pixelbuf)

{

    m_param = param;

    uint32_t picWidth = m_param->sourceWidth;

    uint32_t picHeight = m_param->sourceHeight;

    uint32_t picCsp = m_param->internalCsp;

    m_picWidth  = picWidth;

    m_picHeight = picHeight;

    m_hChromaShift = CHROMA_H_SHIFT(picCsp);

    m_vChromaShift = CHROMA_V_SHIFT(picCsp);

    m_picCsp = picCsp;

    uint32_t numCuInWidth = (m_picWidth + param->maxCUSize - 1)  / param->maxCUSize;

    uint32_t numCuInHeight = (m_picHeight + param->maxCUSize - 1) / param->maxCUSize;

    m_lumaMarginX = param->maxCUSize + 32; // search margin and 8-tap filter half-length, padded for 32-byte alignment

    m_lumaMarginY = param->maxCUSize + 16; // margin for 8-tap filter and infinite padding

    m_stride = (numCuInWidth * param->maxCUSize) + (m_lumaMarginX << 1);

    int maxHeight = numCuInHeight * param->maxCUSize;

    if (pixelbuf)

        m_picOrg[0] = pixelbuf;

    else

    {

        if (picAlloc)

        {

            CHECKED_MALLOC(m_picBuf[0], pixel, m_stride * (maxHeight + (m_lumaMarginY * 2)));

            m_picOrg[0] = m_picBuf[0] + m_lumaMarginY * m_stride + m_lumaMarginX;

        }

    }

    if (picCsp != X265_CSP_I400)

    {

        m_chromaMarginX = m_lumaMarginX;  // keep 16-byte alignment for chroma CTUs

        m_chromaMarginY = m_lumaMarginY >> m_vChromaShift;

        m_strideC = ((numCuInWidth * m_param->maxCUSize) >> m_hChromaShift) + (m_chromaMarginX * 2);

        if (picAlloc)

        {

            CHECKED_MALLOC(m_picBuf[1], pixel, m_strideC * ((maxHeight >> m_vChromaShift) + (m_chromaMarginY * 2)));

            CHECKED_MALLOC(m_picBuf[2], pixel, m_strideC * ((maxHeight >> m_vChromaShift) + (m_chromaMarginY * 2)));

            m_picOrg[1] = m_picBuf[1] + m_chromaMarginY * m_strideC + m_chromaMarginX;

            m_picOrg[2] = m_picBuf[2] + m_chromaMarginY * m_strideC + m_chromaMarginX;

        }

    }

    else

    {

        m_picBuf[1] = m_picBuf[2] = NULL;

        m_picOrg[1] = m_picOrg[2] = NULL;

    }

    return true;

fail:

    return false;

}

/*Copy pixels from the picture buffer of a frame to picture buffer of another frame*/

void PicYuv::copyFromFrame(PicYuv* source)

{

    uint32_t numCuInHeight = (m_picHeight + m_param->maxCUSize - 1) / m_param->maxCUSize;

    int maxHeight = numCuInHeight * m_param->maxCUSize;

    memcpy(m_picBuf[0], source->m_picBuf[0], sizeof(pixel)* m_stride * (maxHeight + (m_lumaMarginY * 2)));

    m_picOrg[0] = m_picBuf[0] + m_lumaMarginY * m_stride + m_lumaMarginX;

    if (m_picCsp != X265_CSP_I400)

    {

        memcpy(m_picBuf[1], source->m_picBuf[1], sizeof(pixel)* m_strideC * ((maxHeight >> m_vChromaShift) + (m_chromaMarginY * 2)));

        memcpy(m_picBuf[2], source->m_picBuf[2], sizeof(pixel)* m_strideC * ((maxHeight >> m_vChromaShift) + (m_chromaMarginY * 2)));

        m_picOrg[1] = m_picBuf[1] + m_chromaMarginY * m_strideC + m_chromaMarginX;

        m_picOrg[2] = m_picBuf[2] + m_chromaMarginY * m_strideC + m_chromaMarginX;

    }

    else

    {

        m_picBuf[1] = m_picBuf[2] = NULL;

        m_picOrg[1] = m_picOrg[2] = NULL;

    }

}

bool PicYuv::createScaledPicYUV(x265_param* param, uint8_t scaleFactor)

{

    m_param = param;

    m_picWidth = m_param->sourceWidth / scaleFactor;

    m_picHeight = m_param->sourceHeight / scaleFactor;

    int maxBlocksInRow = (m_picWidth + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;

    int maxBlocksInCol = (m_picHeight + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;

    m_picWidth = maxBlocksInRow * X265_LOWRES_CU_SIZE;

    m_picHeight = maxBlocksInCol * X265_LOWRES_CU_SIZE;

    m_picCsp = m_param->internalCsp;

    m_hChromaShift = CHROMA_H_SHIFT(m_picCsp);

    m_vChromaShift = CHROMA_V_SHIFT(m_picCsp);

    uint32_t numCuInWidth = (m_picWidth + param->maxCUSize - 1) / param->maxCUSize;

    uint32_t numCuInHeight = (m_picHeight + param->maxCUSize - 1) / param->maxCUSize;

    m_lumaMarginX = 128; // search margin for L0 and L1 ME in horizontal direction

    m_lumaMarginY = 128; // search margin for L0 and L1 ME in vertical direction

    m_stride = (numCuInWidth * param->maxCUSize) + (m_lumaMarginX << 1);

    int maxHeight = numCuInHeight * param->maxCUSize;

    CHECKED_MALLOC_ZERO(m_picBuf[0], pixel, m_stride * (maxHeight + (m_lumaMarginY * 2)));

    m_picOrg[0] = m_picBuf[0] + m_lumaMarginY * m_stride + m_lumaMarginX;

    m_picBuf[1] = m_picBuf[2] = NULL;

    m_picOrg[1] = m_picOrg[2] = NULL;

    return true;

fail:

    return false;

}

int PicYuv::getLumaBufLen(uint32_t picWidth, uint32_t picHeight, uint32_t picCsp)

{

    m_picWidth = picWidth;

    m_picHeight = picHeight;

    m_hChromaShift = CHROMA_H_SHIFT(picCsp);

    m_vChromaShift = CHROMA_V_SHIFT(picCsp);

    m_picCsp = picCsp;

    uint32_t numCuInWidth = (m_picWidth + m_param->maxCUSize - 1) / m_param->maxCUSize;

    uint32_t numCuInHeight = (m_picHeight + m_param->maxCUSize - 1) / m_param->maxCUSize;

    m_lumaMarginX = m_param->maxCUSize + 32; // search margin and 8-tap filter half-length, padded for 32-byte alignment

    m_lumaMarginY = m_param->maxCUSize + 16; // margin for 8-tap filter and infinite padding

    m_stride = (numCuInWidth * m_param->maxCUSize) + (m_lumaMarginX << 1);

    int maxHeight = numCuInHeight * m_param->maxCUSize;

    int bufLen = (int)(m_stride * (maxHeight + (m_lumaMarginY * 2)));

    return bufLen;

}

/* the first picture allocated by the encoder will be asked to generate these

 * offset arrays. Once generated, they will be provided to all future PicYuv

 * allocated by the same encoder. */

bool PicYuv::createOffsets(const SPS& sps)

{

    uint32_t numPartitions = 1 << (m_param->unitSizeDepth * 2);

    if (m_picCsp != X265_CSP_I400)

    {

        CHECKED_MALLOC(m_cuOffsetY, intptr_t, sps.numCuInWidth * sps.numCuInHeight);

        CHECKED_MALLOC(m_cuOffsetC, intptr_t, sps.numCuInWidth * sps.numCuInHeight);

        for (uint32_t cuRow = 0; cuRow < sps.numCuInHeight; cuRow++)

        {

            for (uint32_t cuCol = 0; cuCol < sps.numCuInWidth; cuCol++)

            {

                m_cuOffsetY[cuRow * sps.numCuInWidth + cuCol] = m_stride * cuRow * m_param->maxCUSize + cuCol * m_param->maxCUSize;

                m_cuOffsetC[cuRow * sps.numCuInWidth + cuCol] = m_strideC * cuRow * (m_param->maxCUSize >> m_vChromaShift) + cuCol * (m_param->maxCUSize >> m_hChromaShift);

            }

        }

        CHECKED_MALLOC(m_buOffsetY, intptr_t, (size_t)numPartitions);

        CHECKED_MALLOC(m_buOffsetC, intptr_t, (size_t)numPartitions);

        for (uint32_t idx = 0; idx < numPartitions; ++idx)

        {

            intptr_t x = g_zscanToPelX[idx];

            intptr_t y = g_zscanToPelY[idx];

            m_buOffsetY[idx] = m_stride * y + x;

            m_buOffsetC[idx] = m_strideC * (y >> m_vChromaShift) + (x >> m_hChromaShift);

        }

    }

    else

    {

        CHECKED_MALLOC(m_cuOffsetY, intptr_t, sps.numCuInWidth * sps.numCuInHeight);

        for (uint32_t cuRow = 0; cuRow < sps.numCuInHeight; cuRow++)

        for (uint32_t cuCol = 0; cuCol < sps.numCuInWidth; cuCol++)

            m_cuOffsetY[cuRow * sps.numCuInWidth + cuCol] = m_stride * cuRow * m_param->maxCUSize + cuCol * m_param->maxCUSize;

        CHECKED_MALLOC(m_buOffsetY, intptr_t, (size_t)numPartitions);

        for (uint32_t idx = 0; idx < numPartitions; ++idx)

        {

            intptr_t x = g_zscanToPelX[idx];

            intptr_t y = g_zscanToPelY[idx];

            m_buOffsetY[idx] = m_stride * y + x;

        }

    }

    return true;

fail:

    return false;

}

void PicYuv::destroy()

{

    X265_FREE(m_picBuf[0]);

    X265_FREE(m_picBuf[1]);

    X265_FREE(m_picBuf[2]);

}

/* Copy pixels from an x265_picture into internal PicYuv instance.

 * Shift pixels as necessary, mask off bits above X265_DEPTH for safety. */

void PicYuv::copyFromPicture(const x265_picture& pic, const x265_param& param, int padx, int pady, bool isBase)

{

    /* m_picWidth is the width that is being encoded, padx indicates how many

     * of those pixels are padding to reach multiple of MinCU(4) size.

     *

     * Internally, we need to extend rows out to a multiple of 16 for lowres

     * downscale and other operations. But those padding pixels are never

     * encoded.

     *

     * The same applies to m_picHeight and pady */

    /* width and height - without padsize (input picture raw width and height) */

    int width = m_picWidth - padx;

    int height = m_picHeight - pady;

    /* internal pad to multiple of 16x16 blocks */

    uint8_t rem = width & 15;

    padx = rem ? 16 - rem : padx;

    rem = height & 15;

    pady = rem ? 16 - rem : pady;

    /* add one more row and col of pad for downscale interpolation, fixes

     * warnings from valgrind about using uninitialized pixels */

    padx++;

    pady++;

    m_picCsp = pic.colorSpace;

    X265_CHECK(pic.bitDepth >= 8, "pic.bitDepth check failure");

    uint64_t lumaSum;

    uint64_t cbSum;

    uint64_t crSum;

    lumaSum = cbSum = crSum = 0;

    if (m_param->bCopyPicToFrame)

    {

        if (pic.bitDepth == 8)

        {

#if (X265_DEPTH > 8)

        {

            pixel *yPixel = m_picOrg[0];

            uint8_t *yChar = (uint8_t*)pic.planes[0];

            int shift = (X265_DEPTH - 8);

            primitives.planecopy_cp(yChar, pic.stride[0] / sizeof(*yChar), yPixel, m_stride, width, height, shift);

            if (param.internalCsp != X265_CSP_I400)

            {

                pixel *uPixel = m_picOrg[1];

                pixel *vPixel = m_picOrg[2];

                uint8_t *uChar = (uint8_t*)pic.planes[1];

                uint8_t *vChar = (uint8_t*)pic.planes[2];

                primitives.planecopy_cp(uChar, pic.stride[1] / sizeof(*uChar), uPixel, m_strideC, width >> m_hChromaShift, height >> m_vChromaShift, shift);

                primitives.planecopy_cp(vChar, pic.stride[2] / sizeof(*vChar), vPixel, m_strideC, width >> m_hChromaShift, height >> m_vChromaShift, shift);

            }

        }

#else /* Case for (X265_DEPTH == 8) */

            // TODO: Does we need this path? may merge into above in future

        {

            if (isBase || param.numViews > 1)

            {

                int offsetX, offsetY;

                offsetX = (!isBase && pic.format == 1 ? width : 0);

                offsetY = (!isBase && pic.format == 2 ? pic.stride[0] * height : 0);

                pixel *yPixel = m_picOrg[0];

                uint8_t* yChar = (uint8_t*)pic.planes[0] + offsetX + offsetY;

                for (int r = 0; r < height; r++)

                {

                    memcpy(yPixel, yChar, width * sizeof(pixel));

                    yPixel += m_stride;

                    yChar += pic.stride[0] / sizeof(*yChar);

                }

                if (param.internalCsp != X265_CSP_I400)

                {

                    offsetX = offsetX >> m_hChromaShift;

                    int offsetYU = (!isBase && pic.format == 2 ? pic.stride[1] * (height >> m_vChromaShift) : 0);

                    int offsetYV = (!isBase && pic.format == 2 ? pic.stride[2] * (height >> m_vChromaShift) : 0);

                    pixel *uPixel = m_picOrg[1];

                    pixel *vPixel = m_picOrg[2];

                    uint8_t* uChar = (uint8_t*)pic.planes[1] + offsetX + offsetYU;

                    uint8_t* vChar = (uint8_t*)pic.planes[2] + offsetX + offsetYV;

                    for (int r = 0; r < height >> m_vChromaShift; r++)

                    {

                        memcpy(uPixel, uChar, (width >> m_hChromaShift) * sizeof(pixel));

                        memcpy(vPixel, vChar, (width >> m_hChromaShift) * sizeof(pixel));

                        uPixel += m_strideC;

                        vPixel += m_strideC;

                        uChar += pic.stride[1] / sizeof(*uChar);

                        vChar += pic.stride[2] / sizeof(*vChar);

                    }

                }

            }

#if ENABLE_ALPHA

            if (!isBase && param.bEnableAlpha)

            {

                pixel* aPixel = m_picOrg[0];

                uint8_t* aChar = (uint8_t*)pic.planes[3];

                for (int r = 0; r < height; r++)

                {

                    memcpy(aPixel, aChar, width * sizeof(pixel));

                    aPixel += m_stride;

                    aChar += pic.stride[0] / sizeof(*aChar);

                }

                pixel* uPixel = m_picOrg[1];

                pixel* vPixel = m_picOrg[2];

                for (int r = 0; r < height >> m_vChromaShift; r++)

                {

                    memset(uPixel, 128, (width >> m_hChromaShift) * sizeof(pixel));

                    memset(vPixel, 128, (width >> m_hChromaShift) * sizeof(pixel));

                    uPixel += m_strideC;

                    vPixel += m_strideC;

                }

            }

#endif

        }

#endif /* (X265_DEPTH > 8) */

        }

        else /* pic.bitDepth > 8 */

        {

            /* defensive programming, mask off bits that are supposed to be zero */

            if (isBase)

            {

                uint16_t mask = (1 << X265_DEPTH) - 1;

                int shift = abs(pic.bitDepth - X265_DEPTH);

                pixel* yPixel = m_picOrg[0];

                uint16_t* yShort = (uint16_t*)pic.planes[0];

                if (pic.bitDepth > X265_DEPTH)

                {

                    /* shift right and mask pixels to final size */

                    primitives.planecopy_sp(yShort, pic.stride[0] / sizeof(*yShort), yPixel, m_stride, width, height, shift, mask);

                }

                else /* Case for (pic.bitDepth <= X265_DEPTH) */

                {

                    /* shift left and mask pixels to final size */

                    primitives.planecopy_sp_shl(yShort, pic.stride[0] / sizeof(*yShort), yPixel, m_stride, width, height, shift, mask);

                }

                if (param.internalCsp != X265_CSP_I400)

                {

                    pixel* uPixel = m_picOrg[1];

                    pixel* vPixel = m_picOrg[2];

                    uint16_t* uShort = (uint16_t*)pic.planes[1];

                    uint16_t* vShort = (uint16_t*)pic.planes[2];

                    if (pic.bitDepth > X265_DEPTH)

                    {

                        primitives.planecopy_sp(uShort, pic.stride[1] / sizeof(*uShort), uPixel, m_strideC, width >> m_hChromaShift, height >> m_vChromaShift, shift, mask);

                        primitives.planecopy_sp(vShort, pic.stride[2] / sizeof(*vShort), vPixel, m_strideC, width >> m_hChromaShift, height >> m_vChromaShift, shift, mask);

                    }

                    else /* Case for (pic.bitDepth <= X265_DEPTH) */

                    {

                        primitives.planecopy_sp_shl(uShort, pic.stride[1] / sizeof(*uShort), uPixel, m_strideC, width >> m_hChromaShift, height >> m_vChromaShift, shift, mask);

                        primitives.planecopy_sp_shl(vShort, pic.stride[2] / sizeof(*vShort), vPixel, m_strideC, width >> m_hChromaShift, height >> m_vChromaShift, shift, mask);

                    }

                }

            }

#if ENABLE_ALPHA

            if (!isBase && param.bEnableAlpha)

            {

                /* defensive programming, mask off bits that are supposed to be zero */

                uint16_t mask = (1 << X265_DEPTH) - 1;

                int shift = abs(pic.bitDepth - X265_DEPTH);

                pixel* yPixel = m_picOrg[0];

                uint16_t* yShort = (uint16_t*)pic.planes[3];

                if (pic.bitDepth > X265_DEPTH)

                {

                    /* shift right and mask pixels to final size */

                    primitives.planecopy_sp(yShort, pic.stride[0] / sizeof(*yShort), yPixel, m_stride, width, height, shift, mask);

                }

                else /* Case for (pic.bitDepth <= X265_DEPTH) */

                {

                    /* shift left and mask pixels to final size */

                    primitives.planecopy_sp_shl(yShort, pic.stride[0] / sizeof(*yShort), yPixel, m_stride, width, height, shift, mask);

                }

                if (param.internalCsp != X265_CSP_I400)

                {

                    pixel* uPixel = m_picOrg[1];

                    pixel* vPixel = m_picOrg[2];

                    for (int r = 0; r < height >> m_vChromaShift; r++)

                    {

                        for (int c = 0; c < (width >> m_hChromaShift); c++)

                        {

                            uPixel[c] = ((1 << X265_DEPTH) >> 1);

                            vPixel[c] = ((1 << X265_DEPTH) >> 1);

                        }

                        uPixel += m_strideC;

                        vPixel += m_strideC;

                    }

                }

            }

#endif

        }

    }

    else

    {

        m_picOrg[0] = (pixel*)pic.planes[0];

        m_picOrg[1] = (pixel*)pic.planes[1];

        m_picOrg[2] = (pixel*)pic.planes[2];

    }

    pixel *Y = m_picOrg[0];

    pixel *U = m_picOrg[1];

    pixel *V = m_picOrg[2];

    pixel *yPic = m_picOrg[0];

    pixel *uPic = m_picOrg[1];

    pixel *vPic = m_picOrg[2];

    if(param.minLuma != 0 || param.maxLuma != PIXEL_MAX)

    {

        for (int r = 0; r < height; r++)

        {

            for (int c = 0; c < width; c++)

            {

                yPic[c] = X265_MIN(yPic[c], (pixel)param.maxLuma);

                yPic[c] = X265_MAX(yPic[c], (pixel)param.minLuma);

            }

            yPic += m_stride;

        }

    }

    yPic = m_picOrg[0];

    if (param.csvLogLevel >= 2 || param.maxCLL || param.maxFALL)

    {

        for (int r = 0; r < height; r++)

        {

            for (int c = 0; c < width; c++)

            {

                m_maxLumaLevel = X265_MAX(yPic[c], m_maxLumaLevel);

                m_minLumaLevel = X265_MIN(yPic[c], m_minLumaLevel);

                lumaSum += yPic[c];

            }

            yPic += m_stride;

        }

        m_avgLumaLevel = (double)lumaSum / (m_picHeight * m_picWidth);

    }

    if (param.csvLogLevel >= 2)

    {

        if (param.internalCsp != X265_CSP_I400)

        {

            for (int r = 0; r < height >> m_vChromaShift; r++)

            {

                for (int c = 0; c < width >> m_hChromaShift; c++)

                {

                    m_maxChromaULevel = X265_MAX(uPic[c], m_maxChromaULevel);

                    m_minChromaULevel = X265_MIN(uPic[c], m_minChromaULevel);

                    cbSum += uPic[c];

                    m_maxChromaVLevel = X265_MAX(vPic[c], m_maxChromaVLevel);

                    m_minChromaVLevel = X265_MIN(vPic[c], m_minChromaVLevel);

                    crSum += vPic[c];

                }

                uPic += m_strideC;

                vPic += m_strideC;

            }

            m_avgChromaULevel = (double)cbSum / ((height >> m_vChromaShift) * (width >> m_hChromaShift));

            m_avgChromaVLevel = (double)crSum / ((height >> m_vChromaShift) * (width >> m_hChromaShift));

        }

    }

#if HIGH_BIT_DEPTH

    bool calcHDRParams = !!param.minLuma || (param.maxLuma != PIXEL_MAX);

    /* Apply min/max luma bounds for HDR pixel manipulations */

    if (calcHDRParams)

    {

        X265_CHECK(pic.bitDepth == 10, "HDR stats can be applied/calculated only for 10bpp content");

        uint64_t sumLuma;

        m_maxLumaLevel = primitives.planeClipAndMax(Y, m_stride, width, height, &sumLuma, (pixel)param.minLuma, (pixel)param.maxLuma);

        m_avgLumaLevel = (double) sumLuma / (m_picHeight * m_picWidth);

    }

#else

    (void) param;

#endif

    /* extend the right edge if width was not multiple of the minimum CU size */

    for (int r = 0; r < height; r++)

    {

        for (int x = 0; x < padx; x++)

            Y[width + x] = Y[width - 1];

        Y += m_stride;

    }

    /* extend the bottom if height was not multiple of the minimum CU size */

    Y = m_picOrg[0] + (height - 1) * m_stride;

    for (int i = 1; i <= pady; i++)

        memcpy(Y + i * m_stride, Y, (width + padx) * sizeof(pixel));

    if (param.internalCsp != X265_CSP_I400)

    {

        for (int r = 0; r < height >> m_vChromaShift; r++)

        {

            for (int x = 0; x < padx >> m_hChromaShift; x++)

            {

                U[(width >> m_hChromaShift) + x] = U[(width >> m_hChromaShift) - 1];

                V[(width >> m_hChromaShift) + x] = V[(width >> m_hChromaShift) - 1];

            }

            U += m_strideC;

            V += m_strideC;

        }

        U = m_picOrg[1] + ((height >> m_vChromaShift) - 1) * m_strideC;

        V = m_picOrg[2] + ((height >> m_vChromaShift) - 1) * m_strideC;

        for (int j = 1; j <= pady >> m_vChromaShift; j++)

        {

            memcpy(U + j * m_strideC, U, ((width + padx) >> m_hChromaShift) * sizeof(pixel));

            memcpy(V + j * m_strideC, V, ((width + padx) >> m_hChromaShift) * sizeof(pixel));

        }

    }

}

namespace X265_NS {

template<uint32_t OUTPUT_BITDEPTH_DIV8>

static void md5_block(MD5Context& md5, const pixel* plane, uint32_t n)

{

    /* create a 64 byte buffer for packing pixel's into */

    uint8_t buf[64 / OUTPUT_BITDEPTH_DIV8][OUTPUT_BITDEPTH_DIV8];

    for (uint32_t i = 0; i < n; i++)

    {

        pixel pel = plane[i];

        /* perform bitdepth and endian conversion */

        for (uint32_t d = 0; d < OUTPUT_BITDEPTH_DIV8; d++)

            buf[i][d] = (uint8_t)(pel >> (d * 8));

    }

    MD5Update(&md5, (uint8_t*)buf, n * OUTPUT_BITDEPTH_DIV8);

}

Unexecuted instantiation: picyuv.cpp:void x265::md5_block<1u>(x265::MD5Context&, unsigned char const*, unsigned int)

Unexecuted instantiation: picyuv.cpp:void x265::md5_block<2u>(x265::MD5Context&, unsigned char const*, unsigned int)

/* Update md5 with all samples in plane in raster order, each sample

 * is adjusted to OUTBIT_BITDEPTH_DIV8 */

template<uint32_t OUTPUT_BITDEPTH_DIV8>

static void md5_plane(MD5Context& md5, const pixel* plane, uint32_t width, uint32_t height, intptr_t stride)

{

    /* N is the number of samples to process per md5 update.

     * All N samples must fit in buf */

    uint32_t N = 32;

    uint32_t width_modN = width % N;

    uint32_t width_less_modN = width - width_modN;

    for (uint32_t y = 0; y < height; y++)

    {

        /* convert pel's into uint32_t chars in little endian byte order.

         * NB, for 8bit data, data is truncated to 8bits. */

        for (uint32_t x = 0; x < width_less_modN; x += N)

            md5_block<OUTPUT_BITDEPTH_DIV8>(md5, &plane[y * stride + x], N);

        /* mop up any of the remaining line */

        md5_block<OUTPUT_BITDEPTH_DIV8>(md5, &plane[y * stride + width_less_modN], width_modN);

    }

}

Unexecuted instantiation: picyuv.cpp:void x265::md5_plane<1u>(x265::MD5Context&, unsigned char const*, unsigned int, unsigned int, long)

Unexecuted instantiation: picyuv.cpp:void x265::md5_plane<2u>(x265::MD5Context&, unsigned char const*, unsigned int, unsigned int, long)

void updateCRC(const pixel* plane, uint32_t& crcVal, uint32_t height, uint32_t width, intptr_t stride)

{

    uint32_t crcMsb;

    uint32_t bitVal;

    uint32_t bitIdx;

    for (uint32_t y = 0; y < height; y++)

    {

        for (uint32_t x = 0; x < width; x++)

        {

            // take CRC of first pictureData byte

            for (bitIdx = 0; bitIdx < 8; bitIdx++)

            {

                crcMsb = (crcVal >> 15) & 1;

                bitVal = (plane[y * stride + x] >> (7 - bitIdx)) & 1;

                crcVal = (((crcVal << 1) + bitVal) & 0xffff) ^ (crcMsb * 0x1021);

            }

#if _MSC_VER

#pragma warning(disable: 4127) // conditional expression is constant

#endif

            // take CRC of second pictureData byte if bit depth is greater than 8-bits

            if (X265_DEPTH > 8)

            {

                for (bitIdx = 0; bitIdx < 8; bitIdx++)

                {

                    crcMsb = (crcVal >> 15) & 1;

                    bitVal = (plane[y * stride + x] >> (15 - bitIdx)) & 1;

                    crcVal = (((crcVal << 1) + bitVal) & 0xffff) ^ (crcMsb * 0x1021);

                }

            }

        }

    }

}

void crcFinish(uint32_t& crcVal, uint8_t digest[16])

{

    uint32_t crcMsb;

    for (int bitIdx = 0; bitIdx < 16; bitIdx++)

    {

        crcMsb = (crcVal >> 15) & 1;

        crcVal = ((crcVal << 1) & 0xffff) ^ (crcMsb * 0x1021);

    }

    digest[0] = (crcVal >> 8)  & 0xff;

    digest[1] =  crcVal        & 0xff;

}

void updateChecksum(const pixel* plane, uint32_t& checksumVal, uint32_t height, uint32_t width, intptr_t stride, int row, uint32_t cuHeight)

{

    uint8_t xor_mask;

    for (uint32_t y = row * cuHeight; y < ((row * cuHeight) + height); y++)

    {

        for (uint32_t x = 0; x < width; x++)

        {

            xor_mask = (uint8_t)((x & 0xff) ^ (y & 0xff) ^ (x >> 8) ^ (y >> 8));

            checksumVal = (checksumVal + ((plane[y * stride + x] & 0xff) ^ xor_mask)) & 0xffffffff;

            if (X265_DEPTH > 8)

                checksumVal = (checksumVal + ((plane[y * stride + x] >> 7 >> 1) ^ xor_mask)) & 0xffffffff;

        }

    }

}

void checksumFinish(uint32_t checksum, uint8_t digest[16])

{

    digest[0] = (checksum >> 24) & 0xff;

    digest[1] = (checksum >> 16) & 0xff;

    digest[2] = (checksum >> 8)  & 0xff;

    digest[3] =  checksum        & 0xff;

}

void updateMD5Plane(MD5Context& md5, const pixel* plane, uint32_t width, uint32_t height, intptr_t stride)

{

    /* choose an md5_plane packing function based on the system bitdepth */

    typedef void(*MD5PlaneFunc)(MD5Context&, const pixel*, uint32_t, uint32_t, intptr_t);

    MD5PlaneFunc md5_plane_func;

    md5_plane_func = X265_DEPTH <= 8 ? (MD5PlaneFunc)md5_plane<1> : (MD5PlaneFunc)md5_plane<2>;

    md5_plane_func(md5, plane, width, height, stride);

}

}