Apollo 11.0
自动驾驶开放平台
命名空间 | 宏定义 | 函数 | 变量
util.h 文件参考
#include <fcntl.h>
#include <malloc.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <cassert>
#include <cerrno>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <immintrin.h>
#include <x86intrin.h>
util.h 的引用(Include)关系图:
此图展示该文件直接或间接的被哪些文件引用了:

浏览源代码.

命名空间

namespace  apollo
 class register implement
 
namespace  apollo::drivers
 apollo::drivers
 
namespace  apollo::drivers::camera
 

宏定义

#define SIMD_INLINE   inline __attribute__((always_inline))
 
#define SIMD_CHAR_AS_LONGLONG(a)   (((int64_t)a) & 0xFF)
 
#define SIMD_SHORT_AS_LONGLONG(a)   (((int64_t)a) & 0xFFFF)
 
#define SIMD_INT_AS_LONGLONG(a)   (((int64_t)a) & 0xFFFFFFFF)
 
#define SIMD_LL_SET1_EPI8(a)
 
#define SIMD_LL_SET2_EPI8(a, b)
 
#define SIMD_LL_SETR_EPI8(a, b, c, d, e, f, g, h)
 
#define SIMD_LL_SET1_EPI16(a)
 
#define SIMD_LL_SET2_EPI16(a, b)
 
#define SIMD_LL_SETR_EPI16(a, b, c, d)
 
#define SIMD_LL_SET1_EPI32(a)   SIMD_INT_AS_LONGLONG(a) | (SIMD_INT_AS_LONGLONG(a) << 32)
 
#define SIMD_LL_SET2_EPI32(a, b)   SIMD_INT_AS_LONGLONG(a) | (SIMD_INT_AS_LONGLONG(b) << 32)
 
#define SIMD_MM256_SET1_EPI8(a)
 
#define SIMD_MM256_SET2_EPI8(a0, a1)
 
#define SIMD_MM256_SETR_EPI8( a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf)
 
#define SIMD_MM256_SET1_EPI16(a)
 
#define SIMD_MM256_SET2_EPI16(a0, a1)
 
#define SIMD_MM256_SETR_EPI16(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af)
 
#define SIMD_MM256_SET1_EPI32(a)
 
#define SIMD_MM256_SET2_EPI32(a0, a1)
 
#define SIMD_MM256_SETR_EPI32(a0, a1, a2, a3, a4, a5, a6, a7)
 

函数

void apollo::drivers::camera::yuyv2rgb_avx (unsigned char *YUV, unsigned char *RGB, int NumPixels)
 
void apollo::drivers::camera::print_m256 (__m256i a)
 
void apollo::drivers::camera::print_m256_i32 (const __m256i a)
 
void apollo::drivers::camera::print_m256_i16 (const __m256i a)
 
template<class T >
SIMD_INLINE char apollo::drivers::camera::GetChar (T value, size_t index)
 
template<bool align>
SIMD_INLINE __m256i apollo::drivers::camera::Load (const __m256i *p)
 
template<>
SIMD_INLINE __m256i apollo::drivers::camera::Load< false > (const __m256i *p)
 
template<>
SIMD_INLINE __m256i apollo::drivers::camera::Load< true > (const __m256i *p)
 
SIMD_INLINE void * apollo::drivers::camera::AlignLo (const void *ptr, size_t align)
 
SIMD_INLINE bool apollo::drivers::camera::Aligned (const void *ptr, size_t align=sizeof(__m256))
 
template<bool align>
SIMD_INLINE void apollo::drivers::camera::Store (__m256i *p, __m256i a)
 
template<>
SIMD_INLINE void apollo::drivers::camera::Store< false > (__m256i *p, __m256i a)
 
template<>
SIMD_INLINE void apollo::drivers::camera::Store< true > (__m256i *p, __m256i a)
 
SIMD_INLINE __m256i apollo::drivers::camera::SaturateI16ToU8 (__m256i value)
 
SIMD_INLINE __m256i apollo::drivers::camera::AdjustY16 (__m256i y16)
 
SIMD_INLINE __m256i apollo::drivers::camera::AdjustUV16 (__m256i uv16)
 
SIMD_INLINE __m256i apollo::drivers::camera::AdjustedYuvToRed32 (__m256i y16_1, __m256i v16_0)
 
SIMD_INLINE __m256i apollo::drivers::camera::AdjustedYuvToRed16 (__m256i y16, __m256i v16)
 
SIMD_INLINE __m256i apollo::drivers::camera::AdjustedYuvToGreen32 (__m256i y16_1, __m256i u16_v16)
 
SIMD_INLINE __m256i apollo::drivers::camera::AdjustedYuvToGreen16 (__m256i y16, __m256i u16, __m256i v16)
 
SIMD_INLINE __m256i apollo::drivers::camera::AdjustedYuvToBlue32 (__m256i y16_1, __m256i u16_0)
 
SIMD_INLINE __m256i apollo::drivers::camera::AdjustedYuvToBlue16 (__m256i y16, __m256i u16)
 
SIMD_INLINE __m256i apollo::drivers::camera::YuvToRed (__m256i y, __m256i v)
 
SIMD_INLINE __m256i apollo::drivers::camera::YuvToGreen (__m256i y, __m256i u, __m256i v)
 
SIMD_INLINE __m256i apollo::drivers::camera::YuvToBlue (__m256i y, __m256i u)
 
template<int index>
__m256i apollo::drivers::camera::InterleaveBgr (__m256i blue, __m256i green, __m256i red)
 
template<>
SIMD_INLINE __m256i apollo::drivers::camera::InterleaveBgr< 0 > (__m256i blue, __m256i green, __m256i red)
 
template<>
SIMD_INLINE __m256i apollo::drivers::camera::InterleaveBgr< 1 > (__m256i blue, __m256i green, __m256i red)
 
template<>
SIMD_INLINE __m256i apollo::drivers::camera::InterleaveBgr< 2 > (__m256i blue, __m256i green, __m256i red)
 
SIMD_INLINE __m256i apollo::drivers::camera::BgrToBlue (__m256i bgr[3])
 
SIMD_INLINE __m256i apollo::drivers::camera::BgrToGreen (__m256i bgr[3])
 
SIMD_INLINE __m256i apollo::drivers::camera::BgrToRed (__m256i bgr[3])
 
template<bool align>
SIMD_INLINE __m256i apollo::drivers::camera::LoadPermuted (const __m256i *p)
 

变量

const size_t apollo::drivers::camera::A = sizeof(__m256i)
 
const size_t apollo::drivers::camera::DA = 2 * A
 
const size_t apollo::drivers::camera::QA = 4 * A
 
const size_t apollo::drivers::camera::OA = 8 * A
 
const size_t apollo::drivers::camera::HA = A / 2
 
const __m256i apollo::drivers::camera::K_ZERO = SIMD_MM256_SET1_EPI8(0)
 
const __m256i apollo::drivers::camera::K_INV_ZERO = SIMD_MM256_SET1_EPI8(0xFF)
 
const __m256i apollo::drivers::camera::K8_01 = SIMD_MM256_SET1_EPI8(0x01)
 
const __m256i apollo::drivers::camera::K8_02 = SIMD_MM256_SET1_EPI8(0x02)
 
const __m256i apollo::drivers::camera::K8_04 = SIMD_MM256_SET1_EPI8(0x04)
 
const __m256i apollo::drivers::camera::K8_08 = SIMD_MM256_SET1_EPI8(0x08)
 
const __m256i apollo::drivers::camera::K8_10 = SIMD_MM256_SET1_EPI8(0x10)
 
const __m256i apollo::drivers::camera::K8_20 = SIMD_MM256_SET1_EPI8(0x20)
 
const __m256i apollo::drivers::camera::K8_40 = SIMD_MM256_SET1_EPI8(0x40)
 
const __m256i apollo::drivers::camera::K8_80 = SIMD_MM256_SET1_EPI8(0x80)
 
const __m256i apollo::drivers::camera::K8_01_FF = SIMD_MM256_SET2_EPI8(0x01, 0xFF)
 
const __m256i apollo::drivers::camera::K16_0001 = SIMD_MM256_SET1_EPI16(0x0001)
 
const __m256i apollo::drivers::camera::K16_0002 = SIMD_MM256_SET1_EPI16(0x0002)
 
const __m256i apollo::drivers::camera::K16_0003 = SIMD_MM256_SET1_EPI16(0x0003)
 
const __m256i apollo::drivers::camera::K16_0004 = SIMD_MM256_SET1_EPI16(0x0004)
 
const __m256i apollo::drivers::camera::K16_0005 = SIMD_MM256_SET1_EPI16(0x0005)
 
const __m256i apollo::drivers::camera::K16_0006 = SIMD_MM256_SET1_EPI16(0x0006)
 
const __m256i apollo::drivers::camera::K16_0008 = SIMD_MM256_SET1_EPI16(0x0008)
 
const __m256i apollo::drivers::camera::K16_0010 = SIMD_MM256_SET1_EPI16(0x0010)
 
const __m256i apollo::drivers::camera::K16_0018 = SIMD_MM256_SET1_EPI16(0x0018)
 
const __m256i apollo::drivers::camera::K16_0020 = SIMD_MM256_SET1_EPI16(0x0020)
 
const __m256i apollo::drivers::camera::K16_0080 = SIMD_MM256_SET1_EPI16(0x0080)
 
const __m256i apollo::drivers::camera::K16_00FF = SIMD_MM256_SET1_EPI16(0x00FF)
 
const __m256i apollo::drivers::camera::K16_FF00 = SIMD_MM256_SET1_EPI16(0xFF00)
 
