Apollo 10.0
自动驾驶开放平台
apollo::drivers::camera 命名空间参考

命名空间

namespace  config
 

struct  buffer
 
class  CameraComponent
 
struct  CameraImage
 
class  CompressComponent
 
class  UsbCam
 

类型定义

typedef std::shared_ptr< CameraImageCameraImagePtr
 

函数

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
 
const int U_TO_BLUE_WEIGHT
 
const int U_TO_GREEN_WEIGHT
 
const int V_TO_GREEN_WEIGHT
 
const int V_TO_RED_WEIGHT
 
const __m256i K16_YRGB_RT
 
const __m256i K16_VR_0 = SIMD_MM256_SET2_EPI16(V_TO_RED_WEIGHT, 0)
 
const __m256i K16_UG_VG
 
const __m256i K16_UB_0 = SIMD_MM256_SET2_EPI16(U_TO_BLUE_WEIGHT, 0)
 

类型定义说明

◆ CameraImagePtr

在文件 usb_cam.h100 行定义.

函数说明

◆ AdjustedYuvToBlue16()

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

在文件 util.h418 行定义.

418 {
419 return SaturateI16ToU8(_mm256_packs_epi32(
420 AdjustedYuvToBlue32(_mm256_unpacklo_epi16(y16, K16_0001),
421 _mm256_unpacklo_epi16(u16, K_ZERO)),
422 AdjustedYuvToBlue32(_mm256_unpackhi_epi16(y16, K16_0001),
423 _mm256_unpackhi_epi16(u16, K_ZERO))));
424}
SIMD_INLINE __m256i SaturateI16ToU8(__m256i value)
Definition util.h:361
SIMD_INLINE __m256i AdjustedYuvToBlue32(__m256i y16_1, __m256i u16_0)
Definition util.h:411

◆ AdjustedYuvToBlue32()

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

在文件 util.h411 行定义.

411 {
412 return _mm256_srai_epi32(
413 _mm256_add_epi32(_mm256_madd_epi16(y16_1, K16_YRGB_RT),
414 _mm256_madd_epi16(u16_0, K16_UB_0)),
415 YUV_TO_BGR_AVERAGING_SHIFT);
416}

◆ AdjustedYuvToGreen16()

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

在文件 util.h402 行定义.

403 {
404 return SaturateI16ToU8(_mm256_packs_epi32(
405 AdjustedYuvToGreen32(_mm256_unpacklo_epi16(y16, K16_0001),
406 _mm256_unpacklo_epi16(u16, v16)),
407 AdjustedYuvToGreen32(_mm256_unpackhi_epi16(y16, K16_0001),
408 _mm256_unpackhi_epi16(u16, v16))));
409}
SIMD_INLINE __m256i AdjustedYuvToGreen32(__m256i y16_1, __m256i u16_v16)
Definition util.h:395

◆ AdjustedYuvToGreen32()

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

在文件 util.h395 行定义.

395 {
396 return _mm256_srai_epi32(
397 _mm256_add_epi32(_mm256_madd_epi16(y16_1, K16_YRGB_RT),
398 _mm256_madd_epi16(u16_v16, K16_UG_VG)),
399 YUV_TO_BGR_AVERAGING_SHIFT);
400}

◆ AdjustedYuvToRed16()

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

在文件 util.h384 行定义.

384 {
385 // print_m256_i32(AdjustedYuvToRed32(_mm256_unpacklo_epi16(y16, K16_0001),
386 // _mm256_unpacklo_epi16(v16, K_ZERO)));
387 // print_m256_i16(_mm256_unpacklo_epi16(y16, K16_0001));
388 return SaturateI16ToU8(_mm256_packs_epi32(
389 AdjustedYuvToRed32(_mm256_unpacklo_epi16(y16, K16_0001),
390 _mm256_unpacklo_epi16(v16, K_ZERO)),
391 AdjustedYuvToRed32(_mm256_unpackhi_epi16(y16, K16_0001),
392 _mm256_unpackhi_epi16(v16, K_ZERO))));
393}
SIMD_INLINE __m256i AdjustedYuvToRed32(__m256i y16_1, __m256i v16_0)
Definition util.h:373

◆ AdjustedYuvToRed32()

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

