/*!
************************************************************************
* \brief
* Quantization process for All coefficients for a 2x2 DC block
*
* \par Input:
*
* \par Output:
*
************************************************************************
*/
int quant_dc2x2_trellis(int (*tblock)[4], int qp, int* DCLevel, int* DCRun,
int **fadjust, int levelscale, int invlevelscale, int **leveloffset,
const byte (*pos_scan)[2], int is_cavlc)
{
static int coeff_ctr;
static int *m7;
int level, run = 0;
int nonzero = FALSE;
int qp_per = qp_per_matrix[qp];
int qp_rem = qp_rem_matrix[qp];
//const byte *p_scan = &pos_scan[0][0];
int* DCL = &DCLevel[0];
int* DCR = &DCRun[0];
static int levelTrellis[16];
rdoq_dc_cr(tblock,qp_per,qp_rem, levelscale, leveloffset,pos_scan, levelTrellis, CHROMA_DC);
m7 = *tblock;
// Quantization
for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
{
// we need to update leveloffset to a 4x1 array that would contain offset info for
// every 2x2 DC position
if (*m7)
{
level = levelTrellis[coeff_ctr];
if (level != 0)
{
if (is_cavlc)
level = imin(level, CAVLC_LEVEL_LIMIT);
level = isignab(level, *m7);
*m7++ = ((level * invlevelscale) << qp_per);
*DCL++ = level;
*DCR++ = run;
// reset zero level counter
run = 0;
nonzero = TRUE;
}
else
{
run++;
*m7++ = 0;
}
}
else
{
run++;
m7++;
}
}
*DCL = 0;
return nonzero;
}
/*!
************************************************************************
* \brief
* Quantization process for All coefficients for a 2x2 DC block
*
* \par Input:
*
* \par Output:
*
************************************************************************
*/
int quant_dc4x2_trellis(int (*tblock)[4], int qp, int* DCLevel, int* DCRun,
int **fadjust, int levelscale, int invlevelscale, int **leveloffset,
const byte (*pos_scan)[2], int is_cavlc)
{
static int i,j, coeff_ctr;
static int *m7;
int level, run = 0;
int nonzero = FALSE;
int qp_per = qp_per_matrix[qp];
int qp_rem = qp_rem_matrix[qp];
const byte *p_scan = &pos_scan[0][0];
int* DCL = &DCLevel[0];
int* DCR = &DCRun[0];
static int levelTrellis[16];
rdoq_dc_cr(tblock,qp_per,qp_rem, levelscale, leveloffset,pos_scan, levelTrellis, CHROMA_DC_2x4);
for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
{
j = *p_scan++; // note that in this part, somehow coefficients were transposed from 2x4 to 4x2.
i = *p_scan++;
m7 = &tblock[j][i];
if (*m7 != 0)
{
level = levelTrellis[coeff_ctr];
if (level != 0)
{
if (is_cavlc)
level = imin(level, CAVLC_LEVEL_LIMIT);
level = isignab(level, *m7);
*m7 = ((level * invlevelscale) << qp_per);
*DCL++ = level;
*DCR++ = run;
// reset zero level counter
run = 0;
nonzero = TRUE;
}
else
{
run++;
*m7 = 0;
}
}
else
{
run++;
}
}
*DCL = 0;
return nonzero;
}
/*!
************************************************************************
* \brief
* Quantization process for All coefficients for a 4x4 block
*
************************************************************************
*/
int quant_4x4_2step(Macroblock *currMB, int **tblock, struct quant_methods *q_method)
{
VideoParameters *p_Vid = currMB->p_Vid;
QuantParameters *p_Quant = p_Vid->p_Quant;
Slice *currSlice = currMB->p_Slice;
Boolean is_cavlc = (Boolean) (currSlice->symbol_mode == CAVLC);
int block_x = q_method->block_x;
int qp = q_method->qp;
int* ACL = &q_method->ACLevel[0];
int* ACR = &q_method->ACRun[0];
LevelQuantParams **q_params_4x4 = q_method->q_params;
const byte (*pos_scan)[2] = q_method->pos_scan;
const byte *c_cost = q_method->c_cost;
int *coeff_cost = q_method->coeff_cost;
LevelQuantParams *q_params = NULL;
int i,j, coeff_ctr;
int *m7;
int scaled_coeff;
int level, run = 0;
int nonzero = FALSE;
int qp_per = p_Quant->qp_per_matrix[qp];
int q_bits = Q_BITS + qp_per;
const byte *p_scan = &pos_scan[0][0];
// Quantization
for (coeff_ctr = 0; coeff_ctr < 16; ++coeff_ctr)
{
i = *p_scan++; // horizontal position
j = *p_scan++; // vertical position
m7 = &tblock[j][block_x + i];
if (*m7 != 0)
{
q_params = &q_params_4x4[j][i];
scaled_coeff = iabs (*m7) * q_params->ScaleComp;
level = (scaled_coeff + q_params->OffsetComp) >> q_bits;
if (level != 0)
{
if (is_cavlc)
level = imin(level, CAVLC_LEVEL_LIMIT);
*coeff_cost += (level > 1) ? MAX_VALUE : c_cost[run];
level = isignab(level, *m7);
*m7 = rshift_rnd_sf(((level * q_params->InvScaleComp) << qp_per), 4);
// inverse scale can be alternative performed as follows to ensure 16bit
// arithmetic is satisfied.
// *m7 = (qp_per<4) ? rshift_rnd_sf((level*q_params->InvScaleComp),4-qp_per) : (level*q_params->InvScaleComp)<<(qp_per-4);
*ACL++ = level;
*ACR++ = run;
// reset zero level counter
run = 0;
nonzero = TRUE;
}
else
{
*m7 = 0;
++run;
}
}
else
{
++run;
/*!
************************************************************************
* \brief
* Quantization process for All coefficients for a 2x2 DC block
*
* \par Input:
*
* \par Output:
*
************************************************************************
*/
int quant_dc2x2_normal(int (*tblock)[4], int qp, int* DCLevel, int* DCRun,
int **fadjust, int levelscale, int invlevelscale, int **leveloffset,
const byte (*pos_scan)[2], int is_cavlc)
{
static int coeff_ctr;
static int *m7;
static int scaled_coeff;
int level, run = 0;
int nonzero = FALSE;
int qp_per = qp_per_matrix[qp];
int q_bits = Q_BITS + qp_per + 1;
//const byte *p_scan = &pos_scan[0][0];
int* DCL = &DCLevel[0];
int* DCR = &DCRun[0];
m7 = *tblock;
// Quantization
for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
{
// we need to update leveloffset to a 4x1 array that would contain offset info for
// every 2x2 DC position
if (*m7)
{
scaled_coeff = iabs (*m7) * levelscale;
level = (scaled_coeff + (leveloffset[0][0] << 1) ) >> q_bits;
if (level != 0)
{
if (is_cavlc)
level = imin(level, CAVLC_LEVEL_LIMIT);
level = isignab(level, *m7);
*m7++ = ((level * invlevelscale) << qp_per);
*DCL++ = level;
*DCR++ = run;
run = 0;
nonzero = TRUE;
}
else
{
run++;
*m7++ = 0;
}
}
else
{
run++;
m7++;
}
}
/*!
************************************************************************
* \brief
* Quantization process for All coefficients for a 2x2 DC block
*
* \par Input:
*
* \par Output:
*
************************************************************************
*/
int quant_dc2x2_around(Macroblock *currMB, int **tblock, int qp, int* DCLevel, int* DCRun,
LevelQuantParams *q_params_4x4, int **fadjust, const byte (*pos_scan)[2])
{
QuantParameters *p_Quant = currMB->p_Vid->p_Quant;
Boolean is_cavlc = (Boolean) (currMB->p_Slice->symbol_mode == CAVLC);
int coeff_ctr;
int *m7;
int scaled_coeff;
int level, run = 0;
int nonzero = FALSE;
int qp_per = p_Quant->qp_per_matrix[qp];
int q_bits = Q_BITS + qp_per + 1;
//const byte *p_scan = &pos_scan[0][0];
int* DCL = &DCLevel[0];
int* DCR = &DCRun[0];
m7 = *tblock;
// Quantization
for (coeff_ctr=0; coeff_ctr < 4; ++coeff_ctr)
{
// we need to update q_params_4x4->OffsetComp to a 4x1 array that would contain offset info for
// every 2x2 DC position
if (*m7)
{
scaled_coeff = iabs (*m7) * q_params_4x4->ScaleComp;
level = (scaled_coeff + (q_params_4x4->OffsetComp << 1) ) >> q_bits;
if (level != 0)
{
if (is_cavlc)
level = imin(level, CAVLC_LEVEL_LIMIT);
level = isignab(level, *m7);
*m7++ = ((level * q_params_4x4->InvScaleComp) << qp_per);
*DCL++ = level;
*DCR++ = run;
// reset zero level counter
run = 0;
nonzero = TRUE;
}
else
{
++run;
*m7++ = 0;
}
}
else
{
++run;
++m7;
}
}
/*!
************************************************************************
* \brief
* Quantization process for All coefficients for a 4x4 block
*
* \par Input:
*
* \par Output:
*
************************************************************************
*/
int quant_4x4_normal(int (*tblock)[16], int block_y, int block_x, int qp,
int* ACLevel, int* ACRun,
int **fadjust4x4, int **levelscale, int **invlevelscale, int **leveloffset,
int *coeff_cost, const byte (*pos_scan)[2], const byte *c_cost, int is_cavlc)
{
static int i,j, coeff_ctr;
static int *m7;
static int scaled_coeff;
int level, run = 0;
int nonzero = FALSE;
int qp_per = qp_per_matrix[qp];
int q_bits = Q_BITS + qp_per;
const byte *p_scan = &pos_scan[0][0];
int* ACL = &ACLevel[0];
int* ACR = &ACRun[0];
// Quantization
for (coeff_ctr = 0; coeff_ctr < 16; coeff_ctr++)
{
i = *p_scan++; // horizontal position
j = *p_scan++; // vertical position
m7 = &tblock[j][block_x + i];
if (*m7 != 0)
{
scaled_coeff = iabs (*m7) * levelscale[j][i];
level = (scaled_coeff + leveloffset[j][i]) >> q_bits;
if (level != 0)
{
if (is_cavlc)
level = imin(level, CAVLC_LEVEL_LIMIT);
*coeff_cost += (level > 1) ? MAX_VALUE : c_cost[run];
level = isignab(level, *m7);
*m7 = rshift_rnd_sf(((level * invlevelscale[j][i]) << qp_per), 4);
// inverse scale can be alternative performed as follows to ensure 16bit
// arithmetic is satisfied.
// *m7 = (qp_per<4) ? rshift_rnd_sf((level*invlevelscale[j][i]),4-qp_per) : (level*invlevelscale[j][i])<<(qp_per-4);
*ACL++ = level;
*ACR++ = run;
// reset zero level counter
run = 0;
nonzero = TRUE;
}
else
{
run++;
*m7 = 0;
}
}
else
{