const __m256i apollo::drivers::camera::K32_00000001 = SIMD_MM256_SET1_EPI32(0x00000001)
 
const __m256i apollo::drivers::camera::K32_00000002 = SIMD_MM256_SET1_EPI32(0x00000002)
 
const __m256i apollo::drivers::camera::K32_00000004 = SIMD_MM256_SET1_EPI32(0x00000004)
 
const __m256i apollo::drivers::camera::K32_00000008 = SIMD_MM256_SET1_EPI32(0x00000008)
 
const __m256i apollo::drivers::camera::K32_000000FF = SIMD_MM256_SET1_EPI32(0x000000FF)
 
const __m256i apollo::drivers::camera::K32_0000FFFF = SIMD_MM256_SET1_EPI32(0x0000FFFF)
 
const __m256i apollo::drivers::camera::K32_00010000 = SIMD_MM256_SET1_EPI32(0x00010000)
 
const __m256i apollo::drivers::camera::K32_01000000 = SIMD_MM256_SET1_EPI32(0x01000000)
 
const __m256i apollo::drivers::camera::K32_FFFFFF00 = SIMD_MM256_SET1_EPI32(0xFFFFFF00)
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_BLUE
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_BLUE
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_BLUE
 
const __m256i apollo::drivers::camera::Y_SHUFFLE0
 
const __m256i apollo::drivers::camera::Y_SHUFFLE1
 
const __m256i apollo::drivers::camera::U_SHUFFLE0
 
const __m256i apollo::drivers::camera::U_SHUFFLE1
 
const __m256i apollo::drivers::camera::U_SHUFFLE2
 
const __m256i apollo::drivers::camera::U_SHUFFLE3
 
const __m256i apollo::drivers::camera::U_SHUFFLE4
 
const __m256i apollo::drivers::camera::V_SHUFFLE0
 
const __m256i apollo::drivers::camera::V_SHUFFLE1
 
const __m256i apollo::drivers::camera::V_SHUFFLE2
 
const __m256i apollo::drivers::camera::V_SHUFFLE3
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR0
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR1
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR2
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_GREEN
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_GREEN
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_GREEN
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_RED
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_RED
 
const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_RED
 
const __m256i apollo::drivers::camera::K16_Y_ADJUST = SIMD_MM256_SET1_EPI16(0)
 
const __m256i apollo::drivers::camera::K16_UV_ADJUST = SIMD_MM256_SET1_EPI16(128)
 
const int apollo::drivers::camera::Y_ADJUST = 0
 
const int apollo::drivers::camera::UV_ADJUST = 128
 
const int apollo::drivers::camera::YUV_TO_BGR_AVERAGING_SHIFT = 13
 
const int apollo::drivers::camera::YUV_TO_BGR_ROUND_TERM = 0
 
const int apollo::drivers::camera::Y_TO_RGB_WEIGHT = static_cast<int>((((1 << YUV_TO_BGR_AVERAGING_SHIFT))))
 
const int apollo::drivers::camera::U_TO_BLUE_WEIGHT = static_cast<int>((2.041 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))
 
const int apollo::drivers::camera::U_TO_GREEN_WEIGHT = -static_cast<int>((0.3455 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))
 
const int apollo::drivers::camera::V_TO_GREEN_WEIGHT = -static_cast<int>((0.7169 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))
 
const int apollo::drivers::camera::V_TO_RED_WEIGHT = static_cast<int>((1.4065 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))
 
const __m256i apollo::drivers::camera::K16_YRGB_RT = SIMD_MM256_SET2_EPI16(Y_TO_RGB_WEIGHT, YUV_TO_BGR_ROUND_TERM)
 
const __m256i apollo::drivers::camera::K16_VR_0 = SIMD_MM256_SET2_EPI16(V_TO_RED_WEIGHT, 0)
 
const __m256i apollo::drivers::camera::K16_UG_VG = SIMD_MM256_SET2_EPI16(U_TO_GREEN_WEIGHT, V_TO_GREEN_WEIGHT)
 
const __m256i apollo::drivers::camera::K16_UB_0 = SIMD_MM256_SET2_EPI16(U_TO_BLUE_WEIGHT, 0)
 

宏定义说明

◆ SIMD_CHAR_AS_LONGLONG

#define SIMD_CHAR_AS_LONGLONG (   a)    (((int64_t)a) & 0xFF)

在文件 util.h 第 54 行定义.

◆ SIMD_INLINE

#define SIMD_INLINE   inline __attribute__((always_inline))

在文件 util.h 第 43 行定义.

◆ SIMD_INT_AS_LONGLONG

#define SIMD_INT_AS_LONGLONG (   a)    (((int64_t)a) & 0xFFFFFFFF)

在文件 util.h 第 58 行定义.

◆ SIMD_LL_SET1_EPI16

#define SIMD_LL_SET1_EPI16 (   a)
值:
SIMD_SHORT_AS_LONGLONG(a) | (SIMD_SHORT_AS_LONGLONG(a) << 16) | (SIMD_SHORT_AS_LONGLONG(a) << 32) \
| (SIMD_SHORT_AS_LONGLONG(a) << 48)
SIMD_SHORT_AS_LONGLONG
#define SIMD_SHORT_AS_LONGLONG(a)
Definition util.h:56

在文件 util.h 第 75 行定义.

