diff options
Diffstat (limited to 'media/libstagefright/codecs/m4v_h263/enc/src/fastquant.cpp')
| -rw-r--r-- | media/libstagefright/codecs/m4v_h263/enc/src/fastquant.cpp | 967 |
1 files changed, 967 insertions, 0 deletions
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/fastquant.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/fastquant.cpp new file mode 100644 index 0000000..466ce47 --- /dev/null +++ b/media/libstagefright/codecs/m4v_h263/enc/src/fastquant.cpp @@ -0,0 +1,967 @@ +/* ------------------------------------------------------------------ + * Copyright (C) 1998-2009 PacketVideo + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. + * See the License for the specific language governing permissions + * and limitations under the License. + * ------------------------------------------------------------------- + */ +#include "mp4enc_lib.h" +#include "fastquant_inline.h" + +#define siz 63 +#define LSL 18 + + +const static UChar imask[8] = {128, 64, 32, 16, 8, 4, 2, 1}; +#define SIGN0(a) ( ((a)<0) ? -1 : (((a)>0) ? 1 : 0) ) + +/* variable bit precision quantization scale */ +/* used to avoid using 32-bit multiplication */ +const static Short scaleArrayV[32] = {0, 16384, 8192, 5462, /* 15 */ + 4096, 3277, 2731, 2341, + 4096, 3641, 3277, 2979, /* 16 */ + 2731, 2521, 2341, 2185, + 4096, 3856, 3641, 3450, /* 17 */ + 3277, 3121, 2979, 2850, + 5462, 5243, 5042, 4855, /* 18 */ + 4682, 4520, 4370, 4229 + }; + +/* scale for dc_scaler and qmat, note, no value smaller than 8 */ +const static Short scaleArrayV2[47] = {0, 0, 0, 0, 0, 0, 0, 0, /* 15 */ + 4096, 3641, 3277, 2979, 2731, 2521, 2341, 2185, + 4096, 3856, 3641, 3450, 3277, 3121, 2979, 2850, /* 16 */ + 2731, 2622, 2521, 2428, 2341, 2260, 2185, 2115, + 4096, 3972, 3856, 3745, 3641, 3543, 3450, 3361, /* 17 */ + 3277, 3197, 3121, 3049, 2979, 2913, 2850 + }; + +/* AAN scale and zigzag */ +const static Short AANScale[64] = +{ + /* 0 */ 0x1000, 0x0B89, 0x0C3E, 0x0D9B, 0x1000, 0x0A2E, 0x0EC8, 0x0E7F, + /* 1 */ 0x0B89, 0x0851, 0x08D4, 0x09CF, 0x0B89, 0x0757, 0x0AA8, 0x0A73, + /* 2 */ 0x0C3E, 0x08D4, 0x095F, 0x0A6A, 0x0C3E, 0x07CB, 0x0B50, 0x0B18, + /* 3 */ 0x0D9B, 0x09CF, 0x0A6A, 0x0B92, 0x0D9B, 0x08A8, 0x0C92, 0x0C54, + /* 4 */ 0x1000, 0x0B89, 0x0C3E, 0x0D9B, 0x1000, 0x0A2E, 0x0EC8, 0x0E7F, + /* 5 */ 0x0A2E, 0x0757, 0x07CB, 0x08A8, 0x0A2E, 0x067A, 0x0968, 0x0939, + /* 6 */ 0x0EC8, 0x0AA8, 0x0B50, 0x0C92, 0x0EC8, 0x0968, 0x0DA8, 0x0D64, + /* 7 */ 0x0E7F, 0x0A73, 0x0B18, 0x0C54, 0x0E7F, 0x0939, 0x0D64, 0x0D23 +}; + +const static UShort ZZTab[64] = +{ + /* 0 */ 0x0, 0x2, 0xA, 0xC, 0x1C, 0x1E, 0x36, 0x38, + /* 1 */ 0x4, 0x8, 0xE, 0x1A, 0x20, 0x34, 0x3A, 0x54, + /* 2 */ 0x6, 0x10, 0x18, 0x22, 0x32, 0x3C, 0x52, 0x56, + /* 3 */ 0x12, 0x16, 0x24, 0x30, 0x3E, 0x50, 0x58, 0x6A, + /* 4 */ 0x14, 0x26, 0x2E, 0x40, 0x4E, 0x5A, 0x68, 0x6C, + /* 5 */ 0x28, 0x2C, 0x42, 0x4C, 0x5C, 0x66, 0x6E, 0x78, + /* 6 */ 0x2A, 0x44, 0x4A, 0x5E, 0x64, 0x70, 0x76, 0x7A, + /* 7 */ 0x46, 0x48, 0x60, 0x62, 0x72, 0x74, 0x7C, 0x7E +}; + + +//Tao need to remove, write another version of abs +//#include <math.h> + +/* ======================================================================== */ +/* Function : cal_dc_scalerENC */ +/* Date : 01/25/2000 */ +/* Purpose : calculation of DC quantization scale according to the + incoming Q and type; */ +/* In/out : */ +/* Int Qp Quantizer */ +/* Return : */ +/* DC Scaler */ +/* Modified : */ +/* ======================================================================== */ +/* ======================================================================== */ +Int cal_dc_scalerENC(Int QP, Int type) +{ + + Int dc_scaler; + if (type == 1) + { + if (QP > 0 && QP < 5) + dc_scaler = 8; + else if (QP > 4 && QP < 9) + dc_scaler = 2 * QP; + else if (QP > 8 && QP < 25) + dc_scaler = QP + 8; + else + dc_scaler = 2 * QP - 16; + } + else + { + if (QP > 0 && QP < 5) + dc_scaler = 8; + else if (QP > 4 && QP < 25) + dc_scaler = (QP + 13) / 2; + else + dc_scaler = QP - 6; + } + return dc_scaler; +} + + +/*********************************************************************** + Function: BlckQuantDequantH263 + Date: June 15, 1999 + Purpose: Combine BlockQuantH263 and BlockDequantH263ENC + Input: coeff=> DCT coefficient + Output: qcoeff=> quantized coefficient + rcoeff=> reconstructed coefficient + return CBP for this block + 4/2/01, correct dc_scaler for short_header mode. + 5/14/01, + changed the division into LUT multiplication/shift and other + modifications to speed up fastQuant/DeQuant (check for zero 1st, rowq LUT, + fast bitmaprow mask and borrowed Addition method instead of ifs from , ). + 6/25/01, + Further optimization (~100K/QCIF), need more testing/comment before integration. + + 7/4/01, break up Inter / Intra function and merge for different cases. + 7/22/01, combine AAN scaling here and reordering. + 7/24/01, , reorder already done in FDCT, the input here is in the next block and + it's the + transpose of the raster scan. Output the same order (for proof of concenpt). + 8/1/01, , change FDCT to do row/column FDCT without reordering, input is still + in the next block. The reconstructed DCT output is current block in normal + order. The quantized output is in zigzag scan order for INTER, row/column for + INTRA. Use bitmapzz for zigzag RunLevel for INTER. The quantization is done + in column/row scanning order. + 8/2/01, , change IDCT to do column/row, change bitmaprow/col to the opposite. + 8/3/01, , add clipping to the reconstructed coefficient [-2047,2047] + 9/4/05, , removed scaling for AAN IDCT, use Chen IDCT instead. + ********************************************************************/ + +Int BlockQuantDequantH263Inter(Short *rcoeff, Short *qcoeff, struct QPstruct *QuantParam, + UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz, + Int dctMode, Int comp, Int dummy, UChar shortHeader) +{ + Int i, zz; + Int tmp, coeff, q_value; + Int QPdiv2 = QuantParam->QPdiv2; + Int QPx2 = QuantParam->QPx2; + Int Addition = QuantParam->Addition; + Int QPx2plus = QuantParam->QPx2plus; + Int round = 1 << 15; + Int q_scale = scaleArrayV[QuantParam->QP]; + Int shift = 15 + (QPx2 >> 4); + Int *temp; + UChar *bcolptr = bitmapcol; + Int ac_clip; /* quantized coeff bound */ + + OSCL_UNUSED_ARG(comp); + OSCL_UNUSED_ARG(dummy); + + + if (shortHeader) ac_clip = 126; /* clip between [-127,126] (standard allows 127!) */ + else ac_clip = 2047; /* clip between [-2048,2047] */ + + /* reset all bitmap to zero */ + temp = (Int*) bitmapcol; + temp[0] = temp[1] = 0; + bitmapzz[0] = bitmapzz[1] = 0; + *bitmaprow = 0; + QPx2plus <<= 4; + QPx2plus -= 8; + + rcoeff += 64; /* actual data is 64 item ahead */ + //end = rcoeff + dctMode - 1; + //rcoeff--; + bcolptr--; + i = 0; + + do + { + bcolptr++; + //rcoeff++; + //i=0; + coeff = rcoeff[i]; + if (coeff == 0x7fff) /* all zero column */ + { + i++; + continue; + } + + do + { + if (coeff >= -QPx2plus && coeff < QPx2plus) /* quantize to zero */ + { + i += 8; + if (i < (dctMode << 3)) + { + coeff = rcoeff[i]; + if (coeff > -QPx2plus && coeff < QPx2plus) /* quantize to zero */ + { + i += 8; + coeff = rcoeff[i]; + continue; + } + else + goto NONZERO1; + } + } + else + { +NONZERO1: + /* scaling */ + q_value = AANScale[i]; /* load scale AAN */ + zz = ZZTab[i]; /* zigzag order */ + + coeff = aan_scale(q_value, coeff, round, QPdiv2); + q_value = coeff_quant(coeff, q_scale, shift); + + /* dequantization */ + if (q_value) + { + + //coeff = PV_MIN(ac_clip,PV_MAX(-ac_clip-1, q_value)); + q_value = coeff_clip(q_value, ac_clip); + qcoeff[zz>>1] = q_value; + + // dequant and clip + //coeff = PV_MIN(2047,PV_MAX(-2048, q_value)); + tmp = 2047; + coeff = coeff_dequant(q_value, QPx2, Addition, tmp); + rcoeff[i-64] = coeff; + + (*bcolptr) |= imask[i>>3]; + if ((zz >> 1) > 31) bitmapzz[1] |= (1 << (63 - (zz >> 1))); + else bitmapzz[0] |= (1 << (31 - (zz >> 1))); + } + i += 8; + coeff = rcoeff[i]; + } + } + while (i < (dctMode << 3)); + + i += (1 - (dctMode << 3)); + } + while (i < dctMode) ; + + i = dctMode; + tmp = 1 << (8 - i); + while (i--) + { + if (bitmapcol[i])(*bitmaprow) |= tmp; + tmp <<= 1; + } + + if (*bitmaprow) + return 1; + else + return 0; +} + +Int BlockQuantDequantH263Intra(Short *rcoeff, Short *qcoeff, struct QPstruct *QuantParam, + UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz, + Int dctMode, Int comp, Int dc_scaler, UChar shortHeader) +{ + Int i; + Int tmp, coeff, q_value; + Int QPx2 = QuantParam->QPx2; + Int Addition = QuantParam->Addition; + Int QPx2plus = QuantParam->QPx2plus; + Int round = 1 << 15; + Int q_scale = scaleArrayV[QuantParam->QP]; + Int shift = 15 + (QPx2 >> 4); + UChar *bmcolptr = bitmapcol; + Int ac_clip; /* quantized coeff bound */ + + OSCL_UNUSED_ARG(bitmapzz); + OSCL_UNUSED_ARG(comp); + + + if (shortHeader) ac_clip = 126; /* clip between [-127,126] (standard allows 127!) */ + else ac_clip = 2047; /* clip between [-2048,2047] */ + + *((Int*)bitmapcol) = *((Int*)(bitmapcol + 4)) = 0; + *bitmaprow = 0; + + QPx2plus = QPx2 << 4; + QPx2plus -= 8; + + rcoeff += 64; /* actual data is 64 element ahead */ + i = 0; + + /* DC value */ + coeff = *rcoeff; + /* scaling */ + if (coeff == 0x7fff && !shortHeader) /* all zero column */ + { + bmcolptr++; + i++; + } + else + { + if (coeff == 0x7fff) /* shortHeader on */ + { + coeff = 1; /* can't be zero */ + qcoeff[0] = coeff; + coeff = coeff * dc_scaler; + coeff = PV_MAX(-2048, PV_MIN(2047, coeff)); + rcoeff[-64] = coeff; + bitmapcol[0] |= 128; + bmcolptr++; + //qcoeff++; + //rcoeff++; + //i=0; + i++; + } + else + { + q_value = round + (coeff << 12); + coeff = q_value >> 16; + if (coeff >= 0) coeff += (dc_scaler >> 1) ; + else coeff -= (dc_scaler >> 1) ; + q_value = scaleArrayV2[dc_scaler]; + coeff = coeff * q_value; + coeff >>= (15 + (dc_scaler >> 4)); + coeff += ((UInt)coeff >> 31); + + if (shortHeader) + coeff = PV_MAX(1, PV_MIN(254, coeff)); + + if (coeff) + { + qcoeff[0] = coeff; + coeff = coeff * dc_scaler; + coeff = PV_MAX(-2048, PV_MIN(2047, coeff)); + rcoeff[-64] = coeff; + bitmapcol[0] |= 128; + } + i += 8; + } + } + /* AC values */ + do + { + coeff = rcoeff[i]; + if (coeff == 0x7fff) /* all zero row */ + { + bmcolptr++; + i++; + continue; + } + do + { + if (coeff >= -QPx2plus && coeff < QPx2plus) /* quantize to zero */ + { + i += 8; + if (i < dctMode << 3) + { + coeff = rcoeff[i]; + if (coeff > -QPx2plus && coeff < QPx2plus) /* quantize to zero */ + { + i += 8; + coeff = rcoeff[i]; + continue; + } + else + goto NONZERO2; + } + } + else + { +NONZERO2: /* scaling */ + q_value = AANScale[i]; /* 09/02/05 */ + + /* scale aan */ + q_value = smlabb(q_value, coeff, round); + coeff = q_value >> 16; + /* quant */ + q_value = smulbb(q_scale, coeff); /*mov q_value, coeff, lsl #14 */ + /*smull tmp, coeff, q_value, q_scale*/ + q_value >>= shift; + q_value += ((UInt)q_value >> 31); /* add 1 if negative */ + + if (q_value) + { + //coeff = PV_MIN(ac_clip,PV_MAX(-ac_clip-1, q_value)); + q_value = coeff_clip(q_value, ac_clip); + qcoeff[i] = q_value; + + // dequant and clip + //coeff = PV_MIN(2047,PV_MAX(-2048, q_value)); + tmp = 2047; + coeff = coeff_dequant(q_value, QPx2, Addition, tmp); + rcoeff[i-64] = coeff; + + (*bmcolptr) |= imask[i>>3]; + } + i += 8; + coeff = rcoeff[i]; + } + } + while (i < (dctMode << 3)) ; + + //qcoeff++; /* next column */ + bmcolptr++; + //rcoeff++; + i += (1 - (dctMode << 3)); //i = 0; + } + while (i < dctMode);//while(rcoeff < end) ; + + i = dctMode; + tmp = 1 << (8 - i); + while (i--) + { + if (bitmapcol[i])(*bitmaprow) |= tmp; + tmp <<= 1; + } + + if (((*bitmaprow)&127) || (bitmapcol[0]&127)) /* exclude DC */ + return 1; + else + return 0; +} + + +/*********************************************************************** + Function: BlckQuantDequantH263DC + Date: 5/3/2001 + Purpose: H.263 quantization mode, only for DC component + 6/25/01, + Further optimization (~100K/QCIF), need more testing/comment before integration. + + ********************************************************************/ +Int BlockQuantDequantH263DCInter(Short *rcoeff, Short *qcoeff, struct QPstruct *QuantParam, + UChar *bitmaprow, UInt *bitmapzz, Int dummy, UChar shortHeader) +{ + Int coeff, scale_q; + Int CBP = 0; + Int QP = QuantParam->QP; + Int QPx2plus = QuantParam->QPx2plus; + Int Addition = QuantParam->Addition; + Int shift = 15 + (QP >> 3); + Int ac_clip; /* quantized coeff bound */ + Int tmp; + + OSCL_UNUSED_ARG(dummy); + + if (shortHeader) ac_clip = 126; /* clip between [-127,126] (standard allows 127!) */ + else ac_clip = 2047; /* clip between [-2048,2047] */ + + *bitmaprow = 0; + bitmapzz[0] = bitmapzz[1] = 0; + coeff = rcoeff[0]; + + if (coeff >= -QPx2plus && coeff < QPx2plus) + { + rcoeff[0] = 0; + return CBP;//rcoeff[0] = 0; not needed since CBP will be zero + } + else + { + scale_q = scaleArrayV[QP]; + + coeff = aan_dc_scale(coeff, QP); + + scale_q = coeff_quant(coeff, scale_q, shift); + + //coeff = PV_MIN(ac_clip,PV_MAX(-ac_clip-1, tmp)); + scale_q = coeff_clip(scale_q, ac_clip); + + qcoeff[0] = scale_q; + + QP <<= 1; + //coeff = PV_MIN(2047,PV_MAX(-2048, tmp)); + tmp = 2047; + coeff = coeff_dequant(scale_q, QP, Addition, tmp); + + rcoeff[0] = coeff; + + (*bitmaprow) = 128; + bitmapzz[0] = (ULong)1 << 31; + CBP = 1; + } + return CBP; +} + + +Int BlockQuantDequantH263DCIntra(Short *rcoeff, Short *qcoeff, struct QPstruct *QuantParam, + UChar *bitmaprow, UInt *bitmapzz, Int dc_scaler, UChar shortHeader) +{ + Int tmp, coeff; + + OSCL_UNUSED_ARG(QuantParam); + + *bitmaprow = 0; + coeff = rcoeff[0]; + + if (coeff >= 0) coeff += (dc_scaler >> 1) ; + else coeff -= (dc_scaler >> 1) ; + tmp = scaleArrayV2[dc_scaler]; + tmp = coeff * tmp; + tmp >>= (15 + (dc_scaler >> 4)); + tmp += ((UInt)tmp >> 31); + + if (shortHeader) + tmp = PV_MAX(1, PV_MIN(254, tmp)); + + if (tmp) + { + qcoeff[0] = tmp; + coeff = tmp * dc_scaler; + coeff = PV_MAX(-2048, PV_MIN(2047, coeff)); + rcoeff[0] = coeff; + *bitmaprow = 128; + bitmapzz[0] = (ULong)1 << 31; + } + + return 0; +} + +#ifndef NO_MPEG_QUANT +/*********************************************************************** + Function: BlckQuantDequantMPEG + Date: June 15, 1999 + Purpose: Combine BlockQuantMPEG and BlockDequantMPEGENC + Input: coeff=> DCT coefficient + Output: qcoeff=> quantized coefficient + rcoeff=> reconstructed coefficient + Modified: 7/5/01, break up function for Intra/Inter + 8/3/01, update with changes from H263 quant mode. + 8/3/01, add clipping to the reconstructed coefficient [-2048,2047] + 8/6/01, optimize using multiplicative lookup-table. + can be further optimized using ARM assembly, e.g., + clipping, 16-bit mult., etc !!!!!!!!!!!!! + ********************************************************************/ + +Int BlockQuantDequantMPEGInter(Short *rcoeff, Short *qcoeff, Int QP, Int *qmat, + UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz, + Int dctMode, Int comp, Int dc_scaler) +{ + Int i, zz; + Int tmp, coeff, q_value = 0; + Int sum = 0; + Int stepsize, QPx2 = QP << 1; + Int CBP = 0; + Int round = 1 << 15; + Int q_scale = scaleArrayV[QP]; + Int shift = 15 + (QP >> 3); + UChar *bcolptr = bitmapcol; + + OSCL_UNUSED_ARG(dc_scaler); + OSCL_UNUSED_ARG(comp); + + + *((Int*)bitmapcol) = *((Int*)(bitmapcol + 4)) = 0; + bitmapzz[0] = bitmapzz[1] = 0; + *bitmaprow = 0; + + rcoeff += 64; + i = 0; + bcolptr--; + + do + { + bcolptr++; + coeff = rcoeff[i]; + if (coeff == 0x7fff) /* all zero column */ + { + i++; + continue; + } + do + { + q_value = AANScale[i]; /* 09/02/05 scaling for AAN*/ + /* aan scaling */ + q_value = smlabb(q_value, coeff, round); + + coeff = q_value >> 16; + + stepsize = qmat[i]; +// if(coeff>0) coeff = (16*coeff + (stepsize/2)) / stepsize; +// else coeff = (16*coeff - (stepsize/2)) / stepsize; + coeff <<= 4; + if (coeff >= 0) coeff += (stepsize >> 1) ; + else coeff -= (stepsize >> 1) ; + q_value = scaleArrayV2[stepsize]; + /* mpeg quant table scale */ + coeff = smulbb(coeff, q_value); + + coeff >>= (15 + (stepsize >> 4)); + coeff += ((UInt)coeff >> 31); + + /* QP scale */ + if (coeff >= -QPx2 && coeff < QPx2) /* quantized to zero*/ + { + i += 8; + } + else + { +// q_value = coeff/(QPx2); + q_value = coeff_quant(coeff, q_scale, shift); + + if (q_value) /* dequant */ + { + + zz = ZZTab[i]; /* zigzag order */ + + tmp = 2047; + + q_value = clip_2047(q_value, tmp); + + qcoeff[zz>>1] = q_value; + + //q_value=(((coeff*2)+SIGN0(coeff))*stepsize*QP)/16; + /* no need for SIGN0, no zero coming in this {} */ + q_value = coeff_dequant_mpeg(q_value, stepsize, QP, tmp); + + rcoeff[i-64] = q_value; + + sum += q_value; + (*bcolptr) |= imask[i>>3]; + if ((zz >> 1) > 31) bitmapzz[1] |= (1 << (63 - (zz >> 1))); + else bitmapzz[0] |= (1 << (31 - (zz >> 1))); + } + i += 8; + } + coeff = rcoeff[i]; + } + while (i < (dctMode << 3)) ; + + i += (1 - (dctMode << 3)); + } + while (i < dctMode) ; + + i = dctMode; + tmp = 1 << (8 - i); + while (i--) + { + if (bitmapcol[i])(*bitmaprow) |= tmp; + tmp <<= 1; + } + + if (*bitmaprow) + CBP = 1; /* check CBP before mismatch control, 7/5/01 */ + + /* Mismatch control, 5/3/01 */ + if (CBP) + { + if ((sum&0x1) == 0) + { + rcoeff--; /* rcoeff[63] */ + coeff = *rcoeff; + coeff ^= 0x1; + *rcoeff = coeff; + if (coeff) + { + bitmapcol[7] |= 1; + (*bitmaprow) |= 1; + } + } + } + + return CBP; +} + +Int BlockQuantDequantMPEGIntra(Short *rcoeff, Short *qcoeff, Int QP, Int *qmat, + UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz, + Int dctMode, Int comp, Int dc_scaler) +{ + Int i; + Int tmp, coeff, q_value = 0; + Int sum = 0; + Int stepsize; + Int CBP = 0; + Int round = 1 << 15; + Int q_scale = scaleArrayV[QP]; + Int shift = 15 + (QP >> 3); + Int round2 = (3 * QP + 2) >> 2; + Int QPx2plus = (QP << 1) - round2; + UChar *bmcolptr = bitmapcol; + + OSCL_UNUSED_ARG(bitmapzz); + OSCL_UNUSED_ARG(comp); + + *((Int*)bitmapcol) = *((Int*)(bitmapcol + 4)) = 0; + *bitmaprow = 0; + + rcoeff += 64; + i = 0; + + /* DC value */ + coeff = *rcoeff; + + if (coeff == 0x7fff) /* all zero column */ + { + bmcolptr++; + i++; + } + else + { + q_value = round + (coeff << 12); + coeff = q_value >> 16; + /*if (coeff >= 0) coeff = (coeff + (dc_scaler/2)) / dc_scaler; + else coeff = (coeff - (dc_scaler/2)) / dc_scaler;*/ + if (coeff >= 0) coeff += (dc_scaler >> 1) ; + else coeff -= (dc_scaler >> 1) ; + q_value = scaleArrayV2[dc_scaler]; + + /* mpeg quant table scale */ + coeff = smulbb(coeff, q_value); + + coeff >>= (15 + (dc_scaler >> 4)); + coeff += ((UInt)coeff >> 31); + + if (coeff) + { + coeff = PV_MAX(1, PV_MIN(254, coeff)); + qcoeff[0] = coeff; + + coeff = smulbb(coeff, dc_scaler); + + q_value = clip_2047(coeff, 2047); + + sum = q_value; + + rcoeff[-64] = q_value; + + bitmapcol[0] |= 128; + } + i += 8; + } + /* AC values */ + do + { + coeff = rcoeff[i]; + if (coeff == 0x7fff) /* all zero row */ + { + bmcolptr++; + i++; + continue; + } + do + { + /* scaling */ + q_value = AANScale[i]; /* 09/02/05 */ + + /* q_value = coeff*q_value + round */ + q_value = smlabb(coeff, q_value, round); + coeff = q_value >> 16; + + stepsize = qmat[i]; + /*if(coeff>0) coeff = (16*coeff + (stepsize/2)) / stepsize; + else coeff = (16*coeff - (stepsize/2)) / stepsize;*/ + coeff <<= 4; + if (coeff >= 0) coeff += (stepsize >> 1) ; + else coeff -= (stepsize >> 1) ; + q_value = scaleArrayV2[stepsize]; + + /* scale mpeg quant */ + coeff = smulbb(coeff, q_value); + + coeff >>= (15 + (stepsize >> 4)); + coeff += ((UInt)coeff >> 31); + + if (coeff >= -QPx2plus && coeff < QPx2plus) + { + i += 8; + } + else + { + //q_value = ( coeff + SIGN0(coeff)*((3*QP+2)/4))/(2*QP); + if (coeff > 0) coeff += round2; + else if (coeff < 0) coeff -= round2; + + q_value = smulbb(coeff, q_scale); + q_value >>= shift; + q_value += ((UInt)q_value >> 31); + + if (q_value) + { + tmp = 2047; + q_value = clip_2047(q_value, tmp); + + qcoeff[i] = q_value; + + stepsize = smulbb(stepsize, QP); + q_value = smulbb(q_value, stepsize); + + q_value = coeff_dequant_mpeg_intra(q_value, tmp); + //q_value = (coeff*stepsize*QP*2)/16; + + rcoeff[i-64] = q_value; + + sum += q_value; + (*bmcolptr) |= imask[i>>3]; + } + i += 8; + } + coeff = rcoeff[i]; + } + while (i < (dctMode << 3)) ; + + bmcolptr++; + i += (1 - (dctMode << 3)); + } + while (i < dctMode) ; + + i = dctMode; + tmp = 1 << (8 - i); + while (i--) + { + if (bitmapcol[i])(*bitmaprow) |= tmp; + tmp <<= 1; + } + + if (((*bitmaprow) &127) || (bitmapcol[0]&127)) + CBP = 1; /* check CBP before mismatch control, 7/5/01 */ + + /* Mismatch control, 5/3/01 */ + if (CBP || bitmapcol[0]) + { + if ((sum&0x1) == 0) + { + rcoeff--; /* rcoeff[63] */ + coeff = *rcoeff; + coeff ^= 0x1; + *rcoeff = coeff; + if (coeff) + { + bitmapcol[7] |= 1; + (*bitmaprow) |= 1; + } + } + } + + return CBP; +} + + +/*********************************************************************** + Function: BlckQuantDequantMPEGDC + Date: 5/3/2001 + Purpose: MPEG Quant/Dequant for DC only block. + ********************************************************************/ +Int BlockQuantDequantMPEGDCInter(Short *rcoeff, Short *qcoeff, Int QP, Int *qmat, + UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz, Int dummy) +{ + Int q_value, coeff, stepsize; + Int CBP = 0; + Int q_scale = scaleArrayV[QP]; + Int shift = 15 + (QP >> 3); + Int QPx2 = QP << 1; + + OSCL_UNUSED_ARG(dummy); + + *((Int*)bitmapcol) = *((Int*)(bitmapcol + 4)) = 0; + *bitmaprow = 0; + bitmapzz[0] = bitmapzz[1] = 0; + coeff = rcoeff[0]; + stepsize = qmat[0]; + + /*if(coeff>0) coeff = (16*coeff + (stepsize/2)) / stepsize; + else coeff = (16*coeff - (stepsize/2)) / stepsize;*/ + coeff <<= 4; + if (coeff >= 0) coeff += (stepsize >> 1) ; + else coeff -= (stepsize >> 1) ; + q_value = scaleArrayV2[stepsize]; + + coeff = smulbb(coeff, q_value); + + coeff >>= (15 + (stepsize >> 4)); + coeff += ((UInt)coeff >> 31); + + if (coeff >= -QPx2 && coeff < QPx2) + { + rcoeff[0] = 0; + return CBP; + } + else + { +// q_value = coeff/(QPx2); + q_value = coeff_quant(coeff, q_scale, shift); + + if (q_value) + { + + //PV_MIN(2047,PV_MAX(-2048, q_value)); + q_value = clip_2047(q_value, 2047); + qcoeff[0] = q_value; + q_value = coeff_dequant_mpeg(q_value, stepsize, QP, 2047); + //q_value=(((coeff*2)+SIGN0(coeff))*stepsize*QP)/16; + rcoeff[0] = q_value; + + bitmapcol[0] = 128; + (*bitmaprow) = 128; + bitmapzz[0] = (UInt)1 << 31; + CBP = 1; + + /* Mismatch control, 5/3/01 */ + if ((q_value&0x1) == 0) + { + rcoeff[63] = 1; /* after scaling it remains the same */ + bitmapcol[7] |= 1; + (*bitmaprow) |= 1; + } + } + } + return CBP; +} + + +Int BlockQuantDequantMPEGDCIntra(Short *rcoeff, Short *qcoeff, Int QP, Int *qmat, + UChar bitmapcol[ ], UChar *bitmaprow, UInt *bitmapzz, + Int dc_scaler) +{ + Int tmp, coeff, q_value; + + OSCL_UNUSED_ARG(QP); + OSCL_UNUSED_ARG(qmat); + + + *((Int*)bitmapcol) = *((Int*)(bitmapcol + 4)) = 0; + *bitmaprow = 0; + coeff = rcoeff[0]; + + /*if (coeff >= 0) tmp = (coeff + dc_scaler/2) / dc_scaler; + else tmp = (coeff - dc_scaler/2) / dc_scaler;*/ + if (coeff >= 0) coeff += (dc_scaler >> 1) ; + else coeff -= (dc_scaler >> 1) ; + tmp = scaleArrayV2[dc_scaler]; + + tmp = smulbb(tmp, coeff); + tmp >>= (15 + (dc_scaler >> 4)); + tmp += ((UInt)tmp >> 31); + + if (tmp) + { + coeff = PV_MAX(1, PV_MIN(254, tmp)); + qcoeff[0] = coeff; + + q_value = smulbb(coeff, dc_scaler); + q_value = clip_2047(q_value, 2047); + rcoeff[0] = q_value; + bitmapcol[0] = 128; + *bitmaprow = 128; + bitmapzz[0] = (UInt)1 << 31; + + /* Mismatch control, 5/3/01 */ + if ((q_value&0x1) == 0) + { + rcoeff[63] = 1; /* after scaling it remains the same */ + bitmapcol[7] |= 1; + (*bitmaprow) |= 1; + } + } + + return 0; +} +#endif + |