← Back to branch summary

~ubuntu-branches/ubuntu/wily/qtbase-opensource-src/wily

« back to all changes in this revision

Viewing changes to src/3rdparty/libjpeg/jfdctint.c

  • Committer: Package Import Robot
  • Author(s): Timo Jyrinki
  • Date: 2013-02-05 12:46:17 UTC
  • Revision ID: package-import@ubuntu.com-20130205124617-c8jouts182j002fx
Tags: upstream-5.0.1+dfsg
Import upstream version 5.0.1+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/libjpeg/jfdctint.c
 
1
/*
 
2
 * jfdctint.c
 
3
 *
 
4
 * Copyright (C) 1991-1996, Thomas G. Lane.
 
5
 * Modification developed 2003-2009 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
 * forward DCT (Discrete Cosine Transform).
 
11
 *
 
12
 * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
 
13
 * on each column.  Direct algorithms are also available, but they are
 
14
 * much more complex and seem not to be any faster when reduced to code.
 
15
 *
 
16
 * This implementation is based on an algorithm described in
 
17
 *   C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
 
18
 *   Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
 
19
 *   Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
 
20
 * The primary algorithm described there uses 11 multiplies and 29 adds.
 
21
 * We use their alternate method with 12 multiplies and 32 adds.
 
22
 * The advantage of this method is that no data path contains more than one
 
23
 * multiplication; this allows a very simple and accurate implementation in
 
24
 * scaled fixed-point arithmetic, with a minimal number of shifts.
 
25
 *
 
26
 * We also provide FDCT routines with various input sample block sizes for
 
27
 * direct resolution reduction or enlargement and for direct resolving the
 
28
 * common 2x1 and 1x2 subsampling cases without additional resampling: NxN
 
29
 * (N=1...16), 2NxN, and Nx2N (N=1...8) pixels for one 8x8 output DCT block.
 
30
 *
 
31
 * For N<8 we fill the remaining block coefficients with zero.
 
32
 * For N>8 we apply a partial N-point FDCT on the input samples, computing
 
33
 * just the lower 8 frequency coefficients and discarding the rest.
 
34
 *
 
35
 * We must scale the output coefficients of the N-point FDCT appropriately
 
36
 * to the standard 8-point FDCT level by 8/N per 1-D pass.  This scaling
 
37
 * is folded into the constant multipliers (pass 2) and/or final/initial
 
38
 * shifting.
 
39
 *
 
40
 * CAUTION: We rely on the FIX() macro except for the N=1,2,4,8 cases
 
41
 * since there would be too many additional constants to pre-calculate.
 
42
 */
 
43
 
 
44
#define JPEG_INTERNALS
 
45
#include "jinclude.h"
 
46
#include "jpeglib.h"
 
47
#include "jdct.h"               /* Private declarations for DCT subsystem */
 
48
 
 
49
#ifdef DCT_ISLOW_SUPPORTED
 
50
 
 
51
 
 
52
/*
 
53
 * This module is specialized to the case DCTSIZE = 8.
 
54
 */
 
55
 
 
56
#if DCTSIZE != 8
 
57
  Sorry, this code only copes with 8x8 DCT blocks. /* deliberate syntax err */
 
58
#endif
 
59
 
 
60
 
 
61
/*
 
62
 * The poop on this scaling stuff is as follows:
 
63
 *
 
64
 * Each 1-D DCT step produces outputs which are a factor of sqrt(N)
 
65
 * larger than the true DCT outputs.  The final outputs are therefore
 
66
 * a factor of N larger than desired; since N=8 this can be cured by
 
67
 * a simple right shift at the end of the algorithm.  The advantage of
 
68
 * this arrangement is that we save two multiplications per 1-D DCT,
 
69
 * because the y0 and y4 outputs need not be divided by sqrt(N).
 
70
 * In the IJG code, this factor of 8 is removed by the quantization step
 
71
 * (in jcdctmgr.c), NOT in this module.
 
72
 *
 
73
 * We have to do addition and subtraction of the integer inputs, which
 
74
 * is no problem, and multiplication by fractional constants, which is
 
75
 * a problem to do in integer arithmetic.  We multiply all the constants
 
76
 * by CONST_SCALE and convert them to integer constants (thus retaining
 
77
 * CONST_BITS bits of precision in the constants).  After doing a
 
78
 * multiplication we have to divide the product by CONST_SCALE, with proper
 
79
 * rounding, to produce the correct output.  This division can be done
 
80
 * cheaply as a right shift of CONST_BITS bits.  We postpone shifting
 
81
 * as long as possible so that partial sums can be added together with
 
82
 * full fractional precision.
 
83
 *
 
84
 * The outputs of the first pass are scaled up by PASS1_BITS bits so that
 
85
 * they are represented to better-than-integral precision.  These outputs
 
86
 * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
 
87
 * with the recommended scaling.  (For 12-bit sample data, the intermediate
 
88
 * array is INT32 anyway.)
 
89
 *
 
90
 * To avoid overflow of the 32-bit intermediate results in pass 2, we must
 
91
 * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26.  Error analysis
 
92
 * shows that the values given below are the most effective.
 
93
 */
 
94
 
 
95
#if BITS_IN_JSAMPLE == 8
 
96
#define CONST_BITS  13
 
97
#define PASS1_BITS  2
 
98
#else
 
99
#define CONST_BITS  13
 
100
#define PASS1_BITS  1           /* lose a little precision to avoid overflow */
 
101
#endif
 
102
 
 
103
/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
 
104
 * causing a lot of useless floating-point operations at run time.
 
105
 * To get around this we use the following pre-calculated constants.
 
106
 * If you change CONST_BITS you may want to add appropriate values.
 
107
 * (With a reasonable C compiler, you can just rely on the FIX() macro...)
 
108
 */
 
109
 
 
110
#if CONST_BITS == 13
 
111
#define FIX_0_298631336  ((INT32)  2446)        /* FIX(0.298631336) */
 
112
#define FIX_0_390180644  ((INT32)  3196)        /* FIX(0.390180644) */
 
113
#define FIX_0_541196100  ((INT32)  4433)        /* FIX(0.541196100) */
 
114
#define FIX_0_765366865  ((INT32)  6270)        /* FIX(0.765366865) */
 
115
#define FIX_0_899976223  ((INT32)  7373)        /* FIX(0.899976223) */
 
116
#define FIX_1_175875602  ((INT32)  9633)        /* FIX(1.175875602) */
 
117
#define FIX_1_501321110  ((INT32)  12299)       /* FIX(1.501321110) */
 
118
#define FIX_1_847759065  ((INT32)  15137)       /* FIX(1.847759065) */
 
119
#define FIX_1_961570560  ((INT32)  16069)       /* FIX(1.961570560) */
 
120
#define FIX_2_053119869  ((INT32)  16819)       /* FIX(2.053119869) */
 
121
#define FIX_2_562915447  ((INT32)  20995)       /* FIX(2.562915447) */
 
122
#define FIX_3_072711026  ((INT32)  25172)       /* FIX(3.072711026) */
 
123
#else
 
124
#define FIX_0_298631336  FIX(0.298631336)
 
125
#define FIX_0_390180644  FIX(0.390180644)
 
126
#define FIX_0_541196100  FIX(0.541196100)
 
127
#define FIX_0_765366865  FIX(0.765366865)
 
128
#define FIX_0_899976223  FIX(0.899976223)
 
129
#define FIX_1_175875602  FIX(1.175875602)
 
130
#define FIX_1_501321110  FIX(1.501321110)
 
131
#define FIX_1_847759065  FIX(1.847759065)
 
132
#define FIX_1_961570560  FIX(1.961570560)
 
133
#define FIX_2_053119869  FIX(2.053119869)
 
134
#define FIX_2_562915447  FIX(2.562915447)
 
135
#define FIX_3_072711026  FIX(3.072711026)
 
136
#endif
 
137
 
 
138
 
 
139
/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
 
140
 * For 8-bit samples with the recommended scaling, all the variable
 
141
 * and constant values involved are no more than 16 bits wide, so a
 
142
 * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
 
143
 * For 12-bit samples, a full 32-bit multiplication will be needed.
 
144
 */
 
145
 
 
146
#if BITS_IN_JSAMPLE == 8
 
147
#define MULTIPLY(var,const)  MULTIPLY16C16(var,const)
 
148
#else
 
149
#define MULTIPLY(var,const)  ((var) * (const))
 
150
#endif
 
151
 
 
152
 
 
153
/*
 
154
 * Perform the forward DCT on one block of samples.
 
155
 */
 
156
 
 
157
GLOBAL(void)
 
158
jpeg_fdct_islow (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
159
{
 
160
  INT32 tmp0, tmp1, tmp2, tmp3;
 
161
  INT32 tmp10, tmp11, tmp12, tmp13;
 
162
  INT32 z1;
 
163
  DCTELEM *dataptr;
 
164
  JSAMPROW elemptr;
 
165
  int ctr;
 
166
  SHIFT_TEMPS
 
167
 
 
168
  /* Pass 1: process rows. */
 
169
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
170
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
171
 
 
172
  dataptr = data;
 
173
  for (ctr = 0; ctr < DCTSIZE; ctr++) {
 
174
    elemptr = sample_data[ctr] + start_col;
 
175
 
 
176
    /* Even part per LL&M figure 1 --- note that published figure is faulty;
 
177
     * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
 
178
     */
 
179
 
 
180
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[7]);
 
181
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[6]);
 
182
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[5]);
 
183
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[4]);
 
184
 
 
185
    tmp10 = tmp0 + tmp3;
 
186
    tmp12 = tmp0 - tmp3;
 
187
    tmp11 = tmp1 + tmp2;
 
188
    tmp13 = tmp1 - tmp2;
 
189
 
 
190
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[7]);
 
191
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[6]);
 
192
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[5]);
 
193
    tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[4]);
 
194
 
 
195
    /* Apply unsigned->signed conversion */
 
196
    dataptr[0] = (DCTELEM) ((tmp10 + tmp11 - 8 * CENTERJSAMPLE) << PASS1_BITS);
 
197
    dataptr[4] = (DCTELEM) ((tmp10 - tmp11) << PASS1_BITS);
 
198
 
 
199
    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
 
200
    /* Add fudge factor here for final descale. */
 
201
    z1 += ONE << (CONST_BITS-PASS1_BITS-1);
 
202
    dataptr[2] = (DCTELEM) RIGHT_SHIFT(z1 + MULTIPLY(tmp12, FIX_0_765366865),
 
203
                                       CONST_BITS-PASS1_BITS);
 
204
    dataptr[6] = (DCTELEM) RIGHT_SHIFT(z1 - MULTIPLY(tmp13, FIX_1_847759065),
 
205
                                       CONST_BITS-PASS1_BITS);
 
206
 
 
207
    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
 
208
     * cK represents sqrt(2) * cos(K*pi/16).
 
209
     * i0..i3 in the paper are tmp0..tmp3 here.
 
210
     */
 
211
 
 
212
    tmp10 = tmp0 + tmp3;
 
213
    tmp11 = tmp1 + tmp2;
 
214
    tmp12 = tmp0 + tmp2;
 
215
    tmp13 = tmp1 + tmp3;
 
216
    z1 = MULTIPLY(tmp12 + tmp13, FIX_1_175875602); /*  c3 */
 
217
    /* Add fudge factor here for final descale. */
 
218
    z1 += ONE << (CONST_BITS-PASS1_BITS-1);
 
219
 
 
220
    tmp0  = MULTIPLY(tmp0,    FIX_1_501321110);    /*  c1+c3-c5-c7 */
 
221
    tmp1  = MULTIPLY(tmp1,    FIX_3_072711026);    /*  c1+c3+c5-c7 */
 
222
    tmp2  = MULTIPLY(tmp2,    FIX_2_053119869);    /*  c1+c3-c5+c7 */
 
223
    tmp3  = MULTIPLY(tmp3,    FIX_0_298631336);    /* -c1+c3+c5-c7 */
 
224
    tmp10 = MULTIPLY(tmp10, - FIX_0_899976223);    /*  c7-c3 */
 
225
    tmp11 = MULTIPLY(tmp11, - FIX_2_562915447);    /* -c1-c3 */
 
226
    tmp12 = MULTIPLY(tmp12, - FIX_0_390180644);    /*  c5-c3 */
 
227
    tmp13 = MULTIPLY(tmp13, - FIX_1_961570560);    /* -c3-c5 */
 
228
 
 
229
    tmp12 += z1;
 
230
    tmp13 += z1;
 
231
 
 
232
    dataptr[1] = (DCTELEM)
 
233
      RIGHT_SHIFT(tmp0 + tmp10 + tmp12, CONST_BITS-PASS1_BITS);
 
234
    dataptr[3] = (DCTELEM)
 
235
      RIGHT_SHIFT(tmp1 + tmp11 + tmp13, CONST_BITS-PASS1_BITS);
 
236
    dataptr[5] = (DCTELEM)
 
237
      RIGHT_SHIFT(tmp2 + tmp11 + tmp12, CONST_BITS-PASS1_BITS);
 
238
    dataptr[7] = (DCTELEM)
 
239
      RIGHT_SHIFT(tmp3 + tmp10 + tmp13, CONST_BITS-PASS1_BITS);
 
240
 
 
241
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
242
  }
 
243
 
 
244
  /* Pass 2: process columns.
 
245
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
246
   * by an overall factor of 8.
 
247
   */
 
248
 
 
249
  dataptr = data;
 
250
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
251
    /* Even part per LL&M figure 1 --- note that published figure is faulty;
 
252
     * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
 
253
     */
 
254
 
 
255
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
 
256
    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
 
257
    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
 
258
    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
 
259
 
 
260
    /* Add fudge factor here for final descale. */
 
261
    tmp10 = tmp0 + tmp3 + (ONE << (PASS1_BITS-1));
 
262
    tmp12 = tmp0 - tmp3;
 
263
    tmp11 = tmp1 + tmp2;
 
264
    tmp13 = tmp1 - tmp2;
 
265
 
 
266
    tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
 
267
    tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
 
268
    tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
 
269
    tmp3 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
 
270
 
 
271
    dataptr[DCTSIZE*0] = (DCTELEM) RIGHT_SHIFT(tmp10 + tmp11, PASS1_BITS);
 
272
    dataptr[DCTSIZE*4] = (DCTELEM) RIGHT_SHIFT(tmp10 - tmp11, PASS1_BITS);
 
273
 
 
274
    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
 
275
    /* Add fudge factor here for final descale. */
 
276
    z1 += ONE << (CONST_BITS+PASS1_BITS-1);
 
277
    dataptr[DCTSIZE*2] = (DCTELEM)
 
278
      RIGHT_SHIFT(z1 + MULTIPLY(tmp12, FIX_0_765366865), CONST_BITS+PASS1_BITS);
 
279
    dataptr[DCTSIZE*6] = (DCTELEM)
 
280
      RIGHT_SHIFT(z1 - MULTIPLY(tmp13, FIX_1_847759065), CONST_BITS+PASS1_BITS);
 
281
 
 
282
    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
 
283
     * cK represents sqrt(2) * cos(K*pi/16).
 
284
     * i0..i3 in the paper are tmp0..tmp3 here.
 
285
     */
 
286
 
 
287
    tmp10 = tmp0 + tmp3;
 
288
    tmp11 = tmp1 + tmp2;
 
289
    tmp12 = tmp0 + tmp2;
 
290
    tmp13 = tmp1 + tmp3;
 
291
    z1 = MULTIPLY(tmp12 + tmp13, FIX_1_175875602); /*  c3 */
 
292
    /* Add fudge factor here for final descale. */
 
293
    z1 += ONE << (CONST_BITS+PASS1_BITS-1);
 
294
 
 
295
    tmp0  = MULTIPLY(tmp0,    FIX_1_501321110);    /*  c1+c3-c5-c7 */
 
296
    tmp1  = MULTIPLY(tmp1,    FIX_3_072711026);    /*  c1+c3+c5-c7 */
 
297
    tmp2  = MULTIPLY(tmp2,    FIX_2_053119869);    /*  c1+c3-c5+c7 */
 
298
    tmp3  = MULTIPLY(tmp3,    FIX_0_298631336);    /* -c1+c3+c5-c7 */
 
299
    tmp10 = MULTIPLY(tmp10, - FIX_0_899976223);    /*  c7-c3 */
 
300
    tmp11 = MULTIPLY(tmp11, - FIX_2_562915447);    /* -c1-c3 */
 
301
    tmp12 = MULTIPLY(tmp12, - FIX_0_390180644);    /*  c5-c3 */
 
302
    tmp13 = MULTIPLY(tmp13, - FIX_1_961570560);    /* -c3-c5 */
 
303
 
 
304
    tmp12 += z1;
 
305
    tmp13 += z1;
 
306
 
 
307
    dataptr[DCTSIZE*1] = (DCTELEM)
 
308
      RIGHT_SHIFT(tmp0 + tmp10 + tmp12, CONST_BITS+PASS1_BITS);
 
309
    dataptr[DCTSIZE*3] = (DCTELEM)
 
310
      RIGHT_SHIFT(tmp1 + tmp11 + tmp13, CONST_BITS+PASS1_BITS);
 
311
    dataptr[DCTSIZE*5] = (DCTELEM)
 
312
      RIGHT_SHIFT(tmp2 + tmp11 + tmp12, CONST_BITS+PASS1_BITS);
 
313
    dataptr[DCTSIZE*7] = (DCTELEM)
 
314
      RIGHT_SHIFT(tmp3 + tmp10 + tmp13, CONST_BITS+PASS1_BITS);
 
315
 
 
316
    dataptr++;                  /* advance pointer to next column */
 
317
  }
 
318
}
 
319
 
 
320
#ifdef DCT_SCALING_SUPPORTED
 
321
 
 
322
 
 
323
/*
 
324
 * Perform the forward DCT on a 7x7 sample block.
 
325
 */
 
326
 
 
327
GLOBAL(void)
 
328
jpeg_fdct_7x7 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
329
{
 
330
  INT32 tmp0, tmp1, tmp2, tmp3;
 
331
  INT32 tmp10, tmp11, tmp12;
 
332
  INT32 z1, z2, z3;
 
333
  DCTELEM *dataptr;
 
334
  JSAMPROW elemptr;
 
335
  int ctr;
 
336
  SHIFT_TEMPS
 
337
 
 
338
  /* Pre-zero output coefficient block. */
 
339
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
340
 
 
341
  /* Pass 1: process rows. */
 
342
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
343
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
344
  /* cK represents sqrt(2) * cos(K*pi/14). */
 
345
 
 
346
  dataptr = data;
 
347
  for (ctr = 0; ctr < 7; ctr++) {
 
348
    elemptr = sample_data[ctr] + start_col;
 
349
 
 
350
    /* Even part */
 
351
 
 
352
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[6]);
 
353
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[5]);
 
354
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[4]);
 
355
    tmp3 = GETJSAMPLE(elemptr[3]);
 
356
 
 
357
    tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[6]);
 
358
    tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[5]);
 
359
    tmp12 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[4]);
 
360
 
 
361
    z1 = tmp0 + tmp2;
 
362
    /* Apply unsigned->signed conversion */
 
363
    dataptr[0] = (DCTELEM)
 
364
      ((z1 + tmp1 + tmp3 - 7 * CENTERJSAMPLE) << PASS1_BITS);
 
365
    tmp3 += tmp3;
 
366
    z1 -= tmp3;
 
367
    z1 -= tmp3;
 
368
    z1 = MULTIPLY(z1, FIX(0.353553391));                /* (c2+c6-c4)/2 */
 
369
    z2 = MULTIPLY(tmp0 - tmp2, FIX(0.920609002));       /* (c2+c4-c6)/2 */
 
370
    z3 = MULTIPLY(tmp1 - tmp2, FIX(0.314692123));       /* c6 */
 
371
    dataptr[2] = (DCTELEM) DESCALE(z1 + z2 + z3, CONST_BITS-PASS1_BITS);
 
372
    z1 -= z2;
 
373
    z2 = MULTIPLY(tmp0 - tmp1, FIX(0.881747734));       /* c4 */
 
374
    dataptr[4] = (DCTELEM)
 
375
      DESCALE(z2 + z3 - MULTIPLY(tmp1 - tmp3, FIX(0.707106781)), /* c2+c6-c4 */
 
376
              CONST_BITS-PASS1_BITS);
 
377
    dataptr[6] = (DCTELEM) DESCALE(z1 + z2, CONST_BITS-PASS1_BITS);
 
378
 
 
379
    /* Odd part */
 
380
 
 
381
    tmp1 = MULTIPLY(tmp10 + tmp11, FIX(0.935414347));   /* (c3+c1-c5)/2 */
 
382
    tmp2 = MULTIPLY(tmp10 - tmp11, FIX(0.170262339));   /* (c3+c5-c1)/2 */
 
383
    tmp0 = tmp1 - tmp2;
 
384
    tmp1 += tmp2;
 
385
    tmp2 = MULTIPLY(tmp11 + tmp12, - FIX(1.378756276)); /* -c1 */
 
386
    tmp1 += tmp2;
 
387
    tmp3 = MULTIPLY(tmp10 + tmp12, FIX(0.613604268));   /* c5 */
 
388
    tmp0 += tmp3;
 
389
    tmp2 += tmp3 + MULTIPLY(tmp12, FIX(1.870828693));   /* c3+c1-c5 */
 
390
 
 
391
    dataptr[1] = (DCTELEM) DESCALE(tmp0, CONST_BITS-PASS1_BITS);
 
392
    dataptr[3] = (DCTELEM) DESCALE(tmp1, CONST_BITS-PASS1_BITS);
 
393
    dataptr[5] = (DCTELEM) DESCALE(tmp2, CONST_BITS-PASS1_BITS);
 
394
 
 
395
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
396
  }
 
397
 
 
398
  /* Pass 2: process columns.
 
399
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
400
   * by an overall factor of 8.
 
401
   * We must also scale the output by (8/7)**2 = 64/49, which we fold
 
402
   * into the constant multipliers:
 
403
   * cK now represents sqrt(2) * cos(K*pi/14) * 64/49.
 
404
   */
 
405
 
 
406
  dataptr = data;
 
407
  for (ctr = 0; ctr < 7; ctr++) {
 
408
    /* Even part */
 
409
 
 
410
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*6];
 
411
    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*5];
 
412
    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*4];
 
413
    tmp3 = dataptr[DCTSIZE*3];
 
414
 
 
415
    tmp10 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*6];
 
416
    tmp11 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*5];
 
417
    tmp12 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*4];
 
418
 
 
419
    z1 = tmp0 + tmp2;
 
420
    dataptr[DCTSIZE*0] = (DCTELEM)
 
421
      DESCALE(MULTIPLY(z1 + tmp1 + tmp3, FIX(1.306122449)), /* 64/49 */
 
422
              CONST_BITS+PASS1_BITS);
 
423
    tmp3 += tmp3;
 
424
    z1 -= tmp3;
 
425
    z1 -= tmp3;
 
426
    z1 = MULTIPLY(z1, FIX(0.461784020));                /* (c2+c6-c4)/2 */
 
427
    z2 = MULTIPLY(tmp0 - tmp2, FIX(1.202428084));       /* (c2+c4-c6)/2 */
 
428
    z3 = MULTIPLY(tmp1 - tmp2, FIX(0.411026446));       /* c6 */
 
429
    dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(z1 + z2 + z3, CONST_BITS+PASS1_BITS);
 
430
    z1 -= z2;
 
431
    z2 = MULTIPLY(tmp0 - tmp1, FIX(1.151670509));       /* c4 */
 
432
    dataptr[DCTSIZE*4] = (DCTELEM)
 
433
      DESCALE(z2 + z3 - MULTIPLY(tmp1 - tmp3, FIX(0.923568041)), /* c2+c6-c4 */
 
434
              CONST_BITS+PASS1_BITS);
 
435
    dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(z1 + z2, CONST_BITS+PASS1_BITS);
 
436
 
 
437
    /* Odd part */
 
438
 
 
439
    tmp1 = MULTIPLY(tmp10 + tmp11, FIX(1.221765677));   /* (c3+c1-c5)/2 */
 
440
    tmp2 = MULTIPLY(tmp10 - tmp11, FIX(0.222383464));   /* (c3+c5-c1)/2 */
 
441
    tmp0 = tmp1 - tmp2;
 
442
    tmp1 += tmp2;
 
443
    tmp2 = MULTIPLY(tmp11 + tmp12, - FIX(1.800824523)); /* -c1 */
 
444
    tmp1 += tmp2;
 
445
    tmp3 = MULTIPLY(tmp10 + tmp12, FIX(0.801442310));   /* c5 */
 
446
    tmp0 += tmp3;
 
447
    tmp2 += tmp3 + MULTIPLY(tmp12, FIX(2.443531355));   /* c3+c1-c5 */
 
448
 
 
449
    dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp0, CONST_BITS+PASS1_BITS);
 
450
    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp1, CONST_BITS+PASS1_BITS);
 
451
    dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp2, CONST_BITS+PASS1_BITS);
 
452
 
 
453
    dataptr++;                  /* advance pointer to next column */
 
454
  }
 
455
}
 
456
 
 
457
 
 
458
/*
 
459
 * Perform the forward DCT on a 6x6 sample block.
 
460
 */
 
461
 
 
462
GLOBAL(void)
 
463
jpeg_fdct_6x6 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
464
{
 
465
  INT32 tmp0, tmp1, tmp2;
 
466
  INT32 tmp10, tmp11, tmp12;
 
467
  DCTELEM *dataptr;
 
468
  JSAMPROW elemptr;
 
469
  int ctr;
 
470
  SHIFT_TEMPS
 
471
 
 
472
  /* Pre-zero output coefficient block. */
 
473
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
474
 
 
475
  /* Pass 1: process rows. */
 
476
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
477
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
478
  /* cK represents sqrt(2) * cos(K*pi/12). */
 
479
 
 
480
  dataptr = data;
 
481
  for (ctr = 0; ctr < 6; ctr++) {
 
482
    elemptr = sample_data[ctr] + start_col;
 
483
 
 
484
    /* Even part */
 
485
 
 
486
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[5]);
 
487
    tmp11 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[4]);
 
488
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[3]);
 
489
 
 
490
    tmp10 = tmp0 + tmp2;
 
491
    tmp12 = tmp0 - tmp2;
 
492
 
 
493
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[5]);
 
494
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[4]);
 
495
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[3]);
 
496
 
 
497
    /* Apply unsigned->signed conversion */
 
498
    dataptr[0] = (DCTELEM)
 
499
      ((tmp10 + tmp11 - 6 * CENTERJSAMPLE) << PASS1_BITS);
 
500
    dataptr[2] = (DCTELEM)
 
501
      DESCALE(MULTIPLY(tmp12, FIX(1.224744871)),                 /* c2 */
 
502
              CONST_BITS-PASS1_BITS);
 
503
    dataptr[4] = (DCTELEM)
 
504
      DESCALE(MULTIPLY(tmp10 - tmp11 - tmp11, FIX(0.707106781)), /* c4 */
 
505
              CONST_BITS-PASS1_BITS);
 
506
 
 
507
    /* Odd part */
 
508
 
 
509
    tmp10 = DESCALE(MULTIPLY(tmp0 + tmp2, FIX(0.366025404)),     /* c5 */
 
510
                    CONST_BITS-PASS1_BITS);
 
511
 
 
512
    dataptr[1] = (DCTELEM) (tmp10 + ((tmp0 + tmp1) << PASS1_BITS));
 
513
    dataptr[3] = (DCTELEM) ((tmp0 - tmp1 - tmp2) << PASS1_BITS);
 
514
    dataptr[5] = (DCTELEM) (tmp10 + ((tmp2 - tmp1) << PASS1_BITS));
 
515
 
 
516
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
517
  }
 
518
 
 
519
  /* Pass 2: process columns.
 
520
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
521
   * by an overall factor of 8.
 
522
   * We must also scale the output by (8/6)**2 = 16/9, which we fold
 
523
   * into the constant multipliers:
 
524
   * cK now represents sqrt(2) * cos(K*pi/12) * 16/9.
 
525
   */
 
526
 
 
527
  dataptr = data;
 
528
  for (ctr = 0; ctr < 6; ctr++) {
 
529
    /* Even part */
 
530
 
 
531
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*5];
 
532
    tmp11 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*4];
 
533
    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*3];
 
534
 
 
535
    tmp10 = tmp0 + tmp2;
 
536
    tmp12 = tmp0 - tmp2;
 
537
 
 
538
    tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*5];
 
539
    tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*4];
 
540
    tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*3];
 
541
 
 
542
    dataptr[DCTSIZE*0] = (DCTELEM)
 
543
      DESCALE(MULTIPLY(tmp10 + tmp11, FIX(1.777777778)),         /* 16/9 */
 
544
              CONST_BITS+PASS1_BITS);
 
545
    dataptr[DCTSIZE*2] = (DCTELEM)
 
546
      DESCALE(MULTIPLY(tmp12, FIX(2.177324216)),                 /* c2 */
 
547
              CONST_BITS+PASS1_BITS);
 
548
    dataptr[DCTSIZE*4] = (DCTELEM)
 
549
      DESCALE(MULTIPLY(tmp10 - tmp11 - tmp11, FIX(1.257078722)), /* c4 */
 
550
              CONST_BITS+PASS1_BITS);
 
551
 
 
552
    /* Odd part */
 
553
 
 
554
    tmp10 = MULTIPLY(tmp0 + tmp2, FIX(0.650711829));             /* c5 */
 
555
 
 
556
    dataptr[DCTSIZE*1] = (DCTELEM)
 
557
      DESCALE(tmp10 + MULTIPLY(tmp0 + tmp1, FIX(1.777777778)),   /* 16/9 */
 
558
              CONST_BITS+PASS1_BITS);
 
559
    dataptr[DCTSIZE*3] = (DCTELEM)
 
560
      DESCALE(MULTIPLY(tmp0 - tmp1 - tmp2, FIX(1.777777778)),    /* 16/9 */
 
561
              CONST_BITS+PASS1_BITS);
 
562
    dataptr[DCTSIZE*5] = (DCTELEM)
 
563
      DESCALE(tmp10 + MULTIPLY(tmp2 - tmp1, FIX(1.777777778)),   /* 16/9 */
 
564
              CONST_BITS+PASS1_BITS);
 
565
 
 
566
    dataptr++;                  /* advance pointer to next column */
 
567
  }
 
568
}
 
569
 
 
570
 
 
571
/*
 
572
 * Perform the forward DCT on a 5x5 sample block.
 
573
 */
 
574
 
 
575
GLOBAL(void)
 
576
jpeg_fdct_5x5 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
577
{
 
578
  INT32 tmp0, tmp1, tmp2;
 
579
  INT32 tmp10, tmp11;
 
580
  DCTELEM *dataptr;
 
581
  JSAMPROW elemptr;
 
582
  int ctr;
 
583
  SHIFT_TEMPS
 
584
 
 
585
  /* Pre-zero output coefficient block. */
 
586
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
587
 
 
588
  /* Pass 1: process rows. */
 
589
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
590
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
591
  /* We scale the results further by 2 as part of output adaption */
 
592
  /* scaling for different DCT size. */
 
593
  /* cK represents sqrt(2) * cos(K*pi/10). */
 
594
 
 
595
  dataptr = data;
 
596
  for (ctr = 0; ctr < 5; ctr++) {
 
597
    elemptr = sample_data[ctr] + start_col;
 
598
 
 
599
    /* Even part */
 
600
 
 
601
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[4]);
 
602
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[3]);
 
