i422_yuy2.h
上传用户:kjfoods
上传日期:2020-07-06
资源大小:29949k
文件大小:16k
源码类别:

midi

开发平台:

Unix_Linux

  1. /*****************************************************************************
  2.  * i422_yuy2.h : YUV to YUV conversion module for vlc
  3.  *****************************************************************************
  4.  * Copyright (C) 2002 the VideoLAN team
  5.  * $Id: 52ad7e4c3fd571c65b319714141afcceb4ad58d6 $
  6.  *
  7.  * Authors: Samuel Hocevar <sam@zoy.org>
  8.  *          Damien Fouilleul <damienf@videolan.org>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23.  *****************************************************************************/
  24. #ifdef MODULE_NAME_IS_i422_yuy2_mmx
  25. #if defined(CAN_COMPILE_MMX)
  26. /* MMX assembly */
  27.  
  28. #define MMX_CALL(MMX_INSTRUCTIONS)          
  29.     do {                                    
  30.     __asm__ __volatile__(                   
  31.         ".p2align 3 nt"                   
  32.         MMX_INSTRUCTIONS                    
  33.         :                                   
  34.         : "r" (p_line), "r" (p_y),          
  35.           "r" (p_u), "r" (p_v) );           
  36.         p_line += 16; p_y += 8;             
  37.         p_u += 4; p_v += 4;                 
  38.     } while(0)
  39. #define MMX_END __asm__ __volatile__ ( "emms" )
  40. #define MMX_YUV422_YUYV "                                                 n
  41. movq       (%1), %%mm0  # Load 8 Y            y7 y6 y5 y4 y3 y2 y1 y0     n
  42. movd       (%2), %%mm1  # Load 4 Cb           00 00 00 00 u3 u2 u1 u0     n
  43. movd       (%3), %%mm2  # Load 4 Cr           00 00 00 00 v3 v2 v1 v0     n
  44. punpcklbw %%mm2, %%mm1  #                     v3 u3 v2 u2 v1 u1 v0 u0     n
  45. movq      %%mm0, %%mm2  #                     y7 y6 y5 y4 y3 y2 y1 y0     n
  46. punpcklbw %%mm1, %%mm2  #                     v1 y3 u1 y2 v0 y1 u0 y0     n
  47. movq      %%mm2, (%0)   # Store low YUYV                                  n
  48. punpckhbw %%mm1, %%mm0  #                     v3 y7 u3 y6 v2 y5 u2 y4     n
  49. movq      %%mm0, 8(%0)  # Store high YUYV                                 n
  50. "
  51. #define MMX_YUV422_YVYU "                                                 n
  52. movq       (%1), %%mm0  # Load 8 Y            y7 y6 y5 y4 y3 y2 y1 y0     n
  53. movd       (%2), %%mm2  # Load 4 Cb           00 00 00 00 u3 u2 u1 u0     n
  54. movd       (%3), %%mm1  # Load 4 Cr           00 00 00 00 v3 v2 v1 v0     n
  55. punpcklbw %%mm2, %%mm1  #                     u3 v3 u2 v2 u1 v1 u0 v0     n
  56. movq      %%mm0, %%mm2  #                     y7 y6 y5 y4 y3 y2 y1 y0     n
  57. punpcklbw %%mm1, %%mm2  #                     u1 y3 v1 y2 u0 y1 v0 y0     n
  58. movq      %%mm2, (%0)   # Store low YUYV                                  n
  59. punpckhbw %%mm1, %%mm0  #                     u3 y7 v3 y6 u2 y5 v2 y4     n
  60. movq      %%mm0, 8(%0)  # Store high YUYV                                 n
  61. "
  62. #define MMX_YUV422_UYVY "                                                 n
  63. movq       (%1), %%mm0  # Load 8 Y            y7 y6 y5 y4 y3 y2 y1 y0     n
  64. movd       (%2), %%mm1  # Load 4 Cb           00 00 00 00 u3 u2 u1 u0     n
  65. movd       (%3), %%mm2  # Load 4 Cr           00 00 00 00 v3 v2 v1 v0     n
  66. punpcklbw %%mm2, %%mm1  #                     v3 u3 v2 u2 v1 u1 v0 u0     n
  67. movq      %%mm1, %%mm2  #                     v3 u3 v2 u2 v1 u1 v0 u0     n
  68. punpcklbw %%mm0, %%mm2  #                     y3 v1 y2 u1 y1 v0 y0 u0     n
  69. movq      %%mm2, (%0)   # Store low UYVY                                  n
  70. punpckhbw %%mm0, %%mm1  #                     y7 v3 y6 u3 y5 v2 y4 u2     n
  71. movq      %%mm1, 8(%0)  # Store high UYVY                                 n
  72. "
  73. #define MMX_YUV422_Y211 "                                                 n
  74. "
  75. #elif defined(HAVE_MMX_INTRINSICS)
  76. /* MMX intrinsics */
  77. #include <mmintrin.h>
  78. #define MMX_CALL(MMX_INSTRUCTIONS)  
  79.     do {                            
  80.         __m64 mm0, mm1, mm2;        
  81.         MMX_INSTRUCTIONS            
  82.         p_line += 16; p_y += 8;     
  83.         p_u += 4; p_v += 4;         
  84.     } while(0)
  85. #define MMX_END _mm_empty()
  86. #define MMX_YUV422_YUYV                     
  87.     mm0 = (__m64)*(uint64_t*)p_y;           
  88.     mm1 = _mm_cvtsi32_si64(*(int*)p_u);     
  89.     mm2 = _mm_cvtsi32_si64(*(int*)p_v);     
  90.     mm1 = _mm_unpacklo_pi8(mm1, mm2);       
  91.     mm2 = mm0;                              
  92.     mm2 = _mm_unpacklo_pi8(mm2, mm1);       
  93.     *(uint64_t*)p_line = (uint64_t)mm2;     
  94.     mm0 = _mm_unpackhi_pi8(mm0, mm1);       
  95.     *(uint64_t*)(p_line+8) = (uint64_t)mm0;
  96.  
  97. #define MMX_YUV422_YVYU                     
  98.     mm0 = (__m64)*(uint64_t*)p_y;           
  99.     mm2 = _mm_cvtsi32_si64(*(int*)p_u);     
  100.     mm1 = _mm_cvtsi32_si64(*(int*)p_v);     
  101.     mm1 = _mm_unpacklo_pi8(mm1, mm2);       
  102.     mm2 = mm0;                              
  103.     mm2 = _mm_unpacklo_pi8(mm2, mm1);       
  104.     *(uint64_t*)p_line = (uint64_t)mm2;     
  105.     mm0 = _mm_unpackhi_pi8(mm0, mm1);       
  106.     *(uint64_t*)(p_line+8) = (uint64_t)mm0;
  107. #define MMX_YUV422_UYVY                     
  108.     mm0 = (__m64)*(uint64_t*)p_y;           
  109.     mm1 = _mm_cvtsi32_si64(*(int*)p_u);     
  110.     mm2 = _mm_cvtsi32_si64(*(int*)p_v);     
  111.     mm1 = _mm_unpacklo_pi8(mm1, mm2);       
  112.     mm2 = mm1;                              
  113.     mm2 = _mm_unpacklo_pi8(mm2, mm0);       
  114.     *(uint64_t*)p_line = (uint64_t)mm2;     
  115.     mm1 = _mm_unpackhi_pi8(mm1, mm0);       
  116.     *(uint64_t*)(p_line+8) = (uint64_t)mm1;
  117. #endif
  118.  
  119. #elif defined( MODULE_NAME_IS_i422_yuy2_sse2 )
  120. #if defined(CAN_COMPILE_SSE2)
  121. /* SSE2 assembly */
  122. #define SSE2_CALL(MMX_INSTRUCTIONS)         
  123.     do {                                    
  124.     __asm__ __volatile__(                   
  125.         ".p2align 3 nt"                   
  126.         MMX_INSTRUCTIONS                    
  127.         :                                   
  128.         : "r" (p_line), "r" (p_y),          
  129.           "r" (p_u), "r" (p_v) );           
  130.         p_line += 32; p_y += 16;            
  131.         p_u += 8; p_v += 8;                 
  132.     } while(0)
  133. #define SSE2_END  __asm__ __volatile__ ( "sfence" ::: "memory" )
  134. #define SSE2_YUV422_YUYV_ALIGNED "                                        n
  135. movdqa      (%1), %%xmm0  # Load 8 Y            y7 y6 y5 y4 y3 y2 y1 y0   n
  136. movq        (%2), %%xmm1  # Load 4 Cb           00 00 00 00 u3 u2 u1 u0   n
  137. movq        (%3), %%xmm2  # Load 4 Cr           00 00 00 00 v3 v2 v1 v0   n
  138. punpcklbw %%xmm2, %%xmm1  #                     v3 u3 v2 u2 v1 u1 v0 u0   n
  139. movdqa    %%xmm0, %%xmm2  #                     y7 y6 y5 y4 y3 y2 y1 y0   n
  140. punpcklbw %%xmm1, %%xmm2  #                     v1 y3 u1 y2 v0 y1 u0 y0   n
  141. movntdq   %%xmm2, (%0)    # Store low YUYV                                n
  142. punpckhbw %%xmm1, %%xmm0  #                     v3 y7 u3 y6 v2 y5 u2 y4   n
  143. movntdq   %%xmm0, 16(%0)  # Store high YUYV                               n
  144. "
  145. #define SSE2_YUV422_YUYV_UNALIGNED "                                      n
  146. movdqu      (%1), %%xmm0  # Load 8 Y            y7 y6 y5 y4 y3 y2 y1 y0   n
  147. movq        (%2), %%xmm1  # Load 4 Cb           00 00 00 00 u3 u2 u1 u0   n
  148. movq        (%3), %%xmm2  # Load 4 Cr           00 00 00 00 v3 v2 v1 v0   n
  149. prefetchnta (%0)          # Tell CPU not to cache output YUYV data        n
  150. punpcklbw %%xmm2, %%xmm1  #                     v3 u3 v2 u2 v1 u1 v0 u0   n
  151. movdqa    %%xmm0, %%xmm2  #                     y7 y6 y5 y4 y3 y2 y1 y0   n
  152. punpcklbw %%xmm1, %%xmm2  #                     v1 y3 u1 y2 v0 y1 u0 y0   n
  153. movdqu    %%xmm2, (%0)    # Store low YUYV                                n
  154. punpckhbw %%xmm1, %%xmm0  #                     v3 y7 u3 y6 v2 y5 u2 y4   n
  155. movdqu    %%xmm0, 16(%0)  # Store high YUYV                               n
  156. "
  157. #define SSE2_YUV422_YVYU_ALIGNED "                                        n
  158. movdqa      (%1), %%xmm0  # Load 8 Y            y7 y6 y5 y4 y3 y2 y1 y0   n
  159. movq        (%2), %%xmm2  # Load 4 Cb           00 00 00 00 u3 u2 u1 u0   n
  160. movq        (%3), %%xmm1  # Load 4 Cr           00 00 00 00 v3 v2 v1 v0   n
  161. punpcklbw %%xmm2, %%xmm1  #                     u3 v3 u2 v2 u1 v1 u0 v0   n
  162. movdqa    %%xmm0, %%xmm2  #                     y7 y6 y5 y4 y3 y2 y1 y0   n
  163. punpcklbw %%xmm1, %%xmm2  #                     u1 y3 v1 y2 u0 y1 v0 y0   n
  164. movntdq   %%xmm2, (%0)    # Store low YUYV                                n
  165. punpckhbw %%xmm1, %%xmm0  #                     u3 y7 v3 y6 u2 y5 v2 y4   n
  166. movntdq   %%xmm0, 16(%0)  # Store high YUYV                               n
  167. "
  168. #define SSE2_YUV422_YVYU_UNALIGNED "                                      n
  169. movdqu      (%1), %%xmm0  # Load 8 Y            y7 y6 y5 y4 y3 y2 y1 y0   n
  170. movq        (%2), %%xmm2  # Load 4 Cb           00 00 00 00 u3 u2 u1 u0   n
  171. movq        (%3), %%xmm1  # Load 4 Cr           00 00 00 00 v3 v2 v1 v0   n
  172. prefetchnta (%0)          # Tell CPU not to cache output YUYV data        n
  173. punpcklbw %%xmm2, %%xmm1  #                     u3 v3 u2 v2 u1 v1 u0 v0   n
  174. movdqa    %%xmm0, %%xmm2  #                     y7 y6 y5 y4 y3 y2 y1 y0   n
  175. punpcklbw %%xmm1, %%xmm2  #                     u1 y3 v1 y2 u0 y1 v0 y0   n
  176. movdqu    %%xmm2, (%0)    # Store low YUYV                                n
  177. punpckhbw %%xmm1, %%xmm0  #                     u3 y7 v3 y6 u2 y5 v2 y4   n
  178. movdqu    %%xmm0, 16(%0)  # Store high YUYV                               n
  179. "
  180. #define SSE2_YUV422_UYVY_ALIGNED "                                        n
  181. movdqa      (%1), %%xmm0  # Load 8 Y            y7 y6 y5 y4 y3 y2 y1 y0   n
  182. movq        (%2), %%xmm1  # Load 4 Cb           00 00 00 00 u3 u2 u1 u0   n
  183. movq        (%3), %%xmm2  # Load 4 Cr           00 00 00 00 v3 v2 v1 v0   n
  184. punpcklbw %%xmm2, %%xmm1  #                     v3 u3 v2 u2 v1 u1 v0 u0   n
  185. movdqa    %%xmm1, %%xmm2  #                     v3 u3 v2 u2 v1 u1 v0 u0   n
  186. punpcklbw %%xmm0, %%xmm2  #                     y3 v1 y2 u1 y1 v0 y0 u0   n
  187. movntdq   %%xmm2, (%0)    # Store low UYVY                                n
  188. punpckhbw %%xmm0, %%xmm1  #                     y7 v3 y6 u3 y5 v2 y4 u2   n
  189. movntdq   %%xmm1, 16(%0)  # Store high UYVY                               n
  190. "
  191. #define SSE2_YUV422_UYVY_UNALIGNED "                                      n
  192. movdqu      (%1), %%xmm0  # Load 8 Y            y7 y6 y5 y4 y3 y2 y1 y0   n
  193. movq        (%2), %%xmm1  # Load 4 Cb           00 00 00 00 u3 u2 u1 u0   n
  194. movq        (%3), %%xmm2  # Load 4 Cr           00 00 00 00 v3 v2 v1 v0   n
  195. prefetchnta (%0)          # Tell CPU not to cache output YUYV data        n
  196. punpcklbw %%xmm2, %%xmm1  #                     v3 u3 v2 u2 v1 u1 v0 u0   n
  197. movdqa    %%xmm1, %%xmm2  #                     v3 u3 v2 u2 v1 u1 v0 u0   n
  198. punpcklbw %%xmm0, %%xmm2  #                     y3 v1 y2 u1 y1 v0 y0 u0   n
  199. movdqu    %%xmm2, (%0)    # Store low UYVY                                n
  200. punpckhbw %%xmm0, %%xmm1  #                     y7 v3 y6 u3 y5 v2 y4 u2   n
  201. movdqu    %%xmm1, 16(%0)  # Store high UYVY                               n
  202. "
  203. #elif defined(HAVE_SSE2_INTRINSICS)
  204. /* SSE2 intrinsics */
  205. #include <emmintrin.h>
  206. #define SSE2_CALL(SSE2_INSTRUCTIONS)    
  207.     do {                                
  208.         __m128i xmm0, xmm1, xmm2;        
  209.         SSE2_INSTRUCTIONS               
  210.         p_line += 32; p_y += 16;        
  211.         p_u += 8; p_v += 8;             
  212.     } while(0)
  213. #define SSE2_END  _mm_sfence()
  214. #define SSE2_YUV422_YUYV_ALIGNED                
  215.     xmm0 = _mm_load_si128((__m128i *)p_y);      
  216.     xmm1 = _mm_loadl_epi64((__m128i *)p_u);     
  217.     xmm2 = _mm_loadl_epi64((__m128i *)p_v);     
  218.     xmm1 = _mm_unpacklo_epi8(xmm1, xmm2);       
  219.     xmm2 = xmm0;                                
  220.     xmm2 = _mm_unpacklo_epi8(xmm2, xmm1);       
  221.     _mm_stream_si128((__m128i*)(p_line), xmm2); 
  222.     xmm0 = _mm_unpackhi_epi8(xmm0, xmm1);       
  223.     _mm_stream_si128((__m128i*)(p_line+16), xmm0);
  224.  
  225. #define SSE2_YUV422_YUYV_UNALIGNED              
  226.     xmm0 = _mm_loadu_si128((__m128i *)p_y);     
  227.     xmm1 = _mm_loadl_epi64((__m128i *)p_u);     
  228.     xmm2 = _mm_loadl_epi64((__m128i *)p_v);     
  229.     xmm1 = _mm_unpacklo_epi8(xmm1, xmm2);       
  230.     xmm2 = xmm0;                                
  231.     xmm2 = _mm_unpacklo_epi8(xmm2, xmm1);       
  232.     _mm_storeu_si128((__m128i*)(p_line), xmm2); 
  233.     xmm0 = _mm_unpackhi_epi8(xmm0, xmm1);       
  234.     _mm_storeu_si128((__m128i*)(p_line+16), xmm0);
  235.  
  236. #define SSE2_YUV422_YVYU_ALIGNED                
  237.     xmm0 = _mm_load_si128((__m128i *)p_y);      
  238.     xmm2 = _mm_loadl_epi64((__m128i *)p_u);     
  239.     xmm1 = _mm_loadl_epi64((__m128i *)p_v);     
  240.     xmm1 = _mm_unpacklo_epi8(xmm1, xmm2);       
  241.     xmm2 = xmm0;                                
  242.     xmm2 = _mm_unpacklo_epi8(xmm2, xmm1);       
  243.     _mm_stream_si128((__m128i*)(p_line), xmm2); 
  244.     xmm0 = _mm_unpackhi_epi8(xmm0, xmm1);       
  245.     _mm_stream_si128((__m128i*)(p_line+16), xmm0);
  246. #define SSE2_YUV422_YVYU_UNALIGNED              
  247.     xmm0 = _mm_loadu_si128((__m128i *)p_y);     
  248.     xmm2 = _mm_loadl_epi64((__m128i *)p_u);     
  249.     xmm1 = _mm_loadl_epi64((__m128i *)p_v);     
  250.     xmm1 = _mm_unpacklo_epi8(xmm1, xmm2);       
  251.     xmm2 = xmm0;                                
  252.     xmm2 = _mm_unpacklo_epi8(xmm2, xmm1);       
  253.     _mm_storeu_si128((__m128i*)(p_line), xmm2); 
  254.     xmm0 = _mm_unpackhi_epi8(xmm0, xmm1);       
  255.     _mm_storeu_si128((__m128i*)(p_line+16), xmm0);
  256. #define SSE2_YUV422_UYVY_ALIGNED                
  257.     xmm0 = _mm_load_si128((__m128i *)p_y);      
  258.     xmm1 = _mm_loadl_epi64((__m128i *)p_u);     
  259.     xmm2 = _mm_loadl_epi64((__m128i *)p_v);     
  260.     xmm1 = _mm_unpacklo_epi8(xmm1, xmm2);       
  261.     xmm2 = xmm1;                                
  262.     xmm2 = _mm_unpacklo_epi8(xmm2, xmm0);       
  263.     _mm_stream_si128((__m128i*)(p_line), xmm2); 
  264.     xmm1 = _mm_unpackhi_epi8(xmm1, xmm0);       
  265.     _mm_stream_si128((__m128i*)(p_line+16), xmm1);
  266. #define SSE2_YUV422_UYVY_UNALIGNED              
  267.     xmm0 = _mm_loadu_si128((__m128i *)p_y);     
  268.     xmm1 = _mm_loadl_epi64((__m128i *)p_u);     
  269.     xmm2 = _mm_loadl_epi64((__m128i *)p_v);     
  270.     xmm1 = _mm_unpacklo_epi8(xmm1, xmm2);       
  271.     xmm2 = xmm1;                                
  272.     xmm2 = _mm_unpacklo_epi8(xmm2, xmm0);       
  273.     _mm_storeu_si128((__m128i*)(p_line), xmm2); 
  274.     xmm1 = _mm_unpackhi_epi8(xmm1, xmm0);       
  275.     _mm_storeu_si128((__m128i*)(p_line+16), xmm1);
  276. #endif
  277. #endif
  278. #define C_YUV422_YUYV( p_line, p_y, p_u, p_v )                              
  279.     *(p_line)++ = *(p_y)++;                                                 
  280.     *(p_line)++ = *(p_u)++;                                                 
  281.     *(p_line)++ = *(p_y)++;                                                 
  282.     *(p_line)++ = *(p_v)++;                                                 
  283. #define C_YUV422_YVYU( p_line, p_y, p_u, p_v )                              
  284.     *(p_line)++ = *(p_y)++;                                                 
  285.     *(p_line)++ = *(p_v)++;                                                 
  286.     *(p_line)++ = *(p_y)++;                                                 
  287.     *(p_line)++ = *(p_u)++;                                                 
  288. #define C_YUV422_UYVY( p_line, p_y, p_u, p_v )                              
  289.     *(p_line)++ = *(p_u)++;                                                 
  290.     *(p_line)++ = *(p_y)++;                                                 
  291.     *(p_line)++ = *(p_v)++;                                                 
  292.     *(p_line)++ = *(p_y)++;                                                 
  293. #define C_YUV422_Y211( p_line, p_y, p_u, p_v )                              
  294.     *(p_line)++ = *(p_y); p_y += 2;                                         
  295.     *(p_line)++ = *(p_u) - 0x80; p_u += 2;                                  
  296.     *(p_line)++ = *(p_y); p_y += 2;                                         
  297.     *(p_line)++ = *(p_v) - 0x80; p_v += 2;