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

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

多媒体

开发平台：

MultiPlatform

rgb2rgb_template.c：源码内容
  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.  */
  11. #include <stddef.h>
  12. #include <inttypes.h> /* for __WORDSIZE */
  14. #ifndef __WORDSIZE
  15. // #warning You have misconfigured system and probably will lose performance!
  16. #define __WORDSIZE MP_WORDSIZE
  17. #endif
  19. #undef PREFETCH
  20. #undef MOVNTQ
  21. #undef EMMS
  22. #undef SFENCE
  23. #undef MMREG_SIZE
  24. #undef PREFETCHW
  25. #undef PAVGB
  27. #ifdef HAVE_SSE2
  28. #define MMREG_SIZE 16
  29. #else
  30. #define MMREG_SIZE 8
  31. #endif
  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
  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
  53. #ifdef HAVE_MMX2
  54. #define MOVNTQ "movntq"
  55. #define SFENCE "sfence"
  56. #else
  57. #define MOVNTQ "movq"
  58. #define SFENCE "/nop"
  59. #endif
  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%1nt"
  78. "movd %1, %%mm0nt"
  79. "punpckldq 3%1, %%mm0nt"
  80. "movd 6%1, %%mm1nt"
  81. "punpckldq 9%1, %%mm1nt"
  82. "movd 12%1, %%mm2nt"
  83. "punpckldq 15%1, %%mm2nt"
  84. "movd 18%1, %%mm3nt"
  85. "punpckldq 21%1, %%mm3nt"
  86. "pand %%mm7, %%mm0nt"
  87. "pand %%mm7, %%mm1nt"
  88. "pand %%mm7, %%mm2nt"
  89. "pand %%mm7, %%mm3nt"
  90. MOVNTQ" %%mm0, %0nt"
  91. MOVNTQ" %%mm1, 8%0nt"
  92. MOVNTQ" %%mm2, 16%0nt"
  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. }
  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%1nt"
  128. "movq %1, %%mm0nt"
  129. "movq 8%1, %%mm1nt"
  130. "movq 16%1, %%mm4nt"
  131. "movq 24%1, %%mm5nt"
  132. "movq %%mm0, %%mm2nt"
  133. "movq %%mm1, %%mm3nt"
  134. "movq %%mm4, %%mm6nt"
  135. "movq %%mm5, %%mm7nt"
  136. "psrlq $8, %%mm2nt"
  137. "psrlq $8, %%mm3nt"
  138. "psrlq $8, %%mm6nt"
  139. "psrlq $8, %%mm7nt"
  140. "pand %2, %%mm0nt"
  141. "pand %2, %%mm1nt"
  142. "pand %2, %%mm4nt"
  143. "pand %2, %%mm5nt"
  144. "pand %3, %%mm2nt"
  145. "pand %3, %%mm3nt"
  146. "pand %3, %%mm6nt"
  147. "pand %3, %%mm7nt"
  148. "por %%mm2, %%mm0nt"
  149. "por %%mm3, %%mm1nt"
  150. "por %%mm6, %%mm4nt"
  151. "por %%mm7, %%mm5nt"
  153. "movq %%mm1, %%mm2nt"
  154. "movq %%mm4, %%mm3nt"
  155. "psllq $48, %%mm2nt"
  156. "psllq $32, %%mm3nt"
  157. "pand %4, %%mm2nt"
  158. "pand %5, %%mm3nt"
  159. "por %%mm2, %%mm0nt"
  160. "psrlq $16, %%mm1nt"
  161. "psrlq $32, %%mm4nt"
  162. "psllq $16, %%mm5nt"
  163. "por %%mm3, %%mm1nt"
  164. "pand %6, %%mm5nt"
  165. "por %%mm5, %%mm4nt"
  167. MOVNTQ" %%mm0, %0nt"
  168. MOVNTQ" %%mm1, 8%0nt"
  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. }
  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%1nt"
  210. "movq %1, %%mm0nt"
  211. "movq 8%1, %%mm2nt"
  212. "movq %%mm0, %%mm1nt"
  213. "movq %%mm2, %%mm3nt"
  214. "pand %%mm4, %%mm0nt"
  215. "pand %%mm4, %%mm2nt"
  216. "paddw %%mm1, %%mm0nt"
  217. "paddw %%mm3, %%mm2nt"
  218. MOVNTQ" %%mm0, %0nt"
  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. }
  244. static inline void RENAME(rgb16to15)(const uint8_t *src,uint8_t *dst,unsigned src_size)
  245. {
  246.   register const uint8_t* s=src;
  247.   register uint8_t* d=dst;
  248.   register const uint8_t *end;
  249.   const uint8_t *mm_end;
  250.   end = s + src_size;
  251. #ifdef HAVE_MMX
  252.   __asm __volatile(PREFETCH" %0"::"m"(*s));
  253.   __asm __volatile("movq %0, %%mm7"::"m"(mask15rg));
  254.   __asm __volatile("movq %0, %%mm6"::"m"(mask15b));
  255.   mm_end = end - 15;
  256.   while(s<mm_end)
  257.   {
  258. __asm __volatile(
  259. PREFETCH" 32%1nt"
  260. "movq %1, %%mm0nt"
  261. "movq 8%1, %%mm2nt"
  262. "movq %%mm0, %%mm1nt"
  263. "movq %%mm2, %%mm3nt"
  264. "psrlq $1, %%mm0nt"
  265. "psrlq $1, %%mm2nt"
  266. "pand %%mm7, %%mm0nt"
  267. "pand %%mm7, %%mm2nt"
  268. "pand %%mm6, %%mm1nt"
  269. "pand %%mm6, %%mm3nt"
  270. "por %%mm1, %%mm0nt"
  271. "por %%mm3, %%mm2nt"
  272. MOVNTQ" %%mm0, %0nt"
  273. MOVNTQ" %%mm2, 8%0"
  274. :"=m"(*d)
  275. :"m"(*s)
  276. );
  277. d+=16;
  278. s+=16;
  279.   }
  280.   __asm __volatile(SFENCE:::"memory");
  281.   __asm __volatile(EMMS:::"memory");
  282. #endif
  283.     mm_end = end - 3;
  284.     while(s < mm_end)
  285.     {
  286. register uint32_t x= *((uint32_t *)s);
  287. *((uint32_t *)d) = ((x>>1)&0x7FE07FE0) | (x&0x001F001F);
  288. s+=4;
  289. d+=4;
  290.     }
  291.     if(s < end)
  292.     {
  293. register uint16_t x= *((uint16_t *)s);
  294. *((uint16_t *)d) = ((x>>1)&0x7FE0) | (x&0x001F);
  295. s+=2;
  296. d+=2;
  297.     }
  298. }
  300. static inline void RENAME(rgb32to16)(const uint8_t *src, uint8_t *dst, unsigned src_size)
  301. {
  302. const uint8_t *s = src;
  303. const uint8_t *end;
  304. #ifdef HAVE_MMX
  305. const uint8_t *mm_end;
  306. #endif
  307. uint16_t *d = (uint16_t *)dst;
  308. end = s + src_size;
  309. #ifdef HAVE_MMX
  310. mm_end = end - 15;
  311. #if 1 //is faster only if multiplies are reasonable fast (FIXME figure out on which cpus this is faster, on Athlon its slightly faster)
  312. asm volatile(
  313. "movq %3, %%mm5 nt"
  314. "movq %4, %%mm6 nt"
  315. "movq %5, %%mm7 nt"
  316. ".balign 16 nt"
  317. "1: nt"
  318. PREFETCH" 32(%1) nt"
  319. "movd (%1), %%mm0 nt"
  320. "movd 4(%1), %%mm3 nt"
  321. "punpckldq 8(%1), %%mm0 nt"
  322. "punpckldq 12(%1), %%mm3 nt"
  323. "movq %%mm0, %%mm1 nt"
  324. "movq %%mm3, %%mm4 nt"
  325. "pand %%mm6, %%mm0 nt"
  326. "pand %%mm6, %%mm3 nt"
  327. "pmaddwd %%mm7, %%mm0 nt"
  328. "pmaddwd %%mm7, %%mm3 nt"
  329. "pand %%mm5, %%mm1 nt"
  330. "pand %%mm5, %%mm4 nt"
  331. "por %%mm1, %%mm0 nt"
  332. "por %%mm4, %%mm3 nt"
  333. "psrld $5, %%mm0 nt"
  334. "pslld $11, %%mm3 nt"
  335. "por %%mm3, %%mm0 nt"
  336. MOVNTQ" %%mm0, (%0) nt"
  337. "addl $16, %1 nt"
  338. "addl $8, %0 nt"
  339. "cmpl %2, %1 nt"
  340. " jb 1b nt"
  341. : "+r" (d), "+r"(s)
  342. : "r" (mm_end), "m" (mask3216g), "m" (mask3216br), "m" (mul3216)
  343. );
  344. #else
  345. __asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
  346. __asm __volatile(
  347.     "movq %0, %%mm7nt"
  348.     "movq %1, %%mm6nt"
  349.     ::"m"(red_16mask),"m"(green_16mask));
  350. while(s < mm_end)
  351. {
  352.     __asm __volatile(
  353. PREFETCH" 32%1nt"
  354. "movd %1, %%mm0nt"
  355. "movd 4%1, %%mm3nt"
  356. "punpckldq 8%1, %%mm0nt"
  357. "punpckldq 12%1, %%mm3nt"
  358. "movq %%mm0, %%mm1nt"
  359. "movq %%mm0, %%mm2nt"
  360. "movq %%mm3, %%mm4nt"
  361. "movq %%mm3, %%mm5nt"
  362. "psrlq $3, %%mm0nt"
  363. "psrlq $3, %%mm3nt"
  364. "pand %2, %%mm0nt"
  365. "pand %2, %%mm3nt"
  366. "psrlq $5, %%mm1nt"
  367. "psrlq $5, %%mm4nt"
  368. "pand %%mm6, %%mm1nt"
  369. "pand %%mm6, %%mm4nt"
  370. "psrlq $8, %%mm2nt"
  371. "psrlq $8, %%mm5nt"
  372. "pand %%mm7, %%mm2nt"
  373. "pand %%mm7, %%mm5nt"
  374. "por %%mm1, %%mm0nt"
  375. "por %%mm4, %%mm3nt"
  376. "por %%mm2, %%mm0nt"
  377. "por %%mm5, %%mm3nt"
  378. "psllq $16, %%mm3nt"
  379. "por %%mm3, %%mm0nt"
  380. MOVNTQ" %%mm0, %0nt"
  381. :"=m"(*d):"m"(*s),"m"(blue_16mask):"memory");
  382. d += 4;
  383. s += 16;
  384. }
  385. #endif
  386. __asm __volatile(SFENCE:::"memory");
  387. __asm __volatile(EMMS:::"memory");
  388. #endif
  389. while(s < end)
  390. {
  391. const int src= *s; s += 4;
  392. *d++ = ((src&0xFF)>>3) + ((src&0xFC00)>>5) + ((src&0xF80000)>>8);
  393. // *d++ = ((src>>3)&0x1F) + ((src>>5)&0x7E0) + ((src>>8)&0xF800);
  394. }
  395. }
  397. static inline void RENAME(rgb32tobgr16)(const uint8_t *src, uint8_t *dst, unsigned int src_size)
  398. {
  399. const uint8_t *s = src;
  400. const uint8_t *end;
  401. #ifdef HAVE_MMX
  402. const uint8_t *mm_end;
  403. #endif
  404. uint16_t *d = (uint16_t *)dst;
  405. end = s + src_size;
  406. #ifdef HAVE_MMX
  407. __asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
  408. __asm __volatile(
  409.     "movq %0, %%mm7nt"
  410.     "movq %1, %%mm6nt"
  411.     ::"m"(red_16mask),"m"(green_16mask));
  412. mm_end = end - 15;
  413. while(s < mm_end)
  414. {
  415.     __asm __volatile(
  416. PREFETCH" 32%1nt"
  417. "movd %1, %%mm0nt"
  418. "movd 4%1, %%mm3nt"
  419. "punpckldq 8%1, %%mm0nt"
  420. "punpckldq 12%1, %%mm3nt"
  421. "movq %%mm0, %%mm1nt"
  422. "movq %%mm0, %%mm2nt"
  423. "movq %%mm3, %%mm4nt"
  424. "movq %%mm3, %%mm5nt"
  425. "psllq $8, %%mm0nt"
  426. "psllq $8, %%mm3nt"
  427. "pand %%mm7, %%mm0nt"
  428. "pand %%mm7, %%mm3nt"
  429. "psrlq $5, %%mm1nt"
  430. "psrlq $5, %%mm4nt"
  431. "pand %%mm6, %%mm1nt"
  432. "pand %%mm6, %%mm4nt"
  433. "psrlq $19, %%mm2nt"
  434. "psrlq $19, %%mm5nt"
  435. "pand %2, %%mm2nt"
  436. "pand %2, %%mm5nt"
  437. "por %%mm1, %%mm0nt"
  438. "por %%mm4, %%mm3nt"
  439. "por %%mm2, %%mm0nt"
  440. "por %%mm5, %%mm3nt"
  441. "psllq $16, %%mm3nt"
  442. "por %%mm3, %%mm0nt"
  443. MOVNTQ" %%mm0, %0nt"
  444. :"=m"(*d):"m"(*s),"m"(blue_16mask):"memory");
  445. d += 4;
  446. s += 16;
  447. }
  448. __asm __volatile(SFENCE:::"memory");
  449. __asm __volatile(EMMS:::"memory");
  450. #endif
  451. while(s < end)
  452. {
  453. const int src= *s; s += 4;
  454. *d++ = ((src&0xF8)<<8) + ((src&0xFC00)>>5) + ((src&0xF80000)>>19);
  455. }
  456. }
  458. static inline void RENAME(rgb32to15)(const uint8_t *src, uint8_t *dst, unsigned src_size)
  459. {
  460. const uint8_t *s = src;
  461. const uint8_t *end;
  462. #ifdef HAVE_MMX
  463. const uint8_t *mm_end;
  464. #endif
  465. uint16_t *d = (uint16_t *)dst;
  466. end = s + src_size;
  467. #ifdef HAVE_MMX
  468. mm_end = end - 15;
  469. #if 1 //is faster only if multiplies are reasonable fast (FIXME figure out on which cpus this is faster, on Athlon its slightly faster)
  470. asm volatile(
  471. "movq %3, %%mm5 nt"
  472. "movq %4, %%mm6 nt"
  473. "movq %5, %%mm7 nt"
  474. ".balign 16 nt"
  475. "1: nt"
  476. PREFETCH" 32(%1) nt"
  477. "movd (%1), %%mm0 nt"
  478. "movd 4(%1), %%mm3 nt"
  479. "punpckldq 8(%1), %%mm0 nt"
  480. "punpckldq 12(%1), %%mm3 nt"
  481. "movq %%mm0, %%mm1 nt"
  482. "movq %%mm3, %%mm4 nt"
  483. "pand %%mm6, %%mm0 nt"
  484. "pand %%mm6, %%mm3 nt"
  485. "pmaddwd %%mm7, %%mm0 nt"
  486. "pmaddwd %%mm7, %%mm3 nt"
  487. "pand %%mm5, %%mm1 nt"
  488. "pand %%mm5, %%mm4 nt"
  489. "por %%mm1, %%mm0 nt"
  490. "por %%mm4, %%mm3 nt"
  491. "psrld $6, %%mm0 nt"
  492. "pslld $10, %%mm3 nt"
  493. "por %%mm3, %%mm0 nt"
  494. MOVNTQ" %%mm0, (%0) nt"
  495. "addl $16, %1 nt"
  496. "addl $8, %0 nt"
  497. "cmpl %2, %1 nt"
  498. " jb 1b nt"
  499. : "+r" (d), "+r"(s)
  500. : "r" (mm_end), "m" (mask3215g), "m" (mask3216br), "m" (mul3215)
  501. );
  502. #else
  503. __asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
  504. __asm __volatile(
  505.     "movq %0, %%mm7nt"
  506.     "movq %1, %%mm6nt"
  507.     ::"m"(red_15mask),"m"(green_15mask));
  508. while(s < mm_end)
  509. {
  510.     __asm __volatile(
  511. PREFETCH" 32%1nt"
  512. "movd %1, %%mm0nt"
  513. "movd 4%1, %%mm3nt"
  514. "punpckldq 8%1, %%mm0nt"
  515. "punpckldq 12%1, %%mm3nt"
  516. "movq %%mm0, %%mm1nt"
  517. "movq %%mm0, %%mm2nt"
  518. "movq %%mm3, %%mm4nt"
  519. "movq %%mm3, %%mm5nt"
  520. "psrlq $3, %%mm0nt"
  521. "psrlq $3, %%mm3nt"
  522. "pand %2, %%mm0nt"
  523. "pand %2, %%mm3nt"
  524. "psrlq $6, %%mm1nt"
  525. "psrlq $6, %%mm4nt"
  526. "pand %%mm6, %%mm1nt"
  527. "pand %%mm6, %%mm4nt"
  528. "psrlq $9, %%mm2nt"
  529. "psrlq $9, %%mm5nt"
  530. "pand %%mm7, %%mm2nt"
  531. "pand %%mm7, %%mm5nt"
  532. "por %%mm1, %%mm0nt"
  533. "por %%mm4, %%mm3nt"
  534. "por %%mm2, %%mm0nt"
  535. "por %%mm5, %%mm3nt"
  536. "psllq $16, %%mm3nt"
  537. "por %%mm3, %%mm0nt"
  538. MOVNTQ" %%mm0, %0nt"
  539. :"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");
  540. d += 4;
  541. s += 16;
  542. }
  543. #endif
  544. __asm __volatile(SFENCE:::"memory");
  545. __asm __volatile(EMMS:::"memory");
  546. #endif
  547. while(s < end)
  548. {
  549. const int src= *s; s += 4;
  550. *d++ = ((src&0xFF)>>3) + ((src&0xF800)>>6) + ((src&0xF80000)>>9);
  551. }
  552. }
  554. static inline void RENAME(rgb32tobgr15)(const uint8_t *src, uint8_t *dst, unsigned src_size)
  555. {
  556. const uint8_t *s = src;
  557. const uint8_t *end;
  558. #ifdef HAVE_MMX
  559. const uint8_t *mm_end;
  560. #endif
  561. uint16_t *d = (uint16_t *)dst;
  562. end = s + src_size;
  563. #ifdef HAVE_MMX
  564. __asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
  565. __asm __volatile(
  566.     "movq %0, %%mm7nt"
  567.     "movq %1, %%mm6nt"
  568.     ::"m"(red_15mask),"m"(green_15mask));
  569. mm_end = end - 15;
  570. while(s < mm_end)
  571. {
  572.     __asm __volatile(
  573. PREFETCH" 32%1nt"
  574. "movd %1, %%mm0nt"
  575. "movd 4%1, %%mm3nt"
  576. "punpckldq 8%1, %%mm0nt"
  577. "punpckldq 12%1, %%mm3nt"
  578. "movq %%mm0, %%mm1nt"
  579. "movq %%mm0, %%mm2nt"
  580. "movq %%mm3, %%mm4nt"
  581. "movq %%mm3, %%mm5nt"
  582. "psllq $7, %%mm0nt"
  583. "psllq $7, %%mm3nt"
  584. "pand %%mm7, %%mm0nt"
  585. "pand %%mm7, %%mm3nt"
  586. "psrlq $6, %%mm1nt"
  587. "psrlq $6, %%mm4nt"
  588. "pand %%mm6, %%mm1nt"
  589. "pand %%mm6, %%mm4nt"
  590. "psrlq $19, %%mm2nt"
  591. "psrlq $19, %%mm5nt"
  592. "pand %2, %%mm2nt"
  593. "pand %2, %%mm5nt"
  594. "por %%mm1, %%mm0nt"
  595. "por %%mm4, %%mm3nt"
  596. "por %%mm2, %%mm0nt"
  597. "por %%mm5, %%mm3nt"
  598. "psllq $16, %%mm3nt"
  599. "por %%mm3, %%mm0nt"
  600. MOVNTQ" %%mm0, %0nt"
  601. :"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");
  602. d += 4;
  603. s += 16;
  604. }
  605. __asm __volatile(SFENCE:::"memory");
  606. __asm __volatile(EMMS:::"memory");
  607. #endif
  608. while(s < end)
  609. {
  610. const int src= *s; s += 4;
  611. *d++ = ((src&0xF8)<<7) + ((src&0xF800)>>6) + ((src&0xF80000)>>19);
  612. }
  613. }
  615. static inline void RENAME(rgb24to16)(const uint8_t *src, uint8_t *dst, unsigned src_size)
  616. {
  617. const uint8_t *s = src;
  618. const uint8_t *end;
  619. #ifdef HAVE_MMX
  620. const uint8_t *mm_end;
  621. #endif
  622. uint16_t *d = (uint16_t *)dst;
  623. end = s + src_size;
  624. #ifdef HAVE_MMX
  625. __asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
  626. __asm __volatile(
  627.     "movq %0, %%mm7nt"
  628.     "movq %1, %%mm6nt"
  629.     ::"m"(red_16mask),"m"(green_16mask));
  630. mm_end = end - 11;
  631. while(s < mm_end)
  632. {
  633.     __asm __volatile(
  634. PREFETCH" 32%1nt"
  635. "movd %1, %%mm0nt"
  636. "movd 3%1, %%mm3nt"
  637. "punpckldq 6%1, %%mm0nt"
  638. "punpckldq 9%1, %%mm3nt"
  639. "movq %%mm0, %%mm1nt"
  640. "movq %%mm0, %%mm2nt"
  641. "movq %%mm3, %%mm4nt"
  642. "movq %%mm3, %%mm5nt"
  643. "psrlq $3, %%mm0nt"
  644. "psrlq $3, %%mm3nt"
  645. "pand %2, %%mm0nt"
  646. "pand %2, %%mm3nt"
  647. "psrlq $5, %%mm1nt"
  648. "psrlq $5, %%mm4nt"
  649. "pand %%mm6, %%mm1nt"
  650. "pand %%mm6, %%mm4nt"
  651. "psrlq $8, %%mm2nt"
  652. "psrlq $8, %%mm5nt"
  653. "pand %%mm7, %%mm2nt"
  654. "pand %%mm7, %%mm5nt"
  655. "por %%mm1, %%mm0nt"
  656. "por %%mm4, %%mm3nt"
  657. "por %%mm2, %%mm0nt"
  658. "por %%mm5, %%mm3nt"
  659. "psllq $16, %%mm3nt"
  660. "por %%mm3, %%mm0nt"
  661. MOVNTQ" %%mm0, %0nt"
  662. :"=m"(*d):"m"(*s),"m"(blue_16mask):"memory");
  663. d += 4;
  664. s += 12;
  665. }
  666. __asm __volatile(SFENCE:::"memory");
  667. __asm __volatile(EMMS:::"memory");
  668. #endif
  669. while(s < end)
  670. {
  671. const int b= *s++;
  672. const int g= *s++;
  673. const int r= *s++;
  674. *d++ = (b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8);
  675. }
  676. }
  678. static inline void RENAME(rgb24tobgr16)(const uint8_t *src, uint8_t *dst, unsigned int src_size)
  679. {
  680. const uint8_t *s = src;
  681. const uint8_t *end;
  682. #ifdef HAVE_MMX
  683. const uint8_t *mm_end;
  684. #endif
  685. uint16_t *d = (uint16_t *)dst;
  686. end = s + src_size;
  687. #ifdef HAVE_MMX
  688. __asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
  689. __asm __volatile(
  690.     "movq %0, %%mm7nt"
  691.     "movq %1, %%mm6nt"
  692.     ::"m"(red_16mask),"m"(green_16mask));
  693. mm_end = end - 15;
  694. while(s < mm_end)
  695. {
  696.     __asm __volatile(
  697. PREFETCH" 32%1nt"
  698. "movd %1, %%mm0nt"
  699. "movd 3%1, %%mm3nt"
  700. "punpckldq 6%1, %%mm0nt"
  701. "punpckldq 9%1, %%mm3nt"
  702. "movq %%mm0, %%mm1nt"
  703. "movq %%mm0, %%mm2nt"
  704. "movq %%mm3, %%mm4nt"
  705. "movq %%mm3, %%mm5nt"
  706. "psllq $8, %%mm0nt"
  707. "psllq $8, %%mm3nt"
  708. "pand %%mm7, %%mm0nt"
  709. "pand %%mm7, %%mm3nt"
  710. "psrlq $5, %%mm1nt"
  711. "psrlq $5, %%mm4nt"
  712. "pand %%mm6, %%mm1nt"
  713. "pand %%mm6, %%mm4nt"
  714. "psrlq $19, %%mm2nt"
  715. "psrlq $19, %%mm5nt"
  716. "pand %2, %%mm2nt"
  717. "pand %2, %%mm5nt"
  718. "por %%mm1, %%mm0nt"
  719. "por %%mm4, %%mm3nt"
  720. "por %%mm2, %%mm0nt"
  721. "por %%mm5, %%mm3nt"
  722. "psllq $16, %%mm3nt"
  723. "por %%mm3, %%mm0nt"
  724. MOVNTQ" %%mm0, %0nt"
  725. :"=m"(*d):"m"(*s),"m"(blue_16mask):"memory");
  726. d += 4;
  727. s += 12;
  728. }
  729. __asm __volatile(SFENCE:::"memory");
  730. __asm __volatile(EMMS:::"memory");
  731. #endif
  732. while(s < end)
  733. {
  734. const int r= *s++;
  735. const int g= *s++;
  736. const int b= *s++;
  737. *d++ = (b>>3) | ((g&0xFC)<<3) | ((r&0xF8)<<8);
  738. }
  739. }
  741. static inline void RENAME(rgb24to15)(const uint8_t *src, uint8_t *dst, unsigned src_size)
  742. {
  743. const uint8_t *s = src;
  744. const uint8_t *end;
  745. #ifdef HAVE_MMX
  746. const uint8_t *mm_end;
  747. #endif
  748. uint16_t *d = (uint16_t *)dst;
  749. end = s + src_size;
  750. #ifdef HAVE_MMX
  751. __asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
  752. __asm __volatile(
  753.     "movq %0, %%mm7nt"
  754.     "movq %1, %%mm6nt"
  755.     ::"m"(red_15mask),"m"(green_15mask));
  756. mm_end = end - 11;
  757. while(s < mm_end)
  758. {
  759.     __asm __volatile(
  760. PREFETCH" 32%1nt"
  761. "movd %1, %%mm0nt"
  762. "movd 3%1, %%mm3nt"
  763. "punpckldq 6%1, %%mm0nt"
  764. "punpckldq 9%1, %%mm3nt"
  765. "movq %%mm0, %%mm1nt"
  766. "movq %%mm0, %%mm2nt"
  767. "movq %%mm3, %%mm4nt"
  768. "movq %%mm3, %%mm5nt"
  769. "psrlq $3, %%mm0nt"
  770. "psrlq $3, %%mm3nt"
  771. "pand %2, %%mm0nt"
  772. "pand %2, %%mm3nt"
  773. "psrlq $6, %%mm1nt"
  774. "psrlq $6, %%mm4nt"
  775. "pand %%mm6, %%mm1nt"
  776. "pand %%mm6, %%mm4nt"
  777. "psrlq $9, %%mm2nt"
  778. "psrlq $9, %%mm5nt"
  779. "pand %%mm7, %%mm2nt"
  780. "pand %%mm7, %%mm5nt"
  781. "por %%mm1, %%mm0nt"
  782. "por %%mm4, %%mm3nt"
  783. "por %%mm2, %%mm0nt"
  784. "por %%mm5, %%mm3nt"
  785. "psllq $16, %%mm3nt"
  786. "por %%mm3, %%mm0nt"
  787. MOVNTQ" %%mm0, %0nt"
  788. :"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");
  789. d += 4;
  790. s += 12;
  791. }
  792. __asm __volatile(SFENCE:::"memory");
  793. __asm __volatile(EMMS:::"memory");
  794. #endif
  795. while(s < end)
  796. {
  797. const int b= *s++;
  798. const int g= *s++;
  799. const int r= *s++;
  800. *d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);
  801. }
  802. }
  804. static inline void RENAME(rgb24tobgr15)(const uint8_t *src, uint8_t *dst, unsigned src_size)
  805. {
  806. const uint8_t *s = src;
  807. const uint8_t *end;
  808. #ifdef HAVE_MMX
  809. const uint8_t *mm_end;
  810. #endif
  811. uint16_t *d = (uint16_t *)dst;
  812. end = s + src_size;
  813. #ifdef HAVE_MMX
  814. __asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
  815. __asm __volatile(
  816.     "movq %0, %%mm7nt"
  817.     "movq %1, %%mm6nt"
  818.     ::"m"(red_15mask),"m"(green_15mask));
  819. mm_end = end - 15;
  820. while(s < mm_end)
  821. {
  822.     __asm __volatile(
  823. PREFETCH" 32%1nt"
  824. "movd %1, %%mm0nt"
  825. "movd 3%1, %%mm3nt"
  826. "punpckldq 6%1, %%mm0nt"
  827. "punpckldq 9%1, %%mm3nt"
  828. "movq %%mm0, %%mm1nt"
  829. "movq %%mm0, %%mm2nt"
  830. "movq %%mm3, %%mm4nt"
  831. "movq %%mm3, %%mm5nt"
  832. "psllq $7, %%mm0nt"
  833. "psllq $7, %%mm3nt"
  834. "pand %%mm7, %%mm0nt"
  835. "pand %%mm7, %%mm3nt"
  836. "psrlq $6, %%mm1nt"
  837. "psrlq $6, %%mm4nt"
  838. "pand %%mm6, %%mm1nt"
  839. "pand %%mm6, %%mm4nt"
  840. "psrlq $19, %%mm2nt"
  841. "psrlq $19, %%mm5nt"
  842. "pand %2, %%mm2nt"
  843. "pand %2, %%mm5nt"
  844. "por %%mm1, %%mm0nt"
  845. "por %%mm4, %%mm3nt"
  846. "por %%mm2, %%mm0nt"
  847. "por %%mm5, %%mm3nt"
  848. "psllq $16, %%mm3nt"
  849. "por %%mm3, %%mm0nt"
  850. MOVNTQ" %%mm0, %0nt"
  851. :"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");
  852. d += 4;
  853. s += 12;
  854. }
  855. __asm __volatile(SFENCE:::"memory");
  856. __asm __volatile(EMMS:::"memory");
  857. #endif
  858. while(s < end)
  859. {
  860. const int r= *s++;
  861. const int g= *s++;
  862. const int b= *s++;
  863. *d++ = (b>>3) | ((g&0xF8)<<2) | ((r&0xF8)<<7);
  864. }
  865. }
  867. /*
  868.   I use here less accurate approximation by simply
  869.  left-shifting the input
  870.   value and filling the low order bits with
  871.  zeroes. This method improves png's
  872.   compression but this scheme cannot reproduce white exactly, since it does not
  873.   generate an all-ones maximum value; the net effect is to darken the
  874.   image slightly.
  876.   The better method should be "left bit replication":
  878.    4 3 2 1 0
  879.    ---------
  880.    1 1 0 1 1
  882.    7 6 5 4 3  2 1 0
  883.    ----------------
  884.    1 1 0 1 1  1 1 0
  885.    |=======|  |===|
  886.        |      Leftmost Bits Repeated to Fill Open Bits
  887.        |
  888.    Original Bits
  889. */
  890. static inline void RENAME(rgb15to24)(const uint8_t *src, uint8_t *dst, unsigned src_size)
  891. {
  892. const uint16_t *end;
  893. #ifdef HAVE_MMX
  894. const uint16_t *mm_end;
  895. #endif
  896. uint8_t *d = (uint8_t *)dst;
  897. const uint16_t *s = (uint16_t *)src;
  898. end = s + src_size/2;
  899. #ifdef HAVE_MMX
  900. __asm __volatile(PREFETCH" %0"::"m"(*s):"memory");
  901. mm_end = end - 7;
  902. while(s < mm_end)
  903. {
  904.     __asm __volatile(
  905. PREFETCH" 32%1nt"
  906. "movq %1, %%mm0nt"
  907. "movq %1, %%mm1nt"
  908. "movq %1, %%mm2nt"
  909. "pand %2, %%mm0nt"
  910. "pand %3, %%mm1nt"
  911. "pand %4, %%mm2nt"
  912. "psllq $3, %%mm0nt"
  913. "psrlq $2, %%mm1nt"
  914. "psrlq $7, %%mm2nt"
  915. "movq %%mm0, %%mm3nt"
  916. "movq %%mm1, %%mm4nt"
  917. "movq %%mm2, %%mm5nt"
  918. "punpcklwd %5, %%mm0nt"
  919. "punpcklwd %5, %%mm1nt"
  920. "punpcklwd %5, %%mm2nt"
  921. "punpckhwd %5, %%mm3nt"
  922. "punpckhwd %5, %%mm4nt"
  923. "punpckhwd %5, %%mm5nt"
  924. "psllq $8, %%mm1nt"
  925. "psllq $16, %%mm2nt"
  926. "por %%mm1, %%mm0nt"
  927. "por %%mm2, %%mm0nt"
  928. "psllq $8, %%mm4nt"
  929. "psllq $16, %%mm5nt"
  930. "por %%mm4, %%mm3nt"
  931. "por %%mm5, %%mm3nt"
  933. "movq %%mm0, %%mm6nt"
  934. "movq %%mm3, %%mm7nt"
  936. "movq 8%1, %%mm0nt"
  937. "movq 8%1, %%mm1nt"
  938. "movq 8%1, %%mm2nt"
  939. "pand %2, %%mm0nt"
  940. "pand %3, %%mm1nt"
  941. "pand %4, %%mm2nt"
  942. "psllq $3, %%mm0nt"
  943. "psrlq $2, %%mm1nt"
  944. "psrlq $7, %%mm2nt"
  945. "movq %%mm0, %%mm3nt"
  946. "movq %%mm1, %%mm4nt"
  947. "movq %%mm2, %%mm5nt"
  948. "punpcklwd %5, %%mm0nt"
  949. "punpcklwd %5, %%mm1nt"
  950. "punpcklwd %5, %%mm2nt"
  951. "punpckhwd %5, %%mm3nt"
  952. "punpckhwd %5, %%mm4nt"
  953. "punpckhwd %5, %%mm5nt"
  954. "psllq $8, %%mm1nt"
  955. "psllq $16, %%mm2nt"
  956. "por %%mm1, %%mm0nt"
  957. "por %%mm2, %%mm0nt"
  958. "psllq $8, %%mm4nt"
  959. "psllq $16, %%mm5nt"
  960. "por %%mm4, %%mm3nt"
  961. "por %%mm5, %%mm3nt"
  963. :"=m"(*d)
  964. :"m"(*s),"m"(mask15b),"m"(mask15g),"m"(mask15r), "m"(mmx_null)
  965. :"memory");
  966.     /* Borrowed 32 to 24 */
  967.     __asm __volatile(
  968. "movq %%mm0, %%mm4nt"
  969. "movq %%mm3, %%mm5nt"
  970. "movq %%mm6, %%mm0nt"
  971. "movq %%mm7, %%mm1nt"
  973. "movq %%mm4, %%mm6nt"
  974. "movq %%mm5, %%mm7nt"
  975. "movq %%mm0, %%mm2nt"
  976. "movq %%mm1, %%mm3nt"
  978. "psrlq $8, %%mm2nt"
  979. "psrlq $8, %%mm3nt"
  980. "psrlq $8, %%mm6nt"
  981. "psrlq $8, %%mm7nt"
  982. "pand %2, %%mm0nt"
  983. "pand %2, %%mm1nt"
  984. "pand %2, %%mm4nt"
  985. "pand %2, %%mm5nt"
  986. "pand %3, %%mm2nt"
  987. "pand %3, %%mm3nt"
  988. "pand %3, %%mm6nt"
  989. "pand %3, %%mm7nt"
  990. "por %%mm2, %%mm0nt"
  991. "por %%mm3, %%mm1nt"
  992. "por %%mm6, %%mm4nt"
  993. "por %%mm7, %%mm5nt"
  995. "movq %%mm1, %%mm2nt"
  996. "movq %%mm4, %%mm3nt"
  997. "psllq $48, %%mm2nt"
  998. "psllq $32, %%mm3nt"
  999. "pand %4, %%mm2nt"
  1000. "pand %5, %%mm3nt"
  1001. "por %%mm2, %%mm0nt"
  1002. "psrlq $16, %%mm1nt"
  1003. "psrlq $32, %%mm4nt"
  1004. "psllq $16, %%mm5nt"
  1005. "por %%mm3, %%mm1nt"
  1006. "pand %6, %%mm5nt"
  1007. "por %%mm5, %%mm4nt"
  1009. MOVNTQ" %%mm0, %0nt"
  1010. MOVNTQ" %%mm1, 8%0nt"
  1011. MOVNTQ" %%mm4, 16%0"
  1013. :"=m"(*d)
  1014. :"m"(*s),"m"(mask24l),"m"(mask24h),"m"(mask24hh),"m"(mask24hhh),"m"(mask24hhhh)
  1015. :"memory");
  1016. d += 24;
  1017. s += 8;
  1018. }
  1019. __asm __volatile(SFENCE:::"memory");
  1020. __asm __volatile(EMMS:::"memory");
  1021. #endif
  1022. while(s < end)
  1023. {
  1024. register uint16_t bgr;
  1025. bgr = *s++;
  1026. *d++ = (bgr&0x1F)<<3;
  1027. *d++ = (bgr&0x3E0)>>2;
  1028. *d++ = (bgr&0x7C00)>>7;
  1029. }
  1030. }
  1032. static inline void RENAME(rgb16to24)(const uint8_t *src, uint8_t *dst, unsigned src_size)
  1033. {
  1034. const uint16_t *end;
  1035. #ifdef HAVE_MMX
  1036. const uint16_t *mm_end;
  1037. #endif
  1038. uint8_t *d = (uint8_t *)dst;
  1039. const uint16_t *s = (const uint16_t *)src;
  1040. end = s + src_size/2;
  1041. #ifdef HAVE_MMX
  1042. __asm __volatile(PREFETCH" %0"::"m"(*s):"memory");
  1043. mm_end = end - 7;
  1044. while(s < mm_end)
  1045. {
  1046.     __asm __volatile(
  1047. PREFETCH" 32%1nt"
  1048. "movq %1, %%mm0nt"
  1049. "movq %1, %%mm1nt"
  1050. "movq %1, %%mm2nt"
  1051. "pand %2, %%mm0nt"
  1052. "pand %3, %%mm1nt"
  1053. "pand %4, %%mm2nt"
  1054. "psllq $3, %%mm0nt"
  1055. "psrlq $3, %%mm1nt"
  1056. "psrlq $8, %%mm2nt"
  1057. "movq %%mm0, %%mm3nt"
  1058. "movq %%mm1, %%mm4nt"
  1059. "movq %%mm2, %%mm5nt"
  1060. "punpcklwd %5, %%mm0nt"
  1061. "punpcklwd %5, %%mm1nt"
  1062. "punpcklwd %5, %%mm2nt"
  1063. "punpckhwd %5, %%mm3nt"
  1064. "punpckhwd %5, %%mm4nt"
  1065. "punpckhwd %5, %%mm5nt"
  1066. "psllq $8, %%mm1nt"
  1067. "psllq $16, %%mm2nt"
  1068. "por %%mm1, %%mm0nt"
  1069. "por %%mm2, %%mm0nt"
  1070. "psllq $8, %%mm4nt"
  1071. "psllq $16, %%mm5nt"
  1072. "por %%mm4, %%mm3nt"
  1073. "por %%mm5, %%mm3nt"
  1075. "movq %%mm0, %%mm6nt"
  1076. "movq %%mm3, %%mm7nt"
  1078. "movq 8%1, %%mm0nt"
  1079. "movq 8%1, %%mm1nt"
  1080. "movq 8%1, %%mm2nt"
  1081. "pand %2, %%mm0nt"
  1082. "pand %3, %%mm1nt"
  1083. "pand %4, %%mm2nt"
  1084. "psllq $3, %%mm0nt"
  1085. "psrlq $3, %%mm1nt"
  1086. "psrlq $8, %%mm2nt"
  1087. "movq %%mm0, %%mm3nt"
  1088. "movq %%mm1, %%mm4nt"
  1089. "movq %%mm2, %%mm5nt"
  1090. "punpcklwd %5, %%mm0nt"
  1091. "punpcklwd %5, %%mm1nt"
  1092. "punpcklwd %5, %%mm2nt"
  1093. "punpckhwd %5, %%mm3nt"
  1094. "punpckhwd %5, %%mm4nt"
  1095. "punpckhwd %5, %%mm5nt"
  1096. "psllq $8, %%mm1nt"
  1097. "psllq $16, %%mm2nt"
  1098. "por %%mm1, %%mm0nt"
  1099. "por %%mm2, %%mm0nt"
  1100. "psllq $8, %%mm4nt"
  1101. "psllq $16, %%mm5nt"
  1102. "por %%mm4, %%mm3nt"
  1103. "por %%mm5, %%mm3nt"
  1104. :"=m"(*d)
  1105. :"m"(*s),"m"(mask16b),"m"(mask16g),"m"(mask16r),"m"(mmx_null)
  1106. :"memory");
  1107.     /* Borrowed 32 to 24 */
  1108.     __asm __volatile(
  1109. "movq %%mm0, %%mm4nt"
  1110. "movq %%mm3, %%mm5nt"
  1111. "movq %%mm6, %%mm0nt"
  1112. "movq %%mm7, %%mm1nt"
  1114. "movq %%mm4, %%mm6nt"
  1115. "movq %%mm5, %%mm7nt"
  1116. "movq %%mm0, %%mm2nt"
  1117. "movq %%mm1, %%mm3nt"
  1119. "psrlq $8, %%mm2nt"
  1120. "psrlq $8, %%mm3nt"
  1121. "psrlq $8, %%mm6nt"
  1122. "psrlq $8, %%mm7nt"
  1123. "pand %2, %%mm0nt"
  1124. "pand %2, %%mm1nt"
  1125. "pand %2, %%mm4nt"
  1126. "pand %2, %%mm5nt"
  1127. "pand %3, %%mm2nt"
  1128. "pand %3, %%mm3nt"
  1129. "pand %3, %%mm6nt"
  1130. "pand %3, %%mm7nt"
  1131. "por %%mm2, %%mm0nt"
  1132. "por %%mm3, %%mm1nt"
  1133. "por %%mm6, %%mm4nt"
  1134. "por %%mm7, %%mm5nt"
  1136. "movq %%mm1, %%mm2nt"
  1137. "movq %%mm4, %%mm3nt"
  1138. "psllq $48, %%mm2nt"
  1139. "psllq $32, %%mm3nt"
  1140. "pand %4, %%mm2nt"
  1141. "pand %5, %%mm3nt"
  1142. "por %%mm2, %%mm0nt"
  1143. "psrlq $16, %%mm1nt"
  1144. "psrlq $32, %%mm4nt"
  1145. "psllq $16, %%mm5nt"
  1146. "por %%mm3, %%mm1nt"
  1147. "pand %6, %%mm5nt"
  1148. "por %%mm5, %%mm4nt"
  1150. MOVNTQ" %%mm0, %0nt"
  1151. MOVNTQ" %%mm1, 8%0nt"
  1152. MOVNTQ" %%mm4, 16%0"
  1154. :"=m"(*d)
  1155. :"m"(*s),"m"(mask24l),"m"(mask24h),"m"(mask24hh),"m"(mask24hhh),"m"(mask24hhhh)
  1156. :"memory");
  1157. d += 24;
  1158. s += 8;
  1159. }
  1160. __asm __volatile(SFENCE:::"memory");
  1161. __asm __volatile(EMMS:::"memory");
  1162. #endif
  1163. while(s < end)
  1164. {
  1165. register uint16_t bgr;
  1166. bgr = *s++;
  1167. *d++ = (bgr&0x1F)<<3;
  1168. *d++ = (bgr&0x7E0)>>3;
  1169. *d++ = (bgr&0xF800)>>8;
  1170. }
  1171. }
  1173. static inline void RENAME(rgb15to32)(const uint8_t *src, uint8_t *dst, unsigned src_size)
  1174. {
  1175. const uint16_t *end;
  1176. #ifdef HAVE_MMX
  1177. const uint16_t *mm_end;
  1178. #endif
  1179. uint8_t *d = (uint8_t *)dst;
  1180. const uint16_t *s = (const uint16_t *)src;
  1181. end = s + src_size/2;
  1182. #ifdef HAVE_MMX
  1183. __asm __volatile(PREFETCH" %0"::"m"(*s):"memory");
  1184. __asm __volatile("pxor %%mm7,%%mm7nt":::"memory");
  1185. mm_end = end - 3;
  1186. while(s < mm_end)
  1187. {
  1188.     __asm __volatile(
  1189. PREFETCH" 32%1nt"
  1190. "movq %1, %%mm0nt"
  1191. "movq %1, %%mm1nt"
  1192. "movq %1, %%mm2nt"
  1193. "pand %2, %%mm0nt"
  1194. "pand %3, %%mm1nt"
  1195. "pand %4, %%mm2nt"
  1196. "psllq $3, %%mm0nt"
  1197. "psrlq $2, %%mm1nt"
  1198. "psrlq $7, %%mm2nt"
  1199. "movq %%mm0, %%mm3nt"
  1200. "movq %%mm1, %%mm4nt"
  1201. "movq %%mm2, %%mm5nt"
  1202. "punpcklwd %%mm7, %%mm0nt"
  1203. "punpcklwd %%mm7, %%mm1nt"
  1204. "punpcklwd %%mm7, %%mm2nt"
  1205. "punpckhwd %%mm7, %%mm3nt"
  1206. "punpckhwd %%mm7, %%mm4nt"
  1207. "punpckhwd %%mm7, %%mm5nt"
  1208. "psllq $8, %%mm1nt"
  1209. "psllq $16, %%mm2nt"
  1210. "por %%mm1, %%mm0nt"
  1211. "por %%mm2, %%mm0nt"
  1212. "psllq $8, %%mm4nt"
  1213. "psllq $16, %%mm5nt"
  1214. "por %%mm4, %%mm3nt"
  1215. "por %%mm5, %%mm3nt"
  1216. MOVNTQ" %%mm0, %0nt"
  1217. MOVNTQ" %%mm3, 8%0nt"
  1218. :"=m"(*d)
  1219. :"m"(*s),"m"(mask15b),"m"(mask15g),"m"(mask15r)
  1220. :"memory");
  1221. d += 16;
  1222. s += 4;
  1223. }
  1224. __asm __volatile(SFENCE:::"memory");
  1225. __asm __volatile(EMMS:::"memory");
  1226. #endif
  1227. while(s < end)
  1228. {
  1229. #if 0 //slightly slower on athlon
  1230. int bgr= *s++;
  1231. *((uint32_t*)d)++ = ((bgr&0x1F)<<3) + ((bgr&0x3E0)<<6) + ((bgr&0x7C00)<<9);
  1232. #else
  1233. //FIXME this is very likely wrong for bigendian (and the following converters too)
  1234. register uint16_t bgr;
  1235. bgr = *s++;
  1236. *d++ = (bgr&0x1F)<<3;
  1237. *d++ = (bgr&0x3E0)>>2;
  1238. *d++ = (bgr&0x7C00)>>7;
  1239. *d++ = 0;
  1240. #endif
  1241. }
  1242. }
  1244. static inline void RENAME(rgb16to32)(const uint8_t *src, uint8_t *dst, unsigned src_size)
  1245. {
  1246. const uint16_t *end;
  1247. #ifdef HAVE_MMX
  1248. const uint16_t *mm_end;
  1249. #endif
  1250. uint8_t *d = (uint8_t *)dst;
  1251. const uint16_t *s = (uint16_t *)src;
  1252. end = s + src_size/2;
  1253. #ifdef HAVE_MMX
  1254. __asm __volatile(PREFETCH" %0"::"m"(*s):"memory");
  1255. __asm __volatile("pxor %%mm7,%%mm7nt":::"memory");
  1256. mm_end = end - 3;
  1257. while(s < mm_end)
  1258. {
  1259.     __asm __volatile(
  1260. PREFETCH" 32%1nt"
  1261. "movq %1, %%mm0nt"
  1262. "movq %1, %%mm1nt"
  1263. "movq %1, %%mm2nt"
  1264. "pand %2, %%mm0nt"
  1265. "pand %3, %%mm1nt"
  1266. "pand %4, %%mm2nt"
  1267. "psllq $3, %%mm0nt"
  1268. "psrlq $3, %%mm1nt"
  1269. "psrlq $8, %%mm2nt"
  1270. "movq %%mm0, %%mm3nt"
  1271. "movq %%mm1, %%mm4nt"
  1272. "movq %%mm2, %%mm5nt"
  1273. "punpcklwd %%mm7, %%mm0nt"
  1274. "punpcklwd %%mm7, %%mm1nt"
  1275. "punpcklwd %%mm7, %%mm2nt"
  1276. "punpckhwd %%mm7, %%mm3nt"
  1277. "punpckhwd %%mm7, %%mm4nt"
  1278. "punpckhwd %%mm7, %%mm5nt"
  1279. "psllq $8, %%mm1nt"
  1280. "psllq $16, %%mm2nt"
  1281. "por %%mm1, %%mm0nt"
  1282. "por %%mm2, %%mm0nt"
  1283. "psllq $8, %%mm4nt"
  1284. "psllq $16, %%mm5nt"
  1285. "por %%mm4, %%mm3nt"
  1286. "por %%mm5, %%mm3nt"
  1287. MOVNTQ" %%mm0, %0nt"
  1288. MOVNTQ" %%mm3, 8%0nt"
  1289. :"=m"(*d)
  1290. :"m"(*s),"m"(mask16b),"m"(mask16g),"m"(mask16r)
  1291. :"memory");
  1292. d += 16;
  1293. s += 4;
  1294. }
  1295. __asm __volatile(SFENCE:::"memory");
  1296. __asm __volatile(EMMS:::"memory");
  1297. #endif
  1298. while(s < end)
  1299. {
  1300. register uint16_t bgr;
  1301. bgr = *s++;
  1302. *d++ = (bgr&0x1F)<<3;
  1303. *d++ = (bgr&0x7E0)>>3;
  1304. *d++ = (bgr&0xF800)>>8;
  1305. *d++ = 0;
  1306. }
  1307. }
  1309. static inline void RENAME(rgb32tobgr32)(const uint8_t *src, uint8_t *dst, unsigned int src_size)
  1310. {
  1311. #ifdef HAVE_MMX
  1312. /* TODO: unroll this loop */
  1313. asm volatile (
  1314. "xorl %%eax, %%eax nt"
  1315. ".balign 16 nt"
  1316. "1: nt"
  1317. PREFETCH" 32(%0, %%eax) nt"
  1318. "movq (%0, %%eax), %%mm0 nt"
  1319. "movq %%mm0, %%mm1 nt"
  1320. "movq %%mm0, %%mm2 nt"
  1321. "pslld $16, %%mm0 nt"
  1322. "psrld $16, %%mm1 nt"
  1323. "pand "MANGLE(mask32r)", %%mm0 nt"
  1324. "pand "MANGLE(mask32g)", %%mm2 nt"
  1325. "pand "MANGLE(mask32b)", %%mm1 nt"
  1326. "por %%mm0, %%mm2 nt"
  1327. "por %%mm1, %%mm2 nt"
  1328. MOVNTQ" %%mm2, (%1, %%eax) nt"
  1329. "addl $8, %%eax nt"
  1330. "cmpl %2, %%eax nt"
  1331. " jb 1b nt"
  1332. :: "r" (src), "r"(dst), "r" (src_size-7)
  1333. : "%eax"
  1334. );
  1336. __asm __volatile(SFENCE:::"memory");
  1337. __asm __volatile(EMMS:::"memory");
  1338. #else
  1339. unsigned i;
  1340. unsigned num_pixels = src_size >> 2;
  1341. for(i=0; i<num_pixels; i++)
  1342. {
  1343. #ifdef WORDS_BIGENDIAN  
  1344.   dst[4*i + 1] = src[4*i + 3];
  1345.   dst[4*i + 2] = src[4*i + 2];
  1346.   dst[4*i + 3] = src[4*i + 1];
  1347. #else
  1348.   dst[4*i + 0] = src[4*i + 2];
  1349.   dst[4*i + 1] = src[4*i + 1];
  1350.   dst[4*i + 2] = src[4*i + 0];
  1351. #endif
  1352. }
  1353. #endif
  1354. }
  1356. static inline void RENAME(rgb24tobgr24)(const uint8_t *src, uint8_t *dst, unsigned int src_size)
  1357. {
  1358. unsigned i;
  1359. #ifdef HAVE_MMX
  1360. int mmx_size= 23 - src_size;
  1361. asm volatile (
  1362. "movq "MANGLE(mask24r)", %%mm5 nt"
  1363. "movq "MANGLE(mask24g)", %%mm6 nt"
  1364. "movq "MANGLE(mask24b)", %%mm7 nt"
  1365. ".balign 16 nt"
  1366. "1: nt"
  1367. PREFETCH" 32(%1, %%eax) nt"
  1368. "movq   (%1, %%eax), %%mm0 nt" // BGR BGR BG
  1369. "movq   (%1, %%eax), %%mm1 nt" // BGR BGR BG
  1370. "movq  2(%1, %%eax), %%mm2 nt" // R BGR BGR B
  1371. "psllq $16, %%mm0 nt" // 00 BGR BGR
  1372. "pand %%mm5, %%mm0 nt"
  1373. "pand %%mm6, %%mm1 nt"
  1374. "pand %%mm7, %%mm2 nt"
  1375. "por %%mm0, %%mm1 nt"
  1376. "por %%mm2, %%mm1 nt"                
  1377. "movq  6(%1, %%eax), %%mm0 nt" // BGR BGR BG
  1378. MOVNTQ" %%mm1,   (%2, %%eax) nt" // RGB RGB RG
  1379. "movq  8(%1, %%eax), %%mm1 nt" // R BGR BGR B
  1380. "movq 10(%1, %%eax), %%mm2 nt" // GR BGR BGR
  1381. "pand %%mm7, %%mm0 nt"
  1382. "pand %%mm5, %%mm1 nt"
  1383. "pand %%mm6, %%mm2 nt"
  1384. "por %%mm0, %%mm1 nt"
  1385. "por %%mm2, %%mm1 nt"                
  1386. "movq 14(%1, %%eax), %%mm0 nt" // R BGR BGR B
  1387. MOVNTQ" %%mm1,  8(%2, %%eax) nt" // B RGB RGB R
  1388. "movq 16(%1, %%eax), %%mm1 nt" // GR BGR BGR
  1389. "movq 18(%1, %%eax), %%mm2 nt" // BGR BGR BG
  1390. "pand %%mm6, %%mm0 nt"
  1391. "pand %%mm7, %%mm1 nt"
  1392. "pand %%mm5, %%mm2 nt"
  1393. "por %%mm0, %%mm1 nt"
  1394. "por %%mm2, %%mm1 nt"                
  1395. MOVNTQ" %%mm1, 16(%2, %%eax) nt"
  1396. "addl $24, %%eax nt"
  1397. " js 1b nt"
  1398. : "+a" (mmx_size)
  1399. : "r" (src-mmx_size), "r"(dst-mmx_size)
  1400. );
  1402. __asm __volatile(SFENCE:::"memory");
  1403. __asm __volatile(EMMS:::"memory");
  1405. if(mmx_size==23) return; //finihsed, was multiple of 8
  1407. src+= src_size;
  1408. dst+= src_size;
  1409. src_size= 23-mmx_size;
  1410. src-= src_size;
  1411. dst-= src_size;
  1412. #endif
  1413. for(i=0; i<src_size; i+=3)
  1414. {
  1415. register uint8_t x;
  1416. x          = src[i + 2];
  1417. dst[i + 1] = src[i + 1];
  1418. dst[i + 2] = src[i + 0];
  1419. dst[i + 0] = x;
  1420. }
  1421. }
  1423. static inline void RENAME(yuvPlanartoyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
  1424. unsigned int width, unsigned int height,
  1425. int lumStride, int chromStride, int dstStride, int vertLumPerChroma)
  1426. {
  1427. unsigned y;
  1428. const unsigned chromWidth= width>>1;
  1429. for(y=0; y<height; y++)
  1430. {
  1431. #ifdef HAVE_MMX
  1432. //FIXME handle 2 lines a once (fewer prefetch, reuse some chrom, but very likely limited by mem anyway)
  1433. asm volatile(
  1434. "xorl %%eax, %%eax nt"
  1435. ".balign 16 nt"
  1436. "1: nt"
  1437. PREFETCH" 32(%1, %%eax, 2) nt"
  1438. PREFETCH" 32(%2, %%eax) nt"
  1439. PREFETCH" 32(%3, %%eax) nt"
  1440. "movq (%2, %%eax), %%mm0 nt" // U(0)
  1441. "movq %%mm0, %%mm2 nt" // U(0)
  1442. "movq (%3, %%eax), %%mm1 nt" // V(0)
  1443. "punpcklbw %%mm1, %%mm0 nt" // UVUV UVUV(0)
  1444. "punpckhbw %%mm1, %%mm2 nt" // UVUV UVUV(8)
  1446. "movq (%1, %%eax,2), %%mm3 nt" // Y(0)
  1447. "movq 8(%1, %%eax,2), %%mm5 nt" // Y(8)
  1448. "movq %%mm3, %%mm4 nt" // Y(0)
  1449. "movq %%mm5, %%mm6 nt" // Y(8)
  1450. "punpcklbw %%mm0, %%mm3 nt" // YUYV YUYV(0)
  1451. "punpckhbw %%mm0, %%mm4 nt" // YUYV YUYV(4)
  1452. "punpcklbw %%mm2, %%mm5 nt" // YUYV YUYV(8)
  1453. "punpckhbw %%mm2, %%mm6 nt" // YUYV YUYV(12)
  1455. MOVNTQ" %%mm3, (%0, %%eax, 4) nt"
  1456. MOVNTQ" %%mm4, 8(%0, %%eax, 4) nt"
  1457. MOVNTQ" %%mm5, 16(%0, %%eax, 4) nt"
  1458. MOVNTQ" %%mm6, 24(%0, %%eax, 4) nt"
  1460. "addl $8, %%eax nt"
  1461. "cmpl %4, %%eax nt"
  1462. " jb 1b nt"
  1463. ::"r"(dst), "r"(ysrc), "r"(usrc), "r"(vsrc), "g" (chromWidth)
  1464. : "%eax"
  1465. );
  1466. #else
  1468. #if defined ARCH_ALPHA && defined HAVE_MVI
  1469. #define pl2yuy2(n)
  1470. y1 = yc[n];
  1471. y2 = yc2[n];
  1472. u = uc[n];
  1473. v = vc[n];
  1474. asm("unpkbw %1, %0" : "=r"(y1) : "r"(y1));
  1475. asm("unpkbw %1, %0" : "=r"(y2) : "r"(y2));
  1476. asm("unpkbl %1, %0" : "=r"(u) : "r"(u));
  1477. asm("unpkbl %1, %0" : "=r"(v) : "r"(v));
  1478. yuv1 = (u << 8) + (v << 24);
  1479. yuv2 = yuv1 + y2;
  1480. yuv1 += y1;
  1481. qdst[n] = yuv1;
  1482. qdst2[n] = yuv2;
  1484. int i;
  1485. uint64_t *qdst = (uint64_t *) dst;
  1486. uint64_t *qdst2 = (uint64_t *) (dst + dstStride);
  1487. const uint32_t *yc = (uint32_t *) ysrc;
  1488. const uint32_t *yc2 = (uint32_t *) (ysrc + lumStride);
  1489. const uint16_t *uc = (uint16_t*) usrc, *vc = (uint16_t*) vsrc;
  1490. for(i = 0; i < chromWidth; i += 8){
  1491. uint64_t y1, y2, yuv1, yuv2;
  1492. uint64_t u, v;
  1493. /* Prefetch */
  1494. asm("ldq $31,64(%0)" :: "r"(yc));
  1495. asm("ldq $31,64(%0)" :: "r"(yc2));
  1496. asm("ldq $31,64(%0)" :: "r"(uc));
  1497. asm("ldq $31,64(%0)" :: "r"(vc));
  1499. pl2yuy2(0);
  1500. pl2yuy2(1);
  1501. pl2yuy2(2);
  1502. pl2yuy2(3);
  1504. yc += 4;
  1505. yc2 += 4;
  1506. uc += 4;
  1507. vc += 4;
  1508. qdst += 4;
  1509. qdst2 += 4;
  1510. }
  1511. y++;
  1512. ysrc += lumStride;
  1513. dst += dstStride;
  1515. #elif __WORDSIZE >= 64
  1516. int i;
  1517. uint64_t *ldst = (uint64_t *) dst;
  1518. const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
  1519. for(i = 0; i < chromWidth; i += 2){
  1520. uint64_t k, l;
  1521. k = yc[0] + (uc[0] << 8) +
  1522.     (yc[1] << 16) + (vc[0] << 24);
  1523. l = yc[2] + (uc[1] << 8) +
  1524.     (yc[3] << 16) + (vc[1] << 24);
  1525. *ldst++ = k + (l << 32);
  1526. yc += 4;
  1527. uc += 2;
  1528. vc += 2;
  1529. }
  1531. #else
  1532. int i, *idst = (int32_t *) dst;
  1533. const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
  1534. for(i = 0; i < chromWidth; i++){
  1535. #ifdef WORDS_BIGENDIAN
  1536. *idst++ = (yc[0] << 24)+ (uc[0] << 16) +
  1537.     (yc[1] << 8) + (vc[0] << 0);
  1538. #else
  1539. *idst++ = yc[0] + (uc[0] << 8) +
  1540.     (yc[1] << 16) + (vc[0] << 24);
  1541. #endif
  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" nt"
  1558.         SFENCE" nt"
  1559.         :::"memory");
  1560. #endif
  1561. }
  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. }
  1576. static inline void RENAME(yuvPlanartouyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
  1577. unsigned int width, unsigned int height,
  1578. int lumStride, int chromStride, int dstStride, int vertLumPerChroma)
  1579. {
  1580. unsigned y;
  1581. const unsigned chromWidth= width>>1;
  1582. for(y=0; y<height; y++)
  1583. {
  1584. #ifdef HAVE_MMX
  1585. //FIXME handle 2 lines a once (fewer prefetch, reuse some chrom, but very likely limited by mem anyway)
  1586. asm volatile(
  1587. "xorl %%eax, %%eax nt"
  1588. ".balign 16 nt"
  1589. "1: nt"
  1590. PREFETCH" 32(%1, %%eax, 2) nt"
  1591. PREFETCH" 32(%2, %%eax) nt"
  1592. PREFETCH" 32(%3, %%eax) nt"
  1593. "movq (%2, %%eax), %%mm0 nt" // U(0)
  1594. "movq %%mm0, %%mm2 nt" // U(0)
  1595. "movq (%3, %%eax), %%mm1 nt" // V(0)
  1596. "punpcklbw %%mm1, %%mm0 nt" // UVUV UVUV(0)
  1597. "punpckhbw %%mm1, %%mm2 nt" // UVUV UVUV(8)
  1599. "movq (%1, %%eax,2), %%mm3 nt" // Y(0)
  1600. "movq 8(%1, %%eax,2), %%mm5 nt" // Y(8)
  1601. "movq %%mm0, %%mm4 nt" // Y(0)
  1602. "movq %%mm2, %%mm6 nt" // Y(8)
  1603. "punpcklbw %%mm3, %%mm0 nt" // YUYV YUYV(0)
  1604. "punpckhbw %%mm3, %%mm4 nt" // YUYV YUYV(4)
  1605. "punpcklbw %%mm5, %%mm2 nt" // YUYV YUYV(8)
  1606. "punpckhbw %%mm5, %%mm6 nt" // YUYV YUYV(12)
  1608. MOVNTQ" %%mm0, (%0, %%eax, 4) nt"
  1609. MOVNTQ" %%mm4, 8(%0, %%eax, 4) nt"
  1610. MOVNTQ" %%mm2, 16(%0, %%eax, 4) nt"
  1611. MOVNTQ" %%mm6, 24(%0, %%eax, 4) nt"
  1613. "addl $8, %%eax nt"
  1614. "cmpl %4, %%eax nt"
  1615. " jb 1b nt"
  1616. ::"r"(dst), "r"(ysrc), "r"(usrc), "r"(vsrc), "g" (chromWidth)
  1617. : "%eax"
  1618. );
  1619. #else
  1620. //FIXME adapt the alpha asm code from yv12->yuy2
  1622. #if __WORDSIZE >= 64
  1623. int i;
  1624. uint64_t *ldst = (uint64_t *) dst;
  1625. const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
  1626. for(i = 0; i < chromWidth; i += 2){
  1627. uint64_t k, l;
  1628. k = uc[0] + (yc[0] << 8) +
  1629.     (vc[0] << 16) + (yc[1] << 24);
  1630. l = uc[1] + (yc[2] << 8) +
  1631.     (vc[1] << 16) + (yc[3] << 24);
  1632. *ldst++ = k + (l << 32);
  1633. yc += 4;
  1634. uc += 2;
  1635. vc += 2;
  1636. }
  1638. #else
  1639. int i, *idst = (int32_t *) dst;
  1640. const uint8_t *yc = ysrc, *uc = usrc, *vc = vsrc;
  1641. for(i = 0; i < chromWidth; i++){
  1642. #ifdef WORDS_BIGENDIAN
  1643. *idst++ = (uc[0] << 24)+ (yc[0] << 16) +
  1644.     (vc[0] << 8) + (yc[1] << 0);
  1645. #else
  1646. *idst++ = uc[0] + (yc[0] << 8) +
  1647.     (vc[0] << 16) + (yc[1] << 24);
  1648. #endif
  1649. yc += 2;
  1650. uc++;
  1651. vc++;
  1652. }
  1653. #endif
  1654. #endif
  1655. if((y&(vertLumPerChroma-1))==(vertLumPerChroma-1) )
  1656. {
  1657. usrc += chromStride;
  1658. vsrc += chromStride;
  1659. }
  1660. ysrc += lumStride;
  1661. dst += dstStride;
  1662. }
  1663. #ifdef HAVE_MMX
  1664. asm(    EMMS" nt"
  1665.         SFENCE" nt"
  1666.         :::"memory");
  1667. #endif
  1668. }
  1670. /**
  1671.  *
  1672.  * height should be a multiple of 2 and width should be a multiple of 16 (if this is a
  1673.  * problem for anyone then tell me, and ill fix it)
  1674.  */
  1675. static inline void RENAME(yv12touyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
  1676. unsigned int width, unsigned int height,
  1677. int lumStride, int chromStride, int dstStride)
  1678. {
  1679. //FIXME interpolate chroma
  1680. RENAME(yuvPlanartouyvy)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 2);
  1681. }
  1683. /**
  1684.  *
  1685.  * width should be a multiple of 16
  1686.  */
  1687. static inline void RENAME(yuv422ptoyuy2)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
  1688. unsigned int width, unsigned int height,
  1689. int lumStride, int chromStride, int dstStride)
  1690. {
  1691. RENAME(yuvPlanartoyuy2)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 1);
  1692. }
  1694. /**
  1695.  *
  1696.  * height should be a multiple of 2 and width should be a multiple of 16 (if this is a
  1697.  * problem for anyone then tell me, and ill fix it)
  1698.  */
  1699. static inline void RENAME(yuy2toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
  1700. unsigned int width, unsigned int height,
  1701. int lumStride, int chromStride, int srcStride)
  1702. {
  1703. unsigned y;
  1704. const unsigned chromWidth= width>>1;
  1705. for(y=0; y<height; y+=2)
  1706. {
  1707. #ifdef HAVE_MMX
  1708. asm volatile(
  1709. "xorl %%eax, %%eax nt"
  1710. "pcmpeqw %%mm7, %%mm7 nt"
  1711. "psrlw $8, %%mm7 nt" // FF,00,FF,00...
  1712. ".balign 16 nt"
  1713. "1: nt"
  1714. PREFETCH" 64(%0, %%eax, 4) nt"
  1715. "movq (%0, %%eax, 4), %%mm0 nt" // YUYV YUYV(0)
  1716. "movq 8(%0, %%eax, 4), %%mm1 nt" // YUYV YUYV(4)
  1717. "movq %%mm0, %%mm2 nt" // YUYV YUYV(0)
  1718. "movq %%mm1, %%mm3 nt" // YUYV YUYV(4)
  1719. "psrlw $8, %%mm0 nt" // U0V0 U0V0(0)
  1720. "psrlw $8, %%mm1 nt" // U0V0 U0V0(4)
  1721. "pand %%mm7, %%mm2 nt" // Y0Y0 Y0Y0(0)
  1722. "pand %%mm7, %%mm3 nt" // Y0Y0 Y0Y0(4)
  1723. "packuswb %%mm1, %%mm0 nt" // UVUV UVUV(0)
  1724. "packuswb %%mm3, %%mm2 nt" // YYYY YYYY(0)
  1726. MOVNTQ" %%mm2, (%1, %%eax, 2) nt"
  1728. "movq 16(%0, %%eax, 4), %%mm1 nt" // YUYV YUYV(8)
  1729. "movq 24(%0, %%eax, 4), %%mm2 nt" // YUYV YUYV(12)
  1730. "movq %%mm1, %%mm3 nt" // YUYV YUYV(8)
  1731. "movq %%mm2, %%mm4 nt" // YUYV YUYV(12)
  1732. "psrlw $8, %%mm1 nt" // U0V0 U0V0(8)
  1733. "psrlw $8, %%mm2 nt" // U0V0 U0V0(12)
  1734. "pand %%mm7, %%mm3 nt" // Y0Y0 Y0Y0(8)
  1735. "pand %%mm7, %%mm4 nt" // Y0Y0 Y0Y0(12)
  1736. "packuswb %%mm2, %%mm1 nt" // UVUV UVUV(8)
  1737. "packuswb %%mm4, %%mm3 nt" // YYYY YYYY(8)
  1739. MOVNTQ" %%mm3, 8(%1, %%eax, 2) nt"
  1741. "movq %%mm0, %%mm2 nt" // UVUV UVUV(0)
  1742. "movq %%mm1, %%mm3 nt" // UVUV UVUV(8)
  1743. "psrlw $8, %%mm0 nt" // V0V0 V0V0(0)
  1744. "psrlw $8, %%mm1 nt" // V0V0 V0V0(8)
  1745. "pand %%mm7, %%mm2 nt" // U0U0 U0U0(0)
  1746. "pand %%mm7, %%mm3 nt" // U0U0 U0U0(8)
  1747. "packuswb %%mm1, %%mm0 nt" // VVVV VVVV(0)
  1748. "packuswb %%mm3, %%mm2 nt" // UUUU UUUU(0)
  1750. MOVNTQ" %%mm0, (%3, %%eax) nt"
  1751. MOVNTQ" %%mm2, (%2, %%eax) nt"
  1753. "addl $8, %%eax nt"
  1754. "cmpl %4, %%eax nt"
  1755. " jb 1b nt"
  1756. ::"r"(src), "r"(ydst), "r"(udst), "r"(vdst), "g" (chromWidth)
  1757. : "memory", "%eax"
  1758. );
  1760. ydst += lumStride;
  1761. src  += srcStride;
  1763. asm volatile(
  1764. "xorl %%eax, %%eax nt"
  1765. ".balign 16 nt"
  1766. "1: nt"
  1767. PREFETCH" 64(%0, %%eax, 4) nt"
  1768. "movq (%0, %%eax, 4), %%mm0 nt" // YUYV YUYV(0)
  1769. "movq 8(%0, %%eax, 4), %%mm1 nt" // YUYV YUYV(4)
  1770. "movq 16(%0, %%eax, 4), %%mm2 nt" // YUYV YUYV(8)
  1771. "movq 24(%0, %%eax, 4), %%mm3 nt" // YUYV YUYV(12)
  1772. "pand %%mm7, %%mm0 nt" // Y0Y0 Y0Y0(0)
  1773. "pand %%mm7, %%mm1 nt" // Y0Y0 Y0Y0(4)
  1774. "pand %%mm7, %%mm2 nt" // Y0Y0 Y0Y0(8)
  1775. "pand %%mm7, %%mm3 nt" // Y0Y0 Y0Y0(12)
  1776. "packuswb %%mm1, %%mm0 nt" // YYYY YYYY(0)
  1777. "packuswb %%mm3, %%mm2 nt" // YYYY YYYY(8)
  1779. MOVNTQ" %%mm0, (%1, %%eax, 2) nt"
  1780. MOVNTQ" %%mm2, 8(%1, %%eax, 2) nt"
  1782. "addl $8, %%eax nt"
  1783. "cmpl %4, %%eax nt"
  1784. " jb 1b nt"
  1786. ::"r"(src), "r"(ydst), "r"(udst), "r"(vdst), "g" (chromWidth)
  1787. : "memory", "%eax"
  1788. );
  1789. #else
  1790. unsigned i;
  1791. for(i=0; i<chromWidth; i++)
  1792. {
  1793. ydst[2*i+0]  = src[4*i+0];
  1794. udst[i]  = src[4*i+1];
  1795. ydst[2*i+1]  = src[4*i+2];
  1796. vdst[i]  = src[4*i+3];
  1797. }
  1798. ydst += lumStride;
  1799. src  += srcStride;
  1801. for(i=0; i<chromWidth; i++)
  1802. {
  1803. ydst[2*i+0]  = src[4*i+0];
  1804. ydst[2*i+1]  = src[4*i+2];
  1805. }
  1806. #endif
  1807. udst += chromStride;
  1808. vdst += chromStride;
  1809. ydst += lumStride;
  1810. src  += srcStride;
  1811. }
  1812. #ifdef HAVE_MMX
  1813. asm volatile(   EMMS" nt"
  1814.          SFENCE" nt"
  1815.          :::"memory");
  1816. #endif
  1817. }
  1819. static inline void RENAME(yvu9toyv12)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc,
  1820. uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
  1821. unsigned int width, unsigned int height, int lumStride, int chromStride)
  1822. {
  1823. /* Y Plane */
  1824. memcpy(ydst, ysrc, width*height);
  1826. /* XXX: implement upscaling for U,V */
  1827. }
  1829. static inline void RENAME(planar2x)(const uint8_t *src, uint8_t *dst, int srcWidth, int srcHeight, int srcStride, int dstStride)
  1830. {
  1831. int x,y;
  1833. dst[0]= src[0];
  1834.         
  1835. // first line
  1836. for(x=0; x<srcWidth-1; x++){
  1837. dst[2*x+1]= (3*src[x] +   src[x+1])>>2;
  1838. dst[2*x+2]= (  src[x] + 3*src[x+1])>>2;
  1839. }
  1840. dst[2*srcWidth-1]= src[srcWidth-1];
  1842.         dst+= dstStride;
  1844. for(y=1; y<srcHeight; y++){
  1845. #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
  1846. const int mmxSize= srcWidth&~15;
  1847. asm volatile(
  1848. "movl %4, %%eax nt"
  1849. "1: nt"
  1850. "movq (%0, %%eax), %%mm0 nt"
  1851. "movq (%1, %%eax), %%mm1 nt"
  1852. "movq 1(%0, %%eax), %%mm2 nt"
  1853. "movq 1(%1, %%eax), %%mm3 nt"
  1854. "movq -1(%0, %%eax), %%mm4 nt"
  1855. "movq -1(%1, %%eax), %%mm5 nt"
  1856. PAVGB" %%mm0, %%mm5 nt"
  1857. PAVGB" %%mm0, %%mm3 nt"
  1858. PAVGB" %%mm0, %%mm5 nt"
  1859. PAVGB" %%mm0, %%mm3 nt"
  1860. PAVGB" %%mm1, %%mm4 nt"
  1861. PAVGB" %%mm1, %%mm2 nt"
  1862. PAVGB" %%mm1, %%mm4 nt"
  1863. PAVGB" %%mm1, %%mm2 nt"
  1864. "movq %%mm5, %%mm7 nt"
  1865. "movq %%mm4, %%mm6 nt"
  1866. "punpcklbw %%mm3, %%mm5 nt"
  1867. "punpckhbw %%mm3, %%mm7 nt"
  1868. "punpcklbw %%mm2, %%mm4 nt"
  1869. "punpckhbw %%mm2, %%mm6 nt"
  1870. #if 1
  1871. MOVNTQ" %%mm5, (%2, %%eax, 2) nt"
  1872. MOVNTQ" %%mm7, 8(%2, %%eax, 2) nt"
  1873. MOVNTQ" %%mm4, (%3, %%eax, 2) nt"
  1874. MOVNTQ" %%mm6, 8(%3, %%eax, 2) nt"
  1875. #else
  1876. "movq %%mm5, (%2, %%eax, 2) nt"
  1877. "movq %%mm7, 8(%2, %%eax, 2) nt"
  1878. "movq %%mm4, (%3, %%eax, 2) nt"
  1879. "movq %%mm6, 8(%3, %%eax, 2) nt"
  1880. #endif
  1881. "addl $8, %%eax nt"
  1882. " js 1b nt"
  1883. :: "r" (src + mmxSize  ), "r" (src + srcStride + mmxSize  ),
  1884.    "r" (dst + mmxSize*2), "r" (dst + dstStride + mmxSize*2),
  1885.    "g" (-mmxSize)
  1886. : "%eax"
  1888. );
  1889. #else
  1890. const int mmxSize=1;
  1891. #endif
  1892. dst[0        ]= (3*src[0] +   src[srcStride])>>2;
  1893. dst[dstStride]= (  src[0] + 3*src[srcStride])>>2;
  1895. for(x=mmxSize-1; x<srcWidth-1; x++){
  1896. dst[2*x          +1]= (3*src[x+0] +   src[x+srcStride+1])>>2;
  1897. dst[2*x+dstStride+2]= (  src[x+0] + 3*src[x+srcStride+1])>>2;
  1898. dst[2*x+dstStride+1]= (  src[x+1] + 3*src[x+srcStride  ])>>2;
  1899. dst[2*x          +2]= (3*src[x+1] +   src[x+srcStride  ])>>2;
  1900. }
  1901. dst[srcWidth*2 -1            ]= (3*src[srcWidth-1] +   src[srcWidth-1 + srcStride])>>2;
  1902. dst[srcWidth*2 -1 + dstStride]= (  src[srcWidth-1] + 3*src[srcWidth-1 + srcStride])>>2;
  1904. dst+=dstStride*2;
  1905. src+=srcStride;
  1906. }
  1908. // last line
  1909. #if 1
  1910. dst[0]= src[0];
  1911.         
  1912. for(x=0; x<srcWidth-1; x++){
  1913. dst[2*x+1]= (3*src[x] +   src[x+1])>>2;
  1914. dst[2*x+2]= (  src[x] + 3*src[x+1])>>2;
  1915. }
  1916. dst[2*srcWidth-1]= src[srcWidth-1];
  1917. #else
  1918. for(x=0; x<srcWidth; x++){
  1919. dst[2*x+0]=
  1920. dst[2*x+1]= src[x];
  1921. }
  1922. #endif
  1924. #ifdef HAVE_MMX
  1925. asm volatile(   EMMS" nt"
  1926.          SFENCE" nt"
  1927.          :::"memory");
  1928. #endif
  1929. }
  1931. /**
  1932.  *
  1933.  * height should be a multiple of 2 and width should be a multiple of 16 (if this is a
  1934.  * problem for anyone then tell me, and ill fix it)
  1935.  * chrominance data is only taken from every secound line others are ignored FIXME write HQ version
  1936.  */
  1937. static inline void RENAME(uyvytoyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
  1938. unsigned int width, unsigned int height,
  1939. int lumStride, int chromStride, int srcStride)
  1940. {
  1941. unsigned y;
  1942. const unsigned chromWidth= width>>1;
  1943. for(y=0; y<height; y+=2)
  1944. {
  1945. #ifdef HAVE_MMX
  1946. asm volatile(
  1947. "xorl %%eax, %%eax nt"
  1948. "pcmpeqw %%mm7, %%mm7 nt"
  1949. "psrlw $8, %%mm7 nt" // FF,00,FF,00...
  1950. ".balign 16 nt"
  1951. "1: nt"
  1952. PREFETCH" 64(%0, %%eax, 4) nt"
  1953. "movq (%0, %%eax, 4), %%mm0 nt" // UYVY UYVY(0)
  1954. "movq 8(%0, %%eax, 4), %%mm1 nt" // UYVY UYVY(4)
  1955. "movq %%mm0, %%mm2 nt" // UYVY UYVY(0)
  1956. "movq %%mm1, %%mm3 nt" // UYVY UYVY(4)
  1957. "pand %%mm7, %%mm0 nt" // U0V0 U0V0(0)
  1958. "pand %%mm7, %%mm1 nt" // U0V0 U0V0(4)
  1959. "psrlw $8, %%mm2 nt" // Y0Y0 Y0Y0(0)
  1960. "psrlw $8, %%mm3 nt" // Y0Y0 Y0Y0(4)
  1961. "packuswb %%mm1, %%mm0 nt" // UVUV UVUV(0)
  1962. "packuswb %%mm3, %%mm2 nt" // YYYY YYYY(0)
  1964. MOVNTQ" %%mm2, (%1, %%eax, 2) nt"
  1966. "movq 16(%0, %%eax, 4), %%mm1 nt" // UYVY UYVY(8)
  1967. "movq 24(%0, %%eax, 4), %%mm2 nt" // UYVY UYVY(12)
  1968. "movq %%mm1, %%mm3 nt" // UYVY UYVY(8)
  1969. "movq %%mm2, %%mm4 nt" // UYVY UYVY(12)
  1970. "pand %%mm7, %%mm1 nt" // U0V0 U0V0(8)
  1971. "pand %%mm7, %%mm2 nt" // U0V0 U0V0(12)
  1972. "psrlw $8, %%mm3 nt" // Y0Y0 Y0Y0(8)
  1973. "psrlw $8, %%mm4 nt" // Y0Y0 Y0Y0(12)
  1974. "packuswb %%mm2, %%mm1 nt" // UVUV UVUV(8)
  1975. "packuswb %%mm4, %%mm3 nt" // YYYY YYYY(8)
  1977. MOVNTQ" %%mm3, 8(%1, %%eax, 2) nt"
  1979. "movq %%mm0, %%mm2 nt" // UVUV UVUV(0)
  1980. "movq %%mm1, %%mm3 nt" // UVUV UVUV(8)
  1981. "psrlw $8, %%mm0 nt" // V0V0 V0V0(0)
  1982. "psrlw $8, %%mm1 nt" // V0V0 V0V0(8)
  1983. "pand %%mm7, %%mm2 nt" // U0U0 U0U0(0)
  1984. "pand %%mm7, %%mm3 nt" // U0U0 U0U0(8)
  1985. "packuswb %%mm1, %%mm0 nt" // VVVV VVVV(0)
  1986. "packuswb %%mm3, %%mm2 nt" // UUUU UUUU(0)
  1988. MOVNTQ" %%mm0, (%3, %%eax) nt"
  1989. MOVNTQ" %%mm2, (%2, %%eax) nt"
  1991. "addl $8, %%eax nt"
  1992. "cmpl %4, %%eax nt"
  1993. " jb 1b nt"
  1994. ::"r"(src), "r"(ydst), "r"(udst), "r"(vdst), "g" (chromWidth)
  1995. : "memory", "%eax"
  1996. );
  1998. ydst += lumStride;
  1999. src  += srcStride;
  2001. asm volatile(
  2002. "xorl %%eax, %%eax nt"
  2003. ".balign 16 nt"
  2004. "1: nt"
  2005. PREFETCH" 64(%0, %%eax, 4) nt"
  2006. "movq (%0, %%eax, 4), %%mm0 nt" // YUYV YUYV(0)
  2007. "movq 8(%0, %%eax, 4), %%mm1 nt" // YUYV YUYV(4)
  2008. "movq 16(%0, %%eax, 4), %%mm2 nt" // YUYV YUYV(8)
  2009. "movq 24(%0, %%eax, 4), %%mm3 nt" // YUYV YUYV(12)
  2010. "psrlw $8, %%mm0 nt" // Y0Y0 Y0Y0(0)
  2011. "psrlw $8, %%mm1 nt" // Y0Y0 Y0Y0(4)
  2012. "psrlw $8, %%mm2 nt" // Y0Y0 Y0Y0(8)
  2013. "psrlw $8, %%mm3 nt" // Y0Y0 Y0Y0(12)
  2014. "packuswb %%mm1, %%mm0 nt" // YYYY YYYY(0)
  2015. "packuswb %%mm3, %%mm2 nt" // YYYY YYYY(8)
  2017. MOVNTQ" %%mm0, (%1, %%eax, 2) nt"
  2018. MOVNTQ" %%mm2, 8(%1, %%eax, 2) nt"
  2020. "addl $8, %%eax nt"
  2021. "cmpl %4, %%eax nt"
  2022. " jb 1b nt"
  2024. ::"r"(src), "r"(ydst), "r"(udst), "r"(vdst), "g" (chromWidth)
  2025. : "memory", "%eax"
  2026. );
  2027. #else
  2028. unsigned i;
  2029. for(i=0; i<chromWidth; i++)
  2030. {
  2031. udst[i]  = src[4*i+0];
  2032. ydst[2*i+0]  = src[4*i+1];
  2033. vdst[i]  = src[4*i+2];
  2034. ydst[2*i+1]  = src[4*i+3];
  2035. }
  2036. ydst += lumStride;
  2037. src  += srcStride;
  2039. for(i=0; i<chromWidth; i++)
  2040. {
  2041. ydst[2*i+0]  = src[4*i+1];
  2042. ydst[2*i+1]  = src[4*i+3];
  2043. }
  2044. #endif
  2045. udst += chromStride;
  2046. vdst += chromStride;
  2047. ydst += lumStride;
  2048. src  += srcStride;
  2049. }
  2050. #ifdef HAVE_MMX
  2051. asm volatile(   EMMS" nt"
  2052.          SFENCE" nt"
  2053.          :::"memory");
  2054. #endif
  2055. }
  2057. /**
  2058.  *
  2059.  * height should be a multiple of 2 and width should be a multiple of 2 (if this is a
  2060.  * problem for anyone then tell me, and ill fix it)
  2061.  * chrominance data is only taken from every secound line others are ignored in the C version FIXME write HQ version
  2062.  */
  2063. static inline void RENAME(rgb24toyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
  2064. unsigned int width, unsigned int height,
  2065. int lumStride, int chromStride, int srcStride)
  2066. {
  2067. unsigned y;
  2068. const unsigned chromWidth= width>>1;
  2069. #ifdef HAVE_MMX
  2070. for(y=0; y<height-2; y+=2)
  2071. {
  2072. unsigned i;
  2073. for(i=0; i<2; i++)
  2074. {
  2075. asm volatile(
  2076. "movl %2, %%eax nt"
  2077. "movq "MANGLE(bgr2YCoeff)", %%mm6 nt"
  2078. "movq "MANGLE(w1111)", %%mm5 nt"
  2079. "pxor %%mm7, %%mm7 nt"
  2080. "leal (%%eax, %%eax, 2), %%ebx nt"
  2081. ".balign 16 nt"
  2082. "1: nt"
  2083. PREFETCH" 64(%0, %%ebx) nt"
  2084. "movd (%0, %%ebx), %%mm0 nt"
  2085. "movd 3(%0, %%ebx), %%mm1 nt"
  2086. "punpcklbw %%mm7, %%mm0 nt"
  2087. "punpcklbw %%mm7, %%mm1 nt"
  2088. "movd 6(%0, %%ebx), %%mm2 nt"
  2089. "movd 9(%0, %%ebx), %%mm3 nt"
  2090. "punpcklbw %%mm7, %%mm2 nt"
  2091. "punpcklbw %%mm7, %%mm3 nt"
  2092. "pmaddwd %%mm6, %%mm0 nt"
  2093. "pmaddwd %%mm6, %%mm1 nt"
  2094. "pmaddwd %%mm6, %%mm2 nt"
  2095. "pmaddwd %%mm6, %%mm3 nt"
  2096. #ifndef FAST_BGR2YV12
  2097. "psrad $8, %%mm0 nt"
  2098. "psrad $8, %%mm1 nt"
  2099. "psrad $8, %%mm2 nt"
  2100. "psrad $8, %%mm3 nt"
  2101. #endif
  2102. "packssdw %%mm1, %%mm0 nt"
  2103. "packssdw %%mm3, %%mm2 nt"
  2104. "pmaddwd %%mm5, %%mm0 nt"
  2105. "pmaddwd %%mm5, %%mm2 nt"
  2106. "packssdw %%mm2, %%mm0 nt"
  2107. "psraw $7, %%mm0 nt"
  2109. "movd 12(%0, %%ebx), %%mm4 nt"
  2110. "movd 15(%0, %%ebx), %%mm1 nt"
  2111. "punpcklbw %%mm7, %%mm4 nt"
  2112. "punpcklbw %%mm7, %%mm1 nt"
  2113. "movd 18(%0, %%ebx), %%mm2 nt"
  2114. "movd 21(%0, %%ebx), %%mm3 nt"
  2115. "punpcklbw %%mm7, %%mm2 nt"
  2116. "punpcklbw %%mm7, %%mm3 nt"
  2117. "pmaddwd %%mm6, %%mm4 nt"
  2118. "pmaddwd %%mm6, %%mm1 nt"
  2119. "pmaddwd %%mm6, %%mm2 nt"
  2120. "pmaddwd %%mm6, %%mm3 nt"
  2121. #ifndef FAST_BGR2YV12
  2122. "psrad $8, %%mm4 nt"
  2123. "psrad $8, %%mm1 nt"
  2124. "psrad $8, %%mm2 nt"
  2125. "psrad $8, %%mm3 nt"
  2126. #endif
  2127. "packssdw %%mm1, %%mm4 nt"
  2128. "packssdw %%mm3, %%mm2 nt"
  2129. "pmaddwd %%mm5, %%mm4 nt"
  2130. "pmaddwd %%mm5, %%mm2 nt"
  2131. "addl $24, %%ebx nt"
  2132. "packssdw %%mm2, %%mm4 nt"
  2133. "psraw $7, %%mm4 nt"
  2135. "packuswb %%mm4, %%mm0 nt"
  2136. "paddusb "MANGLE(bgr2YOffset)", %%mm0 nt"
  2138. MOVNTQ" %%mm0, (%1, %%eax) nt"
  2139. "addl $8, %%eax nt"
  2140. " js 1b nt"
  2141. : : "r" (src+width*3), "r" (ydst+width), "g" (-width)
  2142. : "%eax", "%ebx"
  2143. );
  2144. ydst += lumStride;
  2145. src  += srcStride;
  2146. }
  2147. src -= srcStride*2;
  2148. asm volatile(
  2149. "movl %4, %%eax nt"
  2150. "movq "MANGLE(w1111)", %%mm5 nt"
  2151. "movq "MANGLE(bgr2UCoeff)", %%mm6 nt"
  2152. "pxor %%mm7, %%mm7 nt"
  2153. "leal (%%eax, %%eax, 2), %%ebx nt"
  2154. "addl %%ebx, %%ebx nt"
  2155. ".balign 16 nt"
  2156. "1: nt"
  2157. PREFETCH" 64(%0, %%ebx) nt"
  2158. PREFETCH" 64(%1, %%ebx) nt"
  2159. #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
  2160. "movq (%0, %%ebx), %%mm0 nt"
  2161. "movq (%1, %%ebx), %%mm1 nt"
  2162. "movq 6(%0, %%ebx), %%mm2 nt"
  2163. "movq 6(%1, %%ebx), %%mm3 nt"
  2164. PAVGB" %%mm1, %%mm0 nt"
  2165. PAVGB" %%mm3, %%mm2 nt"
  2166. "movq %%mm0, %%mm1 nt"
  2167. "movq %%mm2, %%mm3 nt"
  2168. "psrlq $24, %%mm0 nt"
  2169. "psrlq $24, %%mm2 nt"
  2170. PAVGB" %%mm1, %%mm0 nt"
  2171. PAVGB" %%mm3, %%mm2 nt"
  2172. "punpcklbw %%mm7, %%mm0 nt"
  2173. "punpcklbw %%mm7, %%mm2 nt"
  2174. #else
  2175. "movd (%0, %%ebx), %%mm0 nt"
  2176. "movd (%1, %%ebx), %%mm1 nt"
  2177. "movd 3(%0, %%ebx), %%mm2 nt"
  2178. "movd 3(%1, %%ebx), %%mm3 nt"
  2179. "punpcklbw %%mm7, %%mm0 nt"
  2180. "punpcklbw %%mm7, %%mm1 nt"
  2181. "punpcklbw %%mm7, %%mm2 nt"
  2182. "punpcklbw %%mm7, %%mm3 nt"
  2183. "paddw %%mm1, %%mm0 nt"
  2184. "paddw %%mm3, %%mm2 nt"
  2185. "paddw %%mm2, %%mm0 nt"
  2186. "movd 6(%0, %%ebx), %%mm4 nt"
  2187. "movd 6(%1, %%ebx), %%mm1 nt"
  2188. "movd 9(%0, %%ebx), %%mm2 nt"
  2189. "movd 9(%1, %%ebx), %%mm3 nt"
  2190. "punpcklbw %%mm7, %%mm4 nt"
  2191. "punpcklbw %%mm7, %%mm1 nt"
  2192. "punpcklbw %%mm7, %%mm2 nt"
  2193. "punpcklbw %%mm7, %%mm3 nt"
  2194. "paddw %%mm1, %%mm4 nt"
  2195. "paddw %%mm3, %%mm2 nt"
  2196. "paddw %%mm4, %%mm2 nt"
  2197. "psrlw $2, %%mm0 nt"
  2198. "psrlw $2, %%mm2 nt"
  2199. #endif
  2200. "movq "MANGLE(bgr2VCoeff)", %%mm1 nt"
  2201. "movq "MANGLE(bgr2VCoeff)", %%mm3 nt"
  2203. "pmaddwd %%mm0, %%mm1 nt"
  2204. "pmaddwd %%mm2, %%mm3 nt"
  2205. "pmaddwd %%mm6, %%mm0 nt"
  2206. "pmaddwd %%mm6, %%mm2 nt"
  2207. #ifndef FAST_BGR2YV12
  2208. "psrad $8, %%mm0 nt"
  2209. "psrad $8, %%mm1 nt"
  2210. "psrad $8, %%mm2 nt"
  2211. "psrad $8, %%mm3 nt"
  2212. #endif
  2213. "packssdw %%mm2, %%mm0 nt"
  2214. "packssdw %%mm3, %%mm1 nt"
  2215. "pmaddwd %%mm5, %%mm0 nt"
  2216. "pmaddwd %%mm5, %%mm1 nt"
  2217. "packssdw %%mm1, %%mm0 nt" // V1 V0 U1 U0
  2218. "psraw $7, %%mm0 nt"
  2220. #if defined (HAVE_MMX2) || defined (HAVE_3DNOW)
  2221. "movq 12(%0, %%ebx), %%mm4 nt"
  2222. "movq 12(%1, %%ebx), %%mm1 nt"
  2223. "movq 18(%0, %%ebx), %%mm2 nt"
  2224. "movq 18(%1, %%ebx), %%mm3 nt"
  2225. PAVGB" %%mm1, %%mm4 nt"
  2226. PAVGB" %%mm3, %%mm2 nt"
  2227. "movq %%mm4, %%mm1 nt"
  2228. "movq %%mm2, %%mm3 nt"
  2229. "psrlq $24, %%mm4 nt"
  2230. "psrlq $24, %%mm2 nt"
  2231. PAVGB" %%mm1, %%mm4 nt"
  2232. PAVGB" %%mm3, %%mm2 nt"
  2233. "punpcklbw %%mm7, %%mm4 nt"
  2234. "punpcklbw %%mm7, %%mm2 nt"
  2235. #else
  2236. "movd 12(%0, %%ebx), %%mm4 nt"
  2237. "movd 12(%1, %%ebx), %%mm1 nt"
  2238. "movd 15(%0, %%ebx), %%mm2 nt"
  2239. "movd 15(%1, %%ebx), %%mm3 nt"
  2240. "punpcklbw %%mm7, %%mm4 nt"
  2241. "punpcklbw %%mm7, %%mm1 nt"
  2242. "punpcklbw %%mm7, %%mm2 nt"
  2243. "punpcklbw %%mm7, %%mm3 nt"
  2244. "paddw %%mm1, %%mm4 nt"
  2245. "paddw %%mm3, %%mm2 nt"
  2246. "paddw %%mm2, %%mm4 nt"
  2247. "movd 18(%0, %%ebx), %%mm5 nt"
  2248. "movd 18(%1, %%ebx), %%mm1 nt"
  2249. "movd 21(%0, %%ebx), %%mm2 nt"
  2250. "movd 21(%1, %%ebx), %%mm3 nt"
  2251. "punpcklbw %%mm7, %%mm5 nt"
  2252. "punpcklbw %%mm7, %%mm1 nt"
  2253. "punpcklbw %%mm7, %%mm2 nt"
  2254. "punpcklbw %%mm7, %%mm3 nt"
  2255. "paddw %%mm1, %%mm5 nt"
  2256. "paddw %%mm3, %%mm2 nt"
  2257. "paddw %%mm5, %%mm2 nt"
  2258. "movq "MANGLE(w1111)", %%mm5 nt"
  2259. "psrlw $2, %%mm4 nt"
  2260. "psrlw $2, %%mm2 nt"
  2261. #endif
  2262. "movq "MANGLE(bgr2VCoeff)", %%mm1 nt"
  2263. "movq "MANGLE(bgr2VCoeff)", %%mm3 nt"
  2265. "pmaddwd %%mm4, %%mm1 nt"
  2266. "pmaddwd %%mm2, %%mm3 nt"
  2267. "pmaddwd %%mm6, %%mm4 nt"
  2268. "pmaddwd %%mm6, %%mm2 nt"
  2269. #ifndef FAST_BGR2YV12
  2270. "psrad $8, %%mm4 nt"
  2271. "psrad $8, %%mm1 nt"
  2272. "psrad $8, %%mm2 nt"
  2273. "psrad $8, %%mm3 nt"
  2274. #endif
  2275. "packssdw %%mm2, %%mm4 nt"
  2276. "packssdw %%mm3, %%mm1 nt"
  2277. "pmaddwd %%mm5, %%mm4 nt"
  2278. "pmaddwd %%mm5, %%mm1 nt"
  2279. "addl $24, %%ebx nt"
  2280. "packssdw %%mm1, %%mm4 nt" // V3 V2 U3 U2
  2281. "psraw $7, %%mm4 nt"
  2283. "movq %%mm0, %%mm1 nt"
  2284. "punpckldq %%mm4, %%mm0 nt"
  2285. "punpckhdq %%mm4, %%mm1 nt"
  2286. "packsswb %%mm1, %%mm0 nt"
  2287. "paddb "MANGLE(bgr2UVOffset)", %%mm0 nt"
  2289. "movd %%mm0, (%2, %%eax) nt"
  2290. "punpckhdq %%mm0, %%mm0 nt"
  2291. "movd %%mm0, (%3, %%eax) nt"
  2292. "addl $4, %%eax nt"
  2293. " js 1b nt"
  2294. : : "r" (src+chromWidth*6), "r" (src+srcStride+chromWidth*6), "r" (udst+chromWidth), "r" (vdst+chromWidth), "g" (-chromWidth)
  2295. : "%eax", "%ebx"
  2296. );
  2298. udst += chromStride;
  2299. vdst += chromStride;
  2300. src  += srcStride*2;
  2301. }
  2303. asm volatile(   EMMS" nt"
  2304. SFENCE" nt"
  2305. :::"memory");
  2306. #else
  2307. y=0;
  2308. #endif
  2309. for(; y<height; y+=2)
  2310. {
  2311. unsigned i;
  2312. for(i=0; i<chromWidth; i++)
  2313. {
  2314. unsigned int b= src[6*i+0];
  2315. unsigned int g= src[6*i+1];
  2316. unsigned int r= src[6*i+2];
  2318. unsigned int Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
  2319. unsigned int V  =  ((RV*r + GV*g + BV*b)>>RGB2YUV_SHIFT) + 128;
  2320. unsigned int U  =  ((RU*r + GU*g + BU*b)>>RGB2YUV_SHIFT) + 128;
  2322. udst[i]  = U;
  2323. vdst[i]  = V;
  2324. ydst[2*i]  = Y;
  2326. b= src[6*i+3];
  2327. g= src[6*i+4];
  2328. r= src[6*i+5];
  2330. Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
  2331. ydst[2*i+1]  = Y;
  2332. }
  2333. ydst += lumStride;
  2334. src  += srcStride;
  2336. for(i=0; i<chromWidth; i++)
  2337. {
  2338. unsigned int b= src[6*i+0];
  2339. unsigned int g= src[6*i+1];
  2340. unsigned int r= src[6*i+2];
  2342. unsigned int Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
  2344. ydst[2*i]  = Y;
  2346. b= src[6*i+3];
  2347. g= src[6*i+4];
  2348. r= src[6*i+5];
  2350. Y  =  ((RY*r + GY*g + BY*b)>>RGB2YUV_SHIFT) + 16;
  2351. ydst[2*i+1]  = Y;
  2352. }
  2353. udst += chromStride;
  2354. vdst += chromStride;
  2355. ydst += lumStride;
  2356. src  += srcStride;
  2357. }
  2358. }
  2360. void RENAME(interleaveBytes)(uint8_t *src1, uint8_t *src2, uint8_t *dest,
  2361.     unsigned width, unsigned height, int src1Stride,
  2362.     int src2Stride, int dstStride){
  2363. unsigned h;
  2365. for(h=0; h < height; h++)
  2366. {
  2367. unsigned w;
  2369. #ifdef HAVE_MMX
  2370. #ifdef HAVE_SSE2
  2371. asm(
  2372. "xorl %%eax, %%eax nt"
  2373. "1: nt"
  2374. PREFETCH" 64(%1, %%eax) nt"
  2375. PREFETCH" 64(%2, %%eax) nt"
  2376. "movdqa (%1, %%eax), %%xmm0 nt"
  2377. "movdqa (%1, %%eax), %%xmm1 nt"
  2378. "movdqa (%2, %%eax), %%xmm2 nt"
  2379. "punpcklbw %%xmm2, %%xmm0 nt"
  2380. "punpckhbw %%xmm2, %%xmm1 nt"
  2381. "movntdq %%xmm0, (%0, %%eax, 2) nt"
  2382. "movntdq %%xmm1, 16(%0, %%eax, 2)nt"
  2383. "addl $16, %%eax nt"
  2384. "cmpl %3, %%eax nt"
  2385. " jb 1b nt"
  2386. ::"r"(dest), "r"(src1), "r"(src2), "r" (width-15)
  2387. : "memory", "%eax"
  2388. );
  2389. #else
  2390. asm(
  2391. "xorl %%eax, %%eax nt"
  2392. "1: nt"
  2393. PREFETCH" 64(%1, %%eax) nt"
  2394. PREFETCH" 64(%2, %%eax) nt"
  2395. "movq (%1, %%eax), %%mm0 nt"
  2396. "movq 8(%1, %%eax), %%mm2 nt"
  2397. "movq %%mm0, %%mm1 nt"
  2398. "movq %%mm2, %%mm3 nt"
  2399. "movq (%2, %%eax), %%mm4 nt"
  2400. "movq 8(%2, %%eax), %%mm5 nt"
  2401. "punpcklbw %%mm4, %%mm0 nt"
  2402. "punpckhbw %%mm4, %%mm1 nt"
  2403. "punpcklbw %%mm5, %%mm2 nt"
  2404. "punpckhbw %%mm5, %%mm3 nt"
  2405. MOVNTQ" %%mm0, (%0, %%eax, 2) nt"
  2406. MOVNTQ" %%mm1, 8(%0, %%eax, 2) nt"
  2407. MOVNTQ" %%mm2, 16(%0, %%eax, 2) nt"
  2408. MOVNTQ" %%mm3, 24(%0, %%eax, 2) nt"
  2409. "addl $16, %%eax nt"
  2410. "cmpl %3, %%eax nt"
  2411. " jb 1b nt"
  2412. ::"r"(dest), "r"(src1), "r"(src2), "r" (width-15)
  2413. : "memory", "%eax"
  2414. );
  2415. #endif
  2416. for(w= (width&(~15)); w < width; w++)
  2417. {
  2418. dest[2*w+0] = src1[w];
  2419. dest[2*w+1] = src2[w];
  2420. }
  2421. #else
  2422. for(w=0; w < width; w++)
  2423. {
  2424. dest[2*w+0] = src1[w];
  2425. dest[2*w+1] = src2[w];
  2426. }
  2427. #endif
  2428. dest += dstStride;
  2429.                 src1 += src1Stride;
  2430.                 src2 += src2Stride;
  2431. }
  2432. #ifdef HAVE_MMX
  2433. asm(
  2434. EMMS" nt"
  2435. SFENCE" nt"
  2436. ::: "memory"
  2437. );
  2438. #endif
  2439. }
  2441. static inline void RENAME(vu9_to_vu12)(const uint8_t *src1, const uint8_t *src2,
  2442. uint8_t *dst1, uint8_t *dst2,
  2443. unsigned width, unsigned height,
  2444. int srcStride1, int srcStride2,
  2445. int dstStride1, int dstStride2)
  2446. {
  2447.     unsigned int y,x,h;
  2448.     int w;
  2449.     w=width/2; h=height/2;
  2450. #ifdef HAVE_MMX
  2451.     asm volatile(
  2452. PREFETCH" %0nt"
  2453. PREFETCH" %1nt"
  2454. ::"m"(*(src1+srcStride1)),"m"(*(src2+srcStride2)):"memory");
  2455. #endif
  2456.     for(y=0;y<h;y++){
  2457. const uint8_t* s1=src1+srcStride1*(y>>1);
  2458. uint8_t* d=dst1+dstStride1*y;
  2459. x=0;
  2460. #ifdef HAVE_MMX
  2461. for(;x<w-31;x+=32)
  2462. {
  2463.     asm volatile(
  2464. PREFETCH" 32%1nt"
  2465.         "movq %1, %%mm0nt"
  2466.         "movq 8%1, %%mm2nt"
  2467.         "movq 16%1, %%mm4nt"
  2468.         "movq 24%1, %%mm6nt"
  2469.         "movq %%mm0, %%mm1nt"
  2470.         "movq %%mm2, %%mm3nt"
  2471.         "movq %%mm4, %%mm5nt"
  2472.         "movq %%mm6, %%mm7nt"
  2473. "punpcklbw %%mm0, %%mm0nt"
  2474. "punpckhbw %%mm1, %%mm1nt"
  2475. "punpcklbw %%mm2, %%mm2nt"
  2476. "punpckhbw %%mm3, %%mm3nt"
  2477. "punpcklbw %%mm4, %%mm4nt"
  2478. "punpckhbw %%mm5, %%mm5nt"
  2479. "punpcklbw %%mm6, %%mm6nt"
  2480. "punpckhbw %%mm7, %%mm7nt"
  2481. MOVNTQ" %%mm0, %0nt"
  2482. MOVNTQ" %%mm1, 8%0nt"
  2483. MOVNTQ" %%mm2, 16%0nt"
  2484. MOVNTQ" %%mm3, 24%0nt"
  2485. MOVNTQ" %%mm4, 32%0nt"
  2486. MOVNTQ" %%mm5, 40%0nt"
  2487. MOVNTQ" %%mm6, 48%0nt"
  2488. MOVNTQ" %%mm7, 56%0"
  2489. :"=m"(d[2*x])
  2490. :"m"(s1[x])
  2491. :"memory");
  2492. }
  2493. #endif
  2494. for(;x<w;x++) d[2*x]=d[2*x+1]=s1[x];
  2495.     }
  2496.     for(y=0;y<h;y++){
  2497. const uint8_t* s2=src2+srcStride2*(y>>1);
  2498. uint8_t* d=dst2+dstStride2*y;
  2499. x=0;
  2500. #ifdef HAVE_MMX
  2501. for(;x<w-31;x+=32)
  2502. {
  2503.     asm volatile(
  2504. PREFETCH" 32%1nt"
  2505.         "movq %1, %%mm0nt"
  2506.         "movq 8%1, %%mm2nt"
  2507.         "movq 16%1, %%mm4nt"
  2508.         "movq 24%1, %%mm6nt"
  2509.         "movq %%mm0, %%mm1nt"
  2510.         "movq %%mm2, %%mm3nt"
  2511.         "movq %%mm4, %%mm5nt"
  2512.         "movq %%mm6, %%mm7nt"
  2513. "punpcklbw %%mm0, %%mm0nt"
  2514. "punpckhbw %%mm1, %%mm1nt"
  2515. "punpcklbw %%mm2, %%mm2nt"
  2516. "punpckhbw %%mm3, %%mm3nt"
  2517. "punpcklbw %%mm4, %%mm4nt"
  2518. "punpckhbw %%mm5, %%mm5nt"
  2519. "punpcklbw %%mm6, %%mm6nt"
  2520. "punpckhbw %%mm7, %%mm7nt"
  2521. MOVNTQ" %%mm0, %0nt"
  2522. MOVNTQ" %%mm1, 8%0nt"
  2523. MOVNTQ" %%mm2, 16%0nt"
  2524. MOVNTQ" %%mm3, 24%0nt"
  2525. MOVNTQ" %%mm4, 32%0nt"
  2526. MOVNTQ" %%mm5, 40%0nt"
  2527. MOVNTQ" %%mm6, 48%0nt"
  2528. MOVNTQ" %%mm7, 56%0"
  2529. :"=m"(d[2*x])
  2530. :"m"(s2[x])
  2531. :"memory");
  2532. }
  2533. #endif
  2534. for(;x<w;x++) d[2*x]=d[2*x+1]=s2[x];
  2535.     }
  2536. #ifdef HAVE_MMX
  2537. asm(
  2538. EMMS" nt"
  2539. SFENCE" nt"
  2540. ::: "memory"
  2541. );
  2542. #endif
  2543. }
  2545. static inline void RENAME(yvu9_to_yuy2)(const uint8_t *src1, const uint8_t *src2, const uint8_t *src3,
  2546. uint8_t *dst,
  2547. unsigned width, unsigned height,
  2548. int srcStride1, int srcStride2,
  2549. int srcStride3, int dstStride)
  2550. {
  2551.     unsigned y,x,w,h;
  2552.     w=width/2; h=height;
  2553.     for(y=0;y<h;y++){
  2554. const uint8_t* yp=src1+srcStride1*y;
  2555. const uint8_t* up=src2+srcStride2*(y>>2);
  2556. const uint8_t* vp=src3+srcStride3*(y>>2);
  2557. uint8_t* d=dst+dstStride*y;
  2558. x=0;
  2559. #ifdef HAVE_MMX
  2560. for(;x<w-7;x+=8)
  2561. {
  2562.     asm volatile(
  2563. PREFETCH" 32(%1, %0)nt"
  2564. PREFETCH" 32(%2, %0)nt"
  2565. PREFETCH" 32(%3, %0)nt"
  2566. "movq (%1, %0, 4), %%mm0nt"       /* Y0Y1Y2Y3Y4Y5Y6Y7 */
  2567. "movq (%2, %0), %%mm1nt"       /* U0U1U2U3U4U5U6U7 */
  2568. "movq (%3, %0), %%mm2nt"      /* V0V1V2V3V4V5V6V7 */
  2569. "movq %%mm0, %%mm3nt"    /* Y0Y1Y2Y3Y4Y5Y6Y7 */
  2570. "movq %%mm1, %%mm4nt"    /* U0U1U2U3U4U5U6U7 */
  2571. "movq %%mm2, %%mm5nt"    /* V0V1V2V3V4V5V6V7 */
  2572. "punpcklbw %%mm1, %%mm1nt" /* U0U0 U1U1 U2U2 U3U3 */
  2573. "punpcklbw %%mm2, %%mm2nt" /* V0V0 V1V1 V2V2 V3V3 */
  2574. "punpckhbw %%mm4, %%mm4nt" /* U4U4 U5U5 U6U6 U7U7 */
  2575. "punpckhbw %%mm5, %%mm5nt" /* V4V4 V5V5 V6V6 V7V7 */
  2577. "movq %%mm1, %%mm6nt"
  2578. "punpcklbw %%mm2, %%mm1nt" /* U0V0 U0V0 U1V1 U1V1*/
  2579. "punpcklbw %%mm1, %%mm0nt" /* Y0U0 Y1V0 Y2U0 Y3V0*/
  2580. "punpckhbw %%mm1, %%mm3nt" /* Y4U1 Y5V1 Y6U1 Y7V1*/
  2581. MOVNTQ" %%mm0, (%4, %0, 8)nt"
  2582. MOVNTQ" %%mm3, 8(%4, %0, 8)nt"
  2584. "punpckhbw %%mm2, %%mm6nt" /* U2V2 U2V2 U3V3 U3V3*/
  2585. "movq 8(%1, %0, 4), %%mm0nt"
  2586. "movq %%mm0, %%mm3nt"
  2587. "punpcklbw %%mm6, %%mm0nt" /* Y U2 Y V2 Y U2 Y V2*/
  2588. "punpckhbw %%mm6, %%mm3nt" /* Y U3 Y V3 Y U3 Y V3*/
  2589. MOVNTQ" %%mm0, 16(%4, %0, 8)nt"
  2590. MOVNTQ" %%mm3, 24(%4, %0, 8)nt"
  2592. "movq %%mm4, %%mm6nt"
  2593. "movq 16(%1, %0, 4), %%mm0nt"
  2594. "movq %%mm0, %%mm3nt"
  2595. "punpcklbw %%mm5, %%mm4nt"
  2596. "punpcklbw %%mm4, %%mm0nt" /* Y U4 Y V4 Y U4 Y V4*/
  2597. "punpckhbw %%mm4, %%mm3nt" /* Y U5 Y V5 Y U5 Y V5*/
  2598. MOVNTQ" %%mm0, 32(%4, %0, 8)nt"
  2599. MOVNTQ" %%mm3, 40(%4, %0, 8)nt"
  2601. "punpckhbw %%mm5, %%mm6nt"
  2602. "movq 24(%1, %0, 4), %%mm0nt"
  2603. "movq %%mm0, %%mm3nt"
  2604. "punpcklbw %%mm6, %%mm0nt" /* Y U6 Y V6 Y U6 Y V6*/
  2605. "punpckhbw %%mm6, %%mm3nt" /* Y U7 Y V7 Y U7 Y V7*/
  2606. MOVNTQ" %%mm0, 48(%4, %0, 8)nt"
  2607. MOVNTQ" %%mm3, 56(%4, %0, 8)nt"
  2609. : "+r" (x)
  2610.                 : "r"(yp), "r" (up), "r"(vp), "r"(d)
  2611. :"memory");
  2612. }
  2613. #endif
  2614. for(; x<w; x++)
  2615. {
  2616.     const int x2= x<<2;
  2617.     d[8*x+0]=yp[x2];
  2618.     d[8*x+1]=up[x];
  2619.     d[8*x+2]=yp[x2+1];
  2620.     d[8*x+3]=vp[x];
  2621.     d[8*x+4]=yp[x2+2];
  2622.     d[8*x+5]=up[x];
  2623.     d[8*x+6]=yp[x2+3];
  2624.     d[8*x+7]=vp[x];
  2625. }
  2626.     }
  2627. #ifdef HAVE_MMX
  2628. asm(
  2629. EMMS" nt"
  2630. SFENCE" nt"
  2631. ::: "memory"
  2632. );
  2633. #endif
  2634. }