PIMPL implementation for jpeg2000_codec. More...

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

Public Member Functions
	impl (bool lossless, float compression_ratio, int resolution_levels)

bool	is_lossless_mode () const noexcept

float	compression_ratio () const noexcept

int	resolution_levels () const noexcept

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 Attributes
bool	lossless_

float	compression_ratio_

int	resolution_levels_

Detailed Description

PIMPL implementation for jpeg2000_codec.

Definition at line 214 of file jpeg2000_codec.cpp.

Constructor & Destructor Documentation

◆ impl()

kcenon::pacs::encoding::compression::jpeg2000_codec::impl::impl	(	bool	lossless,
		float	compression_ratio,
		int	resolution_levels )

inlineexplicit

Definition at line 216 of file jpeg2000_codec.cpp.

        : lossless_(lossless)
        , compression_ratio_(compression_ratio)
        , resolution_levels_(std::clamp(resolution_levels, 1, 32)) {}

Member Function Documentation

◆ compression_ratio()

float kcenon::pacs::encoding::compression::jpeg2000_codec::impl::compression_ratio ( ) const

inlinenodiscardnoexcept

Definition at line 225 of file jpeg2000_codec.cpp.

                                                           {
        return compression_ratio_;
    }

References compression_ratio_.

Referenced by kcenon::pacs::encoding::compression::jpeg2000_codec::compression_ratio().

Here is the caller graph for this function:

◆ decode()

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

inlinenodiscard

Definition at line 419 of file jpeg2000_codec.cpp.

                                                                         {
#ifndef PACS_WITH_JPEG2000_CODEC
        (void)compressed_data;
        (void)params;
        return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, 
            "JPEG 2000 codec not available: OpenJPEG library not found at build time");