在文件 util.h373 行定义.

373 {
374 // print_m256_i16(y16_1);
375 // print_m256_i16(v16_0);
376 // print_m256_i32(_mm256_madd_epi16(y16_1, K16_YRGB_RT));
377 // print_m256_i32(_mm256_madd_epi16(v16_0, K16_VR_0));
378 return _mm256_srai_epi32(
379 _mm256_add_epi32(_mm256_madd_epi16(y16_1, K16_YRGB_RT),
380 _mm256_madd_epi16(v16_0, K16_VR_0)),
381 YUV_TO_BGR_AVERAGING_SHIFT);
382}

◆ AdjustUV16()

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

在文件 util.h369 行定义.

369 {
370 return _mm256_subs_epi16(uv16, K16_UV_ADJUST);
371}

◆ AdjustY16()

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

在文件 util.h365 行定义.

365 {
366 return _mm256_subs_epi16(y16, K16_Y_ADJUST);
367}

◆ Aligned()

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

在文件 util.h344 行定义.

344 {
345 return ptr == AlignLo(ptr, align);
346}
SIMD_INLINE void * AlignLo(const void *ptr, size_t align)
Definition util.h:340

◆ AlignLo()

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

在文件 util.h340 行定义.

340 {
341 return reinterpret_cast<void *>(((size_t)ptr) & ~(align - 1));
342}

◆ BgrToBlue()

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

在文件 util.h493 行定义.

493 {
494 __m256i b0 = _mm256_shuffle_epi8(bgr[0], K8_SHUFFLE_BGR0_TO_BLUE);
495 __m256i b2 = _mm256_shuffle_epi8(bgr[2], K8_SHUFFLE_BGR2_TO_BLUE);
496 return _mm256_or_si256(
497 _mm256_permute2x128_si256(b0, b2, 0x20),
498 _mm256_or_si256(_mm256_shuffle_epi8(bgr[1], K8_SHUFFLE_BGR1_TO_BLUE),
499 _mm256_permute2x128_si256(b0, b2, 0x31)));
500}

◆ BgrToGreen()

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

在文件 util.h502 行定义.

502 {
503 __m256i g0 = _mm256_shuffle_epi8(bgr[0], K8_SHUFFLE_BGR0_TO_GREEN);
504 __m256i g2 = _mm256_shuffle_epi8(bgr[2], K8_SHUFFLE_BGR2_TO_GREEN);
505 return _mm256_or_si256(
506 _mm256_permute2x128_si256(g0, g2, 0x20),
507 _mm256_or_si256(_mm256_shuffle_epi8(bgr[1], K8_SHUFFLE_BGR1_TO_GREEN),
508 _mm256_permute2x128_si256(g0, g2, 0x31)));
509}

◆ BgrToRed()

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

在文件 util.h511 行定义.

511 {
512 __m256i r0 = _mm256_shuffle_epi8(bgr[0], K8_SHUFFLE_BGR0_TO_RED);
513 __m256i r2 = _mm256_shuffle_epi8(bgr[2], K8_SHUFFLE_BGR2_TO_RED);
514 return _mm256_or_si256(
515 _mm256_permute2x128_si256(r0, r2, 0x20),
516 _mm256_or_si256(_mm256_shuffle_epi8(bgr[1], K8_SHUFFLE_BGR1_TO_RED),
517 _mm256_permute2x128_si256(r0, r2, 0x31)));
518}

◆ GetChar()

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

在文件 util.h50 行定义.

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.h461 行定义.

461 {
462 return _mm256_or_si256(
463 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(blue, 0x44),
464 K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0),
465 _mm256_or_si256(_mm256_shuffle_epi8(_mm256_permute4x64_epi64(green, 0x44),
466 K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0),
467 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(red, 0x44),
468 K8_SHUFFLE_PERMUTED_RED_TO_BGR0)));
469}

◆ InterleaveBgr< 1 >()

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

在文件 util.h472 行定义.

472 {
473 return _mm256_or_si256(
474 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(blue, 0x99),
475 K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1),
476 _mm256_or_si256(_mm256_shuffle_epi8(_mm256_permute4x64_epi64(green, 0x99),
477 K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1),
478 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(red, 0x99),
479 K8_SHUFFLE_PERMUTED_RED_TO_BGR1)));
480}

