Add support to encode and decode 2 components by line and sample interleave mode (#331)

2 components in interleave mode none was already supported. But the options line and sample were not implemented.
Add these 2 options to support all interleave options.

.clang-tidy

@@ -20,6 +20,7 @@
 # -clang-diagnostic-unused-macros => Rationale: Macros defined in header are reported as problem
 # -clang-diagnostic-sign-conversion => Rationale: warning will be enabled in additional steps
 # -clang-diagnostic-switch-enum => Rationale: options are handled by default case
+# -clang-diagnostic-global-constructors => Rationale: Acceptable construction
 # -clang-diagnostic-exit-time-destructors => Rationale: Acceptable construction
 # -clang-diagnostic-pragma-once-outside-header => Rationale: Generates false warnings for usage in header files
 # -clang-diagnostic-unused-const-variable => Rationale: false warnings for constexpr in .h files
@@ -74,6 +75,7 @@ Checks:          '*,
                   -clang-diagnostic-unused-macros,
                   -clang-diagnostic-sign-conversion,
                   -clang-diagnostic-switch-enum,
+                  -clang-diagnostic-global-constructors,
                   -clang-diagnostic-exit-time-destructors,
                   -clang-diagnostic-pragma-once-outside-header,
                   -clang-diagnostic-unused-const-variable,

src/charls_jpegls_decoder.cpp

@@ -177,7 +177,6 @@ struct charls_jpegls_decoder final
     {
         check_argument(destination.data() || destination.empty());
         check_operation(state_ == state::header_read);
-        check_parameter_coherent();
 
         // Compute the stride for the uncompressed destination buffer.
         const size_t minimum_stride{calculate_minimum_stride()};
@@ -250,21 +249,6 @@ private:
         check_argument_range(0, mapping_table_count() - 1, mapping_table_index);
     }
 
-    void check_parameter_coherent() const
-    {
-        switch (frame_info().component_count)
-        {
-        case 4:
-        case 3:
-            break;
-        default:
-            if (UNLIKELY(reader_.parameters().interleave_mode != interleave_mode::none))
-                throw_jpegls_error(jpegls_errc::parameter_value_not_supported);
-
-            break;
-        }
-    }
-
     enum class state
     {
         initial,

src/copy_from_line_buffer.hpp

@@ -30,8 +30,12 @@ public:
             return &copy_samples;
 
         case interleave_mode::line:
-            if (component_count == 3)
+            switch (component_count)
             {
+            case 2:
+                return &copy_line_2_components;
+
+            case 3:
                 switch (color_transformation)
                 {
                 case color_transformation::none:
@@ -46,14 +50,21 @@ public:
                 case color_transformation::hp3:
                     return &copy_line_3_components_transform<transform_hp3<sample_type>>;
                 }
-            }
+                break;
 
-            ASSERT(component_count == 4);
-            return &copy_line_4_components;
+            default:
+                ASSERT(component_count == 4);
+                return &copy_line_4_components;
+            }
+            break;
 
         case interleave_mode::sample:
-            if (component_count == 3)
+            switch (component_count)
             {
+            case 2:
+                return &copy_pixels_2_components;
+
+            case 3:
                 switch (color_transformation)
                 {
                 case color_transformation::none:
@@ -68,10 +79,12 @@ public:
                 case color_transformation::hp3:
                     return &copy_pixels_3_components_transform<transform_hp3<sample_type>>;
                 }
-            }
+                break;
 
-            ASSERT(component_count == 4);
-            return &copy_pixels_4_components;
+            default:
+                ASSERT(component_count == 4);
+                return &copy_pixels_4_components;
+            }
         }
 
         unreachable();
@@ -85,6 +98,18 @@ private:
         memcpy(destination, source, pixel_count * sizeof(sample_type));
     }
 
+    static void copy_line_2_components(const void* source, void* destination, const size_t pixel_count) noexcept
+    {
+        auto* s{static_cast<const sample_type*>(source)};
+        auto* d{static_cast<pair<sample_type>*>(destination)};
+        const size_t pixel_stride{pixel_count_to_pixel_stride(pixel_count)};
+
+        for (size_t i{}; i != pixel_count; ++i)
+        {
+            d[i] = {s[i], s[i + pixel_stride]};
+        }
+    }
+
     static void copy_line_3_components(const void* source, void* destination, const size_t pixel_count) noexcept
     {
         auto* s{static_cast<const sample_type*>(source)};
@@ -129,6 +154,11 @@ private:
         }
     }
 
