CoCalc -- jidctint.c

GitHub Repository: Tetragramm/opencv
Path: blob/master/3rdparty/libjpeg/jidctint.c
¹⁶³³⁷ views
1
/*
2
 * jidctint.c
3
 *
4
 * Copyright (C) 1991-1998, Thomas G. Lane.
5
 * Modification developed 2002-2015 by Guido Vollbeding.
6
 * This file is part of the Independent JPEG Group's software.
7
 * For conditions of distribution and use, see the accompanying README file.
8
 *
9
 * This file contains a slow-but-accurate integer implementation of the
10
 * inverse DCT (Discrete Cosine Transform).  In the IJG code, this routine
11
 * must also perform dequantization of the input coefficients.
12
 *
13
 * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
14
 * on each row (or vice versa, but it's more convenient to emit a row at
15
 * a time).  Direct algorithms are also available, but they are much more
16
 * complex and seem not to be any faster when reduced to code.
17
 *
18
 * This implementation is based on an algorithm described in
19
 *   C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
20
 *   Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
21
 *   Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
22
 * The primary algorithm described there uses 11 multiplies and 29 adds.
23
 * We use their alternate method with 12 multiplies and 32 adds.
24
 * The advantage of this method is that no data path contains more than one
25
 * multiplication; this allows a very simple and accurate implementation in
26
 * scaled fixed-point arithmetic, with a minimal number of shifts.
27
 *
28
 * We also provide IDCT routines with various output sample block sizes for
29
 * direct resolution reduction or enlargement and for direct resolving the
30
 * common 2x1 and 1x2 subsampling cases without additional resampling: NxN
31
 * (N=1...16), 2NxN, and Nx2N (N=1...8) pixels for one 8x8 input DCT block.
32
 *
33
 * For N<8 we simply take the corresponding low-frequency coefficients of
34
 * the 8x8 input DCT block and apply an NxN point IDCT on the sub-block
35
 * to yield the downscaled outputs.
36
 * This can be seen as direct low-pass downsampling from the DCT domain
37
 * point of view rather than the usual spatial domain point of view,
38
 * yielding significant computational savings and results at least
39
 * as good as common bilinear (averaging) spatial downsampling.
40
 *
41
 * For N>8 we apply a partial NxN IDCT on the 8 input coefficients as
42
 * lower frequencies and higher frequencies assumed to be zero.
43
 * It turns out that the computational effort is similar to the 8x8 IDCT
44
 * regarding the output size.
45
 * Furthermore, the scaling and descaling is the same for all IDCT sizes.
46
 *
47
 * CAUTION: We rely on the FIX() macro except for the N=1,2,4,8 cases
48
 * since there would be too many additional constants to pre-calculate.
49
 */
50

51
#define JPEG_INTERNALS
52
#include "jinclude.h"
53
#include "jpeglib.h"
54
#include "jdct.h"		/* Private declarations for DCT subsystem */
55

56
#ifdef DCT_ISLOW_SUPPORTED
57

58

59
/*
60
 * This module is specialized to the case DCTSIZE = 8.
61
 */
62

63
#if DCTSIZE != 8
64
  Sorry, this code only copes with 8x8 DCT blocks. /* deliberate syntax err */
65
#endif
66

67

68
/*
69
 * The poop on this scaling stuff is as follows:
70
 *
71
 * Each 1-D IDCT step produces outputs which are a factor of sqrt(N)
72
 * larger than the true IDCT outputs.  The final outputs are therefore
73
 * a factor of N larger than desired; since N=8 this can be cured by
74
 * a simple right shift at the end of the algorithm.  The advantage of
75
 * this arrangement is that we save two multiplications per 1-D IDCT,
76
 * because the y0 and y4 inputs need not be divided by sqrt(N).
77
 *
78
 * We have to do addition and subtraction of the integer inputs, which
79
 * is no problem, and multiplication by fractional constants, which is
80
 * a problem to do in integer arithmetic.  We multiply all the constants
81
 * by CONST_SCALE and convert them to integer constants (thus retaining
82
 * CONST_BITS bits of precision in the constants).  After doing a
83
 * multiplication we have to divide the product by CONST_SCALE, with proper
84
 * rounding, to produce the correct output.  This division can be done
85
 * cheaply as a right shift of CONST_BITS bits.  We postpone shifting
86
 * as long as possible so that partial sums can be added together with
87
 * full fractional precision.
88
 *
89
 * The outputs of the first pass are scaled up by PASS1_BITS bits so that
90
 * they are represented to better-than-integral precision.  These outputs
91
 * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
92
 * with the recommended scaling.  (To scale up 12-bit sample data further, an
93
 * intermediate INT32 array would be needed.)
94
 *
95
 * To avoid overflow of the 32-bit intermediate results in pass 2, we must
96
 * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26.  Error analysis
97
 * shows that the values given below are the most effective.
98
 */
99

100
#if BITS_IN_JSAMPLE == 8
101
#define CONST_BITS  13
102
#define PASS1_BITS  2
103
#else
104
#define CONST_BITS  13
105
#define PASS1_BITS  1		/* lose a little precision to avoid overflow */
106
#endif
107

108
/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
109
 * causing a lot of useless floating-point operations at run time.
110
 * To get around this we use the following pre-calculated constants.
111
 * If you change CONST_BITS you may want to add appropriate values.
112
 * (With a reasonable C compiler, you can just rely on the FIX() macro...)
113
 */
114

115
#if CONST_BITS == 13
116
#define FIX_0_298631336  ((INT32)  2446)	/* FIX(0.298631336) */
117
#define FIX_0_390180644  ((INT32)  3196)	/* FIX(0.390180644) */
118
#define FIX_0_541196100  ((INT32)  4433)	/* FIX(0.541196100) */
119
#define FIX_0_765366865  ((INT32)  6270)	/* FIX(0.765366865) */
120
#define FIX_0_899976223  ((INT32)  7373)	/* FIX(0.899976223) */
121
#define FIX_1_175875602  ((INT32)  9633)	/* FIX(1.175875602) */
122
#define FIX_1_501321110  ((INT32)  12299)	/* FIX(1.501321110) */
123
#define FIX_1_847759065  ((INT32)  15137)	/* FIX(1.847759065) */
124
#define FIX_1_961570560  ((INT32)  16069)	/* FIX(1.961570560) */
125
#define FIX_2_053119869  ((INT32)  16819)	/* FIX(2.053119869) */
126
#define FIX_2_562915447  ((INT32)  20995)	/* FIX(2.562915447) */
127
#define FIX_3_072711026  ((INT32)  25172)	/* FIX(3.072711026) */
128
#else
129
#define FIX_0_298631336  FIX(0.298631336)
130
#define FIX_0_390180644  FIX(0.390180644)
131
#define FIX_0_541196100  FIX(0.541196100)
132
#define FIX_0_765366865  FIX(0.765366865)
133
#define FIX_0_899976223  FIX(0.899976223)
134
#define FIX_1_175875602  FIX(1.175875602)
135
#define FIX_1_501321110  FIX(1.501321110)
136
#define FIX_1_847759065  FIX(1.847759065)
137
#define FIX_1_961570560  FIX(1.961570560)
138
#define FIX_2_053119869  FIX(2.053119869)
139
#define FIX_2_562915447  FIX(2.562915447)
140
#define FIX_3_072711026  FIX(3.072711026)
141
#endif
142

143

144
/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
145
 * For 8-bit samples with the recommended scaling, all the variable
146
 * and constant values involved are no more than 16 bits wide, so a
147
 * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
148
 * For 12-bit samples, a full 32-bit multiplication will be needed.
149
 */
150

151
#if BITS_IN_JSAMPLE == 8
152
#define MULTIPLY(var,const)  MULTIPLY16C16(var,const)
153
#else
154
#define MULTIPLY(var,const)  ((var) * (const))
155
#endif
156

157

158
/* Dequantize a coefficient by multiplying it by the multiplier-table
159
 * entry; produce an int result.  In this module, both inputs and result
160
 * are 16 bits or less, so either int or short multiply will work.
161
 */
162

163
#define DEQUANTIZE(coef,quantval)  (((ISLOW_MULT_TYPE) (coef)) * (quantval))
164

165

166
/*
167
 * Perform dequantization and inverse DCT on one block of coefficients.
168
 *
169
 * cK represents sqrt(2) * cos(K*pi/16).
170
 */
171

172
GLOBAL(void)
173
jpeg_idct_islow (j_decompress_ptr cinfo, jpeg_component_info * compptr,
174
		 JCOEFPTR coef_block,
175
		 JSAMPARRAY output_buf, JDIMENSION output_col)
176
{
177
  INT32 tmp0, tmp1, tmp2, tmp3;
178
  INT32 tmp10, tmp11, tmp12, tmp13;
179
  INT32 z1, z2, z3;
180
  JCOEFPTR inptr;
181
  ISLOW_MULT_TYPE * quantptr;
182
  int * wsptr;
183
  JSAMPROW outptr;
184
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
185
  int ctr;
186
  int workspace[DCTSIZE2];	/* buffers data between passes */
187
  SHIFT_TEMPS
188

189
  /* Pass 1: process columns from input, store into work array.
190
   * Note results are scaled up by sqrt(8) compared to a true IDCT;
191
   * furthermore, we scale the results by 2**PASS1_BITS.
192
   */
193

194
  inptr = coef_block;
195
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
196
  wsptr = workspace;
197
  for (ctr = DCTSIZE; ctr > 0; ctr--) {
198
    /* Due to quantization, we will usually find that many of the input
199
     * coefficients are zero, especially the AC terms.  We can exploit this
200
     * by short-circuiting the IDCT calculation for any column in which all
201
     * the AC terms are zero.  In that case each output is equal to the
202
     * DC coefficient (with scale factor as needed).
203
     * With typical images and quantization tables, half or more of the
204
     * column DCT calculations can be simplified this way.
205
     */
206

207
    if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
208
	inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
209
	inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
210
	inptr[DCTSIZE*7] == 0) {
211
      /* AC terms all zero */
212
      int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
213

214
      wsptr[DCTSIZE*0] = dcval;
215
      wsptr[DCTSIZE*1] = dcval;
216
      wsptr[DCTSIZE*2] = dcval;
217
      wsptr[DCTSIZE*3] = dcval;
218
      wsptr[DCTSIZE*4] = dcval;
219
      wsptr[DCTSIZE*5] = dcval;
220
      wsptr[DCTSIZE*6] = dcval;
221
      wsptr[DCTSIZE*7] = dcval;
222

223
      inptr++;			/* advance pointers to next column */
224
      quantptr++;
225
      wsptr++;
226
      continue;
227
    }
228

229
    /* Even part: reverse the even part of the forward DCT.
230
     * The rotator is c(-6).
231
     */
232

233
    z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
234
    z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
235
    z2 <<= CONST_BITS;
236
    z3 <<= CONST_BITS;
237
    /* Add fudge factor here for final descale. */
238
    z2 += ONE << (CONST_BITS-PASS1_BITS-1);
239

240
    tmp0 = z2 + z3;
241
    tmp1 = z2 - z3;
242

243
    z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
244
    z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
245

246
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
247
    tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
248
    tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
249

250
    tmp10 = tmp0 + tmp2;
251
    tmp13 = tmp0 - tmp2;
252
    tmp11 = tmp1 + tmp3;
253
    tmp12 = tmp1 - tmp3;
254

255
    /* Odd part per figure 8; the matrix is unitary and hence its
256
     * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
257
     */
258

259
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
260
    tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
261
    tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
262
    tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
263

264
    z2 = tmp0 + tmp2;
265
    z3 = tmp1 + tmp3;
266

267
    z1 = MULTIPLY(z2 + z3, FIX_1_175875602);       /*  c3 */
268
    z2 = MULTIPLY(z2, - FIX_1_961570560);          /* -c3-c5 */
269
    z3 = MULTIPLY(z3, - FIX_0_390180644);          /* -c3+c5 */
270
    z2 += z1;
271
    z3 += z1;
272

273
    z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
274
    tmp0 = MULTIPLY(tmp0, FIX_0_298631336);        /* -c1+c3+c5-c7 */
275
    tmp3 = MULTIPLY(tmp3, FIX_1_501321110);        /*  c1+c3-c5-c7 */
276
    tmp0 += z1 + z2;
277
    tmp3 += z1 + z3;
278

279
    z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
280
    tmp1 = MULTIPLY(tmp1, FIX_2_053119869);        /*  c1+c3-c5+c7 */
281
    tmp2 = MULTIPLY(tmp2, FIX_3_072711026);        /*  c1+c3+c5-c7 */
282
    tmp1 += z1 + z3;
283
    tmp2 += z1 + z2;
284

285
    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
286

287
    wsptr[DCTSIZE*0] = (int) RIGHT_SHIFT(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
288
    wsptr[DCTSIZE*7] = (int) RIGHT_SHIFT(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
289
    wsptr[DCTSIZE*1] = (int) RIGHT_SHIFT(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
290
    wsptr[DCTSIZE*6] = (int) RIGHT_SHIFT(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
291
    wsptr[DCTSIZE*2] = (int) RIGHT_SHIFT(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
292
    wsptr[DCTSIZE*5] = (int) RIGHT_SHIFT(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
293
    wsptr[DCTSIZE*3] = (int) RIGHT_SHIFT(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
294
    wsptr[DCTSIZE*4] = (int) RIGHT_SHIFT(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
295

296
    inptr++;			/* advance pointers to next column */
297
    quantptr++;
298
    wsptr++;
299
  }
300

301
  /* Pass 2: process rows from work array, store into output array.
302
   * Note that we must descale the results by a factor of 8 == 2**3,
303
   * and also undo the PASS1_BITS scaling.
304
   */
305

306
  wsptr = workspace;
307
  for (ctr = 0; ctr < DCTSIZE; ctr++) {
308
    outptr = output_buf[ctr] + output_col;
309

310
    /* Add range center and fudge factor for final descale and range-limit. */
311
    z2 = (INT32) wsptr[0] +
312
	   ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
313
	    (ONE << (PASS1_BITS+2)));
314

315
    /* Rows of zeroes can be exploited in the same way as we did with columns.
316
     * However, the column calculation has created many nonzero AC terms, so
317
     * the simplification applies less often (typically 5% to 10% of the time).
318
     * On machines with very fast multiplication, it's possible that the
319
     * test takes more time than it's worth.  In that case this section
320
     * may be commented out.
321
     */
322

323
#ifndef NO_ZERO_ROW_TEST
324
    if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 &&
325
	wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
326
      /* AC terms all zero */
327
      JSAMPLE dcval = range_limit[(int) RIGHT_SHIFT(z2, PASS1_BITS+3)
328
				  & RANGE_MASK];
329

330
      outptr[0] = dcval;
331
      outptr[1] = dcval;
332
      outptr[2] = dcval;
333
      outptr[3] = dcval;
334
      outptr[4] = dcval;
335
      outptr[5] = dcval;
336
      outptr[6] = dcval;
337
      outptr[7] = dcval;
338

339
      wsptr += DCTSIZE;		/* advance pointer to next row */
340
      continue;
341
    }
342
#endif
343

344
    /* Even part: reverse the even part of the forward DCT.
345
     * The rotator is c(-6).
346
     */
347

348
    z3 = (INT32) wsptr[4];
349

350
    tmp0 = (z2 + z3) << CONST_BITS;
351
    tmp1 = (z2 - z3) << CONST_BITS;
352

353
    z2 = (INT32) wsptr[2];
354
    z3 = (INT32) wsptr[6];
355

356
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
357
    tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
358
    tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
359

360
    tmp10 = tmp0 + tmp2;
361
    tmp13 = tmp0 - tmp2;
362
    tmp11 = tmp1 + tmp3;
363
    tmp12 = tmp1 - tmp3;
364

365
    /* Odd part per figure 8; the matrix is unitary and hence its
366
     * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
367
     */
368

369
    tmp0 = (INT32) wsptr[7];
370
    tmp1 = (INT32) wsptr[5];
371
    tmp2 = (INT32) wsptr[3];
372
    tmp3 = (INT32) wsptr[1];
373

374
    z2 = tmp0 + tmp2;
375
    z3 = tmp1 + tmp3;
376

377
    z1 = MULTIPLY(z2 + z3, FIX_1_175875602);       /*  c3 */
378
    z2 = MULTIPLY(z2, - FIX_1_961570560);          /* -c3-c5 */
379
    z3 = MULTIPLY(z3, - FIX_0_390180644);          /* -c3+c5 */
380
    z2 += z1;
381
    z3 += z1;
382

383
    z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
384
    tmp0 = MULTIPLY(tmp0, FIX_0_298631336);        /* -c1+c3+c5-c7 */
385
    tmp3 = MULTIPLY(tmp3, FIX_1_501321110);        /*  c1+c3-c5-c7 */
386
    tmp0 += z1 + z2;
387
    tmp3 += z1 + z3;
388

389
    z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
390
    tmp1 = MULTIPLY(tmp1, FIX_2_053119869);        /*  c1+c3-c5+c7 */
391
    tmp2 = MULTIPLY(tmp2, FIX_3_072711026);        /*  c1+c3+c5-c7 */
392
    tmp1 += z1 + z3;
393
    tmp2 += z1 + z2;
394

395
    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
396

397
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp3,
398
					      CONST_BITS+PASS1_BITS+3)
399
			    & RANGE_MASK];
400
    outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp3,
401
					      CONST_BITS+PASS1_BITS+3)
402
			    & RANGE_MASK];
403
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp2,
404
					      CONST_BITS+PASS1_BITS+3)
405
			    & RANGE_MASK];
406
    outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp2,
407
					      CONST_BITS+PASS1_BITS+3)
408
			    & RANGE_MASK];
409
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp1,
410
					      CONST_BITS+PASS1_BITS+3)
411
			    & RANGE_MASK];
412
    outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp1,
413
					      CONST_BITS+PASS1_BITS+3)
414
			    & RANGE_MASK];
415
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp0,
416
					      CONST_BITS+PASS1_BITS+3)
417
			    & RANGE_MASK];
418
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp0,
419
					      CONST_BITS+PASS1_BITS+3)
420
			    & RANGE_MASK];
421

422
    wsptr += DCTSIZE;		/* advance pointer to next row */
423
  }
424
}
425

426
#ifdef IDCT_SCALING_SUPPORTED
427

428

429
/*
430
 * Perform dequantization and inverse DCT on one block of coefficients,
431
 * producing a 7x7 output block.
432
 *
433
 * Optimized algorithm with 12 multiplications in the 1-D kernel.
434
 * cK represents sqrt(2) * cos(K*pi/14).
435
 */
436

437
GLOBAL(void)
438
jpeg_idct_7x7 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
439
	       JCOEFPTR coef_block,
440
	       JSAMPARRAY output_buf, JDIMENSION output_col)
441
{
442
  INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12, tmp13;
443
  INT32 z1, z2, z3;
444
  JCOEFPTR inptr;
445
  ISLOW_MULT_TYPE * quantptr;
446
  int * wsptr;
447
  JSAMPROW outptr;
448
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
449
  int ctr;
450
  int workspace[7*7];	/* buffers data between passes */
451
  SHIFT_TEMPS
452

453
  /* Pass 1: process columns from input, store into work array. */
454

455
  inptr = coef_block;
456
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
457
  wsptr = workspace;
458
  for (ctr = 0; ctr < 7; ctr++, inptr++, quantptr++, wsptr++) {
459
    /* Even part */
460

461
    tmp13 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
462
    tmp13 <<= CONST_BITS;
463
    /* Add fudge factor here for final descale. */
464
    tmp13 += ONE << (CONST_BITS-PASS1_BITS-1);
465

466
    z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
467
    z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
468
    z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
469

470
    tmp10 = MULTIPLY(z2 - z3, FIX(0.881747734));     /* c4 */
471
    tmp12 = MULTIPLY(z1 - z2, FIX(0.314692123));     /* c6 */
472
    tmp11 = tmp10 + tmp12 + tmp13 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
473
    tmp0 = z1 + z3;
474
    z2 -= tmp0;
475
    tmp0 = MULTIPLY(tmp0, FIX(1.274162392)) + tmp13; /* c2 */
476
    tmp10 += tmp0 - MULTIPLY(z3, FIX(0.077722536));  /* c2-c4-c6 */
477
    tmp12 += tmp0 - MULTIPLY(z1, FIX(2.470602249));  /* c2+c4+c6 */
478
    tmp13 += MULTIPLY(z2, FIX(1.414213562));         /* c0 */
479

480
    /* Odd part */
481

482
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
483
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
484
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
485

486
    tmp1 = MULTIPLY(z1 + z2, FIX(0.935414347));      /* (c3+c1-c5)/2 */
487
    tmp2 = MULTIPLY(z1 - z2, FIX(0.170262339));      /* (c3+c5-c1)/2 */
488
    tmp0 = tmp1 - tmp2;
489
    tmp1 += tmp2;
490
    tmp2 = MULTIPLY(z2 + z3, - FIX(1.378756276));    /* -c1 */
491
    tmp1 += tmp2;
492
    z2 = MULTIPLY(z1 + z3, FIX(0.613604268));        /* c5 */
493
    tmp0 += z2;
494
    tmp2 += z2 + MULTIPLY(z3, FIX(1.870828693));     /* c3+c1-c5 */
495

496
    /* Final output stage */
497

498
    wsptr[7*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
499
    wsptr[7*6] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
500
    wsptr[7*1] = (int) RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS-PASS1_BITS);
501
    wsptr[7*5] = (int) RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS-PASS1_BITS);
502
    wsptr[7*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
503
    wsptr[7*4] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
504
    wsptr[7*3] = (int) RIGHT_SHIFT(tmp13, CONST_BITS-PASS1_BITS);
505
  }
506

507
  /* Pass 2: process 7 rows from work array, store into output array. */
508

509
  wsptr = workspace;
510
  for (ctr = 0; ctr < 7; ctr++) {
511
    outptr = output_buf[ctr] + output_col;
512

513
    /* Even part */
514

515
    /* Add range center and fudge factor for final descale and range-limit. */
516
    tmp13 = (INT32) wsptr[0] +
517
	      ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
518
	       (ONE << (PASS1_BITS+2)));
519
    tmp13 <<= CONST_BITS;
520

521
    z1 = (INT32) wsptr[2];
522
    z2 = (INT32) wsptr[4];
523
    z3 = (INT32) wsptr[6];
524

525
    tmp10 = MULTIPLY(z2 - z3, FIX(0.881747734));     /* c4 */
526
    tmp12 = MULTIPLY(z1 - z2, FIX(0.314692123));     /* c6 */
527
    tmp11 = tmp10 + tmp12 + tmp13 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
528
    tmp0 = z1 + z3;
529
    z2 -= tmp0;
530
    tmp0 = MULTIPLY(tmp0, FIX(1.274162392)) + tmp13; /* c2 */
531
    tmp10 += tmp0 - MULTIPLY(z3, FIX(0.077722536));  /* c2-c4-c6 */
532
    tmp12 += tmp0 - MULTIPLY(z1, FIX(2.470602249));  /* c2+c4+c6 */
533
    tmp13 += MULTIPLY(z2, FIX(1.414213562));         /* c0 */
534

535
    /* Odd part */
536

537
    z1 = (INT32) wsptr[1];
538
    z2 = (INT32) wsptr[3];
539
    z3 = (INT32) wsptr[5];
540

541
    tmp1 = MULTIPLY(z1 + z2, FIX(0.935414347));      /* (c3+c1-c5)/2 */
542
    tmp2 = MULTIPLY(z1 - z2, FIX(0.170262339));      /* (c3+c5-c1)/2 */
543
    tmp0 = tmp1 - tmp2;
544
    tmp1 += tmp2;
545
    tmp2 = MULTIPLY(z2 + z3, - FIX(1.378756276));    /* -c1 */
546
    tmp1 += tmp2;
547
    z2 = MULTIPLY(z1 + z3, FIX(0.613604268));        /* c5 */
548
    tmp0 += z2;
549
    tmp2 += z2 + MULTIPLY(z3, FIX(1.870828693));     /* c3+c1-c5 */
550

551
    /* Final output stage */
552

553
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
554
					      CONST_BITS+PASS1_BITS+3)
555
			    & RANGE_MASK];
556
    outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
557
					      CONST_BITS+PASS1_BITS+3)
558
			    & RANGE_MASK];
559
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
560
					      CONST_BITS+PASS1_BITS+3)
561
			    & RANGE_MASK];
562
    outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
563
					      CONST_BITS+PASS1_BITS+3)
564
			    & RANGE_MASK];
565
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
566
					      CONST_BITS+PASS1_BITS+3)
567
			    & RANGE_MASK];
568
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
569
					      CONST_BITS+PASS1_BITS+3)
570
			    & RANGE_MASK];
571
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13,
572
					      CONST_BITS+PASS1_BITS+3)
573
			    & RANGE_MASK];
574

575
    wsptr += 7;		/* advance pointer to next row */
576
  }
577
}
578

579

580
/*
581
 * Perform dequantization and inverse DCT on one block of coefficients,
582
 * producing a reduced-size 6x6 output block.
583
 *
584
 * Optimized algorithm with 3 multiplications in the 1-D kernel.
585
 * cK represents sqrt(2) * cos(K*pi/12).
586
 */
587

588
GLOBAL(void)
589
jpeg_idct_6x6 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
590
	       JCOEFPTR coef_block,
591
	       JSAMPARRAY output_buf, JDIMENSION output_col)
592
{
593
  INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12;
594
  INT32 z1, z2, z3;
595
  JCOEFPTR inptr;
596
  ISLOW_MULT_TYPE * quantptr;
597
  int * wsptr;
598
  JSAMPROW outptr;
599
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
600
  int ctr;
601
  int workspace[6*6];	/* buffers data between passes */
602
  SHIFT_TEMPS
603

604
  /* Pass 1: process columns from input, store into work array. */
605

606
  inptr = coef_block;
607
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
608
  wsptr = workspace;
609
  for (ctr = 0; ctr < 6; ctr++, inptr++, quantptr++, wsptr++) {
610
    /* Even part */
611

612
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
613
    tmp0 <<= CONST_BITS;
614
    /* Add fudge factor here for final descale. */
615
    tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
616
    tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
617
    tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
618
    tmp1 = tmp0 + tmp10;
619
    tmp11 = RIGHT_SHIFT(tmp0 - tmp10 - tmp10, CONST_BITS-PASS1_BITS);
620
    tmp10 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
621
    tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
622
    tmp10 = tmp1 + tmp0;
623
    tmp12 = tmp1 - tmp0;
624

625
    /* Odd part */
626

627
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
628
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
629
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
630
    tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
631
    tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
632
    tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
633
    tmp1 = (z1 - z2 - z3) << PASS1_BITS;
634

635
    /* Final output stage */
636

637
    wsptr[6*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
638
    wsptr[6*5] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
639
    wsptr[6*1] = (int) (tmp11 + tmp1);
640
    wsptr[6*4] = (int) (tmp11 - tmp1);
641
    wsptr[6*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
642
    wsptr[6*3] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
643
  }
644

645
  /* Pass 2: process 6 rows from work array, store into output array. */
646

647
  wsptr = workspace;
648
  for (ctr = 0; ctr < 6; ctr++) {
649
    outptr = output_buf[ctr] + output_col;
650

651
    /* Even part */
652

653
    /* Add range center and fudge factor for final descale and range-limit. */
654
    tmp0 = (INT32) wsptr[0] +
655
	     ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
656
	      (ONE << (PASS1_BITS+2)));
657
    tmp0 <<= CONST_BITS;
658
    tmp2 = (INT32) wsptr[4];
659
    tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
660
    tmp1 = tmp0 + tmp10;
661
    tmp11 = tmp0 - tmp10 - tmp10;
662
    tmp10 = (INT32) wsptr[2];
663
    tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
664
    tmp10 = tmp1 + tmp0;
665
    tmp12 = tmp1 - tmp0;
666

667
    /* Odd part */
668

669
    z1 = (INT32) wsptr[1];
670
    z2 = (INT32) wsptr[3];
671
    z3 = (INT32) wsptr[5];
672
    tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
673
    tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
674
    tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
675
    tmp1 = (z1 - z2 - z3) << CONST_BITS;
676

677
    /* Final output stage */
678

679
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
680
					      CONST_BITS+PASS1_BITS+3)
681
			    & RANGE_MASK];
682
    outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
683
					      CONST_BITS+PASS1_BITS+3)
