simple_idct.c

来自「君正早期ucos系统(只有早期的才不没有打包成库),MPLAYER,文件系统,图」· C语言 代码 · 共 925 行 · 第 1/3 页

// calculate b1
      D16MUL_LW(xr10, xr7, xr1, xr15);      //xr10(nx1 * W3) xr15(x1 * W3)
      D16MAC_SS_LW(xr10, xr8, xr2, xr15);   //xr10(nx1*W3 - nx3*W7) xr15(x1*W3 - x3*W7)
      D16MAC_SS_HW(xr10, xr7, xr3, xr15);   //xr10(nx1*W3 - nx3*W7 - nx5*W1)
                                            //xr15(x1*W3 - x3*W7 - x5*W1)
      D16MAC_SS_HW(xr10, xr8, xr4, xr15);   //xr10(nx1*W3 - nx3*W7 - nx5*W1 - nx7*W5)
                                            //xr15(x1*W3 - x3*W7 - x5*W1 - nx7*W5)
      D16MACF_AA_WW(xr10, xr0, xr0, xr15);  //xr10 (nb1,b1)
// store result
      Q16ADD_AS_WW(xr11,xr11,xr9,xr9);      //xr11(na0+nb0,a0+b0) xr9(na0-nb0, a0-b0)
      S32STD(xr11, inptr, 0x00);
      S32STD(xr9,  inptr, 0x70);
      Q16ADD_AS_WW(xr13,xr13,xr10,xr10);    //xr13(na1+nb1,a1+b1) xr10(na1-nb1, a1-b1)
      S32STD(xr13, inptr, 0x10);
      S32STD(xr10, inptr, 0x60);
// calculate b2
      D16MUL_HW(xr9, xr8, xr1, xr10);      //xr9(nx1 * W5) xr10(x1 * W5)
      D16MAC_SS_HW(xr9, xr7, xr2, xr10);   //xr9(nx1*W5 - nx3*W1) xr10(x1*W5 - x3*W1)
      D16MAC_AA_LW(xr9, xr8, xr3, xr10);   //xr9(nx1*W5 - nx3*W1 + nx5*W7)
                                           //xr10(x1*W5 - x3*W1 + x5*W7)
      D16MAC_AA_LW(xr9, xr7, xr4, xr10);   //xr9(nx1*W5 - nx3*W1 + nx5*W7 + nx7*W3)
                                           //xr10(x1*W5 - x3*W1 + x5*W7 + nx7*W3)
      D16MACF_AA_WW(xr9, xr0, xr0, xr10);  //xr9 (nb2,b2)
// calculate b3
      D16MUL_LW(xr10, xr8, xr1, xr15);      //xr10(nx1 * W7) xr15(x1 * W7)
      D16MAC_SS_HW(xr10, xr8, xr2, xr15);   //xr10(nx1*W7 - nx3*W5) xr15(x1*W7 - x3*W5)
      D16MAC_AA_LW(xr10, xr7, xr3, xr15);   //xr10(nx1*W7 - nx3*W5 + nx5*W3)
                                            //xr15(x1*W7 - x3*W5 + x5*W3)
      D16MAC_SS_HW(xr10, xr7, xr4, xr15);   //xr10(nx1*W7 - nx3*W5 + nx5*W3 - nx7*W1)
                                            //xr15(x1*W7 - x3*W5 + x5*W3 - nx7*W1)
      D16MACF_AA_WW(xr10, xr0, xr0, xr15);  //xr10 (nb3,b3)
// store result
      Q16ADD_AS_WW(xr14,xr14,xr9,xr9);      //xr14(na2+nb2,a2+b2) xr9(na2-nb2, a2-b2)
      S32STD(xr14, inptr, 0x20);
      S32STD(xr9,  inptr, 0x50);
      Q16ADD_AS_WW(xr12,xr12,xr10,xr10);    //xr12(na3+nb3,a3+b3) xr10(na3-nb3, a3-b3)
      S32LDI(xr1, inptr, 0x04);    //  xr1 (nx0, x0)
      S32STD(xr12, inptr, 0x2c);
      S32STD(xr10, inptr, 0x3c);
   } while (inptr != endptr);

   inptr = block;
   endptr = inptr + 8*8;
   S32LDD(xr1, inptr, 0);          //  xr1 (x1, x0)
