Sweden-Number/libs/jxr/image/decode/strPredQuantDec.c

540 lines
17 KiB
C

//*@@@+++@@@@******************************************************************
//
// Copyright © Microsoft Corp.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// • Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// • Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//*@@@---@@@@******************************************************************
#include "strcodec.h"
#define DEQUANT(iRaw, iQP) ((iRaw) * (iQP))
Void dequantizeBlock4x4(PixelI * pRec, Int * pOrg, const Int * pIndex, Int iQPLP)
{
Int i;
for(i = 1; i < 16; i ++)
pRec[pIndex[i]] = DEQUANT(pOrg[i], iQPLP);
}
Void dequantizeBlock2x2(PixelI * pRec, Int * pOrg, Int iQPLP)
{
pRec[32] = DEQUANT(pOrg[1], iQPLP);
pRec[16] = DEQUANT(pOrg[2], iQPLP);
pRec[48] = DEQUANT(pOrg[3], iQPLP);
}
Void dequantizeBlock4x2(PixelI * pRec, Int * pOrg, Int iQPLP)
{
pRec[ 64] = DEQUANT(pOrg[1], iQPLP);
pRec[ 16] = DEQUANT(pOrg[2], iQPLP);
pRec[ 80] = DEQUANT(pOrg[3], iQPLP);
pRec[ 32] = DEQUANT(pOrg[4], iQPLP);
pRec[ 96] = DEQUANT(pOrg[5], iQPLP);
pRec[ 48] = DEQUANT(pOrg[6], iQPLP);
pRec[112] = DEQUANT(pOrg[7], iQPLP);
}
Int dequantizeMacroblock(CWMImageStrCodec * pSC)
{
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
CWMIMBInfo *pMBInfo = &pSC->MBInfo;
CWMITile * pTile = pSC->pTile + pSC->cTileColumn;
const size_t iChannels = pSC->m_param.cNumChannels;
size_t i;
for(i = 0; i < iChannels; i ++){
//dequantize DC
pSC->p1MBbuffer[i][0] = DEQUANT(pMBInfo->iBlockDC[i][0], pTile->pQuantizerDC[i]->iQP);
// dequantize LP
if(pSC->WMISCP.sbSubband != SB_DC_ONLY)
if(i == 0 || (cf != YUV_422 && cf != YUV_420))
dequantizeBlock4x4(pSC->p1MBbuffer[i] , pMBInfo->iBlockDC[i], dctIndex[2], pTile->pQuantizerLP[i][pMBInfo->iQIndexLP].iQP);
else if(cf == YUV_422)
dequantizeBlock4x2(pSC->p1MBbuffer[i], pMBInfo->iBlockDC[i], pTile->pQuantizerLP[i][pMBInfo->iQIndexLP].iQP);
else // 420
dequantizeBlock2x2(pSC->p1MBbuffer[i], pMBInfo->iBlockDC[i], pTile->pQuantizerLP[i][pMBInfo->iQIndexLP].iQP);
}
return ICERR_OK;
}
/* frequency domain inverse DCAC prediction */
Void predDCACDec(CWMImageStrCodec * pSC)
{
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
const Int iChannels = (cf == YUV_420 || cf == YUV_422) ? 1 : (Int) pSC->m_param.cNumChannels;
CWMIMBInfo *pMBInfo = &(pSC->MBInfo);
size_t mbX = pSC->cColumn;// mbY = pSC->cRow;
Int iDCACPredMode = getDCACPredMode(pSC, mbX);
Int iDCPredMode = (iDCACPredMode & 0x3);
Int iADPredMode = (iDCACPredMode & 0xC);
PixelI * pOrg, * pRef;
Int ii;
for(ii = 0; ii < iChannels; ii ++){
pOrg = pMBInfo->iBlockDC[ii];//[dcBlkIdx + (i >> 4)]; // current DC block
/* DC prediction */
if(iDCPredMode == 1){ // predict DC from top
pOrg[0] += pSC->PredInfoPrevRow[ii][mbX].iDC;
}
else if(iDCPredMode == 0){ // predict DC from left
pOrg[0] += (pSC->PredInfo[ii] + mbX - 1)->iDC;
}
else if(iDCPredMode == 2){// predict DC from top&left
pOrg[0] += ((pSC->PredInfo[ii] + mbX - 1)->iDC + (pSC->PredInfoPrevRow[ii] + mbX)->iDC) >> 1;
}
/* AD prediction */
if(iADPredMode == 4){// predict AD from top
pRef = (pSC->PredInfoPrevRow[ii] + mbX)->piAD;
pOrg[4] += pRef[3], pOrg[8] += pRef[4], pOrg[12] += pRef[5];
}
else if(iADPredMode == 0){// predict AD from left
pRef = (pSC->PredInfo[ii] + mbX - 1)->piAD;
pOrg[1] += pRef[0], pOrg[2] += pRef[1], pOrg[3] += pRef[2];
}
}
if(cf == YUV_420){
for(ii = 1; ii < 3; ii ++){
pOrg = pMBInfo->iBlockDC[ii];//dcBlkIdx + ii]; // current DC block
/* DC prediction */
if(iDCPredMode == 1){ // predict DC from top
pOrg[0] += (pSC->PredInfoPrevRow[ii] + mbX)->iDC;
}
else if(iDCPredMode == 0){ // predict DC from left
pOrg[0] += (pSC->PredInfo[ii] + mbX - 1)->iDC;
}
else if(iDCPredMode == 2){ // predict DC from top&left
pOrg[0] += (((pSC->PredInfo[ii] + mbX - 1)->iDC + (pSC->PredInfoPrevRow[ii] + mbX)->iDC + 1) >> 1);
}
/* AD prediciton */
if(iADPredMode == 4){// predict AD from top
pOrg[2] += (pSC->PredInfoPrevRow[ii] + mbX)->piAD[1];
}
else if(iADPredMode == 0){// predict AD from left
pOrg[1] += (pSC->PredInfo[ii] + mbX - 1)->piAD[0];
}
}
}
else if(cf == YUV_422){
for(ii = 1; ii < 3; ii ++){
pOrg = pMBInfo->iBlockDC[ii];//[dcBlkIdx + ii]; // current DC block
/* DC prediciton */
if(iDCPredMode == 1){ // predict DC from top
pOrg[0] += (pSC->PredInfoPrevRow[ii] + mbX)->iDC;
}
else if(iDCPredMode == 0){ // predict DC from left
pOrg[0] += (pSC->PredInfo[ii] + mbX - 1)->iDC;
}
else if(iDCPredMode == 2){ // predict DC from top&left
pOrg[0] += (((pSC->PredInfo[ii] + mbX - 1)->iDC + (pSC->PredInfoPrevRow[ii] + mbX)->iDC + 1) >> 1);
}
/* AD prediction */
if(iADPredMode == 4){// predict AD from top
pOrg[4] += (pSC->PredInfoPrevRow[ii] + mbX)->piAD[4]; // AC of HT !!!
pOrg[2] += (pSC->PredInfoPrevRow[ii] + mbX)->piAD[3];
pOrg[6] += pOrg[2];
}
else if(iADPredMode == 0){// predict AD from left
pOrg[4] += (pSC->PredInfo[ii] + mbX - 1)->piAD[4]; // AC of HT !!!
pOrg[1] += (pSC->PredInfo[ii] + mbX - 1)->piAD[0];
pOrg[5] += (pSC->PredInfo[ii] + mbX - 1)->piAD[2];
}
else if(iDCPredMode == 1){
pOrg[6] += pOrg[2];
}
}
}
pMBInfo->iOrientation = 2 - getACPredMode(pMBInfo, cf);
}
/*************************************************************************
Frequency domain inverse AC prediction
*************************************************************************/
Void predACDec(CWMImageStrCodec * pSC)
{
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
const Int iChannels = (cf == YUV_420 || cf == YUV_422) ? 1 : (Int) pSC->m_param.cNumChannels;
// size_t mbX = pSC->cColumn, mbY = pSC->cRow;
CWMIMBInfo *pMBInfo = &pSC->MBInfo;
Int iACPredMode = 2 - pMBInfo->iOrientation;
PixelI * pOrg, * pRef;
Int i, j;
/* AC prediction */
for(i = 0; i < iChannels; i++){
// prediction only happens inside MB
PixelI* pSrc = pSC->p1MBbuffer[i];//0 == i ? pSC->pY1 : (1 == i ? pSC->pU1 : pSC->pV1);
switch (iACPredMode)
{
case 1:
{
// predict from top
static U8 blkIdx[] = {1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15};
for (j = 0; j < sizeof(blkIdx) / sizeof(*blkIdx); ++j)
{
pOrg = pSrc + 16 * blkIdx[j];
pRef = pOrg - 16;
pOrg[ 2] += pRef[ 2];
pOrg[10] += pRef[10];
pOrg[ 9] += pRef[ 9];
}
break;
}
case 0:
// predict from left
for (j = 64; j < 256; j += 16)
{
pOrg = pSrc + j;
pRef = pOrg - 64;
pOrg[1] += pRef[1];
pOrg[5] += pRef[5];
pOrg[6] += pRef[6];
}
break;
default:
// no prediction
break;
}
}
if(cf == YUV_420){
for(i = 16; i <= 20; i += 4){
PixelI* pSrc = pSC->p1MBbuffer[(i >> 2) - 3];//16 == i ? pSC->pU1 : pSC->pV1;
switch (iACPredMode)
{
case 1:
{
// predict from top
for (j = 1; j <= 3; j += 2)
{
pOrg = pSrc + 16 * j;
pRef = pOrg - 16;
pOrg[ 2] += pRef[ 2];
pOrg[10] += pRef[10];
pOrg[ 9] += pRef[ 9];
}
break;
}
case 0:
// predict from left
for (j = 2; j <= 3; ++j)
{
pOrg = pSrc + 16 * j;
pRef = pOrg - 32;
pOrg[1] += pRef[1];
pOrg[5] += pRef[5];
pOrg[6] += pRef[6];
}
break;
default:
// no prediction
break;
}
}
}
else if(cf == YUV_422){
for(i = 16; i < 32; i += 8){
PixelI* pSrc = pSC->p1MBbuffer[(i >> 3) - 1];//16 == i ? pSC->pU1 : pSC->pV1;
switch (iACPredMode)
{
case 1:
{
// predict from top
for (j = 2; j < 8; j ++)
{
pOrg = pSrc + blkOffsetUV_422[j];
pRef = pOrg - 16;
pOrg[10] += pRef[10];
pOrg[ 2] += pRef[ 2];
pOrg[ 9] += pRef[ 9];
}
break;
}
case 0:
// predict from left
for (j = 1; j < 8; j += 2)
{
pOrg = pSrc + blkOffsetUV_422[j];
pRef = pOrg - 64;
pOrg[1] += pRef[1];
pOrg[5] += pRef[5];
pOrg[6] += pRef[6];
}
break;
default:
// no prediction
break;
}
}
}
}
/*************************************************************************
CBP
*************************************************************************/
static int NumOnes(int i)
{
int retval = 0;
static const int g_Count[] = { 0,1,1,2, 1,2,2,3, 1,2,2,3, 2,3,3,4 };
i = i & 0xffff;
while (i) {
retval += g_Count[i & 0xf];
i >>= 4;
}
return retval;
}
#define SATURATE32(x) if((unsigned int)(x + 16) >= 32) { if (x < 0) x = -16; else x = 15; }
/* CBP prediction for 16 x 16 MB */
/* block index */
/* 0 1 4 5 */
/* 2 3 6 7 */
/* 8 9 12 13 */
/* 10 11 14 15 */
static Int predCBPCDec(CWMImageStrCodec * pSC, Int iCBP, size_t mbX, size_t mbY, size_t c, CCBPModel *pModel)
{
Int iNOrig;
const int iNDiff = AVG_NDIFF;
size_t c1 = c ? 1 : 0;
UNREFERENCED_PARAMETER( mbY );
if (pModel->m_iState[c1] == 0) {
if(pSC->m_bCtxLeft) {
if (pSC->m_bCtxTop) {
iCBP ^= 1;
}
else {
Int iTopCBP = (pSC->PredInfoPrevRow[c] + mbX)->iCBP;
iCBP ^= (iTopCBP >> 10) & 1; // left: top(10) => 0
}
}
else {
Int iLeftCBP = (pSC->PredInfo[c] + mbX - 1)->iCBP;
iCBP ^= ((iLeftCBP >> 5) & 1); // left(5) => 0
}
iCBP ^= (0x02 & (iCBP << 1)); // 0 => 1
iCBP ^= (0x10 & (iCBP << 3)); // 1 => 4
iCBP ^= (0x20 & (iCBP << 1)); // 4 => 5
iCBP ^= ((iCBP & 0x33) << 2);
iCBP ^= ((iCBP & 0xcc) << 6);
iCBP ^= ((iCBP & 0x3300) << 2);
}
else if (pModel->m_iState[c1] == 2) {
iCBP ^= 0xffff;
}
iNOrig = NumOnes(iCBP);
pModel->m_iCount0[c1] += iNOrig - iNDiff;
SATURATE32(pModel->m_iCount0[c1]);
pModel->m_iCount1[c1] += 16 - iNOrig - iNDiff;
SATURATE32(pModel->m_iCount1[c1]);
if (pModel->m_iCount0[c1] < 0) {
if (pModel->m_iCount0[c1] < pModel->m_iCount1[c1]) {
pModel->m_iState[c1] = 1;
}
else {
pModel->m_iState[c1] = 2;
}
}
else if (pModel->m_iCount1[c1] < 0) {
pModel->m_iState[c1] = 2;
}
else {
pModel->m_iState[c1] = 0;
}
return iCBP;
}
static Int predCBPC420Dec(CWMImageStrCodec * pSC, Int iCBP, size_t mbX, size_t mbY, size_t c, CCBPModel *pModel)
{
Int iNOrig;
const int iNDiff = AVG_NDIFF;
UNREFERENCED_PARAMETER( mbY );
if (pModel->m_iState[1] == 0) {
if(pSC->m_bCtxLeft) {
if (pSC->m_bCtxTop) {
iCBP ^= 1;
}
else {
Int iTopCBP = (pSC->PredInfoPrevRow[c] + mbX)->iCBP;
iCBP ^= (iTopCBP >> 2) & 1; // left: top(2) => 0
}
}
else {
Int iLeftCBP = (pSC->PredInfo[c] + mbX - 1)->iCBP;
iCBP ^= ((iLeftCBP >> 1) & 1); // left(1) => 0
}
iCBP ^= (0x02 & (iCBP << 1)); // 0 => 1
iCBP ^= ((iCBP & 0x3) << 2); // [0 1] -> [2 3]
}
else if (pModel->m_iState[1] == 2) {
iCBP ^= 0xf;
}
iNOrig = NumOnes(iCBP) * 4;
pModel->m_iCount0[1] += iNOrig - iNDiff;
SATURATE32(pModel->m_iCount0[1]);
pModel->m_iCount1[1] += 16 - iNOrig - iNDiff;
SATURATE32(pModel->m_iCount1[1]);
if (pModel->m_iCount0[1] < 0) {
if (pModel->m_iCount0[1] < pModel->m_iCount1[1]) {
pModel->m_iState[1] = 1;
}
else {
pModel->m_iState[1] = 2;
}
}
else if (pModel->m_iCount1[1] < 0) {
pModel->m_iState[1] = 2;
}
else {
pModel->m_iState[1] = 0;
}
return iCBP;
}
static Int predCBPC422Dec(CWMImageStrCodec * pSC, Int iCBP, size_t mbX, size_t mbY, size_t c, CCBPModel *pModel)
{
Int iNOrig;
const int iNDiff = AVG_NDIFF;
UNREFERENCED_PARAMETER( mbY );
if (pModel->m_iState[1] == 0) {
if(pSC->m_bCtxLeft) {
if (pSC->m_bCtxTop) {
iCBP ^= 1;
}
else {
Int iTopCBP = (pSC->PredInfoPrevRow[c] + mbX)->iCBP;
iCBP ^= (iTopCBP >> 6) & 1; // left: top(6) => 0
}
}
else {
Int iLeftCBP = (pSC->PredInfo[c] + mbX - 1)->iCBP;
iCBP ^= ((iLeftCBP >> 1) & 1); // left(1) => 0
}
iCBP ^= (iCBP & 0x1) << 1; // [0]->[1]
iCBP ^= (iCBP & 0x3) << 2; // [0 1]->[2 3]
iCBP ^= (iCBP & 0xc) << 2; // [2 3]->[4 5]
iCBP ^= (iCBP & 0x30) << 2; // [4 5]->[6 7]
}
else if (pModel->m_iState[1] == 2) {
iCBP ^= 0xff;
}
iNOrig = NumOnes(iCBP) * 2;
pModel->m_iCount0[1] += iNOrig - iNDiff;
SATURATE32(pModel->m_iCount0[1]);
pModel->m_iCount1[1] += 16 - iNOrig - iNDiff;
SATURATE32(pModel->m_iCount1[1]);
if (pModel->m_iCount0[1] < 0) {
if (pModel->m_iCount0[1] < pModel->m_iCount1[1]) {
pModel->m_iState[1] = 1;
}
else {
pModel->m_iState[1] = 2;
}
}
else if (pModel->m_iCount1[1] < 0) {
pModel->m_iState[1] = 2;
}
else {
pModel->m_iState[1] = 0;
}
return iCBP;
}
/* Coded Block Pattern (CBP) prediction */
Void predCBPDec(CWMImageStrCodec *pSC, CCodingContext *pContext)
{
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
const size_t iChannels = (cf == YUV_420 || cf == YUV_422) ? 1 : pSC->m_param.cNumChannels;
size_t i, mbX = pSC->cColumn, mbY = pSC->cRow;
CWMIMBInfo *pMBInfo = &(pSC->MBInfo);
for (i = 0; i < iChannels; i++) {
(pSC->PredInfo[i] + mbX)->iCBP = pMBInfo->iCBP[i] = predCBPCDec(pSC, pMBInfo->iDiffCBP[i], mbX, mbY, i, &pContext->m_aCBPModel); // Y Channel
}
if (cf == YUV_422){
(pSC->PredInfo[1] + mbX)->iCBP = pMBInfo->iCBP[1] = predCBPC422Dec(pSC, pMBInfo->iDiffCBP[1], mbX, mbY, 1, &pContext->m_aCBPModel);
(pSC->PredInfo[2] + mbX)->iCBP = pMBInfo->iCBP[2] = predCBPC422Dec(pSC, pMBInfo->iDiffCBP[2], mbX, mbY, 2, &pContext->m_aCBPModel);
}
else if (cf == YUV_420) {
(pSC->PredInfo[1] + mbX)->iCBP = pMBInfo->iCBP[1] = predCBPC420Dec(pSC, pMBInfo->iDiffCBP[1], mbX, mbY, 1, &pContext->m_aCBPModel);
(pSC->PredInfo[2] + mbX)->iCBP = pMBInfo->iCBP[2] = predCBPC420Dec(pSC, pMBInfo->iDiffCBP[2], mbX, mbY, 2, &pContext->m_aCBPModel);
}
//}
}