Namespaces
namespace	detail

Classes
struct	vec128_int
	Portable 128-bit integer vector wrapper. More...

struct	vec256_int
	Portable 256-bit integer vector wrapper. More...

class	window_level_lut
	Precomputed LUT for fast repeated window/level application. More...

struct	window_level_params
	Window/Level parameters. More...

Enumerations
enum class	simd_feature : uint32_t { none = 0 , sse2 = 1 << 0 , ssse3 = 1 << 1 , sse41 = 1 << 2 , avx = 1 << 3 , avx2 = 1 << 4 , avx512f = 1 << 5 , neon = 1 << 6 }
	SIMD feature flags for runtime detection. More...

Functions
constexpr simd_feature	operator\| (simd_feature a, simd_feature b) noexcept
	Bitwise OR for simd_feature flags.

constexpr simd_feature	operator& (simd_feature a, simd_feature b) noexcept
	Bitwise AND for simd_feature flags.

constexpr bool	has_feature (simd_feature features, simd_feature check) noexcept
	Check if a specific feature is set.

simd_feature	detect_features () noexcept
	Detect available SIMD features at runtime.

simd_feature	get_features () noexcept
	Get cached SIMD features (singleton pattern)

bool	has_sse2 () noexcept
	Check if SSE2 is available.

bool	has_ssse3 () noexcept
	Check if SSSE3 is available.

bool	has_sse41 () noexcept
	Check if SSE4.1 is available.

bool	has_avx () noexcept
	Check if AVX is available.

bool	has_avx2 () noexcept
	Check if AVX2 is available.

bool	has_avx512f () noexcept
	Check if AVX-512F is available.

bool	has_neon () noexcept
	Check if NEON is available.

size_t	optimal_vector_width () noexcept
	Get optimal vector width in bytes for current CPU.

void	invert_monochrome_8bit (const uint8_t src, uint8_t dst, size_t pixel_count) noexcept
	Invert 8-bit monochrome pixels (MONOCHROME1 <-> MONOCHROME2)

void	invert_monochrome_16bit (const uint16_t src, uint16_t dst, size_t pixel_count, uint16_t max_value) noexcept
	Invert 16-bit monochrome pixels.

void	rgb_to_ycbcr_8bit (const uint8_t src, uint8_t dst, size_t pixel_count) noexcept
	Convert RGB to YCbCr color space (ITU-R BT.601)

void	ycbcr_to_rgb_8bit (const uint8_t src, uint8_t dst, size_t pixel_count) noexcept
	Convert YCbCr to RGB color space (ITU-R BT.601)

void	interleaved_to_planar_rgb8 (const uint8_t src, uint8_t r, uint8_t g, uint8_t b, size_t pixel_count) noexcept
	Convert interleaved RGB to planar format using best available SIMD.

void	planar_to_interleaved_rgb8 (const uint8_t r, const uint8_t g, const uint8_t b, uint8_t dst, size_t pixel_count) noexcept
	Convert planar RGB to interleaved format using best available SIMD.

void	split_16bit_to_planes (const uint8_t src, uint8_t high, uint8_t *low, size_t pixel_count) noexcept
	Split 16-bit data into high and low byte planes.

void	merge_planes_to_16bit (const uint8_t high, const uint8_t low, uint8_t *dst, size_t pixel_count) noexcept
	Merge high and low byte planes into 16-bit data.

template<size_t Alignment>
constexpr bool	is_aligned (const void *ptr) noexcept
	Check if a pointer is aligned to the specified boundary.

template<size_t Alignment>
constexpr size_t	align_offset (const void *ptr) noexcept
	Get the aligned portion start offset.

void	swap_bytes_16_simd (const uint8_t src, uint8_t dst, size_t byte_count) noexcept
	Swap bytes in 16-bit words using best available SIMD.

void	swap_bytes_32_simd (const uint8_t src, uint8_t dst, size_t byte_count) noexcept
	Swap bytes in 32-bit words using best available SIMD.

void	swap_bytes_64_simd (const uint8_t src, uint8_t dst, size_t byte_count) noexcept
	Swap bytes in 64-bit words using best available SIMD.

void	apply_window_level_8bit (const uint8_t src, uint8_t dst, size_t pixel_count, const window_level_params &params) noexcept
	Apply window/level transformation to 8-bit grayscale data.