#else
        if (compressed_data.empty()) {
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Empty compressed data");
        }
 
        // Detect format
        OPJ_CODEC_FORMAT format = detect_j2k_format(compressed_data);
 
        // Create decoder
        opj_codec_t* codec = opj_create_decompress(format);
        if (!codec) {
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to create OpenJPEG decoder");
        }
 
        // Set up error handling
        std::string error_msg;
        opj_set_error_handler(codec, opj_error_callback, &error_msg);
        opj_set_warning_handler(codec, opj_warning_callback, nullptr);
        opj_set_info_handler(codec, opj_info_callback, nullptr);
 
        // Set decoding parameters
        opj_dparameters_t parameters;
        opj_set_default_decoder_parameters(&parameters);
 
        if (!opj_setup_decoder(codec, &parameters)) {
            opj_destroy_codec(codec);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to setup OpenJPEG decoder: " + error_msg);
        }
 
        // Create input stream
        opj_memory_stream input_stream;
        input_stream.data = compressed_data.data();
        input_stream.size = compressed_data.size();
        input_stream.offset = 0;
 
        opj_stream_t* stream = opj_stream_default_create(OPJ_TRUE);
        if (!stream) {
            opj_destroy_codec(codec);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to create OpenJPEG input stream");
        }
 
        opj_stream_set_user_data(stream, &input_stream, nullptr);
        opj_stream_set_user_data_length(stream, compressed_data.size());
        opj_stream_set_read_function(stream, opj_memory_stream_read);
        opj_stream_set_skip_function(stream, opj_memory_stream_skip);
        opj_stream_set_seek_function(stream, opj_memory_stream_seek);
 
        // Read header
        opj_image_t* image = nullptr;
        if (!opj_read_header(stream, codec, &image)) {
            opj_stream_destroy(stream);
            opj_destroy_codec(codec);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to read JPEG 2000 header: " + error_msg);
        }
 
        // Decode
        if (!opj_decode(codec, stream, image)) {
            opj_image_destroy(image);
            opj_stream_destroy(stream);
            opj_destroy_codec(codec);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to decode JPEG 2000 data: " + error_msg);
        }
 
        if (!opj_end_decompress(codec, stream)) {
            opj_image_destroy(image);
            opj_stream_destroy(stream);
            opj_destroy_codec(codec);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to finalize JPEG 2000 decoding: " + error_msg);
        }
 
        // Extract image parameters from decoded data
        image_params output_params = params;
        output_params.width = static_cast<uint16_t>(image->x1 - image->x0);
        output_params.height = static_cast<uint16_t>(image->y1 - image->y0);
        output_params.samples_per_pixel = static_cast<uint16_t>(image->numcomps);
 
        if (image->numcomps > 0) {
            output_params.bits_stored = static_cast<uint16_t>(image->comps[0].prec);
            output_params.bits_allocated = (output_params.bits_stored <= 8) ? 8 : 16;
            output_params.high_bit = output_params.bits_stored - 1;
            output_params.pixel_representation = image->comps[0].sgnd ? 1 : 0;
        }
 
        // Determine photometric interpretation
        if (image->numcomps == 1) {
            output_params.photometric = photometric_interpretation::monochrome2;
        } else if (image->numcomps == 3) {
            output_params.photometric = (image->color_space == OPJ_CLRSPC_SRGB)
                                            ? photometric_interpretation::rgb
                                            : photometric_interpretation::ycbcr_full;
        }
 
        // Validate dimensions if provided
        if (params.width > 0 && params.width != output_params.width) {
            opj_image_destroy(image);
            opj_stream_destroy(stream);
            opj_destroy_codec(codec);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Image width mismatch: expected " +
                                        std::to_string(params.width) + ", got " +
                                        std::to_string(output_params.width));
        }
        if (params.height > 0 && params.height != output_params.height) {
            opj_image_destroy(image);
            opj_stream_destroy(stream);
            opj_destroy_codec(codec);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Image height mismatch: expected " +
                                        std::to_string(params.height) + ", got " +
                                        std::to_string(output_params.height));
        }
 
        // Allocate output buffer
        size_t pixel_count = static_cast<size_t>(output_params.width) * output_params.height;
        size_t bytes_per_sample = (output_params.bits_allocated + 7) / 8;
        size_t total_size = pixel_count * output_params.samples_per_pixel * bytes_per_sample;
 
        std::vector<uint8_t> output_data(total_size);
 
        // Copy decoded data to output buffer (interleaved format)
        for (OPJ_UINT32 c = 0; c < image->numcomps; ++c) {
            const OPJ_INT32* comp_data = image->comps[c].data;
 
            for (size_t i = 0; i < pixel_count; ++i) {
                size_t dst_idx = (i * output_params.samples_per_pixel + c) * bytes_per_sample;
                OPJ_INT32 value = comp_data[i];
 
                if (bytes_per_sample == 1) {
                    output_data[dst_idx] = static_cast<uint8_t>(value & 0xFF);
                } else {
                    // 16-bit little-endian
                    output_data[dst_idx] = static_cast<uint8_t>(value & 0xFF);
                    output_data[dst_idx + 1] = static_cast<uint8_t>((value >> 8) & 0xFF);
                }
            }
        }
 
        // Cleanup
        opj_image_destroy(image);
        opj_stream_destroy(stream);
        opj_destroy_codec(codec);
 
        output_params.planar_configuration = 0;  // Output is always interleaved
        return kcenon::pacs::ok<compression_result>(compression_result{std::move(output_data), output_params});
#endif  // PACS_WITH_JPEG2000_CODEC
    }

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encode()

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

inlinenodiscard

Definition at line 233 of file jpeg2000_codec.cpp.

                                                                                 {
#ifndef PACS_WITH_JPEG2000_CODEC
        (void)pixel_data;
        (void)params;
        (void)options;
        return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, 
            "JPEG 2000 codec not available: OpenJPEG library not found at build time");
