ffmpeg / libavcodec / dsputil.c @ 05f361f0
History  View  Annotate  Download (20.4 KB)
1 
/*


2 
* DSP utils

3 
* Copyright (c) 2000, 2001 Gerard Lantau.

4 
*

5 
* This program is free software; you can redistribute it and/or modify

6 
* it under the terms of the GNU General Public License as published by

7 
* the Free Software Foundation; either version 2 of the License, or

8 
* (at your option) any later version.

9 
*

10 
* This program is distributed in the hope that it will be useful,

11 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

12 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

13 
* GNU General Public License for more details.

14 
*

15 
* You should have received a copy of the GNU General Public License

16 
* along with this program; if not, write to the Free Software

17 
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

18 
*/

19 
#include <stdlib.h> 
20 
#include <stdio.h> 
21 
#include "avcodec.h" 
22 
#include "dsputil.h" 
23 
#include "simple_idct.h" 
24  
25 
void (*ff_idct)(DCTELEM *block);

26 
void (*get_pixels)(DCTELEM *block, const UINT8 *pixels, int line_size); 
27 
void (*put_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size); 
28 
void (*add_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size); 
29  
30 
op_pixels_abs_func pix_abs16x16; 
31 
op_pixels_abs_func pix_abs16x16_x2; 
32 
op_pixels_abs_func pix_abs16x16_y2; 
33 
op_pixels_abs_func pix_abs16x16_xy2; 
34  
35 
UINT8 cropTbl[256 + 2 * MAX_NEG_CROP]; 
36 
UINT32 squareTbl[512];

37  
38 
extern UINT16 default_intra_matrix[64]; 
39 
extern UINT16 default_non_intra_matrix[64]; 
40  
41 
UINT8 zigzag_direct[64] = {

42 
0, 1, 8, 16, 9, 2, 3, 10, 
43 
17, 24, 32, 25, 18, 11, 4, 5, 
44 
12, 19, 26, 33, 40, 48, 41, 34, 
45 
27, 20, 13, 6, 7, 14, 21, 28, 
46 
35, 42, 49, 56, 57, 50, 43, 36, 
47 
29, 22, 15, 23, 30, 37, 44, 51, 
48 
58, 59, 52, 45, 38, 31, 39, 46, 
49 
53, 60, 61, 54, 47, 55, 62, 63 
50 
}; 
51  
52 
UINT8 ff_alternate_horizontal_scan[64] = {

53 
0, 1, 2, 3, 8, 9, 16, 17, 
54 
10, 11, 4, 5, 6, 7, 15, 14, 
55 
13, 12, 19, 18, 24, 25, 32, 33, 
56 
26, 27, 20, 21, 22, 23, 28, 29, 
57 
30, 31, 34, 35, 40, 41, 48, 49, 
58 
42, 43, 36, 37, 38, 39, 44, 45, 
59 
46, 47, 50, 51, 56, 57, 58, 59, 
60 
52, 53, 54, 55, 60, 61, 62, 63, 
61 
}; 
62  
63 
UINT8 ff_alternate_vertical_scan[64] = {

64 
0, 8, 16, 24, 1, 9, 2, 10, 
65 
17, 25, 32, 40, 48, 56, 57, 49, 
66 
41, 33, 26, 18, 3, 11, 4, 12, 
67 
19, 27, 34, 42, 50, 58, 35, 43, 
68 
51, 59, 20, 28, 5, 13, 6, 14, 
69 
21, 29, 36, 44, 52, 60, 37, 45, 
70 
53, 61, 22, 30, 7, 15, 23, 31, 
71 
38, 46, 54, 62, 39, 47, 55, 63, 
72 
}; 
73  
74  
75 
static UINT8 simple_mmx_permutation[64]={ 
76 
0x00, 0x08, 0x01, 0x09, 0x04, 0x0C, 0x05, 0x0D, 
77 
0x10, 0x18, 0x11, 0x19, 0x14, 0x1C, 0x15, 0x1D, 
78 
0x02, 0x0A, 0x03, 0x0B, 0x06, 0x0E, 0x07, 0x0F, 
79 
0x12, 0x1A, 0x13, 0x1B, 0x16, 0x1E, 0x17, 0x1F, 
80 
0x20, 0x28, 0x21, 0x29, 0x24, 0x2C, 0x25, 0x2D, 
81 
0x30, 0x38, 0x31, 0x39, 0x34, 0x3C, 0x35, 0x3D, 
82 
0x22, 0x2A, 0x23, 0x2B, 0x26, 0x2E, 0x27, 0x2F, 
83 
0x32, 0x3A, 0x33, 0x3B, 0x36, 0x3E, 0x37, 0x3F, 
84 
}; 
85  
86 
UINT8 permutation[64];

