Alien-FreeImage
view release on metacpan or search on metacpan
src/Source/LibJXR/image/decode/strInvTransform.c view on Meta::CPAN
}
if (bottom || bHoriTileBoundary)
{
for (j = (left ? 0 : -192); j < (right ? -64 : 64); j += 64)
{
if (!bVertTileBoundary || j != -64) {
strPost4x4Stage1_alternate(p0 + 16 + j, 0);
strPost4x4Stage1_alternate(p0 + 32 + j, 0);
p = p0 + 48 + j;
strPost4_alternate(p + 15, p + 14, p + 74, p + 75);
strPost4_alternate(p + 13, p + 12, p + 72, p + 73);
p = NULL;
}
}
}
if (!top && !bottom && !bHoriTileBoundary)
{
for (j = (left ? 0 : -192); j < (right ? -64 : 64); j += 64)
{
if (!bVertTileBoundary || j != -64) {
strPost4x4Stage1_alternate(p0 + 16 + j, 0);
strPost4x4Stage1_alternate(p0 + 32 + j, 0);
strPost4x4Stage1Split_alternate(p0 + 48 + j, p1 + j, 0);
strPost4x4Stage1_alternate(p1 + j, 0);
}
}
}
}
if(pSC->WMII.cPostProcStrength > 0 && (!topORleft))
postProcBlock(pSC->pPostProcInfo, p0, p1, mbX, i, qp[i]); // destairing and first stage deblocking
}
//================================================================
// 420_UV
for (i = 0; i < (YUV_420 == cfColorFormat? 2U : 0U) && tScale < 16; ++i)
{
PixelI* const p0 = pSC->p0MBbuffer[1 + i];//(0 == i ? pSC->pU0 : pSC->pV0);
PixelI* const p1 = pSC->p1MBbuffer[1 + i];//(0 == i ? pSC->pU1 : pSC->pV1);
//========================================
// second level inverse transform (420_UV)
if (!bottomORright)
{
if (!pSC->m_param.bScaledArith) {
strDCT2x2dn(p1, p1 + 32, p1 + 16, p1 + 48);
}
else {
strDCT2x2dnDec(p1, p1 + 32, p1 + 16, p1 + 48);
}
}
//========================================
// second level inverse overlap (420_UV)
if (OL_TWO == olOverlap)
{
if ((leftAdjacentColumn || bOneMBRightVertTB) && (top || bHoriTileBoundary))
COMPUTE_CORNER_PRED_DIFF(p1 - 64 + 0, *(p1 - 64 + 32));
if ((rightAdjacentColumn || bOneMBLeftVertTB) && (top || bHoriTileBoundary))
iPredBefore[i][0] = *(p1 + 0);
if ((right || bVertTileBoundary) && (top || bHoriTileBoundary))
COMPUTE_CORNER_PRED_DIFF(p1 - 64 + 32, iPredBefore[i][0]);
if ((leftAdjacentColumn || bOneMBRightVertTB) && (bottom || bHoriTileBoundary))
COMPUTE_CORNER_PRED_DIFF(p0 - 64 + 16, *(p0 - 64 + 48));
if ((rightAdjacentColumn || bOneMBLeftVertTB) && (bottom || bHoriTileBoundary))
iPredBefore[i][1] = *(p0 + 16);
if ((right || bVertTileBoundary) && (bottom || bHoriTileBoundary))
COMPUTE_CORNER_PRED_DIFF(p0 - 64 + 48, iPredBefore[i][1]);
if ((leftORright || bVertTileBoundary) && !topORbottom && !bHoriTileBoundary)
{
if (left || bVertTileBoundary)
strPost2_alternate(p0 + 0 + 16, p1 + 0);
if (right || bVertTileBoundary)
strPost2_alternate(p0 + -32 + 16, p1 + -32);
}
if (!leftORright)
{
if ((topORbottom || bHoriTileBoundary) && !bVertTileBoundary)
{
if (top || bHoriTileBoundary)
strPost2_alternate(p1 - 32, p1);
if (bottom || bHoriTileBoundary)
strPost2_alternate(p0 + 16 - 32, p0 + 16);
}
else if (!topORbottom && !bHoriTileBoundary && !bVertTileBoundary) {
strPost2x2_alternate(p0 - 16, p0 + 16, p1 - 32, p1);
}
}
if ((leftAdjacentColumn || bOneMBRightVertTB) && (top || bHoriTileBoundary))
COMPUTE_CORNER_PRED_ADD(p1 - 64 + 0, *(p1 - 64 + 32));
if ((rightAdjacentColumn || bOneMBLeftVertTB) && (top || bHoriTileBoundary))
iPredAfter[i][0] = *(p1 + 0);
if ((right || bVertTileBoundary) && (top || bHoriTileBoundary))
COMPUTE_CORNER_PRED_ADD(p1 - 64 + 32, iPredAfter[i][0]);
if ((leftAdjacentColumn || bOneMBRightVertTB) && (bottom || bHoriTileBoundary))
COMPUTE_CORNER_PRED_ADD(p0 - 64 + 16, *(p0 - 64 + 48));
if ((rightAdjacentColumn || bOneMBLeftVertTB) && (bottom || bHoriTileBoundary))
iPredAfter[i][1] = *(p0 + 16);
if ((right || bVertTileBoundary) && (bottom || bHoriTileBoundary))
COMPUTE_CORNER_PRED_ADD(p0 - 64 + 48, iPredAfter[i][1]);
}
//========================================
// first level inverse transform (420_UV)
if(tScale >= 4) // bypass first level transform for 4:1 and smaller thumbnail
continue;
if (!top)
{
// In order to allow correction operation of corner chroma overlap operators (fixed)
// processing of left most MB column must be delayed by one MB
// Thus left MB not processed until leftAdjacentColumn = 1
for (j = ((left) ? 48 : ((leftAdjacentColumn || bOneMBRightVertTB) ? -48 : -16)); j < ((right || bVertTileBoundary) ? 16 : 48); j += 32)
{
strIDCT4x4Stage1(p0 + j);
}
}
if (!bottom)
{
// In order to allow correction operation of corner chroma overlap operators (fixed)
// processing of left most MB column must be delayed by one MB
// Thus left MB not processed until leftAdjacentColumn = 1
for (j = ((left) ? 32 : ((leftAdjacentColumn || bOneMBRightVertTB) ? -64 : -32)); j < ((right || bVertTileBoundary) ? 0 : 32); j += 32)
{
strIDCT4x4Stage1(p1 + j);
}
}
//========================================
// first level inverse overlap (420_UV)
if (OL_NONE != olOverlap)
{
/* Corner operations */
/* Change because the top-left corner ICT will not have happened until leftAdjacentColumn ==1 */
if ((top || bHoriTileBoundary) && (leftAdjacentColumn || bOneMBRightVertTB))
strPost4_alternate(p1 - 64 + 0, p1 - 64 + 1, p1 - 64 + 2, p1 - 64 + 3);
if ((top || bHoriTileBoundary) && (right || bVertTileBoundary))
strPost4_alternate(p1 - 27, p1 - 28, p1 - 25, p1 - 26);
/* Change because the bottom-left corner ICT will not have happened until leftAdjacentColumn ==1 */
if ((bottom || bHoriTileBoundary) && (leftAdjacentColumn || bOneMBRightVertTB))
strPost4_alternate(p0 - 64 + 16 + 10, p0 - 64 + 16 + 11, p0 - 64 + 16 + 8, p0 - 64 + 16 + 9);
if ((bottom || bHoriTileBoundary) && (right || bVertTileBoundary))
strPost4_alternate(p0 - 1, p0 - 2, p0 - 3, p0 - 4);
if(!left && !top)
{
/* Change because the vertical 1-D overlap operations of the left edge pixels cannot be performed until leftAdjacentColumn ==1 */
if (leftAdjacentColumn || bOneMBRightVertTB)
{
if (!bottom && !bHoriTileBoundary)
{
strPost4_alternate(p0 - 64 + 26, p0 - 64 + 24, p1 - 64 + 0, p1 - 64 + 2);
strPost4_alternate(p0 - 64 + 27, p0 - 64 + 25, p1 - 64 + 1, p1 - 64 + 3);
}
strPost4_alternate(p0 - 64 + 10, p0 - 64 + 8, p0 - 64 + 16, p0 - 64 + 18);
strPost4_alternate(p0 - 64 + 11, p0 - 64 + 9, p0 - 64 + 17, p0 - 64 + 19);
}
if (bottom || bHoriTileBoundary)
{
src/Source/LibJXR/image/decode/strInvTransform.c view on Meta::CPAN
}
else
{
strPost4x4Stage1_alternate(p0 - 32, 32);
}
strPost4x4Stage1_alternate(p0 - 64, 32);
}
if (top || bHoriTileBoundary)
{
if (!left)
{
p = p1 + -64 + 4;
strPost4_alternate(p + 1, p + 0, p + 28, p + 29);
strPost4_alternate(p + 3, p + 2, p + 30, p + 31);
p = NULL;
}
if (!left && !right && !bVertTileBoundary)
{
p = p1 + -32 + 4;
strPost4_alternate(p + 1, p + 0, p + 28, p + 29);
strPost4_alternate(p + 3, p + 2, p + 30, p + 31);
p = NULL;
}
}
}
}
//================================================================
// 422_UV
for (i = 0; i < (YUV_422 == cfColorFormat? 2U : 0U) && tScale < 16; ++i)
{
PixelI* const p0 = pSC->p0MBbuffer[1 + i];//(0 == i ? pSC->pU0 : pSC->pV0);
PixelI* const p1 = pSC->p1MBbuffer[1 + i];//(0 == i ? pSC->pU1 : pSC->pV1);
//========================================
// second level inverse transform (422_UV)
if ((!bottomORright) && pSC->m_Dparam->cThumbnailScale < 16)
{
// 1D lossless HT
p1[0] -= ((p1[32] + 1) >> 1);
p1[32] += p1[0];
if (!pSC->m_param.bScaledArith) {
strDCT2x2dn(p1 + 0, p1 + 64, p1 + 16, p1 + 80);
strDCT2x2dn(p1 + 32, p1 + 96, p1 + 48, p1 + 112);
}
else {
strDCT2x2dnDec(p1 + 0, p1 + 64, p1 + 16, p1 + 80);
strDCT2x2dnDec(p1 + 32, p1 + 96, p1 + 48, p1 + 112);
}
}
//========================================
// second level inverse overlap (422_UV)
if (OL_TWO == olOverlap)
{
if ((leftAdjacentColumn || bOneMBRightVertTB) && (top || bHoriTileBoundary))
COMPUTE_CORNER_PRED_DIFF(p1 - 128 + 0, *(p1 - 128 + 64));
if ((rightAdjacentColumn || bOneMBLeftVertTB) && (top || bHoriTileBoundary))
iPredBefore[i][0] = *(p1 + 0);
if ((right || bVertTileBoundary) && (top || bHoriTileBoundary))
COMPUTE_CORNER_PRED_DIFF(p1 - 128 + 64, iPredBefore[i][0]);
if ((leftAdjacentColumn || bOneMBRightVertTB) && (bottom || bHoriTileBoundary))
COMPUTE_CORNER_PRED_DIFF(p0 - 128 + 48, *(p0 - 128 + 112));
if ((rightAdjacentColumn || bOneMBLeftVertTB) && (bottom || bHoriTileBoundary))
iPredBefore[i][1] = *(p0 + 48);
if ((right || bVertTileBoundary) && (bottom || bHoriTileBoundary))
COMPUTE_CORNER_PRED_DIFF(p0 - 128 + 112, iPredBefore[i][1]);
if (!bottom)
{
if (leftORright || bVertTileBoundary)
{
if (!top && !bHoriTileBoundary)
{
if (left || bVertTileBoundary)
strPost2_alternate(p0 + 48 + 0, p1 + 0);
if (right || bVertTileBoundary)
strPost2_alternate(p0 + 48 + -64, p1 + -64);
}
if (left || bVertTileBoundary)
strPost2_alternate(p1 + 16, p1 + 16 + 16);
if (right || bVertTileBoundary)
strPost2_alternate(p1 + -48, p1 + -48 + 16);
}
if (!leftORright && !bVertTileBoundary)
{
if (top || bHoriTileBoundary)
strPost2_alternate(p1 - 64, p1);
else
strPost2x2_alternate(p0 - 16, p0 + 48, p1 - 64, p1);
strPost2x2_alternate(p1 - 48, p1 + 16, p1 - 32, p1 + 32);
}
}
if ((bottom || bHoriTileBoundary) && (!leftORright && !bVertTileBoundary))
strPost2_alternate(p0 - 16, p0 + 48);
if ((leftAdjacentColumn || bOneMBRightVertTB) && (top || bHoriTileBoundary))
COMPUTE_CORNER_PRED_ADD(p1 - 128 + 0, *(p1 - 128 + 64));
if ((rightAdjacentColumn || bOneMBLeftVertTB) && (top || bHoriTileBoundary))
iPredAfter[i][0] = *(p1 + 0);
if ((right || bVertTileBoundary) && (top || bHoriTileBoundary))
COMPUTE_CORNER_PRED_ADD(p1 - 128 + 64, iPredAfter[i][0]);
if ((leftAdjacentColumn || bOneMBRightVertTB) && (bottom || bHoriTileBoundary))
COMPUTE_CORNER_PRED_ADD(p0 - 128 + 48, *(p0 - 128 + 112));
if ((rightAdjacentColumn || bOneMBLeftVertTB) && (bottom || bHoriTileBoundary))
iPredAfter[i][1] = *(p0 + 48);
if ((right || bVertTileBoundary) && (bottom || bHoriTileBoundary))
COMPUTE_CORNER_PRED_ADD(p0 - 128 + 112, iPredAfter[i][1]);
}
//========================================
// first level inverse transform (422_UV)
if(tScale >= 4) // bypass first level transform for 4:1 and smaller thumbnail
continue;
if (!top)
{
// Need to delay processing of left column until leftAdjacentColumn = 1 for corner overlap operators
// Since 422 has no vertical downsampling, no top MB delay of processing is necessary
for (j = (left ? 112 : ((leftAdjacentColumn || bOneMBRightVertTB) ? -80 : -16)); j < ((right || bVertTileBoundary) ? 48 : 112); j += 64)
{
strIDCT4x4Stage1(p0 + j);
}
}
if (!bottom)
{
// Need to delay processing of left column until leftAdjacentColumn = 1 for corner overlap operators
// Since 422 has no vertical downsampling, no top MB delay of processing is necessary
for (j = (left ? 64 : ((leftAdjacentColumn || bOneMBRightVertTB) ? -128 : -64)); j < ((right || bVertTileBoundary) ? 0 : 64); j += 64)
{
strIDCT4x4Stage1(p1 + j + 0);
strIDCT4x4Stage1(p1 + j + 16);
strIDCT4x4Stage1(p1 + j + 32);
}
}
//========================================
// first level inverse overlap (422_UV)
if (OL_NONE != olOverlap)
{
/* Corner operations */
if ((top || bHoriTileBoundary) && (leftAdjacentColumn || bOneMBRightVertTB))
strPost4_alternate(p1 - 128 + 0, p1 - 128 + 1, p1 - 128 + 2, p1 - 128 + 3);
if ((top || bHoriTileBoundary) && (right || bVertTileBoundary))
strPost4_alternate(p1 - 59, p1 - 60, p1 - 57, p1 - 58);
if ((bottom || bHoriTileBoundary) && (leftAdjacentColumn || bOneMBRightVertTB))
strPost4_alternate(p0 - 128 + 48 + 10, p0 - 128 + 48 + 11, p0 - 128 + 48 + 8, p0 - 128 + 48 + 9);
if ((bottom || bHoriTileBoundary) && (right || bVertTileBoundary))
strPost4_alternate(p0 - 1, p0 - 2, p0 - 3, p0 - 4);
if (!top)
{
// Need to delay processing of left column until leftAdjacentColumn = 1 for corner overlap operators
if (leftAdjacentColumn || bOneMBRightVertTB) {
p = p0 + 32 + 10 - 128;
strPost4_alternate(p + 0, p - 2, p + 6, p + 8);
strPost4_alternate(p + 1, p - 1, p + 7, p + 9);
p = NULL;
}
if (right || bVertTileBoundary) {
p = p0 + -32 + 14;
strPost4_alternate(p + 0, p - 2, p + 6, p + 8);
strPost4_alternate(p + 1, p - 1, p + 7, p + 9);
p = NULL;
}
for (j = (left ? 0 : -128); j < ((right || bVertTileBoundary) ? -64 : 0); j += 64)
( run in 0.646 second using v1.01-cache-2.11-cpan-119454b85a5 )