mem_transfer.c

用MPEG-4对YUV视频文件编码压缩成divx视频文件

	uint32_t const *ptr_src = src;
	uint8_t   *ptr_dst = dst;   /*cannot add const*/
	int32_t src0,src1,src2,src3;
	uint32_t clip_src0,clip_src1,clip_src2,clip_src3;
	uint32_t stride1;
	stride1 = stride - 8;

	for (j = 0; j < 8; j++) {
		
		src0 = *(ptr_src++);
		src1 = *(ptr_src++);
		src2 = *(ptr_src++);
		src3 = *(ptr_src++);
		clip_src0 = DUALUCLIPI(src0,255);
		clip_src1 = DUALUCLIPI(src1,255);
		clip_src2 = DUALUCLIPI(src2,255);
		clip_src3 = DUALUCLIPI(src3,255);
		
		*(ptr_dst++) = (uint8_t)UBYTESEL(clip_src0,0);
		*(ptr_dst++) = (uint8_t)UBYTESEL(clip_src0,2);
		*(ptr_dst++) = (uint8_t)UBYTESEL(clip_src1,0);
		*(ptr_dst++) = (uint8_t)UBYTESEL(clip_src1,2);
		*(ptr_dst++) = (uint8_t)UBYTESEL(clip_src2,0);
		*(ptr_dst++) = (uint8_t)UBYTESEL(clip_src2,2);
		*(ptr_dst++) = (uint8_t)UBYTESEL(clip_src3,0);
		*(ptr_dst++) = (uint8_t)UBYTESEL(clip_src3,2);
		ptr_dst += stride1;
	
		/*for (i = 0; i < 8; i++) {
			pixel = src[j * 8 + i];

			if (pixel < 0) {
				pixel = 0;
			} 
			else if (pixel > 255) {
				pixel = 255;
			}
			dst[j * stride + i] = (uint8_t) pixel;
		}*/
		
	}
}
#endif
#ifdef optimize_16to8copy_4
void
transfer_16to8copy_c(uint8_t * const dst,		/*<--> the destination buffer*/
					 const int16_t * const src,	/*<--  the source buffer*/
					 uint32_t stride)			/*<--  stride*/
{
	uint32_t i, j;
	int16_t pixel ;
	uint32_t const *ptr_src = src;
	uint8_t   *ptr_dst = dst;   /*cannot add const*/
	int32_t src0,src1,src2,src3;
	uint32_t clip_src0,clip_src1,clip_src2,clip_src3;
	

	for (j = 0; j < 8; j++) {
		
		src0 = *(ptr_src+0);
		src1 = *(ptr_src+1);
		src2 = *(ptr_src+2);
		src3 = *(ptr_src+3);
		clip_src0 = DUALUCLIPI(src0,255);
		clip_src1 = DUALUCLIPI(src1,255);
		clip_src2 = DUALUCLIPI(src2,255);
		clip_src3 = DUALUCLIPI(src3,255);
		
		*(ptr_dst+0) = (uint8_t)UBYTESEL(clip_src0,0);
		*(ptr_dst+1) = (uint8_t)UBYTESEL(clip_src0,2);
		*(ptr_dst+2) = (uint8_t)UBYTESEL(clip_src1,0);
		*(ptr_dst+3) = (uint8_t)UBYTESEL(clip_src1,2);
		*(ptr_dst+4) = (uint8_t)UBYTESEL(clip_src2,0);
		*(ptr_dst+5) = (uint8_t)UBYTESEL(clip_src2,2);
		*(ptr_dst+6) = (uint8_t)UBYTESEL(clip_src3,0);
		*(ptr_dst+7) = (uint8_t)UBYTESEL(clip_src3,2);
		ptr_dst += stride;
		ptr_src += 4;
		
	
		/*for (i = 0; i < 8; i++) {
			pixel = src[j * 8 + i];

			if (pixel < 0) {
				pixel = 0;
			} 
			else if (pixel > 255) {
				pixel = 255;
			}
			dst[j * stride + i] = (uint8_t) pixel;
		}*/
		
	}
}
#endif
/*!
 ************************************************************************   
 * \brief
 *    the function does the 8->16 bit transfer and this serie of operations 
 *	  R   (8bit)  = R
 *    C   (8bit)  = R
 *    DCT (16bit) = C - R
 ************************************************************************
 */