684
			    & RANGE_MASK];
685
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
686
					      CONST_BITS+PASS1_BITS+3)
687
			    & RANGE_MASK];
688
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
689
					      CONST_BITS+PASS1_BITS+3)
690
			    & RANGE_MASK];
691
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
692
					      CONST_BITS+PASS1_BITS+3)
693
			    & RANGE_MASK];
694
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
695
					      CONST_BITS+PASS1_BITS+3)
696
			    & RANGE_MASK];
697

698
    wsptr += 6;		/* advance pointer to next row */
699
  }
700
}
701

702

703
/*
704
 * Perform dequantization and inverse DCT on one block of coefficients,
705
 * producing a reduced-size 5x5 output block.
706
 *
707
 * Optimized algorithm with 5 multiplications in the 1-D kernel.
708
 * cK represents sqrt(2) * cos(K*pi/10).
709
 */
710

711
GLOBAL(void)
712
jpeg_idct_5x5 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
713
	       JCOEFPTR coef_block,
714
	       JSAMPARRAY output_buf, JDIMENSION output_col)
715
{
716
  INT32 tmp0, tmp1, tmp10, tmp11, tmp12;
717
  INT32 z1, z2, z3;
718
  JCOEFPTR inptr;
719
  ISLOW_MULT_TYPE * quantptr;
720
  int * wsptr;
721
  JSAMPROW outptr;
722
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
723
  int ctr;
724
  int workspace[5*5];	/* buffers data between passes */
725
  SHIFT_TEMPS
726

727
  /* Pass 1: process columns from input, store into work array. */
728

729
  inptr = coef_block;
730
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
731
  wsptr = workspace;
732
  for (ctr = 0; ctr < 5; ctr++, inptr++, quantptr++, wsptr++) {
733
    /* Even part */
734

735
    tmp12 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
736
    tmp12 <<= CONST_BITS;
737
    /* Add fudge factor here for final descale. */
738
    tmp12 += ONE << (CONST_BITS-PASS1_BITS-1);
739
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
740
    tmp1 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
741
    z1 = MULTIPLY(tmp0 + tmp1, FIX(0.790569415)); /* (c2+c4)/2 */
742
    z2 = MULTIPLY(tmp0 - tmp1, FIX(0.353553391)); /* (c2-c4)/2 */
743
    z3 = tmp12 + z2;
744
    tmp10 = z3 + z1;
745
    tmp11 = z3 - z1;
746
    tmp12 -= z2 << 2;
747

748
    /* Odd part */
749

750
    z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
751
    z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
752

753
    z1 = MULTIPLY(z2 + z3, FIX(0.831253876));     /* c3 */
754
    tmp0 = z1 + MULTIPLY(z2, FIX(0.513743148));   /* c1-c3 */
755
    tmp1 = z1 - MULTIPLY(z3, FIX(2.176250899));   /* c1+c3 */
756

757
    /* Final output stage */
758

759
    wsptr[5*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
760
    wsptr[5*4] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
761
    wsptr[5*1] = (int) RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS-PASS1_BITS);
762
    wsptr[5*3] = (int) RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS-PASS1_BITS);
763
    wsptr[5*2] = (int) RIGHT_SHIFT(tmp12, CONST_BITS-PASS1_BITS);
764
  }
765

766
  /* Pass 2: process 5 rows from work array, store into output array. */
767

768
  wsptr = workspace;
769
  for (ctr = 0; ctr < 5; ctr++) {
770
    outptr = output_buf[ctr] + output_col;
771

772
    /* Even part */
773

774
    /* Add range center and fudge factor for final descale and range-limit. */
775
    tmp12 = (INT32) wsptr[0] +
776
	      ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
777
	       (ONE << (PASS1_BITS+2)));
778
    tmp12 <<= CONST_BITS;
779
    tmp0 = (INT32) wsptr[2];
780
    tmp1 = (INT32) wsptr[4];
781
    z1 = MULTIPLY(tmp0 + tmp1, FIX(0.790569415)); /* (c2+c4)/2 */
782
    z2 = MULTIPLY(tmp0 - tmp1, FIX(0.353553391)); /* (c2-c4)/2 */
783
    z3 = tmp12 + z2;
784
    tmp10 = z3 + z1;
785
    tmp11 = z3 - z1;
786
    tmp12 -= z2 << 2;
787

788
    /* Odd part */
789

790
    z2 = (INT32) wsptr[1];
791
    z3 = (INT32) wsptr[3];
792

793
    z1 = MULTIPLY(z2 + z3, FIX(0.831253876));     /* c3 */
794
    tmp0 = z1 + MULTIPLY(z2, FIX(0.513743148));   /* c1-c3 */
795
    tmp1 = z1 - MULTIPLY(z3, FIX(2.176250899));   /* c1+c3 */
796

797
    /* Final output stage */
798

799
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
800
					      CONST_BITS+PASS1_BITS+3)
801
			    & RANGE_MASK];
802
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
803
					      CONST_BITS+PASS1_BITS+3)
804
			    & RANGE_MASK];
805
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
806
					      CONST_BITS+PASS1_BITS+3)
807
			    & RANGE_MASK];
808
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
809
					      CONST_BITS+PASS1_BITS+3)
810
			    & RANGE_MASK];
811
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12,
812
					      CONST_BITS+PASS1_BITS+3)
813
			    & RANGE_MASK];
814

815
    wsptr += 5;		/* advance pointer to next row */
816
  }
817
}
818

819

820
/*
821
 * Perform dequantization and inverse DCT on one block of coefficients,
822
 * producing a reduced-size 4x4 output block.
823
 *
824
 * Optimized algorithm with 3 multiplications in the 1-D kernel.
825
 * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
826
 */
827

828
GLOBAL(void)
829
jpeg_idct_4x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
830
	       JCOEFPTR coef_block,
831
	       JSAMPARRAY output_buf, JDIMENSION output_col)
832
{
833
  INT32 tmp0, tmp2, tmp10, tmp12;
834
  INT32 z1, z2, z3;
835
  JCOEFPTR inptr;
836
  ISLOW_MULT_TYPE * quantptr;
837
  int * wsptr;
838
  JSAMPROW outptr;
839
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
840
  int ctr;
841
  int workspace[4*4];	/* buffers data between passes */
842
  SHIFT_TEMPS
843

844
  /* Pass 1: process columns from input, store into work array. */
845

846
  inptr = coef_block;
847
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
848
  wsptr = workspace;
849
  for (ctr = 0; ctr < 4; ctr++, inptr++, quantptr++, wsptr++) {
850
    /* Even part */
851

852
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
853
    tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
854
    
855
    tmp10 = (tmp0 + tmp2) << PASS1_BITS;
856
    tmp12 = (tmp0 - tmp2) << PASS1_BITS;
857

858
    /* Odd part */
859
    /* Same rotation as in the even part of the 8x8 LL&M IDCT */
860

861
    z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
862
    z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
863

864
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);               /* c6 */
865
    /* Add fudge factor here for final descale. */
866
    z1 += ONE << (CONST_BITS-PASS1_BITS-1);
867
    tmp0 = RIGHT_SHIFT(z1 + MULTIPLY(z2, FIX_0_765366865), /* c2-c6 */
868
		       CONST_BITS-PASS1_BITS);
869
    tmp2 = RIGHT_SHIFT(z1 - MULTIPLY(z3, FIX_1_847759065), /* c2+c6 */
870
		       CONST_BITS-PASS1_BITS);
871

872
    /* Final output stage */
873

874
    wsptr[4*0] = (int) (tmp10 + tmp0);
875
    wsptr[4*3] = (int) (tmp10 - tmp0);
876
    wsptr[4*1] = (int) (tmp12 + tmp2);
877
    wsptr[4*2] = (int) (tmp12 - tmp2);
878
  }
879

880
  /* Pass 2: process 4 rows from work array, store into output array. */
881

882
  wsptr = workspace;
883
  for (ctr = 0; ctr < 4; ctr++) {
884
    outptr = output_buf[ctr] + output_col;
885

886
    /* Even part */
887

888
    /* Add range center and fudge factor for final descale and range-limit. */
889
    tmp0 = (INT32) wsptr[0] +
890
	     ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
891
	      (ONE << (PASS1_BITS+2)));
892
    tmp2 = (INT32) wsptr[2];
893

894
    tmp10 = (tmp0 + tmp2) << CONST_BITS;
895
    tmp12 = (tmp0 - tmp2) << CONST_BITS;
896

897
    /* Odd part */
898
    /* Same rotation as in the even part of the 8x8 LL&M IDCT */
899

900
    z2 = (INT32) wsptr[1];
901
    z3 = (INT32) wsptr[3];
902

903
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);   /* c6 */
904
    tmp0 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
905
    tmp2 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
906

907
    /* Final output stage */
908

909
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
910
					      CONST_BITS+PASS1_BITS+3)
911
			    & RANGE_MASK];
912
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
913
					      CONST_BITS+PASS1_BITS+3)
914
			    & RANGE_MASK];
915
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
916
					      CONST_BITS+PASS1_BITS+3)
917
			    & RANGE_MASK];
918
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
919
					      CONST_BITS+PASS1_BITS+3)
920
			    & RANGE_MASK];
921

922
    wsptr += 4;		/* advance pointer to next row */
923
  }
924
}
925

926

927
/*
928
 * Perform dequantization and inverse DCT on one block of coefficients,
929
 * producing a reduced-size 3x3 output block.
930
 *
931
 * Optimized algorithm with 2 multiplications in the 1-D kernel.
932
 * cK represents sqrt(2) * cos(K*pi/6).
933
 */
934

935
GLOBAL(void)
936
jpeg_idct_3x3 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
937
	       JCOEFPTR coef_block,
938
	       JSAMPARRAY output_buf, JDIMENSION output_col)
939
{
940
  INT32 tmp0, tmp2, tmp10, tmp12;
941
  JCOEFPTR inptr;
942
  ISLOW_MULT_TYPE * quantptr;
943
  int * wsptr;
944
  JSAMPROW outptr;
945
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
946
  int ctr;
947
  int workspace[3*3];	/* buffers data between passes */
948
  SHIFT_TEMPS
949

950
  /* Pass 1: process columns from input, store into work array. */
951

952
  inptr = coef_block;
953
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
954
  wsptr = workspace;
955
  for (ctr = 0; ctr < 3; ctr++, inptr++, quantptr++, wsptr++) {
956
    /* Even part */
957

958
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
959
    tmp0 <<= CONST_BITS;
960
    /* Add fudge factor here for final descale. */
961
    tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
962
    tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
963
    tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
964
    tmp10 = tmp0 + tmp12;
965
    tmp2 = tmp0 - tmp12 - tmp12;
966

967
    /* Odd part */
968

969
    tmp12 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
970
    tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
971

972
    /* Final output stage */
973

974
    wsptr[3*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
975
    wsptr[3*2] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
976
    wsptr[3*1] = (int) RIGHT_SHIFT(tmp2, CONST_BITS-PASS1_BITS);
977
  }
978

979
  /* Pass 2: process 3 rows from work array, store into output array. */
980

981
  wsptr = workspace;
982
  for (ctr = 0; ctr < 3; ctr++) {
983
    outptr = output_buf[ctr] + output_col;
984

985
    /* Even part */
986

987
    /* Add range center and fudge factor for final descale and range-limit. */
988
    tmp0 = (INT32) wsptr[0] +
989
	     ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
990
	      (ONE << (PASS1_BITS+2)));
991
    tmp0 <<= CONST_BITS;
992
    tmp2 = (INT32) wsptr[2];
993
    tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
994
    tmp10 = tmp0 + tmp12;
995
    tmp2 = tmp0 - tmp12 - tmp12;
996

997
    /* Odd part */
998

999
    tmp12 = (INT32) wsptr[1];
1000
    tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
1001

1002
    /* Final output stage */
1003

1004
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
1005
					      CONST_BITS+PASS1_BITS+3)
1006
			    & RANGE_MASK];
1007
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
1008
					      CONST_BITS+PASS1_BITS+3)
1009
			    & RANGE_MASK];
1010
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp2,
1011
					      CONST_BITS+PASS1_BITS+3)
1012
			    & RANGE_MASK];
1013

1014
    wsptr += 3;		/* advance pointer to next row */
1015
  }
1016
}
1017

1018

1019
/*
1020
 * Perform dequantization and inverse DCT on one block of coefficients,
1021
 * producing a reduced-size 2x2 output block.
1022
 *
1023
 * Multiplication-less algorithm.
1024
 */
1025

1026
GLOBAL(void)
1027
jpeg_idct_2x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1028
	       JCOEFPTR coef_block,
1029
	       JSAMPARRAY output_buf, JDIMENSION output_col)
1030
{
1031
  DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
1032
  ISLOW_MULT_TYPE * quantptr;
1033
  JSAMPROW outptr;
1034
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1035
  ISHIFT_TEMPS
1036

1037
  /* Pass 1: process columns from input. */
1038

1039
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1040

1041
  /* Column 0 */
1042
  tmp4 = DEQUANTIZE(coef_block[DCTSIZE*0], quantptr[DCTSIZE*0]);
1043
  tmp5 = DEQUANTIZE(coef_block[DCTSIZE*1], quantptr[DCTSIZE*1]);
1044
  /* Add range center and fudge factor for final descale and range-limit. */
1045
  tmp4 += (((DCTELEM) RANGE_CENTER) << 3) + (1 << 2);
1046

1047
  tmp0 = tmp4 + tmp5;
1048
  tmp2 = tmp4 - tmp5;
1049

1050
  /* Column 1 */
1051
  tmp4 = DEQUANTIZE(coef_block[DCTSIZE*0+1], quantptr[DCTSIZE*0+1]);
1052
  tmp5 = DEQUANTIZE(coef_block[DCTSIZE*1+1], quantptr[DCTSIZE*1+1]);
1053

1054
  tmp1 = tmp4 + tmp5;
1055
  tmp3 = tmp4 - tmp5;
1056

1057
  /* Pass 2: process 2 rows, store into output array. */
1058

1059
  /* Row 0 */
1060
  outptr = output_buf[0] + output_col;
1061

1062
  outptr[0] = range_limit[(int) IRIGHT_SHIFT(tmp0 + tmp1, 3) & RANGE_MASK];
1063
  outptr[1] = range_limit[(int) IRIGHT_SHIFT(tmp0 - tmp1, 3) & RANGE_MASK];
1064

1065
  /* Row 1 */
1066
  outptr = output_buf[1] + output_col;
1067

1068
  outptr[0] = range_limit[(int) IRIGHT_SHIFT(tmp2 + tmp3, 3) & RANGE_MASK];
1069
  outptr[1] = range_limit[(int) IRIGHT_SHIFT(tmp2 - tmp3, 3) & RANGE_MASK];
1070
}
1071

1072

1073
/*
1074
 * Perform dequantization and inverse DCT on one block of coefficients,
1075
 * producing a reduced-size 1x1 output block.
1076
 *
1077
 * We hardly need an inverse DCT routine for this: just take the
1078
 * average pixel value, which is one-eighth of the DC coefficient.
1079
 */
1080

1081
GLOBAL(void)
1082
jpeg_idct_1x1 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1083
	       JCOEFPTR coef_block,
1084
	       JSAMPARRAY output_buf, JDIMENSION output_col)
1085
{
1086
  DCTELEM dcval;
1087
  ISLOW_MULT_TYPE * quantptr;
1088
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1089
  ISHIFT_TEMPS
1090

1091
  /* 1x1 is trivial: just take the DC coefficient divided by 8. */
1092

1093
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1094

1095
  dcval = DEQUANTIZE(coef_block[0], quantptr[0]);
1096
  /* Add range center and fudge factor for descale and range-limit. */
1097
  dcval += (((DCTELEM) RANGE_CENTER) << 3) + (1 << 2);
1098

1099
  output_buf[0][output_col] =
1100
    range_limit[(int) IRIGHT_SHIFT(dcval, 3) & RANGE_MASK];
1101
}
1102

1103

1104
/*
1105
 * Perform dequantization and inverse DCT on one block of coefficients,
1106
 * producing a 9x9 output block.
1107
 *
1108
 * Optimized algorithm with 10 multiplications in the 1-D kernel.
1109
 * cK represents sqrt(2) * cos(K*pi/18).
1110
 */
1111

1112
GLOBAL(void)
1113
jpeg_idct_9x9 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1114
	       JCOEFPTR coef_block,
1115
	       JSAMPARRAY output_buf, JDIMENSION output_col)
1116
{
1117
  INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13, tmp14;
1118
  INT32 z1, z2, z3, z4;
1119
  JCOEFPTR inptr;
1120
  ISLOW_MULT_TYPE * quantptr;
1121
  int * wsptr;
1122
  JSAMPROW outptr;
1123
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1124
  int ctr;
1125
  int workspace[8*9];	/* buffers data between passes */
1126
  SHIFT_TEMPS
1127

1128
  /* Pass 1: process columns from input, store into work array. */
1129

1130
  inptr = coef_block;
1131
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1132
  wsptr = workspace;
1133
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1134
    /* Even part */
1135

1136
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1137
    tmp0 <<= CONST_BITS;
1138
    /* Add fudge factor here for final descale. */
1139
    tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
1140

1141
    z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1142
    z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1143
    z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1144

1145
    tmp3 = MULTIPLY(z3, FIX(0.707106781));      /* c6 */
1146
    tmp1 = tmp0 + tmp3;
1147
    tmp2 = tmp0 - tmp3 - tmp3;
1148

1149
    tmp0 = MULTIPLY(z1 - z2, FIX(0.707106781)); /* c6 */
1150
    tmp11 = tmp2 + tmp0;
1151
    tmp14 = tmp2 - tmp0 - tmp0;
1152

1153
    tmp0 = MULTIPLY(z1 + z2, FIX(1.328926049)); /* c2 */
1154
    tmp2 = MULTIPLY(z1, FIX(1.083350441));      /* c4 */
1155
    tmp3 = MULTIPLY(z2, FIX(0.245575608));      /* c8 */
1156

1157
    tmp10 = tmp1 + tmp0 - tmp3;
1158
    tmp12 = tmp1 - tmp0 + tmp2;
1159
    tmp13 = tmp1 - tmp2 + tmp3;
1160

1161
    /* Odd part */
1162

1163
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1164
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1165
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1166
    z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1167

1168
    z2 = MULTIPLY(z2, - FIX(1.224744871));           /* -c3 */
1169

1170
    tmp2 = MULTIPLY(z1 + z3, FIX(0.909038955));      /* c5 */
1171
    tmp3 = MULTIPLY(z1 + z4, FIX(0.483689525));      /* c7 */
1172
    tmp0 = tmp2 + tmp3 - z2;
1173
    tmp1 = MULTIPLY(z3 - z4, FIX(1.392728481));      /* c1 */
1174
    tmp2 += z2 - tmp1;
1175
    tmp3 += z2 + tmp1;
1176
    tmp1 = MULTIPLY(z1 - z3 - z4, FIX(1.224744871)); /* c3 */
1177

1178
    /* Final output stage */
1179

1180
    wsptr[8*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
1181
    wsptr[8*8] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
1182
    wsptr[8*1] = (int) RIGHT_SHIFT(tmp11 + tmp1, CONST_BITS-PASS1_BITS);
1183
    wsptr[8*7] = (int) RIGHT_SHIFT(tmp11 - tmp1, CONST_BITS-PASS1_BITS);
1184
    wsptr[8*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
1185
    wsptr[8*6] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
1186
    wsptr[8*3] = (int) RIGHT_SHIFT(tmp13 + tmp3, CONST_BITS-PASS1_BITS);
1187
    wsptr[8*5] = (int) RIGHT_SHIFT(tmp13 - tmp3, CONST_BITS-PASS1_BITS);
1188
    wsptr[8*4] = (int) RIGHT_SHIFT(tmp14, CONST_BITS-PASS1_BITS);
1189
  }
1190

1191
  /* Pass 2: process 9 rows from work array, store into output array. */
1192

1193
  wsptr = workspace;
1194
  for (ctr = 0; ctr < 9; ctr++) {
1195
    outptr = output_buf[ctr] + output_col;
1196

1197
    /* Even part */
1198

1199
    /* Add range center and fudge factor for final descale and range-limit. */
1200
    tmp0 = (INT32) wsptr[0] +
1201
	     ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
1202
	      (ONE << (PASS1_BITS+2)));
1203
    tmp0 <<= CONST_BITS;
1204

1205
    z1 = (INT32) wsptr[2];
1206
    z2 = (INT32) wsptr[4];
1207
    z3 = (INT32) wsptr[6];
1208

1209
    tmp3 = MULTIPLY(z3, FIX(0.707106781));      /* c6 */
1210
    tmp1 = tmp0 + tmp3;
1211
    tmp2 = tmp0 - tmp3 - tmp3;
1212

1213
    tmp0 = MULTIPLY(z1 - z2, FIX(0.707106781)); /* c6 */
1214
    tmp11 = tmp2 + tmp0;
1215
    tmp14 = tmp2 - tmp0 - tmp0;
1216

1217
    tmp0 = MULTIPLY(z1 + z2, FIX(1.328926049)); /* c2 */
1218
    tmp2 = MULTIPLY(z1, FIX(1.083350441));      /* c4 */
1219
    tmp3 = MULTIPLY(z2, FIX(0.245575608));      /* c8 */
1220

1221
    tmp10 = tmp1 + tmp0 - tmp3;
1222
    tmp12 = tmp1 - tmp0 + tmp2;
1223
    tmp13 = tmp1 - tmp2 + tmp3;
1224

1225
    /* Odd part */
1226

1227
    z1 = (INT32) wsptr[1];
1228
    z2 = (INT32) wsptr[3];
1229
    z3 = (INT32) wsptr[5];
1230
    z4 = (INT32) wsptr[7];
1231

1232
    z2 = MULTIPLY(z2, - FIX(1.224744871));           /* -c3 */
1233

1234
    tmp2 = MULTIPLY(z1 + z3, FIX(0.909038955));      /* c5 */
1235
    tmp3 = MULTIPLY(z1 + z4, FIX(0.483689525));      /* c7 */
1236
    tmp0 = tmp2 + tmp3 - z2;
1237
    tmp1 = MULTIPLY(z3 - z4, FIX(1.392728481));      /* c1 */
1238
    tmp2 += z2 - tmp1;
1239
    tmp3 += z2 + tmp1;
1240
    tmp1 = MULTIPLY(z1 - z3 - z4, FIX(1.224744871)); /* c3 */
1241

1242
    /* Final output stage */
1243

1244
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
1245
					      CONST_BITS+PASS1_BITS+3)
1246
			    & RANGE_MASK];
1247
    outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
1248
					      CONST_BITS+PASS1_BITS+3)
1249
			    & RANGE_MASK];
1250
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
1251
					      CONST_BITS+PASS1_BITS+3)
1252
			    & RANGE_MASK];
1253
    outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
1254
					      CONST_BITS+PASS1_BITS+3)
1255
			    & RANGE_MASK];
1256
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
1257
					      CONST_BITS+PASS1_BITS+3)
1258
			    & RANGE_MASK];
1259
    outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
1260
					      CONST_BITS+PASS1_BITS+3)
1261
			    & RANGE_MASK];
1262
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp3,
1263
					      CONST_BITS+PASS1_BITS+3)
1264
			    & RANGE_MASK];
1265
    outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp3,
1266
					      CONST_BITS+PASS1_BITS+3)
1267
			    & RANGE_MASK];
1268
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp14,
1269
					      CONST_BITS+PASS1_BITS+3)
1270
			    & RANGE_MASK];
1271

1272
    wsptr += 8;		/* advance pointer to next row */
1273
  }
1274
}
1275

1276

1277
/*
1278
 * Perform dequantization and inverse DCT on one block of coefficients,
1279
 * producing a 10x10 output block.
1280
 *
1281
 * Optimized algorithm with 12 multiplications in the 1-D kernel.
1282
 * cK represents sqrt(2) * cos(K*pi/20).
1283
 */
1284

1285
GLOBAL(void)
1286
jpeg_idct_10x10 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1287
		 JCOEFPTR coef_block,
1288
		 JSAMPARRAY output_buf, JDIMENSION output_col)
1289
{
1290
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
1291
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24;
1292
  INT32 z1, z2, z3, z4, z5;
1293
  JCOEFPTR inptr;
1294
  ISLOW_MULT_TYPE * quantptr;
1295
  int * wsptr;
1296
  JSAMPROW outptr;
1297
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1298
  int ctr;
1299
  int workspace[8*10];	/* buffers data between passes */
1300
  SHIFT_TEMPS
1301

1302
  /* Pass 1: process columns from input, store into work array. */
1303

1304
  inptr = coef_block;
1305
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1306
  wsptr = workspace;
1307
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1308
    /* Even part */
1309

1310
    z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1311
    z3 <<= CONST_BITS;
1312
    /* Add fudge factor here for final descale. */
1313
    z3 += ONE << (CONST_BITS-PASS1_BITS-1);
1314
    z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1315
    z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
1316
    z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
1317
    tmp10 = z3 + z1;
1318
    tmp11 = z3 - z2;
1319

1320
    tmp22 = RIGHT_SHIFT(z3 - ((z1 - z2) << 1),   /* c0 = (c4-c8)*2 */
1321
			CONST_BITS-PASS1_BITS);
1322

1323
    z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1324
    z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1325

1326
    z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
1327
    tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
1328
    tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
1329

1330
    tmp20 = tmp10 + tmp12;
1331
    tmp24 = tmp10 - tmp12;
1332
    tmp21 = tmp11 + tmp13;
1333
    tmp23 = tmp11 - tmp13;
1334

1335
    /* Odd part */
1336

1337
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1338
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1339
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1340
    z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1341

1342
    tmp11 = z2 + z4;
1343
    tmp13 = z2 - z4;
1344

1345
    tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
1346
    z5 = z3 << CONST_BITS;
1347

1348
    z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
1349
    z4 = z5 + tmp12;
1350

1351
    tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
1352
    tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
1353

1354
    z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
1355
    z4 = z5 - tmp12 - (tmp13 << (CONST_BITS - 1));
1356

1357
    tmp12 = (z1 - tmp13 - z3) << PASS1_BITS;
1358

1359
    tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
1360
    tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
1361

1362
    /* Final output stage */
1363

1364
    wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1365
    wsptr[8*9] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1366
    wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1367
    wsptr[8*8] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1368
    wsptr[8*2] = (int) (tmp22 + tmp12);
1369
    wsptr[8*7] = (int) (tmp22 - tmp12);
1370
    wsptr[8*3] = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
1371
    wsptr[8*6] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
1372
    wsptr[8*4] = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1373
    wsptr[8*5] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1374
  }
