dsputil.c

播放H264文件的播放器

	for(j=0; j<2; j++)
	{ 
		int i; 
		uint32_t l0, h0;
		uint32_t l1,h1;
		//const uint32_t a= (*((const uint32_t*)(pixels))); 
		//const uint32_t b= (*((const uint32_t*)(pixels+1))); 
		memcpy(&a, pixels, sizeof(uint32_t));
		memcpy(&b, pixels+1, sizeof(uint32_t));
		l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; 
		h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); 
		 
		pixels+=line_size; 
		for(i=0; i<h; i+=2)
		{ 
			//uint32_t a= (*((const uint32_t*)(pixels))); 
			//uint32_t b= (*((const uint32_t*)(pixels+1))); 
			memcpy(&a, pixels, sizeof(uint32_t));
			memcpy(&b, pixels+1, sizeof(uint32_t));
			l1= (a&0x03030303UL) + (b&0x03030303UL); 
			h1= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); 
			//*((uint32_t*)block) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); 
			a = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL);
			memcpy(block, &a, sizeof(uint32_t));
			pixels+=line_size; 
			block +=line_size; 

			//a= (*((const uint32_t*)(pixels))); 
			//b= (*((const uint32_t*)(pixels+1))); 
			memcpy(&a, pixels, sizeof(uint32_t));
			memcpy(&b, pixels+1, sizeof(uint32_t));
			l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x02020202UL; 
			h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); 
			//*((uint32_t*)block) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); 
			a = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL);
			memcpy(block, &a, sizeof(uint32_t));
			pixels+=line_size; 
			block +=line_size; 
		}
		pixels+=4-line_size*(h+1); 
		block +=4-line_size*h; 
	}
}

static _inline void put_no_rnd_pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{ 
	int j; 
	uint32_t a;
	uint32_t b;

	for(j=0; j<2; j++)
	{ 
		int i; 
		uint32_t l0, h0;
		uint32_t l1,h1; 
		//const uint32_t a= (*((const uint32_t*)(pixels))); 
		//const uint32_t b= (*((const uint32_t*)(pixels+1))); 
		memcpy(&a, pixels, sizeof(uint32_t));
		memcpy(&b, pixels+1, sizeof(uint32_t));
		l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x01010101UL; 
		h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); 
		
		pixels+=line_size; 
		for(i=0; i<h; i+=2)
		{ 
			//uint32_t a= (*((const uint32_t*)(pixels))); 
			//uint32_t b= (*((const uint32_t*)(pixels+1))); 
			memcpy(&a, pixels, sizeof(uint32_t));
			memcpy(&b, pixels+1, sizeof(uint32_t));
			l1= (a&0x03030303UL) + (b&0x03030303UL); 
			h1= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); 
			//*((uint32_t*)block) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); 
			a = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL);
			memcpy(block, &a, sizeof(uint32_t));
			pixels+=line_size; 
			block +=line_size; 

			//a= (*((const uint32_t*)(pixels))); 
			//b= (*((const uint32_t*)(pixels+1))); 
			memcpy(&a, pixels, sizeof(uint32_t));
			memcpy(&b, pixels+1, sizeof(uint32_t));
			l0= (a&0x03030303UL) + (b&0x03030303UL) + 0x01010101UL; 
			h0= ((a&0xFCFCFCFCUL)>>2) + ((b&0xFCFCFCFCUL)>>2); 
			//*((uint32_t*)block) = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL); 
			a = h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL);
			memcpy(block, &a, sizeof(uint32_t));
			pixels+=line_size; 
			block +=line_size; 
		}
		pixels+=4-line_size*(h+1); 
		block +=4-line_size*h; 
	}
}

static void put_pixels16_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{ 
	put_pixels8_c(block , pixels , line_size, h); 
	put_pixels8_c(block+8, pixels+8, line_size, h);
}

static void put_pixels16_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{ 
	put_pixels8_x2_c(block , pixels , line_size, h); 
	put_pixels8_x2_c(block+8, pixels+8, line_size, h);
}

