block.c

Mobile IP VCEG的信道模拟程序

			run=-1;
			ilev=level*JQ[quant_set][1];
		}
		m1[coeff_ctr]=sign(ilev,m1[coeff_ctr]);
	}

	img->cofu[scan_pos][0][uv]=0;

	/*  Invers transform of 2x2 DC levels */

	img->m7[0][0]=(m1[0]+m1[1]+m1[2]+m1[3])/2;
	img->m7[4][0]=(m1[0]-m1[1]+m1[2]-m1[3])/2;
	img->m7[0][4]=(m1[0]+m1[1]-m1[2]-m1[3])/2;
	img->m7[4][4]=(m1[0]-m1[1]-m1[2]+m1[3])/2;

	/*     Quant of chroma AC-coeffs. */

	for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
	{
		for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
		{
			pos_x=n1/BLOCK_SIZE + 2*uv;
			pos_y=n2/BLOCK_SIZE + BLOCK_SIZE;
			run=-1;
			scan_pos=0;

			for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)
			{
				i=SNGL_SCAN[coeff_ctr][0];
				j=SNGL_SCAN[coeff_ctr][1];
				coeff[coeff_ctr-1]=img->m7[n1+i][n2+j];
			}
			rd_quant(QUANT_CHROMA_AC,coeff);

			for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)
			{
				i=SNGL_SCAN[coeff_ctr][0];
				j=SNGL_SCAN[coeff_ctr][1];
				++run;
				ilev=0;

				level=absm(coeff[coeff_ctr-1]);
				if (level  != 0)
				{
					cr_cbp=2;
					img->cof[pos_x][pos_y][scan_pos][0][0]=sign(level,img->m7[n1+i][n2+j]);
					img->cof[pos_x][pos_y][scan_pos][1][0]=run;
					++scan_pos;
					run=-1;
					ilev=level*JQ[quant_set][1];
				}
				img->m7[n1+i][n2+j]=sign(ilev,img->m7[n1+i][n2+j]); /* for use in IDCT */
			}
			img->cof[pos_x][pos_y][scan_pos][0][0]=0; /* EOB */


			/*     IDCT. */

			/*     Horizontal. */
			for (j=0; j < BLOCK_SIZE; j++)
			{
				for (i=0; i < BLOCK_SIZE; i++)
				{
					m5[i]=img->m7[n1+i][n2+j];
				}
				m6[0]=(m5[0]+m5[2])*13;
				m6[1]=(m5[0]-m5[2])*13;
				m6[2]=m5[1]*7-m5[3]*17;
				m6[3]=m5[1]*17+m5[3]*7;

				for (i=0; i < 2; i++)
				{
					i1=3-i;
					img->m7[n1+i][n2+j]=m6[i]+m6[i1];
					img->m7[n1+i1][n2+j]=m6[i]-m6[i1];
				}
			}

			/*     Vertical. */
			for (i=0; i < BLOCK_SIZE; i++)
			{
				for (j=0; j < BLOCK_SIZE; j++)
				{
					m5[j]=img->m7[n1+i][n2+j];
				}
				m6[0]=(m5[0]+m5[2])*13;
				m6[1]=(m5[0]-m5[2])*13;
				m6[2]=m5[1]*7-m5[3]*17;
				m6[3]=m5[1]*17+m5[3]*7;

				for (j=0; j < 2; j++)
				{
					j2=3-j;
					img->m7[n1+i][n2+j]=min(255,max(0,(m6[j]+m6[j2]+img->mpr[n1+i][n2+j]*JQQ1+JQQ2)/JQQ1));
					img->m7[n1+i][n2+j2]=min(255,max(0,(m6[j]-m6[j2]+img->mpr[n1+i][n2+j2]*JQQ1+JQQ2)/JQQ1));
				}
			}
		}
	}

	/*  Decoded block moved to memory */
	for (j=0; j < BLOCK_SIZE*2; j++)
		for (i=0; i < BLOCK_SIZE*2; i++)
		{
			imgUV[uv][img->pix_c_y+j][img->pix_c_x+i]= img->m7[i][j];
		}

	return cr_cbp;
}
#endif
#ifdef NO_RDQUANT
int dct_chroma(int uv,int cr_cbp)
{
	int i,j,i1,j2,ilev,n2,n1,j1,mb_y,coeff_ctr,qp_const,pos_x,pos_y,quant_set,level ,scan_pos,run;
	int m1[BLOCK_SIZE],m5[BLOCK_SIZE],m6[BLOCK_SIZE];
//	int coeff[16];
  int coeff_cost;//CHROMA_CHANGE
  int cr_cbp_tmp;//CHROMA_CHANGE
  int nn0,nn1;//CHROMA_CHANGE

	if (img->type == INTRA_IMG)
		qp_const=JQQ3;
	else
		qp_const=JQQ4;

	for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
	{
		for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
		{

			/*  Horizontal transform. */
			for (j=0; j < BLOCK_SIZE; j++)
			{
				mb_y=n2+j;
				for (i=0; i < 2; i++)
				{
					i1=3-i;
					m5[i]=img->m7[i+n1][mb_y]+img->m7[i1+n1][mb_y];
					m5[i1]=img->m7[i+n1][mb_y]-img->m7[i1+n1][mb_y];
				}
				img->m7[n1][mb_y]=(m5[0]+m5[1])*13;
				img->m7[n1+2][mb_y]=(m5[0]-m5[1])*13;
				img->m7[n1+1][mb_y]=m5[3]*17+m5[2]*7;
				img->m7[n1+3][mb_y]=m5[3]*7-m5[2]*17;
			}

			/*  Vertical transform. */

			for (i=0; i < BLOCK_SIZE; i++)
			{
				j1=n1+i;
				for (j=0; j < 2; j++)
				{
					j2=3-j;
					m5[j]=img->m7[j1][n2+j]+img->m7[j1][n2+j2];
					m5[j2]=img->m7[j1][n2+j]-img->m7[j1][n2+j2];
				}
				img->m7[j1][n2+0]=(m5[0]+m5[1])*13;
				img->m7[j1][n2+2]=(m5[0]-m5[1])*13;
				img->m7[j1][n2+1]=m5[3]*17+m5[2]*7;
				img->m7[j1][n2+3]=m5[3]*7-m5[2]*17;
			}
		}
	}

	/*     2X2 transform of DC coeffs. */
	m1[0]=(img->m7[0][0]+img->m7[4][0]+img->m7[0][4]+img->m7[4][4])/2;
	m1[1]=(img->m7[0][0]-img->m7[4][0]+img->m7[0][4]-img->m7[4][4])/2;
	m1[2]=(img->m7[0][0]+img->m7[4][0]-img->m7[0][4]-img->m7[4][4])/2;
	m1[3]=(img->m7[0][0]-img->m7[4][0]-img->m7[0][4]+img->m7[4][4])/2;

/*     Quant of chroma 2X2 coeffs.*/
	quant_set=QP_SCALE_CR[img->qp];
	run=-1;
	scan_pos=0;

	for (coeff_ctr=0; coeff_ctr < 4; coeff_ctr++)
  {
		run++;
		ilev=0;

		level =(abs(m1[coeff_ctr])*JQ[quant_set][0]+qp_const)/JQQ1;// CHANGE rd_quant removed
		if (level  != 0)
		{
			cr_cbp=max(1,cr_cbp);
			img->cofu[scan_pos][0][uv]=sign(level ,m1[coeff_ctr]);
			img->cofu[scan_pos][1][uv]=run;
			scan_pos++;
			run=-1;
			ilev=level*JQ[quant_set][1];
		}
		m1[coeff_ctr]=sign(ilev,m1[coeff_ctr]);
	}
	img->cofu[scan_pos][0][uv]=0;

	/*  Invers transform of 2x2 DC levels */

	img->m7[0][0]=(m1[0]+m1[1]+m1[2]+m1[3])/2;
	img->m7[4][0]=(m1[0]-m1[1]+m1[2]-m1[3])/2;
	img->m7[0][4]=(m1[0]+m1[1]-m1[2]-m1[3])/2;
	img->m7[4][4]=(m1[0]-m1[1]-m1[2]+m1[3])/2;

	/*     Quant of chroma AC-coeffs. */
  coeff_cost=0;//CHROMA_CHANGE
  cr_cbp_tmp=0;//CHROMA_CHANGE

	for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
	{
		for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
		{
			pos_x=n1/BLOCK_SIZE + 2*uv;
			pos_y=n2/BLOCK_SIZE + BLOCK_SIZE;
			run=-1;
			scan_pos=0;

			for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)//start change rd_quant
			{
				i=SNGL_SCAN[coeff_ctr][0];
				j=SNGL_SCAN[coeff_ctr][1];
				++run;
				ilev=0;

        level=(abs(img->m7[n1+i][n2+j])*JQ[quant_set][0]+qp_const)/JQQ1;// CHANGE rd_quant removed
				if (level  != 0)
				{
					if (level > 1) //CHROMA_CHANGE
						coeff_cost += MAX_VALUE;                /* set high cost, shall not be discarded */
					else
						coeff_cost += COEFF_COST[run];//CHROMA_CHANGE

					cr_cbp_tmp=2;//CHROMA_CHANGE
					img->cof[pos_x][pos_y][scan_pos][0][0]=sign(level,img->m7[n1+i][n2+j]);
					img->cof[pos_x][pos_y][scan_pos][1][0]=run;
					++scan_pos;
					run=-1;
					ilev=level*JQ[quant_set][1];
				}
				img->m7[n1+i][n2+j]=sign(ilev,img->m7[n1+i][n2+j]); /* for use in IDCT */
			}
			img->cof[pos_x][pos_y][scan_pos][0][0]=0; /* EOB */
    }//CHROMA_CHANGE
  }//CHROMA_CHANGE

  //CHROMA_CHANGE start
  //* reset chroma coeffs
  if(coeff_cost<7)
  {
    cr_cbp_tmp=0;
	  for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)
    {
		  for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)
      {
			  nn0=n1/4+2*uv;
        nn1=4+n2/4;
        img->cof[nn0][nn1][0][0][0]=0;//dc coeff
        for (coeff_ctr=1; coeff_ctr < 16; coeff_ctr++)//ac coeff
        {
          i=SNGL_SCAN[coeff_ctr][0];
				  j=SNGL_SCAN[coeff_ctr][1];
          img->m7[n1+i][n2+j]=0;
          img->cof[nn0][nn1][coeff_ctr][0][0]=0;
        }
      }
    }
  }
  if(cr_cbp_tmp==2)
      cr_cbp=2;
 //CHROMA_CHANGE stopp 
  /*     IDCT. */

			/*     Horizontal. */
  for (n2=0; n2 <= BLOCK_SIZE; n2 += BLOCK_SIZE)//CHROMA_CHANGE
	{
		for (n1=0; n1 <= BLOCK_SIZE; n1 += BLOCK_SIZE)//CHROMA_CHANGE
		{
			for (j=0; j < BLOCK_SIZE; j++)
			{
				for (i=0; i < BLOCK_SIZE; i++)
				{
					m5[i]=img->m7[n1+i][n2+j];
				}
				m6[0]=(m5[0]+m5[2])*13;
				m6[1]=(m5[0]-m5[2])*13;
				m6[2]=m5[1]*7-m5[3]*17;
				m6[3]=m5[1]*17+m5[3]*7;

				for (i=0; i < 2; i++)
				{
					i1=3-i;
					img->m7[n1+i][n2+j]=m6[i]+m6[i1];
					img->m7[n1+i1][n2+j]=m6[i]-m6[i1];
				}
			}

			/*     Vertical. */
			for (i=0; i < BLOCK_SIZE; i++)
			{
				for (j=0; j < BLOCK_SIZE; j++)
				{
					m5[j]=img->m7[n1+i][n2+j];
				}
				m6[0]=(m5[0]+m5[2])*13;
				m6[1]=(m5[0]-m5[2])*13;
				m6[2]=m5[1]*7-m5[3]*17;
				m6[3]=m5[1]*17+m5[3]*7;

				for (j=0; j < 2; j++)
				{
					j2=3-j;
					img->m7[n1+i][n2+j]=min(255,max(0,(m6[j]+m6[j2]+img->mpr[n1+i][n2+j]*JQQ1+JQQ2)/JQQ1));
					img->m7[n1+i][n2+j2]=min(255,max(0,(m6[j]-m6[j2]+img->mpr[n1+i][n2+j2]*JQQ1+JQQ2)/JQQ1));
				}
			}
		}
	}

	/*  Decoded block moved to memory */
	for (j=0; j < BLOCK_SIZE*2; j++)
		for (i=0; i < BLOCK_SIZE*2; i++)
		{
			imgUV[uv][img->pix_c_y+j][img->pix_c_x+i]= img->m7[i][j];
		}

	return cr_cbp;
}


