dsputil.c

播放H264文件的播放器

    }

    start_y= ((0) > (-src_y) ? (0) : (-src_y));
    start_x= ((0) > (-src_x) ? (0) : (-src_x));
    end_y= ((block_h) > (h-src_y) ? (h-src_y) : (block_h));
    end_x= ((block_w) > (w-src_x) ? (w-src_x) : (block_w));

    
    for(y=start_y; y<end_y; y++){
        for(x=start_x; x<end_x; x++){
            buf[x + y*linesize]= src[x + y*linesize];
        }
    }

    
    for(y=0; y<start_y; y++){
        for(x=start_x; x<end_x; x++){
            buf[x + y*linesize]= buf[x + start_y*linesize];
        }
    }

    
    for(y=end_y; y<block_h; y++){
        for(x=start_x; x<end_x; x++){
            buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
        }
    }

    for(y=0; y<block_h; y++){
       
        for(x=0; x<start_x; x++){
            buf[x + y*linesize]= buf[start_x + y*linesize];
        }

       
        for(x=end_x; x<block_w; x++){
            buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
        }
    }
}

static void get_pixels_c(DCTELEM * block, const uint8_t *pixels, int line_size)
{
    int i;

    
    for(i=0;i<8;i++) {
        block[0] = pixels[0];
        block[1] = pixels[1];
        block[2] = pixels[2];
        block[3] = pixels[3];
        block[4] = pixels[4];
        block[5] = pixels[5];
        block[6] = pixels[6];
        block[7] = pixels[7];
        pixels += line_size;
        block += 8;
    }
}

static void diff_pixels_c(DCTELEM * block, const uint8_t *s1,
                          const uint8_t *s2, int stride){
    int i;

    
    for(i=0;i<8;i++) {
        block[0] = s1[0] - s2[0];
        block[1] = s1[1] - s2[1];
        block[2] = s1[2] - s2[2];
        block[3] = s1[3] - s2[3];
        block[4] = s1[4] - s2[4];
        block[5] = s1[5] - s2[5];
        block[6] = s1[6] - s2[6];
        block[7] = s1[7] - s2[7];
        s1 += stride;
        s2 += stride;
        block += 8;
    }
}


static void put_pixels_clamped_c(const DCTELEM *block, uint8_t * pixels,
                                 int line_size)
{
    int i;
    uint8_t *cm = ff_cropTbl + 1024;

    
    for(i=0;i<8;i++) {
        pixels[0] = cm[block[0]];
        pixels[1] = cm[block[1]];
        pixels[2] = cm[block[2]];
        pixels[3] = cm[block[3]];
        pixels[4] = cm[block[4]];
        pixels[5] = cm[block[5]];
        pixels[6] = cm[block[6]];
        pixels[7] = cm[block[7]];

        pixels += line_size;
        block += 8;
    }
}

static void put_pixels_clamped4_c(const DCTELEM *block, uint8_t * pixels,
                                 int line_size)
{
    int i;
    uint8_t *cm = ff_cropTbl + 1024;

    
    for(i=0;i<4;i++) {
        pixels[0] = cm[block[0]];
        pixels[1] = cm[block[1]];
        pixels[2] = cm[block[2]];
        pixels[3] = cm[block[3]];

        pixels += line_size;
        block += 8;
    }
}

static void put_pixels_clamped2_c(const DCTELEM *block, uint8_t * pixels,
                                 int line_size)
{
    int i;
    uint8_t *cm = ff_cropTbl + 1024;

    
    for(i=0;i<2;i++) {
        pixels[0] = cm[block[0]];
        pixels[1] = cm[block[1]];

        pixels += line_size;
        block += 8;
    }
}

static void put_signed_pixels_clamped_c(const DCTELEM *block,
                                        uint8_t * pixels,
                                        int line_size)
{
    int i, j;

    for (i = 0; i < 8; i++) {
        for (j = 0; j < 8; j++) {
            if (*block < -128)
                *pixels = 0;
            else if (*block > 127)
                *pixels = 255;
            else
                *pixels = (uint8_t)(*block + 128);
            block++;
            pixels++;
        }
        pixels += (line_size - 8);
    }
}

