Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Copyright 1999-2101 Alibaba Group.
3
    *
4
    * Licensed under the Apache License, Version 2.0 (the "License");
5
    * you may not use this file except in compliance with the License.
6
    * You may obtain a copy of the License at
7
    *
8
    *      http://www.apache.org/licenses/LICENSE-2.0
9
    *
10
   * Unless required by applicable law or agreed to in writing, software
11
   * distributed under the License is distributed on an "AS IS" BASIS,
12
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
   * See the License for the specific language governing permissions and
14
   * limitations under the License.
15
   */
16
  package com.alibaba.simpleimage.codec.convertor;

Author(s):
wendell
20
  
21
  public class SlowInverseDCTCalculator extends InverseDCTCalculator {
22
  
23
      public static final int PASS1_BITS      = 2;
24
      public static final int CONST_BITS      = 13;
25
      public static final int ONE             = 1;
26
      public static final int CONST_SCALE     =  << ;
27
  
28
      public static final int FIX_0_541196100 = 4433;
29
      public static final int FIX_2_562915447 = 20995;
30
      public static final int FIX_0_899976223 = 7373;
31
      public static final int FIX_0_765366865 = 6270;
32
      public static final int FIX_1_175875602 = 9633;
33
      public static final int FIX_0_298631336 = 2446;
34
      public static final int FIX_0_390180644 = 3196;
35
      public static final int FIX_1_501321110 = 12299;
36
      public static final int FIX_1_847759065 = 15137;
37
      public static final int FIX_1_961570560 = 16069;
38
      public static final int FIX_2_053119869 = 16819;
39
      public static final int FIX_3_072711026 = 25172;
40
  
41
      public static final int FIX_0_275899379 = FIX(0.275899379);
42
      public static final int FIX_1_306562965 = FIX(1.306562965);
43
      public static final int FIX_1_387039845 = FIX(1.387039845);
44
      public static final int FIX_0_601344887 = FIX(0.601344887);
45
      public static final int FIX_0_509795579 = FIX(0.509795579);
46
      public static final int FIX_1_353318001 = FIX(1.353318001);
47
      public static final int FIX_1_247225013 = FIX(1.247225013);
48
      public static final int FIX_1_093201867 = FIX(1.093201867);
49
      public static final int FIX_0_897167586 = FIX(0.897167586);
50
      public static final int FIX_0_666655658 = FIX(0.666655658);
51
      public static final int FIX_0_410524528 = FIX(0.410524528);
52
      public static final int FIX_2_286341144 = FIX(2.286341144);
53
      public static final int FIX_1_835730603 = FIX(1.835730603);
54
      public static final int FIX_0_138617169 = FIX(0.138617169);
55
      public static final int FIX_0_071888074 = FIX(0.071888074);
56
      public static final int FIX_1_125726048 = FIX(1.125726048);
57
      public static final int FIX_1_407403738 = FIX(1.407403738);
58
      public static final int FIX_0_766367282 = FIX(0.766367282);
59
      public static final int FIX_1_971951411 = FIX(1.971951411);
60
      public static final int FIX_1_065388962 = FIX(1.065388962);
61
      public static final int FIX_3_141271809 = FIX(3.141271809);
62
  
63
      /*
64
       * (non-Javadoc)
65
       * @see com.alibaba.simpleimage.codec.jpeg.InverseDCTCalculator#calculate(int[], int, int)
66
       */
67
      @Override
68
      public Object calculate(int[] input, int inPos, int[] quant, int[] output, int outPos, int width, int height) {
69
          if (width == 16 && height == 16) {
70
              return calculate16x16(input, inPos, quant, output, outPos);
71
          } else if (width == 16 && height == 8) {
72
              return calculate16x8(input, inPos, quant, output, outPos);
73
          } else if (width == 8 && height == 16) {
74
              return calculate8x16(input, inPos, quant, output, outPos);
75
          } else if (width == 8 && height == 8) {
76
              return calculate8x8(input, inPos, quant, output, outPos);
77
          } else {
78
              throw new IllegalArgumentException("Unsupported output size!");
79
          }
80
      }
81
  
82
      public static int FIX(double x) {
83
          return (int) ((x) *  + 0.5);
84
      }
85
  
86
      private int DESCALE(int x, int n) {
87
          return (x + ( << (n - 1))) >> n;
88
      }
89
  
90
      protected Object calculate16x16(int[] inptr, int inPos, int[] quantptr, int[] output, int outPos) {
91
          int tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
92
          int tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
93
          int z1, z2, z3, z4;
94
  
95
          int[] outptr = (output != null ? output : new int[ * 4]);
96
  
97
          short[] rangeLimitMap = ;
98
          int rangeLimitOffset =  + ;
99
  
100
         int ctr;
101
         int workspace[] = new int[8 * 16]; /* buffers data between passes */
102
 
103
         int inputOffset = inPos, quantOffset = 0, wsOffset = 0, outputOffset1 = 0, outputOffset2 = 0;
104
 
105
         /* Pass 1: process columns from input, store into work array. */
106
         int[] wsptr = workspace;
107
 
108
         for (ctr = 0; ctr < 8; ctr++, inputOffset++, quantOffset++, wsOffset++) {
109
             /* Even part */
110
 
111
             tmp0 = inptr[inputOffset] * quantptr[quantOffset];
112
             tmp0 <<= ;
113
 
114
             /* Add fudge factor here for final descale. */
115
             tmp0 += (1 << ( -  - 1));
116
 
117
             z1 = inptr[inputOffset +  * 4] * quantptr[quantOffset +  * 4];
118
             tmp1 = (z1 * ); /* c4[16] = c2[8] */
119
             tmp2 = (z1 * ); /* c12[16] = c6[8] */
120
 
121
             tmp10 = tmp0 + tmp1;
122
             tmp11 = tmp0 - tmp1;
123
             tmp12 = tmp0 + tmp2;
124
             tmp13 = tmp0 - tmp2;
125
 
126
             z1 = inptr[inputOffset +  * 2] * quantptr[quantOffset +  * 2];
127
             z2 = inptr[inputOffset +  * 6] * quantptr[quantOffset +  * 6];
128
             z3 = z1 - z2;
129
             z4 = (z3 * ); /* c14[16] = c7[8] */
130
             z3 = (z3 * ); /* c2[16] = c1[8] */
131
 
132
             tmp0 = z3 + (z2 * );
133
             tmp1 = z4 + (z1 * );
134
             tmp2 = z3 - (z1 * );
135
             tmp3 = z4 - (z2 * );
136
 
137
             tmp20 = tmp10 + tmp0;
138
             tmp27 = tmp10 - tmp0;
139
             tmp21 = tmp12 + tmp1;
140
             tmp26 = tmp12 - tmp1;
141
             tmp22 = tmp13 + tmp2;
142
             tmp25 = tmp13 - tmp2;
143
             tmp23 = tmp11 + tmp3;
144
             tmp24 = tmp11 - tmp3;
145
 
146
             /* Odd part */
147
 
148
             z1 = inptr[inputOffset +  * 1] * quantptr[quantOffset +  * 1];
149
             z2 = inptr[inputOffset +  * 3] * quantptr[quantOffset +  * 3];
150
             z3 = inptr[inputOffset +  * 5] * quantptr[quantOffset +  * 5];
151
             z4 = inptr[inputOffset +  * 7] * quantptr[quantOffset +  * 7];
152
 
153
             tmp11 = z1 + z3;
154
 
155
             tmp1 = ((z1 + z2) * ); /* c3 */
156
             tmp2 = (tmp11 * ); /* c5 */
157
             tmp3 = ((z1 + z4) * ); /* c7 */
158
             tmp10 = ((z1 - z4) * ); /* c9 */
159
             tmp11 = (tmp11 * ); /* c11 */
160
             tmp12 = ((z1 - z2) * ); /* c13 */
161
             tmp0 = tmp1 + tmp2 + tmp3 - (z1 * );
162
             tmp13 = tmp10 + tmp11 + tmp12 - (z1 * );
163
             z1 = ((z2 + z3) * ); /* c15 */
164
             tmp1 += z1 + (z2 * ); /* c9+c11-c3-c15 */
165
             tmp2 += z1 - (z3 * ); /* c5+c7+c15-c3 */
166
             z1 = ((z3 - z2) * ); /* c1 */
167
             tmp11 += z1 - (z3 * ); /* c1+c11-c9-c13 */
168
             tmp12 += z1 + (z2 * ); /* c1+c5+c13-c7 */
169
             z2 += z4;
170
             z1 = (z2 * (-)); /* -c11 */
171
             tmp1 += z1;
172
             tmp3 += z1 + (z4 * ); /* c3+c11+c15-c7 */
173
             z2 = (z2 * (-)); /* -c5 */
174
             tmp10 += z2 + (z4 * ); /* c1+c5+c9-c13 */
175
             tmp12 += z2;
176
             z2 = ((z3 + z4) * (-)); /* -c3 */
177
             tmp2 += z2;
178
             tmp3 += z2;
179
             z2 = ((z4 - z3) * ); /* c13 */
180
             tmp10 += z2;
181
             tmp11 += z2;
182
 
183
             /* Final output stage */
184
             wsptr[wsOffset + 8 * 0] = (tmp20 + tmp0) >> ( - );
185
             wsptr[wsOffset + 8 * 15] = (tmp20 - tmp0) >> ( - );
186
             wsptr[wsOffset + 8 * 1] = (tmp21 + tmp1) >> ( - );
187
             wsptr[wsOffset + 8 * 14] = (tmp21 - tmp1) >> ( - );
188
             wsptr[wsOffset + 8 * 2] = (tmp22 + tmp2) >> ( - );
189
             wsptr[wsOffset + 8 * 13] = (tmp22 - tmp2) >> ( - );
190
             wsptr[wsOffset + 8 * 3] = (tmp23 + tmp3) >> ( - );
191
             wsptr[wsOffset + 8 * 12] = (tmp23 - tmp3) >> ( - );
192
             wsptr[wsOffset + 8 * 4] = (tmp24 + tmp10) >> ( - );
193
             wsptr[wsOffset + 8 * 11] = (tmp24 - tmp10) >> ( - );
194
             wsptr[wsOffset + 8 * 5] = (tmp25 + tmp11) >> ( - );
195
             wsptr[wsOffset + 8 * 10] = (tmp25 - tmp11) >> ( - );
196
             wsptr[wsOffset + 8 * 6] = (tmp26 + tmp12) >> ( - );
197
             wsptr[wsOffset + 8 * 9] = (tmp26 - tmp12) >> ( - );
198
             wsptr[wsOffset + 8 * 7] = (tmp27 + tmp13) >> ( - );
199
             wsptr[wsOffset + 8 * 8] = (tmp27 - tmp13) >> ( - );
200
         }
201
 
202
         /* Pass 2: process 16 rows from work array, store into output array. */
203
 
204
         wsOffset = 0;
205
         for (ctr = 0; ctr < 16; ctr++) {
206
             if (ctr < 8) {
207
                 outputOffset1 = outPos + ctr * 8;
208
                 outputOffset2 = outPos +  + ctr * 8;
209
             } else {
210
                 outputOffset1 = outPos +  + ctr * 8;
211
                 outputOffset2 = outPos +  * 2 + ctr * 8;
212
             }
213
             /* Even part */
214
 
215
             /* Add fudge factor here for final descale. */
216
             tmp0 = wsptr[wsOffset] + ( << ( + 2));
217
             tmp0 <<= ;
218
 
219
             z1 = wsptr[wsOffset + 4];
220
             tmp1 = (z1 * ); /* c4[16] = c2[8] */
221
             tmp2 = (z1 * ); /* c12[16] = c6[8] */
222
 
223
             tmp10 = tmp0 + tmp1;
224
             tmp11 = tmp0 - tmp1;
225
             tmp12 = tmp0 + tmp2;
226
             tmp13 = tmp0 - tmp2;
227
 
228
             z1 = wsptr[wsOffset + 2];
229
             z2 = wsptr[wsOffset + 6];
230
             z3 = z1 - z2;
231
             z4 = (z3 * ); /* c14[16] = c7[8] */
232
             z3 = (z3 * ); /* c2[16] = c1[8] */
233
 
234
             // (c6+c2)[16] = (c3+c1)[8]
235
             tmp0 = z3 + (z2 * );
236
             // (c6-c14)[16] = (c3-c7)[8]
237
             tmp1 = z4 + (z1 * );
238
             // (c2-c10)[16] = (c1-c5)[8]
239
             tmp2 = z3 - (z1 * );
240
             // (c10-c14)[16] = (c5-c7)[8]
241
             tmp3 = z4 - (z2 * );
242
 
243
             tmp20 = tmp10 + tmp0;
244
             tmp27 = tmp10 - tmp0;
245
             tmp21 = tmp12 + tmp1;
246
             tmp26 = tmp12 - tmp1;
247
             tmp22 = tmp13 + tmp2;
248
             tmp25 = tmp13 - tmp2;
249
             tmp23 = tmp11 + tmp3;
250
             tmp24 = tmp11 - tmp3;
251
 
252
             /* Odd part */
253
 
254
             z1 = wsptr[wsOffset + 1];
255
             z2 = wsptr[wsOffset + 3];
256
             z3 = wsptr[wsOffset + 5];
257
             z4 = wsptr[wsOffset + 7];
258
 
259
             tmp11 = z1 + z3;
260
 
261
             tmp1 = ((z1 + z2) * ); /* c3 */
262
             tmp2 = (tmp11 * ); /* c5 */
263
             tmp3 = ((z1 + z4) * ); /* c7 */
264
             tmp10 = ((z1 - z4) * ); /* c9 */
265
             tmp11 = (tmp11 * ); /* c11 */
266
             tmp12 = ((z1 - z2) * ); /* c13 */
267
             tmp0 = tmp1 + tmp2 + tmp3 - (z1 * );
268
             tmp13 = tmp10 + tmp11 + tmp12 - (z1 * );
269
             z1 = ((z2 + z3) * ); /* c15 */
270
             tmp1 += z1 + (z2 * ); /* c9+c11-c3-c15 */
271
             tmp2 += z1 - (z3 * ); /* c5+c7+c15-c3 */
272
             z1 = ((z3 - z2) * ); /* c1 */
273
             tmp11 += z1 - (z3 * ); /* c1+c11-c9-c13 */
274
             tmp12 += z1 + (z2 * ); /* c1+c5+c13-c7 */
275
             z2 += z4;
276
             z1 = (z2 * (-)); /* -c11 */
277
             tmp1 += z1;
278
             tmp3 += z1 + (z4 * ); /* c3+c11+c15-c7 */
279
             z2 = (z2 * (-)); /* -c5 */
280
             tmp10 += z2 + (z4 * ); /* c1+c5+c9-c13 */
281
             tmp12 += z2;
282
             z2 = ((z3 + z4) * (-)); /* -c3 */
283
             tmp2 += z2;
284
             tmp3 += z2;
285
             z2 = ((z4 - z3) * ); /* c13 */
286
             tmp10 += z2;
287
             tmp11 += z2;
288
 
289
             /* Final output stage */
290
             outptr[outputOffset1 + 0] = rangeLimitMap[rangeLimitOffset
291
                                                       + (((tmp20 + tmp0) >> ( +  + 3)) & )];
292
             outptr[outputOffset2 + 7] = rangeLimitMap[rangeLimitOffset
293
                                                       + (((tmp20 - tmp0) >> ( +  + 3)) & )];
294
             outptr[outputOffset1 + 1] = rangeLimitMap[rangeLimitOffset
295
                                                       + (((tmp21 + tmp1) >> ( +  + 3)) & )];
296
             outptr[outputOffset2 + 6] = rangeLimitMap[rangeLimitOffset
297
                                                       + (((tmp21 - tmp1) >> ( +  + 3)) & )];
298
             outptr[outputOffset1 + 2] = rangeLimitMap[rangeLimitOffset
299
                                                       + (((tmp22 + tmp2) >> ( +  + 3)) & )];
300
             outptr[outputOffset2 + 5] = rangeLimitMap[rangeLimitOffset
301
                                                       + (((tmp22 - tmp2) >> ( +  + 3)) & )];
302
             outptr[outputOffset1 + 3] = rangeLimitMap[rangeLimitOffset
303
                                                       + (((tmp23 + tmp3) >> ( +  + 3)) & )];
304
             outptr[outputOffset2 + 4] = rangeLimitMap[rangeLimitOffset
305
                                                       + (((tmp23 - tmp3) >> ( +  + 3)) & )];
306
             outptr[outputOffset1 + 4] = rangeLimitMap[rangeLimitOffset
307
                                                       + (((tmp24 + tmp10) >> ( +  + 3)) & )];
308
             outptr[outputOffset2 + 3] = rangeLimitMap[rangeLimitOffset
309
                                                       + (((tmp24 - tmp10) >> ( +  + 3)) & )];
310
             outptr[outputOffset1 + 5] = rangeLimitMap[rangeLimitOffset
311
                                                       + (((tmp25 + tmp11) >> ( +  + 3)) & )];
312
             outptr[outputOffset2 + 2] = rangeLimitMap[rangeLimitOffset
313
                                                       + (((tmp25 - tmp11) >> ( +  + 3)) & )];
314
             outptr[outputOffset1 + 6] = rangeLimitMap[rangeLimitOffset
315
                                                       + (((tmp26 + tmp12) >> ( +  + 3)) & )];
316
             outptr[outputOffset2 + 1] = rangeLimitMap[rangeLimitOffset
317
                                                       + (((tmp26 - tmp12) >> ( +  + 3)) & )];
318
             outptr[outputOffset1 + 7] = rangeLimitMap[rangeLimitOffset
319
                                                       + (((tmp27 + tmp13) >> ( +  + 3)) & )];
320
             outptr[outputOffset2 + 0] = rangeLimitMap[rangeLimitOffset
321
                                                       + (((tmp27 - tmp13) >> ( +  + 3)) & )];
322
 
323
             wsOffset += 8; /* advance pointer to next row */
324
         }
325
 
326
         return outptr;
327
     }
328
 
329
     protected Object calculate16x8(int[] inptr, int inPos, int[] quant, int[] output, int outPos) {
330
         int tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
331
         int tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
332
         int z1, z2, z3, z4;
333
         int[] wsptr;
334
         int[] outptr = (output != null ? output : new int[ * 2]);
335
         short[] rangeLimitMap = ;
336
         int rangeLimitOffset =  + ;
337
 
338
         int ctr;
339
         int workspace[] = new int[]; /* buffers data between passes */
340
         int inputOffset = inPos, outputOffset1 = 0, outputOffset2 = 0, quantOffset = 0, wsOffset = 0;
341
 
342
         /* Pass 1: process columns from input, store into work array. */
343
         /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
344
         /* furthermore, we scale the results by 2**PASS1_BITS. */
345
 
346
         wsptr = workspace;
347
         for (ctr = ; ctr > 0; ctr--) {
348
             if (inptr[inputOffset +  * 1] == 0 && inptr[inputOffset +  * 2] == 0
349
                 && inptr[inputOffset +  * 3] == 0 && inptr[inputOffset +  * 4] == 0
350
                 && inptr[inputOffset +  * 5] == 0 && inptr[inputOffset +  * 6] == 0
351
                 && inptr[inputOffset +  * 7] == 0) {
352
                 /* AC terms all zero */
353
                 int dcval = (inptr[inputOffset] * quant[quantOffset]) << ;
354
 
355
                 wsptr[wsOffset +  * 0] = dcval;
356
                 wsptr[wsOffset +  * 1] = dcval;
357
                 wsptr[wsOffset +  * 2] = dcval;
358
                 wsptr[wsOffset +  * 3] = dcval;
359
                 wsptr[wsOffset +  * 4] = dcval;
360
                 wsptr[wsOffset +  * 5] = dcval;
361
                 wsptr[wsOffset +  * 6] = dcval;
362
                 wsptr[wsOffset +  * 7] = dcval;
363
 
364
                 /* advance pointers to next column */
365
                 inputOffset++;
366
                 quantOffset++;
367
                 wsOffset++;
368
 
369
                 continue;
370
             }
371
 
372
             /* Even part: reverse the even part of the forward DCT. */
373
             /* The rotator is sqrt(2)*c(-6). */
374
 
375
             z2 = inptr[inputOffset +  * 2] * quant[quantOffset +  * 2];
376
             z3 = inptr[inputOffset +  * 6] * quant[quantOffset +  * 6];
377
 
378
             z1 = ((z2 + z3) * );
379
             tmp2 = z1 + (z2 * );
380
             tmp3 = z1 - (z3 * );
381
 
382
             z2 = inptr[inputOffset +  * 0] * quant[quantOffset +  * 0];
383
             z3 = inptr[inputOffset +  * 4] * quant[quantOffset +  * 4];
384
             z2 <<= ;
385
             z3 <<= ;
386
             /* Add fudge factor here for final descale. */
387
             z2 += ( << ( -  - 1));
388
 
389
             tmp0 = z2 + z3;
390
             tmp1 = z2 - z3;
391
 
392
             tmp10 = tmp0 + tmp2;
393
             tmp13 = tmp0 - tmp2;
394
             tmp11 = tmp1 + tmp3;
395
             tmp12 = tmp1 - tmp3;
396
 
397
             /*
398
              * Odd part per figure 8; the matrix is unitary and hence its transpose is its inverse. i0..i3 are
399
              * y7,y5,y3,y1 respectively.
400
              */
401
 
402
             tmp0 = inptr[inputOffset +  * 7] * quant[quantOffset +  * 7];
403
             tmp1 = inptr[inputOffset +  * 5] * quant[quantOffset +  * 5];
404
             tmp2 = inptr[inputOffset +  * 3] * quant[quantOffset +  * 3];
405
             tmp3 = inptr[inputOffset +  * 1] * quant[quantOffset +  * 1];
406
 
407
             z2 = tmp0 + tmp2;
408
             z3 = tmp1 + tmp3;
409
 
410
             z1 = ((z2 + z3) * ); /* sqrt(2) * c3 */
411
             z2 = (z2 * (-)); /* sqrt(2) * (-c3-c5) */
412
             z3 = (z3 * (-)); /* sqrt(2) * (c5-c3) */
413
             z2 += z1;
414
             z3 += z1;
415
 
416
             z1 = ((tmp0 + tmp3) * (-)); /* sqrt(2) * (c7-c3) */
417
             tmp0 = (tmp0 * ); /* sqrt(2) * (-c1+c3+c5-c7) */
418
             tmp3 = (tmp3 * ); /* sqrt(2) * ( c1+c3-c5-c7) */
419
             tmp0 += z1 + z2;
420
             tmp3 += z1 + z3;
421
 
422
             z1 = ((tmp1 + tmp2) * (-)); /* sqrt(2) * (-c1-c3) */
423
             tmp1 = (tmp1 * ); /* sqrt(2) * ( c1+c3-c5+c7) */
424
             tmp2 = (tmp2 * ); /* sqrt(2) * ( c1+c3+c5-c7) */
425
             tmp1 += z1 + z3;
426
             tmp2 += z1 + z2;
427
 
428
             /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
429
 
430
             wsptr[wsOffset +  * 0] = (tmp10 + tmp3) >> ( - );
431
             wsptr[wsOffset +  * 7] = (tmp10 - tmp3) >> ( - );
432
             wsptr[wsOffset +  * 1] = (tmp11 + tmp2) >> ( - );
433
             wsptr[wsOffset +  * 6] = (tmp11 - tmp2) >> ( - );
434
             wsptr[wsOffset +  * 2] = (tmp12 + tmp1) >> ( - );
435
             wsptr[wsOffset +  * 5] = (tmp12 - tmp1) >> ( - );
436
             wsptr[wsOffset +  * 3] = (tmp13 + tmp0) >> ( - );
437
             wsptr[wsOffset +  * 4] = (tmp13 - tmp0) >> ( - );
438
 
439
             /* advance pointers to next column */
440
             inputOffset++;
441
             quantOffset++;
442
             wsOffset++;
443
         }
444
 
445
         /*
446
          * Pass 2: process 8 rows from work array, store into output array. 16-point IDCT kernel, cK represents sqrt(2)
447
          * * cos(K*pi/32).
448
          */
449
         wsOffset = 0;
450
         for (ctr = 0; ctr < ; ctr++) {
451
             // outptr = output_buf[ctr] + output_col;
452
             outputOffset1 = outPos + ctr * ;
453
             outputOffset2 = outPos +  + ctr * ;
454
 
455
             /* Even part */
456
 
457
             /* Add fudge factor here for final descale. */
458
             tmp0 = wsptr[wsOffset] + ( << ( + 2));
459
             tmp0 <<= ;
460
 
461
             z1 = wsptr[wsOffset + 4];
462
             tmp1 = (z1 * ); /* c4[16] = c2[8] */
463
             tmp2 = (z1 * ); /* c12[16] = c6[8] */
464
 
465
             tmp10 = tmp0 + tmp1;
466
             tmp11 = tmp0 - tmp1;
467
             tmp12 = tmp0 + tmp2;
468
             tmp13 = tmp0 - tmp2;
469
 
470
             z1 = wsptr[wsOffset + 2];
471
             z2 = wsptr[wsOffset + 6];
472
             z3 = z1 - z2;
473
             z4 = (z3 * ); /* c14[16] = c7[8] */
474
             z3 = (z3 * ); /* c2[16] = c1[8] */
475
 
476
             // (c6+c2)[16] = (c3+c1)[8]
477
             tmp0 = z3 + (z2 * );
478
             // (c6-c14)[16] = (c3-c7)[8]
479
             tmp1 = z4 + (z1 * );
480
             // (c2-c10)[16] = (c1-c5)[8]
481
             tmp2 = z3 - (z1 * );
482
             // (c10-c14)[16] = (c5-c7)[8]
483
             tmp3 = z4 - (z2 * );
484
 
485
             tmp20 = tmp10 + tmp0;
486
             tmp27 = tmp10 - tmp0;
487
             tmp21 = tmp12 + tmp1;
488
             tmp26 = tmp12 - tmp1;
489
             tmp22 = tmp13 + tmp2;
490
             tmp25 = tmp13 - tmp2;
491
             tmp23 = tmp11 + tmp3;
492
             tmp24 = tmp11 - tmp3;
493
 
494
             /* Odd part */
495
             z1 = wsptr[wsOffset + 1];
496
             z2 = wsptr[wsOffset + 3];
497
             z3 = wsptr[wsOffset + 5];
498
             z4 = wsptr[wsOffset + 7];
499
 
500
             tmp11 = z1 + z3;
501
 
502
             tmp1 = ((z1 + z2) * ); /* c3 */
503
             tmp2 = (tmp11 * ); /* c5 */
504
             tmp3 = ((z1 + z4) * ); /* c7 */
505
             tmp10 = ((z1 - z4) * ); /* c9 */
506
             tmp11 = (tmp11 * ); /* c11 */
507
             tmp12 = ((z1 - z2) * ); /* c13 */
508
             // c7+c5+c3-c1
509
             tmp0 = tmp1 + tmp2 + tmp3 - (z1 * );
510
             tmp13 = tmp10 + tmp11 + tmp12 - (z1 * );
511
             z1 = ((z2 + z3) * ); /* c15 */
512
             tmp1 += z1 + (z2 * ); /* c9+c11-c3-c15 */
513
             tmp2 += z1 - (z3 * ); /* c5+c7+c15-c3 */
514
             z1 = ((z3 - z2) * ); /* c1 */
515
             tmp11 += z1 - (z3 * ); /* c1+c11-c9-c13 */
516
             tmp12 += z1 + (z2 * ); /* c1+c5+c13-c7 */
517
             z2 += z4;
518
             z1 = (z2 * (-)); /* -c11 */
519
             tmp1 += z1;
520
             tmp3 += z1 + (z4 * ); /* c3+c11+c15-c7 */
521
             z2 = (z2 * (-)); /* -c5 */
522
             tmp10 += z2 + (z4 * ); /* c1+c5+c9-c13 */
523
             tmp12 += z2;
524
             z2 = ((z3 + z4) * (-)); /* -c3 */
525
             tmp2 += z2;
526
             tmp3 += z2;
527
             z2 = ((z4 - z3) * ); /* c13 */
528
             tmp10 += z2;
529
             tmp11 += z2;
530
 
531
             /* Final output stage */
532
             outptr[outputOffset1 + 0] = rangeLimitMap[rangeLimitOffset
533
                                                       + (((tmp20 + tmp0) >> ( +  + 3)) & )];
534
             outptr[outputOffset2 + 7] = rangeLimitMap[rangeLimitOffset
535
                                                       + (((tmp20 - tmp0) >> ( +  + 3)) & )];
536
             outptr[outputOffset1 + 1] = rangeLimitMap[rangeLimitOffset
537
                                                       + (((tmp21 + tmp1) >> ( +  + 3)) & )];
538
             outptr[outputOffset2 + 6] = rangeLimitMap[rangeLimitOffset
539
                                                       + (((tmp21 - tmp1) >> ( +  + 3)) & )];
540
             outptr[outputOffset1 + 2] = rangeLimitMap[rangeLimitOffset
541
                                                       + (((tmp22 + tmp2) >> ( +  + 3)) & )];
542
             outptr[outputOffset2 + 5] = rangeLimitMap[rangeLimitOffset
543
                                                       + (((tmp22 - tmp2) >> ( +  + 3)) & )];
544
             outptr[outputOffset1 + 3] = rangeLimitMap[rangeLimitOffset
545
                                                       + (((tmp23 + tmp3) >> ( +  + 3)) & )];
546
             outptr[outputOffset2 + 4] = rangeLimitMap[rangeLimitOffset
547
                                                       + (((tmp23 - tmp3) >> ( +  + 3)) & )];
548
             outptr[outputOffset1 + 4] = rangeLimitMap[rangeLimitOffset
549
                                                       + (((tmp24 + tmp10) >> ( +  + 3)) & )];
550
             outptr[outputOffset2 + 3] = rangeLimitMap[rangeLimitOffset
551
                                                       + (((tmp24 - tmp10) >> ( +  + 3)) & )];
552
             outptr[outputOffset1 + 5] = rangeLimitMap[rangeLimitOffset
553
                                                       + (((tmp25 + tmp11) >> ( +  + 3)) & )];
554
             outptr[outputOffset2 + 2] = rangeLimitMap[rangeLimitOffset
555
                                                       + (((tmp25 - tmp11) >> ( +  + 3)) & )];
556
             outptr[outputOffset1 + 6] = rangeLimitMap[rangeLimitOffset
557
                                                       + (((tmp26 + tmp12) >> ( +  + 3)) & )];
558
             outptr[outputOffset2 + 1] = rangeLimitMap[rangeLimitOffset
559
                                                       + (((tmp26 - tmp12) >> ( +  + 3)) & )];
560
             outptr[outputOffset1 + 7] = rangeLimitMap[rangeLimitOffset
561
                                                       + (((tmp27 + tmp13) >> ( +  + 3)) & )];
562
             outptr[outputOffset2 + 0] = rangeLimitMap[rangeLimitOffset
563
                                                       + (((tmp27 - tmp13) >> ( +  + 3)) & )];
564
 
565
             wsOffset += 8; /* advance pointer to next row */
566
         }
567
 
568
         return outptr;
569
     }
570
 
571
     protected Object calculate8x16(int[] inptr, int inPos, int[] quant, int[] output, int outPos) {
572
         int tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
573
         int tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27;
574
         int z1, z2, z3, z4;
575
         int[] wsptr;
576
         int[] outptr = (output != null ? output : new int[ * 2]);
577
 
578
         short[] rangeLimitMap = ;
579
         int rangeLimitOffset =  + ;
580
 
581
         int ctr;
582
         int[] workspace = new int[8 * 16]; /* buffers data between passes */
583
 
584
         int inputOffset = inPos, quantOffset = 0, outputOffset = 0, wsOffset = 0;
585
         /*
586
          * Pass 1: process columns from input, store into work array. 16-point IDCT kernel, cK represents sqrt(2) *
587
          * cos(K*pi/32).
588
          */
589
         wsptr = workspace;
590
 
591
         for (ctr = 0; ctr < 8; ctr++, inputOffset++, quantOffset++, wsOffset++) {
592
             /* Even part */
593
 
594
             tmp0 = inptr[inputOffset] * quant[quantOffset];
595
             tmp0 <<= ;
596
             /* Add fudge factor here for final descale. */
597
             tmp0 += ( << ( -  - 1));
598
 
599
             z1 = inptr[inputOffset +  * 4] * quant[quantOffset +  * 4];
600
             tmp1 = (z1 * ); /* c4[16] = c2[8] */
601
             tmp2 = (z1 * ); /* c12[16] = c6[8] */
602
 
603
             tmp10 = tmp0 + tmp1;
604
             tmp11 = tmp0 - tmp1;
605
             tmp12 = tmp0 + tmp2;
606
             tmp13 = tmp0 - tmp2;
607
 
608
             z1 = inptr[inputOffset +  * 2] * quant[quantOffset +  * 2];
609
             z2 = inptr[inputOffset +  * 6] * quant[quantOffset +  * 6];
610
             z3 = z1 - z2;
611
             z4 = (z3 * ); /* c14[16] = c7[8] */
612
             z3 = (z3 * ); /* c2[16] = c1[8] */
613
 
614
             // (c6+c2)[16] = (c3+c1)[8]
615
             tmp0 = z3 + (z2 * );
616
             // (c6-c14)[16] = (c3-c7)[8]
617
             tmp1 = z4 + (z1 * );
618
             // (c2-c10)[16] = (c1-c5)[8]
619
             tmp2 = z3 - (z1 * );
620
             // (c10-c14)[16] = (c5-c7)[8]
621
             tmp3 = z4 - (z2 * );
622
 
623
             tmp20 = tmp10 + tmp0;
624
             tmp27 = tmp10 - tmp0;
625
             tmp21 = tmp12 + tmp1;
626
             tmp26 = tmp12 - tmp1;
627
             tmp22 = tmp13 + tmp2;
628
             tmp25 = tmp13 - tmp2;
629
             tmp23 = tmp11 + tmp3;
630
             tmp24 = tmp11 - tmp3;
631
 
632
             /* Odd part */
633
 
634
             z1 = inptr[inputOffset +  * 1] * quant[quantOffset +  * 1];
635
             z2 = inptr[inputOffset +  * 3] * quant[quantOffset +  * 3];
636
             z3 = inptr[inputOffset +  * 5] * quant[quantOffset +  * 5];
637
             z4 = inptr[inputOffset +  * 7] * quant[quantOffset +  * 7];
638
 
639
             tmp11 = z1 + z3;
640
 
641
             tmp1 = ((z1 + z2) * ); /* c3 */
642
             tmp2 = (tmp11 * ); /* c5 */
643
             tmp3 = ((z1 + z4) * ); /* c7 */
644
             tmp10 = ((z1 - z4) * ); /* c9 */
645
             tmp11 = (tmp11 * ); /* c11 */
646
             tmp12 = ((z1 - z2) * ); /* c13 */
647
             // c7+c5+c3-c1
648
             tmp0 = tmp1 + tmp2 + tmp3 - (z1 * );
649
             tmp13 = tmp10 + tmp11 + tmp12 - (z1 * );
650
             z1 = ((z2 + z3) * ); /* c15 */
651
             tmp1 += z1 + (z2 * ); /* c9+c11-c3-c15 */
652
             tmp2 += z1 - (z3 * ); /* c5+c7+c15-c3 */
653
             z1 = ((z3 - z2) * ); /* c1 */
654
             tmp11 += z1 - (z3 * ); /* c1+c11-c9-c13 */
655
             tmp12 += z1 + (z2 * ); /* c1+c5+c13-c7 */
656
             z2 += z4;
657
             z1 = (z2 * (-)); /* -c11 */
658
             tmp1 += z1;
659
             tmp3 += z1 + (z4 * ); /* c3+c11+c15-c7 */
660
             z2 = (z2 * (-)); /* -c5 */
661
             tmp10 += z2 + (z4 * ); /* c1+c5+c9-c13 */
662
             tmp12 += z2;
663
             z2 = ((z3 + z4) * (-)); /* -c3 */
664
             tmp2 += z2;
665
             tmp3 += z2;
666
             z2 = ((z4 - z3) * ); /* c13 */
667
             tmp10 += z2;
668
             tmp11 += z2;
669
 
670
             /* Final output stage */
671
 
672
             wsptr[wsOffset + 8 * 0] = (tmp20 + tmp0) >> ( - );
673
             wsptr[wsOffset + 8 * 15] = (tmp20 - tmp0) >> ( - );
674
             wsptr[wsOffset + 8 * 1] = (tmp21 + tmp1) >> ( - );
675
             wsptr[wsOffset + 8 * 14] = (tmp21 - tmp1) >> ( - );
676
             wsptr[wsOffset + 8 * 2] = (tmp22 + tmp2) >> ( - );
677
             wsptr[wsOffset + 8 * 13] = (tmp22 - tmp2) >> ( - );
678
             wsptr[wsOffset + 8 * 3] = (tmp23 + tmp3) >> ( - );
679
             wsptr[wsOffset + 8 * 12] = (tmp23 - tmp3) >> ( - );
680
             wsptr[wsOffset + 8 * 4] = (tmp24 + tmp10) >> ( - );
681
             wsptr[wsOffset + 8 * 11] = (tmp24 - tmp10) >> ( - );
682
             wsptr[wsOffset + 8 * 5] = (tmp25 + tmp11) >> ( - );
683
             wsptr[wsOffset + 8 * 10] = (tmp25 - tmp11) >> ( - );
684
             wsptr[wsOffset + 8 * 6] = (tmp26 + tmp12) >> ( - );
685
             wsptr[wsOffset + 8 * 9] = (tmp26 - tmp12) >> ( - );
686
             wsptr[wsOffset + 8 * 7] = (tmp27 + tmp13) >> ( - );
687
             wsptr[wsOffset + 8 * 8] = (tmp27 - tmp13) >> ( - );
688
         }
689
 
690
         /* Pass 2: process rows from work array, store into output array. */
691
         /* Note that we must descale the results by a factor of 8 == 2**3, */
692
         /* and also undo the PASS1_BITS scaling. */
693
 
694
         // wsptr = workspace;
695
         wsOffset = 0;
696
         for (ctr = 0; ctr < 16; ctr++) {
697
             outputOffset = outPos + ctr * 8;
698
 
699
             /* Even part: reverse the even part of the forward DCT. */
700
             /* The rotator is sqrt(2)*c(-6). */
701
 
702
             z2 = wsptr[wsOffset + 2];
703
             z3 = wsptr[wsOffset + 6];
704
 
705
             z1 = ((z2 + z3) * );
706
             tmp2 = z1 + (z2 * );
707
             tmp3 = z1 - (z3 * );
708
 
709
             /* Add fudge factor here for final descale. */
710
             z2 = wsptr[wsOffset] + ( << ( + 2));
711
             z3 = wsptr[wsOffset + 4];
712
 
713
             tmp0 = (z2 + z3) << ;
714
             tmp1 = (z2 - z3) << ;
715
 
716
             tmp10 = tmp0 + tmp2;
717
             tmp13 = tmp0 - tmp2;
718
             tmp11 = tmp1 + tmp3;
719
             tmp12 = tmp1 - tmp3;
720
 
721
             /*
722
              * Odd part per figure 8; the matrix is unitary and hence its transpose is its inverse. i0..i3 are
723
              * y7,y5,y3,y1 respectively.
724
              */
725
 
726
             tmp0 = wsptr[wsOffset + 7];
727
             tmp1 = wsptr[wsOffset + 5];
728
             tmp2 = wsptr[wsOffset + 3];
729
             tmp3 = wsptr[wsOffset + 1];
730
 
731
             z2 = tmp0 + tmp2;
732
             z3 = tmp1 + tmp3;
733
 
734
             z1 = ((z2 + z3) * ); /* sqrt(2) * c3 */
735
             z2 = (z2 * (-)); /* sqrt(2) * (-c3-c5) */
736
             z3 = (z3 * (-)); /* sqrt(2) * (c5-c3) */
737
             z2 += z1;
738
             z3 += z1;
739
 
740
             z1 = ((tmp0 + tmp3) * (-)); /* sqrt(2) * (c7-c3) */
741
             tmp0 = (tmp0 * ); /* sqrt(2) * (-c1+c3+c5-c7) */
742
             tmp3 = (tmp3 * ); /* sqrt(2) * ( c1+c3-c5-c7) */
743
             tmp0 += z1 + z2;
744
             tmp3 += z1 + z3;
745
 
746
             z1 = ((tmp1 + tmp2) * (-)); /* sqrt(2) * (-c1-c3) */
747
             tmp1 = (tmp1 * ); /* sqrt(2) * ( c1+c3-c5+c7) */
748
             tmp2 = (tmp2 * ); /* sqrt(2) * ( c1+c3+c5-c7) */
749
             tmp1 += z1 + z3;
750
             tmp2 += z1 + z2;
751
 
752
             /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
753
             outptr[outputOffset + 0] = rangeLimitMap[rangeLimitOffset
754
                                                      + (((tmp10 + tmp3) >> ( +  + 3)) & )];
755
             outptr[outputOffset + 7] = rangeLimitMap[rangeLimitOffset
756
                                                      + (((tmp10 - tmp3) >> ( +  + 3)) & )];
757
             outptr[outputOffset + 1] = rangeLimitMap[rangeLimitOffset
758
                                                      + (((tmp11 + tmp2) >> ( +  + 3)) & )];
759
             outptr[outputOffset + 6] = rangeLimitMap[rangeLimitOffset
760
                                                      + (((tmp11 - tmp2) >> ( +  + 3)) & )];
761
             outptr[outputOffset + 2] = rangeLimitMap[rangeLimitOffset
762
                                                      + (((tmp12 + tmp1) >> ( +  + 3)) & )];
763
             outptr[outputOffset + 5] = rangeLimitMap[rangeLimitOffset
764
                                                      + (((tmp12 - tmp1) >> ( +  + 3)) & )];
765
             outptr[outputOffset + 3] = rangeLimitMap[rangeLimitOffset
766
                                                      + (((tmp13 + tmp0) >> ( +  + 3)) & )];
767
             outptr[outputOffset + 4] = rangeLimitMap[rangeLimitOffset
768
                                                      + (((tmp13 - tmp0) >> ( +  + 3)) & )];
769
 
770
             wsOffset += ; /* advance pointer to next row */
771
         }
772
 
773
         return outptr;
774
     }
775
 
776
     protected Object calculate8x8(int[] inptr, int inPos, int[] quant, int[] output, int outPos) {
777
         int tmp0, tmp1, tmp2, tmp3;
778
         int tmp10, tmp11, tmp12, tmp13;
779
         int z1, z2, z3;
780
         int[] wsptr;
781
         int[] outptr = (output != null ? output : new int[]);
782
 
783
         short[] rangeLimitMap = ;
784
         int rangeLimitOffset =  + ;
785
 
786
         int ctr;
787
         int workspace[] = new int[]; /* buffers data between passes */
788
 
789
         int inputOffset = inPos, wsOffset = 0, quantOffset = 0, outputOffset = 0;
790
         /* Pass 1: process columns from input, store into work array. */
791
         /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
792
         /* furthermore, we scale the results by 2**PASS1_BITS. */
793
         wsptr = workspace;
794
 
795
         for (ctr = ; ctr > 0; ctr--) {
796
             if (inptr[inputOffset +  * 1] == 0 && inptr[inputOffset +  * 2] == 0
797
                 && inptr[inputOffset +  * 3] == 0 && inptr[inputOffset +  * 4] == 0
798
                 && inptr[inputOffset +  * 5] == 0 && inptr[inputOffset +  * 6] == 0
799
                 && inptr[inputOffset +  * 7] == 0) {
800
                 /* AC terms all zero */
801
                 int dcval = (inptr[inputOffset] * quant[quantOffset]) << ;
802
 
803
                 wsptr[wsOffset +  * 0] = dcval;
804
                 wsptr[wsOffset +  * 1] = dcval;
805
                 wsptr[wsOffset +  * 2] = dcval;
806
                 wsptr[wsOffset +  * 3] = dcval;
807
                 wsptr[wsOffset +  * 4] = dcval;
808
                 wsptr[wsOffset +  * 5] = dcval;
809
                 wsptr[wsOffset +  * 6] = dcval;
810
                 wsptr[wsOffset +  * 7] = dcval;
811
 
812
                 /* advance pointers to next column */
813
                 inputOffset++;
814
                 quantOffset++;
815
                 wsOffset++;
816
 
817
                 continue;
818
             }
819
 
820
             /* Even part: reverse the even part of the forward DCT. */
821
             /* The rotator is sqrt(2)*c(-6). */
822
 
823
             z2 = inptr[inputOffset +  * 2] * quant[quantOffset +  * 2];
824
             z3 = inptr[inputOffset +  * 6] * quant[quantOffset +  * 6];
825
 
826
             z1 = ((z2 + z3) * );
827
             tmp2 = z1 + (z2 * );
828
             tmp3 = z1 - (z3 * );
829
 
830
             z2 = inptr[inputOffset +  * 0] * quant[quantOffset +  * 0];
831
             z3 = inptr[inputOffset +  * 4] * quant[quantOffset +  * 4];
832
             z2 <<= ;
833
             z3 <<= ;
834
             /* Add fudge factor here for final descale. */
835
             z2 += ( << ( -  - 1));
836
 
837
             tmp0 = z2 + z3;
838
             tmp1 = z2 - z3;
839
 
840
             tmp10 = tmp0 + tmp2;
841
             tmp13 = tmp0 - tmp2;
842
             tmp11 = tmp1 + tmp3;
843
             tmp12 = tmp1 - tmp3;
844
 
845
             /*
846
              * Odd part per figure 8; the matrix is unitary and hence its transpose is its inverse. i0..i3 are
847
              * y7,y5,y3,y1 respectively.
848
              */
849
 
850
             tmp0 = inptr[inputOffset +  * 7] * quant[quantOffset +  * 7];
851
             tmp1 = inptr[inputOffset +  * 5] * quant[quantOffset +  * 5];
852
             tmp2 = inptr[inputOffset +  * 3] * quant[quantOffset +  * 3];
853
             tmp3 = inptr[inputOffset +  * 1] * quant[quantOffset +  * 1];
854
 
855
             z2 = tmp0 + tmp2;
856
             z3 = tmp1 + tmp3;
857
 
858
             z1 = ((z2 + z3) * ); /* sqrt(2) * c3 */
859
             z2 = (z2 * (-)); /* sqrt(2) * (-c3-c5) */
860
             z3 = (z3 * (-)); /* sqrt(2) * (c5-c3) */
861
             z2 += z1;
862
             z3 += z1;
863
 
864
             z1 = ((tmp0 + tmp3) * (-)); /* sqrt(2) * (c7-c3) */
865
             tmp0 = (tmp0 * ); /* sqrt(2) * (-c1+c3+c5-c7) */
866
             tmp3 = (tmp3 * ); /* sqrt(2) * ( c1+c3-c5-c7) */
867
             tmp0 += z1 + z2;
868
             tmp3 += z1 + z3;
869
 
870
             z1 = ((tmp1 + tmp2) * (-)); /* sqrt(2) * (-c1-c3) */
871
             tmp1 = (tmp1 * ); /* sqrt(2) * ( c1+c3-c5+c7) */
872
             tmp2 = (tmp2 * ); /* sqrt(2) * ( c1+c3+c5-c7) */
873
             tmp1 += z1 + z3;
874
             tmp2 += z1 + z2;
875
 
876
             /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
877
 
878
             wsptr[wsOffset +  * 0] = (tmp10 + tmp3) >> ( - );
879
             wsptr[wsOffset +  * 7] = (tmp10 - tmp3) >> ( - );
880
             wsptr[wsOffset +  * 1] = (tmp11 + tmp2) >> ( - );
881
             wsptr[wsOffset +  * 6] = (tmp11 - tmp2) >> ( - );
882
             wsptr[wsOffset +  * 2] = (tmp12 + tmp1) >> ( - );
883
             wsptr[wsOffset +  * 5] = (tmp12 - tmp1) >> ( - );
884
             wsptr[wsOffset +