#else
        // Determine if we should use lossless mode
        bool use_lossless = lossless_ || options.lossless;
 
        // Create image component parameters
        std::vector<opj_image_cmptparm_t> cmptparm(params.samples_per_pixel);
        for (uint16_t i = 0; i < params.samples_per_pixel; ++i) {
            std::memset(&cmptparm[i], 0, sizeof(opj_image_cmptparm_t));
            cmptparm[i].prec = params.bits_stored;
            cmptparm[i].bpp = params.bits_stored;
            cmptparm[i].sgnd = params.is_signed() ? 1 : 0;
            cmptparm[i].dx = 1;
            cmptparm[i].dy = 1;
            cmptparm[i].w = params.width;
            cmptparm[i].h = params.height;
        }
 
        // Determine color space
        OPJ_COLOR_SPACE color_space = OPJ_CLRSPC_GRAY;
        if (params.samples_per_pixel == 3) {
            color_space = (params.photometric == photometric_interpretation::rgb)
                              ? OPJ_CLRSPC_SRGB
                              : OPJ_CLRSPC_SYCC;
        }
 
        // Create image
        opj_image_t* image = opj_image_create(
            params.samples_per_pixel,
            cmptparm.data(),
            color_space);
 
        if (!image) {
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to create OpenJPEG image structure");
        }
 
        // Set image offset and reference grid
        image->x0 = 0;
        image->y0 = 0;
        image->x1 = params.width;
        image->y1 = params.height;
 
        // Copy pixel data to image components
        size_t bytes_per_sample = (params.bits_allocated + 7) / 8;
        size_t pixel_count = static_cast<size_t>(params.width) * params.height;
 
        for (uint16_t c = 0; c < params.samples_per_pixel; ++c) {
            OPJ_INT32* comp_data = image->comps[c].data;
 
            for (size_t i = 0; i < pixel_count; ++i) {
                size_t src_idx;
                if (params.planar_configuration == 0) {
                    // Interleaved: R0G0B0R1G1B1...
                    src_idx = (i * params.samples_per_pixel + c) * bytes_per_sample;
                } else {
                    // Planar: RRR...GGG...BBB...
                    src_idx = (c * pixel_count + i) * bytes_per_sample;
                }
 
                if (src_idx + bytes_per_sample > pixel_data.size()) {
                    opj_image_destroy(image);
                    return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Pixel data buffer too small");
                }
 
                OPJ_INT32 value = 0;
                if (bytes_per_sample == 1) {
                    value = params.is_signed()
                                ? static_cast<OPJ_INT32>(static_cast<int8_t>(pixel_data[src_idx]))
                                : static_cast<OPJ_INT32>(pixel_data[src_idx]);
                } else {
                    // 16-bit (little-endian)
                    uint16_t raw = static_cast<uint16_t>(pixel_data[src_idx]) |
                                   (static_cast<uint16_t>(pixel_data[src_idx + 1]) << 8);
                    value = params.is_signed()
                                ? static_cast<OPJ_INT32>(static_cast<int16_t>(raw))
                                : static_cast<OPJ_INT32>(raw);
                }
                comp_data[i] = value;
            }
        }
 
        // Create encoder
        opj_codec_t* codec = opj_create_compress(OPJ_CODEC_J2K);
        if (!codec) {
            opj_image_destroy(image);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to create OpenJPEG encoder");
        }
 
        // Set up error handling
        std::string error_msg;
        opj_set_error_handler(codec, opj_error_callback, &error_msg);
        opj_set_warning_handler(codec, opj_warning_callback, nullptr);
        opj_set_info_handler(codec, opj_info_callback, nullptr);
 
        // Set encoding parameters
        opj_cparameters_t parameters;
        opj_set_default_encoder_parameters(&parameters);
 
        parameters.tcp_numlayers = 1;
        parameters.cp_disto_alloc = 1;
        parameters.numresolution = resolution_levels_;
 
        if (use_lossless) {
            // Lossless: use reversible 5/3 wavelet
            parameters.irreversible = 0;
            parameters.tcp_rates[0] = 0;  // 0 = lossless
        } else {
            // Lossy: use irreversible 9/7 wavelet
            parameters.irreversible = 1;
 
            // Convert quality (1-100) to compression ratio
            float ratio = compression_ratio_;
            if (options.quality > 0 && options.quality <= 100) {
                // Map quality 100->2 (near lossless), quality 1->100 (high compression)
                ratio = 2.0f + (100.0f - static_cast<float>(options.quality)) * 0.98f;
            }
            parameters.tcp_rates[0] = ratio;
        }
 
        // Setup encoder with parameters
        if (!opj_setup_encoder(codec, &parameters, image)) {
            opj_destroy_codec(codec);
            opj_image_destroy(image);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to setup OpenJPEG encoder: " + error_msg);
        }
 
        // Create output stream
        opj_output_buffer output_buf;
        output_buf.offset = 0;
        output_buf.data.reserve(pixel_data.size() / 2);  // Estimate compressed size
 
        opj_stream_t* stream = opj_stream_default_create(OPJ_FALSE);
        if (!stream) {
            opj_destroy_codec(codec);
            opj_image_destroy(image);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to create OpenJPEG output stream");
        }
 
        opj_stream_set_user_data(stream, &output_buf, nullptr);
        opj_stream_set_user_data_length(stream, 0);
        opj_stream_set_write_function(stream, opj_output_buffer_write);
        opj_stream_set_skip_function(stream, opj_output_buffer_skip);
        opj_stream_set_seek_function(stream, opj_output_buffer_seek);
 
        // Encode
        if (!opj_start_compress(codec, image, stream)) {
            opj_stream_destroy(stream);
            opj_destroy_codec(codec);
            opj_image_destroy(image);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to start JPEG 2000 encoding: " + error_msg);
        }
 
        if (!opj_encode(codec, stream)) {
            opj_stream_destroy(stream);
            opj_destroy_codec(codec);
            opj_image_destroy(image);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to encode JPEG 2000 data: " + error_msg);
        }
 
        if (!opj_end_compress(codec, stream)) {
            opj_stream_destroy(stream);
            opj_destroy_codec(codec);
            opj_image_destroy(image);
            return kcenon::pacs::pacs_error<compression_result>(kcenon::pacs::error_codes::decompression_error, "Failed to finalize JPEG 2000 encoding: " + error_msg);
        }
 
        // Cleanup
        opj_stream_destroy(stream);
        opj_destroy_codec(codec);
        opj_image_destroy(image);
 
        // Trim output buffer to actual size
        output_buf.data.resize(output_buf.offset);
 
        return kcenon::pacs::ok<compression_result>(compression_result{std::move(output_buf.data), params});
