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