87 
//UINT8 invPermutation[64];

88  
89 
void get_pixels_c(DCTELEM *block, const UINT8 *pixels, int line_size) 
90 
{ 
91 
DCTELEM *p; 
92 
const UINT8 *pix;

93 
int i;

94  
95 
/* read the pixels */

96 
p = block; 
97 
pix = pixels; 
98 
for(i=0;i<8;i++) { 
99 
p[0] = pix[0]; 
100 
p[1] = pix[1]; 
101 
p[2] = pix[2]; 
102 
p[3] = pix[3]; 
103 
p[4] = pix[4]; 
104 
p[5] = pix[5]; 
105 
p[6] = pix[6]; 
106 
p[7] = pix[7]; 
107 
pix += line_size; 
108 
p += 8;

109 
} 
110 
} 
111  
112 
void put_pixels_clamped_c(const DCTELEM *block, UINT8 *pixels, int line_size) 
113 
{ 
114 
const DCTELEM *p;

115 
UINT8 *pix; 
116 
int i;

117 
UINT8 *cm = cropTbl + MAX_NEG_CROP; 
118 

119 
/* read the pixels */

120 
p = block; 
121 
pix = pixels; 
122 
for(i=0;i<8;i++) { 
123 
pix[0] = cm[p[0]]; 
124 
pix[1] = cm[p[1]]; 
125 
pix[2] = cm[p[2]]; 
126 
pix[3] = cm[p[3]]; 
127 
pix[4] = cm[p[4]]; 
128 
pix[5] = cm[p[5]]; 
129 
pix[6] = cm[p[6]]; 
130 
pix[7] = cm[p[7]]; 
131 
pix += line_size; 
132 
p += 8;

133 
} 
134 
} 
135  
136 
void add_pixels_clamped_c(const DCTELEM *block, UINT8 *pixels, int line_size) 
137 
{ 
138 
const DCTELEM *p;

139 
UINT8 *pix; 
140 
int i;

141 
UINT8 *cm = cropTbl + MAX_NEG_CROP; 
142 

143 
/* read the pixels */

144 
p = block; 
145 
pix = pixels; 
146 
for(i=0;i<8;i++) { 
147 
pix[0] = cm[pix[0] + p[0]]; 
148 
pix[1] = cm[pix[1] + p[1]]; 
149 
pix[2] = cm[pix[2] + p[2]]; 
150 
pix[3] = cm[pix[3] + p[3]]; 
151 
pix[4] = cm[pix[4] + p[4]]; 
152 
pix[5] = cm[pix[5] + p[5]]; 
153 
pix[6] = cm[pix[6] + p[6]]; 
154 
pix[7] = cm[pix[7] + p[7]]; 
155 
pix += line_size; 
156 
p += 8;

157 
} 
158 
} 
159  
160 
#define PIXOP(BTYPE, OPNAME, OP, INCR) \

