PIMPL implementation for rle_codec. More...

Collaboration diagram for kcenon::pacs::encoding::compression::rle_codec::impl:

Public Member Functions
	impl ()=default

codec_result	encode (std::span< const uint8_t > pixel_data, const image_params &params, const compression_options &options) const

codec_result	decode (std::span< const uint8_t > compressed_data, const image_params &params) const

Private Member Functions
bool	valid_for_rle (const image_params &params) const noexcept

codec_result	encode_frame (std::span< const uint8_t > pixel_data, const image_params &params) const

codec_result	decode_frame (std::span< const uint8_t > compressed_data, const image_params &params) const

Detailed Description

PIMPL implementation for rle_codec.

Definition at line 181 of file rle_codec.cpp.

Constructor & Destructor Documentation

◆ impl()

kcenon::pacs::encoding::compression::rle_codec::impl::impl ( )

default

Member Function Documentation

◆ decode()

codec_result kcenon::pacs::encoding::compression::rle_codec::impl::decode	(	std::span< const uint8_t >	compressed_data,
		const image_params &	params ) const

inlinenodiscard

Definition at line 213 of file rle_codec.cpp.

                                          {
 
        if (compressed_data.empty()) {
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Empty compressed data");
        }
 
        if (compressed_data.size() < kRLEHeaderSize) {
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Compressed data too small for RLE header");
        }
 
        try {
            return decode_frame(compressed_data, params);
        } catch (const std::exception& e) {
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, std::string("RLE decoding failed: ") + e.what());
        }
    }

References decode_frame(), kcenon::pacs::error_codes::decompression_error, kcenon::pacs::encoding::compression::rle_codec::kRLEHeaderSize, and kcenon::pacs::pacs_error().

Referenced by kcenon::pacs::encoding::compression::rle_codec::decode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decode_frame()

codec_result kcenon::pacs::encoding::compression::rle_codec::impl::decode_frame	(	std::span< const uint8_t >	compressed_data,
		const image_params &	params ) const

inlinenodiscardprivate

