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
156
157
158
159
160
161
162
163
|
// Copyright (c) the JPEG XL Project Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
#ifndef LIB_JXL_AUX_OUT_H_
#define LIB_JXL_AUX_OUT_H_
// Optional output information for debugging and analyzing size usage.
#include <stddef.h>
#include <array>
#include <functional>
#include <string>
#include "lib/jxl/image.h"
#include "lib/jxl/jxl_inspection.h"
namespace jxl {
struct ColorEncoding;
// For LayerName and AuxOut::layers[] index. Order does not matter.
enum {
kLayerHeader = 0,
kLayerTOC,
kLayerDictionary,
kLayerSplines,
kLayerNoise,
kLayerQuant,
kLayerModularTree,
kLayerModularGlobal,
kLayerDC,
kLayerModularDcGroup,
kLayerControlFields,
kLayerOrder,
kLayerAC,
kLayerACTokens,
kLayerModularAcGroup,
kNumImageLayers
};
const char* LayerName(size_t layer);
// Statistics gathered during compression or decompression.
struct AuxOut {
private:
struct LayerTotals {
void Assimilate(const LayerTotals& victim) {
num_clustered_histograms += victim.num_clustered_histograms;
histogram_bits += victim.histogram_bits;
extra_bits += victim.extra_bits;
total_bits += victim.total_bits;
clustered_entropy += victim.clustered_entropy;
}
void Print(size_t num_inputs) const;
size_t num_clustered_histograms = 0;
size_t extra_bits = 0;
// Set via BitsWritten below
size_t histogram_bits = 0;
size_t total_bits = 0;
double clustered_entropy = 0.0;
};
public:
AuxOut() = default;
AuxOut(const AuxOut&) = default;
void Assimilate(const AuxOut& victim);
void Print(size_t num_inputs) const;
size_t TotalBits() const {
size_t total = 0;
for (const auto& layer : layers) {
total += layer.total_bits;
}
return total;
}
template <typename T>
void DumpImage(const char* label, const Image3<T>& image) const;
void DumpXybImage(const char* label, const Image3F& image) const;
template <typename T>
void DumpPlaneNormalized(const char* label, const Plane<T>& image) const;
void SetInspectorImage3F(const jxl::InspectorImage3F& inspector) {
inspector_image3f_ = inspector;
}
// Allows hooking intermediate data inspection into various places of the
// processing pipeline. Returns true iff processing should proceed.
bool InspectImage3F(const char* label, const Image3F& image) {
if (inspector_image3f_ != nullptr) {
return inspector_image3f_(label, image);
}
return true;
}
std::array<LayerTotals, kNumImageLayers> layers;
size_t num_blocks = 0;
// Number of blocks that use larger DCT (set by ac_strategy).
size_t num_small_blocks = 0;
size_t num_dct4x8_blocks = 0;
size_t num_afv_blocks = 0;
size_t num_dct8_blocks = 0;
size_t num_dct8x16_blocks = 0;
size_t num_dct8x32_blocks = 0;
size_t num_dct16_blocks = 0;
size_t num_dct16x32_blocks = 0;
size_t num_dct32_blocks = 0;
size_t num_dct32x64_blocks = 0;
size_t num_dct64_blocks = 0;
std::array<uint32_t, 8> dc_pred_usage = {{0}};
std::array<uint32_t, 8> dc_pred_usage_xb = {{0}};
int num_butteraugli_iters = 0;
float max_quant_rescale = 1.0f;
float min_quant_rescale = 1.0f;
float min_bitrate_error = 0.0f;
float max_bitrate_error = 0.0f;
// If not empty, additional debugging information (e.g. debug images) is
// saved in files with this prefix.
std::string debug_prefix;
// By how much the decoded image was downsampled relative to the encoded
// image.
size_t downsampling = 1;
jxl::InspectorImage3F inspector_image3f_;
std::function<Status(Image3F&&, const ColorEncoding&, const std::string&)>
dump_image = nullptr;
};
extern template void AuxOut::DumpImage(const char* label,
const Image3<float>& image) const;
extern template void AuxOut::DumpImage(const char* label,
const Image3<uint8_t>& image) const;
extern template void AuxOut::DumpPlaneNormalized(
const char* label, const Plane<float>& image) const;
extern template void AuxOut::DumpPlaneNormalized(
const char* label, const Plane<uint8_t>& image) const;
// Used to skip image creation if they won't be written to debug directory.
static inline bool WantDebugOutput(const AuxOut* aux_out) {
// Need valid pointer and filename.
return aux_out != nullptr && !aux_out->debug_prefix.empty();
}
} // namespace jxl
#endif // LIB_JXL_AUX_OUT_H_
|