void	apply_window_level_16bit (const uint16_t src, uint8_t dst, size_t pixel_count, const window_level_params &params) noexcept
	Apply window/level transformation to 16-bit unsigned grayscale data.

void	apply_window_level_16bit_signed (const int16_t src, uint8_t dst, size_t pixel_count, const window_level_params &params) noexcept
	Apply window/level transformation to 16-bit signed grayscale data.

Variables
constexpr size_t	SSE_ALIGNMENT = 16

constexpr size_t	AVX_ALIGNMENT = 32

constexpr size_t	AVX512_ALIGNMENT = 64

Enumeration Type Documentation

◆ simd_feature

enum class kcenon::pacs::encoding::simd::simd_feature : uint32_t

strong

SIMD feature flags for runtime detection.

Enumerator
none
sse2
ssse3
sse41
avx
avx2
avx512f
neon

Definition at line 87 of file simd_config.h.

                        : uint32_t {
    none = 0,
    sse2 = 1 << 0,
    ssse3 = 1 << 1,
    sse41 = 1 << 2,
    avx = 1 << 3,
    avx2 = 1 << 4,
    avx512f = 1 << 5,
    neon = 1 << 6
};

Function Documentation

◆ align_offset()

template<size_t Alignment>

size_t kcenon::pacs::encoding::simd::align_offset ( const void * ptr )

nodiscardconstexprnoexcept

Get the aligned portion start offset.

Definition at line 219 of file simd_types.h.

                                                                      {
    const auto addr = reinterpret_cast<uintptr_t>(ptr);
    const auto remainder = addr % Alignment;
    return remainder == 0 ? 0 : Alignment - remainder;
}

References align_offset().

Referenced by align_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_window_level_16bit()

void kcenon::pacs::encoding::simd::apply_window_level_16bit	(	const uint16_t *	src,
		uint8_t *	dst,
		size_t	pixel_count,
		const window_level_params &	params )

inlinenoexcept

Apply window/level transformation to 16-bit unsigned grayscale data.

Parameters

src	Source pixel data (16-bit unsigned grayscale)
dst	Destination pixel data (8-bit display values)
pixel_count	Number of pixels to process
params	Window/level parameters

Definition at line 860 of file simd_windowing.h.

                                                                                  {
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::apply_window_level_16bit_avx2(src, dst, pixel_count, params);
        return;
    }
#endif
#if defined(PACS_SIMD_SSE2)
    if (has_sse2()) {
        detail::apply_window_level_16bit_sse2(src, dst, pixel_count, params);
        return;
    }
#endif
#if defined(PACS_SIMD_NEON)
    if (has_neon()) {
        detail::apply_window_level_16bit_neon(src, dst, pixel_count, params);
        return;
    }
#endif
    detail::apply_window_level_16bit_scalar(src, dst, pixel_count, params);
}

References kcenon::pacs::encoding::simd::detail::apply_window_level_16bit_scalar(), has_avx2(), has_neon(), and has_sse2().

Here is the call graph for this function:

◆ apply_window_level_16bit_signed()

void kcenon::pacs::encoding::simd::apply_window_level_16bit_signed	(	const int16_t *	src,
		uint8_t *	dst,
		size_t	pixel_count,
		const window_level_params &	params )

inlinenoexcept

Apply window/level transformation to 16-bit signed grayscale data.

Handles signed pixel data commonly found in CT images.

Parameters

src	Source pixel data (16-bit signed grayscale)
dst	Destination pixel data (8-bit display values)
pixel_count	Number of pixels to process
params	Window/level parameters

Definition at line 894 of file simd_windowing.h.

                                                                                         {
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::apply_window_level_16bit_signed_avx2(src, dst, pixel_count, params);
        return;
    }
#endif
#if defined(PACS_SIMD_SSE2)
    if (has_sse2()) {
        detail::apply_window_level_16bit_signed_sse2(src, dst, pixel_count, params);
        return;
    }
#endif
#if defined(PACS_SIMD_NEON)
    if (has_neon()) {
        detail::apply_window_level_16bit_signed_neon(src, dst, pixel_count, params);
        return;
    }
