Apollo 11.0
自动驾驶开放平台
命名空间 | 类 | 类型定义 | 枚举 | 函数 | 变量
apollo::drivers::camera 命名空间参考

命名空间

namespace  config
 

类

struct  buffer
 
class  CameraComponent
 
struct  CameraImage
 
class  CompressComponent
 
class  CudaConvertHandler
 
class  UsbCam
 

类型定义

typedef std::shared_ptr< CameraImage > CameraImagePtr
 

枚举

enum  CameraDeviceState : std::uint8_t {
  STATE_SUCCESS = 0 , STATE_DROP , STATE_INTR , STATE_DEVICE_ERROR ,
  STATE_OTHER
}
 

函数

void cuda_convert_yuv_to_rgb (unsigned char *src, unsigned char *dst, unsigned int width, unsigned int height)
 floating conversion of YUV to RGB implemented with cuda
 
void print_m256 (__m256i a)
 
void print_m256_i32 (const __m256i a)
 
void print_m256_i16 (const __m256i a)
 
template<bool align>
SIMD_INLINE void yuv_separate_avx2 (uint8_t *y, __m256i *y0, __m256i *y1, __m256i *u0, __m256i *v0)
 
template<bool align>
void yuv2rgb_avx2 (__m256i y0, __m256i u0, __m256i v0, uint8_t *rgb)
 
template<bool align>
void yuv2rgb_avx2 (uint8_t *yuv, uint8_t *rgb)
 
void yuyv2rgb_avx (unsigned char *YUV, unsigned char *RGB, int NumPixels)
 
template<class T >
SIMD_INLINE char GetChar (T value, size_t index)
 
template<bool align>
SIMD_INLINE __m256i Load (const __m256i *p)
 
template<>
SIMD_INLINE __m256i Load< false > (const __m256i *p)
 
template<>
SIMD_INLINE __m256i Load< true > (const __m256i *p)
 
SIMD_INLINE void * AlignLo (const void *ptr, size_t align)
 
SIMD_INLINE bool Aligned (const void *ptr, size_t align=sizeof(__m256))
 
template<bool align>
SIMD_INLINE void Store (__m256i *p, __m256i a)
 
template<>
SIMD_INLINE void Store< false > (__m256i *p, __m256i a)
 
template<>
SIMD_INLINE void Store< true > (__m256i *p, __m256i a)
 
SIMD_INLINE __m256i SaturateI16ToU8 (__m256i value)
 
SIMD_INLINE __m256i AdjustY16 (__m256i y16)
 
SIMD_INLINE __m256i AdjustUV16 (__m256i uv16)
 
SIMD_INLINE __m256i AdjustedYuvToRed32 (__m256i y16_1, __m256i v16_0)
 
SIMD_INLINE __m256i AdjustedYuvToRed16 (__m256i y16, __m256i v16)
 
SIMD_INLINE __m256i AdjustedYuvToGreen32 (__m256i y16_1, __m256i u16_v16)
 
SIMD_INLINE __m256i AdjustedYuvToGreen16 (__m256i y16, __m256i u16, __m256i v16)
 
SIMD_INLINE __m256i AdjustedYuvToBlue32 (__m256i y16_1, __m256i u16_0)
 
SIMD_INLINE __m256i AdjustedYuvToBlue16 (__m256i y16, __m256i u16)
 
SIMD_INLINE __m256i YuvToRed (__m256i y, __m256i v)
 
SIMD_INLINE __m256i YuvToGreen (__m256i y, __m256i u, __m256i v)
 
SIMD_INLINE __m256i YuvToBlue (__m256i y, __m256i u)
 
template<int index>
__m256i InterleaveBgr (__m256i blue, __m256i green, __m256i red)
 
template<>
SIMD_INLINE __m256i InterleaveBgr< 0 > (__m256i blue, __m256i green, __m256i red)
 
template<>
SIMD_INLINE __m256i InterleaveBgr< 1 > (__m256i blue, __m256i green, __m256i red)
 
template<>
SIMD_INLINE __m256i InterleaveBgr< 2 > (__m256i blue, __m256i green, __m256i red)
 
SIMD_INLINE __m256i BgrToBlue (__m256i bgr[3])
 
SIMD_INLINE __m256i BgrToGreen (__m256i bgr[3])
 
SIMD_INLINE __m256i BgrToRed (__m256i bgr[3])
 
template<bool align>
SIMD_INLINE __m256i LoadPermuted (const __m256i *p)
 

变量

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

类型定义说明

◆ CameraImagePtr

typedef std::shared_ptr<CameraImage> apollo::drivers::camera::CameraImagePtr

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

枚举类型说明

◆ CameraDeviceState

enum apollo::drivers::camera::CameraDeviceState : std::uint8_t
枚举值
STATE_SUCCESS 
STATE_DROP 
STATE_INTR 
STATE_DEVICE_ERROR 
STATE_OTHER 

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

