jfdct_bin_c1.c

JPEG Image compression using IJG standards followed

	tmp5 = (((tmp6 << 3) + (tmp6 << 2) + tmp6 ) >> 5) - tmp10;

    tmp10 = tmp4 + tmp5;
    tmp11 = tmp4 - tmp5;
    tmp12 = tmp7 - tmp6;
    tmp13 = tmp7 + tmp6;

    /* 7pi/16 = 3/16u -3/16d: alter the sign to get positive scaling factor */
    dataptr[7] = (((tmp13 << 1) + tmp13 ) >> 4) - tmp10;
	dataptr[1] = tmp13 - (((dataptr[7] << 1) + dataptr[7] ) >> 4);

    /* 3pi/16 = */
	/* new version: 11/16, 15/32 */
    dataptr[5] = tmp11 + (((tmp12 << 3) + (tmp12 << 1) + tmp12 ) >> 4);
    dataptr[3] = tmp12 - (((dataptr[5] << 4) - dataptr[5] ) >> 5);
   
    dataptr += DCTSIZE;		/* advance pointer to next row */
  }

  /* Pass 2: process columns.
   * We remove the PASS1_BITS scaling, but leave the results scaled up
   * by an overall factor of 8.
   */

  dataptr = data;
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
    tmp0 = (dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]);
    tmp7 = (dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]);
    tmp1 = (dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]);
    tmp6 = (dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]);
    tmp2 = (dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]);
    tmp5 = (dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]);
    tmp3 = (dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]);
    tmp4 = (dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]);

    /* Even part */
    
    tmp10 = (tmp0 + tmp3);	/* phase 2 */
    tmp13 = tmp0 - tmp3;
    tmp11 = (tmp1 + tmp2);
    tmp12 = tmp1 - tmp2;
    
    dataptr[DCTSIZE*0] = (tmp10 + tmp11); /* phase 3 */
	dataptr[DCTSIZE*4] = ((dataptr[DCTSIZE*0] ) >> 1) - tmp11;   /* Jie 05/18/00 */
    //dataptr[DCTSIZE*4] = (tmp10 - tmp11); /* phase 3 */

	// 3pi/8: 13/32, 11/32
    dataptr[DCTSIZE*6] = (((tmp13 << 3) + (tmp13 << 2) + tmp13 ) >> 5) - tmp12;
    dataptr[DCTSIZE*2] = tmp13 - (( (dataptr[DCTSIZE*6] << 3) + (dataptr[DCTSIZE*6] << 1) + dataptr[DCTSIZE*6] ) >> 5);
 
    /* Odd part */

/* pi/4 = 13/32, 11/16, 13/32*/
	tmp10 = tmp5 - (((tmp6 << 3) + (tmp6 << 2) + tmp6 ) >> 5);
	tmp6 = tmp6 + tmp10 - (((tmp10 << 2) + tmp10 ) >> 4);
	tmp5 = (((tmp6 << 3) + (tmp6 << 2) + tmp6 ) >> 5) - tmp10;

    tmp10 = tmp4 + tmp5;
    tmp11 = tmp4 - tmp5;
    tmp12 = tmp7 - tmp6;
    tmp13 = tmp7 + tmp6;

    /* 7pi/16 = 3/16u -3/16d: alter sign to get positive scaling factor */
    dataptr[DCTSIZE*7] = (((tmp13 << 1) + tmp13 ) >> 4) - tmp10;
	dataptr[DCTSIZE*1] = tmp13 - (((dataptr[DCTSIZE*7] << 1) + dataptr[DCTSIZE*7] ) >> 4);

    /* 3pi/16 = */
	/* 11/16, 15/32 */
    dataptr[DCTSIZE*5] = tmp11 + (((tmp12 << 3) + (tmp12 << 1) + tmp12 ) >> 4);
    dataptr[DCTSIZE*3] = tmp12 - (((dataptr[DCTSIZE*5] << 4) - dataptr[DCTSIZE*5] ) >> 5);

     dataptr++;			/* advance pointer to next column */

  }