1375

1376
  /* Pass 2: process 10 rows from work array, store into output array. */
1377

1378
  wsptr = workspace;
1379
  for (ctr = 0; ctr < 10; ctr++) {
1380
    outptr = output_buf[ctr] + output_col;
1381

1382
    /* Even part */
1383

1384
    /* Add range center and fudge factor for final descale and range-limit. */
1385
    z3 = (INT32) wsptr[0] +
1386
	   ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
1387
	    (ONE << (PASS1_BITS+2)));
1388
    z3 <<= CONST_BITS;
1389
    z4 = (INT32) wsptr[4];
1390
    z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
1391
    z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
1392
    tmp10 = z3 + z1;
1393
    tmp11 = z3 - z2;
1394

1395
    tmp22 = z3 - ((z1 - z2) << 1);               /* c0 = (c4-c8)*2 */
1396

1397
    z2 = (INT32) wsptr[2];
1398
    z3 = (INT32) wsptr[6];
1399

1400
    z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
1401
    tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
1402
    tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
1403

1404
    tmp20 = tmp10 + tmp12;
1405
    tmp24 = tmp10 - tmp12;
1406
    tmp21 = tmp11 + tmp13;
1407
    tmp23 = tmp11 - tmp13;
1408

1409
    /* Odd part */
1410

1411
    z1 = (INT32) wsptr[1];
1412
    z2 = (INT32) wsptr[3];
1413
    z3 = (INT32) wsptr[5];
1414
    z3 <<= CONST_BITS;
1415
    z4 = (INT32) wsptr[7];
1416

1417
    tmp11 = z2 + z4;
1418
    tmp13 = z2 - z4;
1419

1420
    tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
1421

1422
    z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
1423
    z4 = z3 + tmp12;
1424

1425
    tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
1426
    tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
1427

1428
    z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
1429
    z4 = z3 - tmp12 - (tmp13 << (CONST_BITS - 1));
1430

1431
    tmp12 = ((z1 - tmp13) << CONST_BITS) - z3;
1432

1433
    tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
1434
    tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
1435

1436
    /* Final output stage */
1437

1438
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
1439
					      CONST_BITS+PASS1_BITS+3)
1440
			    & RANGE_MASK];
1441
    outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
1442
					      CONST_BITS+PASS1_BITS+3)
1443
			    & RANGE_MASK];
1444
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
1445
					      CONST_BITS+PASS1_BITS+3)
1446
			    & RANGE_MASK];
1447
    outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
1448
					      CONST_BITS+PASS1_BITS+3)
1449
			    & RANGE_MASK];
1450
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
1451
					      CONST_BITS+PASS1_BITS+3)
1452
			    & RANGE_MASK];
1453
    outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
1454
					      CONST_BITS+PASS1_BITS+3)
1455
			    & RANGE_MASK];
1456
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
1457
					      CONST_BITS+PASS1_BITS+3)
1458
			    & RANGE_MASK];
1459
    outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
1460
					      CONST_BITS+PASS1_BITS+3)
1461
			    & RANGE_MASK];
1462
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
1463
					      CONST_BITS+PASS1_BITS+3)
1464
			    & RANGE_MASK];
1465
    outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
1466
					      CONST_BITS+PASS1_BITS+3)
1467
			    & RANGE_MASK];
1468

1469
    wsptr += 8;		/* advance pointer to next row */
1470
  }
1471
}
1472

1473

1474
/*
1475
 * Perform dequantization and inverse DCT on one block of coefficients,
1476
 * producing a 11x11 output block.
1477
 *
1478
 * Optimized algorithm with 24 multiplications in the 1-D kernel.
1479
 * cK represents sqrt(2) * cos(K*pi/22).
1480
 */
1481

1482
GLOBAL(void)
1483
jpeg_idct_11x11 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1484
		 JCOEFPTR coef_block,
1485
		 JSAMPARRAY output_buf, JDIMENSION output_col)
1486
{
1487
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
1488
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
1489
  INT32 z1, z2, z3, z4;
1490
  JCOEFPTR inptr;
1491
  ISLOW_MULT_TYPE * quantptr;
1492
  int * wsptr;
1493
  JSAMPROW outptr;
1494
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1495
  int ctr;
1496
  int workspace[8*11];	/* buffers data between passes */
1497
  SHIFT_TEMPS
1498

1499
  /* Pass 1: process columns from input, store into work array. */
1500

1501
  inptr = coef_block;
1502
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1503
  wsptr = workspace;
1504
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1505
    /* Even part */
1506

1507
    tmp10 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1508
    tmp10 <<= CONST_BITS;
1509
    /* Add fudge factor here for final descale. */
1510
    tmp10 += ONE << (CONST_BITS-PASS1_BITS-1);
1511

1512
    z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1513
    z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1514
    z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1515

1516
    tmp20 = MULTIPLY(z2 - z3, FIX(2.546640132));     /* c2+c4 */
1517
    tmp23 = MULTIPLY(z2 - z1, FIX(0.430815045));     /* c2-c6 */
1518
    z4 = z1 + z3;
1519
    tmp24 = MULTIPLY(z4, - FIX(1.155664402));        /* -(c2-c10) */
1520
    z4 -= z2;
1521
    tmp25 = tmp10 + MULTIPLY(z4, FIX(1.356927976));  /* c2 */
1522
    tmp21 = tmp20 + tmp23 + tmp25 -
1523
	    MULTIPLY(z2, FIX(1.821790775));          /* c2+c4+c10-c6 */
1524
    tmp20 += tmp25 + MULTIPLY(z3, FIX(2.115825087)); /* c4+c6 */
1525
    tmp23 += tmp25 - MULTIPLY(z1, FIX(1.513598477)); /* c6+c8 */
1526
    tmp24 += tmp25;
1527
    tmp22 = tmp24 - MULTIPLY(z3, FIX(0.788749120));  /* c8+c10 */
1528
    tmp24 += MULTIPLY(z2, FIX(1.944413522)) -        /* c2+c8 */
1529
	     MULTIPLY(z1, FIX(1.390975730));         /* c4+c10 */
1530
    tmp25 = tmp10 - MULTIPLY(z4, FIX(1.414213562));  /* c0 */
1531

1532
    /* Odd part */
1533

1534
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1535
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1536
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1537
    z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1538

1539
    tmp11 = z1 + z2;
1540
    tmp14 = MULTIPLY(tmp11 + z3 + z4, FIX(0.398430003)); /* c9 */
1541
    tmp11 = MULTIPLY(tmp11, FIX(0.887983902));           /* c3-c9 */
1542
    tmp12 = MULTIPLY(z1 + z3, FIX(0.670361295));         /* c5-c9 */
1543
    tmp13 = tmp14 + MULTIPLY(z1 + z4, FIX(0.366151574)); /* c7-c9 */
1544
    tmp10 = tmp11 + tmp12 + tmp13 -
1545
	    MULTIPLY(z1, FIX(0.923107866));              /* c7+c5+c3-c1-2*c9 */
1546
    z1    = tmp14 - MULTIPLY(z2 + z3, FIX(1.163011579)); /* c7+c9 */
1547
    tmp11 += z1 + MULTIPLY(z2, FIX(2.073276588));        /* c1+c7+3*c9-c3 */
1548
    tmp12 += z1 - MULTIPLY(z3, FIX(1.192193623));        /* c3+c5-c7-c9 */
1549
    z1    = MULTIPLY(z2 + z4, - FIX(1.798248910));       /* -(c1+c9) */
1550
    tmp11 += z1;
1551
    tmp13 += z1 + MULTIPLY(z4, FIX(2.102458632));        /* c1+c5+c9-c7 */
1552
    tmp14 += MULTIPLY(z2, - FIX(1.467221301)) +          /* -(c5+c9) */
1553
	     MULTIPLY(z3, FIX(1.001388905)) -            /* c1-c9 */
1554
	     MULTIPLY(z4, FIX(1.684843907));             /* c3+c9 */
1555

1556
    /* Final output stage */
1557

1558
    wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1559
    wsptr[8*10] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1560
    wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1561
    wsptr[8*9]  = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1562
    wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
1563
    wsptr[8*8]  = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
1564
    wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
1565
    wsptr[8*7]  = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
1566
    wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1567
    wsptr[8*6]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1568
    wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25, CONST_BITS-PASS1_BITS);
1569
  }
1570

1571
  /* Pass 2: process 11 rows from work array, store into output array. */
1572

1573
  wsptr = workspace;
1574
  for (ctr = 0; ctr < 11; ctr++) {
1575
    outptr = output_buf[ctr] + output_col;
1576

1577
    /* Even part */
1578

1579
    /* Add range center and fudge factor for final descale and range-limit. */
1580
    tmp10 = (INT32) wsptr[0] +
1581
	      ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
1582
	       (ONE << (PASS1_BITS+2)));
1583
    tmp10 <<= CONST_BITS;
1584

1585
    z1 = (INT32) wsptr[2];
1586
    z2 = (INT32) wsptr[4];
1587
    z3 = (INT32) wsptr[6];
1588

1589
    tmp20 = MULTIPLY(z2 - z3, FIX(2.546640132));     /* c2+c4 */
1590
    tmp23 = MULTIPLY(z2 - z1, FIX(0.430815045));     /* c2-c6 */
1591
    z4 = z1 + z3;
1592
    tmp24 = MULTIPLY(z4, - FIX(1.155664402));        /* -(c2-c10) */
1593
    z4 -= z2;
1594
    tmp25 = tmp10 + MULTIPLY(z4, FIX(1.356927976));  /* c2 */
1595
    tmp21 = tmp20 + tmp23 + tmp25 -
1596
	    MULTIPLY(z2, FIX(1.821790775));          /* c2+c4+c10-c6 */
1597
    tmp20 += tmp25 + MULTIPLY(z3, FIX(2.115825087)); /* c4+c6 */
1598
    tmp23 += tmp25 - MULTIPLY(z1, FIX(1.513598477)); /* c6+c8 */
1599
    tmp24 += tmp25;
1600
    tmp22 = tmp24 - MULTIPLY(z3, FIX(0.788749120));  /* c8+c10 */
1601
    tmp24 += MULTIPLY(z2, FIX(1.944413522)) -        /* c2+c8 */
1602
	     MULTIPLY(z1, FIX(1.390975730));         /* c4+c10 */
1603
    tmp25 = tmp10 - MULTIPLY(z4, FIX(1.414213562));  /* c0 */
1604

1605
    /* Odd part */
1606

1607
    z1 = (INT32) wsptr[1];
1608
    z2 = (INT32) wsptr[3];
1609
    z3 = (INT32) wsptr[5];
1610
    z4 = (INT32) wsptr[7];
1611

1612
    tmp11 = z1 + z2;
1613
    tmp14 = MULTIPLY(tmp11 + z3 + z4, FIX(0.398430003)); /* c9 */
1614
    tmp11 = MULTIPLY(tmp11, FIX(0.887983902));           /* c3-c9 */
1615
    tmp12 = MULTIPLY(z1 + z3, FIX(0.670361295));         /* c5-c9 */
1616
    tmp13 = tmp14 + MULTIPLY(z1 + z4, FIX(0.366151574)); /* c7-c9 */
1617
    tmp10 = tmp11 + tmp12 + tmp13 -
1618
	    MULTIPLY(z1, FIX(0.923107866));              /* c7+c5+c3-c1-2*c9 */
1619
    z1    = tmp14 - MULTIPLY(z2 + z3, FIX(1.163011579)); /* c7+c9 */
1620
    tmp11 += z1 + MULTIPLY(z2, FIX(2.073276588));        /* c1+c7+3*c9-c3 */
1621
    tmp12 += z1 - MULTIPLY(z3, FIX(1.192193623));        /* c3+c5-c7-c9 */
1622
    z1    = MULTIPLY(z2 + z4, - FIX(1.798248910));       /* -(c1+c9) */
1623
    tmp11 += z1;
1624
    tmp13 += z1 + MULTIPLY(z4, FIX(2.102458632));        /* c1+c5+c9-c7 */
1625
    tmp14 += MULTIPLY(z2, - FIX(1.467221301)) +          /* -(c5+c9) */
1626
	     MULTIPLY(z3, FIX(1.001388905)) -            /* c1-c9 */
1627
	     MULTIPLY(z4, FIX(1.684843907));             /* c3+c9 */
1628

1629
    /* Final output stage */
1630

1631
    outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
1632
					       CONST_BITS+PASS1_BITS+3)
1633
			     & RANGE_MASK];
1634
    outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
1635
					       CONST_BITS+PASS1_BITS+3)
1636
			     & RANGE_MASK];
1637
    outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
1638
					       CONST_BITS+PASS1_BITS+3)
1639
			     & RANGE_MASK];
1640
    outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
1641
					       CONST_BITS+PASS1_BITS+3)
1642
			     & RANGE_MASK];
1643
    outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
1644
					       CONST_BITS+PASS1_BITS+3)
1645
			     & RANGE_MASK];
1646
    outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
1647
					       CONST_BITS+PASS1_BITS+3)
1648
			     & RANGE_MASK];
1649
    outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
1650
					       CONST_BITS+PASS1_BITS+3)
1651
			     & RANGE_MASK];
1652
    outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
1653
					       CONST_BITS+PASS1_BITS+3)
1654
			     & RANGE_MASK];
1655
    outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
1656
					       CONST_BITS+PASS1_BITS+3)
1657
			     & RANGE_MASK];
1658
    outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
1659
					       CONST_BITS+PASS1_BITS+3)
1660
			     & RANGE_MASK];
1661
    outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25,
1662
					       CONST_BITS+PASS1_BITS+3)
1663
			     & RANGE_MASK];
1664

1665
    wsptr += 8;		/* advance pointer to next row */
1666
  }
1667
}
1668

1669

1670
/*
1671
 * Perform dequantization and inverse DCT on one block of coefficients,
1672
 * producing a 12x12 output block.
1673
 *
1674
 * Optimized algorithm with 15 multiplications in the 1-D kernel.
1675
 * cK represents sqrt(2) * cos(K*pi/24).
1676
 */
1677

1678
GLOBAL(void)
1679
jpeg_idct_12x12 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1680
		 JCOEFPTR coef_block,
1681
		 JSAMPARRAY output_buf, JDIMENSION output_col)
1682
{
1683
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
1684
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
1685
  INT32 z1, z2, z3, z4;
1686
  JCOEFPTR inptr;
1687
  ISLOW_MULT_TYPE * quantptr;
1688
  int * wsptr;
1689
  JSAMPROW outptr;
1690
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1691
  int ctr;
1692
  int workspace[8*12];	/* buffers data between passes */
1693
  SHIFT_TEMPS
1694

1695
  /* Pass 1: process columns from input, store into work array. */
1696

1697
  inptr = coef_block;
1698
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1699
  wsptr = workspace;
1700
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1701
    /* Even part */
1702

1703
    z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1704
    z3 <<= CONST_BITS;
1705
    /* Add fudge factor here for final descale. */
1706
    z3 += ONE << (CONST_BITS-PASS1_BITS-1);
1707

1708
    z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1709
    z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
1710

1711
    tmp10 = z3 + z4;
1712
    tmp11 = z3 - z4;
1713

1714
    z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1715
    z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
1716
    z1 <<= CONST_BITS;
1717
    z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1718
    z2 <<= CONST_BITS;
1719

1720
    tmp12 = z1 - z2;
1721

1722
    tmp21 = z3 + tmp12;
1723
    tmp24 = z3 - tmp12;
1724

1725
    tmp12 = z4 + z2;
1726

1727
    tmp20 = tmp10 + tmp12;
1728
    tmp25 = tmp10 - tmp12;
1729

1730
    tmp12 = z4 - z1 - z2;
1731

1732
    tmp22 = tmp11 + tmp12;
1733
    tmp23 = tmp11 - tmp12;
1734

1735
    /* Odd part */
1736

1737
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1738
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1739
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1740
    z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1741

1742
    tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
1743
    tmp14 = MULTIPLY(z2, - FIX_0_541196100);                 /* -c9 */
1744

1745
    tmp10 = z1 + z3;
1746
    tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
1747
    tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
1748
    tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
1749
    tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580));           /* -(c7+c11) */
1750
    tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
1751
    tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
1752
    tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
1753
	     MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
1754

1755
    z1 -= z4;
1756
    z2 -= z3;
1757
    z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
1758
    tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
1759
    tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
1760

1761
    /* Final output stage */
1762

1763
    wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1764
    wsptr[8*11] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1765
    wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1766
    wsptr[8*10] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1767
    wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
1768
    wsptr[8*9]  = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
1769
    wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
1770
    wsptr[8*8]  = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
1771
    wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1772
    wsptr[8*7]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1773
    wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
1774
    wsptr[8*6]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
1775
  }
1776

1777
  /* Pass 2: process 12 rows from work array, store into output array. */
1778

1779
  wsptr = workspace;
1780
  for (ctr = 0; ctr < 12; ctr++) {
1781
    outptr = output_buf[ctr] + output_col;
1782

1783
    /* Even part */
1784

1785
    /* Add range center and fudge factor for final descale and range-limit. */
1786
    z3 = (INT32) wsptr[0] +
1787
	   ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
1788
	    (ONE << (PASS1_BITS+2)));
1789
    z3 <<= CONST_BITS;
1790

1791
    z4 = (INT32) wsptr[4];
1792
    z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
1793

1794
    tmp10 = z3 + z4;
1795
    tmp11 = z3 - z4;
1796

1797
    z1 = (INT32) wsptr[2];
1798
    z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
1799
    z1 <<= CONST_BITS;
1800
    z2 = (INT32) wsptr[6];
1801
    z2 <<= CONST_BITS;
1802

1803
    tmp12 = z1 - z2;
1804

1805
    tmp21 = z3 + tmp12;
1806
    tmp24 = z3 - tmp12;
1807

1808
    tmp12 = z4 + z2;
1809

1810
    tmp20 = tmp10 + tmp12;
1811
    tmp25 = tmp10 - tmp12;
1812

1813
    tmp12 = z4 - z1 - z2;
1814

1815
    tmp22 = tmp11 + tmp12;
1816
    tmp23 = tmp11 - tmp12;
1817

1818
    /* Odd part */
1819

1820
    z1 = (INT32) wsptr[1];
1821
    z2 = (INT32) wsptr[3];
1822
    z3 = (INT32) wsptr[5];
1823
    z4 = (INT32) wsptr[7];
1824

1825
    tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
1826
    tmp14 = MULTIPLY(z2, - FIX_0_541196100);                 /* -c9 */
1827

1828
    tmp10 = z1 + z3;
1829
    tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
1830
    tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
1831
    tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
1832
    tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580));           /* -(c7+c11) */
1833
    tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
1834
    tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
1835
    tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
1836
	     MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
1837

1838
    z1 -= z4;
1839
    z2 -= z3;
1840
    z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
1841
    tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
1842
    tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
1843

1844
    /* Final output stage */
1845

1846
    outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
1847
					       CONST_BITS+PASS1_BITS+3)
1848
			     & RANGE_MASK];
1849
    outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
1850
					       CONST_BITS+PASS1_BITS+3)
1851
			     & RANGE_MASK];
1852
    outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
1853
					       CONST_BITS+PASS1_BITS+3)
1854
			     & RANGE_MASK];
1855
    outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
1856
					       CONST_BITS+PASS1_BITS+3)
1857
			     & RANGE_MASK];
1858
    outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
1859
					       CONST_BITS+PASS1_BITS+3)
1860
			     & RANGE_MASK];
1861
    outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
1862
					       CONST_BITS+PASS1_BITS+3)
1863
			     & RANGE_MASK];
1864
    outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
1865
					       CONST_BITS+PASS1_BITS+3)
1866
			     & RANGE_MASK];
1867
    outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
1868
					       CONST_BITS+PASS1_BITS+3)
1869
			     & RANGE_MASK];
1870
    outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
1871
					       CONST_BITS+PASS1_BITS+3)
1872
			     & RANGE_MASK];
1873
    outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
1874
					       CONST_BITS+PASS1_BITS+3)
1875
			     & RANGE_MASK];
1876
    outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
1877
					       CONST_BITS+PASS1_BITS+3)
1878
			     & RANGE_MASK];
1879
    outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
1880
					       CONST_BITS+PASS1_BITS+3)
1881
			     & RANGE_MASK];
1882

1883
    wsptr += 8;		/* advance pointer to next row */
1884
  }
1885
}
1886

1887

1888
/*
1889
 * Perform dequantization and inverse DCT on one block of coefficients,
1890
 * producing a 13x13 output block.
1891
 *
1892
 * Optimized algorithm with 29 multiplications in the 1-D kernel.
1893
 * cK represents sqrt(2) * cos(K*pi/26).
1894
 */
1895

1896
GLOBAL(void)
1897
jpeg_idct_13x13 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
1898
		 JCOEFPTR coef_block,
1899
		 JSAMPARRAY output_buf, JDIMENSION output_col)
1900
{
1901
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
1902
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
1903
  INT32 z1, z2, z3, z4;
1904
  JCOEFPTR inptr;
1905
  ISLOW_MULT_TYPE * quantptr;
1906
  int * wsptr;
1907
  JSAMPROW outptr;
1908
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
1909
  int ctr;
1910
  int workspace[8*13];	/* buffers data between passes */
1911
  SHIFT_TEMPS
1912

1913
  /* Pass 1: process columns from input, store into work array. */
1914

1915
  inptr = coef_block;
1916
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
1917
  wsptr = workspace;
1918
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
1919
    /* Even part */
1920

1921
    z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
1922
    z1 <<= CONST_BITS;
1923
    /* Add fudge factor here for final descale. */
1924
    z1 += ONE << (CONST_BITS-PASS1_BITS-1);
1925

1926
    z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
1927
    z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
1928
    z4 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
1929

1930
    tmp10 = z3 + z4;
1931
    tmp11 = z3 - z4;
1932

1933
    tmp12 = MULTIPLY(tmp10, FIX(1.155388986));                /* (c4+c6)/2 */
1934
    tmp13 = MULTIPLY(tmp11, FIX(0.096834934)) + z1;           /* (c4-c6)/2 */
1935

1936
    tmp20 = MULTIPLY(z2, FIX(1.373119086)) + tmp12 + tmp13;   /* c2 */
1937
    tmp22 = MULTIPLY(z2, FIX(0.501487041)) - tmp12 + tmp13;   /* c10 */
1938

1939
    tmp12 = MULTIPLY(tmp10, FIX(0.316450131));                /* (c8-c12)/2 */
1940
    tmp13 = MULTIPLY(tmp11, FIX(0.486914739)) + z1;           /* (c8+c12)/2 */
1941

1942
    tmp21 = MULTIPLY(z2, FIX(1.058554052)) - tmp12 + tmp13;   /* c6 */
1943
    tmp25 = MULTIPLY(z2, - FIX(1.252223920)) + tmp12 + tmp13; /* c4 */
1944

1945
    tmp12 = MULTIPLY(tmp10, FIX(0.435816023));                /* (c2-c10)/2 */
1946
    tmp13 = MULTIPLY(tmp11, FIX(0.937303064)) - z1;           /* (c2+c10)/2 */
1947

1948
    tmp23 = MULTIPLY(z2, - FIX(0.170464608)) - tmp12 - tmp13; /* c12 */
1949
    tmp24 = MULTIPLY(z2, - FIX(0.803364869)) + tmp12 - tmp13; /* c8 */
1950

1951
    tmp26 = MULTIPLY(tmp11 - z2, FIX(1.414213562)) + z1;      /* c0 */
1952

1953
    /* Odd part */
1954

1955
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
1956
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
1957
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
1958
    z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
1959

1960
    tmp11 = MULTIPLY(z1 + z2, FIX(1.322312651));     /* c3 */
1961
    tmp12 = MULTIPLY(z1 + z3, FIX(1.163874945));     /* c5 */
1962
    tmp15 = z1 + z4;
1963
    tmp13 = MULTIPLY(tmp15, FIX(0.937797057));       /* c7 */
1964
    tmp10 = tmp11 + tmp12 + tmp13 -
1965
	    MULTIPLY(z1, FIX(2.020082300));          /* c7+c5+c3-c1 */
1966
    tmp14 = MULTIPLY(z2 + z3, - FIX(0.338443458));   /* -c11 */
1967
    tmp11 += tmp14 + MULTIPLY(z2, FIX(0.837223564)); /* c5+c9+c11-c3 */
1968
    tmp12 += tmp14 - MULTIPLY(z3, FIX(1.572116027)); /* c1+c5-c9-c11 */
1969
    tmp14 = MULTIPLY(z2 + z4, - FIX(1.163874945));   /* -c5 */
1970
    tmp11 += tmp14;
1971
    tmp13 += tmp14 + MULTIPLY(z4, FIX(2.205608352)); /* c3+c5+c9-c7 */
1972
    tmp14 = MULTIPLY(z3 + z4, - FIX(0.657217813));   /* -c9 */
1973
    tmp12 += tmp14;
1974
    tmp13 += tmp14;
1975
    tmp15 = MULTIPLY(tmp15, FIX(0.338443458));       /* c11 */
1976
    tmp14 = tmp15 + MULTIPLY(z1, FIX(0.318774355)) - /* c9-c11 */
1977
	    MULTIPLY(z2, FIX(0.466105296));          /* c1-c7 */
1978
    z1    = MULTIPLY(z3 - z2, FIX(0.937797057));     /* c7 */
1979
    tmp14 += z1;
1980
    tmp15 += z1 + MULTIPLY(z3, FIX(0.384515595)) -   /* c3-c7 */
1981
	     MULTIPLY(z4, FIX(1.742345811));         /* c1+c11 */
1982

1983
    /* Final output stage */
1984

1985
    wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
1986
    wsptr[8*12] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
1987
    wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
1988
    wsptr[8*11] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
1989
    wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
1990
    wsptr[8*10] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
1991
    wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
1992
    wsptr[8*9]  = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
1993
    wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
1994
    wsptr[8*8]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
1995
    wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
1996
    wsptr[8*7]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
1997
    wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26, CONST_BITS-PASS1_BITS);
1998
  }
1999

2000
  /* Pass 2: process 13 rows from work array, store into output array. */
2001

2002
  wsptr = workspace;
2003
  for (ctr = 0; ctr < 13; ctr++) {
2004
    outptr = output_buf[ctr] + output_col;
2005

2006
    /* Even part */
2007

2008
    /* Add range center and fudge factor for final descale and range-limit. */
2009
    z1 = (INT32) wsptr[0] +
2010
	   ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
2011
	    (ONE << (PASS1_BITS+2)));
2012
    z1 <<= CONST_BITS;
2013

2014
    z2 = (INT32) wsptr[2];
2015
    z3 = (INT32) wsptr[4];
2016
    z4 = (INT32) wsptr[6];
2017

2018
    tmp10 = z3 + z4;
2019
    tmp11 = z3 - z4;
2020

2021
    tmp12 = MULTIPLY(tmp10, FIX(1.155388986));                /* (c4+c6)/2 */
2022
    tmp13 = MULTIPLY(tmp11, FIX(0.096834934)) + z1;           /* (c4-c6)/2 */
2023

