pictureb.cpp

H.263的编码程序,加了CPU指令优化,VC版.

		else
		{
			encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
		}
		flag = flag >> 1;
		qcoeff_p+=64;
		
		//! Cr block
		curr_block = curr_mb.pCr;
		recon_block = recon_mb.pCr;
		
		encoder->method.pred_chrom_bid(pix_x/2, pix_y/2, ref_img->pCr, next_img->pCr, lx_ref_c, dxf, dyf, dxb, dyb, pred_block);
		
		encoder->method.make_diff(curr_block, pic_width/2, pred_block, diff_block);
		
		if (block_SAD(diff_block) > sad_gate)
		{		
			encoder->method.DCT(diff_block, diff_block);
			if (encoder->method.Quant_blk_P(diff_block, qcoeff_p, QP))               
			{
				cbp|=flag;
				encoder->method.DeQuant_blk_P (qcoeff_p, diff_block, QP);      
				encoder->method.IDCT(diff_block, diff_block);
				encoder->method.recon_pic(recon_block, rec_width/2, pred_block, diff_block);
			}
			else
			{
				encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
			}
		}
		else
		{
			encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
		}		
	}
	/* forward mode */
	else if (B_FORWARD == pred_mode)
	{
		//! Encode each block in the MB
		//!4 lum blocks
		for (i = 0; i < 16; i+=8)
		{
			for (j = 0; j < 16; j+=8)
			{
				curr_block = curr_mb.pLum + i*pic_width + j;
				recon_block = recon_mb.pLum + i*rec_width + j;
				
				MV = MC->mv_frame[0][mb_y+1][mb_x+1];
				
				encoder->method.pred_lum(pix_x+j, pix_y+i, MV, prev_ipol, lx_ipol, pred_block);
				encoder->method.make_diff(curr_block, pic_width, pred_block, diff_block);
				
				if (block_SAD(diff_block) > sad_gate)
				{
					encoder->method.DCT( diff_block, diff_block);
					if (encoder->method.Quant_blk_P(diff_block, qcoeff_p, QP)) 
						
					{
						cbp|=flag;
						encoder->method.DeQuant_blk_P(qcoeff_p, diff_block, QP);  
						encoder->method.IDCT(diff_block, diff_block);
						encoder->method.recon_pic(recon_block, rec_width, pred_block, diff_block);
					}
					else
					{
						encoder->method.block_copy1(recon_block, pred_block, rec_width);
					}
				}
				else
				{
					encoder->method.block_copy1(recon_block, pred_block, rec_width);
				}
				flag = flag >> 1;
				qcoeff_p+=64;			
			}
		}
		/* only find forward MV for chrom blocks in forward mode */
        findchromMV(encoder, MC, pix_x, pix_y, &dxf, &dyf, 0);
		
		//! Cb block
		curr_block = curr_mb.pCb;
		recon_block = recon_mb.pCb;
		
		encoder->method.pred_chrom(pix_x/2, pix_y/2, ref_img->pCb, lx_ref_c, dxf, dyf, pred_block);
		
		encoder->method.make_diff(curr_block, pic_width/2, pred_block, diff_block);
		
		if (block_SAD(diff_block) > sad_gate)
		{
			encoder->method.DCT(diff_block, diff_block);
			if (encoder->method.Quant_blk_P(diff_block, qcoeff_p, QP))               
			{
				
				cbp|=flag;
				encoder->method.DeQuant_blk_P (qcoeff_p, diff_block, QP);  
				encoder->method.IDCT(diff_block, diff_block);
				encoder->method.recon_pic(recon_block, rec_width/2, pred_block, diff_block);
			}
			else
			{
				encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
			}
		}
		else
		{
			encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
		}
		flag = flag >> 1;
		qcoeff_p+=64;
		
		//! Cr block
		curr_block = curr_mb.pCr;
		recon_block = recon_mb.pCr;
		
		encoder->method.pred_chrom(pix_x/2, pix_y/2, ref_img->pCr, lx_ref_c, dxf, dyf, pred_block);
		
		encoder->method.make_diff(curr_block, pic_width/2, pred_block, diff_block);
		
		if (block_SAD(diff_block) > sad_gate)
		{
			encoder->method.DCT(diff_block, diff_block);
			if (encoder->method.Quant_blk_P(diff_block, qcoeff_p, QP))               
			{
				cbp|=flag;
				encoder->method.DeQuant_blk_P (qcoeff_p, diff_block, QP);      
				encoder->method.IDCT(diff_block, diff_block);
				encoder->method.recon_pic(recon_block, rec_width/2, pred_block, diff_block);
			}
			else
			{
				encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
			}
		}
		else
		{
			encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
		}
	}
	/* backward mode */
	else if (B_BACKWARD == pred_mode)
	{
		//! Encode each block in the MB
		//!4 lum blocks
		for (i = 0; i < 16; i+=8)
		{
			for (j = 0; j < 16; j+=8)
			{
				curr_block = curr_mb.pLum + i*pic_width + j;
				recon_block = recon_mb.pLum + i*rec_width + j;
				
				MV = MC->mv_frame[5][mb_y+1][mb_x+1];
				
				encoder->method.pred_lum(pix_x+j, pix_y+i, MV, next_ipol, lx_ipol, pred_block);
				encoder->method.make_diff(curr_block, pic_width, pred_block, diff_block);
				
				if (block_SAD(diff_block) > sad_gate)
				{
					encoder->method.DCT(diff_block, diff_block);
					if (encoder->method.Quant_blk_P(diff_block, qcoeff_p, QP)) 
						
					{
						cbp|=flag;
						encoder->method.DeQuant_blk_P(qcoeff_p, diff_block, QP);  
						encoder->method.IDCT(diff_block, diff_block);
						encoder->method.recon_pic(recon_block, rec_width, pred_block, diff_block);
					}
					else
					{
						encoder->method.block_copy1(recon_block, pred_block, rec_width);
					}
				}
				else
				{
					encoder->method.block_copy1(recon_block, pred_block, rec_width);
				}
				flag = flag >> 1;
				qcoeff_p+=64;			
			}
		}
		/* only find backward MV for chrom blocks in backward mode */
        findchromMV(encoder, MC, pix_x, pix_y, &dxb, &dyb, 1);		
		
		//! Cb block
		curr_block = curr_mb.pCb;
		recon_block = recon_mb.pCb;
		
		encoder->method.pred_chrom(pix_x/2, pix_y/2, next_img->pCb, lx_ref_c, dxb, dyb, pred_block);
		
		encoder->method.make_diff(curr_block, pic_width/2, pred_block, diff_block);
		
		if (block_SAD(diff_block) > sad_gate)
		{
			encoder->method.DCT(diff_block, diff_block);
			if (encoder->method.Quant_blk_P(diff_block, qcoeff_p, QP))               
			{
				
				cbp|=flag;
				encoder->method.DeQuant_blk_P (qcoeff_p, diff_block, QP);  
				encoder->method.IDCT(diff_block, diff_block);
				encoder->method.recon_pic(recon_block, rec_width/2, pred_block, diff_block);
			}
			else
			{
				encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
			}
		}
		else
		{
			encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
		}
		flag = flag >> 1;
		qcoeff_p+=64;
		
		//! Cr block
		curr_block = curr_mb.pCr;
		recon_block = recon_mb.pCr;
		
		encoder->method.pred_chrom(pix_x/2, pix_y/2, next_img->pCr, lx_ref_c, dxb, dyb, pred_block);
		
		encoder->method.make_diff(curr_block, pic_width/2, pred_block, diff_block);
		
		if (block_SAD(diff_block) > sad_gate)
		{
			encoder->method.DCT(diff_block, diff_block);		
			if (encoder->method.Quant_blk_P(diff_block, qcoeff_p, QP))               
			{
				cbp|=flag;
				encoder->method.DeQuant_blk_P (qcoeff_p, diff_block, QP);      
				encoder->method.IDCT(diff_block, diff_block);
				encoder->method.recon_pic(recon_block, rec_width/2, pred_block, diff_block);
			}
			else
			{
				encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
			}
		}
		else
		{
			encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
		}
	}
	/* bi-direction mode */
	else if (B_BIDIRECTIONAL == pred_mode)
	{
		//! Encode each block in the MB
		//!4 lum blocks
		for (i = 0; i < 16; i+=8)
		{
			for (j = 0; j < 16; j+=8)
			{
				curr_block = curr_mb.pLum + i*pic_width + j;
				recon_block = recon_mb.pLum + i*rec_width + j;
				
				dxf = MC->mv_frame[0][mb_y+1][mb_x+1]->x*2 + MC->mv_frame[0][mb_y+1][mb_x+1]->x_half;
				dyf = MC->mv_frame[0][mb_y+1][mb_x+1]->y*2 + MC->mv_frame[0][mb_y+1][mb_x+1]->y_half;
				dxb = MC->mv_frame[5][mb_y+1][mb_x+1]->x*2 + MC->mv_frame[5][mb_y+1][mb_x+1]->x_half;
				dyb = MC->mv_frame[5][mb_y+1][mb_x+1]->y*2 + MC->mv_frame[5][mb_y+1][mb_x+1]->y_half;
				
				encoder->method.pred_lum_bid(pix_x+j, pix_y+i, dxf, dyf, dxb, dyb, prev_ipol, next_ipol, lx_ipol, pred_block);
				encoder->method.make_diff(curr_block, pic_width, pred_block, diff_block);
				
				if (block_SAD(diff_block) > sad_gate)
				{
					encoder->method.DCT(diff_block, diff_block);
					if (encoder->method.Quant_blk_P(diff_block, qcoeff_p, QP)) 
						
					{
						cbp|=flag;
						encoder->method.DeQuant_blk_P(qcoeff_p, diff_block, QP);  
						encoder->method.IDCT(diff_block, diff_block);
						encoder->method.recon_pic(recon_block, rec_width, pred_block, diff_block);
					}
					else
					{
						encoder->method.block_copy1(recon_block, pred_block, rec_width);
					}
				}
				else
				{
					encoder->method.block_copy1(recon_block, pred_block, rec_width);
				}
				flag = flag >> 1;
				qcoeff_p+=64;			
			}
		}
		/* find forward MV and backward MV for chrom blocks respectivly in bi-direction mode */  
        findchromMV(encoder, MC, pix_x, pix_y, &dxf, &dyf, 0);
		findchromMV(encoder, MC, pix_x, pix_y, &dxb, &dyb, 1);
		
		//! Cb block
		curr_block = curr_mb.pCb;
		recon_block = recon_mb.pCb;
		
		encoder->method.pred_chrom_bid(pix_x/2, pix_y/2, ref_img->pCb, next_img->pCb, lx_ref_c, dxf, dyf,
			dxb, dyb, pred_block);
		
		encoder->method.make_diff(curr_block, pic_width/2, pred_block, diff_block);
		
		if (block_SAD(diff_block) > sad_gate)
		{
			encoder->method.DCT(diff_block, diff_block);		
			if (encoder->method.Quant_blk_P(diff_block, qcoeff_p, QP))               
			{
				
				cbp|=flag;
				encoder->method.DeQuant_blk_P (qcoeff_p, diff_block, QP);  
				encoder->method.IDCT(diff_block, diff_block);
				encoder->method.recon_pic(recon_block, rec_width/2, pred_block, diff_block);
			}
			else
			{
				encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
			}
		}
		else
		{
			encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
		}
		flag = flag >> 1;
		qcoeff_p+=64;
		
		//! Cr block
		curr_block = curr_mb.pCr;
		recon_block = recon_mb.pCr;
		
        encoder->method.pred_chrom_bid(pix_x/2, pix_y/2, ref_img->pCr, next_img->pCr, lx_ref_c, dxf, dyf,
			dxb, dyb, pred_block);
		
		encoder->method.make_diff(curr_block, pic_width/2, pred_block, diff_block);
		
		if (block_SAD(diff_block) > sad_gate)
		{
			encoder->method.DCT(diff_block, diff_block);
			if (encoder->method.Quant_blk_P(diff_block, qcoeff_p, QP))               
			{
				cbp|=flag;
				encoder->method.DeQuant_blk_P (qcoeff_p, diff_block, QP);      
				encoder->method.IDCT(diff_block, diff_block);
				encoder->method.recon_pic(recon_block, rec_width/2, pred_block, diff_block);
			}
			else
			{
				encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
			}
		}
		else
		{
			encoder->method.block_copy1(recon_block, pred_block, rec_width/2);
		}		
	}
	else
	{
		return -1;
	}

	return cbp;
}