static void add_pixels_clamped_c(const DCTELEM *block, uint8_t * pixels,
                          int line_size)
{
    int i;
    uint8_t *cm = ff_cropTbl + 1024;

    
    for(i=0;i<8;i++) {
        pixels[0] = cm[pixels[0] + block[0]];
        pixels[1] = cm[pixels[1] + block[1]];
        pixels[2] = cm[pixels[2] + block[2]];
        pixels[3] = cm[pixels[3] + block[3]];
        pixels[4] = cm[pixels[4] + block[4]];
        pixels[5] = cm[pixels[5] + block[5]];
        pixels[6] = cm[pixels[6] + block[6]];
        pixels[7] = cm[pixels[7] + block[7]];
        pixels += line_size;
        block += 8;
    }
}

static void add_pixels_clamped4_c(const DCTELEM *block, uint8_t * pixels,
                          int line_size)
{
    int i;
    uint8_t *cm = ff_cropTbl + 1024;

    
    for(i=0;i<4;i++) {
        pixels[0] = cm[pixels[0] + block[0]];
        pixels[1] = cm[pixels[1] + block[1]];
        pixels[2] = cm[pixels[2] + block[2]];
        pixels[3] = cm[pixels[3] + block[3]];
        pixels += line_size;
        block += 8;
    }
}

static void add_pixels_clamped2_c(const DCTELEM *block, uint8_t * pixels,
                          int line_size)
{
    int i;
    uint8_t *cm = ff_cropTbl + 1024;

    
    for(i=0;i<2;i++) {
        pixels[0] = cm[pixels[0] + block[0]];
        pixels[1] = cm[pixels[1] + block[1]];
        pixels += line_size;
        block += 8;
    }
}

static void add_pixels8_c(uint8_t * pixels, DCTELEM *block, int line_size)
{
    int i;
    for(i=0;i<8;i++) {
        pixels[0] += block[0];
        pixels[1] += block[1];
        pixels[2] += block[2];
        pixels[3] += block[3];
        pixels[4] += block[4];
        pixels[5] += block[5];
        pixels[6] += block[6];
        pixels[7] += block[7];
        pixels += line_size;
        block += 8;
    }
}

static void add_pixels4_c(uint8_t * pixels, DCTELEM *block, int line_size)
{
    int i;
    for(i=0;i<4;i++) {
        pixels[0] += block[0];
        pixels[1] += block[1];
        pixels[2] += block[2];
        pixels[3] += block[3];
        pixels += line_size;
        block += 4;
    }
}

static int sum_abs_dctelem_c(DCTELEM *block)
{
    int sum=0, i;
    for(i=0; i<64; i++)
        sum+= ((block[i]) >= 0 ? (block[i]) : (-(block[i])));
    return sum;
}

//Avg Functions
static void avg_pixels2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{
	int i;
	uint16_t a,b;
	for(i=0; i<h; i++)
	{ 
		//*((uint16_t*)(block )) = rnd_avg32(*((uint16_t*)(block )), (*((const uint16_t*)(pixels))));
		memcpy(&a, block, sizeof(uint16_t));
		memcpy(&b, pixels, sizeof(uint16_t));
		a = rnd_avg32(a, b);
		memcpy(block, &a, sizeof(uint16_t));
		pixels+=line_size;
		block +=line_size; 
	}
}

static void avg_pixels4_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{
	int i;
	uint32_t a,b;
	for(i=0; i<h; i++)
	{
		//*((uint32_t*)(block )) = rnd_avg32(*((uint32_t*)(block )), (*((const uint32_t*)(pixels))));
		memcpy(&a, block, sizeof(uint32_t));
		memcpy(&b, pixels, sizeof(uint32_t));
		a = rnd_avg32(a, b);
		memcpy(block, &a, sizeof(uint32_t));
		pixels+=line_size;
		block +=line_size;
	}
}

