Apollo 10.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
 
const int apollo::drivers::camera::U_TO_BLUE_WEIGHT
 
const int apollo::drivers::camera::U_TO_GREEN_WEIGHT
 
const int apollo::drivers::camera::V_TO_GREEN_WEIGHT
 
const int apollo::drivers::camera::V_TO_RED_WEIGHT
 
const __m256i apollo::drivers::camera::K16_YRGB_RT
 
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
 
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 第 78 行定义.

96 { \
97 SIMD_LL_SET1_EPI8(a) \
98 , SIMD_LL_SET1_EPI8(a), SIMD_LL_SET1_EPI8(a), SIMD_LL_SET1_EPI8(a) \
99 }
100
101#define SIMD_MM256_SET2_EPI8(a0, a1) \
102 { \
103 SIMD_LL_SET2_EPI8(a0, a1) \
104 , SIMD_LL_SET2_EPI8(a0, a1), SIMD_LL_SET2_EPI8(a0, a1), \
105 SIMD_LL_SET2_EPI8(a0, a1) \
106 }
107
108#define SIMD_MM256_SETR_EPI8(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, \
109 ac, ad, ae, af, b0, b1, b2, b3, b4, b5, b6, b7, \
110 b8, b9, ba, bb, bc, bd, be, bf) \
111 { \
112 SIMD_LL_SETR_EPI8(a0, a1, a2, a3, a4, a5, a6, a7) \
113 , SIMD_LL_SETR_EPI8(a8, a9, aa, ab, ac, ad, ae, af), \
114 SIMD_LL_SETR_EPI8(b0, b1, b2, b3, b4, b5, b6, b7), \
115 SIMD_LL_SETR_EPI8(b8, b9, ba, bb, bc, bd, be, bf) \
116 }
117
118#define SIMD_MM256_SET1_EPI16(a) \
119 { \
120 SIMD_LL_SET1_EPI16(a) \
121 , SIMD_LL_SET1_EPI16(a), SIMD_LL_SET1_EPI16(a), SIMD_LL_SET1_EPI16(a) \
122 }
123
124#define SIMD_MM256_SET2_EPI16(a0, a1) \
125 { \
126 SIMD_LL_SET2_EPI16(a0, a1) \
127 , SIMD_LL_SET2_EPI16(a0, a1), SIMD_LL_SET2_EPI16(a0, a1), \
128 SIMD_LL_SET2_EPI16(a0, a1) \
129 }
130
131#define SIMD_MM256_SETR_EPI16(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, \
132 ac, ad, ae, af) \
133 { \
134 SIMD_LL_SETR_EPI16(a0, a1, a2, a3) \
135 , SIMD_LL_SETR_EPI16(a4, a5, a6, a7), SIMD_LL_SETR_EPI16(a8, a9, aa, ab), \
136 SIMD_LL_SETR_EPI16(ac, ad, ae, af) \
137 }
138
139#define SIMD_MM256_SET1_EPI32(a) \
140 { \
141 SIMD_LL_SET1_EPI32(a) \
142 , SIMD_LL_SET1_EPI32(a), SIMD_LL_SET1_EPI32(a), SIMD_LL_SET1_EPI32(a) \
143 }
144
145#define SIMD_MM256_SET2_EPI32(a0, a1) \
146 { \
147 SIMD_LL_SET2_EPI32(a0, a1) \
148 , SIMD_LL_SET2_EPI32(a0, a1), SIMD_LL_SET2_EPI32(a0, a1), \
149 SIMD_LL_SET2_EPI32(a0, a1) \
150 }
151
152#define SIMD_MM256_SETR_EPI32(a0, a1, a2, a3, a4, a5, a6, a7) \
153 { \
154 SIMD_LL_SET2_EPI32(a0, a1) \
155 , SIMD_LL_SET2_EPI32(a2, a3), SIMD_LL_SET2_EPI32(a4, a5), \
156 SIMD_LL_SET2_EPI32(a6, a7) \
157 }
158
159const size_t A = sizeof(__m256i);
160const size_t DA = 2 * A;
161const size_t QA = 4 * A;
162const size_t OA = 8 * A;
163const size_t HA = A / 2;
164
165const __m256i K_ZERO = SIMD_MM256_SET1_EPI8(0);
166const __m256i K_INV_ZERO = SIMD_MM256_SET1_EPI8(0xFF);
167
168const __m256i K8_01 = SIMD_MM256_SET1_EPI8(0x01);
169const __m256i K8_02 = SIMD_MM256_SET1_EPI8(0x02);
170const __m256i K8_04 = SIMD_MM256_SET1_EPI8(0x04);
171const __m256i K8_08 = SIMD_MM256_SET1_EPI8(0x08);
172const __m256i K8_10 = SIMD_MM256_SET1_EPI8(0x10);
173const __m256i K8_20 = SIMD_MM256_SET1_EPI8(0x20);
174const __m256i K8_40 = SIMD_MM256_SET1_EPI8(0x40);
175const __m256i K8_80 = SIMD_MM256_SET1_EPI8(0x80);
176
177const __m256i K8_01_FF = SIMD_MM256_SET2_EPI8(0x01, 0xFF);
178
179const __m256i K16_0001 = SIMD_MM256_SET1_EPI16(0x0001);
180const __m256i K16_0002 = SIMD_MM256_SET1_EPI16(0x0002);
181const __m256i K16_0003 = SIMD_MM256_SET1_EPI16(0x0003);
182const __m256i K16_0004 = SIMD_MM256_SET1_EPI16(0x0004);
183const __m256i K16_0005 = SIMD_MM256_SET1_EPI16(0x0005);
184const __m256i K16_0006 = SIMD_MM256_SET1_EPI16(0x0006);
185const __m256i K16_0008 = SIMD_MM256_SET1_EPI16(0x0008);
186const __m256i K16_0010 = SIMD_MM256_SET1_EPI16(0x0010);
187const __m256i K16_0018 = SIMD_MM256_SET1_EPI16(0x0018);
188const __m256i K16_0020 = SIMD_MM256_SET1_EPI16(0x0020);
189const __m256i K16_0080 = SIMD_MM256_SET1_EPI16(0x0080);
190const __m256i K16_00FF = SIMD_MM256_SET1_EPI16(0x00FF);
191const __m256i K16_FF00 = SIMD_MM256_SET1_EPI16(0xFF00);
192
193const __m256i K32_00000001 = SIMD_MM256_SET1_EPI32(0x00000001);
194const __m256i K32_00000002 = SIMD_MM256_SET1_EPI32(0x00000002);
195const __m256i K32_00000004 = SIMD_MM256_SET1_EPI32(0x00000004);
196const __m256i K32_00000008 = SIMD_MM256_SET1_EPI32(0x00000008);
197const __m256i K32_000000FF = SIMD_MM256_SET1_EPI32(0x000000FF);
198const __m256i K32_0000FFFF = SIMD_MM256_SET1_EPI32(0x0000FFFF);
199const __m256i K32_00010000 = SIMD_MM256_SET1_EPI32(0x00010000);
200const __m256i K32_01000000 = SIMD_MM256_SET1_EPI32(0x01000000);
201const __m256i K32_FFFFFF00 = SIMD_MM256_SET1_EPI32(0xFFFFFF00);
202
203const __m256i K8_SHUFFLE_BGR0_TO_BLUE = SIMD_MM256_SETR_EPI8(
204 0x0, 0x3, 0x6, 0x9, 0xC, 0xF, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
205 -1, -1, -1, -1, -1, 0x2, 0x5, 0x8, 0xB, 0xE, -1, -1, -1, -1, -1);
206const __m256i K8_SHUFFLE_BGR1_TO_BLUE = SIMD_MM256_SETR_EPI8(
207 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x1, 0x4, 0x7, 0xA, 0xD, 0x0,
208 0x3, 0x6, 0x9, 0xC, 0xF, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
209const __m256i K8_SHUFFLE_BGR2_TO_BLUE = SIMD_MM256_SETR_EPI8(
210 -1, -1, -1, -1, -1, -1, 0x2, 0x5, 0x8, 0xB, 0xE, -1, -1, -1, -1, -1, -1, -1,
211 -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x1, 0x4, 0x7, 0xA, 0xD);
212
213const __m256i Y_SHUFFLE0 = SIMD_MM256_SETR_EPI8(
214 0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, -1, -1, -1, -1, -1, -1, -1, -1, 0x0,
215 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, -1, -1, -1, -1, -1, -1, -1, -1);
216const __m256i Y_SHUFFLE1 = SIMD_MM256_SETR_EPI8(
217 -1, -1, -1, -1, -1, -1, -1, -1, 0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, -1,
218 -1, -1, -1, -1, -1, -1, -1, 0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe);
219
220const __m256i U_SHUFFLE0 = SIMD_MM256_SETR_EPI8(
221 0x1, 0x5, 0x9, 0xd, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x1,
222 0x5, 0x9, 0xd, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
223const __m256i U_SHUFFLE1 = SIMD_MM256_SETR_EPI8(
224 -1, -1, -1, -1, 0x1, 0x5, 0x9, 0xd, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
225 -1, -1, 0x1, 0x5, 0x9, 0xd, -1, -1, -1, -1, -1, -1, -1, -1);
226const __m256i U_SHUFFLE2 = SIMD_MM256_SETR_EPI8(
227 -1, -1, -1, -1, -1, -1, -1, -1, 0x1, 0x5, 0x9, 0xd, -1, -1, -1, -1, -1, -1,
228 -1, -1, -1, -1, -1, -1, 0x1, 0x5, 0x9, 0xd, -1, -1, -1, -1);
229
230const __m256i U_SHUFFLE3 = SIMD_MM256_SETR_EPI8(
231 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x1, 0x5, 0x9, 0xd, -1, -1,
232 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x1, 0x5, 0x9, 0xd);
233const __m256i U_SHUFFLE4 =
234 SIMD_MM256_SETR_EPI8(0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0,
235 0x0, 0x5, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x6, 0x0,
236 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0);
237
238const __m256i V_SHUFFLE0 = SIMD_MM256_SETR_EPI8(
239 0x3, 0x7, 0xb, 0xf, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x3,
240 0x7, 0xb, 0xf, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
241const __m256i V_SHUFFLE1 = SIMD_MM256_SETR_EPI8(
242 -1, -1, -1, -1, 0x3, 0x7, 0xb, 0xf, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
243 -1, -1, 0x3, 0x7, 0xb, 0xf, -1, -1, -1, -1, -1, -1, -1, -1);
244const __m256i V_SHUFFLE2 = SIMD_MM256_SETR_EPI8(
245 -1, -1, -1, -1, -1, -1, -1, -1, 0x3, 0x7, 0xb, 0xf, -1, -1, -1, -1, -1, -1,
246 -1, -1, -1, -1, -1, -1, 0x3, 0x7, 0xb, 0xf, -1, -1, -1, -1);
247
248const __m256i V_SHUFFLE3 = SIMD_MM256_SETR_EPI8(
249 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x3, 0x7, 0xb, 0xf, -1, -1,
250 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x3, 0x7, 0xb, 0xf);
251
252const __m256i K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0 = SIMD_MM256_SETR_EPI8(
253 0x0, -1, -1, 0x1, -1, -1, 0x2, -1, -1, 0x3, -1, -1, 0x4, -1, -1, 0x5, -1,
254 -1, 0x6, -1, -1, 0x7, -1, -1, 0x8, -1, -1, 0x9, -1, -1, 0xA, -1);
255const __m256i K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1 = SIMD_MM256_SETR_EPI8(
256 -1, 0x3, -1, -1, 0x4, -1, -1, 0x5, -1, -1, 0x6, -1, -1, 0x7, -1, -1, 0x8,
257 -1, -1, 0x9, -1, -1, 0xA, -1, -1, 0xB, -1, -1, 0xC, -1, -1, 0xD);
258const __m256i K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2 = SIMD_MM256_SETR_EPI8(
259 -1, -1, 0x6, -1, -1, 0x7, -1, -1, 0x8, -1, -1, 0x9, -1, -1, 0xA, -1, -1,
260 0xB, -1, -1, 0xC, -1, -1, 0xD, -1, -1, 0xE, -1, -1, 0xF, -1, -1);
261
262const __m256i K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0 = SIMD_MM256_SETR_EPI8(
263 -1, 0x0, -1, -1, 0x1, -1, -1, 0x2, -1, -1, 0x3, -1, -1, 0x4, -1, -1, 0x5,
264 -1, -1, 0x6, -1, -1, 0x7, -1, -1, 0x8, -1, -1, 0x9, -1, -1, 0xA);
265const __m256i K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1 = SIMD_MM256_SETR_EPI8(
266 -1, -1, 0x3, -1, -1, 0x4, -1, -1, 0x5, -1, -1, 0x6, -1, -1, 0x7, -1, -1,
267 0x8, -1, -1, 0x9, -1, -1, 0xA, -1, -1, 0xB, -1, -1, 0xC, -1, -1);
268const __m256i K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2 = SIMD_MM256_SETR_EPI8(
269 0x5, -1, -1, 0x6, -1, -1, 0x7, -1, -1, 0x8, -1, -1, 0x9, -1, -1, 0xA, -1,
270 -1, 0xB, -1, -1, 0xC, -1, -1, 0xD, -1, -1, 0xE, -1, -1, 0xF, -1);
271
272const __m256i K8_SHUFFLE_PERMUTED_RED_TO_BGR0 = SIMD_MM256_SETR_EPI8(
273 -1, -1, 0x0, -1, -1, 0x1, -1, -1, 0x2, -1, -1, 0x3, -1, -1, 0x4, -1, -1,
274 0x5, -1, -1, 0x6, -1, -1, 0x7, -1, -1, 0x8, -1, -1, 0x9, -1, -1);
275const __m256i K8_SHUFFLE_PERMUTED_RED_TO_BGR1 = SIMD_MM256_SETR_EPI8(
276 0x2, -1, -1, 0x3, -1, -1, 0x4, -1, -1, 0x5, -1, -1, 0x6, -1, -1, 0x7, -1,
277 -1, 0x8, -1, -1, 0x9, -1, -1, 0xA, -1, -1, 0xB, -1, -1, 0xC, -1);
278const __m256i K8_SHUFFLE_PERMUTED_RED_TO_BGR2 = SIMD_MM256_SETR_EPI8(
279 -1, 0x5, -1, -1, 0x6, -1, -1, 0x7, -1, -1, 0x8, -1, -1, 0x9, -1, -1, 0xA,
280 -1, -1, 0xB, -1, -1, 0xC, -1, -1, 0xD, -1, -1, 0xE, -1, -1, 0xF);
281
282const __m256i K8_SHUFFLE_BGR0_TO_GREEN = SIMD_MM256_SETR_EPI8(
283 0x1, 0x4, 0x7, 0xA, 0xD, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
284 -1, -1, -1, 0x0, 0x3, 0x6, 0x9, 0xC, 0xF, -1, -1, -1, -1, -1);
285const __m256i K8_SHUFFLE_BGR1_TO_GREEN = SIMD_MM256_SETR_EPI8(
286 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x2, 0x5, 0x8, 0xB, 0xE, 0x1,
287 0x4, 0x7, 0xA, 0xD, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
288const __m256i K8_SHUFFLE_BGR2_TO_GREEN = SIMD_MM256_SETR_EPI8(
289 -1, -1, -1, -1, -1, 0x0, 0x3, 0x6, 0x9, 0xC, 0xF, -1, -1, -1, -1, -1, -1,
290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x2, 0x5, 0x8, 0xB, 0xE);
291
292const __m256i K8_SHUFFLE_BGR0_TO_RED = SIMD_MM256_SETR_EPI8(
293 0x2, 0x5, 0x8, 0xB, 0xE, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
294 -1, -1, -1, 0x1, 0x4, 0x7, 0xA, 0xD, -1, -1, -1, -1, -1, -1);
295const __m256i K8_SHUFFLE_BGR1_TO_RED = SIMD_MM256_SETR_EPI8(
296 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x0, 0x3, 0x6, 0x9, 0xC, 0xF, 0x2,
297 0x5, 0x8, 0xB, 0xE, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
298const __m256i K8_SHUFFLE_BGR2_TO_RED = SIMD_MM256_SETR_EPI8(
299 -1, -1, -1, -1, -1, 0x1, 0x4, 0x7, 0xA, 0xD, -1, -1, -1, -1, -1, -1, -1, -1,
300 -1, -1, -1, -1, -1, -1, -1, -1, 0x0, 0x3, 0x6, 0x9, 0xC, 0xF);
301
302const __m256i K16_Y_ADJUST = SIMD_MM256_SET1_EPI16(0);
303const __m256i K16_UV_ADJUST = SIMD_MM256_SET1_EPI16(128);
304const int Y_ADJUST = 0;
305const int UV_ADJUST = 128;
306const int YUV_TO_BGR_AVERAGING_SHIFT = 13;
307const int YUV_TO_BGR_ROUND_TERM = 0; // 1 << (YUV_TO_BGR_AVERAGING_SHIFT);
308const int Y_TO_RGB_WEIGHT =
309 static_cast<int>((((1 << YUV_TO_BGR_AVERAGING_SHIFT))));
310const int U_TO_BLUE_WEIGHT =
311 static_cast<int>((2.041 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)));
312const int U_TO_GREEN_WEIGHT =
313 -static_cast<int>((0.3455 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)));
314const int V_TO_GREEN_WEIGHT =
315 -static_cast<int>((0.7169 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)));
316const int V_TO_RED_WEIGHT =
317 static_cast<int>((1.4065 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)));
318
319const __m256i K16_YRGB_RT =
320 SIMD_MM256_SET2_EPI16(Y_TO_RGB_WEIGHT, YUV_TO_BGR_ROUND_TERM);
321const __m256i K16_VR_0 = SIMD_MM256_SET2_EPI16(V_TO_RED_WEIGHT, 0);
322const __m256i K16_UG_VG =
323 SIMD_MM256_SET2_EPI16(U_TO_GREEN_WEIGHT, V_TO_GREEN_WEIGHT);
324const __m256i K16_UB_0 = SIMD_MM256_SET2_EPI16(U_TO_BLUE_WEIGHT, 0);
325
326template <bool align>
327SIMD_INLINE __m256i Load(const __m256i *p);
328
329template <>
330SIMD_INLINE __m256i Load<false>(const __m256i *p) {
331 return _mm256_loadu_si256(p);
332}
333
334template <>
335SIMD_INLINE __m256i Load<true>(const __m256i *p) {
336 return _mm256_load_si256(p);
337}
338
339SIMD_INLINE void *AlignLo(const void *ptr, size_t align) {
340 return reinterpret_cast<void *>(((size_t)ptr) & ~(align - 1));
341}
342
343SIMD_INLINE bool Aligned(const void *ptr, size_t align = sizeof(__m256)) {
344 return ptr == AlignLo(ptr, align);
345}
346
347template <bool align>
348SIMD_INLINE void Store(__m256i *p, __m256i a);
349
350template <>
351SIMD_INLINE void Store<false>(__m256i *p, __m256i a) {
352 _mm256_storeu_si256(p, a);
353}
354
355template <>
356SIMD_INLINE void Store<true>(__m256i *p, __m256i a) {
357 _mm256_store_si256(p, a);
358}
359
360SIMD_INLINE __m256i SaturateI16ToU8(__m256i value) {
361 return _mm256_min_epi16(K16_00FF, _mm256_max_epi16(value, K_ZERO));
362}
363
364SIMD_INLINE __m256i AdjustY16(__m256i y16) {
365 return _mm256_subs_epi16(y16, K16_Y_ADJUST);
366}
367
368SIMD_INLINE __m256i AdjustUV16(__m256i uv16) {
369 return _mm256_subs_epi16(uv16, K16_UV_ADJUST);
370}
371
372SIMD_INLINE __m256i AdjustedYuvToRed32(__m256i y16_1, __m256i v16_0) {
373 // print_m256_i16(y16_1);
374 // print_m256_i16(v16_0);
375 // print_m256_i32(_mm256_madd_epi16(y16_1, K16_YRGB_RT));
376 // print_m256_i32(_mm256_madd_epi16(v16_0, K16_VR_0));
377 return _mm256_srai_epi32(
378 _mm256_add_epi32(_mm256_madd_epi16(y16_1, K16_YRGB_RT),
379 _mm256_madd_epi16(v16_0, K16_VR_0)),
380 YUV_TO_BGR_AVERAGING_SHIFT);
381}
382
383SIMD_INLINE __m256i AdjustedYuvToRed16(__m256i y16, __m256i v16) {
384 // print_m256_i32(AdjustedYuvToRed32(_mm256_unpacklo_epi16(y16, K16_0001),
385 // _mm256_unpacklo_epi16(v16, K_ZERO)));
386 // print_m256_i16(_mm256_unpacklo_epi16(y16, K16_0001));
387 return SaturateI16ToU8(_mm256_packs_epi32(
388 AdjustedYuvToRed32(_mm256_unpacklo_epi16(y16, K16_0001),
389 _mm256_unpacklo_epi16(v16, K_ZERO)),
390 AdjustedYuvToRed32(_mm256_unpackhi_epi16(y16, K16_0001),
391 _mm256_unpackhi_epi16(v16, K_ZERO))));
392}
393
394SIMD_INLINE __m256i AdjustedYuvToGreen32(__m256i y16_1, __m256i u16_v16) {
395 return _mm256_srai_epi32(
396 _mm256_add_epi32(_mm256_madd_epi16(y16_1, K16_YRGB_RT),
397 _mm256_madd_epi16(u16_v16, K16_UG_VG)),
398 YUV_TO_BGR_AVERAGING_SHIFT);
399}
400
401SIMD_INLINE __m256i AdjustedYuvToGreen16(__m256i y16, __m256i u16,
402 __m256i v16) {
403 return SaturateI16ToU8(_mm256_packs_epi32(
404 AdjustedYuvToGreen32(_mm256_unpacklo_epi16(y16, K16_0001),
405 _mm256_unpacklo_epi16(u16, v16)),
406 AdjustedYuvToGreen32(_mm256_unpackhi_epi16(y16, K16_0001),
407 _mm256_unpackhi_epi16(u16, v16))));
408}
409
410SIMD_INLINE __m256i AdjustedYuvToBlue32(__m256i y16_1, __m256i u16_0) {
411 return _mm256_srai_epi32(
412 _mm256_add_epi32(_mm256_madd_epi16(y16_1, K16_YRGB_RT),
413 _mm256_madd_epi16(u16_0, K16_UB_0)),
414 YUV_TO_BGR_AVERAGING_SHIFT);
415}
416
417SIMD_INLINE __m256i AdjustedYuvToBlue16(__m256i y16, __m256i u16) {
418 return SaturateI16ToU8(_mm256_packs_epi32(
419 AdjustedYuvToBlue32(_mm256_unpacklo_epi16(y16, K16_0001),
420 _mm256_unpacklo_epi16(u16, K_ZERO)),
421 AdjustedYuvToBlue32(_mm256_unpackhi_epi16(y16, K16_0001),
422 _mm256_unpackhi_epi16(u16, K_ZERO))));
423}
424
425SIMD_INLINE __m256i YuvToRed(__m256i y, __m256i v) {
426 __m256i lo = AdjustedYuvToRed16(_mm256_unpacklo_epi8(y, K_ZERO),
427 AdjustUV16(_mm256_unpacklo_epi8(v, K_ZERO)));
428 __m256i hi = AdjustedYuvToRed16((_mm256_unpackhi_epi8(y, K_ZERO)),
429 AdjustUV16(_mm256_unpackhi_epi8(v, K_ZERO)));
430
431 // print_m256_i16(lo);
432 // print_m256_i16(hi);
433 return _mm256_packus_epi16(lo, hi);
434}
435
436SIMD_INLINE __m256i YuvToGreen(__m256i y, __m256i u, __m256i v) {
437 __m256i lo =
438 AdjustedYuvToGreen16((_mm256_unpacklo_epi8(y, K_ZERO)),
439 AdjustUV16(_mm256_unpacklo_epi8(u, K_ZERO)),
440 AdjustUV16(_mm256_unpacklo_epi8(v, K_ZERO)));
441 __m256i hi =
442 AdjustedYuvToGreen16((_mm256_unpackhi_epi8(y, K_ZERO)),
443 AdjustUV16(_mm256_unpackhi_epi8(u, K_ZERO)),
444 AdjustUV16(_mm256_unpackhi_epi8(v, K_ZERO)));
445 return _mm256_packus_epi16(lo, hi);
446}
447
448SIMD_INLINE __m256i YuvToBlue(__m256i y, __m256i u) {
449 __m256i lo = AdjustedYuvToBlue16((_mm256_unpacklo_epi8(y, K_ZERO)),
450 AdjustUV16(_mm256_unpacklo_epi8(u, K_ZERO)));
451 __m256i hi = AdjustedYuvToBlue16((_mm256_unpackhi_epi8(y, K_ZERO)),
452 AdjustUV16(_mm256_unpackhi_epi8(u, K_ZERO)));
453 return _mm256_packus_epi16(lo, hi);
454}
455
456template <int index>
457__m256i InterleaveBgr(__m256i blue, __m256i green, __m256i red);
458
459template <>
460SIMD_INLINE __m256i InterleaveBgr<0>(__m256i blue, __m256i green, __m256i red) {
461 return _mm256_or_si256(
462 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(blue, 0x44),
463 K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0),
464 _mm256_or_si256(_mm256_shuffle_epi8(_mm256_permute4x64_epi64(green, 0x44),
465 K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0),
466 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(red, 0x44),
467 K8_SHUFFLE_PERMUTED_RED_TO_BGR0)));
468}
469
470template <>
471SIMD_INLINE __m256i InterleaveBgr<1>(__m256i blue, __m256i green, __m256i red) {
472 return _mm256_or_si256(
473 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(blue, 0x99),
474 K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1),
475 _mm256_or_si256(_mm256_shuffle_epi8(_mm256_permute4x64_epi64(green, 0x99),
476 K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1),
477 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(red, 0x99),
478 K8_SHUFFLE_PERMUTED_RED_TO_BGR1)));
479}
480
481template <>
482SIMD_INLINE __m256i InterleaveBgr<2>(__m256i blue, __m256i green, __m256i red) {
483 return _mm256_or_si256(
484 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(blue, 0xEE),
485 K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2),
486 _mm256_or_si256(_mm256_shuffle_epi8(_mm256_permute4x64_epi64(green, 0xEE),
487 K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2),
488 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(red, 0xEE),
489 K8_SHUFFLE_PERMUTED_RED_TO_BGR2)));
490}
491
492SIMD_INLINE __m256i BgrToBlue(__m256i bgr[3]) {
493 __m256i b0 = _mm256_shuffle_epi8(bgr[0], K8_SHUFFLE_BGR0_TO_BLUE);
494 __m256i b2 = _mm256_shuffle_epi8(bgr[2], K8_SHUFFLE_BGR2_TO_BLUE);
495 return _mm256_or_si256(
496 _mm256_permute2x128_si256(b0, b2, 0x20),
497 _mm256_or_si256(_mm256_shuffle_epi8(bgr[1], K8_SHUFFLE_BGR1_TO_BLUE),
498 _mm256_permute2x128_si256(b0, b2, 0x31)));
499}
500
501SIMD_INLINE __m256i BgrToGreen(__m256i bgr[3]) {
502 __m256i g0 = _mm256_shuffle_epi8(bgr[0], K8_SHUFFLE_BGR0_TO_GREEN);
503 __m256i g2 = _mm256_shuffle_epi8(bgr[2], K8_SHUFFLE_BGR2_TO_GREEN);
504 return _mm256_or_si256(
505 _mm256_permute2x128_si256(g0, g2, 0x20),
506 _mm256_or_si256(_mm256_shuffle_epi8(bgr[1], K8_SHUFFLE_BGR1_TO_GREEN),
507 _mm256_permute2x128_si256(g0, g2, 0x31)));
508}
509
510SIMD_INLINE __m256i BgrToRed(__m256i bgr[3]) {
511 __m256i r0 = _mm256_shuffle_epi8(bgr[0], K8_SHUFFLE_BGR0_TO_RED);
512 __m256i r2 = _mm256_shuffle_epi8(bgr[2], K8_SHUFFLE_BGR2_TO_RED);
513 return _mm256_or_si256(
514 _mm256_permute2x128_si256(r0, r2, 0x20),
515 _mm256_or_si256(_mm256_shuffle_epi8(bgr[1], K8_SHUFFLE_BGR1_TO_RED),
516 _mm256_permute2x128_si256(r0, r2, 0x31)));
517}
518
519template <bool align>
520SIMD_INLINE __m256i LoadPermuted(const __m256i *p) {
521 return _mm256_permute4x64_epi64(Load<align>(p), 0xD8);
522}
523
524} // namespace camera
525} // namespace drivers
526} // namespace apollo
SIMD_MM256_SET1_EPI16
#define SIMD_MM256_SET1_EPI16(a)
Definition util.h:119
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:102
SIMD_MM256_SET1_EPI32
#define SIMD_MM256_SET1_EPI32(a)
Definition util.h:140
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:109
SIMD_MM256_SET1_EPI8
#define SIMD_MM256_SET1_EPI8(a)
Definition util.h:96
SIMD_MM256_SET2_EPI16
#define SIMD_MM256_SET2_EPI16(a0, a1)
Definition util.h:125
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:313
apollo::drivers::camera::A
const size_t A
Definition util.h:160
apollo::drivers::camera::K16_FF00
const __m256i K16_FF00
Definition util.h:192
apollo::drivers::camera::BgrToGreen
SIMD_INLINE __m256i BgrToGreen(__m256i bgr[3])
Definition util.h:502
apollo::drivers::camera::K32_00000004
const __m256i K32_00000004
Definition util.h:196
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR2
const __m256i K8_SHUFFLE_PERMUTED_RED_TO_BGR2
Definition util.h:279
apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_BLUE
const __m256i K8_SHUFFLE_BGR1_TO_BLUE
Definition util.h:207
apollo::drivers::camera::K16_0010
const __m256i K16_0010
Definition util.h:187
apollo::drivers::camera::K8_10
const __m256i K8_10
Definition util.h:173
apollo::drivers::camera::K16_0004
const __m256i K16_0004
Definition util.h:183
apollo::drivers::camera::K16_0005
const __m256i K16_0005
Definition util.h:184
apollo::drivers::camera::K16_YRGB_RT
const __m256i K16_YRGB_RT
Definition util.h:320
apollo::drivers::camera::OA
const size_t OA
Definition util.h:163
apollo::drivers::camera::K8_04
const __m256i K8_04
Definition util.h:171
apollo::drivers::camera::QA
const size_t QA
Definition util.h:162
apollo::drivers::camera::K16_0001
const __m256i K16_0001
Definition util.h:180
apollo::drivers::camera::Y_TO_RGB_WEIGHT
const int Y_TO_RGB_WEIGHT
Definition util.h:309
apollo::drivers::camera::K16_UG_VG
const __m256i K16_UG_VG
Definition util.h:323
apollo::drivers::camera::Y_SHUFFLE0
const __m256i Y_SHUFFLE0
Definition util.h:214
apollo::drivers::camera::V_SHUFFLE3
const __m256i V_SHUFFLE3
Definition util.h:249
apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_RED
const __m256i K8_SHUFFLE_BGR1_TO_RED
Definition util.h:296
apollo::drivers::camera::YuvToRed
SIMD_INLINE __m256i YuvToRed(__m256i y, __m256i v)
Definition util.h:426
apollo::drivers::camera::K8_01
const __m256i K8_01
Definition util.h:169
apollo::drivers::camera::U_SHUFFLE1
const __m256i U_SHUFFLE1
Definition util.h:224
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0
const __m256i K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0
Definition util.h:253
apollo::drivers::camera::K8_80
const __m256i K8_80
Definition util.h:176
apollo::drivers::camera::K16_0008
const __m256i K16_0008
Definition util.h:186
apollo::drivers::camera::SaturateI16ToU8
SIMD_INLINE __m256i SaturateI16ToU8(__m256i value)
Definition util.h:361
apollo::drivers::camera::K32_00010000
const __m256i K32_00010000
Definition util.h:200
apollo::drivers::camera::K16_00FF
const __m256i K16_00FF
Definition util.h:191
apollo::drivers::camera::YUV_TO_BGR_AVERAGING_SHIFT
const int YUV_TO_BGR_AVERAGING_SHIFT
Definition util.h:307
apollo::drivers::camera::K16_VR_0
const __m256i K16_VR_0
Definition util.h:322
apollo::drivers::camera::AdjustY16
SIMD_INLINE __m256i AdjustY16(__m256i y16)
Definition util.h:365
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1
const __m256i K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1
Definition util.h:256
apollo::drivers::camera::BgrToRed
SIMD_INLINE __m256i BgrToRed(__m256i bgr[3])
Definition util.h:511
apollo::drivers::camera::YuvToBlue
SIMD_INLINE __m256i YuvToBlue(__m256i y, __m256i u)
Definition util.h:449
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2
const __m256i K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2
Definition util.h:269
apollo::drivers::camera::AdjustUV16
SIMD_INLINE __m256i AdjustUV16(__m256i uv16)
Definition util.h:369
apollo::drivers::camera::K16_UV_ADJUST
const __m256i K16_UV_ADJUST
Definition util.h:304
apollo::drivers::camera::DA
const size_t DA
Definition util.h:161
apollo::drivers::camera::V_SHUFFLE1
const __m256i V_SHUFFLE1
Definition util.h:242
apollo::drivers::camera::AdjustedYuvToBlue16
SIMD_INLINE __m256i AdjustedYuvToBlue16(__m256i y16, __m256i u16)
Definition util.h:418
apollo::drivers::camera::K32_00000008
const __m256i K32_00000008
Definition util.h:197
apollo::drivers::camera::UV_ADJUST
const int UV_ADJUST
Definition util.h:306
apollo::drivers::camera::U_SHUFFLE2
const __m256i U_SHUFFLE2
Definition util.h:227
apollo::drivers::camera::V_SHUFFLE2
const __m256i V_SHUFFLE2
Definition util.h:245
apollo::drivers::camera::K16_0080
const __m256i K16_0080
Definition util.h:190
apollo::drivers::camera::V_TO_RED_WEIGHT
const int V_TO_RED_WEIGHT
Definition util.h:317
apollo::drivers::camera::K8_02
const __m256i K8_02
Definition util.h:170
apollo::drivers::camera::K8_40
const __m256i K8_40
Definition util.h:175
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2
const __m256i K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2
Definition util.h:259
apollo::drivers::camera::AdjustedYuvToRed16
SIMD_INLINE __m256i AdjustedYuvToRed16(__m256i y16, __m256i v16)
Definition util.h:384
apollo::drivers::camera::K32_00000002
const __m256i K32_00000002
Definition util.h:195
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:411
apollo::drivers::camera::K16_0018
const __m256i K16_0018
Definition util.h:188
apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_RED
const __m256i K8_SHUFFLE_BGR0_TO_RED
Definition util.h:293
apollo::drivers::camera::V_TO_GREEN_WEIGHT
const int V_TO_GREEN_WEIGHT
Definition util.h:315
apollo::drivers::camera::AdjustedYuvToGreen32
SIMD_INLINE __m256i AdjustedYuvToGreen32(__m256i y16_1, __m256i u16_v16)
Definition util.h:395
apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_RED
const __m256i K8_SHUFFLE_BGR2_TO_RED
Definition util.h:299
apollo::drivers::camera::Y_SHUFFLE1
const __m256i Y_SHUFFLE1
Definition util.h:217
apollo::drivers::camera::K16_Y_ADJUST
const __m256i K16_Y_ADJUST
Definition util.h:303
apollo::drivers::camera::AdjustedYuvToGreen16
SIMD_INLINE __m256i AdjustedYuvToGreen16(__m256i y16, __m256i u16, __m256i v16)
Definition util.h:402
apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_BLUE
const __m256i K8_SHUFFLE_BGR0_TO_BLUE
Definition util.h:204
apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_GREEN
const __m256i K8_SHUFFLE_BGR2_TO_GREEN
Definition util.h:289
apollo::drivers::camera::AlignLo
SIMD_INLINE void * AlignLo(const void *ptr, size_t align)
Definition util.h:340
apollo::drivers::camera::BgrToBlue
SIMD_INLINE __m256i BgrToBlue(__m256i bgr[3])
Definition util.h:493
apollo::drivers::camera::HA
const size_t HA
Definition util.h:164
apollo::drivers::camera::K16_0006
const __m256i K16_0006
Definition util.h:185
apollo::drivers::camera::V_SHUFFLE0
const __m256i V_SHUFFLE0
Definition util.h:239
apollo::drivers::camera::YUV_TO_BGR_ROUND_TERM
const int YUV_TO_BGR_ROUND_TERM
Definition util.h:308
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR1
const __m256i K8_SHUFFLE_PERMUTED_RED_TO_BGR1
Definition util.h:276
apollo::drivers::camera::AdjustedYuvToRed32
SIMD_INLINE __m256i AdjustedYuvToRed32(__m256i y16_1, __m256i v16_0)
Definition util.h:373
apollo::drivers::camera::U_TO_BLUE_WEIGHT
const int U_TO_BLUE_WEIGHT
Definition util.h:311
apollo::drivers::camera::Y_ADJUST
const int Y_ADJUST
Definition util.h:305
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR0
const __m256i K8_SHUFFLE_PERMUTED_RED_TO_BGR0
Definition util.h:273
apollo::drivers::camera::U_SHUFFLE4
const __m256i U_SHUFFLE4
Definition util.h:234
apollo::drivers::camera::K_INV_ZERO
const __m256i K_INV_ZERO
Definition util.h:167
apollo::drivers::camera::InterleaveBgr
__m256i InterleaveBgr(__m256i blue, __m256i green, __m256i red)
apollo::drivers::camera::K32_01000000
const __m256i K32_01000000
Definition util.h:201
apollo::drivers::camera::YuvToGreen
SIMD_INLINE __m256i YuvToGreen(__m256i y, __m256i u, __m256i v)
Definition util.h:437
apollo::drivers::camera::K8_01_FF
const __m256i K8_01_FF
Definition util.h:178
apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_GREEN
const __m256i K8_SHUFFLE_BGR1_TO_GREEN
Definition util.h:286
apollo::drivers::camera::K16_0003
const __m256i K16_0003
Definition util.h:182
apollo::drivers::camera::K_ZERO
const __m256i K_ZERO
Definition util.h:166
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1
const __m256i K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1
Definition util.h:266
apollo::drivers::camera::K32_00000001
const __m256i K32_00000001
Definition util.h:194
apollo::drivers::camera::U_SHUFFLE3
const __m256i U_SHUFFLE3
Definition util.h:231
apollo::drivers::camera::K32_0000FFFF
const __m256i K32_0000FFFF
Definition util.h:199
apollo::drivers::camera::K8_08
const __m256i K8_08
Definition util.h:172
apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0
const __m256i K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0
Definition util.h:263
apollo::drivers::camera::Load
SIMD_INLINE __m256i Load(const __m256i *p)
apollo::drivers::camera::K32_000000FF
const __m256i K32_000000FF
Definition util.h:198
apollo::drivers::camera::K8_20
const __m256i K8_20
Definition util.h:174
apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_GREEN
const __m256i K8_SHUFFLE_BGR0_TO_GREEN
Definition util.h:283
apollo::drivers::camera::LoadPermuted
SIMD_INLINE __m256i LoadPermuted(const __m256i *p)
Definition util.h:521
apollo::drivers::camera::K16_0020
const __m256i K16_0020
Definition util.h:189
apollo::drivers::camera::K32_FFFFFF00
const __m256i K32_FFFFFF00
Definition util.h:202
apollo::drivers::camera::K16_UB_0
const __m256i K16_UB_0
Definition util.h:325
apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_BLUE
const __m256i K8_SHUFFLE_BGR2_TO_BLUE
Definition util.h:210
apollo::drivers::camera::U_SHUFFLE0
const __m256i U_SHUFFLE0
Definition util.h:221
apollo::drivers::camera::Aligned
SIMD_INLINE bool Aligned(const void *ptr, size_t align=sizeof(__m256))
Definition util.h:344
apollo::drivers::camera::K16_0002
const __m256i K16_0002
Definition util.h:181