◆ InterleaveBgr< 2 >()

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

在文件 util.h483 行定义.

483 {
484 return _mm256_or_si256(
485 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(blue, 0xEE),
486 K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2),
487 _mm256_or_si256(_mm256_shuffle_epi8(_mm256_permute4x64_epi64(green, 0xEE),
488 K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2),
489 _mm256_shuffle_epi8(_mm256_permute4x64_epi64(red, 0xEE),
490 K8_SHUFFLE_PERMUTED_RED_TO_BGR2)));
491}

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

331 {
332 return _mm256_loadu_si256(p);
333}

◆ Load< true >()

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

在文件 util.h336 行定义.

336 {
337 return _mm256_load_si256(p);
338}

◆ LoadPermuted()

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

在文件 util.h521 行定义.

521 {
522 return _mm256_permute4x64_epi64(Load<align>(p), 0xD8);
523}

◆ print_m256()

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

在文件 util.cc26 行定义.

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 else
32 Store<false>(reinterpret_cast<__m256i*>(snoop), a);
33 for (int i = 0; i < 32; ++i) {
34 printf("DEBUG8 %d %u \n", i, snoop[i]);
35 }
36}
SIMD_INLINE bool Aligned(const void *ptr, size_t align=sizeof(__m256))
Definition util.h:344

◆ print_m256_i16()

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

在文件 util.cc49 行定义.

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

◆ print_m256_i32()

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

在文件 util.cc37 行定义.

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

◆ SaturateI16ToU8()

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

在文件 util.h361 行定义.

361 {
362 return _mm256_min_epi16(K16_00FF, _mm256_max_epi16(value, K_ZERO));
363}

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

352 {
353 _mm256_storeu_si256(p, a);
354}

◆ Store< true >()

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

在文件 util.h357 行定义.

357 {
358 _mm256_store_si256(p, a);
359}

◆ yuv2rgb_avx2() [1/2]

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

在文件 util.cc106 行定义.

106 {
107 __m256i r0 = YuvToRed(y0, v0);
108 __m256i g0 = YuvToGreen(y0, u0, v0);
109 __m256i b0 = YuvToBlue(y0, u0);
110
111 Store<align>(reinterpret_cast<__m256i*>(rgb) + 0,
112 InterleaveBgr<0>(r0, g0, b0));
113 Store<align>(reinterpret_cast<__m256i*>(rgb) + 1,
114 InterleaveBgr<1>(r0, g0, b0));
115 Store<align>(reinterpret_cast<__m256i*>(rgb) + 2,
116 InterleaveBgr<2>(r0, g0, b0));
117}
SIMD_INLINE __m256i YuvToRed(__m256i y, __m256i v)
Definition util.h:426
SIMD_INLINE __m256i YuvToBlue(__m256i y, __m256i u)
Definition util.h:449
SIMD_INLINE __m256i YuvToGreen(__m256i y, __m256i u, __m256i v)
Definition util.h:437

◆ yuv2rgb_avx2() [2/2]

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

在文件 util.cc120 行定义.

120 {
121 __m256i y0, y1, u0, v0;
122
123 yuv_separate_avx2<align>(yuv, &y0, &y1, &u0, &v0);
124 __m256i u0_u0 = _mm256_permute4x64_epi64(u0, 0xD8);
125 __m256i v0_v0 = _mm256_permute4x64_epi64(v0, 0xD8);
126 yuv2rgb_avx2<align>(y0, _mm256_unpacklo_epi8(u0_u0, u0_u0),
127 _mm256_unpacklo_epi8(v0_v0, v0_v0), rgb);
128 yuv2rgb_avx2<align>(y1, _mm256_unpackhi_epi8(u0_u0, u0_u0),
129 _mm256_unpackhi_epi8(v0_v0, v0_v0),
130 rgb + 3 * sizeof(__m256i));
131}

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

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

◆ YuvToBlue()

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

在文件 util.h449 行定义.