75 : std::uint8_t {
76 STATE_SUCCESS = 0,
77 STATE_DROP,
78 STATE_INTR,
79 STATE_DEVICE_ERROR,
80 STATE_OTHER,
81};

函数说明

◆ AdjustedYuvToBlue16()

SIMD_INLINE __m256i apollo::drivers::camera::AdjustedYuvToBlue16 ( __m256i  y16,
__m256i  u16 
)

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

1290 {
1291 return SaturateI16ToU8(_mm256_packs_epi32(
1292 AdjustedYuvToBlue32(_mm256_unpacklo_epi16(y16, K16_0001), _mm256_unpacklo_epi16(u16, K_ZERO)),
1293 AdjustedYuvToBlue32(_mm256_unpackhi_epi16(y16, K16_0001), _mm256_unpackhi_epi16(u16, K_ZERO))));
1294}
apollo::drivers::camera::SaturateI16ToU8
SIMD_INLINE __m256i SaturateI16ToU8(__m256i value)
Definition util.h:1241
apollo::drivers::camera::AdjustedYuvToBlue32
SIMD_INLINE __m256i AdjustedYuvToBlue32(__m256i y16_1, __m256i u16_0)
Definition util.h:1284

◆ AdjustedYuvToBlue32()

SIMD_INLINE __m256i apollo::drivers::camera::AdjustedYuvToBlue32 ( __m256i  y16_1,
__m256i  u16_0 
)

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

1284 {
1285 return _mm256_srai_epi32(
1286 _mm256_add_epi32(_mm256_madd_epi16(y16_1, K16_YRGB_RT), _mm256_madd_epi16(u16_0, K16_UB_0)),
1287 YUV_TO_BGR_AVERAGING_SHIFT);
1288}

◆ AdjustedYuvToGreen16()

SIMD_INLINE __m256i apollo::drivers::camera::AdjustedYuvToGreen16 ( __m256i  y16,
__m256i  u16,
__m256i  v16 
)

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

1278 {
1279 return SaturateI16ToU8(_mm256_packs_epi32(
1280 AdjustedYuvToGreen32(_mm256_unpacklo_epi16(y16, K16_0001), _mm256_unpacklo_epi16(u16, v16)),
1281 AdjustedYuvToGreen32(_mm256_unpackhi_epi16(y16, K16_0001), _mm256_unpackhi_epi16(u16, v16))));
1282}
apollo::drivers::camera::AdjustedYuvToGreen32
SIMD_INLINE __m256i AdjustedYuvToGreen32(__m256i y16_1, __m256i u16_v16)
Definition util.h:1272

◆ AdjustedYuvToGreen32()

SIMD_INLINE __m256i apollo::drivers::camera::AdjustedYuvToGreen32 ( __m256i  y16_1,
__m256i  u16_v16 
)

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

1272 {
1273 return _mm256_srai_epi32(
1274 _mm256_add_epi32(_mm256_madd_epi16(y16_1, K16_YRGB_RT), _mm256_madd_epi16(u16_v16, K16_UG_VG)),
1275 YUV_TO_BGR_AVERAGING_SHIFT);
1276}

◆ AdjustedYuvToRed16()

SIMD_INLINE __m256i apollo::drivers::camera::AdjustedYuvToRed16 ( __m256i  y16,
__m256i  v16 
)

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

1263 {
1264 // print_m256_i32(AdjustedYuvToRed32(_mm256_unpacklo_epi16(y16, K16_0001),
1265 // _mm256_unpacklo_epi16(v16, K_ZERO)));
1266 // print_m256_i16(_mm256_unpacklo_epi16(y16, K16_0001));
1267 return SaturateI16ToU8(_mm256_packs_epi32(
1268 AdjustedYuvToRed32(_mm256_unpacklo_epi16(y16, K16_0001), _mm256_unpacklo_epi16(v16, K_ZERO)),
1269 AdjustedYuvToRed32(_mm256_unpackhi_epi16(y16, K16_0001), _mm256_unpackhi_epi16(v16, K_ZERO))));
1270}
apollo::drivers::camera::AdjustedYuvToRed32
SIMD_INLINE __m256i AdjustedYuvToRed32(__m256i y16_1, __m256i v16_0)
Definition util.h:1253

◆ AdjustedYuvToRed32()

SIMD_INLINE __m256i apollo::drivers::camera::AdjustedYuvToRed32 ( __m256i  y16_1,
__m256i  v16_0 
)

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

1253 {
1254 // print_m256_i16(y16_1);
1255 // print_m256_i16(v16_0);
1256 // print_m256_i32(_mm256_madd_epi16(y16_1, K16_YRGB_RT));
1257 // print_m256_i32(_mm256_madd_epi16(v16_0, K16_VR_0));
1258 return _mm256_srai_epi32(
1259 _mm256_add_epi32(_mm256_madd_epi16(y16_1, K16_YRGB_RT), _mm256_madd_epi16(v16_0, K16_VR_0)),
1260 YUV_TO_BGR_AVERAGING_SHIFT);
1261}

