jdk
393 строки · 15.1 Кб
1/*2* reserved comment block3* DO NOT REMOVE OR ALTER!4*/5/*6* jidctint.c7*8* Copyright (C) 1991-1998, Thomas G. Lane.9* This file is part of the Independent JPEG Group's software.10* For conditions of distribution and use, see the accompanying README file.11*12* This file contains a slow-but-accurate integer implementation of the13* inverse DCT (Discrete Cosine Transform). In the IJG code, this routine14* must also perform dequantization of the input coefficients.15*16* A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT17* on each row (or vice versa, but it's more convenient to emit a row at18* a time). Direct algorithms are also available, but they are much more19* complex and seem not to be any faster when reduced to code.20*21* This implementation is based on an algorithm described in22* C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT23* Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,24* Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.25* The primary algorithm described there uses 11 multiplies and 29 adds.26* We use their alternate method with 12 multiplies and 32 adds.27* The advantage of this method is that no data path contains more than one28* multiplication; this allows a very simple and accurate implementation in29* scaled fixed-point arithmetic, with a minimal number of shifts.30*/31/*41* This module is specialized to the case DCTSIZE = 8.42*/43/*50* The poop on this scaling stuff is as follows:51*52* Each 1-D IDCT step produces outputs which are a factor of sqrt(N)53* larger than the true IDCT outputs. The final outputs are therefore54* a factor of N larger than desired; since N=8 this can be cured by55* a simple right shift at the end of the algorithm. The advantage of56* this arrangement is that we save two multiplications per 1-D IDCT,57* because the y0 and y4 inputs need not be divided by sqrt(N).58*59* We have to do addition and subtraction of the integer inputs, which60* is no problem, and multiplication by fractional constants, which is61* a problem to do in integer arithmetic. We multiply all the constants62* by CONST_SCALE and convert them to integer constants (thus retaining63* CONST_BITS bits of precision in the constants). After doing a64* multiplication we have to divide the product by CONST_SCALE, with proper65* rounding, to produce the correct output. This division can be done66* cheaply as a right shift of CONST_BITS bits. We postpone shifting67* as long as possible so that partial sums can be added together with68* full fractional precision.69*70* The outputs of the first pass are scaled up by PASS1_BITS bits so that71* they are represented to better-than-integral precision. These outputs72* require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word73* with the recommended scaling. (To scale up 12-bit sample data further, an74* intermediate INT32 array would be needed.)75*76* To avoid overflow of the 32-bit intermediate results in pass 2, we must77* have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26. Error analysis78* shows that the values given below are the most effective.79*/80/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus90* causing a lot of useless floating-point operations at run time.91* To get around this we use the following pre-calculated constants.92* If you change CONST_BITS you may want to add appropriate values.93* (With a reasonable C compiler, you can just rely on the FIX() macro...)94*/95/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.126* For 8-bit samples with the recommended scaling, all the variable127* and constant values involved are no more than 16 bits wide, so a128* 16x16->32 bit multiply can be used instead of a full 32x32 multiply.129* For 12-bit samples, a full 32-bit multiplication will be needed.130*/131/* Dequantize a coefficient by multiplying it by the multiplier-table140* entry; produce an int result. In this module, both inputs and result141* are 16 bits or less, so either int or short multiply will work.142*/143/*148* Perform dequantization and inverse DCT on one block of coefficients.149*/150{156INT32 tmp0, tmp1, tmp2, tmp3;157INT32 tmp10, tmp11, tmp12, tmp13;158INT32 z1, z2, z3, z4, z5;159JCOEFPTR inptr;160ISLOW_MULT_TYPE * quantptr;161int * wsptr;162JSAMPROW outptr;163JSAMPLE *range_limit = IDCT_range_limit(cinfo);164int ctr;165int workspace[DCTSIZE2]; /* buffers data between passes */166SHIFT_TEMPS167* coefficients are zero, especially the AC terms. We can exploit this178* by short-circuiting the IDCT calculation for any column in which all179* the AC terms are zero. In that case each output is equal to the180* DC coefficient (with scale factor as needed).181* With typical images and quantization tables, half or more of the182* column DCT calculations can be simplified this way.183*/184* transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.230*/231* However, the column calculation has created many nonzero AC terms, so285* the simplification applies less often (typically 5% to 10% of the time).286* On machines with very fast multiplication, it's possible that the287* test takes more time than it's worth. In that case this section288* may be commented out.289*/290* transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.332*/333}392