dh263mb.cpp

这是G.723和G.729的音频编解码的源代码

		{MBInfo.CBPB = 0;
	     MODB_index =SADeco->decode_a_symbol(cumf_MODB);
	     MBInfo.MODB = modb_tab[MODB_index];
		 if (MBInfo.MODB == PBMODE_CBPB_MVDB)
			{for(i=0; i<6; i++)
				{YCBPB_index =SADeco->decode_a_symbol(cumf_YCBPB);
				 YCBPB = ycbpb_tab[YCBPB_index];
				 MBInfo.CBPB |= (YCBPB << (5-i));
				}
			}
		}

 	if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
		{ /* Intra */
	     CBPY_index =SADeco->decode_a_symbol(cumf_CBPY_intra);
	     MBInfo.CBPY = cbpy_intratab[CBPY_index];
		}
	else
		{CBPY_index =SADeco->decode_a_symbol(cumf_CBPY);
		 MBInfo.CBPY = cbpytab[CBPY_index];
		}

	CBP = (MBInfo.CBPY << 2) | (MBInfo.MCBPC >> 4);
    if (Mode == MODE_INTER_Q || Mode == MODE_INTRA_Q)
		{/* Read DQUANT if necessary */
		 DQUANT_index =SADeco->decode_a_symbol(cumf_DQUANT);
		 MBInfo.DQUANT = dquanttab[DQUANT_index]-2; 
		 QP=max(Pic.PQUANT,min(31,QP+MBInfo.DQUANT));
		}

    if (Mode == MODE_INTER ||Mode == MODE_INTER_Q||
		Mode == MODE_INTER4V||Pic.PBMode)
		{if (!Pic.APMode)
			{mvx_index =SADeco->decode_a_symbol(cumf_MVD);
			 mvx = mvdtab[mvx_index];
			 mvy_index =SADeco->decode_a_symbol(cumf_MVD);
			 mvy = mvdtab[mvy_index];
			 FindPMV(xpos,ypos,pmvx,pmvy);
			 mvx = MotionDecode(mvx, pmvx);
			 mvy = MotionDecode(mvy, pmvy);
			 (m_pPic->DMV)[Ori].x=mvx/2;
			 (m_pPic->DMV)[Ori].y=mvy/2;
			 (m_pPic->DMV)[Ori].x_half=mvx%2;
			 (m_pPic->DMV)[Ori].y_half=mvy%2;
			 (m_pPic->DMV)[Ori].Mode=Mode;
			}
		 else
			{if (Mode == MODE_INTER4V)
				{startmv = 1;
				 stopmv = 4;
				}
			 else 
				{startmv = 0;
				 stopmv = 0;
				}
			 for (k = startmv; k <= stopmv; k++)
				{mvx_index =SADeco->decode_a_symbol(cumf_MVD);
				 mvx = mvdtab[mvx_index];
				 mvy_index =SADeco->decode_a_symbol(cumf_MVD);
				 mvy = mvdtab[mvy_index];
				 if (k>0) 
					oo=k-1;
				 else
					oo=k;
				 FindAPPMV(xpos,ypos,pmvx,pmvy,oo);
				 mvx = MotionDecode(mvx, pmvx);
				 mvy = MotionDecode(mvy, pmvy);
				 if (k==0)
					{(m_pPic->DMV)[Ori].x=mvx/2;
					 (m_pPic->DMV)[Ori].y=mvy/2;
					 (m_pPic->DMV)[Ori].x_half=mvx%2;
					 (m_pPic->DMV)[Ori].y_half=mvy%2;
					 (m_pPic->DMV)[Ori].Mode=Mode;
					 (m_pPic->DMVAP)[Ori][0]=(m_pPic->DMV)[ypos*WMB+xpos];
					 (m_pPic->DMVAP)[Ori][1]=(m_pPic->DMV)[ypos*WMB+xpos];
					 (m_pPic->DMVAP)[Ori][2]=(m_pPic->DMV)[ypos*WMB+xpos];
					 (m_pPic->DMVAP)[Ori][3]=(m_pPic->DMV)[ypos*WMB+xpos];
					}
				 else
					{(m_pPic->DMVAP)[Ori][oo].x=mvx/2;
					 (m_pPic->DMVAP)[Ori][oo].y=mvy/2;
					 (m_pPic->DMVAP)[Ori][oo].x_half=mvx%2;
					 (m_pPic->DMVAP)[Ori][oo].y_half=mvy%2;
					 (m_pPic->DMVAP)[Ori][oo].Mode=Mode;
					}
				}
			}

		 // PB frame delta vectors 
		 if (Pic.PBMode)
			{if (MBInfo.MODB == PBMODE_MVDB ||MBInfo. MODB == PBMODE_CBPB_MVDB)
				{mvx_index =SADeco->decode_a_symbol(cumf_MVD);
				 mvdbx = mvdtab[mvx_index];
				 mvy_index =SADeco->decode_a_symbol(cumf_MVD);
				 mvdby = mvdtab[mvy_index];
				 mvdbx = MotionDecode(mvdbx, 0);
				 mvdby = MotionDecode(mvdby, 0);
	    		}
			 else
				{mvdbx = 0; 
				 mvdby = 0;
				}
			 (m_pPic->DMVPB)[Ori].x=mvdbx/2;
			 (m_pPic->DMVPB)[Ori].y=mvdby/2;
			 (m_pPic->DMVPB)[Ori].x_half=mvdbx%2;
			 (m_pPic->DMVPB)[Ori].y_half=mvdby%2;
			}
		}
	if (Pic.PictureType==PCT_INTER)
		if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) 
			if (!Pic.PBMode)
				{ZeroVec((m_pPic->DMV)[Ori]);
				 if (Pic.APMode)
					{ZeroVec((m_pPic->DMVAP)[Ori][0]);
					 ZeroVec((m_pPic->DMVAP)[Ori][1]);
					 ZeroVec((m_pPic->DMVAP)[Ori][2]);
					 ZeroVec((m_pPic->DMVAP)[Ori][3]);
					}
				}

	return 1;
}