◆ AdjustUV16()

SIMD_INLINE __m256i apollo::drivers::camera::AdjustUV16 ( __m256i  uv16)

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

1249 {
1250 return _mm256_subs_epi16(uv16, K16_UV_ADJUST);
1251}

◆ AdjustY16()

SIMD_INLINE __m256i apollo::drivers::camera::AdjustY16 ( __m256i  y16)

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

1245 {
1246 return _mm256_subs_epi16(y16, K16_Y_ADJUST);
1247}

◆ Aligned()

SIMD_INLINE bool apollo::drivers::camera::Aligned ( const void *  ptr,
size_t  align = sizeof(__m256) 
)

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

1224 {
1225 return ptr == AlignLo(ptr, align);
1226}
apollo::drivers::camera::AlignLo
SIMD_INLINE void * AlignLo(const void *ptr, size_t align)
Definition util.h:1220

◆ AlignLo()

SIMD_INLINE void * apollo::drivers::camera::AlignLo ( const void *  ptr,
size_t  align 
)

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

1220 {
1221 return reinterpret_cast<void *>(((size_t)ptr) & ~(align - 1));
1222}

◆ BgrToBlue()

SIMD_INLINE __m256i apollo::drivers::camera::BgrToBlue ( __m256i  bgr[3])

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

1353 {
1354 __m256i b0 = _mm256_shuffle_epi8(bgr[0], K8_SHUFFLE_BGR0_TO_BLUE);
1355 __m256i b2 = _mm256_shuffle_epi8(bgr[2], K8_SHUFFLE_BGR2_TO_BLUE);
1356 return _mm256_or_si256(
1357 _mm256_permute2x128_si256(b0, b2, 0x20),
1358 _mm256_or_si256(
1359 _mm256_shuffle_epi8(bgr[1], K8_SHUFFLE_BGR1_TO_BLUE), _mm256_permute2x128_si256(b0, b2, 0x31)));
1360}

◆ BgrToGreen()

SIMD_INLINE __m256i apollo::drivers::camera::BgrToGreen ( __m256i  bgr[3])

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

1362 {
1363 __m256i g0 = _mm256_shuffle_epi8(bgr[0], K8_SHUFFLE_BGR0_TO_GREEN);
1364 __m256i g2 = _mm256_shuffle_epi8(bgr[2], K8_SHUFFLE_BGR2_TO_GREEN);
1365 return _mm256_or_si256(
1366 _mm256_permute2x128_si256(g0, g2, 0x20),
1367 _mm256_or_si256(
1368 _mm256_shuffle_epi8(bgr[1], K8_SHUFFLE_BGR1_TO_GREEN), _mm256_permute2x128_si256(g0, g2, 0x31)));
1369}

◆ BgrToRed()

SIMD_INLINE __m256i apollo::drivers::camera::BgrToRed ( __m256i  bgr[3])

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

1371 {
1372 __m256i r0 = _mm256_shuffle_epi8(bgr[0], K8_SHUFFLE_BGR0_TO_RED);
1373 __m256i r2 = _mm256_shuffle_epi8(bgr[2], K8_SHUFFLE_BGR2_TO_RED);
1374 return _mm256_or_si256(
1375 _mm256_permute2x128_si256(r0, r2, 0x20),
1376 _mm256_or_si256(
1377 _mm256_shuffle_epi8(bgr[1], K8_SHUFFLE_BGR1_TO_RED), _mm256_permute2x128_si256(r0, r2, 0x31)));
1378}

◆ cuda_convert_yuv_to_rgb()

void apollo::drivers::camera::cuda_convert_yuv_to_rgb ( unsigned char *  src,
unsigned char *  dst,
unsigned int  width,
unsigned int  height 
)

floating conversion of YUV to RGB implemented with cuda

参数
srcPointer to image with yuv format
dstPointer to converted image
widthwidth of image
heightheight of image

◆ GetChar()

template<class T >
SIMD_INLINE char apollo::drivers::camera::GetChar ( T  value,
size_t  index 
)

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

50 {
51 return (reinterpret_cast<char *>(&value))[index];
52}

◆ InterleaveBgr()

template<int index>
__m256i apollo::drivers::camera::InterleaveBgr ( __m256i  blue,
__m256i  green,
__m256i  red 
)

◆ InterleaveBgr< 0 >()

template<>
SIMD_INLINE __m256i apollo::drivers::camera::InterleaveBgr< 0 > ( __m256i  blue,
__m256i  green,
__m256i  red 
)

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

1327 {
1328 return _mm256_or_si256(
1329 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(blue, 0x44), K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0),
1330 _mm256_or_si256(
1331 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(green, 0x44), K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0),
1332 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(red, 0x44), K8_SHUFFLE_PERMUTED_RED_TO_BGR0)));
1333}

◆ InterleaveBgr< 1 >()

template<>
SIMD_INLINE __m256i apollo::drivers::camera::InterleaveBgr< 1 > ( __m256i  blue,
__m256i  green,
__m256i  red 
)

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

