Void printBlockToStream( std::ostream &ss, const Char *pLinePrefix, TComYuv &src, const UInt numSubBlocksAcross, const UInt numSubBlocksUp, const UInt defWidth )
{
const UInt numValidComp=src.getNumberValidComponents();
for (UInt ch=0; ch<numValidComp ; ch++)
{
const ComponentID compID = ComponentID(ch);
const UInt width = src.getWidth(compID);
const UInt height = src.getHeight(compID);
const UInt stride = src.getStride(compID);
const Pel* blkSrc = src.getAddr(compID);
const UInt subBlockWidth=width/numSubBlocksAcross;
const UInt subBlockHeight=height/numSubBlocksUp;
ss << pLinePrefix << " compID: " << compID << "\n";
for (UInt y=0; y<height; y++)
{
if ((y%subBlockHeight)==0 && y!=0)
ss << pLinePrefix << '\n';
ss << pLinePrefix;
for (UInt x=0; x<width; x++)
{
if ((x%subBlockWidth)==0 && x!=0)
ss << std::setw(defWidth+2) << "";
ss << std::setw(defWidth) << blkSrc[y*stride + x] << ' ';
}
ss << '\n';
}
ss << pLinePrefix << " --- \n";
}
}
//index== 0 above 1 left 2 above and left 3 above and right
Int GolombCode_Predict_SingleNeighbor(TComYuv *pcResiYuv, TComTU& rTu, const ComponentID compID, UInt uiCUHandleAddr, UInt uiAIndex, TCoeff* pcCoeff)
{
const Bool bIsLuma = isLuma(compID);
const TComRectangle &rect = rTu.getRect(compID);
TComDataCU *pcCU = rTu.getCU();
UInt uiCUAddr = pcCU->getCtuRsAddr();
//if ((int)uiCUHandleAddr < 0) return -1;
TComPicYuv *pcPicYuvResi = pcCU->getPic()->getPicYuvResi();
if (pcPicYuvResi == NULL) return -1;
const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
// const UInt uiZOrder = pcCU->getZorderIdxInCU() +uiAbsPartIdx;
const UInt uiTrDepth = rTu.GetTransformDepthRelAdj(compID);
const UInt uiFullDepth = rTu.GetTransformDepthTotal();
const UInt uiLog2TrSize = rTu.GetLog2LumaTrSize();
const ChromaFormat chFmt = pcCU->getPic()->getChromaFormat();
const UInt uiWidth = rect.width;
const UInt uiHeight = rect.height;
const UInt uiStride = pcResiYuv->getStride(compID);
UInt uiAddr = pcCU->getCtuRsAddr();
TComYuv *pcTemp;
pcTemp = new TComYuv;
UInt uiSrc1Stride = pcPicYuvResi->getStride(compID);
UInt CUPelX, CUPelY;
CUPelX = (uiCUHandleAddr % pcCU->getPic()->getFrameWidthInCtus()) * g_uiMaxCUWidth;
CUPelY = (uiCUHandleAddr / pcCU->getPic()->getFrameWidthInCtus()) * g_uiMaxCUHeight;
CUPelX = CUPelX + g_auiRasterToPelX[g_auiZscanToRaster[uiAbsPartIdx]];
CUPelY = CUPelY + g_auiRasterToPelY[g_auiZscanToRaster[uiAbsPartIdx]];
//for(int m=0;m<256;m++) cout<<g_auiZscanToRaster[m] <<" ";cout<<endl;
//for(int m=0;m<256;m++) cout<<g_auiRasterToPelX[m] <<" ";cout<<endl;
//for(int m=0;m<256;m++) cout<<g_auiRasterToPelY[m] <<" ";cout<<endl;
//Pel *pSrc1 = pcPicYuvResi->getAddr(compID) +CUPelY * uiSrc1Stride + CUPelX;
Pel *pSrc1 = pcPicYuvResi->getAddr(compID, uiCUHandleAddr, uiAbsPartIdx + pcCU->getZorderIdxInCtu());
/* if( compID != COMPONENT_Y)
{
pSrc1 = pcPicYuvResi->getAddr(COMPONENT_Y, uiCUHandleAddr, uiAbsPartIdx + pcCU->getZorderIdxInCU());
}*/
pcTemp->create(uiWidth, uiHeight, chFmt);
// pcTemp->copyFromPicComponent(compID,pcPicYuvResi,uiCUHandleAddr, pcCU->getZorderIdxInCU()+uiAbsPartIdx);
UInt uiTempStride = pcTemp->getStride(compID);
Pel *pTemp = pcTemp->getAddr(compID);
for (Int y = 0; y < uiHeight; y++)
{
for (Int x = 0; x < uiWidth; x++)
{
pTemp[x] = pSrc1[x];
}
pTemp += uiTempStride;
pSrc1 += uiSrc1Stride;
}
int srclx = 0; int srcly = 0; int srclv = 0;
int srchasleft = 1;
Pel srcpel;
int srclist[3][64 * 64];
int srcindex = 0;
memset(srclist, -1, 3 * 64 * 64 * sizeof(int));
int cursrclistindex = 0;
Pel* piSrc = pcTemp->getAddr(compID);
//Pel* piSrc = pcTemp->getAddr(compID, uiAbsPartIdx);
Pel* pSrc = piSrc;
//found the source list
while (srchasleft) {
int ndis = 1000;
int nx = -1; int ny = -1;
pSrc = piSrc;
for (UInt y = 0; y < uiHeight; y++) {
for (UInt x = 0; x<uiWidth; x++) {
assert(pSrc[x] >-256 && pSrc[x] < 256);
if (pSrc[x] != 0) {
int dis = 0;
dis += getG0Bits((x - srclx));
dis += getG0Bits((y - srcly));
if (dis < ndis) {
nx = x;
ny = y;
ndis = dis;
}
}
}
pSrc += uiTempStride;
}
if (nx != -1 && ny != -1) {
srcpel = *(piSrc + ny*uiTempStride + nx);
srclx = nx; srcly = ny; srclv = srcpel;
srclist[0][srcindex] = srclx;
srclist[1][srcindex] = srcly;
srclist[2][srcindex] = srcpel;
srcindex++;
*(piSrc + ny*uiTempStride + nx) = 0;
}
else {
srchasleft = 0;
}
}
if (srcindex == 0) {
pcTemp->destroy();
delete pcTemp;
pcTemp = NULL;
return -1;
}
////
TComPicYuv *pcPicOrg = pcCU->getPic()->getPicYuvOrg();
Pel* piOrg = pcPicOrg->getAddr(compID, pcCU->getCtuRsAddr(), pcCU->getZorderIdxInCtu() + uiAbsPartIdx);
const UInt uiOrgStride = pcPicOrg->getStride(compID);
////
Pel* piResi = pcResiYuv->getAddr(compID, uiAbsPartIdx);
Pel* pResi = piResi;
int dstindex = 0;
int indexlist[64 * 64][5];
memset(indexlist, 0, 5 * 64 * 64 * sizeof(int));
int contz = 0;
int contnz = 0;
int cs = 0;
int bits = 0;
// int temp;
int lx = 0; int ly = 0; int lv = 0;
int hasleft = 1;
Pel pel;
while (hasleft) {
//found the least distance point
int ndis = 1000;
int nx = -1; int ny = -1;
pResi = piResi;
for (UInt y = 0; y < uiHeight; y++) {
for (UInt x = 0; x < uiWidth; x++) {
if (pResi[x] != 0) {
int dis = 0;
dis += getG0Bits((x - lx));
dis += getG0Bits((y - ly));
if (dis < ndis) {
nx = x;
ny = y;
ndis = dis;
}
}
}
pResi += uiStride;
}
if (nx != -1 && ny != -1) {
pel = *(piResi + ny*uiStride + nx);
int srcdis = 1024 * 4;
int srccur = -1;
for (UInt s = 0; s < srcindex; s++) {
int curdis = 0;
curdis += getG0Bits((nx - srclist[0][s]));
curdis += getG0Bits((ny - srclist[1][s]));
// curdis += getG0Bits( (pel-srclist[2][s]));// getG0Bits can handle -512 && 512
if (curdis < srcdis) {
srccur = s;
srcdis = curdis;
}
}
if (srccur != -1) {
indexlist[dstindex][0] = nx - srclist[0][srccur];
indexlist[dstindex][1] = ny - srclist[1][srccur];
assert(pel != 0);
indexlist[dstindex][4] = srccur;
dstindex++;
cursrclistindex = srccur;
}
else {
assert(true);
}
lx = nx; ly = ny; lv = pel;
*(piResi + ny*uiStride + nx) = 0;
}
else {
hasleft = 0;
}
}
pcTemp->destroy();
delete pcTemp;
pcTemp = NULL;
if (dstindex == 0) {
assert(bits == 0);
return bits;
}
qsort(indexlist, dstindex, sizeof(int)* 5, compare5);
for (UInt x = dstindex - 1; x > 0; x--) {
indexlist[x][4] -= indexlist[x - 1][4];
}
//bits += getG0Bits( (indexlist[0][0]));
//bits += getG0Bits( (indexlist[0][1]));
int maxlength = 0;
UInt truebits = 0;
bool vlcf[3] = { false, false, false };// dx & dy residual srcindex
int z01 = 0;
for (UInt x = 1; x < dstindex; x++) {
if (indexlist[x][0] == indexlist[x - 1][0] && indexlist[x][1] == indexlist[x - 1][1]) {
maxlength++;
}
else {
bits += getG0Bits((maxlength));
bits += getG0Bits((indexlist[x - 1][0]));
bits += getG0Bits((indexlist[x - 1][1]));
maxlength = 0;
}
if (indexlist[x][0] == 0 && indexlist[x][1] == 0) z01++;
}
bits += getG0Bits((maxlength));
bits += getG0Bits((indexlist[dstindex - 1][0]));
bits += getG0Bits((indexlist[dstindex - 1][1]));
UInt sbits = 0;
for (UInt x = 0; x < dstindex; x++) {
sbits += getG0Bits((indexlist[x][0]));
sbits += getG0Bits((indexlist[x][1]));
}
// printf("gain %6d position before %6d after %6d\n",sbits-bits,sbits,bits);
if (sbits < bits) {
vlcf[0] = true;
bits = sbits;
}
sbits = bits + 1;
//bits += getG0Bits( PTable(compID,indexlist[0][2]));
{
maxlength = 0;
for (UInt x = 1; x < dstindex; x++) {
if (indexlist[x][2] == indexlist[x - 1][2] && indexlist[x][3] == indexlist[x - 1][3]) {
maxlength++;
}
else {
bits += getG0Bits((maxlength));
bits += getG0Bits(indexlist[x - 1][3]);
bits += getG0Bits(indexlist[x - 1][2]);
maxlength = 0;
}
}
bits += getG0Bits((maxlength));
bits += getG0Bits(indexlist[dstindex - 1][3]);
bits += getG0Bits((indexlist[dstindex - 1][2]));
}
UInt vbits = 0;
sbits = bits - sbits;
for (UInt x = 0; x < dstindex; x++) {
{
vbits += getG0Bits(indexlist[x][2]);
vbits += getG0Bits(indexlist[x][3]);
}
}
// printf("gain %6d delta resi before %6d after %6d\n",vbits-sbits,vbits,sbits);
if (vbits < sbits) {
vlcf[1] = true;
bits = bits - sbits + vbits;
}
sbits = bits + 1;
//bits += getG0Bits( (indexlist[0][3]));
Int srcPosIndex;
srcPosIndex = 4;
maxlength = 0;
for (UInt x = 1; x < dstindex; x++) {
if (indexlist[x][srcPosIndex] == indexlist[x - 1][srcPosIndex]) {
maxlength++;
}
else {
bits += getG0Bits((maxlength));
bits += getG0Bits((indexlist[x - 1][srcPosIndex]));
maxlength = 0;
}
}
bits += getG0Bits((maxlength));
bits += getG0Bits((indexlist[dstindex - 1][srcPosIndex]));
sbits = bits - sbits;
vbits = 0;
for (UInt x = 0; x < dstindex; x++) {
vbits += getG0Bits((indexlist[x][srcPosIndex]));
}
// printf("gain %6d delta index before %6d after %6d\n",vbits-sbits,vbits,sbits);
if (vbits < sbits) {
vlcf[2] = true;
bits = bits - sbits + vbits;
}
//#if INTRA_PR_DEBUG
// if( pcCU->getAddr()==INTRA_PR_CUNUM )
// printf("position distance zero %6d of %6d total bits %6d\n",z01,dstindex,bits+1);
//#endif
truebits = 0;
ExpGolombEncode(uiAIndex, pcCoeff, truebits);
//--------------encode srcindex
if (vlcf[2]) {
ExpGolombEncode(0, pcCoeff, truebits);
for (UInt x = 0; x < dstindex; x++) {
//cout<<" "<<indexlist[x][3] ;
ExpGolombEncode((indexlist[x][srcPosIndex]), pcCoeff, truebits);
}
}
else{
ExpGolombEncode(1, pcCoeff, truebits);
maxlength = 0;
for (UInt x = 1; x<dstindex; x++) {
if (indexlist[x][srcPosIndex] == indexlist[x - 1][srcPosIndex]) {
maxlength++;
}
else {
ExpGolombEncode((maxlength), pcCoeff, truebits);
ExpGolombEncode((indexlist[x - 1][srcPosIndex]), pcCoeff, truebits);
maxlength = 0;
}
}
assert(maxlength>-1);
ExpGolombEncode((maxlength), pcCoeff, truebits);
ExpGolombEncode((indexlist[dstindex - 1][srcPosIndex]), pcCoeff, truebits);
}
ExpGolombEncode(-1, pcCoeff, truebits);
//---------------encode residual
if (vlcf[1]) {
ExpGolombEncode(0, pcCoeff, truebits);
for (UInt x = 0; x < dstindex; x++) {
{
ExpGolombEncode(indexlist[x][2], pcCoeff, truebits);
// if( !bNoResidual)
// ExpGolombEncode( indexlist[x][3],pcCoeff,truebits);
}
}
}
else{
ExpGolombEncode(1, pcCoeff, truebits);
//ExpGolombEncode( (indexlist[0][2]),pcCoeff,truebits);
maxlength = 0;
{
for (UInt x = 1; x < dstindex; x++) {
if (indexlist[x][2] == indexlist[x - 1][2] && indexlist[x][3] == indexlist[x - 1][3]) {
maxlength++;
}
else {
ExpGolombEncode((maxlength), pcCoeff, truebits);
//assert( (maxlength)>=0);
ExpGolombEncode(indexlist[x - 1][2], pcCoeff, truebits);
// if( !bNoResidual)
// ExpGolombEncode( indexlist[x-1][3],pcCoeff,truebits);
maxlength = 0;
}
}
ExpGolombEncode((maxlength), pcCoeff, truebits);
ExpGolombEncode(indexlist[dstindex - 1][2], pcCoeff, truebits);
//if( !bNoResidual)
// ExpGolombEncode( indexlist[dstindex-1][3] , pcCoeff, truebits);
}
}
//--------------encode dx and dy -----------
if (vlcf[0]) {
ExpGolombEncode(0, pcCoeff, truebits);
for (UInt x = 0; x < dstindex; x++) {
ExpGolombEncode((indexlist[x][0]), pcCoeff, truebits);
ExpGolombEncode((indexlist[x][1]), pcCoeff, truebits);
}
}
else{
ExpGolombEncode(1, pcCoeff, truebits);
//ExpGolombEncode( (indexlist[0][0]),pcCoeff,truebits);
//ExpGolombEncode( (indexlist[0][1]),pcCoeff,truebits);
maxlength = 0;
for (UInt x = 1; x < dstindex; x++) {
if (indexlist[x][0] == indexlist[x - 1][0] && indexlist[x][1] == indexlist[x - 1][1]) {
maxlength++;
}
else {
ExpGolombEncode((maxlength), pcCoeff, truebits);
ExpGolombEncode((indexlist[x - 1][0]), pcCoeff, truebits);
ExpGolombEncode((indexlist[x - 1][1]), pcCoeff, truebits);
maxlength = 0;
}
}
ExpGolombEncode((maxlength), pcCoeff, truebits);
ExpGolombEncode((indexlist[dstindex - 1][0]), pcCoeff, truebits);
ExpGolombEncode((indexlist[dstindex - 1][1]), pcCoeff, truebits);
}
return truebits;/* bits +1*/;
}
UInt PositionCode_Predict(TComYuv *pcResiYuv, TComTU& rTu, const ComponentID compID, TCoeff* pcCoeff /*,Bool bMV,bool bNoResidual*/)
{
if (!rTu.ProcessComponentSection(compID)) return -1;
TComDataCU *pcCU = rTu.getCU();
UInt uiCUAddr = pcCU->getCtuRsAddr();
UInt uiFrameWidthInCU = pcCU->getPic()->getFrameWidthInCtus();
UInt uiCUAboveAddr = uiCUAddr - uiFrameWidthInCU;
UInt uiCULeftAddr = uiCUAddr - 1;
UInt uiCUAboveLeftAddr = uiCUAddr - 1 - uiFrameWidthInCU;
UInt uiCUAboveRightAddr = uiCUAddr + 1 - uiFrameWidthInCU;
UInt uiCUArray[4] = { uiCULeftAddr, uiCUAboveAddr, uiCUAboveLeftAddr, uiCUAboveRightAddr };
UInt uiCUHandleAddr;
Int curindex, minibits, temp/*,truebits*/;
TCoeff pcCoeffTemp[MAX_BUFFER];
TComYuv *pcComYuv = new TComYuv;
const TComRectangle &rect = rTu.getRect(compID);
UInt uiTempStride, uiSrcStride;
uiSrcStride = pcResiYuv->getStride(compID);
UInt uiHeight = pcResiYuv->getHeight(compID);
UInt uiWidth = pcResiYuv->getWidth(compID);
pcComYuv->create(uiWidth, uiHeight, pcCU->getPic()->getChromaFormat());
uiTempStride = pcComYuv->getStride(compID);
//memset(pcCoeffTemp,0,sizeof(TCoeff)*MAX_BUFFER);
minibits = MAX_INT;
for (UInt index = 0; index < 4; index++) {
uiCUHandleAddr = uiCUArray[index];
if ((int)uiCUHandleAddr < 0) continue;
pcComYuv->clear();
for (UInt y = 0; y < uiHeight; y++) {
for (UInt x = 0; x<uiWidth; x++) {
*(pcComYuv->getAddr(compID) + y*uiTempStride + x) = *(pcResiYuv->getAddr(compID) + y*uiSrcStride + x);
}
}
//pcResiYuv->copyToPartComponent ( compID, pcComYuv, 0);
memset(pcCoeffTemp, 0, sizeof(TCoeff)*MAX_BUFFER);
//_CrtMemState s1,s2,s3;
//_CrtMemCheckpoint( &s1 );
temp = GolombCode_Predict_SingleNeighbor(pcComYuv, rTu, compID, uiCUHandleAddr, index, pcCoeffTemp);
if (temp> -1 && temp < minibits) {
curindex = index;//uiCUHandleAddr;
minibits = temp;
//truebits = minibits / GOLOMB_EXP_BUFFER + ( (minibits % GOLOMB_EXP_BUFFER==0) ? 0:1 );
memcpy(pcCoeff, pcCoeffTemp, sizeof(TCoeff)*rect.height*rect.width/* truebits*/);
}
//_CrtMemCheckpoint( &s2 );
//if ( _CrtMemDifference( &s3, &s1, &s2) )
//{
// _CrtMemDumpStatistics( &s3 );
// _CrtDumpMemoryLeaks();
//}
}
pcComYuv->destroy();
delete pcComYuv;
pcComYuv = NULL;
if (minibits != MAX_INT) {
assert(uiCUArray[curindex] >= 0);
return minibits;
}
return MAX_UINT;
}