static void put_pixels16_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{ 
	put_pixels8_y2_c(block , pixels , line_size, h); 
	put_pixels8_y2_c(block+8, pixels+8, line_size, h);
}

static void put_pixels16_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{ 
	put_pixels8_xy2_c(block , pixels , line_size, h); 
	put_pixels8_xy2_c(block+8, pixels+8, line_size, h);
}

static void put_no_rnd_pixels16_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{ 
	put_pixels8_c(block , pixels , line_size, h); 
	put_pixels8_c(block+8, pixels+8, line_size, h);
}

static void put_no_rnd_pixels16_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{ 
	put_no_rnd_pixels8_x2_c(block , pixels , line_size, h); 
	put_no_rnd_pixels8_x2_c(block+8, pixels+8, line_size, h);
}

static void put_no_rnd_pixels16_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{ 
	put_no_rnd_pixels8_y2_c(block , pixels , line_size, h); 
	put_no_rnd_pixels8_y2_c(block+8, pixels+8, line_size, h);
}

static void put_no_rnd_pixels16_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{ 
	put_no_rnd_pixels8_xy2_c(block , pixels , line_size, h); 
	put_no_rnd_pixels8_xy2_c(block+8, pixels+8, line_size, h);
}

static void put_no_rnd_pixels16_l2_c(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h)
{
    put_no_rnd_pixels16_l2(dst, a, b, stride, stride, stride, h);
}

static void put_no_rnd_pixels8_l2_c(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h)
{
    put_no_rnd_pixels8_l2(dst, a, b, stride, stride, stride, h);
}

static void gmc1_c(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder)
{
    const int A=(16-x16)*(16-y16);
    const int B=(   x16)*(16-y16);
    const int C=(16-x16)*(   y16);
    const int D=(   x16)*(   y16);
    int i;

    for(i=0; i<h; i++)
    {
        dst[0]= (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + rounder)>>8;
        dst[1]= (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + rounder)>>8;
        dst[2]= (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + rounder)>>8;
        dst[3]= (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + rounder)>>8;
        dst[4]= (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + rounder)>>8;
        dst[5]= (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + rounder)>>8;
        dst[6]= (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + rounder)>>8;
        dst[7]= (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + rounder)>>8;
        dst+= stride;
        src+= stride;
    }
}

void ff_gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
                  int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height)
{
    int y, vx, vy;
    const int s= 1<<shift;

    width--;
    height--;

    for(y=0; y<h; y++){
        int x;

        vx= ox;
        vy= oy;
        for(x=0; x<8; x++){ 
            int src_x, src_y, frac_x, frac_y, index;

            src_x= vx>>16;
            src_y= vy>>16;
            frac_x= src_x&(s-1);
            frac_y= src_y&(s-1);
            src_x>>=shift;
            src_y>>=shift;

            if((unsigned)src_x < width){
                if((unsigned)src_y < height){
                    index= src_x + src_y*stride;
                    dst[y*stride + x]= (  (  src[index         ]*(s-frac_x)
                                           + src[index       +1]*   frac_x )*(s-frac_y)
                                        + (  src[index+stride  ]*(s-frac_x)
                                           + src[index+stride+1]*   frac_x )*   frac_y
                                        + r)>>(shift*2);
                }else{
                    index= src_x + av_clip(src_y, 0, height)*stride;
                    dst[y*stride + x]= ( (  src[index         ]*(s-frac_x)
                                          + src[index       +1]*   frac_x )*s
                                        + r)>>(shift*2);
                }
            }else{
                if((unsigned)src_y < height){
                    index= av_clip(src_x, 0, width) + src_y*stride;
                    dst[y*stride + x]= (  (  src[index         ]*(s-frac_y)
                                           + src[index+stride  ]*   frac_y )*s
                                        + r)>>(shift*2);
                }else{
                    index= av_clip(src_x, 0, width) + av_clip(src_y, 0, height)*stride;
                    dst[y*stride + x]=    src[index         ];
                }
            }

            vx+= dxx;
            vy+= dyx;
        }
        ox += dxy;
        oy += dyy;
    }
}