// calculate line
   do {
      S32LDD(xr2, inptr, 0x4);        //  xr2 (x3, x2)
      S32LDD(xr3, inptr, 0x8);        //  xr3 (x5, x4)
      S32LDD(xr4, inptr, 0xc);        //  xr4 (x7, x6)

// calculate b0,b1,b2,b3
      D16MUL_HW(xr11, xr1, xr7, xr12); // xr11 (W1*x1)  xr12 (W3*x1)
      D16MUL_HW(xr13, xr1, xr8, xr14); // xr13 (W5*x1)  xr14 (W7*x1)
      D16MAC_SA_HW(xr13,xr2,xr7,xr11); // xr13 (W5*x1 - W1*x3) xr11 (W1*x1 + W3*x3)
      D16MAC_SS_HW(xr14,xr2,xr8,xr12); // xr14 (W7*x1 - W5*x3) xr12 (W3*x1 - W7*x3)
      D16MAC_SA_HW(xr12,xr3,xr7,xr14); // xr12 (W3*x1 - W7*x3 - W1*x5)
                                       // xr14 (W7*x1 - W5*x3 + W3*x5)
      D16MAC_AA_HW(xr11,xr3,xr8,xr13); // xr11 (W1*x1 + W3*x3 + W5*x5)
                                       // xr13 (W5*x1 - W1*x3 + W7*x5)
//calculate a0,a1,a2,a3
      D16MUL_LW(xr9, xr1, xr5, xr10); // xr9 (W4*x0)  xr10 (W4*x0)
      D16MAC_AS_LW(xr9,xr3,xr5,xr10); // xr9 (W4*x0 + W4*x4) xr10 (W4*x0 - W4*x4)
      D16MUL_LW(xr1, xr2, xr6, xr3); // xr1 (W2*x2)  xr3 (W6*x2)
      D16MAC_SA_LW(xr3,xr4,xr6,xr1); // xr3 (W6*x2 - W2*x6) xr1 (W2*x2 + W6*x6)
//schedule b0 ~ b3
      D16MAC_SA_HW(xr12,xr4,xr8,xr11); // xr12 (W3*x1 - W7*x3 - W1*x5 - W5*x7),b1
                                       // xr11 (W1*x1 + W3*x3 + W5*x5 + W7*x7),b0
      D16MAC_SA_HW(xr14,xr4,xr7,xr13); // xr14 (W7*x1 - W5*x3 + W3*x5 - W1*x7),b3
                                       // xr13 (W5*x1 - W1*x3 + W7*x5 + W3*x7),b2
// continue a0 ~ a3
      D32ADD_AS(xr2, xr9, xr1, xr4);   //xr2 (W4*x0 + W4*x4 + W2*x2 + W6*x6),a0
                                       //xr4 (W4*x0 + W4*x4 - W2*x2 - W6*x6),a3
      D32ADD_AS(xr9,xr10,xr3, xr1);    //xr9(W4*x0 - W4*x4 + W6*x2 - W2*x6),a1
                                       //xr1(W4*x0 - W4*x4 - W6*x2 + W2*x6),a2
//calculate a +/- b
      D32ADD_AS(xr2, xr2, xr11, xr11); //xr2(a0 + b0)  xr11 (a0 - b0)
      D32ADD_AS(xr4, xr4, xr14, xr14); //xr4(a3 + b3)  xr14 (a3 - b3)
      D32ADD_AS(xr9, xr9, xr12, xr12); //xr9(a1 + b1)  xr12 (a1 - b1)
      D32ADD_AS(xr1, xr1, xr13, xr13); //xr1(a2 + b2)  xr13 (a2 - b2)
//padding and saturate
      D16MACF_AA_WW(xr9, xr0, xr0, xr2);  // r9 (a1+b1, a0+b0)
      D16MACF_AA_WW(xr4, xr0, xr0, xr1);  // r4 (a3+b3, a2+b2)
      D16MACF_AA_WW(xr13,xr0, xr0, xr14); // r13(a2-b2, a3-b3)
      D16MACF_AA_WW(xr11,xr0, xr0, xr12); // r11(a0-b0, a1-b1)
      S32LDD(xr1, dest, 0x00);    //  xr1 (x3, x2, x1, x0)
      S32LDD(xr2, dest, 0x04);    //  xr2 (x7, x6, x5, x4)
      Q8ACCE_AA(xr4, xr1,  xr0, xr9);
      Q8ACCE_AA(xr11, xr2, xr0, xr13);
      S32LDI(xr1, inptr, 0x10);          //  xr1 (x1, x0)

      Q16SAT(xr4, xr4, xr9);
      Q16SAT(xr11,xr11, xr13);
      S32STD(xr4, dest, 0x0);
      S32STD(xr11,dest, 0x4);
      dest += line_size;
   } while (inptr != endptr);
}
#else
void simple_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
{
    int i;
    for(i=0; i<8; i++)
        idctRowCondDC(block + i*8);

    for(i=0; i<8; i++)
        idctSparseColAdd(dest + i, line_size, block + i);
}
#endif

