Statistics
| Branch: | Revision:

ffmpeg / libavcodec / simple_idct.c @ 1e98dffb

History | View | Annotate | Download (13.7 KB)

1
/*
2
    Copyright (C) 2001 Michael Niedermayer (michaelni@gmx.at)
3

4
    This program is free software; you can redistribute it and/or modify
5
    it under the terms of the GNU General Public License as published by
6
    the Free Software Foundation; either version 2 of the License, or
7
    (at your option) any later version.
8

9
    This program is distributed in the hope that it will be useful,
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
    GNU General Public License for more details.
13

14
    You should have received a copy of the GNU General Public License
15
    along with this program; if not, write to the Free Software
16
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
*/
18

    
19
/*
20
  based upon some outcommented c code from mpeg2dec (idct_mmx.c written by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>)
21
*/
22

    
23
#include <inttypes.h>
24

    
25
#include "simple_idct.h"
26
#include "../config.h"
27

    
28
#if 0
29
#define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */
30
#define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */
31
#define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */
32
#define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */
33
#define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */
34
#define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */
35
#define W7 565  /* 2048*sqrt (2)*cos (7*pi/16) */
36
#define ROW_SHIFT 8
37
#define COL_SHIFT 17
38
#else
39
#define W1  22725  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
40
#define W2  21407  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
41
#define W3  19266  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
42
#define W4  16384  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
43
#define W5  12873  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
44
#define W6  8867   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
45
#define W7  4520   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
46
#define ROW_SHIFT 11
47
#define COL_SHIFT 20 // 6
48
#endif
49

    
50
/* 8x8 Matrix used to do a trivial (slow) 8 point IDCT */
51
static int coeff[64]={
52
        W4, W4, W4, W4, W4, W4, W4, W4,
53
        W1, W3, W5, W7,-W7,-W5,-W3,-W1,
54
        W2, W6,-W6,-W2,-W2,-W6, W6, W2,
55
        W3,-W7,-W1,-W5, W5, W1, W7,-W3,
56
        W4,-W4,-W4, W4, W4,-W4,-W4, W4,
57
        W5,-W1, W7, W3,-W3,-W7, W1,-W5,
58
        W6,-W2, W2,-W6,-W6, W2,-W2, W6,
59
        W7,-W5, W3,-W1, W1,-W3, W5,-W7
60
};
61

    
62
static int inline idctRowCondZ (int16_t * row)
63
{
64
        int a0, a1, a2, a3, b0, b1, b2, b3;
65

    
66
        if( !( ((uint32_t*)row)[0]|((uint32_t*)row)[1] |((uint32_t*)row)[2] |((uint32_t*)row)[3])) {
67
/*                row[0] = row[1] = row[2] = row[3] = row[4] =
68
                        row[5] = row[6] = row[7] = 0;*/
69
                return 0;
70
        }
71

    
72
        if(!( ((uint32_t*)row)[2] |((uint32_t*)row)[3] )){
73
                a0 = W4*row[0] + W2*row[2] + (1<<(ROW_SHIFT-1));
74
                a1 = W4*row[0] + W6*row[2] + (1<<(ROW_SHIFT-1));
75
                a2 = W4*row[0] - W6*row[2] + (1<<(ROW_SHIFT-1));
76
                a3 = W4*row[0] - W2*row[2] + (1<<(ROW_SHIFT-1));
77

    
78
                b0 = W1*row[1] + W3*row[3];
79
                b1 = W3*row[1] - W7*row[3];
80
                b2 = W5*row[1] - W1*row[3];
81
                b3 = W7*row[1] - W5*row[3];
82
        }else{
83
                a0 = W4*row[0] + W2*row[2] + W4*row[4] + W6*row[6] + (1<<(ROW_SHIFT-1));
84
                a1 = W4*row[0] + W6*row[2] - W4*row[4] - W2*row[6] + (1<<(ROW_SHIFT-1));
85
                a2 = W4*row[0] - W6*row[2] - W4*row[4] + W2*row[6] + (1<<(ROW_SHIFT-1));
86
                a3 = W4*row[0] - W2*row[2] + W4*row[4] - W6*row[6] + (1<<(ROW_SHIFT-1));
87

    
88
                b0 = W1*row[1] + W3*row[3] + W5*row[5] + W7*row[7];
89
                b1 = W3*row[1] - W7*row[3] - W1*row[5] - W5*row[7];
90
                b2 = W5*row[1] - W1*row[3] + W7*row[5] + W3*row[7];
91
                b3 = W7*row[1] - W5*row[3] + W3*row[5] - W1*row[7];
92
        }
93

    
94
        row[0] = (a0 + b0) >> ROW_SHIFT;
95
        row[1] = (a1 + b1) >> ROW_SHIFT;
96
        row[2] = (a2 + b2) >> ROW_SHIFT;
97
        row[3] = (a3 + b3) >> ROW_SHIFT;
98
        row[4] = (a3 - b3) >> ROW_SHIFT;
99
        row[5] = (a2 - b2) >> ROW_SHIFT;
100
        row[6] = (a1 - b1) >> ROW_SHIFT;
101
        row[7] = (a0 - b0) >> ROW_SHIFT;
102
        
103
        return 1;
104
}
105

    
106
#ifdef ARCH_ALPHA
107
static int inline idctRowCondDC(int16_t *row)
108
{
109
        int_fast32_t a0, a1, a2, a3, b0, b1, b2, b3;
110
        uint64_t *lrow = (uint64_t *) row;
111

    
112
        if (lrow[1] == 0) {
113
                if (lrow[0] == 0)
114
                        return 0;
115
                if ((lrow[0] & ~0xffffULL) == 0) {
116
                        uint64_t v;
117

    
118
                        a0 = W4 * row[0];
119
                        a0 += 1 << (ROW_SHIFT - 1);
120
                        a0 >>= ROW_SHIFT;
121
                        v = (uint16_t) a0;
122
                        v += v << 16;
123
                        v += v << 32;
124
                        lrow[0] = v;
125
                        lrow[1] = v;
126

    
127
                        return 1;
128
                }
129
        }
130

    
131
        a0 = W4 * row[0];
132
        a1 = W4 * row[0];
133
        a2 = W4 * row[0];
134
        a3 = W4 * row[0];
135

    
136
        if (row[2]) {
137
                a0 += W2 * row[2];
138
                a1 += W6 * row[2];
139
                a2 -= W6 * row[2];
140
                a3 -= W2 * row[2];
141
        }
142

    
143
        if (row[4]) {
144
                a0 += W4 * row[4];
145
                a1 -= W4 * row[4];
146
                a2 -= W4 * row[4];
147
                a3 += W4 * row[4];
148
        }
149

    
150
        if (row[6]) {
151
                a0 += W6 * row[6];
152
                a1 -= W2 * row[6];
153
                a2 += W2 * row[6];
154
                a3 -= W6 * row[6];
155
        }
156

    
157
        a0 += 1 << (ROW_SHIFT - 1);
158
        a1 += 1 << (ROW_SHIFT - 1);
159
        a2 += 1 << (ROW_SHIFT - 1);
160
        a3 += 1 << (ROW_SHIFT - 1);
161

    
162
        if (row[1]) {
163
                b0 = W1 * row[1];
164
                b1 = W3 * row[1];
165
                b2 = W5 * row[1];
166
                b3 = W7 * row[1];
167
        } else {
168
                b0 = 0;
169
                b1 = 0;
170
                b2 = 0;
171
                b3 = 0;
172
        }
173

    
174
        if (row[3]) {
175
                b0 += W3 * row[3];
176
                b1 -= W7 * row[3];
177
                b2 -= W1 * row[3];
178
                b3 -= W5 * row[3];
179
        }
180

    
181
        if (row[5]) {
182
                b0 += W5 * row[5];
183
                b1 -= W1 * row[5];
184
                b2 += W7 * row[5];
185
                b3 += W3 * row[5];
186
        }
187

    
188
        if (row[7]) {
189
                b0 += W7 * row[7];
190
                b1 -= W5 * row[7];
191
                b2 += W3 * row[7];
192
                b3 -= W1 * row[7];
193
        }
194

    
195
        row[0] = (a0 + b0) >> ROW_SHIFT;
196
        row[1] = (a1 + b1) >> ROW_SHIFT;
197
        row[2] = (a2 + b2) >> ROW_SHIFT;
198
        row[3] = (a3 + b3) >> ROW_SHIFT;
199
        row[4] = (a3 - b3) >> ROW_SHIFT;
200
        row[5] = (a2 - b2) >> ROW_SHIFT;
201
        row[6] = (a1 - b1) >> ROW_SHIFT;
202
        row[7] = (a0 - b0) >> ROW_SHIFT;
203

    
204
        return 1;
205
}
206
#else  /* not ARCH_ALPHA */
207
static int inline idctRowCondDC (int16_t * row)
208
{
209
        int a0, a1, a2, a3, b0, b1, b2, b3;
210

    
211
        if( !( ((uint32_t*)row)[1] |((uint32_t*)row)[2] |((uint32_t*)row)[3]| row[1])) {
212
//                row[0] = row[1] = row[2] = row[3] = row[4] = row[5] = row[6] = row[7] = row[0]<<3;
213
                uint16_t temp= row[0]<<3;
214
                ((uint32_t*)row)[0]=((uint32_t*)row)[1]=
215
                ((uint32_t*)row)[2]=((uint32_t*)row)[3]= temp + (temp<<16);
216
                return 0;
217
        }
218

    
219
        if(!( ((uint32_t*)row)[2] |((uint32_t*)row)[3] )){
220
                a0 = W4*row[0] + W2*row[2] + (1<<(ROW_SHIFT-1));
221
                a1 = W4*row[0] + W6*row[2] + (1<<(ROW_SHIFT-1));
222
                a2 = W4*row[0] - W6*row[2] + (1<<(ROW_SHIFT-1));
223
                a3 = W4*row[0] - W2*row[2] + (1<<(ROW_SHIFT-1));
224

    
225
                b0 = W1*row[1] + W3*row[3];
226
                b1 = W3*row[1] - W7*row[3];
227
                b2 = W5*row[1] - W1*row[3];
228
                b3 = W7*row[1] - W5*row[3];
229
        }else{
230
                a0 = W4*row[0] + W2*row[2] + W4*row[4] + W6*row[6] + (1<<(ROW_SHIFT-1));
231
                a1 = W4*row[0] + W6*row[2] - W4*row[4] - W2*row[6] + (1<<(ROW_SHIFT-1));
232
                a2 = W4*row[0] - W6*row[2] - W4*row[4] + W2*row[6] + (1<<(ROW_SHIFT-1));
233
                a3 = W4*row[0] - W2*row[2] + W4*row[4] - W6*row[6] + (1<<(ROW_SHIFT-1));
234

    
235
                b0 = W1*row[1] + W3*row[3] + W5*row[5] + W7*row[7];
236
                b1 = W3*row[1] - W7*row[3] - W1*row[5] - W5*row[7];
237
                b2 = W5*row[1] - W1*row[3] + W7*row[5] + W3*row[7];
238
                b3 = W7*row[1] - W5*row[3] + W3*row[5] - W1*row[7];
239
        }
240

    
241
        row[0] = (a0 + b0) >> ROW_SHIFT;
242
        row[7] = (a0 - b0) >> ROW_SHIFT;
243
        row[1] = (a1 + b1) >> ROW_SHIFT;
244
        row[6] = (a1 - b1) >> ROW_SHIFT;
245
        row[2] = (a2 + b2) >> ROW_SHIFT;
246
        row[5] = (a2 - b2) >> ROW_SHIFT;
247
        row[3] = (a3 + b3) >> ROW_SHIFT;
248
        row[4] = (a3 - b3) >> ROW_SHIFT;
249
        
250
        return 1;
251
}
252
#endif /* not ARCH_ALPHA */
253

    
254
static void inline idctCol (int16_t * col)
255
{
256

    
257
/*
258
        if( !(col[8*1] | col[8*2] |col[8*3] |col[8*4] |col[8*5] |col[8*6] | col[8*7])) {
259
                col[8*0] = col[8*1] = col[8*2] = col[8*3] = col[8*4] =
260
                        col[8*5] = col[8*6] = col[8*7] = col[8*0]<<3;
261
                return;
262
        }*/
263

    
264
        int a0, a1, a2, a3, b0, b1, b2, b3;
265
        col[0] += (1<<(COL_SHIFT-1))/W4;
266
        a0 = W4*col[8*0] + W2*col[8*2] + W4*col[8*4] + W6*col[8*6];
267
        a1 = W4*col[8*0] + W6*col[8*2] - W4*col[8*4] - W2*col[8*6];
268
        a2 = W4*col[8*0] - W6*col[8*2] - W4*col[8*4] + W2*col[8*6];
269
        a3 = W4*col[8*0] - W2*col[8*2] + W4*col[8*4] - W6*col[8*6];
270

    
271
        b0 = W1*col[8*1] + W3*col[8*3] + W5*col[8*5] + W7*col[8*7];
272
        b1 = W3*col[8*1] - W7*col[8*3] - W1*col[8*5] - W5*col[8*7];
273
        b2 = W5*col[8*1] - W1*col[8*3] + W7*col[8*5] + W3*col[8*7];
274
        b3 = W7*col[8*1] - W5*col[8*3] + W3*col[8*5] - W1*col[8*7];
275

    
276
        col[8*0] = (a0 + b0) >> COL_SHIFT;
277
        col[8*7] = (a0 - b0) >> COL_SHIFT;
278
        col[8*1] = (a1 + b1) >> COL_SHIFT;
279
        col[8*6] = (a1 - b1) >> COL_SHIFT;
280
        col[8*2] = (a2 + b2) >> COL_SHIFT;
281
        col[8*5] = (a2 - b2) >> COL_SHIFT;
282
        col[8*3] = (a3 + b3) >> COL_SHIFT;
283
        col[8*4] = (a3 - b3) >> COL_SHIFT;
284
}
285

    
286
static void inline idctSparseCol (int16_t * col)
287
{
288
        int a0, a1, a2, a3, b0, b1, b2, b3;
289
        col[0] += (1<<(COL_SHIFT-1))/W4;
290
        a0 = W4*col[8*0];
291
        a1 = W4*col[8*0];
292
        a2 = W4*col[8*0];
293
        a3 = W4*col[8*0];
294

    
295
        if(col[8*2]){
296
                a0 +=  + W2*col[8*2];
297
                a1 +=  + W6*col[8*2];
298
                a2 +=  - W6*col[8*2];
299
                a3 +=  - W2*col[8*2];
300
        }
301

    
302
        if(col[8*4]){
303
                a0 += + W4*col[8*4];
304
                a1 += - W4*col[8*4];
305
                a2 += - W4*col[8*4];
306
                a3 += + W4*col[8*4];
307
        }
308

    
309
        if(col[8*6]){
310
                a0 += + W6*col[8*6];
311
                a1 += - W2*col[8*6];
312
                a2 += + W2*col[8*6];
313
                a3 += - W6*col[8*6];
314
        }
315

    
316
        if(col[8*1]){
317
                b0 = W1*col[8*1];
318
                b1 = W3*col[8*1];
319
                b2 = W5*col[8*1];
320
                b3 = W7*col[8*1];
321
        }else{
322
                b0 = 
323
                b1 = 
324
                b2 = 
325
                b3 = 0;
326
        }
327

    
328
        if(col[8*3]){
329
                b0 += + W3*col[8*3];
330
                b1 += - W7*col[8*3];
331
                b2 += - W1*col[8*3];
332
                b3 += - W5*col[8*3];
333
        }
334

    
335
        if(col[8*5]){
336
                b0 += + W5*col[8*5];
337
                b1 += - W1*col[8*5];
338
                b2 += + W7*col[8*5];
339
                b3 += + W3*col[8*5];
340
        }
341

    
342
        if(col[8*7]){
343
                b0 += + W7*col[8*7];
344
                b1 += - W5*col[8*7];
345
                b2 += + W3*col[8*7];
346
                b3 += - W1*col[8*7];
347
        }
348

    
349
#ifndef ARCH_ALPHA
350
        if(!(b0|b1|b2|b3)){
351
                col[8*0] = (a0) >> COL_SHIFT;
352
                col[8*7] = (a0) >> COL_SHIFT;
353
                col[8*1] = (a1) >> COL_SHIFT;
354
                col[8*6] = (a1) >> COL_SHIFT;
355
                col[8*2] = (a2) >> COL_SHIFT;
356
                col[8*5] = (a2) >> COL_SHIFT;
357
                col[8*3] = (a3) >> COL_SHIFT;
358
                col[8*4] = (a3) >> COL_SHIFT;
359
        }else{
360
#endif
361
                col[8*0] = (a0 + b0) >> COL_SHIFT;
362
                col[8*7] = (a0 - b0) >> COL_SHIFT;
363
                col[8*1] = (a1 + b1) >> COL_SHIFT;
364
                col[8*6] = (a1 - b1) >> COL_SHIFT;
365
                col[8*2] = (a2 + b2) >> COL_SHIFT;
366
                col[8*5] = (a2 - b2) >> COL_SHIFT;
367
                col[8*3] = (a3 + b3) >> COL_SHIFT;
368
                col[8*4] = (a3 - b3) >> COL_SHIFT;
369
#ifndef ARCH_ALPHA
370
        }
371
#endif
372
}
373

    
374
static void inline idctSparse2Col (int16_t * col)
375
{
376
        int a0, a1, a2, a3, b0, b1, b2, b3;
377
        col[0] += (1<<(COL_SHIFT-1))/W4;
378
        a0 = W4*col[8*0];
379
        a1 = W4*col[8*0];
380
        a2 = W4*col[8*0];
381
        a3 = W4*col[8*0];
382

    
383
        if(col[8*2]){
384
                a0 +=  + W2*col[8*2];
385
                a1 +=  + W6*col[8*2];
386
                a2 +=  - W6*col[8*2];
387
                a3 +=  - W2*col[8*2];
388
        }
389

    
390
        if(col[8*4]){
391
                a0 += + W4*col[8*4];
392
                a1 += - W4*col[8*4];
393
                a2 += - W4*col[8*4];
394
                a3 += + W4*col[8*4];
395
        }
396

    
397
        if(col[8*6]){
398
                a0 += + W6*col[8*6];
399
                a1 += - W2*col[8*6];
400
                a2 += + W2*col[8*6];
401
                a3 += - W6*col[8*6];
402
        }
403

    
404
        if(col[8*1] || 1){
405
                b0 = W1*col[8*1];
406
                b1 = W3*col[8*1];
407
                b2 = W5*col[8*1];
408
                b3 = W7*col[8*1];
409
        }else{
410
                b0 = 
411
                b1 = 
412
                b2 = 
413
                b3 = 0;
414
        }
415

    
416
        if(col[8*3]){
417
                b0 += + W3*col[8*3];
418
                b1 += - W7*col[8*3];
419
                b2 += - W1*col[8*3];
420
                b3 += - W5*col[8*3];
421
        }
422

    
423
        if(col[8*5]){
424
                b0 += + W5*col[8*5];
425
                b1 += - W1*col[8*5];
426
                b2 += + W7*col[8*5];
427
                b3 += + W3*col[8*5];
428
        }
429

    
430
        if(col[8*7]){
431
                b0 += + W7*col[8*7];
432
                b1 += - W5*col[8*7];
433
                b2 += + W3*col[8*7];
434
                b3 += - W1*col[8*7];
435
        }
436

    
437
        col[8*0] = (a0 + b0) >> COL_SHIFT;
438
        col[8*7] = (a0 - b0) >> COL_SHIFT;
439
        col[8*1] = (a1 + b1) >> COL_SHIFT;
440
        col[8*6] = (a1 - b1) >> COL_SHIFT;
441
        col[8*2] = (a2 + b2) >> COL_SHIFT;
442
        col[8*5] = (a2 - b2) >> COL_SHIFT;
443
        col[8*3] = (a3 + b3) >> COL_SHIFT;
444
        col[8*4] = (a3 - b3) >> COL_SHIFT;
445
}
446

    
447
#ifdef ARCH_ALPHA
448
/* If all rows but the first one are zero after row transformation,
449
   all rows will be identical after column transformation.  */