449 {
450 __m256i lo = AdjustedYuvToBlue16((_mm256_unpacklo_epi8(y, K_ZERO)),
451 AdjustUV16(_mm256_unpacklo_epi8(u, K_ZERO)));
452 __m256i hi = AdjustedYuvToBlue16((_mm256_unpackhi_epi8(y, K_ZERO)),
453 AdjustUV16(_mm256_unpackhi_epi8(u, K_ZERO)));
454 return _mm256_packus_epi16(lo, hi);
455}
SIMD_INLINE __m256i AdjustUV16(__m256i uv16)
Definition util.h:369
SIMD_INLINE __m256i AdjustedYuvToBlue16(__m256i y16, __m256i u16)
Definition util.h:418

◆ YuvToGreen()

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

在文件 util.h437 行定义.

437 {
438 __m256i lo =
439 AdjustedYuvToGreen16((_mm256_unpacklo_epi8(y, K_ZERO)),
440 AdjustUV16(_mm256_unpacklo_epi8(u, K_ZERO)),
441 AdjustUV16(_mm256_unpacklo_epi8(v, K_ZERO)));
442 __m256i hi =
443 AdjustedYuvToGreen16((_mm256_unpackhi_epi8(y, K_ZERO)),
444 AdjustUV16(_mm256_unpackhi_epi8(u, K_ZERO)),
445 AdjustUV16(_mm256_unpackhi_epi8(v, K_ZERO)));
446 return _mm256_packus_epi16(lo, hi);
447}
SIMD_INLINE __m256i AdjustedYuvToGreen16(__m256i y16, __m256i u16, __m256i v16)
Definition util.h:402

◆ YuvToRed()

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

在文件 util.h426 行定义.

426 {
427 __m256i lo = AdjustedYuvToRed16(_mm256_unpacklo_epi8(y, K_ZERO),
428 AdjustUV16(_mm256_unpacklo_epi8(v, K_ZERO)));
429 __m256i hi = AdjustedYuvToRed16((_mm256_unpackhi_epi8(y, K_ZERO)),
430 AdjustUV16(_mm256_unpackhi_epi8(v, K_ZERO)));
431
432 // print_m256_i16(lo);
433 // print_m256_i16(hi);
434 return _mm256_packus_epi16(lo, hi);
435}
SIMD_INLINE __m256i AdjustedYuvToRed16(__m256i y16, __m256i v16)
Definition util.h:384

◆ yuyv2rgb_avx()

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

在文件 util.cc133 行定义.

133 {
134 assert(NumPixels == (1920 * 1080));
135 bool align = Aligned(YUV) & Aligned(RGB);
136 uint8_t* yuv_offset = YUV;
137 uint8_t* rgb_offset = RGB;
138 if (align) {
139 for (int i = 0; i < NumPixels;
140 i = i + static_cast<int>(2 * sizeof(__m256i)),
141 yuv_offset += 4 * static_cast<int>(sizeof(__m256i)),
142 rgb_offset += 6 * static_cast<int>(sizeof(__m256i))) {
143 yuv2rgb_avx2<true>(yuv_offset, rgb_offset);
144 }
145 } else {
146 for (int i = 0; i < NumPixels;
147 i = i + static_cast<int>(2 * sizeof(__m256i)),
148 yuv_offset += 4 * static_cast<int>(sizeof(__m256i)),
149 rgb_offset += 6 * static_cast<int>(sizeof(__m256i))) {
150 yuv2rgb_avx2<false>(yuv_offset, rgb_offset);
151 }
152 }
153}

变量说明

◆ A

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

在文件 util.h160 行定义.

◆ DA

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

在文件 util.h161 行定义.

◆ HA

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

在文件 util.h164 行定义.

◆ K16_0001

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

在文件 util.h180 行定义.

◆ K16_0002

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

在文件 util.h181 行定义.

◆ K16_0003

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

在文件 util.h182 行定义.

◆ K16_0004

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

在文件 util.h183 行定义.

◆ K16_0005

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

在文件 util.h184 行定义.

◆ K16_0006

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

在文件 util.h185 行定义.

◆ K16_0008

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

在文件 util.h186 行定义.

◆ K16_0010

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

在文件 util.h187 行定义.

◆ K16_0018

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

在文件 util.h188 行定义.

◆ K16_0020

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

在文件 util.h189 行定义.

◆ K16_0080

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

在文件 util.h190 行定义.