Definition at line 401 of file rle_codec.cpp.

                                          {
 
        const uint8_t* header = compressed_data.data();
 
        // Read number of segments from header
        uint32_t num_segments = read_le32(header);
        if (num_segments == 0 || num_segments > kMaxSegments) {
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, 
                "Invalid RLE segment count: " + std::to_string(num_segments));
        }
 
        int expected_segments = calculate_segment_count(params);
        if (static_cast<int>(num_segments) != expected_segments) {
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, 
                "Segment count mismatch: expected " + std::to_string(expected_segments) +
                ", got " + std::to_string(num_segments));
        }
 
        // Read segment offsets
        std::vector<uint32_t> offsets(num_segments);
        for (uint32_t i = 0; i < num_segments; ++i) {
            offsets[i] = read_le32(header + 4 + i * 4);
            if (offsets[i] >= compressed_data.size()) {
                return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, 
                    "Invalid segment offset: " + std::to_string(offsets[i]));
            }
        }
 
        // Calculate segment sizes
        std::vector<size_t> sizes(num_segments);
        for (uint32_t i = 0; i < num_segments; ++i) {
            if (i + 1 < num_segments) {
                sizes[i] = offsets[i + 1] - offsets[i];
            } else {
                sizes[i] = compressed_data.size() - offsets[i];
            }
        }
 
        size_t pixels_per_frame = static_cast<size_t>(params.width) * params.height;
        int bytes_per_sample = (params.bits_allocated + 7) / 8;
 
        // Decode each segment
        std::vector<std::vector<uint8_t>> decoded_segments(num_segments);
        for (uint32_t i = 0; i < num_segments; ++i) {
            std::span<const uint8_t> segment_data(
                compressed_data.data() + offsets[i], sizes[i]);
            auto segment_result = decode_rle_segment(segment_data, pixels_per_frame);
            if (segment_result.is_err()) {
                return kcenon::pacs::pacs_error<compression_result>(
                    kcenon::pacs::error_codes::decompression_error,
                    "Segment " + std::to_string(i) + ": " + segment_result.error().message);
            }
            decoded_segments[i] = std::move(segment_result.value());
 
            if (decoded_segments[i].size() != pixels_per_frame) {
                return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, 
                    "Segment " + std::to_string(i) + " decoded size mismatch: expected " +
                    std::to_string(pixels_per_frame) + ", got " +
                    std::to_string(decoded_segments[i].size()));
            }
        }
 
        // Reconstruct pixel data from segments using SIMD optimization
        size_t output_size = pixels_per_frame * params.samples_per_pixel * bytes_per_sample;
        std::vector<uint8_t> output(output_size);
 
        if (bytes_per_sample == 1) {
            // 8-bit samples
            if (params.samples_per_pixel == 1) {
                // Grayscale: direct move
                output = std::move(decoded_segments[0]);
            } else if (params.samples_per_pixel == 3) {
                // Color (RGB): interleave samples using SIMD
                simd::planar_to_interleaved_rgb8(
                    decoded_segments[0].data(),
                    decoded_segments[1].data(),
                    decoded_segments[2].data(),
                    output.data(),
                    pixels_per_frame);
            } else {
                // Other sample counts: scalar fallback
                for (size_t i = 0; i < pixels_per_frame; ++i) {
                    for (int s = 0; s < params.samples_per_pixel; ++s) {
                        output[i * params.samples_per_pixel + s] = decoded_segments[s][i];
                    }
                }
            }
        } else {
            // 16-bit samples
            if (params.samples_per_pixel == 1) {
                // Grayscale: combine high and low byte segments using SIMD
                simd::merge_planes_to_16bit(
                    decoded_segments[0].data(),  // High byte
                    decoded_segments[1].data(),  // Low byte
                    output.data(),
                    pixels_per_frame);
            } else if (params.samples_per_pixel == 3) {
                // 16-bit Color: merge each color component, then interleave
                std::vector<uint8_t> r_plane(pixels_per_frame * 2);
                std::vector<uint8_t> g_plane(pixels_per_frame * 2);
                std::vector<uint8_t> b_plane(pixels_per_frame * 2);
 
                // Merge high/low bytes for each color using SIMD
                simd::merge_planes_to_16bit(decoded_segments[0].data(),
                                             decoded_segments[1].data(),
                                             r_plane.data(), pixels_per_frame);
                simd::merge_planes_to_16bit(decoded_segments[2].data(),
                                             decoded_segments[3].data(),
                                             g_plane.data(), pixels_per_frame);
                simd::merge_planes_to_16bit(decoded_segments[4].data(),
                                             decoded_segments[5].data(),
                                             b_plane.data(), pixels_per_frame);
 
                // Interleave RGB (scalar for now, 16-bit RGB is rare)
                for (size_t i = 0; i < pixels_per_frame; ++i) {
                    size_t src_idx = i * 2;
                    size_t dst_idx = i * 6;  // 3 samples * 2 bytes
                    output[dst_idx] = r_plane[src_idx];
                    output[dst_idx + 1] = r_plane[src_idx + 1];
                    output[dst_idx + 2] = g_plane[src_idx];
                    output[dst_idx + 3] = g_plane[src_idx + 1];
                    output[dst_idx + 4] = b_plane[src_idx];
                    output[dst_idx + 5] = b_plane[src_idx + 1];
                }
            } else {
                // Other sample counts: scalar fallback
                for (size_t i = 0; i < pixels_per_frame; ++i) {
                    for (int s = 0; s < params.samples_per_pixel; ++s) {
                        size_t idx = (i * params.samples_per_pixel + s) * 2;
                        output[idx] = decoded_segments[s * 2 + 1][i];      // Low byte
                        output[idx + 1] = decoded_segments[s * 2][i];      // High byte
                    }
                }
            }
        }
 
        // Build output parameters
        image_params output_params;
        output_params.width = params.width;
        output_params.height = params.height;
        output_params.bits_allocated = params.bits_allocated;
        output_params.bits_stored = params.bits_stored > 0 ? params.bits_stored : params.bits_allocated;
        output_params.high_bit = output_params.bits_stored - 1;
        output_params.samples_per_pixel = params.samples_per_pixel;
        output_params.planar_configuration = 0;  // Always interleaved output
        output_params.pixel_representation = params.pixel_representation;
        output_params.photometric = params.photometric;
 
        return kcenon::pacs::ok<compression_result>(compression_result{std::move(output), output_params});
    }

Referenced by decode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encode()

codec_result kcenon::pacs::encoding::compression::rle_codec::impl::encode	(	std::span< const uint8_t >	pixel_data,
		const image_params &	params,
		const compression_options &	options ) const

inlinenodiscard