◆ SIMD_LL_SET1_EPI32

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

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

◆ 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 第 82 行定义.

◆ SIMD_LL_SET2_EPI32

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

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

◆ 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 第 66 行定义.

◆ 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 第 86 行定义.

◆ 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 第 72 行定义.

◆ 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:78

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

120 { \
121 SIMD_LL_SET1_EPI16(a) \
122 , SIMD_LL_SET1_EPI16(a), SIMD_LL_SET1_EPI16(a), SIMD_LL_SET1_EPI16(a) \
123 }

◆ 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:90

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

141 { \
142 SIMD_LL_SET1_EPI32(a) \
143 , SIMD_LL_SET1_EPI32(a), SIMD_LL_SET1_EPI32(a), SIMD_LL_SET1_EPI32(a) \
144 }

◆ 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 第 96 行定义.

97 { \
98 SIMD_LL_SET1_EPI8(a) \
99 , SIMD_LL_SET1_EPI8(a), SIMD_LL_SET1_EPI8(a), SIMD_LL_SET1_EPI8(a) \
100 }

◆ 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:82

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

126 { \
127 SIMD_LL_SET2_EPI16(a0, a1) \
128 , SIMD_LL_SET2_EPI16(a0, a1), SIMD_LL_SET2_EPI16(a0, a1), \
129 SIMD_LL_SET2_EPI16(a0, a1) \
130 }