1336 {
1337 return _mm256_or_si256(
1338 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(blue, 0x99), K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1),
1339 _mm256_or_si256(
1340 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(green, 0x99), K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1),
1341 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(red, 0x99), K8_SHUFFLE_PERMUTED_RED_TO_BGR1)));
1342}

◆ InterleaveBgr< 2 >()

template<>
SIMD_INLINE __m256i apollo::drivers::camera::InterleaveBgr< 2 > ( __m256i  blue,
__m256i  green,
__m256i  red 
)

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

1345 {
1346 return _mm256_or_si256(
1347 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(blue, 0xEE), K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2),
1348 _mm256_or_si256(
1349 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(green, 0xEE), K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2),
1350 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(red, 0xEE), K8_SHUFFLE_PERMUTED_RED_TO_BGR2)));
1351}

◆ Load()

template<bool align>
SIMD_INLINE __m256i apollo::drivers::camera::Load ( const __m256i *  p)

◆ Load< false >()

template<>
SIMD_INLINE __m256i apollo::drivers::camera::Load< false > ( const __m256i *  p)

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

1211 {
1212 return _mm256_loadu_si256(p);
1213}

◆ Load< true >()

template<>
SIMD_INLINE __m256i apollo::drivers::camera::Load< true > ( const __m256i *  p)

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

1216 {
1217 return _mm256_load_si256(p);
1218}

◆ LoadPermuted()

template<bool align>
SIMD_INLINE __m256i apollo::drivers::camera::LoadPermuted ( const __m256i *  p)

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

1381 {
1382 return _mm256_permute4x64_epi64(Load<align>(p), 0xD8);
1383}

◆ print_m256()

void apollo::drivers::camera::print_m256 ( __m256i  a)

在文件 util.cc 第 26 行定义.

26 {
27 unsigned char snoop[32];
28 bool dst_align = Aligned(reinterpret_cast<void*>(snoop));
29 if (dst_align) {
30 Store<true>(reinterpret_cast<__m256i*>(snoop), a);
31 }
32 else {
33 Store<false>(reinterpret_cast<__m256i*>(snoop), a);
34 }
35 for (int i = 0; i < 32; ++i) {
36 printf("DEBUG8 %d %u \n", i, snoop[i]);
37 }
38}
apollo::drivers::camera::Aligned
SIMD_INLINE bool Aligned(const void *ptr, size_t align=sizeof(__m256))
Definition util.h:1224

◆ print_m256_i16()

void apollo::drivers::camera::print_m256_i16 ( const __m256i  a)

在文件 util.cc 第 51 行定义.

51 {
52 uint16_t snoop[16];
53 bool dst_align = Aligned(reinterpret_cast<void*>(snoop));
54 if (dst_align)
55 Store<true>(reinterpret_cast<__m256i*>(snoop), a);
56 else
57 Store<false>(reinterpret_cast<__m256i*>(snoop), a);
58 for (int i = 0; i < 16; ++i) {
59 printf("DEBUG16 %d %u \n", i, snoop[i]);
60 }
61}

◆ print_m256_i32()

void apollo::drivers::camera::print_m256_i32 ( const __m256i  a)

在文件 util.cc 第 39 行定义.

39 {
40 unsigned int snoop[8];
41 bool dst_align = Aligned(reinterpret_cast<void*>(snoop));
42 if (dst_align)
43 Store<true>(reinterpret_cast<__m256i*>(snoop), a);
44 else
45 Store<false>(reinterpret_cast<__m256i*>(snoop), a);
46 for (int i = 0; i < 8; ++i) {
47 printf("DEBUG32 %d %u \n", i, snoop[i]);
48 }
49}

◆ SaturateI16ToU8()

SIMD_INLINE __m256i apollo::drivers::camera::SaturateI16ToU8 ( __m256i  value)

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

1241 {
1242 return _mm256_min_epi16(K16_00FF, _mm256_max_epi16(value, K_ZERO));
1243}

◆ Store()

template<bool align>
SIMD_INLINE void apollo::drivers::camera::Store ( __m256i *  p,
__m256i  a 
)

◆ Store< false >()

template<>
SIMD_INLINE void apollo::drivers::camera::Store< false > ( __m256i *  p,
__m256i  a 
)

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

1232 {
1233 _mm256_storeu_si256(p, a);
1234}

◆ Store< true >()

template<>
SIMD_INLINE void apollo::drivers::camera::Store< true > ( __m256i *  p,
__m256i  a 
)

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

1237 {
1238 _mm256_store_si256(p, a);
1239}

◆ yuv2rgb_avx2() [1/2]

template<bool align>
void apollo::drivers::camera::yuv2rgb_avx2 ( __m256i  y0,
__m256i  u0,
__m256i  v0,
uint8_t *  rgb 
)

在文件 util.cc 第 105 行定义.

