/*! ************************************************************************ * \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 {