/****************************************************************************/
   
} else {

/****************************************************************************/
  //Case 2: lossless binDCT: Use new butterflies.

  dataptr = data;
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {


/*******************/
/* Jie: test code */
	//	for (tmp0 = 0; tmp0 < 8; tmp0 ++) {
	//	  fprintf(stderr, "%10d", dataptr[tmp0]+128);
	//	}
	//	fprintf(stderr, "\n");

    tmp7 = dataptr[0] - dataptr[7];
    tmp0 = dataptr[0] - ((tmp7 ) >> 1);

    tmp6 = dataptr[1] - dataptr[6];
    tmp1 = dataptr[1] - ((tmp6 ) >> 1);

    tmp5 = dataptr[2] - dataptr[5];
    tmp2 = dataptr[2] - ((tmp5 ) >> 1);

    tmp4 = dataptr[3] - dataptr[4];
    tmp3 = dataptr[3] - ((tmp4 ) >> 1);
    
    /* Even part */
	//old method: larger dynamic range.
	//    tmp10 = (tmp0 + tmp3) ;	/* phase 2 */
	//    tmp13 = ((tmp10 ) >> 1) - tmp3;
	tmp13 = tmp0 - tmp3;
 	tmp10 = tmp0 - ((tmp13 ) >> 1);	

	//    tmp11 = (tmp1 + tmp2) ;
	//    tmp12 = ((tmp11 ) >> 1) - tmp2;
	tmp12 = tmp1 - tmp2;
	tmp11 = tmp1 - ((tmp12 ) >> 1);   

    //    dataptr[0] = (tmp10 + tmp11);             /* phase 3 */
	//    dataptr[4] = ((dataptr[0] ) >> 1) - tmp11;   /* Jie 05/18/00 */
	dataptr[4] = tmp10 - tmp11;
    dataptr[0] = tmp10 - ((dataptr[4] ) >> 1);

	//3pi/8: 13/32, 11/32.
    dataptr[6] = ( ((tmp13 << 3) + (tmp13 << 2) + tmp13 ) >> 5) - tmp12;     
    dataptr[2] = tmp13 - (((dataptr[6] << 3) + (dataptr[6] << 1) + dataptr[6] ) >> 5);
    
    /* Odd part */

	/* pi/4 = 13/32, 11/16, 13/32 */
	tmp10 = tmp5 - (( (tmp6 << 3) + (tmp6 << 2) + tmp6 ) >> 5);
	tmp6 = tmp6 + tmp10 - (((tmp10 << 2) + tmp10 ) >> 4);
	tmp5 = (((tmp6 << 3) + (tmp6 << 2) + tmp6 ) >> 5) - tmp10;

	//butterflies:
    //tmp10 = tmp4 + tmp5;
    //tmp11 = ((tmp10 ) >> 1) - tmp5;
	tmp11 = tmp4 - tmp5;
	tmp10 = tmp4 - ((tmp11 ) >> 1);

    //tmp13 = tmp6 + tmp7;
    //tmp12 = ((tmp13 ) >> 1) - tmp6;
	tmp12 = tmp7 - tmp6;
	tmp13 = tmp7 - (( tmp12 ) >> 1);

    /* 7pi/16 = 3/16u -3/16d: alter the sign to get positive scaling factor */
    dataptr[7] = (((tmp13 << 1) + tmp13) >> 4) - tmp10;
	dataptr[1] = tmp13 - (((dataptr[7] << 1) + dataptr[7] ) >> 4);

    /* 3pi/16 = */
	/* new version: 11/16, 15/32 */
    dataptr[5] = tmp11 + (((tmp12 << 3) + (tmp12 << 1) + tmp12 ) >> 4);
    dataptr[3] = tmp12 - (((dataptr[5] << 4) - dataptr[5] ) >> 5);
    
    dataptr += DCTSIZE;		/* advance pointer to next row */
  }

  /* Pass 2: process columns.
   * We remove the PASS1_BITS scaling, but leave the results scaled up
   * by an overall factor of 8.
   */

  dataptr = data;
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {

    tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
    tmp0 = dataptr[DCTSIZE*0] - ((tmp7 ) >> 1);

    tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
    tmp1 = dataptr[DCTSIZE*1] - ((tmp6 ) >> 1);

    tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
    tmp2 = dataptr[DCTSIZE*2] - ((tmp5 ) >> 1);

    tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
    tmp3 = dataptr[DCTSIZE*3] - ((tmp4 ) >> 1);

    /* Even part */
    
    //tmp10 = (tmp0 + tmp3); 
    //tmp13 = ((tmp10 ) >> 1) - tmp3;
	tmp13 = tmp0 - tmp3;
 	tmp10 = tmp0 - ((tmp13 ) >> 1);

    //tmp11 = (tmp1 + tmp2);
    //tmp12 = ((tmp11 ) >> 1) - tmp2;
	tmp12 = tmp1 - tmp2;
	tmp11 = tmp1 - ((tmp12 ) >> 1);

	//old method: larger dynamic range
    //dataptr[DCTSIZE*0] = (tmp10 + tmp11); /* phase 3 */
	//dataptr[DCTSIZE*4] = ((dataptr[DCTSIZE*0] ) >> 1) - tmp11;   /* Jie 05/18/00 */
	dataptr[DCTSIZE*4] = tmp10 - tmp11;
    dataptr[DCTSIZE*0] = tmp10 - ((dataptr[DCTSIZE*4] ) >> 1);

	// 3pi/8: 13/32, 11/32
    dataptr[DCTSIZE*6] = (((tmp13 << 3) + (tmp13 << 2) + tmp13 ) >> 5) - tmp12;
    dataptr[DCTSIZE*2] = tmp13 - (((dataptr[DCTSIZE*6] << 3) + (dataptr[DCTSIZE*6] << 1) + dataptr[DCTSIZE*6] ) >> 5);
 
    /* Odd part */

	/* pi/4 = 13/32, 11/16, 13/32 */
	tmp10 = tmp5 - (((tmp6 << 3) + (tmp6 << 2) + tmp6 ) >> 5);
	tmp6 = tmp6 + tmp10 - (((tmp10 << 2) + tmp10 ) >> 4);
	tmp5 = (((tmp6 << 3) + (tmp6 << 2) + tmp6 ) >> 5) - tmp10;

	//butterflies
	//old
    //tmp10 = tmp4 + tmp5;
    //tmp11 = ((tmp10 ) >> 1) - tmp5;
	tmp11 = tmp4 - tmp5;
	tmp10 = tmp4 - ((tmp11 ) >> 1);

	//old
    //tmp13 = tmp7 + tmp6;
    //tmp12 = ((tmp13 ) >> 1) - tmp6;
	tmp12 = tmp7 - tmp6;
	tmp13 = tmp7 - (( tmp12 ) >> 1);

    /* 7pi/16 = 3/16u -3/16d: alter sign to get positive scaling factor */
    dataptr[DCTSIZE*7] = (((tmp13 << 1) + tmp13 ) >> 4) - tmp10;
	dataptr[DCTSIZE*1] = tmp13 - (((dataptr[DCTSIZE*7] << 1) + dataptr[DCTSIZE*7] ) >> 4);

    /* 3pi/16 = */
	/* new : 11/16 and 15/32 */
    dataptr[DCTSIZE*5] = tmp11 + (((tmp12 << 3) + (tmp12 << 1) + tmp12 ) >> 4);
    dataptr[DCTSIZE*3] = tmp12 - (((dataptr[DCTSIZE*5] << 4) - dataptr[DCTSIZE*5] ) >> 5);

    dataptr++;			/* advance pointer to next column */
  }

} // lossless ot not.
 
}

/**************************************
 * problem with Sachin's code:
 * 1: it's verison binDCT-C.
 * 2: X[0] and X[4]: butterfly, not lifting.
 * 3: Neg scaling required.
 **************************************
 */

#endif /* DCT_BIN_C1_SUPPORTED */