105 {
106 __m256i r0 = YuvToRed(y0, v0);
107 __m256i g0 = YuvToGreen(y0, u0, v0);
108 __m256i b0 = YuvToBlue(y0, u0);
109
110 Store<align>(reinterpret_cast<__m256i*>(rgb) + 0, InterleaveBgr<0>(r0, g0, b0));
111 Store<align>(reinterpret_cast<__m256i*>(rgb) + 1, InterleaveBgr<1>(r0, g0, b0));
112 Store<align>(reinterpret_cast<__m256i*>(rgb) + 2, InterleaveBgr<2>(r0, g0, b0));
113}
apollo::drivers::camera::YuvToRed
SIMD_INLINE __m256i YuvToRed(__m256i y, __m256i v)
Definition util.h:1296
apollo::drivers::camera::YuvToBlue
SIMD_INLINE __m256i YuvToBlue(__m256i y, __m256i u)
Definition util.h:1317
apollo::drivers::camera::YuvToGreen
SIMD_INLINE __m256i YuvToGreen(__m256i y, __m256i u, __m256i v)
Definition util.h:1305

◆ yuv2rgb_avx2() [2/2]

template<bool align>
void apollo::drivers::camera::yuv2rgb_avx2 ( uint8_t *  yuv,
uint8_t *  rgb 
)

在文件 util.cc 第 116 行定义.

116 {
117 __m256i y0, y1, u0, v0;
118
119 yuv_separate_avx2<align>(yuv, &y0, &y1, &u0, &v0);
120 __m256i u0_u0 = _mm256_permute4x64_epi64(u0, 0xD8);
121 __m256i v0_v0 = _mm256_permute4x64_epi64(v0, 0xD8);
122 yuv2rgb_avx2<align>(y0, _mm256_unpacklo_epi8(u0_u0, u0_u0), _mm256_unpacklo_epi8(v0_v0, v0_v0), rgb);
123 yuv2rgb_avx2<align>(
124 y1, _mm256_unpackhi_epi8(u0_u0, u0_u0), _mm256_unpackhi_epi8(v0_v0, v0_v0), rgb + 3 * sizeof(__m256i));
125}

◆ yuv_separate_avx2()

template<bool align>
SIMD_INLINE void apollo::drivers::camera::yuv_separate_avx2 ( uint8_t *  y,
__m256i *  y0,
__m256i *  y1,
__m256i *  u0,
__m256i *  v0 
)

在文件 util.cc 第 64 行定义.

64 {
65 __m256i yuv_m256[4];
66
67 if (align) {
68 yuv_m256[0] = Load<true>(reinterpret_cast<__m256i*>(y));
69 yuv_m256[1] = Load<true>(reinterpret_cast<__m256i*>(y) + 1);
70 yuv_m256[2] = Load<true>(reinterpret_cast<__m256i*>(y) + 2);
71 yuv_m256[3] = Load<true>(reinterpret_cast<__m256i*>(y) + 3);
72 } else {
73 yuv_m256[0] = Load<false>(reinterpret_cast<__m256i*>(y));
74 yuv_m256[1] = Load<false>(reinterpret_cast<__m256i*>(y) + 1);
75 yuv_m256[2] = Load<false>(reinterpret_cast<__m256i*>(y) + 2);
76 yuv_m256[3] = Load<false>(reinterpret_cast<__m256i*>(y) + 3);
77 }
78
79 *y0 = _mm256_or_si256(
80 _mm256_permute4x64_epi64(_mm256_shuffle_epi8(yuv_m256[0], Y_SHUFFLE0), 0xD8),
81 _mm256_permute4x64_epi64(_mm256_shuffle_epi8(yuv_m256[1], Y_SHUFFLE1), 0xD8));
82 *y1 = _mm256_or_si256(
83 _mm256_permute4x64_epi64(_mm256_shuffle_epi8(yuv_m256[2], Y_SHUFFLE0), 0xD8),
84 _mm256_permute4x64_epi64(_mm256_shuffle_epi8(yuv_m256[3], Y_SHUFFLE1), 0xD8));
85
86 *u0 = _mm256_permutevar8x32_epi32(
87 _mm256_or_si256(
88 _mm256_or_si256(
89 _mm256_shuffle_epi8(yuv_m256[0], U_SHUFFLE0), _mm256_shuffle_epi8(yuv_m256[1], U_SHUFFLE1)),
90 _mm256_or_si256(
91 _mm256_shuffle_epi8(yuv_m256[2], U_SHUFFLE2),
92 _mm256_shuffle_epi8(yuv_m256[3], U_SHUFFLE3))),
93 U_SHUFFLE4);
94 *v0 = _mm256_permutevar8x32_epi32(
95 _mm256_or_si256(
96 _mm256_or_si256(
97 _mm256_shuffle_epi8(yuv_m256[0], V_SHUFFLE0), _mm256_shuffle_epi8(yuv_m256[1], V_SHUFFLE1)),
98 _mm256_or_si256(
99 _mm256_shuffle_epi8(yuv_m256[2], V_SHUFFLE2),
100 _mm256_shuffle_epi8(yuv_m256[3], V_SHUFFLE3))),
101 U_SHUFFLE4);
102}

