Debian Codegraph @

lib/jxl/jpeg/jpeg_data.h

raw
1 // Copyright (c) the JPEG XL Project Authors. All rights reserved.
2 //
3 // Use of this source code is governed by a BSD-style
4 // license that can be found in the LICENSE file.
5
6 // Data structures that represent the non-pixel contents of a jpeg file.
7
8 #ifndef LIB_JXL_JPEG_JPEG_DATA_H_
9 #define LIB_JXL_JPEG_JPEG_DATA_H_
10
11 #include <array>
12 #include <cstddef>
13 #include <cstdint>
14 #include <vector>
15
16 #include "lib/jxl/base/status.h"
17 #include "lib/jxl/common.h" // JPEGXL_ENABLE_TRANSCODE_JPEG
18 #include "lib/jxl/field_encodings.h"
19 #include "lib/jxl/fields.h"
20 #include "lib/jxl/frame_dimensions.h"
21
22 namespace jxl {
23 namespace jpeg {
24
25 constexpr int kMaxComponents = 4;
26 constexpr int kMaxQuantTables = 4;
27 constexpr int kMaxHuffmanTables = 4;
28 constexpr size_t kJpegHuffmanMaxBitLength = 16;
29 constexpr int kJpegHuffmanAlphabetSize = 256;
30 constexpr int kJpegDCAlphabetSize = 12;
31 constexpr int kMaxDHTMarkers = 512;
32 constexpr int kMaxDimPixels = 65535;
33 constexpr uint8_t kApp1 = 0xE1;
34 constexpr uint8_t kApp2 = 0xE2;
35 const uint8_t kIccProfileTag[12] = "ICC_PROFILE";
36 const uint8_t kExifTag[6] = "Exif\0";
37 const uint8_t kXMPTag[29] = "http://ns.adobe.com/xap/1.0/";
38
39 /* clang-format off */
40 constexpr uint32_t kJPEGNaturalOrder[80] = {
41 0, 1, 8, 16, 9, 2, 3, 10,
42 17, 24, 32, 25, 18, 11, 4, 5,
43 12, 19, 26, 33, 40, 48, 41, 34,
44 27, 20, 13, 6, 7, 14, 21, 28,
45 35, 42, 49, 56, 57, 50, 43, 36,
46 29, 22, 15, 23, 30, 37, 44, 51,
47 58, 59, 52, 45, 38, 31, 39, 46,
48 53, 60, 61, 54, 47, 55, 62, 63,
49 // extra entries for safety in decoder
50 63, 63, 63, 63, 63, 63, 63, 63,
51 63, 63, 63, 63, 63, 63, 63, 63
52 };
53
54 constexpr uint32_t kJPEGZigZagOrder[64] = {
55 0, 1, 5, 6, 14, 15, 27, 28,
56 2, 4, 7, 13, 16, 26, 29, 42,
57 3, 8, 12, 17, 25, 30, 41, 43,
58 9, 11, 18, 24, 31, 40, 44, 53,
59 10, 19, 23, 32, 39, 45, 52, 54,
60 20, 22, 33, 38, 46, 51, 55, 60,
61 21, 34, 37, 47, 50, 56, 59, 61,
62 35, 36, 48, 49, 57, 58, 62, 63
63 };
64 /* clang-format on */
65
66 // Quantization values for an 8x8 pixel block.
67 struct JPEGQuantTable {
68 std::array<int32_t, kDCTBlockSize> values;
69 uint32_t precision = 0;
70 // The index of this quantization table as it was parsed from the input JPEG.
71 // Each DQT marker segment contains an 'index' field, and we save this index
72 // here. Valid values are 0 to 3.
73 uint32_t index = 0;
74 // Set to true if this table is the last one within its marker segment.
75 bool is_last = true;
76 };
77
78 // Huffman code and decoding lookup table used for DC and AC coefficients.
79 struct JPEGHuffmanCode {
80 // Bit length histogram.
81 std::array<uint32_t, kJpegHuffmanMaxBitLength + 1> counts = {};
82 // Symbol values sorted by increasing bit lengths.
83 std::array<uint32_t, kJpegHuffmanAlphabetSize + 1> values = {};
84 // The index of the Huffman code in the current set of Huffman codes. For AC
85 // component Huffman codes, 0x10 is added to the index.
86 int slot_id = 0;
87 // Set to true if this Huffman code is the last one within its marker segment.
88 bool is_last = true;
89 };
90
91 // Huffman table indexes used for one component of one scan.
92 struct JPEGComponentScanInfo {
93 uint32_t comp_idx;
94 uint32_t dc_tbl_idx;
95 uint32_t ac_tbl_idx;
96 };
97
98 // Contains information that is used in one scan.
99 struct JPEGScanInfo {
100 // Parameters used for progressive scans (named the same way as in the spec):
101 // Ss : Start of spectral band in zig-zag sequence.
102 // Se : End of spectral band in zig-zag sequence.
103 // Ah : Successive approximation bit position, high.
104 // Al : Successive approximation bit position, low.
105 uint32_t Ss;
106 uint32_t Se;
107 uint32_t Ah;
108 uint32_t Al;
109 uint32_t num_components = 0;
110 std::array<JPEGComponentScanInfo, 4> components;
111 // Last codestream pass that is needed to write this scan.
112 uint32_t last_needed_pass = 0;
113
114 // Extra information required for bit-precise JPEG file reconstruction.
115
116 // Set of block indexes where the JPEG encoder has to flush the end-of-block
117 // runs and refinement bits.
118 std::vector<uint32_t> reset_points;
119 // The number of extra zero runs (Huffman symbol 0xf0) before the end of
120 // block (if nonzero), indexed by block index.
121 // All of these symbols can be omitted without changing the pixel values, but
122 // some jpeg encoders put these at the end of blocks.
123 typedef struct {
124 uint32_t block_idx;
125 uint32_t num_extra_zero_runs;
126 } ExtraZeroRunInfo;
127 std::vector<ExtraZeroRunInfo> extra_zero_runs;
128 };
129
130 typedef int16_t coeff_t;
131
132 // Represents one component of a jpeg file.
133 struct JPEGComponent {
134 JPEGComponent()
135 : id(0),
136 h_samp_factor(1),
137 v_samp_factor(1),
138 quant_idx(0),
139 width_in_blocks(0),
140 height_in_blocks(0) {}
141
142 // One-byte id of the component.
143 uint32_t id;
144 // Horizontal and vertical sampling factors.
145 // In interleaved mode, each minimal coded unit (MCU) has
146 // h_samp_factor x v_samp_factor DCT blocks from this component.
147 int h_samp_factor;
148 int v_samp_factor;
149 // The index of the quantization table used for this component.
150 uint32_t quant_idx;
151 // The dimensions of the component measured in 8x8 blocks.
152 uint32_t width_in_blocks;
153 uint32_t height_in_blocks;
154 // The DCT coefficients of this component, laid out block-by-block, divided
155 // through the quantization matrix values.
156 std::vector<coeff_t> coeffs;
157 };
158
159 enum class AppMarkerType : uint32_t {
160 kUnknown = 0,
161 kICC = 1,
162 kExif = 2,
163 kXMP = 3,
164 };
165
166 // Represents a parsed jpeg file.
167 struct JPEGData : public Fields {
168 JPEGData()
169 : width(0), height(0), restart_interval(0), has_zero_padding_bit(false) {}
170
171 JXL_FIELDS_NAME(JPEGData)
172 #if JPEGXL_ENABLE_TRANSCODE_JPEG
173 // Doesn't serialize everything - skips brotli-encoded data and what is
174 // already encoded in the codestream.
175 Status VisitFields(Visitor* visitor) override;
176 #else
177 Status VisitFields(Visitor* /* visitor */) override {
178 return JXL_UNREACHABLE("JPEG transcoding support not enabled");
179 }
180 #endif // JPEGXL_ENABLE_TRANSCODE_JPEG
181
182 void CalculateMcuSize(const JPEGScanInfo& scan, int* MCUs_per_row,
183 int* MCU_rows) const;
184
185 int width;
186 int height;
187 uint32_t restart_interval;
188 std::vector<std::vector<uint8_t>> app_data;
189 std::vector<AppMarkerType> app_marker_type;
190 std::vector<std::vector<uint8_t>> com_data;
191 std::vector<JPEGQuantTable> quant;
192 std::vector<JPEGHuffmanCode> huffman_code;
193 std::vector<JPEGComponent> components;
194 std::vector<JPEGScanInfo> scan_info;
195 std::vector<uint8_t> marker_order;
196 std::vector<std::vector<uint8_t>> inter_marker_data;
197 std::vector<uint8_t> tail_data;
198
199 // Extra information required for bit-precise JPEG file reconstruction.
200
201 bool has_zero_padding_bit;
202 std::vector<uint8_t> padding_bits;
203 };
204
205 #if JPEGXL_ENABLE_TRANSCODE_JPEG
206 // Set ICC profile in jpeg_data.
207 Status SetJPEGDataFromICC(const std::vector<uint8_t>& icc,
208 jpeg::JPEGData* jpeg_data);
209 #else
210 static JXL_INLINE Status SetJPEGDataFromICC(
211 const std::vector<uint8_t>& /* icc */, jpeg::JPEGData* /* jpeg_data */) {
212 return JXL_UNREACHABLE("JPEG transcoding support not enabled");
213 }
214 #endif // JPEGXL_ENABLE_TRANSCODE_JPEG
215
216 } // namespace jpeg
217 } // namespace jxl
218
219 #endif // LIB_JXL_JPEG_JPEG_DATA_H_