+    static void copy_pixels_2_components(const void* source, void* destination, const size_t pixel_count) noexcept
+    {
+        memcpy(destination, source, pixel_count * sizeof(pair<sample_type>));
+    }
+
     static void copy_pixels_3_components(const void* source, void* destination, const size_t pixel_count) noexcept
     {
         memcpy(destination, source, pixel_count * sizeof(triplet<sample_type>));

src/copy_to_line_buffer.hpp

@@ -35,8 +35,12 @@ public:
         }
 
         case interleave_mode::line:
-            if (component_count == 3)
+            switch (component_count)
             {
+            case 2:
+                return &copy_line_2_components;
+
+            case 3:
                 switch (color_transformation)
                 {
                 case color_transformation::none:
@@ -51,14 +55,21 @@ public:
                 case color_transformation::hp3:
                     return &copy_line_3_components_transform<transform_hp3<sample_type>>;
                 }
-            }
+                break;
 
-            ASSERT(component_count == 4);
-            return &copy_line_4_components;
+            default:
+                ASSERT(component_count == 4);
+                return &copy_line_4_components;
+            }
+            break;
 
         case interleave_mode::sample:
-            if (component_count == 3)
+            switch (component_count)
             {
+            case 2:
+                return &copy_pixels_2_components;
+
+            case 3:
                 switch (color_transformation)
                 {
                 case color_transformation::none:
@@ -73,10 +84,12 @@ public:
                 case color_transformation::hp3:
                     return &copy_pixels_3_components_transform<transform_hp3<sample_type>>;
                 }
-            }
+                break;
 
-            ASSERT(component_count == 4);
-            return &copy_pixels_4_components;
+            default:
+                ASSERT(component_count == 4);
+                return &copy_pixels_4_components;
+            }
         }
 
         unreachable();
@@ -102,6 +115,23 @@ private:
         }
     }
 
+    static void copy_line_2_components(const void* source, void* destination, const size_t pixel_count,
+                                       uint32_t mask) noexcept
+    {
+        auto* s{static_cast<const pair<sample_type>*>(source)};
+        auto* d{static_cast<sample_type*>(destination)};
+        const size_t pixel_stride{pixel_count_to_pixel_stride(pixel_count)};
+        const auto m{static_cast<sample_type>(mask)};
+
+        for (size_t i{}; i != pixel_count; ++i)
+        {
+            const auto pixel{s[i]};
+
+            d[i] = pixel.v1 & m;
+            d[i + pixel_stride] = pixel.v2 & m;
+        }
+    }
+
     static void copy_line_3_components(const void* source, void* destination, const size_t pixel_count,
                                        uint32_t mask) noexcept
     {
@@ -165,6 +195,20 @@ private:
         }
     }
 
+    static void copy_pixels_2_components(const void* source, void* destination, const size_t pixel_count,
+                                         uint32_t mask) noexcept
+    {
+        auto* s{static_cast<const pair<sample_type>*>(source)};
+        auto* d{static_cast<pair<sample_type>*>(destination)};
+        const auto m{static_cast<sample_type>(mask)};
+
+        for (size_t i{}; i != pixel_count; ++i)
+        {
+            const auto pixel{s[i]};
+            d[i] = {static_cast<sample_type>(pixel.v1 & m), static_cast<sample_type>(pixel.v2 & m)};
+        }
+    }
+
     static void copy_pixels_3_components(const void* source, void* destination, const size_t pixel_count,
                                          uint32_t mask) noexcept
     {

src/default_traits.hpp

@@ -86,6 +86,12 @@ struct default_traits final
         return std::abs(lhs - rhs) <= near_lossless;
     }
 