#endif
    detail::apply_window_level_16bit_signed_scalar(src, dst, pixel_count, params);
}

References kcenon::pacs::encoding::simd::detail::apply_window_level_16bit_signed_scalar(), has_avx2(), has_neon(), and has_sse2().

Here is the call graph for this function:

◆ apply_window_level_8bit()

void kcenon::pacs::encoding::simd::apply_window_level_8bit	(	const uint8_t *	src,
		uint8_t *	dst,
		size_t	pixel_count,
		const window_level_params &	params )

inlinenoexcept

Apply window/level transformation to 8-bit grayscale data.

Maps input pixel values to output values based on window center and width. Uses SIMD when available for better performance.

Parameters

src	Source pixel data (8-bit grayscale)
dst	Destination pixel data (8-bit display values)
pixel_count	Number of pixels to process
params	Window/level parameters

Definition at line 828 of file simd_windowing.h.

                                                                                 {
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::apply_window_level_8bit_avx2(src, dst, pixel_count, params);
        return;
    }
#endif
#if defined(PACS_SIMD_SSE2)
    if (has_sse2()) {
        detail::apply_window_level_8bit_sse2(src, dst, pixel_count, params);
        return;
    }
#endif
#if defined(PACS_SIMD_NEON)
    if (has_neon()) {
        detail::apply_window_level_8bit_neon(src, dst, pixel_count, params);
        return;
    }
#endif
    detail::apply_window_level_8bit_scalar(src, dst, pixel_count, params);
}

References kcenon::pacs::encoding::simd::detail::apply_window_level_8bit_scalar(), has_avx2(), has_neon(), and has_sse2().

Here is the call graph for this function:

◆ detect_features()

simd_feature kcenon::pacs::encoding::simd::detect_features ( )

inlinenodiscardnoexcept

Detect available SIMD features at runtime.

Returns: Bitwise OR of available simd_feature flags

Definition at line 164 of file simd_config.h.

                                                             {
    simd_feature features = simd_feature::none;
 
#if defined(PACS_ARCH_X64) || defined(PACS_ARCH_X86)
    int info[4] = {0};
 
    // Check basic CPUID
    detail::cpuid(info, 0);
    int max_function = info[0];
 
    if (max_function >= 1) {
        detail::cpuid(info, 1);
 
        // EDX features
        if (info[3] & (1 << 26)) {
            features = features | simd_feature::sse2;
        }
 
        // ECX features
        if (info[2] & (1 << 0)) {
            features = features | simd_feature::ssse3;
        }
        if (info[2] & (1 << 19)) {
            features = features | simd_feature::sse41;
        }
        if (info[2] & (1 << 28)) {
            features = features | simd_feature::avx;
        }
    }
 
    if (max_function >= 7) {
        detail::cpuid_ex(info, 7, 0);
 
        // EBX features
        if (info[1] & (1 << 5)) {
            features = features | simd_feature::avx2;
        }
        if (info[1] & (1 << 16)) {
            features = features | simd_feature::avx512f;
        }
    }
 
#elif defined(PACS_ARCH_ARM64)
    // ARM64 always has NEON
    features = features | simd_feature::neon;
 
#elif defined(PACS_ARCH_ARM32)
    // ARM32: Check for NEON via auxiliary vector or runtime detection
    // For simplicity, assume NEON is available if compiled with NEON support
#if defined(PACS_SIMD_NEON)
    features = features | simd_feature::neon;
#endif
 
#endif  // Architecture
 
    return features;
}

References avx, avx2, avx512f, neon, none, sse2, sse41, and ssse3.

Referenced by get_features().

Here is the caller graph for this function:

◆ get_features()

simd_feature kcenon::pacs::encoding::simd::get_features ( )

inlinenodiscardnoexcept

Get cached SIMD features (singleton pattern)

Returns: Detected SIMD features

Definition at line 226 of file simd_config.h.

                                                          {
    static const simd_feature features = detect_features();
    return features;
}

References detect_features().

Referenced by has_avx(), has_avx2(), has_avx512f(), has_neon(), has_sse2(), has_sse41(), and has_ssse3().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_avx()

bool kcenon::pacs::encoding::simd::has_avx ( )

inlinenodiscardnoexcept

Check if AVX is available.