2024
    tmp20 = MULTIPLY(z2, FIX(1.373119086)) + tmp12 + tmp13;   /* c2 */
2025
    tmp22 = MULTIPLY(z2, FIX(0.501487041)) - tmp12 + tmp13;   /* c10 */
2026

2027
    tmp12 = MULTIPLY(tmp10, FIX(0.316450131));                /* (c8-c12)/2 */
2028
    tmp13 = MULTIPLY(tmp11, FIX(0.486914739)) + z1;           /* (c8+c12)/2 */
2029

2030
    tmp21 = MULTIPLY(z2, FIX(1.058554052)) - tmp12 + tmp13;   /* c6 */
2031
    tmp25 = MULTIPLY(z2, - FIX(1.252223920)) + tmp12 + tmp13; /* c4 */
2032

2033
    tmp12 = MULTIPLY(tmp10, FIX(0.435816023));                /* (c2-c10)/2 */
2034
    tmp13 = MULTIPLY(tmp11, FIX(0.937303064)) - z1;           /* (c2+c10)/2 */
2035

2036
    tmp23 = MULTIPLY(z2, - FIX(0.170464608)) - tmp12 - tmp13; /* c12 */
2037
    tmp24 = MULTIPLY(z2, - FIX(0.803364869)) + tmp12 - tmp13; /* c8 */
2038

2039
    tmp26 = MULTIPLY(tmp11 - z2, FIX(1.414213562)) + z1;      /* c0 */
2040

2041
    /* Odd part */
2042

2043
    z1 = (INT32) wsptr[1];
2044
    z2 = (INT32) wsptr[3];
2045
    z3 = (INT32) wsptr[5];
2046
    z4 = (INT32) wsptr[7];
2047

2048
    tmp11 = MULTIPLY(z1 + z2, FIX(1.322312651));     /* c3 */
2049
    tmp12 = MULTIPLY(z1 + z3, FIX(1.163874945));     /* c5 */
2050
    tmp15 = z1 + z4;
2051
    tmp13 = MULTIPLY(tmp15, FIX(0.937797057));       /* c7 */
2052
    tmp10 = tmp11 + tmp12 + tmp13 -
2053
	    MULTIPLY(z1, FIX(2.020082300));          /* c7+c5+c3-c1 */
2054
    tmp14 = MULTIPLY(z2 + z3, - FIX(0.338443458));   /* -c11 */
2055
    tmp11 += tmp14 + MULTIPLY(z2, FIX(0.837223564)); /* c5+c9+c11-c3 */
2056
    tmp12 += tmp14 - MULTIPLY(z3, FIX(1.572116027)); /* c1+c5-c9-c11 */
2057
    tmp14 = MULTIPLY(z2 + z4, - FIX(1.163874945));   /* -c5 */
2058
    tmp11 += tmp14;
2059
    tmp13 += tmp14 + MULTIPLY(z4, FIX(2.205608352)); /* c3+c5+c9-c7 */
2060
    tmp14 = MULTIPLY(z3 + z4, - FIX(0.657217813));   /* -c9 */
2061
    tmp12 += tmp14;
2062
    tmp13 += tmp14;
2063
    tmp15 = MULTIPLY(tmp15, FIX(0.338443458));       /* c11 */
2064
    tmp14 = tmp15 + MULTIPLY(z1, FIX(0.318774355)) - /* c9-c11 */
2065
	    MULTIPLY(z2, FIX(0.466105296));          /* c1-c7 */
2066
    z1    = MULTIPLY(z3 - z2, FIX(0.937797057));     /* c7 */
2067
    tmp14 += z1;
2068
    tmp15 += z1 + MULTIPLY(z3, FIX(0.384515595)) -   /* c3-c7 */
2069
	     MULTIPLY(z4, FIX(1.742345811));         /* c1+c11 */
2070

2071
    /* Final output stage */
2072

2073
    outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
2074
					       CONST_BITS+PASS1_BITS+3)
2075
			     & RANGE_MASK];
2076
    outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
2077
					       CONST_BITS+PASS1_BITS+3)
2078
			     & RANGE_MASK];
2079
    outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
2080
					       CONST_BITS+PASS1_BITS+3)
2081
			     & RANGE_MASK];
2082
    outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
2083
					       CONST_BITS+PASS1_BITS+3)
2084
			     & RANGE_MASK];
2085
    outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
2086
					       CONST_BITS+PASS1_BITS+3)
2087
			     & RANGE_MASK];
2088
    outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
2089
					       CONST_BITS+PASS1_BITS+3)
2090
			     & RANGE_MASK];
2091
    outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
2092
					       CONST_BITS+PASS1_BITS+3)
2093
			     & RANGE_MASK];
2094
    outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
2095
					       CONST_BITS+PASS1_BITS+3)
2096
			     & RANGE_MASK];
2097
    outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
2098
					       CONST_BITS+PASS1_BITS+3)
2099
			     & RANGE_MASK];
2100
    outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
2101
					       CONST_BITS+PASS1_BITS+3)
2102
			     & RANGE_MASK];
2103
    outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
2104
					       CONST_BITS+PASS1_BITS+3)
2105
			     & RANGE_MASK];
2106
    outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
2107
					       CONST_BITS+PASS1_BITS+3)
2108
			     & RANGE_MASK];
2109
    outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26,
2110
					       CONST_BITS+PASS1_BITS+3)
2111
			     & RANGE_MASK];
2112

2113
    wsptr += 8;		/* advance pointer to next row */
2114
  }
2115
}
2116

2117

2118
/*
2119
 * Perform dequantization and inverse DCT on one block of coefficients,
2120
 * producing a 14x14 output block.
2121
 *
2122
 * Optimized algorithm with 20 multiplications in the 1-D kernel.
2123
 * cK represents sqrt(2) * cos(K*pi/28).
2124
 */
2125

2126
GLOBAL(void)
2127
jpeg_idct_14x14 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
2128
		 JCOEFPTR coef_block,
2129
		 JSAMPARRAY output_buf, JDIMENSION output_col)
2130
{
2131
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
2132
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
2133
  INT32 z1, z2, z3, z4;
2134
  JCOEFPTR inptr;
2135
  ISLOW_MULT_TYPE * quantptr;
2136
  int * wsptr;
2137
  JSAMPROW outptr;
2138
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
2139
  int ctr;
2140
  int workspace[8*14];	/* buffers data between passes */
2141
  SHIFT_TEMPS
2142

2143
  /* Pass 1: process columns from input, store into work array. */
2144

2145
  inptr = coef_block;
2146
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
2147
  wsptr = workspace;
2148
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
2149
    /* Even part */
2150

2151
    z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
2152
    z1 <<= CONST_BITS;
2153
    /* Add fudge factor here for final descale. */
2154
    z1 += ONE << (CONST_BITS-PASS1_BITS-1);
2155
    z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
2156
    z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
2157
    z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
2158
    z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
2159

2160
    tmp10 = z1 + z2;
2161
    tmp11 = z1 + z3;
2162
    tmp12 = z1 - z4;
2163

2164
    tmp23 = RIGHT_SHIFT(z1 - ((z2 + z3 - z4) << 1), /* c0 = (c4+c12-c8)*2 */
2165
			CONST_BITS-PASS1_BITS);
2166

2167
    z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
2168
    z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
2169

2170
    z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
2171

2172
    tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
2173
    tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
2174
    tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
2175
	    MULTIPLY(z2, FIX(1.378756276));      /* c2 */
2176

2177
    tmp20 = tmp10 + tmp13;
2178
    tmp26 = tmp10 - tmp13;
2179
    tmp21 = tmp11 + tmp14;
2180
    tmp25 = tmp11 - tmp14;
2181
    tmp22 = tmp12 + tmp15;
2182
    tmp24 = tmp12 - tmp15;
2183

2184
    /* Odd part */
2185

2186
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
2187
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
2188
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
2189
    z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
2190
    tmp13 = z4 << CONST_BITS;
2191

2192
    tmp14 = z1 + z3;
2193
    tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
2194
    tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
2195
    tmp10 = tmp11 + tmp12 + tmp13 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
2196
    tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
2197
    tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
2198
    z1    -= z2;
2199
    tmp15 = MULTIPLY(z1, FIX(0.467085129)) - tmp13;        /* c11 */
2200
    tmp16 += tmp15;
2201
    z1    += z4;
2202
    z4    = MULTIPLY(z2 + z3, - FIX(0.158341681)) - tmp13; /* -c13 */
2203
    tmp11 += z4 - MULTIPLY(z2, FIX(0.424103948));          /* c3-c9-c13 */
2204
    tmp12 += z4 - MULTIPLY(z3, FIX(2.373959773));          /* c3+c5-c13 */
2205
    z4    = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
2206
    tmp14 += z4 + tmp13 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
2207
    tmp15 += z4 + MULTIPLY(z2, FIX(0.674957567));          /* c1+c11-c5 */
2208

2209
    tmp13 = (z1 - z3) << PASS1_BITS;
2210

2211
    /* Final output stage */
2212

2213
    wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
2214
    wsptr[8*13] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
2215
    wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
2216
    wsptr[8*12] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
2217
    wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
2218
    wsptr[8*11] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
2219
    wsptr[8*3]  = (int) (tmp23 + tmp13);
2220
    wsptr[8*10] = (int) (tmp23 - tmp13);
2221
    wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
2222
    wsptr[8*9]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
2223
    wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
2224
    wsptr[8*8]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
2225
    wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS-PASS1_BITS);
2226
    wsptr[8*7]  = (int) RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS-PASS1_BITS);
2227
  }
2228

2229
  /* Pass 2: process 14 rows from work array, store into output array. */
2230

2231
  wsptr = workspace;
2232
  for (ctr = 0; ctr < 14; ctr++) {
2233
    outptr = output_buf[ctr] + output_col;
2234

2235
    /* Even part */
2236

2237
    /* Add range center and fudge factor for final descale and range-limit. */
2238
    z1 = (INT32) wsptr[0] +
2239
	   ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
2240
	    (ONE << (PASS1_BITS+2)));
2241
    z1 <<= CONST_BITS;
2242
    z4 = (INT32) wsptr[4];
2243
    z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
2244
    z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
2245
    z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
2246

2247
    tmp10 = z1 + z2;
2248
    tmp11 = z1 + z3;
2249
    tmp12 = z1 - z4;
2250

2251
    tmp23 = z1 - ((z2 + z3 - z4) << 1);          /* c0 = (c4+c12-c8)*2 */
2252

2253
    z1 = (INT32) wsptr[2];
2254
    z2 = (INT32) wsptr[6];
2255

2256
    z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
2257

2258
    tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
2259
    tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
2260
    tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
2261
	    MULTIPLY(z2, FIX(1.378756276));      /* c2 */
2262

2263
    tmp20 = tmp10 + tmp13;
2264
    tmp26 = tmp10 - tmp13;
2265
    tmp21 = tmp11 + tmp14;
2266
    tmp25 = tmp11 - tmp14;
2267
    tmp22 = tmp12 + tmp15;
2268
    tmp24 = tmp12 - tmp15;
2269

2270
    /* Odd part */
2271

2272
    z1 = (INT32) wsptr[1];
2273
    z2 = (INT32) wsptr[3];
2274
    z3 = (INT32) wsptr[5];
2275
    z4 = (INT32) wsptr[7];
2276
    z4 <<= CONST_BITS;
2277

2278
    tmp14 = z1 + z3;
2279
    tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
2280
    tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
2281
    tmp10 = tmp11 + tmp12 + z4 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
2282
    tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
2283
    tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
2284
    z1    -= z2;
2285
    tmp15 = MULTIPLY(z1, FIX(0.467085129)) - z4;           /* c11 */
2286
    tmp16 += tmp15;
2287
    tmp13 = MULTIPLY(z2 + z3, - FIX(0.158341681)) - z4;    /* -c13 */
2288
    tmp11 += tmp13 - MULTIPLY(z2, FIX(0.424103948));       /* c3-c9-c13 */
2289
    tmp12 += tmp13 - MULTIPLY(z3, FIX(2.373959773));       /* c3+c5-c13 */
2290
    tmp13 = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
2291
    tmp14 += tmp13 + z4 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
2292
    tmp15 += tmp13 + MULTIPLY(z2, FIX(0.674957567));       /* c1+c11-c5 */
2293

2294
    tmp13 = ((z1 - z3) << CONST_BITS) + z4;
2295

2296
    /* Final output stage */
2297

2298
    outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
2299
					       CONST_BITS+PASS1_BITS+3)
2300
			     & RANGE_MASK];
2301
    outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
2302
					       CONST_BITS+PASS1_BITS+3)
2303
			     & RANGE_MASK];
2304
    outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
2305
					       CONST_BITS+PASS1_BITS+3)
2306
			     & RANGE_MASK];
2307
    outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
2308
					       CONST_BITS+PASS1_BITS+3)
2309
			     & RANGE_MASK];
2310
    outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
2311
					       CONST_BITS+PASS1_BITS+3)
2312
			     & RANGE_MASK];
2313
    outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
2314
					       CONST_BITS+PASS1_BITS+3)
2315
			     & RANGE_MASK];
2316
    outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
2317
					       CONST_BITS+PASS1_BITS+3)
2318
			     & RANGE_MASK];
2319
    outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
2320
					       CONST_BITS+PASS1_BITS+3)
2321
			     & RANGE_MASK];
2322
    outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
2323
					       CONST_BITS+PASS1_BITS+3)
2324
			     & RANGE_MASK];
2325
    outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
2326
					       CONST_BITS+PASS1_BITS+3)
2327
			     & RANGE_MASK];
2328
    outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
2329
					       CONST_BITS+PASS1_BITS+3)
2330
			     & RANGE_MASK];
2331
    outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
2332
					       CONST_BITS+PASS1_BITS+3)
2333
			     & RANGE_MASK];
2334
    outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp16,
2335
					       CONST_BITS+PASS1_BITS+3)
2336
			     & RANGE_MASK];
2337
    outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp16,
2338
					       CONST_BITS+PASS1_BITS+3)
2339
			     & RANGE_MASK];
2340

2341
    wsptr += 8;		/* advance pointer to next row */
2342
  }
2343
}
2344

2345

2346
/*
2347
 * Perform dequantization and inverse DCT on one block of coefficients,
2348
 * producing a 15x15 output block.
2349
 *
2350
 * Optimized algorithm with 22 multiplications in the 1-D kernel.
2351
 * cK represents sqrt(2) * cos(K*pi/30).
2352
 */
2353

2354
GLOBAL(void)
2355
jpeg_idct_15x15 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
2356
		 JCOEFPTR coef_block,
2357
		 JSAMPARRAY output_buf, JDIMENSION output_col)
2358
{
2359
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
2360
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
2361
  INT32 z1, z2, z3, z4;
2362
  JCOEFPTR inptr;
2363
  ISLOW_MULT_TYPE * quantptr;
2364
  int * wsptr;
2365
  JSAMPROW outptr;
2366
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
2367
  int ctr;
2368
  int workspace[8*15];	/* buffers data between passes */
2369
  SHIFT_TEMPS
2370

2371
  /* Pass 1: process columns from input, store into work array. */
2372

2373
  inptr = coef_block;
2374
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
2375
  wsptr = workspace;
2376
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
2377
    /* Even part */
2378

2379
    z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
2380
    z1 <<= CONST_BITS;
2381
    /* Add fudge factor here for final descale. */
2382
    z1 += ONE << (CONST_BITS-PASS1_BITS-1);
2383

2384
    z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
2385
    z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
2386
    z4 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
2387

2388
    tmp10 = MULTIPLY(z4, FIX(0.437016024)); /* c12 */
2389
    tmp11 = MULTIPLY(z4, FIX(1.144122806)); /* c6 */
2390

2391
    tmp12 = z1 - tmp10;
2392
    tmp13 = z1 + tmp11;
2393
    z1 -= (tmp11 - tmp10) << 1;             /* c0 = (c6-c12)*2 */
2394

2395
    z4 = z2 - z3;
2396
    z3 += z2;
2397
    tmp10 = MULTIPLY(z3, FIX(1.337628990)); /* (c2+c4)/2 */
2398
    tmp11 = MULTIPLY(z4, FIX(0.045680613)); /* (c2-c4)/2 */
2399
    z2 = MULTIPLY(z2, FIX(1.439773946));    /* c4+c14 */
2400

2401
    tmp20 = tmp13 + tmp10 + tmp11;
2402
    tmp23 = tmp12 - tmp10 + tmp11 + z2;
2403

2404
    tmp10 = MULTIPLY(z3, FIX(0.547059574)); /* (c8+c14)/2 */
2405
    tmp11 = MULTIPLY(z4, FIX(0.399234004)); /* (c8-c14)/2 */
2406

2407
    tmp25 = tmp13 - tmp10 - tmp11;
2408
    tmp26 = tmp12 + tmp10 - tmp11 - z2;
2409

2410
    tmp10 = MULTIPLY(z3, FIX(0.790569415)); /* (c6+c12)/2 */
2411
    tmp11 = MULTIPLY(z4, FIX(0.353553391)); /* (c6-c12)/2 */
2412

2413
    tmp21 = tmp12 + tmp10 + tmp11;
2414
    tmp24 = tmp13 - tmp10 + tmp11;
2415
    tmp11 += tmp11;
2416
    tmp22 = z1 + tmp11;                     /* c10 = c6-c12 */
2417
    tmp27 = z1 - tmp11 - tmp11;             /* c0 = (c6-c12)*2 */
2418

2419
    /* Odd part */
2420

2421
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
2422
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
2423
    z4 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
2424
    z3 = MULTIPLY(z4, FIX(1.224744871));                    /* c5 */
2425
    z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
2426

2427
    tmp13 = z2 - z4;
2428
    tmp15 = MULTIPLY(z1 + tmp13, FIX(0.831253876));         /* c9 */
2429
    tmp11 = tmp15 + MULTIPLY(z1, FIX(0.513743148));         /* c3-c9 */
2430
    tmp14 = tmp15 - MULTIPLY(tmp13, FIX(2.176250899));      /* c3+c9 */
2431

2432
    tmp13 = MULTIPLY(z2, - FIX(0.831253876));               /* -c9 */
2433
    tmp15 = MULTIPLY(z2, - FIX(1.344997024));               /* -c3 */
2434
    z2 = z1 - z4;
2435
    tmp12 = z3 + MULTIPLY(z2, FIX(1.406466353));            /* c1 */
2436

2437
    tmp10 = tmp12 + MULTIPLY(z4, FIX(2.457431844)) - tmp15; /* c1+c7 */
2438
    tmp16 = tmp12 - MULTIPLY(z1, FIX(1.112434820)) + tmp13; /* c1-c13 */
2439
    tmp12 = MULTIPLY(z2, FIX(1.224744871)) - z3;            /* c5 */
2440
    z2 = MULTIPLY(z1 + z4, FIX(0.575212477));               /* c11 */
2441
    tmp13 += z2 + MULTIPLY(z1, FIX(0.475753014)) - z3;      /* c7-c11 */
2442
    tmp15 += z2 - MULTIPLY(z4, FIX(0.869244010)) + z3;      /* c11+c13 */
2443

2444
    /* Final output stage */
2445

2446
    wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
2447
    wsptr[8*14] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
2448
    wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
2449
    wsptr[8*13] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
2450
    wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
2451
    wsptr[8*12] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
2452
    wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
2453
    wsptr[8*11] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
2454
    wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
2455
    wsptr[8*10] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
2456
    wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
2457
    wsptr[8*9]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
2458
    wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS-PASS1_BITS);
2459
    wsptr[8*8]  = (int) RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS-PASS1_BITS);
2460
    wsptr[8*7]  = (int) RIGHT_SHIFT(tmp27, CONST_BITS-PASS1_BITS);
2461
  }
2462

2463
  /* Pass 2: process 15 rows from work array, store into output array. */
2464

2465
  wsptr = workspace;
2466
  for (ctr = 0; ctr < 15; ctr++) {
2467
    outptr = output_buf[ctr] + output_col;
2468

2469
    /* Even part */
2470

2471
    /* Add range center and fudge factor for final descale and range-limit. */
2472
    z1 = (INT32) wsptr[0] +
2473
	   ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
2474
	    (ONE << (PASS1_BITS+2)));
2475
    z1 <<= CONST_BITS;
2476

2477
    z2 = (INT32) wsptr[2];
2478
    z3 = (INT32) wsptr[4];
2479
    z4 = (INT32) wsptr[6];
2480

2481
    tmp10 = MULTIPLY(z4, FIX(0.437016024)); /* c12 */
2482
    tmp11 = MULTIPLY(z4, FIX(1.144122806)); /* c6 */
2483

2484
    tmp12 = z1 - tmp10;
2485
    tmp13 = z1 + tmp11;
2486
    z1 -= (tmp11 - tmp10) << 1;             /* c0 = (c6-c12)*2 */
2487

2488
    z4 = z2 - z3;
2489
    z3 += z2;
2490
    tmp10 = MULTIPLY(z3, FIX(1.337628990)); /* (c2+c4)/2 */
2491
    tmp11 = MULTIPLY(z4, FIX(0.045680613)); /* (c2-c4)/2 */
2492
    z2 = MULTIPLY(z2, FIX(1.439773946));    /* c4+c14 */
2493

2494
    tmp20 = tmp13 + tmp10 + tmp11;
2495
    tmp23 = tmp12 - tmp10 + tmp11 + z2;
2496

2497
    tmp10 = MULTIPLY(z3, FIX(0.547059574)); /* (c8+c14)/2 */
2498
    tmp11 = MULTIPLY(z4, FIX(0.399234004)); /* (c8-c14)/2 */
2499

2500
    tmp25 = tmp13 - tmp10 - tmp11;
2501
    tmp26 = tmp12 + tmp10 - tmp11 - z2;
2502

2503
    tmp10 = MULTIPLY(z3, FIX(0.790569415)); /* (c6+c12)/2 */
2504
    tmp11 = MULTIPLY(z4, FIX(0.353553391)); /* (c6-c12)/2 */
2505

2506
    tmp21 = tmp12 + tmp10 + tmp11;
2507
    tmp24 = tmp13 - tmp10 + tmp11;
2508
    tmp11 += tmp11;
2509
    tmp22 = z1 + tmp11;                     /* c10 = c6-c12 */
2510
    tmp27 = z1 - tmp11 - tmp11;             /* c0 = (c6-c12)*2 */
2511

2512
    /* Odd part */
2513

2514
    z1 = (INT32) wsptr[1];
2515
    z2 = (INT32) wsptr[3];
2516
    z4 = (INT32) wsptr[5];
2517
    z3 = MULTIPLY(z4, FIX(1.224744871));                    /* c5 */
2518
    z4 = (INT32) wsptr[7];
2519

2520
    tmp13 = z2 - z4;
2521
    tmp15 = MULTIPLY(z1 + tmp13, FIX(0.831253876));         /* c9 */
2522
    tmp11 = tmp15 + MULTIPLY(z1, FIX(0.513743148));         /* c3-c9 */
2523
    tmp14 = tmp15 - MULTIPLY(tmp13, FIX(2.176250899));      /* c3+c9 */
2524

2525
    tmp13 = MULTIPLY(z2, - FIX(0.831253876));               /* -c9 */
2526
    tmp15 = MULTIPLY(z2, - FIX(1.344997024));               /* -c3 */
2527
    z2 = z1 - z4;
2528
    tmp12 = z3 + MULTIPLY(z2, FIX(1.406466353));            /* c1 */
2529

2530
    tmp10 = tmp12 + MULTIPLY(z4, FIX(2.457431844)) - tmp15; /* c1+c7 */
2531
    tmp16 = tmp12 - MULTIPLY(z1, FIX(1.112434820)) + tmp13; /* c1-c13 */
2532
    tmp12 = MULTIPLY(z2, FIX(1.224744871)) - z3;            /* c5 */
2533
    z2 = MULTIPLY(z1 + z4, FIX(0.575212477));               /* c11 */
2534
    tmp13 += z2 + MULTIPLY(z1, FIX(0.475753014)) - z3;      /* c7-c11 */
2535
    tmp15 += z2 - MULTIPLY(z4, FIX(0.869244010)) + z3;      /* c11+c13 */
2536

2537
    /* Final output stage */
2538

2539
    outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
2540
					       CONST_BITS+PASS1_BITS+3)
2541
			     & RANGE_MASK];
2542
    outptr[14] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
2543
					       CONST_BITS+PASS1_BITS+3)
2544
			     & RANGE_MASK];
2545
    outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
2546
					       CONST_BITS+PASS1_BITS+3)
2547
			     & RANGE_MASK];
2548
    outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
2549
					       CONST_BITS+PASS1_BITS+3)
2550
			     & RANGE_MASK];
2551
    outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
2552
					       CONST_BITS+PASS1_BITS+3)
2553
			     & RANGE_MASK];
2554
    outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
2555
					       CONST_BITS+PASS1_BITS+3)
2556
			     & RANGE_MASK];
2557
    outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
2558
					       CONST_BITS+PASS1_BITS+3)
2559
			     & RANGE_MASK];
2560
    outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
2561
					       CONST_BITS+PASS1_BITS+3)
2562
			     & RANGE_MASK];
2563
    outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
2564
					       CONST_BITS+PASS1_BITS+3)
2565
			     & RANGE_MASK];
2566
    outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
2567
					       CONST_BITS+PASS1_BITS+3)
2568
			     & RANGE_MASK];
2569
    outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
2570
					       CONST_BITS+PASS1_BITS+3)
2571
			     & RANGE_MASK];
2572
    outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
2573
					       CONST_BITS+PASS1_BITS+3)
2574
			     & RANGE_MASK];
2575
    outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp16,
2576
					       CONST_BITS+PASS1_BITS+3)
2577
			     & RANGE_MASK];
2578
    outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp16,
2579
					       CONST_BITS+PASS1_BITS+3)
2580
			     & RANGE_MASK];
2581
    outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp27,
2582
					       CONST_BITS+PASS1_BITS+3)
2583
			     & RANGE_MASK];
2584

2585
    wsptr += 8;		/* advance pointer to next row */
2586
  }
2587
}
2588

2589

2590
/*
2591
 * Perform dequantization and inverse DCT on one block of coefficients,
2592
 * producing a 16x16 output block.
2593
 *
2594
 * Optimized algorithm with 28 multiplications in the 1-D kernel.
2595
 * cK represents sqrt(2) * cos(K*pi/32).
2596
 */
2597

2598
GLOBAL(void)
2599
jpeg_idct_16x16 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
2600
		 JCOEFPTR coef_block,
2601
		 JSAMPARRAY output_buf, JDIMENSION output_col)