91 { \
92 SIMD_LL_SET1_EPI8(a) \
93 , SIMD_LL_SET1_EPI8(a), SIMD_LL_SET1_EPI8(a), SIMD_LL_SET1_EPI8(a) \
94 }
95
96#define SIMD_MM256_SET2_EPI8(a0, a1) \
97 { \
98 SIMD_LL_SET2_EPI8(a0, a1) \
99 , SIMD_LL_SET2_EPI8(a0, a1), SIMD_LL_SET2_EPI8(a0, a1), SIMD_LL_SET2_EPI8(a0, a1) \
100 }
101
102#define SIMD_MM256_SETR_EPI8( \
103 a0, \
104 a1, \
105 a2, \
106 a3, \
107 a4, \
108 a5, \
109 a6, \
110 a7, \
111 a8, \
112 a9, \
113 aa, \
114 ab, \
115 ac, \
116 ad, \
117 ae, \
118 af, \
119 b0, \
120 b1, \
121 b2, \
122 b3, \
123 b4, \
124 b5, \
125 b6, \
126 b7, \
127 b8, \
128 b9, \
129 ba, \
130 bb, \
131 bc, \
132 bd, \
133 be, \
134 bf) \
135 { \
136 SIMD_LL_SETR_EPI8(a0, a1, a2, a3, a4, a5, a6, a7) \
137 , SIMD_LL_SETR_EPI8(a8, a9, aa, ab, ac, ad, ae, af), SIMD_LL_SETR_EPI8(b0, b1, b2, b3, b4, b5, b6, b7), \
138 SIMD_LL_SETR_EPI8(b8, b9, ba, bb, bc, bd, be, bf) \
139 }
140
141#define SIMD_MM256_SET1_EPI16(a) \
142 { \
143 SIMD_LL_SET1_EPI16(a) \
144 , SIMD_LL_SET1_EPI16(a), SIMD_LL_SET1_EPI16(a), SIMD_LL_SET1_EPI16(a) \
145 }
146
147#define SIMD_MM256_SET2_EPI16(a0, a1) \
148 { \
149 SIMD_LL_SET2_EPI16(a0, a1) \
150 , SIMD_LL_SET2_EPI16(a0, a1), SIMD_LL_SET2_EPI16(a0, a1), SIMD_LL_SET2_EPI16(a0, a1) \
151 }
152
153#define SIMD_MM256_SETR_EPI16(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af) \
154 { \
155 SIMD_LL_SETR_EPI16(a0, a1, a2, a3) \
156 , SIMD_LL_SETR_EPI16(a4, a5, a6, a7), SIMD_LL_SETR_EPI16(a8, a9, aa, ab), SIMD_LL_SETR_EPI16(ac, ad, ae, af) \
157 }
158
159#define SIMD_MM256_SET1_EPI32(a) \
160 { \
161 SIMD_LL_SET1_EPI32(a) \
162 , SIMD_LL_SET1_EPI32(a), SIMD_LL_SET1_EPI32(a), SIMD_LL_SET1_EPI32(a) \
163 }
164
165#define SIMD_MM256_SET2_EPI32(a0, a1) \
166 { \
167 SIMD_LL_SET2_EPI32(a0, a1) \
168 , SIMD_LL_SET2_EPI32(a0, a1), SIMD_LL_SET2_EPI32(a0, a1), SIMD_LL_SET2_EPI32(a0, a1) \
169 }
170
171#define SIMD_MM256_SETR_EPI32(a0, a1, a2, a3, a4, a5, a6, a7) \
172 { \
173 SIMD_LL_SET2_EPI32(a0, a1) \
174 , SIMD_LL_SET2_EPI32(a2, a3), SIMD_LL_SET2_EPI32(a4, a5), SIMD_LL_SET2_EPI32(a6, a7) \
175 }
176
177const size_t A = sizeof(__m256i);
178const size_t DA = 2 * A;
179const size_t QA = 4 * A;
180const size_t OA = 8 * A;
181const size_t HA = A / 2;
182
183const __m256i K_ZERO = SIMD_MM256_SET1_EPI8(0);
184const __m256i K_INV_ZERO = SIMD_MM256_SET1_EPI8(0xFF);
185
186const __m256i K8_01 = SIMD_MM256_SET1_EPI8(0x01);
187const __m256i K8_02 = SIMD_MM256_SET1_EPI8(0x02);
188const __m256i K8_04 = SIMD_MM256_SET1_EPI8(0x04);
189const __m256i K8_08 = SIMD_MM256_SET1_EPI8(0x08);
190const __m256i K8_10 = SIMD_MM256_SET1_EPI8(0x10);
191const __m256i K8_20 = SIMD_MM256_SET1_EPI8(0x20);
192const __m256i K8_40 = SIMD_MM256_SET1_EPI8(0x40);
193const __m256i K8_80 = SIMD_MM256_SET1_EPI8(0x80);
194
195const __m256i K8_01_FF = SIMD_MM256_SET2_EPI8(0x01, 0xFF);
196
197const __m256i K16_0001 = SIMD_MM256_SET1_EPI16(0x0001);
198const __m256i K16_0002 = SIMD_MM256_SET1_EPI16(0x0002);
199const __m256i K16_0003 = SIMD_MM256_SET1_EPI16(0x0003);
200const __m256i K16_0004 = SIMD_MM256_SET1_EPI16(0x0004);
201const __m256i K16_0005 = SIMD_MM256_SET1_EPI16(0x0005);
202const __m256i K16_0006 = SIMD_MM256_SET1_EPI16(0x0006);
203const __m256i K16_0008 = SIMD_MM256_SET1_EPI16(0x0008);
204const __m256i K16_0010 = SIMD_MM256_SET1_EPI16(0x0010);
205const __m256i K16_0018 = SIMD_MM256_SET1_EPI16(0x0018);
206const __m256i K16_0020 = SIMD_MM256_SET1_EPI16(0x0020);
207const __m256i K16_0080 = SIMD_MM256_SET1_EPI16(0x0080);
208const __m256i K16_00FF = SIMD_MM256_SET1_EPI16(0x00FF);
209const __m256i K16_FF00 = SIMD_MM256_SET1_EPI16(0xFF00);
210
211const __m256i K32_00000001 = SIMD_MM256_SET1_EPI32(0x00000001);
212const __m256i K32_00000002 = SIMD_MM256_SET1_EPI32(0x00000002);
213const __m256i K32_00000004 = SIMD_MM256_SET1_EPI32(0x00000004);
214const __m256i K32_00000008 = SIMD_MM256_SET1_EPI32(0x00000008);
215const __m256i K32_000000FF = SIMD_MM256_SET1_EPI32(0x000000FF);
216const __m256i K32_0000FFFF = SIMD_MM256_SET1_EPI32(0x0000FFFF);
217const __m256i K32_00010000 = SIMD_MM256_SET1_EPI32(0x00010000);
218const __m256i K32_01000000 = SIMD_MM256_SET1_EPI32(0x01000000);
219const __m256i K32_FFFFFF00 = SIMD_MM256_SET1_EPI32(0xFFFFFF00);
220
221const __m256i K8_SHUFFLE_BGR0_TO_BLUE = SIMD_MM256_SETR_EPI8(
222 0x0,
223 0x3,
224 0x6,
225 0x9,
226 0xC,
227 0xF,
228 -1,
229 -1,
230 -1,
231 -1,
232 -1,
233 -1,
234 -1,
235 -1,
236 -1,
237 -1,
238 -1,
239 -1,
240 -1,
241 -1,
242 -1,
243 -1,
244 0x2,
245 0x5,
246 0x8,
247 0xB,
248 0xE,
249 -1,
250 -1,
251 -1,
252 -1,
253 -1);
254const __m256i K8_SHUFFLE_BGR1_TO_BLUE = SIMD_MM256_SETR_EPI8(
255 -1,
256 -1,
257 -1,
258 -1,
259 -1,
260 -1,
261 -1,
262 -1,
263 -1,
264 -1,
265 -1,
266 0x1,
267 0x4,
268 0x7,
269 0xA,
270 0xD,
271 0x0,
272 0x3,
273 0x6,
274 0x9,
275 0xC,
276 0xF,
277 -1,
278 -1,
279 -1,
280 -1,
281 -1,
282 -1,
283 -1,
284 -1,
285 -1,
286 -1);
287const __m256i K8_SHUFFLE_BGR2_TO_BLUE = SIMD_MM256_SETR_EPI8(
288 -1,
289 -1,
290 -1,
291 -1,
292 -1,
293 -1,
294 0x2,
295 0x5,
296 0x8,
297 0xB,
298 0xE,
299 -1,
300 -1,
301 -1,
302 -1,
303 -1,
304 -1,
305 -1,
306 -1,
307 -1,
308 -1,
309 -1,
310 -1,
311 -1,
312 -1,
313 -1,
314 -1,
315 0x1,
316 0x4,
317 0x7,
318 0xA,
319 0xD);
320
321const __m256i Y_SHUFFLE0 = SIMD_MM256_SETR_EPI8(
322 0x0,
323 0x2,
324 0x4,
325 0x6,
326 0x8,
327 0xa,
328 0xc,
329 0xe,
330 -1,
331 -1,
332 -1,
333 -1,
334 -1,
335 -1,
336 -1,
337 -1,
338 0x0,
339 0x2,
340 0x4,
341 0x6,
342 0x8,
343 0xa,
344 0xc,
345 0xe,
346 -1,
347 -1,
348 -1,
349 -1,
350 -1,
351 -1,
352 -1,
353 -1);
354const __m256i Y_SHUFFLE1 = SIMD_MM256_SETR_EPI8(
355 -1,
356 -1,
357 -1,
358 -1,
359 -1,
360 -1,
361 -1,
362 -1,
363 0x0,
364 0x2,
365 0x4,
366 0x6,
367 0x8,
368 0xa,
369 0xc,
370 0xe,
371 -1,
372 -1,
373 -1,
374 -1,
375 -1,
376 -1,
377 -1,
378 -1,
379 0x0,
380 0x2,
381 0x4,
382 0x6,
383 0x8,
384 0xa,
385 0xc,
386 0xe);
387
388const __m256i U_SHUFFLE0 = SIMD_MM256_SETR_EPI8(
389 0x1,
390 0x5,
391 0x9,
392 0xd,
393 -1,
394 -1,
395 -1,
396 -1,
397 -1,
398 -1,
399 -1,
400 -1,
401 -1,
402 -1,
403 -1,
404 -1,
405 0x1,
406 0x5,
407 0x9,
408 0xd,
409 -1,
410 -1,
411 -1,
412 -1,
413 -1,
414 -1,
415 -1,
416 -1,
417 -1,
418 -1,
419 -1,
420 -1);
421const __m256i U_SHUFFLE1 = SIMD_MM256_SETR_EPI8(
422 -1,
423 -1,
424 -1,
425 -1,
426 0x1,
427 0x5,
428 0x9,
429 0xd,
430 -1,
431 -1,
432 -1,
433 -1,
434 -1,
435 -1,
436 -1,
437 -1,
438 -1,
439 -1,
440 -1,
441 -1,
442 0x1,
443 0x5,
444 0x9,
445 0xd,
446 -1,
447 -1,
448 -1,
449 -1,
450 -1,
451 -1,
452 -1,
453 -1);
454const __m256i U_SHUFFLE2 = SIMD_MM256_SETR_EPI8(
455 -1,
456 -1,
457 -1,
458 -1,
459 -1,
460 -1,
461 -1,
462 -1,
463 0x1,
464 0x5,
465 0x9,
466 0xd,
467 -1,
468 -1,
469 -1,
470 -1,
471 -1,
472 -1,
473 -1,
474 -1,
475 -1,
476 -1,
477 -1,
478 -1,
479 0x1,
480 0x5,
481 0x9,
482 0xd,
483 -1,
484 -1,
485 -1,
486 -1);
487
488const __m256i U_SHUFFLE3 = SIMD_MM256_SETR_EPI8(
489 -1,
490 -1,
491 -1,
492 -1,
493 -1,
494 -1,
495 -1,
496 -1,
497 -1,
498 -1,
499 -1,
500 -1,
501 0x1,
502 0x5,
503 0x9,
504 0xd,
505 -1,
506 -1,
507 -1,
508 -1,
509 -1,
510 -1,
511 -1,
512 -1,
513 -1,
514 -1,
515 -1,
516 -1,
517 0x1,
518 0x5,
519 0x9,
520 0xd);
521const __m256i U_SHUFFLE4 = SIMD_MM256_SETR_EPI8(
522 0x0,
523 0x0,
524 0x0,
525 0x0,
526 0x4,
527 0x0,
528 0x0,
529 0x0,
530 0x1,
531 0x0,
532 0x0,
533 0x0,
534 0x5,
535 0x0,
536 0x0,
537 0x0,
538 0x2,
539 0x0,
540 0x0,
541 0x0,
542 0x6,
543 0x0,
544 0x0,
545 0x0,
546 0x3,
547 0x0,
548 0x0,
549 0x0,
550 0x7,
551 0x0,
552 0x0,
553 0x0);
554
555const __m256i V_SHUFFLE0 = SIMD_MM256_SETR_EPI8(
556 0x3,
557 0x7,
558 0xb,
559 0xf,
560 -1,
561 -1,
562 -1,
563 -1,
564 -1,
565 -1,
566 -1,
567 -1,
568 -1,
569 -1,
570 -1,
571 -1,
572 0x3,
573 0x7,
574 0xb,
575 0xf,
576 -1,
577 -1,
578 -1,
579 -1,
580 -1,
581 -1,
582 -1,
583 -1,
584 -1,
585 -1,
586 -1,
587 -1);
588const __m256i V_SHUFFLE1 = SIMD_MM256_SETR_EPI8(
589 -1,
590 -1,
591 -1,
592 -1,
593 0x3,
594 0x7,
595 0xb,
596 0xf,
597 -1,
598 -1,
599 -1,
600 -1,
601 -1,
602 -1,
603 -1,
604 -1,
605 -1,
606 -1,
607 -1,
608 -1,
609 0x3,
610 0x7,
611 0xb,
612 0xf,
613 -1,
614 -1,
615 -1,
616 -1,
617 -1,
618 -1,
619 -1,
620 -1);
621const __m256i V_SHUFFLE2 = SIMD_MM256_SETR_EPI8(
622 -1,
623 -1,
624 -1,
625 -1,
626 -1,
627 -1,
628 -1,
629 -1,
630 0x3,
631 0x7,
632 0xb,
633 0xf,
634 -1,
635 -1,
636 -1,
637 -1,
638 -1,
639 -1,
640 -1,
641 -1,
642 -1,
643 -1,
644 -1,
645 -1,
646 0x3,
647 0x7,
648 0xb,
649 0xf,
650 -1,
651 -1,
652 -1,
653 -1);
654
655const __m256i V_SHUFFLE3 = SIMD_MM256_SETR_EPI8(
656 -1,
657 -1,
658 -1,
659 -1,
660 -1,
661 -1,
662 -1,
663 -1,
664 -1,
665 -1,
666 -1,
667 -1,
668 0x3,
669 0x7,
670 0xb,
671 0xf,
672 -1,
673 -1,
674 -1,
675 -1,
676 -1,
677 -1,
678 -1,
679 -1,
680 -1,
681 -1,
682 -1,
683 -1,
684 0x3,
685 0x7,
686 0xb,
687 0xf);
688
689const __m256i K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0 = SIMD_MM256_SETR_EPI8(
690 0x0,
691 -1,
692 -1,
693 0x1,
694 -1,
695 -1,
696 0x2,
697 -1,
698 -1,
699 0x3,
700 -1,
701 -1,
702 0x4,
703 -1,
704 -1,
705 0x5,
706 -1,
707 -1,
708 0x6,
709 -1,
710 -1,
711 0x7,
712 -1,
713 -1,
714 0x8,
715 -1,
716 -1,
717 0x9,
718 -1,
719 -1,
720 0xA,
721 -1);
722const __m256i K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1 = SIMD_MM256_SETR_EPI8(
723 -1,
724 0x3,
725 -1,
726 -1,
727 0x4,
728 -1,
729 -1,
730 0x5,
731 -1,
732 -1,
733 0x6,
734 -1,
735 -1,
736 0x7,
737 -1,
738 -1,
739 0x8,
740 -1,
741 -1,
742 0x9,
743 -1,
744 -1,
745 0xA,
746 -1,
747 -1,
748 0xB,
749 -1,
750 -1,
751 0xC,
752 -1,
753 -1,
754 0xD);
755const __m256i K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2 = SIMD_MM256_SETR_EPI8(
756 -1,
757 -1,
758 0x6,
759 -1,
760 -1,
761 0x7,
762 -1,
763 -1,
764 0x8,
765 -1,
766 -1,
767 0x9,
768 -1,
769 -1,
770 0xA,
771 -1,
772 -1,
773 0xB,
774 -1,
775 -1,
776 0xC,
777 -1,
778 -1,
779 0xD,
780 -1,
781 -1,
782 0xE,
783 -1,
784 -1,
785 0xF,
786 -1,
787 -1);
788
789const __m256i K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0 = SIMD_MM256_SETR_EPI8(
790 -1,
791 0x0,
792 -1,
793 -1,
794 0x1,
795 -1,
796 -1,
797 0x2,
798 -1,
799 -1,
800 0x3,
801 -1,
802 -1,
803 0x4,
804 -1,
805 -1,
806 0x5,
807 -1,
808 -1,
809 0x6,
810 -1,
811 -1,
812 0x7,
813 -1,
814 -1,
815 0x8,
816 -1,
817 -1,
818 0x9,
819 -1,
820 -1,
821 0xA);
822const __m256i K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1 = SIMD_MM256_SETR_EPI8(
823 -1,
824 -1,
825 0x3,
826 -1,
827 -1,
828 0x4,
829 -1,
830 -1,
831 0x5,
832 -1,
833 -1,
834 0x6,
835 -1,
836 -1,
837 0x7,
838 -1,
839 -1,
840 0x8,
841 -1,
842 -1,
843 0x9,
844 -1,
845 -1,
846 0xA,
847 -1,
848 -1,
849 0xB,
850 -1,
851 -1,
852 0xC,
853 -1,
854 -1);
855const __m256i K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2 = SIMD_MM256_SETR_EPI8(
856 0x5,
857 -1,
858 -1,
859 0x6,
860 -1,
861 -1,
862 0x7,
863 -1,
864 -1,
865 0x8,
866 -1,
867 -1,
868 0x9,
869 -1,
870 -1,
871 0xA,
872 -1,
873 -1,
874 0xB,
875 -1,
876 -1,
877 0xC,
878 -1,
879 -1,
880 0xD,
881 -1,
882 -1,
883 0xE,
884 -1,
885 -1,
886 0xF,
887 -1);
888
889const __m256i K8_SHUFFLE_PERMUTED_RED_TO_BGR0 = SIMD_MM256_SETR_EPI8(
890 -1,
891 -1,
892 0x0,
893 -1,
894 -1,
895 0x1,
896 -1,
897 -1,
898 0x2,
899 -1,
900 -1,
901 0x3,
902 -1,
903 -1,
904 0x4,
905 -1,
906 -1,
907 0x5,
908 -1,
909 -1,
910 0x6,
911 -1,
912 -1,
913 0x7,
914 -1,
915 -1,
916 0x8,
917 -1,
918 -1,
919 0x9,
920 -1,
921 -1);
922const __m256i K8_SHUFFLE_PERMUTED_RED_TO_BGR1 = SIMD_MM256_SETR_EPI8(
923 0x2,
924 -1,
925 -1,
926 0x3,
927 -1,
928 -1,
929 0x4,
930 -1,
931 -1,
932 0x5,
933 -1,
934 -1,
935 0x6,
936 -1,
937 -1,
938 0x7,
939 -1,
940 -1,
941 0x8,
942 -1,
943 -1,
944 0x9,
945 -1,
946 -1,
947 0xA,
948 -1,
949 -1,
950 0xB,
951 -1,
952 -1,
953 0xC,
954 -1);
955const __m256i K8_SHUFFLE_PERMUTED_RED_TO_BGR2 = SIMD_MM256_SETR_EPI8(
956 -1,
957 0x5,
958 -1,
959 -1,
960 0x6,
961 -1,
962 -1,
963 0x7,
964 -1,
965 -1,
966 0x8,
967 -1,
968 -1,
969 0x9,
970 -1,
971 -1,
972 0xA,
973 -1,
974 -1,
975 0xB,
976 -1,
977 -1,
978 0xC,
979 -1,
980 -1,
981 0xD,
982 -1,
983 -1,
984 0xE,
985 -1,
986 -1,
987 0xF);
988
989const __m256i K8_SHUFFLE_BGR0_TO_GREEN = SIMD_MM256_SETR_EPI8(
990 0x1,
991 0x4,
992 0x7,
993 0xA,
994 0xD,
995 -1,
996 -1,
997 -1,
998 -1,
999 -1,
1000 -1,
1001 -1,
1002 -1,
1003 -1,
1004 -1,
1005 -1,
1006 -1,
1007 -1,
1008 -1,
1009 -1,
1010 -1,
1011 0x0,
1012 0x3,
1013 0x6,
1014 0x9,
1015 0xC,
1016 0xF,
1017 -1,
1018 -1,
1019 -1,
1020 -1,
1021 -1);
1022const __m256i K8_SHUFFLE_BGR1_TO_GREEN = SIMD_MM256_SETR_EPI8(
1023 -1,
1024 -1,
1025 -1,
1026 -1,
1027 -1,
1028 -1,
1029 -1,
1030 -1,
1031 -1,
1032 -1,
1033 -1,
1034 0x2,
1035 0x5,
1036 0x8,
1037 0xB,
1038 0xE,
1039 0x1,
1040 0x4,
1041 0x7,
1042 0xA,
1043 0xD,
1044 -1,
1045 -1,
1046 -1,
1047 -1,
1048 -1,
1049 -1,
1050 -1,
1051 -1,
1052 -1,
1053 -1,
1054 -1);
1055const __m256i K8_SHUFFLE_BGR2_TO_GREEN = SIMD_MM256_SETR_EPI8(
1056 -1,
1057 -1,
1058 -1,
1059 -1,
1060 -1,
1061 0x0,
1062 0x3,
1063 0x6,
1064 0x9,
1065 0xC,
1066 0xF,
1067 -1,
1068 -1,
1069 -1,
1070 -1,
1071 -1,
1072 -1,
1073 -1,
1074 -1,
1075 -1,
1076 -1,
1077 -1,
1078 -1,
1079 -1,
1080 -1,
1081 -1,
1082 -1,
1083 0x2,
1084 0x5,
1085 0x8,
1086 0xB,
1087 0xE);
1088
1089const __m256i K8_SHUFFLE_BGR0_TO_RED = SIMD_MM256_SETR_EPI8(
1090 0x2,
1091 0x5,
1092 0x8,
1093 0xB,
1094 0xE,
1095 -1,
1096 -1,
1097 -1,
1098 -1,
1099 -1,
1100 -1,
1101 -1,
1102 -1,
1103 -1,
1104 -1,
1105 -1,
1106 -1,
1107 -1,
1108 -1,
1109 -1,
1110 -1,
1111 0x1,
1112 0x4,
1113 0x7,
1114 0xA,
1115 0xD,
1116 -1,
1117 -1,
1118 -1,
1119 -1,
1120 -1,
1121 -1);
1122const __m256i K8_SHUFFLE_BGR1_TO_RED = SIMD_MM256_SETR_EPI8(
1123 -1,
1124 -1,
1125 -1,
1126 -1,
1127 -1,
1128 -1,
1129 -1,
1130 -1,
1131 -1,
1132 -1,
1133 0x0,
1134 0x3,
1135 0x6,
1136 0x9,
1137 0xC,
1138 0xF,
1139 0x2,
1140 0x5,
1141 0x8,
1142 0xB,
1143 0xE,
1144 -1,
1145 -1,
1146 -1,
1147 -1,
1148 -1,
1149 -1,
1150 -1,
1151 -1,
1152 -1,
1153 -1,
1154 -1);
1155const __m256i K8_SHUFFLE_BGR2_TO_RED = SIMD_MM256_SETR_EPI8(
1156 -1,
1157 -1,
1158 -1,
1159 -1,
1160 -1,
1161 0x1,
1162 0x4,
1163 0x7,
1164 0xA,
1165 0xD,
1166 -1,
1167 -1,
1168 -1,
1169 -1,
1170 -1,
1171 -1,
1172 -1,
1173 -1,
1174 -1,
1175 -1,
1176 -1,
1177 -1,
1178 -1,
1179 -1,
1180 -1,
1181 -1,
1182 0x0,
1183 0x3,
1184 0x6,
1185 0x9,
1186 0xC,
1187 0xF);
1188
1189const __m256i K16_Y_ADJUST = SIMD_MM256_SET1_EPI16(0);
1190const __m256i K16_UV_ADJUST = SIMD_MM256_SET1_EPI16(128);
1191const int Y_ADJUST = 0;
1192const int UV_ADJUST = 128;
1193const int YUV_TO_BGR_AVERAGING_SHIFT = 13;
1194const int YUV_TO_BGR_ROUND_TERM = 0; // 1 << (YUV_TO_BGR_AVERAGING_SHIFT);
1195const int Y_TO_RGB_WEIGHT = static_cast<int>((((1 << YUV_TO_BGR_AVERAGING_SHIFT))));
1196const int U_TO_BLUE_WEIGHT = static_cast<int>((2.041 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)));
1197const int U_TO_GREEN_WEIGHT = -static_cast<int>((0.3455 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)));
1198const int V_TO_GREEN_WEIGHT = -static_cast<int>((0.7169 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)));
1199const int V_TO_RED_WEIGHT = static_cast<int>((1.4065 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)));
1200
1201const __m256i K16_YRGB_RT = SIMD_MM256_SET2_EPI16(Y_TO_RGB_WEIGHT, YUV_TO_BGR_ROUND_TERM);
1202const __m256i K16_VR_0 = SIMD_MM256_SET2_EPI16(V_TO_RED_WEIGHT, 0);
1203const __m256i K16_UG_VG = SIMD_MM256_SET2_EPI16(U_TO_GREEN_WEIGHT, V_TO_GREEN_WEIGHT);
1204const __m256i K16_UB_0 = SIMD_MM256_SET2_EPI16(U_TO_BLUE_WEIGHT, 0);
1205
1206template <bool align>
1207SIMD_INLINE __m256i Load(const __m256i *p);
1208
1209template <>
1210SIMD_INLINE __m256i Load<false>(const __m256i *p) {
1211 return _mm256_loadu_si256(p);
1212}
1213
1214template <>
1215SIMD_INLINE __m256i Load<true>(const __m256i *p) {
1216 return _mm256_load_si256(p);
1217}
1218
1219SIMD_INLINE void *AlignLo(const void *ptr, size_t align) {
1220 return reinterpret_cast<void *>(((size_t)ptr) & ~(align - 1));
1221}
1222
1223SIMD_INLINE bool Aligned(const void *ptr, size_t align = sizeof(__m256)) {
1224 return ptr == AlignLo(ptr, align);
1225}
1226
1227template <bool align>
1228SIMD_INLINE void Store(__m256i *p, __m256i a);
1229
1230template <>
1231SIMD_INLINE void Store<false>(__m256i *p, __m256i a) {
1232 _mm256_storeu_si256(p, a);
1233}
1234
1235template <>
1236SIMD_INLINE void Store<true>(__m256i *p, __m256i a) {
1237 _mm256_store_si256(p, a);
1238}
1239
1240SIMD_INLINE __m256i SaturateI16ToU8(__m256i value) {
1241 return _mm256_min_epi16(K16_00FF, _mm256_max_epi16(value, K_ZERO));
1242}
1243
1244SIMD_INLINE __m256i AdjustY16(__m256i y16) {
1245 return _mm256_subs_epi16(y16, K16_Y_ADJUST);
1246}
1247
1248SIMD_INLINE __m256i AdjustUV16(__m256i uv16) {
1249 return _mm256_subs_epi16(uv16, K16_UV_ADJUST);
1250}
1251
1252SIMD_INLINE __m256i AdjustedYuvToRed32(__m256i y16_1, __m256i v16_0) {
1253 // print_m256_i16(y16_1);
1254 // print_m256_i16(v16_0);
1255 // print_m256_i32(_mm256_madd_epi16(y16_1, K16_YRGB_RT));
1256 // print_m256_i32(_mm256_madd_epi16(v16_0, K16_VR_0));
1257 return _mm256_srai_epi32(
1258 _mm256_add_epi32(_mm256_madd_epi16(y16_1, K16_YRGB_RT), _mm256_madd_epi16(v16_0, K16_VR_0)),
1259 YUV_TO_BGR_AVERAGING_SHIFT);
1260}
1261
1262SIMD_INLINE __m256i AdjustedYuvToRed16(__m256i y16, __m256i v16) {
1263 // print_m256_i32(AdjustedYuvToRed32(_mm256_unpacklo_epi16(y16, K16_0001),
1264 // _mm256_unpacklo_epi16(v16, K_ZERO)));
1265 // print_m256_i16(_mm256_unpacklo_epi16(y16, K16_0001));
1266 return SaturateI16ToU8(_mm256_packs_epi32(
1267 AdjustedYuvToRed32(_mm256_unpacklo_epi16(y16, K16_0001), _mm256_unpacklo_epi16(v16, K_ZERO)),
1268 AdjustedYuvToRed32(_mm256_unpackhi_epi16(y16, K16_0001), _mm256_unpackhi_epi16(v16, K_ZERO))));
1269}
1270
1271SIMD_INLINE __m256i AdjustedYuvToGreen32(__m256i y16_1, __m256i u16_v16) {
1272 return _mm256_srai_epi32(
1273 _mm256_add_epi32(_mm256_madd_epi16(y16_1, K16_YRGB_RT), _mm256_madd_epi16(u16_v16, K16_UG_VG)),
1274 YUV_TO_BGR_AVERAGING_SHIFT);
1275}
1276
1277SIMD_INLINE __m256i AdjustedYuvToGreen16(__m256i y16, __m256i u16, __m256i v16) {
1278 return SaturateI16ToU8(_mm256_packs_epi32(
1279 AdjustedYuvToGreen32(_mm256_unpacklo_epi16(y16, K16_0001), _mm256_unpacklo_epi16(u16, v16)),
1280 AdjustedYuvToGreen32(_mm256_unpackhi_epi16(y16, K16_0001), _mm256_unpackhi_epi16(u16, v16))));
1281}
1282
1283SIMD_INLINE __m256i AdjustedYuvToBlue32(__m256i y16_1, __m256i u16_0) {
1284 return _mm256_srai_epi32(
1285 _mm256_add_epi32(_mm256_madd_epi16(y16_1, K16_YRGB_RT), _mm256_madd_epi16(u16_0, K16_UB_0)),
1286 YUV_TO_BGR_AVERAGING_SHIFT);
1287}
1288
1289SIMD_INLINE __m256i AdjustedYuvToBlue16(__m256i y16, __m256i u16) {
1290 return SaturateI16ToU8(_mm256_packs_epi32(
1291 AdjustedYuvToBlue32(_mm256_unpacklo_epi16(y16, K16_0001), _mm256_unpacklo_epi16(u16, K_ZERO)),
1292 AdjustedYuvToBlue32(_mm256_unpackhi_epi16(y16, K16_0001), _mm256_unpackhi_epi16(u16, K_ZERO))));
1293}
1294
1295SIMD_INLINE __m256i YuvToRed(__m256i y, __m256i v) {
1296 __m256i lo = AdjustedYuvToRed16(_mm256_unpacklo_epi8(y, K_ZERO), AdjustUV16(_mm256_unpacklo_epi8(v, K_ZERO)));
1297 __m256i hi = AdjustedYuvToRed16((_mm256_unpackhi_epi8(y, K_ZERO)), AdjustUV16(_mm256_unpackhi_epi8(v, K_ZERO)));
1298
1299 // print_m256_i16(lo);
1300 // print_m256_i16(hi);
1301 return _mm256_packus_epi16(lo, hi);
1302}
1303
1304SIMD_INLINE __m256i YuvToGreen(__m256i y, __m256i u, __m256i v) {
1305 __m256i lo = AdjustedYuvToGreen16(
1306 (_mm256_unpacklo_epi8(y, K_ZERO)),
1307 AdjustUV16(_mm256_unpacklo_epi8(u, K_ZERO)),
1308 AdjustUV16(_mm256_unpacklo_epi8(v, K_ZERO)));
1309 __m256i hi = AdjustedYuvToGreen16(
1310 (_mm256_unpackhi_epi8(y, K_ZERO)),
1311 AdjustUV16(_mm256_unpackhi_epi8(u, K_ZERO)),
1312 AdjustUV16(_mm256_unpackhi_epi8(v, K_ZERO)));
1313 return _mm256_packus_epi16(lo, hi);
1314}
1315
1316SIMD_INLINE __m256i YuvToBlue(__m256i y, __m256i u) {
1317 __m256i lo = AdjustedYuvToBlue16((_mm256_unpacklo_epi8(y, K_ZERO)), AdjustUV16(_mm256_unpacklo_epi8(u, K_ZERO)));
1318 __m256i hi = AdjustedYuvToBlue16((_mm256_unpackhi_epi8(y, K_ZERO)), AdjustUV16(_mm256_unpackhi_epi8(u, K_ZERO)));
1319 return _mm256_packus_epi16(lo, hi);
1320}
1321
1322template <int index>
1323__m256i InterleaveBgr(__m256i blue, __m256i green, __m256i red);
1324
1325template <>
1326SIMD_INLINE __m256i InterleaveBgr<0>(__m256i blue, __m256i green, __m256i red) {
1327 return _mm256_or_si256(
1328 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(blue, 0x44), K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0),
1329 _mm256_or_si256(
1330 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(green, 0x44), K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0),
1331 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(red, 0x44), K8_SHUFFLE_PERMUTED_RED_TO_BGR0)));
1332}
1333
1334template <>
1335SIMD_INLINE __m256i InterleaveBgr<1>(__m256i blue, __m256i green, __m256i red) {
1336 return _mm256_or_si256(
1337 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(blue, 0x99), K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1),
1338 _mm256_or_si256(
1339 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(green, 0x99), K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1),
1340 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(red, 0x99), K8_SHUFFLE_PERMUTED_RED_TO_BGR1)));
1341}
1342
1343template <>
1344SIMD_INLINE __m256i InterleaveBgr<2>(__m256i blue, __m256i green, __m256i red) {
1345 return _mm256_or_si256(
1346 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(blue, 0xEE), K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2),
1347 _mm256_or_si256(
1348 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(green, 0xEE), K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2),
1349 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(red, 0xEE), K8_SHUFFLE_PERMUTED_RED_TO_BGR2)));
1350}
1351
1352SIMD_INLINE __m256i BgrToBlue(__m256i bgr[3]) {
1353 __m256i b0 = _mm256_shuffle_epi8(bgr[0], K8_SHUFFLE_BGR0_TO_BLUE);
1354 __m256i b2 = _mm256_shuffle_epi8(bgr[2], K8_SHUFFLE_BGR2_TO_BLUE);
1355 return _mm256_or_si256(
1356 _mm256_permute2x128_si256(b0, b2, 0x20),
1357 _mm256_or_si256(
1358 _mm256_shuffle_epi8(bgr[1], K8_SHUFFLE_BGR1_TO_BLUE), _mm256_permute2x128_si256(b0, b2, 0x31)));
1359}
1360
1361SIMD_INLINE __m256i BgrToGreen(__m256i bgr[3]) {
1362 __m256i g0 = _mm256_shuffle_epi8(bgr[0], K8_SHUFFLE_BGR0_TO_GREEN);
1363 __m256i g2 = _mm256_shuffle_epi8(bgr[2], K8_SHUFFLE_BGR2_TO_GREEN);
1364 return _mm256_or_si256(
1365 _mm256_permute2x128_si256(g0, g2, 0x20),
1366 _mm256_or_si256(
1367 _mm256_shuffle_epi8(bgr[1], K8_SHUFFLE_BGR1_TO_GREEN), _mm256_permute2x128_si256(g0, g2, 0x31)));
1368}
1369
1370SIMD_INLINE __m256i BgrToRed(__m256i bgr[3]) {
1371 __m256i r0 = _mm256_shuffle_epi8(bgr[0], K8_SHUFFLE_BGR0_TO_RED);
1372 __m256i r2 = _mm256_shuffle_epi8(bgr[2], K8_SHUFFLE_BGR2_TO_RED);
1373 return _mm256_or_si256(
1374 _mm256_permute2x128_si256(r0, r2, 0x20),
1375 _mm256_or_si256(
1376 _mm256_shuffle_epi8(bgr[1], K8_SHUFFLE_BGR1_TO_RED), _mm256_permute2x128_si256(r0, r2, 0x31)));
1377}
1378
1379template <bool align>
1380SIMD_INLINE __m256i LoadPermuted(const __m256i *p) {
1381 return _mm256_permute4x64_epi64(Load<align>(p), 0xD8);
1382}
1383
1384} // namespace camera
1385} // namespace drivers
1386} // namespace apollo
SIMD_MM256_SET1_EPI16
#define SIMD_MM256_SET1_EPI16(a)
Definition util.h:142
SIMD_LL_SET1_EPI8
#define SIMD_LL_SET1_EPI8(a)
Definition util.h:60
SIMD_MM256_SET2_EPI8
#define SIMD_MM256_SET2_EPI8(a0, a1)
Definition util.h:97
SIMD_MM256_SETR_EPI8
#define SIMD_MM256_SETR_EPI8( a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf)
Definition util.h:103
SIMD_MM256_SET1_EPI32
#define SIMD_MM256_SET1_EPI32(a)
Definition util.h:160
SIMD_MM256_SET1_EPI8
#define SIMD_MM256_SET1_EPI8(a)
Definition util.h:91
SIMD_MM256_SET2_EPI16
#define SIMD_MM256_SET2_EPI16(a0, a1)
Definition util.h:148
SIMD_INLINE
#define SIMD_INLINE
Definition util.h:43
apollo::drivers::camera::U_TO_GREEN_WEIGHT
const int U_TO_GREEN_WEIGHT
Definition util.h:1198
apollo::drivers::camera::A
const size_t A
Definition util.h:178
apollo::drivers::camera::K16_FF00
const __m256i K16_FF00
Definition util.h:210
apollo::drivers::camera::BgrToGreen
SIMD_INLINE __m256i BgrToGreen(__m256i bgr[3])
Definition util.h:1362
apollo::drivers::camera::K32_00000004
const __m256i K32_00000004
Definition util.h:214
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR2
const __m256i K8_SHUFFLE_PERMUTED_RED_TO_BGR2
Definition util.h:956
apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_BLUE
const __m256i K8_SHUFFLE_BGR1_TO_BLUE
Definition util.h:255
apollo::drivers::camera::K16_0010
const __m256i K16_0010
Definition util.h:205
apollo::drivers::camera::K8_10
const __m256i K8_10
Definition util.h:191
apollo::drivers::camera::K16_0004
const __m256i K16_0004
Definition util.h:201
apollo::drivers::camera::K16_0005
const __m256i K16_0005
Definition util.h:202
apollo::drivers::camera::K16_YRGB_RT
const __m256i K16_YRGB_RT
Definition util.h:1202
apollo::drivers::camera::OA
const size_t OA
Definition util.h:181
apollo::drivers::camera::K8_04
const __m256i K8_04
Definition util.h:189
apollo::drivers::camera::QA
const size_t QA
Definition util.h:180
apollo::drivers::camera::K16_0001
const __m256i K16_0001
Definition util.h:198
apollo::drivers::camera::Y_TO_RGB_WEIGHT
const int Y_TO_RGB_WEIGHT
Definition util.h:1196
apollo::drivers::camera::K16_UG_VG
const __m256i K16_UG_VG
Definition util.h:1204
apollo::drivers::camera::Y_SHUFFLE0
const __m256i Y_SHUFFLE0
Definition util.h:322
apollo::drivers::camera::V_SHUFFLE3
const __m256i V_SHUFFLE3
Definition util.h:656
apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_RED
const __m256i K8_SHUFFLE_BGR1_TO_RED
Definition util.h:1123
apollo::drivers::camera::YuvToRed
SIMD_INLINE __m256i YuvToRed(__m256i y, __m256i v)
Definition util.h:1296
apollo::drivers::camera::K8_01
const __m256i K8_01
Definition util.h:187
apollo::drivers::camera::U_SHUFFLE1
const __m256i U_SHUFFLE1
Definition util.h:422
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0
const __m256i K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0
Definition util.h:690
apollo::drivers::camera::K8_80
const __m256i K8_80
Definition util.h:194
apollo::drivers::camera::K16_0008
const __m256i K16_0008
Definition util.h:204
apollo::drivers::camera::SaturateI16ToU8
SIMD_INLINE __m256i SaturateI16ToU8(__m256i value)
Definition util.h:1241
apollo::drivers::camera::K32_00010000
const __m256i K32_00010000
Definition util.h:218
apollo::drivers::camera::K16_00FF
const __m256i K16_00FF
Definition util.h:209
apollo::drivers::camera::YUV_TO_BGR_AVERAGING_SHIFT
const int YUV_TO_BGR_AVERAGING_SHIFT
Definition util.h:1194
apollo::drivers::camera::K16_VR_0
const __m256i K16_VR_0
Definition util.h:1203
apollo::drivers::camera::AdjustY16
SIMD_INLINE __m256i AdjustY16(__m256i y16)
Definition util.h:1245
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1
const __m256i K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1
Definition util.h:723
apollo::drivers::camera::BgrToRed
SIMD_INLINE __m256i BgrToRed(__m256i bgr[3])
Definition util.h:1371
apollo::drivers::camera::YuvToBlue
SIMD_INLINE __m256i YuvToBlue(__m256i y, __m256i u)
Definition util.h:1317
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2
const __m256i K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2
Definition util.h:856
apollo::drivers::camera::AdjustUV16
SIMD_INLINE __m256i AdjustUV16(__m256i uv16)
Definition util.h:1249
apollo::drivers::camera::K16_UV_ADJUST
const __m256i K16_UV_ADJUST
Definition util.h:1191
apollo::drivers::camera::DA
const size_t DA
Definition util.h:179
apollo::drivers::camera::V_SHUFFLE1
const __m256i V_SHUFFLE1
Definition util.h:589
apollo::drivers::camera::AdjustedYuvToBlue16
SIMD_INLINE __m256i AdjustedYuvToBlue16(__m256i y16, __m256i u16)
Definition util.h:1290
apollo::drivers::camera::K32_00000008
const __m256i K32_00000008
Definition util.h:215
apollo::drivers::camera::UV_ADJUST
const int UV_ADJUST
Definition util.h:1193
apollo::drivers::camera::U_SHUFFLE2
const __m256i U_SHUFFLE2
Definition util.h:455
apollo::drivers::camera::V_SHUFFLE2
const __m256i V_SHUFFLE2
Definition util.h:622
apollo::drivers::camera::K16_0080
const __m256i K16_0080
Definition util.h:208
apollo::drivers::camera::V_TO_RED_WEIGHT
const int V_TO_RED_WEIGHT
Definition util.h:1200
apollo::drivers::camera::K8_02
const __m256i K8_02
Definition util.h:188
apollo::drivers::camera::K8_40
const __m256i K8_40
Definition util.h:193
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2
const __m256i K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2
Definition util.h:756
apollo::drivers::camera::AdjustedYuvToRed16
SIMD_INLINE __m256i AdjustedYuvToRed16(__m256i y16, __m256i v16)
Definition util.h:1263
apollo::drivers::camera::K32_00000002
const __m256i K32_00000002
Definition util.h:213
apollo::drivers::camera::Store
SIMD_INLINE void Store(__m256i *p, __m256i a)
apollo::drivers::camera::AdjustedYuvToBlue32
SIMD_INLINE __m256i AdjustedYuvToBlue32(__m256i y16_1, __m256i u16_0)
Definition util.h:1284
apollo::drivers::camera::K16_0018
const __m256i K16_0018
Definition util.h:206
apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_RED
const __m256i K8_SHUFFLE_BGR0_TO_RED
Definition util.h:1090
apollo::drivers::camera::V_TO_GREEN_WEIGHT
const int V_TO_GREEN_WEIGHT
Definition util.h:1199
apollo::drivers::camera::AdjustedYuvToGreen32
SIMD_INLINE __m256i AdjustedYuvToGreen32(__m256i y16_1, __m256i u16_v16)
Definition util.h:1272
apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_RED
const __m256i K8_SHUFFLE_BGR2_TO_RED
Definition util.h:1156
apollo::drivers::camera::Y_SHUFFLE1
const __m256i Y_SHUFFLE1
Definition util.h:355
apollo::drivers::camera::K16_Y_ADJUST
const __m256i K16_Y_ADJUST
Definition util.h:1190
apollo::drivers::camera::AdjustedYuvToGreen16
SIMD_INLINE __m256i AdjustedYuvToGreen16(__m256i y16, __m256i u16, __m256i v16)
Definition util.h:1278
apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_BLUE
const __m256i K8_SHUFFLE_BGR0_TO_BLUE
Definition util.h:222
apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_GREEN
const __m256i K8_SHUFFLE_BGR2_TO_GREEN
Definition util.h:1056
apollo::drivers::camera::AlignLo
SIMD_INLINE void * AlignLo(const void *ptr, size_t align)
Definition util.h:1220
apollo::drivers::camera::BgrToBlue
SIMD_INLINE __m256i BgrToBlue(__m256i bgr[3])
Definition util.h:1353
apollo::drivers::camera::HA
const size_t HA
Definition util.h:182
apollo::drivers::camera::K16_0006
const __m256i K16_0006
Definition util.h:203
apollo::drivers::camera::V_SHUFFLE0
const __m256i V_SHUFFLE0
Definition util.h:556
apollo::drivers::camera::YUV_TO_BGR_ROUND_TERM
const int YUV_TO_BGR_ROUND_TERM
Definition util.h:1195
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR1
const __m256i K8_SHUFFLE_PERMUTED_RED_TO_BGR1
Definition util.h:923
apollo::drivers::camera::AdjustedYuvToRed32
SIMD_INLINE __m256i AdjustedYuvToRed32(__m256i y16_1, __m256i v16_0)
Definition util.h:1253
apollo::drivers::camera::U_TO_BLUE_WEIGHT
const int U_TO_BLUE_WEIGHT
Definition util.h:1197
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR0
const __m256i K8_SHUFFLE_PERMUTED_RED_TO_BGR0
Definition util.h:890
apollo::drivers::camera::U_SHUFFLE4
const __m256i U_SHUFFLE4
Definition util.h:522
apollo::drivers::camera::K_INV_ZERO
const __m256i K_INV_ZERO
Definition util.h:185
apollo::drivers::camera::InterleaveBgr
__m256i InterleaveBgr(__m256i blue, __m256i green, __m256i red)
apollo::drivers::camera::K32_01000000
const __m256i K32_01000000
Definition util.h:219
apollo::drivers::camera::YuvToGreen
SIMD_INLINE __m256i YuvToGreen(__m256i y, __m256i u, __m256i v)
Definition util.h:1305
apollo::drivers::camera::K8_01_FF
const __m256i K8_01_FF
Definition util.h:196
apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_GREEN
const __m256i K8_SHUFFLE_BGR1_TO_GREEN
Definition util.h:1023
apollo::drivers::camera::K16_0003
const __m256i K16_0003
Definition util.h:200
apollo::drivers::camera::K_ZERO
const __m256i K_ZERO
Definition util.h:184
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1
const __m256i K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1
Definition util.h:823
apollo::drivers::camera::K32_00000001
const __m256i K32_00000001
Definition util.h:212
apollo::drivers::camera::U_SHUFFLE3
const __m256i U_SHUFFLE3
Definition util.h:489
apollo::drivers::camera::K32_0000FFFF
const __m256i K32_0000FFFF
Definition util.h:217
apollo::drivers::camera::K8_08
const __m256i K8_08
Definition util.h:190
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0
const __m256i K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0
Definition util.h:790
apollo::drivers::camera::Load
SIMD_INLINE __m256i Load(const __m256i *p)
apollo::drivers::camera::K32_000000FF
const __m256i K32_000000FF
Definition util.h:216
apollo::drivers::camera::K8_20
const __m256i K8_20
Definition util.h:192
apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_GREEN
const __m256i K8_SHUFFLE_BGR0_TO_GREEN
Definition util.h:990
apollo::drivers::camera::LoadPermuted
SIMD_INLINE __m256i LoadPermuted(const __m256i *p)
Definition util.h:1381
apollo::drivers::camera::K16_0020
const __m256i K16_0020
Definition util.h:207
apollo::drivers::camera::K32_FFFFFF00
const __m256i K32_FFFFFF00
Definition util.h:220
apollo::drivers::camera::K16_UB_0
const __m256i K16_UB_0
Definition util.h:1205
apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_BLUE
const __m256i K8_SHUFFLE_BGR2_TO_BLUE
Definition util.h:288
apollo::drivers::camera::U_SHUFFLE0
const __m256i U_SHUFFLE0
Definition util.h:389
apollo::drivers::camera::Aligned
SIMD_INLINE bool Aligned(const void *ptr, size_t align=sizeof(__m256))
Definition util.h:1224
apollo::drivers::camera::K16_0002
const __m256i K16_0002
Definition util.h:199