Definition at line 255 of file simd_config.h.

                                             {
    return has_feature(get_features(), simd_feature::avx);
}

References avx, get_features(), and has_feature().

Here is the call graph for this function:

◆ has_avx2()

bool kcenon::pacs::encoding::simd::has_avx2 ( )

inlinenodiscardnoexcept

Check if AVX2 is available.

Definition at line 262 of file simd_config.h.

                                              {
    return has_feature(get_features(), simd_feature::avx2);
}

References avx2, get_features(), and has_feature().

Referenced by apply_window_level_16bit(), apply_window_level_16bit_signed(), apply_window_level_8bit(), interleaved_to_planar_rgb8(), invert_monochrome_16bit(), invert_monochrome_8bit(), merge_planes_to_16bit(), optimal_vector_width(), planar_to_interleaved_rgb8(), rgb_to_ycbcr_8bit(), split_16bit_to_planes(), swap_bytes_16_simd(), swap_bytes_32_simd(), swap_bytes_64_simd(), and ycbcr_to_rgb_8bit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_avx512f()

bool kcenon::pacs::encoding::simd::has_avx512f ( )

inlinenodiscardnoexcept

Check if AVX-512F is available.

Definition at line 269 of file simd_config.h.

                                                 {
    return has_feature(get_features(), simd_feature::avx512f);
}

References avx512f, get_features(), and has_feature().

Referenced by optimal_vector_width().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_feature()

bool kcenon::pacs::encoding::simd::has_feature	(	simd_feature	features,
		simd_feature	check )

nodiscardconstexprnoexcept

Check if a specific feature is set.

Definition at line 119 of file simd_config.h.

                                                                      {
    return (features & check) == check;
}

Referenced by has_avx(), has_avx2(), has_avx512f(), has_neon(), has_sse2(), has_sse41(), and has_ssse3().

Here is the caller graph for this function:

◆ has_neon()

bool kcenon::pacs::encoding::simd::has_neon ( )

inlinenodiscardnoexcept

Check if NEON is available.

Definition at line 276 of file simd_config.h.

                                              {
    return has_feature(get_features(), simd_feature::neon);
}

References get_features(), has_feature(), and neon.

Referenced by apply_window_level_16bit(), apply_window_level_16bit_signed(), apply_window_level_8bit(), invert_monochrome_16bit(), invert_monochrome_8bit(), optimal_vector_width(), rgb_to_ycbcr_8bit(), and ycbcr_to_rgb_8bit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_sse2()

bool kcenon::pacs::encoding::simd::has_sse2 ( )

inlinenodiscardnoexcept

Check if SSE2 is available.

Definition at line 234 of file simd_config.h.

                                              {
    return has_feature(get_features(), simd_feature::sse2);
}

References get_features(), has_feature(), and sse2.

Referenced by apply_window_level_16bit(), apply_window_level_16bit_signed(), apply_window_level_8bit(), invert_monochrome_16bit(), invert_monochrome_8bit(), and optimal_vector_width().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_sse41()

bool kcenon::pacs::encoding::simd::has_sse41 ( )

inlinenodiscardnoexcept

Check if SSE4.1 is available.

Definition at line 248 of file simd_config.h.

                                               {
    return has_feature(get_features(), simd_feature::sse41);
}

References get_features(), has_feature(), and sse41.

Here is the call graph for this function:

◆ has_ssse3()

bool kcenon::pacs::encoding::simd::has_ssse3 ( )

inlinenodiscardnoexcept

Check if SSSE3 is available.

Definition at line 241 of file simd_config.h.

                                               {
    return has_feature(get_features(), simd_feature::ssse3);
}

References get_features(), has_feature(), and ssse3.

Referenced by interleaved_to_planar_rgb8(), merge_planes_to_16bit(), planar_to_interleaved_rgb8(), split_16bit_to_planes(), swap_bytes_16_simd(), swap_bytes_32_simd(), and swap_bytes_64_simd().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ interleaved_to_planar_rgb8()

void kcenon::pacs::encoding::simd::interleaved_to_planar_rgb8	(	const uint8_t *	src,
		uint8_t *	r,
		uint8_t *	g,
		uint8_t *	b,
		size_t	pixel_count )

inlinenoexcept

