CoCalc -- jidctint.c

GitHub Repository: wine-mirror/wine
Path: blob/master/libs/jpeg/jidctint.c
⁴³⁸⁹ views
1
/*
2
 * jidctint.c
3
 *
4
 * Copyright (C) 1991-1998, Thomas G. Lane.
5
 * Modification developed 2002-2018 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
 * Optimized algorithm with 12 multiplications in the 1-D kernel.
170
 * cK represents sqrt(2) * cos(K*pi/16).
171
 */
172

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

427
#ifdef IDCT_SCALING_SUPPORTED
428

429

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

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

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

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

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

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

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

481
    /* Odd part */
482

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

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

497
    /* Final output stage */
498

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

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

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

514
    /* Even part */
515

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

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

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

536
    /* Odd part */
537

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

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

552
    /* Final output stage */
553

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

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

580

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

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

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

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

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

626
    /* Odd part */
627

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

636
    /* Final output stage */
637

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

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

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

652
    /* Even part */
653

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

668
    /* Odd part */
669

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

678
    /* Final output stage */
679

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

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

703

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

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

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

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

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

749
    /* Odd part */
750

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

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

758
    /* Final output stage */
759

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

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

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

773
    /* Even part */
774

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

789
    /* Odd part */
790

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

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

798
    /* Final output stage */
799

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

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

820

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

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

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

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

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

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

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

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

873
    /* Final output stage */
874

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

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

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

887
    /* Even part */
888

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

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

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

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

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

908
    /* Final output stage */
909

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

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

927

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

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

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

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

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

968
    /* Odd part */
969

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

973
    /* Final output stage */
974

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

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

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

986
    /* Even part */
987

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

998
    /* Odd part */
999

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

1003
    /* Final output stage */
1004

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

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

1019

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

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

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

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

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

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

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

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

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

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

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

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

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

1073

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

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

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

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

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

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

1104

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

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

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

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

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

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

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

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

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

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

1162
    /* Odd part */
1163

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

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

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

1179
    /* Final output stage */
1180

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

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

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

1198
    /* Even part */
1199

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

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

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

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

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

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

1226
    /* Odd part */
1227

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

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

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

1243
    /* Final output stage */
1244

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

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

1277

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

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

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

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

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

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

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

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

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

1336
    /* Odd part */
1337

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

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

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

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

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

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

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

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

1363
    /* Final output stage */
1364

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

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

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

1383
    /* Even part */
1384

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

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

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

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

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

1410
    /* Odd part */
1411

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

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

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

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

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

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

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

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

1437
    /* Final output stage */
1438

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

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

1474

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

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

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

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

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

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

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

1533
    /* Odd part */
1534

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

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

1557
    /* Final output stage */
1558

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

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

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

1578
    /* Even part */
1579

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

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

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

1606
    /* Odd part */
1607

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

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

1630
    /* Final output stage */
1631

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

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

1670

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

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

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

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

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

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

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

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

1721
    tmp12 = z1 - z2;
1722

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

1726
    tmp12 = z4 + z2;
1727

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

1731
    tmp12 = z4 - z1 - z2;
1732

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

1736
    /* Odd part */
1737

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

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

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

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

1762
    /* Final output stage */
1763

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

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

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

1784
    /* Even part */
1785

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

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

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

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

1804
    tmp12 = z1 - z2;
1805

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

1809
    tmp12 = z4 + z2;
1810

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

1814
    tmp12 = z4 - z1 - z2;
1815

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

1819
    /* Odd part */
1820

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

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

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

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

1845
    /* Final output stage */
1846

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

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

1888

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1954
    /* Odd part */
1955

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

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

1984
    /* Final output stage */
1985

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

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

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

2007
    /* Even part */
2008

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

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

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

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

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

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

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

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

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

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

2042
    /* Odd part */
2043

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

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

2072
    /* Final output stage */
2073

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

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

2118

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

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

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

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

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

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

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

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

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

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

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

2185
    /* Odd part */
2186

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

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

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

2212
    /* Final output stage */
2213

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

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

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

2236
    /* Even part */
2237

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

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

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

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

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

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

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

2271
    /* Odd part */
2272

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

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

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

2297
    /* Final output stage */
2298

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

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

2346

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2420
    /* Odd part */
2421

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

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

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

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

2445
    /* Final output stage */
2446

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

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

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

2470
    /* Even part */
2471

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

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

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

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

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

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

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

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

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

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

2513
    /* Odd part */
2514

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

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

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

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

2538
    /* Final output stage */
2539

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

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

2590

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

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

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

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

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

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

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

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

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

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

2658
    /* Odd part */
2659

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

2665
    tmp11 = z1 + z3;
2666

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

2697
    /* Final output stage */
2698

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

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

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

2723
    /* Even part */
2724

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

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

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

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

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

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

2760
    /* Odd part */
2761

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

2767
    tmp11 = z1 + z3;
2768

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

2799
    /* Final output stage */
2800

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

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

2854

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

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

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

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

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

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

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

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

2924
    z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
2925
    z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
2926
    z2 <<= CONST_BITS;
2927
    z3 <<= CONST_BITS;
2928
    /* Add fudge factor here for final descale. */
2929
    z2 += ONE << (CONST_BITS-PASS1_BITS-1);
2930

2931
    tmp0 = z2 + z3;
2932
    tmp1 = z2 - z3;