◆ K16_00FF

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

在文件 util.h191 行定义.

◆ K16_FF00

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

在文件 util.h192 行定义.

◆ K16_UB_0

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

在文件 util.h325 行定义.

◆ K16_UG_VG

const __m256i apollo::drivers::camera::K16_UG_VG
初始值:
=
SIMD_MM256_SET2_EPI16(U_TO_GREEN_WEIGHT, V_TO_GREEN_WEIGHT)
#define SIMD_MM256_SET2_EPI16(a0, a1)
Definition util.h:125

在文件 util.h323 行定义.

◆ K16_UV_ADJUST

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

在文件 util.h304 行定义.

◆ K16_VR_0

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

在文件 util.h322 行定义.

◆ K16_Y_ADJUST

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

在文件 util.h303 行定义.

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

◆ K32_00000001

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

在文件 util.h194 行定义.

◆ K32_00000002

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

在文件 util.h195 行定义.

◆ K32_00000004

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

在文件 util.h196 行定义.

◆ K32_00000008

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

在文件 util.h197 行定义.

◆ K32_000000FF

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

在文件 util.h198 行定义.

◆ K32_0000FFFF

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

在文件 util.h199 行定义.

◆ K32_00010000

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

在文件 util.h200 行定义.

◆ K32_01000000

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

在文件 util.h201 行定义.

◆ K32_FFFFFF00

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

在文件 util.h202 行定义.

◆ K8_01

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

在文件 util.h169 行定义.

◆ K8_01_FF

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

在文件 util.h178 行定义.

◆ K8_02

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

在文件 util.h170 行定义.

◆ K8_04

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

在文件 util.h171 行定义.

◆ K8_08

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

在文件 util.h172 行定义.

◆ K8_10

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

在文件 util.h173 行定义.

◆ K8_20

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

在文件 util.h174 行定义.

◆ K8_40

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

在文件 util.h175 行定义.

◆ K8_80

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

在文件 util.h176 行定义.

◆ K8_SHUFFLE_BGR0_TO_BLUE

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_BLUE
初始值:
0x0, 0x3, 0x6, 0x9, 0xC, 0xF, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 0x2, 0x5, 0x8, 0xB, 0xE, -1, -1, -1, -1, -1)
#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

在文件 util.h204 行定义.

◆ K8_SHUFFLE_BGR0_TO_GREEN

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_GREEN
初始值:
0x1, 0x4, 0x7, 0xA, 0xD, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 0x0, 0x3, 0x6, 0x9, 0xC, 0xF, -1, -1, -1, -1, -1)

在文件 util.h283 行定义.

◆ K8_SHUFFLE_BGR0_TO_RED

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR0_TO_RED
初始值:
0x2, 0x5, 0x8, 0xB, 0xE, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 0x1, 0x4, 0x7, 0xA, 0xD, -1, -1, -1, -1, -1, -1)

在文件 util.h293 行定义.

◆ K8_SHUFFLE_BGR1_TO_BLUE

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_BLUE
初始值:
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x1, 0x4, 0x7, 0xA, 0xD, 0x0,
0x3, 0x6, 0x9, 0xC, 0xF, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1)

在文件 util.h207 行定义.

◆ K8_SHUFFLE_BGR1_TO_GREEN

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_GREEN
初始值:
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x2, 0x5, 0x8, 0xB, 0xE, 0x1,
0x4, 0x7, 0xA, 0xD, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1)

在文件 util.h286 行定义.

◆ K8_SHUFFLE_BGR1_TO_RED

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR1_TO_RED
初始值:
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x0, 0x3, 0x6, 0x9, 0xC, 0xF, 0x2,
0x5, 0x8, 0xB, 0xE, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1)

在文件 util.h296 行定义.

◆ K8_SHUFFLE_BGR2_TO_BLUE

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_BLUE
初始值:
-1, -1, -1, -1, -1, -1, 0x2, 0x5, 0x8, 0xB, 0xE, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 0x1, 0x4, 0x7, 0xA, 0xD)

在文件 util.h210 行定义.

◆ K8_SHUFFLE_BGR2_TO_GREEN

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_GREEN
初始值:
-1, -1, -1, -1, -1, 0x0, 0x3, 0x6, 0x9, 0xC, 0xF, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x2, 0x5, 0x8, 0xB, 0xE)

