forked from mirror/libbpg
427 lines
16 KiB
C++
427 lines
16 KiB
C++
/*****************************************************************************
|
|
* Copyright (C) 2015 x265 project
|
|
*
|
|
* Authors: Steve Borho <steve@borho.org>
|
|
*
|
|
* 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;
|
|
}
|
|
|
|
bool PicYuv::create(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 + g_maxCUSize - 1) / g_maxCUSize;
|
|
uint32_t numCuInHeight = (m_picHeight + g_maxCUSize - 1) / g_maxCUSize;
|
|
|
|
m_lumaMarginX = g_maxCUSize + 32; // search margin and 8-tap filter half-length, padded for 32-byte alignment
|
|
m_lumaMarginY = g_maxCUSize + 16; // margin for 8-tap filter and infinite padding
|
|
m_stride = (numCuInWidth * g_maxCUSize) + (m_lumaMarginX << 1);
|
|
|
|
m_chromaMarginX = m_lumaMarginX; // keep 16-byte alignment for chroma CTUs
|
|
m_chromaMarginY = m_lumaMarginY >> m_vChromaShift;
|
|
|
|
m_strideC = ((numCuInWidth * g_maxCUSize) >> m_hChromaShift) + (m_chromaMarginX * 2);
|
|
int maxHeight = numCuInHeight * g_maxCUSize;
|
|
|
|
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 (m_picCsp != X265_CSP_I400) {
|
|
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;
|
|
}
|
|
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
|
|
/* 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 << (g_unitSizeDepth * 2);
|
|
CHECKED_MALLOC(m_cuOffsetY, intptr_t, sps.numCuInWidth * sps.numCuInHeight);
|
|
if (m_picCsp != X265_CSP_I400) {
|
|
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 * g_maxCUSize + cuCol * g_maxCUSize;
|
|
if (m_picCsp != X265_CSP_I400) {
|
|
m_cuOffsetC[cuRow * sps.numCuInWidth + cuCol] = m_strideC * cuRow * (g_maxCUSize >> m_vChromaShift) + cuCol * (g_maxCUSize >> m_hChromaShift);
|
|
}
|
|
}
|
|
}
|
|
|
|
CHECKED_MALLOC(m_buOffsetY, intptr_t, (size_t)numPartitions);
|
|
if (m_picCsp != X265_CSP_I400) {
|
|
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;
|
|
if (m_picCsp != X265_CSP_I400) {
|
|
m_buOffsetC[idx] = m_strideC * (y >> m_vChromaShift) + (x >> m_hChromaShift);
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
/* 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++;
|
|
|
|
X265_CHECK(pic.bitDepth >= 8, "pic.bitDepth check failure");
|
|
|
|
if (pic.bitDepth == 8)
|
|
{
|
|
#if (X265_DEPTH > 8)
|
|
{
|
|
pixel *yPixel = m_picOrg[0];
|
|
pixel *uPixel = m_picOrg[1];
|
|
pixel *vPixel = m_picOrg[2];
|
|
|
|
uint8_t *yChar = (uint8_t*)pic.planes[0];
|
|
uint8_t *uChar = (uint8_t*)pic.planes[1];
|
|
uint8_t *vChar = (uint8_t*)pic.planes[2];
|
|
int shift = (X265_DEPTH - 8);
|
|
|
|
primitives.planecopy_cp(yChar, pic.stride[0] / sizeof(*yChar), yPixel, m_stride, width, height, shift);
|
|
if (m_picCsp != X265_CSP_I400) {
|
|
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
|
|
{
|
|
pixel *yPixel = m_picOrg[0];
|
|
pixel *uPixel = m_picOrg[1];
|
|
pixel *vPixel = m_picOrg[2];
|
|
|
|
uint8_t *yChar = (uint8_t*)pic.planes[0];
|
|
uint8_t *uChar = (uint8_t*)pic.planes[1];
|
|
uint8_t *vChar = (uint8_t*)pic.planes[2];
|
|
|
|
for (int r = 0; r < height; r++)
|
|
{
|
|
memcpy(yPixel, yChar, width * sizeof(pixel));
|
|
|
|
yPixel += m_stride;
|
|
yChar += pic.stride[0] / sizeof(*yChar);
|
|
}
|
|
|
|
if (m_picCsp != X265_CSP_I400) {
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
#endif /* (X265_DEPTH > 8) */
|
|
}
|
|
else /* pic.bitDepth > 8 */
|
|
{
|
|
/* 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];
|
|
pixel *uPixel = m_picOrg[1];
|
|
pixel *vPixel = m_picOrg[2];
|
|
|
|
uint16_t *yShort = (uint16_t*)pic.planes[0];
|
|
uint16_t *uShort = (uint16_t*)pic.planes[1];
|
|
uint16_t *vShort = (uint16_t*)pic.planes[2];
|
|
|
|
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);
|
|
if (m_picCsp != X265_CSP_I400) {
|
|
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) */
|
|
{
|
|
/* 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 (m_picCsp != X265_CSP_I400) {
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* extend the right edge if width was not multiple of the minimum CU size */
|
|
|
|
pixel *Y = m_picOrg[0];
|
|
pixel *U = m_picOrg[1];
|
|
pixel *V = m_picOrg[2];
|
|
|
|
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);
|
|
|
|
for (int r = 0; r < height; r++)
|
|
{
|
|
for (int x = 0; x < padx; x++)
|
|
Y[width + x] = Y[width - 1];
|
|
|
|
Y += m_stride;
|
|
}
|
|
|
|
if (m_picCsp != 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;
|
|
}
|
|
}
|
|
|
|
/* 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 (m_picCsp != X265_CSP_I400) {
|
|
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);
|
|
}
|
|
|
|
/* 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);
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|