int DH263MB::DecodeCoeff(DBitStream *InputStream)
{	int i,DC;
	HuffmanDec VLDec(InputStream);

	if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
		for (i=0;i<6;i++)
			{DC=InputStream->GetVarible(8);
			 if (DC==128)
				return -1;
			 if (DC== 255)  /* Spec. in H.26P, not in TMN4 */
				DC=128;
			 QCoeff[i*64]=DC; /* Iquant */
			 if (CBP&AndValue[i])
				VLDec.GetIntraBlock(QCoeff+64*i);
			}
	else 
		for (i=0;i<6;i++)
			if (CBP&AndValue[i])
				VLDec.GetInterBlock(QCoeff+64*i);
	return 0;
}	  

int  DH263MB::SACDecodeCoeff(SAD *SADeco)
{	int i,DC,INTRADC_index;
	if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
		for (i=0;i<6;i++)
			{INTRADC_index =SADeco->decode_a_symbol(cumf_INTRADC);
			 DC= intradctab[INTRADC_index];
			 if (DC==128)
				return -1;
			 if (DC== 255)  /* Spec. in H.26P, not in TMN4 */
				DC=128;
			 QCoeff[i*64]=DC; /* Iquant */
			 if (CBP&AndValue[i])
				 SADeco->GetIntraBlock(QCoeff+64*i);
			}
	else
		for (i=0;i<6;i++)
			if (CBP&AndValue[i])
				SADeco->GetInterBlock(QCoeff+64*i);
	return 0;
}

int DH263MB::MotionDecode(int vec,int pmv)
{	if (vec > 31) 
		vec -= 64;
	vec += pmv;
	if (vec > 31)
		vec -= 64;
	if (vec < -32)
		vec += 64;
	return vec;
}