◆ SIMD_LL_SET1_EPI32

#define SIMD_LL_SET1_EPI32 (   a)    SIMD_INT_AS_LONGLONG(a) | (SIMD_INT_AS_LONGLONG(a) << 32)

在文件 util.h 第 87 行定义.

◆ SIMD_LL_SET1_EPI8

#define SIMD_LL_SET1_EPI8 (   a)
值:
SIMD_CHAR_AS_LONGLONG(a) | (SIMD_CHAR_AS_LONGLONG(a) << 8) | (SIMD_CHAR_AS_LONGLONG(a) << 16) \
| (SIMD_CHAR_AS_LONGLONG(a) << 24) | (SIMD_CHAR_AS_LONGLONG(a) << 32) | (SIMD_CHAR_AS_LONGLONG(a) << 40) \
| (SIMD_CHAR_AS_LONGLONG(a) << 48) | (SIMD_CHAR_AS_LONGLONG(a) << 56)
SIMD_CHAR_AS_LONGLONG
#define SIMD_CHAR_AS_LONGLONG(a)
Definition util.h:54

在文件 util.h 第 60 行定义.

◆ SIMD_LL_SET2_EPI16

#define SIMD_LL_SET2_EPI16 (   a,
  b 
)
值:
SIMD_SHORT_AS_LONGLONG(a) | (SIMD_SHORT_AS_LONGLONG(b) << 16) | (SIMD_SHORT_AS_LONGLONG(a) << 32) \
| (SIMD_SHORT_AS_LONGLONG(b) << 48)