static _inline void put_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    switch(width){
    case 2: put_pixels2_c (dst, src, stride, height); break;
    case 4: put_pixels4_c (dst, src, stride, height); break;
    case 8: put_pixels8_c (dst, src, stride, height); break;
    case 16:put_pixels16_c(dst, src, stride, height); break;
    }
}

static _inline void put_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    int i,j;
    for (i=0; i < height; i++) {
      for (j=0; j < width; j++) {
        dst[j] = (683*(2*src[j] + src[j+1] + 1)) >> 11;
      }
      src += stride;
      dst += stride;
    }
}

static _inline void put_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    int i,j;
    for (i=0; i < height; i++) {
      for (j=0; j < width; j++) {
        dst[j] = (683*(src[j] + 2*src[j+1] + 1)) >> 11;
      }
      src += stride;
      dst += stride;
    }
}

static _inline void put_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    int i,j;
    for (i=0; i < height; i++) {
      for (j=0; j < width; j++) {
        dst[j] = (683*(2*src[j] + src[j+stride] + 1)) >> 11;
      }
      src += stride;
      dst += stride;
    }
}

static _inline void put_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    int i,j;
    for (i=0; i < height; i++) {
      for (j=0; j < width; j++) {
        dst[j] = (2731*(4*src[j] + 3*src[j+1] + 3*src[j+stride] + 2*src[j+stride+1] + 6)) >> 15;
      }
      src += stride;
      dst += stride;
    }
}

static _inline void put_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    int i,j;
    for (i=0; i < height; i++) {
      for (j=0; j < width; j++) {
        dst[j] = (2731*(3*src[j] + 2*src[j+1] + 4*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
      }
      src += stride;
      dst += stride;
    }
}

static _inline void put_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    int i,j;
    for (i=0; i < height; i++) {
      for (j=0; j < width; j++) {
        dst[j] = (683*(src[j] + 2*src[j+stride] + 1)) >> 11;
      }
      src += stride;
      dst += stride;
    }
}

static _inline void put_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    int i,j;
    for (i=0; i < height; i++) {
      for (j=0; j < width; j++) {
        dst[j] = (2731*(3*src[j] + 4*src[j+1] + 2*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
      }
      src += stride;
      dst += stride;
    }
}

static _inline void put_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    int i,j;
    for (i=0; i < height; i++) {
      for (j=0; j < width; j++) {
        dst[j] = (2731*(2*src[j] + 3*src[j+1] + 3*src[j+stride] + 4*src[j+stride+1] + 6)) >> 15;
      }
      src += stride;
      dst += stride;
    }
}

static _inline void avg_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    switch(width){
    case 2: avg_pixels2_c (dst, src, stride, height); break;
    case 4: avg_pixels4_c (dst, src, stride, height); break;
    case 8: avg_pixels8_c (dst, src, stride, height); break;
    case 16:avg_pixels16_c(dst, src, stride, height); break;
    }
}

static _inline void avg_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    int i,j;
    for (i=0; i < height; i++) {
      for (j=0; j < width; j++) {
        dst[j] = (dst[j] + ((683*(2*src[j] + src[j+1] + 1)) >> 11) + 1) >> 1;
      }
      src += stride;
      dst += stride;
    }
}

static _inline void avg_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    int i,j;
    for (i=0; i < height; i++) {
      for (j=0; j < width; j++) {
        dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+1] + 1)) >> 11) + 1) >> 1;
      }
      src += stride;
      dst += stride;
    }
}

static _inline void avg_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
    int i,j;
    for (i=0; i < height; i++) {
      for (j=0; j < width; j++) {
        dst[j] = (dst[j] + ((683*(2*src[j] + src[j+stride] + 1)) >> 11)