Convert interleaved RGB to planar format using best available SIMD.

Parameters

src	Source interleaved RGB data (RGBRGBRGB...)
r	Destination R plane
g	Destination G plane
b	Destination B plane
pixel_count	Number of pixels to convert

Definition at line 725 of file simd_rle.h.

                                                                     {
    if (pixel_count == 0) {
        return;
    }
 
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::interleaved_to_planar_rgb8_avx2(src, r, g, b, pixel_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_SSSE3)
    if (has_ssse3()) {
        detail::interleaved_to_planar_rgb8_ssse3(src, r, g, b, pixel_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_NEON)
    detail::interleaved_to_planar_rgb8_neon(src, r, g, b, pixel_count);
    return;
#endif
 
    detail::interleaved_to_planar_rgb8_scalar(src, r, g, b, pixel_count);
}

References has_avx2(), has_ssse3(), and kcenon::pacs::encoding::simd::detail::interleaved_to_planar_rgb8_scalar().

Referenced by kcenon::pacs::encoding::compression::rle_codec::impl::encode_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ invert_monochrome_16bit()

void kcenon::pacs::encoding::simd::invert_monochrome_16bit	(	const uint16_t *	src,
		uint16_t *	dst,
		size_t	pixel_count,
		uint16_t	max_value )

inlinenoexcept

Invert 16-bit monochrome pixels.

Parameters

src	Source pixel data
dst	Destination pixel data
pixel_count	Number of pixels to process
max_value	Maximum pixel value (e.g., 4095 for 12-bit, 65535 for 16-bit)

Definition at line 621 of file simd_photometric.h.

                                                                  {
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::invert_monochrome_16bit_avx2(src, dst, pixel_count, max_value);
        return;
    }
#endif
#if defined(PACS_SIMD_SSE2)
    if (has_sse2()) {
        detail::invert_monochrome_16bit_sse2(src, dst, pixel_count, max_value);
        return;
    }
#endif
#if defined(PACS_SIMD_NEON)
    if (has_neon()) {
        detail::invert_monochrome_16bit_neon(src, dst, pixel_count, max_value);
        return;
    }
#endif
    detail::invert_monochrome_16bit_scalar(src, dst, pixel_count, max_value);
}

References has_avx2(), has_neon(), has_sse2(), and kcenon::pacs::encoding::simd::detail::invert_monochrome_16bit_scalar().

Here is the call graph for this function:

◆ invert_monochrome_8bit()

void kcenon::pacs::encoding::simd::invert_monochrome_8bit	(	const uint8_t *	src,
		uint8_t *	dst,
		size_t	pixel_count )

inlinenoexcept

Invert 8-bit monochrome pixels (MONOCHROME1 <-> MONOCHROME2)

Converts between MONOCHROME1 (white = 0) and MONOCHROME2 (white = max). Uses SIMD when available for better performance.

Parameters

src	Source pixel data
dst	Destination pixel data (can be same as src for in-place)
pixel_count	Number of pixels to process

Definition at line 590 of file simd_photometric.h.

                                                                 {
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::invert_monochrome_8bit_avx2(src, dst, pixel_count);
        return;
    }
#endif
#if defined(PACS_SIMD_SSE2)
    if (has_sse2()) {
        detail::invert_monochrome_8bit_sse2(src, dst, pixel_count);
        return;
    }
#endif
#if defined(PACS_SIMD_NEON)
    if (has_neon()) {
        detail::invert_monochrome_8bit_neon(src, dst, pixel_count);
        return;
    }
#endif
    detail::invert_monochrome_8bit_scalar(src, dst, pixel_count);
}

References has_avx2(), has_neon(), has_sse2(), and kcenon::pacs::encoding::simd::detail::invert_monochrome_8bit_scalar().

Here is the call graph for this function:

◆ is_aligned()

template<size_t Alignment>

bool kcenon::pacs::encoding::simd::is_aligned ( const void * ptr )

nodiscardconstexprnoexcept

Check if a pointer is aligned to the specified boundary.

Definition at line 211 of file simd_types.h.

                                                                  {
    return (reinterpret_cast<uintptr_t>(ptr) % Alignment) == 0;
}

References is_aligned().

Referenced by is_aligned().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ merge_planes_to_16bit()

