imxsim.c

可以了解TI的DSP iMX的用法。适用DSP54X

    dpage = (short *) IMGBUFA;
  data_byte = ((short) (data_init - dpage)) << 1;
  
  if ((short) coef_init >= iMXCOEFFBUF) 
    cpage = (short *) iMXCOEFFBUF;      
  else
    cpage = (short *) IMGBUFA;
  coef_byte = ((short) (coef_init - cpage)) << 1;
  
  if ((short) outp_init >= iMXCOEFFBUF) 
    opage = (short *) iMXCOEFFBUF;      
  else
    opage = (short *) IMGBUFA;
  outp_byte = ((short) (outp_init - opage)) << 1;
#endif

  dpage = image_buf;
  cpage = coeff_buf;
  opage = image_buf;
  data_byte = ((short) (data_init - dpage)) << 1;
  coef_byte = ((short) (coef_init - cpage)) << 1;
  outp_byte = ((short) (outp_init - opage)) << 1;

  for (i1=0; i1<=lpend1; i1++) {
    for (i2=0; i2<=lpend2; i2++) {
      for (i3=0; i3<=lpend3; i3++) {
        for (i4=0; i4<=lpend4; i4++) {

          /* format data */
          access_mem(dpage, data_byte, dpoints, dsize, x, 0);
          
          access_mem(cpage, coef_byte, cpoints, csize, y, 1);
          
          /* initialize acc */
          if (acc_mode == 0) /* single accumulator */
            if ((acclp == 0 && first234(i2,i3,i4)) ||
               (acclp == 1 && first34(i2,i3,i4)) ||
               (acclp == 2 && first4(i2,i3,i4)) ||
               (acclp == 3)) 
            {
              init_acc = 1;
              for (pe = 0; pe < NO_OF_MACS; pe++) 
                acc[0][pe] = rnd_add;
            }
            else {
              init_acc = 0;
            }
          else /* multiple accumulator */
            if ((acclp == 0 && first23(i2,i3,i4)) ||
               (acclp == 1 && first3(i2,i3,i4)) ||
               (acclp == 2) || (acclp == 3))
            {
              init_acc = 1;
              for (pe = 0; pe < NO_OF_MACS; pe++)
                acc[i4][pe] = rnd_add;
            }
            else {
               init_acc = 0;
            }

          /* multiply-accumulate */
          for (pe = 0; (pe < NO_OF_MACS) && (op != 4); pe++) 
            switch(op) {
              case 0: acc[acc_mode*i4][pe] += (long)(x[pe]) * (long)(y[pe]); break;
              case 1: acc[acc_mode*i4][pe] += abs(x[pe] - y[pe]); break;
              case 3: acc[acc_mode*i4][pe] += x[pe] - y[pe]; break;
              default: acc[acc_mode*i4][pe] += x[pe] + y[pe]; break;
            }

          /* table lookup */
          if (op == 4) {
            tlu_offset = (short)((x[0] + rnd_add) >> rnd_shift);  /* round, saturate */
            tlu_offset = (tlu_offset >= sat_high) ? sat_high_set : tlu_offset;
            tlu_offset = (tlu_offset < 0) ? 0 : tlu_offset;
            if (csize == iMXTYPE_SHORT) /* short */ 
              tlu_out = cpage[(coef_byte >> 1) + tlu_offset];
            else /* byte */ {
              tlu_offset += coef_byte;
              if (tlu_offset & 1) /* odd, high byte */
                 tlu_out = (cpage[tlu_offset >> 1] >> 8) & 0xFF;
              else                /* even, low byte */
                 tlu_out = cpage[tlu_offset >> 1] & 0xFF; 
            }
          }

          /* write back */
          if (((acc_mode == 0) && 
               ((acclp == 3) ||
                (acclp == 2 && last4(i2,i3,i4,lpend2,lpend3,lpend4)) ||
                (acclp == 1 && last34(i2,i3,i4,lpend2,lpend3,lpend4)) ||
                (acclp == 0 && last234(i2,i3,i4,lpend2,lpend3,lpend4))
                )
               ) ||
              ((acc_mode == 1) && 
               ((acclp == 3) || (acclp == 2) ||
                (acclp == 1 && last3(i2,i3,i4,lpend2,lpend3,lpend4)) ||
                (acclp == 0 && last23(i2,i3,i4,lpend2,lpend3,lpend4))
                )
               )
              )
          {
            writeback = 1;
            outp_short = &opage[outp_byte >> 1];
            
            if (op == 4) { /* table lookup should bypass sat/rnd */
              if (osize == iMXTYPE_SHORT) /* short */
                outp_short[0] = tlu_out;
              else                        /* byte */ {
                if (outp_byte & 1)   /* odd, high byte */
                  outp_short[0] = (outp_short[0] & 0x00FF) | (outp_tmp[0] << 8);
                else                 /* even, low byte */
                  outp_short[0] = (outp_short[0] & 0xFF00) | outp_tmp[0];
              }
            }
            else {
              if (osize == iMXTYPE_SHORT) /* short */
                switch(opoints) {
                case 4: outp_short[0] = imx_saturate(acc[acc_mode*i4][0] >> rnd_shift);
                        outp_short[1] = imx_saturate(acc[acc_mode*i4][1] >> rnd_shift);
                        outp_short[2] = imx_saturate(acc[acc_mode*i4][2] >> rnd_shift);
                        outp_short[3] = imx_saturate(acc[acc_mode*i4][3] >> rnd_shift); 
                        break;
                case 2: outp_short[0] = imx_saturate(acc[acc_mode*i4][0] >> rnd_shift);
                        outp_short[1] = imx_saturate(acc[acc_mode*i4][2] >> rnd_shift); 
                        break;
                case 1: outp_short[0] = imx_saturate(acc[acc_mode*i4][0] >> rnd_shift); 
                        break;
                }
              else /* byte */
                switch(opoints) {
                case 4: outp_tmp[0] = imx_saturate(acc[acc_mode*i4][0] >> rnd_shift);
                        outp_tmp[1] = imx_saturate(acc[acc_mode*i4][1] >> rnd_shift);
                        outp_tmp[2] = imx_saturate(acc[acc_mode*i4][2] >> rnd_shift);
                        outp_tmp[3] = imx_saturate(acc[acc_mode*i4][3] >> rnd_shift); 
                        outp_short[0] = (outp_tmp[1] << 8) | (outp_tmp[0] & 0xFF);
                        outp_short[1] = (outp_tmp[3] << 8) | (outp_tmp[2] & 0xFF);
                        break;
                case 2: outp_tmp[0] = imx_saturate(acc[acc_mode*i4][0] >> rnd_shift);
                        outp_tmp[1] = imx_saturate(acc[acc_mode*i4][2] >> rnd_shift); 
                        outp_short[0] = (outp_tmp[1] << 8) | (outp_tmp[0] & 0xFF);
                        break;
                case 1: outp_tmp[0] = imx_saturate(acc[acc_mode*i4][0] >> rnd_shift); 
                        if (outp_byte & 1)   /* odd, high byte */
                           outp_short[0] = (outp_short[0] & 0x00FF) | (outp_tmp[0] << 8);
                        else                 /* even, low byte */
                           outp_short[0] = (outp_short[0] & 0xFF00) | outp_tmp[0];
                        break;
                }
            }
          }
          else {
            writeback = 0;
          }

#if (DEBUG1)
          printf("DEBUG1  ");
          printf("%d %d %d %d %d\n", writeback, (init_acc ? 3 : 0),
                 data_byte, coef_byte, outp_byte);
#endif

          /* pointer increments */
         
#if 1 
          if (! ( ((data_inc_mask1 & 4) && !last(i2, lpend2)) ||
                  ((data_inc_mask1 & 2) && !last(i3, lpend3)) ||
                  ((data_inc_mask1 & 1) && !last(i4, lpend4)) )) {
#else   /* simpler logic -> easier to understand, saves one logical operator K.I. 26.10.99 */
          if ( (!(data_inc_mask1 & 4) || last(i2, lpend2)) &&
               (!(data_inc_mask1 & 2) || last(i3, lpend3)) &&
               (!(data_inc_mask1 & 1) || last(i4, lpend4)) )
          {
#endif
            data_byte += data_inc1;
          }
          else if (! ( ((data_inc_mask2 & 4) && !last(i2, lpend2)) ||
                  ((data_inc_mask2 & 2) && !last(i3, lpend3)) ||
                  ((data_inc_mask2 & 1) && !last(i4, lpend4)) )) {
            data_byte += data_inc2;
          }
          else if (! ( ((data_inc_mask3 & 4) && !last(i2, lpend2)) ||
                  ((data_inc_mask3 & 2) && !last(i3, lpend3)) ||
                  ((data_inc_mask3 & 1) && !last(i4, lpend4)) )) {
            data_byte += data_inc3;
          }
          else {
            data_byte += data_inc4;
          }

          if (! ( ((coef_inc_mask1 & 4) && !last(i2, lpend2)) ||
                  ((coef_inc_mask1 & 2) && !last(i3, lpend3)) ||
                  ((coef_inc_mask1 & 1) && !last(i4, lpend4)) )) {
            coef_byte += coef_inc1;
          }
          else if (! ( ((coef_inc_mask2 & 4) && !last(i2, lpend2)) ||
                  ((coef_inc_mask2 & 2) && !last(i3, lpend3)) ||
                  ((coef_inc_mask2 & 1) && !last(i4, lpend4)) )) {
            coef_byte += coef_inc2;
          }
          else if (! ( ((coef_inc_mask3 & 4) && !last(i2, lpend2)) ||
                  ((coef_inc_mask3 & 2) && !last(i3, lpend3)) ||
                  ((coef_inc_mask3 & 1) && !last(i4, lpend4)) )) {
            coef_byte += coef_inc3;
          }
          else {
            coef_byte += coef_inc4;
          }

          if (! ( ((outp_inc_mask1 & 4) && !last(i2, lpend2)) ||
                  ((outp_inc_mask1 & 2) && !last(i3, lpend3)) ||
                  ((outp_inc_mask1 & 1) && !last(i4, lpend4)) )) {
            outp_byte += outp_inc1;
          }
          else if (! ( ((outp_inc_mask2 & 4) && !last(i2, lpend2)) ||
                  ((outp_inc_mask2 & 2) && !last(i3, lpend3)) ||
                  ((outp_inc_mask2 & 1) && !last(i4, lpend4)) )) {
            outp_byte += outp_inc2;
          }
          else if (! ( ((outp_inc_mask3 & 4) && !last(i2, lpend2)) ||
                  ((outp_inc_mask3 & 2) && !last(i3, lpend3)) ||
                  ((outp_inc_mask3 & 1) && !last(i4, lpend4)) )) {
            outp_byte += outp_inc3;
          }
          else {
            outp_byte += outp_inc4;
          }

        }
      }
    }
  }

}