#ifdef _TRIMEDIA
#define  optimize_8to16sub_3        /*useful*/
#endif

#ifndef _TRIMEDIA
void
transfer_8to16sub_c(int16_t * const dct,		/*<--> the dct coefficient buffer*/
					uint8_t * const cur,		/*<-->in:the current buffer/out:save the ref*/	
					const uint8_t * ref,		/*<-- the reference buffer*/
					const uint32_t stride		/*<-- the dct coefficient buffer*/
					)
{
	uint32_t i, j;

	for (j = 0; j < 8; j++) {
		for (i = 0; i < 8; i++) {
			uint8_t c = cur[j * stride + i];
			uint8_t r = ref[j * stride + i];

			cur[j * stride + i] = r;
			dct[j * 8 + i] = (int16_t) c - (int16_t) r;
		}
	}
}
#endif 

#ifdef  optimize_8to16sub_2
void
transfer_8to16sub_c(int16_t * const dct,		/*<--> the dct coefficient buffer*/
					uint8_t * const cur,		/*<-->in:the current buffer/out:save the ref*/	
					const uint8_t * ref,		/*<-- the reference buffer*/
					const uint32_t stride		/*<-- the dct coefficient buffer*/
					)
{
	uint32_t i, j;
	uint32_t  * ptr_cur = cur;
	uint32_t const * ptr_ref = ref;
	int32_t  * ptr_dct = dct;
	uint32_t src0,src1,src2;
	uint32_t ref0,ref1,ref2;
	uint32_t ref16_0,ref16_1,ref16_2,ref16_3;
	uint32_t cur0,cur1;
	uint32_t cur16_0,cur16_1,cur16_2,cur16_3;
	
	uint32_t cur_ref_stride;
	uint32_t temp;
	temp = ((uint32_t)ref)&3;
	cur_ref_stride = stride >>2;
	if(!temp)    /*word align*/
	{
		for (j=0; j < 8; j++) {
			ref0 = *(ptr_ref);
			ref1 = *(ptr_ref+1);
			ref16_0 = MERGELSB(0,ref0);
			ref16_1 = MERGEMSB(0,ref0);
			ref16_2 = MERGELSB(0,ref1);
			ref16_3 = MERGEMSB(0,ref1);
			cur0 = *(ptr_cur);
			cur1 = *(ptr_cur+1);
			cur16_0 = MERGELSB(0,cur0);
			cur16_1 = MERGEMSB(0,cur0);
			cur16_2 = MERGELSB(0,cur1);
			cur16_3 = MERGEMSB(0,cur1);
			*(ptr_cur ) = ref0;
			*(ptr_cur+1)= ref1;
			*(ptr_dct)  = DSPIDUALSUB(cur16_0,ref16_0);
			*(ptr_dct+1)  = DSPIDUALSUB(cur16_1,ref16_1);
			*(ptr_dct+2)  = DSPIDUALSUB(cur16_2,ref16_2);
			*(ptr_dct+3)  = DSPIDUALSUB(cur16_3,ref16_3);
			ptr_ref += cur_ref_stride;
			ptr_cur += cur_ref_stride;
			ptr_dct += 4;
			
		}
			
	}
	else if(temp==1)
	{
		for(j =0; j < 8; j++)
		{
		
			/*get three word*/
			src0 = *(ptr_ref);
			src1 = *(ptr_ref+1);
			src2 = *(ptr_ref+2);	
			/*make up two word*/
			ref0 = FUNSHIFT3(src1,src0);
			ref1 = FUNSHIFT3(src2,src1);
			ref16_0 = MERGELSB(0,ref0);
			ref16_1 = MERGEMSB(0,ref0);
			ref16_2 = MERGELSB(0,ref1);
			ref16_3 = MERGEMSB(0,ref1);
			cur0 = *(ptr_cur);
			cur1 = *(ptr_cur+1);
			cur16_0 = MERGELSB(0,cur0);
			cur16_1 = MERGEMSB(0,cur0);
			cur16_2 = MERGELSB(0,cur1);
			cur16_3 = MERGEMSB(0,cur1);
			*(ptr_cur ) = ref0;
			*(ptr_cur+1)= ref1;
			*(ptr_dct)  = DSPIDUALSUB(cur16_0,ref16_0);
			*(ptr_dct+1)  = DSPIDUALSUB(cur16_1,ref16_1);
			*(ptr_dct+2)  = DSPIDUALSUB(cur16_2,ref16_2);
			*(ptr_dct+3)  = DSPIDUALSUB(cur16_3,ref16_3);
			ptr_ref += cur_ref_stride;
			ptr_cur += cur_ref_stride;
			ptr_dct += 4;
			
			

		}
	}
	else if(temp==2)
	{
		for(j =0; j < 8; j++)
		{
		
			/*get three word*/
			src0 = *(ptr_ref);
			src1 = *(ptr_ref+1);
			src2 = *(ptr_ref+2);	
			/*make up two word*/
			ref0 = FUNSHIFT2(src1,src0);
			ref1 = FUNSHIFT2(src2,src1);
			ref16_0 = MERGELSB(0,ref0);
			ref16_1 = MERGEMSB(0,ref0);
			ref16_2 = MERGELSB(0,ref1);
			ref16_3 = MERGEMSB(0,ref1);
			cur0 = *(ptr_cur);
			cur1 = *(ptr_cur+1);
			cur16_0 = MERGELSB(0,cur0);
			cur16_1 = MERGEMSB(0,cur0);
			cur16_2 = MERGELSB(0,cur1);
			cur16_3 = MERGEMSB(0,cur1);
			*(ptr_cur ) = ref0;
			*(ptr_cur+1)= ref1;
			*(ptr_dct)  = DSPIDUALSUB(cur16_0,ref16_0);
			*(ptr_dct+1)  = DSPIDUALSUB(cur16_1,ref16_1);
			*(ptr_dct+2)  = DSPIDUALSUB(cur16_2,ref16_2);
			*(ptr_dct+3)  = DSPIDUALSUB(cur16_3,ref16_3);
			ptr_ref += cur_ref_stride;
			ptr_cur += cur_ref_stride;
			ptr_dct += 4;
			
			

		}
	}
	else if(temp==3)
	{
		for(j =0; j < 8; j++)
		{
		
			/*get three word*/
			src0 = *(ptr_ref);
			src1 = *(ptr_ref+1);
			src2 = *(ptr_ref+2);	
			/*make up two word*/
			ref0 = FUNSHIFT1(src1,src0);
			ref1 = FUNSHIFT1(src2,src1);
			ref16_0 = MERGELSB(0,ref0);
			ref16_1 = MERGEMSB(0,ref0);
			ref16_2 = MERGELSB(0,ref1);
			ref16_3 = MERGEMSB(0,ref1);
			cur0 = *(ptr_cur);
			cur1 = *(ptr_cur+1);
			cur16_0 = MERGELSB(0,cur0);
			cur16_1 = MERGEMSB(0,cur0);
			cur16_2 = MERGELSB(0,cur1);
			cur16_3 = MERGEMSB(0,cur1);
			*(ptr_cur ) = ref0;
			*(ptr_cur+1)= ref1;
			*(ptr_dct)  = DSPIDUALSUB(cur16_0,ref16_0);
			*(ptr_dct+1)  = DSPIDUALSUB(cur16_1,ref16_1);
			*(ptr_dct+2)  = DSPIDUALSUB(cur16_2,ref16_2);
			*(ptr_dct+3)  = DSPIDUALSUB(cur16_3,ref16_3);
			ptr_ref += cur_ref_stride;
			ptr_cur += cur_ref_stride;
			ptr_dct += 4;
			
			

		}
	}

}
#endif 