在文件 util.h289 行定义.

◆ K8_SHUFFLE_BGR2_TO_RED

const __m256i apollo::drivers::camera::K8_SHUFFLE_BGR2_TO_RED
初始值:
-1, -1, -1, -1, -1, 0x1, 0x4, 0x7, 0xA, 0xD, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 0x0, 0x3, 0x6, 0x9, 0xC, 0xF)

在文件 util.h299 行定义.

◆ K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0
初始值:
0x0, -1, -1, 0x1, -1, -1, 0x2, -1, -1, 0x3, -1, -1, 0x4, -1, -1, 0x5, -1,
-1, 0x6, -1, -1, 0x7, -1, -1, 0x8, -1, -1, 0x9, -1, -1, 0xA, -1)

在文件 util.h253 行定义.

◆ K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1
初始值:
-1, 0x3, -1, -1, 0x4, -1, -1, 0x5, -1, -1, 0x6, -1, -1, 0x7, -1, -1, 0x8,
-1, -1, 0x9, -1, -1, 0xA, -1, -1, 0xB, -1, -1, 0xC, -1, -1, 0xD)

在文件 util.h256 行定义.

◆ K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2
初始值:
-1, -1, 0x6, -1, -1, 0x7, -1, -1, 0x8, -1, -1, 0x9, -1, -1, 0xA, -1, -1,
0xB, -1, -1, 0xC, -1, -1, 0xD, -1, -1, 0xE, -1, -1, 0xF, -1, -1)

在文件 util.h259 行定义.

◆ K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0
初始值:
-1, 0x0, -1, -1, 0x1, -1, -1, 0x2, -1, -1, 0x3, -1, -1, 0x4, -1, -1, 0x5,
-1, -1, 0x6, -1, -1, 0x7, -1, -1, 0x8, -1, -1, 0x9, -1, -1, 0xA)

在文件 util.h263 行定义.

◆ K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1
初始值:
-1, -1, 0x3, -1, -1, 0x4, -1, -1, 0x5, -1, -1, 0x6, -1, -1, 0x7, -1, -1,
0x8, -1, -1, 0x9, -1, -1, 0xA, -1, -1, 0xB, -1, -1, 0xC, -1, -1)

在文件 util.h266 行定义.

◆ K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2
初始值:
0x5, -1, -1, 0x6, -1, -1, 0x7, -1, -1, 0x8, -1, -1, 0x9, -1, -1, 0xA, -1,
-1, 0xB, -1, -1, 0xC, -1, -1, 0xD, -1, -1, 0xE, -1, -1, 0xF, -1)

在文件 util.h269 行定义.

◆ K8_SHUFFLE_PERMUTED_RED_TO_BGR0

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR0
初始值:
-1, -1, 0x0, -1, -1, 0x1, -1, -1, 0x2, -1, -1, 0x3, -1, -1, 0x4, -1, -1,
0x5, -1, -1, 0x6, -1, -1, 0x7, -1, -1, 0x8, -1, -1, 0x9, -1, -1)

在文件 util.h273 行定义.

◆ K8_SHUFFLE_PERMUTED_RED_TO_BGR1

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR1
初始值:
0x2, -1, -1, 0x3, -1, -1, 0x4, -1, -1, 0x5, -1, -1, 0x6, -1, -1, 0x7, -1,
-1, 0x8, -1, -1, 0x9, -1, -1, 0xA, -1, -1, 0xB, -1, -1, 0xC, -1)

在文件 util.h276 行定义.

◆ K8_SHUFFLE_PERMUTED_RED_TO_BGR2

const __m256i apollo::drivers::camera::K8_SHUFFLE_PERMUTED_RED_TO_BGR2
初始值:
-1, 0x5, -1, -1, 0x6, -1, -1, 0x7, -1, -1, 0x8, -1, -1, 0x9, -1, -1, 0xA,
-1, -1, 0xB, -1, -1, 0xC, -1, -1, 0xD, -1, -1, 0xE, -1, -1, 0xF)

在文件 util.h279 行定义.

◆ K_INV_ZERO

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

在文件 util.h167 行定义.

◆ K_ZERO

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