#endif




#ifndef NO_RDQUANT
void rd_quant(int scan_type,int *coeff)
{
	int idx,coeff_ctr;
	int qp_const,intra_add;

	int dbl_coeff_ctr;
	int level0,level1;
	int snr0;
	int dbl_coeff,k,k1,k2,rd_best,best_coeff_comb,rd_curr,snr1;
	int k0;
	int quant_set;
	int ilev,run,level;
	int no_coeff;

	if (img->type == INTRA_IMG)
	{
		qp_const=JQQ3;
		intra_add=2;
	}
	else
	{
		qp_const=JQQ4;
		intra_add=0;
	}
	quant_set=img->qp;

	switch (scan_type)
	{
	case  QUANT_LUMA_SNG:
		quant_set=img->qp;
		idx=2;
		no_coeff=16;
		break;
	case  QUANT_LUMA_AC:
		quant_set=img->qp;
		idx=2;
		no_coeff=15;
		break;
	case QUANT_LUMA_DBL:
		quant_set=img->qp;
		idx=1;
		no_coeff=8;
		break;
	case QUANT_CHROMA_DC:
		quant_set=QP_SCALE_CR[img->qp];
		idx=0;
		no_coeff=4;
		break;
	case QUANT_CHROMA_AC:
		quant_set=QP_SCALE_CR[img->qp];
		idx=2;
		no_coeff=15;
		break;
	default:
		break;
	}

	dbl_coeff_ctr=0;
	for (coeff_ctr=0;coeff_ctr < no_coeff ;coeff_ctr++)
	{
		k0=coeff[coeff_ctr];
		k1=abs(k0);

		if (dbl_coeff_ctr < MAX_TWO_LEVEL_COEFF)  /* limit the number of 'twin' levels */
		{
			level0 = (k0*JQ[quant_set][0])/J20;
			level1 = (k1*JQ[quant_set][0]+JQ4)/J20; /* make positive summation */
			level1 = sign(level1,k0);/* set back sign on level */
		}
		else
		{
			level0 = (k1*JQ[quant_set][0]+qp_const)/J20;
			level0 = sign(level0,k0);
			level1 = level0;
		}

		if (level0 != level1)
		{
			dbl_coeff = TRUE;     /* decision is still open */
			dbl_coeff_ctr++;      /* count number of coefficients with 2 possible levels */
		}
		else
			dbl_coeff = FALSE;    /* level is decided       */


		snr0 = (12+intra_add)*level0*(64*level0 - (JQ[quant_set][0]*coeff[coeff_ctr])/J13); /* find SNR improvement */

		level_arr[coeff_ctr][MTLC_POW]=0; /* indicates that all coefficients are decided */

		for (k=0; k< MTLC_POW; k++)
		{
			level_arr[coeff_ctr][k]=level0;
			snr_arr[coeff_ctr][k]=snr0;
		}
		if (dbl_coeff)
		{
			snr1 = (12+intra_add)*level1*(64*level1 - (JQ[quant_set][0]*coeff[coeff_ctr])/J13);
			ilev= (int)pow(2,dbl_coeff_ctr-1);
			for (k1=ilev; k1<MTLC_POW; k1+=ilev*2)
			{
				for (k2=k1; k2<k1+ilev; k2++)
				{
					level_arr[coeff_ctr][k2]=level1;
					snr_arr[coeff_ctr][k2]=snr1;
				}
			}
		}
	}

	rd_best=0;
	best_coeff_comb= MTLC_POW;      /* initial setting, used if no double decision coefficients */
	for (k=0; k < pow(2,dbl_coeff_ctr);k++) /* go through all combinations */
	{
		rd_curr=0;
		run=-1;
		for (coeff_ctr=0;coeff_ctr < no_coeff;coeff_ctr++)
		{
			run++;
			level=min(16,absm(level_arr[coeff_ctr][k]));
			if (level != 0)
			{
				rd_curr += 64*COEFF_BIT_COST[idx][run][level-1]+snr_arr[coeff_ctr][k];
				run = -1;
			}
		}
		if (rd_curr < rd_best)
		{
			rd_best=rd_curr;
			best_coeff_comb=k;
		}
	}
	for (coeff_ctr=0;coeff_ctr < no_coeff ;coeff_ctr++)
		coeff[coeff_ctr]=level_arr[coeff_ctr][best_coeff_comb];

	return;
}

#endif