开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
swscale_template.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：85k
源码类别：

多媒体

开发平台：

MultiPlatform

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