2602
{
2603
  INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
2604
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
2605
  INT32 z1, z2, z3, z4;
2606
  JCOEFPTR inptr;
2607
  ISLOW_MULT_TYPE * quantptr;
2608
  int * wsptr;
2609
  JSAMPROW outptr;
2610
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
2611
  int ctr;
2612
  int workspace[8*16];	/* buffers data between passes */
2613
  SHIFT_TEMPS
2614

2615
  /* Pass 1: process columns from input, store into work array. */
2616

2617
  inptr = coef_block;
2618
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
2619
  wsptr = workspace;
2620
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
2621
    /* Even part */
2622

2623
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
2624
    tmp0 <<= CONST_BITS;
2625
    /* Add fudge factor here for final descale. */
2626
    tmp0 += 1 << (CONST_BITS-PASS1_BITS-1);
2627

2628
    z1 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
2629
    tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
2630
    tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
2631

2632
    tmp10 = tmp0 + tmp1;
2633
    tmp11 = tmp0 - tmp1;
2634
    tmp12 = tmp0 + tmp2;
2635
    tmp13 = tmp0 - tmp2;
2636

2637
    z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
2638
    z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
2639
    z3 = z1 - z2;
2640
    z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
2641
    z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
2642

2643
    tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
2644
    tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
2645
    tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
2646
    tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
2647

2648
    tmp20 = tmp10 + tmp0;
2649
    tmp27 = tmp10 - tmp0;
2650
    tmp21 = tmp12 + tmp1;
2651
    tmp26 = tmp12 - tmp1;
2652
    tmp22 = tmp13 + tmp2;
2653
    tmp25 = tmp13 - tmp2;
2654
    tmp23 = tmp11 + tmp3;
2655
    tmp24 = tmp11 - tmp3;
2656

2657
    /* Odd part */
2658

2659
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
2660
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
2661
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
2662
    z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
2663

2664
    tmp11 = z1 + z3;
2665

2666
    tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
2667
    tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
2668
    tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
2669
    tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
2670
    tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
2671
    tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
2672
    tmp0  = tmp1 + tmp2 + tmp3 -
2673
	    MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
2674
    tmp13 = tmp10 + tmp11 + tmp12 -
2675
	    MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
2676
    z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
2677
    tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
2678
    tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
2679
    z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
2680
    tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
2681
    tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
2682
    z2    += z4;
2683
    z1    = MULTIPLY(z2, - FIX(0.666655658));      /* -c11 */
2684
    tmp1  += z1;
2685
    tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
2686
    z2    = MULTIPLY(z2, - FIX(1.247225013));      /* -c5 */
2687
    tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
2688
    tmp12 += z2;
2689
    z2    = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
2690
    tmp2  += z2;
2691
    tmp3  += z2;
2692
    z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
2693
    tmp10 += z2;
2694
    tmp11 += z2;
2695

2696
    /* Final output stage */
2697

2698
    wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp0,  CONST_BITS-PASS1_BITS);
2699
    wsptr[8*15] = (int) RIGHT_SHIFT(tmp20 - tmp0,  CONST_BITS-PASS1_BITS);
2700
    wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp1,  CONST_BITS-PASS1_BITS);
2701
    wsptr[8*14] = (int) RIGHT_SHIFT(tmp21 - tmp1,  CONST_BITS-PASS1_BITS);
2702
    wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp2,  CONST_BITS-PASS1_BITS);
2703
    wsptr[8*13] = (int) RIGHT_SHIFT(tmp22 - tmp2,  CONST_BITS-PASS1_BITS);
2704
    wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp3,  CONST_BITS-PASS1_BITS);
2705
    wsptr[8*12] = (int) RIGHT_SHIFT(tmp23 - tmp3,  CONST_BITS-PASS1_BITS);
2706
    wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp10, CONST_BITS-PASS1_BITS);
2707
    wsptr[8*11] = (int) RIGHT_SHIFT(tmp24 - tmp10, CONST_BITS-PASS1_BITS);
2708
    wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp11, CONST_BITS-PASS1_BITS);
2709
    wsptr[8*10] = (int) RIGHT_SHIFT(tmp25 - tmp11, CONST_BITS-PASS1_BITS);
2710
    wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26 + tmp12, CONST_BITS-PASS1_BITS);
2711
    wsptr[8*9]  = (int) RIGHT_SHIFT(tmp26 - tmp12, CONST_BITS-PASS1_BITS);
2712
    wsptr[8*7]  = (int) RIGHT_SHIFT(tmp27 + tmp13, CONST_BITS-PASS1_BITS);
2713
    wsptr[8*8]  = (int) RIGHT_SHIFT(tmp27 - tmp13, CONST_BITS-PASS1_BITS);
2714
  }
2715

2716
  /* Pass 2: process 16 rows from work array, store into output array. */
2717

2718
  wsptr = workspace;
2719
  for (ctr = 0; ctr < 16; ctr++) {
2720
    outptr = output_buf[ctr] + output_col;
2721

2722
    /* Even part */
2723

2724
    /* Add range center and fudge factor for final descale and range-limit. */
2725
    tmp0 = (INT32) wsptr[0] +
2726
	     ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
2727
	      (ONE << (PASS1_BITS+2)));
2728
    tmp0 <<= CONST_BITS;
2729

2730
    z1 = (INT32) wsptr[4];
2731
    tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
2732
    tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
2733

2734
    tmp10 = tmp0 + tmp1;
2735
    tmp11 = tmp0 - tmp1;
2736
    tmp12 = tmp0 + tmp2;
2737
    tmp13 = tmp0 - tmp2;
2738

2739
    z1 = (INT32) wsptr[2];
2740
    z2 = (INT32) wsptr[6];
2741
    z3 = z1 - z2;
2742
    z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
2743
    z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
2744

2745
    tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
2746
    tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
2747
    tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
2748
    tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
2749

2750
    tmp20 = tmp10 + tmp0;
2751
    tmp27 = tmp10 - tmp0;
2752
    tmp21 = tmp12 + tmp1;
2753
    tmp26 = tmp12 - tmp1;
2754
    tmp22 = tmp13 + tmp2;
2755
    tmp25 = tmp13 - tmp2;
2756
    tmp23 = tmp11 + tmp3;
2757
    tmp24 = tmp11 - tmp3;
2758

2759
    /* Odd part */
2760

2761
    z1 = (INT32) wsptr[1];
2762
    z2 = (INT32) wsptr[3];
2763
    z3 = (INT32) wsptr[5];
2764
    z4 = (INT32) wsptr[7];
2765

2766
    tmp11 = z1 + z3;
2767

2768
    tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
2769
    tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
2770
    tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
2771
    tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
2772
    tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
2773
    tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
2774
    tmp0  = tmp1 + tmp2 + tmp3 -
2775
	    MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
2776
    tmp13 = tmp10 + tmp11 + tmp12 -
2777
	    MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
2778
    z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
2779
    tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
2780
    tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
2781
    z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
2782
    tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
2783
    tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
2784
    z2    += z4;
2785
    z1    = MULTIPLY(z2, - FIX(0.666655658));      /* -c11 */
2786
    tmp1  += z1;
2787
    tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
2788
    z2    = MULTIPLY(z2, - FIX(1.247225013));      /* -c5 */
2789
    tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
2790
    tmp12 += z2;
2791
    z2    = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
2792
    tmp2  += z2;
2793
    tmp3  += z2;
2794
    z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
2795
    tmp10 += z2;
2796
    tmp11 += z2;
2797

2798
    /* Final output stage */
2799

2800
    outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp0,
2801
					       CONST_BITS+PASS1_BITS+3)
2802
			     & RANGE_MASK];
2803
    outptr[15] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp0,
2804
					       CONST_BITS+PASS1_BITS+3)
2805
			     & RANGE_MASK];
2806
    outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp1,
2807
					       CONST_BITS+PASS1_BITS+3)
2808
			     & RANGE_MASK];
2809
    outptr[14] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp1,
2810
					       CONST_BITS+PASS1_BITS+3)
2811
			     & RANGE_MASK];
2812
    outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp2,
2813
					       CONST_BITS+PASS1_BITS+3)
2814
			     & RANGE_MASK];
2815
    outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp2,
2816
					       CONST_BITS+PASS1_BITS+3)
2817
			     & RANGE_MASK];
2818
    outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp3,
2819
					       CONST_BITS+PASS1_BITS+3)
2820
			     & RANGE_MASK];
2821
    outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp3,
2822
					       CONST_BITS+PASS1_BITS+3)
2823
			     & RANGE_MASK];
2824
    outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp10,
2825
					       CONST_BITS+PASS1_BITS+3)
2826
			     & RANGE_MASK];
2827
    outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp10,
2828
					       CONST_BITS+PASS1_BITS+3)
2829
			     & RANGE_MASK];
2830
    outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp11,
2831
					       CONST_BITS+PASS1_BITS+3)
2832
			     & RANGE_MASK];
2833
    outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp11,
2834
					       CONST_BITS+PASS1_BITS+3)
2835
			     & RANGE_MASK];
2836
    outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp12,
2837
					       CONST_BITS+PASS1_BITS+3)
2838
			     & RANGE_MASK];
2839
    outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp12,
2840
					       CONST_BITS+PASS1_BITS+3)
2841
			     & RANGE_MASK];
2842
    outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp27 + tmp13,
2843
					       CONST_BITS+PASS1_BITS+3)
2844
			     & RANGE_MASK];
2845
    outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp27 - tmp13,
2846
					       CONST_BITS+PASS1_BITS+3)
2847
			     & RANGE_MASK];
2848

2849
    wsptr += 8;		/* advance pointer to next row */
2850
  }
2851
}
2852

2853

2854
/*
2855
 * Perform dequantization and inverse DCT on one block of coefficients,
2856
 * producing a 16x8 output block.
2857
 *
2858
 * 8-point IDCT in pass 1 (columns), 16-point in pass 2 (rows).
2859
 */
2860

2861
GLOBAL(void)
2862
jpeg_idct_16x8 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
2863
		JCOEFPTR coef_block,
2864
		JSAMPARRAY output_buf, JDIMENSION output_col)
2865
{
2866
  INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
2867
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
2868
  INT32 z1, z2, z3, z4;
2869
  JCOEFPTR inptr;
2870
  ISLOW_MULT_TYPE * quantptr;
2871
  int * wsptr;
2872
  JSAMPROW outptr;
2873
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
2874
  int ctr;
2875
  int workspace[8*8];	/* buffers data between passes */
2876
  SHIFT_TEMPS
2877

2878
  /* Pass 1: process columns from input, store into work array.
2879
   * Note results are scaled up by sqrt(8) compared to a true IDCT;
2880
   * furthermore, we scale the results by 2**PASS1_BITS.
2881
   * 8-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
2882
   */
2883

2884
  inptr = coef_block;
2885
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
2886
  wsptr = workspace;
2887
  for (ctr = DCTSIZE; ctr > 0; ctr--) {
2888
    /* Due to quantization, we will usually find that many of the input
2889
     * coefficients are zero, especially the AC terms.  We can exploit this
2890
     * by short-circuiting the IDCT calculation for any column in which all
2891
     * the AC terms are zero.  In that case each output is equal to the
2892
     * DC coefficient (with scale factor as needed).
2893
     * With typical images and quantization tables, half or more of the
2894
     * column DCT calculations can be simplified this way.
2895
     */
2896

2897
    if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
2898
	inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
2899
	inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
2900
	inptr[DCTSIZE*7] == 0) {
2901
      /* AC terms all zero */
2902
      int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
2903

2904
      wsptr[DCTSIZE*0] = dcval;
2905
      wsptr[DCTSIZE*1] = dcval;
2906
      wsptr[DCTSIZE*2] = dcval;
2907
      wsptr[DCTSIZE*3] = dcval;
2908
      wsptr[DCTSIZE*4] = dcval;
2909
      wsptr[DCTSIZE*5] = dcval;
2910
      wsptr[DCTSIZE*6] = dcval;
2911
      wsptr[DCTSIZE*7] = dcval;
2912

2913
      inptr++;			/* advance pointers to next column */
2914
      quantptr++;
2915
      wsptr++;
2916
      continue;
2917
    }
2918

2919
    /* Even part: reverse the even part of the forward DCT.
2920
     * The rotator is c(-6).
2921
     */
2922

2923
    z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
2924
    z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
2925

2926
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
2927
    tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
2928
    tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
2929

2930
    z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
2931
    z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
2932
    z2 <<= CONST_BITS;
2933
    z3 <<= CONST_BITS;
2934
    /* Add fudge factor here for final descale. */
2935
    z2 += ONE << (CONST_BITS-PASS1_BITS-1);
2936

2937
    tmp0 = z2 + z3;
2938
    tmp1 = z2 - z3;
2939

2940
    tmp10 = tmp0 + tmp2;
2941
    tmp13 = tmp0 - tmp2;
2942
    tmp11 = tmp1 + tmp3;
2943
    tmp12 = tmp1 - tmp3;
2944

2945
    /* Odd part per figure 8; the matrix is unitary and hence its
2946
     * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
2947
     */
2948

2949
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
2950
    tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
2951
    tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
2952
    tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
2953

2954
    z2 = tmp0 + tmp2;
2955
    z3 = tmp1 + tmp3;
2956

2957
    z1 = MULTIPLY(z2 + z3, FIX_1_175875602);       /*  c3 */
2958
    z2 = MULTIPLY(z2, - FIX_1_961570560);          /* -c3-c5 */
2959
    z3 = MULTIPLY(z3, - FIX_0_390180644);          /* -c3+c5 */
2960
    z2 += z1;
2961
    z3 += z1;
2962

2963
    z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
2964
    tmp0 = MULTIPLY(tmp0, FIX_0_298631336);        /* -c1+c3+c5-c7 */
2965
    tmp3 = MULTIPLY(tmp3, FIX_1_501321110);        /*  c1+c3-c5-c7 */
2966
    tmp0 += z1 + z2;
2967
    tmp3 += z1 + z3;
2968

2969
    z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
2970
    tmp1 = MULTIPLY(tmp1, FIX_2_053119869);        /*  c1+c3-c5+c7 */
2971
    tmp2 = MULTIPLY(tmp2, FIX_3_072711026);        /*  c1+c3+c5-c7 */
2972
    tmp1 += z1 + z3;
2973
    tmp2 += z1 + z2;
2974

2975
    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
2976

2977
    wsptr[DCTSIZE*0] = (int) RIGHT_SHIFT(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
2978
    wsptr[DCTSIZE*7] = (int) RIGHT_SHIFT(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
2979
    wsptr[DCTSIZE*1] = (int) RIGHT_SHIFT(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
2980
    wsptr[DCTSIZE*6] = (int) RIGHT_SHIFT(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
2981
    wsptr[DCTSIZE*2] = (int) RIGHT_SHIFT(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
2982
    wsptr[DCTSIZE*5] = (int) RIGHT_SHIFT(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
2983
    wsptr[DCTSIZE*3] = (int) RIGHT_SHIFT(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
2984
    wsptr[DCTSIZE*4] = (int) RIGHT_SHIFT(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
2985

2986
    inptr++;			/* advance pointers to next column */
2987
    quantptr++;
2988
    wsptr++;
2989
  }
2990

2991
  /* Pass 2: process 8 rows from work array, store into output array.
2992
   * 16-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/32).
2993
   */
2994

2995
  wsptr = workspace;
2996
  for (ctr = 0; ctr < 8; ctr++) {
2997
    outptr = output_buf[ctr] + output_col;
2998

2999
    /* Even part */
3000

3001
    /* Add range center and fudge factor for final descale and range-limit. */
3002
    tmp0 = (INT32) wsptr[0] +
3003
	     ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
3004
	      (ONE << (PASS1_BITS+2)));
3005
    tmp0 <<= CONST_BITS;
3006

3007
    z1 = (INT32) wsptr[4];
3008
    tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
3009
    tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
3010

3011
    tmp10 = tmp0 + tmp1;
3012
    tmp11 = tmp0 - tmp1;
3013
    tmp12 = tmp0 + tmp2;
3014
    tmp13 = tmp0 - tmp2;
3015

3016
    z1 = (INT32) wsptr[2];
3017
    z2 = (INT32) wsptr[6];
3018
    z3 = z1 - z2;
3019
    z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
3020
    z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
3021

3022
    tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
3023
    tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
3024
    tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
3025
    tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
3026

3027
    tmp20 = tmp10 + tmp0;
3028
    tmp27 = tmp10 - tmp0;
3029
    tmp21 = tmp12 + tmp1;
3030
    tmp26 = tmp12 - tmp1;
3031
    tmp22 = tmp13 + tmp2;
3032
    tmp25 = tmp13 - tmp2;
3033
    tmp23 = tmp11 + tmp3;
3034
    tmp24 = tmp11 - tmp3;
3035

3036
    /* Odd part */
3037

3038
    z1 = (INT32) wsptr[1];
3039
    z2 = (INT32) wsptr[3];
3040
    z3 = (INT32) wsptr[5];
3041
    z4 = (INT32) wsptr[7];
3042

3043
    tmp11 = z1 + z3;
3044

3045
    tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
3046
    tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
3047
    tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
3048
    tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
3049
    tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
3050
    tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
3051
    tmp0  = tmp1 + tmp2 + tmp3 -
3052
	    MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
3053
    tmp13 = tmp10 + tmp11 + tmp12 -
3054
	    MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
3055
    z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
3056
    tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
3057
    tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
3058
    z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
3059
    tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
3060
    tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
3061
    z2    += z4;
3062
    z1    = MULTIPLY(z2, - FIX(0.666655658));      /* -c11 */
3063
    tmp1  += z1;
3064
    tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
3065
    z2    = MULTIPLY(z2, - FIX(1.247225013));      /* -c5 */
3066
    tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
3067
    tmp12 += z2;
3068
    z2    = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
3069
    tmp2  += z2;
3070
    tmp3  += z2;
3071
    z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
3072
    tmp10 += z2;
3073
    tmp11 += z2;
3074

3075
    /* Final output stage */
3076

3077
    outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp0,
3078
					       CONST_BITS+PASS1_BITS+3)
3079
			     & RANGE_MASK];
3080
    outptr[15] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp0,
3081
					       CONST_BITS+PASS1_BITS+3)
3082
			     & RANGE_MASK];
3083
    outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp1,
3084
					       CONST_BITS+PASS1_BITS+3)
3085
			     & RANGE_MASK];
3086
    outptr[14] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp1,
3087
					       CONST_BITS+PASS1_BITS+3)
3088
			     & RANGE_MASK];
3089
    outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp2,
3090
					       CONST_BITS+PASS1_BITS+3)
3091
			     & RANGE_MASK];
3092
    outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp2,
3093
					       CONST_BITS+PASS1_BITS+3)
3094
			     & RANGE_MASK];
3095
    outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp3,
3096
					       CONST_BITS+PASS1_BITS+3)
3097
			     & RANGE_MASK];
3098
    outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp3,
3099
					       CONST_BITS+PASS1_BITS+3)
3100
			     & RANGE_MASK];
3101
    outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp10,
3102
					       CONST_BITS+PASS1_BITS+3)
3103
			     & RANGE_MASK];
3104
    outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp10,
3105
					       CONST_BITS+PASS1_BITS+3)
3106
			     & RANGE_MASK];
3107
    outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp11,
3108
					       CONST_BITS+PASS1_BITS+3)
3109
			     & RANGE_MASK];
3110
    outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp11,
3111
					       CONST_BITS+PASS1_BITS+3)
3112
			     & RANGE_MASK];
3113
    outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp12,
3114
					       CONST_BITS+PASS1_BITS+3)
3115
			     & RANGE_MASK];
3116
    outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp12,
3117
					       CONST_BITS+PASS1_BITS+3)
3118
			     & RANGE_MASK];
3119
    outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp27 + tmp13,
3120
					       CONST_BITS+PASS1_BITS+3)
3121
			     & RANGE_MASK];
3122
    outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp27 - tmp13,
3123
					       CONST_BITS+PASS1_BITS+3)
3124
			     & RANGE_MASK];
3125

3126
    wsptr += 8;		/* advance pointer to next row */
3127
  }
3128
}
3129

3130

3131
/*
3132
 * Perform dequantization and inverse DCT on one block of coefficients,
3133
 * producing a 14x7 output block.
3134
 *
3135
 * 7-point IDCT in pass 1 (columns), 14-point in pass 2 (rows).
3136
 */
3137

3138
GLOBAL(void)
3139
jpeg_idct_14x7 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
3140
		JCOEFPTR coef_block,
3141
		JSAMPARRAY output_buf, JDIMENSION output_col)
3142
{
3143
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
3144
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
3145
  INT32 z1, z2, z3, z4;
3146
  JCOEFPTR inptr;
3147
  ISLOW_MULT_TYPE * quantptr;
3148
  int * wsptr;
3149
  JSAMPROW outptr;
3150
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
3151
  int ctr;
3152
  int workspace[8*7];	/* buffers data between passes */
3153
  SHIFT_TEMPS
3154

3155
  /* Pass 1: process columns from input, store into work array.
3156
   * 7-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/14).
3157
   */
3158

3159
  inptr = coef_block;
3160
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
3161
  wsptr = workspace;
3162
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
3163
    /* Even part */
3164

3165
    tmp23 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
3166
    tmp23 <<= CONST_BITS;
3167
    /* Add fudge factor here for final descale. */
3168
    tmp23 += ONE << (CONST_BITS-PASS1_BITS-1);
3169

3170
    z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
3171
    z2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
3172
    z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
3173

3174
    tmp20 = MULTIPLY(z2 - z3, FIX(0.881747734));       /* c4 */
3175
    tmp22 = MULTIPLY(z1 - z2, FIX(0.314692123));       /* c6 */
3176
    tmp21 = tmp20 + tmp22 + tmp23 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
3177
    tmp10 = z1 + z3;
3178
    z2 -= tmp10;
3179
    tmp10 = MULTIPLY(tmp10, FIX(1.274162392)) + tmp23; /* c2 */
3180
    tmp20 += tmp10 - MULTIPLY(z3, FIX(0.077722536));   /* c2-c4-c6 */
3181
    tmp22 += tmp10 - MULTIPLY(z1, FIX(2.470602249));   /* c2+c4+c6 */
3182
    tmp23 += MULTIPLY(z2, FIX(1.414213562));           /* c0 */
3183

3184
    /* Odd part */
3185

3186
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
3187
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
3188
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
3189

3190
    tmp11 = MULTIPLY(z1 + z2, FIX(0.935414347));       /* (c3+c1-c5)/2 */
3191
    tmp12 = MULTIPLY(z1 - z2, FIX(0.170262339));       /* (c3+c5-c1)/2 */
3192
    tmp10 = tmp11 - tmp12;
3193
    tmp11 += tmp12;
3194
    tmp12 = MULTIPLY(z2 + z3, - FIX(1.378756276));     /* -c1 */
3195
    tmp11 += tmp12;
3196
    z2 = MULTIPLY(z1 + z3, FIX(0.613604268));          /* c5 */
3197
    tmp10 += z2;
3198
    tmp12 += z2 + MULTIPLY(z3, FIX(1.870828693));      /* c3+c1-c5 */
3199

3200
    /* Final output stage */
3201

3202
    wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
3203
    wsptr[8*6] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
3204
    wsptr[8*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
3205
    wsptr[8*5] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
3206
    wsptr[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
3207
    wsptr[8*4] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
3208
    wsptr[8*3] = (int) RIGHT_SHIFT(tmp23, CONST_BITS-PASS1_BITS);
3209
  }
3210

3211
  /* Pass 2: process 7 rows from work array, store into output array.
3212
   * 14-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/28).
3213
   */
3214

3215
  wsptr = workspace;
3216
  for (ctr = 0; ctr < 7; ctr++) {
3217
    outptr = output_buf[ctr] + output_col;
3218

3219
    /* Even part */
3220

3221
    /* Add range center and fudge factor for final descale and range-limit. */
3222
    z1 = (INT32) wsptr[0] +
3223
	   ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
3224
	    (ONE << (PASS1_BITS+2)));
3225
    z1 <<= CONST_BITS;
3226
    z4 = (INT32) wsptr[4];
3227
    z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
3228
    z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
3229
    z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
3230

3231
    tmp10 = z1 + z2;
3232
    tmp11 = z1 + z3;
3233
    tmp12 = z1 - z4;
3234

3235
    tmp23 = z1 - ((z2 + z3 - z4) << 1);          /* c0 = (c4+c12-c8)*2 */
3236

3237
    z1 = (INT32) wsptr[2];
3238
    z2 = (INT32) wsptr[6];
3239

3240
    z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
3241

3242
    tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
3243
    tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
3244
    tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
3245
	    MULTIPLY(z2, FIX(1.378756276));      /* c2 */
3246

3247
    tmp20 = tmp10 + tmp13;
3248
    tmp26 = tmp10 - tmp13;
3249
    tmp21 = tmp11 + tmp14;
3250
    tmp25 = tmp11 - tmp14;
3251
    tmp22 = tmp12 + tmp15;
3252
    tmp24 = tmp12 - tmp15;
3253

3254
    /* Odd part */
3255

3256
    z1 = (INT32) wsptr[1];
3257
    z2 = (INT32) wsptr[3];
3258
    z3 = (INT32) wsptr[5];
3259
    z4 = (INT32) wsptr[7];
3260
    z4 <<= CONST_BITS;
3261

3262
    tmp14 = z1 + z3;
3263
    tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
3264
    tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
3265
    tmp10 = tmp11 + tmp12 + z4 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
3266
    tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
3267
    tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
3268
    z1    -= z2;
3269
    tmp15 = MULTIPLY(z1, FIX(0.467085129)) - z4;           /* c11 */
3270
    tmp16 += tmp15;
3271
    tmp13 = MULTIPLY(z2 + z3, - FIX(0.158341681)) - z4;    /* -c13 */
3272
    tmp11 += tmp13 - MULTIPLY(z2, FIX(0.424103948));       /* c3-c9-c13 */
3273
    tmp12 += tmp13 - MULTIPLY(z3, FIX(2.373959773));       /* c3+c5-c13 */
3274
    tmp13 = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
3275
    tmp14 += tmp13 + z4 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
3276
    tmp15 += tmp13 + MULTIPLY(z2, FIX(0.674957567));       /* c1+c11-c5 */
3277

3278
    tmp13 = ((z1 - z3) << CONST_BITS) + z4;
3279

3280
    /* Final output stage */
3281

3282
    outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
3283
					       CONST_BITS+PASS1_BITS+3)
3284
			     & RANGE_MASK];
3285
    outptr[13] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
3286
					       CONST_BITS+PASS1_BITS+3)
3287
			     & RANGE_MASK];
3288
    outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
3289
					       CONST_BITS+PASS1_BITS+3)
3290
			     & RANGE_MASK];
3291
    outptr[12] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
3292
					       CONST_BITS+PASS1_BITS+3)
3293
			     & RANGE_MASK];
3294
    outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
3295
					       CONST_BITS+PASS1_BITS+3)
3296
			     & RANGE_MASK];
3297
    outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
3298
					       CONST_BITS+PASS1_BITS+3)
3299
			     & RANGE_MASK];
3300
    outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
3301
					       CONST_BITS+PASS1_BITS+3)
3302
			     & RANGE_MASK];
3303
    outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
3304
					       CONST_BITS+PASS1_BITS+3)
3305
			     & RANGE_MASK];
3306
    outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
3307
					       CONST_BITS+PASS1_BITS+3)
3308
			     & RANGE_MASK];
3309
    outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
3310
					       CONST_BITS+PASS1_BITS+3)
3311
			     & RANGE_MASK];
3312
    outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
3313
					       CONST_BITS+PASS1_BITS+3)
3314
			     & RANGE_MASK];
3315
    outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
3316
					       CONST_BITS+PASS1_BITS+3)
3317
			     & RANGE_MASK];
3318
    outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp26 + tmp16,
3319
					       CONST_BITS+PASS1_BITS+3)
3320
			     & RANGE_MASK];
3321
    outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp26 - tmp16,
3322
					       CONST_BITS+PASS1_BITS+3)
3323
			     & RANGE_MASK];
3324

3325
    wsptr += 8;		/* advance pointer to next row */