/*!
  findbiSAD
  calculate the sum of the absolute difference between one MB and its bi-direction 
  predicted value
*/


int  findbiSAD_c(unsigned char *prev, unsigned char *next, unsigned char *curr, 
			   int lx_ipol,  int lx_curr, int blocksize)
{
	int i, j;
	unsigned char *p0 = curr;
	unsigned char *p1 = prev;
	unsigned char *p2 = next;
	int sad = 0;

	for (j = 0; j < blocksize; j++)
	{
		for (i = 0; i < blocksize; i++)
		{
			sad += absm(p0[i] - (p1[i<<1]+p2[i<<1]+1)/2);
		}
		p0 += lx_curr;
		p1 += lx_ipol<<1;
		p2 += lx_ipol<<1;
	}

	return sad;

}

/*!
   findIntraSAD 
   calculate the sum of the absolute difference between each pixel of one MB and its 
   mean value
*/
int  findIntraSAD(unsigned char *curr, int lx_curr)
{
	int i, j;
	int MB_mean = 0;
	int A = 0;
	int y_off = 0;
	
	for (j = 0; j < 16; j++)
	{
		for (i = 0; i < 16; i++)
		{
			MB_mean += *(curr + i + y_off);
		}
		y_off += lx_curr;
	}
	MB_mean /= 256;

	y_off = 0;
	for (j = 0; j < 16; j++)
	{
		for (i = 0; i < 16; i++)
		{
			A += abs (*(curr + i + y_off) - MB_mean);
		}
		y_off += lx_curr;
	}

	return A;
}