idct.c

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

      S32STD(xr5, blk, 0x50);
      S32STD(xr3, blk, 0x60);
      S32STD(xr11, blk, 0x70);
    }
  blk = block -8;
  dest -= stride;
  for (i=0; i< 8; i++) {
    S32LDI(xr1, blk, 0x10);
    S32LDD(xr2, blk, 0x4);
    S32LDD(xr3, blk, 0x8);
    S32LDD(xr4, blk, 0xc);
    S32STD(xr0, blk, 0x0);
    S32STD(xr0, blk, 0x4); 
    S32STD(xr0, blk, 0x8);
    S32STD(xr0, blk, 0xc);
    Q16SAT(xr5, xr2, xr1);
    Q16SAT(xr6, xr4, xr3);
    S32SDIV(xr5, dest, stride, 0x0);
    S32STD(xr6, dest, 0x4);
  }
}
#else
static void mpeg2_idct_copy_c (int16_t * block, uint8_t * dest,
                               const int stride)
{
    int i;
    for (i = 0; i < 8; i++)
        idct_row (block + 8 * i);
    for (i = 0; i < 8; i++)
        idct_col (block + i);
    do {
        dest[0] = CLIP (block[0]);
        dest[1] = CLIP (block[1]);
        dest[2] = CLIP (block[2]);
        dest[3] = CLIP (block[3]);
        dest[4] = CLIP (block[4]);
        dest[5] = CLIP (block[5]);
        dest[6] = CLIP (block[6]);
        dest[7] = CLIP (block[7]);

        ((int32_t *)block)[0] = 0;      ((int32_t *)block)[1] = 0;
        ((int32_t *)block)[2] = 0;      ((int32_t *)block)[3] = 0;

        dest += stride;
        block += 8;
    } while (--i);
}
#endif

#ifdef JZ4740_MXU_OPT

