← Back to branch summary

~siretart/libav/merge.raring.libav-0.8.6

« back to all changes in this revision

Viewing changes to libavcodec/simple_idct.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2012-01-12 22:30:00 UTC
  • mfrom: (1.4.1)
  • mto: (1.3.11 sid) (26.1.1 quantal-security)
  • mto: This revision was merged to the branch mainline in revision 15.
  • Revision ID: package-import@ubuntu.com-20120112223000-s1reiy1e28hnix42
Tags: upstream-0.8~beta2
Import upstream version 0.8~beta2

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/simple_idct.c
25
25
 * simpleidct in C.
26
26
 */
27
27
 
28
 
/*
29
 
  based upon some outcommented c code from mpeg2dec (idct_mmx.c
30
 
  written by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>)
31
 
 */
 
28
#include "libavutil/intreadwrite.h"
32
29
#include "avcodec.h"
33
30
#include "dsputil.h"
34
31
#include "mathops.h"
35
32
#include "simple_idct.h"
36
33
 
37
 
#if 0
38
 
#define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */
39
 
#define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */
40
 
#define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */
41
 
#define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */
42
 
#define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */
43
 
#define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */
44
 
#define W7 565  /* 2048*sqrt (2)*cos (7*pi/16) */
45
 
#define ROW_SHIFT 8
46
 
#define COL_SHIFT 17
47
 
#else
48
 
#define W1  22725  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
49
 
#define W2  21407  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
50
 
#define W3  19266  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
51
 
#define W4  16383  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
52
 
#define W5  12873  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
53
 
#define W6  8867   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
54
 
#define W7  4520   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
55
 
#define ROW_SHIFT 11
56
 
#define COL_SHIFT 20 // 6
57
 
#endif
58
 
 
59
 
static inline void idctRowCondDC (DCTELEM * row)
60
 