3326
  }
3327
}
3328

3329

3330
/*
3331
 * Perform dequantization and inverse DCT on one block of coefficients,
3332
 * producing a 12x6 output block.
3333
 *
3334
 * 6-point IDCT in pass 1 (columns), 12-point in pass 2 (rows).
3335
 */
3336

3337
GLOBAL(void)
3338
jpeg_idct_12x6 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
3339
		JCOEFPTR coef_block,
3340
		JSAMPARRAY output_buf, JDIMENSION output_col)
3341
{
3342
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
3343
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
3344
  INT32 z1, z2, z3, z4;
3345
  JCOEFPTR inptr;
3346
  ISLOW_MULT_TYPE * quantptr;
3347
  int * wsptr;
3348
  JSAMPROW outptr;
3349
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
3350
  int ctr;
3351
  int workspace[8*6];	/* buffers data between passes */
3352
  SHIFT_TEMPS
3353

3354
  /* Pass 1: process columns from input, store into work array.
3355
   * 6-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
3356
   */
3357

3358
  inptr = coef_block;
3359
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
3360
  wsptr = workspace;
3361
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
3362
    /* Even part */
3363

3364
    tmp10 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
3365
    tmp10 <<= CONST_BITS;
3366
    /* Add fudge factor here for final descale. */
3367
    tmp10 += ONE << (CONST_BITS-PASS1_BITS-1);
3368
    tmp12 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
3369
    tmp20 = MULTIPLY(tmp12, FIX(0.707106781));   /* c4 */
3370
    tmp11 = tmp10 + tmp20;
3371
    tmp21 = RIGHT_SHIFT(tmp10 - tmp20 - tmp20, CONST_BITS-PASS1_BITS);
3372
    tmp20 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
3373
    tmp10 = MULTIPLY(tmp20, FIX(1.224744871));   /* c2 */
3374
    tmp20 = tmp11 + tmp10;
3375
    tmp22 = tmp11 - tmp10;
3376

3377
    /* Odd part */
3378

3379
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
3380
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
3381
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
3382
    tmp11 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
3383
    tmp10 = tmp11 + ((z1 + z2) << CONST_BITS);
3384
    tmp12 = tmp11 + ((z3 - z2) << CONST_BITS);
3385
    tmp11 = (z1 - z2 - z3) << PASS1_BITS;
3386

3387
    /* Final output stage */
3388

3389
    wsptr[8*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
3390
    wsptr[8*5] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
3391
    wsptr[8*1] = (int) (tmp21 + tmp11);
3392
    wsptr[8*4] = (int) (tmp21 - tmp11);
3393
    wsptr[8*2] = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
3394
    wsptr[8*3] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
3395
  }
3396

3397
  /* Pass 2: process 6 rows from work array, store into output array.
3398
   * 12-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/24).
3399
   */
3400

3401
  wsptr = workspace;
3402
  for (ctr = 0; ctr < 6; ctr++) {
3403
    outptr = output_buf[ctr] + output_col;
3404

3405
    /* Even part */
3406

3407
    /* Add range center and fudge factor for final descale and range-limit. */
3408
    z3 = (INT32) wsptr[0] +
3409
	   ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
3410
	    (ONE << (PASS1_BITS+2)));
3411
    z3 <<= CONST_BITS;
3412

3413
    z4 = (INT32) wsptr[4];
3414
    z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
3415

3416
    tmp10 = z3 + z4;
3417
    tmp11 = z3 - z4;
3418

3419
    z1 = (INT32) wsptr[2];
3420
    z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
3421
    z1 <<= CONST_BITS;
3422
    z2 = (INT32) wsptr[6];
3423
    z2 <<= CONST_BITS;
3424

3425
    tmp12 = z1 - z2;
3426

3427
    tmp21 = z3 + tmp12;
3428
    tmp24 = z3 - tmp12;
3429

3430
    tmp12 = z4 + z2;
3431

3432
    tmp20 = tmp10 + tmp12;
3433
    tmp25 = tmp10 - tmp12;
3434

3435
    tmp12 = z4 - z1 - z2;
3436

3437
    tmp22 = tmp11 + tmp12;
3438
    tmp23 = tmp11 - tmp12;
3439

3440
    /* Odd part */
3441

3442
    z1 = (INT32) wsptr[1];
3443
    z2 = (INT32) wsptr[3];
3444
    z3 = (INT32) wsptr[5];
3445
    z4 = (INT32) wsptr[7];
3446

3447
    tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
3448
    tmp14 = MULTIPLY(z2, - FIX_0_541196100);                 /* -c9 */
3449

3450
    tmp10 = z1 + z3;
3451
    tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
3452
    tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
3453
    tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
3454
    tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580));           /* -(c7+c11) */
3455
    tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
3456
    tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
3457
    tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
3458
	     MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
3459

3460
    z1 -= z4;
3461
    z2 -= z3;
3462
    z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
3463
    tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
3464
    tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
3465

3466
    /* Final output stage */
3467

3468
    outptr[0]  = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
3469
					       CONST_BITS+PASS1_BITS+3)
3470
			     & RANGE_MASK];
3471
    outptr[11] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
3472
					       CONST_BITS+PASS1_BITS+3)
3473
			     & RANGE_MASK];
3474
    outptr[1]  = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
3475
					       CONST_BITS+PASS1_BITS+3)
3476
			     & RANGE_MASK];
3477
    outptr[10] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
3478
					       CONST_BITS+PASS1_BITS+3)
3479
			     & RANGE_MASK];
3480
    outptr[2]  = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
3481
					       CONST_BITS+PASS1_BITS+3)
3482
			     & RANGE_MASK];
3483
    outptr[9]  = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
3484
					       CONST_BITS+PASS1_BITS+3)
3485
			     & RANGE_MASK];
3486
    outptr[3]  = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
3487
					       CONST_BITS+PASS1_BITS+3)
3488
			     & RANGE_MASK];
3489
    outptr[8]  = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
3490
					       CONST_BITS+PASS1_BITS+3)
3491
			     & RANGE_MASK];
3492
    outptr[4]  = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
3493
					       CONST_BITS+PASS1_BITS+3)
3494
			     & RANGE_MASK];
3495
    outptr[7]  = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
3496
					       CONST_BITS+PASS1_BITS+3)
3497
			     & RANGE_MASK];
3498
    outptr[5]  = range_limit[(int) RIGHT_SHIFT(tmp25 + tmp15,
3499
					       CONST_BITS+PASS1_BITS+3)
3500
			     & RANGE_MASK];
3501
    outptr[6]  = range_limit[(int) RIGHT_SHIFT(tmp25 - tmp15,
3502
					       CONST_BITS+PASS1_BITS+3)
3503
			     & RANGE_MASK];
3504

3505
    wsptr += 8;		/* advance pointer to next row */
3506
  }
3507
}
3508

3509

3510
/*
3511
 * Perform dequantization and inverse DCT on one block of coefficients,
3512
 * producing a 10x5 output block.
3513
 *
3514
 * 5-point IDCT in pass 1 (columns), 10-point in pass 2 (rows).
3515
 */
3516

3517
GLOBAL(void)
3518
jpeg_idct_10x5 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
3519
		JCOEFPTR coef_block,
3520
		JSAMPARRAY output_buf, JDIMENSION output_col)
3521
{
3522
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
3523
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24;
3524
  INT32 z1, z2, z3, z4;
3525
  JCOEFPTR inptr;
3526
  ISLOW_MULT_TYPE * quantptr;
3527
  int * wsptr;
3528
  JSAMPROW outptr;
3529
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
3530
  int ctr;
3531
  int workspace[8*5];	/* buffers data between passes */
3532
  SHIFT_TEMPS
3533

3534
  /* Pass 1: process columns from input, store into work array.
3535
   * 5-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/10).
3536
   */
3537

3538
  inptr = coef_block;
3539
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
3540
  wsptr = workspace;
3541
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
3542
    /* Even part */
3543

3544
    tmp12 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
3545
    tmp12 <<= CONST_BITS;
3546
    /* Add fudge factor here for final descale. */
3547
    tmp12 += ONE << (CONST_BITS-PASS1_BITS-1);
3548
    tmp13 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
3549
    tmp14 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
3550
    z1 = MULTIPLY(tmp13 + tmp14, FIX(0.790569415)); /* (c2+c4)/2 */
3551
    z2 = MULTIPLY(tmp13 - tmp14, FIX(0.353553391)); /* (c2-c4)/2 */
3552
    z3 = tmp12 + z2;
3553
    tmp10 = z3 + z1;
3554
    tmp11 = z3 - z1;
3555
    tmp12 -= z2 << 2;
3556

3557
    /* Odd part */
3558

3559
    z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
3560
    z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
3561

3562
    z1 = MULTIPLY(z2 + z3, FIX(0.831253876));       /* c3 */
3563
    tmp13 = z1 + MULTIPLY(z2, FIX(0.513743148));    /* c1-c3 */
3564
    tmp14 = z1 - MULTIPLY(z3, FIX(2.176250899));    /* c1+c3 */
3565

3566
    /* Final output stage */
3567

3568
    wsptr[8*0] = (int) RIGHT_SHIFT(tmp10 + tmp13, CONST_BITS-PASS1_BITS);
3569
    wsptr[8*4] = (int) RIGHT_SHIFT(tmp10 - tmp13, CONST_BITS-PASS1_BITS);
3570
    wsptr[8*1] = (int) RIGHT_SHIFT(tmp11 + tmp14, CONST_BITS-PASS1_BITS);
3571
    wsptr[8*3] = (int) RIGHT_SHIFT(tmp11 - tmp14, CONST_BITS-PASS1_BITS);
3572
    wsptr[8*2] = (int) RIGHT_SHIFT(tmp12, CONST_BITS-PASS1_BITS);
3573
  }
3574

3575
  /* Pass 2: process 5 rows from work array, store into output array.
3576
   * 10-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/20).
3577
   */
3578

3579
  wsptr = workspace;
3580
  for (ctr = 0; ctr < 5; ctr++) {
3581
    outptr = output_buf[ctr] + output_col;
3582

3583
    /* Even part */
3584

3585
    /* Add range center and fudge factor for final descale and range-limit. */
3586
    z3 = (INT32) wsptr[0] +
3587
	   ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
3588
	    (ONE << (PASS1_BITS+2)));
3589
    z3 <<= CONST_BITS;
3590
    z4 = (INT32) wsptr[4];
3591
    z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
3592
    z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
3593
    tmp10 = z3 + z1;
3594
    tmp11 = z3 - z2;
3595

3596
    tmp22 = z3 - ((z1 - z2) << 1);               /* c0 = (c4-c8)*2 */
3597

3598
    z2 = (INT32) wsptr[2];
3599
    z3 = (INT32) wsptr[6];
3600

3601
    z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
3602
    tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
3603
    tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
3604

3605
    tmp20 = tmp10 + tmp12;
3606
    tmp24 = tmp10 - tmp12;
3607
    tmp21 = tmp11 + tmp13;
3608
    tmp23 = tmp11 - tmp13;
3609

3610
    /* Odd part */
3611

3612
    z1 = (INT32) wsptr[1];
3613
    z2 = (INT32) wsptr[3];
3614
    z3 = (INT32) wsptr[5];
3615
    z3 <<= CONST_BITS;
3616
    z4 = (INT32) wsptr[7];
3617

3618
    tmp11 = z2 + z4;
3619
    tmp13 = z2 - z4;
3620

3621
    tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
3622

3623
    z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
3624
    z4 = z3 + tmp12;
3625

3626
    tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
3627
    tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
3628

3629
    z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
3630
    z4 = z3 - tmp12 - (tmp13 << (CONST_BITS - 1));
3631

3632
    tmp12 = ((z1 - tmp13) << CONST_BITS) - z3;
3633

3634
    tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
3635
    tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
3636

3637
    /* Final output stage */
3638

3639
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
3640
					      CONST_BITS+PASS1_BITS+3)
3641
			    & RANGE_MASK];
3642
    outptr[9] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
3643
					      CONST_BITS+PASS1_BITS+3)
3644
			    & RANGE_MASK];
3645
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
3646
					      CONST_BITS+PASS1_BITS+3)
3647
			    & RANGE_MASK];
3648
    outptr[8] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
3649
					      CONST_BITS+PASS1_BITS+3)
3650
			    & RANGE_MASK];
3651
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
3652
					      CONST_BITS+PASS1_BITS+3)
3653
			    & RANGE_MASK];
3654
    outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
3655
					      CONST_BITS+PASS1_BITS+3)
3656
			    & RANGE_MASK];
3657
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23 + tmp13,
3658
					      CONST_BITS+PASS1_BITS+3)
3659
			    & RANGE_MASK];
3660
    outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp23 - tmp13,
3661
					      CONST_BITS+PASS1_BITS+3)
3662
			    & RANGE_MASK];
3663
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp24 + tmp14,
3664
					      CONST_BITS+PASS1_BITS+3)
3665
			    & RANGE_MASK];
3666
    outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp24 - tmp14,
3667
					      CONST_BITS+PASS1_BITS+3)
3668
			    & RANGE_MASK];
3669

3670
    wsptr += 8;		/* advance pointer to next row */
3671
  }
3672
}
3673

3674

3675
/*
3676
 * Perform dequantization and inverse DCT on one block of coefficients,
3677
 * producing a 8x4 output block.
3678
 *
3679
 * 4-point IDCT in pass 1 (columns), 8-point in pass 2 (rows).
3680
 */
3681

3682
GLOBAL(void)
3683
jpeg_idct_8x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
3684
	       JCOEFPTR coef_block,
3685
	       JSAMPARRAY output_buf, JDIMENSION output_col)
3686
{
3687
  INT32 tmp0, tmp1, tmp2, tmp3;
3688
  INT32 tmp10, tmp11, tmp12, tmp13;
3689
  INT32 z1, z2, z3;
3690
  JCOEFPTR inptr;
3691
  ISLOW_MULT_TYPE * quantptr;
3692
  int * wsptr;
3693
  JSAMPROW outptr;
3694
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
3695
  int ctr;
3696
  int workspace[8*4];	/* buffers data between passes */
3697
  SHIFT_TEMPS
3698

3699
  /* Pass 1: process columns from input, store into work array.
3700
   * 4-point IDCT kernel,
3701
   * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
3702
   */
3703

3704
  inptr = coef_block;
3705
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
3706
  wsptr = workspace;
3707
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
3708
    /* Even part */
3709

3710
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
3711
    tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
3712

3713
    tmp10 = (tmp0 + tmp2) << PASS1_BITS;
3714
    tmp12 = (tmp0 - tmp2) << PASS1_BITS;
3715

3716
    /* Odd part */
3717
    /* Same rotation as in the even part of the 8x8 LL&M IDCT */
3718

3719
    z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
3720
    z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
3721

3722
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);               /* c6 */
3723
    /* Add fudge factor here for final descale. */
3724
    z1 += ONE << (CONST_BITS-PASS1_BITS-1);
3725
    tmp0 = RIGHT_SHIFT(z1 + MULTIPLY(z2, FIX_0_765366865), /* c2-c6 */
3726
		       CONST_BITS-PASS1_BITS);
3727
    tmp2 = RIGHT_SHIFT(z1 - MULTIPLY(z3, FIX_1_847759065), /* c2+c6 */
3728
		       CONST_BITS-PASS1_BITS);
3729

3730
    /* Final output stage */
3731

3732
    wsptr[8*0] = (int) (tmp10 + tmp0);
3733
    wsptr[8*3] = (int) (tmp10 - tmp0);
3734
    wsptr[8*1] = (int) (tmp12 + tmp2);
3735
    wsptr[8*2] = (int) (tmp12 - tmp2);
3736
  }
3737

3738
  /* Pass 2: process rows from work array, store into output array.
3739
   * Note that we must descale the results by a factor of 8 == 2**3,
3740
   * and also undo the PASS1_BITS scaling.
3741
   * 8-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
3742
   */
3743

3744
  wsptr = workspace;
3745
  for (ctr = 0; ctr < 4; ctr++) {
3746
    outptr = output_buf[ctr] + output_col;
3747

3748
    /* Even part: reverse the even part of the forward DCT.
3749
     * The rotator is c(-6).
3750
     */
3751

3752
    /* Add range center and fudge factor for final descale and range-limit. */
3753
    z2 = (INT32) wsptr[0] +
3754
	   ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
3755
	    (ONE << (PASS1_BITS+2)));
3756
    z3 = (INT32) wsptr[4];
3757

3758
    tmp0 = (z2 + z3) << CONST_BITS;
3759
    tmp1 = (z2 - z3) << CONST_BITS;
3760

3761
    z2 = (INT32) wsptr[2];
3762
    z3 = (INT32) wsptr[6];
3763

3764
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
3765
    tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
3766
    tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
3767

3768
    tmp10 = tmp0 + tmp2;
3769
    tmp13 = tmp0 - tmp2;
3770
    tmp11 = tmp1 + tmp3;
3771
    tmp12 = tmp1 - tmp3;
3772

3773
    /* Odd part per figure 8; the matrix is unitary and hence its
3774
     * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
3775
     */
3776

3777
    tmp0 = (INT32) wsptr[7];
3778
    tmp1 = (INT32) wsptr[5];
3779
    tmp2 = (INT32) wsptr[3];
3780
    tmp3 = (INT32) wsptr[1];
3781

3782
    z2 = tmp0 + tmp2;
3783
    z3 = tmp1 + tmp3;
3784

3785
    z1 = MULTIPLY(z2 + z3, FIX_1_175875602);       /*  c3 */
3786
    z2 = MULTIPLY(z2, - FIX_1_961570560);          /* -c3-c5 */
3787
    z3 = MULTIPLY(z3, - FIX_0_390180644);          /* -c3+c5 */
3788
    z2 += z1;
3789
    z3 += z1;
3790

3791
    z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
3792
    tmp0 = MULTIPLY(tmp0, FIX_0_298631336);        /* -c1+c3+c5-c7 */
3793
    tmp3 = MULTIPLY(tmp3, FIX_1_501321110);        /*  c1+c3-c5-c7 */
3794
    tmp0 += z1 + z2;
3795
    tmp3 += z1 + z3;
3796

3797
    z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
3798
    tmp1 = MULTIPLY(tmp1, FIX_2_053119869);        /*  c1+c3-c5+c7 */
3799
    tmp2 = MULTIPLY(tmp2, FIX_3_072711026);        /*  c1+c3+c5-c7 */
3800
    tmp1 += z1 + z3;
3801
    tmp2 += z1 + z2;
3802

3803
    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
3804

3805
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp3,
3806
					      CONST_BITS+PASS1_BITS+3)
3807
			    & RANGE_MASK];
3808
    outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp3,
3809
					      CONST_BITS+PASS1_BITS+3)
3810
			    & RANGE_MASK];
3811
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp2,
3812
					      CONST_BITS+PASS1_BITS+3)
3813
			    & RANGE_MASK];
3814
    outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp2,
3815
					      CONST_BITS+PASS1_BITS+3)
3816
			    & RANGE_MASK];
3817
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp1,
3818
					      CONST_BITS+PASS1_BITS+3)
3819
			    & RANGE_MASK];
3820
    outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp1,
3821
					      CONST_BITS+PASS1_BITS+3)
3822
			    & RANGE_MASK];
3823
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp0,
3824
					      CONST_BITS+PASS1_BITS+3)
3825
			    & RANGE_MASK];
3826
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp0,
3827
					      CONST_BITS+PASS1_BITS+3)
3828
			    & RANGE_MASK];
3829

3830
    wsptr += DCTSIZE;		/* advance pointer to next row */
3831
  }
3832
}
3833

3834

3835
/*
3836
 * Perform dequantization and inverse DCT on one block of coefficients,
3837
 * producing a reduced-size 6x3 output block.
3838
 *
3839
 * 3-point IDCT in pass 1 (columns), 6-point in pass 2 (rows).
3840
 */
3841

3842
GLOBAL(void)
3843
jpeg_idct_6x3 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
3844
	       JCOEFPTR coef_block,
3845
	       JSAMPARRAY output_buf, JDIMENSION output_col)
3846
{
3847
  INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12;
3848
  INT32 z1, z2, z3;
3849
  JCOEFPTR inptr;
3850
  ISLOW_MULT_TYPE * quantptr;
3851
  int * wsptr;
3852
  JSAMPROW outptr;
3853
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
3854
  int ctr;
3855
  int workspace[6*3];	/* buffers data between passes */
3856
  SHIFT_TEMPS
3857

3858
  /* Pass 1: process columns from input, store into work array.
3859
   * 3-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/6).
3860
   */
3861

3862
  inptr = coef_block;
3863
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
3864
  wsptr = workspace;
3865
  for (ctr = 0; ctr < 6; ctr++, inptr++, quantptr++, wsptr++) {
3866
    /* Even part */
3867

3868
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
3869
    tmp0 <<= CONST_BITS;
3870
    /* Add fudge factor here for final descale. */
3871
    tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
3872
    tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
3873
    tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
3874
    tmp10 = tmp0 + tmp12;
3875
    tmp2 = tmp0 - tmp12 - tmp12;
3876

3877
    /* Odd part */
3878

3879
    tmp12 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
3880
    tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
3881

3882
    /* Final output stage */
3883

3884
    wsptr[6*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
3885
    wsptr[6*2] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
3886
    wsptr[6*1] = (int) RIGHT_SHIFT(tmp2, CONST_BITS-PASS1_BITS);
3887
  }
3888
  
3889
  /* Pass 2: process 3 rows from work array, store into output array.
3890
   * 6-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
3891
   */
3892

3893
  wsptr = workspace;
3894
  for (ctr = 0; ctr < 3; ctr++) {
3895
    outptr = output_buf[ctr] + output_col;
3896

3897
    /* Even part */
3898

3899
    /* Add range center and fudge factor for final descale and range-limit. */
3900
    tmp0 = (INT32) wsptr[0] +
3901
	     ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
3902
	      (ONE << (PASS1_BITS+2)));
3903
    tmp0 <<= CONST_BITS;
3904
    tmp2 = (INT32) wsptr[4];
3905
    tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
3906
    tmp1 = tmp0 + tmp10;
3907
    tmp11 = tmp0 - tmp10 - tmp10;
3908
    tmp10 = (INT32) wsptr[2];
3909
    tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
3910
    tmp10 = tmp1 + tmp0;
3911
    tmp12 = tmp1 - tmp0;
3912

3913
    /* Odd part */
3914

3915
    z1 = (INT32) wsptr[1];
3916
    z2 = (INT32) wsptr[3];
3917
    z3 = (INT32) wsptr[5];
3918
    tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
3919
    tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
3920
    tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
3921
    tmp1 = (z1 - z2 - z3) << CONST_BITS;
3922

3923
    /* Final output stage */
3924

3925
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
3926
					      CONST_BITS+PASS1_BITS+3)
3927
			    & RANGE_MASK];
3928
    outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
3929
					      CONST_BITS+PASS1_BITS+3)
3930
			    & RANGE_MASK];
3931
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp1,
3932
					      CONST_BITS+PASS1_BITS+3)
3933
			    & RANGE_MASK];
3934
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp1,
3935
					      CONST_BITS+PASS1_BITS+3)
3936
			    & RANGE_MASK];
3937
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
3938
					      CONST_BITS+PASS1_BITS+3)
3939
			    & RANGE_MASK];
3940
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
3941
					      CONST_BITS+PASS1_BITS+3)
3942
			    & RANGE_MASK];
3943

3944
    wsptr += 6;		/* advance pointer to next row */
3945
  }
3946
}
3947

3948

3949
/*
3950
 * Perform dequantization and inverse DCT on one block of coefficients,
3951
 * producing a 4x2 output block.
3952
 *
3953
 * 2-point IDCT in pass 1 (columns), 4-point in pass 2 (rows).
3954
 */
3955

3956
GLOBAL(void)
3957
jpeg_idct_4x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
3958
	       JCOEFPTR coef_block,
3959
	       JSAMPARRAY output_buf, JDIMENSION output_col)
3960
{
3961
  INT32 tmp0, tmp2, tmp10, tmp12;
3962
  INT32 z1, z2, z3;
3963
  JCOEFPTR inptr;
3964
  ISLOW_MULT_TYPE * quantptr;
3965
  INT32 * wsptr;
3966
  JSAMPROW outptr;
3967
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
3968
  int ctr;
3969
  INT32 workspace[4*2];	/* buffers data between passes */
3970
  SHIFT_TEMPS
3971

3972
  /* Pass 1: process columns from input, store into work array. */
3973

3974
  inptr = coef_block;
3975
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
3976
  wsptr = workspace;
3977
  for (ctr = 0; ctr < 4; ctr++, inptr++, quantptr++, wsptr++) {
3978
    /* Even part */
3979

3980
    tmp10 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
3981

3982
    /* Odd part */
3983

3984
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
3985

3986
    /* Final output stage */
3987

3988
    wsptr[4*0] = tmp10 + tmp0;
3989
    wsptr[4*1] = tmp10 - tmp0;
3990
  }
3991

3992
  /* Pass 2: process 2 rows from work array, store into output array.
3993
   * 4-point IDCT kernel,
3994
   * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
3995
   */
3996

3997
  wsptr = workspace;
3998
  for (ctr = 0; ctr < 2; ctr++) {
3999
    outptr = output_buf[ctr] + output_col;
4000

4001
    /* Even part */
4002

4003
    /* Add range center and fudge factor for final descale and range-limit. */
4004
    tmp0 = wsptr[0] + ((((INT32) RANGE_CENTER) << 3) + (ONE << 2));
4005
    tmp2 = wsptr[2];
4006

4007
    tmp10 = (tmp0 + tmp2) << CONST_BITS;
4008
    tmp12 = (tmp0 - tmp2) << CONST_BITS;
4009

4010
    /* Odd part */
4011
    /* Same rotation as in the even part of the 8x8 LL&M IDCT */
4012

4013
    z2 = wsptr[1];
4014
    z3 = wsptr[3];
4015

4016
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);   /* c6 */
4017
    tmp0 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
4018
    tmp2 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
4019

4020
    /* Final output stage */
4021

4022
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
4023
					      CONST_BITS+3)
4024
			    & RANGE_MASK];
4025
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
4026
					      CONST_BITS+3)
4027
			    & RANGE_MASK];
4028
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
4029
					      CONST_BITS+3)
4030
			    & RANGE_MASK];
4031
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
4032
					      CONST_BITS+3)
4033
			    & RANGE_MASK];
4034

4035
    wsptr += 4;		/* advance pointer to next row */
4036
  }
4037
}
4038

4039

4040
/*
4041
 * Perform dequantization and inverse DCT on one block of coefficients,
4042
 * producing a 2x1 output block.
4043
 *
4044
 * 1-point IDCT in pass 1 (columns), 2-point in pass 2 (rows).
4045
 */
4046

4047
GLOBAL(void)
4048
jpeg_idct_2x1 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4049
	       JCOEFPTR coef_block,
4050
	       JSAMPARRAY output_buf, JDIMENSION output_col)