在文件 util.h 第 79 行定义.

◆ SIMD_LL_SET2_EPI32

#define SIMD_LL_SET2_EPI32 (   a,
  b 
)    SIMD_INT_AS_LONGLONG(a) | (SIMD_INT_AS_LONGLONG(b) << 32)

在文件 util.h 第 89 行定义.

◆ SIMD_LL_SET2_EPI8

#define SIMD_LL_SET2_EPI8 (   a,
  b 
)
值:
SIMD_CHAR_AS_LONGLONG(a) | (SIMD_CHAR_AS_LONGLONG(b) << 8) | (SIMD_CHAR_AS_LONGLONG(a) << 16) \
| (SIMD_CHAR_AS_LONGLONG(b) << 24) | (SIMD_CHAR_AS_LONGLONG(a) << 32) | (SIMD_CHAR_AS_LONGLONG(b) << 40) \
| (SIMD_CHAR_AS_LONGLONG(a) << 48) | (SIMD_CHAR_AS_LONGLONG(b) << 56)

在文件 util.h 第 65 行定义.

◆ SIMD_LL_SETR_EPI16

#define SIMD_LL_SETR_EPI16 (   a,
  b,
  c,
  d 
)
值:
SIMD_SHORT_AS_LONGLONG(a) | (SIMD_SHORT_AS_LONGLONG(b) << 16) | (SIMD_SHORT_AS_LONGLONG(c) << 32) \
| (SIMD_SHORT_AS_LONGLONG(d) << 48)