603
    tmp2 = GETJSAMPLE(elemptr[2]);
 
604
 
 
605
    tmp10 = tmp0 + tmp1;
 
606
    tmp11 = tmp0 - tmp1;
 
607
 
 
608
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[4]);
 
609
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[3]);
 
610
 
 
611
    /* Apply unsigned->signed conversion */
 
612
    dataptr[0] = (DCTELEM)
 
613
      ((tmp10 + tmp2 - 5 * CENTERJSAMPLE) << (PASS1_BITS+1));
 
614
    tmp11 = MULTIPLY(tmp11, FIX(0.790569415));          /* (c2+c4)/2 */
 
615
    tmp10 -= tmp2 << 2;
 
616
    tmp10 = MULTIPLY(tmp10, FIX(0.353553391));          /* (c2-c4)/2 */
 
617
    dataptr[2] = (DCTELEM) DESCALE(tmp11 + tmp10, CONST_BITS-PASS1_BITS-1);
 
618
    dataptr[4] = (DCTELEM) DESCALE(tmp11 - tmp10, CONST_BITS-PASS1_BITS-1);
 
619
 
 
620
    /* Odd part */
 
621
 
 
622
    tmp10 = MULTIPLY(tmp0 + tmp1, FIX(0.831253876));    /* c3 */
 
623
 
 
624
    dataptr[1] = (DCTELEM)
 
625
      DESCALE(tmp10 + MULTIPLY(tmp0, FIX(0.513743148)), /* c1-c3 */
 
626
              CONST_BITS-PASS1_BITS-1);
 
627
    dataptr[3] = (DCTELEM)
 
628
      DESCALE(tmp10 - MULTIPLY(tmp1, FIX(2.176250899)), /* c1+c3 */
 
629
              CONST_BITS-PASS1_BITS-1);
 
630
 
 
631
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
632
  }
 
633
 
 
634
  /* Pass 2: process columns.
 
635
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
636
   * by an overall factor of 8.
 
637
   * We must also scale the output by (8/5)**2 = 64/25, which we partially
 
638
   * fold into the constant multipliers (other part was done in pass 1):
 
639
   * cK now represents sqrt(2) * cos(K*pi/10) * 32/25.
 
640
   */
 
641
 
 
642
  dataptr = data;
 
643
  for (ctr = 0; ctr < 5; ctr++) {
 
644
    /* Even part */
 
645
 
 
646
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*4];
 
647
    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*3];
 
648
    tmp2 = dataptr[DCTSIZE*2];
 
649
 
 
650
    tmp10 = tmp0 + tmp1;
 
651
    tmp11 = tmp0 - tmp1;
 
652
 
 
653
    tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*4];
 
654
    tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*3];
 
655
 
 
656
    dataptr[DCTSIZE*0] = (DCTELEM)
 
657
      DESCALE(MULTIPLY(tmp10 + tmp2, FIX(1.28)),        /* 32/25 */
 
658
              CONST_BITS+PASS1_BITS);
 
659
    tmp11 = MULTIPLY(tmp11, FIX(1.011928851));          /* (c2+c4)/2 */
 
660
    tmp10 -= tmp2 << 2;
 
661
    tmp10 = MULTIPLY(tmp10, FIX(0.452548340));          /* (c2-c4)/2 */
 
662
    dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(tmp11 + tmp10, CONST_BITS+PASS1_BITS);
 
663
    dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp11 - tmp10, CONST_BITS+PASS1_BITS);
 
664
 
 
665
    /* Odd part */
 
666
 
 
667
    tmp10 = MULTIPLY(tmp0 + tmp1, FIX(1.064004961));    /* c3 */
 
668
 
 
669
    dataptr[DCTSIZE*1] = (DCTELEM)
 
670
      DESCALE(tmp10 + MULTIPLY(tmp0, FIX(0.657591230)), /* c1-c3 */
 
671
              CONST_BITS+PASS1_BITS);
 
672
    dataptr[DCTSIZE*3] = (DCTELEM)
 
673
      DESCALE(tmp10 - MULTIPLY(tmp1, FIX(2.785601151)), /* c1+c3 */
 
674
              CONST_BITS+PASS1_BITS);
 
675
 
 
676
    dataptr++;                  /* advance pointer to next column */
 
677
  }
 
678
}
 
679
 
 
680
 
 
681
/*
 
682
 * Perform the forward DCT on a 4x4 sample block.
 
683
 */
 
684
 
 
685
GLOBAL(void)
 
686
jpeg_fdct_4x4 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
687
{
 
688
  INT32 tmp0, tmp1;
 
689
  INT32 tmp10, tmp11;
 
690
  DCTELEM *dataptr;
 
691
  JSAMPROW elemptr;
 
692
  int ctr;
 
693
  SHIFT_TEMPS
 
694
 
 
695
  /* Pre-zero output coefficient block. */
 
696
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
697
 
 
698
  /* Pass 1: process rows. */
 
699
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
700
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
701
  /* We must also scale the output by (8/4)**2 = 2**2, which we add here. */
 
702
  /* cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT]. */
 
703
 
 
704
  dataptr = data;
 
705
  for (ctr = 0; ctr < 4; ctr++) {
 
706
    elemptr = sample_data[ctr] + start_col;
 
707
 
 
708
    /* Even part */
 
709
 
 
710
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[3]);
 
711
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[2]);
 
712
 
 
713
    tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[3]);
 
714
    tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[2]);
 
715
 
 
716
    /* Apply unsigned->signed conversion */
 
717
    dataptr[0] = (DCTELEM)
 
718
      ((tmp0 + tmp1 - 4 * CENTERJSAMPLE) << (PASS1_BITS+2));
 
719
    dataptr[2] = (DCTELEM) ((tmp0 - tmp1) << (PASS1_BITS+2));
 
720
 
 
721
    /* Odd part */
 
722
 
 
723
    tmp0 = MULTIPLY(tmp10 + tmp11, FIX_0_541196100);       /* c6 */
 
724
    /* Add fudge factor here for final descale. */
 
725
    tmp0 += ONE << (CONST_BITS-PASS1_BITS-3);
 
726
 
 
727
    dataptr[1] = (DCTELEM)
 
728
      RIGHT_SHIFT(tmp0 + MULTIPLY(tmp10, FIX_0_765366865), /* c2-c6 */
 
729
                  CONST_BITS-PASS1_BITS-2);
 
730
    dataptr[3] = (DCTELEM)
 
731
      RIGHT_SHIFT(tmp0 - MULTIPLY(tmp11, FIX_1_847759065), /* c2+c6 */
 
732
                  CONST_BITS-PASS1_BITS-2);
 
733
 
 
734
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
735
  }
 
736
 
 
737
  /* Pass 2: process columns.
 
738
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
739
   * by an overall factor of 8.
 
740
   */
 
741
 
 
742
  dataptr = data;
 
743
  for (ctr = 0; ctr < 4; ctr++) {
 
744
    /* Even part */
 
745
 
 
746
    /* Add fudge factor here for final descale. */
 
747
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*3] + (ONE << (PASS1_BITS-1));
 
748
    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*2];
 
749
 
 
750
    tmp10 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*3];
 
751
    tmp11 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*2];
 
752
 
 
753
    dataptr[DCTSIZE*0] = (DCTELEM) RIGHT_SHIFT(tmp0 + tmp1, PASS1_BITS);
 
754
    dataptr[DCTSIZE*2] = (DCTELEM) RIGHT_SHIFT(tmp0 - tmp1, PASS1_BITS);
 
755
 
 
756
    /* Odd part */
 
757
 
 
758
    tmp0 = MULTIPLY(tmp10 + tmp11, FIX_0_541196100);       /* c6 */
 
759
    /* Add fudge factor here for final descale. */
 
760
    tmp0 += ONE << (CONST_BITS+PASS1_BITS-1);
 
761
 
 
762
    dataptr[DCTSIZE*1] = (DCTELEM)
 
763
      RIGHT_SHIFT(tmp0 + MULTIPLY(tmp10, FIX_0_765366865), /* c2-c6 */
 
764
                  CONST_BITS+PASS1_BITS);
 
765
    dataptr[DCTSIZE*3] = (DCTELEM)
 
766
      RIGHT_SHIFT(tmp0 - MULTIPLY(tmp11, FIX_1_847759065), /* c2+c6 */
 
767
                  CONST_BITS+PASS1_BITS);
 
768
 
 
769
    dataptr++;                  /* advance pointer to next column */
 
770
  }
 
771
}
 
772
 
 
773
 
 
774
/*
 
775
 * Perform the forward DCT on a 3x3 sample block.
 
776
 */
 
777
 
 
778
GLOBAL(void)
 
779
jpeg_fdct_3x3 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
780
{
 
781
  INT32 tmp0, tmp1, tmp2;
 
782
  DCTELEM *dataptr;
 
783
  JSAMPROW elemptr;
 
784
  int ctr;
 
785
  SHIFT_TEMPS
 
786
 
 
787
  /* Pre-zero output coefficient block. */
 
788
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
789
 
 
790
  /* Pass 1: process rows. */
 
791
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
792
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
793
  /* We scale the results further by 2**2 as part of output adaption */
 
794
  /* scaling for different DCT size. */
 
795
  /* cK represents sqrt(2) * cos(K*pi/6). */
 
796
 
 
797
  dataptr = data;
 
798
  for (ctr = 0; ctr < 3; ctr++) {
 
799
    elemptr = sample_data[ctr] + start_col;
 
800
 
 
801
    /* Even part */
 
802
 
 
803
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[2]);
 
804
    tmp1 = GETJSAMPLE(elemptr[1]);
 
805
 
 
806
    tmp2 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[2]);
 
807
 
 
808
    /* Apply unsigned->signed conversion */
 
809
    dataptr[0] = (DCTELEM)
 
810
      ((tmp0 + tmp1 - 3 * CENTERJSAMPLE) << (PASS1_BITS+2));
 
811
    dataptr[2] = (DCTELEM)
 
812
      DESCALE(MULTIPLY(tmp0 - tmp1 - tmp1, FIX(0.707106781)), /* c2 */
 
813
              CONST_BITS-PASS1_BITS-2);
 
814
 
 
815
    /* Odd part */
 
816
 
 
817
    dataptr[1] = (DCTELEM)
 
818
      DESCALE(MULTIPLY(tmp2, FIX(1.224744871)),               /* c1 */
 
819
              CONST_BITS-PASS1_BITS-2);
 
820
 
 
821
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
822
  }
 
823
 
 
824
  /* Pass 2: process columns.
 
825
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
826
   * by an overall factor of 8.
 
827
   * We must also scale the output by (8/3)**2 = 64/9, which we partially
 
828
   * fold into the constant multipliers (other part was done in pass 1):
 
829
   * cK now represents sqrt(2) * cos(K*pi/6) * 16/9.
 
830
   */
 
831
 
 
832
  dataptr = data;
 
833
  for (ctr = 0; ctr < 3; ctr++) {
 
834
    /* Even part */
 
835
 
 
836
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*2];
 
837
    tmp1 = dataptr[DCTSIZE*1];
 
838
 
 
839
    tmp2 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*2];
 
840
 
 
841
    dataptr[DCTSIZE*0] = (DCTELEM)
 
842
      DESCALE(MULTIPLY(tmp0 + tmp1, FIX(1.777777778)),        /* 16/9 */
 
843
              CONST_BITS+PASS1_BITS);
 
844
    dataptr[DCTSIZE*2] = (DCTELEM)
 
845
      DESCALE(MULTIPLY(tmp0 - tmp1 - tmp1, FIX(1.257078722)), /* c2 */
 
846
              CONST_BITS+PASS1_BITS);
 
847
 
 
848
    /* Odd part */
 
849
 
 
850
    dataptr[DCTSIZE*1] = (DCTELEM)
 
851
      DESCALE(MULTIPLY(tmp2, FIX(2.177324216)),               /* c1 */
 
852
              CONST_BITS+PASS1_BITS);
 
853
 
 
854
    dataptr++;                  /* advance pointer to next column */
 
855
  }
 
856
}
 
857
 
 
858
 
 
859
/*
 
860
 * Perform the forward DCT on a 2x2 sample block.
 
861
 */
 
862
 
 
863
GLOBAL(void)
 
864
jpeg_fdct_2x2 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
865
{
 
866
  INT32 tmp0, tmp1, tmp2, tmp3;
 
867
  JSAMPROW elemptr;
 
868
 
 
869
  /* Pre-zero output coefficient block. */
 
870
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
871
 
 
872
  /* Pass 1: process rows. */
 
873
  /* Note results are scaled up by sqrt(8) compared to a true DCT. */
 
874
 
 
875
  /* Row 0 */
 
876
  elemptr = sample_data[0] + start_col;
 
877
 
 
878
  tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[1]);
 
879
  tmp1 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[1]);
 
880
 
 
881
  /* Row 1 */
 
882
  elemptr = sample_data[1] + start_col;
 
883
 
 
884
  tmp2 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[1]);
 
885
  tmp3 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[1]);
 
886
 
 
887
  /* Pass 2: process columns.
 
888
   * We leave the results scaled up by an overall factor of 8.
 
889
   * We must also scale the output by (8/2)**2 = 2**4.
 
890
   */
 
891
 
 
892
  /* Column 0 */
 
893
  /* Apply unsigned->signed conversion */
 
894
  data[DCTSIZE*0] = (DCTELEM) ((tmp0 + tmp2 - 4 * CENTERJSAMPLE) << 4);
 
895
  data[DCTSIZE*1] = (DCTELEM) ((tmp0 - tmp2) << 4);
 
896
 
 
897
  /* Column 1 */
 
898
  data[DCTSIZE*0+1] = (DCTELEM) ((tmp1 + tmp3) << 4);
 
899
  data[DCTSIZE*1+1] = (DCTELEM) ((tmp1 - tmp3) << 4);
 
900
}
 
901
 
 
902
 
 
903
/*
 
904
 * Perform the forward DCT on a 1x1 sample block.
 
905
 */
 
906
 
 
907
GLOBAL(void)
 
908
jpeg_fdct_1x1 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
909
{
 
910
  /* Pre-zero output coefficient block. */
 
911
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
912
 
 
913
  /* We leave the result scaled up by an overall factor of 8. */
 
914
  /* We must also scale the output by (8/1)**2 = 2**6. */
 
915
  /* Apply unsigned->signed conversion */
 
916
  data[0] = (DCTELEM)
 
917
    ((GETJSAMPLE(sample_data[0][start_col]) - CENTERJSAMPLE) << 6);
 
918
}
 
919
 
 
920
 
 
921
/*
 
922
 * Perform the forward DCT on a 9x9 sample block.
 
923
 */
 
924
 
 
925
GLOBAL(void)
 
926
jpeg_fdct_9x9 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
927
{
 
928
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4;
 
929
  INT32 tmp10, tmp11, tmp12, tmp13;
 
930
  INT32 z1, z2;
 
931
  DCTELEM workspace[8];
 
932
  DCTELEM *dataptr;
 
933
  DCTELEM *wsptr;
 
934
  JSAMPROW elemptr;
 
935
  int ctr;
 
936
  SHIFT_TEMPS
 
937
 
 
938
  /* Pass 1: process rows. */
 
939
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
940
  /* we scale the results further by 2 as part of output adaption */
 
941
  /* scaling for different DCT size. */
 
942
  /* cK represents sqrt(2) * cos(K*pi/18). */
 
943
 
 
944
  dataptr = data;
 
945
  ctr = 0;
 
946
  for (;;) {
 
947
    elemptr = sample_data[ctr] + start_col;
 
948
 
 
949
    /* Even part */
 
950
 
 
951
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[8]);
 
952
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[7]);
 
953
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[6]);
 
954
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[5]);
 
955
    tmp4 = GETJSAMPLE(elemptr[4]);
 
956
 
 
957
    tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[8]);
 
958
    tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[7]);
 
959
    tmp12 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[6]);
 
960
    tmp13 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[5]);
 
961
 
 
962
    z1 = tmp0 + tmp2 + tmp3;
 
963
    z2 = tmp1 + tmp4;
 
964
    /* Apply unsigned->signed conversion */
 
965
    dataptr[0] = (DCTELEM) ((z1 + z2 - 9 * CENTERJSAMPLE) << 1);
 
966
    dataptr[6] = (DCTELEM)
 
967
      DESCALE(MULTIPLY(z1 - z2 - z2, FIX(0.707106781)),  /* c6 */
 
968
              CONST_BITS-1);
 
969
    z1 = MULTIPLY(tmp0 - tmp2, FIX(1.328926049));        /* c2 */
 
970
    z2 = MULTIPLY(tmp1 - tmp4 - tmp4, FIX(0.707106781)); /* c6 */
 
971
    dataptr[2] = (DCTELEM)
 
972
      DESCALE(MULTIPLY(tmp2 - tmp3, FIX(1.083350441))    /* c4 */
 
973
              + z1 + z2, CONST_BITS-1);
 
974
    dataptr[4] = (DCTELEM)
 
975
      DESCALE(MULTIPLY(tmp3 - tmp0, FIX(0.245575608))    /* c8 */
 
976
              + z1 - z2, CONST_BITS-1);
 
977
 
 
978
    /* Odd part */
 
979
 
 
980
    dataptr[3] = (DCTELEM)
 
981
      DESCALE(MULTIPLY(tmp10 - tmp12 - tmp13, FIX(1.224744871)), /* c3 */
 
982
              CONST_BITS-1);
 
983
 
 
984
    tmp11 = MULTIPLY(tmp11, FIX(1.224744871));        /* c3 */
 
985
    tmp0 = MULTIPLY(tmp10 + tmp12, FIX(0.909038955)); /* c5 */
 
986
    tmp1 = MULTIPLY(tmp10 + tmp13, FIX(0.483689525)); /* c7 */
 
987
 
 
988
    dataptr[1] = (DCTELEM) DESCALE(tmp11 + tmp0 + tmp1, CONST_BITS-1);
 
989
 
 
990
    tmp2 = MULTIPLY(tmp12 - tmp13, FIX(1.392728481)); /* c1 */
 
991
 
 
992
    dataptr[5] = (DCTELEM) DESCALE(tmp0 - tmp11 - tmp2, CONST_BITS-1);
 
993
    dataptr[7] = (DCTELEM) DESCALE(tmp1 - tmp11 + tmp2, CONST_BITS-1);
 
994
 
 
995
    ctr++;
 
996
 
 
997
    if (ctr != DCTSIZE) {
 
998
      if (ctr == 9)
 
999
        break;                  /* Done. */
 
1000
      dataptr += DCTSIZE;       /* advance pointer to next row */
 
1001
    } else
 
1002
      dataptr = workspace;      /* switch pointer to extended workspace */
 
1003
  }
 
1004
 
 
1005
  /* Pass 2: process columns.
 
1006
   * We leave the results scaled up by an overall factor of 8.
 
1007
   * We must also scale the output by (8/9)**2 = 64/81, which we partially
 
1008
   * fold into the constant multipliers and final/initial shifting:
 
1009
   * cK now represents sqrt(2) * cos(K*pi/18) * 128/81.
 
1010
   */
 
1011
 
 
1012
  dataptr = data;
 
1013
  wsptr = workspace;
 
1014
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
1015
    /* Even part */
 
1016
 
 
1017
    tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*0];
 
1018
    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*7];
 
1019
    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*6];
 
1020
    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*5];
 
1021
    tmp4 = dataptr[DCTSIZE*4];
 
1022
 
 
1023
    tmp10 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*0];
 
1024
    tmp11 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*7];
 
1025
    tmp12 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*6];
 
1026
    tmp13 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*5];
 
1027
 
 
1028
    z1 = tmp0 + tmp2 + tmp3;
 
1029
    z2 = tmp1 + tmp4;
 
1030
    dataptr[DCTSIZE*0] = (DCTELEM)
 
1031
      DESCALE(MULTIPLY(z1 + z2, FIX(1.580246914)),       /* 128/81 */
 
1032
              CONST_BITS+2);
 
1033
    dataptr[DCTSIZE*6] = (DCTELEM)
 
1034
      DESCALE(MULTIPLY(z1 - z2 - z2, FIX(1.117403309)),  /* c6 */
 
1035
              CONST_BITS+2);
 
1036
    z1 = MULTIPLY(tmp0 - tmp2, FIX(2.100031287));        /* c2 */
 
1037
    z2 = MULTIPLY(tmp1 - tmp4 - tmp4, FIX(1.117403309)); /* c6 */
 
1038
    dataptr[DCTSIZE*2] = (DCTELEM)
 
1039
      DESCALE(MULTIPLY(tmp2 - tmp3, FIX(1.711961190))    /* c4 */
 
1040
              + z1 + z2, CONST_BITS+2);
 
1041
    dataptr[DCTSIZE*4] = (DCTELEM)
 
1042
      DESCALE(MULTIPLY(tmp3 - tmp0, FIX(0.388070096))    /* c8 */
 
1043
              + z1 - z2, CONST_BITS+2);
 
1044
 
 
1045
    /* Odd part */
 
1046
 
 
1047
    dataptr[DCTSIZE*3] = (DCTELEM)
 
1048
      DESCALE(MULTIPLY(tmp10 - tmp12 - tmp13, FIX(1.935399303)), /* c3 */
 
1049
              CONST_BITS+2);
 
1050
 
 
1051
    tmp11 = MULTIPLY(tmp11, FIX(1.935399303));        /* c3 */
 
1052
    tmp0 = MULTIPLY(tmp10 + tmp12, FIX(1.436506004)); /* c5 */
 
1053
    tmp1 = MULTIPLY(tmp10 + tmp13, FIX(0.764348879)); /* c7 */
 
1054
 
 
1055
    dataptr[DCTSIZE*1] = (DCTELEM)
 
1056
      DESCALE(tmp11 + tmp0 + tmp1, CONST_BITS+2);
 
1057
 
 
1058
    tmp2 = MULTIPLY(tmp12 - tmp13, FIX(2.200854883)); /* c1 */
 
1059
 
 
1060
    dataptr[DCTSIZE*5] = (DCTELEM)
 
1061
      DESCALE(tmp0 - tmp11 - tmp2, CONST_BITS+2);
 
1062
    dataptr[DCTSIZE*7] = (DCTELEM)
 
1063
      DESCALE(tmp1 - tmp11 + tmp2, CONST_BITS+2);
 
1064
 
 
1065
    dataptr++;                  /* advance pointer to next column */
 
1066
    wsptr++;                    /* advance pointer to next column */
 
1067
  }
 
1068
}
 
1069
 
 
1070
 
 
1071
/*
 
1072
 * Perform the forward DCT on a 10x10 sample block.
 
1073
 */
 
1074
 
 
1075
GLOBAL(void)
 
1076
jpeg_fdct_10x10 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
1077
{
 
1078
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4;
 
1079
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
 
1080
  DCTELEM workspace[8*2];
 
1081
  DCTELEM *dataptr;
 
1082
  DCTELEM *wsptr;
 
1083
  JSAMPROW elemptr;
 
1084
  int ctr;
 
1085
  SHIFT_TEMPS
 
1086
 
 
1087
  /* Pass 1: process rows. */
 
1088
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
1089
  /* we scale the results further by 2 as part of output adaption */
 
1090
  /* scaling for different DCT size. */
 
1091
  /* cK represents sqrt(2) * cos(K*pi/20). */
 
1092
 
 
1093
  dataptr = data;
 
1094
  ctr = 0;
 
1095
  for (;;) {
 
1096
    elemptr = sample_data[ctr] + start_col;
 
1097
 
 
1098
    /* Even part */
 
1099
 
 
1100
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[9]);
 
1101
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[8]);
 
1102
    tmp12 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[7]);
 
1103
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[6]);
 
1104
    tmp4 = GETJSAMPLE(elemptr[4]) + GETJSAMPLE(elemptr[5]);
 
1105
 
 
1106
    tmp10 = tmp0 + tmp4;
 
1107
    tmp13 = tmp0 - tmp4;
 
1108
    tmp11 = tmp1 + tmp3;
 
1109
    tmp14 = tmp1 - tmp3;
 
1110
 
 
1111
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[9]);
 
1112
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[8]);
 
1113
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[7]);
 
1114
    tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[6]);
 
1115
    tmp4 = GETJSAMPLE(elemptr[4]) - GETJSAMPLE(elemptr[5]);
 
1116
 
 
1117
    /* Apply unsigned->signed conversion */
 
1118
    dataptr[0] = (DCTELEM)
 
1119
      ((tmp10 + tmp11 + tmp12 - 10 * CENTERJSAMPLE) << 1);
 
1120
    tmp12 += tmp12;
 
1121
    dataptr[4] = (DCTELEM)
 
1122
      DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.144122806)) - /* c4 */
 
1123
              MULTIPLY(tmp11 - tmp12, FIX(0.437016024)),  /* c8 */
 
1124
              CONST_BITS-1);
 
1125
    tmp10 = MULTIPLY(tmp13 + tmp14, FIX(0.831253876));    /* c6 */
 
1126
    dataptr[2] = (DCTELEM)
 
1127
      DESCALE(tmp10 + MULTIPLY(tmp13, FIX(0.513743148)),  /* c2-c6 */
 
1128
              CONST_BITS-1);
 
1129
    dataptr[6] = (DCTELEM)
 
1130
      DESCALE(tmp10 - MULTIPLY(tmp14, FIX(2.176250899)),  /* c2+c6 */
 
1131
              CONST_BITS-1);
 
1132
 
 
1133
    /* Odd part */
 
1134
 
 
1135
    tmp10 = tmp0 + tmp4;
 
1136
    tmp11 = tmp1 - tmp3;
 
1137
    dataptr[5] = (DCTELEM) ((tmp10 - tmp11 - tmp2) << 1);
 
1138
    tmp2 <<= CONST_BITS;
 
1139
    dataptr[1] = (DCTELEM)
 
1140
      DESCALE(MULTIPLY(tmp0, FIX(1.396802247)) +          /* c1 */
 
1141
              MULTIPLY(tmp1, FIX(1.260073511)) + tmp2 +   /* c3 */
 
1142
              MULTIPLY(tmp3, FIX(0.642039522)) +          /* c7 */
 
1143
              MULTIPLY(tmp4, FIX(0.221231742)),           /* c9 */
 
1144
              CONST_BITS-1);
 
1145
    tmp12 = MULTIPLY(tmp0 - tmp4, FIX(0.951056516)) -     /* (c3+c7)/2 */
 
1146
            MULTIPLY(tmp1 + tmp3, FIX(0.587785252));      /* (c1-c9)/2 */
 
1147
    tmp13 = MULTIPLY(tmp10 + tmp11, FIX(0.309016994)) +   /* (c3-c7)/2 */
 
1148
            (tmp11 << (CONST_BITS - 1)) - tmp2;
 
1149
    dataptr[3] = (DCTELEM) DESCALE(tmp12 + tmp13, CONST_BITS-1);
 
1150
    dataptr[7] = (DCTELEM) DESCALE(tmp12 - tmp13, CONST_BITS-1);
 
1151
 
 
1152
    ctr++;
 
1153
 
 
1154
    if (ctr != DCTSIZE) {
 
1155
      if (ctr == 10)
 
1156
        break;                  /* Done. */
 
1157
      dataptr += DCTSIZE;       /* advance pointer to next row */
 
1158
    } else
 
1159
      dataptr = workspace;      /* switch pointer to extended workspace */
 
1160
  }
 
1161
 
 
1162
  /* Pass 2: process columns.
 
1163
   * We leave the results scaled up by an overall factor of 8.
 
1164
   * We must also scale the output by (8/10)**2 = 16/25, which we partially
 
1165
   * fold into the constant multipliers and final/initial shifting:
 
1166
   * cK now represents sqrt(2) * cos(K*pi/20) * 32/25.
 
1167
   */
 
1168
 
 
1169
  dataptr = data;
 
1170
  wsptr = workspace;
 
1171
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
1172
    /* Even part */
 
1173
 
 
1174
    tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*1];
 
1175
    tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*0];
 
1176
    tmp12 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*7];
 
1177
    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*6];
 
1178
    tmp4 = dataptr[DCTSIZE*4] + dataptr[DCTSIZE*5];
 
1179
 
 
1180
    tmp10 = tmp0 + tmp4;
 
1181
    tmp13 = tmp0 - tmp4;
 
1182
    tmp11 = tmp1 + tmp3;
 
1183
    tmp14 = tmp1 - tmp3;
 
1184
 
 
1185
    tmp0 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*1];
 
1186
    tmp1 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*0];
 
1187
    tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*7];
 
1188
    tmp3 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*6];
 
1189
    tmp4 = dataptr[DCTSIZE*4] - dataptr[DCTSIZE*5];
 
1190
 
 
1191
    dataptr[DCTSIZE*0] = (DCTELEM)
 
1192
      DESCALE(MULTIPLY(tmp10 + tmp11 + tmp12, FIX(1.28)), /* 32/25 */
 
1193
              CONST_BITS+2);
 
1194
    tmp12 += tmp12;
 
1195
    dataptr[DCTSIZE*4] = (DCTELEM)
 
1196
      DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.464477191)) - /* c4 */
 
1197
              MULTIPLY(tmp11 - tmp12, FIX(0.559380511)),  /* c8 */
 
1198
              CONST_BITS+2);
 
1199
    tmp10 = MULTIPLY(tmp13 + tmp14, FIX(1.064004961));    /* c6 */
 
1200
    dataptr[DCTSIZE*2] = (DCTELEM)
 
1201
      DESCALE(tmp10 + MULTIPLY(tmp13, FIX(0.657591230)),  /* c2-c6 */
 
1202
              CONST_BITS+2);
 
1203
    dataptr[DCTSIZE*6] = (DCTELEM)
 
1204
      DESCALE(tmp10 - MULTIPLY(tmp14, FIX(2.785601151)),  /* c2+c6 */
 
1205
              CONST_BITS+2);
 
1206
 
 
1207
    /* Odd part */
 
1208
 
 
1209
    tmp10 = tmp0 + tmp4;
 
1210
    tmp11 = tmp1 - tmp3;
 
1211
    dataptr[DCTSIZE*5] = (DCTELEM)
 
1212
      DESCALE(MULTIPLY(tmp10 - tmp11 - tmp2, FIX(1.28)),  /* 32/25 */
 
1213
              CONST_BITS+2);
 
1214
    tmp2 = MULTIPLY(tmp2, FIX(1.28));                     /* 32/25 */
 
1215
    dataptr[DCTSIZE*1] = (DCTELEM)
 
1216
      DESCALE(MULTIPLY(tmp0, FIX(1.787906876)) +          /* c1 */
 
1217
              MULTIPLY(tmp1, FIX(1.612894094)) + tmp2 +   /* c3 */
 
1218
              MULTIPLY(tmp3, FIX(0.821810588)) +          /* c7 */
 
1219
              MULTIPLY(tmp4, FIX(0.283176630)),           /* c9 */
 
1220
              CONST_BITS+2);
 
1221
    tmp12 = MULTIPLY(tmp0 - tmp4, FIX(1.217352341)) -     /* (c3+c7)/2 */
 
1222
            MULTIPLY(tmp1 + tmp3, FIX(0.752365123));      /* (c1-c9)/2 */
 
1223
    tmp13 = MULTIPLY(tmp10 + tmp11, FIX(0.395541753)) +   /* (c3-c7)/2 */
 
1224
            MULTIPLY(tmp11, FIX(0.64)) - tmp2;            /* 16/25 */
 
1225
    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp12 + tmp13, CONST_BITS+2);
 