◆ YuvToBlue()

SIMD_INLINE __m256i apollo::drivers::camera::YuvToBlue ( __m256i  y,
__m256i  u 
)

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

1317 {
1318 __m256i lo = AdjustedYuvToBlue16((_mm256_unpacklo_epi8(y, K_ZERO)), AdjustUV16(_mm256_unpacklo_epi8(u, K_ZERO)));
1319 __m256i hi = AdjustedYuvToBlue16((_mm256_unpackhi_epi8(y, K_ZERO)), AdjustUV16(_mm256_unpackhi_epi8(u, K_ZERO)));
1320 return _mm256_packus_epi16(lo, hi);
1321}
apollo::drivers::camera::AdjustUV16
SIMD_INLINE __m256i AdjustUV16(__m256i uv16)
Definition util.h:1249
apollo::drivers::camera::AdjustedYuvToBlue16
SIMD_INLINE __m256i AdjustedYuvToBlue16(__m256i y16, __m256i u16)
Definition util.h:1290

◆ YuvToGreen()

SIMD_INLINE __m256i apollo::drivers::camera::YuvToGreen ( __m256i  y,
__m256i  u,
__m256i  v 
)

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

1305 {
1306 __m256i lo = AdjustedYuvToGreen16(
1307 (_mm256_unpacklo_epi8(y, K_ZERO)),
1308 AdjustUV16(_mm256_unpacklo_epi8(u, K_ZERO)),
1309 AdjustUV16(_mm256_unpacklo_epi8(v, K_ZERO)));
1310 __m256i hi = AdjustedYuvToGreen16(
1311 (_mm256_unpackhi_epi8(y, K_ZERO)),
1312 AdjustUV16(_mm256_unpackhi_epi8(u, K_ZERO)),
1313 AdjustUV16(_mm256_unpackhi_epi8(v, K_ZERO)));
1314 return _mm256_packus_epi16(lo, hi);
1315}
apollo::drivers::camera::AdjustedYuvToGreen16
SIMD_INLINE __m256i AdjustedYuvToGreen16(__m256i y16, __m256i u16, __m256i v16)
Definition util.h:1278

◆ YuvToRed()

SIMD_INLINE __m256i apollo::drivers::camera::YuvToRed ( __m256i  y,
__m256i  v 
)

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

1296 {
1297 __m256i lo = AdjustedYuvToRed16(_mm256_unpacklo_epi8(y, K_ZERO), AdjustUV16(_mm256_unpacklo_epi8(v, K_ZERO)));
1298 __m256i hi = AdjustedYuvToRed16((_mm256_unpackhi_epi8(y, K_ZERO)), AdjustUV16(_mm256_unpackhi_epi8(v, K_ZERO)));
1299
1300 // print_m256_i16(lo);
1301 // print_m256_i16(hi);
1302 return _mm256_packus_epi16(lo, hi);
1303}
apollo::drivers::camera::AdjustedYuvToRed16
SIMD_INLINE __m256i AdjustedYuvToRed16(__m256i y16, __m256i v16)
Definition util.h:1263

◆ yuyv2rgb_avx()

void apollo::drivers::camera::yuyv2rgb_avx ( unsigned char *  YUV,
unsigned char *  RGB,
int  NumPixels 
)

在文件 util.cc 第 127 行定义.

127 {
128 assert(NumPixels == (1920 * 1080));
129 bool align = Aligned(YUV) & Aligned(RGB);
130 uint8_t* yuv_offset = YUV;
131 uint8_t* rgb_offset = RGB;
132 if (align) {
133 for (int i = 0; i < NumPixels; i = i + static_cast<int>(2 * sizeof(__m256i)),
134 yuv_offset += 4 * static_cast<int>(sizeof(__m256i)),
135 rgb_offset += 6 * static_cast<int>(sizeof(__m256i))) {
136 yuv2rgb_avx2<true>(yuv_offset, rgb_offset);
137 }
138 } else {
139 for (int i = 0; i < NumPixels; i = i + static_cast<int>(2 * sizeof(__m256i)),
140 yuv_offset += 4 * static_cast<int>(sizeof(__m256i)),
141 rgb_offset += 6 * static_cast<int>(sizeof(__m256i))) {
142 yuv2rgb_avx2<false>(yuv_offset, rgb_offset);
143 }
144 }
145}

变量说明

◆ A

const size_t apollo::drivers::camera::A = sizeof(__m256i)

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

◆ DA

const size_t apollo::drivers::camera::DA = 2 * A

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

◆ HA

const size_t apollo::drivers::camera::HA = A / 2

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

◆ K16_0001

const __m256i apollo::drivers::camera::K16_0001 = SIMD_MM256_SET1_EPI16(0x0001)

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

◆ K16_0002