4051
{
4052
  DCTELEM tmp0, tmp1;
4053
  ISLOW_MULT_TYPE * quantptr;
4054
  JSAMPROW outptr;
4055
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4056
  ISHIFT_TEMPS
4057

4058
  /* Pass 1: empty. */
4059

4060
  /* Pass 2: process 1 row from input, store into output array. */
4061

4062
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4063
  outptr = output_buf[0] + output_col;
4064

4065
  /* Even part */
4066

4067
  tmp0 = DEQUANTIZE(coef_block[0], quantptr[0]);
4068
  /* Add range center and fudge factor for final descale and range-limit. */
4069
  tmp0 += (((DCTELEM) RANGE_CENTER) << 3) + (1 << 2);
4070

4071
  /* Odd part */
4072

4073
  tmp1 = DEQUANTIZE(coef_block[1], quantptr[1]);
4074

4075
  /* Final output stage */
4076

4077
  outptr[0] = range_limit[(int) IRIGHT_SHIFT(tmp0 + tmp1, 3) & RANGE_MASK];
4078
  outptr[1] = range_limit[(int) IRIGHT_SHIFT(tmp0 - tmp1, 3) & RANGE_MASK];
4079
}
4080

4081

4082
/*
4083
 * Perform dequantization and inverse DCT on one block of coefficients,
4084
 * producing a 8x16 output block.
4085
 *
4086
 * 16-point IDCT in pass 1 (columns), 8-point in pass 2 (rows).
4087
 */
4088

4089
GLOBAL(void)
4090
jpeg_idct_8x16 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4091
		JCOEFPTR coef_block,
4092
		JSAMPARRAY output_buf, JDIMENSION output_col)
4093
{
4094
  INT32 tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
4095
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
4096
  INT32 z1, z2, z3, z4;
4097
  JCOEFPTR inptr;
4098
  ISLOW_MULT_TYPE * quantptr;
4099
  int * wsptr;
4100
  JSAMPROW outptr;
4101
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4102
  int ctr;
4103
  int workspace[8*16];	/* buffers data between passes */
4104
  SHIFT_TEMPS
4105

4106
  /* Pass 1: process columns from input, store into work array.
4107
   * 16-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/32).
4108
   */
4109

4110
  inptr = coef_block;
4111
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4112
  wsptr = workspace;
4113
  for (ctr = 0; ctr < 8; ctr++, inptr++, quantptr++, wsptr++) {
4114
    /* Even part */
4115

4116
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
4117
    tmp0 <<= CONST_BITS;
4118
    /* Add fudge factor here for final descale. */
4119
    tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
4120

4121
    z1 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
4122
    tmp1 = MULTIPLY(z1, FIX(1.306562965));      /* c4[16] = c2[8] */
4123
    tmp2 = MULTIPLY(z1, FIX_0_541196100);       /* c12[16] = c6[8] */
4124

4125
    tmp10 = tmp0 + tmp1;
4126
    tmp11 = tmp0 - tmp1;
4127
    tmp12 = tmp0 + tmp2;
4128
    tmp13 = tmp0 - tmp2;
4129

4130
    z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
4131
    z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
4132
    z3 = z1 - z2;
4133
    z4 = MULTIPLY(z3, FIX(0.275899379));        /* c14[16] = c7[8] */
4134
    z3 = MULTIPLY(z3, FIX(1.387039845));        /* c2[16] = c1[8] */
4135

4136
    tmp0 = z3 + MULTIPLY(z2, FIX_2_562915447);  /* (c6+c2)[16] = (c3+c1)[8] */
4137
    tmp1 = z4 + MULTIPLY(z1, FIX_0_899976223);  /* (c6-c14)[16] = (c3-c7)[8] */
4138
    tmp2 = z3 - MULTIPLY(z1, FIX(0.601344887)); /* (c2-c10)[16] = (c1-c5)[8] */
4139
    tmp3 = z4 - MULTIPLY(z2, FIX(0.509795579)); /* (c10-c14)[16] = (c5-c7)[8] */
4140

4141
    tmp20 = tmp10 + tmp0;
4142
    tmp27 = tmp10 - tmp0;
4143
    tmp21 = tmp12 + tmp1;
4144
    tmp26 = tmp12 - tmp1;
4145
    tmp22 = tmp13 + tmp2;
4146
    tmp25 = tmp13 - tmp2;
4147
    tmp23 = tmp11 + tmp3;
4148
    tmp24 = tmp11 - tmp3;
4149

4150
    /* Odd part */
4151

4152
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
4153
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
4154
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
4155
    z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
4156

4157
    tmp11 = z1 + z3;
4158

4159
    tmp1  = MULTIPLY(z1 + z2, FIX(1.353318001));   /* c3 */
4160
    tmp2  = MULTIPLY(tmp11,   FIX(1.247225013));   /* c5 */
4161
    tmp3  = MULTIPLY(z1 + z4, FIX(1.093201867));   /* c7 */
4162
    tmp10 = MULTIPLY(z1 - z4, FIX(0.897167586));   /* c9 */
4163
    tmp11 = MULTIPLY(tmp11,   FIX(0.666655658));   /* c11 */
4164
    tmp12 = MULTIPLY(z1 - z2, FIX(0.410524528));   /* c13 */
4165
    tmp0  = tmp1 + tmp2 + tmp3 -
4166
	    MULTIPLY(z1, FIX(2.286341144));        /* c7+c5+c3-c1 */
4167
    tmp13 = tmp10 + tmp11 + tmp12 -
4168
	    MULTIPLY(z1, FIX(1.835730603));        /* c9+c11+c13-c15 */
4169
    z1    = MULTIPLY(z2 + z3, FIX(0.138617169));   /* c15 */
4170
    tmp1  += z1 + MULTIPLY(z2, FIX(0.071888074));  /* c9+c11-c3-c15 */
4171
    tmp2  += z1 - MULTIPLY(z3, FIX(1.125726048));  /* c5+c7+c15-c3 */
4172
    z1    = MULTIPLY(z3 - z2, FIX(1.407403738));   /* c1 */
4173
    tmp11 += z1 - MULTIPLY(z3, FIX(0.766367282));  /* c1+c11-c9-c13 */
4174
    tmp12 += z1 + MULTIPLY(z2, FIX(1.971951411));  /* c1+c5+c13-c7 */
4175
    z2    += z4;
4176
    z1    = MULTIPLY(z2, - FIX(0.666655658));      /* -c11 */
4177
    tmp1  += z1;
4178
    tmp3  += z1 + MULTIPLY(z4, FIX(1.065388962));  /* c3+c11+c15-c7 */
4179
    z2    = MULTIPLY(z2, - FIX(1.247225013));      /* -c5 */
4180
    tmp10 += z2 + MULTIPLY(z4, FIX(3.141271809));  /* c1+c5+c9-c13 */
4181
    tmp12 += z2;
4182
    z2    = MULTIPLY(z3 + z4, - FIX(1.353318001)); /* -c3 */
4183
    tmp2  += z2;
4184
    tmp3  += z2;
4185
    z2    = MULTIPLY(z4 - z3, FIX(0.410524528));   /* c13 */
4186
    tmp10 += z2;
4187
    tmp11 += z2;
4188

4189
    /* Final output stage */
4190

4191
    wsptr[8*0]  = (int) RIGHT_SHIFT(tmp20 + tmp0,  CONST_BITS-PASS1_BITS);
4192
    wsptr[8*15] = (int) RIGHT_SHIFT(tmp20 - tmp0,  CONST_BITS-PASS1_BITS);
4193
    wsptr[8*1]  = (int) RIGHT_SHIFT(tmp21 + tmp1,  CONST_BITS-PASS1_BITS);
4194
    wsptr[8*14] = (int) RIGHT_SHIFT(tmp21 - tmp1,  CONST_BITS-PASS1_BITS);
4195
    wsptr[8*2]  = (int) RIGHT_SHIFT(tmp22 + tmp2,  CONST_BITS-PASS1_BITS);
4196
    wsptr[8*13] = (int) RIGHT_SHIFT(tmp22 - tmp2,  CONST_BITS-PASS1_BITS);
4197
    wsptr[8*3]  = (int) RIGHT_SHIFT(tmp23 + tmp3,  CONST_BITS-PASS1_BITS);
4198
    wsptr[8*12] = (int) RIGHT_SHIFT(tmp23 - tmp3,  CONST_BITS-PASS1_BITS);
4199
    wsptr[8*4]  = (int) RIGHT_SHIFT(tmp24 + tmp10, CONST_BITS-PASS1_BITS);
4200
    wsptr[8*11] = (int) RIGHT_SHIFT(tmp24 - tmp10, CONST_BITS-PASS1_BITS);
4201
    wsptr[8*5]  = (int) RIGHT_SHIFT(tmp25 + tmp11, CONST_BITS-PASS1_BITS);
4202
    wsptr[8*10] = (int) RIGHT_SHIFT(tmp25 - tmp11, CONST_BITS-PASS1_BITS);
4203
    wsptr[8*6]  = (int) RIGHT_SHIFT(tmp26 + tmp12, CONST_BITS-PASS1_BITS);
4204
    wsptr[8*9]  = (int) RIGHT_SHIFT(tmp26 - tmp12, CONST_BITS-PASS1_BITS);
4205
    wsptr[8*7]  = (int) RIGHT_SHIFT(tmp27 + tmp13, CONST_BITS-PASS1_BITS);
4206
    wsptr[8*8]  = (int) RIGHT_SHIFT(tmp27 - tmp13, CONST_BITS-PASS1_BITS);
4207
  }
4208

4209
  /* Pass 2: process rows from work array, store into output array.
4210
   * Note that we must descale the results by a factor of 8 == 2**3,
4211
   * and also undo the PASS1_BITS scaling.
4212
   * 8-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
4213
   */
4214

4215
  wsptr = workspace;
4216
  for (ctr = 0; ctr < 16; ctr++) {
4217
    outptr = output_buf[ctr] + output_col;
4218

4219
    /* Even part: reverse the even part of the forward DCT.
4220
     * The rotator is c(-6).
4221
     */
4222

4223
    /* Add range center and fudge factor for final descale and range-limit. */
4224
    z2 = (INT32) wsptr[0] +
4225
	   ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
4226
	    (ONE << (PASS1_BITS+2)));
4227
    z3 = (INT32) wsptr[4];
4228

4229
    tmp0 = (z2 + z3) << CONST_BITS;
4230
    tmp1 = (z2 - z3) << CONST_BITS;
4231

4232
    z2 = (INT32) wsptr[2];
4233
    z3 = (INT32) wsptr[6];
4234

4235
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
4236
    tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
4237
    tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
4238

4239
    tmp10 = tmp0 + tmp2;
4240
    tmp13 = tmp0 - tmp2;
4241
    tmp11 = tmp1 + tmp3;
4242
    tmp12 = tmp1 - tmp3;
4243

4244
    /* Odd part per figure 8; the matrix is unitary and hence its
4245
     * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
4246
     */
4247

4248
    tmp0 = (INT32) wsptr[7];
4249
    tmp1 = (INT32) wsptr[5];
4250
    tmp2 = (INT32) wsptr[3];
4251
    tmp3 = (INT32) wsptr[1];
4252

4253
    z2 = tmp0 + tmp2;
4254
    z3 = tmp1 + tmp3;
4255

4256
    z1 = MULTIPLY(z2 + z3, FIX_1_175875602);       /*  c3 */
4257
    z2 = MULTIPLY(z2, - FIX_1_961570560);          /* -c3-c5 */
4258
    z3 = MULTIPLY(z3, - FIX_0_390180644);          /* -c3+c5 */
4259
    z2 += z1;
4260
    z3 += z1;
4261

4262
    z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
4263
    tmp0 = MULTIPLY(tmp0, FIX_0_298631336);        /* -c1+c3+c5-c7 */
4264
    tmp3 = MULTIPLY(tmp3, FIX_1_501321110);        /*  c1+c3-c5-c7 */
4265
    tmp0 += z1 + z2;
4266
    tmp3 += z1 + z3;
4267

4268
    z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
4269
    tmp1 = MULTIPLY(tmp1, FIX_2_053119869);        /*  c1+c3-c5+c7 */
4270
    tmp2 = MULTIPLY(tmp2, FIX_3_072711026);        /*  c1+c3+c5-c7 */
4271
    tmp1 += z1 + z3;
4272
    tmp2 += z1 + z2;
4273

4274
    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
4275

4276
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp3,
4277
					      CONST_BITS+PASS1_BITS+3)
4278
			    & RANGE_MASK];
4279
    outptr[7] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp3,
4280
					      CONST_BITS+PASS1_BITS+3)
4281
			    & RANGE_MASK];
4282
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp2,
4283
					      CONST_BITS+PASS1_BITS+3)
4284
			    & RANGE_MASK];
4285
    outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp2,
4286
					      CONST_BITS+PASS1_BITS+3)
4287
			    & RANGE_MASK];
4288
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp1,
4289
					      CONST_BITS+PASS1_BITS+3)
4290
			    & RANGE_MASK];
4291
    outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp1,
4292
					      CONST_BITS+PASS1_BITS+3)
4293
			    & RANGE_MASK];
4294
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp13 + tmp0,
4295
					      CONST_BITS+PASS1_BITS+3)
4296
			    & RANGE_MASK];
4297
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp13 - tmp0,
4298
					      CONST_BITS+PASS1_BITS+3)
4299
			    & RANGE_MASK];
4300

4301
    wsptr += DCTSIZE;		/* advance pointer to next row */
4302
  }
4303
}
4304

4305

4306
/*
4307
 * Perform dequantization and inverse DCT on one block of coefficients,
4308
 * producing a 7x14 output block.
4309
 *
4310
 * 14-point IDCT in pass 1 (columns), 7-point in pass 2 (rows).
4311
 */
4312

4313
GLOBAL(void)
4314
jpeg_idct_7x14 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4315
		JCOEFPTR coef_block,
4316
		JSAMPARRAY output_buf, JDIMENSION output_col)
4317
{
4318
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
4319
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26;
4320
  INT32 z1, z2, z3, z4;
4321
  JCOEFPTR inptr;
4322
  ISLOW_MULT_TYPE * quantptr;
4323
  int * wsptr;
4324
  JSAMPROW outptr;
4325
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4326
  int ctr;
4327
  int workspace[7*14];	/* buffers data between passes */
4328
  SHIFT_TEMPS
4329

4330
  /* Pass 1: process columns from input, store into work array.
4331
   * 14-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/28).
4332
   */
4333

4334
  inptr = coef_block;
4335
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4336
  wsptr = workspace;
4337
  for (ctr = 0; ctr < 7; ctr++, inptr++, quantptr++, wsptr++) {
4338
    /* Even part */
4339

4340
    z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
4341
    z1 <<= CONST_BITS;
4342
    /* Add fudge factor here for final descale. */
4343
    z1 += ONE << (CONST_BITS-PASS1_BITS-1);
4344
    z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
4345
    z2 = MULTIPLY(z4, FIX(1.274162392));         /* c4 */
4346
    z3 = MULTIPLY(z4, FIX(0.314692123));         /* c12 */
4347
    z4 = MULTIPLY(z4, FIX(0.881747734));         /* c8 */
4348

4349
    tmp10 = z1 + z2;
4350
    tmp11 = z1 + z3;
4351
    tmp12 = z1 - z4;
4352

4353
    tmp23 = RIGHT_SHIFT(z1 - ((z2 + z3 - z4) << 1), /* c0 = (c4+c12-c8)*2 */
4354
			CONST_BITS-PASS1_BITS);
4355

4356
    z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
4357
    z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
4358

4359
    z3 = MULTIPLY(z1 + z2, FIX(1.105676686));    /* c6 */
4360

4361
    tmp13 = z3 + MULTIPLY(z1, FIX(0.273079590)); /* c2-c6 */
4362
    tmp14 = z3 - MULTIPLY(z2, FIX(1.719280954)); /* c6+c10 */
4363
    tmp15 = MULTIPLY(z1, FIX(0.613604268)) -     /* c10 */
4364
	    MULTIPLY(z2, FIX(1.378756276));      /* c2 */
4365

4366
    tmp20 = tmp10 + tmp13;
4367
    tmp26 = tmp10 - tmp13;
4368
    tmp21 = tmp11 + tmp14;
4369
    tmp25 = tmp11 - tmp14;
4370
    tmp22 = tmp12 + tmp15;
4371
    tmp24 = tmp12 - tmp15;
4372

4373
    /* Odd part */
4374

4375
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
4376
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
4377
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
4378
    z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
4379
    tmp13 = z4 << CONST_BITS;
4380

4381
    tmp14 = z1 + z3;
4382
    tmp11 = MULTIPLY(z1 + z2, FIX(1.334852607));           /* c3 */
4383
    tmp12 = MULTIPLY(tmp14, FIX(1.197448846));             /* c5 */
4384
    tmp10 = tmp11 + tmp12 + tmp13 - MULTIPLY(z1, FIX(1.126980169)); /* c3+c5-c1 */
4385
    tmp14 = MULTIPLY(tmp14, FIX(0.752406978));             /* c9 */
4386
    tmp16 = tmp14 - MULTIPLY(z1, FIX(1.061150426));        /* c9+c11-c13 */
4387
    z1    -= z2;
4388
    tmp15 = MULTIPLY(z1, FIX(0.467085129)) - tmp13;        /* c11 */
4389
    tmp16 += tmp15;
4390
    z1    += z4;
4391
    z4    = MULTIPLY(z2 + z3, - FIX(0.158341681)) - tmp13; /* -c13 */
4392
    tmp11 += z4 - MULTIPLY(z2, FIX(0.424103948));          /* c3-c9-c13 */
4393
    tmp12 += z4 - MULTIPLY(z3, FIX(2.373959773));          /* c3+c5-c13 */
4394
    z4    = MULTIPLY(z3 - z2, FIX(1.405321284));           /* c1 */
4395
    tmp14 += z4 + tmp13 - MULTIPLY(z3, FIX(1.6906431334)); /* c1+c9-c11 */
4396
    tmp15 += z4 + MULTIPLY(z2, FIX(0.674957567));          /* c1+c11-c5 */
4397

4398
    tmp13 = (z1 - z3) << PASS1_BITS;
4399

4400
    /* Final output stage */
4401

4402
    wsptr[7*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
4403
    wsptr[7*13] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
4404
    wsptr[7*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
4405
    wsptr[7*12] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
4406
    wsptr[7*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
4407
    wsptr[7*11] = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
4408
    wsptr[7*3]  = (int) (tmp23 + tmp13);
4409
    wsptr[7*10] = (int) (tmp23 - tmp13);
4410
    wsptr[7*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
4411
    wsptr[7*9]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
4412
    wsptr[7*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
4413
    wsptr[7*8]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
4414
    wsptr[7*6]  = (int) RIGHT_SHIFT(tmp26 + tmp16, CONST_BITS-PASS1_BITS);
4415
    wsptr[7*7]  = (int) RIGHT_SHIFT(tmp26 - tmp16, CONST_BITS-PASS1_BITS);
4416
  }
4417

4418
  /* Pass 2: process 14 rows from work array, store into output array.
4419
   * 7-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/14).
4420
   */
4421

4422
  wsptr = workspace;
4423
  for (ctr = 0; ctr < 14; ctr++) {
4424
    outptr = output_buf[ctr] + output_col;
4425

4426
    /* Even part */
4427

4428
    /* Add range center and fudge factor for final descale and range-limit. */
4429
    tmp23 = (INT32) wsptr[0] +
4430
	      ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
4431
	       (ONE << (PASS1_BITS+2)));
4432
    tmp23 <<= CONST_BITS;
4433

4434
    z1 = (INT32) wsptr[2];
4435
    z2 = (INT32) wsptr[4];
4436
    z3 = (INT32) wsptr[6];
4437

4438
    tmp20 = MULTIPLY(z2 - z3, FIX(0.881747734));       /* c4 */
4439
    tmp22 = MULTIPLY(z1 - z2, FIX(0.314692123));       /* c6 */
4440
    tmp21 = tmp20 + tmp22 + tmp23 - MULTIPLY(z2, FIX(1.841218003)); /* c2+c4-c6 */
4441
    tmp10 = z1 + z3;
4442
    z2 -= tmp10;
4443
    tmp10 = MULTIPLY(tmp10, FIX(1.274162392)) + tmp23; /* c2 */
4444
    tmp20 += tmp10 - MULTIPLY(z3, FIX(0.077722536));   /* c2-c4-c6 */
4445
    tmp22 += tmp10 - MULTIPLY(z1, FIX(2.470602249));   /* c2+c4+c6 */
4446
    tmp23 += MULTIPLY(z2, FIX(1.414213562));           /* c0 */
4447

4448
    /* Odd part */
4449

4450
    z1 = (INT32) wsptr[1];
4451
    z2 = (INT32) wsptr[3];
4452
    z3 = (INT32) wsptr[5];
4453

4454
    tmp11 = MULTIPLY(z1 + z2, FIX(0.935414347));       /* (c3+c1-c5)/2 */
4455
    tmp12 = MULTIPLY(z1 - z2, FIX(0.170262339));       /* (c3+c5-c1)/2 */
4456
    tmp10 = tmp11 - tmp12;
4457
    tmp11 += tmp12;
4458
    tmp12 = MULTIPLY(z2 + z3, - FIX(1.378756276));     /* -c1 */
4459
    tmp11 += tmp12;
4460
    z2 = MULTIPLY(z1 + z3, FIX(0.613604268));          /* c5 */
4461
    tmp10 += z2;
4462
    tmp12 += z2 + MULTIPLY(z3, FIX(1.870828693));      /* c3+c1-c5 */
4463

4464
    /* Final output stage */
4465

4466
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
4467
					      CONST_BITS+PASS1_BITS+3)
4468
			    & RANGE_MASK];
4469
    outptr[6] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
4470
					      CONST_BITS+PASS1_BITS+3)
4471
			    & RANGE_MASK];
4472
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
4473
					      CONST_BITS+PASS1_BITS+3)
4474
			    & RANGE_MASK];
4475
    outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
4476
					      CONST_BITS+PASS1_BITS+3)
4477
			    & RANGE_MASK];
4478
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
4479
					      CONST_BITS+PASS1_BITS+3)
4480
			    & RANGE_MASK];
4481
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
4482
					      CONST_BITS+PASS1_BITS+3)
4483
			    & RANGE_MASK];
4484
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp23,
4485
					      CONST_BITS+PASS1_BITS+3)
4486
			    & RANGE_MASK];
4487

4488
    wsptr += 7;		/* advance pointer to next row */
4489
  }
4490
}
4491

4492

4493
/*
4494
 * Perform dequantization and inverse DCT on one block of coefficients,
4495
 * producing a 6x12 output block.
4496
 *
4497
 * 12-point IDCT in pass 1 (columns), 6-point in pass 2 (rows).
4498
 */
4499

4500
GLOBAL(void)
4501
jpeg_idct_6x12 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4502
		JCOEFPTR coef_block,
4503
		JSAMPARRAY output_buf, JDIMENSION output_col)
4504
{
4505
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
4506
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24, tmp25;
4507
  INT32 z1, z2, z3, z4;
4508
  JCOEFPTR inptr;
4509
  ISLOW_MULT_TYPE * quantptr;
4510
  int * wsptr;
4511
  JSAMPROW outptr;
4512
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4513
  int ctr;
4514
  int workspace[6*12];	/* buffers data between passes */
4515
  SHIFT_TEMPS
4516

4517
  /* Pass 1: process columns from input, store into work array.
4518
   * 12-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/24).
4519
   */
4520

4521
  inptr = coef_block;
4522
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4523
  wsptr = workspace;
4524
  for (ctr = 0; ctr < 6; ctr++, inptr++, quantptr++, wsptr++) {
4525
    /* Even part */
4526

4527
    z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
4528
    z3 <<= CONST_BITS;
4529
    /* Add fudge factor here for final descale. */
4530
    z3 += ONE << (CONST_BITS-PASS1_BITS-1);
4531

4532
    z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
4533
    z4 = MULTIPLY(z4, FIX(1.224744871)); /* c4 */
4534

4535
    tmp10 = z3 + z4;
4536
    tmp11 = z3 - z4;
4537

4538
    z1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
4539
    z4 = MULTIPLY(z1, FIX(1.366025404)); /* c2 */
4540
    z1 <<= CONST_BITS;
4541
    z2 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
4542
    z2 <<= CONST_BITS;
4543

4544
    tmp12 = z1 - z2;
4545

4546
    tmp21 = z3 + tmp12;
4547
    tmp24 = z3 - tmp12;
4548

4549
    tmp12 = z4 + z2;
4550

4551
    tmp20 = tmp10 + tmp12;
4552
    tmp25 = tmp10 - tmp12;
4553

4554
    tmp12 = z4 - z1 - z2;
4555

4556
    tmp22 = tmp11 + tmp12;
4557
    tmp23 = tmp11 - tmp12;
4558

4559
    /* Odd part */
4560

4561
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
4562
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
4563
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
4564
    z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
4565

4566
    tmp11 = MULTIPLY(z2, FIX(1.306562965));                  /* c3 */
4567
    tmp14 = MULTIPLY(z2, - FIX_0_541196100);                 /* -c9 */
4568

4569
    tmp10 = z1 + z3;
4570
    tmp15 = MULTIPLY(tmp10 + z4, FIX(0.860918669));          /* c7 */
4571
    tmp12 = tmp15 + MULTIPLY(tmp10, FIX(0.261052384));       /* c5-c7 */
4572
    tmp10 = tmp12 + tmp11 + MULTIPLY(z1, FIX(0.280143716));  /* c1-c5 */
4573
    tmp13 = MULTIPLY(z3 + z4, - FIX(1.045510580));           /* -(c7+c11) */
4574
    tmp12 += tmp13 + tmp14 - MULTIPLY(z3, FIX(1.478575242)); /* c1+c5-c7-c11 */
4575
    tmp13 += tmp15 - tmp11 + MULTIPLY(z4, FIX(1.586706681)); /* c1+c11 */
4576
    tmp15 += tmp14 - MULTIPLY(z1, FIX(0.676326758)) -        /* c7-c11 */
4577
	     MULTIPLY(z4, FIX(1.982889723));                 /* c5+c7 */
4578

4579
    z1 -= z4;
4580
    z2 -= z3;
4581
    z3 = MULTIPLY(z1 + z2, FIX_0_541196100);                 /* c9 */
4582
    tmp11 = z3 + MULTIPLY(z1, FIX_0_765366865);              /* c3-c9 */
4583
    tmp14 = z3 - MULTIPLY(z2, FIX_1_847759065);              /* c3+c9 */
4584

4585
    /* Final output stage */
4586

4587
    wsptr[6*0]  = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
4588
    wsptr[6*11] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
4589
    wsptr[6*1]  = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
4590
    wsptr[6*10] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
4591
    wsptr[6*2]  = (int) RIGHT_SHIFT(tmp22 + tmp12, CONST_BITS-PASS1_BITS);
4592
    wsptr[6*9]  = (int) RIGHT_SHIFT(tmp22 - tmp12, CONST_BITS-PASS1_BITS);
4593
    wsptr[6*3]  = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
4594
    wsptr[6*8]  = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
4595
    wsptr[6*4]  = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
4596
    wsptr[6*7]  = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
4597
    wsptr[6*5]  = (int) RIGHT_SHIFT(tmp25 + tmp15, CONST_BITS-PASS1_BITS);
4598
    wsptr[6*6]  = (int) RIGHT_SHIFT(tmp25 - tmp15, CONST_BITS-PASS1_BITS);
4599
  }
4600

4601
  /* Pass 2: process 12 rows from work array, store into output array.
4602
   * 6-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
4603
   */
4604

4605
  wsptr = workspace;
4606
  for (ctr = 0; ctr < 12; ctr++) {
4607
    outptr = output_buf[ctr] + output_col;
4608

4609
    /* Even part */
4610

4611
    /* Add range center and fudge factor for final descale and range-limit. */
4612
    tmp10 = (INT32) wsptr[0] +
4613
	      ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
4614
	       (ONE << (PASS1_BITS+2)));
4615
    tmp10 <<= CONST_BITS;
4616
    tmp12 = (INT32) wsptr[4];
4617
    tmp20 = MULTIPLY(tmp12, FIX(0.707106781));   /* c4 */
4618
    tmp11 = tmp10 + tmp20;
4619
    tmp21 = tmp10 - tmp20 - tmp20;
4620
    tmp20 = (INT32) wsptr[2];
4621
    tmp10 = MULTIPLY(tmp20, FIX(1.224744871));   /* c2 */
4622
    tmp20 = tmp11 + tmp10;
4623
    tmp22 = tmp11 - tmp10;
4624

4625
    /* Odd part */
4626

4627
    z1 = (INT32) wsptr[1];
4628
    z2 = (INT32) wsptr[3];
4629
    z3 = (INT32) wsptr[5];
4630
    tmp11 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
4631
    tmp10 = tmp11 + ((z1 + z2) << CONST_BITS);
4632
    tmp12 = tmp11 + ((z3 - z2) << CONST_BITS);
4633
    tmp11 = (z1 - z2 - z3) << CONST_BITS;
4634

4635
    /* Final output stage */
4636

4637
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp20 + tmp10,
4638
					      CONST_BITS+PASS1_BITS+3)