1226
    dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp12 - tmp13, CONST_BITS+2);
 
1227
 
 
1228
    dataptr++;                  /* advance pointer to next column */
 
1229
    wsptr++;                    /* advance pointer to next column */
 
1230
  }
 
1231
}
 
1232
 
 
1233
 
 
1234
/*
 
1235
 * Perform the forward DCT on an 11x11 sample block.
 
1236
 */
 
1237
 
 
1238
GLOBAL(void)
 
1239
jpeg_fdct_11x11 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
1240
{
 
1241
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
 
1242
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
 
1243
  INT32 z1, z2, z3;
 
1244
  DCTELEM workspace[8*3];
 
1245
  DCTELEM *dataptr;
 
1246
  DCTELEM *wsptr;
 
1247
  JSAMPROW elemptr;
 
1248
  int ctr;
 
1249
  SHIFT_TEMPS
 
1250
 
 
1251
  /* Pass 1: process rows. */
 
1252
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
1253
  /* we scale the results further by 2 as part of output adaption */
 
1254
  /* scaling for different DCT size. */
 
1255
  /* cK represents sqrt(2) * cos(K*pi/22). */
 
1256
 
 
1257
  dataptr = data;
 
1258
  ctr = 0;
 
1259
  for (;;) {
 
1260
    elemptr = sample_data[ctr] + start_col;
 
1261
 
 
1262
    /* Even part */
 
1263
 
 
1264
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[10]);
 
1265
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[9]);
 
1266
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[8]);
 
1267
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[7]);
 
1268
    tmp4 = GETJSAMPLE(elemptr[4]) + GETJSAMPLE(elemptr[6]);
 
1269
    tmp5 = GETJSAMPLE(elemptr[5]);
 
1270
 
 
1271
    tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[10]);
 
1272
    tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[9]);
 
1273
    tmp12 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[8]);
 
1274
    tmp13 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[7]);
 
1275
    tmp14 = GETJSAMPLE(elemptr[4]) - GETJSAMPLE(elemptr[6]);
 
1276
 
 
1277
    /* Apply unsigned->signed conversion */
 
1278
    dataptr[0] = (DCTELEM)
 
1279
      ((tmp0 + tmp1 + tmp2 + tmp3 + tmp4 + tmp5 - 11 * CENTERJSAMPLE) << 1);
 
1280
    tmp5 += tmp5;
 
1281
    tmp0 -= tmp5;
 
1282
    tmp1 -= tmp5;
 
1283
    tmp2 -= tmp5;
 
1284
    tmp3 -= tmp5;
 
1285
    tmp4 -= tmp5;
 
1286
    z1 = MULTIPLY(tmp0 + tmp3, FIX(1.356927976)) +       /* c2 */
 
1287
         MULTIPLY(tmp2 + tmp4, FIX(0.201263574));        /* c10 */
 
1288
    z2 = MULTIPLY(tmp1 - tmp3, FIX(0.926112931));        /* c6 */
 
1289
    z3 = MULTIPLY(tmp0 - tmp1, FIX(1.189712156));        /* c4 */
 
1290
    dataptr[2] = (DCTELEM)
 
1291
      DESCALE(z1 + z2 - MULTIPLY(tmp3, FIX(1.018300590)) /* c2+c8-c6 */
 
1292
              - MULTIPLY(tmp4, FIX(1.390975730)),        /* c4+c10 */
 
1293
              CONST_BITS-1);
 
1294
    dataptr[4] = (DCTELEM)
 
1295
      DESCALE(z2 + z3 + MULTIPLY(tmp1, FIX(0.062335650)) /* c4-c6-c10 */
 
1296
              - MULTIPLY(tmp2, FIX(1.356927976))         /* c2 */
 
1297
              + MULTIPLY(tmp4, FIX(0.587485545)),        /* c8 */
 
1298
              CONST_BITS-1);
 
1299
    dataptr[6] = (DCTELEM)
 
1300
      DESCALE(z1 + z3 - MULTIPLY(tmp0, FIX(1.620527200)) /* c2+c4-c6 */
 
1301
              - MULTIPLY(tmp2, FIX(0.788749120)),        /* c8+c10 */
 
1302
              CONST_BITS-1);
 
1303
 
 
1304
    /* Odd part */
 
1305
 
 
1306
    tmp1 = MULTIPLY(tmp10 + tmp11, FIX(1.286413905));    /* c3 */
 
1307
    tmp2 = MULTIPLY(tmp10 + tmp12, FIX(1.068791298));    /* c5 */
 
1308
    tmp3 = MULTIPLY(tmp10 + tmp13, FIX(0.764581576));    /* c7 */
 
1309
    tmp0 = tmp1 + tmp2 + tmp3 - MULTIPLY(tmp10, FIX(1.719967871)) /* c7+c5+c3-c1 */
 
1310
           + MULTIPLY(tmp14, FIX(0.398430003));          /* c9 */
 
1311
    tmp4 = MULTIPLY(tmp11 + tmp12, - FIX(0.764581576));  /* -c7 */
 
1312
    tmp5 = MULTIPLY(tmp11 + tmp13, - FIX(1.399818907));  /* -c1 */
 
1313
    tmp1 += tmp4 + tmp5 + MULTIPLY(tmp11, FIX(1.276416582)) /* c9+c7+c1-c3 */
 
1314
            - MULTIPLY(tmp14, FIX(1.068791298));         /* c5 */
 
1315
    tmp10 = MULTIPLY(tmp12 + tmp13, FIX(0.398430003));   /* c9 */
 
1316
    tmp2 += tmp4 + tmp10 - MULTIPLY(tmp12, FIX(1.989053629)) /* c9+c5+c3-c7 */
 
1317
            + MULTIPLY(tmp14, FIX(1.399818907));         /* c1 */
 
1318
    tmp3 += tmp5 + tmp10 + MULTIPLY(tmp13, FIX(1.305598626)) /* c1+c5-c9-c7 */
 
1319
            - MULTIPLY(tmp14, FIX(1.286413905));         /* c3 */
 
1320
 
 
1321
    dataptr[1] = (DCTELEM) DESCALE(tmp0, CONST_BITS-1);
 
1322
    dataptr[3] = (DCTELEM) DESCALE(tmp1, CONST_BITS-1);
 
1323
    dataptr[5] = (DCTELEM) DESCALE(tmp2, CONST_BITS-1);
 
1324
    dataptr[7] = (DCTELEM) DESCALE(tmp3, CONST_BITS-1);
 
1325
 
 
1326
    ctr++;
 
1327
 
 
1328
    if (ctr != DCTSIZE) {
 
1329
      if (ctr == 11)
 
1330
        break;                  /* Done. */
 
1331
      dataptr += DCTSIZE;       /* advance pointer to next row */
 
1332
    } else
 
1333
      dataptr = workspace;      /* switch pointer to extended workspace */
 
1334
  }
 
1335
 
 
1336
  /* Pass 2: process columns.
 
1337
   * We leave the results scaled up by an overall factor of 8.
 
1338
   * We must also scale the output by (8/11)**2 = 64/121, which we partially
 
1339
   * fold into the constant multipliers and final/initial shifting:
 
1340
   * cK now represents sqrt(2) * cos(K*pi/22) * 128/121.
 
1341
   */
 
1342
 
 
1343
  dataptr = data;
 
1344
  wsptr = workspace;
 
1345
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
1346
    /* Even part */
 
1347
 
 
1348
    tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*2];
 
1349
    tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*1];
 
1350
    tmp2 = dataptr[DCTSIZE*2] + wsptr[DCTSIZE*0];
 
1351
    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*7];
 
1352
    tmp4 = dataptr[DCTSIZE*4] + dataptr[DCTSIZE*6];
 
1353
    tmp5 = dataptr[DCTSIZE*5];
 
1354
 
 
1355
    tmp10 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*2];
 
1356
    tmp11 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*1];
 
1357
    tmp12 = dataptr[DCTSIZE*2] - wsptr[DCTSIZE*0];
 
1358
    tmp13 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*7];
 
1359
    tmp14 = dataptr[DCTSIZE*4] - dataptr[DCTSIZE*6];
 
1360
 
 
1361
    dataptr[DCTSIZE*0] = (DCTELEM)
 
1362
      DESCALE(MULTIPLY(tmp0 + tmp1 + tmp2 + tmp3 + tmp4 + tmp5,
 
1363
                       FIX(1.057851240)),                /* 128/121 */
 
1364
              CONST_BITS+2);
 
1365
    tmp5 += tmp5;
 
1366
    tmp0 -= tmp5;
 
1367
    tmp1 -= tmp5;
 
1368
    tmp2 -= tmp5;
 
1369
    tmp3 -= tmp5;
 
1370
    tmp4 -= tmp5;
 
1371
    z1 = MULTIPLY(tmp0 + tmp3, FIX(1.435427942)) +       /* c2 */
 
1372
         MULTIPLY(tmp2 + tmp4, FIX(0.212906922));        /* c10 */
 
1373
    z2 = MULTIPLY(tmp1 - tmp3, FIX(0.979689713));        /* c6 */
 
1374
    z3 = MULTIPLY(tmp0 - tmp1, FIX(1.258538479));        /* c4 */
 
1375
    dataptr[DCTSIZE*2] = (DCTELEM)
 
1376
      DESCALE(z1 + z2 - MULTIPLY(tmp3, FIX(1.077210542)) /* c2+c8-c6 */
 
1377
              - MULTIPLY(tmp4, FIX(1.471445400)),        /* c4+c10 */
 
1378
              CONST_BITS+2);
 
1379
    dataptr[DCTSIZE*4] = (DCTELEM)
 
1380
      DESCALE(z2 + z3 + MULTIPLY(tmp1, FIX(0.065941844)) /* c4-c6-c10 */
 
1381
              - MULTIPLY(tmp2, FIX(1.435427942))         /* c2 */
 
1382
              + MULTIPLY(tmp4, FIX(0.621472312)),        /* c8 */
 
1383
              CONST_BITS+2);
 
1384
    dataptr[DCTSIZE*6] = (DCTELEM)
 
1385
      DESCALE(z1 + z3 - MULTIPLY(tmp0, FIX(1.714276708)) /* c2+c4-c6 */
 
1386
              - MULTIPLY(tmp2, FIX(0.834379234)),        /* c8+c10 */
 
1387
              CONST_BITS+2);
 
1388
 
 
1389
    /* Odd part */
 
1390
 
 
1391
    tmp1 = MULTIPLY(tmp10 + tmp11, FIX(1.360834544));    /* c3 */
 
1392
    tmp2 = MULTIPLY(tmp10 + tmp12, FIX(1.130622199));    /* c5 */
 
1393
    tmp3 = MULTIPLY(tmp10 + tmp13, FIX(0.808813568));    /* c7 */
 
1394
    tmp0 = tmp1 + tmp2 + tmp3 - MULTIPLY(tmp10, FIX(1.819470145)) /* c7+c5+c3-c1 */
 
1395
           + MULTIPLY(tmp14, FIX(0.421479672));          /* c9 */
 
1396
    tmp4 = MULTIPLY(tmp11 + tmp12, - FIX(0.808813568));  /* -c7 */
 
1397
    tmp5 = MULTIPLY(tmp11 + tmp13, - FIX(1.480800167));  /* -c1 */
 
1398
    tmp1 += tmp4 + tmp5 + MULTIPLY(tmp11, FIX(1.350258864)) /* c9+c7+c1-c3 */
 
1399
            - MULTIPLY(tmp14, FIX(1.130622199));         /* c5 */
 
1400
    tmp10 = MULTIPLY(tmp12 + tmp13, FIX(0.421479672));   /* c9 */
 
1401
    tmp2 += tmp4 + tmp10 - MULTIPLY(tmp12, FIX(2.104122847)) /* c9+c5+c3-c7 */
 
1402
            + MULTIPLY(tmp14, FIX(1.480800167));         /* c1 */
 
1403
    tmp3 += tmp5 + tmp10 + MULTIPLY(tmp13, FIX(1.381129125)) /* c1+c5-c9-c7 */
 
1404
            - MULTIPLY(tmp14, FIX(1.360834544));         /* c3 */
 
1405
 
 
1406
    dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp0, CONST_BITS+2);
 
1407
    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp1, CONST_BITS+2);
 
1408
    dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp2, CONST_BITS+2);
 
1409
    dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp3, CONST_BITS+2);
 
1410
 
 
1411
    dataptr++;                  /* advance pointer to next column */
 
1412
    wsptr++;                    /* advance pointer to next column */
 
1413
  }
 
1414
}
 
1415
 
 
1416
 
 
1417
/*
 
1418
 * Perform the forward DCT on a 12x12 sample block.
 
1419
 */
 
1420
 
 
1421
GLOBAL(void)
 
1422
jpeg_fdct_12x12 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
1423
{
 
1424
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
 
1425
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
 
1426
  DCTELEM workspace[8*4];
 
1427
  DCTELEM *dataptr;
 
1428
  DCTELEM *wsptr;
 
1429
  JSAMPROW elemptr;
 
1430
  int ctr;
 
1431
  SHIFT_TEMPS
 
1432
 
 
1433
  /* Pass 1: process rows. */
 
1434
  /* Note results are scaled up by sqrt(8) compared to a true DCT. */
 
1435
  /* cK represents sqrt(2) * cos(K*pi/24). */
 
1436
 
 
1437
  dataptr = data;
 
1438
  ctr = 0;
 
1439
  for (;;) {
 
1440
    elemptr = sample_data[ctr] + start_col;
 
1441
 
 
1442
    /* Even part */
 
1443
 
 
1444
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[11]);
 
1445
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[10]);
 
1446
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[9]);
 
1447
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[8]);
 
1448
    tmp4 = GETJSAMPLE(elemptr[4]) + GETJSAMPLE(elemptr[7]);
 
1449
    tmp5 = GETJSAMPLE(elemptr[5]) + GETJSAMPLE(elemptr[6]);
 
1450
 
 
1451
    tmp10 = tmp0 + tmp5;
 
1452
    tmp13 = tmp0 - tmp5;
 
1453
    tmp11 = tmp1 + tmp4;
 
1454
    tmp14 = tmp1 - tmp4;
 
1455
    tmp12 = tmp2 + tmp3;
 
1456
    tmp15 = tmp2 - tmp3;
 
1457
 
 
1458
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[11]);
 
1459
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[10]);
 
1460
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[9]);
 
1461
    tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[8]);
 
1462
    tmp4 = GETJSAMPLE(elemptr[4]) - GETJSAMPLE(elemptr[7]);
 
1463
    tmp5 = GETJSAMPLE(elemptr[5]) - GETJSAMPLE(elemptr[6]);
 
1464
 
 
1465
    /* Apply unsigned->signed conversion */
 
1466
    dataptr[0] = (DCTELEM) (tmp10 + tmp11 + tmp12 - 12 * CENTERJSAMPLE);
 
1467
    dataptr[6] = (DCTELEM) (tmp13 - tmp14 - tmp15);
 
1468
    dataptr[4] = (DCTELEM)
 
1469
      DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.224744871)), /* c4 */
 
1470
              CONST_BITS);
 
1471
    dataptr[2] = (DCTELEM)
 
1472
      DESCALE(tmp14 - tmp15 + MULTIPLY(tmp13 + tmp15, FIX(1.366025404)), /* c2 */
 
1473
              CONST_BITS);
 
1474
 
 
1475
    /* Odd part */
 
1476
 
 
1477
    tmp10 = MULTIPLY(tmp1 + tmp4, FIX_0_541196100);    /* c9 */
 
1478
    tmp14 = tmp10 + MULTIPLY(tmp1, FIX_0_765366865);   /* c3-c9 */
 
1479
    tmp15 = tmp10 - MULTIPLY(tmp4, FIX_1_847759065);   /* c3+c9 */
 
1480
    tmp12 = MULTIPLY(tmp0 + tmp2, FIX(1.121971054));   /* c5 */
 
1481
    tmp13 = MULTIPLY(tmp0 + tmp3, FIX(0.860918669));   /* c7 */
 
1482
    tmp10 = tmp12 + tmp13 + tmp14 - MULTIPLY(tmp0, FIX(0.580774953)) /* c5+c7-c1 */
 
1483
            + MULTIPLY(tmp5, FIX(0.184591911));        /* c11 */
 
1484
    tmp11 = MULTIPLY(tmp2 + tmp3, - FIX(0.184591911)); /* -c11 */
 
1485
    tmp12 += tmp11 - tmp15 - MULTIPLY(tmp2, FIX(2.339493912)) /* c1+c5-c11 */
 
1486
            + MULTIPLY(tmp5, FIX(0.860918669));        /* c7 */
 
1487
    tmp13 += tmp11 - tmp14 + MULTIPLY(tmp3, FIX(0.725788011)) /* c1+c11-c7 */
 
1488
            - MULTIPLY(tmp5, FIX(1.121971054));        /* c5 */
 
1489
    tmp11 = tmp15 + MULTIPLY(tmp0 - tmp3, FIX(1.306562965)) /* c3 */
 
1490
            - MULTIPLY(tmp2 + tmp5, FIX_0_541196100);  /* c9 */
 
1491
 
 
1492
    dataptr[1] = (DCTELEM) DESCALE(tmp10, CONST_BITS);
 
1493
    dataptr[3] = (DCTELEM) DESCALE(tmp11, CONST_BITS);
 
1494
    dataptr[5] = (DCTELEM) DESCALE(tmp12, CONST_BITS);
 
1495
    dataptr[7] = (DCTELEM) DESCALE(tmp13, CONST_BITS);
 
1496
 
 
1497
    ctr++;
 
1498
 
 
1499
    if (ctr != DCTSIZE) {
 
1500
      if (ctr == 12)
 
1501
        break;                  /* Done. */
 
1502
      dataptr += DCTSIZE;       /* advance pointer to next row */
 
1503
    } else
 
1504
      dataptr = workspace;      /* switch pointer to extended workspace */
 
1505
  }
 
1506
 
 
1507
  /* Pass 2: process columns.
 
1508
   * We leave the results scaled up by an overall factor of 8.
 
1509
   * We must also scale the output by (8/12)**2 = 4/9, which we partially
 
1510
   * fold into the constant multipliers and final shifting:
 
1511
   * cK now represents sqrt(2) * cos(K*pi/24) * 8/9.
 
1512
   */
 
1513
 
 
1514
  dataptr = data;
 
1515
  wsptr = workspace;
 
1516
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
1517
    /* Even part */
 
1518
 
 
1519
    tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*3];
 
1520
    tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*2];
 
1521
    tmp2 = dataptr[DCTSIZE*2] + wsptr[DCTSIZE*1];
 
1522
    tmp3 = dataptr[DCTSIZE*3] + wsptr[DCTSIZE*0];
 
1523
    tmp4 = dataptr[DCTSIZE*4] + dataptr[DCTSIZE*7];
 
1524
    tmp5 = dataptr[DCTSIZE*5] + dataptr[DCTSIZE*6];
 
1525
 
 
1526
    tmp10 = tmp0 + tmp5;
 
1527
    tmp13 = tmp0 - tmp5;
 
1528
    tmp11 = tmp1 + tmp4;
 
1529
    tmp14 = tmp1 - tmp4;
 
1530
    tmp12 = tmp2 + tmp3;
 
1531
    tmp15 = tmp2 - tmp3;
 
1532
 
 
1533
    tmp0 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*3];
 
1534
    tmp1 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*2];
 
1535
    tmp2 = dataptr[DCTSIZE*2] - wsptr[DCTSIZE*1];
 
1536
    tmp3 = dataptr[DCTSIZE*3] - wsptr[DCTSIZE*0];
 
1537
    tmp4 = dataptr[DCTSIZE*4] - dataptr[DCTSIZE*7];
 
1538
    tmp5 = dataptr[DCTSIZE*5] - dataptr[DCTSIZE*6];
 
1539
 
 
1540
    dataptr[DCTSIZE*0] = (DCTELEM)
 
1541
      DESCALE(MULTIPLY(tmp10 + tmp11 + tmp12, FIX(0.888888889)), /* 8/9 */
 
1542
              CONST_BITS+1);
 
1543
    dataptr[DCTSIZE*6] = (DCTELEM)
 
1544
      DESCALE(MULTIPLY(tmp13 - tmp14 - tmp15, FIX(0.888888889)), /* 8/9 */
 
1545
              CONST_BITS+1);
 
1546
    dataptr[DCTSIZE*4] = (DCTELEM)
 
1547
      DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.088662108)),         /* c4 */
 
1548
              CONST_BITS+1);
 
1549
    dataptr[DCTSIZE*2] = (DCTELEM)
 
1550
      DESCALE(MULTIPLY(tmp14 - tmp15, FIX(0.888888889)) +        /* 8/9 */
 
1551
              MULTIPLY(tmp13 + tmp15, FIX(1.214244803)),         /* c2 */
 
1552
              CONST_BITS+1);
 
1553
 
 
1554
    /* Odd part */
 
1555
 
 
1556
    tmp10 = MULTIPLY(tmp1 + tmp4, FIX(0.481063200));   /* c9 */
 
1557
    tmp14 = tmp10 + MULTIPLY(tmp1, FIX(0.680326102));  /* c3-c9 */
 
1558
    tmp15 = tmp10 - MULTIPLY(tmp4, FIX(1.642452502));  /* c3+c9 */
 
1559
    tmp12 = MULTIPLY(tmp0 + tmp2, FIX(0.997307603));   /* c5 */
 
1560
    tmp13 = MULTIPLY(tmp0 + tmp3, FIX(0.765261039));   /* c7 */
 
1561
    tmp10 = tmp12 + tmp13 + tmp14 - MULTIPLY(tmp0, FIX(0.516244403)) /* c5+c7-c1 */
 
1562
            + MULTIPLY(tmp5, FIX(0.164081699));        /* c11 */
 
1563
    tmp11 = MULTIPLY(tmp2 + tmp3, - FIX(0.164081699)); /* -c11 */
 
1564
    tmp12 += tmp11 - tmp15 - MULTIPLY(tmp2, FIX(2.079550144)) /* c1+c5-c11 */
 
1565
            + MULTIPLY(tmp5, FIX(0.765261039));        /* c7 */
 
1566
    tmp13 += tmp11 - tmp14 + MULTIPLY(tmp3, FIX(0.645144899)) /* c1+c11-c7 */
 
1567
            - MULTIPLY(tmp5, FIX(0.997307603));        /* c5 */
 
1568
    tmp11 = tmp15 + MULTIPLY(tmp0 - tmp3, FIX(1.161389302)) /* c3 */
 
1569
            - MULTIPLY(tmp2 + tmp5, FIX(0.481063200)); /* c9 */
 
1570
 
 
1571
    dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp10, CONST_BITS+1);
 
1572
    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp11, CONST_BITS+1);
 
1573
    dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp12, CONST_BITS+1);
 
1574
    dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp13, CONST_BITS+1);
 
1575
 
 
1576
    dataptr++;                  /* advance pointer to next column */
 
1577
    wsptr++;                    /* advance pointer to next column */
 
1578
  }
 
1579
}
 
1580
 
 
1581
 
 
1582
/*
 
1583
 * Perform the forward DCT on a 13x13 sample block.
 
1584
 */
 
1585
 
 
1586
GLOBAL(void)
 
1587
jpeg_fdct_13x13 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
1588
{
 
1589
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
 
1590
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
 
1591
  INT32 z1, z2;
 
1592
  DCTELEM workspace[8*5];
 
1593
  DCTELEM *dataptr;
 
1594
  DCTELEM *wsptr;
 
1595
  JSAMPROW elemptr;
 
1596
  int ctr;
 
1597
  SHIFT_TEMPS
 
1598
 
 
1599
  /* Pass 1: process rows. */
 
1600
  /* Note results are scaled up by sqrt(8) compared to a true DCT. */
 
1601
  /* cK represents sqrt(2) * cos(K*pi/26). */
 
1602
 
 
1603
  dataptr = data;
 
1604
  ctr = 0;
 
1605
  for (;;) {
 
1606
    elemptr = sample_data[ctr] + start_col;
 
1607
 
 
1608
    /* Even part */
 
1609
 
 
1610
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[12]);
 
1611
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[11]);
 
1612
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[10]);
 
1613
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[9]);
 
1614
    tmp4 = GETJSAMPLE(elemptr[4]) + GETJSAMPLE(elemptr[8]);
 
1615
    tmp5 = GETJSAMPLE(elemptr[5]) + GETJSAMPLE(elemptr[7]);
 
1616
    tmp6 = GETJSAMPLE(elemptr[6]);
 
1617
 
 
1618
    tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[12]);
 
1619
    tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[11]);
 
1620
    tmp12 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[10]);
 
1621
    tmp13 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[9]);
 
1622
    tmp14 = GETJSAMPLE(elemptr[4]) - GETJSAMPLE(elemptr[8]);
 
1623
    tmp15 = GETJSAMPLE(elemptr[5]) - GETJSAMPLE(elemptr[7]);
 
1624
 
 
1625
    /* Apply unsigned->signed conversion */
 
1626
    dataptr[0] = (DCTELEM)
 
1627
      (tmp0 + tmp1 + tmp2 + tmp3 + tmp4 + tmp5 + tmp6 - 13 * CENTERJSAMPLE);
 
1628
    tmp6 += tmp6;
 
1629
    tmp0 -= tmp6;
 
1630
    tmp1 -= tmp6;
 
1631
    tmp2 -= tmp6;
 
1632
    tmp3 -= tmp6;
 
1633
    tmp4 -= tmp6;
 
1634
    tmp5 -= tmp6;
 
1635
    dataptr[2] = (DCTELEM)
 
1636
      DESCALE(MULTIPLY(tmp0, FIX(1.373119086)) +   /* c2 */
 
1637
              MULTIPLY(tmp1, FIX(1.058554052)) +   /* c6 */
 
1638
              MULTIPLY(tmp2, FIX(0.501487041)) -   /* c10 */
 
1639
              MULTIPLY(tmp3, FIX(0.170464608)) -   /* c12 */
 
1640
              MULTIPLY(tmp4, FIX(0.803364869)) -   /* c8 */
 
1641
              MULTIPLY(tmp5, FIX(1.252223920)),    /* c4 */
 
1642
              CONST_BITS);
 
1643
    z1 = MULTIPLY(tmp0 - tmp2, FIX(1.155388986)) - /* (c4+c6)/2 */
 
1644
         MULTIPLY(tmp3 - tmp4, FIX(0.435816023)) - /* (c2-c10)/2 */
 
1645
         MULTIPLY(tmp1 - tmp5, FIX(0.316450131));  /* (c8-c12)/2 */
 
1646
    z2 = MULTIPLY(tmp0 + tmp2, FIX(0.096834934)) - /* (c4-c6)/2 */
 
1647
         MULTIPLY(tmp3 + tmp4, FIX(0.937303064)) + /* (c2+c10)/2 */
 
1648
         MULTIPLY(tmp1 + tmp5, FIX(0.486914739));  /* (c8+c12)/2 */
 
1649
 
 
1650
    dataptr[4] = (DCTELEM) DESCALE(z1 + z2, CONST_BITS);
 
1651
    dataptr[6] = (DCTELEM) DESCALE(z1 - z2, CONST_BITS);
 
1652
 
 
1653
    /* Odd part */
 
1654
 
 
1655
    tmp1 = MULTIPLY(tmp10 + tmp11, FIX(1.322312651));   /* c3 */
 
1656
    tmp2 = MULTIPLY(tmp10 + tmp12, FIX(1.163874945));   /* c5 */
 
1657
    tmp3 = MULTIPLY(tmp10 + tmp13, FIX(0.937797057)) +  /* c7 */
 
1658
           MULTIPLY(tmp14 + tmp15, FIX(0.338443458));   /* c11 */
 
1659
    tmp0 = tmp1 + tmp2 + tmp3 -
 
1660
           MULTIPLY(tmp10, FIX(2.020082300)) +          /* c3+c5+c7-c1 */
 
1661
           MULTIPLY(tmp14, FIX(0.318774355));           /* c9-c11 */
 
1662
    tmp4 = MULTIPLY(tmp14 - tmp15, FIX(0.937797057)) -  /* c7 */
 
1663
           MULTIPLY(tmp11 + tmp12, FIX(0.338443458));   /* c11 */
 
1664
    tmp5 = MULTIPLY(tmp11 + tmp13, - FIX(1.163874945)); /* -c5 */
 
1665
    tmp1 += tmp4 + tmp5 +
 
1666
            MULTIPLY(tmp11, FIX(0.837223564)) -         /* c5+c9+c11-c3 */
 
1667
            MULTIPLY(tmp14, FIX(2.341699410));          /* c1+c7 */
 
1668
    tmp6 = MULTIPLY(tmp12 + tmp13, - FIX(0.657217813)); /* -c9 */
 
1669
    tmp2 += tmp4 + tmp6 -
 
1670
            MULTIPLY(tmp12, FIX(1.572116027)) +         /* c1+c5-c9-c11 */
 
1671
            MULTIPLY(tmp15, FIX(2.260109708));          /* c3+c7 */
 
1672
    tmp3 += tmp5 + tmp6 +
 
1673
            MULTIPLY(tmp13, FIX(2.205608352)) -         /* c3+c5+c9-c7 */
 
1674
            MULTIPLY(tmp15, FIX(1.742345811));          /* c1+c11 */
 
1675
 
 
1676
    dataptr[1] = (DCTELEM) DESCALE(tmp0, CONST_BITS);
 
1677
    dataptr[3] = (DCTELEM) DESCALE(tmp1, CONST_BITS);
 
1678
    dataptr[5] = (DCTELEM) DESCALE(tmp2, CONST_BITS);
 
1679
    dataptr[7] = (DCTELEM) DESCALE(tmp3, CONST_BITS);
 
1680
 
 
1681
    ctr++;
 
1682
 
 
1683
    if (ctr != DCTSIZE) {
 
1684
      if (ctr == 13)
 
1685
        break;                  /* Done. */
 
1686
      dataptr += DCTSIZE;       /* advance pointer to next row */
 
1687
    } else
 
1688
      dataptr = workspace;      /* switch pointer to extended workspace */
 
1689
  }
 
1690
 
 
1691
  /* Pass 2: process columns.
 
1692
   * We leave the results scaled up by an overall factor of 8.
 
1693
   * We must also scale the output by (8/13)**2 = 64/169, which we partially
 
1694
   * fold into the constant multipliers and final shifting:
 
1695
   * cK now represents sqrt(2) * cos(K*pi/26) * 128/169.
 
1696
   */
 
1697
 
 
1698
  dataptr = data;
 
1699
  wsptr = workspace;
 
1700
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
1701
    /* Even part */
 
1702
 
 
1703
    tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*4];
 
1704
    tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*3];
 
1705
    tmp2 = dataptr[DCTSIZE*2] + wsptr[DCTSIZE*2];
 
1706
    tmp3 = dataptr[DCTSIZE*3] + wsptr[DCTSIZE*1];
 
1707
    tmp4 = dataptr[DCTSIZE*4] + wsptr[DCTSIZE*0];
 
1708
    tmp5 = dataptr[DCTSIZE*5] + dataptr[DCTSIZE*7];
 
1709
    tmp6 = dataptr[DCTSIZE*6];
 
1710
 
 
1711
    tmp10 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*4];
 
1712
    tmp11 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*3];
 
1713
    tmp12 = dataptr[DCTSIZE*2] - wsptr[DCTSIZE*2];
 
1714
    tmp13 = dataptr[DCTSIZE*3] - wsptr[DCTSIZE*1];
 
