Revision 1e98dffb libavcodec/simple_idct.c
libavcodec/simple_idct.c  

23  23 
#include <inttypes.h> 
24  24  
25  25 
#include "simple_idct.h" 
26 
#include "../config.h" 

26  27  
27  28 
#if 0 
28  29 
#define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */ 
...  ...  
102  103 
return 1; 
103  104 
} 
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 */ 

105  207 
static int inline idctRowCondDC (int16_t * row) 
106  208 
{ 
107  209 
int a0, a1, a2, a3, b0, b1, b2, b3; 
...  ...  
147  249 

148  250 
return 1; 
149  251 
} 
252 
#endif /* not ARCH_ALPHA */ 

150  253  
151  254 
static void inline idctCol (int16_t * col) 
152  255 
{ 
...  ...  
243  346 
b3 +=  W1*col[8*7]; 
244  347 
} 
245  348  
349 
#ifndef ARCH_ALPHA 

246  350 
if(!(b0b1b2b3)){ 
247  351 
col[8*0] = (a0) >> COL_SHIFT; 
248  352 
col[8*7] = (a0) >> COL_SHIFT; 
...  ...  
253  357 
col[8*3] = (a3) >> COL_SHIFT; 
254  358 
col[8*4] = (a3) >> COL_SHIFT; 
255  359 
}else{ 
360 
#endif 

256  361 
col[8*0] = (a0 + b0) >> COL_SHIFT; 
257  362 
col[8*7] = (a0  b0) >> COL_SHIFT; 
258  363 
col[8*1] = (a1 + b1) >> COL_SHIFT; 
...  ...  
261  366 
col[8*5] = (a2  b2) >> COL_SHIFT; 
262  367 
col[8*3] = (a3 + b3) >> COL_SHIFT; 
263  368 
col[8*4] = (a3  b3) >> COL_SHIFT; 
369 
#ifndef ARCH_ALPHA 

264  370 
} 
371 
#endif 

265  372 
} 
266  373  
267  374 
static void inline idctSparse2Col (int16_t * col) 
...  ...  
337  444 
col[8*4] = (a3  b3) >> COL_SHIFT; 
338  445 
} 
339  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 

340  475  
341  476 
void simple_idct (short *block) 
342  477 
{ 
...  ...  
411  546 
for(i=0; i<8; i++) 
412  547 
idctSparse2Col(block + i); 
413  548 
} 
414 
#else 

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 

415  565 
for(i=0; i<8; i++) 
416  566 
idctRowCondDC(block + i*8); 
417  567 

Also available in: Unified diff