const __m256i apollo::drivers::camera::K16_0002 = SIMD_MM256_SET1_EPI16(0x0002)

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

◆ K16_0003

const __m256i apollo::drivers::camera::K16_0003 = SIMD_MM256_SET1_EPI16(0x0003)

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

◆ K16_0004

const __m256i apollo::drivers::camera::K16_0004 = SIMD_MM256_SET1_EPI16(0x0004)

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

◆ K16_0005

const __m256i apollo::drivers::camera::K16_0005 = SIMD_MM256_SET1_EPI16(0x0005)

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

◆ K16_0006

const __m256i apollo::drivers::camera::K16_0006 = SIMD_MM256_SET1_EPI16(0x0006)

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

◆ K16_0008

const __m256i apollo::drivers::camera::K16_0008 = SIMD_MM256_SET1_EPI16(0x0008)

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

◆ K16_0010

const __m256i apollo::drivers::camera::K16_0010 = SIMD_MM256_SET1_EPI16(0x0010)

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

◆ K16_0018

const __m256i apollo::drivers::camera::K16_0018 = SIMD_MM256_SET1_EPI16(0x0018)

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

◆ K16_0020

const __m256i apollo::drivers::camera::K16_0020 = SIMD_MM256_SET1_EPI16(0x0020)

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

◆ K16_0080

const __m256i apollo::drivers::camera::K16_0080 = SIMD_MM256_SET1_EPI16(0x0080)

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

◆ K16_00FF

const __m256i apollo::drivers::camera::K16_00FF = SIMD_MM256_SET1_EPI16(0x00FF)

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

◆ K16_FF00

const __m256i apollo::drivers::camera::K16_FF00 = SIMD_MM256_SET1_EPI16(0xFF00)

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

◆ K16_UB_0

const __m256i apollo::drivers::camera::K16_UB_0 = SIMD_MM256_SET2_EPI16(U_TO_BLUE_WEIGHT, 0)

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

◆ K16_UG_VG

const __m256i apollo::drivers::camera::K16_UG_VG = SIMD_MM256_SET2_EPI16(U_TO_GREEN_WEIGHT, V_TO_GREEN_WEIGHT)

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

◆ K16_UV_ADJUST

const __m256i apollo::drivers::camera::K16_UV_ADJUST = SIMD_MM256_SET1_EPI16(128)

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

◆ K16_VR_0

const __m256i apollo::drivers::camera::K16_VR_0 = SIMD_MM256_SET2_EPI16(V_TO_RED_WEIGHT, 0)

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

◆ K16_Y_ADJUST

const __m256i apollo::drivers::camera::K16_Y_ADJUST = SIMD_MM256_SET1_EPI16(0)

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

◆ K16_YRGB_RT

const __m256i apollo::drivers::camera::K16_YRGB_RT = SIMD_MM256_SET2_EPI16(Y_TO_RGB_WEIGHT, YUV_TO_BGR_ROUND_TERM)

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

◆ K32_00000001

const __m256i apollo::drivers::camera::K32_00000001 = SIMD_MM256_SET1_EPI32(0x00000001)

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

◆ K32_00000002

const __m256i apollo::drivers::camera::K32_00000002 = SIMD_MM256_SET1_EPI32(0x00000002)

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

◆ K32_00000004

const __m256i apollo::drivers::camera::K32_00000004 = SIMD_MM256_SET1_EPI32(0x00000004)

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

◆ K32_00000008

const __m256i apollo::drivers::camera::K32_00000008 = SIMD_MM256_SET1_EPI32(0x00000008)

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

◆ K32_000000FF

const __m256i apollo::drivers::camera::K32_000000FF = SIMD_MM256_SET1_EPI32(0x000000FF)

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

◆ K32_0000FFFF

const __m256i apollo::drivers::camera::K32_0000FFFF = SIMD_MM256_SET1_EPI32(0x0000FFFF)

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

◆ K32_00010000

const __m256i apollo::drivers::camera::K32_00010000 = SIMD_MM256_SET1_EPI32(0x00010000)

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

◆ K32_01000000

const __m256i apollo::drivers::camera::K32_01000000 = SIMD_MM256_SET1_EPI32(0x01000000)

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

◆ K32_FFFFFF00

const __m256i apollo::drivers::camera::K32_FFFFFF00 = SIMD_MM256_SET1_EPI32(0xFFFFFF00)

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

◆ K8_01

const __m256i apollo::drivers::camera::K8_01 = SIMD_MM256_SET1_EPI8(0x01)

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

◆ K8_01_FF

const __m256i apollo::drivers::camera::K8_01_FF = SIMD_MM256_SET2_EPI8(0x01, 0xFF)

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

◆ K8_02

const __m256i apollo::drivers::camera::K8_02 = SIMD_MM256_SET1_EPI8(0x02)

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

◆ K8_04

const __m256i apollo::drivers::camera::K8_04 = SIMD_MM256_SET1_EPI8(0x04)

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

◆ K8_08