1715
    tmp14 = dataptr[DCTSIZE*4] - wsptr[DCTSIZE*0];
 
1716
    tmp15 = dataptr[DCTSIZE*5] - dataptr[DCTSIZE*7];
 
1717
 
 
1718
    dataptr[DCTSIZE*0] = (DCTELEM)
 
1719
      DESCALE(MULTIPLY(tmp0 + tmp1 + tmp2 + tmp3 + tmp4 + tmp5 + tmp6,
 
1720
                       FIX(0.757396450)),          /* 128/169 */
 
1721
              CONST_BITS+1);
 
1722
    tmp6 += tmp6;
 
1723
    tmp0 -= tmp6;
 
1724
    tmp1 -= tmp6;
 
1725
    tmp2 -= tmp6;
 
1726
    tmp3 -= tmp6;
 
1727
    tmp4 -= tmp6;
 
1728
    tmp5 -= tmp6;
 
1729
    dataptr[DCTSIZE*2] = (DCTELEM)
 
1730
      DESCALE(MULTIPLY(tmp0, FIX(1.039995521)) +   /* c2 */
 
1731
              MULTIPLY(tmp1, FIX(0.801745081)) +   /* c6 */
 
1732
              MULTIPLY(tmp2, FIX(0.379824504)) -   /* c10 */
 
1733
              MULTIPLY(tmp3, FIX(0.129109289)) -   /* c12 */
 
1734
              MULTIPLY(tmp4, FIX(0.608465700)) -   /* c8 */
 
1735
              MULTIPLY(tmp5, FIX(0.948429952)),    /* c4 */
 
1736
              CONST_BITS+1);
 
1737
    z1 = MULTIPLY(tmp0 - tmp2, FIX(0.875087516)) - /* (c4+c6)/2 */
 
1738
         MULTIPLY(tmp3 - tmp4, FIX(0.330085509)) - /* (c2-c10)/2 */
 
1739
         MULTIPLY(tmp1 - tmp5, FIX(0.239678205));  /* (c8-c12)/2 */
 
1740
    z2 = MULTIPLY(tmp0 + tmp2, FIX(0.073342435)) - /* (c4-c6)/2 */
 
1741
         MULTIPLY(tmp3 + tmp4, FIX(0.709910013)) + /* (c2+c10)/2 */
 
1742
         MULTIPLY(tmp1 + tmp5, FIX(0.368787494));  /* (c8+c12)/2 */
 
1743
 
 
1744
    dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(z1 + z2, CONST_BITS+1);
 
1745
    dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(z1 - z2, CONST_BITS+1);
 
1746
 
 
1747
    /* Odd part */
 
1748
 
 
1749
    tmp1 = MULTIPLY(tmp10 + tmp11, FIX(1.001514908));   /* c3 */
 
1750
    tmp2 = MULTIPLY(tmp10 + tmp12, FIX(0.881514751));   /* c5 */
 
1751
    tmp3 = MULTIPLY(tmp10 + tmp13, FIX(0.710284161)) +  /* c7 */
 
1752
           MULTIPLY(tmp14 + tmp15, FIX(0.256335874));   /* c11 */
 
1753
    tmp0 = tmp1 + tmp2 + tmp3 -
 
1754
           MULTIPLY(tmp10, FIX(1.530003162)) +          /* c3+c5+c7-c1 */
 
1755
           MULTIPLY(tmp14, FIX(0.241438564));           /* c9-c11 */
 
1756
    tmp4 = MULTIPLY(tmp14 - tmp15, FIX(0.710284161)) -  /* c7 */
 
1757
           MULTIPLY(tmp11 + tmp12, FIX(0.256335874));   /* c11 */
 
1758
    tmp5 = MULTIPLY(tmp11 + tmp13, - FIX(0.881514751)); /* -c5 */
 
1759
    tmp1 += tmp4 + tmp5 +
 
1760
            MULTIPLY(tmp11, FIX(0.634110155)) -         /* c5+c9+c11-c3 */
 
1761
            MULTIPLY(tmp14, FIX(1.773594819));          /* c1+c7 */
 
1762
    tmp6 = MULTIPLY(tmp12 + tmp13, - FIX(0.497774438)); /* -c9 */
 
1763
    tmp2 += tmp4 + tmp6 -
 
1764
            MULTIPLY(tmp12, FIX(1.190715098)) +         /* c1+c5-c9-c11 */
 
1765
            MULTIPLY(tmp15, FIX(1.711799069));          /* c3+c7 */
 
1766
    tmp3 += tmp5 + tmp6 +
 
1767
            MULTIPLY(tmp13, FIX(1.670519935)) -         /* c3+c5+c9-c7 */
 
1768
            MULTIPLY(tmp15, FIX(1.319646532));          /* c1+c11 */
 
1769
 
 
1770
    dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp0, CONST_BITS+1);
 
1771
    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp1, CONST_BITS+1);
 
1772
    dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp2, CONST_BITS+1);
 
1773
    dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp3, CONST_BITS+1);
 
1774
 
 
1775
    dataptr++;                  /* advance pointer to next column */
 
1776
    wsptr++;                    /* advance pointer to next column */
 
1777
  }
 
1778
}
 
1779
 
 
1780
 
 
1781
/*
 
1782
 * Perform the forward DCT on a 14x14 sample block.
 
1783
 */
 
1784
 
 
1785
GLOBAL(void)
 
1786
jpeg_fdct_14x14 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
1787
{
 
1788
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
 
1789
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
 
1790
  DCTELEM workspace[8*6];
 
1791
  DCTELEM *dataptr;
 
1792
  DCTELEM *wsptr;
 
1793
  JSAMPROW elemptr;
 
1794
  int ctr;
 
1795
  SHIFT_TEMPS
 
1796
 
 
1797
  /* Pass 1: process rows. */
 
1798
  /* Note results are scaled up by sqrt(8) compared to a true DCT. */
 
1799
  /* cK represents sqrt(2) * cos(K*pi/28). */
 
1800
 
 
1801
  dataptr = data;
 
1802
  ctr = 0;
 
1803
  for (;;) {
 
1804
    elemptr = sample_data[ctr] + start_col;
 
1805
 
 
1806
    /* Even part */
 
1807
 
 
1808
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[13]);
 
1809
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[12]);
 
1810
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[11]);
 
1811
    tmp13 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[10]);
 
1812
    tmp4 = GETJSAMPLE(elemptr[4]) + GETJSAMPLE(elemptr[9]);
 
1813
    tmp5 = GETJSAMPLE(elemptr[5]) + GETJSAMPLE(elemptr[8]);
 
1814
    tmp6 = GETJSAMPLE(elemptr[6]) + GETJSAMPLE(elemptr[7]);
 
1815
 
 
1816
    tmp10 = tmp0 + tmp6;
 
1817
    tmp14 = tmp0 - tmp6;
 
1818
    tmp11 = tmp1 + tmp5;
 
1819
    tmp15 = tmp1 - tmp5;
 
1820
    tmp12 = tmp2 + tmp4;
 
1821
    tmp16 = tmp2 - tmp4;
 
1822
 
 
1823
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[13]);
 
1824
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[12]);
 
1825
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[11]);
 
1826
    tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[10]);
 
1827
    tmp4 = GETJSAMPLE(elemptr[4]) - GETJSAMPLE(elemptr[9]);
 
1828
    tmp5 = GETJSAMPLE(elemptr[5]) - GETJSAMPLE(elemptr[8]);
 
1829
    tmp6 = GETJSAMPLE(elemptr[6]) - GETJSAMPLE(elemptr[7]);
 
1830
 
 
1831
    /* Apply unsigned->signed conversion */
 
1832
    dataptr[0] = (DCTELEM)
 
1833
      (tmp10 + tmp11 + tmp12 + tmp13 - 14 * CENTERJSAMPLE);
 
1834
    tmp13 += tmp13;
 
1835
    dataptr[4] = (DCTELEM)
 
1836
      DESCALE(MULTIPLY(tmp10 - tmp13, FIX(1.274162392)) + /* c4 */
 
1837
              MULTIPLY(tmp11 - tmp13, FIX(0.314692123)) - /* c12 */
 
1838
              MULTIPLY(tmp12 - tmp13, FIX(0.881747734)),  /* c8 */
 
1839
              CONST_BITS);
 
1840
 
 
1841
    tmp10 = MULTIPLY(tmp14 + tmp15, FIX(1.105676686));    /* c6 */
 
1842
 
 
1843
    dataptr[2] = (DCTELEM)
 
1844
      DESCALE(tmp10 + MULTIPLY(tmp14, FIX(0.273079590))   /* c2-c6 */
 
1845
              + MULTIPLY(tmp16, FIX(0.613604268)),        /* c10 */
 
1846
              CONST_BITS);
 
1847
    dataptr[6] = (DCTELEM)
 
1848
      DESCALE(tmp10 - MULTIPLY(tmp15, FIX(1.719280954))   /* c6+c10 */
 
1849
              - MULTIPLY(tmp16, FIX(1.378756276)),        /* c2 */
 
1850
              CONST_BITS);
 
1851
 
 
1852
    /* Odd part */
 
1853
 
 
1854
    tmp10 = tmp1 + tmp2;
 
1855
    tmp11 = tmp5 - tmp4;
 
1856
    dataptr[7] = (DCTELEM) (tmp0 - tmp10 + tmp3 - tmp11 - tmp6);
 
1857
    tmp3 <<= CONST_BITS;
 
1858
    tmp10 = MULTIPLY(tmp10, - FIX(0.158341681));          /* -c13 */
 
1859
    tmp11 = MULTIPLY(tmp11, FIX(1.405321284));            /* c1 */
 
1860
    tmp10 += tmp11 - tmp3;
 
1861
    tmp11 = MULTIPLY(tmp0 + tmp2, FIX(1.197448846)) +     /* c5 */
 
1862
            MULTIPLY(tmp4 + tmp6, FIX(0.752406978));      /* c9 */
 
1863
    dataptr[5] = (DCTELEM)
 
1864
      DESCALE(tmp10 + tmp11 - MULTIPLY(tmp2, FIX(2.373959773)) /* c3+c5-c13 */
 
1865
              + MULTIPLY(tmp4, FIX(1.119999435)),         /* c1+c11-c9 */
 
1866
              CONST_BITS);
 
1867
    tmp12 = MULTIPLY(tmp0 + tmp1, FIX(1.334852607)) +     /* c3 */
 
1868
            MULTIPLY(tmp5 - tmp6, FIX(0.467085129));      /* c11 */
 
1869
    dataptr[3] = (DCTELEM)
 
1870
      DESCALE(tmp10 + tmp12 - MULTIPLY(tmp1, FIX(0.424103948)) /* c3-c9-c13 */
 
1871
              - MULTIPLY(tmp5, FIX(3.069855259)),         /* c1+c5+c11 */
 
1872
              CONST_BITS);
 
1873
    dataptr[1] = (DCTELEM)
 
1874
      DESCALE(tmp11 + tmp12 + tmp3 + tmp6 -
 
1875
              MULTIPLY(tmp0 + tmp6, FIX(1.126980169)),    /* c3+c5-c1 */
 
1876
              CONST_BITS);
 
1877
 
 
1878
    ctr++;
 
1879
 
 
1880
    if (ctr != DCTSIZE) {
 
1881
      if (ctr == 14)
 
1882
        break;                  /* Done. */
 
1883
      dataptr += DCTSIZE;       /* advance pointer to next row */
 
1884
    } else
 
1885
      dataptr = workspace;      /* switch pointer to extended workspace */
 
1886
  }
 
1887
 
 
1888
  /* Pass 2: process columns.
 
1889
   * We leave the results scaled up by an overall factor of 8.
 
1890
   * We must also scale the output by (8/14)**2 = 16/49, which we partially
 
1891
   * fold into the constant multipliers and final shifting:
 
1892
   * cK now represents sqrt(2) * cos(K*pi/28) * 32/49.
 
1893
   */
 
1894
 
 
1895
  dataptr = data;
 
1896
  wsptr = workspace;
 
1897
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
1898
    /* Even part */
 
1899
 
 
1900
    tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*5];
 
1901
    tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*4];
 
1902
    tmp2 = dataptr[DCTSIZE*2] + wsptr[DCTSIZE*3];
 
1903
    tmp13 = dataptr[DCTSIZE*3] + wsptr[DCTSIZE*2];
 
1904
    tmp4 = dataptr[DCTSIZE*4] + wsptr[DCTSIZE*1];
 
1905
    tmp5 = dataptr[DCTSIZE*5] + wsptr[DCTSIZE*0];
 
1906
    tmp6 = dataptr[DCTSIZE*6] + dataptr[DCTSIZE*7];
 
1907
 
 
1908
    tmp10 = tmp0 + tmp6;
 
1909
    tmp14 = tmp0 - tmp6;
 
1910
    tmp11 = tmp1 + tmp5;
 
1911
    tmp15 = tmp1 - tmp5;
 
1912
    tmp12 = tmp2 + tmp4;
 
1913
    tmp16 = tmp2 - tmp4;
 
1914
 
 
1915
    tmp0 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*5];
 
1916
    tmp1 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*4];
 
1917
    tmp2 = dataptr[DCTSIZE*2] - wsptr[DCTSIZE*3];
 
1918
    tmp3 = dataptr[DCTSIZE*3] - wsptr[DCTSIZE*2];
 
1919
    tmp4 = dataptr[DCTSIZE*4] - wsptr[DCTSIZE*1];
 
1920
    tmp5 = dataptr[DCTSIZE*5] - wsptr[DCTSIZE*0];
 
1921
    tmp6 = dataptr[DCTSIZE*6] - dataptr[DCTSIZE*7];
 
1922
 
 
1923
    dataptr[DCTSIZE*0] = (DCTELEM)
 
1924
      DESCALE(MULTIPLY(tmp10 + tmp11 + tmp12 + tmp13,
 
1925
                       FIX(0.653061224)),                 /* 32/49 */
 
1926
              CONST_BITS+1);
 
1927
    tmp13 += tmp13;
 
1928
    dataptr[DCTSIZE*4] = (DCTELEM)
 
1929
      DESCALE(MULTIPLY(tmp10 - tmp13, FIX(0.832106052)) + /* c4 */
 
1930
              MULTIPLY(tmp11 - tmp13, FIX(0.205513223)) - /* c12 */
 
1931
              MULTIPLY(tmp12 - tmp13, FIX(0.575835255)),  /* c8 */
 
1932
              CONST_BITS+1);
 
1933
 
 
1934
    tmp10 = MULTIPLY(tmp14 + tmp15, FIX(0.722074570));    /* c6 */
 
1935
 
 
1936
    dataptr[DCTSIZE*2] = (DCTELEM)
 
1937
      DESCALE(tmp10 + MULTIPLY(tmp14, FIX(0.178337691))   /* c2-c6 */
 
1938
              + MULTIPLY(tmp16, FIX(0.400721155)),        /* c10 */
 
1939
              CONST_BITS+1);
 
1940
    dataptr[DCTSIZE*6] = (DCTELEM)
 
1941
      DESCALE(tmp10 - MULTIPLY(tmp15, FIX(1.122795725))   /* c6+c10 */
 
1942
              - MULTIPLY(tmp16, FIX(0.900412262)),        /* c2 */
 
1943
              CONST_BITS+1);
 
1944
 
 
1945
    /* Odd part */
 
1946
 
 
1947
    tmp10 = tmp1 + tmp2;
 
1948
    tmp11 = tmp5 - tmp4;
 
1949
    dataptr[DCTSIZE*7] = (DCTELEM)
 
1950
      DESCALE(MULTIPLY(tmp0 - tmp10 + tmp3 - tmp11 - tmp6,
 
1951
                       FIX(0.653061224)),                 /* 32/49 */
 
1952
              CONST_BITS+1);
 
1953
    tmp3  = MULTIPLY(tmp3 , FIX(0.653061224));            /* 32/49 */
 
1954
    tmp10 = MULTIPLY(tmp10, - FIX(0.103406812));          /* -c13 */
 
1955
    tmp11 = MULTIPLY(tmp11, FIX(0.917760839));            /* c1 */
 
1956
    tmp10 += tmp11 - tmp3;
 
1957
    tmp11 = MULTIPLY(tmp0 + tmp2, FIX(0.782007410)) +     /* c5 */
 
1958
            MULTIPLY(tmp4 + tmp6, FIX(0.491367823));      /* c9 */
 
1959
    dataptr[DCTSIZE*5] = (DCTELEM)
 
1960
      DESCALE(tmp10 + tmp11 - MULTIPLY(tmp2, FIX(1.550341076)) /* c3+c5-c13 */
 
1961
              + MULTIPLY(tmp4, FIX(0.731428202)),         /* c1+c11-c9 */
 
1962
              CONST_BITS+1);
 
1963
    tmp12 = MULTIPLY(tmp0 + tmp1, FIX(0.871740478)) +     /* c3 */
 
1964
            MULTIPLY(tmp5 - tmp6, FIX(0.305035186));      /* c11 */
 
1965
    dataptr[DCTSIZE*3] = (DCTELEM)
 
1966
      DESCALE(tmp10 + tmp12 - MULTIPLY(tmp1, FIX(0.276965844)) /* c3-c9-c13 */
 
1967
              - MULTIPLY(tmp5, FIX(2.004803435)),         /* c1+c5+c11 */
 
1968
              CONST_BITS+1);
 
1969
    dataptr[DCTSIZE*1] = (DCTELEM)
 
1970
      DESCALE(tmp11 + tmp12 + tmp3
 
1971
              - MULTIPLY(tmp0, FIX(0.735987049))          /* c3+c5-c1 */
 
1972
              - MULTIPLY(tmp6, FIX(0.082925825)),         /* c9-c11-c13 */
 
1973
              CONST_BITS+1);
 
1974
 
 
1975
    dataptr++;                  /* advance pointer to next column */
 
1976
    wsptr++;                    /* advance pointer to next column */
 
1977
  }
 
1978
}
 
1979
 
 
1980
 
 
1981
/*
 
1982
 * Perform the forward DCT on a 15x15 sample block.
 
1983
 */
 
1984
 
 
1985
GLOBAL(void)
 
1986
jpeg_fdct_15x15 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
1987
{
 
1988
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 
1989
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
 
1990
  INT32 z1, z2, z3;
 
1991
  DCTELEM workspace[8*7];
 
1992
  DCTELEM *dataptr;
 
1993
  DCTELEM *wsptr;
 
1994
  JSAMPROW elemptr;
 
1995
  int ctr;
 
1996
  SHIFT_TEMPS
 
1997
 
 
1998
  /* Pass 1: process rows. */
 
1999
  /* Note results are scaled up by sqrt(8) compared to a true DCT. */
 
2000
  /* cK represents sqrt(2) * cos(K*pi/30). */
 
2001
 
 
2002
  dataptr = data;
 
2003
  ctr = 0;
 
2004
  for (;;) {
 
2005
    elemptr = sample_data[ctr] + start_col;
 
2006
 
 
2007
    /* Even part */
 
2008
 
 
2009
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[14]);
 
2010
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[13]);
 
2011
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[12]);
 
2012
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[11]);
 
2013
    tmp4 = GETJSAMPLE(elemptr[4]) + GETJSAMPLE(elemptr[10]);
 
2014
    tmp5 = GETJSAMPLE(elemptr[5]) + GETJSAMPLE(elemptr[9]);
 
2015
    tmp6 = GETJSAMPLE(elemptr[6]) + GETJSAMPLE(elemptr[8]);
 
2016
    tmp7 = GETJSAMPLE(elemptr[7]);
 
2017
 
 
2018
    tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[14]);
 
2019
    tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[13]);
 
2020
    tmp12 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[12]);
 
2021
    tmp13 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[11]);
 
2022
    tmp14 = GETJSAMPLE(elemptr[4]) - GETJSAMPLE(elemptr[10]);
 
2023
    tmp15 = GETJSAMPLE(elemptr[5]) - GETJSAMPLE(elemptr[9]);
 
2024
    tmp16 = GETJSAMPLE(elemptr[6]) - GETJSAMPLE(elemptr[8]);
 
2025
 
 
2026
    z1 = tmp0 + tmp4 + tmp5;
 
2027
    z2 = tmp1 + tmp3 + tmp6;
 
2028
    z3 = tmp2 + tmp7;
 
2029
    /* Apply unsigned->signed conversion */
 
2030
    dataptr[0] = (DCTELEM) (z1 + z2 + z3 - 15 * CENTERJSAMPLE);
 
2031
    z3 += z3;
 
2032
    dataptr[6] = (DCTELEM)
 
2033
      DESCALE(MULTIPLY(z1 - z3, FIX(1.144122806)) - /* c6 */
 
2034
              MULTIPLY(z2 - z3, FIX(0.437016024)),  /* c12 */
 
2035
              CONST_BITS);
 
2036
    tmp2 += ((tmp1 + tmp4) >> 1) - tmp7 - tmp7;
 
2037
    z1 = MULTIPLY(tmp3 - tmp2, FIX(1.531135173)) -  /* c2+c14 */
 
2038
         MULTIPLY(tmp6 - tmp2, FIX(2.238241955));   /* c4+c8 */
 
2039
    z2 = MULTIPLY(tmp5 - tmp2, FIX(0.798468008)) -  /* c8-c14 */
 
2040
         MULTIPLY(tmp0 - tmp2, FIX(0.091361227));   /* c2-c4 */
 
2041
    z3 = MULTIPLY(tmp0 - tmp3, FIX(1.383309603)) +  /* c2 */
 
2042
         MULTIPLY(tmp6 - tmp5, FIX(0.946293579)) +  /* c8 */
 
2043
         MULTIPLY(tmp1 - tmp4, FIX(0.790569415));   /* (c6+c12)/2 */
 
2044
 
 
2045
    dataptr[2] = (DCTELEM) DESCALE(z1 + z3, CONST_BITS);
 
2046
    dataptr[4] = (DCTELEM) DESCALE(z2 + z3, CONST_BITS);
 
2047
 
 
2048
    /* Odd part */
 
2049
 
 
2050
    tmp2 = MULTIPLY(tmp10 - tmp12 - tmp13 + tmp15 + tmp16,
 
2051
                    FIX(1.224744871));                         /* c5 */
 
2052
    tmp1 = MULTIPLY(tmp10 - tmp14 - tmp15, FIX(1.344997024)) + /* c3 */
 
2053
           MULTIPLY(tmp11 - tmp13 - tmp16, FIX(0.831253876));  /* c9 */
 
2054
    tmp12 = MULTIPLY(tmp12, FIX(1.224744871));                 /* c5 */
 
2055
    tmp4 = MULTIPLY(tmp10 - tmp16, FIX(1.406466353)) +         /* c1 */
 
2056
           MULTIPLY(tmp11 + tmp14, FIX(1.344997024)) +         /* c3 */
 
2057
           MULTIPLY(tmp13 + tmp15, FIX(0.575212477));          /* c11 */
 
2058
    tmp0 = MULTIPLY(tmp13, FIX(0.475753014)) -                 /* c7-c11 */
 
2059
           MULTIPLY(tmp14, FIX(0.513743148)) +                 /* c3-c9 */
 
2060
           MULTIPLY(tmp16, FIX(1.700497885)) + tmp4 + tmp12;   /* c1+c13 */
 
2061
    tmp3 = MULTIPLY(tmp10, - FIX(0.355500862)) -               /* -(c1-c7) */
 
2062
           MULTIPLY(tmp11, FIX(2.176250899)) -                 /* c3+c9 */
 
2063
           MULTIPLY(tmp15, FIX(0.869244010)) + tmp4 - tmp12;   /* c11+c13 */
 
2064
 
 
2065
    dataptr[1] = (DCTELEM) DESCALE(tmp0, CONST_BITS);
 
2066
    dataptr[3] = (DCTELEM) DESCALE(tmp1, CONST_BITS);
 
2067
    dataptr[5] = (DCTELEM) DESCALE(tmp2, CONST_BITS);
 
2068
    dataptr[7] = (DCTELEM) DESCALE(tmp3, CONST_BITS);
 
2069
 
 
2070
    ctr++;
 
2071
 
 
2072
    if (ctr != DCTSIZE) {
 
2073
      if (ctr == 15)
 
2074
        break;                  /* Done. */
 
2075
      dataptr += DCTSIZE;       /* advance pointer to next row */
 
2076
    } else
 
2077
      dataptr = workspace;      /* switch pointer to extended workspace */
 
2078
  }
 
2079
 
 
2080
  /* Pass 2: process columns.
 
2081
   * We leave the results scaled up by an overall factor of 8.
 
2082
   * We must also scale the output by (8/15)**2 = 64/225, which we partially
 
2083
   * fold into the constant multipliers and final shifting:
 
2084
   * cK now represents sqrt(2) * cos(K*pi/30) * 256/225.
 
2085
   */
 
2086
 
 
2087
  dataptr = data;
 
2088
  wsptr = workspace;
 
2089
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
2090
    /* Even part */
 
2091
 
 
2092
    tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*6];
 
2093
    tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*5];
 
2094
    tmp2 = dataptr[DCTSIZE*2] + wsptr[DCTSIZE*4];
 
2095
    tmp3 = dataptr[DCTSIZE*3] + wsptr[DCTSIZE*3];
 
2096
    tmp4 = dataptr[DCTSIZE*4] + wsptr[DCTSIZE*2];
 
2097
    tmp5 = dataptr[DCTSIZE*5] + wsptr[DCTSIZE*1];
 
2098
    tmp6 = dataptr[DCTSIZE*6] + wsptr[DCTSIZE*0];
 
2099
    tmp7 = dataptr[DCTSIZE*7];
 
2100
 
 
2101
    tmp10 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*6];
 
2102
    tmp11 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*5];
 
2103
    tmp12 = dataptr[DCTSIZE*2] - wsptr[DCTSIZE*4];
 
2104
    tmp13 = dataptr[DCTSIZE*3] - wsptr[DCTSIZE*3];
 
2105
    tmp14 = dataptr[DCTSIZE*4] - wsptr[DCTSIZE*2];
 
2106
    tmp15 = dataptr[DCTSIZE*5] - wsptr[DCTSIZE*1];
 
2107
    tmp16 = dataptr[DCTSIZE*6] - wsptr[DCTSIZE*0];
 
2108
 
 
2109
    z1 = tmp0 + tmp4 + tmp5;
 
2110
    z2 = tmp1 + tmp3 + tmp6;
 
2111
    z3 = tmp2 + tmp7;
 
2112
    dataptr[DCTSIZE*0] = (DCTELEM)
 
2113
      DESCALE(MULTIPLY(z1 + z2 + z3, FIX(1.137777778)), /* 256/225 */
 
2114
              CONST_BITS+2);
 
2115
    z3 += z3;
 
2116
    dataptr[DCTSIZE*6] = (DCTELEM)
 
2117
      DESCALE(MULTIPLY(z1 - z3, FIX(1.301757503)) - /* c6 */
 
2118
              MULTIPLY(z2 - z3, FIX(0.497227121)),  /* c12 */
 
2119
              CONST_BITS+2);
 
2120
    tmp2 += ((tmp1 + tmp4) >> 1) - tmp7 - tmp7;
 
2121
    z1 = MULTIPLY(tmp3 - tmp2, FIX(1.742091575)) -  /* c2+c14 */
 
2122
         MULTIPLY(tmp6 - tmp2, FIX(2.546621957));   /* c4+c8 */
 
2123
    z2 = MULTIPLY(tmp5 - tmp2, FIX(0.908479156)) -  /* c8-c14 */
 
2124
         MULTIPLY(tmp0 - tmp2, FIX(0.103948774));   /* c2-c4 */
 
2125
    z3 = MULTIPLY(tmp0 - tmp3, FIX(1.573898926)) +  /* c2 */
 
2126
         MULTIPLY(tmp6 - tmp5, FIX(1.076671805)) +  /* c8 */
 
2127
         MULTIPLY(tmp1 - tmp4, FIX(0.899492312));   /* (c6+c12)/2 */
 
2128
 
 
2129
    dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(z1 + z3, CONST_BITS+2);
 
2130
    dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(z2 + z3, CONST_BITS+2);
 
2131
 
 
2132
    /* Odd part */
 
2133
 
 
2134
    tmp2 = MULTIPLY(tmp10 - tmp12 - tmp13 + tmp15 + tmp16,
 
2135
                    FIX(1.393487498));                         /* c5 */
 
2136
    tmp1 = MULTIPLY(tmp10 - tmp14 - tmp15, FIX(1.530307725)) + /* c3 */
 
2137
           MULTIPLY(tmp11 - tmp13 - tmp16, FIX(0.945782187));  /* c9 */
 
2138
    tmp12 = MULTIPLY(tmp12, FIX(1.393487498));                 /* c5 */
 
2139
    tmp4 = MULTIPLY(tmp10 - tmp16, FIX(1.600246161)) +         /* c1 */
 
2140
           MULTIPLY(tmp11 + tmp14, FIX(1.530307725)) +         /* c3 */
 
2141
           MULTIPLY(tmp13 + tmp15, FIX(0.654463974));          /* c11 */
 
2142
    tmp0 = MULTIPLY(tmp13, FIX(0.541301207)) -                 /* c7-c11 */
 
2143
           MULTIPLY(tmp14, FIX(0.584525538)) +                 /* c3-c9 */
 
2144
           MULTIPLY(tmp16, FIX(1.934788705)) + tmp4 + tmp12;   /* c1+c13 */
 
2145
    tmp3 = MULTIPLY(tmp10, - FIX(0.404480980)) -               /* -(c1-c7) */
 
2146
           MULTIPLY(tmp11, FIX(2.476089912)) -                 /* c3+c9 */
 
2147
           MULTIPLY(tmp15, FIX(0.989006518)) + tmp4 - tmp12;   /* c11+c13 */
 
2148
 
 
2149
    dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp0, CONST_BITS+2);
 
2150
    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp1, CONST_BITS+2);
 
2151
    dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp2, CONST_BITS+2);
 
2152
    dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp3, CONST_BITS+2);
 
2153
 
 
2154
    dataptr++;                  /* advance pointer to next column */
 
2155
    wsptr++;                    /* advance pointer to next column */
 
2156
  }
 
2157
}
 
2158
 
 
2159
 
 
2160
/*
 
2161
 * Perform the forward DCT on a 16x16 sample block.
 
2162
 */
 
2163
 
 
2164
GLOBAL(void)
 
2165
jpeg_fdct_16x16 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
2166
{
 
2167
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 
2168
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16, tmp17;
 
2169
  DCTELEM workspace[DCTSIZE2];
 
2170
  DCTELEM *dataptr;
 
2171
  DCTELEM *wsptr;
 
2172
  JSAMPROW elemptr;
 
2173
  int ctr;
 
2174
  SHIFT_TEMPS
 
2175
 
 
2176
  /* Pass 1: process rows. */
 
2177
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
2178
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
2179
  /* cK represents sqrt(2) * cos(K*pi/32). */
 
2180
 
 
2181
  dataptr = data;
 
2182
  ctr = 0;
 
2183
  for (;;) {
 
2184
    elemptr = sample_data[ctr] + start_col;
 
2185
 
 
2186
    /* Even part */
 
2187
 
 
2188
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[15]);
 
2189
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[14]);
 
2190
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[13]);
 
2191
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[12]);
 
2192
    tmp4 = GETJSAMPLE(elemptr[4]) + GETJSAMPLE(elemptr[11]);
 
2193
    tmp5 = GETJSAMPLE(elemptr[5]) + GETJSAMPLE(elemptr[10]);
 