◆ 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:93

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

147 { \
148 SIMD_LL_SET2_EPI32(a0, a1) \
149 , SIMD_LL_SET2_EPI32(a0, a1), SIMD_LL_SET2_EPI32(a0, a1), \
150 SIMD_LL_SET2_EPI32(a0, a1) \
151 }

◆ 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:66

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

103 { \
104 SIMD_LL_SET2_EPI8(a0, a1) \
105 , SIMD_LL_SET2_EPI8(a0, a1), SIMD_LL_SET2_EPI8(a0, a1), \
106 SIMD_LL_SET2_EPI8(a0, a1) \
107 }

◆ 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:86

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

134 { \
135 SIMD_LL_SETR_EPI16(a0, a1, a2, a3) \
136 , SIMD_LL_SETR_EPI16(a4, a5, a6, a7), SIMD_LL_SETR_EPI16(a8, a9, aa, ab), \
137 SIMD_LL_SETR_EPI16(ac, ad, ae, af) \
138 }

◆ 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 第 153 行定义.

154 { \
155 SIMD_LL_SET2_EPI32(a0, a1) \
156 , SIMD_LL_SET2_EPI32(a2, a3), SIMD_LL_SET2_EPI32(a4, a5), \
157 SIMD_LL_SET2_EPI32(a6, a7) \
158 }

◆ 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:72

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

112 { \
113 SIMD_LL_SETR_EPI8(a0, a1, a2, a3, a4, a5, a6, a7) \
114 , SIMD_LL_SETR_EPI8(a8, a9, aa, ab, ac, ad, ae, af), \
115 SIMD_LL_SETR_EPI8(b0, b1, b2, b3, b4, b5, b6, b7), \
116 SIMD_LL_SETR_EPI8(b8, b9, ba, bb, bc, bd, be, bf) \
117 }

◆ SIMD_SHORT_AS_LONGLONG

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

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