const __m256i apollo::drivers::camera::K8_08 = SIMD_MM256_SET1_EPI8(0x08)

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

◆ K8_10

const __m256i apollo::drivers::camera::K8_10 = SIMD_MM256_SET1_EPI8(0x10)

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

◆ K8_20

const __m256i apollo::drivers::camera::K8_20 = SIMD_MM256_SET1_EPI8(0x20)

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

◆ K8_40

const __m256i apollo::drivers::camera::K8_40 = SIMD_MM256_SET1_EPI8(0x40)

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

◆ K8_80

const __m256i apollo::drivers::camera::K8_80 = SIMD_MM256_SET1_EPI8(0x80)

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

◆ K8_SHUFFLE_BGR0_TO_BLUE

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_BLUE

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

◆ K8_SHUFFLE_BGR0_TO_GREEN

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_GREEN

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

◆ K8_SHUFFLE_BGR0_TO_RED

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_RED

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

◆ K8_SHUFFLE_BGR1_TO_BLUE

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_BLUE

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

◆ K8_SHUFFLE_BGR1_TO_GREEN

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_GREEN

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

◆ K8_SHUFFLE_BGR1_TO_RED

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_RED

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

◆ K8_SHUFFLE_BGR2_TO_BLUE

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_BLUE

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

◆ K8_SHUFFLE_BGR2_TO_GREEN

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_GREEN

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

◆ K8_SHUFFLE_BGR2_TO_RED

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_RED

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

◆ K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0

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

◆ K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1

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

◆ K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2

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

◆ K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0

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

◆ K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1

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

◆ K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2

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

◆ K8_SHUFFLE_PERMUTED_RED_TO_BGR0

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR0

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

◆ K8_SHUFFLE_PERMUTED_RED_TO_BGR1

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR1

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

◆ K8_SHUFFLE_PERMUTED_RED_TO_BGR2

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR2

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

◆ K_INV_ZERO

const __m256i apollo::drivers::camera::K_INV_ZERO = SIMD_MM256_SET1_EPI8(0xFF)

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

◆ K_ZERO

const __m256i apollo::drivers::camera::K_ZERO = SIMD_MM256_SET1_EPI8(0)

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

◆ OA

const size_t apollo::drivers::camera::OA = 8 * A

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

◆ QA

const size_t apollo::drivers::camera::QA = 4 * A

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

◆ U_SHUFFLE0

const __m256i apollo::drivers::camera::U_SHUFFLE0

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

◆ U_SHUFFLE1

const __m256i apollo::drivers::camera::U_SHUFFLE1

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

◆ U_SHUFFLE2

const __m256i apollo::drivers::camera::U_SHUFFLE2

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

◆ U_SHUFFLE3

const __m256i apollo::drivers::camera::U_SHUFFLE3

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

◆ U_SHUFFLE4

const __m256i apollo::drivers::camera::U_SHUFFLE4

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

◆ U_TO_BLUE_WEIGHT

const int apollo::drivers::camera::U_TO_BLUE_WEIGHT = static_cast<int>((2.041 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))

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

◆ U_TO_GREEN_WEIGHT

const int apollo::drivers::camera::U_TO_GREEN_WEIGHT = -static_cast<int>((0.3455 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))

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

◆ UV_ADJUST

const int apollo::drivers::camera::UV_ADJUST = 128

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

◆ V_SHUFFLE0

const __m256i apollo::drivers::camera::V_SHUFFLE0

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

◆ V_SHUFFLE1

const __m256i apollo::drivers::camera::V_SHUFFLE1

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

◆ V_SHUFFLE2

const __m256i apollo::drivers::camera::V_SHUFFLE2

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

◆ V_SHUFFLE3

const __m256i apollo::drivers::camera::V_SHUFFLE3

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

◆ V_TO_GREEN_WEIGHT

const int apollo::drivers::camera::V_TO_GREEN_WEIGHT = -static_cast<int>((0.7169 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))

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

◆ V_TO_RED_WEIGHT

const int apollo::drivers::camera::V_TO_RED_WEIGHT = static_cast<int>((1.4065 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))

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

◆ Y_ADJUST

const int apollo::drivers::camera::Y_ADJUST = 0

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

◆ Y_SHUFFLE0

const __m256i apollo::drivers::camera::Y_SHUFFLE0

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

◆ Y_SHUFFLE1

const __m256i apollo::drivers::camera::Y_SHUFFLE1

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

◆ Y_TO_RGB_WEIGHT

const int apollo::drivers::camera::Y_TO_RGB_WEIGHT = static_cast<int>((((1 << YUV_TO_BGR_AVERAGING_SHIFT))))

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

◆ YUV_TO_BGR_AVERAGING_SHIFT

const int apollo::drivers::camera::YUV_TO_BGR_AVERAGING_SHIFT = 13

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

◆ YUV_TO_BGR_ROUND_TERM

const int apollo::drivers::camera::YUV_TO_BGR_ROUND_TERM = 0

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