2194
    tmp6 = GETJSAMPLE(elemptr[6]) + GETJSAMPLE(elemptr[9]);
 
2195
    tmp7 = GETJSAMPLE(elemptr[7]) + GETJSAMPLE(elemptr[8]);
 
2196
 
 
2197
    tmp10 = tmp0 + tmp7;
 
2198
    tmp14 = tmp0 - tmp7;
 
2199
    tmp11 = tmp1 + tmp6;
 
2200
    tmp15 = tmp1 - tmp6;
 
2201
    tmp12 = tmp2 + tmp5;
 
2202
    tmp16 = tmp2 - tmp5;
 
2203
    tmp13 = tmp3 + tmp4;
 
2204
    tmp17 = tmp3 - tmp4;
 
2205
 
 
2206
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[15]);
 
2207
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[14]);
 
2208
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[13]);
 
2209
    tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[12]);
 
2210
    tmp4 = GETJSAMPLE(elemptr[4]) - GETJSAMPLE(elemptr[11]);
 
2211
    tmp5 = GETJSAMPLE(elemptr[5]) - GETJSAMPLE(elemptr[10]);
 
2212
    tmp6 = GETJSAMPLE(elemptr[6]) - GETJSAMPLE(elemptr[9]);
 
2213
    tmp7 = GETJSAMPLE(elemptr[7]) - GETJSAMPLE(elemptr[8]);
 
2214
 
 
2215
    /* Apply unsigned->signed conversion */
 
2216
    dataptr[0] = (DCTELEM)
 
2217
      ((tmp10 + tmp11 + tmp12 + tmp13 - 16 * CENTERJSAMPLE) << PASS1_BITS);
 
2218
    dataptr[4] = (DCTELEM)
 
2219
      DESCALE(MULTIPLY(tmp10 - tmp13, FIX(1.306562965)) + /* c4[16] = c2[8] */
 
2220
              MULTIPLY(tmp11 - tmp12, FIX_0_541196100),   /* c12[16] = c6[8] */
 
2221
              CONST_BITS-PASS1_BITS);
 
2222
 
 
2223
    tmp10 = MULTIPLY(tmp17 - tmp15, FIX(0.275899379)) +   /* c14[16] = c7[8] */
 
2224
            MULTIPLY(tmp14 - tmp16, FIX(1.387039845));    /* c2[16] = c1[8] */
 
2225
 
 
2226
    dataptr[2] = (DCTELEM)
 
2227
      DESCALE(tmp10 + MULTIPLY(tmp15, FIX(1.451774982))   /* c6+c14 */
 
2228
              + MULTIPLY(tmp16, FIX(2.172734804)),        /* c2+c10 */
 
2229
              CONST_BITS-PASS1_BITS);
 
2230
    dataptr[6] = (DCTELEM)
 
2231
      DESCALE(tmp10 - MULTIPLY(tmp14, FIX(0.211164243))   /* c2-c6 */
 
2232
              - MULTIPLY(tmp17, FIX(1.061594338)),        /* c10+c14 */
 
2233
              CONST_BITS-PASS1_BITS);
 
2234
 
 
2235
    /* Odd part */
 
2236
 
 
2237
    tmp11 = MULTIPLY(tmp0 + tmp1, FIX(1.353318001)) +         /* c3 */
 
2238
            MULTIPLY(tmp6 - tmp7, FIX(0.410524528));          /* c13 */
 
2239
    tmp12 = MULTIPLY(tmp0 + tmp2, FIX(1.247225013)) +         /* c5 */
 
2240
            MULTIPLY(tmp5 + tmp7, FIX(0.666655658));          /* c11 */
 
2241
    tmp13 = MULTIPLY(tmp0 + tmp3, FIX(1.093201867)) +         /* c7 */
 
2242
            MULTIPLY(tmp4 - tmp7, FIX(0.897167586));          /* c9 */
 
2243
    tmp14 = MULTIPLY(tmp1 + tmp2, FIX(0.138617169)) +         /* c15 */
 
2244
            MULTIPLY(tmp6 - tmp5, FIX(1.407403738));          /* c1 */
 
2245
    tmp15 = MULTIPLY(tmp1 + tmp3, - FIX(0.666655658)) +       /* -c11 */
 
2246
            MULTIPLY(tmp4 + tmp6, - FIX(1.247225013));        /* -c5 */
 
2247
    tmp16 = MULTIPLY(tmp2 + tmp3, - FIX(1.353318001)) +       /* -c3 */
 
2248
            MULTIPLY(tmp5 - tmp4, FIX(0.410524528));          /* c13 */
 
2249
    tmp10 = tmp11 + tmp12 + tmp13 -
 
2250
            MULTIPLY(tmp0, FIX(2.286341144)) +                /* c7+c5+c3-c1 */
 
2251
            MULTIPLY(tmp7, FIX(0.779653625));                 /* c15+c13-c11+c9 */
 
2252
    tmp11 += tmp14 + tmp15 + MULTIPLY(tmp1, FIX(0.071888074)) /* c9-c3-c15+c11 */
 
2253
             - MULTIPLY(tmp6, FIX(1.663905119));              /* c7+c13+c1-c5 */
 
2254
    tmp12 += tmp14 + tmp16 - MULTIPLY(tmp2, FIX(1.125726048)) /* c7+c5+c15-c3 */
 
2255
             + MULTIPLY(tmp5, FIX(1.227391138));              /* c9-c11+c1-c13 */
 
2256
    tmp13 += tmp15 + tmp16 + MULTIPLY(tmp3, FIX(1.065388962)) /* c15+c3+c11-c7 */
 
2257
             + MULTIPLY(tmp4, FIX(2.167985692));              /* c1+c13+c5-c9 */
 
2258
 
 
2259
    dataptr[1] = (DCTELEM) DESCALE(tmp10, CONST_BITS-PASS1_BITS);
 
2260
    dataptr[3] = (DCTELEM) DESCALE(tmp11, CONST_BITS-PASS1_BITS);
 
2261
    dataptr[5] = (DCTELEM) DESCALE(tmp12, CONST_BITS-PASS1_BITS);
 
2262
    dataptr[7] = (DCTELEM) DESCALE(tmp13, CONST_BITS-PASS1_BITS);
 
2263
 
 
2264
    ctr++;
 
2265
 
 
2266
    if (ctr != DCTSIZE) {
 
2267
      if (ctr == DCTSIZE * 2)
 
2268
        break;                  /* Done. */
 
2269
      dataptr += DCTSIZE;       /* advance pointer to next row */
 
2270
    } else
 
2271
      dataptr = workspace;      /* switch pointer to extended workspace */
 
2272
  }
 
2273
 
 
2274
  /* Pass 2: process columns.
 
2275
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
2276
   * by an overall factor of 8.
 
2277
   * We must also scale the output by (8/16)**2 = 1/2**2.
 
2278
   */
 
2279
 
 
2280
  dataptr = data;
 
2281
  wsptr = workspace;
 
2282
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
2283
    /* Even part */
 
2284
 
 
2285
    tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*7];
 
2286
    tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*6];
 
2287
    tmp2 = dataptr[DCTSIZE*2] + wsptr[DCTSIZE*5];
 
2288
    tmp3 = dataptr[DCTSIZE*3] + wsptr[DCTSIZE*4];
 
2289
    tmp4 = dataptr[DCTSIZE*4] + wsptr[DCTSIZE*3];
 
2290
    tmp5 = dataptr[DCTSIZE*5] + wsptr[DCTSIZE*2];
 
2291
    tmp6 = dataptr[DCTSIZE*6] + wsptr[DCTSIZE*1];
 
2292
    tmp7 = dataptr[DCTSIZE*7] + wsptr[DCTSIZE*0];
 
2293
 
 
2294
    tmp10 = tmp0 + tmp7;
 
2295
    tmp14 = tmp0 - tmp7;
 
2296
    tmp11 = tmp1 + tmp6;
 
2297
    tmp15 = tmp1 - tmp6;
 
2298
    tmp12 = tmp2 + tmp5;
 
2299
    tmp16 = tmp2 - tmp5;
 
2300
    tmp13 = tmp3 + tmp4;
 
2301
    tmp17 = tmp3 - tmp4;
 
2302
 
 
2303
    tmp0 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*7];
 
2304
    tmp1 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*6];
 
2305
    tmp2 = dataptr[DCTSIZE*2] - wsptr[DCTSIZE*5];
 
2306
    tmp3 = dataptr[DCTSIZE*3] - wsptr[DCTSIZE*4];
 
2307
    tmp4 = dataptr[DCTSIZE*4] - wsptr[DCTSIZE*3];
 
2308
    tmp5 = dataptr[DCTSIZE*5] - wsptr[DCTSIZE*2];
 
2309
    tmp6 = dataptr[DCTSIZE*6] - wsptr[DCTSIZE*1];
 
2310
    tmp7 = dataptr[DCTSIZE*7] - wsptr[DCTSIZE*0];
 
2311
 
 
2312
    dataptr[DCTSIZE*0] = (DCTELEM)
 
2313
      DESCALE(tmp10 + tmp11 + tmp12 + tmp13, PASS1_BITS+2);
 
2314
    dataptr[DCTSIZE*4] = (DCTELEM)
 
2315
      DESCALE(MULTIPLY(tmp10 - tmp13, FIX(1.306562965)) + /* c4[16] = c2[8] */
 
2316
              MULTIPLY(tmp11 - tmp12, FIX_0_541196100),   /* c12[16] = c6[8] */
 
2317
              CONST_BITS+PASS1_BITS+2);
 
2318
 
 
2319
    tmp10 = MULTIPLY(tmp17 - tmp15, FIX(0.275899379)) +   /* c14[16] = c7[8] */
 
2320
            MULTIPLY(tmp14 - tmp16, FIX(1.387039845));    /* c2[16] = c1[8] */
 
2321
 
 
2322
    dataptr[DCTSIZE*2] = (DCTELEM)
 
2323
      DESCALE(tmp10 + MULTIPLY(tmp15, FIX(1.451774982))   /* c6+c14 */
 
2324
              + MULTIPLY(tmp16, FIX(2.172734804)),        /* c2+10 */
 
2325
              CONST_BITS+PASS1_BITS+2);
 
2326
    dataptr[DCTSIZE*6] = (DCTELEM)
 
2327
      DESCALE(tmp10 - MULTIPLY(tmp14, FIX(0.211164243))   /* c2-c6 */
 
2328
              - MULTIPLY(tmp17, FIX(1.061594338)),        /* c10+c14 */
 
2329
              CONST_BITS+PASS1_BITS+2);
 
2330
 
 
2331
    /* Odd part */
 
2332
 
 
2333
    tmp11 = MULTIPLY(tmp0 + tmp1, FIX(1.353318001)) +         /* c3 */
 
2334
            MULTIPLY(tmp6 - tmp7, FIX(0.410524528));          /* c13 */
 
2335
    tmp12 = MULTIPLY(tmp0 + tmp2, FIX(1.247225013)) +         /* c5 */
 
2336
            MULTIPLY(tmp5 + tmp7, FIX(0.666655658));          /* c11 */
 
2337
    tmp13 = MULTIPLY(tmp0 + tmp3, FIX(1.093201867)) +         /* c7 */
 
2338
            MULTIPLY(tmp4 - tmp7, FIX(0.897167586));          /* c9 */
 
2339
    tmp14 = MULTIPLY(tmp1 + tmp2, FIX(0.138617169)) +         /* c15 */
 
2340
            MULTIPLY(tmp6 - tmp5, FIX(1.407403738));          /* c1 */
 
2341
    tmp15 = MULTIPLY(tmp1 + tmp3, - FIX(0.666655658)) +       /* -c11 */
 
2342
            MULTIPLY(tmp4 + tmp6, - FIX(1.247225013));        /* -c5 */
 
2343
    tmp16 = MULTIPLY(tmp2 + tmp3, - FIX(1.353318001)) +       /* -c3 */
 
2344
            MULTIPLY(tmp5 - tmp4, FIX(0.410524528));          /* c13 */
 
2345
    tmp10 = tmp11 + tmp12 + tmp13 -
 
2346
            MULTIPLY(tmp0, FIX(2.286341144)) +                /* c7+c5+c3-c1 */
 
2347
            MULTIPLY(tmp7, FIX(0.779653625));                 /* c15+c13-c11+c9 */
 
2348
    tmp11 += tmp14 + tmp15 + MULTIPLY(tmp1, FIX(0.071888074)) /* c9-c3-c15+c11 */
 
2349
             - MULTIPLY(tmp6, FIX(1.663905119));              /* c7+c13+c1-c5 */
 
2350
    tmp12 += tmp14 + tmp16 - MULTIPLY(tmp2, FIX(1.125726048)) /* c7+c5+c15-c3 */
 
2351
             + MULTIPLY(tmp5, FIX(1.227391138));              /* c9-c11+c1-c13 */
 
2352
    tmp13 += tmp15 + tmp16 + MULTIPLY(tmp3, FIX(1.065388962)) /* c15+c3+c11-c7 */
 
2353
             + MULTIPLY(tmp4, FIX(2.167985692));              /* c1+c13+c5-c9 */
 
2354
 
 
2355
    dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp10, CONST_BITS+PASS1_BITS+2);
 
2356
    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp11, CONST_BITS+PASS1_BITS+2);
 
2357
    dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp12, CONST_BITS+PASS1_BITS+2);
 
2358
    dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp13, CONST_BITS+PASS1_BITS+2);
 
2359
 
 
2360
    dataptr++;                  /* advance pointer to next column */
 
2361
    wsptr++;                    /* advance pointer to next column */
 
2362
  }
 
2363
}
 
2364
 
 
2365
 
 
2366
/*
 
2367
 * Perform the forward DCT on a 16x8 sample block.
 
2368
 *
 
2369
 * 16-point FDCT in pass 1 (rows), 8-point in pass 2 (columns).
 
2370
 */
 
2371
 
 
2372
GLOBAL(void)
 
2373
jpeg_fdct_16x8 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
2374
{
 
2375
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 
2376
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16, tmp17;
 
2377
  INT32 z1;
 
2378
  DCTELEM *dataptr;
 
2379
  JSAMPROW elemptr;
 
2380
  int ctr;
 
2381
  SHIFT_TEMPS
 
2382
 
 
2383
  /* Pass 1: process rows. */
 
2384
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
2385
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
2386
  /* 16-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/32). */
 
2387
 
 
2388
  dataptr = data;
 
2389
  ctr = 0;
 
2390
  for (ctr = 0; ctr < DCTSIZE; ctr++) {
 
2391
    elemptr = sample_data[ctr] + start_col;
 
2392
 
 
2393
    /* Even part */
 
2394
 
 
2395
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[15]);
 
2396
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[14]);
 
2397
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[13]);
 
2398
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[12]);
 
2399
    tmp4 = GETJSAMPLE(elemptr[4]) + GETJSAMPLE(elemptr[11]);
 
2400
    tmp5 = GETJSAMPLE(elemptr[5]) + GETJSAMPLE(elemptr[10]);
 
2401
    tmp6 = GETJSAMPLE(elemptr[6]) + GETJSAMPLE(elemptr[9]);
 
2402
    tmp7 = GETJSAMPLE(elemptr[7]) + GETJSAMPLE(elemptr[8]);
 
2403
 
 
2404
    tmp10 = tmp0 + tmp7;
 
2405
    tmp14 = tmp0 - tmp7;
 
2406
    tmp11 = tmp1 + tmp6;
 
2407
    tmp15 = tmp1 - tmp6;
 
2408
    tmp12 = tmp2 + tmp5;
 
2409
    tmp16 = tmp2 - tmp5;
 
2410
    tmp13 = tmp3 + tmp4;
 
2411
    tmp17 = tmp3 - tmp4;
 
2412
 
 
2413
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[15]);
 
2414
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[14]);
 
2415
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[13]);
 
2416
    tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[12]);
 
2417
    tmp4 = GETJSAMPLE(elemptr[4]) - GETJSAMPLE(elemptr[11]);
 
2418
    tmp5 = GETJSAMPLE(elemptr[5]) - GETJSAMPLE(elemptr[10]);
 
2419
    tmp6 = GETJSAMPLE(elemptr[6]) - GETJSAMPLE(elemptr[9]);
 
2420
    tmp7 = GETJSAMPLE(elemptr[7]) - GETJSAMPLE(elemptr[8]);
 
2421
 
 
2422
    /* Apply unsigned->signed conversion */
 
2423
    dataptr[0] = (DCTELEM)
 
2424
      ((tmp10 + tmp11 + tmp12 + tmp13 - 16 * CENTERJSAMPLE) << PASS1_BITS);
 
2425
    dataptr[4] = (DCTELEM)
 
2426
      DESCALE(MULTIPLY(tmp10 - tmp13, FIX(1.306562965)) + /* c4[16] = c2[8] */
 
2427
              MULTIPLY(tmp11 - tmp12, FIX_0_541196100),   /* c12[16] = c6[8] */
 
2428
              CONST_BITS-PASS1_BITS);
 
2429
 
 
2430
    tmp10 = MULTIPLY(tmp17 - tmp15, FIX(0.275899379)) +   /* c14[16] = c7[8] */
 
2431
            MULTIPLY(tmp14 - tmp16, FIX(1.387039845));    /* c2[16] = c1[8] */
 
2432
 
 
2433
    dataptr[2] = (DCTELEM)
 
2434
      DESCALE(tmp10 + MULTIPLY(tmp15, FIX(1.451774982))   /* c6+c14 */
 
2435
              + MULTIPLY(tmp16, FIX(2.172734804)),        /* c2+c10 */
 
2436
              CONST_BITS-PASS1_BITS);
 
2437
    dataptr[6] = (DCTELEM)
 
2438
      DESCALE(tmp10 - MULTIPLY(tmp14, FIX(0.211164243))   /* c2-c6 */
 
2439
              - MULTIPLY(tmp17, FIX(1.061594338)),        /* c10+c14 */
 
2440
              CONST_BITS-PASS1_BITS);
 
2441
 
 
2442
    /* Odd part */
 
2443
 
 
2444
    tmp11 = MULTIPLY(tmp0 + tmp1, FIX(1.353318001)) +         /* c3 */
 
2445
            MULTIPLY(tmp6 - tmp7, FIX(0.410524528));          /* c13 */
 
2446
    tmp12 = MULTIPLY(tmp0 + tmp2, FIX(1.247225013)) +         /* c5 */
 
2447
            MULTIPLY(tmp5 + tmp7, FIX(0.666655658));          /* c11 */
 
2448
    tmp13 = MULTIPLY(tmp0 + tmp3, FIX(1.093201867)) +         /* c7 */
 
2449
            MULTIPLY(tmp4 - tmp7, FIX(0.897167586));          /* c9 */
 
2450
    tmp14 = MULTIPLY(tmp1 + tmp2, FIX(0.138617169)) +         /* c15 */
 
2451
            MULTIPLY(tmp6 - tmp5, FIX(1.407403738));          /* c1 */
 
2452
    tmp15 = MULTIPLY(tmp1 + tmp3, - FIX(0.666655658)) +       /* -c11 */
 
2453
            MULTIPLY(tmp4 + tmp6, - FIX(1.247225013));        /* -c5 */
 
2454
    tmp16 = MULTIPLY(tmp2 + tmp3, - FIX(1.353318001)) +       /* -c3 */
 
2455
            MULTIPLY(tmp5 - tmp4, FIX(0.410524528));          /* c13 */
 
2456
    tmp10 = tmp11 + tmp12 + tmp13 -
 
2457
            MULTIPLY(tmp0, FIX(2.286341144)) +                /* c7+c5+c3-c1 */
 
2458
            MULTIPLY(tmp7, FIX(0.779653625));                 /* c15+c13-c11+c9 */
 
2459
    tmp11 += tmp14 + tmp15 + MULTIPLY(tmp1, FIX(0.071888074)) /* c9-c3-c15+c11 */
 
2460
             - MULTIPLY(tmp6, FIX(1.663905119));              /* c7+c13+c1-c5 */
 
2461
    tmp12 += tmp14 + tmp16 - MULTIPLY(tmp2, FIX(1.125726048)) /* c7+c5+c15-c3 */
 
2462
             + MULTIPLY(tmp5, FIX(1.227391138));              /* c9-c11+c1-c13 */
 
2463
    tmp13 += tmp15 + tmp16 + MULTIPLY(tmp3, FIX(1.065388962)) /* c15+c3+c11-c7 */
 
2464
             + MULTIPLY(tmp4, FIX(2.167985692));              /* c1+c13+c5-c9 */
 
2465
 
 
2466
    dataptr[1] = (DCTELEM) DESCALE(tmp10, CONST_BITS-PASS1_BITS);
 
2467
    dataptr[3] = (DCTELEM) DESCALE(tmp11, CONST_BITS-PASS1_BITS);
 
2468
    dataptr[5] = (DCTELEM) DESCALE(tmp12, CONST_BITS-PASS1_BITS);
 
2469
    dataptr[7] = (DCTELEM) DESCALE(tmp13, CONST_BITS-PASS1_BITS);
 
2470
 
 
2471
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
2472
  }
 
2473
 
 
2474
  /* Pass 2: process columns.
 
2475
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
2476
   * by an overall factor of 8.
 
2477
   * We must also scale the output by 8/16 = 1/2.
 
2478
   */
 
2479
 
 
2480
  dataptr = data;
 
2481
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
2482
    /* Even part per LL&M figure 1 --- note that published figure is faulty;
 
2483
     * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
 
2484
     */
 
2485
 
 
2486
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
 
2487
    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
 
2488
    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
 
2489
    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
 
2490
 
 
2491
    tmp10 = tmp0 + tmp3;
 
2492
    tmp12 = tmp0 - tmp3;
 
2493
    tmp11 = tmp1 + tmp2;
 
2494
    tmp13 = tmp1 - tmp2;
 
2495
 
 
2496
    tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
 
2497
    tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
 
2498
    tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
 
2499
    tmp3 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
 
2500
 
 
2501
    dataptr[DCTSIZE*0] = (DCTELEM) DESCALE(tmp10 + tmp11, PASS1_BITS+1);
 
2502
    dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp10 - tmp11, PASS1_BITS+1);
 
2503
 
 
2504
    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
 
2505
    dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, FIX_0_765366865),
 
2506
                                           CONST_BITS+PASS1_BITS+1);
 
2507
    dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(z1 - MULTIPLY(tmp13, FIX_1_847759065),
 
2508
                                           CONST_BITS+PASS1_BITS+1);
 
2509
 
 
2510
    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
 
2511
     * 8-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
 
2512
     * i0..i3 in the paper are tmp0..tmp3 here.
 
2513
     */
 
2514
 
 
2515
    tmp10 = tmp0 + tmp3;
 
2516
    tmp11 = tmp1 + tmp2;
 
2517
    tmp12 = tmp0 + tmp2;
 
2518
    tmp13 = tmp1 + tmp3;
 
2519
    z1 = MULTIPLY(tmp12 + tmp13, FIX_1_175875602); /*  c3 */
 
2520
 
 
2521
    tmp0  = MULTIPLY(tmp0,    FIX_1_501321110);    /*  c1+c3-c5-c7 */
 
2522
    tmp1  = MULTIPLY(tmp1,    FIX_3_072711026);    /*  c1+c3+c5-c7 */
 
2523
    tmp2  = MULTIPLY(tmp2,    FIX_2_053119869);    /*  c1+c3-c5+c7 */
 
2524
    tmp3  = MULTIPLY(tmp3,    FIX_0_298631336);    /* -c1+c3+c5-c7 */
 
2525
    tmp10 = MULTIPLY(tmp10, - FIX_0_899976223);    /*  c7-c3 */
 
2526
    tmp11 = MULTIPLY(tmp11, - FIX_2_562915447);    /* -c1-c3 */
 
2527
    tmp12 = MULTIPLY(tmp12, - FIX_0_390180644);    /*  c5-c3 */
 
2528
    tmp13 = MULTIPLY(tmp13, - FIX_1_961570560);    /* -c3-c5 */
 
2529
 
 
2530
    tmp12 += z1;
 
2531
    tmp13 += z1;
 
2532
 
 
2533
    dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp0 + tmp10 + tmp12,
 
2534
                                           CONST_BITS+PASS1_BITS+1);
 
2535
    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp1 + tmp11 + tmp13,
 
2536
                                           CONST_BITS+PASS1_BITS+1);
 
2537
    dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp2 + tmp11 + tmp12,
 
2538
                                           CONST_BITS+PASS1_BITS+1);
 
2539
    dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp3 + tmp10 + tmp13,
 
2540
                                           CONST_BITS+PASS1_BITS+1);
 
2541
 
 
2542
    dataptr++;                  /* advance pointer to next column */
 
2543
  }
 
2544
}
 
2545
 
 
2546
 
 
2547
/*
 
2548
 * Perform the forward DCT on a 14x7 sample block.
 
2549
 *
 
2550
 * 14-point FDCT in pass 1 (rows), 7-point in pass 2 (columns).
 
2551
 */
 
2552
 
 
2553
GLOBAL(void)
 
2554
jpeg_fdct_14x7 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
2555
{
 
2556
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
 
2557
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
 
2558
  INT32 z1, z2, z3;
 
2559
  DCTELEM *dataptr;
 
2560
  JSAMPROW elemptr;
 
2561
  int ctr;
 
2562
  SHIFT_TEMPS
 
2563
 
 
2564
  /* Zero bottom row of output coefficient block. */
 
2565
  MEMZERO(&data[DCTSIZE*7], SIZEOF(DCTELEM) * DCTSIZE);
 
2566
 
 
2567
  /* Pass 1: process rows. */
 
2568
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
2569
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
2570
  /* 14-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/28). */
 
2571
 
 
2572
  dataptr = data;
 
2573
  for (ctr = 0; ctr < 7; ctr++) {
 
2574
    elemptr = sample_data[ctr] + start_col;
 
2575
 
 
2576
    /* Even part */
 
2577
 
 
2578
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[13]);
 
2579
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[12]);
 
2580
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[11]);
 
2581
    tmp13 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[10]);
 
2582
    tmp4 = GETJSAMPLE(elemptr[4]) + GETJSAMPLE(elemptr[9]);
 
2583
    tmp5 = GETJSAMPLE(elemptr[5]) + GETJSAMPLE(elemptr[8]);
 
2584
    tmp6 = GETJSAMPLE(elemptr[6]) + GETJSAMPLE(elemptr[7]);
 
2585
 
 
2586
    tmp10 = tmp0 + tmp6;
 
2587
    tmp14 = tmp0 - tmp6;
 
2588
    tmp11 = tmp1 + tmp5;
 
2589
    tmp15 = tmp1 - tmp5;
 
2590
    tmp12 = tmp2 + tmp4;
 
2591
    tmp16 = tmp2 - tmp4;
 
2592
 
 
2593
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[13]);
 
2594
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[12]);
 
2595
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[11]);
 
2596
    tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[10]);
 
2597
    tmp4 = GETJSAMPLE(elemptr[4]) - GETJSAMPLE(elemptr[9]);
 
2598
    tmp5 = GETJSAMPLE(elemptr[5]) - GETJSAMPLE(elemptr[8]);
 
2599
    tmp6 = GETJSAMPLE(elemptr[6]) - GETJSAMPLE(elemptr[7]);
 
2600
 
 
2601
    /* Apply unsigned->signed conversion */
 
2602
    dataptr[0] = (DCTELEM)
 
2603
      ((tmp10 + tmp11 + tmp12 + tmp13 - 14 * CENTERJSAMPLE) << PASS1_BITS);
 
2604
    tmp13 += tmp13;
 
2605
    dataptr[4] = (DCTELEM)
 
2606
      DESCALE(MULTIPLY(tmp10 - tmp13, FIX(1.274162392)) + /* c4 */
 
2607
              MULTIPLY(tmp11 - tmp13, FIX(0.314692123)) - /* c12 */
 
2608
              MULTIPLY(tmp12 - tmp13, FIX(0.881747734)),  /* c8 */
 
2609
              CONST_BITS-PASS1_BITS);
 
2610
 
 
2611
    tmp10 = MULTIPLY(tmp14 + tmp15, FIX(1.105676686));    /* c6 */
 
2612
 
 
2613
    dataptr[2] = (DCTELEM)
 
2614
      DESCALE(tmp10 + MULTIPLY(tmp14, FIX(0.273079590))   /* c2-c6 */
 
2615
              + MULTIPLY(tmp16, FIX(0.613604268)),        /* c10 */
 
2616
              CONST_BITS-PASS1_BITS);
 
2617
    dataptr[6] = (DCTELEM)
 
2618
      DESCALE(tmp10 - MULTIPLY(tmp15, FIX(1.719280954))   /* c6+c10 */
 
2619
              - MULTIPLY(tmp16, FIX(1.378756276)),        /* c2 */
 
2620
              CONST_BITS-PASS1_BITS);
 
2621
 
 
2622
    /* Odd part */
 
2623
 
 
2624
    tmp10 = tmp1 + tmp2;
 
2625
    tmp11 = tmp5 - tmp4;
 
2626
    dataptr[7] = (DCTELEM) ((tmp0 - tmp10 + tmp3 - tmp11 - tmp6) << PASS1_BITS);
 
2627
    tmp3 <<= CONST_BITS;
 
2628
    tmp10 = MULTIPLY(tmp10, - FIX(0.158341681));          /* -c13 */
 
2629
    tmp11 = MULTIPLY(tmp11, FIX(1.405321284));            /* c1 */
 
2630
    tmp10 += tmp11 - tmp3;
 
2631
    tmp11 = MULTIPLY(tmp0 + tmp2, FIX(1.197448846)) +     /* c5 */
 
2632
            MULTIPLY(tmp4 + tmp6, FIX(0.752406978));      /* c9 */
 
2633
    dataptr[5] = (DCTELEM)
 
2634
      DESCALE(tmp10 + tmp11 - MULTIPLY(tmp2, FIX(2.373959773)) /* c3+c5-c13 */
 
2635
              + MULTIPLY(tmp4, FIX(1.119999435)),         /* c1+c11-c9 */
 
2636
              CONST_BITS-PASS1_BITS);
 
2637
    tmp12 = MULTIPLY(tmp0 + tmp1, FIX(1.334852607)) +     /* c3 */
 
2638
            MULTIPLY(tmp5 - tmp6, FIX(0.467085129));      /* c11 */
 
2639
    dataptr[3] = (DCTELEM)
 
2640
      DESCALE(tmp10 + tmp12 - MULTIPLY(tmp1, FIX(0.424103948)) /* c3-c9-c13 */
 
2641
              - MULTIPLY(tmp5, FIX(3.069855259)),         /* c1+c5+c11 */
 
2642
              CONST_BITS-PASS1_BITS);
 
2643
    dataptr[1] = (DCTELEM)
 
2644
      DESCALE(tmp11 + tmp12 + tmp3 + tmp6 -
 
2645
              MULTIPLY(tmp0 + tmp6, FIX(1.126980169)),    /* c3+c5-c1 */
 
2646
              CONST_BITS-PASS1_BITS);
 
2647
 
 
2648
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
2649
  }
 
2650
 
 
2651
  /* Pass 2: process columns.
 
2652
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
2653
   * by an overall factor of 8.
 
2654
   * We must also scale the output by (8/14)*(8/7) = 32/49, which we
 
2655
   * partially fold into the constant multipliers and final shifting:
 
2656
   * 7-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/14) * 64/49.
 
2657
   */
 
2658
 
 
2659
  dataptr = data;
 
2660
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
2661
    /* Even part */
 