{
61
 
        int a0, a1, a2, a3, b0, b1, b2, b3;
62
 
#if HAVE_FAST_64BIT
63
 
        uint64_t temp;
64
 
#else
65
 
        uint32_t temp;
66
 
#endif
67
 
 
68
 
#if HAVE_FAST_64BIT
69
 
#if HAVE_BIGENDIAN
70
 
#define ROW0_MASK 0xffff000000000000LL
71
 
#else
72
 
#define ROW0_MASK 0xffffLL
73
 
#endif
74
 
        if(sizeof(DCTELEM)==2){
75
 
            if ( ((((uint64_t *)row)[0] & ~ROW0_MASK) |
76
 
                  ((uint64_t *)row)[1]) == 0) {
77
 
                temp = (row[0] << 3) & 0xffff;
78
 
                temp += temp << 16;
79
 
                temp += temp << 32;
80
 
                ((uint64_t *)row)[0] = temp;
81
 
                ((uint64_t *)row)[1] = temp;
82
 
                return;
83
 
            }
84
 
        }else{
85
 
            if (!(row[1]|row[2]|row[3]|row[4]|row[5]|row[6]|row[7])) {
86
 
                row[0]=row[1]=row[2]=row[3]=row[4]=row[5]=row[6]=row[7]= row[0] << 3;
87
 
                return;
88
 
            }
89
 
        }
90
 
#else
91
 
        if(sizeof(DCTELEM)==2){
92
 
            if (!(((uint32_t*)row)[1] |
93
 
                  ((uint32_t*)row)[2] |
94
 
                  ((uint32_t*)row)[3] |
95
 
                  row[1])) {
96
 
                temp = (row[0] << 3) & 0xffff;
97
 
                temp += temp << 16;
98
 
                ((uint32_t*)row)[0]=((uint32_t*)row)[1] =
99
 
                ((uint32_t*)row)[2]=((uint32_t*)row)[3] = temp;
100
 
                return;
101
 
            }
102
 
        }else{
103
 
            if (!(row[1]|row[2]|row[3]|row[4]|row[5]|row[6]|row[7])) {
104
 
                row[0]=row[1]=row[2]=row[3]=row[4]=row[5]=row[6]=row[7]= row[0] << 3;
105
 
                return;
106
 
            }
107
 
        }
108
 
#endif
109
 
 
110
 
        a0 = (W4 * row[0]) + (1 << (ROW_SHIFT - 1));
111
 
        a1 = a0;
112
 
        a2 = a0;
113
 
        a3 = a0;
114
 
 
115
 
        /* no need to optimize : gcc does it */
116
 
        a0 += W2 * row[2];
117
 
        a1 += W6 * row[2];
118
 
        a2 -= W6 * row[2];
119
 
        a3 -= W2 * row[2];
120
 
 
121
 
        b0 = MUL16(W1, row[1]);
122
 
        MAC16(b0, W3, row[3]);
123
 
        b1 = MUL16(W3, row[1]);
124
 
        MAC16(b1, -W7, row[3]);
125
 
        b2 = MUL16(W5, row[1]);
126
 
        MAC16(b2, -W1, row[3]);
127
 
        b3 = MUL16(W7, row[1]);
128
 
        MAC16(b3, -W5, row[3]);
129
 
 
130
 
#if HAVE_FAST_64BIT
131
 
        temp = ((uint64_t*)row)[1];
132
 
#else
133
 
        temp = ((uint32_t*)row)[2] | ((uint32_t*)row)[3];
134
 
#endif
135
 
        if (temp != 0) {
136
 
            a0 += W4*row[4] + W6*row[6];
137
 
            a1 += - W4*row[4] - W2*row[6];
138
 
            a2 += - W4*row[4] + W2*row[6];
139
 
            a3 += W4*row[4] - W6*row[6];
140
 
 
141
 
            MAC16(b0, W5, row[5]);
142
 
            MAC16(b0, W7, row[7]);
143
 
 
144
 
            MAC16(b1, -W1, row[5]);
145
 
            MAC16(b1, -W5, row[7]);
146
 
 
147
 
            MAC16(b2, W7, row[5]);
148
 
            MAC16(b2, W3, row[7]);
149
 
 
150
 
            MAC16(b3, W3, row[5]);
151
 
            MAC16(b3, -W1, row[7]);
152
 
        }
153
 
 
154
 
        row[0] = (a0 + b0) >> ROW_SHIFT;
155
 
        row[7] = (a0 - b0) >> ROW_SHIFT;
156
 
        row[1] = (a1 + b1) >> ROW_SHIFT;
157
 
        row[6] = (a1 - b1) >> ROW_SHIFT;
158
 
        row[2] = (a2 + b2) >> ROW_SHIFT;
159
 
        row[5] = (a2 - b2) >> ROW_SHIFT;
160
 
        row[3] = (a3 + b3) >> ROW_SHIFT;
161
 
        row[4] = (a3 - b3) >> ROW_SHIFT;
162
 
}
163
 
 
164
 
static inline void idctSparseColPut (uint8_t *dest, int line_size,
165
 
                                     DCTELEM * col)
166
 