4639
			    & RANGE_MASK];
4640
    outptr[5] = range_limit[(int) RIGHT_SHIFT(tmp20 - tmp10,
4641
					      CONST_BITS+PASS1_BITS+3)
4642
			    & RANGE_MASK];
4643
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp21 + tmp11,
4644
					      CONST_BITS+PASS1_BITS+3)
4645
			    & RANGE_MASK];
4646
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp21 - tmp11,
4647
					      CONST_BITS+PASS1_BITS+3)
4648
			    & RANGE_MASK];
4649
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp22 + tmp12,
4650
					      CONST_BITS+PASS1_BITS+3)
4651
			    & RANGE_MASK];
4652
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp22 - tmp12,
4653
					      CONST_BITS+PASS1_BITS+3)
4654
			    & RANGE_MASK];
4655

4656
    wsptr += 6;		/* advance pointer to next row */
4657
  }
4658
}
4659

4660

4661
/*
4662
 * Perform dequantization and inverse DCT on one block of coefficients,
4663
 * producing a 5x10 output block.
4664
 *
4665
 * 10-point IDCT in pass 1 (columns), 5-point in pass 2 (rows).
4666
 */
4667

4668
GLOBAL(void)
4669
jpeg_idct_5x10 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4670
		JCOEFPTR coef_block,
4671
		JSAMPARRAY output_buf, JDIMENSION output_col)
4672
{
4673
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
4674
  INT32 tmp20, tmp21, tmp22, tmp23, tmp24;
4675
  INT32 z1, z2, z3, z4, z5;
4676
  JCOEFPTR inptr;
4677
  ISLOW_MULT_TYPE * quantptr;
4678
  int * wsptr;
4679
  JSAMPROW outptr;
4680
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4681
  int ctr;
4682
  int workspace[5*10];	/* buffers data between passes */
4683
  SHIFT_TEMPS
4684

4685
  /* Pass 1: process columns from input, store into work array.
4686
   * 10-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/20).
4687
   */
4688

4689
  inptr = coef_block;
4690
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4691
  wsptr = workspace;
4692
  for (ctr = 0; ctr < 5; ctr++, inptr++, quantptr++, wsptr++) {
4693
    /* Even part */
4694

4695
    z3 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
4696
    z3 <<= CONST_BITS;
4697
    /* Add fudge factor here for final descale. */
4698
    z3 += ONE << (CONST_BITS-PASS1_BITS-1);
4699
    z4 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
4700
    z1 = MULTIPLY(z4, FIX(1.144122806));         /* c4 */
4701
    z2 = MULTIPLY(z4, FIX(0.437016024));         /* c8 */
4702
    tmp10 = z3 + z1;
4703
    tmp11 = z3 - z2;
4704

4705
    tmp22 = RIGHT_SHIFT(z3 - ((z1 - z2) << 1),   /* c0 = (c4-c8)*2 */
4706
			CONST_BITS-PASS1_BITS);
4707

4708
    z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
4709
    z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
4710

4711
    z1 = MULTIPLY(z2 + z3, FIX(0.831253876));    /* c6 */
4712
    tmp12 = z1 + MULTIPLY(z2, FIX(0.513743148)); /* c2-c6 */
4713
    tmp13 = z1 - MULTIPLY(z3, FIX(2.176250899)); /* c2+c6 */
4714

4715
    tmp20 = tmp10 + tmp12;
4716
    tmp24 = tmp10 - tmp12;
4717
    tmp21 = tmp11 + tmp13;
4718
    tmp23 = tmp11 - tmp13;
4719

4720
    /* Odd part */
4721

4722
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
4723
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
4724
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
4725
    z4 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
4726

4727
    tmp11 = z2 + z4;
4728
    tmp13 = z2 - z4;
4729

4730
    tmp12 = MULTIPLY(tmp13, FIX(0.309016994));        /* (c3-c7)/2 */
4731
    z5 = z3 << CONST_BITS;
4732

4733
    z2 = MULTIPLY(tmp11, FIX(0.951056516));           /* (c3+c7)/2 */
4734
    z4 = z5 + tmp12;
4735

4736
    tmp10 = MULTIPLY(z1, FIX(1.396802247)) + z2 + z4; /* c1 */
4737
    tmp14 = MULTIPLY(z1, FIX(0.221231742)) - z2 + z4; /* c9 */
4738

4739
    z2 = MULTIPLY(tmp11, FIX(0.587785252));           /* (c1-c9)/2 */
4740
    z4 = z5 - tmp12 - (tmp13 << (CONST_BITS - 1));
4741

4742
    tmp12 = (z1 - tmp13 - z3) << PASS1_BITS;
4743

4744
    tmp11 = MULTIPLY(z1, FIX(1.260073511)) - z2 - z4; /* c3 */
4745
    tmp13 = MULTIPLY(z1, FIX(0.642039522)) - z2 + z4; /* c7 */
4746

4747
    /* Final output stage */
4748

4749
    wsptr[5*0] = (int) RIGHT_SHIFT(tmp20 + tmp10, CONST_BITS-PASS1_BITS);
4750
    wsptr[5*9] = (int) RIGHT_SHIFT(tmp20 - tmp10, CONST_BITS-PASS1_BITS);
4751
    wsptr[5*1] = (int) RIGHT_SHIFT(tmp21 + tmp11, CONST_BITS-PASS1_BITS);
4752
    wsptr[5*8] = (int) RIGHT_SHIFT(tmp21 - tmp11, CONST_BITS-PASS1_BITS);
4753
    wsptr[5*2] = (int) (tmp22 + tmp12);
4754
    wsptr[5*7] = (int) (tmp22 - tmp12);
4755
    wsptr[5*3] = (int) RIGHT_SHIFT(tmp23 + tmp13, CONST_BITS-PASS1_BITS);
4756
    wsptr[5*6] = (int) RIGHT_SHIFT(tmp23 - tmp13, CONST_BITS-PASS1_BITS);
4757
    wsptr[5*4] = (int) RIGHT_SHIFT(tmp24 + tmp14, CONST_BITS-PASS1_BITS);
4758
    wsptr[5*5] = (int) RIGHT_SHIFT(tmp24 - tmp14, CONST_BITS-PASS1_BITS);
4759
  }
4760

4761
  /* Pass 2: process 10 rows from work array, store into output array.
4762
   * 5-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/10).
4763
   */
4764

4765
  wsptr = workspace;
4766
  for (ctr = 0; ctr < 10; ctr++) {
4767
    outptr = output_buf[ctr] + output_col;
4768

4769
    /* Even part */
4770

4771
    /* Add range center and fudge factor for final descale and range-limit. */
4772
    tmp12 = (INT32) wsptr[0] +
4773
	      ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
4774
	       (ONE << (PASS1_BITS+2)));
4775
    tmp12 <<= CONST_BITS;
4776
    tmp13 = (INT32) wsptr[2];
4777
    tmp14 = (INT32) wsptr[4];
4778
    z1 = MULTIPLY(tmp13 + tmp14, FIX(0.790569415)); /* (c2+c4)/2 */
4779
    z2 = MULTIPLY(tmp13 - tmp14, FIX(0.353553391)); /* (c2-c4)/2 */
4780
    z3 = tmp12 + z2;
4781
    tmp10 = z3 + z1;
4782
    tmp11 = z3 - z1;
4783
    tmp12 -= z2 << 2;
4784

4785
    /* Odd part */
4786

4787
    z2 = (INT32) wsptr[1];
4788
    z3 = (INT32) wsptr[3];
4789

4790
    z1 = MULTIPLY(z2 + z3, FIX(0.831253876));       /* c3 */
4791
    tmp13 = z1 + MULTIPLY(z2, FIX(0.513743148));    /* c1-c3 */
4792
    tmp14 = z1 - MULTIPLY(z3, FIX(2.176250899));    /* c1+c3 */
4793

4794
    /* Final output stage */
4795

4796
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp13,
4797
					      CONST_BITS+PASS1_BITS+3)
4798
			    & RANGE_MASK];
4799
    outptr[4] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp13,
4800
					      CONST_BITS+PASS1_BITS+3)
4801
			    & RANGE_MASK];
4802
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp11 + tmp14,
4803
					      CONST_BITS+PASS1_BITS+3)
4804
			    & RANGE_MASK];
4805
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp11 - tmp14,
4806
					      CONST_BITS+PASS1_BITS+3)
4807
			    & RANGE_MASK];
4808
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12,
4809
					      CONST_BITS+PASS1_BITS+3)
4810
			    & RANGE_MASK];
4811

4812
    wsptr += 5;		/* advance pointer to next row */
4813
  }
4814
}
4815

4816

4817
/*
4818
 * Perform dequantization and inverse DCT on one block of coefficients,
4819
 * producing a 4x8 output block.
4820
 *
4821
 * 8-point IDCT in pass 1 (columns), 4-point in pass 2 (rows).
4822
 */
4823

4824
GLOBAL(void)
4825
jpeg_idct_4x8 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
4826
	       JCOEFPTR coef_block,
4827
	       JSAMPARRAY output_buf, JDIMENSION output_col)
4828
{
4829
  INT32 tmp0, tmp1, tmp2, tmp3;
4830
  INT32 tmp10, tmp11, tmp12, tmp13;
4831
  INT32 z1, z2, z3;
4832
  JCOEFPTR inptr;
4833
  ISLOW_MULT_TYPE * quantptr;
4834
  int * wsptr;
4835
  JSAMPROW outptr;
4836
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
4837
  int ctr;
4838
  int workspace[4*8];	/* buffers data between passes */
4839
  SHIFT_TEMPS
4840

4841
  /* Pass 1: process columns from input, store into work array.
4842
   * Note results are scaled up by sqrt(8) compared to a true IDCT;
4843
   * furthermore, we scale the results by 2**PASS1_BITS.
4844
   * 8-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
4845
   */
4846

4847
  inptr = coef_block;
4848
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
4849
  wsptr = workspace;
4850
  for (ctr = 4; ctr > 0; ctr--) {
4851
    /* Due to quantization, we will usually find that many of the input
4852
     * coefficients are zero, especially the AC terms.  We can exploit this
4853
     * by short-circuiting the IDCT calculation for any column in which all
4854
     * the AC terms are zero.  In that case each output is equal to the
4855
     * DC coefficient (with scale factor as needed).
4856
     * With typical images and quantization tables, half or more of the
4857
     * column DCT calculations can be simplified this way.
4858
     */
4859

4860
    if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
4861
	inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
4862
	inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
4863
	inptr[DCTSIZE*7] == 0) {
4864
      /* AC terms all zero */
4865
      int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
4866

4867
      wsptr[4*0] = dcval;
4868
      wsptr[4*1] = dcval;
4869
      wsptr[4*2] = dcval;
4870
      wsptr[4*3] = dcval;
4871
      wsptr[4*4] = dcval;
4872
      wsptr[4*5] = dcval;
4873
      wsptr[4*6] = dcval;
4874
      wsptr[4*7] = dcval;
4875

4876
      inptr++;			/* advance pointers to next column */
4877
      quantptr++;
4878
      wsptr++;
4879
      continue;
4880
    }
4881

4882
    /* Even part: reverse the even part of the forward DCT.
4883
     * The rotator is c(-6).
4884
     */
4885

4886
    z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
4887
    z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
4888

4889
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
4890
    tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
4891
    tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
4892

4893
    z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
4894
    z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
4895
    z2 <<= CONST_BITS;
4896
    z3 <<= CONST_BITS;
4897
    /* Add fudge factor here for final descale. */
4898
    z2 += ONE << (CONST_BITS-PASS1_BITS-1);
4899

4900
    tmp0 = z2 + z3;
4901
    tmp1 = z2 - z3;
4902

4903
    tmp10 = tmp0 + tmp2;
4904
    tmp13 = tmp0 - tmp2;
4905
    tmp11 = tmp1 + tmp3;
4906
    tmp12 = tmp1 - tmp3;
4907

4908
    /* Odd part per figure 8; the matrix is unitary and hence its
4909
     * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
4910
     */
4911

4912
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
4913
    tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
4914
    tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
4915
    tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
4916

4917
    z2 = tmp0 + tmp2;
4918
    z3 = tmp1 + tmp3;
4919

4920
    z1 = MULTIPLY(z2 + z3, FIX_1_175875602);       /*  c3 */
4921
    z2 = MULTIPLY(z2, - FIX_1_961570560);          /* -c3-c5 */
4922
    z3 = MULTIPLY(z3, - FIX_0_390180644);          /* -c3+c5 */
4923
    z2 += z1;
4924
    z3 += z1;
4925

4926
    z1 = MULTIPLY(tmp0 + tmp3, - FIX_0_899976223); /* -c3+c7 */
4927
    tmp0 = MULTIPLY(tmp0, FIX_0_298631336);        /* -c1+c3+c5-c7 */
4928
    tmp3 = MULTIPLY(tmp3, FIX_1_501321110);        /*  c1+c3-c5-c7 */
4929
    tmp0 += z1 + z2;
4930
    tmp3 += z1 + z3;
4931

4932
    z1 = MULTIPLY(tmp1 + tmp2, - FIX_2_562915447); /* -c1-c3 */
4933
    tmp1 = MULTIPLY(tmp1, FIX_2_053119869);        /*  c1+c3-c5+c7 */
4934
    tmp2 = MULTIPLY(tmp2, FIX_3_072711026);        /*  c1+c3+c5-c7 */
4935
    tmp1 += z1 + z3;
4936
    tmp2 += z1 + z2;
4937

4938
    /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
4939

4940
    wsptr[4*0] = (int) RIGHT_SHIFT(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
4941
    wsptr[4*7] = (int) RIGHT_SHIFT(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
4942
    wsptr[4*1] = (int) RIGHT_SHIFT(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
4943
    wsptr[4*6] = (int) RIGHT_SHIFT(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
4944
    wsptr[4*2] = (int) RIGHT_SHIFT(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
4945
    wsptr[4*5] = (int) RIGHT_SHIFT(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
4946
    wsptr[4*3] = (int) RIGHT_SHIFT(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
4947
    wsptr[4*4] = (int) RIGHT_SHIFT(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
4948

4949
    inptr++;			/* advance pointers to next column */
4950
    quantptr++;
4951
    wsptr++;
4952
  }
4953

4954
  /* Pass 2: process 8 rows from work array, store into output array.
4955
   * 4-point IDCT kernel,
4956
   * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
4957
   */
4958

4959
  wsptr = workspace;
4960
  for (ctr = 0; ctr < 8; ctr++) {
4961
    outptr = output_buf[ctr] + output_col;
4962

4963
    /* Even part */
4964

4965
    /* Add range center and fudge factor for final descale and range-limit. */
4966
    tmp0 = (INT32) wsptr[0] +
4967
	     ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
4968
	      (ONE << (PASS1_BITS+2)));
4969
    tmp2 = (INT32) wsptr[2];
4970

4971
    tmp10 = (tmp0 + tmp2) << CONST_BITS;
4972
    tmp12 = (tmp0 - tmp2) << CONST_BITS;
4973

4974
    /* Odd part */
4975
    /* Same rotation as in the even part of the 8x8 LL&M IDCT */
4976

4977
    z2 = (INT32) wsptr[1];
4978
    z3 = (INT32) wsptr[3];
4979

4980
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);   /* c6 */
4981
    tmp0 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
4982
    tmp2 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
4983

4984
    /* Final output stage */
4985

4986
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
4987
					      CONST_BITS+PASS1_BITS+3)
4988
			    & RANGE_MASK];
4989
    outptr[3] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
4990
					      CONST_BITS+PASS1_BITS+3)
4991
			    & RANGE_MASK];
4992
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp12 + tmp2,
4993
					      CONST_BITS+PASS1_BITS+3)
4994
			    & RANGE_MASK];
4995
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp12 - tmp2,
4996
					      CONST_BITS+PASS1_BITS+3)
4997
			    & RANGE_MASK];
4998

4999
    wsptr += 4;		/* advance pointer to next row */
5000
  }
5001
}
5002

5003

5004
/*
5005
 * Perform dequantization and inverse DCT on one block of coefficients,
5006
 * producing a reduced-size 3x6 output block.
5007
 *
5008
 * 6-point IDCT in pass 1 (columns), 3-point in pass 2 (rows).
5009
 */
5010

5011
GLOBAL(void)
5012
jpeg_idct_3x6 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
5013
	       JCOEFPTR coef_block,
5014
	       JSAMPARRAY output_buf, JDIMENSION output_col)
5015
{
5016
  INT32 tmp0, tmp1, tmp2, tmp10, tmp11, tmp12;
5017
  INT32 z1, z2, z3;
5018
  JCOEFPTR inptr;
5019
  ISLOW_MULT_TYPE * quantptr;
5020
  int * wsptr;
5021
  JSAMPROW outptr;
5022
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
5023
  int ctr;
5024
  int workspace[3*6];	/* buffers data between passes */
5025
  SHIFT_TEMPS
5026

5027
  /* Pass 1: process columns from input, store into work array.
5028
   * 6-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/12).
5029
   */
5030

5031
  inptr = coef_block;
5032
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
5033
  wsptr = workspace;
5034
  for (ctr = 0; ctr < 3; ctr++, inptr++, quantptr++, wsptr++) {
5035
    /* Even part */
5036

5037
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
5038
    tmp0 <<= CONST_BITS;
5039
    /* Add fudge factor here for final descale. */
5040
    tmp0 += ONE << (CONST_BITS-PASS1_BITS-1);
5041
    tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
5042
    tmp10 = MULTIPLY(tmp2, FIX(0.707106781));   /* c4 */
5043
    tmp1 = tmp0 + tmp10;
5044
    tmp11 = RIGHT_SHIFT(tmp0 - tmp10 - tmp10, CONST_BITS-PASS1_BITS);
5045
    tmp10 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
5046
    tmp0 = MULTIPLY(tmp10, FIX(1.224744871));   /* c2 */
5047
    tmp10 = tmp1 + tmp0;
5048
    tmp12 = tmp1 - tmp0;
5049

5050
    /* Odd part */
5051

5052
    z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
5053
    z2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
5054
    z3 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
5055
    tmp1 = MULTIPLY(z1 + z3, FIX(0.366025404)); /* c5 */
5056
    tmp0 = tmp1 + ((z1 + z2) << CONST_BITS);
5057
    tmp2 = tmp1 + ((z3 - z2) << CONST_BITS);
5058
    tmp1 = (z1 - z2 - z3) << PASS1_BITS;
5059

5060
    /* Final output stage */
5061

5062
    wsptr[3*0] = (int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS-PASS1_BITS);
5063
    wsptr[3*5] = (int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS-PASS1_BITS);
5064
    wsptr[3*1] = (int) (tmp11 + tmp1);
5065
    wsptr[3*4] = (int) (tmp11 - tmp1);
5066
    wsptr[3*2] = (int) RIGHT_SHIFT(tmp12 + tmp2, CONST_BITS-PASS1_BITS);
5067
    wsptr[3*3] = (int) RIGHT_SHIFT(tmp12 - tmp2, CONST_BITS-PASS1_BITS);
5068
  }
5069

5070
  /* Pass 2: process 6 rows from work array, store into output array.
5071
   * 3-point IDCT kernel, cK represents sqrt(2) * cos(K*pi/6).
5072
   */
5073

5074
  wsptr = workspace;
5075
  for (ctr = 0; ctr < 6; ctr++) {
5076
    outptr = output_buf[ctr] + output_col;
5077

5078
    /* Even part */
5079

5080
    /* Add range center and fudge factor for final descale and range-limit. */
5081
    tmp0 = (INT32) wsptr[0] +
5082
	     ((((INT32) RANGE_CENTER) << (PASS1_BITS+3)) +
5083
	      (ONE << (PASS1_BITS+2)));
5084
    tmp0 <<= CONST_BITS;
5085
    tmp2 = (INT32) wsptr[2];
5086
    tmp12 = MULTIPLY(tmp2, FIX(0.707106781)); /* c2 */
5087
    tmp10 = tmp0 + tmp12;
5088
    tmp2 = tmp0 - tmp12 - tmp12;
5089

5090
    /* Odd part */
5091

5092
    tmp12 = (INT32) wsptr[1];
5093
    tmp0 = MULTIPLY(tmp12, FIX(1.224744871)); /* c1 */
5094

5095
    /* Final output stage */
5096

5097
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0,
5098
					      CONST_BITS+PASS1_BITS+3)
5099
			    & RANGE_MASK];
5100
    outptr[2] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0,
5101
					      CONST_BITS+PASS1_BITS+3)
5102
			    & RANGE_MASK];
5103
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp2,
5104
					      CONST_BITS+PASS1_BITS+3)
5105
			    & RANGE_MASK];
5106

5107
    wsptr += 3;		/* advance pointer to next row */
5108
  }
5109
}
5110

5111

5112
/*
5113
 * Perform dequantization and inverse DCT on one block of coefficients,
5114
 * producing a 2x4 output block.
5115
 *
5116
 * 4-point IDCT in pass 1 (columns), 2-point in pass 2 (rows).
5117
 */
5118

5119
GLOBAL(void)
5120
jpeg_idct_2x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
5121
	       JCOEFPTR coef_block,
5122
	       JSAMPARRAY output_buf, JDIMENSION output_col)
5123
{
5124
  INT32 tmp0, tmp2, tmp10, tmp12;
5125
  INT32 z1, z2, z3;
5126
  JCOEFPTR inptr;
5127
  ISLOW_MULT_TYPE * quantptr;
5128
  INT32 * wsptr;
5129
  JSAMPROW outptr;
5130
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
5131
  int ctr;
5132
  INT32 workspace[2*4];	/* buffers data between passes */
5133
  SHIFT_TEMPS
5134

5135
  /* Pass 1: process columns from input, store into work array.
5136
   * 4-point IDCT kernel,
5137
   * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point IDCT].
5138
   */
5139

5140
  inptr = coef_block;
5141
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
5142
  wsptr = workspace;
5143
  for (ctr = 0; ctr < 2; ctr++, inptr++, quantptr++, wsptr++) {
5144
    /* Even part */
5145

5146
    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
5147
    tmp2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
5148

5149
    tmp10 = (tmp0 + tmp2) << CONST_BITS;
5150
    tmp12 = (tmp0 - tmp2) << CONST_BITS;
5151

5152
    /* Odd part */
5153
    /* Same rotation as in the even part of the 8x8 LL&M IDCT */
5154

5155
    z2 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
5156
    z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
5157

5158
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);   /* c6 */
5159
    tmp0 = z1 + MULTIPLY(z2, FIX_0_765366865); /* c2-c6 */
5160
    tmp2 = z1 - MULTIPLY(z3, FIX_1_847759065); /* c2+c6 */
5161

5162
    /* Final output stage */
5163

5164
    wsptr[2*0] = tmp10 + tmp0;
5165
    wsptr[2*3] = tmp10 - tmp0;
5166
    wsptr[2*1] = tmp12 + tmp2;
5167
    wsptr[2*2] = tmp12 - tmp2;
5168
  }
5169

5170
  /* Pass 2: process 4 rows from work array, store into output array. */
5171

5172
  wsptr = workspace;
5173
  for (ctr = 0; ctr < 4; ctr++) {
5174
    outptr = output_buf[ctr] + output_col;
5175

5176
    /* Even part */
5177

5178
    /* Add range center and fudge factor for final descale and range-limit. */
5179
    tmp10 = wsptr[0] +
5180
	      ((((INT32) RANGE_CENTER) << (CONST_BITS+3)) +
5181
	       (ONE << (CONST_BITS+2)));
5182

5183
    /* Odd part */
5184

5185
    tmp0 = wsptr[1];
5186

5187
    /* Final output stage */
5188

5189
    outptr[0] = range_limit[(int) RIGHT_SHIFT(tmp10 + tmp0, CONST_BITS+3)
5190
			    & RANGE_MASK];
5191
    outptr[1] = range_limit[(int) RIGHT_SHIFT(tmp10 - tmp0, CONST_BITS+3)
5192
			    & RANGE_MASK];
5193

5194
    wsptr += 2;		/* advance pointer to next row */
5195
  }
5196
}
5197

5198

5199
/*
5200
 * Perform dequantization and inverse DCT on one block of coefficients,
5201
 * producing a 1x2 output block.
5202
 *
5203
 * 2-point IDCT in pass 1 (columns), 1-point in pass 2 (rows).
5204
 */
5205

5206
GLOBAL(void)
5207
jpeg_idct_1x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
5208
	       JCOEFPTR coef_block,
5209
	       JSAMPARRAY output_buf, JDIMENSION output_col)
5210
{
5211
  DCTELEM tmp0, tmp1;
5212
  ISLOW_MULT_TYPE * quantptr;
5213
  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
5214
  ISHIFT_TEMPS
5215

5216
  /* Process 1 column from input, store into output array. */
5217

5218
  quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
5219

5220
  /* Even part */
5221

5222
  tmp0 = DEQUANTIZE(coef_block[DCTSIZE*0], quantptr[DCTSIZE*0]);
5223
  /* Add range center and fudge factor for final descale and range-limit. */
5224
  tmp0 += (((DCTELEM) RANGE_CENTER) << 3) + (1 << 2);
5225

5226
  /* Odd part */
5227

5228
  tmp1 = DEQUANTIZE(coef_block[DCTSIZE*1], quantptr[DCTSIZE*1]);
5229

5230
  /* Final output stage */
5231

5232
  output_buf[0][output_col] =
5233
    range_limit[(int) IRIGHT_SHIFT(tmp0 + tmp1, 3) & RANGE_MASK];
5234
  output_buf[1][output_col] =
5235
    range_limit[(int) IRIGHT_SHIFT(tmp0 - tmp1, 3) & RANGE_MASK];
5236
}
5237

5238
#endif /* IDCT_SCALING_SUPPORTED */
5239
#endif /* DCT_ISLOW_SUPPORTED */
5240

5241
Product

Resources

Company