+    [[nodiscard]]
+    bool is_near(const pair<SampleType> lhs, const pair<SampleType> rhs) const noexcept
+    {
+        return std::abs(lhs.v1 - rhs.v1) <= near_lossless && std::abs(lhs.v2 - rhs.v2) <= near_lossless;
+    }
+
     [[nodiscard]]
     bool is_near(const triplet<SampleType> lhs, const triplet<SampleType> rhs) const noexcept
     {

src/jpeg_stream_reader.cpp

@@ -882,7 +882,7 @@ void jpeg_stream_reader::call_application_data_callback(const jpeg_marker_code m
 
 void jpeg_stream_reader::find_and_read_define_number_of_lines_segment()
 {
-    for (auto position{position_}; position < end_position_ - 1; ++position)
+    for (const byte* position{position_}; position < end_position_ - 1; ++position)
     {
         if (*position != jpeg_marker_start_byte)
             continue;
@@ -895,7 +895,7 @@ void jpeg_stream_reader::find_and_read_define_number_of_lines_segment()
         if (static_cast<jpeg_marker_code>(optional_marker_code) != jpeg_marker_code::define_number_of_lines)
             break;
 
-        const auto current_position{position_};
+        const byte* current_position{position_};
         position_ = position + 2;
         read_segment_size();
         frame_info_height(read_define_number_of_lines_segment(), true);

src/lossless_traits.hpp

@@ -135,6 +135,29 @@ struct lossless_traits<uint16_t, 16> final : lossless_traits_impl<uint16_t, 16>
 };
 
 
+template<typename SampleType, int32_t BitsPerSample>
+struct lossless_traits<pair<SampleType>, BitsPerSample> final : lossless_traits_impl<SampleType, BitsPerSample>
+{
+    using pixel_type = pair<SampleType>;
+
+    FORCE_INLINE constexpr static bool is_near(const int32_t lhs, const int32_t rhs) noexcept
+    {
+        return lhs == rhs;
+    }
+
+    FORCE_INLINE constexpr static bool is_near(const pixel_type lhs, const pixel_type rhs) noexcept
+    {
+        return lhs == rhs;
+    }
+
+    FORCE_INLINE static SampleType compute_reconstructed_sample(const int32_t predicted_value,
+                                                                const int32_t error_value) noexcept
+    {
+        return static_cast<SampleType>(predicted_value + error_value);
+    }
+};
+
+
 template<typename SampleType, int32_t BitsPerSample>
 struct lossless_traits<triplet<SampleType>, BitsPerSample> final : lossless_traits_impl<SampleType, BitsPerSample>
 {

src/make_scan_codec.cpp

@@ -51,9 +51,6 @@ template<typename ScanProcess>
 unique_ptr<ScanProcess> try_make_optimized_codec(const frame_info& frame, const jpegls_pc_parameters& pc_parameters,
                                                  const coding_parameters& parameters)
 {
-    if (parameters.interleave_mode == interleave_mode::sample && frame.component_count != 3 && frame.component_count != 4)
-        return nullptr;
-
 #ifndef DISABLE_SPECIALIZATIONS
 
     // optimized lossless versions common formats
@@ -61,10 +58,33 @@ unique_ptr<ScanProcess> try_make_optimized_codec(const frame_info& frame, const
     {
         if (parameters.interleave_mode == interleave_mode::sample)
         {
-            if (frame.component_count == 3 && frame.bits_per_sample == 8)
-                return make_codec<ScanProcess>(frame, pc_parameters, parameters, lossless_traits<triplet<uint8_t>, 8>());
-            if (frame.component_count == 4 && frame.bits_per_sample == 8)
-                return make_codec<ScanProcess>(frame, pc_parameters, parameters, lossless_traits<quad<uint8_t>, 8>());
+            if (frame.bits_per_sample == 8)
+            {
+                switch (frame.component_count)
+                {
+                case 2:
+                    return make_codec<ScanProcess>(frame, pc_parameters, parameters, lossless_traits<pair<uint8_t>, 8>());
+                case 3:
+                    return make_codec<ScanProcess>(frame, pc_parameters, parameters, lossless_traits<triplet<uint8_t>, 8>());
+                default:
+                    ASSERT(frame.component_count == 4);
+                    return make_codec<ScanProcess>(frame, pc_parameters, parameters, lossless_traits<quad<uint8_t>, 8>());
+                }
+            }
+
+            if (frame.bits_per_sample == 16)
+            {
+                switch (frame.component_count)
+                {
+                case 2:
+                    return make_codec<ScanProcess>(frame, pc_parameters, parameters, lossless_traits<pair<uint16_t>, 16>());
+                case 3:
+                    return make_codec<ScanProcess>(frame, pc_parameters, parameters, lossless_traits<triplet<uint16_t>, 16>());
+                default:
+                    ASSERT(frame.component_count == 4);
+                    return make_codec<ScanProcess>(frame, pc_parameters, parameters, lossless_traits<quad<uint16_t>, 16>());
+                }
+            }
         }
         else
         {
@@ -90,6 +110,13 @@ unique_ptr<ScanProcess> try_make_optimized_codec(const frame_info& frame, const
     {
         if (parameters.interleave_mode == interleave_mode::sample)
         {
+            if (frame.component_count == 2)
+            {
+                return make_codec<ScanProcess>(
+                    frame, pc_parameters, parameters,
+                    default_traits<uint8_t, pair<uint8_t>>(maximum_sample_value, parameters.near_lossless));
+            }
+
             if (frame.component_count == 3)
             {
                 return make_codec<ScanProcess>(
@@ -108,10 +135,18 @@ unique_ptr<ScanProcess> try_make_optimized_codec(const frame_info& frame, const
         return make_codec<ScanProcess>(frame, pc_parameters, parameters,
                                        default_traits<uint8_t, uint8_t>(maximum_sample_value, parameters.near_lossless));
     }
+
     if (frame.bits_per_sample <= 16)
     {
         if (parameters.interleave_mode == interleave_mode::sample)
         {
+            if (frame.component_count == 2)
+            {
+                return make_codec<ScanProcess>(
+                    frame, pc_parameters, parameters,
+                    default_traits<uint16_t, pair<uint16_t>>(maximum_sample_value, parameters.near_lossless));
+            }
+
             if (frame.component_count == 3)
             {
                 return make_codec<ScanProcess>(
@@ -130,6 +165,7 @@ unique_ptr<ScanProcess> try_make_optimized_codec(const frame_info& frame, const
         return make_codec<ScanProcess>(frame, pc_parameters, parameters,
                                        default_traits<uint16_t, uint16_t>(maximum_sample_value, parameters.near_lossless));
     }
+
     return nullptr;
 }
 

src/scan_decoder_impl.hpp

@@ -89,13 +89,16 @@ private:
                     {
                         decode_sample_line();
                     }
+                    if constexpr (std::is_same_v<pixel_type, pair<sample_type>>)
+                    {
+                        decode_pair_line();
+                    }
                     else if constexpr (std::is_same_v<pixel_type, triplet<sample_type>>)
                     {
                         decode_triplet_line();
                     }
-                    else
+                    else if constexpr (std::is_same_v<pixel_type, quad<sample_type>>)
                     {
-                        static_assert(std::is_same_v<pixel_type, quad<sample_type>>);
                         decode_quad_line();
                     }
 
@@ -150,6 +153,37 @@ private:
         }
     }
 
+    /// <summary>Decodes a scan line of triplets in ILV_SAMPLE mode</summary>
+    void decode_pair_line()
+    {
+        int32_t index{1};
+        while (static_cast<uint32_t>(index) <= width_)
+        {
+            const pair<sample_type> ra{current_line_[index - 1]};
+            const pair<sample_type> rc{previous_line_[index - 1]};
+            const pair<sample_type> rb{previous_line_[index]};
+            const pair<sample_type> rd{previous_line_[index + 1]};
+
+            const int32_t qs1{compute_context_id(quantize_gradient(rd.v1 - rb.v1), quantize_gradient(rb.v1 - rc.v1),
+                                                 quantize_gradient(rc.v1 - ra.v1))};
+            const int32_t qs2{compute_context_id(quantize_gradient(rd.v2 - rb.v2), quantize_gradient(rb.v2 - rc.v2),
+                                                 quantize_gradient(rc.v2 - ra.v2))};
+
+            if (qs1 == 0 && qs2 == 0)
+            {
+                index += decode_run_mode(index);
+            }
+            else
+            {
+                pair<sample_type> rx;
+                rx.v1 = decode_regular(qs1, compute_predicted_value(ra.v1, rb.v1, rc.v1));
+                rx.v2 = decode_regular(qs2, compute_predicted_value(ra.v2, rb.v2, rc.v2));
+                current_line_[index] = rx;
+                ++index;
+            }
+        }
+    }
+
     /// <summary>Decodes a scan line of triplets in ILV_SAMPLE mode</summary>
     void decode_triplet_line()
     {
@@ -296,6 +330,16 @@ private:
         return static_cast<sample_type>(traits_.compute_reconstructed_sample(rb, error_value * sign(rb - ra)));
     }
 
+    [[nodiscard]]
+    pair<sample_type> decode_run_interruption_pixel(pair<sample_type> ra, pair<sample_type> rb)
+    {
+        const int32_t error_value1{decode_run_interruption_error(run_mode_contexts_[0])};
+        const int32_t error_value2{decode_run_interruption_error(run_mode_contexts_[0])};
+
+        return {traits_.compute_reconstructed_sample(rb.v1, error_value1 * sign(rb.v1 - ra.v1)),
+                traits_.compute_reconstructed_sample(rb.v2, error_value2 * sign(rb.v2 - ra.v2))};
+    }
+
     [[nodiscard]]
     triplet<sample_type> decode_run_interruption_pixel(triplet<sample_type> ra, triplet<sample_type> rb)
     {

src/scan_encoder_impl.hpp

@@ -18,10 +18,11 @@ public:
 
     scan_encoder_impl(const charls::frame_info& frame_info, const jpegls_pc_parameters& pc_parameters,
                       const coding_parameters& parameters, const Traits& traits) :
-        scan_encoder{frame_info, pc_parameters, parameters,
+        scan_encoder{
+            frame_info, pc_parameters, parameters,
             copy_to_line_buffer<sample_type>::get_copy_function(parameters.interleave_mode, frame_info.component_count,
-                                                                frame_info.bits_per_sample, parameters.transformation)
-        }, traits_{traits}
+                                                                frame_info.bits_per_sample, parameters.transformation)},
+        traits_{traits}
     {
         ASSERT(traits_.is_valid());
 
@@ -80,6 +81,10 @@ private:
                 {
                     encode_sample_line();
                 }
+                else if constexpr (std::is_same_v<pixel_type, pair<sample_type>>)
+                {
+                    encode_pair_line();
+                }
                 else if constexpr (std::is_same_v<pixel_type, triplet<sample_type>>)
                 {
                     encode_triplet_line();
@@ -127,6 +132,37 @@ private:
         }
     }
 
+    /// <summary>Encodes a scan line of pairs in ILV_SAMPLE mode</summary>
+    void encode_pair_line()
+    {
+        int32_t index{1};
+        while (static_cast<uint32_t>(index) <= width_)
+        {
+            const pair<sample_type> ra{current_line_[index - 1]};
+            const pair<sample_type> rc{previous_line_[index - 1]};
+            const pair<sample_type> rb{previous_line_[index]};
+            const pair<sample_type> rd{previous_line_[index + 1]};
+
+            const int32_t qs1{compute_context_id(quantize_gradient(rd.v1 - rb.v1), quantize_gradient(rb.v1 - rc.v1),
+                                                 quantize_gradient(rc.v1 - ra.v1))};
+            const int32_t qs2{compute_context_id(quantize_gradient(rd.v2 - rb.v2), quantize_gradient(rb.v2 - rc.v2),
+                                                 quantize_gradient(rc.v2 - ra.v2))};
+
+            if (qs1 == 0 && qs2 == 0)
+            {
+                index += encode_run_mode(index);
+            }
+            else
+            {
+                pair<sample_type> rx;
+                rx.v1 = encode_regular(qs1, current_line_[index].v1, compute_predicted_value(ra.v1, rb.v1, rc.v1));
+                rx.v2 = encode_regular(qs2, current_line_[index].v2, compute_predicted_value(ra.v2, rb.v2, rc.v2));
+                current_line_[index] = rx;
+                ++index;
+            }
+        }
+    }
+
     /// <summary>Encodes a scan line of triplets in ILV_SAMPLE mode</summary>
     void encode_triplet_line()
     {
@@ -298,6 +334,20 @@ private:
         return static_cast<sample_type>(traits_.compute_reconstructed_sample(rb, error_value * sign(rb - ra)));
     }
 
+    [[nodiscard]]
+    pair<sample_type> encode_run_interruption_pixel(const pair<sample_type> x, const pair<sample_type> ra,
+                                                    const pair<sample_type> rb)
+    {
+        const int32_t error_value1{traits_.compute_error_value(sign(rb.v1 - ra.v1) * (x.v1 - rb.v1))};
+        encode_run_interruption_error(run_mode_contexts_[0], error_value1);
+
+        const int32_t error_value2{traits_.compute_error_value(sign(rb.v2 - ra.v2) * (x.v2 - rb.v2))};
+        encode_run_interruption_error(run_mode_contexts_[0], error_value2);
+
+        return {traits_.compute_reconstructed_sample(rb.v1, error_value1 * sign(rb.v1 - ra.v1)),
+                traits_.compute_reconstructed_sample(rb.v2, error_value2 * sign(rb.v2 - ra.v2))};
+    }
+
     [[nodiscard]]
     triplet<sample_type> encode_run_interruption_pixel(const triplet<sample_type> x, const triplet<sample_type> ra,
                                                        const triplet<sample_type> rb)

src/util.hpp

@@ -106,6 +106,21 @@ inline CHARLS_NO_INLINE jpegls_errc to_jpegls_errc() noexcept
 }
 
 
+template<typename T>
+struct pair final
+{
+    T v1{};
+    T v2{};
+
+    [[nodiscard]]
+    friend constexpr bool
+    operator==(const pair& lhs, const pair& rhs) noexcept
+    {
+        return lhs.v1 == rhs.v1 && lhs.v2 == rhs.v2;
+    }
+};
+
+
 template<typename T>
 struct triplet final
 {

unittest/encode_test.cpp

@@ -42,6 +42,45 @@ public:
         encode("DataFiles/16-bit-640-480-many-dots.pgm", 4138);
     }
 
+    TEST_METHOD(encode_2_components_8_bit_interleave_none)
+    {
+        constexpr array data{byte{10}, byte{20}, byte{30}, byte{40}, byte{50}, byte{60}, byte{70}, byte{80}};
+        encode({2, 2, 8, 2}, {data.cbegin(), data.cend()}, 53, interleave_mode::none);
+    }
+
+    TEST_METHOD(encode_2_components_8_bit_interleave_line)
+    {
+        constexpr array data{byte{10}, byte{20}, byte{30}, byte{40}, byte{50}, byte{60}, byte{70}, byte{80}};
+        encode({2, 2, 8, 2}, {data.cbegin(), data.cend()}, 43, interleave_mode::line);
+    }
+
+    TEST_METHOD(encode_2_components_8_bit_interleave_sample)
+    {
+        constexpr array data{byte{10}, byte{20}, byte{30}, byte{40}, byte{50}, byte{60}, byte{70}, byte{80}};
+        encode({2, 2, 8, 2}, {data.cbegin(), data.cend()}, 43, interleave_mode::sample);
+    }
+
+    TEST_METHOD(encode_2_components_16_bit_interleave_none)
+    {
+        constexpr array data{byte{10}, byte{1}, byte{20}, byte{1}, byte{30}, byte{1}, byte{40}, byte{1},
+                             byte{50}, byte{1}, byte{60}, byte{1}, byte{70}, byte{1}, byte{80}, byte{1}};
+        encode({2, 2, 16, 2}, {data.cbegin(), data.cend()}, 52, interleave_mode::none);
+    }
+
+    TEST_METHOD(encode_2_components_16_bit_interleave_line)
+    {
+        constexpr array data{byte{10}, byte{1}, byte{20}, byte{1}, byte{30}, byte{1}, byte{40}, byte{1},
+                             byte{50}, byte{1}, byte{60}, byte{1}, byte{70}, byte{1}, byte{80}, byte{1}};
+        encode({2, 2, 16, 2}, {data.cbegin(), data.cend()}, 44, interleave_mode::line);
+    }
+
+    TEST_METHOD(encode_2_components_16_bit_interleave_sample)
+    {
+        constexpr array data{byte{10}, byte{1}, byte{20}, byte{1}, byte{30}, byte{1}, byte{40}, byte{1},
+                             byte{50}, byte{1}, byte{60}, byte{1}, byte{70}, byte{1}, byte{80}, byte{1}};
+        encode({2, 2, 16, 2}, {data.cbegin(), data.cend()}, 44, interleave_mode::sample);
+    }
+
     TEST_METHOD(encode_color_8_bit_interleave_none_lossless) // NOLINT
     {
         encode("DataFiles/test8.ppm", 102248);