在文件 util.h 第 83 行定义.

◆ SIMD_LL_SETR_EPI8

#define SIMD_LL_SETR_EPI8 (   a,
  b,
  c,
  d,
  e,
  f,
  g,
  h 
)
值:
SIMD_CHAR_AS_LONGLONG(a) | (SIMD_CHAR_AS_LONGLONG(b) << 8) | (SIMD_CHAR_AS_LONGLONG(c) << 16) \
| (SIMD_CHAR_AS_LONGLONG(d) << 24) | (SIMD_CHAR_AS_LONGLONG(e) << 32) | (SIMD_CHAR_AS_LONGLONG(f) << 40) \
| (SIMD_CHAR_AS_LONGLONG(g) << 48) | (SIMD_CHAR_AS_LONGLONG(h) << 56)
f
double f
Definition a_star_strategy.cc:33

在文件 util.h 第 70 行定义.

◆ SIMD_MM256_SET1_EPI16

#define SIMD_MM256_SET1_EPI16 (   a)
值:
{ \
SIMD_LL_SET1_EPI16(a) \
, SIMD_LL_SET1_EPI16(a), SIMD_LL_SET1_EPI16(a), SIMD_LL_SET1_EPI16(a) \
}
SIMD_LL_SET1_EPI16
#define SIMD_LL_SET1_EPI16(a)
Definition util.h:75

