4 * Copyright (c) 2001 Michael Niedermayer <michaelni@gmx.at>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 based upon some outcommented c code from mpeg2dec (idct_mmx.c
22 written by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>)
26 #include "simple_idct.h"
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) */
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 16383 //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
47 #define COL_SHIFT 20 // 6
54 #if defined(ARCH_POWERPC_405)
56 /* signed 16x16 -> 32 multiply add accumulate */
57 #define MAC16(rt, ra, rb) \
58 asm ("maclhw %0, %2, %3" : "=r" (rt) : "0" (rt), "r" (ra), "r" (rb));
60 /* signed 16x16 -> 32 multiply */
61 #define MUL16(rt, ra, rb) \
62 asm ("mullhw %0, %1, %2" : "=r" (rt) : "r" (ra), "r" (rb));
66 /* signed 16x16 -> 32 multiply add accumulate */
67 #define MAC16(rt, ra, rb) rt += (ra) * (rb)
69 /* signed 16x16 -> 32 multiply */
70 #define MUL16(rt, ra, rb) rt = (ra) * (rb)
75 /* 0: all entries 0, 1: only first entry nonzero, 2: otherwise */
76 static inline int idctRowCondDC(int16_t *row)
78 int_fast32_t a0, a1, a2, a3, b0, b1, b2, b3;
79 uint64_t *lrow = (uint64_t *) row;
84 if ((lrow[0] & ~0xffffULL) == 0) {
88 a0 += 1 << (ROW_SHIFT - 1);
100 a0 = (W4 * row[0]) + (1 << (ROW_SHIFT - 1));
159 row[0] = (a0 + b0) >> ROW_SHIFT;
160 row[1] = (a1 + b1) >> ROW_SHIFT;
161 row[2] = (a2 + b2) >> ROW_SHIFT;
162 row[3] = (a3 + b3) >> ROW_SHIFT;
163 row[4] = (a3 - b3) >> ROW_SHIFT;
164 row[5] = (a2 - b2) >> ROW_SHIFT;
165 row[6] = (a1 - b1) >> ROW_SHIFT;
166 row[7] = (a0 - b0) >> ROW_SHIFT;
170 #else /* not ARCH_ALPHA */
172 static inline void idctRowCondDC (int16_t * row)
174 int a0, a1, a2, a3, b0, b1, b2, b3;
182 #ifdef WORDS_BIGENDIAN
183 #define ROW0_MASK 0xffff000000000000LL
185 #define ROW0_MASK 0xffffLL
187 if ( ((((uint64_t *)row)[0] & ~ROW0_MASK) |
188 ((uint64_t *)row)[1]) == 0) {
189 temp = (row[0] << 3) & 0xffff;
192 ((uint64_t *)row)[0] = temp;
193 ((uint64_t *)row)[1] = temp;
197 if (!(((uint32_t*)row)[1] |
198 ((uint32_t*)row)[2] |
199 ((uint32_t*)row)[3] |
201 temp = (row[0] << 3) & 0xffff;
203 ((uint32_t*)row)[0]=((uint32_t*)row)[1] =
204 ((uint32_t*)row)[2]=((uint32_t*)row)[3] = temp;
209 a0 = (W4 * row[0]) + (1 << (ROW_SHIFT - 1));
214 /* no need to optimize : gcc does it */
220 MUL16(b0, W1, row[1]);
221 MAC16(b0, W3, row[3]);
222 MUL16(b1, W3, row[1]);
223 MAC16(b1, -W7, row[3]);
224 MUL16(b2, W5, row[1]);
225 MAC16(b2, -W1, row[3]);
226 MUL16(b3, W7, row[1]);
227 MAC16(b3, -W5, row[3]);
230 temp = ((uint64_t*)row)[1];
232 temp = ((uint32_t*)row)[2] | ((uint32_t*)row)[3];
235 a0 += W4*row[4] + W6*row[6];
236 a1 += - W4*row[4] - W2*row[6];
237 a2 += - W4*row[4] + W2*row[6];
238 a3 += W4*row[4] - W6*row[6];
240 MAC16(b0, W5, row[5]);
241 MAC16(b0, W7, row[7]);
243 MAC16(b1, -W1, row[5]);
244 MAC16(b1, -W5, row[7]);
246 MAC16(b2, W7, row[5]);
247 MAC16(b2, W3, row[7]);
249 MAC16(b3, W3, row[5]);
250 MAC16(b3, -W1, row[7]);
253 row[0] = (a0 + b0) >> ROW_SHIFT;
254 row[7] = (a0 - b0) >> ROW_SHIFT;
255 row[1] = (a1 + b1) >> ROW_SHIFT;
256 row[6] = (a1 - b1) >> ROW_SHIFT;
257 row[2] = (a2 + b2) >> ROW_SHIFT;
258 row[5] = (a2 - b2) >> ROW_SHIFT;
259 row[3] = (a3 + b3) >> ROW_SHIFT;
260 row[4] = (a3 - b3) >> ROW_SHIFT;
262 #endif /* not ARCH_ALPHA */
264 static inline void idctSparseColPut (UINT8 *dest, int line_size,
267 int a0, a1, a2, a3, b0, b1, b2, b3;
268 UINT8 *cm = cropTbl + MAX_NEG_CROP;
270 /* XXX: I did that only to give same values as previous code */
271 a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
281 MUL16(b0, W1, col[8*1]);
282 MUL16(b1, W3, col[8*1]);
283 MUL16(b2, W5, col[8*1]);
284 MUL16(b3, W7, col[8*1]);
286 MAC16(b0, + W3, col[8*3]);
287 MAC16(b1, - W7, col[8*3]);
288 MAC16(b2, - W1, col[8*3]);
289 MAC16(b3, - W5, col[8*3]);
299 MAC16(b0, + W5, col[8*5]);
300 MAC16(b1, - W1, col[8*5]);
301 MAC16(b2, + W7, col[8*5]);
302 MAC16(b3, + W3, col[8*5]);
313 MAC16(b0, + W7, col[8*7]);
314 MAC16(b1, - W5, col[8*7]);
315 MAC16(b2, + W3, col[8*7]);
316 MAC16(b3, - W1, col[8*7]);
319 dest[0] = cm[(a0 + b0) >> COL_SHIFT];
321 dest[0] = cm[(a1 + b1) >> COL_SHIFT];
323 dest[0] = cm[(a2 + b2) >> COL_SHIFT];
325 dest[0] = cm[(a3 + b3) >> COL_SHIFT];
327 dest[0] = cm[(a3 - b3) >> COL_SHIFT];
329 dest[0] = cm[(a2 - b2) >> COL_SHIFT];
331 dest[0] = cm[(a1 - b1) >> COL_SHIFT];
333 dest[0] = cm[(a0 - b0) >> COL_SHIFT];
336 static inline void idctSparseColAdd (UINT8 *dest, int line_size,
339 int a0, a1, a2, a3, b0, b1, b2, b3;
340 UINT8 *cm = cropTbl + MAX_NEG_CROP;
342 /* XXX: I did that only to give same values as previous code */
343 a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
353 MUL16(b0, W1, col[8*1]);
354 MUL16(b1, W3, col[8*1]);
355 MUL16(b2, W5, col[8*1]);
356 MUL16(b3, W7, col[8*1]);
358 MAC16(b0, + W3, col[8*3]);
359 MAC16(b1, - W7, col[8*3]);
360 MAC16(b2, - W1, col[8*3]);
361 MAC16(b3, - W5, col[8*3]);
371 MAC16(b0, + W5, col[8*5]);
372 MAC16(b1, - W1, col[8*5]);
373 MAC16(b2, + W7, col[8*5]);
374 MAC16(b3, + W3, col[8*5]);
385 MAC16(b0, + W7, col[8*7]);
386 MAC16(b1, - W5, col[8*7]);
387 MAC16(b2, + W3, col[8*7]);
388 MAC16(b3, - W1, col[8*7]);
391 dest[0] = cm[dest[0] + ((a0 + b0) >> COL_SHIFT)];
393 dest[0] = cm[dest[0] + ((a1 + b1) >> COL_SHIFT)];
395 dest[0] = cm[dest[0] + ((a2 + b2) >> COL_SHIFT)];
397 dest[0] = cm[dest[0] + ((a3 + b3) >> COL_SHIFT)];
399 dest[0] = cm[dest[0] + ((a3 - b3) >> COL_SHIFT)];
401 dest[0] = cm[dest[0] + ((a2 - b2) >> COL_SHIFT)];
403 dest[0] = cm[dest[0] + ((a1 - b1) >> COL_SHIFT)];
405 dest[0] = cm[dest[0] + ((a0 - b0) >> COL_SHIFT)];
409 /* If all rows but the first one are zero after row transformation,
410 all rows will be identical after column transformation. */
411 static inline void idctCol2(int16_t *col)
415 uint64_t *lcol = (uint64_t *) col;
417 for (i = 0; i < 8; ++i) {
418 int a0 = col[0] + (1 << (COL_SHIFT - 1)) / W4;
421 col[0] = a0 >> COL_SHIFT;
427 lcol[ 2] = l; lcol[ 3] = r;
428 lcol[ 4] = l; lcol[ 5] = r;
429 lcol[ 6] = l; lcol[ 7] = r;
430 lcol[ 8] = l; lcol[ 9] = r;
431 lcol[10] = l; lcol[11] = r;
432 lcol[12] = l; lcol[13] = r;
433 lcol[14] = l; lcol[15] = r;
436 void simple_idct (short *block)
440 int rowsZero = 1; /* all rows except row 0 zero */
441 int rowsConstant = 1; /* all rows consist of a constant value */
443 for (i = 0; i < 8; i++) {
444 int sparseness = idctRowCondDC(block + 8 * i);
446 if (i > 0 && sparseness > 0)
454 } else if (rowsConstant) {
455 uint64_t *lblock = (uint64_t *) block;
457 idctSparseCol(block);
458 for (i = 0; i < 8; i++) {
459 uint64_t v = (uint16_t) block[i * 8];
468 for (i = 0; i < 8; i++)
469 idctSparseCol(block + i);
473 /* XXX: suppress this mess */
474 void simple_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
477 put_pixels_clamped(block, dest, line_size);
480 void simple_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
483 add_pixels_clamped(block, dest, line_size);
488 void simple_idct_put(UINT8 *dest, int line_size, INT16 *block)
492 idctRowCondDC(block + i*8);
495 idctSparseColPut(dest + i, line_size, block + i);
498 void simple_idct_add(UINT8 *dest, int line_size, INT16 *block)
502 idctRowCondDC(block + i*8);
505 idctSparseColAdd(dest + i, line_size, block + i);