void DH263MB::FindAPPMV(int x,int y,int &pmvx,int &pmvy,int block)
{	int p1x,p2x,p3x,p1y,p2y,p3y;

	if (block==0)
		{if (x==0)
			{pmvx=0;
			 pmvy=0;
			}
		 else
			{pmvx=2*(m_pPic->DMVAP)[y*WMB+x-1][1].x+(m_pPic->DMVAP)[y*WMB+x-1][1].x_half;
			 pmvy=2*(m_pPic->DMVAP)[y*WMB+x-1][1].y+(m_pPic->DMVAP)[y*WMB+x-1][1].y_half;
			}
		 return;
		}
	
	if (block==1)
		{pmvx=2*(m_pPic->DMVAP)[y*WMB+x][0].x+(m_pPic->DMVAP)[y*WMB+x][0].x_half;
		 pmvy=2*(m_pPic->DMVAP)[y*WMB+x][0].y+(m_pPic->DMVAP)[y*WMB+x][0].y_half;
		 return;
		}

	if (block==2)
		{if (x==0)
			{p1x=0;
			 p1y=0;
			}
		 else
			{p1x=2*(m_pPic->DMVAP)[y*WMB+x-1][3].x+(m_pPic->DMVAP)[y*WMB+x-1][3].x_half;
			 p1y=2*(m_pPic->DMVAP)[y*WMB+x-1][3].y+(m_pPic->DMVAP)[y*WMB+x-1][3].y_half;
			}
		 p2x=2*(m_pPic->DMVAP)[y*WMB+x][0].x+(m_pPic->DMVAP)[y*WMB+x][0].x_half;
		 p2y=2*(m_pPic->DMVAP)[y*WMB+x][0].y+(m_pPic->DMVAP)[y*WMB+x][0].y_half;
		 p3x=2*(m_pPic->DMVAP)[y*WMB+x][1].x+(m_pPic->DMVAP)[y*WMB+x][1].x_half;
		 p3y=2*(m_pPic->DMVAP)[y*WMB+x][1].y+(m_pPic->DMVAP)[y*WMB+x][1].y_half;
		 pmvx=p1x+p2x+p3x-max(p1x,max(p2x,p3x))-min(p1x,min(p2x,p3x));
		 pmvy=p1y+p2y+p3y-max(p1y,max(p2y,p3y))-min(p1y,min(p2y,p3y));
		 return ;
		}

	if (block==3)
		{p1x=2*(m_pPic->DMVAP)[y*WMB+x][2].x+(m_pPic->DMVAP)[y*WMB+x][2].x_half;
		 p1y=2*(m_pPic->DMVAP)[y*WMB+x][2].y+(m_pPic->DMVAP)[y*WMB+x][2].y_half;
		 p2x=2*(m_pPic->DMVAP)[y*WMB+x][0].x+(m_pPic->DMVAP)[y*WMB+x][0].x_half;
		 p2y=2*(m_pPic->DMVAP)[y*WMB+x][0].y+(m_pPic->DMVAP)[y*WMB+x][0].y_half;
		 p3x=2*(m_pPic->DMVAP)[y*WMB+x][1].x+(m_pPic->DMVAP)[y*WMB+x][1].x_half;
		 p3y=2*(m_pPic->DMVAP)[y*WMB+x][1].y+(m_pPic->DMVAP)[y*WMB+x][1].y_half;
		 pmvx=p1x+p2x+p3x-max(p1x,max(p2x,p3x))-min(p1x,min(p2x,p3x));
		 pmvy=p1y+p2y+p3y-max(p1y,max(p2y,p3y))-min(p1y,min(p2y,p3y));
		 return ;
		}
}

void DH263MB::FindPMV(int x,int y,int &pmvx,int &pmvy)
{
	if (x==0)
		{pmvx=0;
		 pmvy=0;
		}
	else
		{pmvx=2*(m_pPic->DMV)[y*WMB+x-1].x+(m_pPic->DMV)[y*WMB+x-1].x_half;
		 pmvy=2*(m_pPic->DMV)[y*WMB+x-1].y+(m_pPic->DMV)[y*WMB+x-1].y_half;
		}
}

void DH263MB::MB_Recon_P(YUVData Loss,YUVData Inter,int xpos, int ypos)
{	int RefWidth,Ori;
	BYTE *Select,RefBlockData[MB_SIZE*MB_SIZE+8],UVData[MB_SIZE*MB_SIZE/4+8];
	BYTE *RefBlock=RefBlockData,*UV=UVData;
	int VectorW,VectorH;

	if ((int)RefBlock%8)
		RefBlock+=(8-(int)RefBlock%8);
	if ((int)UV%8)
		UV+=(8-(int)UV%8);

	if (Pic.UMVMode)
		RefWidth=Width+32;
	else
		RefWidth=Width;
	Ori=ypos/MB_SIZE*WMB+xpos/MB_SIZE;

	VectorW=2*(m_pPic->DMV)[Ori].x+(m_pPic->DMV)[Ori].x_half;
	VectorH=2*(m_pPic->DMV)[Ori].y+(m_pPic->DMV)[Ori].y_half;
	Select=Loss.Y+ypos*Width+xpos;
	LoadRefer(Inter.Y,RefBlock,ypos*2+VectorH,xpos*2+VectorW,2*RefWidth,MB_SIZE,m_pPic->StrPrevInt);
	MMXReconMB(Select,RefBlock,MBData.lum,Width);

	if ((m_pPic->DMV)[Ori].x_half)
		{if (VectorW>=0)
			 VectorW=(m_pPic->DMV)[Ori].x+1-(m_pPic->DMV)[Ori].x%2;
		 else
			 VectorW=(m_pPic->DMV)[Ori].x-1-(m_pPic->DMV)[Ori].x%2;
		}
	else
		VectorW=(m_pPic->DMV)[Ori].x;
	if ((m_pPic->DMV)[Ori].y_half)
		{if (VectorH>=0)
			 VectorH=(m_pPic->DMV)[Ori].y+1-(m_pPic->DMV)[Ori].y%2;
		 else
			 VectorH=(m_pPic->DMV)[Ori].y-1-(m_pPic->DMV)[Ori].y%2;
		}
	else
		VectorH=(m_pPic->DMV)[Ori].y;

	Select=Loss.U+ypos/2*Width/2+xpos/2;
	LoadCBRefer(Inter.U,UV,ypos+VectorH,xpos+VectorW,RefWidth,MB_SIZE/2,m_pPic->StrPrevInt);
	MMXReconBlock(Select,UV,MBData.CB,Width/2);

	Select=Loss.V+ypos/2*Width/2+xpos/2;
	LoadCRRefer(Inter.V,UV,ypos+VectorH,xpos+VectorW,RefWidth,MB_SIZE/2,m_pPic->StrPrevInt);
	MMXReconBlock(Select,UV,MBData.CR,Width/2);
}