Definition at line 185 of file rle_codec.cpp.

                                                                   {
 
        if (pixel_data.empty()) {
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Empty pixel data");
        }
 
        if (!valid_for_rle(params)) {
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, 
                "Invalid parameters for RLE: requires 8/16-bit, 1-3 samples per pixel");
        }
 
        size_t expected_size = params.frame_size_bytes();
        if (pixel_data.size() != expected_size) {
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, 
                "Pixel data size mismatch: expected " + std::to_string(expected_size) +
                ", got " + std::to_string(pixel_data.size()));
        }
 
        try {
            return encode_frame(pixel_data, params);
        } catch (const std::exception& e) {
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, std::string("RLE encoding failed: ") + e.what());
        }
    }

References kcenon::pacs::error_codes::decompression_error, encode_frame(), kcenon::pacs::encoding::compression::image_params::frame_size_bytes(), kcenon::pacs::pacs_error(), and valid_for_rle().

Referenced by kcenon::pacs::encoding::compression::rle_codec::encode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encode_frame()

codec_result kcenon::pacs::encoding::compression::rle_codec::impl::encode_frame	(	std::span< const uint8_t >	pixel_data,
		const image_params &	params ) const

inlinenodiscardprivate

Definition at line 254 of file rle_codec.cpp.

                                          {
 
        int num_segments = calculate_segment_count(params);
        size_t pixels_per_frame = static_cast<size_t>(params.width) * params.height;
        int bytes_per_sample = (params.bits_allocated + 7) / 8;
 
        // Prepare segment data (one vector per segment)
        std::vector<std::vector<uint8_t>> segments(num_segments);
        for (auto& seg : segments) {
            seg.reserve(pixels_per_frame);
        }
 
        // Extract segments from pixel data using SIMD optimization
        // DICOM RLE stores each byte plane separately
        // For 16-bit: high byte first, then low byte
        // For color: each color component separately
 
        if (bytes_per_sample == 1) {
            // 8-bit samples
            if (params.samples_per_pixel == 1) {
                // Grayscale: single segment - direct copy
                segments[0].assign(pixel_data.begin(), pixel_data.end());
            } else if (params.samples_per_pixel == 3) {
                // Color (RGB): 3 segments - use SIMD deinterleaving
                segments[0].resize(pixels_per_frame);
                segments[1].resize(pixels_per_frame);
                segments[2].resize(pixels_per_frame);
                simd::interleaved_to_planar_rgb8(
                    pixel_data.data(),
                    segments[0].data(),
                    segments[1].data(),
                    segments[2].data(),
                    pixels_per_frame);
            } else {
                // Other sample counts: scalar fallback
                for (size_t i = 0; i < pixels_per_frame; ++i) {
                    for (int s = 0; s < params.samples_per_pixel; ++s) {
                        segments[s].push_back(pixel_data[i * params.samples_per_pixel + s]);
                    }
                }
            }
        } else {
            // 16-bit samples (little-endian input)
            // DICOM RLE stores: all high bytes, then all low bytes
            if (params.samples_per_pixel == 1) {
                // Grayscale: 2 segments (high byte, low byte) - use SIMD
                segments[0].resize(pixels_per_frame);
                segments[1].resize(pixels_per_frame);
                simd::split_16bit_to_planes(
                    pixel_data.data(),
                    segments[0].data(),  // High byte
                    segments[1].data(),  // Low byte
                    pixels_per_frame);
            } else if (params.samples_per_pixel == 3) {
                // 16-bit Color: 6 segments - SIMD for each color component
                // First deinterleave RGB, then split each into high/low
                std::vector<uint8_t> r_plane(pixels_per_frame * 2);
                std::vector<uint8_t> g_plane(pixels_per_frame * 2);
                std::vector<uint8_t> b_plane(pixels_per_frame * 2);
 
                // Deinterleave 16-bit RGB (scalar for now, 16-bit RGB is rare)
                for (size_t i = 0; i < pixels_per_frame; ++i) {
                    size_t src_idx = i * 6;  // 3 samples * 2 bytes
                    size_t dst_idx = i * 2;
                    r_plane[dst_idx] = pixel_data[src_idx];
                    r_plane[dst_idx + 1] = pixel_data[src_idx + 1];
                    g_plane[dst_idx] = pixel_data[src_idx + 2];
                    g_plane[dst_idx + 1] = pixel_data[src_idx + 3];
                    b_plane[dst_idx] = pixel_data[src_idx + 4];
                    b_plane[dst_idx + 1] = pixel_data[src_idx + 5];
                }
 
                // Split each color plane into high/low using SIMD
                segments[0].resize(pixels_per_frame);  // R high
                segments[1].resize(pixels_per_frame);  // R low
                segments[2].resize(pixels_per_frame);  // G high
                segments[3].resize(pixels_per_frame);  // G low
                segments[4].resize(pixels_per_frame);  // B high
                segments[5].resize(pixels_per_frame);  // B low
 
                simd::split_16bit_to_planes(r_plane.data(), segments[0].data(),
                                             segments[1].data(), pixels_per_frame);
                simd::split_16bit_to_planes(g_plane.data(), segments[2].data(),
                                             segments[3].data(), pixels_per_frame);
                simd::split_16bit_to_planes(b_plane.data(), segments[4].data(),
                                             segments[5].data(), pixels_per_frame);
            } else {
                // Other sample counts: scalar fallback
                for (size_t i = 0; i < pixels_per_frame; ++i) {
                    for (int s = 0; s < params.samples_per_pixel; ++s) {
                        size_t idx = (i * params.samples_per_pixel + s) * 2;
                        segments[s * 2].push_back(pixel_data[idx + 1]);      // High byte
                        segments[s * 2 + 1].push_back(pixel_data[idx]);      // Low byte
                    }
                }
            }
        }
 
        // Encode each segment
        std::vector<std::vector<uint8_t>> encoded_segments(num_segments);
        for (int i = 0; i < num_segments; ++i) {
            encode_rle_segment(segments[i], encoded_segments[i]);
        }
 
        // Build output with RLE header
        std::vector<uint8_t> output;
 
        // Calculate total size (header + all segments, each padded to even length)
        size_t total_size = kRLEHeaderSize;
        for (const auto& seg : encoded_segments) {
            total_size += seg.size();
            if (seg.size() % 2 != 0) {
                ++total_size;  // Padding byte
            }
        }
        output.reserve(total_size);
 
        // Write header (16 x 4-byte offsets)
        output.resize(kRLEHeaderSize, 0);
 
        // First 4 bytes: number of segments
        write_le32(output.data(), static_cast<uint32_t>(num_segments));
 
        // Calculate and write segment offsets
        uint32_t current_offset = kRLEHeaderSize;
        for (int i = 0; i < num_segments; ++i) {
            write_le32(output.data() + 4 + i * 4, current_offset);
            current_offset += static_cast<uint32_t>(encoded_segments[i].size());
            if (encoded_segments[i].size() % 2 != 0) {
                ++current_offset;  // Account for padding
            }
        }
 
        // Write encoded segments
        for (const auto& seg : encoded_segments) {
            output.insert(output.end(), seg.begin(), seg.end());
            if (seg.size() % 2 != 0) {
                output.push_back(0);  // Padding byte
            }
        }
 
        image_params output_params = params;
        return kcenon::pacs::ok<compression_result>(compression_result{std::move(output), output_params});
    }