在文件 util.h 第 142 行定义.

143 { \
144 SIMD_LL_SET1_EPI16(a) \
145 , SIMD_LL_SET1_EPI16(a), SIMD_LL_SET1_EPI16(a), SIMD_LL_SET1_EPI16(a) \
146 }

◆ SIMD_MM256_SET1_EPI32

#define SIMD_MM256_SET1_EPI32 (   a)
值:
{ \
SIMD_LL_SET1_EPI32(a) \
, SIMD_LL_SET1_EPI32(a), SIMD_LL_SET1_EPI32(a), SIMD_LL_SET1_EPI32(a) \
}
SIMD_LL_SET1_EPI32
#define SIMD_LL_SET1_EPI32(a)
Definition util.h:87

在文件 util.h 第 160 行定义.

161 { \
162 SIMD_LL_SET1_EPI32(a) \
163 , SIMD_LL_SET1_EPI32(a), SIMD_LL_SET1_EPI32(a), SIMD_LL_SET1_EPI32(a) \
164 }

◆ SIMD_MM256_SET1_EPI8

#define SIMD_MM256_SET1_EPI8 (   a)
值:
{ \
SIMD_LL_SET1_EPI8(a) \
, SIMD_LL_SET1_EPI8(a), SIMD_LL_SET1_EPI8(a), SIMD_LL_SET1_EPI8(a) \
}