{
167
 
        int a0, a1, a2, a3, b0, b1, b2, b3;
168
 
        uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
169
 
 
170
 
        /* XXX: I did that only to give same values as previous code */
171
 
        a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
172
 
        a1 = a0;
173
 
        a2 = a0;
174
 
        a3 = a0;
175
 
 
176
 
        a0 +=  + W2*col[8*2];
177
 
        a1 +=  + W6*col[8*2];
178
 
        a2 +=  - W6*col[8*2];
179
 
        a3 +=  - W2*col[8*2];
180
 
 
181
 
        b0 = MUL16(W1, col[8*1]);
182
 
        b1 = MUL16(W3, col[8*1]);
183
 
        b2 = MUL16(W5, col[8*1]);
184
 
        b3 = MUL16(W7, col[8*1]);
185
 
 
186
 
        MAC16(b0, + W3, col[8*3]);
187
 
        MAC16(b1, - W7, col[8*3]);
188
 
        MAC16(b2, - W1, col[8*3]);
189
 
        MAC16(b3, - W5, col[8*3]);
190
 
 
191
 
        if(col[8*4]){
192
 
            a0 += + W4*col[8*4];
193
 
            a1 += - W4*col[8*4];
194
 
            a2 += - W4*col[8*4];
195
 
            a3 += + W4*col[8*4];
196
 
        }
197
 
 
198
 
        if (col[8*5]) {
199
 
            MAC16(b0, + W5, col[8*5]);
200
 
            MAC16(b1, - W1, col[8*5]);
201
 
            MAC16(b2, + W7, col[8*5]);
202
 
            MAC16(b3, + W3, col[8*5]);
203
 
        }
204
 
 
205
 
        if(col[8*6]){
206
 
            a0 += + W6*col[8*6];
207
 
            a1 += - W2*col[8*6];
208
 
            a2 += + W2*col[8*6];
209
 
            a3 += - W6*col[8*6];
210
 
        }
211
 
 
212
 
        if (col[8*7]) {
213
 
            MAC16(b0, + W7, col[8*7]);
214
 
            MAC16(b1, - W5, col[8*7]);
215
 
            MAC16(b2, + W3, col[8*7]);
216
 
            MAC16(b3, - W1, col[8*7]);
217
 
        }
218
 
 
219
 
        dest[0] = cm[(a0 + b0) >> COL_SHIFT];
220
 
        dest += line_size;
221
 
        dest[0] = cm[(a1 + b1) >> COL_SHIFT];
222
 
        dest += line_size;
223
 
        dest[0] = cm[(a2 + b2) >> COL_SHIFT];
224
 
        dest += line_size;
225
 
        dest[0] = cm[(a3 + b3) >> COL_SHIFT];
226
 
        dest += line_size;
227
 
        dest[0] = cm[(a3 - b3) >> COL_SHIFT];
228
 
        dest += line_size;
229
 
        dest[0] = cm[(a2 - b2) >> COL_SHIFT];
230
 
        dest += line_size;
231
 
        dest[0] = cm[(a1 - b1) >> COL_SHIFT];
232
 
        dest += line_size;
233
 
        dest[0] = cm[(a0 - b0) >> COL_SHIFT];
234
 
}
235
 
 
236
 
static inline void idctSparseColAdd (uint8_t *dest, int line_size,
237
 
                                     DCTELEM * col)
238
 