2662
 
 
2663
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*6];
 
2664
    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*5];
 
2665
    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*4];
 
2666
    tmp3 = dataptr[DCTSIZE*3];
 
2667
 
 
2668
    tmp10 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*6];
 
2669
    tmp11 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*5];
 
2670
    tmp12 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*4];
 
2671
 
 
2672
    z1 = tmp0 + tmp2;
 
2673
    dataptr[DCTSIZE*0] = (DCTELEM)
 
2674
      DESCALE(MULTIPLY(z1 + tmp1 + tmp3, FIX(1.306122449)), /* 64/49 */
 
2675
              CONST_BITS+PASS1_BITS+1);
 
2676
    tmp3 += tmp3;
 
2677
    z1 -= tmp3;
 
2678
    z1 -= tmp3;
 
2679
    z1 = MULTIPLY(z1, FIX(0.461784020));                /* (c2+c6-c4)/2 */
 
2680
    z2 = MULTIPLY(tmp0 - tmp2, FIX(1.202428084));       /* (c2+c4-c6)/2 */
 
2681
    z3 = MULTIPLY(tmp1 - tmp2, FIX(0.411026446));       /* c6 */
 
2682
    dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(z1 + z2 + z3, CONST_BITS+PASS1_BITS+1);
 
2683
    z1 -= z2;
 
2684
    z2 = MULTIPLY(tmp0 - tmp1, FIX(1.151670509));       /* c4 */
 
2685
    dataptr[DCTSIZE*4] = (DCTELEM)
 
2686
      DESCALE(z2 + z3 - MULTIPLY(tmp1 - tmp3, FIX(0.923568041)), /* c2+c6-c4 */
 
2687
              CONST_BITS+PASS1_BITS+1);
 
2688
    dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(z1 + z2, CONST_BITS+PASS1_BITS+1);
 
2689
 
 
2690
    /* Odd part */
 
2691
 
 
2692
    tmp1 = MULTIPLY(tmp10 + tmp11, FIX(1.221765677));   /* (c3+c1-c5)/2 */
 
2693
    tmp2 = MULTIPLY(tmp10 - tmp11, FIX(0.222383464));   /* (c3+c5-c1)/2 */
 
2694
    tmp0 = tmp1 - tmp2;
 
2695
    tmp1 += tmp2;
 
2696
    tmp2 = MULTIPLY(tmp11 + tmp12, - FIX(1.800824523)); /* -c1 */
 
2697
    tmp1 += tmp2;
 
2698
    tmp3 = MULTIPLY(tmp10 + tmp12, FIX(0.801442310));   /* c5 */
 
2699
    tmp0 += tmp3;
 
2700
    tmp2 += tmp3 + MULTIPLY(tmp12, FIX(2.443531355));   /* c3+c1-c5 */
 
2701
 
 
2702
    dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp0, CONST_BITS+PASS1_BITS+1);
 
2703
    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp1, CONST_BITS+PASS1_BITS+1);
 
2704
    dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp2, CONST_BITS+PASS1_BITS+1);
 
2705
 
 
2706
    dataptr++;                  /* advance pointer to next column */
 
2707
  }
 
2708
}
 
2709
 
 
2710
 
 
2711
/*
 
2712
 * Perform the forward DCT on a 12x6 sample block.
 
2713
 *
 
2714
 * 12-point FDCT in pass 1 (rows), 6-point in pass 2 (columns).
 
2715
 */
 
2716
 
 
2717
GLOBAL(void)
 
2718
jpeg_fdct_12x6 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
2719
{
 
2720
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
 
2721
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
 
2722
  DCTELEM *dataptr;
 
2723
  JSAMPROW elemptr;
 
2724
  int ctr;
 
2725
  SHIFT_TEMPS
 
2726
 
 
2727
  /* Zero 2 bottom rows of output coefficient block. */
 
2728
  MEMZERO(&data[DCTSIZE*6], SIZEOF(DCTELEM) * DCTSIZE * 2);
 
2729
 
 
2730
  /* Pass 1: process rows. */
 
2731
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
2732
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
2733
  /* 12-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/24). */
 
2734
 
 
2735
  dataptr = data;
 
2736
  for (ctr = 0; ctr < 6; ctr++) {
 
2737
    elemptr = sample_data[ctr] + start_col;
 
2738
 
 
2739
    /* Even part */
 
2740
 
 
2741
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[11]);
 
2742
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[10]);
 
2743
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[9]);
 
2744
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[8]);
 
2745
    tmp4 = GETJSAMPLE(elemptr[4]) + GETJSAMPLE(elemptr[7]);
 
2746
    tmp5 = GETJSAMPLE(elemptr[5]) + GETJSAMPLE(elemptr[6]);
 
2747
 
 
2748
    tmp10 = tmp0 + tmp5;
 
2749
    tmp13 = tmp0 - tmp5;
 
2750
    tmp11 = tmp1 + tmp4;
 
2751
    tmp14 = tmp1 - tmp4;
 
2752
    tmp12 = tmp2 + tmp3;
 
2753
    tmp15 = tmp2 - tmp3;
 
2754
 
 
2755
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[11]);
 
2756
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[10]);
 
2757
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[9]);
 
2758
    tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[8]);
 
2759
    tmp4 = GETJSAMPLE(elemptr[4]) - GETJSAMPLE(elemptr[7]);
 
2760
    tmp5 = GETJSAMPLE(elemptr[5]) - GETJSAMPLE(elemptr[6]);
 
2761
 
 
2762
    /* Apply unsigned->signed conversion */
 
2763
    dataptr[0] = (DCTELEM)
 
2764
      ((tmp10 + tmp11 + tmp12 - 12 * CENTERJSAMPLE) << PASS1_BITS);
 
2765
    dataptr[6] = (DCTELEM) ((tmp13 - tmp14 - tmp15) << PASS1_BITS);
 
2766
    dataptr[4] = (DCTELEM)
 
2767
      DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.224744871)), /* c4 */
 
2768
              CONST_BITS-PASS1_BITS);
 
2769
    dataptr[2] = (DCTELEM)
 
2770
      DESCALE(tmp14 - tmp15 + MULTIPLY(tmp13 + tmp15, FIX(1.366025404)), /* c2 */
 
2771
              CONST_BITS-PASS1_BITS);
 
2772
 
 
2773
    /* Odd part */
 
2774
 
 
2775
    tmp10 = MULTIPLY(tmp1 + tmp4, FIX_0_541196100);    /* c9 */
 
2776
    tmp14 = tmp10 + MULTIPLY(tmp1, FIX_0_765366865);   /* c3-c9 */
 
2777
    tmp15 = tmp10 - MULTIPLY(tmp4, FIX_1_847759065);   /* c3+c9 */
 
2778
    tmp12 = MULTIPLY(tmp0 + tmp2, FIX(1.121971054));   /* c5 */
 
2779
    tmp13 = MULTIPLY(tmp0 + tmp3, FIX(0.860918669));   /* c7 */
 
2780
    tmp10 = tmp12 + tmp13 + tmp14 - MULTIPLY(tmp0, FIX(0.580774953)) /* c5+c7-c1 */
 
2781
            + MULTIPLY(tmp5, FIX(0.184591911));        /* c11 */
 
2782
    tmp11 = MULTIPLY(tmp2 + tmp3, - FIX(0.184591911)); /* -c11 */
 
2783
    tmp12 += tmp11 - tmp15 - MULTIPLY(tmp2, FIX(2.339493912)) /* c1+c5-c11 */
 
2784
            + MULTIPLY(tmp5, FIX(0.860918669));        /* c7 */
 
2785
    tmp13 += tmp11 - tmp14 + MULTIPLY(tmp3, FIX(0.725788011)) /* c1+c11-c7 */
 
2786
            - MULTIPLY(tmp5, FIX(1.121971054));        /* c5 */
 
2787
    tmp11 = tmp15 + MULTIPLY(tmp0 - tmp3, FIX(1.306562965)) /* c3 */
 
2788
            - MULTIPLY(tmp2 + tmp5, FIX_0_541196100);  /* c9 */
 
2789
 
 
2790
    dataptr[1] = (DCTELEM) DESCALE(tmp10, CONST_BITS-PASS1_BITS);
 
2791
    dataptr[3] = (DCTELEM) DESCALE(tmp11, CONST_BITS-PASS1_BITS);
 
2792
    dataptr[5] = (DCTELEM) DESCALE(tmp12, CONST_BITS-PASS1_BITS);
 
2793
    dataptr[7] = (DCTELEM) DESCALE(tmp13, CONST_BITS-PASS1_BITS);
 
2794
 
 
2795
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
2796
  }
 
2797
 
 
2798
  /* Pass 2: process columns.
 
2799
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
2800
   * by an overall factor of 8.
 
2801
   * We must also scale the output by (8/12)*(8/6) = 8/9, which we
 
2802
   * partially fold into the constant multipliers and final shifting:
 
2803
   * 6-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/12) * 16/9.
 
2804
   */
 
2805
 
 
2806
  dataptr = data;
 
2807
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
2808
    /* Even part */
 
2809
 
 
2810
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*5];
 
2811
    tmp11 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*4];
 
2812
    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*3];
 
2813
 
 
2814
    tmp10 = tmp0 + tmp2;
 
2815
    tmp12 = tmp0 - tmp2;
 
2816
 
 
2817
    tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*5];
 
2818
    tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*4];
 
2819
    tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*3];
 
2820
 
 
2821
    dataptr[DCTSIZE*0] = (DCTELEM)
 
2822
      DESCALE(MULTIPLY(tmp10 + tmp11, FIX(1.777777778)),         /* 16/9 */
 
2823
              CONST_BITS+PASS1_BITS+1);
 
2824
    dataptr[DCTSIZE*2] = (DCTELEM)
 
2825
      DESCALE(MULTIPLY(tmp12, FIX(2.177324216)),                 /* c2 */
 
2826
              CONST_BITS+PASS1_BITS+1);
 
2827
    dataptr[DCTSIZE*4] = (DCTELEM)
 
2828
      DESCALE(MULTIPLY(tmp10 - tmp11 - tmp11, FIX(1.257078722)), /* c4 */
 
2829
              CONST_BITS+PASS1_BITS+1);
 
2830
 
 
2831
    /* Odd part */
 
2832
 
 
2833
    tmp10 = MULTIPLY(tmp0 + tmp2, FIX(0.650711829));             /* c5 */
 
2834
 
 
2835
    dataptr[DCTSIZE*1] = (DCTELEM)
 
2836
      DESCALE(tmp10 + MULTIPLY(tmp0 + tmp1, FIX(1.777777778)),   /* 16/9 */
 
2837
              CONST_BITS+PASS1_BITS+1);
 
2838
    dataptr[DCTSIZE*3] = (DCTELEM)
 
2839
      DESCALE(MULTIPLY(tmp0 - tmp1 - tmp2, FIX(1.777777778)),    /* 16/9 */
 
2840
              CONST_BITS+PASS1_BITS+1);
 
2841
    dataptr[DCTSIZE*5] = (DCTELEM)
 
2842
      DESCALE(tmp10 + MULTIPLY(tmp2 - tmp1, FIX(1.777777778)),   /* 16/9 */
 
2843
              CONST_BITS+PASS1_BITS+1);
 
2844
 
 
2845
    dataptr++;                  /* advance pointer to next column */
 
2846
  }
 
2847
}
 
2848
 
 
2849
 
 
2850
/*
 
2851
 * Perform the forward DCT on a 10x5 sample block.
 
2852
 *
 
2853
 * 10-point FDCT in pass 1 (rows), 5-point in pass 2 (columns).
 
2854
 */
 
2855
 
 
2856
GLOBAL(void)
 
2857
jpeg_fdct_10x5 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
2858
{
 
2859
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4;
 
2860
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
 
2861
  DCTELEM *dataptr;
 
2862
  JSAMPROW elemptr;
 
2863
  int ctr;
 
2864
  SHIFT_TEMPS
 
2865
 
 
2866
  /* Zero 3 bottom rows of output coefficient block. */
 
2867
  MEMZERO(&data[DCTSIZE*5], SIZEOF(DCTELEM) * DCTSIZE * 3);
 
2868
 
 
2869
  /* Pass 1: process rows. */
 
2870
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
2871
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
2872
  /* 10-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/20). */
 
2873
 
 
2874
  dataptr = data;
 
2875
  for (ctr = 0; ctr < 5; ctr++) {
 
2876
    elemptr = sample_data[ctr] + start_col;
 
2877
 
 
2878
    /* Even part */
 
2879
 
 
2880
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[9]);
 
2881
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[8]);
 
2882
    tmp12 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[7]);
 
2883
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[6]);
 
2884
    tmp4 = GETJSAMPLE(elemptr[4]) + GETJSAMPLE(elemptr[5]);
 
2885
 
 
2886
    tmp10 = tmp0 + tmp4;
 
2887
    tmp13 = tmp0 - tmp4;
 
2888
    tmp11 = tmp1 + tmp3;
 
2889
    tmp14 = tmp1 - tmp3;
 
2890
 
 
2891
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[9]);
 
2892
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[8]);
 
2893
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[7]);
 
2894
    tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[6]);
 
2895
    tmp4 = GETJSAMPLE(elemptr[4]) - GETJSAMPLE(elemptr[5]);
 
2896
 
 
2897
    /* Apply unsigned->signed conversion */
 
2898
    dataptr[0] = (DCTELEM)
 
2899
      ((tmp10 + tmp11 + tmp12 - 10 * CENTERJSAMPLE) << PASS1_BITS);
 
2900
    tmp12 += tmp12;
 
2901
    dataptr[4] = (DCTELEM)
 
2902
      DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.144122806)) - /* c4 */
 
2903
              MULTIPLY(tmp11 - tmp12, FIX(0.437016024)),  /* c8 */
 
2904
              CONST_BITS-PASS1_BITS);
 
2905
    tmp10 = MULTIPLY(tmp13 + tmp14, FIX(0.831253876));    /* c6 */
 
2906
    dataptr[2] = (DCTELEM)
 
2907
      DESCALE(tmp10 + MULTIPLY(tmp13, FIX(0.513743148)),  /* c2-c6 */
 
2908
              CONST_BITS-PASS1_BITS);
 
2909
    dataptr[6] = (DCTELEM)
 
2910
      DESCALE(tmp10 - MULTIPLY(tmp14, FIX(2.176250899)),  /* c2+c6 */
 
2911
              CONST_BITS-PASS1_BITS);
 
2912
 
 
2913
    /* Odd part */
 
2914
 
 
2915
    tmp10 = tmp0 + tmp4;
 
2916
    tmp11 = tmp1 - tmp3;
 
2917
    dataptr[5] = (DCTELEM) ((tmp10 - tmp11 - tmp2) << PASS1_BITS);
 
2918
    tmp2 <<= CONST_BITS;
 
2919
    dataptr[1] = (DCTELEM)
 
2920
      DESCALE(MULTIPLY(tmp0, FIX(1.396802247)) +          /* c1 */
 
2921
              MULTIPLY(tmp1, FIX(1.260073511)) + tmp2 +   /* c3 */
 
2922
              MULTIPLY(tmp3, FIX(0.642039522)) +          /* c7 */
 
2923
              MULTIPLY(tmp4, FIX(0.221231742)),           /* c9 */
 
2924
              CONST_BITS-PASS1_BITS);
 
2925
    tmp12 = MULTIPLY(tmp0 - tmp4, FIX(0.951056516)) -     /* (c3+c7)/2 */
 
2926
            MULTIPLY(tmp1 + tmp3, FIX(0.587785252));      /* (c1-c9)/2 */
 
2927
    tmp13 = MULTIPLY(tmp10 + tmp11, FIX(0.309016994)) +   /* (c3-c7)/2 */
 
2928
            (tmp11 << (CONST_BITS - 1)) - tmp2;
 
2929
    dataptr[3] = (DCTELEM) DESCALE(tmp12 + tmp13, CONST_BITS-PASS1_BITS);
 
2930
    dataptr[7] = (DCTELEM) DESCALE(tmp12 - tmp13, CONST_BITS-PASS1_BITS);
 
2931
 
 
2932
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
2933
  }
 
2934
 
 
2935
  /* Pass 2: process columns.
 
2936
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
2937
   * by an overall factor of 8.
 
2938
   * We must also scale the output by (8/10)*(8/5) = 32/25, which we
 
2939
   * fold into the constant multipliers:
 
2940
   * 5-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/10) * 32/25.
 
2941
   */
 
2942
 
 
2943
  dataptr = data;
 
2944
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
2945
    /* Even part */
 
2946
 
 
2947
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*4];
 
2948
    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*3];
 
2949
    tmp2 = dataptr[DCTSIZE*2];
 
2950
 
 
2951
    tmp10 = tmp0 + tmp1;
 
2952
    tmp11 = tmp0 - tmp1;
 
2953
 
 
2954
    tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*4];
 
2955
    tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*3];
 
2956
 
 
2957
    dataptr[DCTSIZE*0] = (DCTELEM)
 
2958
      DESCALE(MULTIPLY(tmp10 + tmp2, FIX(1.28)),        /* 32/25 */
 
2959
              CONST_BITS+PASS1_BITS);
 
2960
    tmp11 = MULTIPLY(tmp11, FIX(1.011928851));          /* (c2+c4)/2 */
 
2961
    tmp10 -= tmp2 << 2;
 
2962
    tmp10 = MULTIPLY(tmp10, FIX(0.452548340));          /* (c2-c4)/2 */
 
2963
    dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(tmp11 + tmp10, CONST_BITS+PASS1_BITS);
 
2964
    dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp11 - tmp10, CONST_BITS+PASS1_BITS);
 
2965
 
 
2966
    /* Odd part */
 
2967
 
 
2968
    tmp10 = MULTIPLY(tmp0 + tmp1, FIX(1.064004961));    /* c3 */
 
2969
 
 
2970
    dataptr[DCTSIZE*1] = (DCTELEM)
 
2971
      DESCALE(tmp10 + MULTIPLY(tmp0, FIX(0.657591230)), /* c1-c3 */
 
2972
              CONST_BITS+PASS1_BITS);
 
2973
    dataptr[DCTSIZE*3] = (DCTELEM)
 
2974
      DESCALE(tmp10 - MULTIPLY(tmp1, FIX(2.785601151)), /* c1+c3 */
 
2975
              CONST_BITS+PASS1_BITS);
 
2976
 
 
2977
    dataptr++;                  /* advance pointer to next column */
 
2978
  }
 
2979
}
 
2980
 
 
2981
 
 
2982
/*
 
2983
 * Perform the forward DCT on an 8x4 sample block.
 
2984
 *
 
2985
 * 8-point FDCT in pass 1 (rows), 4-point in pass 2 (columns).
 
2986
 */
 
2987
 
 
2988
GLOBAL(void)
 
2989
jpeg_fdct_8x4 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
2990
{
 
2991
  INT32 tmp0, tmp1, tmp2, tmp3;
 
2992
  INT32 tmp10, tmp11, tmp12, tmp13;
 
2993
  INT32 z1;
 
2994
  DCTELEM *dataptr;
 
2995
  JSAMPROW elemptr;
 
2996
  int ctr;
 
2997
  SHIFT_TEMPS
 
2998
 
 
2999
  /* Zero 4 bottom rows of output coefficient block. */
 
3000
  MEMZERO(&data[DCTSIZE*4], SIZEOF(DCTELEM) * DCTSIZE * 4);
 
3001
 
 
3002
  /* Pass 1: process rows. */
 
3003
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
3004
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
3005
  /* We must also scale the output by 8/4 = 2, which we add here. */
 
3006
 
 
3007
  dataptr = data;
 
3008
  for (ctr = 0; ctr < 4; ctr++) {
 
3009
    elemptr = sample_data[ctr] + start_col;
 
3010
 
 
3011
    /* Even part per LL&M figure 1 --- note that published figure is faulty;
 
3012
     * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
 
3013
     */
 
3014
 
 
3015
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[7]);
 
3016
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[6]);
 
3017
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[5]);
 
3018
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[4]);
 
3019
 
 
3020
    tmp10 = tmp0 + tmp3;
 
3021
    tmp12 = tmp0 - tmp3;
 
3022
    tmp11 = tmp1 + tmp2;
 
3023
    tmp13 = tmp1 - tmp2;
 
3024
 
 
3025
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[7]);
 
3026
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[6]);
 
3027
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[5]);
 
3028
    tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[4]);
 
3029
 
 
3030
    /* Apply unsigned->signed conversion */
 
3031
    dataptr[0] = (DCTELEM)
 
3032
      ((tmp10 + tmp11 - 8 * CENTERJSAMPLE) << (PASS1_BITS+1));
 
3033
    dataptr[4] = (DCTELEM) ((tmp10 - tmp11) << (PASS1_BITS+1));
 
3034
 
 
3035
    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
 
3036
    /* Add fudge factor here for final descale. */
 
3037
    z1 += ONE << (CONST_BITS-PASS1_BITS-2);
 
3038
    dataptr[2] = (DCTELEM) RIGHT_SHIFT(z1 + MULTIPLY(tmp12, FIX_0_765366865),
 
3039
                                       CONST_BITS-PASS1_BITS-1);
 
3040
    dataptr[6] = (DCTELEM) RIGHT_SHIFT(z1 - MULTIPLY(tmp13, FIX_1_847759065),
 
3041
                                       CONST_BITS-PASS1_BITS-1);
 
3042
 
 
3043
    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
 
3044
     * 8-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
 
3045
     * i0..i3 in the paper are tmp0..tmp3 here.
 
3046
     */
 
3047
 
 
3048
    tmp10 = tmp0 + tmp3;
 
3049
    tmp11 = tmp1 + tmp2;
 
3050
    tmp12 = tmp0 + tmp2;
 
3051
    tmp13 = tmp1 + tmp3;
 
3052
    z1 = MULTIPLY(tmp12 + tmp13, FIX_1_175875602); /*  c3 */
 
3053
    /* Add fudge factor here for final descale. */
 
3054
    z1 += ONE << (CONST_BITS-PASS1_BITS-2);
 
3055
 
 
3056
    tmp0  = MULTIPLY(tmp0,    FIX_1_501321110);    /*  c1+c3-c5-c7 */
 
3057
    tmp1  = MULTIPLY(tmp1,    FIX_3_072711026);    /*  c1+c3+c5-c7 */
 
3058
    tmp2  = MULTIPLY(tmp2,    FIX_2_053119869);    /*  c1+c3-c5+c7 */
 
3059
    tmp3  = MULTIPLY(tmp3,    FIX_0_298631336);    /* -c1+c3+c5-c7 */
 
3060
    tmp10 = MULTIPLY(tmp10, - FIX_0_899976223);    /*  c7-c3 */
 
3061
    tmp11 = MULTIPLY(tmp11, - FIX_2_562915447);    /* -c1-c3 */
 
3062
    tmp12 = MULTIPLY(tmp12, - FIX_0_390180644);    /*  c5-c3 */
 
3063
    tmp13 = MULTIPLY(tmp13, - FIX_1_961570560);    /* -c3-c5 */
 
3064
 
 
3065
    tmp12 += z1;
 
3066
    tmp13 += z1;
 
3067
 
 
3068
    dataptr[1] = (DCTELEM)
 
3069
      RIGHT_SHIFT(tmp0 + tmp10 + tmp12, CONST_BITS-PASS1_BITS-1);
 
3070
    dataptr[3] = (DCTELEM)
 
3071
      RIGHT_SHIFT(tmp1 + tmp11 + tmp13, CONST_BITS-PASS1_BITS-1);
 
3072
    dataptr[5] = (DCTELEM)
 
3073
      RIGHT_SHIFT(tmp2 + tmp11 + tmp12, CONST_BITS-PASS1_BITS-1);
 
3074
    dataptr[7] = (DCTELEM)
 
3075
      RIGHT_SHIFT(tmp3 + tmp10 + tmp13, CONST_BITS-PASS1_BITS-1);
 
3076
 
 
3077
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
3078
  }
 
3079
 
 
3080
  /* Pass 2: process columns.
 
3081
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
3082
   * by an overall factor of 8.
 
3083
   * 4-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
 
3084
   */
 
3085
 
 
3086
  dataptr = data;
 
3087
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
3088
    /* Even part */
 
3089
 
 
3090
    /* Add fudge factor here for final descale. */
 
3091
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*3] + (ONE << (PASS1_BITS-1));
 
3092
    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*2];
 
3093
 
 
3094
    tmp10 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*3];
 
3095
    tmp11 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*2];
 
3096
 
 
3097
    dataptr[DCTSIZE*0] = (DCTELEM) RIGHT_SHIFT(tmp0 + tmp1, PASS1_BITS);
 
3098
    dataptr[DCTSIZE*2] = (DCTELEM) RIGHT_SHIFT(tmp0 - tmp1, PASS1_BITS);
 
3099
 
 
3100
    /* Odd part */
 
3101
 
 
3102
    tmp0 = MULTIPLY(tmp10 + tmp11, FIX_0_541196100);   /* c6 */
 
3103
    /* Add fudge factor here for final descale. */
 
3104
    tmp0 += ONE << (CONST_BITS+PASS1_BITS-1);
 
3105
 
 
3106
    dataptr[DCTSIZE*1] = (DCTELEM)
 
3107
      RIGHT_SHIFT(tmp0 + MULTIPLY(tmp10, FIX_0_765366865), /* c2-c6 */
 
3108
                  CONST_BITS+PASS1_BITS);
 
3109
    dataptr[DCTSIZE*3] = (DCTELEM)
 
3110
      RIGHT_SHIFT(tmp0 - MULTIPLY(tmp11, FIX_1_847759065), /* c2+c6 */
 
3111
                  CONST_BITS+PASS1_BITS);
 
3112
 
 
3113
    dataptr++;                  /* advance pointer to next column */
 
3114
  }
 
3115
}
 
3116
 
 
3117
 
 
3118
/*
 
3119
 * Perform the forward DCT on a 6x3 sample block.
 
3120
 *
 
3121
 * 6-point FDCT in pass 1 (rows), 3-point in pass 2 (columns).
 
3122
 */
 
3123
 
 
3124
GLOBAL(void)
 
3125
jpeg_fdct_6x3 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
3126
{
 
3127
  INT32 tmp0, tmp1, tmp2;
 
3128
  INT32 tmp10, tmp11, tmp12;
 
3129
  DCTELEM *dataptr;
 
3130
  JSAMPROW elemptr;
 
3131
  int ctr;
 
3132
  SHIFT_TEMPS
 
3133
 
 
3134
  /* Pre-zero output coefficient block. */
 
3135
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
3136
 
 
3137
  /* Pass 1: process rows. */
 
3138
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
3139
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
3140
  /* We scale the results further by 2 as part of output adaption */
 
3141
  /* scaling for different DCT size. */
 
3142
  /* 6-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/12). */
 
3143
 
 
3144
  dataptr = data;
 
3145
  for (ctr = 0; ctr < 3; ctr++) {
 
3146
    elemptr = sample_data[ctr] + start_col;
 
3147
 
 
3148
    /* Even part */
 
3149
 
 
3150
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[5]);
 
3151
    tmp11 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[4]);
 
3152
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[3]);
 
3153
 
 
3154
    tmp10 = tmp0 + tmp2;
 
3155
    tmp12 = tmp0 - tmp2;
 
3156
 
 
3157
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[5]);
 
3158
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[4]);
 
3159
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[3]);
 
3160
 
 
3161
    /* Apply unsigned->signed conversion */
 
3162
    dataptr[0] = (DCTELEM)
 
3163
      ((tmp10 + tmp11 - 6 * CENTERJSAMPLE) << (PASS1_BITS+1));
 
3164
    dataptr[2] = (DCTELEM)
 
3165
      DESCALE(MULTIPLY(tmp12, FIX(1.224744871)),                 /* c2 */
 
3166
              CONST_BITS-PASS1_BITS-1);
 
3167
    dataptr[4] = (DCTELEM)
 
3168
      DESCALE(MULTIPLY(tmp10 - tmp11 - tmp11, FIX(0.707106781)), /* c4 */
 
3169
              CONST_BITS-PASS1_BITS-1);
 
3170
 
 
3171
    /* Odd part */
 
3172
 
 
3173
    tmp10 = DESCALE(MULTIPLY(tmp0 + tmp2, FIX(0.366025404)),     /* c5 */
 
3174
                    CONST_BITS-PASS1_BITS-1);
 
3175
 
 
3176
    dataptr[1] = (DCTELEM) (tmp10 + ((tmp0 + tmp1) << (PASS1_BITS+1)));
 
3177
    dataptr[3] = (DCTELEM) ((tmp0 - tmp1 - tmp2) << (PASS1_BITS+1));
 
3178
    dataptr[5] = (DCTELEM) (tmp10 + ((tmp2 - tmp1) << (PASS1_BITS+1)));
 
3179
 
 
3180
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
3181
  }
 
3182
 
 
3183
  /* Pass 2: process columns.
 
3184
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
3185
   * by an overall factor of 8.
 
3186
   * We must also scale the output by (8/6)*(8/3) = 32/9, which we partially
 
3187
   * fold into the constant multipliers (other part was done in pass 1):
 
3188
   * 3-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/6) * 16/9.
 
3189
   */
 
3190
 
 
3191
  dataptr = data;
 
3192
  for (ctr = 0; ctr < 6; ctr++) {
 
3193
    /* Even part */
 
3194
 
 
3195
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*2];
 
3196
    tmp1 = dataptr[DCTSIZE*1];
 
3197
 
 
3198
    tmp2 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*2];
 
3199
 
 
3200
    dataptr[DCTSIZE*0] = (DCTELEM)
 
3201
      DESCALE(MULTIPLY(tmp0 + tmp1, FIX(1.777777778)),        /* 16/9 */
 
3202
              CONST_BITS+PASS1_BITS);
 
3203
    dataptr[DCTSIZE*2] = (DCTELEM)
 
3204
      DESCALE(MULTIPLY(tmp0 - tmp1 - tmp1, FIX(1.257078722)), /* c2 */
 
3205
              CONST_BITS+PASS1_BITS);
 
3206
 
 
3207
    /* Odd part */
 
3208
 
 
3209
    dataptr[DCTSIZE*1] = (DCTELEM)
 
3210
      DESCALE(MULTIPLY(tmp2, FIX(2.177324216)),               /* c1 */
 
3211
              CONST_BITS+PASS1_BITS);
 
3212
 
 
3213
    dataptr++;                  /* advance pointer to next column */
 
3214
  }
 
3215
}
 
3216
 
 
3217
 
 
3218
/*
 
3219
 * Perform the forward DCT on a 4x2 sample block.
 
3220
 *
 
3221
 * 4-point FDCT in pass 1 (rows), 2-point in pass 2 (columns).
 
3222
 */
 
3223
 
 
3224
GLOBAL(void)
 
3225
jpeg_fdct_4x2 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
3226
{
 
3227
  INT32 tmp0, tmp1;
 
3228
  INT32 tmp10, tmp11;
 
3229
  DCTELEM *dataptr;
 
3230
  JSAMPROW elemptr;
 
3231
  int ctr;
 
3232
  SHIFT_TEMPS
 
3233
 
 
3234
  /* Pre-zero output coefficient block. */
 
3235
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
3236
 
 
3237
  /* Pass 1: process rows. */
 
3238
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
3239
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
3240
  /* We must also scale the output by (8/4)*(8/2) = 2**3, which we add here. */
 
3241
  /* 4-point FDCT kernel, */
 
3242
  /* cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT]. */
 
3243
 
 
3244
  dataptr = data;
 
3245
  for (ctr = 0; ctr < 2; ctr++) {
 
3246
    elemptr = sample_data[ctr] + start_col;
 
3247
 
 
3248
    /* Even part */
 
3249
 
 
3250
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[3]);
 
3251
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[2]);
 