static void avg_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{
	int i;
	uint32_t a,b;
	for(i=0; i<h; i++)
	{
		//*((uint32_t*)(block )) = rnd_avg32(*((uint32_t*)(block )), (*((const uint32_t*)(pixels))));
		//*((uint32_t*)(block+4)) = rnd_avg32(*((uint32_t*)(block+4)), (*((const uint32_t*)(pixels+4))));
		memcpy(&a, block, sizeof(uint32_t));
		memcpy(&b, pixels, sizeof(uint32_t));
		a = rnd_avg32(a, b);
		memcpy(block, &a, sizeof(uint32_t));

		memcpy(&a, block+4, sizeof(uint32_t));
		memcpy(&b, pixels+4, sizeof(uint32_t));
		a = rnd_avg32(a, b);
		memcpy(block+4, &a, sizeof(uint32_t));

		pixels+=line_size;
		block +=line_size;
	}
}

static _inline void avg_no_rnd_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
{
	avg_pixels8_c(block, pixels, line_size, h);
}

static _inline void avg_no_rnd_pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h)
{
	int i;
	for(i=0; i<h; i++)
	{
		uint32_t a,b,c;
		//a= (*((const uint32_t*)(&src1[i*src_stride1 ])));
		//b= (*((const uint32_t*)(&src2[i*src_stride2 ])));
		memcpy(&a, &src1[i*src_stride1], sizeof(uint32_t));
		memcpy(&b, &src2[i*src_stride2], sizeof(uint32_t));
		memcpy(&c, &dst[i*dst_stride], sizeof(uint32_t));
		//*((uint32_t*)&dst[i*dst_stride ]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride ]), no_rnd_avg32(a, b));
		c = rnd_avg32(c, no_rnd_avg32(a, b));
		memcpy(&dst[i*dst_stride], &c, sizeof(uint32_t));

		//a= (*((const uint32_t*)(&src1[i*src_stride1+4])));
		//b= (*((const uint32_t*)(&src2[i*src_stride2+4])));
		memcpy(&a, &src1[i*src_stride1+4], sizeof(uint32_t));
		memcpy(&b, &src2[i*src_stride2+4], sizeof(uint32_t));
		memcpy(&c, &dst[i*dst_stride+4], sizeof(uint32_t));
		//*((uint32_t*)&dst[i*dst_stride+4]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride+4]), no_rnd_avg32(a, b));
		c = rnd_avg32(c, no_rnd_avg32(a, b));
		memcpy(&dst[i*dst_stride+4], &c, sizeof(uint32_t));
	}
}

static _inline void avg_pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h)
{
	int i;
	for(i=0; i<h; i++)
	{
		uint32_t a,b,c;
		//a= (*((const uint32_t*)(&src1[i*src_stride1 ])));
		//b= (*((const uint32_t*)(&src2[i*src_stride2 ])));
		memcpy(&a, &src1[i*src_stride1], sizeof(uint32_t));
		memcpy(&b, &src2[i*src_stride2], sizeof(uint32_t));
		memcpy(&c, &dst[i*dst_stride], sizeof(uint32_t));
		//*((uint32_t*)&dst[i*dst_stride ]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride ]), rnd_avg32(a, b));
		c = rnd_avg32(c, rnd_avg32(a, b));
		memcpy(&dst[i*dst_stride], &c, sizeof(uint32_t));

		//a= (*((const uint32_t*)(&src1[i*src_stride1+4])));
		//b= (*((const uint32_t*)(&src2[i*src_stride2+4])));
		memcpy(&a, &src1[i*src_stride1+4], sizeof(uint32_t));
		memcpy(&b, &src2[i*src_stride2+4], sizeof(uint32_t));
		memcpy(&c, &dst[i*dst_stride+4], sizeof(uint32_t));
		//*((uint32_t*)&dst[i*dst_stride+4]) = rnd_avg32(*((uint32_t*)&dst[i*dst_stride+4]), rnd_avg32(a, b));
		c = rnd_avg32(c, rnd_avg32(a, b));
		memcpy(&dst[i*dst_stride+4], &c, sizeof(uint32_t));
	}
}

static _inline void avg_pixels4_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h)
{
	int i;
	for(i=0; i<h; i++)
	{
		uint32_t a,b,c;
		//a= (*((const uint32_t*)(&src1[i*src_stride1 ])));
		//b= (*((const uint32_t*)(&src2[i*src_stride2 ])));