/*
*--------------------------------------------------------------
*
* init_pre_idct --
*
* Pre-computes singleton coefficient IDCT values.
*
* Results:
* None.
*
* Side effects:
* None.
*
*--------------------------------------------------------------
*/
void
init_pre_idct() {
int i;
for (i=0; i<64; i++) {
memset((char *) PreIDCT[i], 0, 64*sizeof(DCTELEM));
PreIDCT[i][i] = 1 << SPARSE_SCALE_FACTOR;
j_rev_dct(PreIDCT[i]);
}
}
int main ()
{
int i, j, k, l, m;
short *pdct;
int prev;
int value, npixels;
int sum;
lastlong = 0;
bitsleft = 0;
nextlong = huffbits;
prev = 0;
for (i=0; i<NBLKS; i++) {
huff_dc_dec(&value);
dct_data[i*DCTSIZE*8] = value+prev;
prev = dct_data[i*DCTSIZE*8];
}
for (i=0; i<NBLKS; i++)
huff_ac_dec(&dct_data[i*BLKSIZE]);
pdct = &dct_data[0];
for (i=0; i<NBLKS; i++)
dquantz_lum(pdct+i*BLKSIZE);
pdct = &dct_data[0];
for (i=0; i<NBLKS; i++)
j_rev_dct(pdct+i*BLKSIZE);
npixels = NBLKS*BLKSIZE;
sum = 0;
for (i=m=0; i<npixels; i=i+DCTSIZE*ncols) {
for (j=0; j<BLKSIZE; j=j+DCTSIZE) {
for (k=0; k<DCTSIZE*ncols; k=k+BLKSIZE) {
for (l=0; l<DCTSIZE; l++) {
sum += dct_data[l+k+j+i]+64;
}
}
}
}
if (sum != 127637) {
puts("**************************************jpeg: fail**************************\n");
return -1;
}
else {
puts("jpeg: success\n");
return 0;
}
}
/* Pre compute singleton coefficient IDCT values. */
void
init_pre_idct()
{
int i;
void j_rev_dct();
for (i=0; i<64; i++) {
memset((char *) PreIDCT[i], 0, 64*sizeof(DCTELEM));
PreIDCT[i][i] = 2048;
j_rev_dct(PreIDCT[i]);
}
}
METHODDEF void
reverse_DCT (decompress_info_ptr cinfo,
JBLOCKIMAGE coeff_data, JSAMPIMAGE output_data, int start_row)
{
DCTBLOCK block;
JBLOCKROW browptr;
JSAMPARRAY srowptr;
jpeg_component_info * compptr;
long blocksperrow, bi;
short numrows, ri;
short ci;
for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
compptr = cinfo->cur_comp_info[ci];
/* don't bother to IDCT an uninteresting component */
if (! compptr->component_needed)
continue;
/* calculate size of an MCU row in this component */
blocksperrow = compptr->downsampled_width / DCTSIZE;
numrows = compptr->MCU_height;
/* iterate through all blocks in MCU row */
for (ri = 0; ri < numrows; ri++) {
browptr = coeff_data[ci][ri];
srowptr = output_data[ci] + (ri * DCTSIZE + start_row);
for (bi = 0; bi < blocksperrow; bi++) {
/* copy the data into a local DCTBLOCK. This allows for change of
* representation (if DCTELEM != JCOEF). On 80x86 machines it also
* brings the data back from FAR storage to NEAR storage.
*/
{ register JCOEFPTR elemptr = browptr[bi];
register DCTELEM *localblkptr = block;
register int elem = DCTSIZE2;
while (--elem >= 0)
*localblkptr++ = (DCTELEM) *elemptr++;
}
j_rev_dct(block); /* perform inverse DCT */
/* Output the data into the sample array.
* Note change from signed to unsigned representation:
* DCT calculation works with values +-CENTERJSAMPLE,
* but sample arrays always hold 0..MAXJSAMPLE.
* We have to do range-limiting because of quantization errors in the
* DCT/IDCT phase. We use the sample_range_limit[] table to do this
* quickly; the CENTERJSAMPLE offset is folded into table indexing.
*/
{ register JSAMPROW elemptr;
register DCTELEM *localblkptr = block;
register JSAMPLE *range_limit = cinfo->sample_range_limit +
CENTERJSAMPLE;
#if DCTSIZE != 8
register int elemc;
#endif
register int elemr;
for (elemr = 0; elemr < DCTSIZE; elemr++) {
elemptr = srowptr[elemr] + (bi * DCTSIZE);
#if DCTSIZE == 8 /* unroll the inner loop */
*elemptr++ = range_limit[*localblkptr++];
*elemptr++ = range_limit[*localblkptr++];
*elemptr++ = range_limit[*localblkptr++];
*elemptr++ = range_limit[*localblkptr++];
*elemptr++ = range_limit[*localblkptr++];
*elemptr++ = range_limit[*localblkptr++];
*elemptr++ = range_limit[*localblkptr++];
*elemptr++ = range_limit[*localblkptr++];
#else
for (elemc = DCTSIZE; elemc > 0; elemc--) {
*elemptr++ = range_limit[*localblkptr++];
}
#endif
}
}
}
}
}
}
