?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Extend get_buffer to handle the XvMC case and remove mc_get_buffer
[mplayer/glamo.git] / libswscale / swscale_template.c
blob1f5a10de419ca23bd5cbc7d2e1ff865cb8d487b1
1 /*
2 * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * FFmpeg 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
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 * The C code (not assembly, MMX, ...) of this file can be used
21 * under the LGPL license.
22 */
23
24 #undef REAL_MOVNTQ
25 #undef MOVNTQ
26 #undef PAVGB
27 #undef PREFETCH
28 #undef PREFETCHW
29 #undef EMMS
30 #undef SFENCE
31
32 #if HAVE_AMD3DNOW
33 /* On K6 femms is faster than emms. On K7 femms is directly mapped to emms. */
34 #define EMMS "femms"
35 #else
36 #define EMMS "emms"
37 #endif
38
39 #if HAVE_AMD3DNOW
40 #define PREFETCH "prefetch"
41 #define PREFETCHW "prefetchw"
42 #elif HAVE_MMX2
43 #define PREFETCH "prefetchnta"
44 #define PREFETCHW "prefetcht0"
45 #else
46 #define PREFETCH " # nop"
47 #define PREFETCHW " # nop"
48 #endif
49
50 #if HAVE_MMX2
51 #define SFENCE "sfence"
52 #else
53 #define SFENCE " # nop"
54 #endif
55
56 #if HAVE_MMX2
57 #define PAVGB(a,b) "pavgb " #a ", " #b " \n\t"
58 #elif HAVE_AMD3DNOW
59 #define PAVGB(a,b) "pavgusb " #a ", " #b " \n\t"
60 #endif
61
62 #if HAVE_MMX2
63 #define REAL_MOVNTQ(a,b) "movntq " #a ", " #b " \n\t"
64 #else
65 #define REAL_MOVNTQ(a,b) "movq " #a ", " #b " \n\t"
66 #endif
67 #define MOVNTQ(a,b) REAL_MOVNTQ(a,b)
68
69 #if HAVE_ALTIVEC
70 #include "swscale_altivec_template.c"
71 #endif
72
73 #define YSCALEYUV2YV12X(x, offset, dest, width) \
74 __asm__ volatile(\
75 "xor %%"REG_a", %%"REG_a" \n\t"\
76 "movq "VROUNDER_OFFSET"(%0), %%mm3 \n\t"\
77 "movq %%mm3, %%mm4 \n\t"\
78 "lea " offset "(%0), %%"REG_d" \n\t"\
79 "mov (%%"REG_d"), %%"REG_S" \n\t"\
80 ASMALIGN(4) /* FIXME Unroll? */\
81 "1: \n\t"\
82 "movq 8(%%"REG_d"), %%mm0 \n\t" /* filterCoeff */\
83 "movq " x "(%%"REG_S", %%"REG_a", 2), %%mm2 \n\t" /* srcData */\
84 "movq 8+" x "(%%"REG_S", %%"REG_a", 2), %%mm5 \n\t" /* srcData */\
85 "add $16, %%"REG_d" \n\t"\
86 "mov (%%"REG_d"), %%"REG_S" \n\t"\
87 "test %%"REG_S", %%"REG_S" \n\t"\
88 "pmulhw %%mm0, %%mm2 \n\t"\
89 "pmulhw %%mm0, %%mm5 \n\t"\
90 "paddw %%mm2, %%mm3 \n\t"\
91 "paddw %%mm5, %%mm4 \n\t"\
92 " jnz 1b \n\t"\
93 "psraw $3, %%mm3 \n\t"\
94 "psraw $3, %%mm4 \n\t"\
95 "packuswb %%mm4, %%mm3 \n\t"\
96 MOVNTQ(%%mm3, (%1, %%REGa))\
97 "add $8, %%"REG_a" \n\t"\
98 "cmp %2, %%"REG_a" \n\t"\
99 "movq "VROUNDER_OFFSET"(%0), %%mm3 \n\t"\
100 "movq %%mm3, %%mm4 \n\t"\
101 "lea " offset "(%0), %%"REG_d" \n\t"\
102 "mov (%%"REG_d"), %%"REG_S" \n\t"\
103 "jb 1b \n\t"\
104 :: "r" (&c->redDither),\
105 "r" (dest), "g" (width)\
106 : "%"REG_a, "%"REG_d, "%"REG_S\
107 );
108
109 #define YSCALEYUV2YV12X_ACCURATE(x, offset, dest, width) \
110 __asm__ volatile(\
111 "lea " offset "(%0), %%"REG_d" \n\t"\
112 "xor %%"REG_a", %%"REG_a" \n\t"\
113 "pxor %%mm4, %%mm4 \n\t"\
114 "pxor %%mm5, %%mm5 \n\t"\
115 "pxor %%mm6, %%mm6 \n\t"\
116 "pxor %%mm7, %%mm7 \n\t"\
117 "mov (%%"REG_d"), %%"REG_S" \n\t"\
118 ASMALIGN(4) \
119 "1: \n\t"\
120 "movq " x "(%%"REG_S", %%"REG_a", 2), %%mm0 \n\t" /* srcData */\
121 "movq 8+" x "(%%"REG_S", %%"REG_a", 2), %%mm2 \n\t" /* srcData */\
122 "mov "STR(APCK_PTR2)"(%%"REG_d"), %%"REG_S" \n\t"\
123 "movq " x "(%%"REG_S", %%"REG_a", 2), %%mm1 \n\t" /* srcData */\
124 "movq %%mm0, %%mm3 \n\t"\
125 "punpcklwd %%mm1, %%mm0 \n\t"\
126 "punpckhwd %%mm1, %%mm3 \n\t"\
127 "movq "STR(APCK_COEF)"(%%"REG_d"), %%mm1 \n\t" /* filterCoeff */\
128 "pmaddwd %%mm1, %%mm0 \n\t"\
129 "pmaddwd %%mm1, %%mm3 \n\t"\
130 "paddd %%mm0, %%mm4 \n\t"\
131 "paddd %%mm3, %%mm5 \n\t"\
132 "movq 8+" x "(%%"REG_S", %%"REG_a", 2), %%mm3 \n\t" /* srcData */\
133 "mov "STR(APCK_SIZE)"(%%"REG_d"), %%"REG_S" \n\t"\
134 "add $"STR(APCK_SIZE)", %%"REG_d" \n\t"\
135 "test %%"REG_S", %%"REG_S" \n\t"\
136 "movq %%mm2, %%mm0 \n\t"\
137 "punpcklwd %%mm3, %%mm2 \n\t"\
138 "punpckhwd %%mm3, %%mm0 \n\t"\
139 "pmaddwd %%mm1, %%mm2 \n\t"\
140 "pmaddwd %%mm1, %%mm0 \n\t"\
141 "paddd %%mm2, %%mm6 \n\t"\
142 "paddd %%mm0, %%mm7 \n\t"\
143 " jnz 1b \n\t"\
144 "psrad $16, %%mm4 \n\t"\
145 "psrad $16, %%mm5 \n\t"\
146 "psrad $16, %%mm6 \n\t"\
147 "psrad $16, %%mm7 \n\t"\
148 "movq "VROUNDER_OFFSET"(%0), %%mm0 \n\t"\
149 "packssdw %%mm5, %%mm4 \n\t"\
150 "packssdw %%mm7, %%mm6 \n\t"\
151 "paddw %%mm0, %%mm4 \n\t"\
152 "paddw %%mm0, %%mm6 \n\t"\
153 "psraw $3, %%mm4 \n\t"\
154 "psraw $3, %%mm6 \n\t"\
155 "packuswb %%mm6, %%mm4 \n\t"\
156 MOVNTQ(%%mm4, (%1, %%REGa))\
157 "add $8, %%"REG_a" \n\t"\
158 "cmp %2, %%"REG_a" \n\t"\
159 "lea " offset "(%0), %%"REG_d" \n\t"\
160 "pxor %%mm4, %%mm4 \n\t"\
161 "pxor %%mm5, %%mm5 \n\t"\
162 "pxor %%mm6, %%mm6 \n\t"\
163 "pxor %%mm7, %%mm7 \n\t"\
164 "mov (%%"REG_d"), %%"REG_S" \n\t"\
165 "jb 1b \n\t"\
166 :: "r" (&c->redDither),\
167 "r" (dest), "g" (width)\
168 : "%"REG_a, "%"REG_d, "%"REG_S\
169 );
170
171 #define YSCALEYUV2YV121 \
172 "mov %2, %%"REG_a" \n\t"\
173 ASMALIGN(4) /* FIXME Unroll? */\
174 "1: \n\t"\
175 "movq (%0, %%"REG_a", 2), %%mm0 \n\t"\
176 "movq 8(%0, %%"REG_a", 2), %%mm1 \n\t"\
177 "psraw $7, %%mm0 \n\t"\
178 "psraw $7, %%mm1 \n\t"\
179 "packuswb %%mm1, %%mm0 \n\t"\
180 MOVNTQ(%%mm0, (%1, %%REGa))\
181 "add $8, %%"REG_a" \n\t"\
182 "jnc 1b \n\t"
183
184 #define YSCALEYUV2YV121_ACCURATE \
185 "mov %2, %%"REG_a" \n\t"\
186 "pcmpeqw %%mm7, %%mm7 \n\t"\
187 "psrlw $15, %%mm7 \n\t"\
188 "psllw $6, %%mm7 \n\t"\
189 ASMALIGN(4) /* FIXME Unroll? */\
190 "1: \n\t"\
191 "movq (%0, %%"REG_a", 2), %%mm0 \n\t"\
192 "movq 8(%0, %%"REG_a", 2), %%mm1 \n\t"\
193 "paddsw %%mm7, %%mm0 \n\t"\
194 "paddsw %%mm7, %%mm1 \n\t"\
195 "psraw $7, %%mm0 \n\t"\
196 "psraw $7, %%mm1 \n\t"\
197 "packuswb %%mm1, %%mm0 \n\t"\
198 MOVNTQ(%%mm0, (%1, %%REGa))\
199 "add $8, %%"REG_a" \n\t"\
200 "jnc 1b \n\t"
201
202 /*
203 :: "m" (-lumFilterSize), "m" (-chrFilterSize),
204 "m" (lumMmxFilter+lumFilterSize*4), "m" (chrMmxFilter+chrFilterSize*4),
205 "r" (dest), "m" (dstW),
206 "m" (lumSrc+lumFilterSize), "m" (chrSrc+chrFilterSize)
207 : "%eax", "%ebx", "%ecx", "%edx", "%esi"
208 */
209 #define YSCALEYUV2PACKEDX \
210 __asm__ volatile(\
211 "xor %%"REG_a", %%"REG_a" \n\t"\
212 ASMALIGN(4)\
213 "nop \n\t"\
214 "1: \n\t"\
215 "lea "CHR_MMX_FILTER_OFFSET"(%0), %%"REG_d" \n\t"\
216 "mov (%%"REG_d"), %%"REG_S" \n\t"\
217 "movq "VROUNDER_OFFSET"(%0), %%mm3 \n\t"\
218 "movq %%mm3, %%mm4 \n\t"\
219 ASMALIGN(4)\
220 "2: \n\t"\
221 "movq 8(%%"REG_d"), %%mm0 \n\t" /* filterCoeff */\
222 "movq (%%"REG_S", %%"REG_a"), %%mm2 \n\t" /* UsrcData */\
223 "movq "AV_STRINGIFY(VOF)"(%%"REG_S", %%"REG_a"), %%mm5 \n\t" /* VsrcData */\
224 "add $16, %%"REG_d" \n\t"\
225 "mov (%%"REG_d"), %%"REG_S" \n\t"\
226 "pmulhw %%mm0, %%mm2 \n\t"\
227 "pmulhw %%mm0, %%mm5 \n\t"\
228 "paddw %%mm2, %%mm3 \n\t"\
229 "paddw %%mm5, %%mm4 \n\t"\
230 "test %%"REG_S", %%"REG_S" \n\t"\
231 " jnz 2b \n\t"\
232 \
233 "lea "LUM_MMX_FILTER_OFFSET"(%0), %%"REG_d" \n\t"\
234 "mov (%%"REG_d"), %%"REG_S" \n\t"\
235 "movq "VROUNDER_OFFSET"(%0), %%mm1 \n\t"\
236 "movq %%mm1, %%mm7 \n\t"\
237 ASMALIGN(4)\
238 "2: \n\t"\
239 "movq 8(%%"REG_d"), %%mm0 \n\t" /* filterCoeff */\
240 "movq (%%"REG_S", %%"REG_a", 2), %%mm2 \n\t" /* Y1srcData */\
241 "movq 8(%%"REG_S", %%"REG_a", 2), %%mm5 \n\t" /* Y2srcData */\
242 "add $16, %%"REG_d" \n\t"\
243 "mov (%%"REG_d"), %%"REG_S" \n\t"\
244 "pmulhw %%mm0, %%mm2 \n\t"\
245 "pmulhw %%mm0, %%mm5 \n\t"\
246 "paddw %%mm2, %%mm1 \n\t"\
247 "paddw %%mm5, %%mm7 \n\t"\
248 "test %%"REG_S", %%"REG_S" \n\t"\
249 " jnz 2b \n\t"\
250
251 #define YSCALEYUV2PACKEDX_END \
252 :: "r" (&c->redDither), \
253 "m" (dummy), "m" (dummy), "m" (dummy),\
254 "r" (dest), "m" (dstW) \
255 : "%"REG_a, "%"REG_d, "%"REG_S \
256 );
257
258 #define YSCALEYUV2PACKEDX_ACCURATE \
259 __asm__ volatile(\
260 "xor %%"REG_a", %%"REG_a" \n\t"\
261 ASMALIGN(4)\
262 "nop \n\t"\
263 "1: \n\t"\
264 "lea "CHR_MMX_FILTER_OFFSET"(%0), %%"REG_d" \n\t"\
265 "mov (%%"REG_d"), %%"REG_S" \n\t"\
266 "pxor %%mm4, %%mm4 \n\t"\
267 "pxor %%mm5, %%mm5 \n\t"\
268 "pxor %%mm6, %%mm6 \n\t"\
269 "pxor %%mm7, %%mm7 \n\t"\
270 ASMALIGN(4)\
271 "2: \n\t"\
272 "movq (%%"REG_S", %%"REG_a"), %%mm0 \n\t" /* UsrcData */\
273 "movq "AV_STRINGIFY(VOF)"(%%"REG_S", %%"REG_a"), %%mm2 \n\t" /* VsrcData */\
274 "mov "STR(APCK_PTR2)"(%%"REG_d"), %%"REG_S" \n\t"\
275 "movq (%%"REG_S", %%"REG_a"), %%mm1 \n\t" /* UsrcData */\
276 "movq %%mm0, %%mm3 \n\t"\
277 "punpcklwd %%mm1, %%mm0 \n\t"\
278 "punpckhwd %%mm1, %%mm3 \n\t"\
279 "movq "STR(APCK_COEF)"(%%"REG_d"),%%mm1 \n\t" /* filterCoeff */\
280 "pmaddwd %%mm1, %%mm0 \n\t"\
281 "pmaddwd %%mm1, %%mm3 \n\t"\
282 "paddd %%mm0, %%mm4 \n\t"\
283 "paddd %%mm3, %%mm5 \n\t"\
284 "movq "AV_STRINGIFY(VOF)"(%%"REG_S", %%"REG_a"), %%mm3 \n\t" /* VsrcData */\
285 "mov "STR(APCK_SIZE)"(%%"REG_d"), %%"REG_S" \n\t"\
286 "add $"STR(APCK_SIZE)", %%"REG_d" \n\t"\
287 "test %%"REG_S", %%"REG_S" \n\t"\
288 "movq %%mm2, %%mm0 \n\t"\
289 "punpcklwd %%mm3, %%mm2 \n\t"\
290 "punpckhwd %%mm3, %%mm0 \n\t"\
291 "pmaddwd %%mm1, %%mm2 \n\t"\
292 "pmaddwd %%mm1, %%mm0 \n\t"\
293 "paddd %%mm2, %%mm6 \n\t"\
294 "paddd %%mm0, %%mm7 \n\t"\
295 " jnz 2b \n\t"\
296 "psrad $16, %%mm4 \n\t"\
297 "psrad $16, %%mm5 \n\t"\
298 "psrad $16, %%mm6 \n\t"\
299 "psrad $16, %%mm7 \n\t"\
300 "movq "VROUNDER_OFFSET"(%0), %%mm0 \n\t"\
301 "packssdw %%mm5, %%mm4 \n\t"\
302 "packssdw %%mm7, %%mm6 \n\t"\
303 "paddw %%mm0, %%mm4 \n\t"\
304 "paddw %%mm0, %%mm6 \n\t"\
305 "movq %%mm4, "U_TEMP"(%0) \n\t"\
306 "movq %%mm6, "V_TEMP"(%0) \n\t"\
307 \
308 "lea "LUM_MMX_FILTER_OFFSET"(%0), %%"REG_d" \n\t"\
309 "mov (%%"REG_d"), %%"REG_S" \n\t"\
310 "pxor %%mm1, %%mm1 \n\t"\
311 "pxor %%mm5, %%mm5 \n\t"\
312 "pxor %%mm7, %%mm7 \n\t"\
313 "pxor %%mm6, %%mm6 \n\t"\
314 ASMALIGN(4)\
315 "2: \n\t"\
316 "movq (%%"REG_S", %%"REG_a", 2), %%mm0 \n\t" /* Y1srcData */\
317 "movq 8(%%"REG_S", %%"REG_a", 2), %%mm2 \n\t" /* Y2srcData */\
318 "mov "STR(APCK_PTR2)"(%%"REG_d"), %%"REG_S" \n\t"\
319 "movq (%%"REG_S", %%"REG_a", 2), %%mm4 \n\t" /* Y1srcData */\
320 "movq %%mm0, %%mm3 \n\t"\
321 "punpcklwd %%mm4, %%mm0 \n\t"\
322 "punpckhwd %%mm4, %%mm3 \n\t"\
323 "movq "STR(APCK_COEF)"(%%"REG_d"), %%mm4 \n\t" /* filterCoeff */\
324 "pmaddwd %%mm4, %%mm0 \n\t"\
325 "pmaddwd %%mm4, %%mm3 \n\t"\
326 "paddd %%mm0, %%mm1 \n\t"\
327 "paddd %%mm3, %%mm5 \n\t"\
328 "movq 8(%%"REG_S", %%"REG_a", 2), %%mm3 \n\t" /* Y2srcData */\
329 "mov "STR(APCK_SIZE)"(%%"REG_d"), %%"REG_S" \n\t"\
330 "add $"STR(APCK_SIZE)", %%"REG_d" \n\t"\
331 "test %%"REG_S", %%"REG_S" \n\t"\
332 "movq %%mm2, %%mm0 \n\t"\
333 "punpcklwd %%mm3, %%mm2 \n\t"\
334 "punpckhwd %%mm3, %%mm0 \n\t"\
335 "pmaddwd %%mm4, %%mm2 \n\t"\
336 "pmaddwd %%mm4, %%mm0 \n\t"\
337 "paddd %%mm2, %%mm7 \n\t"\
338 "paddd %%mm0, %%mm6 \n\t"\
339 " jnz 2b \n\t"\
340 "psrad $16, %%mm1 \n\t"\
341 "psrad $16, %%mm5 \n\t"\
342 "psrad $16, %%mm7 \n\t"\
343 "psrad $16, %%mm6 \n\t"\
344 "movq "VROUNDER_OFFSET"(%0), %%mm0 \n\t"\
345 "packssdw %%mm5, %%mm1 \n\t"\
346 "packssdw %%mm6, %%mm7 \n\t"\
347 "paddw %%mm0, %%mm1 \n\t"\
348 "paddw %%mm0, %%mm7 \n\t"\
349 "movq "U_TEMP"(%0), %%mm3 \n\t"\
350 "movq "V_TEMP"(%0), %%mm4 \n\t"\
351
352 #define YSCALEYUV2RGBX \
353 "psubw "U_OFFSET"(%0), %%mm3 \n\t" /* (U-128)8*/\
354 "psubw "V_OFFSET"(%0), %%mm4 \n\t" /* (V-128)8*/\
355 "movq %%mm3, %%mm2 \n\t" /* (U-128)8*/\
356 "movq %%mm4, %%mm5 \n\t" /* (V-128)8*/\
357 "pmulhw "UG_COEFF"(%0), %%mm3 \n\t"\
358 "pmulhw "VG_COEFF"(%0), %%mm4 \n\t"\
359 /* mm2=(U-128)8, mm3=ug, mm4=vg mm5=(V-128)8 */\
360 "pmulhw "UB_COEFF"(%0), %%mm2 \n\t"\
361 "pmulhw "VR_COEFF"(%0), %%mm5 \n\t"\
362 "psubw "Y_OFFSET"(%0), %%mm1 \n\t" /* 8(Y-16)*/\
363 "psubw "Y_OFFSET"(%0), %%mm7 \n\t" /* 8(Y-16)*/\
364 "pmulhw "Y_COEFF"(%0), %%mm1 \n\t"\
365 "pmulhw "Y_COEFF"(%0), %%mm7 \n\t"\
366 /* mm1= Y1, mm2=ub, mm3=ug, mm4=vg mm5=vr, mm7=Y2 */\
367 "paddw %%mm3, %%mm4 \n\t"\
368 "movq %%mm2, %%mm0 \n\t"\
369 "movq %%mm5, %%mm6 \n\t"\
370 "movq %%mm4, %%mm3 \n\t"\
371 "punpcklwd %%mm2, %%mm2 \n\t"\
372 "punpcklwd %%mm5, %%mm5 \n\t"\
373 "punpcklwd %%mm4, %%mm4 \n\t"\
374 "paddw %%mm1, %%mm2 \n\t"\
375 "paddw %%mm1, %%mm5 \n\t"\
376 "paddw %%mm1, %%mm4 \n\t"\
377 "punpckhwd %%mm0, %%mm0 \n\t"\
378 "punpckhwd %%mm6, %%mm6 \n\t"\
379 "punpckhwd %%mm3, %%mm3 \n\t"\
380 "paddw %%mm7, %%mm0 \n\t"\
381 "paddw %%mm7, %%mm6 \n\t"\
382 "paddw %%mm7, %%mm3 \n\t"\
383 /* mm0=B1, mm2=B2, mm3=G2, mm4=G1, mm5=R1, mm6=R2 */\
384 "packuswb %%mm0, %%mm2 \n\t"\
385 "packuswb %%mm6, %%mm5 \n\t"\
386 "packuswb %%mm3, %%mm4 \n\t"\
387 "pxor %%mm7, %%mm7 \n\t"
388
389 #define REAL_YSCALEYUV2PACKED(index, c) \
390 "movq "CHR_MMX_FILTER_OFFSET"+8("#c"), %%mm0 \n\t"\
391 "movq "LUM_MMX_FILTER_OFFSET"+8("#c"), %%mm1 \n\t"\
392 "psraw $3, %%mm0 \n\t"\
393 "psraw $3, %%mm1 \n\t"\
394 "movq %%mm0, "CHR_MMX_FILTER_OFFSET"+8("#c") \n\t"\
395 "movq %%mm1, "LUM_MMX_FILTER_OFFSET"+8("#c") \n\t"\
396 "xor "#index", "#index" \n\t"\
397 ASMALIGN(4)\
398 "1: \n\t"\
399 "movq (%2, "#index"), %%mm2 \n\t" /* uvbuf0[eax]*/\
400 "movq (%3, "#index"), %%mm3 \n\t" /* uvbuf1[eax]*/\
401 "movq "AV_STRINGIFY(VOF)"(%2, "#index"), %%mm5 \n\t" /* uvbuf0[eax+2048]*/\
402 "movq "AV_STRINGIFY(VOF)"(%3, "#index"), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\
403 "psubw %%mm3, %%mm2 \n\t" /* uvbuf0[eax] - uvbuf1[eax]*/\
404 "psubw %%mm4, %%mm5 \n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048]*/\
405 "movq "CHR_MMX_FILTER_OFFSET"+8("#c"), %%mm0 \n\t"\
406 "pmulhw %%mm0, %%mm2 \n\t" /* (uvbuf0[eax] - uvbuf1[eax])uvalpha1>>16*/\
407 "pmulhw %%mm0, %%mm5 \n\t" /* (uvbuf0[eax+2048] - uvbuf1[eax+2048])uvalpha1>>16*/\
408 "psraw $7, %%mm3 \n\t" /* uvbuf0[eax] - uvbuf1[eax] >>4*/\
409 "psraw $7, %%mm4 \n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048] >>4*/\
410 "paddw %%mm2, %%mm3 \n\t" /* uvbuf0[eax]uvalpha1 - uvbuf1[eax](1-uvalpha1)*/\
411 "paddw %%mm5, %%mm4 \n\t" /* uvbuf0[eax+2048]uvalpha1 - uvbuf1[eax+2048](1-uvalpha1)*/\
412 "movq (%0, "#index", 2), %%mm0 \n\t" /*buf0[eax]*/\
413 "movq (%1, "#index", 2), %%mm1 \n\t" /*buf1[eax]*/\
414 "movq 8(%0, "#index", 2), %%mm6 \n\t" /*buf0[eax]*/\
415 "movq 8(%1, "#index", 2), %%mm7 \n\t" /*buf1[eax]*/\
416 "psubw %%mm1, %%mm0 \n\t" /* buf0[eax] - buf1[eax]*/\
417 "psubw %%mm7, %%mm6 \n\t" /* buf0[eax] - buf1[eax]*/\
418 "pmulhw "LUM_MMX_FILTER_OFFSET"+8("#c"), %%mm0 \n\t" /* (buf0[eax] - buf1[eax])yalpha1>>16*/\
419 "pmulhw "LUM_MMX_FILTER_OFFSET"+8("#c"), %%mm6 \n\t" /* (buf0[eax] - buf1[eax])yalpha1>>16*/\
420 "psraw $7, %%mm1 \n\t" /* buf0[eax] - buf1[eax] >>4*/\
421 "psraw $7, %%mm7 \n\t" /* buf0[eax] - buf1[eax] >>4*/\
422 "paddw %%mm0, %%mm1 \n\t" /* buf0[eax]yalpha1 + buf1[eax](1-yalpha1) >>16*/\
423 "paddw %%mm6, %%mm7 \n\t" /* buf0[eax]yalpha1 + buf1[eax](1-yalpha1) >>16*/\
424
425 #define YSCALEYUV2PACKED(index, c) REAL_YSCALEYUV2PACKED(index, c)
426
427 #define REAL_YSCALEYUV2RGB(index, c) \
428 "xor "#index", "#index" \n\t"\
429 ASMALIGN(4)\
430 "1: \n\t"\
431 "movq (%2, "#index"), %%mm2 \n\t" /* uvbuf0[eax]*/\
432 "movq (%3, "#index"), %%mm3 \n\t" /* uvbuf1[eax]*/\
433 "movq "AV_STRINGIFY(VOF)"(%2, "#index"), %%mm5 \n\t" /* uvbuf0[eax+2048]*/\
434 "movq "AV_STRINGIFY(VOF)"(%3, "#index"), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\
435 "psubw %%mm3, %%mm2 \n\t" /* uvbuf0[eax] - uvbuf1[eax]*/\
436 "psubw %%mm4, %%mm5 \n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048]*/\
437 "movq "CHR_MMX_FILTER_OFFSET"+8("#c"), %%mm0 \n\t"\
438 "pmulhw %%mm0, %%mm2 \n\t" /* (uvbuf0[eax] - uvbuf1[eax])uvalpha1>>16*/\
439 "pmulhw %%mm0, %%mm5 \n\t" /* (uvbuf0[eax+2048] - uvbuf1[eax+2048])uvalpha1>>16*/\
440 "psraw $4, %%mm3 \n\t" /* uvbuf0[eax] - uvbuf1[eax] >>4*/\
441 "psraw $4, %%mm4 \n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048] >>4*/\
442 "paddw %%mm2, %%mm3 \n\t" /* uvbuf0[eax]uvalpha1 - uvbuf1[eax](1-uvalpha1)*/\
443 "paddw %%mm5, %%mm4 \n\t" /* uvbuf0[eax+2048]uvalpha1 - uvbuf1[eax+2048](1-uvalpha1)*/\
444 "psubw "U_OFFSET"("#c"), %%mm3 \n\t" /* (U-128)8*/\
445 "psubw "V_OFFSET"("#c"), %%mm4 \n\t" /* (V-128)8*/\
446 "movq %%mm3, %%mm2 \n\t" /* (U-128)8*/\
447 "movq %%mm4, %%mm5 \n\t" /* (V-128)8*/\
448 "pmulhw "UG_COEFF"("#c"), %%mm3 \n\t"\
449 "pmulhw "VG_COEFF"("#c"), %%mm4 \n\t"\
450 /* mm2=(U-128)8, mm3=ug, mm4=vg mm5=(V-128)8 */\
451 "movq (%0, "#index", 2), %%mm0 \n\t" /*buf0[eax]*/\
452 "movq (%1, "#index", 2), %%mm1 \n\t" /*buf1[eax]*/\
453 "movq 8(%0, "#index", 2), %%mm6 \n\t" /*buf0[eax]*/\
454 "movq 8(%1, "#index", 2), %%mm7 \n\t" /*buf1[eax]*/\
455 "psubw %%mm1, %%mm0 \n\t" /* buf0[eax] - buf1[eax]*/\
456 "psubw %%mm7, %%mm6 \n\t" /* buf0[eax] - buf1[eax]*/\
457 "pmulhw "LUM_MMX_FILTER_OFFSET"+8("#c"), %%mm0 \n\t" /* (buf0[eax] - buf1[eax])yalpha1>>16*/\
458 "pmulhw "LUM_MMX_FILTER_OFFSET"+8("#c"), %%mm6 \n\t" /* (buf0[eax] - buf1[eax])yalpha1>>16*/\
459 "psraw $4, %%mm1 \n\t" /* buf0[eax] - buf1[eax] >>4*/\
460 "psraw $4, %%mm7 \n\t" /* buf0[eax] - buf1[eax] >>4*/\
461 "paddw %%mm0, %%mm1 \n\t" /* buf0[eax]yalpha1 + buf1[eax](1-yalpha1) >>16*/\
462 "paddw %%mm6, %%mm7 \n\t" /* buf0[eax]yalpha1 + buf1[eax](1-yalpha1) >>16*/\
463 "pmulhw "UB_COEFF"("#c"), %%mm2 \n\t"\
464 "pmulhw "VR_COEFF"("#c"), %%mm5 \n\t"\
465 "psubw "Y_OFFSET"("#c"), %%mm1 \n\t" /* 8(Y-16)*/\
466 "psubw "Y_OFFSET"("#c"), %%mm7 \n\t" /* 8(Y-16)*/\
467 "pmulhw "Y_COEFF"("#c"), %%mm1 \n\t"\
468 "pmulhw "Y_COEFF"("#c"), %%mm7 \n\t"\
469 /* mm1= Y1, mm2=ub, mm3=ug, mm4=vg mm5=vr, mm7=Y2 */\
470 "paddw %%mm3, %%mm4 \n\t"\
471 "movq %%mm2, %%mm0 \n\t"\
472 "movq %%mm5, %%mm6 \n\t"\
473 "movq %%mm4, %%mm3 \n\t"\
474 "punpcklwd %%mm2, %%mm2 \n\t"\
475 "punpcklwd %%mm5, %%mm5 \n\t"\
476 "punpcklwd %%mm4, %%mm4 \n\t"\
477 "paddw %%mm1, %%mm2 \n\t"\
478 "paddw %%mm1, %%mm5 \n\t"\
479 "paddw %%mm1, %%mm4 \n\t"\
480 "punpckhwd %%mm0, %%mm0 \n\t"\
481 "punpckhwd %%mm6, %%mm6 \n\t"\
482 "punpckhwd %%mm3, %%mm3 \n\t"\
483 "paddw %%mm7, %%mm0 \n\t"\
484 "paddw %%mm7, %%mm6 \n\t"\
485 "paddw %%mm7, %%mm3 \n\t"\
486 /* mm0=B1, mm2=B2, mm3=G2, mm4=G1, mm5=R1, mm6=R2 */\
487 "packuswb %%mm0, %%mm2 \n\t"\
488 "packuswb %%mm6, %%mm5 \n\t"\
489 "packuswb %%mm3, %%mm4 \n\t"\
490 "pxor %%mm7, %%mm7 \n\t"
491 #define YSCALEYUV2RGB(index, c) REAL_YSCALEYUV2RGB(index, c)
492
493 #define REAL_YSCALEYUV2PACKED1(index, c) \
494 "xor "#index", "#index" \n\t"\
495 ASMALIGN(4)\
496 "1: \n\t"\
497 "movq (%2, "#index"), %%mm3 \n\t" /* uvbuf0[eax]*/\
498 "movq "AV_STRINGIFY(VOF)"(%2, "#index"), %%mm4 \n\t" /* uvbuf0[eax+2048]*/\
499 "psraw $7, %%mm3 \n\t" \
500 "psraw $7, %%mm4 \n\t" \
501 "movq (%0, "#index", 2), %%mm1 \n\t" /*buf0[eax]*/\
502 "movq 8(%0, "#index", 2), %%mm7 \n\t" /*buf0[eax]*/\
503 "psraw $7, %%mm1 \n\t" \
504 "psraw $7, %%mm7 \n\t" \
505
506 #define YSCALEYUV2PACKED1(index, c) REAL_YSCALEYUV2PACKED1(index, c)
507
508 #define REAL_YSCALEYUV2RGB1(index, c) \
509 "xor "#index", "#index" \n\t"\
510 ASMALIGN(4)\
511 "1: \n\t"\
512 "movq (%2, "#index"), %%mm3 \n\t" /* uvbuf0[eax]*/\
513 "movq "AV_STRINGIFY(VOF)"(%2, "#index"), %%mm4 \n\t" /* uvbuf0[eax+2048]*/\
514 "psraw $4, %%mm3 \n\t" /* uvbuf0[eax] - uvbuf1[eax] >>4*/\
515 "psraw $4, %%mm4 \n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048] >>4*/\
516 "psubw "U_OFFSET"("#c"), %%mm3 \n\t" /* (U-128)8*/\
517 "psubw "V_OFFSET"("#c"), %%mm4 \n\t" /* (V-128)8*/\
518 "movq %%mm3, %%mm2 \n\t" /* (U-128)8*/\
519 "movq %%mm4, %%mm5 \n\t" /* (V-128)8*/\
520 "pmulhw "UG_COEFF"("#c"), %%mm3 \n\t"\
521 "pmulhw "VG_COEFF"("#c"), %%mm4 \n\t"\
522 /* mm2=(U-128)8, mm3=ug, mm4=vg mm5=(V-128)8 */\
523 "movq (%0, "#index", 2), %%mm1 \n\t" /*buf0[eax]*/\
524 "movq 8(%0, "#index", 2), %%mm7 \n\t" /*buf0[eax]*/\
525 "psraw $4, %%mm1 \n\t" /* buf0[eax] - buf1[eax] >>4*/\
526 "psraw $4, %%mm7 \n\t" /* buf0[eax] - buf1[eax] >>4*/\
527 "pmulhw "UB_COEFF"("#c"), %%mm2 \n\t"\
528 "pmulhw "VR_COEFF"("#c"), %%mm5 \n\t"\
529 "psubw "Y_OFFSET"("#c"), %%mm1 \n\t" /* 8(Y-16)*/\
530 "psubw "Y_OFFSET"("#c"), %%mm7 \n\t" /* 8(Y-16)*/\
531 "pmulhw "Y_COEFF"("#c"), %%mm1 \n\t"\
532 "pmulhw "Y_COEFF"("#c"), %%mm7 \n\t"\
533 /* mm1= Y1, mm2=ub, mm3=ug, mm4=vg mm5=vr, mm7=Y2 */\
534 "paddw %%mm3, %%mm4 \n\t"\
535 "movq %%mm2, %%mm0 \n\t"\
536 "movq %%mm5, %%mm6 \n\t"\
537 "movq %%mm4, %%mm3 \n\t"\
538 "punpcklwd %%mm2, %%mm2 \n\t"\
539 "punpcklwd %%mm5, %%mm5 \n\t"\
540 "punpcklwd %%mm4, %%mm4 \n\t"\
541 "paddw %%mm1, %%mm2 \n\t"\
542 "paddw %%mm1, %%mm5 \n\t"\
543 "paddw %%mm1, %%mm4 \n\t"\
544 "punpckhwd %%mm0, %%mm0 \n\t"\
545 "punpckhwd %%mm6, %%mm6 \n\t"\
546 "punpckhwd %%mm3, %%mm3 \n\t"\
547 "paddw %%mm7, %%mm0 \n\t"\
548 "paddw %%mm7, %%mm6 \n\t"\
549 "paddw %%mm7, %%mm3 \n\t"\
550 /* mm0=B1, mm2=B2, mm3=G2, mm4=G1, mm5=R1, mm6=R2 */\
551 "packuswb %%mm0, %%mm2 \n\t"\
552 "packuswb %%mm6, %%mm5 \n\t"\
553 "packuswb %%mm3, %%mm4 \n\t"\
554 "pxor %%mm7, %%mm7 \n\t"
555 #define YSCALEYUV2RGB1(index, c) REAL_YSCALEYUV2RGB1(index, c)
556
557 #define REAL_YSCALEYUV2PACKED1b(index, c) \
558 "xor "#index", "#index" \n\t"\
559 ASMALIGN(4)\
560 "1: \n\t"\
561 "movq (%2, "#index"), %%mm2 \n\t" /* uvbuf0[eax]*/\
562 "movq (%3, "#index"), %%mm3 \n\t" /* uvbuf1[eax]*/\
563 "movq "AV_STRINGIFY(VOF)"(%2, "#index"), %%mm5 \n\t" /* uvbuf0[eax+2048]*/\
564 "movq "AV_STRINGIFY(VOF)"(%3, "#index"), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\
565 "paddw %%mm2, %%mm3 \n\t" /* uvbuf0[eax] + uvbuf1[eax]*/\
566 "paddw %%mm5, %%mm4 \n\t" /* uvbuf0[eax+2048] + uvbuf1[eax+2048]*/\
567 "psrlw $8, %%mm3 \n\t" \
568 "psrlw $8, %%mm4 \n\t" \
569 "movq (%0, "#index", 2), %%mm1 \n\t" /*buf0[eax]*/\
570 "movq 8(%0, "#index", 2), %%mm7 \n\t" /*buf0[eax]*/\
571 "psraw $7, %%mm1 \n\t" \
572 "psraw $7, %%mm7 \n\t"
573 #define YSCALEYUV2PACKED1b(index, c) REAL_YSCALEYUV2PACKED1b(index, c)
574
575 // do vertical chrominance interpolation
576 #define REAL_YSCALEYUV2RGB1b(index, c) \
577 "xor "#index", "#index" \n\t"\
578 ASMALIGN(4)\
579 "1: \n\t"\
580 "movq (%2, "#index"), %%mm2 \n\t" /* uvbuf0[eax]*/\
581 "movq (%3, "#index"), %%mm3 \n\t" /* uvbuf1[eax]*/\
582 "movq "AV_STRINGIFY(VOF)"(%2, "#index"), %%mm5 \n\t" /* uvbuf0[eax+2048]*/\
583 "movq "AV_STRINGIFY(VOF)"(%3, "#index"), %%mm4 \n\t" /* uvbuf1[eax+2048]*/\
584 "paddw %%mm2, %%mm3 \n\t" /* uvbuf0[eax] + uvbuf1[eax]*/\
585 "paddw %%mm5, %%mm4 \n\t" /* uvbuf0[eax+2048] + uvbuf1[eax+2048]*/\
586 "psrlw $5, %%mm3 \n\t" /*FIXME might overflow*/\
587 "psrlw $5, %%mm4 \n\t" /*FIXME might overflow*/\
588 "psubw "U_OFFSET"("#c"), %%mm3 \n\t" /* (U-128)8*/\
589 "psubw "V_OFFSET"("#c"), %%mm4 \n\t" /* (V-128)8*/\
590 "movq %%mm3, %%mm2 \n\t" /* (U-128)8*/\
591 "movq %%mm4, %%mm5 \n\t" /* (V-128)8*/\
592 "pmulhw "UG_COEFF"("#c"), %%mm3 \n\t"\
593 "pmulhw "VG_COEFF"("#c"), %%mm4 \n\t"\
594 /* mm2=(U-128)8, mm3=ug, mm4=vg mm5=(V-128)8 */\
595 "movq (%0, "#index", 2), %%mm1 \n\t" /*buf0[eax]*/\
596 "movq 8(%0, "#index", 2), %%mm7 \n\t" /*buf0[eax]*/\
597 "psraw $4, %%mm1 \n\t" /* buf0[eax] - buf1[eax] >>4*/\
598 "psraw $4, %%mm7 \n\t" /* buf0[eax] - buf1[eax] >>4*/\
599 "pmulhw "UB_COEFF"("#c"), %%mm2 \n\t"\
600 "pmulhw "VR_COEFF"("#c"), %%mm5 \n\t"\
601 "psubw "Y_OFFSET"("#c"), %%mm1 \n\t" /* 8(Y-16)*/\
602 "psubw "Y_OFFSET"("#c"), %%mm7 \n\t" /* 8(Y-16)*/\
603 "pmulhw "Y_COEFF"("#c"), %%mm1 \n\t"\
604 "pmulhw "Y_COEFF"("#c"), %%mm7 \n\t"\
605 /* mm1= Y1, mm2=ub, mm3=ug, mm4=vg mm5=vr, mm7=Y2 */\
606 "paddw %%mm3, %%mm4 \n\t"\
607 "movq %%mm2, %%mm0 \n\t"\
608 "movq %%mm5, %%mm6 \n\t"\
609 "movq %%mm4, %%mm3 \n\t"\
610 "punpcklwd %%mm2, %%mm2 \n\t"\
611 "punpcklwd %%mm5, %%mm5 \n\t"\
612 "punpcklwd %%mm4, %%mm4 \n\t"\
613 "paddw %%mm1, %%mm2 \n\t"\
614 "paddw %%mm1, %%mm5 \n\t"\
615 "paddw %%mm1, %%mm4 \n\t"\
616 "punpckhwd %%mm0, %%mm0 \n\t"\
617 "punpckhwd %%mm6, %%mm6 \n\t"\
618 "punpckhwd %%mm3, %%mm3 \n\t"\
619 "paddw %%mm7, %%mm0 \n\t"\
620 "paddw %%mm7, %%mm6 \n\t"\
621 "paddw %%mm7, %%mm3 \n\t"\
622 /* mm0=B1, mm2=B2, mm3=G2, mm4=G1, mm5=R1, mm6=R2 */\
623 "packuswb %%mm0, %%mm2 \n\t"\
624 "packuswb %%mm6, %%mm5 \n\t"\
625 "packuswb %%mm3, %%mm4 \n\t"\
626 "pxor %%mm7, %%mm7 \n\t"
627 #define YSCALEYUV2RGB1b(index, c) REAL_YSCALEYUV2RGB1b(index, c)
628
629 #define REAL_WRITEBGR32(dst, dstw, index) \
630 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */\
631 "movq %%mm2, %%mm1 \n\t" /* B */\
632 "movq %%mm5, %%mm6 \n\t" /* R */\
633 "punpcklbw %%mm4, %%mm2 \n\t" /* GBGBGBGB 0 */\
634 "punpcklbw %%mm7, %%mm5 \n\t" /* 0R0R0R0R 0 */\
635 "punpckhbw %%mm4, %%mm1 \n\t" /* GBGBGBGB 2 */\
636 "punpckhbw %%mm7, %%mm6 \n\t" /* 0R0R0R0R 2 */\
637 "movq %%mm2, %%mm0 \n\t" /* GBGBGBGB 0 */\
638 "movq %%mm1, %%mm3 \n\t" /* GBGBGBGB 2 */\
639 "punpcklwd %%mm5, %%mm0 \n\t" /* 0RGB0RGB 0 */\
640 "punpckhwd %%mm5, %%mm2 \n\t" /* 0RGB0RGB 1 */\
641 "punpcklwd %%mm6, %%mm1 \n\t" /* 0RGB0RGB 2 */\
642 "punpckhwd %%mm6, %%mm3 \n\t" /* 0RGB0RGB 3 */\
643 \
644 MOVNTQ(%%mm0, (dst, index, 4))\
645 MOVNTQ(%%mm2, 8(dst, index, 4))\
646 MOVNTQ(%%mm1, 16(dst, index, 4))\
647 MOVNTQ(%%mm3, 24(dst, index, 4))\
648 \
649 "add $8, "#index" \n\t"\
650 "cmp "#dstw", "#index" \n\t"\
651 " jb 1b \n\t"
652 #define WRITEBGR32(dst, dstw, index) REAL_WRITEBGR32(dst, dstw, index)
653
654 #define REAL_WRITERGB16(dst, dstw, index) \
655 "pand "MANGLE(bF8)", %%mm2 \n\t" /* B */\
656 "pand "MANGLE(bFC)", %%mm4 \n\t" /* G */\
657 "pand "MANGLE(bF8)", %%mm5 \n\t" /* R */\
658 "psrlq $3, %%mm2 \n\t"\
659 \
660 "movq %%mm2, %%mm1 \n\t"\
661 "movq %%mm4, %%mm3 \n\t"\
662 \
663 "punpcklbw %%mm7, %%mm3 \n\t"\
664 "punpcklbw %%mm5, %%mm2 \n\t"\
665 "punpckhbw %%mm7, %%mm4 \n\t"\
666 "punpckhbw %%mm5, %%mm1 \n\t"\
667 \
668 "psllq $3, %%mm3 \n\t"\
669 "psllq $3, %%mm4 \n\t"\
670 \
671 "por %%mm3, %%mm2 \n\t"\
672 "por %%mm4, %%mm1 \n\t"\
673 \
674 MOVNTQ(%%mm2, (dst, index, 2))\
675 MOVNTQ(%%mm1, 8(dst, index, 2))\
676 \
677 "add $8, "#index" \n\t"\
678 "cmp "#dstw", "#index" \n\t"\
679 " jb 1b \n\t"
680 #define WRITERGB16(dst, dstw, index) REAL_WRITERGB16(dst, dstw, index)
681
682 #define REAL_WRITERGB15(dst, dstw, index) \
683 "pand "MANGLE(bF8)", %%mm2 \n\t" /* B */\
684 "pand "MANGLE(bF8)", %%mm4 \n\t" /* G */\
685 "pand "MANGLE(bF8)", %%mm5 \n\t" /* R */\
686 "psrlq $3, %%mm2 \n\t"\
687 "psrlq $1, %%mm5 \n\t"\
688 \
689 "movq %%mm2, %%mm1 \n\t"\
690 "movq %%mm4, %%mm3 \n\t"\
691 \
692 "punpcklbw %%mm7, %%mm3 \n\t"\
693 "punpcklbw %%mm5, %%mm2 \n\t"\
694 "punpckhbw %%mm7, %%mm4 \n\t"\
695 "punpckhbw %%mm5, %%mm1 \n\t"\
696 \
697 "psllq $2, %%mm3 \n\t"\
698 "psllq $2, %%mm4 \n\t"\
699 \
700 "por %%mm3, %%mm2 \n\t"\
701 "por %%mm4, %%mm1 \n\t"\
702 \
703 MOVNTQ(%%mm2, (dst, index, 2))\
704 MOVNTQ(%%mm1, 8(dst, index, 2))\
705 \
706 "add $8, "#index" \n\t"\
707 "cmp "#dstw", "#index" \n\t"\
708 " jb 1b \n\t"
709 #define WRITERGB15(dst, dstw, index) REAL_WRITERGB15(dst, dstw, index)
710
711 #define WRITEBGR24OLD(dst, dstw, index) \
712 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */\
713 "movq %%mm2, %%mm1 \n\t" /* B */\
714 "movq %%mm5, %%mm6 \n\t" /* R */\
715 "punpcklbw %%mm4, %%mm2 \n\t" /* GBGBGBGB 0 */\
716 "punpcklbw %%mm7, %%mm5 \n\t" /* 0R0R0R0R 0 */\
717 "punpckhbw %%mm4, %%mm1 \n\t" /* GBGBGBGB 2 */\
718 "punpckhbw %%mm7, %%mm6 \n\t" /* 0R0R0R0R 2 */\
719 "movq %%mm2, %%mm0 \n\t" /* GBGBGBGB 0 */\
720 "movq %%mm1, %%mm3 \n\t" /* GBGBGBGB 2 */\
721 "punpcklwd %%mm5, %%mm0 \n\t" /* 0RGB0RGB 0 */\
722 "punpckhwd %%mm5, %%mm2 \n\t" /* 0RGB0RGB 1 */\
723 "punpcklwd %%mm6, %%mm1 \n\t" /* 0RGB0RGB 2 */\
724 "punpckhwd %%mm6, %%mm3 \n\t" /* 0RGB0RGB 3 */\
725 \
726 "movq %%mm0, %%mm4 \n\t" /* 0RGB0RGB 0 */\
727 "psrlq $8, %%mm0 \n\t" /* 00RGB0RG 0 */\
728 "pand "MANGLE(bm00000111)", %%mm4 \n\t" /* 00000RGB 0 */\
729 "pand "MANGLE(bm11111000)", %%mm0 \n\t" /* 00RGB000 0.5 */\
730 "por %%mm4, %%mm0 \n\t" /* 00RGBRGB 0 */\
731 "movq %%mm2, %%mm4 \n\t" /* 0RGB0RGB 1 */\
732 "psllq $48, %%mm2 \n\t" /* GB000000 1 */\
733 "por %%mm2, %%mm0 \n\t" /* GBRGBRGB 0 */\
734 \
735 "movq %%mm4, %%mm2 \n\t" /* 0RGB0RGB 1 */\
736 "psrld $16, %%mm4 \n\t" /* 000R000R 1 */\
737 "psrlq $24, %%mm2 \n\t" /* 0000RGB0 1.5 */\
738 "por %%mm4, %%mm2 \n\t" /* 000RRGBR 1 */\
739 "pand "MANGLE(bm00001111)", %%mm2 \n\t" /* 0000RGBR 1 */\
740 "movq %%mm1, %%mm4 \n\t" /* 0RGB0RGB 2 */\
741 "psrlq $8, %%mm1 \n\t" /* 00RGB0RG 2 */\
742 "pand "MANGLE(bm00000111)", %%mm4 \n\t" /* 00000RGB 2 */\
743 "pand "MANGLE(bm11111000)", %%mm1 \n\t" /* 00RGB000 2.5 */\
744 "por %%mm4, %%mm1 \n\t" /* 00RGBRGB 2 */\
745 "movq %%mm1, %%mm4 \n\t" /* 00RGBRGB 2 */\
746 "psllq $32, %%mm1 \n\t" /* BRGB0000 2 */\
747 "por %%mm1, %%mm2 \n\t" /* BRGBRGBR 1 */\
748 \
749 "psrlq $32, %%mm4 \n\t" /* 000000RG 2.5 */\
750 "movq %%mm3, %%mm5 \n\t" /* 0RGB0RGB 3 */\
751 "psrlq $8, %%mm3 \n\t" /* 00RGB0RG 3 */\
752 "pand "MANGLE(bm00000111)", %%mm5 \n\t" /* 00000RGB 3 */\
753 "pand "MANGLE(bm11111000)", %%mm3 \n\t" /* 00RGB000 3.5 */\
754 "por %%mm5, %%mm3 \n\t" /* 00RGBRGB 3 */\
755 "psllq $16, %%mm3 \n\t" /* RGBRGB00 3 */\
756 "por %%mm4, %%mm3 \n\t" /* RGBRGBRG 2.5 */\
757 \
758 MOVNTQ(%%mm0, (dst))\
759 MOVNTQ(%%mm2, 8(dst))\
760 MOVNTQ(%%mm3, 16(dst))\
761 "add $24, "#dst" \n\t"\
762 \
763 "add $8, "#index" \n\t"\
764 "cmp "#dstw", "#index" \n\t"\
765 " jb 1b \n\t"
766
767 #define WRITEBGR24MMX(dst, dstw, index) \
768 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */\
769 "movq %%mm2, %%mm1 \n\t" /* B */\
770 "movq %%mm5, %%mm6 \n\t" /* R */\
771 "punpcklbw %%mm4, %%mm2 \n\t" /* GBGBGBGB 0 */\
772 "punpcklbw %%mm7, %%mm5 \n\t" /* 0R0R0R0R 0 */\
773 "punpckhbw %%mm4, %%mm1 \n\t" /* GBGBGBGB 2 */\
774 "punpckhbw %%mm7, %%mm6 \n\t" /* 0R0R0R0R 2 */\
775 "movq %%mm2, %%mm0 \n\t" /* GBGBGBGB 0 */\
776 "movq %%mm1, %%mm3 \n\t" /* GBGBGBGB 2 */\
777 "punpcklwd %%mm5, %%mm0 \n\t" /* 0RGB0RGB 0 */\
778 "punpckhwd %%mm5, %%mm2 \n\t" /* 0RGB0RGB 1 */\
779 "punpcklwd %%mm6, %%mm1 \n\t" /* 0RGB0RGB 2 */\
780 "punpckhwd %%mm6, %%mm3 \n\t" /* 0RGB0RGB 3 */\
781 \
782 "movq %%mm0, %%mm4 \n\t" /* 0RGB0RGB 0 */\
783 "movq %%mm2, %%mm6 \n\t" /* 0RGB0RGB 1 */\
784 "movq %%mm1, %%mm5 \n\t" /* 0RGB0RGB 2 */\
785 "movq %%mm3, %%mm7 \n\t" /* 0RGB0RGB 3 */\
786 \
787 "psllq $40, %%mm0 \n\t" /* RGB00000 0 */\
788 "psllq $40, %%mm2 \n\t" /* RGB00000 1 */\
789 "psllq $40, %%mm1 \n\t" /* RGB00000 2 */\
790 "psllq $40, %%mm3 \n\t" /* RGB00000 3 */\
791 \
792 "punpckhdq %%mm4, %%mm0 \n\t" /* 0RGBRGB0 0 */\
793 "punpckhdq %%mm6, %%mm2 \n\t" /* 0RGBRGB0 1 */\
794 "punpckhdq %%mm5, %%mm1 \n\t" /* 0RGBRGB0 2 */\
795 "punpckhdq %%mm7, %%mm3 \n\t" /* 0RGBRGB0 3 */\
796 \
797 "psrlq $8, %%mm0 \n\t" /* 00RGBRGB 0 */\
798 "movq %%mm2, %%mm6 \n\t" /* 0RGBRGB0 1 */\
799 "psllq $40, %%mm2 \n\t" /* GB000000 1 */\
800 "por %%mm2, %%mm0 \n\t" /* GBRGBRGB 0 */\
801 MOVNTQ(%%mm0, (dst))\
802 \
803 "psrlq $24, %%mm6 \n\t" /* 0000RGBR 1 */\
804 "movq %%mm1, %%mm5 \n\t" /* 0RGBRGB0 2 */\
805 "psllq $24, %%mm1 \n\t" /* BRGB0000 2 */\
806 "por %%mm1, %%mm6 \n\t" /* BRGBRGBR 1 */\
807 MOVNTQ(%%mm6, 8(dst))\
808 \
809 "psrlq $40, %%mm5 \n\t" /* 000000RG 2 */\
810 "psllq $8, %%mm3 \n\t" /* RGBRGB00 3 */\
811 "por %%mm3, %%mm5 \n\t" /* RGBRGBRG 2 */\
812 MOVNTQ(%%mm5, 16(dst))\
813 \
814 "add $24, "#dst" \n\t"\
815 \
816 "add $8, "#index" \n\t"\
817 "cmp "#dstw", "#index" \n\t"\
818 " jb 1b \n\t"
819
820 #define WRITEBGR24MMX2(dst, dstw, index) \
821 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */\
822 "movq "MANGLE(ff_M24A)", %%mm0 \n\t"\
823 "movq "MANGLE(ff_M24C)", %%mm7 \n\t"\
824 "pshufw $0x50, %%mm2, %%mm1 \n\t" /* B3 B2 B3 B2 B1 B0 B1 B0 */\
825 "pshufw $0x50, %%mm4, %%mm3 \n\t" /* G3 G2 G3 G2 G1 G0 G1 G0 */\
826 "pshufw $0x00, %%mm5, %%mm6 \n\t" /* R1 R0 R1 R0 R1 R0 R1 R0 */\
827 \
828 "pand %%mm0, %%mm1 \n\t" /* B2 B1 B0 */\
829 "pand %%mm0, %%mm3 \n\t" /* G2 G1 G0 */\
830 "pand %%mm7, %%mm6 \n\t" /* R1 R0 */\
831 \
832 "psllq $8, %%mm3 \n\t" /* G2 G1 G0 */\
833 "por %%mm1, %%mm6 \n\t"\
834 "por %%mm3, %%mm6 \n\t"\
835 MOVNTQ(%%mm6, (dst))\
836 \
837 "psrlq $8, %%mm4 \n\t" /* 00 G7 G6 G5 G4 G3 G2 G1 */\
838 "pshufw $0xA5, %%mm2, %%mm1 \n\t" /* B5 B4 B5 B4 B3 B2 B3 B2 */\
839 "pshufw $0x55, %%mm4, %%mm3 \n\t" /* G4 G3 G4 G3 G4 G3 G4 G3 */\
840 "pshufw $0xA5, %%mm5, %%mm6 \n\t" /* R5 R4 R5 R4 R3 R2 R3 R2 */\
841 \
842 "pand "MANGLE(ff_M24B)", %%mm1 \n\t" /* B5 B4 B3 */\
843 "pand %%mm7, %%mm3 \n\t" /* G4 G3 */\
844 "pand %%mm0, %%mm6 \n\t" /* R4 R3 R2 */\
845 \
846 "por %%mm1, %%mm3 \n\t" /* B5 G4 B4 G3 B3 */\
847 "por %%mm3, %%mm6 \n\t"\
848 MOVNTQ(%%mm6, 8(dst))\
849 \
850 "pshufw $0xFF, %%mm2, %%mm1 \n\t" /* B7 B6 B7 B6 B7 B6 B6 B7 */\
851 "pshufw $0xFA, %%mm4, %%mm3 \n\t" /* 00 G7 00 G7 G6 G5 G6 G5 */\
852 "pshufw $0xFA, %%mm5, %%mm6 \n\t" /* R7 R6 R7 R6 R5 R4 R5 R4 */\
853 \
854 "pand %%mm7, %%mm1 \n\t" /* B7 B6 */\
855 "pand %%mm0, %%mm3 \n\t" /* G7 G6 G5 */\
856 "pand "MANGLE(ff_M24B)", %%mm6 \n\t" /* R7 R6 R5 */\
857 \
858 "por %%mm1, %%mm3 \n\t"\
859 "por %%mm3, %%mm6 \n\t"\
860 MOVNTQ(%%mm6, 16(dst))\
861 \
862 "add $24, "#dst" \n\t"\
863 \
864 "add $8, "#index" \n\t"\
865 "cmp "#dstw", "#index" \n\t"\
866 " jb 1b \n\t"
867
868 #if HAVE_MMX2
869 #undef WRITEBGR24
870 #define WRITEBGR24(dst, dstw, index) WRITEBGR24MMX2(dst, dstw, index)
871 #else
872 #undef WRITEBGR24
873 #define WRITEBGR24(dst, dstw, index) WRITEBGR24MMX(dst, dstw, index)
874 #endif
875
876 #define REAL_WRITEYUY2(dst, dstw, index) \
877 "packuswb %%mm3, %%mm3 \n\t"\
878 "packuswb %%mm4, %%mm4 \n\t"\
879 "packuswb %%mm7, %%mm1 \n\t"\
880 "punpcklbw %%mm4, %%mm3 \n\t"\
881 "movq %%mm1, %%mm7 \n\t"\
882 "punpcklbw %%mm3, %%mm1 \n\t"\
883 "punpckhbw %%mm3, %%mm7 \n\t"\
884 \
885 MOVNTQ(%%mm1, (dst, index, 2))\
886 MOVNTQ(%%mm7, 8(dst, index, 2))\
887 \
888 "add $8, "#index" \n\t"\
889 "cmp "#dstw", "#index" \n\t"\
890 " jb 1b \n\t"
891 #define WRITEYUY2(dst, dstw, index) REAL_WRITEYUY2(dst, dstw, index)
892
893
894 static inline void RENAME(yuv2yuvX)(SwsContext *c, int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
895 int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
896 uint8_t *dest, uint8_t *uDest, uint8_t *vDest, long dstW, long chrDstW)
897 {
898 #if HAVE_MMX
899 if(!(c->flags & SWS_BITEXACT)){
900 if (c->flags & SWS_ACCURATE_RND){
901 if (uDest){
902 YSCALEYUV2YV12X_ACCURATE( "0", CHR_MMX_FILTER_OFFSET, uDest, chrDstW)
903 YSCALEYUV2YV12X_ACCURATE(AV_STRINGIFY(VOF), CHR_MMX_FILTER_OFFSET, vDest, chrDstW)
904 }
905
906 YSCALEYUV2YV12X_ACCURATE("0", LUM_MMX_FILTER_OFFSET, dest, dstW)
907 }else{
908 if (uDest){
909 YSCALEYUV2YV12X( "0", CHR_MMX_FILTER_OFFSET, uDest, chrDstW)
910 YSCALEYUV2YV12X(AV_STRINGIFY(VOF), CHR_MMX_FILTER_OFFSET, vDest, chrDstW)
911 }
912
913 YSCALEYUV2YV12X("0", LUM_MMX_FILTER_OFFSET, dest, dstW)
914 }
915 return;
916 }
917 #endif
918 #if HAVE_ALTIVEC
919 yuv2yuvX_altivec_real(lumFilter, lumSrc, lumFilterSize,
920 chrFilter, chrSrc, chrFilterSize,
921 dest, uDest, vDest, dstW, chrDstW);
922 #else //HAVE_ALTIVEC
923 yuv2yuvXinC(lumFilter, lumSrc, lumFilterSize,
924 chrFilter, chrSrc, chrFilterSize,
925 dest, uDest, vDest, dstW, chrDstW);
926 #endif //!HAVE_ALTIVEC
927 }
928
929 static inline void RENAME(yuv2nv12X)(SwsContext *c, int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
930 int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
931 uint8_t *dest, uint8_t *uDest, int dstW, int chrDstW, int dstFormat)
932 {
933 yuv2nv12XinC(lumFilter, lumSrc, lumFilterSize,
934 chrFilter, chrSrc, chrFilterSize,
935 dest, uDest, dstW, chrDstW, dstFormat);
936 }
937
938 static inline void RENAME(yuv2yuv1)(SwsContext *c, int16_t *lumSrc, int16_t *chrSrc,
939 uint8_t *dest, uint8_t *uDest, uint8_t *vDest, long dstW, long chrDstW)
940 {
941 int i;
942 #if HAVE_MMX
943 if(!(c->flags & SWS_BITEXACT)){
944 long p= uDest ? 3 : 1;
945 uint8_t *src[3]= {lumSrc + dstW, chrSrc + chrDstW, chrSrc + VOFW + chrDstW};
946 uint8_t *dst[3]= {dest, uDest, vDest};
947 long counter[3] = {dstW, chrDstW, chrDstW};
948
949 if (c->flags & SWS_ACCURATE_RND){
950 while(p--){
951 __asm__ volatile(
952 YSCALEYUV2YV121_ACCURATE
953 :: "r" (src[p]), "r" (dst[p] + counter[p]),
954 "g" (-counter[p])
955 : "%"REG_a
956 );
957 }
958 }else{
959 while(p--){
960 __asm__ volatile(
961 YSCALEYUV2YV121
962 :: "r" (src[p]), "r" (dst[p] + counter[p]),
963 "g" (-counter[p])
964 : "%"REG_a
965 );
966 }
967 }
968 return;
969 }
970 #endif
971 for (i=0; i<dstW; i++)
972 {
973 int val= (lumSrc[i]+64)>>7;
974
975 if (val&256){
976 if (val<0) val=0;
977 else val=255;
978 }
979
980 dest[i]= val;
981 }
982
983 if (uDest)
984 for (i=0; i<chrDstW; i++)
985 {
986 int u=(chrSrc[i ]+64)>>7;
987 int v=(chrSrc[i + VOFW]+64)>>7;
988
989 if ((u|v)&256){
990 if (u<0) u=0;
991 else if (u>255) u=255;
992 if (v<0) v=0;
993 else if (v>255) v=255;
994 }
995
996 uDest[i]= u;
997 vDest[i]= v;
998 }
999 }
1000
1001
1002 /**
1003 * vertical scale YV12 to RGB
1004 */
1005 static inline void RENAME(yuv2packedX)(SwsContext *c, int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
1006 int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
1007 uint8_t *dest, long dstW, long dstY)
1008 {
1009 #if HAVE_MMX
1010 long dummy=0;
1011 if(!(c->flags & SWS_BITEXACT)){
1012 if (c->flags & SWS_ACCURATE_RND){
1013 switch(c->dstFormat){
1014 case PIX_FMT_RGB32:
1015 YSCALEYUV2PACKEDX_ACCURATE
1016 YSCALEYUV2RGBX
1017 WRITEBGR32(%4, %5, %%REGa)
1018
1019 YSCALEYUV2PACKEDX_END
1020 return;
1021 case PIX_FMT_BGR24:
1022 YSCALEYUV2PACKEDX_ACCURATE
1023 YSCALEYUV2RGBX
1024 "lea (%%"REG_a", %%"REG_a", 2), %%"REG_c"\n\t" //FIXME optimize
1025 "add %4, %%"REG_c" \n\t"
1026 WRITEBGR24(%%REGc, %5, %%REGa)
1027
1028
1029 :: "r" (&c->redDither),
1030 "m" (dummy), "m" (dummy), "m" (dummy),
1031 "r" (dest), "m" (dstW)
1032 : "%"REG_a, "%"REG_c, "%"REG_d, "%"REG_S
1033 );
1034 return;
1035 case PIX_FMT_RGB555:
1036 YSCALEYUV2PACKEDX_ACCURATE
1037 YSCALEYUV2RGBX
1038 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
1039 #ifdef DITHER1XBPP
1040 "paddusb "BLUE_DITHER"(%0), %%mm2\n\t"
1041 "paddusb "GREEN_DITHER"(%0), %%mm4\n\t"
1042 "paddusb "RED_DITHER"(%0), %%mm5\n\t"
1043 #endif
1044
1045 WRITERGB15(%4, %5, %%REGa)
1046 YSCALEYUV2PACKEDX_END
1047 return;
1048 case PIX_FMT_RGB565:
1049 YSCALEYUV2PACKEDX_ACCURATE
1050 YSCALEYUV2RGBX
1051 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
1052 #ifdef DITHER1XBPP
1053 "paddusb "BLUE_DITHER"(%0), %%mm2\n\t"
1054 "paddusb "GREEN_DITHER"(%0), %%mm4\n\t"
1055 "paddusb "RED_DITHER"(%0), %%mm5\n\t"
1056 #endif
1057
1058 WRITERGB16(%4, %5, %%REGa)
1059 YSCALEYUV2PACKEDX_END
1060 return;
1061 case PIX_FMT_YUYV422:
1062 YSCALEYUV2PACKEDX_ACCURATE
1063 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
1064
1065 "psraw $3, %%mm3 \n\t"
1066 "psraw $3, %%mm4 \n\t"
1067 "psraw $3, %%mm1 \n\t"
1068 "psraw $3, %%mm7 \n\t"
1069 WRITEYUY2(%4, %5, %%REGa)
1070 YSCALEYUV2PACKEDX_END
1071 return;
1072 }
1073 }else{
1074 switch(c->dstFormat)
1075 {
1076 case PIX_FMT_RGB32:
1077 YSCALEYUV2PACKEDX
1078 YSCALEYUV2RGBX
1079 WRITEBGR32(%4, %5, %%REGa)
1080 YSCALEYUV2PACKEDX_END
1081 return;
1082 case PIX_FMT_BGR24:
1083 YSCALEYUV2PACKEDX
1084 YSCALEYUV2RGBX
1085 "lea (%%"REG_a", %%"REG_a", 2), %%"REG_c" \n\t" //FIXME optimize
1086 "add %4, %%"REG_c" \n\t"
1087 WRITEBGR24(%%REGc, %5, %%REGa)
1088
1089 :: "r" (&c->redDither),
1090 "m" (dummy), "m" (dummy), "m" (dummy),
1091 "r" (dest), "m" (dstW)
1092 : "%"REG_a, "%"REG_c, "%"REG_d, "%"REG_S
1093 );
1094 return;
1095 case PIX_FMT_RGB555:
1096 YSCALEYUV2PACKEDX
1097 YSCALEYUV2RGBX
1098 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
1099 #ifdef DITHER1XBPP
1100 "paddusb "BLUE_DITHER"(%0), %%mm2 \n\t"
1101 "paddusb "GREEN_DITHER"(%0), %%mm4 \n\t"
1102 "paddusb "RED_DITHER"(%0), %%mm5 \n\t"
1103 #endif
1104
1105 WRITERGB15(%4, %5, %%REGa)
1106 YSCALEYUV2PACKEDX_END
1107 return;
1108 case PIX_FMT_RGB565:
1109 YSCALEYUV2PACKEDX
1110 YSCALEYUV2RGBX
1111 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
1112 #ifdef DITHER1XBPP
1113 "paddusb "BLUE_DITHER"(%0), %%mm2 \n\t"
1114 "paddusb "GREEN_DITHER"(%0), %%mm4 \n\t"
1115 "paddusb "RED_DITHER"(%0), %%mm5 \n\t"
1116 #endif
1117
1118 WRITERGB16(%4, %5, %%REGa)
1119 YSCALEYUV2PACKEDX_END
1120 return;
1121 case PIX_FMT_YUYV422:
1122 YSCALEYUV2PACKEDX
1123 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
1124
1125 "psraw $3, %%mm3 \n\t"
1126 "psraw $3, %%mm4 \n\t"
1127 "psraw $3, %%mm1 \n\t"
1128 "psraw $3, %%mm7 \n\t"
1129 WRITEYUY2(%4, %5, %%REGa)
1130 YSCALEYUV2PACKEDX_END
1131 return;
1132 }
1133 }
1134 }
1135 #endif /* HAVE_MMX */
1136 #if HAVE_ALTIVEC
1137 /* The following list of supported dstFormat values should
1138 match what's found in the body of altivec_yuv2packedX() */
1139 if (!(c->flags & SWS_BITEXACT) &&
1140 (c->dstFormat==PIX_FMT_ABGR || c->dstFormat==PIX_FMT_BGRA ||
1141 c->dstFormat==PIX_FMT_BGR24 || c->dstFormat==PIX_FMT_RGB24 ||
1142 c->dstFormat==PIX_FMT_RGBA || c->dstFormat==PIX_FMT_ARGB))
1143 altivec_yuv2packedX (c, lumFilter, lumSrc, lumFilterSize,
1144 chrFilter, chrSrc, chrFilterSize,
1145 dest, dstW, dstY);
1146 else
1147 #endif
1148 yuv2packedXinC(c, lumFilter, lumSrc, lumFilterSize,
1149 chrFilter, chrSrc, chrFilterSize,
1150 dest, dstW, dstY);
1151 }
1152
1153 /**
1154 * vertical bilinear scale YV12 to RGB
1155 */
1156 static inline void RENAME(yuv2packed2)(SwsContext *c, uint16_t *buf0, uint16_t *buf1, uint16_t *uvbuf0, uint16_t *uvbuf1,
1157 uint8_t *dest, int dstW, int yalpha, int uvalpha, int y)
1158 {
1159 int yalpha1=4095- yalpha;
1160 int uvalpha1=4095-uvalpha;
1161 int i;
1162
1163 #if HAVE_MMX
1164 if(!(c->flags & SWS_BITEXACT)){
1165 switch(c->dstFormat)
1166 {
1167 //Note 8280 == DSTW_OFFSET but the preprocessor can't handle that there :(
1168 case PIX_FMT_RGB32:
1169 __asm__ volatile(
1170 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1171 "mov %4, %%"REG_b" \n\t"
1172 "push %%"REG_BP" \n\t"
1173 YSCALEYUV2RGB(%%REGBP, %5)
1174 WRITEBGR32(%%REGb, 8280(%5), %%REGBP)
1175 "pop %%"REG_BP" \n\t"
1176 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1177
1178 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1179 "a" (&c->redDither)
1180 );
1181 return;
1182 case PIX_FMT_BGR24:
1183 __asm__ volatile(
1184 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1185 "mov %4, %%"REG_b" \n\t"
1186 "push %%"REG_BP" \n\t"
1187 YSCALEYUV2RGB(%%REGBP, %5)
1188 WRITEBGR24(%%REGb, 8280(%5), %%REGBP)
1189 "pop %%"REG_BP" \n\t"
1190 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1191 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1192 "a" (&c->redDither)
1193 );
1194 return;
1195 case PIX_FMT_RGB555:
1196 __asm__ volatile(
1197 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1198 "mov %4, %%"REG_b" \n\t"
1199 "push %%"REG_BP" \n\t"
1200 YSCALEYUV2RGB(%%REGBP, %5)
1201 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
1202 #ifdef DITHER1XBPP
1203 "paddusb "BLUE_DITHER"(%5), %%mm2 \n\t"
1204 "paddusb "GREEN_DITHER"(%5), %%mm4 \n\t"
1205 "paddusb "RED_DITHER"(%5), %%mm5 \n\t"
1206 #endif
1207
1208 WRITERGB15(%%REGb, 8280(%5), %%REGBP)
1209 "pop %%"REG_BP" \n\t"
1210 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1211
1212 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1213 "a" (&c->redDither)
1214 );
1215 return;
1216 case PIX_FMT_RGB565:
1217 __asm__ volatile(
1218 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1219 "mov %4, %%"REG_b" \n\t"
1220 "push %%"REG_BP" \n\t"
1221 YSCALEYUV2RGB(%%REGBP, %5)
1222 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
1223 #ifdef DITHER1XBPP
1224 "paddusb "BLUE_DITHER"(%5), %%mm2 \n\t"
1225 "paddusb "GREEN_DITHER"(%5), %%mm4 \n\t"
1226 "paddusb "RED_DITHER"(%5), %%mm5 \n\t"
1227 #endif
1228
1229 WRITERGB16(%%REGb, 8280(%5), %%REGBP)
1230 "pop %%"REG_BP" \n\t"
1231 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1232 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1233 "a" (&c->redDither)
1234 );
1235 return;
1236 case PIX_FMT_YUYV422:
1237 __asm__ volatile(
1238 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1239 "mov %4, %%"REG_b" \n\t"
1240 "push %%"REG_BP" \n\t"
1241 YSCALEYUV2PACKED(%%REGBP, %5)
1242 WRITEYUY2(%%REGb, 8280(%5), %%REGBP)
1243 "pop %%"REG_BP" \n\t"
1244 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1245 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1246 "a" (&c->redDither)
1247 );
1248 return;
1249 default: break;
1250 }
1251 }
1252 #endif //HAVE_MMX
1253 YSCALE_YUV_2_ANYRGB_C(YSCALE_YUV_2_RGB2_C, YSCALE_YUV_2_PACKED2_C, YSCALE_YUV_2_GRAY16_2_C, YSCALE_YUV_2_MONO2_C)
1254 }
1255
1256 /**
1257 * YV12 to RGB without scaling or interpolating
1258 */
1259 static inline void RENAME(yuv2packed1)(SwsContext *c, uint16_t *buf0, uint16_t *uvbuf0, uint16_t *uvbuf1,
1260 uint8_t *dest, int dstW, int uvalpha, int dstFormat, int flags, int y)
1261 {
1262 const int yalpha1=0;
1263 int i;
1264
1265 uint16_t *buf1= buf0; //FIXME needed for RGB1/BGR1
1266 const int yalpha= 4096; //FIXME ...
1267
1268 if (flags&SWS_FULL_CHR_H_INT)
1269 {
1270 RENAME(yuv2packed2)(c, buf0, buf0, uvbuf0, uvbuf1, dest, dstW, 0, uvalpha, y);
1271 return;
1272 }
1273
1274 #if HAVE_MMX
1275 if(!(flags & SWS_BITEXACT)){
1276 if (uvalpha < 2048) // note this is not correct (shifts chrominance by 0.5 pixels) but it is a bit faster
1277 {
1278 switch(dstFormat)
1279 {
1280 case PIX_FMT_RGB32:
1281 __asm__ volatile(
1282 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1283 "mov %4, %%"REG_b" \n\t"
1284 "push %%"REG_BP" \n\t"
1285 YSCALEYUV2RGB1(%%REGBP, %5)
1286 WRITEBGR32(%%REGb, 8280(%5), %%REGBP)
1287 "pop %%"REG_BP" \n\t"
1288 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1289
1290 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1291 "a" (&c->redDither)
1292 );
1293 return;
1294 case PIX_FMT_BGR24:
1295 __asm__ volatile(
1296 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1297 "mov %4, %%"REG_b" \n\t"
1298 "push %%"REG_BP" \n\t"
1299 YSCALEYUV2RGB1(%%REGBP, %5)
1300 WRITEBGR24(%%REGb, 8280(%5), %%REGBP)
1301 "pop %%"REG_BP" \n\t"
1302 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1303
1304 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1305 "a" (&c->redDither)
1306 );
1307 return;
1308 case PIX_FMT_RGB555:
1309 __asm__ volatile(
1310 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1311 "mov %4, %%"REG_b" \n\t"
1312 "push %%"REG_BP" \n\t"
1313 YSCALEYUV2RGB1(%%REGBP, %5)
1314 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
1315 #ifdef DITHER1XBPP
1316 "paddusb "BLUE_DITHER"(%5), %%mm2 \n\t"
1317 "paddusb "GREEN_DITHER"(%5), %%mm4 \n\t"
1318 "paddusb "RED_DITHER"(%5), %%mm5 \n\t"
1319 #endif
1320 WRITERGB15(%%REGb, 8280(%5), %%REGBP)
1321 "pop %%"REG_BP" \n\t"
1322 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1323
1324 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1325 "a" (&c->redDither)
1326 );
1327 return;
1328 case PIX_FMT_RGB565:
1329 __asm__ volatile(
1330 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1331 "mov %4, %%"REG_b" \n\t"
1332 "push %%"REG_BP" \n\t"
1333 YSCALEYUV2RGB1(%%REGBP, %5)
1334 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
1335 #ifdef DITHER1XBPP
1336 "paddusb "BLUE_DITHER"(%5), %%mm2 \n\t"
1337 "paddusb "GREEN_DITHER"(%5), %%mm4 \n\t"
1338 "paddusb "RED_DITHER"(%5), %%mm5 \n\t"
1339 #endif
1340
1341 WRITERGB16(%%REGb, 8280(%5), %%REGBP)
1342 "pop %%"REG_BP" \n\t"
1343 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1344
1345 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1346 "a" (&c->redDither)
1347 );
1348 return;
1349 case PIX_FMT_YUYV422:
1350 __asm__ volatile(
1351 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1352 "mov %4, %%"REG_b" \n\t"
1353 "push %%"REG_BP" \n\t"
1354 YSCALEYUV2PACKED1(%%REGBP, %5)
1355 WRITEYUY2(%%REGb, 8280(%5), %%REGBP)
1356 "pop %%"REG_BP" \n\t"
1357 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1358
1359 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1360 "a" (&c->redDither)
1361 );
1362 return;
1363 }
1364 }
1365 else
1366 {
1367 switch(dstFormat)
1368 {
1369 case PIX_FMT_RGB32:
1370 __asm__ volatile(
1371 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1372 "mov %4, %%"REG_b" \n\t"
1373 "push %%"REG_BP" \n\t"
1374 YSCALEYUV2RGB1b(%%REGBP, %5)
1375 WRITEBGR32(%%REGb, 8280(%5), %%REGBP)
1376 "pop %%"REG_BP" \n\t"
1377 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1378
1379 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1380 "a" (&c->redDither)
1381 );
1382 return;
1383 case PIX_FMT_BGR24:
1384 __asm__ volatile(
1385 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1386 "mov %4, %%"REG_b" \n\t"
1387 "push %%"REG_BP" \n\t"
1388 YSCALEYUV2RGB1b(%%REGBP, %5)
1389 WRITEBGR24(%%REGb, 8280(%5), %%REGBP)
1390 "pop %%"REG_BP" \n\t"
1391 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1392
1393 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1394 "a" (&c->redDither)
1395 );
1396 return;
1397 case PIX_FMT_RGB555:
1398 __asm__ volatile(
1399 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1400 "mov %4, %%"REG_b" \n\t"
1401 "push %%"REG_BP" \n\t"
1402 YSCALEYUV2RGB1b(%%REGBP, %5)
1403 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
1404 #ifdef DITHER1XBPP
1405 "paddusb "BLUE_DITHER"(%5), %%mm2 \n\t"
1406 "paddusb "GREEN_DITHER"(%5), %%mm4 \n\t"
1407 "paddusb "RED_DITHER"(%5), %%mm5 \n\t"
1408 #endif
1409 WRITERGB15(%%REGb, 8280(%5), %%REGBP)
1410 "pop %%"REG_BP" \n\t"
1411 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1412
1413 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1414 "a" (&c->redDither)
1415 );
1416 return;
1417 case PIX_FMT_RGB565:
1418 __asm__ volatile(
1419 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1420 "mov %4, %%"REG_b" \n\t"
1421 "push %%"REG_BP" \n\t"
1422 YSCALEYUV2RGB1b(%%REGBP, %5)
1423 /* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */
1424 #ifdef DITHER1XBPP
1425 "paddusb "BLUE_DITHER"(%5), %%mm2 \n\t"
1426 "paddusb "GREEN_DITHER"(%5), %%mm4 \n\t"
1427 "paddusb "RED_DITHER"(%5), %%mm5 \n\t"
1428 #endif
1429
1430 WRITERGB16(%%REGb, 8280(%5), %%REGBP)
1431 "pop %%"REG_BP" \n\t"
1432 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1433
1434 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1435 "a" (&c->redDither)
1436 );
1437 return;
1438 case PIX_FMT_YUYV422:
1439 __asm__ volatile(
1440 "mov %%"REG_b", "ESP_OFFSET"(%5) \n\t"
1441 "mov %4, %%"REG_b" \n\t"
1442 "push %%"REG_BP" \n\t"
1443 YSCALEYUV2PACKED1b(%%REGBP, %5)
1444 WRITEYUY2(%%REGb, 8280(%5), %%REGBP)
1445 "pop %%"REG_BP" \n\t"
1446 "mov "ESP_OFFSET"(%5), %%"REG_b" \n\t"
1447
1448 :: "c" (buf0), "d" (buf1), "S" (uvbuf0), "D" (uvbuf1), "m" (dest),
1449 "a" (&c->redDither)
1450 );
1451 return;
1452 }
1453 }
1454 }
1455 #endif /* HAVE_MMX */
1456 if (uvalpha < 2048)
1457 {
1458 YSCALE_YUV_2_ANYRGB_C(YSCALE_YUV_2_RGB1_C, YSCALE_YUV_2_PACKED1_C, YSCALE_YUV_2_GRAY16_1_C, YSCALE_YUV_2_MONO2_C)
1459 }else{
1460 YSCALE_YUV_2_ANYRGB_C(YSCALE_YUV_2_RGB1B_C, YSCALE_YUV_2_PACKED1B_C, YSCALE_YUV_2_GRAY16_1_C, YSCALE_YUV_2_MONO2_C)
1461 }
1462 }
1463
1464 //FIXME yuy2* can read up to 7 samples too much
1465
1466 static inline void RENAME(yuy2ToY)(uint8_t *dst, uint8_t *src, long width, uint32_t *unused)
1467 {
1468 #if HAVE_MMX
1469 __asm__ volatile(
1470 "movq "MANGLE(bm01010101)", %%mm2 \n\t"
1471 "mov %0, %%"REG_a" \n\t"
1472 "1: \n\t"
1473 "movq (%1, %%"REG_a",2), %%mm0 \n\t"
1474 "movq 8(%1, %%"REG_a",2), %%mm1 \n\t"
1475 "pand %%mm2, %%mm0 \n\t"
1476 "pand %%mm2, %%mm1 \n\t"
1477 "packuswb %%mm1, %%mm0 \n\t"
1478 "movq %%mm0, (%2, %%"REG_a") \n\t"
1479 "add $8, %%"REG_a" \n\t"
1480 " js 1b \n\t"
1481 : : "g" (-width), "r" (src+width*2), "r" (dst+width)
1482 : "%"REG_a
1483 );
1484 #else
1485 int i;
1486 for (i=0; i<width; i++)
1487 dst[i]= src[2*i];
1488 #endif
1489 }
1490
1491 static inline void RENAME(yuy2ToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, long width, uint32_t *unused)
1492 {
1493 #if HAVE_MMX
1494 __asm__ volatile(
1495 "movq "MANGLE(bm01010101)", %%mm4 \n\t"
1496 "mov %0, %%"REG_a" \n\t"
1497 "1: \n\t"
1498 "movq (%1, %%"REG_a",4), %%mm0 \n\t"
1499 "movq 8(%1, %%"REG_a",4), %%mm1 \n\t"
1500 "psrlw $8, %%mm0 \n\t"
1501 "psrlw $8, %%mm1 \n\t"
1502 "packuswb %%mm1, %%mm0 \n\t"
1503 "movq %%mm0, %%mm1 \n\t"
1504 "psrlw $8, %%mm0 \n\t"
1505 "pand %%mm4, %%mm1 \n\t"
1506 "packuswb %%mm0, %%mm0 \n\t"
1507 "packuswb %%mm1, %%mm1 \n\t"
1508 "movd %%mm0, (%3, %%"REG_a") \n\t"
1509 "movd %%mm1, (%2, %%"REG_a") \n\t"
1510 "add $4, %%"REG_a" \n\t"
1511 " js 1b \n\t"
1512 : : "g" (-width), "r" (src1+width*4), "r" (dstU+width), "r" (dstV+width)
1513 : "%"REG_a
1514 );
1515 #else
1516 int i;
1517 for (i=0; i<width; i++)
1518 {
1519 dstU[i]= src1[4*i + 1];
1520 dstV[i]= src1[4*i + 3];
1521 }
1522 #endif
1523 assert(src1 == src2);
1524 }
1525
1526 /* This is almost identical to the previous, end exists only because
1527 * yuy2ToY/UV)(dst, src+1, ...) would have 100% unaligned accesses. */
1528 static inline void RENAME(uyvyToY)(uint8_t *dst, uint8_t *src, long width, uint32_t *unused)
1529 {
1530 #if HAVE_MMX
1531 __asm__ volatile(
1532 "mov %0, %%"REG_a" \n\t"
1533 "1: \n\t"
1534 "movq (%1, %%"REG_a",2), %%mm0 \n\t"
1535 "movq 8(%1, %%"REG_a",2), %%mm1 \n\t"
1536 "psrlw $8, %%mm0 \n\t"
1537 "psrlw $8, %%mm1 \n\t"
1538 "packuswb %%mm1, %%mm0 \n\t"
1539 "movq %%mm0, (%2, %%"REG_a") \n\t"
1540 "add $8, %%"REG_a" \n\t"
1541 " js 1b \n\t"
1542 : : "g" (-width), "r" (src+width*2), "r" (dst+width)
1543 : "%"REG_a
1544 );
1545 #else
1546 int i;
1547 for (i=0; i<width; i++)
1548 dst[i]= src[2*i+1];
1549 #endif
1550 }
1551
1552 static inline void RENAME(uyvyToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, long width, uint32_t *unused)
1553 {
1554 #if HAVE_MMX
1555 __asm__ volatile(
1556 "movq "MANGLE(bm01010101)", %%mm4 \n\t"
1557 "mov %0, %%"REG_a" \n\t"
1558 "1: \n\t"
1559 "movq (%1, %%"REG_a",4), %%mm0 \n\t"
1560 "movq 8(%1, %%"REG_a",4), %%mm1 \n\t"
1561 "pand %%mm4, %%mm0 \n\t"
1562 "pand %%mm4, %%mm1 \n\t"
1563 "packuswb %%mm1, %%mm0 \n\t"
1564 "movq %%mm0, %%mm1 \n\t"
1565 "psrlw $8, %%mm0 \n\t"
1566 "pand %%mm4, %%mm1 \n\t"
1567 "packuswb %%mm0, %%mm0 \n\t"
1568 "packuswb %%mm1, %%mm1 \n\t"
1569 "movd %%mm0, (%3, %%"REG_a") \n\t"
1570 "movd %%mm1, (%2, %%"REG_a") \n\t"
1571 "add $4, %%"REG_a" \n\t"
1572 " js 1b \n\t"
1573 : : "g" (-width), "r" (src1+width*4), "r" (dstU+width), "r" (dstV+width)
1574 : "%"REG_a
1575 );
1576 #else
1577 int i;
1578 for (i=0; i<width; i++)
1579 {
1580 dstU[i]= src1[4*i + 0];
1581 dstV[i]= src1[4*i + 2];
1582 }
1583 #endif
1584 assert(src1 == src2);
1585 }
1586
1587 #define BGR2Y(type, name, shr, shg, shb, maskr, maskg, maskb, RY, GY, BY, S)\
1588 static inline void RENAME(name)(uint8_t *dst, uint8_t *src, long width, uint32_t *unused)\
1589 {\
1590 int i;\
1591 for (i=0; i<width; i++)\
1592 {\
1593 int b= (((type*)src)[i]>>shb)&maskb;\
1594 int g= (((type*)src)[i]>>shg)&maskg;\
1595 int r= (((type*)src)[i]>>shr)&maskr;\
1596 \
1597 dst[i]= (((RY)*r + (GY)*g + (BY)*b + (33<<((S)-1)))>>(S));\
1598 }\
1599 }
1600
1601 BGR2Y(uint32_t, bgr32ToY,16, 0, 0, 0x00FF, 0xFF00, 0x00FF, RY<< 8, GY , BY<< 8, RGB2YUV_SHIFT+8)
1602 BGR2Y(uint32_t, rgb32ToY, 0, 0,16, 0x00FF, 0xFF00, 0x00FF, RY<< 8, GY , BY<< 8, RGB2YUV_SHIFT+8)
1603 BGR2Y(uint16_t, bgr16ToY, 0, 0, 0, 0x001F, 0x07E0, 0xF800, RY<<11, GY<<5, BY , RGB2YUV_SHIFT+8)
1604 BGR2Y(uint16_t, bgr15ToY, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, RY<<10, GY<<5, BY , RGB2YUV_SHIFT+7)
1605 BGR2Y(uint16_t, rgb16ToY, 0, 0, 0, 0xF800, 0x07E0, 0x001F, RY , GY<<5, BY<<11, RGB2YUV_SHIFT+8)
1606 BGR2Y(uint16_t, rgb15ToY, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, RY , GY<<5, BY<<10, RGB2YUV_SHIFT+7)
1607
1608 #define BGR2UV(type, name, shr, shg, shb, maskr, maskg, maskb, RU, GU, BU, RV, GV, BV, S)\
1609 static inline void RENAME(name)(uint8_t *dstU, uint8_t *dstV, uint8_t *src, uint8_t *dummy, long width, uint32_t *unused)\
1610 {\
1611 int i;\
1612 for (i=0; i<width; i++)\
1613 {\
1614 int b= (((type*)src)[i]&maskb)>>shb;\
1615 int g= (((type*)src)[i]&maskg)>>shg;\
1616 int r= (((type*)src)[i]&maskr)>>shr;\
1617 \
1618 dstU[i]= ((RU)*r + (GU)*g + (BU)*b + (257<<((S)-1)))>>(S);\
1619 dstV[i]= ((RV)*r + (GV)*g + (BV)*b + (257<<((S)-1)))>>(S);\
1620 }\
1621 }\
1622 static inline void RENAME(name ## _half)(uint8_t *dstU, uint8_t *dstV, uint8_t *src, uint8_t *dummy, long width, uint32_t *unused)\
1623 {\
1624 int i;\
1625 for (i=0; i<width; i++)\
1626 {\
1627 int pix0= ((type*)src)[2*i+0];\
1628 int pix1= ((type*)src)[2*i+1];\
1629 int g= (pix0&maskg)+(pix1&maskg);\
1630 int b= ((pix0+pix1-g)&(maskb|(2*maskb)))>>shb;\
1631 int r= ((pix0+pix1-g)&(maskr|(2*maskr)))>>shr;\
1632 \
1633 g>>=shg;\
1634 \
1635 dstU[i]= ((RU)*r + (GU)*g + (BU)*b + (257<<(S)))>>((S)+1);\
1636 dstV[i]= ((RV)*r + (GV)*g + (BV)*b + (257<<(S)))>>((S)+1);\
1637 }\
1638 }
1639
1640 BGR2UV(uint32_t, bgr32ToUV,16, 0, 0, 0xFF0000, 0xFF00, 0x00FF, RU<< 8, GU , BU<< 8, RV<< 8, GV , BV<< 8, RGB2YUV_SHIFT+8)
1641 BGR2UV(uint32_t, rgb32ToUV, 0, 0,16, 0x00FF, 0xFF00, 0xFF0000, RU<< 8, GU , BU<< 8, RV<< 8, GV , BV<< 8, RGB2YUV_SHIFT+8)
1642 BGR2UV(uint16_t, bgr16ToUV, 0, 0, 0, 0x001F, 0x07E0, 0xF800, RU<<11, GU<<5, BU , RV<<11, GV<<5, BV , RGB2YUV_SHIFT+8)
1643 BGR2UV(uint16_t, bgr15ToUV, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, RU<<10, GU<<5, BU , RV<<10, GV<<5, BV , RGB2YUV_SHIFT+7)
1644 BGR2UV(uint16_t, rgb16ToUV, 0, 0, 0, 0xF800, 0x07E0, 0x001F, RU , GU<<5, BU<<11, RV , GV<<5, BV<<11, RGB2YUV_SHIFT+8)
1645 BGR2UV(uint16_t, rgb15ToUV, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, RU , GU<<5, BU<<10, RV , GV<<5, BV<<10, RGB2YUV_SHIFT+7)
1646
1647 #if HAVE_MMX
1648 static inline void RENAME(bgr24ToY_mmx)(uint8_t *dst, uint8_t *src, long width, int srcFormat)
1649 {
1650
1651 if(srcFormat == PIX_FMT_BGR24){
1652 __asm__ volatile(
1653 "movq "MANGLE(ff_bgr24toY1Coeff)", %%mm5 \n\t"
1654 "movq "MANGLE(ff_bgr24toY2Coeff)", %%mm6 \n\t"
1655 :
1656 );
1657 }else{
1658 __asm__ volatile(
1659 "movq "MANGLE(ff_rgb24toY1Coeff)", %%mm5 \n\t"
1660 "movq "MANGLE(ff_rgb24toY2Coeff)", %%mm6 \n\t"
1661 :
1662 );
1663 }
1664
1665 __asm__ volatile(
1666 "movq "MANGLE(ff_bgr24toYOffset)", %%mm4 \n\t"
1667 "mov %2, %%"REG_a" \n\t"
1668 "pxor %%mm7, %%mm7 \n\t"
1669 "1: \n\t"
1670 PREFETCH" 64(%0) \n\t"
1671 "movd (%0), %%mm0 \n\t"
1672 "movd 2(%0), %%mm1 \n\t"
1673 "movd 6(%0), %%mm2 \n\t"
1674 "movd 8(%0), %%mm3 \n\t"
1675 "add $12, %0 \n\t"
1676 "punpcklbw %%mm7, %%mm0 \n\t"
1677 "punpcklbw %%mm7, %%mm1 \n\t"
1678 "punpcklbw %%mm7, %%mm2 \n\t"
1679 "punpcklbw %%mm7, %%mm3 \n\t"
1680 "pmaddwd %%mm5, %%mm0 \n\t"
1681 "pmaddwd %%mm6, %%mm1 \n\t"
1682 "pmaddwd %%mm5, %%mm2 \n\t"
1683 "pmaddwd %%mm6, %%mm3 \n\t"
1684 "paddd %%mm1, %%mm0 \n\t"
1685 "paddd %%mm3, %%mm2 \n\t"
1686 "paddd %%mm4, %%mm0 \n\t"
1687 "paddd %%mm4, %%mm2 \n\t"
1688 "psrad $15, %%mm0 \n\t"
1689 "psrad $15, %%mm2 \n\t"
1690 "packssdw %%mm2, %%mm0 \n\t"
1691 "packuswb %%mm0, %%mm0 \n\t"
1692 "movd %%mm0, (%1, %%"REG_a") \n\t"
1693 "add $4, %%"REG_a" \n\t"
1694 " js 1b \n\t"
1695 : "+r" (src)
1696 : "r" (dst+width), "g" (-width)
1697 : "%"REG_a
1698 );
1699 }
1700
1701 static inline void RENAME(bgr24ToUV_mmx)(uint8_t *dstU, uint8_t *dstV, uint8_t *src, long width, int srcFormat)
1702 {
1703 __asm__ volatile(
1704 "movq 24+%4, %%mm6 \n\t"
1705 "mov %3, %%"REG_a" \n\t"
1706 "pxor %%mm7, %%mm7 \n\t"
1707 "1: \n\t"
1708 PREFETCH" 64(%0) \n\t"
1709 "movd (%0), %%mm0 \n\t"
1710 "movd 2(%0), %%mm1 \n\t"
1711 "punpcklbw %%mm7, %%mm0 \n\t"
1712 "punpcklbw %%mm7, %%mm1 \n\t"
1713 "movq %%mm0, %%mm2 \n\t"
1714 "movq %%mm1, %%mm3 \n\t"
1715 "pmaddwd %4, %%mm0 \n\t"
1716 "pmaddwd 8+%4, %%mm1 \n\t"
1717 "pmaddwd 16+%4, %%mm2 \n\t"
1718 "pmaddwd %%mm6, %%mm3 \n\t"
1719 "paddd %%mm1, %%mm0 \n\t"
1720 "paddd %%mm3, %%mm2 \n\t"
1721
1722 "movd 6(%0), %%mm1 \n\t"
1723 "movd 8(%0), %%mm3 \n\t"
1724 "add $12, %0 \n\t"
1725 "punpcklbw %%mm7, %%mm1 \n\t"
1726 "punpcklbw %%mm7, %%mm3 \n\t"
1727 "movq %%mm1, %%mm4 \n\t"
1728 "movq %%mm3, %%mm5 \n\t"
1729 "pmaddwd %4, %%mm1 \n\t"
1730 "pmaddwd 8+%4, %%mm3 \n\t"
1731 "pmaddwd 16+%4, %%mm4 \n\t"
1732 "pmaddwd %%mm6, %%mm5 \n\t"
1733 "paddd %%mm3, %%mm1 \n\t"
1734 "paddd %%mm5, %%mm4 \n\t"
1735
1736 "movq "MANGLE(ff_bgr24toUVOffset)", %%mm3 \n\t"
1737 "paddd %%mm3, %%mm0 \n\t"
1738 "paddd %%mm3, %%mm2 \n\t"
1739 "paddd %%mm3, %%mm1 \n\t"
1740 "paddd %%mm3, %%mm4 \n\t"
1741 "psrad $15, %%mm0 \n\t"
1742 "psrad $15, %%mm2 \n\t"
1743 "psrad $15, %%mm1 \n\t"
1744 "psrad $15, %%mm4 \n\t"
1745 "packssdw %%mm1, %%mm0 \n\t"
1746 "packssdw %%mm4, %%mm2 \n\t"
1747 "packuswb %%mm0, %%mm0 \n\t"
1748 "packuswb %%mm2, %%mm2 \n\t"
1749 "movd %%mm0, (%1, %%"REG_a") \n\t"
1750 "movd %%mm2, (%2, %%"REG_a") \n\t"
1751 "add $4, %%"REG_a" \n\t"
1752 " js 1b \n\t"
1753 : "+r" (src)
1754 : "r" (dstU+width), "r" (dstV+width), "g" (-width), "m"(ff_bgr24toUV[srcFormat == PIX_FMT_RGB24][0])
1755 : "%"REG_a
1756 );
1757 }
1758 #endif
1759
1760 static inline void RENAME(bgr24ToY)(uint8_t *dst, uint8_t *src, long width, uint32_t *unused)
1761 {
1762 #if HAVE_MMX
1763 RENAME(bgr24ToY_mmx)(dst, src, width, PIX_FMT_BGR24);
1764 #else
1765 int i;
1766 for (i=0; i<width; i++)
1767 {
1768 int b= src[i*3+0];
1769 int g= src[i*3+1];
1770 int r= src[i*3+2];
1771
1772 dst[i]= ((RY*r + GY*g + BY*b + (33<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);
1773 }
1774 #endif /* HAVE_MMX */
1775 }
1776
1777 static inline void RENAME(bgr24ToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, long width, uint32_t *unused)
1778 {
1779 #if HAVE_MMX
1780 RENAME(bgr24ToUV_mmx)(dstU, dstV, src1, width, PIX_FMT_BGR24);
1781 #else
1782 int i;
1783 for (i=0; i<width; i++)
1784 {
1785 int b= src1[3*i + 0];
1786 int g= src1[3*i + 1];
1787 int r= src1[3*i + 2];
1788
1789 dstU[i]= (RU*r + GU*g + BU*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT;
1790 dstV[i]= (RV*r + GV*g + BV*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT;
1791 }
1792 #endif /* HAVE_MMX */
1793 assert(src1 == src2);
1794 }
1795
1796 static inline void RENAME(bgr24ToUV_half)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, long width, uint32_t *unused)
1797 {
1798 int i;
1799 for (i=0; i<width; i++)
1800 {
1801 int b= src1[6*i + 0] + src1[6*i + 3];
1802 int g= src1[6*i + 1] + src1[6*i + 4];
1803 int r= src1[6*i + 2] + src1[6*i + 5];
1804
1805 dstU[i]= (RU*r + GU*g + BU*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);
1806 dstV[i]= (RV*r + GV*g + BV*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);
1807 }
1808 assert(src1 == src2);
1809 }
1810
1811 static inline void RENAME(rgb24ToY)(uint8_t *dst, uint8_t *src, long width, uint32_t *unused)
1812 {
1813 #if HAVE_MMX
1814 RENAME(bgr24ToY_mmx)(dst, src, width, PIX_FMT_RGB24);
1815 #else
1816 int i;
1817 for (i=0; i<width; i++)
1818 {
1819 int r= src[i*3+0];
1820 int g= src[i*3+1];
1821 int b= src[i*3+2];
1822
1823 dst[i]= ((RY*r + GY*g + BY*b + (33<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);
1824 }
1825 #endif
1826 }
1827
1828 static inline void RENAME(rgb24ToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, long width, uint32_t *unused)
1829 {
1830 #if HAVE_MMX
1831 assert(src1==src2);
1832 RENAME(bgr24ToUV_mmx)(dstU, dstV, src1, width, PIX_FMT_RGB24);
1833 #else
1834 int i;
1835 assert(src1==src2);
1836 for (i=0; i<width; i++)
1837 {
1838 int r= src1[3*i + 0];
1839 int g= src1[3*i + 1];
1840 int b= src1[3*i + 2];
1841
1842 dstU[i]= (RU*r + GU*g + BU*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT;
1843 dstV[i]= (RV*r + GV*g + BV*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT;
1844 }
1845 #endif
1846 }
1847
1848 static inline void RENAME(rgb24ToUV_half)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, long width, uint32_t *unused)
1849 {
1850 int i;
1851 assert(src1==src2);
1852 for (i=0; i<width; i++)
1853 {
1854 int r= src1[6*i + 0] + src1[6*i + 3];
1855 int g= src1[6*i + 1] + src1[6*i + 4];
1856 int b= src1[6*i + 2] + src1[6*i + 5];
1857
1858 dstU[i]= (RU*r + GU*g + BU*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);
1859 dstV[i]= (RV*r + GV*g + BV*b + (257<<RGB2YUV_SHIFT))>>(RGB2YUV_SHIFT+1);
1860 }
1861 }
1862
1863
1864 static inline void RENAME(palToY)(uint8_t *dst, uint8_t *src, long width, uint32_t *pal)
1865 {
1866 int i;
1867 for (i=0; i<width; i++)
1868 {
1869 int d= src[i];
1870
1871 dst[i]= pal[d] & 0xFF;
1872 }
1873 }
1874
1875 static inline void RENAME(palToUV)(uint8_t *dstU, uint8_t *dstV, uint8_t *src1, uint8_t *src2, long width, uint32_t *pal)
1876 {
1877 int i;
1878 assert(src1 == src2);
1879 for (i=0; i<width; i++)
1880 {
1881 int p= pal[src1[i]];
1882
1883 dstU[i]= p>>8;
1884 dstV[i]= p>>16;
1885 }
1886 }
1887
1888 static inline void RENAME(monowhite2Y)(uint8_t *dst, uint8_t *src, long width, uint32_t *unused)
1889 {
1890 int i, j;
1891 for (i=0; i<width/8; i++){
1892 int d= ~src[i];
1893 for(j=0; j<8; j++)
1894 dst[8*i+j]= ((d>>(7-j))&1)*255;
1895 }
1896 }
1897
1898 static inline void RENAME(monoblack2Y)(uint8_t *dst, uint8_t *src, long width, uint32_t *unused)
1899 {
1900 int i, j;
1901 for (i=0; i<width/8; i++){
1902 int d= src[i];
1903 for(j=0; j<8; j++)
1904 dst[8*i+j]= ((d>>(7-j))&1)*255;
1905 }
1906 }
1907
1908 // bilinear / bicubic scaling
1909 static inline void RENAME(hScale)(int16_t *dst, int dstW, uint8_t *src, int srcW, int xInc,
1910 int16_t *filter, int16_t *filterPos, long filterSize)
1911 {
1912 #if HAVE_MMX
1913 assert(filterSize % 4 == 0 && filterSize>0);
1914 if (filterSize==4) // Always true for upscaling, sometimes for down, too.
1915 {
1916 long counter= -2*dstW;
1917 filter-= counter*2;
1918 filterPos-= counter/2;
1919 dst-= counter/2;
1920 __asm__ volatile(
1921 #if defined(PIC)
1922 "push %%"REG_b" \n\t"
1923 #endif
1924 "pxor %%mm7, %%mm7 \n\t"
1925 "push %%"REG_BP" \n\t" // we use 7 regs here ...
1926 "mov %%"REG_a", %%"REG_BP" \n\t"
1927 ASMALIGN(4)
1928 "1: \n\t"
1929 "movzwl (%2, %%"REG_BP"), %%eax \n\t"
1930 "movzwl 2(%2, %%"REG_BP"), %%ebx \n\t"
1931 "movq (%1, %%"REG_BP", 4), %%mm1 \n\t"
1932 "movq 8(%1, %%"REG_BP", 4), %%mm3 \n\t"
1933 "movd (%3, %%"REG_a"), %%mm0 \n\t"
1934 "movd (%3, %%"REG_b"), %%mm2 \n\t"
1935 "punpcklbw %%mm7, %%mm0 \n\t"
1936 "punpcklbw %%mm7, %%mm2 \n\t"
1937 "pmaddwd %%mm1, %%mm0 \n\t"
1938 "pmaddwd %%mm2, %%mm3 \n\t"
1939 "movq %%mm0, %%mm4 \n\t"
1940 "punpckldq %%mm3, %%mm0 \n\t"
1941 "punpckhdq %%mm3, %%mm4 \n\t"
1942 "paddd %%mm4, %%mm0 \n\t"
1943 "psrad $7, %%mm0 \n\t"
1944 "packssdw %%mm0, %%mm0 \n\t"
1945 "movd %%mm0, (%4, %%"REG_BP") \n\t"
1946 "add $4, %%"REG_BP" \n\t"
1947 " jnc 1b \n\t"
1948
1949 "pop %%"REG_BP" \n\t"
1950 #if defined(PIC)
1951 "pop %%"REG_b" \n\t"
1952 #endif
1953 : "+a" (counter)
1954 : "c" (filter), "d" (filterPos), "S" (src), "D" (dst)
1955 #if !defined(PIC)
1956 : "%"REG_b
1957 #endif
1958 );
1959 }
1960 else if (filterSize==8)
1961 {
1962 long counter= -2*dstW;
1963 filter-= counter*4;
1964 filterPos-= counter/2;
1965 dst-= counter/2;
1966 __asm__ volatile(
1967 #if defined(PIC)
1968 "push %%"REG_b" \n\t"
1969 #endif
1970 "pxor %%mm7, %%mm7 \n\t"
1971 "push %%"REG_BP" \n\t" // we use 7 regs here ...
1972 "mov %%"REG_a", %%"REG_BP" \n\t"
1973 ASMALIGN(4)
1974 "1: \n\t"
1975 "movzwl (%2, %%"REG_BP"), %%eax \n\t"
1976 "movzwl 2(%2, %%"REG_BP"), %%ebx \n\t"
1977 "movq (%1, %%"REG_BP", 8), %%mm1 \n\t"
1978 "movq 16(%1, %%"REG_BP", 8), %%mm3 \n\t"
1979 "movd (%3, %%"REG_a"), %%mm0 \n\t"
1980 "movd (%3, %%"REG_b"), %%mm2 \n\t"
1981 "punpcklbw %%mm7, %%mm0 \n\t"
1982 "punpcklbw %%mm7, %%mm2 \n\t"
1983 "pmaddwd %%mm1, %%mm0 \n\t"
1984 "pmaddwd %%mm2, %%mm3 \n\t"
1985
1986 "movq 8(%1, %%"REG_BP", 8), %%mm1 \n\t"
1987 "movq 24(%1, %%"REG_BP", 8), %%mm5 \n\t"
1988 "movd 4(%3, %%"REG_a"), %%mm4 \n\t"
1989 "movd 4(%3, %%"REG_b"), %%mm2 \n\t"
1990 "punpcklbw %%mm7, %%mm4 \n\t"
1991 "punpcklbw %%mm7, %%mm2 \n\t"
1992 "pmaddwd %%mm1, %%mm4 \n\t"
1993 "pmaddwd %%mm2, %%mm5 \n\t"
1994 "paddd %%mm4, %%mm0 \n\t"
1995 "paddd %%mm5, %%mm3 \n\t"
1996 "movq %%mm0, %%mm4 \n\t"
1997 "punpckldq %%mm3, %%mm0 \n\t"
1998 "punpckhdq %%mm3, %%mm4 \n\t"
1999 "paddd %%mm4, %%mm0 \n\t"
2000 "psrad $7, %%mm0 \n\t"
2001 "packssdw %%mm0, %%mm0 \n\t"
2002 "movd %%mm0, (%4, %%"REG_BP") \n\t"
2003 "add $4, %%"REG_BP" \n\t"
2004 " jnc 1b \n\t"
2005
2006 "pop %%"REG_BP" \n\t"
2007 #if defined(PIC)
2008 "pop %%"REG_b" \n\t"
2009 #endif
2010 : "+a" (counter)
2011 : "c" (filter), "d" (filterPos), "S" (src), "D" (dst)
2012 #if !defined(PIC)
2013 : "%"REG_b
2014 #endif
2015 );
2016 }
2017 else
2018 {
2019 uint8_t *offset = src+filterSize;
2020 long counter= -2*dstW;
2021 //filter-= counter*filterSize/2;
2022 filterPos-= counter/2;
2023 dst-= counter/2;
2024 __asm__ volatile(
2025 "pxor %%mm7, %%mm7 \n\t"
2026 ASMALIGN(4)
2027 "1: \n\t"
2028 "mov %2, %%"REG_c" \n\t"
2029 "movzwl (%%"REG_c", %0), %%eax \n\t"
2030 "movzwl 2(%%"REG_c", %0), %%edx \n\t"
2031 "mov %5, %%"REG_c" \n\t"
2032 "pxor %%mm4, %%mm4 \n\t"
2033 "pxor %%mm5, %%mm5 \n\t"
2034 "2: \n\t"
2035 "movq (%1), %%mm1 \n\t"
2036 "movq (%1, %6), %%mm3 \n\t"
2037 "movd (%%"REG_c", %%"REG_a"), %%mm0 \n\t"
2038 "movd (%%"REG_c", %%"REG_d"), %%mm2 \n\t"
2039 "punpcklbw %%mm7, %%mm0 \n\t"
2040 "punpcklbw %%mm7, %%mm2 \n\t"
2041 "pmaddwd %%mm1, %%mm0 \n\t"
2042 "pmaddwd %%mm2, %%mm3 \n\t"
2043 "paddd %%mm3, %%mm5 \n\t"
2044 "paddd %%mm0, %%mm4 \n\t"
2045 "add $8, %1 \n\t"
2046 "add $4, %%"REG_c" \n\t"
2047 "cmp %4, %%"REG_c" \n\t"
2048 " jb 2b \n\t"
2049 "add %6, %1 \n\t"
2050 "movq %%mm4, %%mm0 \n\t"
2051 "punpckldq %%mm5, %%mm4 \n\t"
2052 "punpckhdq %%mm5, %%mm0 \n\t"
2053 "paddd %%mm0, %%mm4 \n\t"
2054 "psrad $7, %%mm4 \n\t"
2055 "packssdw %%mm4, %%mm4 \n\t"
2056 "mov %3, %%"REG_a" \n\t"
2057 "movd %%mm4, (%%"REG_a", %0) \n\t"
2058 "add $4, %0 \n\t"
2059 " jnc 1b \n\t"
2060
2061 : "+r" (counter), "+r" (filter)
2062 : "m" (filterPos), "m" (dst), "m"(offset),
2063 "m" (src), "r" (filterSize*2)
2064 : "%"REG_a, "%"REG_c, "%"REG_d
2065 );
2066 }
2067 #else
2068 #if HAVE_ALTIVEC
2069 hScale_altivec_real(dst, dstW, src, srcW, xInc, filter, filterPos, filterSize);
2070 #else
2071 int i;
2072 for (i=0; i<dstW; i++)
2073 {
2074 int j;
2075 int srcPos= filterPos[i];
2076 int val=0;
2077 //printf("filterPos: %d\n", filterPos[i]);
2078 for (j=0; j<filterSize; j++)
2079 {
2080 //printf("filter: %d, src: %d\n", filter[i], src[srcPos + j]);
2081 val += ((int)src[srcPos + j])*filter[filterSize*i + j];
2082 }
2083 //filter += hFilterSize;
2084 dst[i] = FFMIN(val>>7, (1<<15)-1); // the cubic equation does overflow ...
2085 //dst[i] = val>>7;
2086 }
2087 #endif /* HAVE_ALTIVEC */
2088 #endif /* HAVE_MMX */
2089 }
2090 // *** horizontal scale Y line to temp buffer
2091 static inline void RENAME(hyscale)(SwsContext *c, uint16_t *dst, long dstWidth, uint8_t *src, int srcW, int xInc,
2092 int flags, int canMMX2BeUsed, int16_t *hLumFilter,
2093 int16_t *hLumFilterPos, int hLumFilterSize, void *funnyYCode,
2094 int srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter,
2095 int32_t *mmx2FilterPos, uint32_t *pal)
2096 {
2097 if (srcFormat==PIX_FMT_YUYV422 || srcFormat==PIX_FMT_GRAY16BE)
2098 {
2099 RENAME(yuy2ToY)(formatConvBuffer, src, srcW, pal);
2100 src= formatConvBuffer;
2101 }
2102 else if (srcFormat==PIX_FMT_UYVY422 || srcFormat==PIX_FMT_GRAY16LE)
2103 {
2104 RENAME(uyvyToY)(formatConvBuffer, src, srcW, pal);
2105 src= formatConvBuffer;
2106 }
2107 else if (srcFormat==PIX_FMT_RGB32)
2108 {
2109 RENAME(bgr32ToY)(formatConvBuffer, src, srcW, pal);
2110 src= formatConvBuffer;
2111 }
2112 else if (srcFormat==PIX_FMT_RGB32_1)
2113 {
2114 RENAME(bgr32ToY)(formatConvBuffer, src+ALT32_CORR, srcW, pal);
2115 src= formatConvBuffer;
2116 }
2117 else if (srcFormat==PIX_FMT_BGR24)
2118 {
2119 RENAME(bgr24ToY)(formatConvBuffer, src, srcW, pal);
2120 src= formatConvBuffer;
2121 }
2122 else if (srcFormat==PIX_FMT_BGR565)
2123 {
2124 RENAME(bgr16ToY)(formatConvBuffer, src, srcW, pal);
2125 src= formatConvBuffer;
2126 }
2127 else if (srcFormat==PIX_FMT_BGR555)
2128 {
2129 RENAME(bgr15ToY)(formatConvBuffer, src, srcW, pal);
2130 src= formatConvBuffer;
2131 }
2132 else if (srcFormat==PIX_FMT_BGR32)
2133 {
2134 RENAME(rgb32ToY)(formatConvBuffer, src, srcW, pal);
2135 src= formatConvBuffer;
2136 }
2137 else if (srcFormat==PIX_FMT_BGR32_1)
2138 {
2139 RENAME(rgb32ToY)(formatConvBuffer, src+ALT32_CORR, srcW, pal);
2140 src= formatConvBuffer;
2141 }
2142 else if (srcFormat==PIX_FMT_RGB24)
2143 {
2144 RENAME(rgb24ToY)(formatConvBuffer, src, srcW, pal);
2145 src= formatConvBuffer;
2146 }
2147 else if (srcFormat==PIX_FMT_RGB565)
2148 {
2149 RENAME(rgb16ToY)(formatConvBuffer, src, srcW, pal);
2150 src= formatConvBuffer;
2151 }
2152 else if (srcFormat==PIX_FMT_RGB555)
2153 {
2154 RENAME(rgb15ToY)(formatConvBuffer, src, srcW, pal);
2155 src= formatConvBuffer;
2156 }
2157 else if (srcFormat==PIX_FMT_RGB8 || srcFormat==PIX_FMT_BGR8 || srcFormat==PIX_FMT_PAL8 || srcFormat==PIX_FMT_BGR4_BYTE || srcFormat==PIX_FMT_RGB4_BYTE)
2158 {
2159 RENAME(palToY)(formatConvBuffer, src, srcW, pal);
2160 src= formatConvBuffer;
2161 }
2162 else if (srcFormat==PIX_FMT_MONOBLACK)
2163 {
2164 RENAME(monoblack2Y)(formatConvBuffer, src, srcW, pal);
2165 src= formatConvBuffer;
2166 }
2167 else if (srcFormat==PIX_FMT_MONOWHITE)
2168 {
2169 RENAME(monowhite2Y)(formatConvBuffer, src, srcW, pal);
2170 src= formatConvBuffer;
2171 }
2172
2173 #if HAVE_MMX
2174 // Use the new MMX scaler if the MMX2 one can't be used (it is faster than the x86 ASM one).
2175 if (!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))
2176 #else
2177 if (!(flags&SWS_FAST_BILINEAR))
2178 #endif
2179 {
2180 RENAME(hScale)(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);
2181 }
2182 else // fast bilinear upscale / crap downscale
2183 {
2184 #if ARCH_X86
2185 #if HAVE_MMX2
2186 int i;
2187 #if defined(PIC)
2188 uint64_t ebxsave __attribute__((aligned(8)));
2189 #endif
2190 if (canMMX2BeUsed)
2191 {
2192 __asm__ volatile(
2193 #if defined(PIC)
2194 "mov %%"REG_b", %5 \n\t"
2195 #endif
2196 "pxor %%mm7, %%mm7 \n\t"
2197 "mov %0, %%"REG_c" \n\t"
2198 "mov %1, %%"REG_D" \n\t"
2199 "mov %2, %%"REG_d" \n\t"
2200 "mov %3, %%"REG_b" \n\t"
2201 "xor %%"REG_a", %%"REG_a" \n\t" // i
2202 PREFETCH" (%%"REG_c") \n\t"
2203 PREFETCH" 32(%%"REG_c") \n\t"
2204 PREFETCH" 64(%%"REG_c") \n\t"
2205
2206 #if ARCH_X86_64
2207
2208 #define FUNNY_Y_CODE \
2209 "movl (%%"REG_b"), %%esi \n\t"\
2210 "call *%4 \n\t"\
2211 "movl (%%"REG_b", %%"REG_a"), %%esi \n\t"\
2212 "add %%"REG_S", %%"REG_c" \n\t"\
2213 "add %%"REG_a", %%"REG_D" \n\t"\
2214 "xor %%"REG_a", %%"REG_a" \n\t"\
2215
2216 #else
2217
2218 #define FUNNY_Y_CODE \
2219 "movl (%%"REG_b"), %%esi \n\t"\
2220 "call *%4 \n\t"\
2221 "addl (%%"REG_b", %%"REG_a"), %%"REG_c" \n\t"\
2222 "add %%"REG_a", %%"REG_D" \n\t"\
2223 "xor %%"REG_a", %%"REG_a" \n\t"\
2224
2225 #endif /* ARCH_X86_64 */
2226
2227 FUNNY_Y_CODE
2228 FUNNY_Y_CODE
2229 FUNNY_Y_CODE
2230 FUNNY_Y_CODE
2231 FUNNY_Y_CODE
2232 FUNNY_Y_CODE
2233 FUNNY_Y_CODE
2234 FUNNY_Y_CODE
2235
2236 #if defined(PIC)
2237 "mov %5, %%"REG_b" \n\t"
2238 #endif
2239 :: "m" (src), "m" (dst), "m" (mmx2Filter), "m" (mmx2FilterPos),
2240 "m" (funnyYCode)
2241 #if defined(PIC)
2242 ,"m" (ebxsave)
2243 #endif
2244 : "%"REG_a, "%"REG_c, "%"REG_d, "%"REG_S, "%"REG_D
2245 #if !defined(PIC)
2246 ,"%"REG_b
2247 #endif
2248 );
2249 for (i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--) dst[i] = src[srcW-1]*128;
2250 }
2251 else
2252 {
2253 #endif /* HAVE_MMX2 */
2254 long xInc_shr16 = xInc >> 16;
2255 uint16_t xInc_mask = xInc & 0xffff;
2256 //NO MMX just normal asm ...
2257 __asm__ volatile(
2258 "xor %%"REG_a", %%"REG_a" \n\t" // i
2259 "xor %%"REG_d", %%"REG_d" \n\t" // xx
2260 "xorl %%ecx, %%ecx \n\t" // 2*xalpha
2261 ASMALIGN(4)
2262 "1: \n\t"
2263 "movzbl (%0, %%"REG_d"), %%edi \n\t" //src[xx]
2264 "movzbl 1(%0, %%"REG_d"), %%esi \n\t" //src[xx+1]
2265 "subl %%edi, %%esi \n\t" //src[xx+1] - src[xx]
2266 "imull %%ecx, %%esi \n\t" //(src[xx+1] - src[xx])*2*xalpha
2267 "shll $16, %%edi \n\t"
2268 "addl %%edi, %%esi \n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)
2269 "mov %1, %%"REG_D" \n\t"
2270 "shrl $9, %%esi \n\t"
2271 "movw %%si, (%%"REG_D", %%"REG_a", 2) \n\t"
2272 "addw %4, %%cx \n\t" //2*xalpha += xInc&0xFF
2273 "adc %3, %%"REG_d" \n\t" //xx+= xInc>>8 + carry
2274
2275 "movzbl (%0, %%"REG_d"), %%edi \n\t" //src[xx]
2276 "movzbl 1(%0, %%"REG_d"), %%esi \n\t" //src[xx+1]
2277 "subl %%edi, %%esi \n\t" //src[xx+1] - src[xx]
2278 "imull %%ecx, %%esi \n\t" //(src[xx+1] - src[xx])*2*xalpha
2279 "shll $16, %%edi \n\t"
2280 "addl %%edi, %%esi \n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)
2281 "mov %1, %%"REG_D" \n\t"
2282 "shrl $9, %%esi \n\t"
2283 "movw %%si, 2(%%"REG_D", %%"REG_a", 2) \n\t"
2284 "addw %4, %%cx \n\t" //2*xalpha += xInc&0xFF
2285 "adc %3, %%"REG_d" \n\t" //xx+= xInc>>8 + carry
2286
2287
2288 "add $2, %%"REG_a" \n\t"
2289 "cmp %2, %%"REG_a" \n\t"
2290 " jb 1b \n\t"
2291
2292
2293 :: "r" (src), "m" (dst), "m" (dstWidth), "m" (xInc_shr16), "m" (xInc_mask)
2294 : "%"REG_a, "%"REG_d, "%ecx", "%"REG_D, "%esi"
2295 );
2296 #if HAVE_MMX2
2297 } //if MMX2 can't be used
2298 #endif
2299 #else
2300 int i;
2301 unsigned int xpos=0;
2302 for (i=0;i<dstWidth;i++)
2303 {
2304 register unsigned int xx=xpos>>16;
2305 register unsigned int xalpha=(xpos&0xFFFF)>>9;
2306 dst[i]= (src[xx]<<7) + (src[xx+1] - src[xx])*xalpha;
2307 xpos+=xInc;
2308 }
2309 #endif /* ARCH_X86 */
2310 }
2311
2312 if(c->srcRange != c->dstRange && !(isRGB(c->dstFormat) || isBGR(c->dstFormat))){
2313 int i;
2314 //FIXME all pal and rgb srcFormats could do this convertion as well
2315 //FIXME all scalers more complex than bilinear could do half of this transform
2316 if(c->srcRange){
2317 for (i=0; i<dstWidth; i++)
2318 dst[i]= (dst[i]*14071 + 33561947)>>14;
2319 }else{
2320 for (i=0; i<dstWidth; i++)
2321 dst[i]= (FFMIN(dst[i],30189)*19077 - 39057361)>>14;
2322 }
2323 }
2324 }
2325
2326 inline static void RENAME(hcscale)(SwsContext *c, uint16_t *dst, long dstWidth, uint8_t *src1, uint8_t *src2,
2327 int srcW, int xInc, int flags, int canMMX2BeUsed, int16_t *hChrFilter,
2328 int16_t *hChrFilterPos, int hChrFilterSize, void *funnyUVCode,
2329 int srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter,
2330 int32_t *mmx2FilterPos, uint32_t *pal)
2331 {
2332 if (srcFormat==PIX_FMT_YUYV422)
2333 {
2334 RENAME(yuy2ToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2335 src1= formatConvBuffer;
2336 src2= formatConvBuffer+VOFW;
2337 }
2338 else if (srcFormat==PIX_FMT_UYVY422)
2339 {
2340 RENAME(uyvyToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2341 src1= formatConvBuffer;
2342 src2= formatConvBuffer+VOFW;
2343 }
2344 else if (srcFormat==PIX_FMT_RGB32)
2345 {
2346 if(c->chrSrcHSubSample)
2347 RENAME(bgr32ToUV_half)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2348 else
2349 RENAME(bgr32ToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2350 src1= formatConvBuffer;
2351 src2= formatConvBuffer+VOFW;
2352 }
2353 else if (srcFormat==PIX_FMT_RGB32_1)
2354 {
2355 if(c->chrSrcHSubSample)
2356 RENAME(bgr32ToUV_half)(formatConvBuffer, formatConvBuffer+VOFW, src1+ALT32_CORR, src2+ALT32_CORR, srcW, pal);
2357 else
2358 RENAME(bgr32ToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1+ALT32_CORR, src2+ALT32_CORR, srcW, pal);
2359 src1= formatConvBuffer;
2360 src2= formatConvBuffer+VOFW;
2361 }
2362 else if (srcFormat==PIX_FMT_BGR24)
2363 {
2364 if(c->chrSrcHSubSample)
2365 RENAME(bgr24ToUV_half)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2366 else
2367 RENAME(bgr24ToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2368 src1= formatConvBuffer;
2369 src2= formatConvBuffer+VOFW;
2370 }
2371 else if (srcFormat==PIX_FMT_BGR565)
2372 {
2373 if(c->chrSrcHSubSample)
2374 RENAME(bgr16ToUV_half)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2375 else
2376 RENAME(bgr16ToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2377 src1= formatConvBuffer;
2378 src2= formatConvBuffer+VOFW;
2379 }
2380 else if (srcFormat==PIX_FMT_BGR555)
2381 {
2382 if(c->chrSrcHSubSample)
2383 RENAME(bgr15ToUV_half)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2384 else
2385 RENAME(bgr15ToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2386 src1= formatConvBuffer;
2387 src2= formatConvBuffer+VOFW;
2388 }
2389 else if (srcFormat==PIX_FMT_BGR32)
2390 {
2391 if(c->chrSrcHSubSample)
2392 RENAME(rgb32ToUV_half)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2393 else
2394 RENAME(rgb32ToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2395 src1= formatConvBuffer;
2396 src2= formatConvBuffer+VOFW;
2397 }
2398 else if (srcFormat==PIX_FMT_BGR32_1)
2399 {
2400 if(c->chrSrcHSubSample)
2401 RENAME(rgb32ToUV_half)(formatConvBuffer, formatConvBuffer+VOFW, src1+ALT32_CORR, src2+ALT32_CORR, srcW, pal);
2402 else
2403 RENAME(rgb32ToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1+ALT32_CORR, src2+ALT32_CORR, srcW, pal);
2404 src1= formatConvBuffer;
2405 src2= formatConvBuffer+VOFW;
2406 }
2407 else if (srcFormat==PIX_FMT_RGB24)
2408 {
2409 if(c->chrSrcHSubSample)
2410 RENAME(rgb24ToUV_half)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2411 else
2412 RENAME(rgb24ToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2413 src1= formatConvBuffer;
2414 src2= formatConvBuffer+VOFW;
2415 }
2416 else if (srcFormat==PIX_FMT_RGB565)
2417 {
2418 if(c->chrSrcHSubSample)
2419 RENAME(rgb16ToUV_half)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2420 else
2421 RENAME(rgb16ToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2422 src1= formatConvBuffer;
2423 src2= formatConvBuffer+VOFW;
2424 }
2425 else if (srcFormat==PIX_FMT_RGB555)
2426 {
2427 if(c->chrSrcHSubSample)
2428 RENAME(rgb15ToUV_half)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2429 else
2430 RENAME(rgb15ToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2431 src1= formatConvBuffer;
2432 src2= formatConvBuffer+VOFW;
2433 }
2434 else if (isGray(srcFormat) || srcFormat==PIX_FMT_MONOBLACK || srcFormat==PIX_FMT_MONOWHITE)
2435 {
2436 return;
2437 }
2438 else if (srcFormat==PIX_FMT_RGB8 || srcFormat==PIX_FMT_BGR8 || srcFormat==PIX_FMT_PAL8 || srcFormat==PIX_FMT_BGR4_BYTE || srcFormat==PIX_FMT_RGB4_BYTE)
2439 {
2440 RENAME(palToUV)(formatConvBuffer, formatConvBuffer+VOFW, src1, src2, srcW, pal);
2441 src1= formatConvBuffer;
2442 src2= formatConvBuffer+VOFW;
2443 }
2444
2445 #if HAVE_MMX
2446 // Use the new MMX scaler if the MMX2 one can't be used (it is faster than the x86 ASM one).
2447 if (!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))
2448 #else
2449 if (!(flags&SWS_FAST_BILINEAR))
2450 #endif
2451 {
2452 RENAME(hScale)(dst , dstWidth, src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);
2453 RENAME(hScale)(dst+VOFW, dstWidth, src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);
2454 }
2455 else // fast bilinear upscale / crap downscale
2456 {
2457 #if ARCH_X86
2458 #if HAVE_MMX2
2459 int i;
2460 #if defined(PIC)
2461 uint64_t ebxsave __attribute__((aligned(8)));
2462 #endif
2463 if (canMMX2BeUsed)
2464 {
2465 __asm__ volatile(
2466 #if defined(PIC)
2467 "mov %%"REG_b", %6 \n\t"
2468 #endif
2469 "pxor %%mm7, %%mm7 \n\t"
2470 "mov %0, %%"REG_c" \n\t"
2471 "mov %1, %%"REG_D" \n\t"
2472 "mov %2, %%"REG_d" \n\t"
2473 "mov %3, %%"REG_b" \n\t"
2474 "xor %%"REG_a", %%"REG_a" \n\t" // i
2475 PREFETCH" (%%"REG_c") \n\t"
2476 PREFETCH" 32(%%"REG_c") \n\t"
2477 PREFETCH" 64(%%"REG_c") \n\t"
2478
2479 #if ARCH_X86_64
2480
2481 #define FUNNY_UV_CODE \
2482 "movl (%%"REG_b"), %%esi \n\t"\
2483 "call *%4 \n\t"\
2484 "movl (%%"REG_b", %%"REG_a"), %%esi \n\t"\
2485 "add %%"REG_S", %%"REG_c" \n\t"\
2486 "add %%"REG_a", %%"REG_D" \n\t"\
2487 "xor %%"REG_a", %%"REG_a" \n\t"\
2488
2489 #else
2490
2491 #define FUNNY_UV_CODE \
2492 "movl (%%"REG_b"), %%esi \n\t"\
2493 "call *%4 \n\t"\
2494 "addl (%%"REG_b", %%"REG_a"), %%"REG_c" \n\t"\
2495 "add %%"REG_a", %%"REG_D" \n\t"\
2496 "xor %%"REG_a", %%"REG_a" \n\t"\
2497
2498 #endif /* ARCH_X86_64 */
2499
2500 FUNNY_UV_CODE
2501 FUNNY_UV_CODE
2502 FUNNY_UV_CODE
2503 FUNNY_UV_CODE
2504 "xor %%"REG_a", %%"REG_a" \n\t" // i
2505 "mov %5, %%"REG_c" \n\t" // src
2506 "mov %1, %%"REG_D" \n\t" // buf1
2507 "add $"AV_STRINGIFY(VOF)", %%"REG_D" \n\t"
2508 PREFETCH" (%%"REG_c") \n\t"
2509 PREFETCH" 32(%%"REG_c") \n\t"
2510 PREFETCH" 64(%%"REG_c") \n\t"
2511
2512 FUNNY_UV_CODE
2513 FUNNY_UV_CODE
2514 FUNNY_UV_CODE
2515 FUNNY_UV_CODE
2516
2517 #if defined(PIC)
2518 "mov %6, %%"REG_b" \n\t"
2519 #endif
2520 :: "m" (src1), "m" (dst), "m" (mmx2Filter), "m" (mmx2FilterPos),
2521 "m" (funnyUVCode), "m" (src2)
2522 #if defined(PIC)
2523 ,"m" (ebxsave)
2524 #endif
2525 : "%"REG_a, "%"REG_c, "%"REG_d, "%"REG_S, "%"REG_D
2526 #if !defined(PIC)
2527 ,"%"REG_b
2528 #endif
2529 );
2530 for (i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--)
2531 {
2532 //printf("%d %d %d\n", dstWidth, i, srcW);
2533 dst[i] = src1[srcW-1]*128;
2534 dst[i+VOFW] = src2[srcW-1]*128;
2535 }
2536 }
2537 else
2538 {
2539 #endif /* HAVE_MMX2 */
2540 long xInc_shr16 = (long) (xInc >> 16);
2541 uint16_t xInc_mask = xInc & 0xffff;
2542 __asm__ volatile(
2543 "xor %%"REG_a", %%"REG_a" \n\t" // i
2544 "xor %%"REG_d", %%"REG_d" \n\t" // xx
2545 "xorl %%ecx, %%ecx \n\t" // 2*xalpha
2546 ASMALIGN(4)
2547 "1: \n\t"
2548 "mov %0, %%"REG_S" \n\t"
2549 "movzbl (%%"REG_S", %%"REG_d"), %%edi \n\t" //src[xx]
2550 "movzbl 1(%%"REG_S", %%"REG_d"), %%esi \n\t" //src[xx+1]
2551 "subl %%edi, %%esi \n\t" //src[xx+1] - src[xx]
2552 "imull %%ecx, %%esi \n\t" //(src[xx+1] - src[xx])*2*xalpha
2553 "shll $16, %%edi \n\t"
2554 "addl %%edi, %%esi \n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)
2555 "mov %1, %%"REG_D" \n\t"
2556 "shrl $9, %%esi \n\t"
2557 "movw %%si, (%%"REG_D", %%"REG_a", 2) \n\t"
2558
2559 "movzbl (%5, %%"REG_d"), %%edi \n\t" //src[xx]
2560 "movzbl 1(%5, %%"REG_d"), %%esi \n\t" //src[xx+1]
2561 "subl %%edi, %%esi \n\t" //src[xx+1] - src[xx]
2562 "imull %%ecx, %%esi \n\t" //(src[xx+1] - src[xx])*2*xalpha
2563 "shll $16, %%edi \n\t"
2564 "addl %%edi, %%esi \n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)
2565 "mov %1, %%"REG_D" \n\t"
2566 "shrl $9, %%esi \n\t"
2567 "movw %%si, "AV_STRINGIFY(VOF)"(%%"REG_D", %%"REG_a", 2) \n\t"
2568
2569 "addw %4, %%cx \n\t" //2*xalpha += xInc&0xFF
2570 "adc %3, %%"REG_d" \n\t" //xx+= xInc>>8 + carry
2571 "add $1, %%"REG_a" \n\t"
2572 "cmp %2, %%"REG_a" \n\t"
2573 " jb 1b \n\t"
2574
2575 /* GCC 3.3 makes MPlayer crash on IA-32 machines when using "g" operand here,
2576 which is needed to support GCC 4.0. */
2577 #if ARCH_X86_64 && ((__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
2578 :: "m" (src1), "m" (dst), "g" ((long)dstWidth), "m" (xInc_shr16), "m" (xInc_mask),
2579 #else
2580 :: "m" (src1), "m" (dst), "m" ((long)dstWidth), "m" (xInc_shr16), "m" (xInc_mask),
2581 #endif
2582 "r" (src2)
2583 : "%"REG_a, "%"REG_d, "%ecx", "%"REG_D, "%esi"
2584 );
2585 #if HAVE_MMX2
2586 } //if MMX2 can't be used
2587 #endif
2588 #else
2589 int i;
2590 unsigned int xpos=0;
2591 for (i=0;i<dstWidth;i++)
2592 {
2593 register unsigned int xx=xpos>>16;
2594 register unsigned int xalpha=(xpos&0xFFFF)>>9;
2595 dst[i]=(src1[xx]*(xalpha^127)+src1[xx+1]*xalpha);
2596 dst[i+VOFW]=(src2[xx]*(xalpha^127)+src2[xx+1]*xalpha);
2597 /* slower
2598 dst[i]= (src1[xx]<<7) + (src1[xx+1] - src1[xx])*xalpha;
2599 dst[i+VOFW]=(src2[xx]<<7) + (src2[xx+1] - src2[xx])*xalpha;
2600 */
2601 xpos+=xInc;
2602 }
2603 #endif /* ARCH_X86 */
2604 }
2605 if(c->srcRange != c->dstRange && !(isRGB(c->dstFormat) || isBGR(c->dstFormat))){
2606 int i;
2607 //FIXME all pal and rgb srcFormats could do this convertion as well
2608 //FIXME all scalers more complex than bilinear could do half of this transform
2609 if(c->srcRange){
2610 for (i=0; i<dstWidth; i++){
2611 dst[i ]= (dst[i ]*1799 + 4081085)>>11; //1469
2612 dst[i+VOFW]= (dst[i+VOFW]*1799 + 4081085)>>11; //1469
2613 }
2614 }else{
2615 for (i=0; i<dstWidth; i++){
2616 dst[i ]= (FFMIN(dst[i ],30775)*4663 - 9289992)>>12; //-264
2617 dst[i+VOFW]= (FFMIN(dst[i+VOFW],30775)*4663 - 9289992)>>12; //-264
2618 }
2619 }
2620 }
2621 }
2622
2623 static int RENAME(swScale)(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
2624 int srcSliceH, uint8_t* dst[], int dstStride[]){
2625
2626 /* load a few things into local vars to make the code more readable? and faster */
2627 const int srcW= c->srcW;
2628 const int dstW= c->dstW;
2629 const int dstH= c->dstH;
2630 const int chrDstW= c->chrDstW;
2631 const int chrSrcW= c->chrSrcW;
2632 const int lumXInc= c->lumXInc;
2633 const int chrXInc= c->chrXInc;
2634 const int dstFormat= c->dstFormat;
2635 const int srcFormat= c->srcFormat;
2636 const int flags= c->flags;
2637 const int canMMX2BeUsed= c->canMMX2BeUsed;
2638 int16_t *vLumFilterPos= c->vLumFilterPos;
2639 int16_t *vChrFilterPos= c->vChrFilterPos;
2640 int16_t *hLumFilterPos= c->hLumFilterPos;
2641 int16_t *hChrFilterPos= c->hChrFilterPos;
2642 int16_t *vLumFilter= c->vLumFilter;
2643 int16_t *vChrFilter= c->vChrFilter;
2644 int16_t *hLumFilter= c->hLumFilter;
2645 int16_t *hChrFilter= c->hChrFilter;
2646 int32_t *lumMmxFilter= c->lumMmxFilter;
2647 int32_t *chrMmxFilter= c->chrMmxFilter;
2648 const int vLumFilterSize= c->vLumFilterSize;
2649 const int vChrFilterSize= c->vChrFilterSize;
2650 const int hLumFilterSize= c->hLumFilterSize;
2651 const int hChrFilterSize= c->hChrFilterSize;
2652 int16_t **lumPixBuf= c->lumPixBuf;
2653 int16_t **chrPixBuf= c->chrPixBuf;
2654 const int vLumBufSize= c->vLumBufSize;
2655 const int vChrBufSize= c->vChrBufSize;
2656 uint8_t *funnyYCode= c->funnyYCode;
2657 uint8_t *funnyUVCode= c->funnyUVCode;
2658 uint8_t *formatConvBuffer= c->formatConvBuffer;
2659 const int chrSrcSliceY= srcSliceY >> c->chrSrcVSubSample;
2660 const int chrSrcSliceH= -((-srcSliceH) >> c->chrSrcVSubSample);
2661 int lastDstY;
2662 uint32_t *pal=c->pal_yuv;
2663
2664 /* vars which will change and which we need to store back in the context */
2665 int dstY= c->dstY;
2666 int lumBufIndex= c->lumBufIndex;
2667 int chrBufIndex= c->chrBufIndex;
2668 int lastInLumBuf= c->lastInLumBuf;
2669 int lastInChrBuf= c->lastInChrBuf;
2670
2671 if (isPacked(c->srcFormat)){
2672 src[0]=
2673 src[1]=
2674 src[2]= src[0];
2675 srcStride[0]=
2676 srcStride[1]=
2677 srcStride[2]= srcStride[0];
2678 }
2679 srcStride[1]<<= c->vChrDrop;
2680 srcStride[2]<<= c->vChrDrop;
2681
2682 //printf("swscale %X %X %X -> %X %X %X\n", (int)src[0], (int)src[1], (int)src[2],
2683 // (int)dst[0], (int)dst[1], (int)dst[2]);
2684
2685 #if 0 //self test FIXME move to a vfilter or something
2686 {
2687 static volatile int i=0;
2688 i++;
2689 if (srcFormat==PIX_FMT_YUV420P && i==1 && srcSliceH>= c->srcH)
2690 selfTest(src, srcStride, c->srcW, c->srcH);
2691 i--;
2692 }
2693 #endif
2694
2695 //printf("sws Strides:%d %d %d -> %d %d %d\n", srcStride[0],srcStride[1],srcStride[2],
2696 //dstStride[0],dstStride[1],dstStride[2]);
2697
2698 if (dstStride[0]%8 !=0 || dstStride[1]%8 !=0 || dstStride[2]%8 !=0)
2699 {
2700 static int warnedAlready=0; //FIXME move this into the context perhaps
2701 if (flags & SWS_PRINT_INFO && !warnedAlready)
2702 {
2703 av_log(c, AV_LOG_WARNING, "Warning: dstStride is not aligned!\n"
2704 " ->cannot do aligned memory accesses anymore\n");
2705 warnedAlready=1;
2706 }
2707 }
2708
2709 /* Note the user might start scaling the picture in the middle so this
2710 will not get executed. This is not really intended but works
2711 currently, so people might do it. */
2712 if (srcSliceY ==0){
2713 lumBufIndex=0;
2714 chrBufIndex=0;
2715 dstY=0;
2716 lastInLumBuf= -1;
2717 lastInChrBuf= -1;
2718 }
2719
2720 lastDstY= dstY;
2721
2722 for (;dstY < dstH; dstY++){
2723 unsigned char *dest =dst[0]+dstStride[0]*dstY;
2724 const int chrDstY= dstY>>c->chrDstVSubSample;
2725 unsigned char *uDest=dst[1]+dstStride[1]*chrDstY;
2726 unsigned char *vDest=dst[2]+dstStride[2]*chrDstY;
2727
2728 const int firstLumSrcY= vLumFilterPos[dstY]; //First line needed as input
2729 const int firstChrSrcY= vChrFilterPos[chrDstY]; //First line needed as input
2730 const int lastLumSrcY= firstLumSrcY + vLumFilterSize -1; // Last line needed as input
2731 const int lastChrSrcY= firstChrSrcY + vChrFilterSize -1; // Last line needed as input
2732
2733 //printf("dstY:%d dstH:%d firstLumSrcY:%d lastInLumBuf:%d vLumBufSize: %d vChrBufSize: %d slice: %d %d vLumFilterSize: %d firstChrSrcY: %d vChrFilterSize: %d c->chrSrcVSubSample: %d\n",
2734 // dstY, dstH, firstLumSrcY, lastInLumBuf, vLumBufSize, vChrBufSize, srcSliceY, srcSliceH, vLumFilterSize, firstChrSrcY, vChrFilterSize, c->chrSrcVSubSample);
2735 //handle holes (FAST_BILINEAR & weird filters)
2736 if (firstLumSrcY > lastInLumBuf) lastInLumBuf= firstLumSrcY-1;
2737 if (firstChrSrcY > lastInChrBuf) lastInChrBuf= firstChrSrcY-1;
2738 //printf("%d %d %d\n", firstChrSrcY, lastInChrBuf, vChrBufSize);
2739 assert(firstLumSrcY >= lastInLumBuf - vLumBufSize + 1);
2740 assert(firstChrSrcY >= lastInChrBuf - vChrBufSize + 1);
2741
2742 // Do we have enough lines in this slice to output the dstY line
2743 if (lastLumSrcY < srcSliceY + srcSliceH && lastChrSrcY < -((-srcSliceY - srcSliceH)>>c->chrSrcVSubSample))
2744 {
2745 //Do horizontal scaling
2746 while(lastInLumBuf < lastLumSrcY)
2747 {
2748 uint8_t *s= src[0]+(lastInLumBuf + 1 - srcSliceY)*srcStride[0];
2749 lumBufIndex++;
2750 //printf("%d %d %d %d\n", lumBufIndex, vLumBufSize, lastInLumBuf, lastLumSrcY);
2751 assert(lumBufIndex < 2*vLumBufSize);
2752 assert(lastInLumBuf + 1 - srcSliceY < srcSliceH);
2753 assert(lastInLumBuf + 1 - srcSliceY >= 0);
2754 //printf("%d %d\n", lumBufIndex, vLumBufSize);
2755 RENAME(hyscale)(c, lumPixBuf[ lumBufIndex ], dstW, s, srcW, lumXInc,
2756 flags, canMMX2BeUsed, hLumFilter, hLumFilterPos, hLumFilterSize,
2757 funnyYCode, c->srcFormat, formatConvBuffer,
2758 c->lumMmx2Filter, c->lumMmx2FilterPos, pal);
2759 lastInLumBuf++;
2760 }
2761 while(lastInChrBuf < lastChrSrcY)
2762 {
2763 uint8_t *src1= src[1]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[1];
2764 uint8_t *src2= src[2]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[2];
2765 chrBufIndex++;
2766 assert(chrBufIndex < 2*vChrBufSize);
2767 assert(lastInChrBuf + 1 - chrSrcSliceY < (chrSrcSliceH));
2768 assert(lastInChrBuf + 1 - chrSrcSliceY >= 0);
2769 //FIXME replace parameters through context struct (some at least)
2770
2771 if (!(isGray(srcFormat) || isGray(dstFormat)))
2772 RENAME(hcscale)(c, chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, chrSrcW, chrXInc,
2773 flags, canMMX2BeUsed, hChrFilter, hChrFilterPos, hChrFilterSize,
2774 funnyUVCode, c->srcFormat, formatConvBuffer,
2775 c->chrMmx2Filter, c->chrMmx2FilterPos, pal);
2776 lastInChrBuf++;
2777 }
2778 //wrap buf index around to stay inside the ring buffer
2779 if (lumBufIndex >= vLumBufSize) lumBufIndex-= vLumBufSize;
2780 if (chrBufIndex >= vChrBufSize) chrBufIndex-= vChrBufSize;
2781 }
2782 else // not enough lines left in this slice -> load the rest in the buffer
2783 {
2784 /* printf("%d %d Last:%d %d LastInBuf:%d %d Index:%d %d Y:%d FSize: %d %d BSize: %d %d\n",
2785 firstChrSrcY,firstLumSrcY,lastChrSrcY,lastLumSrcY,
2786 lastInChrBuf,lastInLumBuf,chrBufIndex,lumBufIndex,dstY,vChrFilterSize,vLumFilterSize,
2787 vChrBufSize, vLumBufSize);*/
2788
2789 //Do horizontal scaling
2790 while(lastInLumBuf+1 < srcSliceY + srcSliceH)
2791 {
2792 uint8_t *s= src[0]+(lastInLumBuf + 1 - srcSliceY)*srcStride[0];
2793 lumBufIndex++;
2794 assert(lumBufIndex < 2*vLumBufSize);
2795 assert(lastInLumBuf + 1 - srcSliceY < srcSliceH);
2796 assert(lastInLumBuf + 1 - srcSliceY >= 0);
2797 RENAME(hyscale)(c, lumPixBuf[ lumBufIndex ], dstW, s, srcW, lumXInc,
2798 flags, canMMX2BeUsed, hLumFilter, hLumFilterPos, hLumFilterSize,
2799 funnyYCode, c->srcFormat, formatConvBuffer,
2800 c->lumMmx2Filter, c->lumMmx2FilterPos, pal);
2801 lastInLumBuf++;
2802 }
2803 while(lastInChrBuf+1 < (chrSrcSliceY + chrSrcSliceH))
2804 {
2805 uint8_t *src1= src[1]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[1];
2806 uint8_t *src2= src[2]+(lastInChrBuf + 1 - chrSrcSliceY)*srcStride[2];
2807 chrBufIndex++;
2808 assert(chrBufIndex < 2*vChrBufSize);
2809 assert(lastInChrBuf + 1 - chrSrcSliceY < chrSrcSliceH);
2810 assert(lastInChrBuf + 1 - chrSrcSliceY >= 0);
2811
2812 if (!(isGray(srcFormat) || isGray(dstFormat)))
2813 RENAME(hcscale)(c, chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, chrSrcW, chrXInc,
2814 flags, canMMX2BeUsed, hChrFilter, hChrFilterPos, hChrFilterSize,
2815 funnyUVCode, c->srcFormat, formatConvBuffer,
2816 c->chrMmx2Filter, c->chrMmx2FilterPos, pal);
2817 lastInChrBuf++;
2818 }
2819 //wrap buf index around to stay inside the ring buffer
2820 if (lumBufIndex >= vLumBufSize) lumBufIndex-= vLumBufSize;
2821 if (chrBufIndex >= vChrBufSize) chrBufIndex-= vChrBufSize;
2822 break; //we can't output a dstY line so let's try with the next slice
2823 }
2824
2825 #if HAVE_MMX
2826 c->blueDither= ff_dither8[dstY&1];
2827 if (c->dstFormat == PIX_FMT_RGB555 || c->dstFormat == PIX_FMT_BGR555)
2828 c->greenDither= ff_dither8[dstY&1];
2829 else
2830 c->greenDither= ff_dither4[dstY&1];
2831 c->redDither= ff_dither8[(dstY+1)&1];
2832 #endif
2833 if (dstY < dstH-2)
2834 {
2835 int16_t **lumSrcPtr= lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;
2836 int16_t **chrSrcPtr= chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
2837 #if HAVE_MMX
2838 int i;
2839 if (flags & SWS_ACCURATE_RND){
2840 int s= APCK_SIZE / 8;
2841 for (i=0; i<vLumFilterSize; i+=2){
2842 *(void**)&lumMmxFilter[s*i ]= lumSrcPtr[i ];
2843 *(void**)&lumMmxFilter[s*i+APCK_PTR2/4 ]= lumSrcPtr[i+(vLumFilterSize>1)];
2844 lumMmxFilter[s*i+APCK_COEF/4 ]=
2845 lumMmxFilter[s*i+APCK_COEF/4+1]= vLumFilter[dstY*vLumFilterSize + i ]
2846 + (vLumFilterSize>1 ? vLumFilter[dstY*vLumFilterSize + i + 1]<<16 : 0);
2847 }
2848 for (i=0; i<vChrFilterSize; i+=2){
2849 *(void**)&chrMmxFilter[s*i ]= chrSrcPtr[i ];
2850 *(void**)&chrMmxFilter[s*i+APCK_PTR2/4 ]= chrSrcPtr[i+(vChrFilterSize>1)];
2851 chrMmxFilter[s*i+APCK_COEF/4 ]=
2852 chrMmxFilter[s*i+APCK_COEF/4+1]= vChrFilter[chrDstY*vChrFilterSize + i ]
2853 + (vChrFilterSize>1 ? vChrFilter[chrDstY*vChrFilterSize + i + 1]<<16 : 0);
2854 }
2855 }else{
2856 for (i=0; i<vLumFilterSize; i++)
2857 {
2858 lumMmxFilter[4*i+0]= (int32_t)lumSrcPtr[i];
2859 lumMmxFilter[4*i+1]= (uint64_t)lumSrcPtr[i] >> 32;
2860 lumMmxFilter[4*i+2]=
2861 lumMmxFilter[4*i+3]=
2862 ((uint16_t)vLumFilter[dstY*vLumFilterSize + i])*0x10001;
2863 }
2864 for (i=0; i<vChrFilterSize; i++)
2865 {
2866 chrMmxFilter[4*i+0]= (int32_t)chrSrcPtr[i];
2867 chrMmxFilter[4*i+1]= (uint64_t)chrSrcPtr[i] >> 32;
2868 chrMmxFilter[4*i+2]=
2869 chrMmxFilter[4*i+3]=
2870 ((uint16_t)vChrFilter[chrDstY*vChrFilterSize + i])*0x10001;
2871 }
2872 }
2873 #endif
2874 if (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21){
2875 const int chrSkipMask= (1<<c->chrDstVSubSample)-1;
2876 if (dstY&chrSkipMask) uDest= NULL; //FIXME split functions in lumi / chromi
2877 RENAME(yuv2nv12X)(c,
2878 vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,
2879 vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
2880 dest, uDest, dstW, chrDstW, dstFormat);
2881 }
2882 else if (isPlanarYUV(dstFormat) || dstFormat==PIX_FMT_GRAY8) //YV12 like
2883 {
2884 const int chrSkipMask= (1<<c->chrDstVSubSample)-1;
2885 if ((dstY&chrSkipMask) || isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi
2886 if (vLumFilterSize == 1 && vChrFilterSize == 1) // unscaled YV12
2887 {
2888 int16_t *lumBuf = lumPixBuf[0];
2889 int16_t *chrBuf= chrPixBuf[0];
2890 RENAME(yuv2yuv1)(c, lumBuf, chrBuf, dest, uDest, vDest, dstW, chrDstW);
2891 }
2892 else //General YV12
2893 {
2894 RENAME(yuv2yuvX)(c,
2895 vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,
2896 vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
2897 dest, uDest, vDest, dstW, chrDstW);
2898 }
2899 }
2900 else
2901 {
2902 assert(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);
2903 assert(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2);
2904 if (vLumFilterSize == 1 && vChrFilterSize == 2) //unscaled RGB
2905 {
2906 int chrAlpha= vChrFilter[2*dstY+1];
2907 if(flags & SWS_FULL_CHR_H_INT){
2908 yuv2rgbXinC_full(c, //FIXME write a packed1_full function
2909 vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
2910 vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
2911 dest, dstW, dstY);
2912 }else{
2913 RENAME(yuv2packed1)(c, *lumSrcPtr, *chrSrcPtr, *(chrSrcPtr+1),
2914 dest, dstW, chrAlpha, dstFormat, flags, dstY);
2915 }
2916 }
2917 else if (vLumFilterSize == 2 && vChrFilterSize == 2) //bilinear upscale RGB
2918 {
2919 int lumAlpha= vLumFilter[2*dstY+1];
2920 int chrAlpha= vChrFilter[2*dstY+1];
2921 lumMmxFilter[2]=
2922 lumMmxFilter[3]= vLumFilter[2*dstY ]*0x10001;
2923 chrMmxFilter[2]=
2924 chrMmxFilter[3]= vChrFilter[2*chrDstY]*0x10001;
2925 if(flags & SWS_FULL_CHR_H_INT){
2926 yuv2rgbXinC_full(c, //FIXME write a packed2_full function
2927 vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
2928 vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
2929 dest, dstW, dstY);
2930 }else{
2931 RENAME(yuv2packed2)(c, *lumSrcPtr, *(lumSrcPtr+1), *chrSrcPtr, *(chrSrcPtr+1),
2932 dest, dstW, lumAlpha, chrAlpha, dstY);
2933 }
2934 }
2935 else //general RGB
2936 {
2937 if(flags & SWS_FULL_CHR_H_INT){
2938 yuv2rgbXinC_full(c,
2939 vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
2940 vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
2941 dest, dstW, dstY);
2942 }else{
2943 RENAME(yuv2packedX)(c,
2944 vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
2945 vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
2946 dest, dstW, dstY);
2947 }
2948 }
2949 }
2950 }
2951 else // hmm looks like we can't use MMX here without overwriting this array's tail
2952 {
2953 int16_t **lumSrcPtr= lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;
2954 int16_t **chrSrcPtr= chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
2955 if (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21){
2956 const int chrSkipMask= (1<<c->chrDstVSubSample)-1;
2957 if (dstY&chrSkipMask) uDest= NULL; //FIXME split functions in lumi / chromi
2958 yuv2nv12XinC(
2959 vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,
2960 vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
2961 dest, uDest, dstW, chrDstW, dstFormat);
2962 }
2963 else if (isPlanarYUV(dstFormat) || dstFormat==PIX_FMT_GRAY8) //YV12
2964 {
2965 const int chrSkipMask= (1<<c->chrDstVSubSample)-1;
2966 if ((dstY&chrSkipMask) || isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi
2967 yuv2yuvXinC(
2968 vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,
2969 vChrFilter+chrDstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
2970 dest, uDest, vDest, dstW, chrDstW);
2971 }
2972 else
2973 {
2974 assert(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);
2975 assert(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2);
2976 if(flags & SWS_FULL_CHR_H_INT){
2977 yuv2rgbXinC_full(c,
2978 vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
2979 vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
2980 dest, dstW, dstY);
2981 }else{
2982 yuv2packedXinC(c,
2983 vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
2984 vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
2985 dest, dstW, dstY);
2986 }
2987 }
2988 }
2989 }
2990
2991 #if HAVE_MMX
2992 __asm__ volatile(SFENCE:::"memory");
2993 __asm__ volatile(EMMS:::"memory");
2994 #endif
2995 /* store changed local vars back in the context */
2996 c->dstY= dstY;
2997 c->lumBufIndex= lumBufIndex;
2998 c->chrBufIndex= chrBufIndex;
2999 c->lastInLumBuf= lastInLumBuf;
3000 c->lastInChrBuf= lastInChrBuf;
3001
3002 return dstY - lastDstY;
3003 }
mplayer with SMedia Glamo drivers