在文件 util.h166 行定义.

◆ OA

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

在文件 util.h163 行定义.

◆ QA

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

在文件 util.h162 行定义.

◆ U_SHUFFLE0

const __m256i apollo::drivers::camera::U_SHUFFLE0
初始值:
0x1, 0x5, 0x9, 0xd, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x1,
0x5, 0x9, 0xd, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1)

在文件 util.h221 行定义.

◆ U_SHUFFLE1

const __m256i apollo::drivers::camera::U_SHUFFLE1
初始值:
-1, -1, -1, -1, 0x1, 0x5, 0x9, 0xd, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 0x1, 0x5, 0x9, 0xd, -1, -1, -1, -1, -1, -1, -1, -1)

在文件 util.h224 行定义.

◆ U_SHUFFLE2

const __m256i apollo::drivers::camera::U_SHUFFLE2
初始值:
-1, -1, -1, -1, -1, -1, -1, -1, 0x1, 0x5, 0x9, 0xd, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 0x1, 0x5, 0x9, 0xd, -1, -1, -1, -1)

在文件 util.h227 行定义.

◆ U_SHUFFLE3

const __m256i apollo::drivers::camera::U_SHUFFLE3
初始值:
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x1, 0x5, 0x9, 0xd, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x1, 0x5, 0x9, 0xd)

在文件 util.h231 行定义.

◆ U_SHUFFLE4

const __m256i apollo::drivers::camera::U_SHUFFLE4
初始值:
=
SIMD_MM256_SETR_EPI8(0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0,
0x0, 0x5, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x6, 0x0,
0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0)

在文件 util.h234 行定义.

◆ U_TO_BLUE_WEIGHT

const int apollo::drivers::camera::U_TO_BLUE_WEIGHT
初始值:
=
static_cast<int>((2.041 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))
const int YUV_TO_BGR_AVERAGING_SHIFT
Definition util.h:307

在文件 util.h311 行定义.

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

◆ UV_ADJUST

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

在文件 util.h306 行定义.

◆ V_SHUFFLE0

const __m256i apollo::drivers::camera::V_SHUFFLE0
初始值:
0x3, 0x7, 0xb, 0xf, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x3,
0x7, 0xb, 0xf, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1)

在文件 util.h239 行定义.

◆ V_SHUFFLE1

const __m256i apollo::drivers::camera::V_SHUFFLE1
初始值:
-1, -1, -1, -1, 0x3, 0x7, 0xb, 0xf, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 0x3, 0x7, 0xb, 0xf, -1, -1, -1, -1, -1, -1, -1, -1)

在文件 util.h242 行定义.

◆ V_SHUFFLE2

const __m256i apollo::drivers::camera::V_SHUFFLE2
初始值:
-1, -1, -1, -1, -1, -1, -1, -1, 0x3, 0x7, 0xb, 0xf, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 0x3, 0x7, 0xb, 0xf, -1, -1, -1, -1)

在文件 util.h245 行定义.

◆ V_SHUFFLE3

const __m256i apollo::drivers::camera::V_SHUFFLE3
初始值:
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x3, 0x7, 0xb, 0xf, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0x3, 0x7, 0xb, 0xf)

在文件 util.h249 行定义.

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

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

◆ Y_ADJUST

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

在文件 util.h305 行定义.

◆ Y_SHUFFLE0

const __m256i apollo::drivers::camera::Y_SHUFFLE0
初始值:
0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, -1, -1, -1, -1, -1, -1, -1, -1, 0x0,
0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, -1, -1, -1, -1, -1, -1, -1, -1)

在文件 util.h214 行定义.

◆ Y_SHUFFLE1

const __m256i apollo::drivers::camera::Y_SHUFFLE1
初始值:
-1, -1, -1, -1, -1, -1, -1, -1, 0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, -1,
-1, -1, -1, -1, -1, -1, -1, 0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe)

在文件 util.h217 行定义.

◆ Y_TO_RGB_WEIGHT

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

在文件 util.h309 行定义.

◆ YUV_TO_BGR_AVERAGING_SHIFT

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

在文件 util.h307 行定义.

◆ YUV_TO_BGR_ROUND_TERM

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

在文件 util.h308 行定义.