450
static inline void idctCol2(int16_t *col)
451
{
452
        int i;
453
        uint64_t l, r;
454
        uint64_t *lcol = (uint64_t *) col;
455

    
456
        for (i = 0; i < 8; ++i) {
457
                int a0 = col[0] + (1 << (COL_SHIFT - 1)) / W4;
458

    
459
                a0 *= W4;
460
                col[0] = a0 >> COL_SHIFT;
461
                ++col;
462
        }
463

    
464
        l = lcol[0];
465
        r = lcol[1];
466
        lcol[ 2] = l; lcol[ 3] = r;
467
        lcol[ 4] = l; lcol[ 5] = r;
468
        lcol[ 6] = l; lcol[ 7] = r;
469
        lcol[ 8] = l; lcol[ 9] = r;
470
        lcol[10] = l; lcol[11] = r;
471
        lcol[12] = l; lcol[13] = r;
472
        lcol[14] = l; lcol[15] = r;
473
}
474
#endif
475

    
476
void simple_idct (short *block)
477
{
478

    
479
        int i;
480
        
481
#if 0
482
        int nonZero[8];
483
        int buffer[64];
484
        int nNonZero=0;
485
        
486
        idctRowCondDC(block);
487
        
488
        for(i=1; i<8; i++)
489
        {
490
                nonZero[nNonZero]=i;
491
                nNonZero+= idctRowCondZ(block + i*8);
492
        }
493
        
494
        if(nNonZero==0)
495
        {
496
                for(i=0; i<8; i++)
497
                {
498
                        block[i   ]=
499
                        block[i+8 ]=
500
                        block[i+16]=
501
                        block[i+24]=
502
                        block[i+32]=
503
                        block[i+40]=
504
                        block[i+48]=
505
                        block[i+56]= (W4*block[i] + (1<<(COL_SHIFT-1))) >> COL_SHIFT;
506
                }        
507
        }
508
        else if(nNonZero==1)
509
        {
510
                int index= nonZero[0]*8;
511
                for(i=0; i<8; i++)
512
                {
513
                        int bias= W4*block[i] + (1<<(COL_SHIFT-1));
514
                        int c= block[i + index];
515
                        block[i   ]= (c*coeff[index  ] + bias) >> COL_SHIFT;
516
                        block[i+8 ]= (c*coeff[index+1] + bias) >> COL_SHIFT;
517
                        block[i+16]= (c*coeff[index+2] + bias) >> COL_SHIFT;
518
                        block[i+24]= (c*coeff[index+3] + bias) >> COL_SHIFT;
519
                        block[i+32]= (c*coeff[index+4] + bias) >> COL_SHIFT;
520
                        block[i+40]= (c*coeff[index+5] + bias) >> COL_SHIFT;
521
                        block[i+48]= (c*coeff[index+6] + bias) >> COL_SHIFT;
522
                        block[i+56]= (c*coeff[index+7] + bias) >> COL_SHIFT;
523
                }        
524
        }
525
/*        else if(nNonZero==2)
526
        {
527
                int index1= nonZero[0]*8;
528
                int index2= nonZero[1]*8;
529
                for(i=0; i<8; i++)
530
                {
531
                        int bias= W4*block[i] + (1<<(COL_SHIFT-1));
532
                        int c1= block[i + index1];
533
                        int c2= block[i + index2];
534
                        block[i   ]= (c1*coeff[index1  ] + c2*coeff[index2  ] + bias) >> COL_SHIFT;
535
                        block[i+8 ]= (c1*coeff[index1+1] + c2*coeff[index2+1] + bias) >> COL_SHIFT;
536
                        block[i+16]= (c1*coeff[index1+2] + c2*coeff[index2+2] + bias) >> COL_SHIFT;
537
                        block[i+24]= (c1*coeff[index1+3] + c2*coeff[index2+3] + bias) >> COL_SHIFT;
538
                        block[i+32]= (c1*coeff[index1+4] + c2*coeff[index2+4] + bias) >> COL_SHIFT;
539
                        block[i+40]= (c1*coeff[index1+5] + c2*coeff[index2+5] + bias) >> COL_SHIFT;
540
                        block[i+48]= (c1*coeff[index1+6] + c2*coeff[index2+6] + bias) >> COL_SHIFT;
541
                        block[i+56]= (c1*coeff[index1+7] + c2*coeff[index2+7] + bias) >> COL_SHIFT;
542
                }        
543
        }*/
544
        else
545
        {
546
                for(i=0; i<8; i++)
547
                        idctSparse2Col(block + i);
548
        }
549
#elif defined(ARCH_ALPHA)
550
        int shortcut = 1;
551

    
552
        for (i = 0; i < 8; i++) {
553
                int anynonzero = idctRowCondDC(block + 8 * i);
554
                if (i > 0 && anynonzero)
555
                        shortcut = 0;
556
        }
557

    
558
        if (shortcut) {
559
                idctCol2(block);
560
        } else {
561
                for (i = 0; i < 8; i++)
562
                        idctSparseCol(block + i);
563
        }
564
#else
565
        for(i=0; i<8; i++)
566
                idctRowCondDC(block + i*8);
567
        
568
        for(i=0; i<8; i++)
569
                idctSparseCol(block + i);
570
#endif
571
}