void simple_idct(DCTELEM *block)
{
    int i;
    for(i=0; i<8; i++)
        idctRowCondDC(block + i*8);

    for(i=0; i<8; i++)
        idctSparseCol(block + i);
}

/* 2x4x8 idct */

#define CN_SHIFT 12
#define C_FIX(x) ((int)((x) * (1 << CN_SHIFT) + 0.5))
#define C1 C_FIX(0.6532814824)
#define C2 C_FIX(0.2705980501)

/* row idct is multiple by 16 * sqrt(2.0), col idct4 is normalized,
   and the butterfly must be multiplied by 0.5 * sqrt(2.0) */
#define C_SHIFT (4+1+12)

static inline void idct4col(uint8_t *dest, int line_size, const DCTELEM *col)
{
    int c0, c1, c2, c3, a0, a1, a2, a3;
    const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    a0 = col[8*0];
    a1 = col[8*2];
    a2 = col[8*4];
    a3 = col[8*6];
    c0 = ((a0 + a2) << (CN_SHIFT - 1)) + (1 << (C_SHIFT - 1));
    c2 = ((a0 - a2) << (CN_SHIFT - 1)) + (1 << (C_SHIFT - 1));
    c1 = a1 * C1 + a3 * C2;
    c3 = a1 * C2 - a3 * C1;
    dest[0] = cm[(c0 + c1) >> C_SHIFT];
    dest += line_size;
    dest[0] = cm[(c2 + c3) >> C_SHIFT];
    dest += line_size;
    dest[0] = cm[(c2 - c3) >> C_SHIFT];
    dest += line_size;
    dest[0] = cm[(c0 - c1) >> C_SHIFT];
}

#define BF(k) \
{\
    int a0, a1;\
    a0 = ptr[k];\
    a1 = ptr[8 + k];\
    ptr[k] = a0 + a1;\
    ptr[8 + k] = a0 - a1;\
}

/* only used by DV codec. The input must be interlaced. 128 is added
   to the pixels before clamping to avoid systematic error
   (1024*sqrt(2)) offset would be needed otherwise. */
/* XXX: I think a 1.0/sqrt(2) normalization should be needed to
   compensate the extra butterfly stage - I don't have the full DV
   specification */
void simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block)
{
    int i;
    DCTELEM *ptr;

    /* butterfly */
    ptr = block;
    for(i=0;i<4;i++) {
        BF(0);
        BF(1);
        BF(2);
        BF(3);
        BF(4);
        BF(5);
        BF(6);
        BF(7);
        ptr += 2 * 8;
    }

    /* IDCT8 on each line */
    for(i=0; i<8; i++) {
        idctRowCondDC(block + i*8);
    }

    /* IDCT4 and store */
    for(i=0;i<8;i++) {
        idct4col(dest + i, 2 * line_size, block + i);
        idct4col(dest + line_size + i, 2 * line_size, block + 8 + i);
    }
}