161 
\ 
162 
static void OPNAME ## _pixels(BTYPE *block, const UINT8 *pixels, int line_size, int h) \ 
163 
{ \ 
164 
BTYPE *p; \ 
165 
const UINT8 *pix; \

166 
\ 
167 
p = block; \ 
168 
pix = pixels; \ 
169 
do { \

170 
OP(p[0], pix[0]); \ 
171 
OP(p[1], pix[1]); \ 
172 
OP(p[2], pix[2]); \ 
173 
OP(p[3], pix[3]); \ 
174 
OP(p[4], pix[4]); \ 
175 
OP(p[5], pix[5]); \ 
176 
OP(p[6], pix[6]); \ 
177 
OP(p[7], pix[7]); \ 
178 
pix += line_size; \ 
179 
p += INCR; \ 
180 
} while (h);; \

181 
} \ 
182 
\ 
183 
static void OPNAME ## _pixels_x2(BTYPE *block, const UINT8 *pixels, int line_size, int h) \ 
184 
{ \ 
185 
BTYPE *p; \ 
186 
const UINT8 *pix; \

187 
\ 
188 
p = block; \ 
189 
pix = pixels; \ 
190 
do { \

191 
OP(p[0], avg2(pix[0], pix[1])); \ 
192 
OP(p[1], avg2(pix[1], pix[2])); \ 
193 
OP(p[2], avg2(pix[2], pix[3])); \ 
194 
OP(p[3], avg2(pix[3], pix[4])); \ 
195 
OP(p[4], avg2(pix[4], pix[5])); \ 
196 
OP(p[5], avg2(pix[5], pix[6])); \ 
197 
OP(p[6], avg2(pix[6], pix[7])); \ 
198 
OP(p[7], avg2(pix[7], pix[8])); \ 
199 
pix += line_size; \ 
200 
p += INCR; \ 
201 
} while (h); \

202 
} \ 
203 
\ 
204 
static void OPNAME ## _pixels_y2(BTYPE *block, const UINT8 *pixels, int line_size, int h) \ 
205 
{ \ 
206 
BTYPE *p; \ 
207 
const UINT8 *pix; \

208 
const UINT8 *pix1; \

209 
\ 
210 
p = block; \ 
211 
pix = pixels; \ 
212 
pix1 = pixels + line_size; \ 
213 
do { \

214 
OP(p[0], avg2(pix[0], pix1[0])); \ 
215 
OP(p[1], avg2(pix[1], pix1[1])); \ 
216 
OP(p[2], avg2(pix[2], pix1[2])); \ 
217 
OP(p[3], avg2(pix[3], pix1[3])); \ 
218 
OP(p[4], avg2(pix[4], pix1[4])); \ 
219 
OP(p[5], avg2(pix[5], pix1[5])); \ 
220 
OP(p[6], avg2(pix[6], pix1[6])); \ 
221 
OP(p[7], avg2(pix[7], pix1[7])); \ 
222 
pix += line_size; \ 
223 
pix1 += line_size; \ 
224 
p += INCR; \ 
225 
} while(h); \

226 
} \ 
227 
\ 
228 
static void OPNAME ## _pixels_xy2(BTYPE *block, const UINT8 *pixels, int line_size, int h) \ 
229 
{ \ 
230 
BTYPE *p; \ 
231 
const UINT8 *pix; \

232 
const UINT8 *pix1; \

233 
\ 
234 
p = block; \ 
235 
pix = pixels; \ 
236 
pix1 = pixels + line_size; \ 
237 
do { \

238 
OP(p[0], avg4(pix[0], pix[1], pix1[0], pix1[1])); \ 
239 
OP(p[1], avg4(pix[1], pix[2], pix1[1], pix1[2])); \ 
240 
OP(p[2], avg4(pix[2], pix[3], pix1[2], pix1[3])); \ 
241 
OP(p[3], avg4(pix[3], pix[4], pix1[3], pix1[4])); \ 
242 
OP(p[4], avg4(pix[4], pix[5], pix1[4], pix1[5])); \ 
243 
OP(p[5], avg4(pix[5], pix[6], pix1[5], pix1[6])); \ 
244 
OP(p[6], avg4(pix[6], pix[7], pix1[6], pix1[7])); \ 
245 
OP(p[7], avg4(pix[7], pix[8], pix1[7], pix1[8])); \ 
246 
pix += line_size; \ 
247 
pix1 += line_size; \ 
248 
p += INCR; \ 
249 
} while(h); \

250 
} \ 
251 
\ 
252 
void (*OPNAME ## _pixels_tab[4])(BTYPE *block, const UINT8 *pixels, int line_size, int h) = { \ 
253 
OPNAME ## _pixels, \ 
254 
OPNAME ## _pixels_x2, \ 
255 
OPNAME ## _pixels_y2, \ 
256 
OPNAME ## _pixels_xy2, \ 
257 
}; 
258  
259  
260 
/* rounding primitives */