2933

2934
    z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
2935
    z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
2936

2937
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
2938
    tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
2939
    tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
2940

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

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

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

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

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

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

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

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

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

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

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

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

3000
    /* Even part */
3001

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

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

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

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

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

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

3037
    /* Odd part */
3038

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

3044
    tmp11 = z1 + z3;
3045

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

3076
    /* Final output stage */
3077

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

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

3131

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

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

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

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

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

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

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

3185
    /* Odd part */
3186

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

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

3201
    /* Final output stage */
3202

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

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

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

3220
    /* Even part */
3221

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

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

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

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

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

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

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

3255
    /* Odd part */
3256

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

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

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

3281
    /* Final output stage */
3282

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

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

3330

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

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

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

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

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

3378
    /* Odd part */
3379

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

3388
    /* Final output stage */
3389

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

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

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

3406
    /* Even part */
3407

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

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

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

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

3426
    tmp12 = z1 - z2;
3427

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

3431
    tmp12 = z4 + z2;
3432

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

3436
    tmp12 = z4 - z1 - z2;
3437

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

3441
    /* Odd part */
3442

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

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

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

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

3467
    /* Final output stage */
3468

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

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

3510

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

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

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

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

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

3558
    /* Odd part */
3559

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

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

3567
    /* Final output stage */
3568

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

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

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

3584
    /* Even part */
3585

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

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

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

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

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

3611
    /* Odd part */
3612

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

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

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

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

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

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

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

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

3638
    /* Final output stage */
3639

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

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

3675

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

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

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

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

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

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

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

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

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

3731
    /* Final output stage */
3732

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3835

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

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

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

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

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

3878
    /* Odd part */
3879

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

3883
    /* Final output stage */
3884

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

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

3898
    /* Even part */
3899

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

3914
    /* Odd part */
3915

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

3924
    /* Final output stage */
3925

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

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

3949

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

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

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

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

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

3983
    /* Odd part */
3984

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

3987
    /* Final output stage */
3988

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

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

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

4002
    /* Even part */
4003

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

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

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

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

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

4021
    /* Final output stage */
4022

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

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

4040

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

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

4059
  /* Pass 1: empty. */
4060

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

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

4066
  /* Even part */
4067

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

4072
  /* Odd part */
4073

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

4076
  /* Final output stage */
4077

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

4082

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

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

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

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

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

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

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

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

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

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

4151
    /* Odd part */
4152

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

4158
    tmp11 = z1 + z3;
4159

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

4190
    /* Final output stage */
4191

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4306

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

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

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

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

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

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

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

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

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

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

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

4374
    /* Odd part */
4375

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

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

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

4401
    /* Final output stage */
4402

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

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

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

4427
    /* Even part */
4428

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

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

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

4449
    /* Odd part */
4450

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

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

4465
    /* Final output stage */
4466

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

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

4493

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

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

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

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

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

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

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

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

4545
    tmp12 = z1 - z2;
4546

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

4550
    tmp12 = z4 + z2;
4551

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

4555
    tmp12 = z4 - z1 - z2;
4556

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

4560
    /* Odd part */
4561

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

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

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

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

4586
    /* Final output stage */
4587

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

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

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

4610
    /* Even part */
4611

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

4626
    /* Odd part */
4627

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

4636
    /* Final output stage */
4637

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

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

4661

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

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

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

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

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

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

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

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

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

4721
    /* Odd part */
4722

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

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

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

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

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

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

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

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

4748
    /* Final output stage */
4749

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

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

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

4770
    /* Even part */
4771

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

4786
    /* Odd part */
4787

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

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

4795
    /* Final output stage */
4796

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

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

4817

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

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

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

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

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

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

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

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

4887
    z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
4888
    z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
4889
    z2 <<= CONST_BITS;
4890
    z3 <<= CONST_BITS;
4891
    /* Add fudge factor here for final descale. */
4892
    z2 += ONE << (CONST_BITS-PASS1_BITS-1);
4893

4894
    tmp0 = z2 + z3;
4895
    tmp1 = z2 - z3;
4896

4897
    z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
4898
    z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
4899

4900
    z1 = MULTIPLY(z2 + z3, FIX_0_541196100);       /* c6 */
4901
    tmp2 = z1 + MULTIPLY(z2, FIX_0_765366865);     /* c2-c6 */
4902
    tmp3 = z1 - MULTIPLY(z3, FIX_1_847759065);     /* c2+c6 */
4903

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

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

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

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

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

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

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

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

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

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

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

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

4964
    /* Even part */
4965

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

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

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

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

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

4985
    /* Final output stage */
4986

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

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

5004

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

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

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

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

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

5051
    /* Odd part */
5052

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

5061
    /* Final output stage */
5062

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

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

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

5079
    /* Even part */
5080

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

5091
    /* Odd part */
5092

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

5096
    /* Final output stage */
5097

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

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

5112

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

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

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

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

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

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

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

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

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

5163
    /* Final output stage */
5164

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

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

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

5177
    /* Even part */
5178

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

5184
    /* Odd part */
5185

5186
    tmp0 = wsptr[1];
5187

5188
    /* Final output stage */
5189

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

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

5199

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

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

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

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

5221
  /* Even part */
5222

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

5227
  /* Odd part */
5228

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

5231
  /* Final output stage */
5232

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

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

5242
Product

Resources

Company
