dsputil.c

君正早期ucos系统(只有早期的才不没有打包成库),MPLAYER,文件系统,图片解码,浏览,电子书,录音,想学ucos,识货的人就下吧 russblock fmradio explore set

    ff_spatial_dwt(tmp, w, h, 32, type, dec_count);

    s=0;
    assert(w==h);
    for(level=0; level<dec_count; level++){
        for(ori= level ? 1 : 0; ori<4; ori++){
            int size= w>>(dec_count-level);
            int sx= (ori&1) ? size : 0;
            int stride= 32<<(dec_count-level);
            int sy= (ori&2) ? stride>>1 : 0;

            for(i=0; i<size; i++){
                for(j=0; j<size; j++){
                    int v= tmp[sx + sy + i*stride + j] * scale[type][dec_count-3][level][ori];
                    s += FFABS(v);
                }
            }
        }
    }
    assert(s>=0);
    return s>>9;
}

static int w53_8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
    return w_c(v, pix1, pix2, line_size,  8, h, 1);
}

static int w97_8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
    return w_c(v, pix1, pix2, line_size,  8, h, 0);
}

static int w53_16_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
    return w_c(v, pix1, pix2, line_size, 16, h, 1);
}

static int w97_16_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
    return w_c(v, pix1, pix2, line_size, 16, h, 0);
}

int w53_32_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
    return w_c(v, pix1, pix2, line_size, 32, h, 1);
}

int w97_32_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
    return w_c(v, pix1, pix2, line_size, 32, h, 0);
}
#endif

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

    /* read the pixels */
    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 *restrict block, const uint8_t *s1,
                          const uint8_t *s2, int stride){
    int i;

    /* read the pixels */
    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 *restrict pixels,
                                 int line_size)
{
    int i;
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    /* read the pixels */
    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 *restrict pixels,
                                 int line_size)
{
    int i;
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    /* read the pixels */
    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 *restrict pixels,
                                 int line_size)
{
    int i;
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    /* read the pixels */
    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 *restrict 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 *restrict pixels,
                          int line_size)
{
    int i;
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    /* read the pixels */
    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 *restrict pixels,
                          int line_size)
{
    int i;
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    /* read the pixels */
    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 *restrict pixels,
                          int line_size)
{
    int i;
    uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    /* read the pixels */
    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 *restrict 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 *restrict 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+= FFABS(block[i]);
    return sum;
}
#ifdef JZ4740_MXU_OPT
static void put_pixels8_c(uint8_t *dst, const uint8_t *src, int stride, int h){
  
  uint32_t src_aln,src_rs;
  int i;
  src_aln = (uint32_t)src & 0xfffffffc;
  src_rs = 4 - ((uint32_t)src & 3);
  for(i=0; i<h; i++) {
    S32LDD(xr1,src_aln,0);
    S32LDD(xr2,src_aln,0x4);
    S32LDD(xr3,src_aln,0x8);
    S32ALN(xr1,xr2,xr1,src_rs); 
    S32ALN(xr2,xr3,xr2,src_rs); 
    S32STD(xr1,dst,0);
    S32STD(xr2,dst,4);
    dst += stride;
    src_aln+=stride;
  }
}
#else
static void put_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
    int i;
    uint8_t *dst,*src;
    dst = block;
    src = pixels;
    for(i=0; i<h; i++){
       dst[0]= src[0];
       dst[1]= src[1];
       dst[2]= src[2];
       dst[3]= src[3];     
       dst[4]= src[4];
       dst[5]= src[5];
       dst[6]= src[6];
       dst[7]= src[7];
       src += line_size;
       dst += line_size;
    }
}

#endif
static void avg_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
    int i;
    for(i=0; i<h; i++){
        *((uint32_t*)(block  ))= AV_RN32(pixels  );
        *((uint32_t*)(block+4))= AV_RN32(pixels+4);
        pixels+=line_size;
        block +=line_size;
    }
}

#ifdef JZ4740_MXU_OPT
 static void put_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;
    uint32_t src_aln1, src_rs1, src_aln2, src_rs2;

    src_aln1 = (uint32_t)src1 & 0xfffffffc;
    src_rs1 = 4 - ((uint32_t)src1 & 3);
    src_aln2 = (uint32_t)src2 & 0xfffffffc;
    src_rs2 = 4 - ((uint32_t)src2 & 3);

     dst -= dst_stride;
     src_aln1 -= src_stride1;
     src_aln2 -= src_stride2;
    
     for(i=0; i<h; i++) {
      S32LDIV(xr1, src_aln1, src_stride1, 0);
      S32LDD(xr2, src_aln1, 4);
      S32LDD(xr3, src_aln1, 8);
      S32LDIV(xr4, src_aln2, src_stride2, 0);
      S32LDD(xr5, src_aln2, 4);
      S32LDD(xr6, src_aln2, 8);

      S32ALN(xr1, xr2, xr1, src_rs1);
      S32ALN(xr4, xr5, xr4, src_rs2);
      Q8AVGR(xr1, xr4, xr1);

      S32ALN(xr2, xr3, xr2, src_rs1);
      S32ALN(xr5, xr6, xr5, src_rs2);
      Q8AVGR(xr2, xr5, xr2);

      S32SDIV(xr1, dst, dst_stride, 0);
      S32STD(xr2, dst, 4);
    }
}
#else
static  void put_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;
        a= AV_RN32(&src1[i*src_stride1  ]);
        b= AV_RN32(&src2[i*src_stride2  ]);
        *((uint32_t*)&dst[i*dst_stride  ])= rnd_avg32(a, b);
        a= AV_RN32(&src1[i*src_stride1+4]);
        b= AV_RN32(&src2[i*src_stride2+4]);
        *((uint32_t*)&dst[i*dst_stride+4])= rnd_avg32(a, b);
    }
}
#endif
static  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;
        a= AV_RN32(&src1[i*src_stride1  ]);