Classes
struct	buffer

class	CameraComponent

struct	CameraImage

class	CompressComponent

class	UsbCam

Typedefs
typedef std::shared_ptr< CameraImage >	CameraImagePtr

Functions
void	yuyv2rgb_avx (unsigned char YUV, unsigned char RGB, int NumPixels)

void	print_m256 (const __m256i a)

void	print_m256_i32 (const __m256i a)

void	print_m256_i16 (const __m256i a)

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)

Variables
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)

Typedef Documentation

◆ CameraImagePtr

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

Function Documentation

◆ AdjustedYuvToBlue16()

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

◆ AdjustedYuvToBlue32()

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

◆ AdjustedYuvToGreen16()

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

◆ AdjustedYuvToGreen32()

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

◆ AdjustedYuvToRed16()

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

◆ AdjustedYuvToRed32()

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

◆ AdjustUV16()

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

◆ AdjustY16()

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

◆ Aligned()

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

◆ AlignLo()

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

◆ BgrToBlue()

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

◆ BgrToGreen()

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

◆ BgrToRed()

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

◆ GetChar()

template<class T >

SIMD_INLINE char apollo::drivers::camera::GetChar	(	T	value,
		size_t	index
	)

◆ 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
	)

◆ InterleaveBgr< 1 >()

template<>

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

◆ InterleaveBgr< 2 >()

template<>

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

◆ 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 )

◆ Load< true >()

template<>

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

◆ LoadPermuted()

template<bool align>

SIMD_INLINE __m256i apollo::drivers::camera::LoadPermuted ( const __m256i * p )

◆ print_m256()

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

◆ print_m256_i16()

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

◆ print_m256_i32()

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

◆ SaturateI16ToU8()

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

◆ 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
	)

◆ Store< true >()

template<>

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

◆ YuvToBlue()

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

◆ YuvToGreen()

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

◆ YuvToRed()

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

◆ yuyv2rgb_avx()

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

Variable Documentation

◆ A

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

◆ DA

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

◆ HA

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

◆ K16_0001

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

◆ K16_0002

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

◆ K16_0003

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

◆ K16_0004

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

◆ K16_0005

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

◆ K16_0006

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

◆ K16_0008

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

◆ K16_0010

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

◆ K16_0018

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

◆ K16_0020

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

◆ K16_0080

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

◆ K16_00FF

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

◆ K16_FF00

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

◆ K16_UB_0

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

◆ K16_UG_VG

const __m256i apollo::drivers::camera::K16_UG_VG

Initial value:

=

SIMD_MM256_SET2_EPI16(U_TO_GREEN_WEIGHT, V_TO_GREEN_WEIGHT)

SIMD_MM256_SET2_EPI16

#define SIMD_MM256_SET2_EPI16(a0, a1)

Definition: util.h:125

apollo::drivers::camera::V_TO_GREEN_WEIGHT

const int V_TO_GREEN_WEIGHT

Definition: util.h:315

apollo::drivers::camera::U_TO_GREEN_WEIGHT

const int U_TO_GREEN_WEIGHT

Definition: util.h:313

◆ K16_UV_ADJUST

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

◆ K16_VR_0

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

◆ K16_Y_ADJUST

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

◆ K16_YRGB_RT

const __m256i apollo::drivers::camera::K16_YRGB_RT

Initial value:

=

SIMD_MM256_SET2_EPI16(Y_TO_RGB_WEIGHT, YUV_TO_BGR_ROUND_TERM)

SIMD_MM256_SET2_EPI16

#define SIMD_MM256_SET2_EPI16(a0, a1)

Definition: util.h:125

apollo::drivers::camera::Y_TO_RGB_WEIGHT

const int Y_TO_RGB_WEIGHT

Definition: util.h:309

apollo::drivers::camera::YUV_TO_BGR_ROUND_TERM

const int YUV_TO_BGR_ROUND_TERM

Definition: util.h:308

◆ K32_00000001

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

◆ K32_00000002

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

◆ K32_00000004

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

◆ K32_00000008

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

◆ K32_000000FF

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

◆ K32_0000FFFF

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

◆ K32_00010000

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

◆ K32_01000000

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

◆ K32_FFFFFF00

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

◆ K8_01

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

◆ K8_01_FF

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

◆ K8_02

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

◆ K8_04

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

◆ K8_08

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

◆ K8_10

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

◆ K8_20

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

◆ K8_40

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

◆ K8_80

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

◆ K8_SHUFFLE_BGR0_TO_BLUE

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    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)

◆ K8_SHUFFLE_BGR0_TO_GREEN

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    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)

◆ K8_SHUFFLE_BGR0_TO_RED

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    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)

◆ K8_SHUFFLE_BGR1_TO_BLUE

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ K8_SHUFFLE_BGR1_TO_GREEN

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ K8_SHUFFLE_BGR1_TO_RED

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ K8_SHUFFLE_BGR2_TO_BLUE

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ K8_SHUFFLE_BGR2_TO_GREEN

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ K8_SHUFFLE_BGR2_TO_RED

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ K8_SHUFFLE_PERMUTED_BLUE_TO_BGR0

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    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)