#ifndef USE_16M_SDRAM
/* 8x4 & 4x8 WMV2 IDCT */
#undef CN_SHIFT
#undef C_SHIFT
#undef C_FIX
#undef C1
#undef C2
#define CN_SHIFT 12
#define C_FIX(x) ((int)((x) * 1.414213562 * (1 << CN_SHIFT) + 0.5))
#define C1 C_FIX(0.6532814824)
#define C2 C_FIX(0.2705980501)
#define C3 C_FIX(0.5)
#define C_SHIFT (4+1+12)
static inline void idct4col_add(uint8_t *dest, int line_size, const DCTELEM *col)
{
    int c0, c1, c2, c3, a0, a1, a2, a3;
    const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    a0 = col[8*0];
    a1 = col[8*1];
    a2 = col[8*2];
    a3 = col[8*3];
    c0 = (a0 + a2)*C3 + (1 << (C_SHIFT - 1));
    c2 = (a0 - a2)*C3 + (1 << (C_SHIFT - 1));
    c1 = a1 * C1 + a3 * C2;
    c3 = a1 * C2 - a3 * C1;
    dest[0] = cm[dest[0] + ((c0 + c1) >> C_SHIFT)];
    dest += line_size;
    dest[0] = cm[dest[0] + ((c2 + c3) >> C_SHIFT)];
    dest += line_size;
    dest[0] = cm[dest[0] + ((c2 - c3) >> C_SHIFT)];
    dest += line_size;
    dest[0] = cm[dest[0] + ((c0 - c1) >> C_SHIFT)];
}

#define RN_SHIFT 15
#define R_FIX(x) ((int)((x) * 1.414213562 * (1 << RN_SHIFT) + 0.5))
#define R1 R_FIX(0.6532814824)
#define R2 R_FIX(0.2705980501)
#define R3 R_FIX(0.5)
#define R_SHIFT 11
static inline void idct4row(DCTELEM *row)
{
    int c0, c1, c2, c3, a0, a1, a2, a3;
    //const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

    a0 = row[0];
    a1 = row[1];
    a2 = row[2];
    a3 = row[3];
    c0 = (a0 + a2)*R3 + (1 << (R_SHIFT - 1));
    c2 = (a0 - a2)*R3 + (1 << (R_SHIFT - 1));
    c1 = a1 * R1 + a3 * R2;
    c3 = a1 * R2 - a3 * R1;
    row[0]= (c0 + c1) >> R_SHIFT;
    row[1]= (c2 + c3) >> R_SHIFT;
    row[2]= (c2 - c3) >> R_SHIFT;
    row[3]= (c0 - c1) >> R_SHIFT;
}

void simple_idct84_add(uint8_t *dest, int line_size, DCTELEM *block)
{
    int i;

    /* IDCT8 on each line */
    for(i=0; i<4; i++) {
        idctRowCondDC(block + i*8);
    }

    /* IDCT4 and store */
    for(i=0;i<8;i++) {
        idct4col_add(dest + i, line_size, block + i);
    }
}

void simple_idct48_add(uint8_t *dest, int line_size, DCTELEM *block)
{
    int i;

    /* IDCT4 on each line */
    for(i=0; i<8; i++) {
        idct4row(block + i*8);
    }

    /* IDCT8 and store */
    for(i=0; i<4; i++){
        idctSparseColAdd(dest + i, line_size, block + i);
    }
}
#endif

#ifdef JZ4740_MXU_OPT
unsigned int disable_jz4740_mxu (unsigned int mxucr)
{
  S32I2M(xr16, mxucr);
  return 0;
}

unsigned int enable_jz4740_mxu ()
{
  unsigned int mxucr, nval;
  mxucr = S32M2I(xr16);
  nval = mxucr | 0x7;
  S32I2M(xr16, nval);
  return mxucr;
}
#endif