/*!
************************************************************************
* \brief
* Does _diagonal_ interpolation using the BiLinear filter
*
* \param s
* pointer to StorablePicture structure
* \param dstImg
* destination Image
* \param srcImgT
* source top/left image
* \param srcImgB
* source bottom/right image
************************************************************************
*/
void getDiagSubImageBiLinear( StorablePicture *s, imgpel **dstImg, imgpel **srcImgT, imgpel **srcImgB )
{
int jpad, ipad;
int maxx = s->size_x_padded - 1;
int maxy = s->size_y_padded - 1;
imgpel *wBufSrcL, *wBufSrcR, *wBufDst;
for (jpad = 0; jpad < maxy; jpad++)
{
wBufSrcL = srcImgT[jpad + 1]; // 4:4:4 independent mode
wBufSrcR = &srcImgB[jpad][1]; // 4:4:4 independent mode
wBufDst = dstImg[jpad]; // 4:4:4 independent mode
for (ipad = 0; ipad < maxx; ipad++)
{
*wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcL++ + *wBufSrcR++, 1);
}
*wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcL++ + wBufSrcR[-1], 1);
}
wBufSrcL = srcImgT[maxy]; // 4:4:4 independent mode
wBufSrcR = &srcImgB[maxy][1]; // 4:4:4 independent mode
wBufDst = dstImg[maxy]; // 4:4:4 independent mode
for (ipad = 0; ipad < maxx; ipad++)
{
*wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcL++ + *wBufSrcR++, 1);
}
*wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcL++ + wBufSrcR[-1], 1);
}
/*!
************************************************************************
* \brief
* Does _vertical_ interpolation using the BiLinear filter
*
* \param s
* pointer to StorablePicture structure
* \param dstImg
* destination Image
* \param srcImgT
* source top image
* \param srcImgB
* source bottom image
************************************************************************
*/
void getVerSubImageBiLinear( StorablePicture *s, imgpel **dstImg, imgpel **srcImgT, imgpel **srcImgB)
{
int jpad, ipad;
int ypadded_size = s->size_y_padded - 1;
int xpadded_size = s->size_x_padded;
imgpel *wBufSrcT, *wBufSrcB, *wBufDst;
// top
for (jpad = 0; jpad < ypadded_size; jpad++)
{
wBufSrcT = srcImgT[jpad]; // 4:4:4 independent mode
wBufDst = dstImg[jpad]; // 4:4:4 independent mode
wBufSrcB = srcImgB[jpad + 1]; // 4:4:4 independent mode
for (ipad = 0; ipad < xpadded_size; ipad++)
{
*wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcT++ + *wBufSrcB++, 1);
}
}
// bottom
wBufSrcT = srcImgT[ypadded_size]; // 4:4:4 independent mode
wBufDst = dstImg[ypadded_size]; // 4:4:4 independent mode
wBufSrcB = srcImgB[ypadded_size]; // 4:4:4 independent mode
for (ipad = 0; ipad < xpadded_size; ipad++)
{
*wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcT++ + *wBufSrcB++, 1);
}
}
/*!
***********************************************************************
* \brief
* Inverse 8x8 transformation
***********************************************************************
*/
void itrans8x8(Macroblock *currMB, //!< current macroblock
ColorPlane pl, //!< used color plane
int ioff, //!< index to 4x4 block
int joff) //!< index to 4x4 block
{
ImageParameters *p_Img = currMB->p_Img;
Slice *currSlice = currMB->p_Slice;
int i,j;
imgpel **mpr = currSlice->mb_pred[pl];
imgpel **mb_rec = currSlice->mb_rec[pl];
int **m7 = currSlice->mb_rres[pl];
int max_imgpel_value = p_Img->max_imgpel_value_comp[pl];
if (currMB->is_lossless == TRUE)
{
for( j = joff; j < joff + 8; j++)
{
for( i = ioff; i < ioff + 8; i++)
mb_rec[j][i] = (imgpel) iClip1(max_imgpel_value, (m7[j][i] + (long)mpr[j][i]));
}
}
else
{
inverse8x8(m7, m7, joff, ioff);
for( j = joff; j < joff + 8; j++)
{
for( i = ioff; i < ioff + 8; i++)
//mb_rec[j][i] = (imgpel) iClip1(max_imgpel_value, rshift_rnd_sf((m7[j][i] + ((long)mpr[j][i] << DQ_BITS_8)), DQ_BITS_8));
mb_rec[j][i] = (imgpel) iClip1(max_imgpel_value, mpr[j][i] + rshift_rnd_sf(m7[j][i], DQ_BITS_8));
}
}
}
/*!
************************************************************************
* \brief
* Does _horizontal_ interpolation using the BiLinear filter
*
* \param s
* pointer to StorablePicture structure
* \param dstImg
* destination Image
* \param srcImgL
* source left image
* \param srcImgR
* source right image
************************************************************************
*/
void getHorSubImageBiLinear( StorablePicture *s, imgpel **dstImg, imgpel **srcImgL, imgpel **srcImgR)
{
int jpad, ipad;
int ypadded_size = s->size_y_padded;
int xpadded_size = s->size_x_padded - 1;
imgpel *wBufSrcL, *wBufSrcR, *wBufDst;
for (jpad = 0; jpad < ypadded_size; jpad++)
{
wBufSrcL = srcImgL[jpad]; // 4:4:4 independent mode
wBufSrcR = &srcImgR[jpad][1]; // 4:4:4 independent mode
wBufDst = dstImg[jpad]; // 4:4:4 independent mode
// left padded area + center
for (ipad = 0; ipad < xpadded_size; ipad++)
{
*wBufDst++ = (imgpel) rshift_rnd_sf( *wBufSrcL++ + *wBufSrcR++, 1 );
}
// right padded area
*wBufDst++ = (imgpel) rshift_rnd_sf( *wBufSrcL++ + wBufSrcR[-1], 1 );
}
}
void sample_reconstruct (imgpel **curImg, imgpel **mpr, int **mb_rres, int mb_x, int opix_x, int width, int height, int max_imgpel_value, int dq_bits)
{
imgpel *imgOrg, *imgPred;
int *m7;
int i, j;
for (j = 0; j < height; j++)
{
imgOrg = &curImg[j][opix_x];
imgPred = &mpr[j][mb_x];
m7 = &mb_rres[j][mb_x];
for (i=0;i<width;i++)
*imgOrg++ = (imgpel) iClip1( max_imgpel_value, rshift_rnd_sf(*m7++, dq_bits) + *imgPred++);
}
}
void sample_reconstruct2 (imgpel **curImg, imgpel **mpr, int **mb_rres, int mb_y,int mb_x, int opix_x, int width, int height, int max_imgpel_value, int dq_bits,int pl,Macroblock *currMB)
{
imgpel *imgOrg, *imgPred;
int *m7;
int i, j;
quantize_mb(mb_rres,width,height,mb_y,mb_x,pl,currMB);
for (j = 0; j < height; j++)
{
imgOrg = &curImg[j][opix_x];
imgPred = &mpr[j][mb_x];
m7 = &mb_rres[j][mb_x];
for (i=0;i<width;i++){
*imgOrg++ = (imgpel) iClip1( max_imgpel_value, rshift_rnd_sf(*m7++, dq_bits) + *imgPred++);
}
}
}
/*!
************************************************************************
* \brief
* Does _horizontal_ interpolation using the BiLinear filter
*
* \param s
* pointer to StorablePicture structure
* \param dstImg
* destination Image
* \param srcImgL
* source left image
* \param srcImgR
* source right image
************************************************************************
*/
void getSubImageBiLinear( StorablePicture *s, imgpel **dstImg, imgpel **srcImgL, imgpel **srcImgR)
{
int jpad, ipad;
int ypadded_size = s->size_y_padded;
int xpadded_size = s->size_x_padded;
imgpel *wBufSrcL, *wBufSrcR, *wBufDst;
for (jpad = 0; jpad < ypadded_size; jpad++)
{
wBufSrcL = srcImgL[jpad]; // 4:4:4 independent mode
wBufSrcR = srcImgR[jpad]; // 4:4:4 independent mode
wBufDst = dstImg[jpad]; // 4:4:4 independent mode
for (ipad = 0; ipad < xpadded_size; ipad++)
{
*wBufDst++ = (imgpel) rshift_rnd_sf( *wBufSrcL++ + *wBufSrcR++, 1 );
}
}
}
static void recon8x8(int **m7, imgpel **mb_rec, imgpel **mpr, int max_imgpel_value, int ioff)
{
int j;
int *m_tr = NULL;
imgpel *m_rec = NULL;
imgpel *m_prd = NULL;
for( j = 0; j < 8; j++)
{
m_tr = (*m7++) + ioff;
m_rec = (*mb_rec++) + ioff;
m_prd = (*mpr++) + ioff;
*m_rec++ = (imgpel) iClip1(max_imgpel_value, (*m_prd++) + rshift_rnd_sf(*m_tr++, DQ_BITS_8));
*m_rec++ = (imgpel) iClip1(max_imgpel_value, (*m_prd++) + rshift_rnd_sf(*m_tr++, DQ_BITS_8));
*m_rec++ = (imgpel) iClip1(max_imgpel_value, (*m_prd++) + rshift_rnd_sf(*m_tr++, DQ_BITS_8));
*m_rec++ = (imgpel) iClip1(max_imgpel_value, (*m_prd++) + rshift_rnd_sf(*m_tr++, DQ_BITS_8));
*m_rec++ = (imgpel) iClip1(max_imgpel_value, (*m_prd++) + rshift_rnd_sf(*m_tr++, DQ_BITS_8));
*m_rec++ = (imgpel) iClip1(max_imgpel_value, (*m_prd++) + rshift_rnd_sf(*m_tr++, DQ_BITS_8));
*m_rec++ = (imgpel) iClip1(max_imgpel_value, (*m_prd++) + rshift_rnd_sf(*m_tr++, DQ_BITS_8));
*m_rec = (imgpel) iClip1(max_imgpel_value, (*m_prd ) + rshift_rnd_sf(*m_tr , DQ_BITS_8));
}
}
/*!
************************************************************************
* \brief
* block weighted biprediction
************************************************************************
*/
static void weighted_bi_prediction(imgpel** mb_pred,
imgpel *block_l0,
imgpel *block_l1,
int block_size_y,
int block_x,
int block_size_x,
int max_imgpel_value,
int wp_scale_l0,
int wp_scale_l1,
int wp_offset,
int weight_denom)
{
int i, j, result;
int block_x4 = block_x + block_size_x;
for (j = 0; j< block_size_y; j++)
{
for (i=block_x; i<block_x4; i++)
{
result = rshift_rnd_sf((wp_scale_l0 * *(block_l0++) + wp_scale_l1 * *(block_l1++)), weight_denom);
mb_pred[j][i] = (imgpel) iClip1( max_imgpel_value, result + wp_offset);
}
}
}
/*!
************************************************************************
* \brief
* Does _vertical_ interpolation using the SIX TAP filters
*
* \param p_Img
* pointer to ImageParameters structure
* \param s
* pointer to StorablePicture structure
* \param dstImg
* pointer to source image
************************************************************************
*/
void getVerSubImageSixTapTmp( ImageParameters *p_Img, StorablePicture *s, imgpel **dstImg)
{
int is, jpad, ipad;
int ypadded_size = s->size_y_padded;
int xpadded_size = s->size_x_padded;
int maxy = ypadded_size - 1;
imgpel *wxLineDst;
int *srcImgA, *srcImgB, *srcImgC, *srcImgD, *srcImgE, *srcImgF;
const int tap0 = ONE_FOURTH_TAP[0][0];
const int tap1 = ONE_FOURTH_TAP[0][1];
const int tap2 = ONE_FOURTH_TAP[0][2];
// top
for (jpad = 0; jpad < 2; jpad++)
{
wxLineDst = dstImg[jpad];
srcImgA = p_Img->imgY_sub_tmp[jpad ];
srcImgB = p_Img->imgY_sub_tmp[0];
srcImgC = p_Img->imgY_sub_tmp[0];
srcImgD = p_Img->imgY_sub_tmp[jpad + 1];
srcImgE = p_Img->imgY_sub_tmp[jpad + 2];
srcImgF = p_Img->imgY_sub_tmp[jpad + 3];
for (ipad = 0; ipad < xpadded_size; ipad++)
{
is =
(tap0 * (*srcImgA++ + *srcImgD++) +
tap1 * (*srcImgB++ + *srcImgE++) +
tap2 * (*srcImgC++ + *srcImgF++));
wxLineDst[ipad] = (imgpel) iClip1 ( p_Img->max_imgpel_value, rshift_rnd_sf( is, 10 ) );
}
}
// center
for (jpad = 2; jpad < ypadded_size - 3; jpad++)
{
wxLineDst = dstImg[jpad];
srcImgA = p_Img->imgY_sub_tmp[jpad ];
srcImgB = p_Img->imgY_sub_tmp[jpad - 1];
srcImgC = p_Img->imgY_sub_tmp[jpad - 2];
srcImgD = p_Img->imgY_sub_tmp[jpad + 1];
srcImgE = p_Img->imgY_sub_tmp[jpad + 2];
srcImgF = p_Img->imgY_sub_tmp[jpad + 3];
for (ipad = 0; ipad < xpadded_size; ipad++)
{
is =
(tap0 * (*srcImgA++ + *srcImgD++) +
tap1 * (*srcImgB++ + *srcImgE++) +
tap2 * (*srcImgC++ + *srcImgF++));
wxLineDst[ipad] = (imgpel) iClip1 ( p_Img->max_imgpel_value, rshift_rnd_sf( is, 10 ) );
}
}
// bottom
for (jpad = ypadded_size - 3; jpad < ypadded_size; jpad++)
{
wxLineDst = dstImg[jpad];
srcImgA = p_Img->imgY_sub_tmp[jpad ];
srcImgB = p_Img->imgY_sub_tmp[jpad - 1];
srcImgC = p_Img->imgY_sub_tmp[jpad - 2];
srcImgD = p_Img->imgY_sub_tmp[imin (maxy, jpad + 1)];
srcImgE = p_Img->imgY_sub_tmp[maxy];
srcImgF = p_Img->imgY_sub_tmp[maxy];
for (ipad = 0; ipad < xpadded_size; ipad++)
{
is =
(tap0 * (*srcImgA++ + *srcImgD++) +
tap1 * (*srcImgB++ + *srcImgE++) +
tap2 * (*srcImgC++ + *srcImgF++));
wxLineDst[ipad] = (imgpel) iClip1 ( p_Img->max_imgpel_value, rshift_rnd_sf( is, 10 ) );
}
}
}
/*!
************************************************************************
* \brief
* Does _horizontal_ interpolation using the SIX TAP filters
*
* \param p_Img
* pointer to ImageParameters structure
* \param s
* pointer to StorablePicture structure
* \param dstImg
* destination image
* \param srcImg
* source image
************************************************************************
*/
void getHorSubImageSixTap( ImageParameters *p_Img, StorablePicture *s, imgpel **dstImg, imgpel **srcImg)
{
int is, jpad, ipad;
int ypadded_size = s->size_y_padded;
int xpadded_size = s->size_x_padded;
imgpel *wBufSrc, *wBufDst;
imgpel *srcImgA, *srcImgB, *srcImgC, *srcImgD, *srcImgE, *srcImgF;
int *iBufDst;
const int tap0 = ONE_FOURTH_TAP[0][0];
const int tap1 = ONE_FOURTH_TAP[0][1];
const int tap2 = ONE_FOURTH_TAP[0][2];
for (jpad = 0; jpad < ypadded_size; jpad++)
{
wBufSrc = srcImg[jpad]; // 4:4:4 independent mode
wBufDst = dstImg[jpad]; // 4:4:4 independent mode
iBufDst = p_Img->imgY_sub_tmp[jpad];
srcImgA = &wBufSrc[0];
srcImgB = &wBufSrc[0];
srcImgC = &wBufSrc[0];
srcImgD = &wBufSrc[1];
srcImgE = &wBufSrc[2];
srcImgF = &wBufSrc[3];
// left padded area
is =
(tap0 * (*srcImgA++ + *srcImgD++) +
tap1 * (*srcImgB + *srcImgE++) +
tap2 * (*srcImgC + *srcImgF++));
*iBufDst++ = is;
*wBufDst++ = (imgpel) iClip1 ( p_Img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
is =
(tap0 * (*srcImgA++ + *srcImgD++) +
tap1 * (*srcImgB++ + *srcImgE++) +
tap2 * (*srcImgC + *srcImgF++));
*iBufDst++ = is;
*wBufDst++ = (imgpel) iClip1 ( p_Img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
// center
for (ipad = 2; ipad < xpadded_size - 4; ipad++)
{
is =
(tap0 * (*srcImgA++ + *srcImgD++) +
tap1 * (*srcImgB++ + *srcImgE++) +
tap2 * (*srcImgC++ + *srcImgF++));
*iBufDst++ = is;
*wBufDst++ = (imgpel) iClip1 ( p_Img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
}
is = (
tap0 * (*srcImgA++ + *srcImgD++) +
tap1 * (*srcImgB++ + *srcImgE++) +
tap2 * (*srcImgC++ + *srcImgF ));
*iBufDst++ = is;
*wBufDst++ = (imgpel) iClip1 ( p_Img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
// right padded area
is = (
tap0 * (*srcImgA++ + *srcImgD++) +
tap1 * (*srcImgB++ + *srcImgE) +
tap2 * (*srcImgC++ + *srcImgF));
*iBufDst++ = is;
*wBufDst++ = (imgpel) iClip1 ( p_Img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
is = (
tap0 * (*srcImgA++ + *srcImgD) +
tap1 * (*srcImgB++ + *srcImgE) +
tap2 * (*srcImgC++ + *srcImgF));
*iBufDst++ = is;
*wBufDst++ = (imgpel) iClip1 ( p_Img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
is = (
tap0 * (*srcImgA + *srcImgD) +
tap1 * (*srcImgB + *srcImgE) +
tap2 * (*srcImgC + *srcImgF));
*iBufDst = is;
*wBufDst = (imgpel) iClip1 ( p_Img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
}
}
/*!
************************************************************************
* \brief
* Horizontal chroma interpolation image generation routine
************************************************************************
*/
static void generateChroma01( VideoParameters *p_Vid, int size_x_minus1, int size_y_minus1, int weight00, int weight01, imgpel **wImgDst, imgpel **imgUV)
{
int i;//, j;
int jpad = -p_Vid->pad_size_uv_y;
int cur_value;
imgpel *wBufDst;
imgpel *wBufSrc0;
wBufDst = wImgDst[jpad++]-p_Vid->pad_size_uv_x;
wBufSrc0 = imgUV[0];
for (i = -p_Vid->pad_size_uv_x; i < 0; i++)
{
*(wBufDst++) = *wBufSrc0;
}
for (i = 0; i < size_x_minus1; i++)
{
cur_value = weight00 * (*wBufSrc0++);
cur_value += weight01 * (*wBufSrc0 );
*(wBufDst++) = (imgpel) rshift_rnd_sf(cur_value, 6);
}
for (i = -1; i < p_Vid->pad_size_uv_x; i++)
{
*(wBufDst++) = *wBufSrc0;
}
for (; jpad < 1; jpad++)
{
memcpy(wImgDst[jpad]-p_Vid->pad_size_uv_x, wImgDst[jpad - 1]-p_Vid->pad_size_uv_x, (2 * p_Vid->pad_size_uv_x + size_x_minus1+1) * sizeof(imgpel));
}
for (jpad = 1; jpad < size_y_minus1+1; jpad++)
{
wBufDst = wImgDst[jpad]-p_Vid->pad_size_uv_x;
wBufSrc0 = imgUV[jpad];
for (i = -p_Vid->pad_size_uv_x; i < 0; i++)
{
*(wBufDst++) = *wBufSrc0;
}
for (i = 0; i < size_x_minus1; i++)
{
cur_value = weight00 * (*wBufSrc0++);
cur_value += weight01 * (*wBufSrc0 );
*(wBufDst++) = (imgpel) rshift_rnd_sf(cur_value, 6);
}
for (i = -1; i < p_Vid->pad_size_uv_x; i++)
{
*(wBufDst++) = *wBufSrc0;
}
}
for (jpad = size_y_minus1+1; jpad < size_y_minus1+1+p_Vid->pad_size_uv_y; jpad++)
{
memcpy(wImgDst[jpad]-p_Vid->pad_size_uv_x, wImgDst[jpad - 1]-p_Vid->pad_size_uv_x, (2 * p_Vid->pad_size_uv_x + size_x_minus1+1) * sizeof(imgpel));
}
}
/*!
************************************************************************
* \brief
* Generic/Diagonal chroma interpolation image generation routine
************************************************************************
*/
static void generateChromaXX( VideoParameters *p_Vid, int size_x_minus1, int size_y_minus1, int weight00, int weight01, int weight10, int weight11, imgpel **wImgDst, imgpel **imgUV)
{
int i;//, j;
int jpad = -p_Vid->pad_size_uv_y;
int cur_value;
imgpel *wBufDst;
imgpel *wBufSrc0, *wBufSrc1;
int weight0001 = weight00 + weight01;
int weight1011 = weight10 + weight11;
int weight0010 = weight00 + weight10;
int weight0111 = weight01 + weight11;
wBufDst = wImgDst[jpad++]-p_Vid->pad_size_uv_x;
wBufSrc0 = imgUV[0];
for (i = -p_Vid->pad_size_uv_x; i < 0; i++)
{
*(wBufDst++) = *wBufSrc0;
}
for (i = 0; i < size_x_minus1; i++)
{
cur_value = weight0010 * (*wBufSrc0++);
cur_value += weight0111 * (*wBufSrc0 );
*(wBufDst++) = (imgpel) rshift_rnd_sf(cur_value, 6);
}
for (i = -1; i < p_Vid->pad_size_uv_x; i++)
{
*(wBufDst++) = *wBufSrc0;
}
for (; jpad < 0; jpad++)
{
memcpy(wImgDst[jpad]-p_Vid->pad_size_uv_x, wImgDst[jpad - 1]-p_Vid->pad_size_uv_x, (2 * p_Vid->pad_size_uv_x + size_x_minus1+1) * sizeof(imgpel));
}
for (jpad = 0; jpad < size_y_minus1; jpad++)
{
wBufDst = wImgDst[jpad]-p_Vid->pad_size_uv_x;
wBufSrc0 = imgUV[jpad];
wBufSrc1 = imgUV[jpad + 1];
cur_value = rshift_rnd_sf(weight0001 * (*wBufSrc0) + weight1011 * (*wBufSrc1), 6 );
for (i = -p_Vid->pad_size_uv_x; i < 0; i++)
{
*(wBufDst++) = (imgpel) cur_value;
}
for (i = 0; i < size_x_minus1; i++)
{
cur_value = weight00 * (*wBufSrc0++) + weight10 * (*wBufSrc1++);
cur_value += weight01 * (*wBufSrc0 ) + weight11 * (*wBufSrc1 );
*(wBufDst++) = (imgpel) rshift_rnd_sf(cur_value, 6);
}
cur_value = rshift_rnd_sf(weight0001 * (*wBufSrc0) + weight1011 * (*wBufSrc1), 6 );
for (i = -1; i < p_Vid->pad_size_uv_x; i++)
{
*(wBufDst++) = (imgpel) cur_value;
}
}
wBufDst = wImgDst[jpad]-p_Vid->pad_size_uv_x;
wBufSrc0 = imgUV[size_y_minus1];
for (i = -p_Vid->pad_size_uv_x; i < 0; i++)
{
*(wBufDst++) = *wBufSrc0;
}
for (i = 0; i < size_x_minus1; i++)
{
cur_value = weight0010 * (*wBufSrc0++);
cur_value += weight0111 * (*wBufSrc0 );
*(wBufDst++) = (imgpel) rshift_rnd_sf(cur_value, 6);
}
for (i = -1; i < p_Vid->pad_size_uv_x; i++)
{
*(wBufDst++) = *wBufSrc0;
}
for (jpad = size_y_minus1+1; jpad < size_y_minus1+1+p_Vid->pad_size_uv_y; jpad++)
{
memcpy(wImgDst[jpad]-p_Vid->pad_size_uv_x, wImgDst[jpad - 1]-p_Vid->pad_size_uv_x, (2 * p_Vid->pad_size_uv_x + size_x_minus1+1) * sizeof(imgpel));
}
}
/*!
************************************************************************
* \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 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
{
