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