3252
 
 
3253
    tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[3]);
 
3254
    tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[2]);
 
3255
 
 
3256
    /* Apply unsigned->signed conversion */
 
3257
    dataptr[0] = (DCTELEM)
 
3258
      ((tmp0 + tmp1 - 4 * CENTERJSAMPLE) << (PASS1_BITS+3));
 
3259
    dataptr[2] = (DCTELEM) ((tmp0 - tmp1) << (PASS1_BITS+3));
 
3260
 
 
3261
    /* Odd part */
 
3262
 
 
3263
    tmp0 = MULTIPLY(tmp10 + tmp11, FIX_0_541196100);       /* c6 */
 
3264
    /* Add fudge factor here for final descale. */
 
3265
    tmp0 += ONE << (CONST_BITS-PASS1_BITS-4);
 
3266
 
 
3267
    dataptr[1] = (DCTELEM)
 
3268
      RIGHT_SHIFT(tmp0 + MULTIPLY(tmp10, FIX_0_765366865), /* c2-c6 */
 
3269
                  CONST_BITS-PASS1_BITS-3);
 
3270
    dataptr[3] = (DCTELEM)
 
3271
      RIGHT_SHIFT(tmp0 - MULTIPLY(tmp11, FIX_1_847759065), /* c2+c6 */
 
3272
                  CONST_BITS-PASS1_BITS-3);
 
3273
 
 
3274
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
3275
  }
 
3276
 
 
3277
  /* Pass 2: process columns.
 
3278
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
3279
   * by an overall factor of 8.
 
3280
   */
 
3281
 
 
3282
  dataptr = data;
 
3283
  for (ctr = 0; ctr < 4; ctr++) {
 
3284
    /* Even part */
 
3285
 
 
3286
    /* Add fudge factor here for final descale. */
 
3287
    tmp0 = dataptr[DCTSIZE*0] + (ONE << (PASS1_BITS-1));
 
3288
    tmp1 = dataptr[DCTSIZE*1];
 
3289
 
 
3290
    dataptr[DCTSIZE*0] = (DCTELEM) RIGHT_SHIFT(tmp0 + tmp1, PASS1_BITS);
 
3291
 
 
3292
    /* Odd part */
 
3293
 
 
3294
    dataptr[DCTSIZE*1] = (DCTELEM) RIGHT_SHIFT(tmp0 - tmp1, PASS1_BITS);
 
3295
 
 
3296
    dataptr++;                  /* advance pointer to next column */
 
3297
  }
 
3298
}
 
3299
 
 
3300
 
 
3301
/*
 
3302
 * Perform the forward DCT on a 2x1 sample block.
 
3303
 *
 
3304
 * 2-point FDCT in pass 1 (rows), 1-point in pass 2 (columns).
 
3305
 */
 
3306
 
 
3307
GLOBAL(void)
 
3308
jpeg_fdct_2x1 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
3309
{
 
3310
  INT32 tmp0, tmp1;
 
3311
  JSAMPROW elemptr;
 
3312
 
 
3313
  /* Pre-zero output coefficient block. */
 
3314
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
3315
 
 
3316
  elemptr = sample_data[0] + start_col;
 
3317
 
 
3318
  tmp0 = GETJSAMPLE(elemptr[0]);
 
3319
  tmp1 = GETJSAMPLE(elemptr[1]);
 
3320
 
 
3321
  /* We leave the results scaled up by an overall factor of 8.
 
3322
   * We must also scale the output by (8/2)*(8/1) = 2**5.
 
3323
   */
 
3324
 
 
3325
  /* Even part */
 
3326
  /* Apply unsigned->signed conversion */
 
3327
  data[0] = (DCTELEM) ((tmp0 + tmp1 - 2 * CENTERJSAMPLE) << 5);
 
3328
 
 
3329
  /* Odd part */
 
3330
  data[1] = (DCTELEM) ((tmp0 - tmp1) << 5);
 
3331
}
 
3332
 
 
3333
 
 
3334
/*
 
3335
 * Perform the forward DCT on an 8x16 sample block.
 
3336
 *
 
3337
 * 8-point FDCT in pass 1 (rows), 16-point in pass 2 (columns).
 
3338
 */
 
3339
 
 
3340
GLOBAL(void)
 
3341
jpeg_fdct_8x16 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
3342
{
 
3343
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 
3344
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16, tmp17;
 
3345
  INT32 z1;
 
3346
  DCTELEM workspace[DCTSIZE2];
 
3347
  DCTELEM *dataptr;
 
3348
  DCTELEM *wsptr;
 
3349
  JSAMPROW elemptr;
 
3350
  int ctr;
 
3351
  SHIFT_TEMPS
 
3352
 
 
3353
  /* Pass 1: process rows. */
 
3354
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
3355
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
3356
 
 
3357
  dataptr = data;
 
3358
  ctr = 0;
 
3359
  for (;;) {
 
3360
    elemptr = sample_data[ctr] + start_col;
 
3361
 
 
3362
    /* Even part per LL&M figure 1 --- note that published figure is faulty;
 
3363
     * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
 
3364
     */
 
3365
 
 
3366
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[7]);
 
3367
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[6]);
 
3368
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[5]);
 
3369
    tmp3 = GETJSAMPLE(elemptr[3]) + GETJSAMPLE(elemptr[4]);
 
3370
 
 
3371
    tmp10 = tmp0 + tmp3;
 
3372
    tmp12 = tmp0 - tmp3;
 
3373
    tmp11 = tmp1 + tmp2;
 
3374
    tmp13 = tmp1 - tmp2;
 
3375
 
 
3376
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[7]);
 
3377
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[6]);
 
3378
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[5]);
 
3379
    tmp3 = GETJSAMPLE(elemptr[3]) - GETJSAMPLE(elemptr[4]);
 
3380
 
 
3381
    /* Apply unsigned->signed conversion */
 
3382
    dataptr[0] = (DCTELEM) ((tmp10 + tmp11 - 8 * CENTERJSAMPLE) << PASS1_BITS);
 
3383
    dataptr[4] = (DCTELEM) ((tmp10 - tmp11) << PASS1_BITS);
 
3384
 
 
3385
    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
 
3386
    dataptr[2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, FIX_0_765366865),
 
3387
                                   CONST_BITS-PASS1_BITS);
 
3388
    dataptr[6] = (DCTELEM) DESCALE(z1 - MULTIPLY(tmp13, FIX_1_847759065),
 
3389
                                   CONST_BITS-PASS1_BITS);
 
3390
 
 
3391
    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
 
3392
     * 8-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
 
3393
     * i0..i3 in the paper are tmp0..tmp3 here.
 
3394
     */
 
3395
 
 
3396
    tmp10 = tmp0 + tmp3;
 
3397
    tmp11 = tmp1 + tmp2;
 
3398
    tmp12 = tmp0 + tmp2;
 
3399
    tmp13 = tmp1 + tmp3;
 
3400
    z1 = MULTIPLY(tmp12 + tmp13, FIX_1_175875602); /*  c3 */
 
3401
 
 
3402
    tmp0  = MULTIPLY(tmp0,    FIX_1_501321110);    /*  c1+c3-c5-c7 */
 
3403
    tmp1  = MULTIPLY(tmp1,    FIX_3_072711026);    /*  c1+c3+c5-c7 */
 
3404
    tmp2  = MULTIPLY(tmp2,    FIX_2_053119869);    /*  c1+c3-c5+c7 */
 
3405
    tmp3  = MULTIPLY(tmp3,    FIX_0_298631336);    /* -c1+c3+c5-c7 */
 
3406
    tmp10 = MULTIPLY(tmp10, - FIX_0_899976223);    /*  c7-c3 */
 
3407
    tmp11 = MULTIPLY(tmp11, - FIX_2_562915447);    /* -c1-c3 */
 
3408
    tmp12 = MULTIPLY(tmp12, - FIX_0_390180644);    /*  c5-c3 */
 
3409
    tmp13 = MULTIPLY(tmp13, - FIX_1_961570560);    /* -c3-c5 */
 
3410
 
 
3411
    tmp12 += z1;
 
3412
    tmp13 += z1;
 
3413
 
 
3414
    dataptr[1] = (DCTELEM) DESCALE(tmp0 + tmp10 + tmp12, CONST_BITS-PASS1_BITS);
 
3415
    dataptr[3] = (DCTELEM) DESCALE(tmp1 + tmp11 + tmp13, CONST_BITS-PASS1_BITS);
 
3416
    dataptr[5] = (DCTELEM) DESCALE(tmp2 + tmp11 + tmp12, CONST_BITS-PASS1_BITS);
 
3417
    dataptr[7] = (DCTELEM) DESCALE(tmp3 + tmp10 + tmp13, CONST_BITS-PASS1_BITS);
 
3418
 
 
3419
    ctr++;
 
3420
 
 
3421
    if (ctr != DCTSIZE) {
 
3422
      if (ctr == DCTSIZE * 2)
 
3423
        break;                  /* Done. */
 
3424
      dataptr += DCTSIZE;       /* advance pointer to next row */
 
3425
    } else
 
3426
      dataptr = workspace;      /* switch pointer to extended workspace */
 
3427
  }
 
3428
 
 
3429
  /* Pass 2: process columns.
 
3430
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
3431
   * by an overall factor of 8.
 
3432
   * We must also scale the output by 8/16 = 1/2.
 
3433
   * 16-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/32).
 
3434
   */
 
3435
 
 
3436
  dataptr = data;
 
3437
  wsptr = workspace;
 
3438
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
 
3439
    /* Even part */
 
3440
 
 
3441
    tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*7];
 
3442
    tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*6];
 
3443
    tmp2 = dataptr[DCTSIZE*2] + wsptr[DCTSIZE*5];
 
3444
    tmp3 = dataptr[DCTSIZE*3] + wsptr[DCTSIZE*4];
 
3445
    tmp4 = dataptr[DCTSIZE*4] + wsptr[DCTSIZE*3];
 
3446
    tmp5 = dataptr[DCTSIZE*5] + wsptr[DCTSIZE*2];
 
3447
    tmp6 = dataptr[DCTSIZE*6] + wsptr[DCTSIZE*1];
 
3448
    tmp7 = dataptr[DCTSIZE*7] + wsptr[DCTSIZE*0];
 
3449
 
 
3450
    tmp10 = tmp0 + tmp7;
 
3451
    tmp14 = tmp0 - tmp7;
 
3452
    tmp11 = tmp1 + tmp6;
 
3453
    tmp15 = tmp1 - tmp6;
 
3454
    tmp12 = tmp2 + tmp5;
 
3455
    tmp16 = tmp2 - tmp5;
 
3456
    tmp13 = tmp3 + tmp4;
 
3457
    tmp17 = tmp3 - tmp4;
 
3458
 
 
3459
    tmp0 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*7];
 
3460
    tmp1 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*6];
 
3461
    tmp2 = dataptr[DCTSIZE*2] - wsptr[DCTSIZE*5];
 
3462
    tmp3 = dataptr[DCTSIZE*3] - wsptr[DCTSIZE*4];
 
3463
    tmp4 = dataptr[DCTSIZE*4] - wsptr[DCTSIZE*3];
 
3464
    tmp5 = dataptr[DCTSIZE*5] - wsptr[DCTSIZE*2];
 
3465
    tmp6 = dataptr[DCTSIZE*6] - wsptr[DCTSIZE*1];
 
3466
    tmp7 = dataptr[DCTSIZE*7] - wsptr[DCTSIZE*0];
 
3467
 
 
3468
    dataptr[DCTSIZE*0] = (DCTELEM)
 
3469
      DESCALE(tmp10 + tmp11 + tmp12 + tmp13, PASS1_BITS+1);
 
3470
    dataptr[DCTSIZE*4] = (DCTELEM)
 
3471
      DESCALE(MULTIPLY(tmp10 - tmp13, FIX(1.306562965)) + /* c4[16] = c2[8] */
 
3472
              MULTIPLY(tmp11 - tmp12, FIX_0_541196100),   /* c12[16] = c6[8] */
 
3473
              CONST_BITS+PASS1_BITS+1);
 
3474
 
 
3475
    tmp10 = MULTIPLY(tmp17 - tmp15, FIX(0.275899379)) +   /* c14[16] = c7[8] */
 
3476
            MULTIPLY(tmp14 - tmp16, FIX(1.387039845));    /* c2[16] = c1[8] */
 
3477
 
 
3478
    dataptr[DCTSIZE*2] = (DCTELEM)
 
3479
      DESCALE(tmp10 + MULTIPLY(tmp15, FIX(1.451774982))   /* c6+c14 */
 
3480
              + MULTIPLY(tmp16, FIX(2.172734804)),        /* c2+c10 */
 
3481
              CONST_BITS+PASS1_BITS+1);
 
3482
    dataptr[DCTSIZE*6] = (DCTELEM)
 
3483
      DESCALE(tmp10 - MULTIPLY(tmp14, FIX(0.211164243))   /* c2-c6 */
 
3484
              - MULTIPLY(tmp17, FIX(1.061594338)),        /* c10+c14 */
 
3485
              CONST_BITS+PASS1_BITS+1);
 
3486
 
 
3487
    /* Odd part */
 
3488
 
 
3489
    tmp11 = MULTIPLY(tmp0 + tmp1, FIX(1.353318001)) +         /* c3 */
 
3490
            MULTIPLY(tmp6 - tmp7, FIX(0.410524528));          /* c13 */
 
3491
    tmp12 = MULTIPLY(tmp0 + tmp2, FIX(1.247225013)) +         /* c5 */
 
3492
            MULTIPLY(tmp5 + tmp7, FIX(0.666655658));          /* c11 */
 
3493
    tmp13 = MULTIPLY(tmp0 + tmp3, FIX(1.093201867)) +         /* c7 */
 
3494
            MULTIPLY(tmp4 - tmp7, FIX(0.897167586));          /* c9 */
 
3495
    tmp14 = MULTIPLY(tmp1 + tmp2, FIX(0.138617169)) +         /* c15 */
 
3496
            MULTIPLY(tmp6 - tmp5, FIX(1.407403738));          /* c1 */
 
3497
    tmp15 = MULTIPLY(tmp1 + tmp3, - FIX(0.666655658)) +       /* -c11 */
 
3498
            MULTIPLY(tmp4 + tmp6, - FIX(1.247225013));        /* -c5 */
 
3499
    tmp16 = MULTIPLY(tmp2 + tmp3, - FIX(1.353318001)) +       /* -c3 */
 
3500
            MULTIPLY(tmp5 - tmp4, FIX(0.410524528));          /* c13 */
 
3501
    tmp10 = tmp11 + tmp12 + tmp13 -
 
3502
            MULTIPLY(tmp0, FIX(2.286341144)) +                /* c7+c5+c3-c1 */
 
3503
            MULTIPLY(tmp7, FIX(0.779653625));                 /* c15+c13-c11+c9 */
 
3504
    tmp11 += tmp14 + tmp15 + MULTIPLY(tmp1, FIX(0.071888074)) /* c9-c3-c15+c11 */
 
3505
             - MULTIPLY(tmp6, FIX(1.663905119));              /* c7+c13+c1-c5 */
 
3506
    tmp12 += tmp14 + tmp16 - MULTIPLY(tmp2, FIX(1.125726048)) /* c7+c5+c15-c3 */
 
3507
             + MULTIPLY(tmp5, FIX(1.227391138));              /* c9-c11+c1-c13 */
 
3508
    tmp13 += tmp15 + tmp16 + MULTIPLY(tmp3, FIX(1.065388962)) /* c15+c3+c11-c7 */
 
3509
             + MULTIPLY(tmp4, FIX(2.167985692));              /* c1+c13+c5-c9 */
 
3510
 
 
3511
    dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp10, CONST_BITS+PASS1_BITS+1);
 
3512
    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp11, CONST_BITS+PASS1_BITS+1);
 
3513
    dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp12, CONST_BITS+PASS1_BITS+1);
 
3514
    dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp13, CONST_BITS+PASS1_BITS+1);
 
3515
 
 
3516
    dataptr++;                  /* advance pointer to next column */
 
3517
    wsptr++;                    /* advance pointer to next column */
 
3518
  }
 
3519
}
 
3520
 
 
3521
 
 
3522
/*
 
3523
 * Perform the forward DCT on a 7x14 sample block.
 
3524
 *
 
3525
 * 7-point FDCT in pass 1 (rows), 14-point in pass 2 (columns).
 
3526
 */
 
3527
 
 
3528
GLOBAL(void)
 
3529
jpeg_fdct_7x14 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
3530
{
 
3531
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
 
3532
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16;
 
3533
  INT32 z1, z2, z3;
 
3534
  DCTELEM workspace[8*6];
 
3535
  DCTELEM *dataptr;
 
3536
  DCTELEM *wsptr;
 
3537
  JSAMPROW elemptr;
 
3538
  int ctr;
 
3539
  SHIFT_TEMPS
 
3540
 
 
3541
  /* Pre-zero output coefficient block. */
 
3542
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
3543
 
 
3544
  /* Pass 1: process rows. */
 
3545
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
3546
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
3547
  /* 7-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/14). */
 
3548
 
 
3549
  dataptr = data;
 
3550
  ctr = 0;
 
3551
  for (;;) {
 
3552
    elemptr = sample_data[ctr] + start_col;
 
3553
 
 
3554
    /* Even part */
 
3555
 
 
3556
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[6]);
 
3557
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[5]);
 
3558
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[4]);
 
3559
    tmp3 = GETJSAMPLE(elemptr[3]);
 
3560
 
 
3561
    tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[6]);
 
3562
    tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[5]);
 
3563
    tmp12 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[4]);
 
3564
 
 
3565
    z1 = tmp0 + tmp2;
 
3566
    /* Apply unsigned->signed conversion */
 
3567
    dataptr[0] = (DCTELEM)
 
3568
      ((z1 + tmp1 + tmp3 - 7 * CENTERJSAMPLE) << PASS1_BITS);
 
3569
    tmp3 += tmp3;
 
3570
    z1 -= tmp3;
 
3571
    z1 -= tmp3;
 
3572
    z1 = MULTIPLY(z1, FIX(0.353553391));                /* (c2+c6-c4)/2 */
 
3573
    z2 = MULTIPLY(tmp0 - tmp2, FIX(0.920609002));       /* (c2+c4-c6)/2 */
 
3574
    z3 = MULTIPLY(tmp1 - tmp2, FIX(0.314692123));       /* c6 */
 
3575
    dataptr[2] = (DCTELEM) DESCALE(z1 + z2 + z3, CONST_BITS-PASS1_BITS);
 
3576
    z1 -= z2;
 
3577
    z2 = MULTIPLY(tmp0 - tmp1, FIX(0.881747734));       /* c4 */
 
3578
    dataptr[4] = (DCTELEM)
 
3579
      DESCALE(z2 + z3 - MULTIPLY(tmp1 - tmp3, FIX(0.707106781)), /* c2+c6-c4 */
 
3580
              CONST_BITS-PASS1_BITS);
 
3581
    dataptr[6] = (DCTELEM) DESCALE(z1 + z2, CONST_BITS-PASS1_BITS);
 
3582
 
 
3583
    /* Odd part */
 
3584
 
 
3585
    tmp1 = MULTIPLY(tmp10 + tmp11, FIX(0.935414347));   /* (c3+c1-c5)/2 */
 
3586
    tmp2 = MULTIPLY(tmp10 - tmp11, FIX(0.170262339));   /* (c3+c5-c1)/2 */
 
3587
    tmp0 = tmp1 - tmp2;
 
3588
    tmp1 += tmp2;
 
3589
    tmp2 = MULTIPLY(tmp11 + tmp12, - FIX(1.378756276)); /* -c1 */
 
3590
    tmp1 += tmp2;
 
3591
    tmp3 = MULTIPLY(tmp10 + tmp12, FIX(0.613604268));   /* c5 */
 
3592
    tmp0 += tmp3;
 
3593
    tmp2 += tmp3 + MULTIPLY(tmp12, FIX(1.870828693));   /* c3+c1-c5 */
 
3594
 
 
3595
    dataptr[1] = (DCTELEM) DESCALE(tmp0, CONST_BITS-PASS1_BITS);
 
3596
    dataptr[3] = (DCTELEM) DESCALE(tmp1, CONST_BITS-PASS1_BITS);
 
3597
    dataptr[5] = (DCTELEM) DESCALE(tmp2, CONST_BITS-PASS1_BITS);
 
3598
 
 
3599
    ctr++;
 
3600
 
 
3601
    if (ctr != DCTSIZE) {
 
3602
      if (ctr == 14)
 
3603
        break;                  /* Done. */
 
3604
      dataptr += DCTSIZE;       /* advance pointer to next row */
 
3605
    } else
 
3606
      dataptr = workspace;      /* switch pointer to extended workspace */
 
3607
  }
 
3608
 
 
3609
  /* Pass 2: process columns.
 
3610
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
3611
   * by an overall factor of 8.
 
3612
   * We must also scale the output by (8/7)*(8/14) = 32/49, which we
 
3613
   * fold into the constant multipliers:
 
3614
   * 14-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/28) * 32/49.
 
3615
   */
 
3616
 
 
3617
  dataptr = data;
 
3618
  wsptr = workspace;
 
3619
  for (ctr = 0; ctr < 7; ctr++) {
 
3620
    /* Even part */
 
3621
 
 
3622
    tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*5];
 
3623
    tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*4];
 
3624
    tmp2 = dataptr[DCTSIZE*2] + wsptr[DCTSIZE*3];
 
3625
    tmp13 = dataptr[DCTSIZE*3] + wsptr[DCTSIZE*2];
 
3626
    tmp4 = dataptr[DCTSIZE*4] + wsptr[DCTSIZE*1];
 
3627
    tmp5 = dataptr[DCTSIZE*5] + wsptr[DCTSIZE*0];
 
3628
    tmp6 = dataptr[DCTSIZE*6] + dataptr[DCTSIZE*7];
 
3629
 
 
3630
    tmp10 = tmp0 + tmp6;
 
3631
    tmp14 = tmp0 - tmp6;
 
3632
    tmp11 = tmp1 + tmp5;
 
3633
    tmp15 = tmp1 - tmp5;
 
3634
    tmp12 = tmp2 + tmp4;
 
3635
    tmp16 = tmp2 - tmp4;
 
3636
 
 
3637
    tmp0 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*5];
 
3638
    tmp1 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*4];
 
3639
    tmp2 = dataptr[DCTSIZE*2] - wsptr[DCTSIZE*3];
 
3640
    tmp3 = dataptr[DCTSIZE*3] - wsptr[DCTSIZE*2];
 
3641
    tmp4 = dataptr[DCTSIZE*4] - wsptr[DCTSIZE*1];
 
3642
    tmp5 = dataptr[DCTSIZE*5] - wsptr[DCTSIZE*0];
 
3643
    tmp6 = dataptr[DCTSIZE*6] - dataptr[DCTSIZE*7];
 
3644
 
 
3645
    dataptr[DCTSIZE*0] = (DCTELEM)
 
3646
      DESCALE(MULTIPLY(tmp10 + tmp11 + tmp12 + tmp13,
 
3647
                       FIX(0.653061224)),                 /* 32/49 */
 
3648
              CONST_BITS+PASS1_BITS);
 
3649
    tmp13 += tmp13;
 
3650
    dataptr[DCTSIZE*4] = (DCTELEM)
 
3651
      DESCALE(MULTIPLY(tmp10 - tmp13, FIX(0.832106052)) + /* c4 */
 
3652
              MULTIPLY(tmp11 - tmp13, FIX(0.205513223)) - /* c12 */
 
3653
              MULTIPLY(tmp12 - tmp13, FIX(0.575835255)),  /* c8 */
 
3654
              CONST_BITS+PASS1_BITS);
 
3655
 
 
3656
    tmp10 = MULTIPLY(tmp14 + tmp15, FIX(0.722074570));    /* c6 */
 
3657
 
 
3658
    dataptr[DCTSIZE*2] = (DCTELEM)
 
3659
      DESCALE(tmp10 + MULTIPLY(tmp14, FIX(0.178337691))   /* c2-c6 */
 
3660
              + MULTIPLY(tmp16, FIX(0.400721155)),        /* c10 */
 
3661
              CONST_BITS+PASS1_BITS);
 
3662
    dataptr[DCTSIZE*6] = (DCTELEM)
 
3663
      DESCALE(tmp10 - MULTIPLY(tmp15, FIX(1.122795725))   /* c6+c10 */
 
3664
              - MULTIPLY(tmp16, FIX(0.900412262)),        /* c2 */
 
3665
              CONST_BITS+PASS1_BITS);
 
3666
 
 
3667
    /* Odd part */
 
3668
 
 
3669
    tmp10 = tmp1 + tmp2;
 
3670
    tmp11 = tmp5 - tmp4;
 
3671
    dataptr[DCTSIZE*7] = (DCTELEM)
 
3672
      DESCALE(MULTIPLY(tmp0 - tmp10 + tmp3 - tmp11 - tmp6,
 
3673
                       FIX(0.653061224)),                 /* 32/49 */
 
3674
              CONST_BITS+PASS1_BITS);
 
3675
    tmp3  = MULTIPLY(tmp3 , FIX(0.653061224));            /* 32/49 */
 
3676
    tmp10 = MULTIPLY(tmp10, - FIX(0.103406812));          /* -c13 */
 
3677
    tmp11 = MULTIPLY(tmp11, FIX(0.917760839));            /* c1 */
 
3678
    tmp10 += tmp11 - tmp3;
 
3679
    tmp11 = MULTIPLY(tmp0 + tmp2, FIX(0.782007410)) +     /* c5 */
 
3680
            MULTIPLY(tmp4 + tmp6, FIX(0.491367823));      /* c9 */
 
3681
    dataptr[DCTSIZE*5] = (DCTELEM)
 
3682
      DESCALE(tmp10 + tmp11 - MULTIPLY(tmp2, FIX(1.550341076)) /* c3+c5-c13 */
 
3683
              + MULTIPLY(tmp4, FIX(0.731428202)),         /* c1+c11-c9 */
 
3684
              CONST_BITS+PASS1_BITS);
 
3685
    tmp12 = MULTIPLY(tmp0 + tmp1, FIX(0.871740478)) +     /* c3 */
 
3686
            MULTIPLY(tmp5 - tmp6, FIX(0.305035186));      /* c11 */
 
3687
    dataptr[DCTSIZE*3] = (DCTELEM)
 
3688
      DESCALE(tmp10 + tmp12 - MULTIPLY(tmp1, FIX(0.276965844)) /* c3-c9-c13 */
 
3689
              - MULTIPLY(tmp5, FIX(2.004803435)),         /* c1+c5+c11 */
 
3690
              CONST_BITS+PASS1_BITS);
 
3691
    dataptr[DCTSIZE*1] = (DCTELEM)
 
3692
      DESCALE(tmp11 + tmp12 + tmp3
 
3693
              - MULTIPLY(tmp0, FIX(0.735987049))          /* c3+c5-c1 */
 
3694
              - MULTIPLY(tmp6, FIX(0.082925825)),         /* c9-c11-c13 */
 
3695
              CONST_BITS+PASS1_BITS);
 
3696
 
 
3697
    dataptr++;                  /* advance pointer to next column */
 
3698
    wsptr++;                    /* advance pointer to next column */
 
3699
  }
 
3700
}
 
3701
 
 
3702
 
 
3703
/*
 
3704
 * Perform the forward DCT on a 6x12 sample block.
 
3705
 *
 
3706
 * 6-point FDCT in pass 1 (rows), 12-point in pass 2 (columns).
 
3707
 */
 
3708
 
 
3709
GLOBAL(void)
 
3710
jpeg_fdct_6x12 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
3711
{
 
3712
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
 
3713
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
 
3714
  DCTELEM workspace[8*4];
 
3715
  DCTELEM *dataptr;
 
3716
  DCTELEM *wsptr;
 
3717
  JSAMPROW elemptr;
 
3718
  int ctr;
 
3719
  SHIFT_TEMPS
 
3720
 
 
3721
  /* Pre-zero output coefficient block. */
 
3722
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
3723
 
 
3724
  /* Pass 1: process rows. */
 
3725
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
3726
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
3727
  /* 6-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/12). */
 
3728
 
 
3729
  dataptr = data;
 
3730
  ctr = 0;
 
3731
  for (;;) {
 
3732
    elemptr = sample_data[ctr] + start_col;
 
3733
 
 
3734
    /* Even part */
 
3735
 
 
3736
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[5]);
 
3737
    tmp11 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[4]);
 
3738
    tmp2 = GETJSAMPLE(elemptr[2]) + GETJSAMPLE(elemptr[3]);
 
3739
 
 
3740
    tmp10 = tmp0 + tmp2;
 
3741
    tmp12 = tmp0 - tmp2;
 
3742
 
 
3743
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[5]);
 
3744
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[4]);
 
3745
    tmp2 = GETJSAMPLE(elemptr[2]) - GETJSAMPLE(elemptr[3]);
 
3746
 
 
3747
    /* Apply unsigned->signed conversion */
 
3748
    dataptr[0] = (DCTELEM)
 
3749
      ((tmp10 + tmp11 - 6 * CENTERJSAMPLE) << PASS1_BITS);
 
3750
    dataptr[2] = (DCTELEM)
 
3751
      DESCALE(MULTIPLY(tmp12, FIX(1.224744871)),                 /* c2 */
 
3752
              CONST_BITS-PASS1_BITS);
 
3753
    dataptr[4] = (DCTELEM)
 
3754
      DESCALE(MULTIPLY(tmp10 - tmp11 - tmp11, FIX(0.707106781)), /* c4 */
 
3755
              CONST_BITS-PASS1_BITS);
 
3756
 
 
3757
    /* Odd part */
 
3758
 
 
3759
    tmp10 = DESCALE(MULTIPLY(tmp0 + tmp2, FIX(0.366025404)),     /* c5 */
 
3760
                    CONST_BITS-PASS1_BITS);
 
3761
 
 
3762
    dataptr[1] = (DCTELEM) (tmp10 + ((tmp0 + tmp1) << PASS1_BITS));
 
3763
    dataptr[3] = (DCTELEM) ((tmp0 - tmp1 - tmp2) << PASS1_BITS);
 
3764
    dataptr[5] = (DCTELEM) (tmp10 + ((tmp2 - tmp1) << PASS1_BITS));
 
3765
 
 
3766
    ctr++;
 
3767
 
 
3768
    if (ctr != DCTSIZE) {
 
3769
      if (ctr == 12)
 
3770
        break;                  /* Done. */
 
3771
      dataptr += DCTSIZE;       /* advance pointer to next row */
 
3772
    } else
 
3773
      dataptr = workspace;      /* switch pointer to extended workspace */
 
3774
  }
 
3775
 
 
3776
  /* Pass 2: process columns.
 
3777
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
3778
   * by an overall factor of 8.
 
3779
   * We must also scale the output by (8/6)*(8/12) = 8/9, which we
 
3780
   * fold into the constant multipliers:
 
3781
   * 12-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/24) * 8/9.
 
3782
   */
 
3783
 
 
3784
  dataptr = data;
 
3785
  wsptr = workspace;
 
3786
  for (ctr = 0; ctr < 6; ctr++) {
 
3787
    /* Even part */
 
3788
 
 
3789
    tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*3];
 