static void mpeg2_idct_add_c (const int last, int16_t * block,
			      uint8_t * dest, const int stride)
{
  int i;
  int16_t  *blk;
  int32_t wf = (int32_t)whirl_idct;

  S32LDD(xr5, wf, 0x0);         // xr5(w7, w3)
  S32LDD(xr6, wf, 0x4);         // xr6(w9, w8)
  S32LDD(xr7, wf, 0x8);         // xr7(w11,w10)
  S32LDD(xr8, wf, 0xc);         // xr8(w13,w12)
  S32LDD(xr9, wf, 0x10);        // xr9(w6, w0)
  S32LDD(xr10,wf, 0x14);

  blk = block - 8;
  do { /* idct rows */
      S32LDI(xr1, blk, 0x10);        //  xr1 (x4, x0)
      S32LDD(xr2, blk, 0x4);        //  xr2 (x7, x3)
      S32LDD(xr3, blk, 0x8);        //  xr3 (x6, x1)
      S32LDD(xr4, blk, 0xc);        //  xr4 (x5, x2)

      S32SFL(xr1,xr1,xr2,xr2, ptn3);
      S32SFL(xr3,xr3,xr4,xr4, ptn3);

      D16MUL_WW(xr11, xr2, xr5, xr12);
      D16MAC_AA_WW(xr11,xr4,xr6,xr12);

      D16MUL_WW(xr13, xr2, xr6, xr14);
      D16MAC_SS_WW(xr13,xr4,xr5,xr14);

      D16MUL_HW(xr2, xr1, xr7, xr4);
      D16MAC_AS_LW(xr2,xr1,xr9,xr4);
      D16MAC_AS_HW(xr2,xr3,xr10,xr4);
      D16MAC_AS_LW(xr2,xr3,xr8,xr4);
      D16MACF_AA_WW(xr2, xr0, xr0, xr4);
      D16MACF_AA_WW(xr11, xr0, xr0, xr13);
      D16MACF_AA_WW(xr12, xr0, xr0, xr14);

      D16MUL_HW(xr4, xr1, xr8, xr15);
      D16MAC_SS_LW(xr4,xr1,xr10,xr15);
      D16MAC_AA_HW(xr4,xr3,xr9,xr15);
      D16MAC_SA_LW(xr4,xr3,xr7,xr15);
      Q16ADD_AS_WW(xr11,xr11,xr12,xr12); 
      D16MACF_AA_WW(xr15, xr0, xr0, xr4);

      Q16ADD_AS_WW(xr11, xr11, xr2, xr2);
      Q16ADD_AS_XW(xr12, xr12, xr15, xr15);

      S32SFL(xr11,xr11,xr12,xr12, ptn3);
      S32SFL(xr12,xr12,xr11,xr11, ptn3);

      S32STD(xr12, blk, 0x0);
      S32STD(xr11, blk, 0x4);
      S32STD(xr15, blk, 0x8);
      S32STD(xr2, blk, 0xc);
  } while (idct_row_max--);
     blk  = block - 2;
  for (i = 0; i < 4; i++)               /* idct columns */
    {
      S32LDI(xr1, blk, 0x4);
      S32LDD(xr3, blk, 0x20);
      S32I2M(xr5,wxr5);
      S32LDD(xr11, blk, 0x40);
      S32LDD(xr13, blk, 0x60);

      D16MUL_HW(xr15, xr5, xr1, xr9);
      D16MAC_AA_HW(xr15,xr5,xr11,xr9);
      D16MACF_AA_WW(xr15, xr0, xr0, xr9);
      D16MUL_LW(xr10, xr5, xr3, xr9);
      D16MAC_AA_LW(xr10,xr6,xr13,xr9);
      D16MACF_AA_WW(xr10, xr0, xr0, xr9);
      S32LDD(xr2, blk, 0x10);
      S32LDD(xr4, blk, 0x30);
      Q16ADD_AS_WW(xr15,xr15,xr10,xr9);

      D16MUL_HW(xr10, xr5, xr1, xr1);
      D16MAC_SS_HW(xr10,xr5,xr11,xr1);
      D16MACF_AA_WW(xr10, xr0, xr0, xr1);
      D16MUL_LW(xr11, xr6, xr3, xr1);
      D16MAC_SS_LW(xr11,xr5,xr13,xr1);
      D16MACF_AA_WW(xr11, xr0, xr0, xr1);
      S32LDD(xr12, blk, 0x50);
      S32LDD(xr14, blk, 0x70);
      Q16ADD_AS_WW(xr10,xr10,xr11,xr1);

      D16MUL_HW(xr11, xr7, xr2, xr13);
      D16MAC_AA_LW(xr11,xr7,xr4,xr13);
      D16MAC_AA_LW(xr11,xr8,xr12,xr13);
      D16MAC_AA_HW(xr11,xr8,xr14,xr13);
      D16MACF_AA_WW(xr11, xr0, xr0, xr13);
     
       D16MUL_LW(xr3, xr7, xr2, xr13);
      D16MAC_SS_HW(xr3,xr8,xr4,xr13);
      D16MAC_SS_HW(xr3,xr7,xr12,xr13);
      D16MAC_SS_LW(xr3,xr8,xr14,xr13);
      D16MACF_AA_WW(xr3, xr0, xr0, xr13);

      D16MUL_LW(xr5, xr8, xr2, xr13);
      D16MAC_SS_HW(xr5,xr7,xr4,xr13);
      D16MAC_AA_HW(xr5,xr8,xr12,xr13);
      D16MAC_AA_LW(xr5,xr7,xr14,xr13);
      D16MACF_AA_WW(xr5, xr0, xr0, xr13);

      D16MUL_HW(xr2, xr8, xr2, xr13);
      D16MAC_SS_LW(xr2,xr8,xr4,xr13);
      D16MAC_AA_LW(xr2,xr7,xr12,xr13);
      D16MAC_SS_HW(xr2,xr7,xr14,xr13);
      D16MACF_AA_WW(xr2, xr0, xr0, xr13);

      Q16ADD_AS_WW(xr15,xr15,xr11,xr11);
      Q16ADD_AS_WW(xr10,xr10,xr3,xr3);
      Q16ADD_AS_WW(xr1,xr1,xr5,xr5);
      Q16ADD_AS_WW(xr9,xr9,xr2,xr2);

      S32STD(xr15, blk, 0x00);
      S32STD(xr10, blk, 0x10);
      S32STD(xr1, blk, 0x20);
      S32STD(xr9, blk, 0x30);
      S32STD(xr2, blk, 0x40);
      S32STD(xr5, blk, 0x50);
      S32STD(xr3, blk, 0x60);
      S32STD(xr11, blk, 0x70);
    }
  blk = block - 8;
  dest -= stride;
  for (i=0; i< 8; i++) {
    S32LDIV(xr5, dest, stride, 0x0);
    S32LDI(xr1, blk, 0x10);
    S32LDD(xr2, blk, 0x4);
    Q8ACCE_AA(xr2, xr5, xr0, xr1);

    S32LDD(xr6, dest, 0x4);
    S32LDD(xr3, blk, 0x8);
    S32LDD(xr4, blk, 0xc);
    Q8ACCE_AA(xr4, xr6, xr0, xr3);
    S32STD(xr0, blk, 0x0);
    S32STD(xr0, blk, 0x4);
    S32STD(xr0, blk, 0x8);
    S32STD(xr0, blk, 0xc);
    Q16SAT(xr5, xr2, xr1);
    S32STD(xr5, dest, 0x0);
    Q16SAT(xr6, xr4, xr3);
    S32STD(xr6, dest, 0x4);
  }

}

