charls-sys 2.4.5

Bindings for charls
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

// Copyright (c) Team CharLS.
// SPDX-License-Identifier: BSD-3-Clause

#pragma once

#include "constants.h"
#include "util.h"

#include <cassert>
#include <cmath>
#include <cstdlib>

// Default traits that support all JPEG LS parameters: custom limit, near, maxval (not power of 2)

// This traits class is used to initialize a coder/decoder.
// The coder/decoder also delegates some functions to the traits class.
// This is to allow the traits class to replace the default implementation here with optimized specific implementations.
// This is done for lossless coding/decoding: see lossless_traits.h

namespace charls {

template<typename SampleType, typename PixelType>
struct default_traits final
{
    using sample_type = SampleType;
    using pixel_type = PixelType;

    int32_t maximum_sample_value;
    const int32_t near_lossless;
    const int32_t range;
    const int32_t quantized_bits_per_pixel;
    const int32_t bits_per_pixel;
    const int32_t limit;
    const int32_t reset_threshold;

    default_traits(const int32_t arg_maximum_sample_value, const int32_t arg_near_lossless,
                   const int32_t reset = default_reset_value) noexcept :
        maximum_sample_value{arg_maximum_sample_value},
        near_lossless{arg_near_lossless},
        range{compute_range_parameter(maximum_sample_value, near_lossless)},
        quantized_bits_per_pixel{log2_ceil(range)},
        bits_per_pixel{log2_ceil(maximum_sample_value)},
        limit{compute_limit_parameter(bits_per_pixel)},
        reset_threshold{reset}
    {
    }

    default_traits() = delete;
    default_traits(const default_traits&) noexcept = default;
    default_traits(default_traits&&) noexcept = default;
    ~default_traits() = default;
    default_traits& operator=(const default_traits&) = delete;
    default_traits& operator=(default_traits&&) = delete;

    FORCE_INLINE int32_t compute_error_value(const int32_t e) const noexcept
    {
        return modulo_range(quantize(e));
    }

    FORCE_INLINE SampleType compute_reconstructed_sample(const int32_t predicted_value,
                                                         const int32_t error_value) const noexcept
    {
        return fix_reconstructed_value(predicted_value + dequantize(error_value));
    }

    FORCE_INLINE bool is_near(const int32_t lhs, const int32_t rhs) const noexcept
    {
        return std::abs(lhs - rhs) <= near_lossless;
    }

    bool is_near(const triplet<SampleType> lhs, const triplet<SampleType> rhs) const noexcept
    {
        return std::abs(lhs.v1 - rhs.v1) <= near_lossless && std::abs(lhs.v2 - rhs.v2) <= near_lossless &&
               std::abs(lhs.v3 - rhs.v3) <= near_lossless;
    }

    bool is_near(const quad<SampleType> lhs, const quad<SampleType> rhs) const noexcept
    {
        return std::abs(lhs.v1 - rhs.v1) <= near_lossless && std::abs(lhs.v2 - rhs.v2) <= near_lossless &&
               std::abs(lhs.v3 - rhs.v3) <= near_lossless && std::abs(lhs.v4 - rhs.v4) <= near_lossless;
    }

    FORCE_INLINE int32_t correct_prediction(const int32_t predicted) const noexcept
    {
        if ((predicted & maximum_sample_value) == predicted)
            return predicted;

        return (~(predicted >> (int32_t_bit_count - 1))) & maximum_sample_value;
    }

    /// <summary>
    /// Returns the value of errorValue modulo RANGE. ITU.T.87, A.4.5 (code segment A.9)
    /// This ensures the error is reduced to the range (-⌊RANGE/2⌋ .. ⌈RANGE/2⌉-1)
    /// </summary>
    FORCE_INLINE int32_t modulo_range(int32_t error_value) const noexcept
    {
        ASSERT(std::abs(error_value) <= range);

        if (error_value < 0)
        {
            error_value += range;
        }

        if (error_value >= (range + 1) / 2)
        {
            error_value -= range;
        }

        ASSERT(-range / 2 <= error_value && error_value <= ((range + 1) / 2) - 1);
        return error_value;
    }

#ifndef NDEBUG
    bool is_valid() const noexcept
    {
        if (maximum_sample_value < 1 || maximum_sample_value > std::numeric_limits<uint16_t>::max())
            return false;

        if (bits_per_pixel < 1 || bits_per_pixel > 16)
            return false;

        return true;
    }
#endif

private:
    int32_t quantize(const int32_t error_value) const noexcept
    {
        if (error_value > 0)
            return (error_value + near_lossless) / (2 * near_lossless + 1);

        return -(near_lossless - error_value) / (2 * near_lossless + 1);
    }

    FORCE_INLINE int32_t dequantize(const int32_t error_value) const noexcept
    {
        return error_value * (2 * near_lossless + 1);
    }

    FORCE_INLINE SampleType fix_reconstructed_value(int32_t value) const noexcept
    {
        if (value < -near_lossless)
        {
            value = value + range * (2 * near_lossless + 1);
        }
        else if (value > maximum_sample_value + near_lossless)
        {
            value = value - range * (2 * near_lossless + 1);
        }

        return static_cast<SampleType>(correct_prediction(value));
    }
};

} // namespace charls