References kcenon::pacs::encoding::compression::image_params::bits_allocated, kcenon::pacs::encoding::compression::image_params::height, kcenon::pacs::encoding::simd::interleaved_to_planar_rgb8(), kcenon::pacs::encoding::compression::rle_codec::kRLEHeaderSize, kcenon::pacs::encoding::compression::image_params::samples_per_pixel, kcenon::pacs::encoding::simd::split_16bit_to_planes(), and kcenon::pacs::encoding::compression::image_params::width.

Referenced by encode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ valid_for_rle()

bool kcenon::pacs::encoding::compression::rle_codec::impl::valid_for_rle ( const image_params & params ) const

inlinenodiscardprivatenoexcept

Definition at line 233 of file rle_codec.cpp.

                                                                                {
        // RLE supports 8-bit and 16-bit samples
        if (params.bits_allocated != 8 && params.bits_allocated != 16) {
            return false;
        }
        // 1-3 samples per pixel (grayscale, RGB)
        if (params.samples_per_pixel < 1 || params.samples_per_pixel > 3) {
            return false;
        }
        // Check segment count limit
        int num_segments = calculate_segment_count(params);
        if (num_segments > kMaxSegments) {
            return false;
        }
        // Valid dimensions
        if (params.width == 0 || params.height == 0) {
            return false;
        }
        return true;
    }

References kcenon::pacs::encoding::compression::rle_codec::kMaxSegments.

Referenced by encode().

Here is the caller graph for this function:

The documentation for this class was generated from the following file:

src/encoding/compression/rle_codec.cpp

Public Member Functions

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ impl()

Member Function Documentation

◆ decode()

◆ decode_frame()

◆ encode()

◆ encode_frame()

◆ valid_for_rle()