#else
static void mpeg2_idct_add_c (const int last, int16_t * block,
			      uint8_t * dest, const int stride)
{
    int i;
   
    if (last != 129 || (block[0] & (7 << 4)) == (4 << 4)) {
	for (i = 0; i < 8; i++)
	    idct_row (block + 8 * i);
	for (i = 0; i < 8; i++)
	    idct_col (block + i);
	do {
	    dest[0] = CLIP (block[0] + dest[0]);
	    dest[1] = CLIP (block[1] + dest[1]);
	    dest[2] = CLIP (block[2] + dest[2]);
	    dest[3] = CLIP (block[3] + dest[3]);
	    dest[4] = CLIP (block[4] + dest[4]);
	    dest[5] = CLIP (block[5] + dest[5]);
	    dest[6] = CLIP (block[6] + dest[6]);
	    dest[7] = CLIP (block[7] + dest[7]);

	    ((int32_t *)block)[0] = 0;	((int32_t *)block)[1] = 0;
	    ((int32_t *)block)[2] = 0;	((int32_t *)block)[3] = 0;

	    dest += stride;
	    block += 8;
	} while (--i);
    } else {
	int DC;

	DC = (block[0] + 64) >> 7;
	block[0] = block[63] = 0;
	i = 8;
	do {
	    dest[0] = CLIP (DC + dest[0]);
	    dest[1] = CLIP (DC + dest[1]);
	    dest[2] = CLIP (DC + dest[2]);
	    dest[3] = CLIP (DC + dest[3]);
	    dest[4] = CLIP (DC + dest[4]);
	    dest[5] = CLIP (DC + dest[5]);
	    dest[6] = CLIP (DC + dest[6]);
	    dest[7] = CLIP (DC + dest[7]);
	    dest += stride;
	} while (--i);
    }
}
#endif
void mpeg2_idct_init (uint32_t accel)
{
	
#ifdef HAVE_MMX2
    if (accel & MPEG2_ACCEL_X86_MMXEXT) {
	mpeg2_idct_copy = mpeg2_idct_copy_mmxext;
	mpeg2_idct_add = mpeg2_idct_add_mmxext;
	mpeg2_idct_mmx_init ();
    } else
#endif
#ifdef HAVE_MMX
    if (accel & MPEG2_ACCEL_X86_MMX) {
	mpeg2_idct_copy = mpeg2_idct_copy_mmx;
	mpeg2_idct_add = mpeg2_idct_add_mmx;
	mpeg2_idct_mmx_init ();
    } else
#endif
#if defined(ARCH_PPC) && defined(HAVE_ALTIVEC)
    if (accel & MPEG2_ACCEL_PPC_ALTIVEC) {
	mpeg2_idct_copy = mpeg2_idct_copy_altivec;
	mpeg2_idct_add = mpeg2_idct_add_altivec;
	mpeg2_idct_altivec_init ();
    } else
#endif
#ifdef ARCH_ALPHA
#ifdef CAN_COMPILE_ALPHA_MVI
    if (accel & MPEG2_ACCEL_ALPHA_MVI) {
	mpeg2_idct_copy = mpeg2_idct_copy_mvi;
	mpeg2_idct_add = mpeg2_idct_add_mvi;
	mpeg2_idct_alpha_init ();
    } else
#endif
    if (accel & MPEG2_ACCEL_ALPHA) {
	int i;

	mpeg2_idct_copy = mpeg2_idct_copy_alpha;
	mpeg2_idct_add = mpeg2_idct_add_alpha;
	mpeg2_idct_alpha_init ();
	for (i = -3840; i < 3840 + 256; i++)
	    CLIP(i) = (i < 0) ? 0 : ((i > 255) ? 255 : i);
    } else
#endif
    {
	extern uint8_t mpeg2_scan_norm[64];
	extern uint8_t mpeg2_scan_alt[64];
	int i, j;

	mpeg2_idct_copy = mpeg2_idct_copy_c;
	mpeg2_idct_add = mpeg2_idct_add_c;
	static int dInit = 0;
	if(dInit != 0)
		return ;
	dInit = 1;
#ifdef JZ4740_MXU_OPT
#else
	for (i = -3840; i < 3840 + 256; i++)
	    CLIP(i) = (i < 0) ? 0 : ((i > 255) ? 255 : i);
	for (i = 0; i < 64; i++) {
	    j = mpeg2_scan_norm[i];
	    mpeg2_scan_norm[i] = ((j & 0x36) >> 1) | ((j & 0x09) << 2);
	    j = mpeg2_scan_alt[i];
	    mpeg2_scan_alt[i] = ((j & 0x36) >> 1) | ((j & 0x09) << 2);
	}
#endif
    }
}