{
239
 
        int a0, a1, a2, a3, b0, b1, b2, b3;
240
 
        uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
241
 
 
242
 
        /* XXX: I did that only to give same values as previous code */
243
 
        a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
244
 
        a1 = a0;
245
 
        a2 = a0;
246
 
        a3 = a0;
247
 
 
248
 
        a0 +=  + W2*col[8*2];
249
 
        a1 +=  + W6*col[8*2];
250
 
        a2 +=  - W6*col[8*2];
251
 
        a3 +=  - W2*col[8*2];
252
 
 
253
 
        b0 = MUL16(W1, col[8*1]);
254
 
        b1 = MUL16(W3, col[8*1]);
255
 
        b2 = MUL16(W5, col[8*1]);
256
 
        b3 = MUL16(W7, col[8*1]);
257
 
 
258
 
        MAC16(b0, + W3, col[8*3]);
259
 
        MAC16(b1, - W7, col[8*3]);
260
 
        MAC16(b2, - W1, col[8*3]);
261
 
        MAC16(b3, - W5, col[8*3]);
262
 
 
263
 
        if(col[8*4]){
264
 
            a0 += + W4*col[8*4];
265
 
            a1 += - W4*col[8*4];
266
 
            a2 += - W4*col[8*4];
267
 
            a3 += + W4*col[8*4];
268
 
        }
269
 
 
270
 
        if (col[8*5]) {
271
 
            MAC16(b0, + W5, col[8*5]);
272
 
            MAC16(b1, - W1, col[8*5]);
273
 
            MAC16(b2, + W7, col[8*5]);
274
 
            MAC16(b3, + W3, col[8*5]);
275
 
        }
276
 
 
277
 
        if(col[8*6]){
278
 
            a0 += + W6*col[8*6];
279
 
            a1 += - W2*col[8*6];
280
 
            a2 += + W2*col[8*6];
281
 
            a3 += - W6*col[8*6];
282
 
        }
283
 
 
284
 
        if (col[8*7]) {
285
 
            MAC16(b0, + W7, col[8*7]);
286
 
            MAC16(b1, - W5, col[8*7]);
287
 
            MAC16(b2, + W3, col[8*7]);
288
 
            MAC16(b3, - W1, col[8*7]);
289
 
        }
290
 
 
291
 
        dest[0] = cm[dest[0] + ((a0 + b0) >> COL_SHIFT)];
292
 
        dest += line_size;
293
 
        dest[0] = cm[dest[0] + ((a1 + b1) >> COL_SHIFT)];
294
 
        dest += line_size;
295
 
        dest[0] = cm[dest[0] + ((a2 + b2) >> COL_SHIFT)];
296
 
        dest += line_size;
297
 
        dest[0] = cm[dest[0] + ((a3 + b3) >> COL_SHIFT)];
298
 
        dest += line_size;
299
 
        dest[0] = cm[dest[0] + ((a3 - b3) >> COL_SHIFT)];
300
 
        dest += line_size;
301
 
        dest[0] = cm[dest[0] + ((a2 - b2) >> COL_SHIFT)];
302
 
        dest += line_size;
303
 
        dest[0] = cm[dest[0] + ((a1 - b1) >> COL_SHIFT)];
304
 
        dest += line_size;
305
 
        dest[0] = cm[dest[0] + ((a0 - b0) >> COL_SHIFT)];
306
 
}
307
 
 
308
 
static inline void idctSparseCol (DCTELEM * col)
309
 
{
310
 
        int a0, a1, a2, a3, b0, b1, b2, b3;
311
 
 
312
 
        /* XXX: I did that only to give same values as previous code */
313
 
        a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
314
 
        a1 = a0;
315
 
        a2 = a0;
316
 
        a3 = a0;
317
 
 
318
 
        a0 +=  + W2*col[8*2];
319
 
        a1 +=  + W6*col[8*2];
320
 
        a2 +=  - W6*col[8*2];
321
 
        a3 +=  - W2*col[8*2];
322
 
 
323
 
        b0 = MUL16(W1, col[8*1]);
324
 
        b1 = MUL16(W3, col[8*1]);
325
 
        b2 = MUL16(W5, col[8*1]);
326
 
        b3 = MUL16(W7, col[8*1]);
327
 
 
328
 
        MAC16(b0, + W3, col[8*3]);
329
 
        MAC16(b1, - W7, col[8*3]);
330
 
        MAC16(b2, - W1, col[8*3]);
331
 
        MAC16(b3, - W5, col[8*3]);
332
 
 
333
 
        if(col[8*4]){
334
 
            a0 += + W4*col[8*4];
335
 
            a1 += - W4*col[8*4];
336
 
            a2 += - W4*col[8*4];
337
 
            a3 += + W4*col[8*4];
338
 
        }
339
 
 
340
 
        if (col[8*5]) {
341
 
            MAC16(b0, + W5, col[8*5]);
342
 
            MAC16(b1, - W1, col[8*5]);
343
 
            MAC16(b2, + W7, col[8*5]);
344
 
            MAC16(b3, + W3, col[8*5]);
345
 
        }
346
 
 
347
 
        if(col[8*6]){
348
 
            a0 += + W6*col[8*6];
349
 
            a1 += - W2*col[8*6];
350
 
            a2 += + W2*col[8*6];
351
 
            a3 += - W6*col[8*6];
352
 
        }
353
 
 
354
 
        if (col[8*7]) {
355
 
            MAC16(b0, + W7, col[8*7]);
356
 
            MAC16(b1, - W5, col[8*7]);
357
 
            MAC16(b2, + W3, col[8*7]);
358
 
            MAC16(b3, - W1, col[8*7]);
359
 
        }
360
 
 
361
 
        col[0 ] = ((a0 + b0) >> COL_SHIFT);
362
 
        col[8 ] = ((a1 + b1) >> COL_SHIFT);
363
 
        col[16] = ((a2 + b2) >> COL_SHIFT);
364
 
        col[24] = ((a3 + b3) >> COL_SHIFT);
365
 
        col[32] = ((a3 - b3) >> COL_SHIFT);
366
 
        col[40] = ((a2 - b2) >> COL_SHIFT);
367
 
        col[48] = ((a1 - b1) >> COL_SHIFT);
368
 
        col[56] = ((a0 - b0) >> COL_SHIFT);
369
 
}
370
 
 
371
 