3790
    tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*2];
 
3791
    tmp2 = dataptr[DCTSIZE*2] + wsptr[DCTSIZE*1];
 
3792
    tmp3 = dataptr[DCTSIZE*3] + wsptr[DCTSIZE*0];
 
3793
    tmp4 = dataptr[DCTSIZE*4] + dataptr[DCTSIZE*7];
 
3794
    tmp5 = dataptr[DCTSIZE*5] + dataptr[DCTSIZE*6];
 
3795
 
 
3796
    tmp10 = tmp0 + tmp5;
 
3797
    tmp13 = tmp0 - tmp5;
 
3798
    tmp11 = tmp1 + tmp4;
 
3799
    tmp14 = tmp1 - tmp4;
 
3800
    tmp12 = tmp2 + tmp3;
 
3801
    tmp15 = tmp2 - tmp3;
 
3802
 
 
3803
    tmp0 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*3];
 
3804
    tmp1 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*2];
 
3805
    tmp2 = dataptr[DCTSIZE*2] - wsptr[DCTSIZE*1];
 
3806
    tmp3 = dataptr[DCTSIZE*3] - wsptr[DCTSIZE*0];
 
3807
    tmp4 = dataptr[DCTSIZE*4] - dataptr[DCTSIZE*7];
 
3808
    tmp5 = dataptr[DCTSIZE*5] - dataptr[DCTSIZE*6];
 
3809
 
 
3810
    dataptr[DCTSIZE*0] = (DCTELEM)
 
3811
      DESCALE(MULTIPLY(tmp10 + tmp11 + tmp12, FIX(0.888888889)), /* 8/9 */
 
3812
              CONST_BITS+PASS1_BITS);
 
3813
    dataptr[DCTSIZE*6] = (DCTELEM)
 
3814
      DESCALE(MULTIPLY(tmp13 - tmp14 - tmp15, FIX(0.888888889)), /* 8/9 */
 
3815
              CONST_BITS+PASS1_BITS);
 
3816
    dataptr[DCTSIZE*4] = (DCTELEM)
 
3817
      DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.088662108)),         /* c4 */
 
3818
              CONST_BITS+PASS1_BITS);
 
3819
    dataptr[DCTSIZE*2] = (DCTELEM)
 
3820
      DESCALE(MULTIPLY(tmp14 - tmp15, FIX(0.888888889)) +        /* 8/9 */
 
3821
              MULTIPLY(tmp13 + tmp15, FIX(1.214244803)),         /* c2 */
 
3822
              CONST_BITS+PASS1_BITS);
 
3823
 
 
3824
    /* Odd part */
 
3825
 
 
3826
    tmp10 = MULTIPLY(tmp1 + tmp4, FIX(0.481063200));   /* c9 */
 
3827
    tmp14 = tmp10 + MULTIPLY(tmp1, FIX(0.680326102));  /* c3-c9 */
 
3828
    tmp15 = tmp10 - MULTIPLY(tmp4, FIX(1.642452502));  /* c3+c9 */
 
3829
    tmp12 = MULTIPLY(tmp0 + tmp2, FIX(0.997307603));   /* c5 */
 
3830
    tmp13 = MULTIPLY(tmp0 + tmp3, FIX(0.765261039));   /* c7 */
 
3831
    tmp10 = tmp12 + tmp13 + tmp14 - MULTIPLY(tmp0, FIX(0.516244403)) /* c5+c7-c1 */
 
3832
            + MULTIPLY(tmp5, FIX(0.164081699));        /* c11 */
 
3833
    tmp11 = MULTIPLY(tmp2 + tmp3, - FIX(0.164081699)); /* -c11 */
 
3834
    tmp12 += tmp11 - tmp15 - MULTIPLY(tmp2, FIX(2.079550144)) /* c1+c5-c11 */
 
3835
            + MULTIPLY(tmp5, FIX(0.765261039));        /* c7 */
 
3836
    tmp13 += tmp11 - tmp14 + MULTIPLY(tmp3, FIX(0.645144899)) /* c1+c11-c7 */
 
3837
            - MULTIPLY(tmp5, FIX(0.997307603));        /* c5 */
 
3838
    tmp11 = tmp15 + MULTIPLY(tmp0 - tmp3, FIX(1.161389302)) /* c3 */
 
3839
            - MULTIPLY(tmp2 + tmp5, FIX(0.481063200)); /* c9 */
 
3840
 
 
3841
    dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp10, CONST_BITS+PASS1_BITS);
 
3842
    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp11, CONST_BITS+PASS1_BITS);
 
3843
    dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp12, CONST_BITS+PASS1_BITS);
 
3844
    dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp13, CONST_BITS+PASS1_BITS);
 
3845
 
 
3846
    dataptr++;                  /* advance pointer to next column */
 
3847
    wsptr++;                    /* advance pointer to next column */
 
3848
  }
 
3849
}
 
3850
 
 
3851
 
 
3852
/*
 
3853
 * Perform the forward DCT on a 5x10 sample block.
 
3854
 *
 
3855
 * 5-point FDCT in pass 1 (rows), 10-point in pass 2 (columns).
 
3856
 */
 
3857
 
 
3858
GLOBAL(void)
 
3859
jpeg_fdct_5x10 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
3860
{
 
3861
  INT32 tmp0, tmp1, tmp2, tmp3, tmp4;
 
3862
  INT32 tmp10, tmp11, tmp12, tmp13, tmp14;
 
3863
  DCTELEM workspace[8*2];
 
3864
  DCTELEM *dataptr;
 
3865
  DCTELEM *wsptr;
 
3866
  JSAMPROW elemptr;
 
3867
  int ctr;
 
3868
  SHIFT_TEMPS
 
3869
 
 
3870
  /* Pre-zero output coefficient block. */
 
3871
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
3872
 
 
3873
  /* Pass 1: process rows. */
 
3874
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
3875
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
3876
  /* 5-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/10). */
 
3877
 
 
3878
  dataptr = data;
 
3879
  ctr = 0;
 
3880
  for (;;) {
 
3881
    elemptr = sample_data[ctr] + start_col;
 
3882
 
 
3883
    /* Even part */
 
3884
 
 
3885
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[4]);
 
3886
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[3]);
 
3887
    tmp2 = GETJSAMPLE(elemptr[2]);
 
3888
 
 
3889
    tmp10 = tmp0 + tmp1;
 
3890
    tmp11 = tmp0 - tmp1;
 
3891
 
 
3892
    tmp0 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[4]);
 
3893
    tmp1 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[3]);
 
3894
 
 
3895
    /* Apply unsigned->signed conversion */
 
3896
    dataptr[0] = (DCTELEM)
 
3897
      ((tmp10 + tmp2 - 5 * CENTERJSAMPLE) << PASS1_BITS);
 
3898
    tmp11 = MULTIPLY(tmp11, FIX(0.790569415));          /* (c2+c4)/2 */
 
3899
    tmp10 -= tmp2 << 2;
 
3900
    tmp10 = MULTIPLY(tmp10, FIX(0.353553391));          /* (c2-c4)/2 */
 
3901
    dataptr[2] = (DCTELEM) DESCALE(tmp11 + tmp10, CONST_BITS-PASS1_BITS);
 
3902
    dataptr[4] = (DCTELEM) DESCALE(tmp11 - tmp10, CONST_BITS-PASS1_BITS);
 
3903
 
 
3904
    /* Odd part */
 
3905
 
 
3906
    tmp10 = MULTIPLY(tmp0 + tmp1, FIX(0.831253876));    /* c3 */
 
3907
 
 
3908
    dataptr[1] = (DCTELEM)
 
3909
      DESCALE(tmp10 + MULTIPLY(tmp0, FIX(0.513743148)), /* c1-c3 */
 
3910
              CONST_BITS-PASS1_BITS);
 
3911
    dataptr[3] = (DCTELEM)
 
3912
      DESCALE(tmp10 - MULTIPLY(tmp1, FIX(2.176250899)), /* c1+c3 */
 
3913
              CONST_BITS-PASS1_BITS);
 
3914
 
 
3915
    ctr++;
 
3916
 
 
3917
    if (ctr != DCTSIZE) {
 
3918
      if (ctr == 10)
 
3919
        break;                  /* Done. */
 
3920
      dataptr += DCTSIZE;       /* advance pointer to next row */
 
3921
    } else
 
3922
      dataptr = workspace;      /* switch pointer to extended workspace */
 
3923
  }
 
3924
 
 
3925
  /* Pass 2: process columns.
 
3926
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
3927
   * by an overall factor of 8.
 
3928
   * We must also scale the output by (8/5)*(8/10) = 32/25, which we
 
3929
   * fold into the constant multipliers:
 
3930
   * 10-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/20) * 32/25.
 
3931
   */
 
3932
 
 
3933
  dataptr = data;
 
3934
  wsptr = workspace;
 
3935
  for (ctr = 0; ctr < 5; ctr++) {
 
3936
    /* Even part */
 
3937
 
 
3938
    tmp0 = dataptr[DCTSIZE*0] + wsptr[DCTSIZE*1];
 
3939
    tmp1 = dataptr[DCTSIZE*1] + wsptr[DCTSIZE*0];
 
3940
    tmp12 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*7];
 
3941
    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*6];
 
3942
    tmp4 = dataptr[DCTSIZE*4] + dataptr[DCTSIZE*5];
 
3943
 
 
3944
    tmp10 = tmp0 + tmp4;
 
3945
    tmp13 = tmp0 - tmp4;
 
3946
    tmp11 = tmp1 + tmp3;
 
3947
    tmp14 = tmp1 - tmp3;
 
3948
 
 
3949
    tmp0 = dataptr[DCTSIZE*0] - wsptr[DCTSIZE*1];
 
3950
    tmp1 = dataptr[DCTSIZE*1] - wsptr[DCTSIZE*0];
 
3951
    tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*7];
 
3952
    tmp3 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*6];
 
3953
    tmp4 = dataptr[DCTSIZE*4] - dataptr[DCTSIZE*5];
 
3954
 
 
3955
    dataptr[DCTSIZE*0] = (DCTELEM)
 
3956
      DESCALE(MULTIPLY(tmp10 + tmp11 + tmp12, FIX(1.28)), /* 32/25 */
 
3957
              CONST_BITS+PASS1_BITS);
 
3958
    tmp12 += tmp12;
 
3959
    dataptr[DCTSIZE*4] = (DCTELEM)
 
3960
      DESCALE(MULTIPLY(tmp10 - tmp12, FIX(1.464477191)) - /* c4 */
 
3961
              MULTIPLY(tmp11 - tmp12, FIX(0.559380511)),  /* c8 */
 
3962
              CONST_BITS+PASS1_BITS);
 
3963
    tmp10 = MULTIPLY(tmp13 + tmp14, FIX(1.064004961));    /* c6 */
 
3964
    dataptr[DCTSIZE*2] = (DCTELEM)
 
3965
      DESCALE(tmp10 + MULTIPLY(tmp13, FIX(0.657591230)),  /* c2-c6 */
 
3966
              CONST_BITS+PASS1_BITS);
 
3967
    dataptr[DCTSIZE*6] = (DCTELEM)
 
3968
      DESCALE(tmp10 - MULTIPLY(tmp14, FIX(2.785601151)),  /* c2+c6 */
 
3969
              CONST_BITS+PASS1_BITS);
 
3970
 
 
3971
    /* Odd part */
 
3972
 
 
3973
    tmp10 = tmp0 + tmp4;
 
3974
    tmp11 = tmp1 - tmp3;
 
3975
    dataptr[DCTSIZE*5] = (DCTELEM)
 
3976
      DESCALE(MULTIPLY(tmp10 - tmp11 - tmp2, FIX(1.28)),  /* 32/25 */
 
3977
              CONST_BITS+PASS1_BITS);
 
3978
    tmp2 = MULTIPLY(tmp2, FIX(1.28));                     /* 32/25 */
 
3979
    dataptr[DCTSIZE*1] = (DCTELEM)
 
3980
      DESCALE(MULTIPLY(tmp0, FIX(1.787906876)) +          /* c1 */
 
3981
              MULTIPLY(tmp1, FIX(1.612894094)) + tmp2 +   /* c3 */
 
3982
              MULTIPLY(tmp3, FIX(0.821810588)) +          /* c7 */
 
3983
              MULTIPLY(tmp4, FIX(0.283176630)),           /* c9 */
 
3984
              CONST_BITS+PASS1_BITS);
 
3985
    tmp12 = MULTIPLY(tmp0 - tmp4, FIX(1.217352341)) -     /* (c3+c7)/2 */
 
3986
            MULTIPLY(tmp1 + tmp3, FIX(0.752365123));      /* (c1-c9)/2 */
 
3987
    tmp13 = MULTIPLY(tmp10 + tmp11, FIX(0.395541753)) +   /* (c3-c7)/2 */
 
3988
            MULTIPLY(tmp11, FIX(0.64)) - tmp2;            /* 16/25 */
 
3989
    dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp12 + tmp13, CONST_BITS+PASS1_BITS);
 
3990
    dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp12 - tmp13, CONST_BITS+PASS1_BITS);
 
3991
 
 
3992
    dataptr++;                  /* advance pointer to next column */
 
3993
    wsptr++;                    /* advance pointer to next column */
 
3994
  }
 
3995
}
 
3996
 
 
3997
 
 
3998
/*
 
3999
 * Perform the forward DCT on a 4x8 sample block.
 
4000
 *
 
4001
 * 4-point FDCT in pass 1 (rows), 8-point in pass 2 (columns).
 
4002
 */
 
4003
 
 
4004
GLOBAL(void)
 
4005
jpeg_fdct_4x8 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
4006
{
 
4007
  INT32 tmp0, tmp1, tmp2, tmp3;
 
4008
  INT32 tmp10, tmp11, tmp12, tmp13;
 
4009
  INT32 z1;
 
4010
  DCTELEM *dataptr;
 
4011
  JSAMPROW elemptr;
 
4012
  int ctr;
 
4013
  SHIFT_TEMPS
 
4014
 
 
4015
  /* Pre-zero output coefficient block. */
 
4016
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
4017
 
 
4018
  /* Pass 1: process rows. */
 
4019
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
4020
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
4021
  /* We must also scale the output by 8/4 = 2, which we add here. */
 
4022
  /* 4-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/16). */
 
4023
 
 
4024
  dataptr = data;
 
4025
  for (ctr = 0; ctr < DCTSIZE; ctr++) {
 
4026
    elemptr = sample_data[ctr] + start_col;
 
4027
 
 
4028
    /* Even part */
 
4029
 
 
4030
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[3]);
 
4031
    tmp1 = GETJSAMPLE(elemptr[1]) + GETJSAMPLE(elemptr[2]);
 
4032
 
 
4033
    tmp10 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[3]);
 
4034
    tmp11 = GETJSAMPLE(elemptr[1]) - GETJSAMPLE(elemptr[2]);
 
4035
 
 
4036
    /* Apply unsigned->signed conversion */
 
4037
    dataptr[0] = (DCTELEM)
 
4038
      ((tmp0 + tmp1 - 4 * CENTERJSAMPLE) << (PASS1_BITS+1));
 
4039
    dataptr[2] = (DCTELEM) ((tmp0 - tmp1) << (PASS1_BITS+1));
 
4040
 
 
4041
    /* Odd part */
 
4042
 
 
4043
    tmp0 = MULTIPLY(tmp10 + tmp11, FIX_0_541196100);       /* c6 */
 
4044
    /* Add fudge factor here for final descale. */
 
4045
    tmp0 += ONE << (CONST_BITS-PASS1_BITS-2);
 
4046
 
 
4047
    dataptr[1] = (DCTELEM)
 
4048
      RIGHT_SHIFT(tmp0 + MULTIPLY(tmp10, FIX_0_765366865), /* c2-c6 */
 
4049
                  CONST_BITS-PASS1_BITS-1);
 
4050
    dataptr[3] = (DCTELEM)
 
4051
      RIGHT_SHIFT(tmp0 - MULTIPLY(tmp11, FIX_1_847759065), /* c2+c6 */
 
4052
                  CONST_BITS-PASS1_BITS-1);
 
4053
 
 
4054
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
4055
  }
 
4056
 
 
4057
  /* Pass 2: process columns.
 
4058
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
4059
   * by an overall factor of 8.
 
4060
   */
 
4061
 
 
4062
  dataptr = data;
 
4063
  for (ctr = 0; ctr < 4; ctr++) {
 
4064
    /* Even part per LL&M figure 1 --- note that published figure is faulty;
 
4065
     * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
 
4066
     */
 
4067
 
 
4068
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
 
4069
    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
 
4070
    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
 
4071
    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
 
4072
 
 
4073
    /* Add fudge factor here for final descale. */
 
4074
    tmp10 = tmp0 + tmp3 + (ONE << (PASS1_BITS-1));
 
4075
    tmp12 = tmp0 - tmp3;
 
4076
    tmp11 = tmp1 + tmp2;
 
4077
    tmp13 = tmp1 - tmp2;
 
4078
 
 
4079
    tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
 
4080
    tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
 
4081
    tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
 
4082
    tmp3 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
 
4083
 
 
4084
    dataptr[DCTSIZE*0] = (DCTELEM) RIGHT_SHIFT(tmp10 + tmp11, PASS1_BITS);
 
4085
    dataptr[DCTSIZE*4] = (DCTELEM) RIGHT_SHIFT(tmp10 - tmp11, PASS1_BITS);
 
4086
 
 
4087
    z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
 
4088
    /* Add fudge factor here for final descale. */
 
4089
    z1 += ONE << (CONST_BITS+PASS1_BITS-1);
 
4090
    dataptr[DCTSIZE*2] = (DCTELEM)
 
4091
      RIGHT_SHIFT(z1 + MULTIPLY(tmp12, FIX_0_765366865), CONST_BITS+PASS1_BITS);
 
4092
    dataptr[DCTSIZE*6] = (DCTELEM)
 
4093
      RIGHT_SHIFT(z1 - MULTIPLY(tmp13, FIX_1_847759065), CONST_BITS+PASS1_BITS);
 
4094
 
 
4095
    /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
 
4096
     * 8-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/16).
 
4097
     * i0..i3 in the paper are tmp0..tmp3 here.
 
4098
     */
 
4099
 
 
4100
    tmp10 = tmp0 + tmp3;
 
4101
    tmp11 = tmp1 + tmp2;
 
4102
    tmp12 = tmp0 + tmp2;
 
4103
    tmp13 = tmp1 + tmp3;
 
4104
    z1 = MULTIPLY(tmp12 + tmp13, FIX_1_175875602); /*  c3 */
 
4105
    /* Add fudge factor here for final descale. */
 
4106
    z1 += ONE << (CONST_BITS+PASS1_BITS-1);
 
4107
 
 
4108
    tmp0  = MULTIPLY(tmp0,    FIX_1_501321110);    /*  c1+c3-c5-c7 */
 
4109
    tmp1  = MULTIPLY(tmp1,    FIX_3_072711026);    /*  c1+c3+c5-c7 */
 
4110
    tmp2  = MULTIPLY(tmp2,    FIX_2_053119869);    /*  c1+c3-c5+c7 */
 
4111
    tmp3  = MULTIPLY(tmp3,    FIX_0_298631336);    /* -c1+c3+c5-c7 */
 
4112
    tmp10 = MULTIPLY(tmp10, - FIX_0_899976223);    /*  c7-c3 */
 
4113
    tmp11 = MULTIPLY(tmp11, - FIX_2_562915447);    /* -c1-c3 */
 
4114
    tmp12 = MULTIPLY(tmp12, - FIX_0_390180644);    /*  c5-c3 */
 
4115
    tmp13 = MULTIPLY(tmp13, - FIX_1_961570560);    /* -c3-c5 */
 
4116
 
 
4117
    tmp12 += z1;
 
4118
    tmp13 += z1;
 
4119
 
 
4120
    dataptr[DCTSIZE*1] = (DCTELEM)
 
4121
      RIGHT_SHIFT(tmp0 + tmp10 + tmp12, CONST_BITS+PASS1_BITS);
 
4122
    dataptr[DCTSIZE*3] = (DCTELEM)
 
4123
      RIGHT_SHIFT(tmp1 + tmp11 + tmp13, CONST_BITS+PASS1_BITS);
 
4124
    dataptr[DCTSIZE*5] = (DCTELEM)
 
4125
      RIGHT_SHIFT(tmp2 + tmp11 + tmp12, CONST_BITS+PASS1_BITS);
 
4126
    dataptr[DCTSIZE*7] = (DCTELEM)
 
4127
      RIGHT_SHIFT(tmp3 + tmp10 + tmp13, CONST_BITS+PASS1_BITS);
 
4128
 
 
4129
    dataptr++;                  /* advance pointer to next column */
 
4130
  }
 
4131
}
 
4132
 
 
4133
 
 
4134
/*
 
4135
 * Perform the forward DCT on a 3x6 sample block.
 
4136
 *
 
4137
 * 3-point FDCT in pass 1 (rows), 6-point in pass 2 (columns).
 
4138
 */
 
4139
 
 
4140
GLOBAL(void)
 
4141
jpeg_fdct_3x6 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
4142
{
 
4143
  INT32 tmp0, tmp1, tmp2;
 
4144
  INT32 tmp10, tmp11, tmp12;
 
4145
  DCTELEM *dataptr;
 
4146
  JSAMPROW elemptr;
 
4147
  int ctr;
 
4148
  SHIFT_TEMPS
 
4149
 
 
4150
  /* Pre-zero output coefficient block. */
 
4151
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
4152
 
 
4153
  /* Pass 1: process rows. */
 
4154
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
 
4155
  /* furthermore, we scale the results by 2**PASS1_BITS. */
 
4156
  /* We scale the results further by 2 as part of output adaption */
 
4157
  /* scaling for different DCT size. */
 
4158
  /* 3-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/6). */
 
4159
 
 
4160
  dataptr = data;
 
4161
  for (ctr = 0; ctr < 6; ctr++) {
 
4162
    elemptr = sample_data[ctr] + start_col;
 
4163
 
 
4164
    /* Even part */
 
4165
 
 
4166
    tmp0 = GETJSAMPLE(elemptr[0]) + GETJSAMPLE(elemptr[2]);
 
4167
    tmp1 = GETJSAMPLE(elemptr[1]);
 
4168
 
 
4169
    tmp2 = GETJSAMPLE(elemptr[0]) - GETJSAMPLE(elemptr[2]);
 
4170
 
 
4171
    /* Apply unsigned->signed conversion */
 
4172
    dataptr[0] = (DCTELEM)
 
4173
      ((tmp0 + tmp1 - 3 * CENTERJSAMPLE) << (PASS1_BITS+1));
 
4174
    dataptr[2] = (DCTELEM)
 
4175
      DESCALE(MULTIPLY(tmp0 - tmp1 - tmp1, FIX(0.707106781)), /* c2 */
 
4176
              CONST_BITS-PASS1_BITS-1);
 
4177
 
 
4178
    /* Odd part */
 
4179
 
 
4180
    dataptr[1] = (DCTELEM)
 
4181
      DESCALE(MULTIPLY(tmp2, FIX(1.224744871)),               /* c1 */
 
4182
              CONST_BITS-PASS1_BITS-1);
 
4183
 
 
4184
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
4185
  }
 
4186
 
 
4187
  /* Pass 2: process columns.
 
4188
   * We remove the PASS1_BITS scaling, but leave the results scaled up
 
4189
   * by an overall factor of 8.
 
4190
   * We must also scale the output by (8/6)*(8/3) = 32/9, which we partially
 
4191
   * fold into the constant multipliers (other part was done in pass 1):
 
4192
   * 6-point FDCT kernel, cK represents sqrt(2) * cos(K*pi/12) * 16/9.
 
4193
   */
 
4194
 
 
4195
  dataptr = data;
 
4196
  for (ctr = 0; ctr < 3; ctr++) {
 
4197
    /* Even part */
 
4198
 
 
4199
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*5];
 
4200
    tmp11 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*4];
 
4201
    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*3];
 
4202
 
 
4203
    tmp10 = tmp0 + tmp2;
 
4204
    tmp12 = tmp0 - tmp2;
 
4205
 
 
4206
    tmp0 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*5];
 
4207
    tmp1 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*4];
 
4208
    tmp2 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*3];
 
4209
 
 
4210
    dataptr[DCTSIZE*0] = (DCTELEM)
 
4211
      DESCALE(MULTIPLY(tmp10 + tmp11, FIX(1.777777778)),         /* 16/9 */
 
4212
              CONST_BITS+PASS1_BITS);
 
4213
    dataptr[DCTSIZE*2] = (DCTELEM)
 
4214
      DESCALE(MULTIPLY(tmp12, FIX(2.177324216)),                 /* c2 */
 
4215
              CONST_BITS+PASS1_BITS);
 
4216
    dataptr[DCTSIZE*4] = (DCTELEM)
 
4217
      DESCALE(MULTIPLY(tmp10 - tmp11 - tmp11, FIX(1.257078722)), /* c4 */
 
4218
              CONST_BITS+PASS1_BITS);
 
4219
 
 
4220
    /* Odd part */
 
4221
 
 
4222
    tmp10 = MULTIPLY(tmp0 + tmp2, FIX(0.650711829));             /* c5 */
 
4223
 
 
4224
    dataptr[DCTSIZE*1] = (DCTELEM)
 
4225
      DESCALE(tmp10 + MULTIPLY(tmp0 + tmp1, FIX(1.777777778)),   /* 16/9 */
 
4226
              CONST_BITS+PASS1_BITS);
 
4227
    dataptr[DCTSIZE*3] = (DCTELEM)
 
4228
      DESCALE(MULTIPLY(tmp0 - tmp1 - tmp2, FIX(1.777777778)),    /* 16/9 */
 
4229
              CONST_BITS+PASS1_BITS);
 
4230
    dataptr[DCTSIZE*5] = (DCTELEM)
 
4231
      DESCALE(tmp10 + MULTIPLY(tmp2 - tmp1, FIX(1.777777778)),   /* 16/9 */
 
4232
              CONST_BITS+PASS1_BITS);
 
4233
 
 
4234
    dataptr++;                  /* advance pointer to next column */
 
4235
  }
 
4236
}
 
4237
 
 
4238
 
 
4239
/*
 
4240
 * Perform the forward DCT on a 2x4 sample block.
 
4241
 *
 
4242
 * 2-point FDCT in pass 1 (rows), 4-point in pass 2 (columns).
 
4243
 */
 
4244
 
 
4245
GLOBAL(void)
 
4246
jpeg_fdct_2x4 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
4247
{
 
4248
  INT32 tmp0, tmp1;
 
4249
  INT32 tmp10, tmp11;
 
4250
  DCTELEM *dataptr;
 
4251
  JSAMPROW elemptr;
 
4252
  int ctr;
 
4253
  SHIFT_TEMPS
 
4254
 
 
4255
  /* Pre-zero output coefficient block. */
 
4256
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
4257
 
 
4258
  /* Pass 1: process rows. */
 
4259
  /* Note results are scaled up by sqrt(8) compared to a true DCT. */
 
4260
  /* We must also scale the output by (8/2)*(8/4) = 2**3, which we add here. */
 
4261
 
 
4262
  dataptr = data;
 
4263
  for (ctr = 0; ctr < 4; ctr++) {
 
4264
    elemptr = sample_data[ctr] + start_col;
 
4265
 
 
4266
    /* Even part */
 
4267
 
 
4268
    tmp0 = GETJSAMPLE(elemptr[0]);
 
4269
    tmp1 = GETJSAMPLE(elemptr[1]);
 
4270
 
 
4271
    /* Apply unsigned->signed conversion */
 
4272
    dataptr[0] = (DCTELEM) ((tmp0 + tmp1 - 2 * CENTERJSAMPLE) << 3);
 
4273
 
 
4274
    /* Odd part */
 
4275
 
 
4276
    dataptr[1] = (DCTELEM) ((tmp0 - tmp1) << 3);
 
4277
 
 
4278
    dataptr += DCTSIZE;         /* advance pointer to next row */
 
4279
  }
 
4280
 
 
4281
  /* Pass 2: process columns.
 
4282
   * We leave the results scaled up by an overall factor of 8.
 
4283
   * 4-point FDCT kernel,
 
4284
   * cK represents sqrt(2) * cos(K*pi/16) [refers to 8-point FDCT].
 
4285
   */
 
4286
 
 
4287
  dataptr = data;
 
4288
  for (ctr = 0; ctr < 2; ctr++) {
 
4289
    /* Even part */
 
4290
 
 
4291
    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*3];
 
4292
    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*2];
 
4293
 
 
4294
    tmp10 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*3];
 
4295
    tmp11 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*2];
 
4296
 
 
4297
    dataptr[DCTSIZE*0] = (DCTELEM) (tmp0 + tmp1);
 
4298
    dataptr[DCTSIZE*2] = (DCTELEM) (tmp0 - tmp1);
 
4299
 
 
4300
    /* Odd part */
 
4301
 
 
4302
    tmp0 = MULTIPLY(tmp10 + tmp11, FIX_0_541196100);       /* c6 */
 
4303
    /* Add fudge factor here for final descale. */
 
4304
    tmp0 += ONE << (CONST_BITS-1);
 
4305
 
 
4306
    dataptr[DCTSIZE*1] = (DCTELEM)
 
4307
      RIGHT_SHIFT(tmp0 + MULTIPLY(tmp10, FIX_0_765366865), /* c2-c6 */
 
4308
                  CONST_BITS);
 
4309
    dataptr[DCTSIZE*3] = (DCTELEM)
 
4310
      RIGHT_SHIFT(tmp0 - MULTIPLY(tmp11, FIX_1_847759065), /* c2+c6 */
 
4311
                  CONST_BITS);
 
4312
 
 
4313
    dataptr++;                  /* advance pointer to next column */
 
4314
  }
 
4315
}
 
4316
 
 
4317
 
 
4318
/*
 
4319
 * Perform the forward DCT on a 1x2 sample block.
 
4320
 *
 
4321
 * 1-point FDCT in pass 1 (rows), 2-point in pass 2 (columns).
 
4322
 */
 
4323
 
 
4324
GLOBAL(void)
 
4325
jpeg_fdct_1x2 (DCTELEM * data, JSAMPARRAY sample_data, JDIMENSION start_col)
 
4326
{
 
4327
  INT32 tmp0, tmp1;
 
4328
 
 
4329
  /* Pre-zero output coefficient block. */
 
4330
  MEMZERO(data, SIZEOF(DCTELEM) * DCTSIZE2);
 
4331
 
 
4332
  tmp0 = GETJSAMPLE(sample_data[0][start_col]);
 
4333
  tmp1 = GETJSAMPLE(sample_data[1][start_col]);
 
4334
 
 
4335
  /* We leave the results scaled up by an overall factor of 8.
 
4336
   * We must also scale the output by (8/1)*(8/2) = 2**5.
 
4337
   */
 
4338
 
 
4339
  /* Even part */
 
4340
  /* Apply unsigned->signed conversion */
 
4341
  data[DCTSIZE*0] = (DCTELEM) ((tmp0 + tmp1 - 2 * CENTERJSAMPLE) << 5);
 
4342
 
 
4343
  /* Odd part */
 
4344
  data[DCTSIZE*1] = (DCTELEM) ((tmp0 - tmp1) << 5);
 
4345
}
 
4346
 
 
4347
#endif /* DCT_SCALING_SUPPORTED */
 
4348
#endif /* DCT_ISLOW_SUPPORTED */