◆ K8_SHUFFLE_PERMUTED_BLUE_TO_BGR1

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ K8_SHUFFLE_PERMUTED_BLUE_TO_BGR2

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ K8_SHUFFLE_PERMUTED_GREEN_TO_BGR0

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ K8_SHUFFLE_PERMUTED_GREEN_TO_BGR1

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ K8_SHUFFLE_PERMUTED_GREEN_TO_BGR2

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    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)

◆ K8_SHUFFLE_PERMUTED_RED_TO_BGR0

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ K8_SHUFFLE_PERMUTED_RED_TO_BGR1

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    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)

◆ K8_SHUFFLE_PERMUTED_RED_TO_BGR2

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ K_INV_ZERO

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

◆ K_ZERO

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

◆ OA

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

◆ QA

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

◆ U_SHUFFLE0

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    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)

◆ U_SHUFFLE1

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ U_SHUFFLE2

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ U_SHUFFLE3

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ U_SHUFFLE4

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

Initial value:

=
    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)

◆ U_TO_BLUE_WEIGHT

const int apollo::drivers::camera::U_TO_BLUE_WEIGHT

Initial value:

=

static_cast<int>((2.041 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))

apollo::drivers::camera::YUV_TO_BGR_AVERAGING_SHIFT

const int YUV_TO_BGR_AVERAGING_SHIFT

Definition: util.h:307

◆ U_TO_GREEN_WEIGHT

const int apollo::drivers::camera::U_TO_GREEN_WEIGHT

Initial value:

=

-static_cast<int>((0.3455 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))

apollo::drivers::camera::YUV_TO_BGR_AVERAGING_SHIFT

const int YUV_TO_BGR_AVERAGING_SHIFT

Definition: util.h:307

◆ UV_ADJUST

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

◆ V_SHUFFLE0

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    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)

◆ V_SHUFFLE1

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ V_SHUFFLE2

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ V_SHUFFLE3

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ V_TO_GREEN_WEIGHT

const int apollo::drivers::camera::V_TO_GREEN_WEIGHT

Initial value:

=

-static_cast<int>((0.7169 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))

apollo::drivers::camera::YUV_TO_BGR_AVERAGING_SHIFT

const int YUV_TO_BGR_AVERAGING_SHIFT

Definition: util.h:307

◆ V_TO_RED_WEIGHT

const int apollo::drivers::camera::V_TO_RED_WEIGHT

Initial value:

=

static_cast<int>((1.4065 * (1 << YUV_TO_BGR_AVERAGING_SHIFT)))

apollo::drivers::camera::YUV_TO_BGR_AVERAGING_SHIFT

const int YUV_TO_BGR_AVERAGING_SHIFT

Definition: util.h:307

◆ Y_ADJUST

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

◆ Y_SHUFFLE0

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    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)

◆ Y_SHUFFLE1

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

Initial value:

= SIMD_MM256_SETR_EPI8(
    -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)

◆ Y_TO_RGB_WEIGHT

const int apollo::drivers::camera::Y_TO_RGB_WEIGHT

Initial value:

=

static_cast<int>((((1 << YUV_TO_BGR_AVERAGING_SHIFT))))

apollo::drivers::camera::YUV_TO_BGR_AVERAGING_SHIFT

const int YUV_TO_BGR_AVERAGING_SHIFT

Definition: util.h:307

◆ YUV_TO_BGR_AVERAGING_SHIFT

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

◆ YUV_TO_BGR_ROUND_TERM

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

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ CameraImagePtr

Function Documentation

◆ AdjustedYuvToBlue16()

◆ AdjustedYuvToBlue32()

◆ AdjustedYuvToGreen16()

◆ AdjustedYuvToGreen32()

◆ AdjustedYuvToRed16()

◆ AdjustedYuvToRed32()

◆ AdjustUV16()

◆ AdjustY16()

◆ Aligned()

◆ AlignLo()

◆ BgrToBlue()

◆ BgrToGreen()

◆ BgrToRed()

◆ GetChar()

◆ InterleaveBgr()

◆ InterleaveBgr< 0 >()

◆ InterleaveBgr< 1 >()

◆ InterleaveBgr< 2 >()

◆ Load()

◆ Load< false >()

◆ Load< true >()

◆ LoadPermuted()

◆ print_m256()

◆ print_m256_i16()

◆ print_m256_i32()

◆ SaturateI16ToU8()

◆ Store()

◆ Store< false >()

◆ Store< true >()

◆ YuvToBlue()

◆ YuvToGreen()

◆ YuvToRed()

◆ yuyv2rgb_avx()

Variable Documentation

◆ A

◆ DA

◆ HA

◆ K16_0001

◆ K16_0002

◆ K16_0003

◆ K16_0004

◆ K16_0005

◆ K16_0006

◆ K16_0008

◆ K16_0010

◆ K16_0018

◆ K16_0020

◆ K16_0080

◆ K16_00FF

◆ K16_FF00

◆ K16_UB_0

◆ K16_UG_VG

◆ K16_UV_ADJUST

◆ K16_VR_0

◆ K16_Y_ADJUST

◆ K16_YRGB_RT

◆ K32_00000001

◆ K32_00000002

◆ K32_00000004

◆ K32_00000008

◆ K32_000000FF

◆ K32_0000FFFF

◆ K32_00010000

◆ K32_01000000

◆ K32_FFFFFF00

◆ K8_01

◆ K8_01_FF

◆ K8_02

◆ K8_04

◆ K8_08

◆ K8_10

◆ K8_20

◆ K8_40