void DH263MB::MB_Recon_P4V(YUVData Loss,YUVData Inter,int xpos, int ypos)
{	int RefWidth,k,Ori;
	BYTE *SelectPtr,UVData[MB_SIZE*MB_SIZE/4+8],*UV=UVData;
	int VectorW,VectorH;
	int MVCHR[16]={0,0,0,1,1,1,1,1,1,1,1,1,1,1,2,2};

	if ((int)UV%8)
		UV+=(8-(int)UV%8);
	if (Pic.UMVMode)
		RefWidth=Width+32;
	else
		RefWidth=Width;

	Ori=ypos/MB_SIZE*WMB+xpos/MB_SIZE;
	for (k=0;k<4;k++)
		{SelectPtr=Loss.Y+(ypos+k/2*MB_SIZE/2)*Width+xpos+k%2*MB_SIZE/2;
		 VectorW=2*(m_pPic->DMVAP)[Ori][k].x+(m_pPic->DMVAP)[Ori][k].x_half;
		 VectorH=2*(m_pPic->DMVAP)[Ori][k].y+(m_pPic->DMVAP)[Ori][k].y_half;
		 LoadRefer(Inter.Y,UV,(ypos+k/2*MB_SIZE/2)*2+VectorH,
			 (xpos+k%2*MB_SIZE/2)*2+VectorW,2*RefWidth,MB_SIZE/2,m_pPic->StrPrevInt);

		 MMXReconAPBlock(SelectPtr,UV,
			MBData.lum+k/2*128+k%2*8,Width);
		}

	VectorW=2*(m_pPic->DMVAP)[Ori][0].x+(m_pPic->DMVAP)[Ori][0].x_half
		   +2*(m_pPic->DMVAP)[Ori][1].x+(m_pPic->DMVAP)[Ori][1].x_half
		   +2*(m_pPic->DMVAP)[Ori][2].x+(m_pPic->DMVAP)[Ori][2].x_half
		   +2*(m_pPic->DMVAP)[Ori][3].x+(m_pPic->DMVAP)[Ori][3].x_half;
	VectorH=2*(m_pPic->DMVAP)[Ori][0].y+(m_pPic->DMVAP)[Ori][0].y_half
		   +2*(m_pPic->DMVAP)[Ori][1].y+(m_pPic->DMVAP)[Ori][1].y_half
		   +2*(m_pPic->DMVAP)[Ori][2].y+(m_pPic->DMVAP)[Ori][2].y_half
		   +2*(m_pPic->DMVAP)[Ori][3].y+(m_pPic->DMVAP)[Ori][3].y_half;
	if (VectorW>=0)
		VectorW=VectorW/16*2+MVCHR[VectorW%16];
	else
		VectorW=VectorW/16*2-MVCHR[-(VectorW%16)];
	if (VectorH>=0)
		VectorH=VectorH/16*2+MVCHR[VectorH%16];
	else
		VectorH=VectorH/16*2-MVCHR[-(VectorH%16)];

	SelectPtr=Loss.U+ypos/2*Width/2+xpos/2;
	LoadCBRefer(Inter.U,UV,ypos+VectorH,xpos+VectorW,RefWidth,MB_SIZE/2,m_pPic->StrPrevInt);
	MMXReconBlock(SelectPtr,UV,MBData.CB,Width/2);

	SelectPtr=Loss.V+ypos/2*Width/2+xpos/2;
	LoadCRRefer(Inter.V,UV,ypos+VectorH,xpos+VectorW,RefWidth,MB_SIZE/2,m_pPic->StrPrevInt);
	MMXReconBlock(SelectPtr,UV,MBData.CR,Width/2);
}