#endif  // PACS_WITH_JPEG2000_CODEC
    }

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_lossless_mode()

bool kcenon::pacs::encoding::compression::jpeg2000_codec::impl::is_lossless_mode ( ) const

inlinenodiscardnoexcept

Definition at line 221 of file jpeg2000_codec.cpp.

                                                         {
        return lossless_;
    }

References lossless_.

Referenced by kcenon::pacs::encoding::compression::jpeg2000_codec::is_lossless_mode(), kcenon::pacs::encoding::compression::jpeg2000_codec::is_lossy(), and kcenon::pacs::encoding::compression::jpeg2000_codec::name().

Here is the caller graph for this function:

◆ resolution_levels()

int kcenon::pacs::encoding::compression::jpeg2000_codec::impl::resolution_levels ( ) const

inlinenodiscardnoexcept

Definition at line 229 of file jpeg2000_codec.cpp.

                                                         {
        return resolution_levels_;
    }

References resolution_levels_.

Referenced by kcenon::pacs::encoding::compression::jpeg2000_codec::resolution_levels().

Here is the caller graph for this function:

Member Data Documentation

◆ compression_ratio_

float kcenon::pacs::encoding::compression::jpeg2000_codec::impl::compression_ratio_

private

Definition at line 573 of file jpeg2000_codec.cpp.

Referenced by compression_ratio(), and encode().

◆ lossless_

bool kcenon::pacs::encoding::compression::jpeg2000_codec::impl::lossless_

private

Definition at line 572 of file jpeg2000_codec.cpp.

Referenced by encode(), and is_lossless_mode().

◆ resolution_levels_

int kcenon::pacs::encoding::compression::jpeg2000_codec::impl::resolution_levels_

private

Definition at line 574 of file jpeg2000_codec.cpp.

Referenced by encode(), and resolution_levels().

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

src/encoding/compression/jpeg2000_codec.cpp

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ impl()

Member Function Documentation

◆ compression_ratio()

◆ decode()

◆ encode()

◆ is_lossless_mode()

◆ resolution_levels()

Member Data Documentation

◆ compression_ratio_

◆ lossless_

◆ resolution_levels_