void ff_simple_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
372
 
{
373
 
    int i;
374
 
    for(i=0; i<8; i++)
375
 
        idctRowCondDC(block + i*8);
376
 
 
377
 
    for(i=0; i<8; i++)
378
 
        idctSparseColPut(dest + i, line_size, block + i);
379
 
}
380
 
 
381
 
void ff_simple_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
382
 
{
383
 
    int i;
384
 
    for(i=0; i<8; i++)
385
 
        idctRowCondDC(block + i*8);
386
 
 
387
 
    for(i=0; i<8; i++)
388
 
        idctSparseColAdd(dest + i, line_size, block + i);
389
 
}
390
 
 
391
 
void ff_simple_idct(DCTELEM *block)
392
 
{
393
 
    int i;
394
 
    for(i=0; i<8; i++)
395
 
        idctRowCondDC(block + i*8);
396
 
 
397
 
    for(i=0; i<8; i++)
398
 
        idctSparseCol(block + i);
399
 
}
 
34
#define BIT_DEPTH 8
 
35
#include "simple_idct_template.c"
 
36
#undef BIT_DEPTH
 
37
 
 
38
#define BIT_DEPTH 10
 
39
#include "simple_idct_template.c"
 
40
#undef BIT_DEPTH
400
41
 
401
42
/* 2x4x8 idct */
402
43
 
467
108
 
468
109
    /* IDCT8 on each line */
469
110
    for(i=0; i<8; i++) {
470
 
        idctRowCondDC(block + i*8);
 
111
        idctRowCondDC_8(block + i*8, 0);
471
112
    }
472
113
 
473
114
    /* IDCT4 and store */
542
183
 
543
184
    /* IDCT8 on each line */
544
185
    for(i=0; i<4; i++) {
545
 
        idctRowCondDC(block + i*8);
 
186
        idctRowCondDC_8(block + i*8, 0);
546
187
    }
547
188
 
548
189
    /* IDCT4 and store */
562
203
 
563
204
    /* IDCT8 and store */
564
205
    for(i=0; i<4; i++){
565
 
        idctSparseColAdd(dest + i, line_size, block + i);
 
206
        idctSparseColAdd_8(dest + i, line_size, block + i);
566
207
    }
567
208
}
568
209
 
580
221
        idct4col_add(dest + i, line_size, block + i);
581
222
    }
582
223
}
 
224
 
 
225
void ff_prores_idct(DCTELEM *block, const int16_t *qmat)
 
226
{
 
227
    int i;
 
228
 
 
229
    for (i = 0; i < 64; i++)
 
230
        block[i] *= qmat[i];
 
231
 
 
232
    for (i = 0; i < 8; i++)
 
233
        idctRowCondDC_10(block + i*8, 2);
 
234
 
 
235
    for (i = 0; i < 8; i++)
 
236
        idctSparseCol_10(block + i);
 
237
}