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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
// 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.
#include "lib/extras/dec/pgx.h"
#include <string.h>
#include "lib/extras/size_constraints.h"
#include "lib/jxl/base/bits.h"
#include "lib/jxl/base/compiler_specific.h"
namespace jxl {
namespace extras {
namespace {
struct HeaderPGX {
// NOTE: PGX is always grayscale
size_t xsize;
size_t ysize;
size_t bits_per_sample;
bool big_endian;
bool is_signed;
};
class Parser {
public:
explicit Parser(const Span<const uint8_t> bytes)
: pos_(bytes.data()), end_(pos_ + bytes.size()) {}
// Sets "pos" to the first non-header byte/pixel on success.
Status ParseHeader(HeaderPGX* header, const uint8_t** pos) {
// codec.cc ensures we have at least two bytes => no range check here.
if (pos_[0] != 'P' || pos_[1] != 'G') return false;
pos_ += 2;
return ParseHeaderPGX(header, pos);
}
// Exposed for testing
Status ParseUnsigned(size_t* number) {
if (pos_ == end_) return JXL_FAILURE("PGX: reached end before number");
if (!IsDigit(*pos_)) return JXL_FAILURE("PGX: expected unsigned number");
*number = 0;
while (pos_ < end_ && *pos_ >= '0' && *pos_ <= '9') {
*number *= 10;
*number += *pos_ - '0';
++pos_;
}
return true;
}
private:
static bool IsDigit(const uint8_t c) { return '0' <= c && c <= '9'; }
static bool IsLineBreak(const uint8_t c) { return c == '\r' || c == '\n'; }
static bool IsWhitespace(const uint8_t c) {
return IsLineBreak(c) || c == '\t' || c == ' ';
}
Status SkipSpace() {
if (pos_ == end_) return JXL_FAILURE("PGX: reached end before space");
const uint8_t c = *pos_;
if (c != ' ') return JXL_FAILURE("PGX: expected space");
++pos_;
return true;
}
Status SkipLineBreak() {
if (pos_ == end_) return JXL_FAILURE("PGX: reached end before line break");
// Line break can be either "\n" (0a) or "\r\n" (0d 0a).
if (*pos_ == '\n') {
pos_++;
return true;
} else if (*pos_ == '\r' && pos_ + 1 != end_ && *(pos_ + 1) == '\n') {
pos_ += 2;
return true;
}
return JXL_FAILURE("PGX: expected line break");
}
Status SkipSingleWhitespace() {
if (pos_ == end_) return JXL_FAILURE("PGX: reached end before whitespace");
if (!IsWhitespace(*pos_)) return JXL_FAILURE("PGX: expected whitespace");
++pos_;
return true;
}
Status ParseHeaderPGX(HeaderPGX* header, const uint8_t** pos) {
JXL_RETURN_IF_ERROR(SkipSpace());
if (pos_ + 2 > end_) return JXL_FAILURE("PGX: header too small");
if (*pos_ == 'M' && *(pos_ + 1) == 'L') {
header->big_endian = true;
} else if (*pos_ == 'L' && *(pos_ + 1) == 'M') {
header->big_endian = false;
} else {
return JXL_FAILURE("PGX: invalid endianness");
}
pos_ += 2;
JXL_RETURN_IF_ERROR(SkipSpace());
if (pos_ == end_) return JXL_FAILURE("PGX: header too small");
if (*pos_ == '+') {
header->is_signed = false;
} else if (*pos_ == '-') {
header->is_signed = true;
} else {
return JXL_FAILURE("PGX: invalid signedness");
}
pos_++;
// Skip optional space
if (pos_ < end_ && *pos_ == ' ') pos_++;
JXL_RETURN_IF_ERROR(ParseUnsigned(&header->bits_per_sample));
JXL_RETURN_IF_ERROR(SkipSingleWhitespace());
JXL_RETURN_IF_ERROR(ParseUnsigned(&header->xsize));
JXL_RETURN_IF_ERROR(SkipSingleWhitespace());
JXL_RETURN_IF_ERROR(ParseUnsigned(&header->ysize));
// 0xa, or 0xd 0xa.
JXL_RETURN_IF_ERROR(SkipLineBreak());
// TODO(jon): could do up to 24-bit by converting the values to
// JXL_TYPE_FLOAT.
if (header->bits_per_sample > 16) {
return JXL_FAILURE("PGX: >16 bits not yet supported");
}
// TODO(lode): support signed integers. This may require changing the way
// external_image works.
if (header->is_signed) {
return JXL_FAILURE("PGX: signed not yet supported");
}
size_t numpixels = header->xsize * header->ysize;
size_t bytes_per_pixel = header->bits_per_sample <= 8 ? 1 : 2;
if (pos_ + numpixels * bytes_per_pixel > end_) {
return JXL_FAILURE("PGX: data too small");
}
*pos = pos_;
return true;
}
const uint8_t* pos_;
const uint8_t* const end_;
};
} // namespace
Status DecodeImagePGX(const Span<const uint8_t> bytes,
const ColorHints& color_hints, PackedPixelFile* ppf,
const SizeConstraints* constraints) {
Parser parser(bytes);
HeaderPGX header = {};
const uint8_t* pos;
if (!parser.ParseHeader(&header, &pos)) return false;
JXL_RETURN_IF_ERROR(
VerifyDimensions(constraints, header.xsize, header.ysize));
if (header.bits_per_sample == 0 || header.bits_per_sample > 32) {
return JXL_FAILURE("PGX: bits_per_sample invalid");
}
JXL_RETURN_IF_ERROR(ApplyColorHints(color_hints, /*color_already_set=*/false,
/*is_gray=*/true, ppf));
ppf->info.xsize = header.xsize;
ppf->info.ysize = header.ysize;
// Original data is uint, so exponent_bits_per_sample = 0.
ppf->info.bits_per_sample = header.bits_per_sample;
ppf->info.exponent_bits_per_sample = 0;
ppf->info.uses_original_profile = true;
// No alpha in PGX
ppf->info.alpha_bits = 0;
ppf->info.alpha_exponent_bits = 0;
ppf->info.num_color_channels = 1; // Always grayscale
ppf->info.orientation = JXL_ORIENT_IDENTITY;
JxlDataType data_type;
if (header.bits_per_sample > 8) {
data_type = JXL_TYPE_UINT16;
} else {
data_type = JXL_TYPE_UINT8;
}
const JxlPixelFormat format{
/*num_channels=*/1,
/*data_type=*/data_type,
/*endianness=*/header.big_endian ? JXL_BIG_ENDIAN : JXL_LITTLE_ENDIAN,
/*align=*/0,
};
ppf->frames.clear();
// Allocates the frame buffer.
ppf->frames.emplace_back(header.xsize, header.ysize, format);
const auto& frame = ppf->frames.back();
size_t pgx_remaining_size = bytes.data() + bytes.size() - pos;
if (pgx_remaining_size < frame.color.pixels_size) {
return JXL_FAILURE("PGX file too small");
}
memcpy(frame.color.pixels(), pos, frame.color.pixels_size);
return true;
}
} // namespace extras
} // namespace jxl
|
