falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
382 Commits
32 Branches
484MB
Tree: 1e98dffb7a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1e98dffb7a'
${ noResults }
FFmpeg/postproc/swscale_template.c

2117 lines
65KB
Raw Blame History 

  1. 

  2. // Software scaling and colorspace conversion routines for MPlayer

  3. 

  4. // Orginal C implementation by A'rpi/ESP-team <arpi@thot.banki.hu>

  5. // current version mostly by Michael Niedermayer (michaelni@gmx.at)

  6. // the parts written by michael are under GNU GPL

  7. 

  8. #undef MOVNTQ

  9. #undef PAVGB

  10. #undef PREFETCH

  11. #undef PREFETCHW

  12. #undef EMMS

  13. #undef SFENCE

  14. 

  15. #ifdef HAVE_3DNOW

  16. /* On K6 femms is faster of emms. On K7 femms is directly mapped on emms. */

  17. #define EMMS     "femms"

  18. #else

  19. #define EMMS     "emms"

  20. #endif

  21. 

  22. #ifdef HAVE_3DNOW

  23. #define PREFETCH  "prefetch"

  24. #define PREFETCHW "prefetchw"

  25. #elif defined ( HAVE_MMX2 )

  26. #define PREFETCH "prefetchnta"

  27. #define PREFETCHW "prefetcht0"

  28. #else

  29. #define PREFETCH "/nop"

  30. #define PREFETCHW "/nop"

  31. #endif

  32. 

  33. #ifdef HAVE_MMX2

  34. #define SFENCE "sfence"

  35. #else

  36. #define SFENCE "/nop"

  37. #endif

  38. 

  39. #ifdef HAVE_MMX2

  40. #define PAVGB(a,b) "pavgb " #a ", " #b " \n\t"

  41. #elif defined (HAVE_3DNOW)

  42. #define PAVGB(a,b) "pavgusb " #a ", " #b " \n\t"

  43. #endif

  44. 

  45. #ifdef HAVE_MMX2

  46. #define MOVNTQ(a,b) "movntq " #a ", " #b " \n\t"

  47. #else

  48. #define MOVNTQ(a,b) "movq " #a ", " #b " \n\t"

  49. #endif

  50. 

  51. 

  52. #define YSCALEYUV2YV12X(x) \

  53. 			"xorl %%eax, %%eax		\n\t"\

  54. 			"pxor %%mm3, %%mm3		\n\t"\

  55. 			"pxor %%mm4, %%mm4		\n\t"\

  56. 			"movl %0, %%edx			\n\t"\

  57. 			".balign 16			\n\t" /* FIXME Unroll? */\

  58. 			"1:				\n\t"\

  59. 			"movl (%1, %%edx, 4), %%esi	\n\t"\

  60. 			"movq (%2, %%edx, 8), %%mm0	\n\t" /* filterCoeff */\

  61. 			"movq " #x "(%%esi, %%eax, 2), %%mm2	\n\t" /* srcData */\

  62. 			"movq 8+" #x "(%%esi, %%eax, 2), %%mm5	\n\t" /* srcData */\

  63. 			"pmulhw %%mm0, %%mm2		\n\t"\

  64. 			"pmulhw %%mm0, %%mm5		\n\t"\

  65. 			"paddw %%mm2, %%mm3		\n\t"\

  66. 			"paddw %%mm5, %%mm4		\n\t"\

  67. 			"addl $1, %%edx			\n\t"\

  68. 			" jnz 1b			\n\t"\

  69. 			"psraw $3, %%mm3		\n\t"\

  70. 			"psraw $3, %%mm4		\n\t"\

  71. 			"packuswb %%mm4, %%mm3		\n\t"\

  72. 			MOVNTQ(%%mm3, (%3, %%eax))\

  73. 			"addl $8, %%eax			\n\t"\

  74. 			"cmpl %4, %%eax			\n\t"\

  75. 			"pxor %%mm3, %%mm3		\n\t"\

  76. 			"pxor %%mm4, %%mm4		\n\t"\

  77. 			"movl %0, %%edx			\n\t"\

  78. 			"jb 1b				\n\t"

  79. 

  80. #define YSCALEYUV2YV121 \

  81. 			"movl %2, %%eax			\n\t"\

  82. 			".balign 16			\n\t" /* FIXME Unroll? */\

  83. 			"1:				\n\t"\

  84. 			"movq (%0, %%eax, 2), %%mm0	\n\t"\

  85. 			"movq 8(%0, %%eax, 2), %%mm1	\n\t"\

  86. 			"psraw $7, %%mm0		\n\t"\

  87. 			"psraw $7, %%mm1		\n\t"\

  88. 			"packuswb %%mm1, %%mm0		\n\t"\

  89. 			MOVNTQ(%%mm0, (%1, %%eax))\

  90. 			"addl $8, %%eax			\n\t"\

  91. 			"jnc 1b				\n\t"

  92. 

  93. /*

  94. 			:: "m" (-lumFilterSize), "m" (-chrFilterSize),

  95. 			   "m" (lumMmxFilter+lumFilterSize*4), "m" (chrMmxFilter+chrFilterSize*4),

  96. 			   "r" (dest), "m" (dstW),

  97. 			   "m" (lumSrc+lumFilterSize), "m" (chrSrc+chrFilterSize)

  98. 			: "%eax", "%ebx", "%ecx", "%edx", "%esi"

  99. */

  100. #define YSCALEYUV2RGBX \

  101. 		"xorl %%eax, %%eax		\n\t"\

  102. 		".balign 16			\n\t"\

  103. 		"1:				\n\t"\

  104. 		"movl %1, %%edx			\n\t" /* -chrFilterSize */\

  105. 		"movl %3, %%ebx			\n\t" /* chrMmxFilter+lumFilterSize */\

  106. 		"movl %7, %%ecx			\n\t" /* chrSrc+lumFilterSize */\

  107. 		"pxor %%mm3, %%mm3		\n\t"\

  108. 		"pxor %%mm4, %%mm4		\n\t"\

  109. 		"2:				\n\t"\

  110. 		"movl (%%ecx, %%edx, 4), %%esi	\n\t"\

  111. 		"movq (%%ebx, %%edx, 8), %%mm0	\n\t" /* filterCoeff */\

  112. 		"movq (%%esi, %%eax), %%mm2	\n\t" /* UsrcData */\

  113. 		"movq 4096(%%esi, %%eax), %%mm5	\n\t" /* VsrcData */\

  114. 		"pmulhw %%mm0, %%mm2		\n\t"\

  115. 		"pmulhw %%mm0, %%mm5		\n\t"\

  116. 		"paddw %%mm2, %%mm3		\n\t"\

  117. 		"paddw %%mm5, %%mm4		\n\t"\

  118. 		"addl $1, %%edx			\n\t"\

  119. 		" jnz 2b			\n\t"\

  120. \

  121. 		"movl %0, %%edx			\n\t" /* -lumFilterSize */\

  122. 		"movl %2, %%ebx			\n\t" /* lumMmxFilter+lumFilterSize */\

  123. 		"movl %6, %%ecx			\n\t" /* lumSrc+lumFilterSize */\

  124. 		"pxor %%mm1, %%mm1		\n\t"\

  125. 		"pxor %%mm7, %%mm7		\n\t"\

  126. 		"2:				\n\t"\

  127. 		"movl (%%ecx, %%edx, 4), %%esi	\n\t"\

  128. 		"movq (%%ebx, %%edx, 8), %%mm0	\n\t" /* filterCoeff */\

  129. 		"movq (%%esi, %%eax, 2), %%mm2	\n\t" /* Y1srcData */\

  130. 		"movq 8(%%esi, %%eax, 2), %%mm5	\n\t" /* Y2srcData */\

  131. 		"pmulhw %%mm0, %%mm2		\n\t"\

  132. 		"pmulhw %%mm0, %%mm5		\n\t"\

  133. 		"paddw %%mm2, %%mm1		\n\t"\

  134. 		"paddw %%mm5, %%mm7		\n\t"\

  135. 		"addl $1, %%edx			\n\t"\

  136. 		" jnz 2b			\n\t"\

  137. \

  138. 		"psubw "MANGLE(w400)", %%mm3	\n\t" /* (U-128)8*/\

  139. 		"psubw "MANGLE(w400)", %%mm4	\n\t" /* (V-128)8*/\

  140. 		"movq %%mm3, %%mm2		\n\t" /* (U-128)8*/\

  141. 		"movq %%mm4, %%mm5		\n\t" /* (V-128)8*/\

  142. 		"pmulhw "MANGLE(ugCoeff)", %%mm3\n\t"\

  143. 		"pmulhw "MANGLE(vgCoeff)", %%mm4\n\t"\

  144. 	/* mm2=(U-128)8, mm3=ug, mm4=vg mm5=(V-128)8 */\

  145. 		"pmulhw "MANGLE(ubCoeff)", %%mm2\n\t"\

  146. 		"pmulhw "MANGLE(vrCoeff)", %%mm5\n\t"\

  147. 		"psubw "MANGLE(w80)", %%mm1	\n\t" /* 8(Y-16)*/\

  148. 		"psubw "MANGLE(w80)", %%mm7	\n\t" /* 8(Y-16)*/\

  149. 		"pmulhw "MANGLE(yCoeff)", %%mm1	\n\t"\

  150. 		"pmulhw "MANGLE(yCoeff)", %%mm7	\n\t"\

  151. 	/* mm1= Y1, mm2=ub, mm3=ug, mm4=vg mm5=vr, mm7=Y2 */\

  152. 		"paddw %%mm3, %%mm4		\n\t"\

  153. 		"movq %%mm2, %%mm0		\n\t"\

  154. 		"movq %%mm5, %%mm6		\n\t"\

  155. 		"movq %%mm4, %%mm3		\n\t"\

  156. 		"punpcklwd %%mm2, %%mm2		\n\t"\

  157. 		"punpcklwd %%mm5, %%mm5		\n\t"\

  158. 		"punpcklwd %%mm4, %%mm4		\n\t"\

  159. 		"paddw %%mm1, %%mm2		\n\t"\

  160. 		"paddw %%mm1, %%mm5		\n\t"\

  161. 		"paddw %%mm1, %%mm4		\n\t"\

  162. 		"punpckhwd %%mm0, %%mm0		\n\t"\

  163. 		"punpckhwd %%mm6, %%mm6		\n\t"\

  164. 		"punpckhwd %%mm3, %%mm3		\n\t"\

  165. 		"paddw %%mm7, %%mm0		\n\t"\

  166. 		"paddw %%mm7, %%mm6		\n\t"\

  167. 		"paddw %%mm7, %%mm3		\n\t"\

  168. 		/* mm0=B1, mm2=B2, mm3=G2, mm4=G1, mm5=R1, mm6=R2 */\

  169. 		"packuswb %%mm0, %%mm2		\n\t"\

  170. 		"packuswb %%mm6, %%mm5		\n\t"\

  171. 		"packuswb %%mm3, %%mm4		\n\t"\

  172. 		"pxor %%mm7, %%mm7		\n\t"

  173. 

  174. #define FULL_YSCALEYUV2RGB \

  175. 		"pxor %%mm7, %%mm7		\n\t"\

  176. 		"movd %6, %%mm6			\n\t" /*yalpha1*/\

  177. 		"punpcklwd %%mm6, %%mm6		\n\t"\

  178. 		"punpcklwd %%mm6, %%mm6		\n\t"\

  179. 		"movd %7, %%mm5			\n\t" /*uvalpha1*/\

  180. 		"punpcklwd %%mm5, %%mm5		\n\t"\

  181. 		"punpcklwd %%mm5, %%mm5		\n\t"\

  182. 		"xorl %%eax, %%eax		\n\t"\

  183. 		".balign 16			\n\t"\

  184. 		"1:				\n\t"\

  185. 		"movq (%0, %%eax, 2), %%mm0	\n\t" /*buf0[eax]*/\

  186. 		"movq (%1, %%eax, 2), %%mm1	\n\t" /*buf1[eax]*/\

  187. 		"movq (%2, %%eax,2), %%mm2	\n\t" /* uvbuf0[eax]*/\

  188. 		"movq (%3, %%eax,2), %%mm3	\n\t" /* uvbuf1[eax]*/\

  189. 		"psubw %%mm1, %%mm0		\n\t" /* buf0[eax] - buf1[eax]*/\

  190. 		"psubw %%mm3, %%mm2		\n\t" /* uvbuf0[eax] - uvbuf1[eax]*/\

  191. 		"pmulhw %%mm6, %%mm0		\n\t" /* (buf0[eax] - buf1[eax])yalpha1>>16*/\

  192. 		"pmulhw %%mm5, %%mm2		\n\t" /* (uvbuf0[eax] - uvbuf1[eax])uvalpha1>>16*/\

  193. 		"psraw $4, %%mm1		\n\t" /* buf0[eax] - buf1[eax] >>4*/\

  194. 		"movq 4096(%2, %%eax,2), %%mm4	\n\t" /* uvbuf0[eax+2048]*/\

  195. 		"psraw $4, %%mm3		\n\t" /* uvbuf0[eax] - uvbuf1[eax] >>4*/\

  196. 		"paddw %%mm0, %%mm1		\n\t" /* buf0[eax]yalpha1 + buf1[eax](1-yalpha1) >>16*/\

  197. 		"movq 4096(%3, %%eax,2), %%mm0	\n\t" /* uvbuf1[eax+2048]*/\

  198. 		"paddw %%mm2, %%mm3		\n\t" /* uvbuf0[eax]uvalpha1 - uvbuf1[eax](1-uvalpha1)*/\

  199. 		"psubw %%mm0, %%mm4		\n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048]*/\

  200. 		"psubw "MANGLE(w80)", %%mm1	\n\t" /* 8(Y-16)*/\

  201. 		"psubw "MANGLE(w400)", %%mm3	\n\t" /* 8(U-128)*/\

  202. 		"pmulhw "MANGLE(yCoeff)", %%mm1	\n\t"\

  203. \

  204. \

  205. 		"pmulhw %%mm5, %%mm4		\n\t" /* (uvbuf0[eax+2048] - uvbuf1[eax+2048])uvalpha1>>16*/\

  206. 		"movq %%mm3, %%mm2		\n\t" /* (U-128)8*/\

  207. 		"pmulhw "MANGLE(ubCoeff)", %%mm3\n\t"\

  208. 		"psraw $4, %%mm0		\n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048] >>4*/\

  209. 		"pmulhw "MANGLE(ugCoeff)", %%mm2\n\t"\

  210. 		"paddw %%mm4, %%mm0		\n\t" /* uvbuf0[eax+2048]uvalpha1 - uvbuf1[eax+2048](1-uvalpha1)*/\

  211. 		"psubw "MANGLE(w400)", %%mm0	\n\t" /* (V-128)8*/\

  212. \

  213. \

  214. 		"movq %%mm0, %%mm4		\n\t" /* (V-128)8*/\

  215. 		"pmulhw "MANGLE(vrCoeff)", %%mm0\n\t"\

  216. 		"pmulhw "MANGLE(vgCoeff)", %%mm4\n\t"\

  217. 		"paddw %%mm1, %%mm3		\n\t" /* B*/\

  218. 		"paddw %%mm1, %%mm0		\n\t" /* R*/\

  219. 		"packuswb %%mm3, %%mm3		\n\t"\

  220. \

  221. 		"packuswb %%mm0, %%mm0		\n\t"\

  222. 		"paddw %%mm4, %%mm2		\n\t"\

  223. 		"paddw %%mm2, %%mm1		\n\t" /* G*/\

  224. \

  225. 		"packuswb %%mm1, %%mm1		\n\t"

  226. 

  227. #define YSCALEYUV2RGB \

  228. 		"movd %6, %%mm6			\n\t" /*yalpha1*/\

  229. 		"punpcklwd %%mm6, %%mm6		\n\t"\

  230. 		"punpcklwd %%mm6, %%mm6		\n\t"\

  231. 		"movq %%mm6, "MANGLE(asm_yalpha1)"\n\t"\

  232. 		"movd %7, %%mm5			\n\t" /*uvalpha1*/\

  233. 		"punpcklwd %%mm5, %%mm5		\n\t"\

  234. 		"punpcklwd %%mm5, %%mm5		\n\t"\

  235. 		"movq %%mm5, "MANGLE(asm_uvalpha1)"\n\t"\

  236. 		"xorl %%eax, %%eax		\n\t"\

  237. 		".balign 16			\n\t"\

  238. 		"1:				\n\t"\

  239. 		"movq (%2, %%eax), %%mm2	\n\t" /* uvbuf0[eax]*/\

  240. 		"movq (%3, %%eax), %%mm3	\n\t" /* uvbuf1[eax]*/\

  241. 		"movq 4096(%2, %%eax), %%mm5	\n\t" /* uvbuf0[eax+2048]*/\

  242. 		"movq 4096(%3, %%eax), %%mm4	\n\t" /* uvbuf1[eax+2048]*/\

  243. 		"psubw %%mm3, %%mm2		\n\t" /* uvbuf0[eax] - uvbuf1[eax]*/\

  244. 		"psubw %%mm4, %%mm5		\n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048]*/\

  245. 		"movq "MANGLE(asm_uvalpha1)", %%mm0\n\t"\

  246. 		"pmulhw %%mm0, %%mm2		\n\t" /* (uvbuf0[eax] - uvbuf1[eax])uvalpha1>>16*/\

  247. 		"pmulhw %%mm0, %%mm5		\n\t" /* (uvbuf0[eax+2048] - uvbuf1[eax+2048])uvalpha1>>16*/\

  248. 		"psraw $4, %%mm3		\n\t" /* uvbuf0[eax] - uvbuf1[eax] >>4*/\

  249. 		"psraw $4, %%mm4		\n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048] >>4*/\

  250. 		"paddw %%mm2, %%mm3		\n\t" /* uvbuf0[eax]uvalpha1 - uvbuf1[eax](1-uvalpha1)*/\

  251. 		"paddw %%mm5, %%mm4		\n\t" /* uvbuf0[eax+2048]uvalpha1 - uvbuf1[eax+2048](1-uvalpha1)*/\

  252. 		"psubw "MANGLE(w400)", %%mm3	\n\t" /* (U-128)8*/\

  253. 		"psubw "MANGLE(w400)", %%mm4	\n\t" /* (V-128)8*/\

  254. 		"movq %%mm3, %%mm2		\n\t" /* (U-128)8*/\

  255. 		"movq %%mm4, %%mm5		\n\t" /* (V-128)8*/\

  256. 		"pmulhw "MANGLE(ugCoeff)", %%mm3\n\t"\

  257. 		"pmulhw "MANGLE(vgCoeff)", %%mm4\n\t"\

  258. 	/* mm2=(U-128)8, mm3=ug, mm4=vg mm5=(V-128)8 */\

  259. 		"movq (%0, %%eax, 2), %%mm0	\n\t" /*buf0[eax]*/\

  260. 		"movq (%1, %%eax, 2), %%mm1	\n\t" /*buf1[eax]*/\

  261. 		"movq 8(%0, %%eax, 2), %%mm6	\n\t" /*buf0[eax]*/\

  262. 		"movq 8(%1, %%eax, 2), %%mm7	\n\t" /*buf1[eax]*/\

  263. 		"psubw %%mm1, %%mm0		\n\t" /* buf0[eax] - buf1[eax]*/\

  264. 		"psubw %%mm7, %%mm6		\n\t" /* buf0[eax] - buf1[eax]*/\

  265. 		"pmulhw "MANGLE(asm_yalpha1)", %%mm0\n\t" /* (buf0[eax] - buf1[eax])yalpha1>>16*/\

  266. 		"pmulhw "MANGLE(asm_yalpha1)", %%mm6\n\t" /* (buf0[eax] - buf1[eax])yalpha1>>16*/\

  267. 		"psraw $4, %%mm1		\n\t" /* buf0[eax] - buf1[eax] >>4*/\

  268. 		"psraw $4, %%mm7		\n\t" /* buf0[eax] - buf1[eax] >>4*/\

  269. 		"paddw %%mm0, %%mm1		\n\t" /* buf0[eax]yalpha1 + buf1[eax](1-yalpha1) >>16*/\

  270. 		"paddw %%mm6, %%mm7		\n\t" /* buf0[eax]yalpha1 + buf1[eax](1-yalpha1) >>16*/\

  271. 		"pmulhw "MANGLE(ubCoeff)", %%mm2\n\t"\

  272. 		"pmulhw "MANGLE(vrCoeff)", %%mm5\n\t"\

  273. 		"psubw "MANGLE(w80)", %%mm1	\n\t" /* 8(Y-16)*/\

  274. 		"psubw "MANGLE(w80)", %%mm7	\n\t" /* 8(Y-16)*/\

  275. 		"pmulhw "MANGLE(yCoeff)", %%mm1	\n\t"\

  276. 		"pmulhw "MANGLE(yCoeff)", %%mm7	\n\t"\

  277. 	/* mm1= Y1, mm2=ub, mm3=ug, mm4=vg mm5=vr, mm7=Y2 */\

  278. 		"paddw %%mm3, %%mm4		\n\t"\

  279. 		"movq %%mm2, %%mm0		\n\t"\

  280. 		"movq %%mm5, %%mm6		\n\t"\

  281. 		"movq %%mm4, %%mm3		\n\t"\

  282. 		"punpcklwd %%mm2, %%mm2		\n\t"\

  283. 		"punpcklwd %%mm5, %%mm5		\n\t"\

  284. 		"punpcklwd %%mm4, %%mm4		\n\t"\

  285. 		"paddw %%mm1, %%mm2		\n\t"\

  286. 		"paddw %%mm1, %%mm5		\n\t"\

  287. 		"paddw %%mm1, %%mm4		\n\t"\

  288. 		"punpckhwd %%mm0, %%mm0		\n\t"\

  289. 		"punpckhwd %%mm6, %%mm6		\n\t"\

  290. 		"punpckhwd %%mm3, %%mm3		\n\t"\

  291. 		"paddw %%mm7, %%mm0		\n\t"\

  292. 		"paddw %%mm7, %%mm6		\n\t"\

  293. 		"paddw %%mm7, %%mm3		\n\t"\

  294. 		/* mm0=B1, mm2=B2, mm3=G2, mm4=G1, mm5=R1, mm6=R2 */\

  295. 		"packuswb %%mm0, %%mm2		\n\t"\

  296. 		"packuswb %%mm6, %%mm5		\n\t"\

  297. 		"packuswb %%mm3, %%mm4		\n\t"\

  298. 		"pxor %%mm7, %%mm7		\n\t"

  299. 

  300. #define YSCALEYUV2RGB1 \

  301. 		"xorl %%eax, %%eax		\n\t"\

  302. 		".balign 16			\n\t"\

  303. 		"1:				\n\t"\

  304. 		"movq (%2, %%eax), %%mm3	\n\t" /* uvbuf0[eax]*/\

  305. 		"movq 4096(%2, %%eax), %%mm4	\n\t" /* uvbuf0[eax+2048]*/\

  306. 		"psraw $4, %%mm3		\n\t" /* uvbuf0[eax] - uvbuf1[eax] >>4*/\

  307. 		"psraw $4, %%mm4		\n\t" /* uvbuf0[eax+2048] - uvbuf1[eax+2048] >>4*/\

  308. 		"psubw "MANGLE(w400)", %%mm3	\n\t" /* (U-128)8*/\

  309. 		"psubw "MANGLE(w400)", %%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 "MANGLE(ugCoeff)", %%mm3\n\t"\

  313. 		"pmulhw "MANGLE(vgCoeff)", %%mm4\n\t"\

  314. 	/* mm2=(U-128)8, mm3=ug, mm4=vg mm5=(V-128)8 */\

  315. 		"movq (%0, %%eax, 2), %%mm1	\n\t" /*buf0[eax]*/\

  316. 		"movq 8(%0, %%eax, 2), %%mm7	\n\t" /*buf0[eax]*/\

  317. 		"psraw $4, %%mm1		\n\t" /* buf0[eax] - buf1[eax] >>4*/\

  318. 		"psraw $4, %%mm7		\n\t" /* buf0[eax] - buf1[eax] >>4*/\

  319. 		"pmulhw "MANGLE(ubCoeff)", %%mm2\n\t"\

  320. 		"pmulhw "MANGLE(vrCoeff)", %%mm5\n\t"\

  321. 		"psubw "MANGLE(w80)", %%mm1	\n\t" /* 8(Y-16)*/\

  322. 		"psubw "MANGLE(w80)", %%mm7	\n\t" /* 8(Y-16)*/\

  323. 		"pmulhw "MANGLE(yCoeff)", %%mm1	\n\t"\

  324. 		"pmulhw "MANGLE(yCoeff)", %%mm7	\n\t"\

  325. 	/* mm1= Y1, mm2=ub, mm3=ug, mm4=vg mm5=vr, mm7=Y2 */\

  326. 		"paddw %%mm3, %%mm4		\n\t"\

  327. 		"movq %%mm2, %%mm0		\n\t"\

  328. 		"movq %%mm5, %%mm6		\n\t"\

  329. 		"movq %%mm4, %%mm3		\n\t"\

  330. 		"punpcklwd %%mm2, %%mm2		\n\t"\

  331. 		"punpcklwd %%mm5, %%mm5		\n\t"\

  332. 		"punpcklwd %%mm4, %%mm4		\n\t"\

  333. 		"paddw %%mm1, %%mm2		\n\t"\

  334. 		"paddw %%mm1, %%mm5		\n\t"\

  335. 		"paddw %%mm1, %%mm4		\n\t"\

  336. 		"punpckhwd %%mm0, %%mm0		\n\t"\

  337. 		"punpckhwd %%mm6, %%mm6		\n\t"\

  338. 		"punpckhwd %%mm3, %%mm3		\n\t"\

  339. 		"paddw %%mm7, %%mm0		\n\t"\

  340. 		"paddw %%mm7, %%mm6		\n\t"\

  341. 		"paddw %%mm7, %%mm3		\n\t"\

  342. 		/* mm0=B1, mm2=B2, mm3=G2, mm4=G1, mm5=R1, mm6=R2 */\

  343. 		"packuswb %%mm0, %%mm2		\n\t"\

  344. 		"packuswb %%mm6, %%mm5		\n\t"\

  345. 		"packuswb %%mm3, %%mm4		\n\t"\

  346. 		"pxor %%mm7, %%mm7		\n\t"

  347. 

  348. // do vertical chrominance interpolation

  349. #define YSCALEYUV2RGB1b \

  350. 		"xorl %%eax, %%eax		\n\t"\

  351. 		".balign 16			\n\t"\

  352. 		"1:				\n\t"\

  353. 		"movq (%2, %%eax), %%mm2	\n\t" /* uvbuf0[eax]*/\

  354. 		"movq (%3, %%eax), %%mm3	\n\t" /* uvbuf1[eax]*/\

  355. 		"movq 4096(%2, %%eax), %%mm5	\n\t" /* uvbuf0[eax+2048]*/\

  356. 		"movq 4096(%3, %%eax), %%mm4	\n\t" /* uvbuf1[eax+2048]*/\

  357. 		"paddw %%mm2, %%mm3		\n\t" /* uvbuf0[eax] + uvbuf1[eax]*/\

  358. 		"paddw %%mm5, %%mm4		\n\t" /* uvbuf0[eax+2048] + uvbuf1[eax+2048]*/\

  359. 		"psrlw $5, %%mm3		\n\t" /*FIXME might overflow*/\

  360. 		"psrlw $5, %%mm4		\n\t" /*FIXME might overflow*/\

  361. 		"psubw "MANGLE(w400)", %%mm3	\n\t" /* (U-128)8*/\

  362. 		"psubw "MANGLE(w400)", %%mm4	\n\t" /* (V-128)8*/\

  363. 		"movq %%mm3, %%mm2		\n\t" /* (U-128)8*/\

  364. 		"movq %%mm4, %%mm5		\n\t" /* (V-128)8*/\

  365. 		"pmulhw "MANGLE(ugCoeff)", %%mm3\n\t"\

  366. 		"pmulhw "MANGLE(vgCoeff)", %%mm4\n\t"\

  367. 	/* mm2=(U-128)8, mm3=ug, mm4=vg mm5=(V-128)8 */\

  368. 		"movq (%0, %%eax, 2), %%mm1	\n\t" /*buf0[eax]*/\

  369. 		"movq 8(%0, %%eax, 2), %%mm7	\n\t" /*buf0[eax]*/\

  370. 		"psraw $4, %%mm1		\n\t" /* buf0[eax] - buf1[eax] >>4*/\

  371. 		"psraw $4, %%mm7		\n\t" /* buf0[eax] - buf1[eax] >>4*/\

  372. 		"pmulhw "MANGLE(ubCoeff)", %%mm2\n\t"\

  373. 		"pmulhw "MANGLE(vrCoeff)", %%mm5\n\t"\

  374. 		"psubw "MANGLE(w80)", %%mm1	\n\t" /* 8(Y-16)*/\

  375. 		"psubw "MANGLE(w80)", %%mm7	\n\t" /* 8(Y-16)*/\

  376. 		"pmulhw "MANGLE(yCoeff)", %%mm1	\n\t"\

  377. 		"pmulhw "MANGLE(yCoeff)", %%mm7	\n\t"\

  378. 	/* mm1= Y1, mm2=ub, mm3=ug, mm4=vg mm5=vr, mm7=Y2 */\

  379. 		"paddw %%mm3, %%mm4		\n\t"\

  380. 		"movq %%mm2, %%mm0		\n\t"\

  381. 		"movq %%mm5, %%mm6		\n\t"\

  382. 		"movq %%mm4, %%mm3		\n\t"\

  383. 		"punpcklwd %%mm2, %%mm2		\n\t"\

  384. 		"punpcklwd %%mm5, %%mm5		\n\t"\

  385. 		"punpcklwd %%mm4, %%mm4		\n\t"\

  386. 		"paddw %%mm1, %%mm2		\n\t"\

  387. 		"paddw %%mm1, %%mm5		\n\t"\

  388. 		"paddw %%mm1, %%mm4		\n\t"\

  389. 		"punpckhwd %%mm0, %%mm0		\n\t"\

  390. 		"punpckhwd %%mm6, %%mm6		\n\t"\

  391. 		"punpckhwd %%mm3, %%mm3		\n\t"\

  392. 		"paddw %%mm7, %%mm0		\n\t"\

  393. 		"paddw %%mm7, %%mm6		\n\t"\

  394. 		"paddw %%mm7, %%mm3		\n\t"\

  395. 		/* mm0=B1, mm2=B2, mm3=G2, mm4=G1, mm5=R1, mm6=R2 */\

  396. 		"packuswb %%mm0, %%mm2		\n\t"\

  397. 		"packuswb %%mm6, %%mm5		\n\t"\

  398. 		"packuswb %%mm3, %%mm4		\n\t"\

  399. 		"pxor %%mm7, %%mm7		\n\t"

  400. 

  401. #define WRITEBGR32 \

  402. 		/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */\

  403. 			"movq %%mm2, %%mm1		\n\t" /* B */\

  404. 			"movq %%mm5, %%mm6		\n\t" /* R */\

  405. 			"punpcklbw %%mm4, %%mm2		\n\t" /* GBGBGBGB 0 */\

  406. 			"punpcklbw %%mm7, %%mm5		\n\t" /* 0R0R0R0R 0 */\

  407. 			"punpckhbw %%mm4, %%mm1		\n\t" /* GBGBGBGB 2 */\

  408. 			"punpckhbw %%mm7, %%mm6		\n\t" /* 0R0R0R0R 2 */\

  409. 			"movq %%mm2, %%mm0		\n\t" /* GBGBGBGB 0 */\

  410. 			"movq %%mm1, %%mm3		\n\t" /* GBGBGBGB 2 */\

  411. 			"punpcklwd %%mm5, %%mm0		\n\t" /* 0RGB0RGB 0 */\

  412. 			"punpckhwd %%mm5, %%mm2		\n\t" /* 0RGB0RGB 1 */\

  413. 			"punpcklwd %%mm6, %%mm1		\n\t" /* 0RGB0RGB 2 */\

  414. 			"punpckhwd %%mm6, %%mm3		\n\t" /* 0RGB0RGB 3 */\

  415. \

  416. 			MOVNTQ(%%mm0, (%4, %%eax, 4))\

  417. 			MOVNTQ(%%mm2, 8(%4, %%eax, 4))\

  418. 			MOVNTQ(%%mm1, 16(%4, %%eax, 4))\

  419. 			MOVNTQ(%%mm3, 24(%4, %%eax, 4))\

  420. \

  421. 			"addl $8, %%eax			\n\t"\

  422. 			"cmpl %5, %%eax			\n\t"\

  423. 			" jb 1b				\n\t"

  424. 

  425. #define WRITEBGR16 \

  426. 			"pand "MANGLE(bF8)", %%mm2	\n\t" /* B */\

  427. 			"pand "MANGLE(bFC)", %%mm4	\n\t" /* G */\

  428. 			"pand "MANGLE(bF8)", %%mm5	\n\t" /* R */\

  429. 			"psrlq $3, %%mm2		\n\t"\

  430. \

  431. 			"movq %%mm2, %%mm1		\n\t"\

  432. 			"movq %%mm4, %%mm3		\n\t"\

  433. \

  434. 			"punpcklbw %%mm7, %%mm3		\n\t"\

  435. 			"punpcklbw %%mm5, %%mm2		\n\t"\

  436. 			"punpckhbw %%mm7, %%mm4		\n\t"\

  437. 			"punpckhbw %%mm5, %%mm1		\n\t"\

  438. \

  439. 			"psllq $3, %%mm3		\n\t"\

  440. 			"psllq $3, %%mm4		\n\t"\

  441. \

  442. 			"por %%mm3, %%mm2		\n\t"\

  443. 			"por %%mm4, %%mm1		\n\t"\

  444. \

  445. 			MOVNTQ(%%mm2, (%4, %%eax, 2))\

  446. 			MOVNTQ(%%mm1, 8(%4, %%eax, 2))\

  447. \

  448. 			"addl $8, %%eax			\n\t"\

  449. 			"cmpl %5, %%eax			\n\t"\

  450. 			" jb 1b				\n\t"

  451. 

  452. #define WRITEBGR15 \

  453. 			"pand "MANGLE(bF8)", %%mm2	\n\t" /* B */\

  454. 			"pand "MANGLE(bF8)", %%mm4	\n\t" /* G */\

  455. 			"pand "MANGLE(bF8)", %%mm5	\n\t" /* R */\

  456. 			"psrlq $3, %%mm2		\n\t"\

  457. 			"psrlq $1, %%mm5		\n\t"\

  458. \

  459. 			"movq %%mm2, %%mm1		\n\t"\

  460. 			"movq %%mm4, %%mm3		\n\t"\

  461. \

  462. 			"punpcklbw %%mm7, %%mm3		\n\t"\

  463. 			"punpcklbw %%mm5, %%mm2		\n\t"\

  464. 			"punpckhbw %%mm7, %%mm4		\n\t"\

  465. 			"punpckhbw %%mm5, %%mm1		\n\t"\

  466. \

  467. 			"psllq $2, %%mm3		\n\t"\

  468. 			"psllq $2, %%mm4		\n\t"\

  469. \

  470. 			"por %%mm3, %%mm2		\n\t"\

  471. 			"por %%mm4, %%mm1		\n\t"\

  472. \

  473. 			MOVNTQ(%%mm2, (%4, %%eax, 2))\

  474. 			MOVNTQ(%%mm1, 8(%4, %%eax, 2))\

  475. \

  476. 			"addl $8, %%eax			\n\t"\

  477. 			"cmpl %5, %%eax			\n\t"\

  478. 			" jb 1b				\n\t"

  479. 

  480. #define WRITEBGR24OLD \

  481. 		/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */\

  482. 			"movq %%mm2, %%mm1		\n\t" /* B */\

  483. 			"movq %%mm5, %%mm6		\n\t" /* R */\

  484. 			"punpcklbw %%mm4, %%mm2		\n\t" /* GBGBGBGB 0 */\

  485. 			"punpcklbw %%mm7, %%mm5		\n\t" /* 0R0R0R0R 0 */\

  486. 			"punpckhbw %%mm4, %%mm1		\n\t" /* GBGBGBGB 2 */\

  487. 			"punpckhbw %%mm7, %%mm6		\n\t" /* 0R0R0R0R 2 */\

  488. 			"movq %%mm2, %%mm0		\n\t" /* GBGBGBGB 0 */\

  489. 			"movq %%mm1, %%mm3		\n\t" /* GBGBGBGB 2 */\

  490. 			"punpcklwd %%mm5, %%mm0		\n\t" /* 0RGB0RGB 0 */\

  491. 			"punpckhwd %%mm5, %%mm2		\n\t" /* 0RGB0RGB 1 */\

  492. 			"punpcklwd %%mm6, %%mm1		\n\t" /* 0RGB0RGB 2 */\

  493. 			"punpckhwd %%mm6, %%mm3		\n\t" /* 0RGB0RGB 3 */\

  494. \

  495. 			"movq %%mm0, %%mm4		\n\t" /* 0RGB0RGB 0 */\

  496. 			"psrlq $8, %%mm0		\n\t" /* 00RGB0RG 0 */\

  497. 			"pand "MANGLE(bm00000111)", %%mm4\n\t" /* 00000RGB 0 */\

  498. 			"pand "MANGLE(bm11111000)", %%mm0\n\t" /* 00RGB000 0.5 */\

  499. 			"por %%mm4, %%mm0		\n\t" /* 00RGBRGB 0 */\

  500. 			"movq %%mm2, %%mm4		\n\t" /* 0RGB0RGB 1 */\

  501. 			"psllq $48, %%mm2		\n\t" /* GB000000 1 */\

  502. 			"por %%mm2, %%mm0		\n\t" /* GBRGBRGB 0 */\

  503. \

  504. 			"movq %%mm4, %%mm2		\n\t" /* 0RGB0RGB 1 */\

  505. 			"psrld $16, %%mm4		\n\t" /* 000R000R 1 */\

  506. 			"psrlq $24, %%mm2		\n\t" /* 0000RGB0 1.5 */\

  507. 			"por %%mm4, %%mm2		\n\t" /* 000RRGBR 1 */\

  508. 			"pand "MANGLE(bm00001111)", %%mm2\n\t" /* 0000RGBR 1 */\

  509. 			"movq %%mm1, %%mm4		\n\t" /* 0RGB0RGB 2 */\

  510. 			"psrlq $8, %%mm1		\n\t" /* 00RGB0RG 2 */\

  511. 			"pand "MANGLE(bm00000111)", %%mm4\n\t" /* 00000RGB 2 */\

  512. 			"pand "MANGLE(bm11111000)", %%mm1\n\t" /* 00RGB000 2.5 */\

  513. 			"por %%mm4, %%mm1		\n\t" /* 00RGBRGB 2 */\

  514. 			"movq %%mm1, %%mm4		\n\t" /* 00RGBRGB 2 */\

  515. 			"psllq $32, %%mm1		\n\t" /* BRGB0000 2 */\

  516. 			"por %%mm1, %%mm2		\n\t" /* BRGBRGBR 1 */\

  517. \

  518. 			"psrlq $32, %%mm4		\n\t" /* 000000RG 2.5 */\

  519. 			"movq %%mm3, %%mm5		\n\t" /* 0RGB0RGB 3 */\

  520. 			"psrlq $8, %%mm3		\n\t" /* 00RGB0RG 3 */\

  521. 			"pand "MANGLE(bm00000111)", %%mm5\n\t" /* 00000RGB 3 */\

  522. 			"pand "MANGLE(bm11111000)", %%mm3\n\t" /* 00RGB000 3.5 */\

  523. 			"por %%mm5, %%mm3		\n\t" /* 00RGBRGB 3 */\

  524. 			"psllq $16, %%mm3		\n\t" /* RGBRGB00 3 */\

  525. 			"por %%mm4, %%mm3		\n\t" /* RGBRGBRG 2.5 */\

  526. \

  527. 			MOVNTQ(%%mm0, (%%ebx))\

  528. 			MOVNTQ(%%mm2, 8(%%ebx))\

  529. 			MOVNTQ(%%mm3, 16(%%ebx))\

  530. 			"addl $24, %%ebx		\n\t"\

  531. \

  532. 			"addl $8, %%eax			\n\t"\

  533. 			"cmpl %5, %%eax			\n\t"\

  534. 			" jb 1b				\n\t"

  535. 

  536. #define WRITEBGR24MMX \

  537. 		/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */\

  538. 			"movq %%mm2, %%mm1		\n\t" /* B */\

  539. 			"movq %%mm5, %%mm6		\n\t" /* R */\

  540. 			"punpcklbw %%mm4, %%mm2		\n\t" /* GBGBGBGB 0 */\

  541. 			"punpcklbw %%mm7, %%mm5		\n\t" /* 0R0R0R0R 0 */\

  542. 			"punpckhbw %%mm4, %%mm1		\n\t" /* GBGBGBGB 2 */\

  543. 			"punpckhbw %%mm7, %%mm6		\n\t" /* 0R0R0R0R 2 */\

  544. 			"movq %%mm2, %%mm0		\n\t" /* GBGBGBGB 0 */\

  545. 			"movq %%mm1, %%mm3		\n\t" /* GBGBGBGB 2 */\

  546. 			"punpcklwd %%mm5, %%mm0		\n\t" /* 0RGB0RGB 0 */\

  547. 			"punpckhwd %%mm5, %%mm2		\n\t" /* 0RGB0RGB 1 */\

  548. 			"punpcklwd %%mm6, %%mm1		\n\t" /* 0RGB0RGB 2 */\

  549. 			"punpckhwd %%mm6, %%mm3		\n\t" /* 0RGB0RGB 3 */\

  550. \

  551. 			"movq %%mm0, %%mm4		\n\t" /* 0RGB0RGB 0 */\

  552. 			"movq %%mm2, %%mm6		\n\t" /* 0RGB0RGB 1 */\

  553. 			"movq %%mm1, %%mm5		\n\t" /* 0RGB0RGB 2 */\

  554. 			"movq %%mm3, %%mm7		\n\t" /* 0RGB0RGB 3 */\

  555. \

  556. 			"psllq $40, %%mm0		\n\t" /* RGB00000 0 */\

  557. 			"psllq $40, %%mm2		\n\t" /* RGB00000 1 */\

  558. 			"psllq $40, %%mm1		\n\t" /* RGB00000 2 */\

  559. 			"psllq $40, %%mm3		\n\t" /* RGB00000 3 */\

  560. \

  561. 			"punpckhdq %%mm4, %%mm0		\n\t" /* 0RGBRGB0 0 */\

  562. 			"punpckhdq %%mm6, %%mm2		\n\t" /* 0RGBRGB0 1 */\

  563. 			"punpckhdq %%mm5, %%mm1		\n\t" /* 0RGBRGB0 2 */\

  564. 			"punpckhdq %%mm7, %%mm3		\n\t" /* 0RGBRGB0 3 */\

  565. \

  566. 			"psrlq $8, %%mm0		\n\t" /* 00RGBRGB 0 */\

  567. 			"movq %%mm2, %%mm6		\n\t" /* 0RGBRGB0 1 */\

  568. 			"psllq $40, %%mm2		\n\t" /* GB000000 1 */\

  569. 			"por %%mm2, %%mm0		\n\t" /* GBRGBRGB 0 */\

  570. 			MOVNTQ(%%mm0, (%%ebx))\

  571. \

  572. 			"psrlq $24, %%mm6		\n\t" /* 0000RGBR 1 */\

  573. 			"movq %%mm1, %%mm5		\n\t" /* 0RGBRGB0 2 */\

  574. 			"psllq $24, %%mm1		\n\t" /* BRGB0000 2 */\

  575. 			"por %%mm1, %%mm6		\n\t" /* BRGBRGBR 1 */\

  576. 			MOVNTQ(%%mm6, 8(%%ebx))\

  577. \

  578. 			"psrlq $40, %%mm5		\n\t" /* 000000RG 2 */\

  579. 			"psllq $8, %%mm3		\n\t" /* RGBRGB00 3 */\

  580. 			"por %%mm3, %%mm5		\n\t" /* RGBRGBRG 2 */\

  581. 			MOVNTQ(%%mm5, 16(%%ebx))\

  582. \

  583. 			"addl $24, %%ebx		\n\t"\

  584. \

  585. 			"addl $8, %%eax			\n\t"\

  586. 			"cmpl %5, %%eax			\n\t"\

  587. 			" jb 1b				\n\t"

  588. 

  589. #define WRITEBGR24MMX2 \

  590. 		/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */\

  591. 			"movq "MANGLE(M24A)", %%mm0	\n\t"\

  592. 			"movq "MANGLE(M24C)", %%mm7	\n\t"\

  593. 			"pshufw $0x50, %%mm2, %%mm1	\n\t" /* B3 B2 B3 B2  B1 B0 B1 B0 */\

  594. 			"pshufw $0x50, %%mm4, %%mm3	\n\t" /* G3 G2 G3 G2  G1 G0 G1 G0 */\

  595. 			"pshufw $0x00, %%mm5, %%mm6	\n\t" /* R1 R0 R1 R0  R1 R0 R1 R0 */\

  596. \

  597. 			"pand %%mm0, %%mm1		\n\t" /*    B2        B1       B0 */\

  598. 			"pand %%mm0, %%mm3		\n\t" /*    G2        G1       G0 */\

  599. 			"pand %%mm7, %%mm6		\n\t" /*       R1        R0       */\

  600. \

  601. 			"psllq $8, %%mm3		\n\t" /* G2        G1       G0    */\

  602. 			"por %%mm1, %%mm6		\n\t"\

  603. 			"por %%mm3, %%mm6		\n\t"\

  604. 			MOVNTQ(%%mm6, (%%ebx))\

  605. \

  606. 			"psrlq $8, %%mm4		\n\t" /* 00 G7 G6 G5  G4 G3 G2 G1 */\

  607. 			"pshufw $0xA5, %%mm2, %%mm1	\n\t" /* B5 B4 B5 B4  B3 B2 B3 B2 */\

  608. 			"pshufw $0x55, %%mm4, %%mm3	\n\t" /* G4 G3 G4 G3  G4 G3 G4 G3 */\

  609. 			"pshufw $0xA5, %%mm5, %%mm6	\n\t" /* R5 R4 R5 R4  R3 R2 R3 R2 */\

  610. \

  611. 			"pand "MANGLE(M24B)", %%mm1	\n\t" /* B5       B4        B3    */\

  612. 			"pand %%mm7, %%mm3		\n\t" /*       G4        G3       */\

  613. 			"pand %%mm0, %%mm6		\n\t" /*    R4        R3       R2 */\

  614. \

  615. 			"por %%mm1, %%mm3		\n\t" /* B5    G4 B4     G3 B3    */\

  616. 			"por %%mm3, %%mm6		\n\t"\

  617. 			MOVNTQ(%%mm6, 8(%%ebx))\

  618. \

  619. 			"pshufw $0xFF, %%mm2, %%mm1	\n\t" /* B7 B6 B7 B6  B7 B6 B6 B7 */\

  620. 			"pshufw $0xFA, %%mm4, %%mm3	\n\t" /* 00 G7 00 G7  G6 G5 G6 G5 */\

  621. 			"pshufw $0xFA, %%mm5, %%mm6	\n\t" /* R7 R6 R7 R6  R5 R4 R5 R4 */\

  622. \

  623. 			"pand %%mm7, %%mm1		\n\t" /*       B7        B6       */\

  624. 			"pand %%mm0, %%mm3		\n\t" /*    G7        G6       G5 */\

  625. 			"pand "MANGLE(M24B)", %%mm6	\n\t" /* R7       R6        R5    */\

  626. \

  627. 			"por %%mm1, %%mm3		\n\t"\

  628. 			"por %%mm3, %%mm6		\n\t"\

  629. 			MOVNTQ(%%mm6, 16(%%ebx))\

  630. \

  631. 			"addl $24, %%ebx		\n\t"\

  632. \

  633. 			"addl $8, %%eax			\n\t"\

  634. 			"cmpl %5, %%eax			\n\t"\

  635. 			" jb 1b				\n\t"

  636. 

  637. #ifdef HAVE_MMX2

  638. #undef WRITEBGR24

  639. #define WRITEBGR24 WRITEBGR24MMX2

  640. #else

  641. #undef WRITEBGR24

  642. #define WRITEBGR24 WRITEBGR24MMX

  643. #endif

  644. 

  645. static inline void RENAME(yuv2yuvX)(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,

  646. 				    int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,

  647. 				    uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW,

  648. 				    int16_t * lumMmxFilter, int16_t * chrMmxFilter)

  649. {

  650. #ifdef HAVE_MMX

  651. 	if(uDest != NULL)

  652. 	{

  653. 		asm volatile(

  654. 				YSCALEYUV2YV12X(0)

  655. 				:: "m" (-chrFilterSize), "r" (chrSrc+chrFilterSize),

  656. 				"r" (chrMmxFilter+chrFilterSize*4), "r" (uDest), "m" (dstW>>1)

  657. 				: "%eax", "%edx", "%esi"

  658. 			);

  659. 

  660. 		asm volatile(

  661. 				YSCALEYUV2YV12X(4096)

  662. 				:: "m" (-chrFilterSize), "r" (chrSrc+chrFilterSize),

  663. 				"r" (chrMmxFilter+chrFilterSize*4), "r" (vDest), "m" (dstW>>1)

  664. 				: "%eax", "%edx", "%esi"

  665. 			);

  666. 	}

  667. 

  668. 	asm volatile(

  669. 			YSCALEYUV2YV12X(0)

  670. 			:: "m" (-lumFilterSize), "r" (lumSrc+lumFilterSize),

  671. 			   "r" (lumMmxFilter+lumFilterSize*4), "r" (dest), "m" (dstW)

  672. 			: "%eax", "%edx", "%esi"

  673. 		);

  674. #else

  675. yuv2yuvXinC(lumFilter, lumSrc, lumFilterSize,

  676. 	    chrFilter, chrSrc, chrFilterSize,

  677. 	    dest, uDest, vDest, dstW);

  678. #endif

  679. }

  680. 

  681. static inline void RENAME(yuv2yuv1)(int16_t *lumSrc, int16_t *chrSrc,

  682. 				    uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW)

  683. {

  684. #ifdef HAVE_MMX

  685. 	if(uDest != NULL)

  686. 	{

  687. 		asm volatile(

  688. 				YSCALEYUV2YV121

  689. 				:: "r" (chrSrc + (dstW>>1)), "r" (uDest + (dstW>>1)),

  690. 				"g" (-(dstW>>1))

  691. 				: "%eax"

  692. 			);

  693. 

  694. 		asm volatile(

  695. 				YSCALEYUV2YV121

  696. 				:: "r" (chrSrc + 2048 + (dstW>>1)), "r" (vDest + (dstW>>1)),

  697. 				"g" (-(dstW>>1))

  698. 				: "%eax"

  699. 			);

  700. 	}

  701. 

  702. 	asm volatile(

  703. 		YSCALEYUV2YV121

  704. 		:: "r" (lumSrc + dstW), "r" (dest + dstW),

  705. 		"g" (-dstW)

  706. 		: "%eax"

  707. 	);

  708. #else

  709. 	//FIXME Optimize (just quickly writen not opti..)

  710. 	//FIXME replace MINMAX with LUTs

  711. 	int i;

  712. 	for(i=0; i<dstW; i++)

  713. 	{

  714. 		int val= lumSrc[i]>>7;

  715. 

  716. 		dest[i]= MIN(MAX(val>>19, 0), 255);

  717. 	}

  718. 

  719. 	if(uDest != NULL)

  720. 		for(i=0; i<(dstW>>1); i++)

  721. 		{

  722. 			int u=chrSrc[i]>>7;

  723. 			int v=chrSrc[i + 2048]>>7;

  724. 

  725. 			uDest[i]= MIN(MAX(u>>19, 0), 255);

  726. 			vDest[i]= MIN(MAX(v>>19, 0), 255);

  727. 		}

  728. #endif

  729. }

  730. 

  731. 

  732. /**

  733.  * vertical scale YV12 to RGB

  734.  */

  735. static inline void RENAME(yuv2rgbX)(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,

  736. 				    int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,

  737. 			    uint8_t *dest, int dstW, int dstFormat, int16_t * lumMmxFilter, int16_t * chrMmxFilter)

  738. {

  739. /*	if(flags&SWS_FULL_UV_IPOL)

  740. 	{

  741. //FIXME

  742. 	}//FULL_UV_IPOL

  743. 	else*/

  744. 	{

  745. #ifdef HAVE_MMX

  746. 		if(dstFormat == IMGFMT_BGR32) //FIXME untested

  747. 		{

  748. 			asm volatile(

  749. 				YSCALEYUV2RGBX

  750. 				WRITEBGR32

  751. 

  752. 			:: "m" (-lumFilterSize), "m" (-chrFilterSize),

  753. 			   "m" (lumMmxFilter+lumFilterSize*4), "m" (chrMmxFilter+chrFilterSize*4),

  754. 			   "r" (dest), "m" (dstW),

  755. 			   "m" (lumSrc+lumFilterSize), "m" (chrSrc+chrFilterSize)

  756. 			: "%eax", "%ebx", "%ecx", "%edx", "%esi"

  757. 			);

  758. 		}

  759. 		else if(dstFormat == IMGFMT_BGR24) //FIXME untested

  760. 		{

  761. 			asm volatile(

  762. 				YSCALEYUV2RGBX

  763. 				"leal (%%eax, %%eax, 2), %%ebx	\n\t" //FIXME optimize

  764. 				"addl %4, %%ebx			\n\t"

  765. 				WRITEBGR24

  766. 

  767. 			:: "m" (-lumFilterSize), "m" (-chrFilterSize),

  768. 			   "m" (lumMmxFilter+lumFilterSize*4), "m" (chrMmxFilter+chrFilterSize*4),

  769. 			   "r" (dest), "m" (dstW),

  770. 			   "m" (lumSrc+lumFilterSize), "m" (chrSrc+chrFilterSize)

  771. 			: "%eax", "%ebx", "%ecx", "%edx", "%esi"

  772. 			);

  773. 		}

  774. 		else if(dstFormat==IMGFMT_BGR15)

  775. 		{

  776. 			asm volatile(

  777. 				YSCALEYUV2RGBX

  778. 		/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */

  779. #ifdef DITHER1XBPP

  780. 				"paddusb "MANGLE(b5Dither)", %%mm2\n\t"

  781. 				"paddusb "MANGLE(g5Dither)", %%mm4\n\t"

  782. 				"paddusb "MANGLE(r5Dither)", %%mm5\n\t"

  783. #endif

  784. 

  785. 				WRITEBGR15

  786. 

  787. 			:: "m" (-lumFilterSize), "m" (-chrFilterSize),

  788. 			   "m" (lumMmxFilter+lumFilterSize*4), "m" (chrMmxFilter+chrFilterSize*4),

  789. 			   "r" (dest), "m" (dstW),

  790. 			   "m" (lumSrc+lumFilterSize), "m" (chrSrc+chrFilterSize)

  791. 			: "%eax", "%ebx", "%ecx", "%edx", "%esi"

  792. 			);

  793. 		}

  794. 		else if(dstFormat==IMGFMT_BGR16)

  795. 		{

  796. 			asm volatile(

  797. 				YSCALEYUV2RGBX

  798. 		/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */

  799. #ifdef DITHER1XBPP

  800. 				"paddusb "MANGLE(b5Dither)", %%mm2\n\t"

  801. 				"paddusb "MANGLE(g6Dither)", %%mm4\n\t"

  802. 				"paddusb "MANGLE(r5Dither)", %%mm5\n\t"

  803. #endif

  804. 

  805. 				WRITEBGR16

  806. 

  807. 			:: "m" (-lumFilterSize), "m" (-chrFilterSize),

  808. 			   "m" (lumMmxFilter+lumFilterSize*4), "m" (chrMmxFilter+chrFilterSize*4),

  809. 			   "r" (dest), "m" (dstW),

  810. 			   "m" (lumSrc+lumFilterSize), "m" (chrSrc+chrFilterSize)

  811. 			: "%eax", "%ebx", "%ecx", "%edx", "%esi"

  812. 			);

  813. 		}

  814. #else

  815. yuv2rgbXinC(lumFilter, lumSrc, lumFilterSize,

  816. 	    chrFilter, chrSrc, chrFilterSize,

  817. 	    dest, dstW, dstFormat);

  818. 

  819. #endif

  820. 	} //!FULL_UV_IPOL

  821. }

  822. 

  823. 

  824. /**

  825.  * vertical bilinear scale YV12 to RGB

  826.  */

  827. static inline void RENAME(yuv2rgb2)(uint16_t *buf0, uint16_t *buf1, uint16_t *uvbuf0, uint16_t *uvbuf1,

  828. 			    uint8_t *dest, int dstW, int yalpha, int uvalpha, int dstFormat, int flags)

  829. {

  830. 	int yalpha1=yalpha^4095;

  831. 	int uvalpha1=uvalpha^4095;

  832. 

  833. 	if(flags&SWS_FULL_UV_IPOL)

  834. 	{

  835. 

  836. #ifdef HAVE_MMX

  837. 		if(dstFormat==IMGFMT_BGR32)

  838. 		{

  839. 			asm volatile(

  840. 

  841. 

  842. FULL_YSCALEYUV2RGB

  843. 			"punpcklbw %%mm1, %%mm3		\n\t" // BGBGBGBG

  844. 			"punpcklbw %%mm7, %%mm0		\n\t" // R0R0R0R0

  845. 

  846. 			"movq %%mm3, %%mm1		\n\t"

  847. 			"punpcklwd %%mm0, %%mm3		\n\t" // BGR0BGR0

  848. 			"punpckhwd %%mm0, %%mm1		\n\t" // BGR0BGR0

  849. 

  850. 			MOVNTQ(%%mm3, (%4, %%eax, 4))

  851. 			MOVNTQ(%%mm1, 8(%4, %%eax, 4))

  852. 

  853. 			"addl $4, %%eax			\n\t"

  854. 			"cmpl %5, %%eax			\n\t"

  855. 			" jb 1b				\n\t"

  856. 

  857. 

  858. 			:: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW),

  859. 			"m" (yalpha1), "m" (uvalpha1)

  860. 			: "%eax"

  861. 			);

  862. 		}

  863. 		else if(dstFormat==IMGFMT_BGR24)

  864. 		{

  865. 			asm volatile(

  866. 

  867. FULL_YSCALEYUV2RGB

  868. 

  869. 								// lsb ... msb

  870. 			"punpcklbw %%mm1, %%mm3		\n\t" // BGBGBGBG

  871. 			"punpcklbw %%mm7, %%mm0		\n\t" // R0R0R0R0

  872. 

  873. 			"movq %%mm3, %%mm1		\n\t"

  874. 			"punpcklwd %%mm0, %%mm3		\n\t" // BGR0BGR0

  875. 			"punpckhwd %%mm0, %%mm1		\n\t" // BGR0BGR0

  876. 

  877. 			"movq %%mm3, %%mm2		\n\t" // BGR0BGR0

  878. 			"psrlq $8, %%mm3		\n\t" // GR0BGR00

  879. 			"pand "MANGLE(bm00000111)", %%mm2\n\t" // BGR00000

  880. 			"pand "MANGLE(bm11111000)", %%mm3\n\t" // 000BGR00

  881. 			"por %%mm2, %%mm3		\n\t" // BGRBGR00

  882. 			"movq %%mm1, %%mm2		\n\t"

  883. 			"psllq $48, %%mm1		\n\t" // 000000BG

  884. 			"por %%mm1, %%mm3		\n\t" // BGRBGRBG

  885. 

  886. 			"movq %%mm2, %%mm1		\n\t" // BGR0BGR0

  887. 			"psrld $16, %%mm2		\n\t" // R000R000

  888. 			"psrlq $24, %%mm1		\n\t" // 0BGR0000

  889. 			"por %%mm2, %%mm1		\n\t" // RBGRR000

  890. 

  891. 			"movl %4, %%ebx			\n\t"

  892. 			"addl %%eax, %%ebx		\n\t"

  893. 

  894. #ifdef HAVE_MMX2

  895. 			//FIXME Alignment

  896. 			"movntq %%mm3, (%%ebx, %%eax, 2)\n\t"

  897. 			"movntq %%mm1, 8(%%ebx, %%eax, 2)\n\t"

  898. #else

  899. 			"movd %%mm3, (%%ebx, %%eax, 2)	\n\t"

  900. 			"psrlq $32, %%mm3		\n\t"

  901. 			"movd %%mm3, 4(%%ebx, %%eax, 2)	\n\t"

  902. 			"movd %%mm1, 8(%%ebx, %%eax, 2)	\n\t"

  903. #endif

  904. 			"addl $4, %%eax			\n\t"

  905. 			"cmpl %5, %%eax			\n\t"

  906. 			" jb 1b				\n\t"

  907. 

  908. 			:: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "m" (dest), "m" (dstW),

  909. 			"m" (yalpha1), "m" (uvalpha1)

  910. 			: "%eax", "%ebx"

  911. 			);

  912. 		}

  913. 		else if(dstFormat==IMGFMT_BGR15)

  914. 		{

  915. 			asm volatile(

  916. 

  917. FULL_YSCALEYUV2RGB

  918. #ifdef DITHER1XBPP

  919. 			"paddusb "MANGLE(g5Dither)", %%mm1\n\t"

  920. 			"paddusb "MANGLE(r5Dither)", %%mm0\n\t"

  921. 			"paddusb "MANGLE(b5Dither)", %%mm3\n\t"

  922. #endif

  923. 			"punpcklbw %%mm7, %%mm1		\n\t" // 0G0G0G0G

  924. 			"punpcklbw %%mm7, %%mm3		\n\t" // 0B0B0B0B

  925. 			"punpcklbw %%mm7, %%mm0		\n\t" // 0R0R0R0R

  926. 

  927. 			"psrlw $3, %%mm3		\n\t"

  928. 			"psllw $2, %%mm1		\n\t"

  929. 			"psllw $7, %%mm0		\n\t"

  930. 			"pand "MANGLE(g15Mask)", %%mm1	\n\t"

  931. 			"pand "MANGLE(r15Mask)", %%mm0	\n\t"

  932. 

  933. 			"por %%mm3, %%mm1		\n\t"

  934. 			"por %%mm1, %%mm0		\n\t"

  935. 

  936. 			MOVNTQ(%%mm0, (%4, %%eax, 2))

  937. 

  938. 			"addl $4, %%eax			\n\t"

  939. 			"cmpl %5, %%eax			\n\t"

  940. 			" jb 1b				\n\t"

  941. 

  942. 			:: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW),

  943. 			"m" (yalpha1), "m" (uvalpha1)

  944. 			: "%eax"

  945. 			);

  946. 		}

  947. 		else if(dstFormat==IMGFMT_BGR16)

  948. 		{

  949. 			asm volatile(

  950. 

  951. FULL_YSCALEYUV2RGB

  952. #ifdef DITHER1XBPP

  953. 			"paddusb "MANGLE(g6Dither)", %%mm1\n\t"

  954. 			"paddusb "MANGLE(r5Dither)", %%mm0\n\t"

  955. 			"paddusb "MANGLE(b5Dither)", %%mm3\n\t"

  956. #endif

  957. 			"punpcklbw %%mm7, %%mm1		\n\t" // 0G0G0G0G

  958. 			"punpcklbw %%mm7, %%mm3		\n\t" // 0B0B0B0B

  959. 			"punpcklbw %%mm7, %%mm0		\n\t" // 0R0R0R0R

  960. 

  961. 			"psrlw $3, %%mm3		\n\t"

  962. 			"psllw $3, %%mm1		\n\t"

  963. 			"psllw $8, %%mm0		\n\t"

  964. 			"pand "MANGLE(g16Mask)", %%mm1	\n\t"

  965. 			"pand "MANGLE(r16Mask)", %%mm0	\n\t"

  966. 

  967. 			"por %%mm3, %%mm1		\n\t"

  968. 			"por %%mm1, %%mm0		\n\t"

  969. 

  970. 			MOVNTQ(%%mm0, (%4, %%eax, 2))

  971. 

  972. 			"addl $4, %%eax			\n\t"

  973. 			"cmpl %5, %%eax			\n\t"

  974. 			" jb 1b				\n\t"

  975. 

  976. 			:: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW),

  977. 			"m" (yalpha1), "m" (uvalpha1)

  978. 			: "%eax"

  979. 			);

  980. 		}

  981. #else

  982. 		if(dstFormat==IMGFMT_BGR32)

  983. 		{

  984. 			int i;

  985. 			for(i=0;i<dstW;i++){

  986. 				// vertical linear interpolation && yuv2rgb in a single step:

  987. 				int Y=yuvtab_2568[((buf0[i]*yalpha1+buf1[i]*yalpha)>>19)];

  988. 				int U=((uvbuf0[i]*uvalpha1+uvbuf1[i]*uvalpha)>>19);

  989. 				int V=((uvbuf0[i+2048]*uvalpha1+uvbuf1[i+2048]*uvalpha)>>19);

  990. 				dest[0]=clip_table[((Y + yuvtab_40cf[U]) >>13)];

  991. 				dest[1]=clip_table[((Y + yuvtab_1a1e[V] + yuvtab_0c92[U]) >>13)];

  992. 				dest[2]=clip_table[((Y + yuvtab_3343[V]) >>13)];

  993. 				dest+= 4;

  994. 			}

  995. 		}

  996. 		else if(dstFormat==IMGFMT_BGR24)

  997. 		{

  998. 			int i;

  999. 			for(i=0;i<dstW;i++){

  1000. 				// vertical linear interpolation && yuv2rgb in a single step:

  1001. 				int Y=yuvtab_2568[((buf0[i]*yalpha1+buf1[i]*yalpha)>>19)];

  1002. 				int U=((uvbuf0[i]*uvalpha1+uvbuf1[i]*uvalpha)>>19);

  1003. 				int V=((uvbuf0[i+2048]*uvalpha1+uvbuf1[i+2048]*uvalpha)>>19);

  1004. 				dest[0]=clip_table[((Y + yuvtab_40cf[U]) >>13)];

  1005. 				dest[1]=clip_table[((Y + yuvtab_1a1e[V] + yuvtab_0c92[U]) >>13)];

  1006. 				dest[2]=clip_table[((Y + yuvtab_3343[V]) >>13)];

  1007. 				dest+= 3;

  1008. 			}

  1009. 		}

  1010. 		else if(dstFormat==IMGFMT_BGR16)

  1011. 		{

  1012. 			int i;

  1013. 			for(i=0;i<dstW;i++){

  1014. 				// vertical linear interpolation && yuv2rgb in a single step:

  1015. 				int Y=yuvtab_2568[((buf0[i]*yalpha1+buf1[i]*yalpha)>>19)];

  1016. 				int U=((uvbuf0[i]*uvalpha1+uvbuf1[i]*uvalpha)>>19);

  1017. 				int V=((uvbuf0[i+2048]*uvalpha1+uvbuf1[i+2048]*uvalpha)>>19);

  1018. 

  1019. 				((uint16_t*)dest)[i] =

  1020. 					clip_table16b[(Y + yuvtab_40cf[U]) >>13] |

  1021. 					clip_table16g[(Y + yuvtab_1a1e[V] + yuvtab_0c92[U]) >>13] |

  1022. 					clip_table16r[(Y + yuvtab_3343[V]) >>13];

  1023. 			}

  1024. 		}

  1025. 		else if(dstFormat==IMGFMT_BGR15)

  1026. 		{

  1027. 			int i;

  1028. 			for(i=0;i<dstW;i++){

  1029. 				// vertical linear interpolation && yuv2rgb in a single step:

  1030. 				int Y=yuvtab_2568[((buf0[i]*yalpha1+buf1[i]*yalpha)>>19)];

  1031. 				int U=((uvbuf0[i]*uvalpha1+uvbuf1[i]*uvalpha)>>19);

  1032. 				int V=((uvbuf0[i+2048]*uvalpha1+uvbuf1[i+2048]*uvalpha)>>19);

  1033. 

  1034. 				((uint16_t*)dest)[i] =

  1035. 					clip_table15b[(Y + yuvtab_40cf[U]) >>13] |

  1036. 					clip_table15g[(Y + yuvtab_1a1e[V] + yuvtab_0c92[U]) >>13] |

  1037. 					clip_table15r[(Y + yuvtab_3343[V]) >>13];

  1038. 			}

  1039. 		}

  1040. #endif

  1041. 	}//FULL_UV_IPOL

  1042. 	else

  1043. 	{

  1044. #ifdef HAVE_MMX

  1045. 		if(dstFormat==IMGFMT_BGR32)

  1046. 		{

  1047. 			asm volatile(

  1048. 				YSCALEYUV2RGB

  1049. 				WRITEBGR32

  1050. 

  1051. 			:: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW),

  1052. 			"m" (yalpha1), "m" (uvalpha1)

  1053. 			: "%eax"

  1054. 			);

  1055. 		}

  1056. 		else if(dstFormat==IMGFMT_BGR24)

  1057. 		{

  1058. 			asm volatile(

  1059. 				"movl %4, %%ebx			\n\t"

  1060. 				YSCALEYUV2RGB

  1061. 				WRITEBGR24

  1062. 

  1063. 			:: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "m" (dest), "m" (dstW),

  1064. 			"m" (yalpha1), "m" (uvalpha1)

  1065. 			: "%eax", "%ebx"

  1066. 			);

  1067. 		}

  1068. 		else if(dstFormat==IMGFMT_BGR15)

  1069. 		{

  1070. 			asm volatile(

  1071. 				YSCALEYUV2RGB

  1072. 		/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */

  1073. #ifdef DITHER1XBPP

  1074. 				"paddusb "MANGLE(b5Dither)", %%mm2\n\t"

  1075. 				"paddusb "MANGLE(g5Dither)", %%mm4\n\t"

  1076. 				"paddusb "MANGLE(r5Dither)", %%mm5\n\t"

  1077. #endif

  1078. 

  1079. 				WRITEBGR15

  1080. 

  1081. 			:: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW),

  1082. 			"m" (yalpha1), "m" (uvalpha1)

  1083. 			: "%eax"

  1084. 			);

  1085. 		}

  1086. 		else if(dstFormat==IMGFMT_BGR16)

  1087. 		{

  1088. 			asm volatile(

  1089. 				YSCALEYUV2RGB

  1090. 		/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */

  1091. #ifdef DITHER1XBPP

  1092. 				"paddusb "MANGLE(b5Dither)", %%mm2\n\t"

  1093. 				"paddusb "MANGLE(g6Dither)", %%mm4\n\t"

  1094. 				"paddusb "MANGLE(r5Dither)", %%mm5\n\t"

  1095. #endif

  1096. 

  1097. 				WRITEBGR16

  1098. 

  1099. 			:: "r" (buf0), "r" (buf1), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW),

  1100. 			"m" (yalpha1), "m" (uvalpha1)

  1101. 			: "%eax"

  1102. 			);

  1103. 		}

  1104. #else

  1105. 		if(dstFormat==IMGFMT_BGR32)

  1106. 		{

  1107. 			int i;

  1108. 			for(i=0; i<dstW-1; i+=2){

  1109. 				// vertical linear interpolation && yuv2rgb in a single step:

  1110. 				int Y1=yuvtab_2568[((buf0[i]*yalpha1+buf1[i]*yalpha)>>19)];

  1111. 				int Y2=yuvtab_2568[((buf0[i+1]*yalpha1+buf1[i+1]*yalpha)>>19)];

  1112. 				int U=((uvbuf0[i>>1]*uvalpha1+uvbuf1[i>>1]*uvalpha)>>19);

  1113. 				int V=((uvbuf0[(i>>1)+2048]*uvalpha1+uvbuf1[(i>>1)+2048]*uvalpha)>>19);

  1114. 

  1115. 				int Cb= yuvtab_40cf[U];

  1116. 				int Cg= yuvtab_1a1e[V] + yuvtab_0c92[U];

  1117. 				int Cr= yuvtab_3343[V];

  1118. 

  1119. 				dest[4*i+0]=clip_table[((Y1 + Cb) >>13)];

  1120. 				dest[4*i+1]=clip_table[((Y1 + Cg) >>13)];

  1121. 				dest[4*i+2]=clip_table[((Y1 + Cr) >>13)];

  1122. 

  1123. 				dest[4*i+4]=clip_table[((Y2 + Cb) >>13)];

  1124. 				dest[4*i+5]=clip_table[((Y2 + Cg) >>13)];

  1125. 				dest[4*i+6]=clip_table[((Y2 + Cr) >>13)];

  1126. 			}

  1127. 		}

  1128. 		else if(dstFormat==IMGFMT_BGR24)

  1129. 		{

  1130. 			int i;

  1131. 			for(i=0; i<dstW-1; i+=2){

  1132. 				// vertical linear interpolation && yuv2rgb in a single step:

  1133. 				int Y1=yuvtab_2568[((buf0[i]*yalpha1+buf1[i]*yalpha)>>19)];

  1134. 				int Y2=yuvtab_2568[((buf0[i+1]*yalpha1+buf1[i+1]*yalpha)>>19)];

  1135. 				int U=((uvbuf0[i>>1]*uvalpha1+uvbuf1[i>>1]*uvalpha)>>19);

  1136. 				int V=((uvbuf0[(i>>1)+2048]*uvalpha1+uvbuf1[(i>>1)+2048]*uvalpha)>>19);

  1137. 

  1138. 				int Cb= yuvtab_40cf[U];

  1139. 				int Cg= yuvtab_1a1e[V] + yuvtab_0c92[U];

  1140. 				int Cr= yuvtab_3343[V];

  1141. 

  1142. 				dest[0]=clip_table[((Y1 + Cb) >>13)];

  1143. 				dest[1]=clip_table[((Y1 + Cg) >>13)];

  1144. 				dest[2]=clip_table[((Y1 + Cr) >>13)];

  1145. 

  1146. 				dest[3]=clip_table[((Y2 + Cb) >>13)];

  1147. 				dest[4]=clip_table[((Y2 + Cg) >>13)];

  1148. 				dest[5]=clip_table[((Y2 + Cr) >>13)];

  1149. 				dest+=6;

  1150. 			}

  1151. 		}

  1152. 		else if(dstFormat==IMGFMT_BGR16)

  1153. 		{

  1154. 			int i;

  1155. 			for(i=0; i<dstW-1; i+=2){

  1156. 				// vertical linear interpolation && yuv2rgb in a single step:

  1157. 				int Y1=yuvtab_2568[((buf0[i]*yalpha1+buf1[i]*yalpha)>>19)];

  1158. 				int Y2=yuvtab_2568[((buf0[i+1]*yalpha1+buf1[i+1]*yalpha)>>19)];

  1159. 				int U=((uvbuf0[i>>1]*uvalpha1+uvbuf1[i>>1]*uvalpha)>>19);

  1160. 				int V=((uvbuf0[(i>>1)+2048]*uvalpha1+uvbuf1[(i>>1)+2048]*uvalpha)>>19);

  1161. 

  1162. 				int Cb= yuvtab_40cf[U];

  1163. 				int Cg= yuvtab_1a1e[V] + yuvtab_0c92[U];

  1164. 				int Cr= yuvtab_3343[V];

  1165. 

  1166. 				((uint16_t*)dest)[i] =

  1167. 					clip_table16b[(Y1 + Cb) >>13] |

  1168. 					clip_table16g[(Y1 + Cg) >>13] |

  1169. 					clip_table16r[(Y1 + Cr) >>13];

  1170. 

  1171. 				((uint16_t*)dest)[i+1] =

  1172. 					clip_table16b[(Y2 + Cb) >>13] |

  1173. 					clip_table16g[(Y2 + Cg) >>13] |

  1174. 					clip_table16r[(Y2 + Cr) >>13];

  1175. 			}

  1176. 		}

  1177. 		else if(dstFormat==IMGFMT_BGR15)

  1178. 		{

  1179. 			int i;

  1180. 			for(i=0; i<dstW-1; i+=2){

  1181. 				// vertical linear interpolation && yuv2rgb in a single step:

  1182. 				int Y1=yuvtab_2568[((buf0[i]*yalpha1+buf1[i]*yalpha)>>19)];

  1183. 				int Y2=yuvtab_2568[((buf0[i+1]*yalpha1+buf1[i+1]*yalpha)>>19)];

  1184. 				int U=((uvbuf0[i>>1]*uvalpha1+uvbuf1[i>>1]*uvalpha)>>19);

  1185. 				int V=((uvbuf0[(i>>1)+2048]*uvalpha1+uvbuf1[(i>>1)+2048]*uvalpha)>>19);

  1186. 

  1187. 				int Cb= yuvtab_40cf[U];

  1188. 				int Cg= yuvtab_1a1e[V] + yuvtab_0c92[U];

  1189. 				int Cr= yuvtab_3343[V];

  1190. 

  1191. 				((uint16_t*)dest)[i] =

  1192. 					clip_table15b[(Y1 + Cb) >>13] |

  1193. 					clip_table15g[(Y1 + Cg) >>13] |

  1194. 					clip_table15r[(Y1 + Cr) >>13];

  1195. 

  1196. 				((uint16_t*)dest)[i+1] =

  1197. 					clip_table15b[(Y2 + Cb) >>13] |

  1198. 					clip_table15g[(Y2 + Cg) >>13] |

  1199. 					clip_table15r[(Y2 + Cr) >>13];

  1200. 			}

  1201. 		}

  1202. #endif

  1203. 	} //!FULL_UV_IPOL

  1204. }

  1205. 

  1206. /**

  1207.  * YV12 to RGB without scaling or interpolating

  1208.  */

  1209. static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *uvbuf1,

  1210. 			    uint8_t *dest, int dstW, int uvalpha, int dstFormat, int flags)

  1211. {

  1212. 	int uvalpha1=uvalpha^4095;

  1213. 	const int yalpha1=0;

  1214. 

  1215. 	if(flags&SWS_FULL_UV_IPOL)

  1216. 	{

  1217. 		RENAME(yuv2rgb2)(buf0, buf0, uvbuf0, uvbuf1, dest, dstW, 0, uvalpha, dstFormat, flags);

  1218. 		return;

  1219. 	}

  1220. 

  1221. #ifdef HAVE_MMX

  1222. 	if( uvalpha < 2048 ) // note this is not correct (shifts chrominance by 0.5 pixels) but its a bit faster

  1223. 	{

  1224. 		if(dstFormat==IMGFMT_BGR32)

  1225. 		{

  1226. 			asm volatile(

  1227. 				YSCALEYUV2RGB1

  1228. 				WRITEBGR32

  1229. 			:: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW),

  1230. 			"m" (yalpha1), "m" (uvalpha1)

  1231. 			: "%eax"

  1232. 			);

  1233. 		}

  1234. 		else if(dstFormat==IMGFMT_BGR24)

  1235. 		{

  1236. 			asm volatile(

  1237. 				"movl %4, %%ebx			\n\t"

  1238. 				YSCALEYUV2RGB1

  1239. 				WRITEBGR24

  1240. 			:: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "m" (dest), "m" (dstW),

  1241. 			"m" (yalpha1), "m" (uvalpha1)

  1242. 			: "%eax", "%ebx"

  1243. 			);

  1244. 		}

  1245. 		else if(dstFormat==IMGFMT_BGR15)

  1246. 		{

  1247. 			asm volatile(

  1248. 				YSCALEYUV2RGB1

  1249. 		/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */

  1250. #ifdef DITHER1XBPP

  1251. 				"paddusb "MANGLE(b5Dither)", %%mm2\n\t"

  1252. 				"paddusb "MANGLE(g5Dither)", %%mm4\n\t"

  1253. 				"paddusb "MANGLE(r5Dither)", %%mm5\n\t"

  1254. #endif

  1255. 				WRITEBGR15

  1256. 			:: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW),

  1257. 			"m" (yalpha1), "m" (uvalpha1)

  1258. 			: "%eax"

  1259. 			);

  1260. 		}

  1261. 		else if(dstFormat==IMGFMT_BGR16)

  1262. 		{

  1263. 			asm volatile(

  1264. 				YSCALEYUV2RGB1

  1265. 		/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */

  1266. #ifdef DITHER1XBPP

  1267. 				"paddusb "MANGLE(b5Dither)", %%mm2\n\t"

  1268. 				"paddusb "MANGLE(g6Dither)", %%mm4\n\t"

  1269. 				"paddusb "MANGLE(r5Dither)", %%mm5\n\t"

  1270. #endif

  1271. 

  1272. 				WRITEBGR16

  1273. 			:: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW),

  1274. 			"m" (yalpha1), "m" (uvalpha1)

  1275. 			: "%eax"

  1276. 			);

  1277. 		}

  1278. 	}

  1279. 	else

  1280. 	{

  1281. 		if(dstFormat==IMGFMT_BGR32)

  1282. 		{

  1283. 			asm volatile(

  1284. 				YSCALEYUV2RGB1b

  1285. 				WRITEBGR32

  1286. 			:: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW),

  1287. 			"m" (yalpha1), "m" (uvalpha1)

  1288. 			: "%eax"

  1289. 			);

  1290. 		}

  1291. 		else if(dstFormat==IMGFMT_BGR24)

  1292. 		{

  1293. 			asm volatile(

  1294. 				"movl %4, %%ebx			\n\t"

  1295. 				YSCALEYUV2RGB1b

  1296. 				WRITEBGR24

  1297. 			:: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "m" (dest), "m" (dstW),

  1298. 			"m" (yalpha1), "m" (uvalpha1)

  1299. 			: "%eax", "%ebx"

  1300. 			);

  1301. 		}

  1302. 		else if(dstFormat==IMGFMT_BGR15)

  1303. 		{

  1304. 			asm volatile(

  1305. 				YSCALEYUV2RGB1b

  1306. 		/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */

  1307. #ifdef DITHER1XBPP

  1308. 				"paddusb "MANGLE(b5Dither)", %%mm2\n\t"

  1309. 				"paddusb "MANGLE(g5Dither)", %%mm4\n\t"

  1310. 				"paddusb "MANGLE(r5Dither)", %%mm5\n\t"

  1311. #endif

  1312. 				WRITEBGR15

  1313. 			:: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW),

  1314. 			"m" (yalpha1), "m" (uvalpha1)

  1315. 			: "%eax"

  1316. 			);

  1317. 		}

  1318. 		else if(dstFormat==IMGFMT_BGR16)

  1319. 		{

  1320. 			asm volatile(

  1321. 				YSCALEYUV2RGB1b

  1322. 		/* mm2=B, %%mm4=G, %%mm5=R, %%mm7=0 */

  1323. #ifdef DITHER1XBPP

  1324. 				"paddusb "MANGLE(b5Dither)", %%mm2\n\t"

  1325. 				"paddusb "MANGLE(g6Dither)", %%mm4\n\t"

  1326. 				"paddusb "MANGLE(r5Dither)", %%mm5\n\t"

  1327. #endif

  1328. 

  1329. 				WRITEBGR16

  1330. 			:: "r" (buf0), "r" (buf0), "r" (uvbuf0), "r" (uvbuf1), "r" (dest), "m" (dstW),

  1331. 			"m" (yalpha1), "m" (uvalpha1)

  1332. 			: "%eax"

  1333. 			);

  1334. 		}

  1335. 	}

  1336. #else

  1337. //FIXME write 2 versions (for even & odd lines)

  1338. 

  1339. 	if(dstFormat==IMGFMT_BGR32)

  1340. 	{

  1341. 		int i;

  1342. 		for(i=0; i<dstW-1; i+=2){

  1343. 			// vertical linear interpolation && yuv2rgb in a single step:

  1344. 			int Y1=yuvtab_2568[buf0[i]>>7];

  1345. 			int Y2=yuvtab_2568[buf0[i+1]>>7];

  1346. 			int U=((uvbuf0[i>>1]*uvalpha1+uvbuf1[i>>1]*uvalpha)>>19);

  1347. 			int V=((uvbuf0[(i>>1)+2048]*uvalpha1+uvbuf1[(i>>1)+2048]*uvalpha)>>19);

  1348. 

  1349. 			int Cb= yuvtab_40cf[U];

  1350. 			int Cg= yuvtab_1a1e[V] + yuvtab_0c92[U];

  1351. 			int Cr= yuvtab_3343[V];

  1352. 

  1353. 			dest[4*i+0]=clip_table[((Y1 + Cb) >>13)];

  1354. 			dest[4*i+1]=clip_table[((Y1 + Cg) >>13)];

  1355. 			dest[4*i+2]=clip_table[((Y1 + Cr) >>13)];

  1356. 

  1357. 			dest[4*i+4]=clip_table[((Y2 + Cb) >>13)];

  1358. 			dest[4*i+5]=clip_table[((Y2 + Cg) >>13)];

  1359. 			dest[4*i+6]=clip_table[((Y2 + Cr) >>13)];

  1360. 		}

  1361. 	}

  1362. 	else if(dstFormat==IMGFMT_BGR24)

  1363. 	{

  1364. 		int i;

  1365. 		for(i=0; i<dstW-1; i+=2){

  1366. 			// vertical linear interpolation && yuv2rgb in a single step:

  1367. 			int Y1=yuvtab_2568[buf0[i]>>7];

  1368. 			int Y2=yuvtab_2568[buf0[i+1]>>7];

  1369. 			int U=((uvbuf0[i>>1]*uvalpha1+uvbuf1[i>>1]*uvalpha)>>19);

  1370. 			int V=((uvbuf0[(i>>1)+2048]*uvalpha1+uvbuf1[(i>>1)+2048]*uvalpha)>>19);

  1371. 

  1372. 			int Cb= yuvtab_40cf[U];

  1373. 			int Cg= yuvtab_1a1e[V] + yuvtab_0c92[U];

  1374. 			int Cr= yuvtab_3343[V];

  1375. 

  1376. 			dest[0]=clip_table[((Y1 + Cb) >>13)];

  1377. 			dest[1]=clip_table[((Y1 + Cg) >>13)];

  1378. 			dest[2]=clip_table[((Y1 + Cr) >>13)];

  1379. 

  1380. 			dest[3]=clip_table[((Y2 + Cb) >>13)];

  1381. 			dest[4]=clip_table[((Y2 + Cg) >>13)];

  1382. 			dest[5]=clip_table[((Y2 + Cr) >>13)];

  1383. 			dest+=6;

  1384. 		}

  1385. 	}

  1386. 	else if(dstFormat==IMGFMT_BGR16)

  1387. 	{

  1388. 		int i;

  1389. 		for(i=0; i<dstW-1; i+=2){

  1390. 			// vertical linear interpolation && yuv2rgb in a single step:

  1391. 			int Y1=yuvtab_2568[buf0[i]>>7];

  1392. 			int Y2=yuvtab_2568[buf0[i+1]>>7];

  1393. 			int U=((uvbuf0[i>>1]*uvalpha1+uvbuf1[i>>1]*uvalpha)>>19);

  1394. 			int V=((uvbuf0[(i>>1)+2048]*uvalpha1+uvbuf1[(i>>1)+2048]*uvalpha)>>19);

  1395. 

  1396. 			int Cb= yuvtab_40cf[U];

  1397. 			int Cg= yuvtab_1a1e[V] + yuvtab_0c92[U];

  1398. 			int Cr= yuvtab_3343[V];

  1399. 

  1400. 			((uint16_t*)dest)[i] =

  1401. 				clip_table16b[(Y1 + Cb) >>13] |

  1402. 				clip_table16g[(Y1 + Cg) >>13] |

  1403. 				clip_table16r[(Y1 + Cr) >>13];

  1404. 

  1405. 			((uint16_t*)dest)[i+1] =

  1406. 				clip_table16b[(Y2 + Cb) >>13] |

  1407. 				clip_table16g[(Y2 + Cg) >>13] |

  1408. 				clip_table16r[(Y2 + Cr) >>13];

  1409. 		}

  1410. 	}

  1411. 	else if(dstFormat==IMGFMT_BGR15)

  1412. 	{

  1413. 		int i;

  1414. 		for(i=0; i<dstW-1; i+=2){

  1415. 			// vertical linear interpolation && yuv2rgb in a single step:

  1416. 			int Y1=yuvtab_2568[buf0[i]>>7];

  1417. 			int Y2=yuvtab_2568[buf0[i+1]>>7];

  1418. 			int U=((uvbuf0[i>>1]*uvalpha1+uvbuf1[i>>1]*uvalpha)>>19);

  1419. 			int V=((uvbuf0[(i>>1)+2048]*uvalpha1+uvbuf1[(i>>1)+2048]*uvalpha)>>19);

  1420. 

  1421. 			int Cb= yuvtab_40cf[U];

  1422. 			int Cg= yuvtab_1a1e[V] + yuvtab_0c92[U];

  1423. 			int Cr= yuvtab_3343[V];

  1424. 

  1425. 			((uint16_t*)dest)[i] =

  1426. 				clip_table15b[(Y1 + Cb) >>13] |

  1427. 				clip_table15g[(Y1 + Cg) >>13] |

  1428. 				clip_table15r[(Y1 + Cr) >>13];

  1429. 

  1430. 			((uint16_t*)dest)[i+1] =

  1431. 				clip_table15b[(Y2 + Cb) >>13] |

  1432. 				clip_table15g[(Y2 + Cg) >>13] |

  1433. 				clip_table15r[(Y2 + Cr) >>13];

  1434. 		}

  1435. 	}

  1436. #endif

  1437. }

  1438. 

  1439. // Bilinear / Bicubic scaling

  1440. static inline void RENAME(hScale)(int16_t *dst, int dstW, uint8_t *src, int srcW, int xInc,

  1441. 				  int16_t *filter, int16_t *filterPos, int filterSize)

  1442. {

  1443. #ifdef HAVE_MMX

  1444. 	if(filterSize==4) // allways true for upscaling, sometimes for down too

  1445. 	{

  1446. 		int counter= -2*dstW;

  1447. 		filter-= counter*2;

  1448. 		filterPos-= counter/2;

  1449. 		dst-= counter/2;

  1450. 		asm volatile(

  1451. 			"pxor %%mm7, %%mm7		\n\t"

  1452. 			"movq "MANGLE(w02)", %%mm6	\n\t"

  1453. 			"pushl %%ebp			\n\t" // we use 7 regs here ...

  1454. 			"movl %%eax, %%ebp		\n\t"

  1455. 			".balign 16			\n\t"

  1456. 			"1:				\n\t"

  1457. 			"movzwl (%2, %%ebp), %%eax	\n\t"

  1458. 			"movzwl 2(%2, %%ebp), %%ebx	\n\t"

  1459. 			"movq (%1, %%ebp, 4), %%mm1	\n\t"

  1460. 			"movq 8(%1, %%ebp, 4), %%mm3	\n\t"

  1461. 			"movd (%3, %%eax), %%mm0	\n\t"

  1462. 			"movd (%3, %%ebx), %%mm2	\n\t"

  1463. 			"punpcklbw %%mm7, %%mm0		\n\t"

  1464. 			"punpcklbw %%mm7, %%mm2		\n\t"

  1465. 			"pmaddwd %%mm1, %%mm0		\n\t"

  1466. 			"pmaddwd %%mm2, %%mm3		\n\t"

  1467. 			"psrad $8, %%mm0		\n\t"

  1468. 			"psrad $8, %%mm3		\n\t"

  1469. 			"packssdw %%mm3, %%mm0		\n\t"

  1470. 			"pmaddwd %%mm6, %%mm0		\n\t"

  1471. 			"packssdw %%mm0, %%mm0		\n\t"

  1472. 			"movd %%mm0, (%4, %%ebp)	\n\t"

  1473. 			"addl $4, %%ebp			\n\t"

  1474. 			" jnc 1b			\n\t"

  1475. 

  1476. 			"popl %%ebp			\n\t"

  1477. 			: "+a" (counter)

  1478. 			: "c" (filter), "d" (filterPos), "S" (src), "D" (dst)

  1479. 			: "%ebx"

  1480. 		);

  1481. 	}

  1482. 	else if(filterSize==8)

  1483. 	{

  1484. 		int counter= -2*dstW;

  1485. 		filter-= counter*4;

  1486. 		filterPos-= counter/2;

  1487. 		dst-= counter/2;

  1488. 		asm volatile(

  1489. 			"pxor %%mm7, %%mm7		\n\t"

  1490. 			"movq "MANGLE(w02)", %%mm6	\n\t"

  1491. 			"pushl %%ebp			\n\t" // we use 7 regs here ...

  1492. 			"movl %%eax, %%ebp		\n\t"

  1493. 			".balign 16			\n\t"

  1494. 			"1:				\n\t"

  1495. 			"movzwl (%2, %%ebp), %%eax	\n\t"

  1496. 			"movzwl 2(%2, %%ebp), %%ebx	\n\t"

  1497. 			"movq (%1, %%ebp, 8), %%mm1	\n\t"

  1498. 			"movq 16(%1, %%ebp, 8), %%mm3	\n\t"

  1499. 			"movd (%3, %%eax), %%mm0	\n\t"

  1500. 			"movd (%3, %%ebx), %%mm2	\n\t"

  1501. 			"punpcklbw %%mm7, %%mm0		\n\t"

  1502. 			"punpcklbw %%mm7, %%mm2		\n\t"

  1503. 			"pmaddwd %%mm1, %%mm0		\n\t"

  1504. 			"pmaddwd %%mm2, %%mm3		\n\t"

  1505. 

  1506. 			"movq 8(%1, %%ebp, 8), %%mm1	\n\t"

  1507. 			"movq 24(%1, %%ebp, 8), %%mm5	\n\t"

  1508. 			"movd 4(%3, %%eax), %%mm4	\n\t"

  1509. 			"movd 4(%3, %%ebx), %%mm2	\n\t"

  1510. 			"punpcklbw %%mm7, %%mm4		\n\t"

  1511. 			"punpcklbw %%mm7, %%mm2		\n\t"

  1512. 			"pmaddwd %%mm1, %%mm4		\n\t"

  1513. 			"pmaddwd %%mm2, %%mm5		\n\t"

  1514. 			"paddd %%mm4, %%mm0		\n\t"

  1515. 			"paddd %%mm5, %%mm3		\n\t"

  1516. 						

  1517. 			"psrad $8, %%mm0		\n\t"

  1518. 			"psrad $8, %%mm3		\n\t"

  1519. 			"packssdw %%mm3, %%mm0		\n\t"

  1520. 			"pmaddwd %%mm6, %%mm0		\n\t"

  1521. 			"packssdw %%mm0, %%mm0		\n\t"

  1522. 			"movd %%mm0, (%4, %%ebp)	\n\t"

  1523. 			"addl $4, %%ebp			\n\t"

  1524. 			" jnc 1b			\n\t"

  1525. 

  1526. 			"popl %%ebp			\n\t"

  1527. 			: "+a" (counter)

  1528. 			: "c" (filter), "d" (filterPos), "S" (src), "D" (dst)

  1529. 			: "%ebx"

  1530. 		);

  1531. 	}

  1532. 	else

  1533. 	{

  1534. 		int counter= -2*dstW;

  1535. //		filter-= counter*filterSize/2;

  1536. 		filterPos-= counter/2;

  1537. 		dst-= counter/2;

  1538. 		asm volatile(

  1539. 			"pxor %%mm7, %%mm7		\n\t"

  1540. 			"movq "MANGLE(w02)", %%mm6	\n\t"

  1541. 			".balign 16			\n\t"

  1542. 			"1:				\n\t"

  1543. 			"movl %2, %%ecx			\n\t"

  1544. 			"movzwl (%%ecx, %0), %%eax	\n\t"

  1545. 			"movzwl 2(%%ecx, %0), %%ebx	\n\t"

  1546. 			"movl %5, %%ecx			\n\t"

  1547. 			"pxor %%mm4, %%mm4		\n\t"

  1548. 			"pxor %%mm5, %%mm5		\n\t"

  1549. 			"2:				\n\t"

  1550. 			"movq (%1), %%mm1		\n\t"

  1551. 			"movq (%1, %6), %%mm3		\n\t"

  1552. 			"movd (%%ecx, %%eax), %%mm0	\n\t"

  1553. 			"movd (%%ecx, %%ebx), %%mm2	\n\t"

  1554. 			"punpcklbw %%mm7, %%mm0		\n\t"

  1555. 			"punpcklbw %%mm7, %%mm2		\n\t"

  1556. 			"pmaddwd %%mm1, %%mm0		\n\t"

  1557. 			"pmaddwd %%mm2, %%mm3		\n\t"

  1558. 			"paddd %%mm3, %%mm5		\n\t"

  1559. 			"paddd %%mm0, %%mm4		\n\t"

  1560. 			"addl $8, %1			\n\t"

  1561. 			"addl $4, %%ecx			\n\t"

  1562. 			"cmpl %4, %%ecx			\n\t"

  1563. 			" jb 2b				\n\t"

  1564. 			"addl %6, %1			\n\t"

  1565. 			"psrad $8, %%mm4		\n\t"

  1566. 			"psrad $8, %%mm5		\n\t"

  1567. 			"packssdw %%mm5, %%mm4		\n\t"

  1568. 			"pmaddwd %%mm6, %%mm4		\n\t"

  1569. 			"packssdw %%mm4, %%mm4		\n\t"

  1570. 			"movl %3, %%eax			\n\t"

  1571. 			"movd %%mm4, (%%eax, %0)	\n\t"

  1572. 			"addl $4, %0			\n\t"

  1573. 			" jnc 1b			\n\t"

  1574. 

  1575. 			: "+r" (counter), "+r" (filter)

  1576. 			: "m" (filterPos), "m" (dst), "m"(src+filterSize),

  1577. 			  "m" (src), "r" (filterSize*2)

  1578. 			: "%ebx", "%eax", "%ecx"

  1579. 		);

  1580. 	}

  1581. #else

  1582. 	int i;

  1583. 	for(i=0; i<dstW; i++)

  1584. 	{

  1585. 		int j;

  1586. 		int srcPos= filterPos[i];

  1587. 		int val=0;

  1588. //		printf("filterPos: %d\n", filterPos[i]);

  1589. 		for(j=0; j<filterSize; j++)

  1590. 		{

  1591. //			printf("filter: %d, src: %d\n", filter[i], src[srcPos + j]);

  1592. 			val += ((int)src[srcPos + j])*filter[filterSize*i + j];

  1593. 		}

  1594. //		filter += hFilterSize;

  1595. 		dst[i] = MIN(MAX(0, val>>7), (1<<15)-1); // the cubic equation does overflow ...

  1596. //		dst[i] = val>>7;

  1597. 	}

  1598. #endif

  1599. }

  1600.       // *** horizontal scale Y line to temp buffer

  1601. static inline void RENAME(hyscale)(uint16_t *dst, int dstWidth, uint8_t *src, int srcW, int xInc,

  1602. 				   int flags, int canMMX2BeUsed, int16_t *hLumFilter,

  1603. 				   int16_t *hLumFilterPos, int hLumFilterSize, void *funnyYCode)

  1604. {

  1605. #ifdef HAVE_MMX

  1606. 	// use the new MMX scaler if th mmx2 cant be used (its faster than the x86asm one)

  1607.     if(!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))

  1608. #else

  1609.     if(!(flags&SWS_FAST_BILINEAR))

  1610. #endif

  1611.     {

  1612.     	RENAME(hScale)(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);

  1613.     }

  1614.     else // Fast Bilinear upscale / crap downscale

  1615.     {

  1616. #ifdef ARCH_X86

  1617. #ifdef HAVE_MMX2

  1618. 	int i;

  1619. 	if(canMMX2BeUsed)

  1620. 	{

  1621. 		asm volatile(

  1622. 			"pxor %%mm7, %%mm7		\n\t"

  1623. 			"pxor %%mm2, %%mm2		\n\t" // 2*xalpha

  1624. 			"movd %5, %%mm6			\n\t" // xInc&0xFFFF

  1625. 			"punpcklwd %%mm6, %%mm6		\n\t"

  1626. 			"punpcklwd %%mm6, %%mm6		\n\t"

  1627. 			"movq %%mm6, %%mm2		\n\t"

  1628. 			"psllq $16, %%mm2		\n\t"

  1629. 			"paddw %%mm6, %%mm2		\n\t"

  1630. 			"psllq $16, %%mm2		\n\t"

  1631. 			"paddw %%mm6, %%mm2		\n\t"

  1632. 			"psllq $16, %%mm2		\n\t" //0,t,2t,3t		t=xInc&0xFF

  1633. 			"movq %%mm2, %%mm4		\n\t"

  1634. 			"movd %4, %%mm6			\n\t" //(xInc*4)&0xFFFF

  1635. 			"punpcklwd %%mm6, %%mm6		\n\t"

  1636. 			"punpcklwd %%mm6, %%mm6		\n\t"

  1637. 			"xorl %%eax, %%eax		\n\t" // i

  1638. 			"movl %0, %%esi			\n\t" // src

  1639. 			"movl %1, %%edi			\n\t" // buf1

  1640. 			"movl %3, %%edx			\n\t" // (xInc*4)>>16

  1641. 			"xorl %%ecx, %%ecx		\n\t"

  1642. 			"xorl %%ebx, %%ebx		\n\t"

  1643. 			"movw %4, %%bx			\n\t" // (xInc*4)&0xFFFF

  1644. 

  1645. #define FUNNY_Y_CODE \

  1646. 			PREFETCH" 1024(%%esi)		\n\t"\

  1647. 			PREFETCH" 1056(%%esi)		\n\t"\

  1648. 			PREFETCH" 1088(%%esi)		\n\t"\

  1649. 			"call *%6			\n\t"\

  1650. 			"movq %%mm4, %%mm2		\n\t"\

  1651. 			"xorl %%ecx, %%ecx		\n\t"

  1652. 

  1653. FUNNY_Y_CODE

  1654. FUNNY_Y_CODE

  1655. FUNNY_Y_CODE

  1656. FUNNY_Y_CODE

  1657. FUNNY_Y_CODE

  1658. FUNNY_Y_CODE

  1659. FUNNY_Y_CODE

  1660. FUNNY_Y_CODE

  1661. 

  1662. 			:: "m" (src), "m" (dst), "m" (dstWidth), "m" ((xInc*4)>>16),

  1663. 			"m" ((xInc*4)&0xFFFF), "m" (xInc&0xFFFF), "m" (funnyYCode)

  1664. 			: "%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi"

  1665. 		);

  1666. 		for(i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--) dst[i] = src[srcW-1]*128;

  1667. 	}

  1668. 	else

  1669. 	{

  1670. #endif

  1671. 	//NO MMX just normal asm ...

  1672. 	asm volatile(

  1673. 		"xorl %%eax, %%eax		\n\t" // i

  1674. 		"xorl %%ebx, %%ebx		\n\t" // xx

  1675. 		"xorl %%ecx, %%ecx		\n\t" // 2*xalpha

  1676. 		".balign 16			\n\t"

  1677. 		"1:				\n\t"

  1678. 		"movzbl  (%0, %%ebx), %%edi	\n\t" //src[xx]

  1679. 		"movzbl 1(%0, %%ebx), %%esi	\n\t" //src[xx+1]

  1680. 		"subl %%edi, %%esi		\n\t" //src[xx+1] - src[xx]

  1681. 		"imull %%ecx, %%esi		\n\t" //(src[xx+1] - src[xx])*2*xalpha

  1682. 		"shll $16, %%edi		\n\t"

  1683. 		"addl %%edi, %%esi		\n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)

  1684. 		"movl %1, %%edi			\n\t"

  1685. 		"shrl $9, %%esi			\n\t"

  1686. 		"movw %%si, (%%edi, %%eax, 2)	\n\t"

  1687. 		"addw %4, %%cx			\n\t" //2*xalpha += xInc&0xFF

  1688. 		"adcl %3, %%ebx			\n\t" //xx+= xInc>>8 + carry

  1689. 

  1690. 		"movzbl (%0, %%ebx), %%edi	\n\t" //src[xx]

  1691. 		"movzbl 1(%0, %%ebx), %%esi	\n\t" //src[xx+1]

  1692. 		"subl %%edi, %%esi		\n\t" //src[xx+1] - src[xx]

  1693. 		"imull %%ecx, %%esi		\n\t" //(src[xx+1] - src[xx])*2*xalpha

  1694. 		"shll $16, %%edi		\n\t"

  1695. 		"addl %%edi, %%esi		\n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)

  1696. 		"movl %1, %%edi			\n\t"

  1697. 		"shrl $9, %%esi			\n\t"

  1698. 		"movw %%si, 2(%%edi, %%eax, 2)	\n\t"

  1699. 		"addw %4, %%cx			\n\t" //2*xalpha += xInc&0xFF

  1700. 		"adcl %3, %%ebx			\n\t" //xx+= xInc>>8 + carry

  1701. 

  1702. 

  1703. 		"addl $2, %%eax			\n\t"

  1704. 		"cmpl %2, %%eax			\n\t"

  1705. 		" jb 1b				\n\t"

  1706. 

  1707. 

  1708. 		:: "r" (src), "m" (dst), "m" (dstWidth), "m" (xInc>>16), "m" (xInc&0xFFFF)

  1709. 		: "%eax", "%ebx", "%ecx", "%edi", "%esi"

  1710. 		);

  1711. #ifdef HAVE_MMX2

  1712. 	} //if MMX2 cant be used

  1713. #endif

  1714. #else

  1715. 	int i;

  1716. 	unsigned int xpos=0;

  1717. 	for(i=0;i<dstWidth;i++)

  1718. 	{

  1719. 		register unsigned int xx=xpos>>16;

  1720. 		register unsigned int xalpha=(xpos&0xFFFF)>>9;

  1721. 		dst[i]= (src[xx]<<7) + (src[xx+1] - src[xx])*xalpha;

  1722. 		xpos+=xInc;

  1723. 	}

  1724. #endif

  1725.     }

  1726. }

  1727. 

  1728. inline static void RENAME(hcscale)(uint16_t *dst, int dstWidth, uint8_t *src1, uint8_t *src2,

  1729. 				   int srcW, int xInc, int flags, int canMMX2BeUsed, int16_t *hChrFilter,

  1730. 				   int16_t *hChrFilterPos, int hChrFilterSize, void *funnyUVCode)

  1731. {

  1732. #ifdef HAVE_MMX

  1733. 	// use the new MMX scaler if th mmx2 cant be used (its faster than the x86asm one)

  1734.     if(!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))

  1735. #else

  1736.     if(!(flags&SWS_FAST_BILINEAR))

  1737. #endif

  1738.     {

  1739.     	RENAME(hScale)(dst     , dstWidth, src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);

  1740.     	RENAME(hScale)(dst+2048, dstWidth, src2, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);

  1741.     }

  1742.     else // Fast Bilinear upscale / crap downscale

  1743.     {

  1744. #ifdef ARCH_X86

  1745. #ifdef HAVE_MMX2

  1746. 	int i;

  1747. 	if(canMMX2BeUsed)

  1748. 	{

  1749. 		asm volatile(

  1750. 		"pxor %%mm7, %%mm7		\n\t"

  1751. 		"pxor %%mm2, %%mm2		\n\t" // 2*xalpha

  1752. 		"movd %5, %%mm6			\n\t" // xInc&0xFFFF

  1753. 		"punpcklwd %%mm6, %%mm6		\n\t"

  1754. 		"punpcklwd %%mm6, %%mm6		\n\t"

  1755. 		"movq %%mm6, %%mm2		\n\t"

  1756. 		"psllq $16, %%mm2		\n\t"

  1757. 		"paddw %%mm6, %%mm2		\n\t"

  1758. 		"psllq $16, %%mm2		\n\t"

  1759. 		"paddw %%mm6, %%mm2		\n\t"

  1760. 		"psllq $16, %%mm2		\n\t" //0,t,2t,3t		t=xInc&0xFFFF

  1761. 		"movq %%mm2, %%mm4		\n\t"

  1762. 		"movd %4, %%mm6			\n\t" //(xInc*4)&0xFFFF

  1763. 		"punpcklwd %%mm6, %%mm6		\n\t"

  1764. 		"punpcklwd %%mm6, %%mm6		\n\t"

  1765. 		"xorl %%eax, %%eax		\n\t" // i

  1766. 		"movl %0, %%esi			\n\t" // src

  1767. 		"movl %1, %%edi			\n\t" // buf1

  1768. 		"movl %3, %%edx			\n\t" // (xInc*4)>>16

  1769. 		"xorl %%ecx, %%ecx		\n\t"

  1770. 		"xorl %%ebx, %%ebx		\n\t"

  1771. 		"movw %4, %%bx			\n\t" // (xInc*4)&0xFFFF

  1772. 

  1773. #define FUNNYUVCODE \

  1774. 			PREFETCH" 1024(%%esi)		\n\t"\

  1775. 			PREFETCH" 1056(%%esi)		\n\t"\

  1776. 			PREFETCH" 1088(%%esi)		\n\t"\

  1777. 			"call *%7			\n\t"\

  1778. 			"movq %%mm4, %%mm2	\n\t"\

  1779. 			"xorl %%ecx, %%ecx		\n\t"

  1780. 

  1781. FUNNYUVCODE

  1782. FUNNYUVCODE

  1783. FUNNYUVCODE

  1784. FUNNYUVCODE

  1785. 

  1786. FUNNYUVCODE

  1787. FUNNYUVCODE

  1788. FUNNYUVCODE

  1789. FUNNYUVCODE

  1790. 		"xorl %%eax, %%eax		\n\t" // i

  1791. 		"movl %6, %%esi			\n\t" // src

  1792. 		"movl %1, %%edi			\n\t" // buf1

  1793. 		"addl $4096, %%edi		\n\t"

  1794. 

  1795. FUNNYUVCODE

  1796. FUNNYUVCODE

  1797. FUNNYUVCODE

  1798. FUNNYUVCODE

  1799. 

  1800. FUNNYUVCODE

  1801. FUNNYUVCODE

  1802. FUNNYUVCODE

  1803. FUNNYUVCODE

  1804. 

  1805. 		:: "m" (src1), "m" (dst), "m" (dstWidth), "m" ((xInc*4)>>16),

  1806. 		  "m" ((xInc*4)&0xFFFF), "m" (xInc&0xFFFF), "m" (src2), "m" (funnyUVCode)

  1807. 		: "%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi"

  1808. 	);

  1809. 		for(i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--)

  1810. 		{

  1811. //			printf("%d %d %d\n", dstWidth, i, srcW);

  1812. 			dst[i] = src1[srcW-1]*128;

  1813. 			dst[i+2048] = src2[srcW-1]*128;

  1814. 		}

  1815. 	}

  1816. 	else

  1817. 	{

  1818. #endif

  1819. 	asm volatile(

  1820. 		"xorl %%eax, %%eax		\n\t" // i

  1821. 		"xorl %%ebx, %%ebx		\n\t" // xx

  1822. 		"xorl %%ecx, %%ecx		\n\t" // 2*xalpha

  1823. 		".balign 16			\n\t"

  1824. 		"1:				\n\t"

  1825. 		"movl %0, %%esi			\n\t"

  1826. 		"movzbl  (%%esi, %%ebx), %%edi	\n\t" //src[xx]

  1827. 		"movzbl 1(%%esi, %%ebx), %%esi	\n\t" //src[xx+1]

  1828. 		"subl %%edi, %%esi		\n\t" //src[xx+1] - src[xx]

  1829. 		"imull %%ecx, %%esi		\n\t" //(src[xx+1] - src[xx])*2*xalpha

  1830. 		"shll $16, %%edi		\n\t"

  1831. 		"addl %%edi, %%esi		\n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)

  1832. 		"movl %1, %%edi			\n\t"

  1833. 		"shrl $9, %%esi			\n\t"

  1834. 		"movw %%si, (%%edi, %%eax, 2)	\n\t"

  1835. 

  1836. 		"movzbl  (%5, %%ebx), %%edi	\n\t" //src[xx]

  1837. 		"movzbl 1(%5, %%ebx), %%esi	\n\t" //src[xx+1]

  1838. 		"subl %%edi, %%esi		\n\t" //src[xx+1] - src[xx]

  1839. 		"imull %%ecx, %%esi		\n\t" //(src[xx+1] - src[xx])*2*xalpha

  1840. 		"shll $16, %%edi		\n\t"

  1841. 		"addl %%edi, %%esi		\n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)

  1842. 		"movl %1, %%edi			\n\t"

  1843. 		"shrl $9, %%esi			\n\t"

  1844. 		"movw %%si, 4096(%%edi, %%eax, 2)\n\t"

  1845. 

  1846. 		"addw %4, %%cx			\n\t" //2*xalpha += xInc&0xFF

  1847. 		"adcl %3, %%ebx			\n\t" //xx+= xInc>>8 + carry

  1848. 		"addl $1, %%eax			\n\t"

  1849. 		"cmpl %2, %%eax			\n\t"

  1850. 		" jb 1b				\n\t"

  1851. 

  1852. 		:: "m" (src1), "m" (dst), "m" (dstWidth), "m" (xInc>>16), "m" (xInc&0xFFFF),

  1853. 		"r" (src2)

  1854. 		: "%eax", "%ebx", "%ecx", "%edi", "%esi"

  1855. 		);

  1856. #ifdef HAVE_MMX2

  1857. 	} //if MMX2 cant be used

  1858. #endif

  1859. #else

  1860. 	int i;

  1861. 	unsigned int xpos=0;

  1862. 	for(i=0;i<dstWidth;i++)

  1863. 	{

  1864. 		register unsigned int xx=xpos>>16;

  1865. 		register unsigned int xalpha=(xpos&0xFFFF)>>9;

  1866. 		dst[i]=(src1[xx]*(xalpha^127)+src1[xx+1]*xalpha);

  1867. 		dst[i+2048]=(src2[xx]*(xalpha^127)+src2[xx+1]*xalpha);

  1868. /* slower

  1869. 	  dst[i]= (src1[xx]<<7) + (src1[xx+1] - src1[xx])*xalpha;

  1870. 	  dst[i+2048]=(src2[xx]<<7) + (src2[xx+1] - src2[xx])*xalpha;

  1871. */

  1872. 		xpos+=xInc;

  1873. 	}

  1874. #endif

  1875.    }

  1876. }

  1877. 

  1878. static void RENAME(swScale)(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,

  1879.              int srcSliceH, uint8_t* dst[], int dstStride[]){

  1880. 

  1881. 	/* load a few things into local vars to make the code more readable? and faster */

  1882. 	const int srcW= c->srcW;

  1883. 	const int dstW= c->dstW;

  1884. 	const int dstH= c->dstH;

  1885. 	const int chrDstW= c->chrDstW;

  1886. 	const int lumXInc= c->lumXInc;

  1887. 	const int chrXInc= c->chrXInc;

  1888. 	const int dstFormat= c->dstFormat; //FIXME serach for dstbpp;

  1889. 	const int flags= c->flags;

  1890. 	const int canMMX2BeUsed= c->canMMX2BeUsed;

  1891. 	int16_t *vLumFilterPos= c->vLumFilterPos;

  1892. 	int16_t *vChrFilterPos= c->vChrFilterPos;

  1893. 	int16_t *hLumFilterPos= c->hLumFilterPos;

  1894. 	int16_t *hChrFilterPos= c->hChrFilterPos;

  1895. 	int16_t *vLumFilter= c->vLumFilter;

  1896. 	int16_t *vChrFilter= c->vChrFilter;

  1897. 	int16_t *hLumFilter= c->hLumFilter;

  1898. 	int16_t *hChrFilter= c->hChrFilter;

  1899. 	int16_t *lumMmxFilter= c->lumMmxFilter;

  1900. 	int16_t *chrMmxFilter= c->chrMmxFilter;

  1901. 	const int vLumFilterSize= c->vLumFilterSize;

  1902. 	const int vChrFilterSize= c->vChrFilterSize;

  1903. 	const int hLumFilterSize= c->hLumFilterSize;

  1904. 	const int hChrFilterSize= c->hChrFilterSize;

  1905. 	int16_t **lumPixBuf= c->lumPixBuf;

  1906. 	int16_t **chrPixBuf= c->chrPixBuf;

  1907. 	const int vLumBufSize= c->vLumBufSize;

  1908. 	const int vChrBufSize= c->vChrBufSize;

  1909. 	uint8_t *funnyYCode= c->funnyYCode;

  1910. 	uint8_t *funnyUVCode= c->funnyUVCode;

  1911. 

  1912. 	/* vars whch will change and which we need to storw back in the context */

  1913. 	int dstY= c->dstY;

  1914. 	int lumBufIndex= c->lumBufIndex;

  1915. 	int chrBufIndex= c->chrBufIndex;

  1916. 	int lastInLumBuf= c->lastInLumBuf;

  1917. 	int lastInChrBuf= c->lastInChrBuf;

  1918. 

  1919. 	if(srcSliceY ==0){

  1920. 		lumBufIndex=0;

  1921. 		chrBufIndex=0;

  1922. 		dstY=0;

  1923. 		lastInLumBuf= -1;

  1924. 		lastInChrBuf= -1;

  1925. 	}

  1926. 

  1927. 	for(;dstY < dstH; dstY++){

  1928. 		unsigned char *dest =dst[0]+dstStride[0]*dstY;

  1929. 		unsigned char *uDest=dst[1]+dstStride[1]*(dstY>>1);

  1930. 		unsigned char *vDest=dst[2]+dstStride[2]*(dstY>>1);

  1931. 		const int chrDstY= dstFormat==IMGFMT_YV12 ? (dstY>>1) : dstY;

  1932. 

  1933. 		const int firstLumSrcY= vLumFilterPos[dstY]; //First line needed as input

  1934. 		const int firstChrSrcY= vChrFilterPos[chrDstY]; //First line needed as input

  1935. 		const int lastLumSrcY= firstLumSrcY + vLumFilterSize -1; // Last line needed as input

  1936. 		const int lastChrSrcY= firstChrSrcY + vChrFilterSize -1; // Last line needed as input

  1937. 

  1938. 		if(flags&SWS_FAST_BILINEAR)

  1939. 		{

  1940. 			//handle holes

  1941. 			if(firstLumSrcY > lastInLumBuf) lastInLumBuf= firstLumSrcY-1;

  1942. 			if(firstChrSrcY > lastInChrBuf) lastInChrBuf= firstChrSrcY-1;

  1943. 		}

  1944. 

  1945. 		ASSERT(firstLumSrcY >= lastInLumBuf - vLumBufSize + 1)

  1946. 		ASSERT(firstChrSrcY >= lastInChrBuf - vChrBufSize + 1)

  1947. 

  1948. 		// Do we have enough lines in this slice to output the dstY line

  1949. 		if(lastLumSrcY < srcSliceY + srcSliceH && lastChrSrcY < ((srcSliceY + srcSliceH)>>1))

  1950. 		{

  1951. 			//Do horizontal scaling

  1952. 			while(lastInLumBuf < lastLumSrcY)

  1953. 			{

  1954. 				uint8_t *s= src[0]+(lastInLumBuf + 1 - srcSliceY)*srcStride[0];

  1955. 				lumBufIndex++;

  1956. 				ASSERT(lumBufIndex < 2*vLumBufSize)

  1957. 				ASSERT(lastInLumBuf + 1 - srcSliceY < srcSliceH)

  1958. 				ASSERT(lastInLumBuf + 1 - srcSliceY >= 0)

  1959. //				printf("%d %d\n", lumBufIndex, vLumBufSize);

  1960. 				RENAME(hyscale)(lumPixBuf[ lumBufIndex ], dstW, s, srcW, lumXInc,

  1961. 						flags, canMMX2BeUsed, hLumFilter, hLumFilterPos, hLumFilterSize,

  1962. 						funnyYCode);

  1963. 				lastInLumBuf++;

  1964. 			}

  1965. 			while(lastInChrBuf < lastChrSrcY)

  1966. 			{

  1967. 				uint8_t *src1= src[1]+(lastInChrBuf + 1 - (srcSliceY>>1))*srcStride[1];

  1968. 				uint8_t *src2= src[2]+(lastInChrBuf + 1 - (srcSliceY>>1))*srcStride[2];

  1969. 				chrBufIndex++;

  1970. 				ASSERT(chrBufIndex < 2*vChrBufSize)

  1971. 				ASSERT(lastInChrBuf + 1 - (srcSliceY>>1) < (srcSliceH>>1))

  1972. 				ASSERT(lastInChrBuf + 1 - (srcSliceY>>1) >= 0)

  1973. 				//FIXME replace parameters through context struct (some at least)

  1974. 				RENAME(hcscale)(chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, (srcW+1)>>1, chrXInc,

  1975. 						flags, canMMX2BeUsed, hChrFilter, hChrFilterPos, hChrFilterSize,

  1976. 						funnyUVCode);

  1977. 				lastInChrBuf++;

  1978. 			}

  1979. 			//wrap buf index around to stay inside the ring buffer

  1980. 			if(lumBufIndex >= vLumBufSize ) lumBufIndex-= vLumBufSize;

  1981. 			if(chrBufIndex >= vChrBufSize ) chrBufIndex-= vChrBufSize;

  1982. 		}

  1983. 		else // not enough lines left in this slice -> load the rest in the buffer

  1984. 		{

  1985. /*		printf("%d %d Last:%d %d LastInBuf:%d %d Index:%d %d Y:%d FSize: %d %d BSize: %d %d\n",

  1986. 			firstChrSrcY,firstLumSrcY,lastChrSrcY,lastLumSrcY,

  1987. 			lastInChrBuf,lastInLumBuf,chrBufIndex,lumBufIndex,dstY,vChrFilterSize,vLumFilterSize,

  1988. 			vChrBufSize, vLumBufSize);

  1989. */

  1990. 			//Do horizontal scaling

  1991. 			while(lastInLumBuf+1 < srcSliceY + srcSliceH)

  1992. 			{

  1993. 				uint8_t *s= src[0]+(lastInLumBuf + 1 - srcSliceY)*srcStride[0];

  1994. 				lumBufIndex++;

  1995. 				ASSERT(lumBufIndex < 2*vLumBufSize)

  1996. 				ASSERT(lastInLumBuf + 1 - srcSliceY < srcSliceH)

  1997. 				ASSERT(lastInLumBuf + 1 - srcSliceY >= 0)

  1998. 				RENAME(hyscale)(lumPixBuf[ lumBufIndex ], dstW, s, srcW, lumXInc,

  1999. 						flags, canMMX2BeUsed, hLumFilter, hLumFilterPos, hLumFilterSize,

  2000. 						funnyYCode);

  2001. 				lastInLumBuf++;

  2002. 			}

  2003. 			while(lastInChrBuf+1 < ((srcSliceY + srcSliceH)>>1))

  2004. 			{

  2005. 				uint8_t *src1= src[1]+(lastInChrBuf + 1 - (srcSliceY>>1))*srcStride[1];

  2006. 				uint8_t *src2= src[2]+(lastInChrBuf + 1 - (srcSliceY>>1))*srcStride[2];

  2007. 				chrBufIndex++;

  2008. 				ASSERT(chrBufIndex < 2*vChrBufSize)

  2009. 				ASSERT(lastInChrBuf + 1 - (srcSliceY>>1) < (srcSliceH>>1))

  2010. 				ASSERT(lastInChrBuf + 1 - (srcSliceY>>1) >= 0)

  2011. 				RENAME(hcscale)(chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, (srcW+1)>>1, chrXInc,

  2012. 						flags, canMMX2BeUsed, hChrFilter, hChrFilterPos, hChrFilterSize,

  2013. 						funnyUVCode);

  2014. 				lastInChrBuf++;

  2015. 			}

  2016. 			//wrap buf index around to stay inside the ring buffer

  2017. 			if(lumBufIndex >= vLumBufSize ) lumBufIndex-= vLumBufSize;

  2018. 			if(chrBufIndex >= vChrBufSize ) chrBufIndex-= vChrBufSize;

  2019. 			break; //we cant output a dstY line so lets try with the next slice

  2020. 		}

  2021. 

  2022. #ifdef HAVE_MMX

  2023. 		b5Dither= dither8[dstY&1];

  2024. 		g6Dither= dither4[dstY&1];

  2025. 		g5Dither= dither8[dstY&1];

  2026. 		r5Dither= dither8[(dstY+1)&1];

  2027. #endif

  2028. 	    if(dstY < dstH-2)

  2029. 	    {

  2030. 		if(dstFormat==IMGFMT_YV12) //YV12

  2031. 		{

  2032. 			if(dstY&1) uDest=vDest= NULL; //FIXME split functions in lumi / chromi

  2033. 			if(vLumFilterSize == 1 && vChrFilterSize == 1) // Unscaled YV12

  2034. 			{

  2035. 				int16_t *lumBuf = lumPixBuf[0];

  2036. 				int16_t *chrBuf= chrPixBuf[0];

  2037. 				RENAME(yuv2yuv1)(lumBuf, chrBuf, dest, uDest, vDest, dstW);

  2038. 			}

  2039. 			else //General YV12

  2040. 			{

  2041. 				int16_t **lumSrcPtr= lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;

  2042. 				int16_t **chrSrcPtr= chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;

  2043. 				RENAME(yuv2yuvX)(

  2044. 					vLumFilter+dstY*vLumFilterSize     , lumSrcPtr, vLumFilterSize,

  2045. 					vChrFilter+(dstY>>1)*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  2046. 					dest, uDest, vDest, dstW,

  2047. 					lumMmxFilter+dstY*vLumFilterSize*4, chrMmxFilter+(dstY>>1)*vChrFilterSize*4);

  2048. 			}

  2049. 		}

  2050. 		else

  2051. 		{

  2052. 			int16_t **lumSrcPtr= lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;

  2053. 			int16_t **chrSrcPtr= chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;

  2054. 

  2055. 			ASSERT(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);

  2056. 			ASSERT(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2);

  2057. 			if(vLumFilterSize == 1 && vChrFilterSize == 2) //Unscaled RGB

  2058. 			{

  2059. 				int chrAlpha= vChrFilter[2*dstY+1];

  2060. 

  2061. 				RENAME(yuv2rgb1)(*lumSrcPtr, *chrSrcPtr, *(chrSrcPtr+1),

  2062. 						 dest, dstW, chrAlpha, dstFormat, flags);

  2063. 			}

  2064. 			else if(vLumFilterSize == 2 && vChrFilterSize == 2) //BiLinear Upscale RGB

  2065. 			{

  2066. 				int lumAlpha= vLumFilter[2*dstY+1];

  2067. 				int chrAlpha= vChrFilter[2*dstY+1];

  2068. 

  2069. 				RENAME(yuv2rgb2)(*lumSrcPtr, *(lumSrcPtr+1), *chrSrcPtr, *(chrSrcPtr+1),

  2070. 						 dest, dstW, lumAlpha, chrAlpha, dstFormat, flags);

  2071. 			}

  2072. 			else //General RGB

  2073. 			{

  2074. 				RENAME(yuv2rgbX)(

  2075. 					vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

  2076. 					vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  2077. 					dest, dstW, dstFormat,

  2078. 					lumMmxFilter+dstY*vLumFilterSize*4, chrMmxFilter+dstY*vChrFilterSize*4);

  2079. 			}

  2080. 		}

  2081.             }

  2082. 	    else // hmm looks like we cant use MMX here without overwriting this arrays tail

  2083. 	    {

  2084. 		int16_t **lumSrcPtr= lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;

  2085. 		int16_t **chrSrcPtr= chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;

  2086. 		if(dstFormat==IMGFMT_YV12) //YV12

  2087. 		{

  2088. 			if(dstY&1) uDest=vDest= NULL; //FIXME split functions in lumi / chromi

  2089. 			yuv2yuvXinC(

  2090. 				vLumFilter+dstY*vLumFilterSize     , lumSrcPtr, vLumFilterSize,

  2091. 				vChrFilter+(dstY>>1)*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  2092. 				dest, uDest, vDest, dstW);

  2093. 		}

  2094. 		else

  2095. 		{

  2096. 			ASSERT(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);

  2097. 			ASSERT(chrSrcPtr + vChrFilterSize - 1 < chrPixBuf + vChrBufSize*2);

  2098. 			yuv2rgbXinC(

  2099. 				vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,

  2100. 				vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,

  2101. 				dest, dstW, dstFormat);

  2102. 		}

  2103. 	    }

  2104. 	}

  2105. 

  2106. #ifdef HAVE_MMX

  2107. 	__asm __volatile(SFENCE:::"memory");

  2108. 	__asm __volatile(EMMS:::"memory");

  2109. #endif

  2110. 	/* store changed local vars back in the context */

  2111. 	c->dstY= dstY;

  2112. 	c->lumBufIndex= lumBufIndex;

  2113. 	c->chrBufIndex= chrBufIndex;

  2114. 	c->lastInLumBuf= lastInLumBuf;

  2115. 	c->lastInChrBuf= lastInChrBuf;

  2116. }