261 
#define avg2(a,b) ((a+b+1)>>1) 
262 
#define avg4(a,b,c,d) ((a+b+c+d+2)>>2) 
263  
264 
#define op_put(a, b) a = b

265 
#define op_avg(a, b) a = avg2(a, b)

266 
#define op_sub(a, b) a = b

267  
268 
PIXOP(UINT8, put, op_put, line_size) 
269 
PIXOP(UINT8, avg, op_avg, line_size) 
270  
271 
PIXOP(DCTELEM, sub, op_sub, 8)

272  
273 
/* not rounding primitives */

274 
#undef avg2

275 
#undef avg4

276 
#define avg2(a,b) ((a+b)>>1) 
277 
#define avg4(a,b,c,d) ((a+b+c+d+1)>>2) 
278  
279 
PIXOP(UINT8, put_no_rnd, op_put, line_size) 
280 
PIXOP(UINT8, avg_no_rnd, op_avg, line_size) 
281  
282 
/* motion estimation */

283  
284 
#undef avg2

285 
#undef avg4

286 
#define avg2(a,b) ((a+b+1)>>1) 
287 
#define avg4(a,b,c,d) ((a+b+c+d+2)>>2) 
288  
289 
int pix_abs16x16_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h) 
290 
{ 
291 
int s, i;

292  
293 
s = 0;

294 
for(i=0;i<h;i++) { 
295 
s += abs(pix1[0]  pix2[0]); 
296 
s += abs(pix1[1]  pix2[1]); 
297 
s += abs(pix1[2]  pix2[2]); 
298 
s += abs(pix1[3]  pix2[3]); 
299 
s += abs(pix1[4]  pix2[4]); 
300 
s += abs(pix1[5]  pix2[5]); 
301 
s += abs(pix1[6]  pix2[6]); 
302 
s += abs(pix1[7]  pix2[7]); 
303 
s += abs(pix1[8]  pix2[8]); 
304 
s += abs(pix1[9]  pix2[9]); 
305 
s += abs(pix1[10]  pix2[10]); 
306 
s += abs(pix1[11]  pix2[11]); 
307 
s += abs(pix1[12]  pix2[12]); 
308 
s += abs(pix1[13]  pix2[13]); 
309 
s += abs(pix1[14]  pix2[14]); 
310 
s += abs(pix1[15]  pix2[15]); 
311 
pix1 += line_size; 
312 
pix2 += line_size; 
313 
} 
314 
return s;

315 
} 
316  
317 
int pix_abs16x16_x2_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h) 
318 
{ 
319 
int s, i;

320  
321 
s = 0;

322 
for(i=0;i<h;i++) { 
323 
s += abs(pix1[0]  avg2(pix2[0], pix2[1])); 
324 
s += abs(pix1[1]  avg2(pix2[1], pix2[2])); 
325 
s += abs(pix1[2]  avg2(pix2[2], pix2[3])); 
326 
s += abs(pix1[3]  avg2(pix2[3], pix2[4])); 
327 
s += abs(pix1[4]  avg2(pix2[4], pix2[5])); 
328 
s += abs(pix1[5]  avg2(pix2[5], pix2[6])); 
329 
s += abs(pix1[6]  avg2(pix2[6], pix2[7])); 
330 
s += abs(pix1[7]  avg2(pix2[7], pix2[8])); 
331 
s += abs(pix1[8]  avg2(pix2[8], pix2[9])); 
332 
s += abs(pix1[9]  avg2(pix2[9], pix2[10])); 
333 
s += abs(pix1[10]  avg2(pix2[10], pix2[11])); 
334 
s += abs(pix1[11]  avg2(pix2[11], pix2[12])); 
335 
s += abs(pix1[12]  avg2(pix2[12], pix2[13])); 
336 
s += abs(pix1[13]  avg2(pix2[13], pix2[14])); 
337 
s += abs(pix1[14]  avg2(pix2[14], pix2[15])); 
338 
s += abs(pix1[15]  avg2(pix2[15], pix2[16])); 
339 
pix1 += line_size; 
340 
pix2 += line_size; 
341 
} 
342 
return s;

343 
} 
344  
345 
int pix_abs16x16_y2_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h) 
346 
{ 
347 
int s, i;

348 
UINT8 *pix3 = pix2 + line_size; 
349  
350 
s = 0;

351 
for(i=0;i<h;i++) { 
352 
s += abs(pix1[0]  avg2(pix2[0], pix3[0])); 
353 
s += abs(pix1[1]  avg2(pix2[1], pix3[1])); 
354 
s += abs(pix1[2]  avg2(pix2[2], pix3[2])); 
355 
s += abs(pix1[3]  avg2(pix2[3], pix3[3])); 
356 
s += abs(pix1[4]  avg2(pix2[4], pix3[4])); 
357 
s += abs(pix1[5]  avg2(pix2[5], pix3[5])); 
358 
s += abs(pix1[6]  avg2(pix2[6], pix3[6])); 
359 
s += abs(pix1[7]  avg2(pix2[7], pix3[7])); 
360 
s += abs(pix1[8]  avg2(pix2[8], pix3[8])); 
361 
s += abs(pix1[9]  avg2(pix2[9], pix3[9])); 
362 
s += abs(pix1[10]  avg2(pix2[10], pix3[10])); 
363 
s += abs(pix1[11]  avg2(pix2[11], pix3[11])); 
364 
s += abs(pix1[12]  avg2(pix2[12], pix3[12])); 
365 
s += abs(pix1[13]  avg2(pix2[13], pix3[13])); 
366 
s += abs(pix1[14]  avg2(pix2[14], pix3[14])); 
367 
s += abs(pix1[15]  avg2(pix2[15], pix3[15])); 
368 
pix1 += line_size; 
369 
pix2 += line_size; 
370 
pix3 += line_size; 
371 
} 
372 
return s;

373 
} 
374  
375 
int pix_abs16x16_xy2_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h) 
376 
{ 
377 
int s, i;

378 
UINT8 *pix3 = pix2 + line_size; 
379  
380 
s = 0;

381 
for(i=0;i<h;i++) { 
382 
s += abs(pix1[0]  avg4(pix2[0], pix2[1], pix3[0], pix3[1])); 
383 
s += abs(pix1[1]  avg4(pix2[1], pix2[2], pix3[1], pix3[2])); 
384 
s += abs(pix1[2]  avg4(pix2[2], pix2[3], pix3[2], pix3[3])); 
385 
s += abs(pix1[3]  avg4(pix2[3], pix2[4], pix3[3], pix3[4])); 
386 
s += abs(pix1[4]  avg4(pix2[4], pix2[5], pix3[4], pix3[5])); 
387 
s += abs(pix1[5]  avg4(pix2[5], pix2[6], pix3[5], pix3[6])); 
388 
s += abs(pix1[6]  avg4(pix2[6], pix2[7], pix3[6], pix3[7])); 
389 
s += abs(pix1[7]  avg4(pix2[7], pix2[8], pix3[7], pix3[8])); 
390 
s += abs(pix1[8]  avg4(pix2[8], pix2[9], pix3[8], pix3[9])); 
391 
s += abs(pix1[9]  avg4(pix2[9], pix2[10], pix3[9], pix3[10])); 
392 
s += abs(pix1[10]  avg4(pix2[10], pix2[11], pix3[10], pix3[11])); 
393 
s += abs(pix1[11]  avg4(pix2[11], pix2[12], pix3[11], pix3[12])); 
394 
s += abs(pix1[12]  avg4(pix2[12], pix2[13], pix3[12], pix3[13])); 
395 
s += abs(pix1[13]  avg4(pix2[13], pix2[14], pix3[13], pix3[14])); 
396 
s += abs(pix1[14]  avg4(pix2[14], pix2[15], pix3[14], pix3[15])); 
397 
s += abs(pix1[15]  avg4(pix2[15], pix2[16], pix3[15], pix3[16])); 
398 
pix1 += line_size; 
399 
pix2 += line_size; 
400 
pix3 += line_size; 
401 
} 
402 
return s;

403 
} 
404  
405 
/* permute block according so that it corresponds to the MMX idct

406 
order */