void kcenon::pacs::encoding::simd::merge_planes_to_16bit	(	const uint8_t *	high,
		const uint8_t *	low,
		uint8_t *	dst,
		size_t	pixel_count )

inlinenoexcept

Merge high and low byte planes into 16-bit data.

Parameters

high	Source high byte plane
low	Source low byte plane
dst	Destination 16-bit little-endian data
pixel_count	Number of 16-bit values to merge

Definition at line 837 of file simd_rle.h.

                                                                {
    if (pixel_count == 0) {
        return;
    }
 
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::merge_planes_to_16bit_avx2(high, low, dst, pixel_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_SSSE3)
    if (has_ssse3()) {
        detail::merge_planes_to_16bit_ssse3(high, low, dst, pixel_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_NEON)
    detail::merge_planes_to_16bit_neon(high, low, dst, pixel_count);
    return;
#endif
 
    detail::merge_planes_to_16bit_scalar(high, low, dst, pixel_count);
}

References has_avx2(), has_ssse3(), and kcenon::pacs::encoding::simd::detail::merge_planes_to_16bit_scalar().

Referenced by kcenon::pacs::encoding::compression::rle_codec::impl::decode_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator&()

simd_feature kcenon::pacs::encoding::simd::operator&	(	simd_feature	a,
		simd_feature	b )

nodiscardconstexprnoexcept

Bitwise AND for simd_feature flags.

Definition at line 110 of file simd_config.h.

                                                                        {
    return static_cast<simd_feature>(static_cast<uint32_t>(a) &
                                     static_cast<uint32_t>(b));
}

◆ operator|()

simd_feature kcenon::pacs::encoding::simd::operator\|	(	simd_feature	a,
		simd_feature	b )

nodiscardconstexprnoexcept

Bitwise OR for simd_feature flags.

Definition at line 101 of file simd_config.h.

                                                                        {
    return static_cast<simd_feature>(static_cast<uint32_t>(a) |
                                     static_cast<uint32_t>(b));
}

◆ optimal_vector_width()

size_t kcenon::pacs::encoding::simd::optimal_vector_width ( )

inlinenodiscardnoexcept

Get optimal vector width in bytes for current CPU.

Returns: Vector width (16 for SSE/NEON, 32 for AVX2, 64 for AVX-512)

Definition at line 284 of file simd_config.h.

                                                            {
    if (has_avx512f()) {
        return 64;
    }
    if (has_avx2()) {
        return 32;
    }
    if (has_sse2() || has_neon()) {
        return 16;
    }
    return 0;  // No SIMD
}

References has_avx2(), has_avx512f(), has_neon(), and has_sse2().

Here is the call graph for this function:

◆ planar_to_interleaved_rgb8()

void kcenon::pacs::encoding::simd::planar_to_interleaved_rgb8	(	const uint8_t *	r,
		const uint8_t *	g,
		const uint8_t *	b,
		uint8_t *	dst,
		size_t	pixel_count )

inlinenoexcept

Convert planar RGB to interleaved format using best available SIMD.

Parameters

r	Source R plane
g	Source G plane
b	Source B plane
dst	Destination interleaved RGB data (RGBRGBRGB...)
pixel_count	Number of pixels to convert

Definition at line 763 of file simd_rle.h.

                                                                     {
    if (pixel_count == 0) {
        return;
    }
 
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::planar_to_interleaved_rgb8_avx2(r, g, b, dst, pixel_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_SSSE3)
    if (has_ssse3()) {
        detail::planar_to_interleaved_rgb8_ssse3(r, g, b, dst, pixel_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_NEON)
    detail::planar_to_interleaved_rgb8_neon(r, g, b, dst, pixel_count);
    return;
#endif
 
    detail::planar_to_interleaved_rgb8_scalar(r, g, b, dst, pixel_count);
}

References has_avx2(), has_ssse3(), and kcenon::pacs::encoding::simd::detail::planar_to_interleaved_rgb8_scalar().

Referenced by kcenon::pacs::encoding::compression::rle_codec::impl::decode_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rgb_to_ycbcr_8bit()

void kcenon::pacs::encoding::simd::rgb_to_ycbcr_8bit	(	const uint8_t *	src,
		uint8_t *	dst,
		size_t	pixel_count )

inlinenoexcept

Convert RGB to YCbCr color space (ITU-R BT.601)

Parameters

src	Source RGB pixel data (interleaved RGBRGB...)
dst	Destination YCbCr pixel data (interleaved YCbCrYCbCr...)
pixel_count	Number of pixels to process

Definition at line 652 of file simd_photometric.h.

                                                            {
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::rgb_to_ycbcr_8bit_avx2(src, dst, pixel_count);
        return;
    }
#endif
#if defined(PACS_SIMD_NEON)
    if (has_neon()) {
        detail::rgb_to_ycbcr_8bit_neon(src, dst, pixel_count);
        return;
    }
#endif
    detail::rgb_to_ycbcr_8bit_scalar(src, dst, pixel_count);
}

References has_avx2(), has_neon(), and kcenon::pacs::encoding::simd::detail::rgb_to_ycbcr_8bit_scalar().

Here is the call graph for this function:

◆ split_16bit_to_planes()

void kcenon::pacs::encoding::simd::split_16bit_to_planes	(	const uint8_t *	src,
		uint8_t *	high,
		uint8_t *	low,
		size_t	pixel_count )

inlinenoexcept

Split 16-bit data into high and low byte planes.

Parameters

src	Source 16-bit little-endian data
high	Destination high byte plane
low	Destination low byte plane
pixel_count	Number of 16-bit values to split

Definition at line 800 of file simd_rle.h.

                                                                {
    if (pixel_count == 0) {
        return;
    }
 
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::split_16bit_to_planes_avx2(src, high, low, pixel_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_SSSE3)
    if (has_ssse3()) {
        detail::split_16bit_to_planes_ssse3(src, high, low, pixel_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_NEON)
    detail::split_16bit_to_planes_neon(src, high, low, pixel_count);
    return;
#endif
 
    detail::split_16bit_to_planes_scalar(src, high, low, pixel_count);
}

References has_avx2(), has_ssse3(), and kcenon::pacs::encoding::simd::detail::split_16bit_to_planes_scalar().

Referenced by kcenon::pacs::encoding::compression::rle_codec::impl::encode_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ swap_bytes_16_simd()

void kcenon::pacs::encoding::simd::swap_bytes_16_simd	(	const uint8_t *	src,
		uint8_t *	dst,
		size_t	byte_count )

inlinenoexcept

Swap bytes in 16-bit words using best available SIMD.

Parameters

src	Source data pointer
dst	Destination data pointer
byte_count	Number of bytes (should be even)

Definition at line 278 of file simd_utils.h.

                                                           {
    if (byte_count < 2) {
        return;
    }
 
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::swap_bytes_16_avx2(src, dst, byte_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_SSSE3)
    if (has_ssse3()) {
        detail::swap_bytes_16_ssse3(src, dst, byte_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_NEON)
    detail::swap_bytes_16_neon(src, dst, byte_count);
    return;
#endif
 
    detail::swap_bytes_16_scalar(src, dst, byte_count);
}

References has_avx2(), has_ssse3(), and kcenon::pacs::encoding::simd::detail::swap_bytes_16_scalar().

Referenced by kcenon::pacs::encoding::swap_ow_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ swap_bytes_32_simd()

void kcenon::pacs::encoding::simd::swap_bytes_32_simd	(	const uint8_t *	src,
		uint8_t *	dst,
		size_t	byte_count )

inlinenoexcept

Swap bytes in 32-bit words using best available SIMD.

Parameters

src	Source data pointer
dst	Destination data pointer
byte_count	Number of bytes (should be multiple of 4)

Definition at line 312 of file simd_utils.h.

                                                           {
    if (byte_count < 4) {
        return;
    }
 
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::swap_bytes_32_avx2(src, dst, byte_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_SSSE3)
    if (has_ssse3()) {
        detail::swap_bytes_32_ssse3(src, dst, byte_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_NEON)
    detail::swap_bytes_32_neon(src, dst, byte_count);
    return;
#endif
 
    detail::swap_bytes_32_scalar(src, dst, byte_count);
}

References has_avx2(), has_ssse3(), and kcenon::pacs::encoding::simd::detail::swap_bytes_32_scalar().

Referenced by kcenon::pacs::encoding::swap_ol_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ swap_bytes_64_simd()

void kcenon::pacs::encoding::simd::swap_bytes_64_simd	(	const uint8_t *	src,
		uint8_t *	dst,
		size_t	byte_count )

inlinenoexcept

Swap bytes in 64-bit words using best available SIMD.

Parameters

src	Source data pointer
dst	Destination data pointer
byte_count	Number of bytes (should be multiple of 8)

Definition at line 346 of file simd_utils.h.

                                                           {
    if (byte_count < 8) {
        return;
    }
 
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::swap_bytes_64_avx2(src, dst, byte_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_SSSE3)
    if (has_ssse3()) {
        detail::swap_bytes_64_ssse3(src, dst, byte_count);
        return;
    }
#endif
 
#if defined(PACS_SIMD_NEON)
    detail::swap_bytes_64_neon(src, dst, byte_count);
    return;
#endif
 
    detail::swap_bytes_64_scalar(src, dst, byte_count);
}

References has_avx2(), has_ssse3(), and kcenon::pacs::encoding::simd::detail::swap_bytes_64_scalar().

Referenced by kcenon::pacs::encoding::swap_od_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ycbcr_to_rgb_8bit()

void kcenon::pacs::encoding::simd::ycbcr_to_rgb_8bit	(	const uint8_t *	src,
		uint8_t *	dst,
		size_t	pixel_count )

inlinenoexcept

Convert YCbCr to RGB color space (ITU-R BT.601)

Parameters

src	Source YCbCr pixel data (interleaved YCbCrYCbCr...)
dst	Destination RGB pixel data (interleaved RGBRGB...)
pixel_count	Number of pixels to process

Definition at line 676 of file simd_photometric.h.

                                                            {
#if defined(PACS_SIMD_AVX2)
    if (has_avx2()) {
        detail::ycbcr_to_rgb_8bit_avx2(src, dst, pixel_count);
        return;
    }
#endif
#if defined(PACS_SIMD_NEON)
    if (has_neon()) {
        detail::ycbcr_to_rgb_8bit_neon(src, dst, pixel_count);
        return;
    }
#endif
    detail::ycbcr_to_rgb_8bit_scalar(src, dst, pixel_count);
}

References has_avx2(), has_neon(), and kcenon::pacs::encoding::simd::detail::ycbcr_to_rgb_8bit_scalar().

Here is the call graph for this function:

Variable Documentation

◆ AVX512_ALIGNMENT

size_t kcenon::pacs::encoding::simd::AVX512_ALIGNMENT = 64

constexpr

Definition at line 28 of file simd_types.h.

◆ AVX_ALIGNMENT

size_t kcenon::pacs::encoding::simd::AVX_ALIGNMENT = 32

constexpr

Definition at line 27 of file simd_types.h.

◆ SSE_ALIGNMENT

size_t kcenon::pacs::encoding::simd::SSE_ALIGNMENT = 16

constexpr

Definition at line 26 of file simd_types.h.

Namespaces

Classes

Enumerations

Functions

Variables

Enumeration Type Documentation

◆ simd_feature

Function Documentation

◆ align_offset()

◆ apply_window_level_16bit()

◆ apply_window_level_16bit_signed()

◆ apply_window_level_8bit()

◆ detect_features()

◆ get_features()

◆ has_avx()

◆ has_avx2()

◆ has_avx512f()

◆ has_feature()

◆ has_neon()

◆ has_sse2()

◆ has_sse41()

◆ has_ssse3()

◆ interleaved_to_planar_rgb8()

◆ invert_monochrome_16bit()

◆ invert_monochrome_8bit()

◆ is_aligned()

◆ merge_planes_to_16bit()

◆ operator&()

◆ operator|()

◆ optimal_vector_width()

◆ planar_to_interleaved_rgb8()

◆ rgb_to_ycbcr_8bit()

◆ split_16bit_to_planes()

◆ swap_bytes_16_simd()

◆ swap_bytes_32_simd()

◆ swap_bytes_64_simd()

◆ ycbcr_to_rgb_8bit()

Variable Documentation

◆ AVX512_ALIGNMENT

◆ AVX_ALIGNMENT

◆ SSE_ALIGNMENT