#ifdef  optimize_8to16sub_3
void
transfer_8to16sub_c(int16_t * const dct,		/*<--> the dct coefficient buffer*/
					uint8_t * const cur,		/*<-->in:the current buffer/out:save the ref*/	
					const uint8_t * ref,		/*<-- the reference buffer*/
					const uint32_t stride		/*<-- the dct coefficient buffer*/
					)
{
	uint32_t i, j;

/*	
	uint32_t  * restrict ptr_cur = (uint32_t  *)cur;
	const uint32_t * restrict ptr_ref = (const uint32_t *)ref;
	int32_t  * restrict ptr_dct = (int32_t *)dct;
*/
	uint32_t  * ptr_cur = (uint32_t  *)cur;
	const uint32_t * ptr_ref = (const uint32_t *)ref;
	int32_t  * ptr_dct = (int32_t *)dct;

	uint32_t src0,src1,src2;
	uint32_t ref0,ref1,ref2;
	uint32_t ref16_0,ref16_1,ref16_2,ref16_3;
	uint32_t cur0,cur1;
	uint32_t cur16_0,cur16_1,cur16_2,cur16_3;
	
	uint32_t cur_ref_stride;
	uint32_t temp;
	temp = ((uint32_t)ref)&3;
	cur_ref_stride = (stride >>2)-1;
	if(!temp)    /*word align*/
	{
		for (j=0; j < 8; j++) {
			ref0 = *(ptr_ref++);
			ref1 = *(ptr_ref);
			ref16_0 = MERGELSB(0,ref0);
			ref16_1 = MERGEMSB(0,ref0);
			ref16_2 = MERGELSB(0,ref1);
			ref16_3 = MERGEMSB(0,ref1);
			cur0 = *(ptr_cur++);
			cur1 = *(ptr_cur--);
			cur16_0 = MERGELSB(0,cur0);
			cur16_1 = MERGEMSB(0,cur0);
			cur16_2 = MERGELSB(0,cur1);
			cur16_3 = MERGEMSB(0,cur1);
			*(ptr_cur++ ) = ref0;
			*(ptr_cur ) = ref1;
			*(ptr_dct++)  = DSPIDUALSUB(cur16_0,ref16_0);
			*(ptr_dct++)  = DSPIDUALSUB(cur16_1,ref16_1);
			*(ptr_dct++)  = DSPIDUALSUB(cur16_2,ref16_2);
			*(ptr_dct++)  = DSPIDUALSUB(cur16_3,ref16_3);
			ptr_ref += cur_ref_stride;
			ptr_cur += cur_ref_stride;
			/*ptr_dct += 4;*/
			
		}
			
	}
	else if(temp==1)
	{
		for(j =0; j < 8; j++)
		{
		
			/*get three word*/
			src0 = *(ptr_ref++);
			src1 = *(ptr_ref++);
			src2 = *(ptr_ref--);	
			/*make up two word*/
			ref0 = FUNSHIFT3(src1,src0);
			ref1 = FUNSHIFT3(src2,src1);
			ref16_0 = MERGELSB(0,ref0);
			ref16_1 = MERGEMSB(0,ref0);
			ref16_2 = MERGELSB(0,ref1);
			ref16_3 = MERGEMSB(0,ref1);
			cur0 = *(ptr_cur++);
			cur1 = *(ptr_cur--);
			cur16_0 = MERGELSB(0,cur0);
			cur16_1 = MERGEMSB(0,cur0);
			cur16_2 = MERGELSB(0,cur1);
			cur16_3 = MERGEMSB(0,cur1);
			*(ptr_cur++) = ref0;
			*(ptr_cur  )= ref1;
			*(ptr_dct++)  = DSPIDUALSUB(cur16_0,ref16_0);
			*(ptr_dct++)  = DSPIDUALSUB(cur16_1,ref16_1);
			*(ptr_dct++)  = DSPIDUALSUB(cur16_2,ref16_2);
			*(ptr_dct++)  = DSPIDUALSUB(cur16_3,ref16_3);
			ptr_ref += cur_ref_stride;
			ptr_cur += cur_ref_stride;
			/*ptr_dct += 4;*/
			
			

		}
	}