512 lines
18 KiB
C
512 lines
18 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"
|
|
#include "encode.h"
|
|
|
|
I32 QUANT_Mulless(PixelI v, PixelI o, I32 r)
|
|
{
|
|
const I32 m = v >> 31;
|
|
|
|
assert(sizeof(PixelI) == sizeof(U32));
|
|
return ((((v ^ m) - m + o) >> r) ^ m) - m;
|
|
}
|
|
|
|
I32 MUL32HR(U32 a, U32 b, U32 r)
|
|
{
|
|
return (I32)((U32)((U64)a * b >> 32) >> r);
|
|
}
|
|
|
|
I32 QUANT(PixelI v, PixelI o, I32 man, I32 exp)
|
|
{
|
|
const I32 m = v >> 31;
|
|
|
|
assert(sizeof(PixelI) == sizeof(U32));
|
|
return (MUL32HR((v ^ m) - m + o, man, exp) ^ m) - m;
|
|
}
|
|
|
|
Int quantizeMacroblock(CWMImageStrCodec* pSC)
|
|
{
|
|
CWMITile * pTile = pSC->pTile + pSC->cTileColumn;
|
|
CWMIMBInfo * pMBInfo = &pSC->MBInfo;
|
|
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
|
|
int iChannel, i, j;
|
|
|
|
if(/*pSC->m_param.bScaledArith && */pSC->m_param.bTranscode == FALSE)
|
|
for(iChannel = 0; iChannel < (int)pSC->m_param.cNumChannels; iChannel ++){
|
|
const Bool bUV = (iChannel > 0 && (cf == YUV_444 || cf == YUV_422 || cf == YUV_420));
|
|
const int iNumBlock = (bUV ? (cf == YUV_422 ? 8 : (cf == YUV_420 ? 4 : 16)) : 16);
|
|
const int * pOffset = (iNumBlock == 4 ? blkOffsetUV : (iNumBlock == 8 ? blkOffsetUV_422 : blkOffset));
|
|
CWMIQuantizer * pQPDC = pTile->pQuantizerDC[iChannel];
|
|
CWMIQuantizer * pQPLP = pTile->pQuantizerLP[iChannel] + pMBInfo->iQIndexLP;
|
|
CWMIQuantizer * pQPHP = pTile->pQuantizerHP[iChannel] + pMBInfo->iQIndexHP;
|
|
|
|
for(j = 0; j < iNumBlock; j ++){
|
|
PixelI * pData = pSC->pPlane[iChannel] + pOffset[j];
|
|
|
|
if(j == 0) // DC
|
|
pData[0] = (pQPDC->iMan == 0 ? QUANT_Mulless(pData[0], pQPDC->iOffset, pQPDC->iExp) : QUANT(pData[0], pQPDC->iOffset, pQPDC->iMan, pQPDC->iExp));
|
|
else if(pSC->WMISCP.sbSubband != SB_DC_ONLY) // LP
|
|
pData[0] = (pQPLP->iMan == 0 ? QUANT_Mulless(pData[0], pQPLP->iOffset, pQPLP->iExp) : QUANT(pData[0], pQPLP->iOffset, pQPLP->iMan, pQPLP->iExp));
|
|
|
|
// quantize HP
|
|
if(pSC->WMISCP.sbSubband != SB_DC_ONLY && pSC->WMISCP.sbSubband != SB_NO_HIGHPASS)
|
|
for(i = 1; i < 16; i ++)
|
|
pData[i] = (pQPHP->iMan == 0 ? QUANT_Mulless(pData[i], pQPHP->iOffset, pQPHP->iExp) : QUANT(pData[i], pQPHP->iOffset, pQPHP->iMan, pQPHP->iExp));
|
|
}
|
|
}
|
|
|
|
for(iChannel = 0; iChannel < (int)pSC->m_param.cNumChannels; iChannel ++){
|
|
I32 * pDC = pSC->MBInfo.iBlockDC[iChannel];
|
|
PixelI * pData = pSC->pPlane[iChannel];
|
|
|
|
if(iChannel > 0 && cf == YUV_422){
|
|
for(i = 0; i < 8; i ++){
|
|
pDC[i] = pData[blkOffsetUV_422[i]];
|
|
}
|
|
}
|
|
else if(iChannel > 0 && cf == YUV_420){
|
|
for(i = 0; i < 4; i ++){
|
|
pDC[i] = pData[blkOffsetUV[i]];
|
|
}
|
|
}
|
|
else{
|
|
for(i = 0; i < 16; i ++){
|
|
pDC[i] = pData[dctIndex[2][i]];
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* frequency domain prediction */
|
|
Void predMacroblockEnc(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 - 1;// mbY = pSC->cRow - 1;
|
|
CWMIMBInfo *pMBInfo = &(pSC->MBInfo);
|
|
Int iDCACPredMode = getDCACPredMode(pSC, mbX);
|
|
Int iDCPredMode = (iDCACPredMode & 0x3);
|
|
Int iADPredMode = (iDCACPredMode & 0xC);
|
|
Int iACPredMode = getACPredMode(pMBInfo, cf);
|
|
PixelI * pOrg, * pRef;
|
|
Int i, j, k;
|
|
|
|
pMBInfo->iOrientation = 2 - iACPredMode;
|
|
|
|
/* keep necessary info for future prediction */
|
|
updatePredInfo(pSC, pMBInfo, mbX, cf);
|
|
|
|
for(i = 0; i < iChannels; i ++){
|
|
pOrg = pMBInfo->iBlockDC[i]; // current DC block
|
|
|
|
/* DC prediction */
|
|
if(iDCPredMode == 1){ // predict DC from top
|
|
pOrg[0] -= (pSC->PredInfoPrevRow[i] + mbX)->iDC;
|
|
}
|
|
else if(iDCPredMode == 0){ // predict DC from left
|
|
pOrg[0] -= (pSC->PredInfo[i] + mbX - 1)->iDC;
|
|
}
|
|
else if(iDCPredMode == 2){// predict DC from top&left
|
|
pOrg[0] -= ((pSC->PredInfo[i] + mbX - 1)->iDC + (pSC->PredInfoPrevRow[i] + mbX)->iDC) >> 1;
|
|
}
|
|
|
|
/* AD prediction */
|
|
if(iADPredMode == 4){// predict AD from top
|
|
pRef = (pSC->PredInfoPrevRow[i] + 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[i] + mbX - 1)->piAD;
|
|
pOrg[1] -= pRef[0], pOrg[2] -= pRef[1], pOrg[3] -= pRef[2];
|
|
}
|
|
|
|
pOrg = pSC->pPlane[i];
|
|
/* AC prediction */
|
|
if(iACPredMode == 1){ // predict from top
|
|
for(k = 0; k <= 192; k += 64){
|
|
/* inside macroblock, in reverse order */
|
|
for(j = 48; j > 0; j -= 16){
|
|
pOrg[k + j + 10] -= pOrg[k + j + 10 - 16];
|
|
pOrg[k + j + 2] -= pOrg[k + j + 2 - 16];
|
|
pOrg[k + j + 9] -= pOrg[k + j + 9 - 16];
|
|
}
|
|
}
|
|
}
|
|
else if(iACPredMode == 0){ // predict from left
|
|
for(k = 0; k < 64; k += 16){
|
|
/* inside macroblock, in reverse order */
|
|
for(j = 192; j > 0; j -= 64){
|
|
pOrg[k + j + 5] -= pOrg[k + j + 5 - 64];
|
|
pOrg[k + j + 1] -= pOrg[k + j + 1 - 64];
|
|
pOrg[k + j + 6] -= pOrg[k + j + 6 - 64];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(cf == YUV_420){
|
|
for(i = 1; i < 3; i ++){
|
|
pOrg = pMBInfo->iBlockDC[i]; // current DC block
|
|
|
|
/* DC prediciton */
|
|
if(iDCPredMode == 1){ // predict DC from top
|
|
pOrg[0] -= (pSC->PredInfoPrevRow[i] + mbX)->iDC;
|
|
}
|
|
else if(iDCPredMode == 0){ // predict DC from left
|
|
pOrg[0] -= (pSC->PredInfo[i] + mbX - 1)->iDC;
|
|
}
|
|
else if(iDCPredMode == 2){ // predict DC from top&left
|
|
pOrg[0] -= (((pSC->PredInfo[i] + mbX - 1)->iDC + (pSC->PredInfoPrevRow[i] + mbX)->iDC + 1) >> 1);
|
|
}
|
|
|
|
/* AD prediction */
|
|
if(iADPredMode == 4){// predict AD from top
|
|
pOrg[2] -= (pSC->PredInfoPrevRow[i] + mbX)->piAD[1];
|
|
}
|
|
else if(iADPredMode == 0){// predict AD from left
|
|
pOrg[1] -= (pSC->PredInfo[i] + mbX - 1)->piAD[0];
|
|
}
|
|
|
|
pOrg = pSC->pPlane[i];
|
|
/* AC prediction */
|
|
if(iACPredMode == 1){ // predict from top
|
|
for(j = 16; j <= 48; j += 32){
|
|
/* inside macroblock */
|
|
pOrg[j + 10] -= pOrg[j + 10 - 16];
|
|
pOrg[j + 2] -= pOrg[j + 2 - 16];
|
|
pOrg[j + 9] -= pOrg[j + 9 - 16];
|
|
}
|
|
}
|
|
else if(iACPredMode == 0){ // predict from left
|
|
for(j = 32; j <= 48; j += 16){
|
|
/* inside macroblock */
|
|
pOrg[j + 5] -= pOrg[j + 5 - 32];
|
|
pOrg[j + 1] -= pOrg[j + 1 - 32];
|
|
pOrg[j + 6] -= pOrg[j + 6 - 32];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(cf == YUV_422){
|
|
for(i = 1; i < 3; i ++){
|
|
pOrg = pMBInfo->iBlockDC[i]; // current DC block
|
|
|
|
/* DC prediciton */
|
|
if(iDCPredMode == 1){ // predict DC from top
|
|
pOrg[0] -= (pSC->PredInfoPrevRow[i] + mbX)->iDC;
|
|
}
|
|
else if(iDCPredMode == 0){ // predict DC from left
|
|
pOrg[0] -= (pSC->PredInfo[i] + mbX - 1)->iDC;
|
|
}
|
|
else if(iDCPredMode == 2){ // predict DC from top&left
|
|
pOrg[0] -= (((pSC->PredInfo[i] + mbX - 1)->iDC + (pSC->PredInfoPrevRow[i] + mbX)->iDC + 1) >> 1);
|
|
}
|
|
|
|
/* AD prediction */
|
|
if(iADPredMode == 4){// predict AD from top
|
|
pOrg[4] -= (pSC->PredInfoPrevRow[i] + mbX)->piAD[4]; // AC of HT !!!
|
|
pOrg[6] -= pOrg[2];
|
|
pOrg[2] -= (pSC->PredInfoPrevRow[i] + mbX)->piAD[3];
|
|
}
|
|
else if(iADPredMode == 0){// predict AD from left
|
|
pOrg[4] -= (pSC->PredInfo[i] + mbX - 1)->piAD[4]; // AC of HT !!!
|
|
pOrg[1] -= (pSC->PredInfo[i] + mbX - 1)->piAD[0];
|
|
pOrg[5] -= (pSC->PredInfo[i] + mbX - 1)->piAD[2];
|
|
}
|
|
else if(iDCPredMode == 1){
|
|
pOrg[6] -= pOrg[2];
|
|
}
|
|
|
|
pOrg = pSC->pPlane[i]; // current MB
|
|
/* AC prediction */
|
|
if(iACPredMode == 1){ // predict from top
|
|
for(j = 48; j > 0; j -= 16){
|
|
for(k = 0; k <= 64; k += 64){
|
|
/* inside macroblock */
|
|
pOrg[j + k + 10] -= pOrg[j + k + 10 - 16];
|
|
pOrg[j + k + 2] -= pOrg[j + k + 2 - 16];
|
|
pOrg[j + k + 9] -= pOrg[j + k + 9 - 16];
|
|
}
|
|
}
|
|
}
|
|
else if(iACPredMode == 0){ // predict from left
|
|
for(j = 64; j <= 112; j += 16){
|
|
/* inside macroblock */
|
|
pOrg[j + 5] -= pOrg[j + 5 - 64];
|
|
pOrg[j + 1] -= pOrg[j + 1 - 64];
|
|
pOrg[j + 6] -= pOrg[j + 6 - 64];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* 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 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; }
|
|
|
|
static Int predCBPCEnc(CWMImageStrCodec *pSC, Int iCBP, size_t mbX, size_t mbY, size_t c, CCBPModel *pModel)
|
|
{
|
|
Int iPredCBP = 0, iRetval = 0;
|
|
Int iNOrig = NumOnes(iCBP), iNDiff = AVG_NDIFF;//NumOnes(iPredCBP ^ iCBP);
|
|
|
|
UNREFERENCED_PARAMETER( mbY );
|
|
|
|
/* only top left block pattern is predicted from neighbour */
|
|
if(pSC->m_bCtxLeft) {
|
|
if (pSC->m_bCtxTop) {
|
|
iPredCBP = 1;
|
|
}
|
|
else {
|
|
Int iTopCBP = (pSC->PredInfoPrevRow[c] + mbX)->iCBP;
|
|
iPredCBP = (iTopCBP >> 10) & 1; // left: top(10) => 0
|
|
}
|
|
}
|
|
else {
|
|
Int iLeftCBP = (pSC->PredInfo[c] + mbX - 1)->iCBP;
|
|
iPredCBP = ((iLeftCBP >> 5) & 1); // left(5) => 0
|
|
}
|
|
|
|
iPredCBP |= (iCBP & 0x3300) << 2; // [8 9 12 13]->[10 11 14 15]
|
|
iPredCBP |= (iCBP & 0xcc) << 6; // [2 3 6 7]->[8 9 12 13]
|
|
iPredCBP |= (iCBP & 0x33) << 2; // [0 1 4 5]->[2 3 6 7]
|
|
iPredCBP |= (iCBP & 0x11) << 1; // [0 4]->[1 5]
|
|
iPredCBP |= (iCBP & 0x2) << 3; // [1]->[4]
|
|
|
|
if (c) c = 1;
|
|
if (pModel->m_iState[c] == 0) {
|
|
iRetval = iPredCBP ^ iCBP;
|
|
}
|
|
else if (pModel->m_iState[c] == 1) {
|
|
iRetval = iCBP;
|
|
}
|
|
else {
|
|
iRetval = iCBP ^ 0xffff;
|
|
}
|
|
|
|
pModel->m_iCount0[c] += iNOrig - iNDiff;
|
|
SATURATE32(pModel->m_iCount0[c]);
|
|
|
|
pModel->m_iCount1[c] += 16 - iNOrig - iNDiff;
|
|
SATURATE32(pModel->m_iCount1[c]);
|
|
|
|
if (pModel->m_iCount0[c] < 0) {
|
|
if (pModel->m_iCount0[c] < pModel->m_iCount1[c]) {
|
|
pModel->m_iState[c] = 1;
|
|
}
|
|
else {
|
|
pModel->m_iState[c] = 2;
|
|
}
|
|
}
|
|
else if (pModel->m_iCount1[c] < 0) {
|
|
pModel->m_iState[c] = 2;
|
|
}
|
|
else {
|
|
pModel->m_iState[c] = 0;
|
|
}
|
|
return iRetval;
|
|
}
|
|
|
|
static Int predCBPC420Enc(CWMImageStrCodec *pSC, Int iCBP, size_t mbX, size_t mbY, size_t c, CCBPModel *pModel)
|
|
{
|
|
Int iPredCBP = 0, iRetval = 0;
|
|
Int iNOrig = NumOnes(iCBP) * 4, iNDiff = AVG_NDIFF;//NumOnes(iPredCBP ^ iCBP);
|
|
|
|
UNREFERENCED_PARAMETER( mbY );
|
|
|
|
/* only top left block pattern is predicted from neighbour */
|
|
if(pSC->m_bCtxLeft) {
|
|
if (pSC->m_bCtxTop) {
|
|
iPredCBP = 1;
|
|
}
|
|
else {
|
|
Int iTopCBP = (pSC->PredInfoPrevRow[c] + mbX)->iCBP;
|
|
iPredCBP = (iTopCBP >> 2) & 1; // left: top(2) => 0
|
|
}
|
|
}
|
|
else {
|
|
Int iLeftCBP = (pSC->PredInfo[c] + mbX - 1)->iCBP;
|
|
iPredCBP = ((iLeftCBP >> 1) & 1); // left(1) => 0
|
|
}
|
|
|
|
iPredCBP |= (iCBP & 0x1) << 1; // [0]->[1]
|
|
iPredCBP |= (iCBP & 0x3) << 2; // [0 1]->[2 3]
|
|
|
|
if (pModel->m_iState[1] == 0) {
|
|
iRetval = iPredCBP ^ iCBP;
|
|
}
|
|
else if (pModel->m_iState[1] == 1) {
|
|
iRetval = iCBP;
|
|
}
|
|
else {
|
|
iRetval = iCBP ^ 0xf;
|
|
}
|
|
|
|
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 iRetval;
|
|
}
|
|
|
|
static Int predCBPC422Enc(CWMImageStrCodec *pSC, Int iCBP, size_t mbX, size_t mbY, size_t c, CCBPModel *pModel)
|
|
{
|
|
Int iPredCBP = 0, iRetval = 0;
|
|
Int iNOrig = NumOnes(iCBP) * 2, iNDiff = AVG_NDIFF;//NumOnes(iPredCBP ^ iCBP);
|
|
|
|
UNREFERENCED_PARAMETER( mbY );
|
|
|
|
/* only top left block pattern is predicted from neighbour */
|
|
if(pSC->m_bCtxLeft) {
|
|
if (pSC->m_bCtxTop) {
|
|
iPredCBP = 1;
|
|
}
|
|
else {
|
|
Int iTopCBP = (pSC->PredInfoPrevRow[c] + mbX)->iCBP;
|
|
iPredCBP = (iTopCBP >> 6) & 1; // left: top(6) => 0
|
|
}
|
|
}
|
|
else {
|
|
Int iLeftCBP = (pSC->PredInfo[c] + mbX - 1)->iCBP;
|
|
iPredCBP = ((iLeftCBP >> 1) & 1); // left(1) => 0
|
|
}
|
|
|
|
iPredCBP |= (iCBP & 0x1) << 1; // [0]->[1]
|
|
iPredCBP |= (iCBP & 0x3) << 2; // [0 1]->[2 3]
|
|
iPredCBP |= (iCBP & 0xc) << 2; // [2 3]->[4 5]
|
|
iPredCBP |= (iCBP & 0x30) << 2; // [4 5]->[6 7]
|
|
|
|
if (pModel->m_iState[1] == 0) {
|
|
iRetval = iPredCBP ^ iCBP;
|
|
}
|
|
else if (pModel->m_iState[1] == 1) {
|
|
iRetval = iCBP;
|
|
}
|
|
else {
|
|
iRetval = iCBP ^ 0xff;
|
|
}
|
|
|
|
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 iRetval;
|
|
}
|
|
|
|
Void predCBPEnc(CWMImageStrCodec* pSC, CCodingContext *pContext)
|
|
{
|
|
size_t mbX = pSC->cColumn - 1, mbY = pSC->cRow - 1;
|
|
CWMIMBInfo * pMBInfo = &(pSC->MBInfo);
|
|
int iChannel, i, j;
|
|
|
|
for(iChannel = 0; iChannel < (int)pSC->m_param.cNumChannels; iChannel ++){
|
|
const COLORFORMAT cf = pSC->m_param.cfColorFormat;
|
|
const Bool bUV = (iChannel > 0);
|
|
const int iNumBlock = (bUV ? (cf == YUV_422 ? 8 : (cf == YUV_420 ? 4 : 16)) : 16);
|
|
const int * pOffset = (iNumBlock == 4 ? blkOffsetUV : (iNumBlock == 8 ? blkOffsetUV_422 : blkOffset));
|
|
const Int threshold = (1 << pContext->m_aModelAC.m_iFlcBits[bUV ? 1 : 0]) - 1, threshold2 = threshold * 2 + 1;
|
|
Int iCBP = 0;
|
|
|
|
for(j = 0; j < iNumBlock; j ++){
|
|
PixelI * pData = pSC->pPlane[iChannel] + pOffset[j];
|
|
for(i = 1; i < 16; i ++){
|
|
if((unsigned int)(pData[i] + threshold) >= (unsigned int) threshold2){ // significant coeff
|
|
iCBP |= (1 << j); // update CBP
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
pMBInfo->iCBP[iChannel] = (pSC->PredInfo[iChannel] + mbX)->iCBP = iCBP;
|
|
|
|
if(iNumBlock == 16){
|
|
pMBInfo->iDiffCBP[iChannel] = predCBPCEnc(pSC, pMBInfo->iCBP[iChannel], mbX, mbY, iChannel, &pContext->m_aCBPModel);
|
|
}
|
|
else if(iNumBlock == 8){
|
|
pSC->MBInfo.iDiffCBP[iChannel] = predCBPC422Enc(pSC, pMBInfo->iCBP[iChannel], mbX, mbY, iChannel, &pContext->m_aCBPModel);
|
|
}
|
|
else{
|
|
pSC->MBInfo.iDiffCBP[iChannel] = predCBPC420Enc(pSC, pMBInfo->iCBP[iChannel], mbX, mbY, iChannel, &pContext->m_aCBPModel);
|
|
}
|
|
}
|
|
}
|
|
|