在文件 util.h 第 91 行定义.

92 { \
93 SIMD_LL_SET1_EPI8(a) \
94 , SIMD_LL_SET1_EPI8(a), SIMD_LL_SET1_EPI8(a), SIMD_LL_SET1_EPI8(a) \
95 }

◆ SIMD_MM256_SET2_EPI16

#define SIMD_MM256_SET2_EPI16 (   a0,
  a1 
)
值:
{ \
SIMD_LL_SET2_EPI16(a0, a1) \
, SIMD_LL_SET2_EPI16(a0, a1), SIMD_LL_SET2_EPI16(a0, a1), SIMD_LL_SET2_EPI16(a0, a1) \
}
SIMD_LL_SET2_EPI16
#define SIMD_LL_SET2_EPI16(a, b)
Definition util.h:79

在文件 util.h 第 148 行定义.

149 { \
150 SIMD_LL_SET2_EPI16(a0, a1) \
151 , SIMD_LL_SET2_EPI16(a0, a1), SIMD_LL_SET2_EPI16(a0, a1), SIMD_LL_SET2_EPI16(a0, a1) \
152 }

◆ SIMD_MM256_SET2_EPI32

#define SIMD_MM256_SET2_EPI32 (   a0,
  a1 
)
值:
{ \
SIMD_LL_SET2_EPI32(a0, a1) \
, SIMD_LL_SET2_EPI32(a0, a1), SIMD_LL_SET2_EPI32(a0, a1), SIMD_LL_SET2_EPI32(a0, a1) \
}
SIMD_LL_SET2_EPI32
#define SIMD_LL_SET2_EPI32(a, b)
Definition util.h:89

在文件 util.h 第 166 行定义.

167 { \
168 SIMD_LL_SET2_EPI32(a0, a1) \
169 , SIMD_LL_SET2_EPI32(a0, a1), SIMD_LL_SET2_EPI32(a0, a1), SIMD_LL_SET2_EPI32(a0, a1) \
170 }

◆ SIMD_MM256_SET2_EPI8

#define SIMD_MM256_SET2_EPI8 (   a0,
  a1 
)
值:
{ \
SIMD_LL_SET2_EPI8(a0, a1) \
, SIMD_LL_SET2_EPI8(a0, a1), SIMD_LL_SET2_EPI8(a0, a1), SIMD_LL_SET2_EPI8(a0, a1) \
}
SIMD_LL_SET2_EPI8
#define SIMD_LL_SET2_EPI8(a, b)
Definition util.h:65

在文件 util.h 第 97 行定义.

98 { \
99 SIMD_LL_SET2_EPI8(a0, a1) \
100 , SIMD_LL_SET2_EPI8(a0, a1), SIMD_LL_SET2_EPI8(a0, a1), SIMD_LL_SET2_EPI8(a0, a1) \
101 }

◆ SIMD_MM256_SETR_EPI16

#define SIMD_MM256_SETR_EPI16 (   a0,
  a1,
  a2,
  a3,
  a4,
  a5,
  a6,
  a7,
  a8,
  a9,
  aa,
  ab,
  ac,
  ad,
  ae,
  af 
)
值:
{ \
SIMD_LL_SETR_EPI16(a0, a1, a2, a3) \
, SIMD_LL_SETR_EPI16(a4, a5, a6, a7), SIMD_LL_SETR_EPI16(a8, a9, aa, ab), SIMD_LL_SETR_EPI16(ac, ad, ae, af) \
}
SIMD_LL_SETR_EPI16
#define SIMD_LL_SETR_EPI16(a, b, c, d)
Definition util.h:83

在文件 util.h 第 154 行定义.

155 { \
156 SIMD_LL_SETR_EPI16(a0, a1, a2, a3) \
157 , SIMD_LL_SETR_EPI16(a4, a5, a6, a7), SIMD_LL_SETR_EPI16(a8, a9, aa, ab), SIMD_LL_SETR_EPI16(ac, ad, ae, af) \
158 }

◆ SIMD_MM256_SETR_EPI32

#define SIMD_MM256_SETR_EPI32 (   a0,
  a1,
  a2,
  a3,
  a4,
  a5,
  a6,
  a7 
)
值:
{ \
SIMD_LL_SET2_EPI32(a0, a1) \
, SIMD_LL_SET2_EPI32(a2, a3), SIMD_LL_SET2_EPI32(a4, a5), SIMD_LL_SET2_EPI32(a6, a7) \
}

在文件 util.h 第 172 行定义.

173 { \
174 SIMD_LL_SET2_EPI32(a0, a1) \
175 , SIMD_LL_SET2_EPI32(a2, a3), SIMD_LL_SET2_EPI32(a4, a5), SIMD_LL_SET2_EPI32(a6, a7) \
176 }

◆ SIMD_MM256_SETR_EPI8

#define SIMD_MM256_SETR_EPI8 (   a0,
  a1,
  a2,
  a3,
  a4,
  a5,
  a6,
  a7,
  a8,
  a9,
  aa,
  ab,
  ac,
  ad,
  ae,
  af,
  b0,
  b1,
  b2,
  b3,
  b4,
  b5,
  b6,
  b7,
  b8,
  b9,
  ba,
  bb,
  bc,
  bd,
  be,
  bf 
)
值:
{ \
SIMD_LL_SETR_EPI8(a0, a1, a2, a3, a4, a5, a6, a7) \
, SIMD_LL_SETR_EPI8(a8, a9, aa, ab, ac, ad, ae, af), SIMD_LL_SETR_EPI8(b0, b1, b2, b3, b4, b5, b6, b7), \
SIMD_LL_SETR_EPI8(b8, b9, ba, bb, bc, bd, be, bf) \
}
SIMD_LL_SETR_EPI8
#define SIMD_LL_SETR_EPI8(a, b, c, d, e, f, g, h)
Definition util.h:70

在文件 util.h 第 103 行定义.

136 { \
137 SIMD_LL_SETR_EPI8(a0, a1, a2, a3, a4, a5, a6, a7) \
138 , SIMD_LL_SETR_EPI8(a8, a9, aa, ab, ac, ad, ae, af), SIMD_LL_SETR_EPI8(b0, b1, b2, b3, b4, b5, b6, b7), \
139 SIMD_LL_SETR_EPI8(b8, b9, ba, bb, bc, bd, be, bf) \
140 }

◆ SIMD_SHORT_AS_LONGLONG

#define SIMD_SHORT_AS_LONGLONG (   a)    (((int64_t)a) & 0xFFFF)

在文件 util.h 第 56 行定义.