407 
#ifdef SIMPLE_IDCT

408 
/* general permutation, but perhaps slightly slower */

409 
void block_permute(INT16 *block)

410 
{ 
411 
int i;

412 
INT16 temp[64];

413  
414 
for(i=0; i<64; i++) temp[ block_permute_op(i) ] = block[i]; 
415  
416 
for(i=0; i<64; i++) block[i] = temp[i]; 
417 
} 
418 
#else

419  
420 
void block_permute(INT16 *block)

421 
{ 
422 
int tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;

423 
int i;

424  
425 
for(i=0;i<8;i++) { 
426 
tmp1 = block[1];

427 
tmp2 = block[2];

428 
tmp3 = block[3];

429 
tmp4 = block[4];

430 
tmp5 = block[5];

431 
tmp6 = block[6];

432 
block[1] = tmp2;

433 
block[2] = tmp4;

434 
block[3] = tmp6;

435 
block[4] = tmp1;

436 
block[5] = tmp3;

437 
block[6] = tmp5;

438 
block += 8;

439 
} 
440 
} 
441 
#endif

442  
443 
void dsputil_init(void) 
444 
{ 
445 
int i, j;

446 
int use_permuted_idct;

447  
448 
for(i=0;i<256;i++) cropTbl[i + MAX_NEG_CROP] = i; 
449 
for(i=0;i<MAX_NEG_CROP;i++) { 
450 
cropTbl[i] = 0;

451 
cropTbl[i + MAX_NEG_CROP + 256] = 255; 
452 
} 
453  
454 
for(i=0;i<512;i++) { 
455 
squareTbl[i] = (i  256) * (i  256); 
456 
} 
457  
458 
#ifdef SIMPLE_IDCT

459 
ff_idct = simple_idct; 
460 
#else

461 
ff_idct = j_rev_dct; 
462 
#endif

463 
get_pixels = get_pixels_c; 
464 
put_pixels_clamped = put_pixels_clamped_c; 
465 
add_pixels_clamped = add_pixels_clamped_c; 
466  
467 
pix_abs16x16 = pix_abs16x16_c; 
468 
pix_abs16x16_x2 = pix_abs16x16_x2_c; 
469 
pix_abs16x16_y2 = pix_abs16x16_y2_c; 
470 
pix_abs16x16_xy2 = pix_abs16x16_xy2_c; 
471 
av_fdct = jpeg_fdct_ifast; 
472  
473 
use_permuted_idct = 1;

474  
475 
#ifdef HAVE_MMX

476 
dsputil_init_mmx(); 
477 
#endif

478 
#ifdef ARCH_ARMV4L

479 
dsputil_init_armv4l(); 
480 
#endif

481 
#ifdef HAVE_MLIB

482 
dsputil_init_mlib(); 
483 
use_permuted_idct = 0;

484 
#endif

485  
486 
#ifdef SIMPLE_IDCT

487 
if(ff_idct == simple_idct) use_permuted_idct=0; 
488 
#endif

489  
490 
if(use_permuted_idct)

491 
#ifdef SIMPLE_IDCT

492 
for(i=0; i<64; i++) permutation[i]= simple_mmx_permutation[i]; 
493 
#else

494 
for(i=0; i<64; i++) permutation[i]= (i & 0x38)  ((i & 6) >> 1)  ((i & 1) << 2); 
495 
#endif

496 
else

497 
for(i=0; i<64; i++) permutation[i]=i; 
498  
499 
if (use_permuted_idct) {

500 
/* permute for IDCT */

501 
for(i=0;i<64;i++) { 
502 
j = zigzag_direct[i]; 
503 
zigzag_direct[i] = block_permute_op(j); 
504 
j = ff_alternate_horizontal_scan[i]; 
505 
ff_alternate_horizontal_scan[i] = block_permute_op(j); 
506 
j = ff_alternate_vertical_scan[i]; 
507 
ff_alternate_vertical_scan[i] = block_permute_op(j); 
508 
} 
509 
block_permute(default_intra_matrix); 
510 
block_permute(default_non_intra_matrix); 
511 
} 
512 
} 