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

2528 lines
63KB
Raw Blame History 

  1. /*

  2.  *

  3.  *  rgb2rgb.c, Software RGB to RGB convertor

  4.  *  pluralize by Software PAL8 to RGB convertor

  5.  *               Software YUV to YUV convertor

  6.  *               Software YUV to RGB convertor

  7.  *  Written by Nick Kurshev.

  8.  *  palette & yuv & runtime cpu stuff by Michael (michaelni@gmx.at) (under GPL)

  9.  */

  10. 

  11. #include <stddef.h>

  12. #include <inttypes.h> /* for __WORDSIZE */

  13. 

  14. #ifndef __WORDSIZE

  15. // #warning You have misconfigured system and probably will lose performance!

  16. #define __WORDSIZE MP_WORDSIZE

  17. #endif

  18. 

  19. #undef PREFETCH

  20. #undef MOVNTQ

  21. #undef EMMS

  22. #undef SFENCE

  23. #undef MMREG_SIZE

  24. #undef PREFETCHW

  25. #undef PAVGB

  26. 

  27. #ifdef HAVE_SSE2

  28. #define MMREG_SIZE 16

  29. #else

  30. #define MMREG_SIZE 8

  31. #endif

  32. 

  33. #ifdef HAVE_3DNOW

  34. #define PREFETCH  "prefetch"

  35. #define PREFETCHW "prefetchw"

  36. #define PAVGB	  "pavgusb"

  37. #elif defined ( HAVE_MMX2 )

  38. #define PREFETCH "prefetchnta"

  39. #define PREFETCHW "prefetcht0"

  40. #define PAVGB	  "pavgb"

  41. #else

  42. #define PREFETCH "/nop"

  43. #define PREFETCHW "/nop"

  44. #endif

  45. 

  46. #ifdef HAVE_3DNOW

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

  48. #define EMMS     "femms"

  49. #else

  50. #define EMMS     "emms"

  51. #endif

  52. 

  53. #ifdef HAVE_MMX2

  54. #define MOVNTQ "movntq"

  55. #define SFENCE "sfence"

  56. #else

  57. #define MOVNTQ "movq"

  58. #define SFENCE "/nop"

  59. #endif

  60. 

  61. static inline void RENAME(rgb24to32)(const uint8_t *src,uint8_t *dst,unsigned src_size)

  62. {

  63.   uint8_t *dest = dst;

  64.   const uint8_t *s = src;

  65.   const uint8_t *end;

  66. #ifdef HAVE_MMX

  67.   const uint8_t *mm_end;

  68. #endif

  69.   end = s + src_size;

  70. #ifdef HAVE_MMX

  71.   __asm __volatile(PREFETCH"	%0"::"m"(*s):"memory");

  72.   mm_end = end - 23;

  73.   __asm __volatile("movq	%0, %%mm7"::"m"(mask32):"memory");

  74.   while(s < mm_end)

  75.   {

  76.     __asm __volatile(

  77. 	PREFETCH"	32%1\n\t"

  78. 	"movd	%1, %%mm0\n\t"

  79. 	"punpckldq 3%1, %%mm0\n\t"

  80. 	"movd	6%1, %%mm1\n\t"

  81. 	"punpckldq 9%1, %%mm1\n\t"

  82. 	"movd	12%1, %%mm2\n\t"

  83. 	"punpckldq 15%1, %%mm2\n\t"

  84. 	"movd	18%1, %%mm3\n\t"

  85. 	"punpckldq 21%1, %%mm3\n\t"

  86. 	"pand	%%mm7, %%mm0\n\t"

  87. 	"pand	%%mm7, %%mm1\n\t"

  88. 	"pand	%%mm7, %%mm2\n\t"

  89. 	"pand	%%mm7, %%mm3\n\t"

  90. 	MOVNTQ"	%%mm0, %0\n\t"

  91. 	MOVNTQ"	%%mm1, 8%0\n\t"

  92. 	MOVNTQ"	%%mm2, 16%0\n\t"

  93. 	MOVNTQ"	%%mm3, 24%0"

  94. 	:"=m"(*dest)

  95. 	:"m"(*s)

  96. 	:"memory");

  97.     dest += 32;

  98.     s += 24;

  99.   }

  100.   __asm __volatile(SFENCE:::"memory");

  101.   __asm __volatile(EMMS:::"memory");

  102. #endif

  103.   while(s < end)

  104.   {

  105.     *dest++ = *s++;

  106.     *dest++ = *s++;

  107.     *dest++ = *s++;

  108.     *dest++ = 0;

  109.   }

  110. }

  111. 

  112. static inline void RENAME(rgb32to24)(const uint8_t *src,uint8_t *dst,unsigned src_size)

  113. {

  114.   uint8_t *dest = dst;

  115.   const uint8_t *s = src;

  116.   const uint8_t *end;

  117. #ifdef HAVE_MMX

  118.   const uint8_t *mm_end;

  119. #endif

  120.   end = s + src_size;

  121. #ifdef HAVE_MMX

  122.   __asm __volatile(PREFETCH"	%0"::"m"(*s):"memory");

  123.   mm_end = end - 31;

  124.   while(s < mm_end)

  125.   {

  126.     __asm __volatile(

  127. 	PREFETCH"	32%1\n\t"

  128. 	"movq	%1, %%mm0\n\t"

  129. 	"movq	8%1, %%mm1\n\t"

  130. 	"movq	16%1, %%mm4\n\t"

  131. 	"movq	24%1, %%mm5\n\t"

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

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

  134. 	"movq	%%mm4, %%mm6\n\t"

  135. 	"movq	%%mm5, %%mm7\n\t"

  136. 	"psrlq	$8, %%mm2\n\t"

  137. 	"psrlq	$8, %%mm3\n\t"

  138. 	"psrlq	$8, %%mm6\n\t"

  139. 	"psrlq	$8, %%mm7\n\t"

  140. 	"pand	%2, %%mm0\n\t"

  141. 	"pand	%2, %%mm1\n\t"

  142. 	"pand	%2, %%mm4\n\t"

  143. 	"pand	%2, %%mm5\n\t"

  144. 	"pand	%3, %%mm2\n\t"

  145. 	"pand	%3, %%mm3\n\t"

  146. 	"pand	%3, %%mm6\n\t"

  147. 	"pand	%3, %%mm7\n\t"

  148. 	"por	%%mm2, %%mm0\n\t"

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

  150. 	"por	%%mm6, %%mm4\n\t"

  151. 	"por	%%mm7, %%mm5\n\t"

  152. 

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

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

  155. 	"psllq	$48, %%mm2\n\t"

  156. 	"psllq	$32, %%mm3\n\t"

  157. 	"pand	%4, %%mm2\n\t"

  158. 	"pand	%5, %%mm3\n\t"

  159. 	"por	%%mm2, %%mm0\n\t"

  160. 	"psrlq	$16, %%mm1\n\t"

  161. 	"psrlq	$32, %%mm4\n\t"

  162. 	"psllq	$16, %%mm5\n\t"

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

  164. 	"pand	%6, %%mm5\n\t"

  165. 	"por	%%mm5, %%mm4\n\t"

  166. 

  167. 	MOVNTQ"	%%mm0, %0\n\t"

  168. 	MOVNTQ"	%%mm1, 8%0\n\t"

  169. 	MOVNTQ"	%%mm4, 16%0"

  170. 	:"=m"(*dest)

  171. 	:"m"(*s),"m"(mask24l),

  172. 	 "m"(mask24h),"m"(mask24hh),"m"(mask24hhh),"m"(mask24hhhh)

  173. 	:"memory");

  174.     dest += 24;

  175.     s += 32;

  176.   }

  177.   __asm __volatile(SFENCE:::"memory");

  178.   __asm __volatile(EMMS:::"memory");

  179. #endif

  180.   while(s < end)

  181.   {

  182.     *dest++ = *s++;

  183.     *dest++ = *s++;

  184.     *dest++ = *s++;

  185.     s++;

  186.   }

  187. }

  188. 

  189. /*

  190.  Original by Strepto/Astral

  191.  ported to gcc & bugfixed : A'rpi

  192.  MMX2, 3DNOW optimization by Nick Kurshev

  193.  32bit c version, and and&add trick by Michael Niedermayer

  194. */

  195. static inline void RENAME(rgb15to16)(const uint8_t *src,uint8_t *dst,unsigned src_size)

  196. {

  197.   register const uint8_t* s=src;

  198.   register uint8_t* d=dst;

  199.   register const uint8_t *end;

  200.   const uint8_t *mm_end;

  201.   end = s + src_size;

  202. #ifdef HAVE_MMX

  203.   __asm __volatile(PREFETCH"	%0"::"m"(*s));

  204.   __asm __volatile("movq	%0, %%mm4"::"m"(mask15s));

  205.   mm_end = end - 15;

  206.   while(s<mm_end)

  207.   {

  208. 	__asm __volatile(

  209. 		PREFETCH"	32%1\n\t"

  210. 		"movq	%1, %%mm0\n\t"

  211. 		"movq	8%1, %%mm2\n\t"

  212. 		"movq	%%mm0, %%mm1\n\t"

  213. 		"movq	%%mm2, %%mm3\n\t"

  214. 		"pand	%%mm4, %%mm0\n\t"

  215. 		"pand	%%mm4, %%mm2\n\t"

  216. 		"paddw	%%mm1, %%mm0\n\t"

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

  218. 		MOVNTQ"	%%mm0, %0\n\t"

  219. 		MOVNTQ"	%%mm2, 8%0"

  220. 		:"=m"(*d)

  221. 		:"m"(*s)

  222. 		);

  223. 	d+=16;

  224. 	s+=16;

  225.   }

  226.   __asm __volatile(SFENCE:::"memory");

  227.   __asm __volatile(EMMS:::"memory");

  228. #endif

  229.     mm_end = end - 3;

  230.     while(s < mm_end)

  231.     {

  232. 	register unsigned x= *((uint32_t *)s);

  233. 	*((uint32_t *)d) = (x&0x7FFF7FFF) + (x&0x7FE07FE0);

  234. 	d+=4;

  235. 	s+=4;

  236.     }

  237.     if(s < end)

  238.     {

  239. 	register unsigned short x= *((uint16_t *)s);

  240. 	*((uint16_t *)d) = (x&0x7FFF) + (x&0x7FE0);

  241.     }

  242. }

  243. 

  244. static inline void RENAME(bgr24torgb24)(const uint8_t *src, uint8_t *dst, unsigned src_size)

  245. {

  246. 	unsigned j,i,num_pixels=src_size/3;

  247. 	for(i=0,j=0; j<num_pixels; i+=3,j+=3)

  248. 	{

  249. 		dst[j+0] = src[i+2];

  250. 		dst[j+1] = src[i+1];

  251. 		dst[j+2] = src[i+0];

  252. 	}

  253. }

  254. 

  255. static inline void RENAME(rgb16to15)(const uint8_t *src,uint8_t *dst,unsigned src_size)

  256. {

  257.   register const uint8_t* s=src;

  258.   register uint8_t* d=dst;

  259.   register const uint8_t *end;

  260.   const uint8_t *mm_end;

  261.   end = s + src_size;

  262. #ifdef HAVE_MMX

  263.   __asm __volatile(PREFETCH"	%0"::"m"(*s));

  264.   __asm __volatile("movq	%0, %%mm7"::"m"(mask15rg));

  265.   __asm __volatile("movq	%0, %%mm6"::"m"(mask15b));

  266.   mm_end = end - 15;

  267.   while(s<mm_end)

  268.   {

  269. 	__asm __volatile(

  270. 		PREFETCH"	32%1\n\t"

  271. 		"movq	%1, %%mm0\n\t"

  272. 		"movq	8%1, %%mm2\n\t"

  273. 		"movq	%%mm0, %%mm1\n\t"

  274. 		"movq	%%mm2, %%mm3\n\t"

  275. 		"psrlq	$1, %%mm0\n\t"

  276. 		"psrlq	$1, %%mm2\n\t"

  277. 		"pand	%%mm7, %%mm0\n\t"

  278. 		"pand	%%mm7, %%mm2\n\t"

  279. 		"pand	%%mm6, %%mm1\n\t"

  280. 		"pand	%%mm6, %%mm3\n\t"

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

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

  283. 		MOVNTQ"	%%mm0, %0\n\t"

  284. 		MOVNTQ"	%%mm2, 8%0"

  285. 		:"=m"(*d)

  286. 		:"m"(*s)

  287. 		);

  288. 	d+=16;

  289. 	s+=16;

  290.   }

  291.   __asm __volatile(SFENCE:::"memory");

  292.   __asm __volatile(EMMS:::"memory");

  293. #endif

  294.     mm_end = end - 3;

  295.     while(s < mm_end)

  296.     {

  297. 	register uint32_t x= *((uint32_t *)s);

  298. 	*((uint32_t *)d) = ((x>>1)&0x7FE07FE0) | (x&0x001F001F);

  299. 	s+=4;

  300. 	d+=4;

  301.     }

  302.     if(s < end)

  303.     {

  304. 	register uint16_t x= *((uint16_t *)s);

  305. 	*((uint16_t *)d) = ((x>>1)&0x7FE0) | (x&0x001F);

  306. 	s+=2;

  307. 	d+=2;

  308.     }

  309. }

  310. 

  311. static inline void RENAME(rgb32to16)(const uint8_t *src, uint8_t *dst, unsigned src_size)

  312. {

  313. 	const uint8_t *s = src;

  314. 	const uint8_t *end;

  315. #ifdef HAVE_MMX

  316. 	const uint8_t *mm_end;

  317. #endif

  318. 	uint16_t *d = (uint16_t *)dst;

  319. 	end = s + src_size;

  320. #ifdef HAVE_MMX

  321. 	mm_end = end - 15;

  322. #if 1 //is faster only if multiplies are reasonable fast (FIXME figure out on which cpus this is faster, on Athlon its slightly faster)

  323. 	asm volatile(

  324. 		"movq %3, %%mm5			\n\t"

  325. 		"movq %4, %%mm6			\n\t"

  326. 		"movq %5, %%mm7			\n\t"

  327. 		".balign 16			\n\t"

  328. 		"1:				\n\t"

  329. 		PREFETCH" 32(%1)		\n\t"

  330. 		"movd	(%1), %%mm0		\n\t"

  331. 		"movd	4(%1), %%mm3		\n\t"

  332. 		"punpckldq 8(%1), %%mm0		\n\t"

  333. 		"punpckldq 12(%1), %%mm3	\n\t"

  334. 		"movq %%mm0, %%mm1		\n\t"

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

  336. 		"pand %%mm6, %%mm0		\n\t"

  337. 		"pand %%mm6, %%mm3		\n\t"

  338. 		"pmaddwd %%mm7, %%mm0		\n\t"

  339. 		"pmaddwd %%mm7, %%mm3		\n\t"

  340. 		"pand %%mm5, %%mm1		\n\t"

  341. 		"pand %%mm5, %%mm4		\n\t"

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

  343. 		"por %%mm4, %%mm3		\n\t"

  344. 		"psrld $5, %%mm0		\n\t"

  345. 		"pslld $11, %%mm3		\n\t"

  346. 		"por %%mm3, %%mm0		\n\t"

  347. 		MOVNTQ"	%%mm0, (%0)		\n\t"

  348. 		"addl $16, %1			\n\t"

  349. 		"addl $8, %0			\n\t"

  350. 		"cmpl %2, %1			\n\t"

  351. 		" jb 1b				\n\t"

  352. 		: "+r" (d), "+r"(s)

  353. 		: "r" (mm_end), "m" (mask3216g), "m" (mask3216br), "m" (mul3216)

  354. 	);

  355. #else

  356. 	__asm __volatile(PREFETCH"	%0"::"m"(*src):"memory");

  357. 	__asm __volatile(

  358. 	    "movq	%0, %%mm7\n\t"

  359. 	    "movq	%1, %%mm6\n\t"

  360. 	    ::"m"(red_16mask),"m"(green_16mask));

  361. 	while(s < mm_end)

  362. 	{

  363. 	    __asm __volatile(

  364. 		PREFETCH" 32%1\n\t"

  365. 		"movd	%1, %%mm0\n\t"

  366. 		"movd	4%1, %%mm3\n\t"

  367. 		"punpckldq 8%1, %%mm0\n\t"

  368. 		"punpckldq 12%1, %%mm3\n\t"

  369. 		"movq	%%mm0, %%mm1\n\t"

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

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

  372. 		"movq	%%mm3, %%mm5\n\t"

  373. 		"psrlq	$3, %%mm0\n\t"

  374. 		"psrlq	$3, %%mm3\n\t"

  375. 		"pand	%2, %%mm0\n\t"

  376. 		"pand	%2, %%mm3\n\t"

  377. 		"psrlq	$5, %%mm1\n\t"

  378. 		"psrlq	$5, %%mm4\n\t"

  379. 		"pand	%%mm6, %%mm1\n\t"

  380. 		"pand	%%mm6, %%mm4\n\t"

  381. 		"psrlq	$8, %%mm2\n\t"

  382. 		"psrlq	$8, %%mm5\n\t"

  383. 		"pand	%%mm7, %%mm2\n\t"

  384. 		"pand	%%mm7, %%mm5\n\t"

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

  386. 		"por	%%mm4, %%mm3\n\t"

  387. 		"por	%%mm2, %%mm0\n\t"

  388. 		"por	%%mm5, %%mm3\n\t"

  389. 		"psllq	$16, %%mm3\n\t"

  390. 		"por	%%mm3, %%mm0\n\t"

  391. 		MOVNTQ"	%%mm0, %0\n\t"

  392. 		:"=m"(*d):"m"(*s),"m"(blue_16mask):"memory");

  393. 		d += 4;

  394. 		s += 16;

  395. 	}

  396. #endif

  397. 	__asm __volatile(SFENCE:::"memory");

  398. 	__asm __volatile(EMMS:::"memory");

  399. #endif

  400. 	while(s < end)

  401. 	{

  402. 		const int src= *((uint32_t*)s)++;

  403. 		*d++ = ((src&0xFF)>>3) + ((src&0xFC00)>>5) + ((src&0xF80000)>>8);

  404. //		*d++ = ((src>>3)&0x1F) + ((src>>5)&0x7E0) + ((src>>8)&0xF800);

  405. 	}

  406. }

  407. 

  408. static inline void RENAME(rgb32tobgr16)(const uint8_t *src, uint8_t *dst, unsigned int src_size)

  409. {

  410. 	const uint8_t *s = src;

  411. 	const uint8_t *end;

  412. #ifdef HAVE_MMX

  413. 	const uint8_t *mm_end;

  414. #endif

  415. 	uint16_t *d = (uint16_t *)dst;

  416. 	end = s + src_size;

  417. #ifdef HAVE_MMX

  418. 	__asm __volatile(PREFETCH"	%0"::"m"(*src):"memory");

  419. 	__asm __volatile(

  420. 	    "movq	%0, %%mm7\n\t"

  421. 	    "movq	%1, %%mm6\n\t"

  422. 	    ::"m"(red_16mask),"m"(green_16mask));

  423. 	mm_end = end - 15;

  424. 	while(s < mm_end)

  425. 	{

  426. 	    __asm __volatile(

  427. 		PREFETCH" 32%1\n\t"

  428. 		"movd	%1, %%mm0\n\t"

  429. 		"movd	4%1, %%mm3\n\t"

  430. 		"punpckldq 8%1, %%mm0\n\t"

  431. 		"punpckldq 12%1, %%mm3\n\t"

  432. 		"movq	%%mm0, %%mm1\n\t"

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

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

  435. 		"movq	%%mm3, %%mm5\n\t"

  436. 		"psllq	$8, %%mm0\n\t"

  437. 		"psllq	$8, %%mm3\n\t"

  438. 		"pand	%%mm7, %%mm0\n\t"

  439. 		"pand	%%mm7, %%mm3\n\t"

  440. 		"psrlq	$5, %%mm1\n\t"

  441. 		"psrlq	$5, %%mm4\n\t"

  442. 		"pand	%%mm6, %%mm1\n\t"

  443. 		"pand	%%mm6, %%mm4\n\t"

  444. 		"psrlq	$19, %%mm2\n\t"

  445. 		"psrlq	$19, %%mm5\n\t"

  446. 		"pand	%2, %%mm2\n\t"

  447. 		"pand	%2, %%mm5\n\t"

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

  449. 		"por	%%mm4, %%mm3\n\t"

  450. 		"por	%%mm2, %%mm0\n\t"

  451. 		"por	%%mm5, %%mm3\n\t"

  452. 		"psllq	$16, %%mm3\n\t"

  453. 		"por	%%mm3, %%mm0\n\t"

  454. 		MOVNTQ"	%%mm0, %0\n\t"

  455. 		:"=m"(*d):"m"(*s),"m"(blue_16mask):"memory");

  456. 		d += 4;

  457. 		s += 16;

  458. 	}

  459. 	__asm __volatile(SFENCE:::"memory");

  460. 	__asm __volatile(EMMS:::"memory");

  461. #endif

  462. 	while(s < end)

  463. 	{

  464. 		const int src= *((uint32_t*)s)++;

  465. 		*d++ = ((src&0xF8)<<8) + ((src&0xFC00)>>5) + ((src&0xF80000)>>19);

  466. 	}

  467. }

  468. 

  469. static inline void RENAME(rgb32to15)(const uint8_t *src, uint8_t *dst, unsigned src_size)

  470. {

  471. 	const uint8_t *s = src;

  472. 	const uint8_t *end;

  473. #ifdef HAVE_MMX

  474. 	const uint8_t *mm_end;

  475. #endif

  476. 	uint16_t *d = (uint16_t *)dst;

  477. 	end = s + src_size;

  478. #ifdef HAVE_MMX

  479. 	mm_end = end - 15;

  480. #if 1 //is faster only if multiplies are reasonable fast (FIXME figure out on which cpus this is faster, on Athlon its slightly faster)

  481. 	asm volatile(

  482. 		"movq %3, %%mm5			\n\t"

  483. 		"movq %4, %%mm6			\n\t"

  484. 		"movq %5, %%mm7			\n\t"

  485. 		".balign 16			\n\t"

  486. 		"1:				\n\t"

  487. 		PREFETCH" 32(%1)		\n\t"

  488. 		"movd	(%1), %%mm0		\n\t"

  489. 		"movd	4(%1), %%mm3		\n\t"

  490. 		"punpckldq 8(%1), %%mm0		\n\t"

  491. 		"punpckldq 12(%1), %%mm3	\n\t"

  492. 		"movq %%mm0, %%mm1		\n\t"

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

  494. 		"pand %%mm6, %%mm0		\n\t"

  495. 		"pand %%mm6, %%mm3		\n\t"

  496. 		"pmaddwd %%mm7, %%mm0		\n\t"

  497. 		"pmaddwd %%mm7, %%mm3		\n\t"

  498. 		"pand %%mm5, %%mm1		\n\t"

  499. 		"pand %%mm5, %%mm4		\n\t"

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

  501. 		"por %%mm4, %%mm3		\n\t"

  502. 		"psrld $6, %%mm0		\n\t"

  503. 		"pslld $10, %%mm3		\n\t"

  504. 		"por %%mm3, %%mm0		\n\t"

  505. 		MOVNTQ"	%%mm0, (%0)		\n\t"

  506. 		"addl $16, %1			\n\t"

  507. 		"addl $8, %0			\n\t"

  508. 		"cmpl %2, %1			\n\t"

  509. 		" jb 1b				\n\t"

  510. 		: "+r" (d), "+r"(s)

  511. 		: "r" (mm_end), "m" (mask3215g), "m" (mask3216br), "m" (mul3215)

  512. 	);

  513. #else

  514. 	__asm __volatile(PREFETCH"	%0"::"m"(*src):"memory");

  515. 	__asm __volatile(

  516. 	    "movq	%0, %%mm7\n\t"

  517. 	    "movq	%1, %%mm6\n\t"

  518. 	    ::"m"(red_15mask),"m"(green_15mask));

  519. 	while(s < mm_end)

  520. 	{

  521. 	    __asm __volatile(

  522. 		PREFETCH" 32%1\n\t"

  523. 		"movd	%1, %%mm0\n\t"

  524. 		"movd	4%1, %%mm3\n\t"

  525. 		"punpckldq 8%1, %%mm0\n\t"

  526. 		"punpckldq 12%1, %%mm3\n\t"

  527. 		"movq	%%mm0, %%mm1\n\t"

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

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

  530. 		"movq	%%mm3, %%mm5\n\t"

  531. 		"psrlq	$3, %%mm0\n\t"

  532. 		"psrlq	$3, %%mm3\n\t"

  533. 		"pand	%2, %%mm0\n\t"

  534. 		"pand	%2, %%mm3\n\t"

  535. 		"psrlq	$6, %%mm1\n\t"

  536. 		"psrlq	$6, %%mm4\n\t"

  537. 		"pand	%%mm6, %%mm1\n\t"

  538. 		"pand	%%mm6, %%mm4\n\t"

  539. 		"psrlq	$9, %%mm2\n\t"

  540. 		"psrlq	$9, %%mm5\n\t"

  541. 		"pand	%%mm7, %%mm2\n\t"

  542. 		"pand	%%mm7, %%mm5\n\t"

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

  544. 		"por	%%mm4, %%mm3\n\t"

  545. 		"por	%%mm2, %%mm0\n\t"

  546. 		"por	%%mm5, %%mm3\n\t"

  547. 		"psllq	$16, %%mm3\n\t"

  548. 		"por	%%mm3, %%mm0\n\t"

  549. 		MOVNTQ"	%%mm0, %0\n\t"

  550. 		:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");

  551. 		d += 4;

  552. 		s += 16;

  553. 	}

  554. #endif

  555. 	__asm __volatile(SFENCE:::"memory");

  556. 	__asm __volatile(EMMS:::"memory");

  557. #endif

  558. 	while(s < end)

  559. 	{

  560. 		const int src= *((uint32_t*)s)++;

  561. 		*d++ = ((src&0xFF)>>3) + ((src&0xF800)>>6) + ((src&0xF80000)>>9);

  562. 	}

  563. }

  564. 

  565. static inline void RENAME(rgb32tobgr15)(const uint8_t *src, uint8_t *dst, unsigned src_size)

  566. {

  567. 	const uint8_t *s = src;

  568. 	const uint8_t *end;

  569. #ifdef HAVE_MMX

  570. 	const uint8_t *mm_end;

  571. #endif

  572. 	uint16_t *d = (uint16_t *)dst;

  573. 	end = s + src_size;

  574. #ifdef HAVE_MMX

  575. 	__asm __volatile(PREFETCH"	%0"::"m"(*src):"memory");

  576. 	__asm __volatile(

  577. 	    "movq	%0, %%mm7\n\t"

  578. 	    "movq	%1, %%mm6\n\t"

  579. 	    ::"m"(red_15mask),"m"(green_15mask));

  580. 	mm_end = end - 15;

  581. 	while(s < mm_end)

  582. 	{

  583. 	    __asm __volatile(

  584. 		PREFETCH" 32%1\n\t"

  585. 		"movd	%1, %%mm0\n\t"

  586. 		"movd	4%1, %%mm3\n\t"

  587. 		"punpckldq 8%1, %%mm0\n\t"

  588. 		"punpckldq 12%1, %%mm3\n\t"

  589. 		"movq	%%mm0, %%mm1\n\t"

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

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

  592. 		"movq	%%mm3, %%mm5\n\t"

  593. 		"psllq	$7, %%mm0\n\t"

  594. 		"psllq	$7, %%mm3\n\t"

  595. 		"pand	%%mm7, %%mm0\n\t"

  596. 		"pand	%%mm7, %%mm3\n\t"

  597. 		"psrlq	$6, %%mm1\n\t"

  598. 		"psrlq	$6, %%mm4\n\t"

  599. 		"pand	%%mm6, %%mm1\n\t"

  600. 		"pand	%%mm6, %%mm4\n\t"

  601. 		"psrlq	$19, %%mm2\n\t"

  602. 		"psrlq	$19, %%mm5\n\t"

  603. 		"pand	%2, %%mm2\n\t"

  604. 		"pand	%2, %%mm5\n\t"

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

  606. 		"por	%%mm4, %%mm3\n\t"

  607. 		"por	%%mm2, %%mm0\n\t"

  608. 		"por	%%mm5, %%mm3\n\t"

  609. 		"psllq	$16, %%mm3\n\t"

  610. 		"por	%%mm3, %%mm0\n\t"

  611. 		MOVNTQ"	%%mm0, %0\n\t"

  612. 		:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");

  613. 		d += 4;

  614. 		s += 16;

  615. 	}

  616. 	__asm __volatile(SFENCE:::"memory");

  617. 	__asm __volatile(EMMS:::"memory");

  618. #endif

  619. 	while(s < end)

  620. 	{

  621. 		const int src= *((uint32_t*)s)++;

  622. 		*d++ = ((src&0xF8)<<7) + ((src&0xF800)>>6) + ((src&0xF80000)>>19);

  623. 	}

  624. }

  625. 

  626. static inline void RENAME(rgb24to16)(const uint8_t *src, uint8_t *dst, unsigned src_size)

  627. {

  628. 	const uint8_t *s = src;

  629. 	const uint8_t *end;

  630. #ifdef HAVE_MMX

  631. 	const uint8_t *mm_end;

  632. #endif

  633. 	uint16_t *d = (uint16_t *)dst;

  634. 	end = s + src_size;

  635. #ifdef HAVE_MMX

  636. 	__asm __volatile(PREFETCH"	%0"::"m"(*src):"memory");

  637. 	__asm __volatile(

  638. 	    "movq	%0, %%mm7\n\t"

  639. 	    "movq	%1, %%mm6\n\t"

  640. 	    ::"m"(red_16mask),"m"(green_16mask));

  641. 	mm_end = end - 11;

  642. 	while(s < mm_end)

  643. 	{

  644. 	    __asm __volatile(

  645. 		PREFETCH" 32%1\n\t"

  646. 		"movd	%1, %%mm0\n\t"

  647. 		"movd	3%1, %%mm3\n\t"

  648. 		"punpckldq 6%1, %%mm0\n\t"

  649. 		"punpckldq 9%1, %%mm3\n\t"

  650. 		"movq	%%mm0, %%mm1\n\t"

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

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

  653. 		"movq	%%mm3, %%mm5\n\t"

  654. 		"psrlq	$3, %%mm0\n\t"

  655. 		"psrlq	$3, %%mm3\n\t"

  656. 		"pand	%2, %%mm0\n\t"

  657. 		"pand	%2, %%mm3\n\t"

  658. 		"psrlq	$5, %%mm1\n\t"

  659. 		"psrlq	$5, %%mm4\n\t"

  660. 		"pand	%%mm6, %%mm1\n\t"

  661. 		"pand	%%mm6, %%mm4\n\t"

  662. 		"psrlq	$8, %%mm2\n\t"

  663. 		"psrlq	$8, %%mm5\n\t"

  664. 		"pand	%%mm7, %%mm2\n\t"

  665. 		"pand	%%mm7, %%mm5\n\t"

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

  667. 		"por	%%mm4, %%mm3\n\t"

  668. 		"por	%%mm2, %%mm0\n\t"

  669. 		"por	%%mm5, %%mm3\n\t"

  670. 		"psllq	$16, %%mm3\n\t"

  671. 		"por	%%mm3, %%mm0\n\t"

  672. 		MOVNTQ"	%%mm0, %0\n\t"

  673. 		:"=m"(*d):"m"(*s),"m"(blue_16mask):"memory");

  674. 		d += 4;

  675. 		s += 12;

  676. 	}

  677. 	__asm __volatile(SFENCE:::"memory");

  678. 	__asm __volatile(EMMS:::"memory");

  679. #endif

  680. 	while(s < end)

  681. 	{

  682. 		const int b= *s++;

  683. 		const int g= *s++;

  684. 		const int r= *s++;

  685. 		*d++ = (b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8);

  686. 	}

  687. }

  688. 

  689. static inline void RENAME(rgb24tobgr16)(const uint8_t *src, uint8_t *dst, unsigned int src_size)

  690. {

  691. 	const uint8_t *s = src;

  692. 	const uint8_t *end;

  693. #ifdef HAVE_MMX

  694. 	const uint8_t *mm_end;

  695. #endif

  696. 	uint16_t *d = (uint16_t *)dst;

  697. 	end = s + src_size;

  698. #ifdef HAVE_MMX

  699. 	__asm __volatile(PREFETCH"	%0"::"m"(*src):"memory");

  700. 	__asm __volatile(

  701. 	    "movq	%0, %%mm7\n\t"

  702. 	    "movq	%1, %%mm6\n\t"

  703. 	    ::"m"(red_16mask),"m"(green_16mask));

  704. 	mm_end = end - 15;

  705. 	while(s < mm_end)

  706. 	{

  707. 	    __asm __volatile(

  708. 		PREFETCH" 32%1\n\t"

  709. 		"movd	%1, %%mm0\n\t"

  710. 		"movd	3%1, %%mm3\n\t"

  711. 		"punpckldq 6%1, %%mm0\n\t"

  712. 		"punpckldq 9%1, %%mm3\n\t"

  713. 		"movq	%%mm0, %%mm1\n\t"

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

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

  716. 		"movq	%%mm3, %%mm5\n\t"

  717. 		"psllq	$8, %%mm0\n\t"

  718. 		"psllq	$8, %%mm3\n\t"

  719. 		"pand	%%mm7, %%mm0\n\t"

  720. 		"pand	%%mm7, %%mm3\n\t"

  721. 		"psrlq	$5, %%mm1\n\t"

  722. 		"psrlq	$5, %%mm4\n\t"

  723. 		"pand	%%mm6, %%mm1\n\t"

  724. 		"pand	%%mm6, %%mm4\n\t"

  725. 		"psrlq	$19, %%mm2\n\t"

  726. 		"psrlq	$19, %%mm5\n\t"

  727. 		"pand	%2, %%mm2\n\t"

  728. 		"pand	%2, %%mm5\n\t"

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

  730. 		"por	%%mm4, %%mm3\n\t"

  731. 		"por	%%mm2, %%mm0\n\t"

  732. 		"por	%%mm5, %%mm3\n\t"

  733. 		"psllq	$16, %%mm3\n\t"

  734. 		"por	%%mm3, %%mm0\n\t"

  735. 		MOVNTQ"	%%mm0, %0\n\t"

  736. 		:"=m"(*d):"m"(*s),"m"(blue_16mask):"memory");

  737. 		d += 4;

  738. 		s += 12;

  739. 	}

  740. 	__asm __volatile(SFENCE:::"memory");

  741. 	__asm __volatile(EMMS:::"memory");

  742. #endif

  743. 	while(s < end)

  744. 	{

  745. 		const int r= *s++;

  746. 		const int g= *s++;

  747. 		const int b= *s++;

  748. 		*d++ = (b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8);

  749. 	}

  750. }

  751. 

  752. static inline void RENAME(rgb24to15)(const uint8_t *src, uint8_t *dst, unsigned src_size)

  753. {

  754. 	const uint8_t *s = src;

  755. 	const uint8_t *end;

  756. #ifdef HAVE_MMX

  757. 	const uint8_t *mm_end;

  758. #endif

  759. 	uint16_t *d = (uint16_t *)dst;

  760. 	end = s + src_size;

  761. #ifdef HAVE_MMX

  762. 	__asm __volatile(PREFETCH"	%0"::"m"(*src):"memory");

  763. 	__asm __volatile(

  764. 	    "movq	%0, %%mm7\n\t"

  765. 	    "movq	%1, %%mm6\n\t"

  766. 	    ::"m"(red_15mask),"m"(green_15mask));

  767. 	mm_end = end - 11;

  768. 	while(s < mm_end)

  769. 	{

  770. 	    __asm __volatile(

  771. 		PREFETCH" 32%1\n\t"

  772. 		"movd	%1, %%mm0\n\t"

  773. 		"movd	3%1, %%mm3\n\t"

  774. 		"punpckldq 6%1, %%mm0\n\t"

  775. 		"punpckldq 9%1, %%mm3\n\t"

  776. 		"movq	%%mm0, %%mm1\n\t"

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

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

  779. 		"movq	%%mm3, %%mm5\n\t"

  780. 		"psrlq	$3, %%mm0\n\t"

  781. 		"psrlq	$3, %%mm3\n\t"

  782. 		"pand	%2, %%mm0\n\t"

  783. 		"pand	%2, %%mm3\n\t"

  784. 		"psrlq	$6, %%mm1\n\t"

  785. 		"psrlq	$6, %%mm4\n\t"

  786. 		"pand	%%mm6, %%mm1\n\t"

  787. 		"pand	%%mm6, %%mm4\n\t"

  788. 		"psrlq	$9, %%mm2\n\t"

  789. 		"psrlq	$9, %%mm5\n\t"

  790. 		"pand	%%mm7, %%mm2\n\t"

  791. 		"pand	%%mm7, %%mm5\n\t"

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

  793. 		"por	%%mm4, %%mm3\n\t"

  794. 		"por	%%mm2, %%mm0\n\t"

  795. 		"por	%%mm5, %%mm3\n\t"

  796. 		"psllq	$16, %%mm3\n\t"

  797. 		"por	%%mm3, %%mm0\n\t"

  798. 		MOVNTQ"	%%mm0, %0\n\t"

  799. 		:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");

  800. 		d += 4;

  801. 		s += 12;

  802. 	}

  803. 	__asm __volatile(SFENCE:::"memory");

  804. 	__asm __volatile(EMMS:::"memory");

  805. #endif

  806. 	while(s < end)

  807. 	{

  808. 		const int b= *s++;

  809. 		const int g= *s++;

  810. 		const int r= *s++;

  811. 		*d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);

  812. 	}

  813. }

  814. 

  815. static inline void RENAME(rgb24tobgr15)(const uint8_t *src, uint8_t *dst, unsigned src_size)

  816. {

  817. 	const uint8_t *s = src;

  818. 	const uint8_t *end;

  819. #ifdef HAVE_MMX

  820. 	const uint8_t *mm_end;

  821. #endif

  822. 	uint16_t *d = (uint16_t *)dst;

  823. 	end = s + src_size;

  824. #ifdef HAVE_MMX

  825. 	__asm __volatile(PREFETCH"	%0"::"m"(*src):"memory");

  826. 	__asm __volatile(

  827. 	    "movq	%0, %%mm7\n\t"

  828. 	    "movq	%1, %%mm6\n\t"

  829. 	    ::"m"(red_15mask),"m"(green_15mask));

  830. 	mm_end = end - 15;

  831. 	while(s < mm_end)

  832. 	{

  833. 	    __asm __volatile(

  834. 		PREFETCH" 32%1\n\t"

  835. 		"movd	%1, %%mm0\n\t"

  836. 		"movd	3%1, %%mm3\n\t"

  837. 		"punpckldq 6%1, %%mm0\n\t"

  838. 		"punpckldq 9%1, %%mm3\n\t"

  839. 		"movq	%%mm0, %%mm1\n\t"

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

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

  842. 		"movq	%%mm3, %%mm5\n\t"

  843. 		"psllq	$7, %%mm0\n\t"

  844. 		"psllq	$7, %%mm3\n\t"

  845. 		"pand	%%mm7, %%mm0\n\t"

  846. 		"pand	%%mm7, %%mm3\n\t"

  847. 		"psrlq	$6, %%mm1\n\t"

  848. 		"psrlq	$6, %%mm4\n\t"

  849. 		"pand	%%mm6, %%mm1\n\t"

  850. 		"pand	%%mm6, %%mm4\n\t"

  851. 		"psrlq	$19, %%mm2\n\t"

  852. 		"psrlq	$19, %%mm5\n\t"

  853. 		"pand	%2, %%mm2\n\t"

  854. 		"pand	%2, %%mm5\n\t"

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

  856. 		"por	%%mm4, %%mm3\n\t"

  857. 		"por	%%mm2, %%mm0\n\t"

  858. 		"por	%%mm5, %%mm3\n\t"

  859. 		"psllq	$16, %%mm3\n\t"

  860. 		"por	%%mm3, %%mm0\n\t"

  861. 		MOVNTQ"	%%mm0, %0\n\t"

  862. 		:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");

  863. 		d += 4;

  864. 		s += 12;

  865. 	}

  866. 	__asm __volatile(SFENCE:::"memory");

  867. 	__asm __volatile(EMMS:::"memory");

  868. #endif

  869. 	while(s < end)

  870. 	{

  871. 		const int r= *s++;

  872. 		const int g= *s++;

  873. 		const int b= *s++;

  874. 		*d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);

  875. 	}

  876. }

  877. 

  878. /*

  879.   I use here less accurate approximation by simply

  880.  left-shifting the input

  881.   value and filling the low order bits with

  882.  zeroes. This method improves png's

  883.   compression but this scheme cannot reproduce white exactly, since it does not

  884.   generate an all-ones maximum value; the net effect is to darken the

  885.   image slightly.

  886. 

  887.   The better method should be "left bit replication":

  888. 

  889.    4 3 2 1 0

  890.    ---------

  891.    1 1 0 1 1

  892. 

  893.    7 6 5 4 3  2 1 0

  894.    ----------------

  895.    1 1 0 1 1  1 1 0

  896.    |=======|  |===|

  897.        |      Leftmost Bits Repeated to Fill Open Bits

  898.        |

  899.    Original Bits

  900. */

  901. static inline void RENAME(rgb15to24)(const uint8_t *src, uint8_t *dst, unsigned src_size)

  902. {

  903. 	const uint16_t *end;

  904. #ifdef HAVE_MMX

  905. 	const uint16_t *mm_end;

  906. #endif

  907. 	uint8_t *d = (uint8_t *)dst;

  908. 	const uint16_t *s = (uint16_t *)src;

  909. 	end = s + src_size/2;

  910. #ifdef HAVE_MMX

  911. 	__asm __volatile(PREFETCH"	%0"::"m"(*s):"memory");

  912. 	mm_end = end - 7;

  913. 	while(s < mm_end)

  914. 	{

  915. 	    __asm __volatile(

  916. 		PREFETCH" 32%1\n\t"

  917. 		"movq	%1, %%mm0\n\t"

  918. 		"movq	%1, %%mm1\n\t"

  919. 		"movq	%1, %%mm2\n\t"

  920. 		"pand	%2, %%mm0\n\t"

  921. 		"pand	%3, %%mm1\n\t"

  922. 		"pand	%4, %%mm2\n\t"

  923. 		"psllq	$3, %%mm0\n\t"

  924. 		"psrlq	$2, %%mm1\n\t"

  925. 		"psrlq	$7, %%mm2\n\t"

  926. 		"movq	%%mm0, %%mm3\n\t"

  927. 		"movq	%%mm1, %%mm4\n\t"

  928. 		"movq	%%mm2, %%mm5\n\t"

  929. 		"punpcklwd %5, %%mm0\n\t"

  930. 		"punpcklwd %5, %%mm1\n\t"

  931. 		"punpcklwd %5, %%mm2\n\t"

  932. 		"punpckhwd %5, %%mm3\n\t"

  933. 		"punpckhwd %5, %%mm4\n\t"

  934. 		"punpckhwd %5, %%mm5\n\t"

  935. 		"psllq	$8, %%mm1\n\t"

  936. 		"psllq	$16, %%mm2\n\t"

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

  938. 		"por	%%mm2, %%mm0\n\t"

  939. 		"psllq	$8, %%mm4\n\t"

  940. 		"psllq	$16, %%mm5\n\t"

  941. 		"por	%%mm4, %%mm3\n\t"

  942. 		"por	%%mm5, %%mm3\n\t"

  943. 

  944. 		"movq	%%mm0, %%mm6\n\t"

  945. 		"movq	%%mm3, %%mm7\n\t"

  946. 		

  947. 		"movq	8%1, %%mm0\n\t"

  948. 		"movq	8%1, %%mm1\n\t"

  949. 		"movq	8%1, %%mm2\n\t"

  950. 		"pand	%2, %%mm0\n\t"

  951. 		"pand	%3, %%mm1\n\t"

  952. 		"pand	%4, %%mm2\n\t"

  953. 		"psllq	$3, %%mm0\n\t"

  954. 		"psrlq	$2, %%mm1\n\t"

  955. 		"psrlq	$7, %%mm2\n\t"

  956. 		"movq	%%mm0, %%mm3\n\t"

  957. 		"movq	%%mm1, %%mm4\n\t"

  958. 		"movq	%%mm2, %%mm5\n\t"

  959. 		"punpcklwd %5, %%mm0\n\t"

  960. 		"punpcklwd %5, %%mm1\n\t"

  961. 		"punpcklwd %5, %%mm2\n\t"

  962. 		"punpckhwd %5, %%mm3\n\t"

  963. 		"punpckhwd %5, %%mm4\n\t"

  964. 		"punpckhwd %5, %%mm5\n\t"

  965. 		"psllq	$8, %%mm1\n\t"

  966. 		"psllq	$16, %%mm2\n\t"

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

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

  969. 		"psllq	$8, %%mm4\n\t"

  970. 		"psllq	$16, %%mm5\n\t"

  971. 		"por	%%mm4, %%mm3\n\t"

  972. 		"por	%%mm5, %%mm3\n\t"

  973. 

  974. 		:"=m"(*d)

  975. 		:"m"(*s),"m"(mask15b),"m"(mask15g),"m"(mask15r), "m"(mmx_null)

  976. 		:"memory");

  977. 	    /* Borrowed 32 to 24 */

  978. 	    __asm __volatile(

  979. 		"movq	%%mm0, %%mm4\n\t"

  980. 		"movq	%%mm3, %%mm5\n\t"

  981. 		"movq	%%mm6, %%mm0\n\t"

  982. 		"movq	%%mm7, %%mm1\n\t"

  983. 		

  984. 		"movq	%%mm4, %%mm6\n\t"

  985. 		"movq	%%mm5, %%mm7\n\t"

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

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

  988. 

  989. 		"psrlq	$8, %%mm2\n\t"

  990. 		"psrlq	$8, %%mm3\n\t"

  991. 		"psrlq	$8, %%mm6\n\t"

  992. 		"psrlq	$8, %%mm7\n\t"

  993. 		"pand	%2, %%mm0\n\t"

  994. 		"pand	%2, %%mm1\n\t"

  995. 		"pand	%2, %%mm4\n\t"

  996. 		"pand	%2, %%mm5\n\t"

  997. 		"pand	%3, %%mm2\n\t"

  998. 		"pand	%3, %%mm3\n\t"

  999. 		"pand	%3, %%mm6\n\t"

  1000. 		"pand	%3, %%mm7\n\t"

  1001. 		"por	%%mm2, %%mm0\n\t"

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

  1003. 		"por	%%mm6, %%mm4\n\t"

  1004. 		"por	%%mm7, %%mm5\n\t"

  1005. 

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

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

  1008. 		"psllq	$48, %%mm2\n\t"

  1009. 		"psllq	$32, %%mm3\n\t"

  1010. 		"pand	%4, %%mm2\n\t"

  1011. 		"pand	%5, %%mm3\n\t"

  1012. 		"por	%%mm2, %%mm0\n\t"

  1013. 		"psrlq	$16, %%mm1\n\t"

  1014. 		"psrlq	$32, %%mm4\n\t"

  1015. 		"psllq	$16, %%mm5\n\t"

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

  1017. 		"pand	%6, %%mm5\n\t"

  1018. 		"por	%%mm5, %%mm4\n\t"

  1019. 

  1020. 		MOVNTQ"	%%mm0, %0\n\t"

  1021. 		MOVNTQ"	%%mm1, 8%0\n\t"

  1022. 		MOVNTQ"	%%mm4, 16%0"

  1023. 

  1024. 		:"=m"(*d)

  1025. 		:"m"(*s),"m"(mask24l),"m"(mask24h),"m"(mask24hh),"m"(mask24hhh),"m"(mask24hhhh)

  1026. 		:"memory");

  1027. 		d += 24;

  1028. 		s += 8;

  1029. 	}

  1030. 	__asm __volatile(SFENCE:::"memory");

  1031. 	__asm __volatile(EMMS:::"memory");

  1032. #endif

  1033. 	while(s < end)

  1034. 	{

  1035. 		register uint16_t bgr;

  1036. 		bgr = *s++;

  1037. 		*d++ = (bgr&0x1F)<<3;

  1038. 		*d++ = (bgr&0x3E0)>>2;

  1039. 		*d++ = (bgr&0x7C00)>>7;

  1040. 	}

  1041. }

  1042. 

  1043. static inline void RENAME(rgb16to24)(const uint8_t *src, uint8_t *dst, unsigned src_size)

  1044. {

  1045. 	const uint16_t *end;

  1046. #ifdef HAVE_MMX

  1047. 	const uint16_t *mm_end;

  1048. #endif

  1049. 	uint8_t *d = (uint8_t *)dst;

  1050. 	const uint16_t *s = (const uint16_t *)src;

  1051. 	end = s + src_size/2;

  1052. #ifdef HAVE_MMX

  1053. 	__asm __volatile(PREFETCH"	%0"::"m"(*s):"memory");

  1054. 	mm_end = end - 7;

  1055. 	while(s < mm_end)

  1056. 	{

  1057. 	    __asm __volatile(

  1058. 		PREFETCH" 32%1\n\t"

  1059. 		"movq	%1, %%mm0\n\t"

  1060. 		"movq	%1, %%mm1\n\t"

  1061. 		"movq	%1, %%mm2\n\t"

  1062. 		"pand	%2, %%mm0\n\t"

  1063. 		"pand	%3, %%mm1\n\t"

  1064. 		"pand	%4, %%mm2\n\t"

  1065. 		"psllq	$3, %%mm0\n\t"

  1066. 		"psrlq	$3, %%mm1\n\t"

  1067. 		"psrlq	$8, %%mm2\n\t"

  1068. 		"movq	%%mm0, %%mm3\n\t"

  1069. 		"movq	%%mm1, %%mm4\n\t"

  1070. 		"movq	%%mm2, %%mm5\n\t"

  1071. 		"punpcklwd %5, %%mm0\n\t"

  1072. 		"punpcklwd %5, %%mm1\n\t"

  1073. 		"punpcklwd %5, %%mm2\n\t"

  1074. 		"punpckhwd %5, %%mm3\n\t"

  1075. 		"punpckhwd %5, %%mm4\n\t"

  1076. 		"punpckhwd %5, %%mm5\n\t"

  1077. 		"psllq	$8, %%mm1\n\t"

  1078. 		"psllq	$16, %%mm2\n\t"

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

  1080. 		"por	%%mm2, %%mm0\n\t"

  1081. 		"psllq	$8, %%mm4\n\t"

  1082. 		"psllq	$16, %%mm5\n\t"

  1083. 		"por	%%mm4, %%mm3\n\t"

  1084. 		"por	%%mm5, %%mm3\n\t"

  1085. 		

  1086. 		"movq	%%mm0, %%mm6\n\t"

  1087. 		"movq	%%mm3, %%mm7\n\t"

  1088. 

  1089. 		"movq	8%1, %%mm0\n\t"

  1090. 		"movq	8%1, %%mm1\n\t"

  1091. 		"movq	8%1, %%mm2\n\t"

  1092. 		"pand	%2, %%mm0\n\t"

  1093. 		"pand	%3, %%mm1\n\t"

  1094. 		"pand	%4, %%mm2\n\t"

  1095. 		"psllq	$3, %%mm0\n\t"

  1096. 		"psrlq	$3, %%mm1\n\t"

  1097. 		"psrlq	$8, %%mm2\n\t"

  1098. 		"movq	%%mm0, %%mm3\n\t"

  1099. 		"movq	%%mm1, %%mm4\n\t"

  1100. 		"movq	%%mm2, %%mm5\n\t"

  1101. 		"punpcklwd %5, %%mm0\n\t"

  1102. 		"punpcklwd %5, %%mm1\n\t"

  1103. 		"punpcklwd %5, %%mm2\n\t"

  1104. 		"punpckhwd %5, %%mm3\n\t"

  1105. 		"punpckhwd %5, %%mm4\n\t"

  1106. 		"punpckhwd %5, %%mm5\n\t"

  1107. 		"psllq	$8, %%mm1\n\t"

  1108. 		"psllq	$16, %%mm2\n\t"

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

  1110. 		"por	%%mm2, %%mm0\n\t"

  1111. 		"psllq	$8, %%mm4\n\t"

  1112. 		"psllq	$16, %%mm5\n\t"

  1113. 		"por	%%mm4, %%mm3\n\t"

  1114. 		"por	%%mm5, %%mm3\n\t"

  1115. 		:"=m"(*d)

  1116. 		:"m"(*s),"m"(mask16b),"m"(mask16g),"m"(mask16r),"m"(mmx_null)		

  1117. 		:"memory");

  1118. 	    /* Borrowed 32 to 24 */

  1119. 	    __asm __volatile(

  1120. 		"movq	%%mm0, %%mm4\n\t"

  1121. 		"movq	%%mm3, %%mm5\n\t"

  1122. 		"movq	%%mm6, %%mm0\n\t"

  1123. 		"movq	%%mm7, %%mm1\n\t"

  1124. 		

  1125. 		"movq	%%mm4, %%mm6\n\t"

  1126. 		"movq	%%mm5, %%mm7\n\t"

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

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

  1129. 

  1130. 		"psrlq	$8, %%mm2\n\t"

  1131. 		"psrlq	$8, %%mm3\n\t"

  1132. 		"psrlq	$8, %%mm6\n\t"

  1133. 		"psrlq	$8, %%mm7\n\t"

  1134. 		"pand	%2, %%mm0\n\t"

  1135. 		"pand	%2, %%mm1\n\t"

  1136. 		"pand	%2, %%mm4\n\t"

  1137. 		"pand	%2, %%mm5\n\t"

  1138. 		"pand	%3, %%mm2\n\t"

  1139. 		"pand	%3, %%mm3\n\t"

  1140. 		"pand	%3, %%mm6\n\t"

  1141. 		"pand	%3, %%mm7\n\t"

  1142. 		"por	%%mm2, %%mm0\n\t"

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

  1144. 		"por	%%mm6, %%mm4\n\t"

  1145. 		"por	%%mm7, %%mm5\n\t"

  1146. 

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

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

  1149. 		"psllq	$48, %%mm2\n\t"

  1150. 		"psllq	$32, %%mm3\n\t"

  1151. 		"pand	%4, %%mm2\n\t"

  1152. 		"pand	%5, %%mm3\n\t"

  1153. 		"por	%%mm2, %%mm0\n\t"

  1154. 		"psrlq	$16, %%mm1\n\t"

  1155. 		"psrlq	$32, %%mm4\n\t"

  1156. 		"psllq	$16, %%mm5\n\t"

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

  1158. 		"pand	%6, %%mm5\n\t"

  1159. 		"por	%%mm5, %%mm4\n\t"

  1160. 

  1161. 		MOVNTQ"	%%mm0, %0\n\t"

  1162. 		MOVNTQ"	%%mm1, 8%0\n\t"

  1163. 		MOVNTQ"	%%mm4, 16%0"

  1164. 

  1165. 		:"=m"(*d)

  1166. 		:"m"(*s),"m"(mask24l),"m"(mask24h),"m"(mask24hh),"m"(mask24hhh),"m"(mask24hhhh)

  1167. 		:"memory");

  1168. 		d += 24;

  1169. 		s += 8;

  1170. 	}

  1171. 	__asm __volatile(SFENCE:::"memory");

  1172. 	__asm __volatile(EMMS:::"memory");

  1173. #endif

  1174. 	while(s < end)

  1175. 	{

  1176. 		register uint16_t bgr;

  1177. 		bgr = *s++;

  1178. 		*d++ = (bgr&0x1F)<<3;

  1179. 		*d++ = (bgr&0x7E0)>>3;

  1180. 		*d++ = (bgr&0xF800)>>8;

  1181. 	}

  1182. }

  1183. 

  1184. static inline void RENAME(rgb15to32)(const uint8_t *src, uint8_t *dst, unsigned src_size)

  1185. {

  1186. 	const uint16_t *end;

  1187. #ifdef HAVE_MMX

  1188. 	const uint16_t *mm_end;

  1189. #endif

  1190. 	uint8_t *d = (uint8_t *)dst;

  1191. 	const uint16_t *s = (const uint16_t *)src;

  1192. 	end = s + src_size/2;

  1193. #ifdef HAVE_MMX

  1194. 	__asm __volatile(PREFETCH"	%0"::"m"(*s):"memory");

  1195. 	__asm __volatile("pxor	%%mm7,%%mm7\n\t":::"memory");

  1196. 	mm_end = end - 3;

  1197. 	while(s < mm_end)

  1198. 	{

  1199. 	    __asm __volatile(

  1200. 		PREFETCH" 32%1\n\t"

  1201. 		"movq	%1, %%mm0\n\t"

  1202. 		"movq	%1, %%mm1\n\t"

  1203. 		"movq	%1, %%mm2\n\t"

  1204. 		"pand	%2, %%mm0\n\t"

  1205. 		"pand	%3, %%mm1\n\t"

  1206. 		"pand	%4, %%mm2\n\t"

  1207. 		"psllq	$3, %%mm0\n\t"

  1208. 		"psrlq	$2, %%mm1\n\t"

  1209. 		"psrlq	$7, %%mm2\n\t"

  1210. 		"movq	%%mm0, %%mm3\n\t"

  1211. 		"movq	%%mm1, %%mm4\n\t"

  1212. 		"movq	%%mm2, %%mm5\n\t"

  1213. 		"punpcklwd %%mm7, %%mm0\n\t"

  1214. 		"punpcklwd %%mm7, %%mm1\n\t"

  1215. 		"punpcklwd %%mm7, %%mm2\n\t"

  1216. 		"punpckhwd %%mm7, %%mm3\n\t"

  1217. 		"punpckhwd %%mm7, %%mm4\n\t"

  1218. 		"punpckhwd %%mm7, %%mm5\n\t"

  1219. 		"psllq	$8, %%mm1\n\t"

  1220. 		"psllq	$16, %%mm2\n\t"

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

  1222. 		"por	%%mm2, %%mm0\n\t"

  1223. 		"psllq	$8, %%mm4\n\t"

  1224. 		"psllq	$16, %%mm5\n\t"

  1225. 		"por	%%mm4, %%mm3\n\t"

  1226. 		"por	%%mm5, %%mm3\n\t"

  1227. 		MOVNTQ"	%%mm0, %0\n\t"

  1228. 		MOVNTQ"	%%mm3, 8%0\n\t"

  1229. 		:"=m"(*d)

  1230. 		:"m"(*s),"m"(mask15b),"m"(mask15g),"m"(mask15r)

  1231. 		:"memory");

  1232. 		d += 16;

  1233. 		s += 4;

  1234. 	}

  1235. 	__asm __volatile(SFENCE:::"memory");

  1236. 	__asm __volatile(EMMS:::"memory");

  1237. #endif

  1238. 	while(s < end)

  1239. 	{

  1240. #if 0 //slightly slower on athlon

  1241. 		int bgr= *s++;

  1242. 		*((uint32_t*)d)++ = ((bgr&0x1F)<<3) + ((bgr&0x3E0)<<6) + ((bgr&0x7C00)<<9);

  1243. #else

  1244. //FIXME this is very likely wrong for bigendian (and the following converters too)

  1245. 		register uint16_t bgr;

  1246. 		bgr = *s++;

  1247. 		*d++ = (bgr&0x1F)<<3;

  1248. 		*d++ = (bgr&0x3E0)>>2;

  1249. 		*d++ = (bgr&0x7C00)>>7;

  1250. 		*d++ = 0;

  1251. #endif

  1252. 	}

  1253. }

  1254. 

  1255. static inline void RENAME(rgb16to32)(const uint8_t *src, uint8_t *dst, unsigned src_size)

  1256. {

  1257. 	const uint16_t *end;

  1258. #ifdef HAVE_MMX

  1259. 	const uint16_t *mm_end;

  1260. #endif

  1261. 	uint8_t *d = (uint8_t *)dst;

  1262. 	const uint16_t *s = (uint16_t *)src;

  1263. 	end = s + src_size/2;

  1264. #ifdef HAVE_MMX

  1265. 	__asm __volatile(PREFETCH"	%0"::"m"(*s):"memory");

  1266. 	__asm __volatile("pxor	%%mm7,%%mm7\n\t":::"memory");

  1267. 	mm_end = end - 3;

  1268. 	while(s < mm_end)

  1269. 	{

  1270. 	    __asm __volatile(

  1271. 		PREFETCH" 32%1\n\t"

  1272. 		"movq	%1, %%mm0\n\t"

  1273. 		"movq	%1, %%mm1\n\t"

  1274. 		"movq	%1, %%mm2\n\t"

  1275. 		"pand	%2, %%mm0\n\t"

  1276. 		"pand	%3, %%mm1\n\t"

  1277. 		"pand	%4, %%mm2\n\t"

  1278. 		"psllq	$3, %%mm0\n\t"

  1279. 		"psrlq	$3, %%mm1\n\t"

  1280. 		"psrlq	$8, %%mm2\n\t"

  1281. 		"movq	%%mm0, %%mm3\n\t"

  1282. 		"movq	%%mm1, %%mm4\n\t"

  1283. 		"movq	%%mm2, %%mm5\n\t"

  1284. 		"punpcklwd %%mm7, %%mm0\n\t"

  1285. 		"punpcklwd %%mm7, %%mm1\n\t"

  1286. 		"punpcklwd %%mm7, %%mm2\n\t"

  1287. 		"punpckhwd %%mm7, %%mm3\n\t"

  1288. 		"punpckhwd %%mm7, %%mm4\n\t"

  1289. 		"punpckhwd %%mm7, %%mm5\n\t"

  1290. 		"psllq	$8, %%mm1\n\t"

  1291. 		"psllq	$16, %%mm2\n\t"

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

  1293. 		"por	%%mm2, %%mm0\n\t"

  1294. 		"psllq	$8, %%mm4\n\t"

  1295. 		"psllq	$16, %%mm5\n\t"

  1296. 		"por	%%mm4, %%mm3\n\t"

  1297. 		"por	%%mm5, %%mm3\n\t"

  1298. 		MOVNTQ"	%%mm0, %0\n\t"

  1299. 		MOVNTQ"	%%mm3, 8%0\n\t"

  1300. 		:"=m"(*d)

  1301. 		:"m"(*s),"m"(mask16b),"m"(mask16g),"m"(mask16r)

  1302. 		:"memory");

  1303. 		d += 16;

  1304. 		s += 4;

  1305. 	}

  1306. 	__asm __volatile(SFENCE:::"memory");

  1307. 	__asm __volatile(EMMS:::"memory");

  1308. #endif

  1309. 	while(s < end)

  1310. 	{

  1311. 		register uint16_t bgr;

  1312. 		bgr = *s++;

  1313. 		*d++ = (bgr&0x1F)<<3;

  1314. 		*d++ = (bgr&0x7E0)>>3;

  1315. 		*d++ = (bgr&0xF800)>>8;

  1316. 		*d++ = 0;

  1317. 	}

  1318. }

  1319. 

  1320. static inline void RENAME(rgb32tobgr32)(const uint8_t *src, uint8_t *dst, unsigned int src_size)

  1321. {

  1322. #ifdef HAVE_MMX

  1323. /* TODO: unroll this loop */

  1324. 	asm volatile (

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

  1326. 		".balign 16			\n\t"

  1327. 		"1:				\n\t"

  1328. 		PREFETCH" 32(%0, %%eax)		\n\t"

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

  1330. 		"movq %%mm0, %%mm1		\n\t"

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

  1332. 		"pslld $16, %%mm0		\n\t"

  1333. 		"psrld $16, %%mm1		\n\t"

  1334. 		"pand "MANGLE(mask32r)", %%mm0	\n\t"

  1335. 		"pand "MANGLE(mask32g)", %%mm2	\n\t"

  1336. 		"pand "MANGLE(mask32b)", %%mm1	\n\t"

  1337. 		"por %%mm0, %%mm2		\n\t"

  1338. 		"por %%mm1, %%mm2		\n\t"

  1339. 		MOVNTQ" %%mm2, (%1, %%eax)	\n\t"

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

  1341. 		"cmpl %2, %%eax			\n\t"

  1342. 		" jb 1b				\n\t"

  1343. 		:: "r" (src), "r"(dst), "r" (src_size-7)

  1344. 		: "%eax"

  1345. 	);

  1346. 

  1347. 	__asm __volatile(SFENCE:::"memory");

  1348. 	__asm __volatile(EMMS:::"memory");

  1349. #else

  1350. 	unsigned i;

  1351. 	unsigned num_pixels = src_size >> 2;

  1352. 	for(i=0; i<num_pixels; i++)

  1353. 	{

  1354. 		dst[4*i + 0] = src[4*i + 2];

  1355. 		dst[4*i + 1] = src[4*i + 1];

  1356. 		dst[4*i + 2] = src[4*i + 0];

  1357. 	}

  1358. #endif

  1359. }

  1360. 

  1361. static inline void RENAME(rgb24tobgr24)(const uint8_t *src, uint8_t *dst, unsigned int src_size)

  1362. {

  1363. 	unsigned i;

  1364. #ifdef HAVE_MMX

  1365. 	int mmx_size= 23 - src_size;

  1366. 	asm volatile (

  1367. 		"movq "MANGLE(mask24r)", %%mm5	\n\t"

  1368. 		"movq "MANGLE(mask24g)", %%mm6	\n\t"

  1369. 		"movq "MANGLE(mask24b)", %%mm7	\n\t"

  1370. 		".balign 16			\n\t"

  1371. 		"1:				\n\t"

  1372. 		PREFETCH" 32(%1, %%eax)		\n\t"

  1373. 		"movq   (%1, %%eax), %%mm0	\n\t" // BGR BGR BG

  1374. 		"movq   (%1, %%eax), %%mm1	\n\t" // BGR BGR BG

  1375. 		"movq  2(%1, %%eax), %%mm2	\n\t" // R BGR BGR B

  1376. 		"psllq $16, %%mm0		\n\t" // 00 BGR BGR

  1377. 		"pand %%mm5, %%mm0		\n\t"

  1378. 		"pand %%mm6, %%mm1		\n\t"

  1379. 		"pand %%mm7, %%mm2		\n\t"

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

  1381. 		"por %%mm2, %%mm1		\n\t"                

  1382. 		"movq  6(%1, %%eax), %%mm0	\n\t" // BGR BGR BG

  1383. 		MOVNTQ" %%mm1,   (%2, %%eax)	\n\t" // RGB RGB RG

  1384. 		"movq  8(%1, %%eax), %%mm1	\n\t" // R BGR BGR B

  1385. 		"movq 10(%1, %%eax), %%mm2	\n\t" // GR BGR BGR

  1386. 		"pand %%mm7, %%mm0		\n\t"

  1387. 		"pand %%mm5, %%mm1		\n\t"

  1388. 		"pand %%mm6, %%mm2		\n\t"

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

  1390. 		"por %%mm2, %%mm1		\n\t"                

  1391. 		"movq 14(%1, %%eax), %%mm0	\n\t" // R BGR BGR B

  1392. 		MOVNTQ" %%mm1,  8(%2, %%eax)	\n\t" // B RGB RGB R

  1393. 		"movq 16(%1, %%eax), %%mm1	\n\t" // GR BGR BGR

  1394. 		"movq 18(%1, %%eax), %%mm2	\n\t" // BGR BGR BG

  1395. 		"pand %%mm6, %%mm0		\n\t"

  1396. 		"pand %%mm7, %%mm1		\n\t"

  1397. 		"pand %%mm5, %%mm2		\n\t"

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

  1399. 		"por %%mm2, %%mm1		\n\t"                

  1400. 		MOVNTQ" %%mm1, 16(%2, %%eax)	\n\t"

  1401. 		"addl $24, %%eax		\n\t"

  1402. 		" js 1b				\n\t"

  1403. 		: "+a" (mmx_size)

  1404. 		: "r" (src-mmx_size), "r"(dst-mmx_size)

  1405. 	);

  1406. 

  1407. 	__asm __volatile(SFENCE:::"memory");

  1408. 	__asm __volatile(EMMS:::"memory");

  1409. 

  1410. 	if(mmx_size==23) return; //finihsed, was multiple of 8

  1411. 

  1412. 	src+= src_size;

  1413. 	dst+= src_size;

  1414. 	src_size= 23-mmx_size;

  1415. 	src-= src_size;

  1416. 	dst-= src_size;

  1417. #endif

  1418. 	for(i=0; i<src_size; i+=3)

  1419. 	{

  1420. 		register uint8_t x;

  1421. 		x          = src[i + 2];

  1422. 		dst[i + 1] = src[i + 1];

  1423. 		dst[i + 2] = src[i + 0];

  1424. 		dst[i + 0] = x;

  1425. 	}

  1426. }

  1427. 

  1428. static inline void RENAME(yuvPlanartoyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,

  1429. 	unsigned int width, unsigned int height,

  1430. 	int lumStride, int chromStride, int dstStride, int vertLumPerChroma)

  1431. {

  1432. 	unsigned y;

  1433. 	const unsigned chromWidth= width>>1;

  1434. 	for(y=0; y<height; y++)

  1435. 	{

  1436. #ifdef HAVE_MMX

  1437. //FIXME handle 2 lines a once (fewer prefetch, reuse some chrom, but very likely limited by mem anyway)

  1438. 		asm volatile(

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

  1440. 			".balign 16			\n\t"

  1441. 			"1:				\n\t"

  1442. 			PREFETCH" 32(%1, %%eax, 2)	\n\t"

  1443. 			PREFETCH" 32(%2, %%eax)		\n\t"

  1444. 			PREFETCH" 32(%3, %%eax)		\n\t"

  1445. 			"movq (%2, %%eax), %%mm0	\n\t" // U(0)

  1446. 			"movq %%mm0, %%mm2		\n\t" // U(0)

  1447. 			"movq (%3, %%eax), %%mm1	\n\t" // V(0)

  1448. 			"punpcklbw %%mm1, %%mm0		\n\t" // UVUV UVUV(0)

  1449. 			"punpckhbw %%mm1, %%mm2		\n\t" // UVUV UVUV(8)

  1450. 

  1451. 			"movq (%1, %%eax,2), %%mm3	\n\t" // Y(0)

  1452. 			"movq 8(%1, %%eax,2), %%mm5	\n\t" // Y(8)

  1453. 			"movq %%mm3, %%mm4		\n\t" // Y(0)

  1454. 			"movq %%mm5, %%mm6		\n\t" // Y(8)

  1455. 			"punpcklbw %%mm0, %%mm3		\n\t" // YUYV YUYV(0)

  1456. 			"punpckhbw %%mm0, %%mm4		\n\t" // YUYV YUYV(4)

  1457. 			"punpcklbw %%mm2, %%mm5		\n\t" // YUYV YUYV(8)

  1458. 			"punpckhbw %%mm2, %%mm6		\n\t" // YUYV YUYV(12)

  1459. 

  1460. 			MOVNTQ" %%mm3, (%0, %%eax, 4)	\n\t"

  1461. 			MOVNTQ" %%mm4, 8(%0, %%eax, 4)	\n\t"

  1462. 			MOVNTQ" %%mm5, 16(%0, %%eax, 4)	\n\t"

  1463. 			MOVNTQ" %%mm6, 24(%0, %%eax, 4)	\n\t"

  1464. 

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

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

  1467. 			" jb 1b				\n\t"

  1468. 			::"r"(dst), "r"(ysrc), "r"(usrc), "r"(vsrc), "g" (chromWidth)

  1469. 			: "%eax"

  1470. 		);

  1471. #else

  1472. 

  1473. #if defined ARCH_ALPHA && defined HAVE_MVI

  1474. #define pl2yuy2(n)					\

  1475. 	y1 = yc[n];					\

  1476. 	y2 = yc2[n];					\

  1477. 	u = uc[n];					\

  1478. 	v = vc[n];					\

  1479. 	asm("unpkbw %1, %0" : "=r"(y1) : "r"(y1));	\

  1480. 	asm("unpkbw %1, %0" : "=r"(y2) : "r"(y2));	\

  1481. 	asm("unpkbl %1, %0" : "=r"(u) : "r"(u));	\

  1482. 	asm("unpkbl %1, %0" : "=r"(v) : "r"(v));	\

  1483. 	yuv1 = (u << 8) + (v << 24);			\

  1484. 	yuv2 = yuv1 + y2;				\

  1485. 	yuv1 += y1;					\

  1486. 	qdst[n] = yuv1;					\

  1487. 	qdst2[n] = yuv2;

  1488. 

  1489. 		int i;

  1490. 		uint64_t *qdst = (uint64_t *) dst;

  1491. 		uint64_t *qdst2 = (uint64_t *) (dst + dstStride);

  1492. 		const uint32_t *yc = (uint32_t *) ysrc;

  1493. 		const uint32_t *yc2 = (uint32_t *) (ysrc + lumStride);

  1494. 		const uint16_t *uc = (uint16_t*) usrc, *vc = (uint16_t*) vsrc;

  1495. 		for(i = 0; i < chromWidth; i += 8){

  1496. 			uint64_t y1, y2, yuv1, yuv2;

  1497. 			uint64_t u, v;

  1498. 			/* Prefetch */

  1499. 			asm("ldq $31,64(%0)" :: "r"(yc));

  1500. 			asm("ldq $31,64(%0)" :: "r"(yc2));

  1501. 			asm("ldq $31,64(%0)" :: "r"(uc));

  1502. 			asm("ldq $31,64(%0)" :: "r"(vc));

  1503. 

  1504. 			pl2yuy2(0);

  1505. 			pl2yuy2(1);

  1506. 			pl2yuy2(2);

  1507. 			pl2yuy2(3);

  1508. 

  1509. 			yc += 4;

  1510. 			yc2 += 4;

  1511. 			uc += 4;

  1512. 			vc += 4;

  1513. 			qdst += 4;

  1514. 			qdst2 += 4;

  1515. 		}

  1516. 		y++;

  1517. 		ysrc += lumStride;

  1518. 		dst += dstStride;

  1519. 

  1520. #elif __WORDSIZE >= 64

  1521. 		int i;

  1522. 		uint64_t *ldst = (uint64_t *) dst;

  1523. 		const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;

  1524. 		for(i = 0; i < chromWidth; i += 2){

  1525. 			uint64_t k, l;

  1526. 			k = yc[0] + (uc[0] << 8) +

  1527. 			    (yc[1] << 16) + (vc[0] << 24);

  1528. 			l = yc[2] + (uc[1] << 8) +

  1529. 			    (yc[3] << 16) + (vc[1] << 24);

  1530. 			*ldst++ = k + (l << 32);

  1531. 			yc += 4;

  1532. 			uc += 2;

  1533. 			vc += 2;

  1534. 		}

  1535. 

  1536. #else

  1537. 		int i, *idst = (int32_t *) dst;

  1538. 		const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;

  1539. 		for(i = 0; i < chromWidth; i++){

  1540. 			*idst++ = yc[0] + (uc[0] << 8) +

  1541. 			    (yc[1] << 16) + (vc[0] << 24);

  1542. 			yc += 2;

  1543. 			uc++;

  1544. 			vc++;

  1545. 		}

  1546. #endif

  1547. #endif

  1548. 		if((y&(vertLumPerChroma-1))==(vertLumPerChroma-1) )

  1549. 		{

  1550. 			usrc += chromStride;

  1551. 			vsrc += chromStride;

  1552. 		}

  1553. 		ysrc += lumStride;

  1554. 		dst += dstStride;

  1555. 	}

  1556. #ifdef HAVE_MMX

  1557. asm(    EMMS" \n\t"

  1558.         SFENCE" \n\t"

  1559.         :::"memory");

  1560. #endif

  1561. }

  1562. 

  1563. /**

  1564.  *

  1565.  * height should be a multiple of 2 and width should be a multiple of 16 (if this is a

  1566.  * problem for anyone then tell me, and ill fix it)

  1567.  */

  1568. static inline void RENAME(yv12toyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,

  1569. 	unsigned int width, unsigned int height,

  1570. 	int lumStride, int chromStride, int dstStride)

  1571. {

  1572. 	//FIXME interpolate chroma

  1573. 	RENAME(yuvPlanartoyuy2)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 2);

  1574. }

  1575. 

  1576. /**

  1577.  *

  1578.  * width should be a multiple of 16

  1579.  */

  1580. static inline void RENAME(yuv422ptoyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,

  1581. 	unsigned int width, unsigned int height,

  1582. 	int lumStride, int chromStride, int dstStride)

  1583. {

  1584. 	RENAME(yuvPlanartoyuy2)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 1);

  1585. }

  1586. 

  1587. /**

  1588.  *

  1589.  * height should be a multiple of 2 and width should be a multiple of 16 (if this is a

  1590.  * problem for anyone then tell me, and ill fix it)

  1591.  */

  1592. static inline void RENAME(yuy2toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,

  1593. 	unsigned int width, unsigned int height,

  1594. 	int lumStride, int chromStride, int srcStride)

  1595. {

  1596. 	unsigned y;

  1597. 	const unsigned chromWidth= width>>1;

  1598. 	for(y=0; y<height; y+=2)

  1599. 	{

  1600. #ifdef HAVE_MMX

  1601. 		asm volatile(

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

  1603. 			"pcmpeqw %%mm7, %%mm7		\n\t"

  1604. 			"psrlw $8, %%mm7		\n\t" // FF,00,FF,00...

  1605. 			".balign 16			\n\t"

  1606. 			"1:				\n\t"

  1607. 			PREFETCH" 64(%0, %%eax, 4)	\n\t"

  1608. 			"movq (%0, %%eax, 4), %%mm0	\n\t" // YUYV YUYV(0)

  1609. 			"movq 8(%0, %%eax, 4), %%mm1	\n\t" // YUYV YUYV(4)

  1610. 			"movq %%mm0, %%mm2		\n\t" // YUYV YUYV(0)

  1611. 			"movq %%mm1, %%mm3		\n\t" // YUYV YUYV(4)

  1612. 			"psrlw $8, %%mm0		\n\t" // U0V0 U0V0(0)

  1613. 			"psrlw $8, %%mm1		\n\t" // U0V0 U0V0(4)

  1614. 			"pand %%mm7, %%mm2		\n\t" // Y0Y0 Y0Y0(0)

  1615. 			"pand %%mm7, %%mm3		\n\t" // Y0Y0 Y0Y0(4)

  1616. 			"packuswb %%mm1, %%mm0		\n\t" // UVUV UVUV(0)

  1617. 			"packuswb %%mm3, %%mm2		\n\t" // YYYY YYYY(0)

  1618. 

  1619. 			MOVNTQ" %%mm2, (%1, %%eax, 2)	\n\t"

  1620. 

  1621. 			"movq 16(%0, %%eax, 4), %%mm1	\n\t" // YUYV YUYV(8)

  1622. 			"movq 24(%0, %%eax, 4), %%mm2	\n\t" // YUYV YUYV(12)

  1623. 			"movq %%mm1, %%mm3		\n\t" // YUYV YUYV(8)

  1624. 			"movq %%mm2, %%mm4		\n\t" // YUYV YUYV(12)

  1625. 			"psrlw $8, %%mm1		\n\t" // U0V0 U0V0(8)

  1626. 			"psrlw $8, %%mm2		\n\t" // U0V0 U0V0(12)

  1627. 			"pand %%mm7, %%mm3		\n\t" // Y0Y0 Y0Y0(8)

  1628. 			"pand %%mm7, %%mm4		\n\t" // Y0Y0 Y0Y0(12)

  1629. 			"packuswb %%mm2, %%mm1		\n\t" // UVUV UVUV(8)

  1630. 			"packuswb %%mm4, %%mm3		\n\t" // YYYY YYYY(8)

  1631. 

  1632. 			MOVNTQ" %%mm3, 8(%1, %%eax, 2)	\n\t"

  1633. 

  1634. 			"movq %%mm0, %%mm2		\n\t" // UVUV UVUV(0)

  1635. 			"movq %%mm1, %%mm3		\n\t" // UVUV UVUV(8)

  1636. 			"psrlw $8, %%mm0		\n\t" // V0V0 V0V0(0)

  1637. 			"psrlw $8, %%mm1		\n\t" // V0V0 V0V0(8)

  1638. 			"pand %%mm7, %%mm2		\n\t" // U0U0 U0U0(0)

  1639. 			"pand %%mm7, %%mm3		\n\t" // U0U0 U0U0(8)

  1640. 			"packuswb %%mm1, %%mm0		\n\t" // VVVV VVVV(0)

  1641. 			"packuswb %%mm3, %%mm2		\n\t" // UUUU UUUU(0)

  1642. 

  1643. 			MOVNTQ" %%mm0, (%3, %%eax)	\n\t"

  1644. 			MOVNTQ" %%mm2, (%2, %%eax)	\n\t"

  1645. 

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

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

  1648. 			" jb 1b				\n\t"

  1649. 			::"r"(src), "r"(ydst), "r"(udst), "r"(vdst), "g" (chromWidth)

  1650. 			: "memory", "%eax"

  1651. 		);

  1652. 

  1653. 		ydst += lumStride;

  1654. 		src  += srcStride;

  1655. 

  1656. 		asm volatile(

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

  1658. 			".balign 16			\n\t"

  1659. 			"1:				\n\t"

  1660. 			PREFETCH" 64(%0, %%eax, 4)	\n\t"

  1661. 			"movq (%0, %%eax, 4), %%mm0	\n\t" // YUYV YUYV(0)

  1662. 			"movq 8(%0, %%eax, 4), %%mm1	\n\t" // YUYV YUYV(4)

  1663. 			"movq 16(%0, %%eax, 4), %%mm2	\n\t" // YUYV YUYV(8)

  1664. 			"movq 24(%0, %%eax, 4), %%mm3	\n\t" // YUYV YUYV(12)

  1665. 			"pand %%mm7, %%mm0		\n\t" // Y0Y0 Y0Y0(0)

  1666. 			"pand %%mm7, %%mm1		\n\t" // Y0Y0 Y0Y0(4)

  1667. 			"pand %%mm7, %%mm2		\n\t" // Y0Y0 Y0Y0(8)

  1668. 			"pand %%mm7, %%mm3		\n\t" // Y0Y0 Y0Y0(12)

  1669. 			"packuswb %%mm1, %%mm0		\n\t" // YYYY YYYY(0)

  1670. 			"packuswb %%mm3, %%mm2		\n\t" // YYYY YYYY(8)

  1671. 

  1672. 			MOVNTQ" %%mm0, (%1, %%eax, 2)	\n\t"

  1673. 			MOVNTQ" %%mm2, 8(%1, %%eax, 2)	\n\t"

  1674. 

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

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

  1677. 			" jb 1b				\n\t"

  1678. 

  1679. 			::"r"(src), "r"(ydst), "r"(udst), "r"(vdst), "g" (chromWidth)

  1680. 			: "memory", "%eax"

  1681. 		);

  1682. #else

  1683. 		unsigned i;

  1684. 		for(i=0; i<chromWidth; i++)

  1685. 		{

  1686. 			ydst[2*i+0] 	= src[4*i+0];

  1687. 			udst[i] 	= src[4*i+1];

  1688. 			ydst[2*i+1] 	= src[4*i+2];

  1689. 			vdst[i] 	= src[4*i+3];

  1690. 		}

  1691. 		ydst += lumStride;

  1692. 		src  += srcStride;

  1693. 

  1694. 		for(i=0; i<chromWidth; i++)

  1695. 		{

  1696. 			ydst[2*i+0] 	= src[4*i+0];

  1697. 			ydst[2*i+1] 	= src[4*i+2];

  1698. 		}

  1699. #endif

  1700. 		udst += chromStride;

  1701. 		vdst += chromStride;

  1702. 		ydst += lumStride;

  1703. 		src  += srcStride;

  1704. 	}

  1705. #ifdef HAVE_MMX

  1706. asm volatile(   EMMS" \n\t"

  1707.         	SFENCE" \n\t"

  1708.         	:::"memory");

  1709. #endif

  1710. }

  1711. 

  1712. static inline void RENAME(yvu9toyv12)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc,

  1713. 	uint8_t *ydst, uint8_t *udst, uint8_t *vdst,

  1714. 	unsigned int width, unsigned int height, int lumStride, int chromStride)

  1715. {

  1716. 	/* Y Plane */

  1717. 	memcpy(ydst, ysrc, width*height);

  1718. 

  1719. 	/* XXX: implement upscaling for U,V */

  1720. }

  1721. 

  1722. static inline void RENAME(planar2x)(const uint8_t *src, uint8_t *dst, int srcWidth, int srcHeight, int srcStride, int dstStride)

  1723. {

  1724. 	int x,y;

  1725. 	

  1726. 	dst[0]= src[0];

  1727.         

  1728. 	// first line

  1729. 	for(x=0; x<srcWidth-1; x++){

  1730. 		dst[2*x+1]= (3*src[x] +   src[x+1])>>2;

  1731. 		dst[2*x+2]= (  src[x] + 3*src[x+1])>>2;

  1732. 	}

  1733. 	dst[2*srcWidth-1]= src[srcWidth-1];

  1734. 	

  1735.         dst+= dstStride;

  1736. 

  1737. 	for(y=1; y<srcHeight; y++){

  1738. #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)

  1739. 		const int mmxSize= srcWidth&~15;

  1740. 		asm volatile(

  1741. 			"movl %4, %%eax			\n\t"

  1742. 			"1:				\n\t"

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

  1744. 			"movq (%1, %%eax), %%mm1	\n\t"

  1745. 			"movq 1(%0, %%eax), %%mm2	\n\t"

  1746. 			"movq 1(%1, %%eax), %%mm3	\n\t"

  1747. 			"movq -1(%0, %%eax), %%mm4	\n\t"

  1748. 			"movq -1(%1, %%eax), %%mm5	\n\t"

  1749. 			PAVGB" %%mm0, %%mm5		\n\t"

  1750. 			PAVGB" %%mm0, %%mm3		\n\t"

  1751. 			PAVGB" %%mm0, %%mm5		\n\t"

  1752. 			PAVGB" %%mm0, %%mm3		\n\t"

  1753. 			PAVGB" %%mm1, %%mm4		\n\t"

  1754. 			PAVGB" %%mm1, %%mm2		\n\t"

  1755. 			PAVGB" %%mm1, %%mm4		\n\t"

  1756. 			PAVGB" %%mm1, %%mm2		\n\t"

  1757. 			"movq %%mm5, %%mm7		\n\t"

  1758. 			"movq %%mm4, %%mm6		\n\t"

  1759. 			"punpcklbw %%mm3, %%mm5		\n\t"

  1760. 			"punpckhbw %%mm3, %%mm7		\n\t"

  1761. 			"punpcklbw %%mm2, %%mm4		\n\t"

  1762. 			"punpckhbw %%mm2, %%mm6		\n\t"

  1763. #if 1

  1764. 			MOVNTQ" %%mm5, (%2, %%eax, 2)	\n\t"

  1765. 			MOVNTQ" %%mm7, 8(%2, %%eax, 2)	\n\t"

  1766. 			MOVNTQ" %%mm4, (%3, %%eax, 2)	\n\t"

  1767. 			MOVNTQ" %%mm6, 8(%3, %%eax, 2)	\n\t"

  1768. #else

  1769. 			"movq %%mm5, (%2, %%eax, 2)	\n\t"

  1770. 			"movq %%mm7, 8(%2, %%eax, 2)	\n\t"

  1771. 			"movq %%mm4, (%3, %%eax, 2)	\n\t"

  1772. 			"movq %%mm6, 8(%3, %%eax, 2)	\n\t"

  1773. #endif

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

  1775. 			" js 1b				\n\t"

  1776. 			:: "r" (src + mmxSize  ), "r" (src + srcStride + mmxSize  ),

  1777. 			   "r" (dst + mmxSize*2), "r" (dst + dstStride + mmxSize*2),

  1778. 			   "g" (-mmxSize)

  1779. 			: "%eax"

  1780. 

  1781. 		);

  1782. #else

  1783. 		const int mmxSize=1;

  1784. #endif

  1785. 		dst[0        ]= (3*src[0] +   src[srcStride])>>2;

  1786. 		dst[dstStride]= (  src[0] + 3*src[srcStride])>>2;

  1787. 

  1788. 		for(x=mmxSize-1; x<srcWidth-1; x++){

  1789. 			dst[2*x          +1]= (3*src[x+0] +   src[x+srcStride+1])>>2;

  1790. 			dst[2*x+dstStride+2]= (  src[x+0] + 3*src[x+srcStride+1])>>2;

  1791. 			dst[2*x+dstStride+1]= (  src[x+1] + 3*src[x+srcStride  ])>>2;

  1792. 			dst[2*x          +2]= (3*src[x+1] +   src[x+srcStride  ])>>2;

  1793. 		}

  1794. 		dst[srcWidth*2 -1            ]= (3*src[srcWidth-1] +   src[srcWidth-1 + srcStride])>>2;

  1795. 		dst[srcWidth*2 -1 + dstStride]= (  src[srcWidth-1] + 3*src[srcWidth-1 + srcStride])>>2;

  1796. 

  1797. 		dst+=dstStride*2;

  1798. 		src+=srcStride;

  1799. 	}

  1800. 	

  1801. 	// last line

  1802. #if 1

  1803. 	dst[0]= src[0];

  1804.         

  1805. 	for(x=0; x<srcWidth-1; x++){

  1806. 		dst[2*x+1]= (3*src[x] +   src[x+1])>>2;

  1807. 		dst[2*x+2]= (  src[x] + 3*src[x+1])>>2;

  1808. 	}

  1809. 	dst[2*srcWidth-1]= src[srcWidth-1];

  1810. #else

  1811. 	for(x=0; x<srcWidth; x++){

  1812. 		dst[2*x+0]=

  1813. 		dst[2*x+1]= src[x];

  1814. 	}

  1815. #endif

  1816. 

  1817. #ifdef HAVE_MMX

  1818. asm volatile(   EMMS" \n\t"

  1819.         	SFENCE" \n\t"

  1820.         	:::"memory");

  1821. #endif

  1822. }

  1823. 

  1824. /**

  1825.  *

  1826.  * height should be a multiple of 2 and width should be a multiple of 16 (if this is a

  1827.  * problem for anyone then tell me, and ill fix it)

  1828.  * chrominance data is only taken from every secound line others are ignored FIXME write HQ version

  1829.  */

  1830. static inline void RENAME(uyvytoyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,

  1831. 	unsigned int width, unsigned int height,

  1832. 	int lumStride, int chromStride, int srcStride)

  1833. {

  1834. 	unsigned y;

  1835. 	const unsigned chromWidth= width>>1;

  1836. 	for(y=0; y<height; y+=2)

  1837. 	{

  1838. #ifdef HAVE_MMX

  1839. 		asm volatile(

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

  1841. 			"pcmpeqw %%mm7, %%mm7		\n\t"

  1842. 			"psrlw $8, %%mm7		\n\t" // FF,00,FF,00...

  1843. 			".balign 16			\n\t"

  1844. 			"1:				\n\t"

  1845. 			PREFETCH" 64(%0, %%eax, 4)	\n\t"

  1846. 			"movq (%0, %%eax, 4), %%mm0	\n\t" // UYVY UYVY(0)

  1847. 			"movq 8(%0, %%eax, 4), %%mm1	\n\t" // UYVY UYVY(4)

  1848. 			"movq %%mm0, %%mm2		\n\t" // UYVY UYVY(0)

  1849. 			"movq %%mm1, %%mm3		\n\t" // UYVY UYVY(4)

  1850. 			"pand %%mm7, %%mm0		\n\t" // U0V0 U0V0(0)

  1851. 			"pand %%mm7, %%mm1		\n\t" // U0V0 U0V0(4)

  1852. 			"psrlw $8, %%mm2		\n\t" // Y0Y0 Y0Y0(0)

  1853. 			"psrlw $8, %%mm3		\n\t" // Y0Y0 Y0Y0(4)

  1854. 			"packuswb %%mm1, %%mm0		\n\t" // UVUV UVUV(0)

  1855. 			"packuswb %%mm3, %%mm2		\n\t" // YYYY YYYY(0)

  1856. 

  1857. 			MOVNTQ" %%mm2, (%1, %%eax, 2)	\n\t"

  1858. 

  1859. 			"movq 16(%0, %%eax, 4), %%mm1	\n\t" // UYVY UYVY(8)

  1860. 			"movq 24(%0, %%eax, 4), %%mm2	\n\t" // UYVY UYVY(12)

  1861. 			"movq %%mm1, %%mm3		\n\t" // UYVY UYVY(8)

  1862. 			"movq %%mm2, %%mm4		\n\t" // UYVY UYVY(12)

  1863. 			"pand %%mm7, %%mm1		\n\t" // U0V0 U0V0(8)

  1864. 			"pand %%mm7, %%mm2		\n\t" // U0V0 U0V0(12)

  1865. 			"psrlw $8, %%mm3		\n\t" // Y0Y0 Y0Y0(8)

  1866. 			"psrlw $8, %%mm4		\n\t" // Y0Y0 Y0Y0(12)

  1867. 			"packuswb %%mm2, %%mm1		\n\t" // UVUV UVUV(8)

  1868. 			"packuswb %%mm4, %%mm3		\n\t" // YYYY YYYY(8)

  1869. 

  1870. 			MOVNTQ" %%mm3, 8(%1, %%eax, 2)	\n\t"

  1871. 

  1872. 			"movq %%mm0, %%mm2		\n\t" // UVUV UVUV(0)

  1873. 			"movq %%mm1, %%mm3		\n\t" // UVUV UVUV(8)

  1874. 			"psrlw $8, %%mm0		\n\t" // V0V0 V0V0(0)

  1875. 			"psrlw $8, %%mm1		\n\t" // V0V0 V0V0(8)

  1876. 			"pand %%mm7, %%mm2		\n\t" // U0U0 U0U0(0)

  1877. 			"pand %%mm7, %%mm3		\n\t" // U0U0 U0U0(8)

  1878. 			"packuswb %%mm1, %%mm0		\n\t" // VVVV VVVV(0)

  1879. 			"packuswb %%mm3, %%mm2		\n\t" // UUUU UUUU(0)

  1880. 

  1881. 			MOVNTQ" %%mm0, (%3, %%eax)	\n\t"

  1882. 			MOVNTQ" %%mm2, (%2, %%eax)	\n\t"

  1883. 

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

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

  1886. 			" jb 1b				\n\t"

  1887. 			::"r"(src), "r"(ydst), "r"(udst), "r"(vdst), "g" (chromWidth)

  1888. 			: "memory", "%eax"

  1889. 		);

  1890. 

  1891. 		ydst += lumStride;

  1892. 		src  += srcStride;

  1893. 

  1894. 		asm volatile(

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

  1896. 			".balign 16			\n\t"

  1897. 			"1:				\n\t"

  1898. 			PREFETCH" 64(%0, %%eax, 4)	\n\t"

  1899. 			"movq (%0, %%eax, 4), %%mm0	\n\t" // YUYV YUYV(0)

  1900. 			"movq 8(%0, %%eax, 4), %%mm1	\n\t" // YUYV YUYV(4)

  1901. 			"movq 16(%0, %%eax, 4), %%mm2	\n\t" // YUYV YUYV(8)

  1902. 			"movq 24(%0, %%eax, 4), %%mm3	\n\t" // YUYV YUYV(12)

  1903. 			"psrlw $8, %%mm0		\n\t" // Y0Y0 Y0Y0(0)

  1904. 			"psrlw $8, %%mm1		\n\t" // Y0Y0 Y0Y0(4)

  1905. 			"psrlw $8, %%mm2		\n\t" // Y0Y0 Y0Y0(8)

  1906. 			"psrlw $8, %%mm3		\n\t" // Y0Y0 Y0Y0(12)

  1907. 			"packuswb %%mm1, %%mm0		\n\t" // YYYY YYYY(0)

  1908. 			"packuswb %%mm3, %%mm2		\n\t" // YYYY YYYY(8)

  1909. 

  1910. 			MOVNTQ" %%mm0, (%1, %%eax, 2)	\n\t"

  1911. 			MOVNTQ" %%mm2, 8(%1, %%eax, 2)	\n\t"

  1912. 

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

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

  1915. 			" jb 1b				\n\t"

  1916. 

  1917. 			::"r"(src), "r"(ydst), "r"(udst), "r"(vdst), "g" (chromWidth)

  1918. 			: "memory", "%eax"

  1919. 		);

  1920. #else

  1921. 		unsigned i;

  1922. 		for(i=0; i<chromWidth; i++)

  1923. 		{

  1924. 			udst[i] 	= src[4*i+0];

  1925. 			ydst[2*i+0] 	= src[4*i+1];

  1926. 			vdst[i] 	= src[4*i+2];

  1927. 			ydst[2*i+1] 	= src[4*i+3];

  1928. 		}

  1929. 		ydst += lumStride;

  1930. 		src  += srcStride;

  1931. 

  1932. 		for(i=0; i<chromWidth; i++)

  1933. 		{

  1934. 			ydst[2*i+0] 	= src[4*i+1];

  1935. 			ydst[2*i+1] 	= src[4*i+3];

  1936. 		}

  1937. #endif

  1938. 		udst += chromStride;

  1939. 		vdst += chromStride;

  1940. 		ydst += lumStride;

  1941. 		src  += srcStride;

  1942. 	}

  1943. #ifdef HAVE_MMX

  1944. asm volatile(   EMMS" \n\t"

  1945.         	SFENCE" \n\t"

  1946.         	:::"memory");

  1947. #endif

  1948. }

  1949. 

  1950. /**

  1951.  *

  1952.  * height should be a multiple of 2 and width should be a multiple of 2 (if this is a

  1953.  * problem for anyone then tell me, and ill fix it)

  1954.  * chrominance data is only taken from every secound line others are ignored in the C version FIXME write HQ version

  1955.  */

  1956. static inline void RENAME(rgb24toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,

  1957. 	unsigned int width, unsigned int height,

  1958. 	int lumStride, int chromStride, int srcStride)

  1959. {

  1960. 	unsigned y;

  1961. 	const unsigned chromWidth= width>>1;

  1962. #ifdef HAVE_MMX

  1963. 	for(y=0; y<height-2; y+=2)

  1964. 	{

  1965. 		unsigned i;

  1966. 		for(i=0; i<2; i++)

  1967. 		{

  1968. 			asm volatile(

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

  1970. 				"movq "MANGLE(bgr2YCoeff)", %%mm6		\n\t"

  1971. 				"movq "MANGLE(w1111)", %%mm5		\n\t"

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

  1973. 				"leal (%%eax, %%eax, 2), %%ebx	\n\t"

  1974. 				".balign 16			\n\t"

  1975. 				"1:				\n\t"

  1976. 				PREFETCH" 64(%0, %%ebx)		\n\t"

  1977. 				"movd (%0, %%ebx), %%mm0	\n\t"

  1978. 				"movd 3(%0, %%ebx), %%mm1	\n\t"

  1979. 				"punpcklbw %%mm7, %%mm0		\n\t"

  1980. 				"punpcklbw %%mm7, %%mm1		\n\t"

  1981. 				"movd 6(%0, %%ebx), %%mm2	\n\t"

  1982. 				"movd 9(%0, %%ebx), %%mm3	\n\t"

  1983. 				"punpcklbw %%mm7, %%mm2		\n\t"

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

  1985. 				"pmaddwd %%mm6, %%mm0		\n\t"

  1986. 				"pmaddwd %%mm6, %%mm1		\n\t"

  1987. 				"pmaddwd %%mm6, %%mm2		\n\t"

  1988. 				"pmaddwd %%mm6, %%mm3		\n\t"

  1989. #ifndef FAST_BGR2YV12

  1990. 				"psrad $8, %%mm0		\n\t"

  1991. 				"psrad $8, %%mm1		\n\t"

  1992. 				"psrad $8, %%mm2		\n\t"

  1993. 				"psrad $8, %%mm3		\n\t"

  1994. #endif

  1995. 				"packssdw %%mm1, %%mm0		\n\t"

  1996. 				"packssdw %%mm3, %%mm2		\n\t"

  1997. 				"pmaddwd %%mm5, %%mm0		\n\t"

  1998. 				"pmaddwd %%mm5, %%mm2		\n\t"

  1999. 				"packssdw %%mm2, %%mm0		\n\t"

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

  2001. 

  2002. 				"movd 12(%0, %%ebx), %%mm4	\n\t"

  2003. 				"movd 15(%0, %%ebx), %%mm1	\n\t"

  2004. 				"punpcklbw %%mm7, %%mm4		\n\t"

  2005. 				"punpcklbw %%mm7, %%mm1		\n\t"

  2006. 				"movd 18(%0, %%ebx), %%mm2	\n\t"

  2007. 				"movd 21(%0, %%ebx), %%mm3	\n\t"

  2008. 				"punpcklbw %%mm7, %%mm2		\n\t"

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

  2010. 				"pmaddwd %%mm6, %%mm4		\n\t"

  2011. 				"pmaddwd %%mm6, %%mm1		\n\t"

  2012. 				"pmaddwd %%mm6, %%mm2		\n\t"

  2013. 				"pmaddwd %%mm6, %%mm3		\n\t"

  2014. #ifndef FAST_BGR2YV12

  2015. 				"psrad $8, %%mm4		\n\t"

  2016. 				"psrad $8, %%mm1		\n\t"

  2017. 				"psrad $8, %%mm2		\n\t"

  2018. 				"psrad $8, %%mm3		\n\t"

  2019. #endif

  2020. 				"packssdw %%mm1, %%mm4		\n\t"

  2021. 				"packssdw %%mm3, %%mm2		\n\t"

  2022. 				"pmaddwd %%mm5, %%mm4		\n\t"

  2023. 				"pmaddwd %%mm5, %%mm2		\n\t"

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

  2025. 				"packssdw %%mm2, %%mm4		\n\t"

  2026. 				"psraw $7, %%mm4		\n\t"

  2027. 

  2028. 				"packuswb %%mm4, %%mm0		\n\t"

  2029. 				"paddusb "MANGLE(bgr2YOffset)", %%mm0	\n\t"

  2030. 

  2031. 				MOVNTQ" %%mm0, (%1, %%eax)	\n\t"

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

  2033. 				" js 1b				\n\t"

  2034. 				: : "r" (src+width*3), "r" (ydst+width), "g" (-width)

  2035. 				: "%eax", "%ebx"

  2036. 			);

  2037. 			ydst += lumStride;

  2038. 			src  += srcStride;

  2039. 		}

  2040. 		src -= srcStride*2;

  2041. 		asm volatile(

  2042. 			"movl %4, %%eax			\n\t"

  2043. 			"movq "MANGLE(w1111)", %%mm5		\n\t"

  2044. 			"movq "MANGLE(bgr2UCoeff)", %%mm6		\n\t"

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

  2046. 			"leal (%%eax, %%eax, 2), %%ebx	\n\t"

  2047. 			"addl %%ebx, %%ebx		\n\t"

  2048. 			".balign 16			\n\t"

  2049. 			"1:				\n\t"

  2050. 			PREFETCH" 64(%0, %%ebx)		\n\t"

  2051. 			PREFETCH" 64(%1, %%ebx)		\n\t"

  2052. #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)

  2053. 			"movq (%0, %%ebx), %%mm0	\n\t"

  2054. 			"movq (%1, %%ebx), %%mm1	\n\t"

  2055. 			"movq 6(%0, %%ebx), %%mm2	\n\t"

  2056. 			"movq 6(%1, %%ebx), %%mm3	\n\t"

  2057. 			PAVGB" %%mm1, %%mm0		\n\t"

  2058. 			PAVGB" %%mm3, %%mm2		\n\t"

  2059. 			"movq %%mm0, %%mm1		\n\t"

  2060. 			"movq %%mm2, %%mm3		\n\t"

  2061. 			"psrlq $24, %%mm0		\n\t"

  2062. 			"psrlq $24, %%mm2		\n\t"

  2063. 			PAVGB" %%mm1, %%mm0		\n\t"

  2064. 			PAVGB" %%mm3, %%mm2		\n\t"

  2065. 			"punpcklbw %%mm7, %%mm0		\n\t"

  2066. 			"punpcklbw %%mm7, %%mm2		\n\t"

  2067. #else

  2068. 			"movd (%0, %%ebx), %%mm0	\n\t"

  2069. 			"movd (%1, %%ebx), %%mm1	\n\t"

  2070. 			"movd 3(%0, %%ebx), %%mm2	\n\t"

  2071. 			"movd 3(%1, %%ebx), %%mm3	\n\t"

  2072. 			"punpcklbw %%mm7, %%mm0		\n\t"

  2073. 			"punpcklbw %%mm7, %%mm1		\n\t"

  2074. 			"punpcklbw %%mm7, %%mm2		\n\t"

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

  2076. 			"paddw %%mm1, %%mm0		\n\t"

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

  2078. 			"paddw %%mm2, %%mm0		\n\t"

  2079. 			"movd 6(%0, %%ebx), %%mm4	\n\t"

  2080. 			"movd 6(%1, %%ebx), %%mm1	\n\t"

  2081. 			"movd 9(%0, %%ebx), %%mm2	\n\t"

  2082. 			"movd 9(%1, %%ebx), %%mm3	\n\t"

  2083. 			"punpcklbw %%mm7, %%mm4		\n\t"

  2084. 			"punpcklbw %%mm7, %%mm1		\n\t"

  2085. 			"punpcklbw %%mm7, %%mm2		\n\t"

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

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

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

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

  2090. 			"psrlw $2, %%mm0		\n\t"

  2091. 			"psrlw $2, %%mm2		\n\t"

  2092. #endif

  2093. 			"movq "MANGLE(bgr2VCoeff)", %%mm1		\n\t"

  2094. 			"movq "MANGLE(bgr2VCoeff)", %%mm3		\n\t"

  2095. 

  2096. 			"pmaddwd %%mm0, %%mm1		\n\t"

  2097. 			"pmaddwd %%mm2, %%mm3		\n\t"

  2098. 			"pmaddwd %%mm6, %%mm0		\n\t"

  2099. 			"pmaddwd %%mm6, %%mm2		\n\t"

  2100. #ifndef FAST_BGR2YV12

  2101. 			"psrad $8, %%mm0		\n\t"

  2102. 			"psrad $8, %%mm1		\n\t"

  2103. 			"psrad $8, %%mm2		\n\t"

  2104. 			"psrad $8, %%mm3		\n\t"

  2105. #endif

  2106. 			"packssdw %%mm2, %%mm0		\n\t"

  2107. 			"packssdw %%mm3, %%mm1		\n\t"

  2108. 			"pmaddwd %%mm5, %%mm0		\n\t"

  2109. 			"pmaddwd %%mm5, %%mm1		\n\t"

  2110. 			"packssdw %%mm1, %%mm0		\n\t" // V1 V0 U1 U0

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

  2112. 

  2113. #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)

  2114. 			"movq 12(%0, %%ebx), %%mm4	\n\t"

  2115. 			"movq 12(%1, %%ebx), %%mm1	\n\t"

  2116. 			"movq 18(%0, %%ebx), %%mm2	\n\t"

  2117. 			"movq 18(%1, %%ebx), %%mm3	\n\t"

  2118. 			PAVGB" %%mm1, %%mm4		\n\t"

  2119. 			PAVGB" %%mm3, %%mm2		\n\t"

  2120. 			"movq %%mm4, %%mm1		\n\t"

  2121. 			"movq %%mm2, %%mm3		\n\t"

  2122. 			"psrlq $24, %%mm4		\n\t"

  2123. 			"psrlq $24, %%mm2		\n\t"

  2124. 			PAVGB" %%mm1, %%mm4		\n\t"

  2125. 			PAVGB" %%mm3, %%mm2		\n\t"

  2126. 			"punpcklbw %%mm7, %%mm4		\n\t"

  2127. 			"punpcklbw %%mm7, %%mm2		\n\t"

  2128. #else

  2129. 			"movd 12(%0, %%ebx), %%mm4	\n\t"

  2130. 			"movd 12(%1, %%ebx), %%mm1	\n\t"

  2131. 			"movd 15(%0, %%ebx), %%mm2	\n\t"

  2132. 			"movd 15(%1, %%ebx), %%mm3	\n\t"

  2133. 			"punpcklbw %%mm7, %%mm4		\n\t"

  2134. 			"punpcklbw %%mm7, %%mm1		\n\t"

  2135. 			"punpcklbw %%mm7, %%mm2		\n\t"

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

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

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

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

  2140. 			"movd 18(%0, %%ebx), %%mm5	\n\t"

  2141. 			"movd 18(%1, %%ebx), %%mm1	\n\t"

  2142. 			"movd 21(%0, %%ebx), %%mm2	\n\t"

  2143. 			"movd 21(%1, %%ebx), %%mm3	\n\t"

  2144. 			"punpcklbw %%mm7, %%mm5		\n\t"

  2145. 			"punpcklbw %%mm7, %%mm1		\n\t"

  2146. 			"punpcklbw %%mm7, %%mm2		\n\t"

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

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

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

  2150. 			"paddw %%mm5, %%mm2		\n\t"

  2151. 			"movq "MANGLE(w1111)", %%mm5		\n\t"

  2152. 			"psrlw $2, %%mm4		\n\t"

  2153. 			"psrlw $2, %%mm2		\n\t"

  2154. #endif

  2155. 			"movq "MANGLE(bgr2VCoeff)", %%mm1		\n\t"

  2156. 			"movq "MANGLE(bgr2VCoeff)", %%mm3		\n\t"

  2157. 

  2158. 			"pmaddwd %%mm4, %%mm1		\n\t"

  2159. 			"pmaddwd %%mm2, %%mm3		\n\t"

  2160. 			"pmaddwd %%mm6, %%mm4		\n\t"

  2161. 			"pmaddwd %%mm6, %%mm2		\n\t"

  2162. #ifndef FAST_BGR2YV12

  2163. 			"psrad $8, %%mm4		\n\t"

  2164. 			"psrad $8, %%mm1		\n\t"

  2165. 			"psrad $8, %%mm2		\n\t"

  2166. 			"psrad $8, %%mm3		\n\t"

  2167. #endif

  2168. 			"packssdw %%mm2, %%mm4		\n\t"

  2169. 			"packssdw %%mm3, %%mm1		\n\t"

  2170. 			"pmaddwd %%mm5, %%mm4		\n\t"

  2171. 			"pmaddwd %%mm5, %%mm1		\n\t"

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

  2173. 			"packssdw %%mm1, %%mm4		\n\t" // V3 V2 U3 U2

  2174. 			"psraw $7, %%mm4		\n\t"

  2175. 

  2176. 			"movq %%mm0, %%mm1		\n\t"

  2177. 			"punpckldq %%mm4, %%mm0		\n\t"

  2178. 			"punpckhdq %%mm4, %%mm1		\n\t"

  2179. 			"packsswb %%mm1, %%mm0		\n\t"

  2180. 			"paddb "MANGLE(bgr2UVOffset)", %%mm0	\n\t"

  2181. 

  2182. 			"movd %%mm0, (%2, %%eax)	\n\t"

  2183. 			"punpckhdq %%mm0, %%mm0		\n\t"

  2184. 			"movd %%mm0, (%3, %%eax)	\n\t"

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

  2186. 			" js 1b				\n\t"

  2187. 			: : "r" (src+width*6), "r" (src+srcStride+width*6), "r" (udst+width), "r" (vdst+width), "g" (-width)

  2188. 			: "%eax", "%ebx"

  2189. 		);

  2190. 

  2191. 		udst += chromStride;

  2192. 		vdst += chromStride;

  2193. 		src  += srcStride*2;

  2194. 	}

  2195. 

  2196. 	asm volatile(   EMMS" \n\t"

  2197. 			SFENCE" \n\t"

  2198. 			:::"memory");

  2199. #else

  2200. 	y=0;

  2201. #endif

  2202. 	for(; y<height; y+=2)

  2203. 	{

  2204. 		unsigned i;

  2205. 		for(i=0; i<chromWidth; i++)

  2206. 		{

  2207. 			unsigned int b= src[6*i+0];

  2208. 			unsigned int g= src[6*i+1];

  2209. 			unsigned int r= src[6*i+2];

  2210. 

  2211. 			unsigned int Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;

  2212. 			unsigned int V  =  ((RV*r + GV*g + BV*b)>>RGB2YUV_SHIFT) + 128;

  2213. 			unsigned int U  =  ((RU*r + GU*g + BU*b)>>RGB2YUV_SHIFT) + 128;

  2214. 

  2215. 			udst[i] 	= U;

  2216. 			vdst[i] 	= V;

  2217. 			ydst[2*i] 	= Y;

  2218. 

  2219. 			b= src[6*i+3];

  2220. 			g= src[6*i+4];

  2221. 			r= src[6*i+5];

  2222. 

  2223. 			Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;

  2224. 			ydst[2*i+1] 	= Y;

  2225. 		}

  2226. 		ydst += lumStride;

  2227. 		src  += srcStride;

  2228. 

  2229. 		for(i=0; i<chromWidth; i++)

  2230. 		{

  2231. 			unsigned int b= src[6*i+0];

  2232. 			unsigned int g= src[6*i+1];

  2233. 			unsigned int r= src[6*i+2];

  2234. 

  2235. 			unsigned int Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;

  2236. 

  2237. 			ydst[2*i] 	= Y;

  2238. 

  2239. 			b= src[6*i+3];

  2240. 			g= src[6*i+4];

  2241. 			r= src[6*i+5];

  2242. 

  2243. 			Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;

  2244. 			ydst[2*i+1] 	= Y;

  2245. 		}

  2246. 		udst += chromStride;

  2247. 		vdst += chromStride;

  2248. 		ydst += lumStride;

  2249. 		src  += srcStride;

  2250. 	}

  2251. }

  2252. 

  2253. void RENAME(interleaveBytes)(uint8_t *src1, uint8_t *src2, uint8_t *dest,

  2254. 			    unsigned width, unsigned height, int src1Stride,

  2255. 			    int src2Stride, int dstStride){

  2256. 	unsigned h;

  2257. 

  2258. 	for(h=0; h < height; h++)

  2259. 	{

  2260. 		unsigned w;

  2261. 

  2262. #ifdef HAVE_MMX

  2263. #ifdef HAVE_SSE2

  2264. 		asm(

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

  2266. 			"1:				\n\t"

  2267. 			PREFETCH" 64(%1, %%eax)		\n\t"

  2268. 			PREFETCH" 64(%2, %%eax)		\n\t"

  2269. 			"movdqa (%1, %%eax), %%xmm0	\n\t"

  2270. 			"movdqa (%1, %%eax), %%xmm1	\n\t"

  2271. 			"movdqa (%2, %%eax), %%xmm2	\n\t"

  2272. 			"punpcklbw %%xmm2, %%xmm0	\n\t"

  2273. 			"punpckhbw %%xmm2, %%xmm1	\n\t"

  2274. 			"movntdq %%xmm0, (%0, %%eax, 2)	\n\t"

  2275. 			"movntdq %%xmm1, 16(%0, %%eax, 2)\n\t"

  2276. 			"addl $16, %%eax			\n\t"

  2277. 			"cmpl %3, %%eax			\n\t"

  2278. 			" jb 1b				\n\t"

  2279. 			::"r"(dest), "r"(src1), "r"(src2), "r" (width-15)

  2280. 			: "memory", "%eax"

  2281. 		);

  2282. #else

  2283. 		asm(

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

  2285. 			"1:				\n\t"

  2286. 			PREFETCH" 64(%1, %%eax)		\n\t"

  2287. 			PREFETCH" 64(%2, %%eax)		\n\t"

  2288. 			"movq (%1, %%eax), %%mm0	\n\t"

  2289. 			"movq 8(%1, %%eax), %%mm2	\n\t"

  2290. 			"movq %%mm0, %%mm1		\n\t"

  2291. 			"movq %%mm2, %%mm3		\n\t"

  2292. 			"movq (%2, %%eax), %%mm4	\n\t"

  2293. 			"movq 8(%2, %%eax), %%mm5	\n\t"

  2294. 			"punpcklbw %%mm4, %%mm0		\n\t"

  2295. 			"punpckhbw %%mm4, %%mm1		\n\t"

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

  2297. 			"punpckhbw %%mm5, %%mm3		\n\t"

  2298. 			MOVNTQ" %%mm0, (%0, %%eax, 2)	\n\t"

  2299. 			MOVNTQ" %%mm1, 8(%0, %%eax, 2)	\n\t"

  2300. 			MOVNTQ" %%mm2, 16(%0, %%eax, 2)	\n\t"

  2301. 			MOVNTQ" %%mm3, 24(%0, %%eax, 2)	\n\t"

  2302. 			"addl $16, %%eax			\n\t"

  2303. 			"cmpl %3, %%eax			\n\t"

  2304. 			" jb 1b				\n\t"

  2305. 			::"r"(dest), "r"(src1), "r"(src2), "r" (width-15)

  2306. 			: "memory", "%eax"

  2307. 		);

  2308. #endif

  2309. 		for(w= (width&(~15)); w < width; w++)

  2310. 		{

  2311. 			dest[2*w+0] = src1[w];

  2312. 			dest[2*w+1] = src2[w];

  2313. 		}

  2314. #else

  2315. 		for(w=0; w < width; w++)

  2316. 		{

  2317. 			dest[2*w+0] = src1[w];

  2318. 			dest[2*w+1] = src2[w];

  2319. 		}

  2320. #endif

  2321. 		dest += dstStride;

  2322.                 src1 += src1Stride;

  2323.                 src2 += src2Stride;

  2324. 	}

  2325. #ifdef HAVE_MMX

  2326. 	asm(

  2327. 		EMMS" \n\t"

  2328. 		SFENCE" \n\t"

  2329. 		::: "memory"

  2330. 		);

  2331. #endif

  2332. }

  2333. 

  2334. static inline void RENAME(vu9_to_vu12)(const uint8_t *src1, const uint8_t *src2,

  2335. 			uint8_t *dst1, uint8_t *dst2,

  2336. 			unsigned width, unsigned height,

  2337. 			int srcStride1, int srcStride2,

  2338. 			int dstStride1, int dstStride2)

  2339. {

  2340.     unsigned int y,x,h;

  2341.     int w;

  2342.     w=width/2; h=height/2;

  2343. #ifdef HAVE_MMX

  2344.     asm volatile(

  2345. 	PREFETCH" %0\n\t"

  2346. 	PREFETCH" %1\n\t"

  2347. 	::"m"(*(src1+srcStride1)),"m"(*(src2+srcStride2)):"memory");

  2348. #endif

  2349.     for(y=0;y<h;y++){

  2350. 	const uint8_t* s1=src1+srcStride1*(y>>1);

  2351. 	uint8_t* d=dst1+dstStride1*y;

  2352. 	x=0;

  2353. #ifdef HAVE_MMX

  2354. 	for(;x<w-31;x+=32)

  2355. 	{

  2356. 	    asm volatile(

  2357. 		PREFETCH" 32%1\n\t"

  2358. 	        "movq	%1, %%mm0\n\t"

  2359. 	        "movq	8%1, %%mm2\n\t"

  2360. 	        "movq	16%1, %%mm4\n\t"

  2361. 	        "movq	24%1, %%mm6\n\t"

  2362. 	        "movq	%%mm0, %%mm1\n\t"

  2363. 	        "movq	%%mm2, %%mm3\n\t"

  2364. 	        "movq	%%mm4, %%mm5\n\t"

  2365. 	        "movq	%%mm6, %%mm7\n\t"

  2366. 		"punpcklbw %%mm0, %%mm0\n\t"

  2367. 		"punpckhbw %%mm1, %%mm1\n\t"

  2368. 		"punpcklbw %%mm2, %%mm2\n\t"

  2369. 		"punpckhbw %%mm3, %%mm3\n\t"

  2370. 		"punpcklbw %%mm4, %%mm4\n\t"

  2371. 		"punpckhbw %%mm5, %%mm5\n\t"

  2372. 		"punpcklbw %%mm6, %%mm6\n\t"

  2373. 		"punpckhbw %%mm7, %%mm7\n\t"

  2374. 		MOVNTQ"	%%mm0, %0\n\t"

  2375. 		MOVNTQ"	%%mm1, 8%0\n\t"

  2376. 		MOVNTQ"	%%mm2, 16%0\n\t"

  2377. 		MOVNTQ"	%%mm3, 24%0\n\t"

  2378. 		MOVNTQ"	%%mm4, 32%0\n\t"

  2379. 		MOVNTQ"	%%mm5, 40%0\n\t"

  2380. 		MOVNTQ"	%%mm6, 48%0\n\t"

  2381. 		MOVNTQ"	%%mm7, 56%0"

  2382. 		:"=m"(d[2*x])

  2383. 		:"m"(s1[x])

  2384. 		:"memory");

  2385. 	}

  2386. #endif

  2387. 	for(;x<w;x++) d[2*x]=d[2*x+1]=s1[x];

  2388.     }

  2389.     for(y=0;y<h;y++){

  2390. 	const uint8_t* s2=src2+srcStride2*(y>>1);

  2391. 	uint8_t* d=dst2+dstStride2*y;

  2392. 	x=0;

  2393. #ifdef HAVE_MMX

  2394. 	for(;x<w-31;x+=32)

  2395. 	{

  2396. 	    asm volatile(

  2397. 		PREFETCH" 32%1\n\t"

  2398. 	        "movq	%1, %%mm0\n\t"

  2399. 	        "movq	8%1, %%mm2\n\t"

  2400. 	        "movq	16%1, %%mm4\n\t"

  2401. 	        "movq	24%1, %%mm6\n\t"

  2402. 	        "movq	%%mm0, %%mm1\n\t"

  2403. 	        "movq	%%mm2, %%mm3\n\t"

  2404. 	        "movq	%%mm4, %%mm5\n\t"

  2405. 	        "movq	%%mm6, %%mm7\n\t"

  2406. 		"punpcklbw %%mm0, %%mm0\n\t"

  2407. 		"punpckhbw %%mm1, %%mm1\n\t"

  2408. 		"punpcklbw %%mm2, %%mm2\n\t"

  2409. 		"punpckhbw %%mm3, %%mm3\n\t"

  2410. 		"punpcklbw %%mm4, %%mm4\n\t"

  2411. 		"punpckhbw %%mm5, %%mm5\n\t"

  2412. 		"punpcklbw %%mm6, %%mm6\n\t"

  2413. 		"punpckhbw %%mm7, %%mm7\n\t"

  2414. 		MOVNTQ"	%%mm0, %0\n\t"

  2415. 		MOVNTQ"	%%mm1, 8%0\n\t"

  2416. 		MOVNTQ"	%%mm2, 16%0\n\t"

  2417. 		MOVNTQ"	%%mm3, 24%0\n\t"

  2418. 		MOVNTQ"	%%mm4, 32%0\n\t"

  2419. 		MOVNTQ"	%%mm5, 40%0\n\t"

  2420. 		MOVNTQ"	%%mm6, 48%0\n\t"

  2421. 		MOVNTQ"	%%mm7, 56%0"

  2422. 		:"=m"(d[2*x])

  2423. 		:"m"(s2[x])

  2424. 		:"memory");

  2425. 	}

  2426. #endif

  2427. 	for(;x<w;x++) d[2*x]=d[2*x+1]=s2[x];

  2428.     }

  2429. #ifdef HAVE_MMX

  2430. 	asm(

  2431. 		EMMS" \n\t"

  2432. 		SFENCE" \n\t"

  2433. 		::: "memory"

  2434. 		);

  2435. #endif

  2436. }

  2437. 

  2438. static inline void RENAME(yvu9_to_yuy2)(const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,

  2439. 			uint8_t *dst,

  2440. 			unsigned width, unsigned height,

  2441. 			int srcStride1, int srcStride2,

  2442. 			int srcStride3, int dstStride)

  2443. {

  2444.     unsigned y,x,w,h;

  2445.     w=width/2; h=height;

  2446.     for(y=0;y<h;y++){

  2447. 	const uint8_t* yp=src1+srcStride1*y;

  2448. 	const uint8_t* up=src2+srcStride2*(y>>2);

  2449. 	const uint8_t* vp=src3+srcStride3*(y>>2);

  2450. 	uint8_t* d=dst+dstStride*y;

  2451. 	x=0;

  2452. #ifdef HAVE_MMX

  2453. 	for(;x<w-7;x+=8)

  2454. 	{

  2455. 	    asm volatile(

  2456. 		PREFETCH" 32(%1, %0)\n\t"

  2457. 		PREFETCH" 32(%2, %0)\n\t"

  2458. 		PREFETCH" 32(%3, %0)\n\t"

  2459. 		"movq	(%1, %0, 4), %%mm0\n\t"       /* Y0Y1Y2Y3Y4Y5Y6Y7 */

  2460. 		"movq	(%2, %0), %%mm1\n\t"       /* U0U1U2U3U4U5U6U7 */

  2461. 		"movq	(%3, %0), %%mm2\n\t"	     /* V0V1V2V3V4V5V6V7 */

  2462. 		"movq	%%mm0, %%mm3\n\t"    /* Y0Y1Y2Y3Y4Y5Y6Y7 */

  2463. 		"movq	%%mm1, %%mm4\n\t"    /* U0U1U2U3U4U5U6U7 */

  2464. 		"movq	%%mm2, %%mm5\n\t"    /* V0V1V2V3V4V5V6V7 */

  2465. 		"punpcklbw %%mm1, %%mm1\n\t" /* U0U0 U1U1 U2U2 U3U3 */

  2466. 		"punpcklbw %%mm2, %%mm2\n\t" /* V0V0 V1V1 V2V2 V3V3 */

  2467. 		"punpckhbw %%mm4, %%mm4\n\t" /* U4U4 U5U5 U6U6 U7U7 */

  2468. 		"punpckhbw %%mm5, %%mm5\n\t" /* V4V4 V5V5 V6V6 V7V7 */

  2469. 

  2470. 		"movq	%%mm1, %%mm6\n\t"

  2471. 		"punpcklbw %%mm2, %%mm1\n\t" /* U0V0 U0V0 U1V1 U1V1*/

  2472. 		"punpcklbw %%mm1, %%mm0\n\t" /* Y0U0 Y1V0 Y2U0 Y3V0*/

  2473. 		"punpckhbw %%mm1, %%mm3\n\t" /* Y4U1 Y5V1 Y6U1 Y7V1*/

  2474. 		MOVNTQ"	%%mm0, (%4, %0, 8)\n\t"

  2475. 		MOVNTQ"	%%mm3, 8(%4, %0, 8)\n\t"

  2476. 		

  2477. 		"punpckhbw %%mm2, %%mm6\n\t" /* U2V2 U2V2 U3V3 U3V3*/

  2478. 		"movq	8(%1, %0, 4), %%mm0\n\t"

  2479. 		"movq	%%mm0, %%mm3\n\t"

  2480. 		"punpcklbw %%mm6, %%mm0\n\t" /* Y U2 Y V2 Y U2 Y V2*/

  2481. 		"punpckhbw %%mm6, %%mm3\n\t" /* Y U3 Y V3 Y U3 Y V3*/

  2482. 		MOVNTQ"	%%mm0, 16(%4, %0, 8)\n\t"

  2483. 		MOVNTQ"	%%mm3, 24(%4, %0, 8)\n\t"

  2484. 

  2485. 		"movq	%%mm4, %%mm6\n\t"

  2486. 		"movq	16(%1, %0, 4), %%mm0\n\t"

  2487. 		"movq	%%mm0, %%mm3\n\t"

  2488. 		"punpcklbw %%mm5, %%mm4\n\t"

  2489. 		"punpcklbw %%mm4, %%mm0\n\t" /* Y U4 Y V4 Y U4 Y V4*/

  2490. 		"punpckhbw %%mm4, %%mm3\n\t" /* Y U5 Y V5 Y U5 Y V5*/

  2491. 		MOVNTQ"	%%mm0, 32(%4, %0, 8)\n\t"

  2492. 		MOVNTQ"	%%mm3, 40(%4, %0, 8)\n\t"

  2493. 		

  2494. 		"punpckhbw %%mm5, %%mm6\n\t"

  2495. 		"movq	24(%1, %0, 4), %%mm0\n\t"

  2496. 		"movq	%%mm0, %%mm3\n\t"

  2497. 		"punpcklbw %%mm6, %%mm0\n\t" /* Y U6 Y V6 Y U6 Y V6*/

  2498. 		"punpckhbw %%mm6, %%mm3\n\t" /* Y U7 Y V7 Y U7 Y V7*/

  2499. 		MOVNTQ"	%%mm0, 48(%4, %0, 8)\n\t"

  2500. 		MOVNTQ"	%%mm3, 56(%4, %0, 8)\n\t"

  2501. 

  2502. 		: "+r" (x)

  2503.                 : "r"(yp), "r" (up), "r"(vp), "r"(d)

  2504. 		:"memory");

  2505. 	}

  2506. #endif

  2507. 	for(; x<w; x++)

  2508. 	{

  2509. 	    const int x2= x<<2;

  2510. 	    d[8*x+0]=yp[x2];

  2511. 	    d[8*x+1]=up[x];

  2512. 	    d[8*x+2]=yp[x2+1];

  2513. 	    d[8*x+3]=vp[x];

  2514. 	    d[8*x+4]=yp[x2+2];

  2515. 	    d[8*x+5]=up[x];

  2516. 	    d[8*x+6]=yp[x2+3];

  2517. 	    d[8*x+7]=vp[x];

  2518. 	}

  2519.     }

  2520. #ifdef HAVE_MMX

  2521. 	asm(

  2522. 		EMMS" \n\t"

  2523. 		SFENCE" \n\t"

  2524. 		::: "memory"

  2525. 		);

  2526. #endif

  2527. }