From 4c70c938e672b7f91328f83d361e7848d16c0472 Mon Sep 17 00:00:00 2001 From: Mar Dominguez Date: Wed, 28 Oct 2026 19:11:26 +0100 Subject: [PATCH] Fix lines left unconverted for NLT type 0 and unsigned type 3 Since #356, tile::push() and tile::pull() pick the sample converter of a component by the type of its NLT record: the plain converter when there is no record, the type 3 converter for type 3 (for signed samples only on the reversible path), and the LUT converter for types 2 and 4. Before cases now match no branch, so no converter runs and the line keeps whatever its buffer held before: - a type 0 (no nonlinearity) record, which param_nlt::read() accepts and set_nonlinear_transform(c, OJPH_NLT_NO_NLT) writes for a component that should not use the nonlinearity of the other components; - type 3 on an unsigned component that uses the reversible path. On decoding, the output lines of such a component are never written, so the application receives the uninitialized contents of the line buffers allocated in codestream::finalize_alloc() instead of the decoded samples; MemorySanitizer reports their use. On encoding, the codestream is built from the uninitialized contents of the tile's lines. Set nlt_ptr to NULL for both cases in tile::finalize_alloc(), so that every dispatch in push() and pull(), with and without the colour transform, uses the plain converter for them, as before #356. Add three tests to tests/test_nlt.cpp: - TypeZeroRecordOfOneComponentKeepsSamples: type 3 for all components and type 0 for one of them; that component decodes to the same samples as without a nonlinearity, and the reversible round trip is lossless. - TypeZeroMarkerSegmentKeepsSamples: a codestream with an inserted type 0 NLT marker segment decodes to the same samples as without it. - BinaryComplementOfUnsignedSamplesIsLossless: a reversible round trip of 8-bit unsigned samples with type 3 is lossless, with and without the colour transform and with and without a type 0 component. The encoding and decoding helpers of the test use interleaved lines when the colour transform is employed, as the library requires. All three tests fail without this change and pass with it; the rest of the test suite passes. --- src/core/codestream/ojph_tile.cpp | 10 +- tests/test_nlt.cpp | 272 ++++++++++++++++++++++++++---- 2 files changed, 247 insertions(+), 35 deletions(-) diff --git a/src/core/codestream/ojph_tile.cpp b/src/core/codestream/ojph_tile.cpp index 7fc26db2..b59ef97d 100644 --- a/src/core/codestream/ojph_tile.cpp +++ b/src/core/codestream/ojph_tile.cpp @@ -192,6 +192,8 @@ namespace ojph { ui32 tile_idx, ui32& offset, ui32 &num_tileparts) { + constexpr ui8 type0 = + param_nlt::nonlinearity::OJPH_NLT_NO_NLT; constexpr ui8 type3 = param_nlt::nonlinearity::OJPH_NLT_BINARY_COMPLEMENT_NLT; @@ -291,6 +293,7 @@ namespace ojph { num_bits[i] = szp->get_bit_depth(i); is_signed[i] = szp->is_signed(i); nlt_ptr[i] = nlp->get_nlt_rec(i); + reversible[i] = codestream->get_coc(i)->is_reversible(); if (nlt_ptr[i]) { @@ -303,9 +306,14 @@ namespace ojph { "(bit_depth = %d, is_signed = %s) from NLT marker segment, " "for component %d", num_bits[i], is_signed[i] ? "True" : "False", bd, is ? "True" : "False", i); + + // type 0, and type 3 on unsigned reversible samples, change + // nothing; push() and pull() convert both as no nonlinearity + if (nlt_type == type0 || + (nlt_type == type3 && !is_signed[i] && reversible[i])) + nlt_ptr[i] = NULL; } cur_line[i] = 0; - reversible[i] = codestream->get_coc(i)->is_reversible(); } offset += tile_rect.siz.w; diff --git a/tests/test_nlt.cpp b/tests/test_nlt.cpp index 905e3a39..b28405d3 100644 --- a/tests/test_nlt.cpp +++ b/tests/test_nlt.cpp @@ -235,6 +235,8 @@ namespace { struct test_image { ui32 width = 0, height = 0, num_comps = 0; + ui32 bit_depth = 32; // of every component + bool is_signed = true; // of every component std::vector > samples; // one entry per component size_t num_samples() const @@ -426,6 +428,8 @@ namespace { bool use_clustered_lut = false; // true: the table of clusteredLutPoints bool use_approx_inverse = false; // true: approx encoding LUT ui8 pt_val = 32; // precision of each LUT point + int no_nlt_comp = -1; // >= 0: this component gets a type 0 record + bool color_transform = false; // true: the colour transform is employed bool reversible; // false: the 9/7 wavelet, true: the 5/3 wavelet float qstep; // the quantization step used with the 9/7 wavelet }; @@ -502,6 +506,9 @@ namespace { d_min, d_max, setting.pt_val, (ui16)num_points, points, setting.type, setting.use_approx_inverse, 0); } + if (setting.no_nlt_comp >= 0) + nlt.set_nonlinear_transform((ui32)setting.no_nlt_comp, + param_nlt::OJPH_NLT_NO_NLT); } /////////////////////////////////////////////////////////////////////////// @@ -516,7 +523,7 @@ namespace { siz.set_image_extent(point(img.width, img.height)); siz.set_num_components(img.num_comps); for (ui32 c = 0; c < img.num_comps; ++c) - siz.set_component(c, point(1, 1), 32, true); + siz.set_component(c, point(1, 1), img.bit_depth, img.is_signed); siz.set_image_offset(point(0, 0)); siz.set_tile_size(size(img.width, img.height)); siz.set_tile_offset(point(0, 0)); @@ -524,14 +531,16 @@ namespace { param_cod cod = cs.access_cod(); cod.set_num_decomposition(5); cod.set_block_dims(64, 64); - cod.set_color_transform(false); + cod.set_color_transform(setting.color_transform); cod.set_reversible(setting.reversible); if (!setting.reversible) cs.access_qcd().set_irrev_quant(setting.qstep); apply_nlt(cs, setting); - cs.set_planar(true); + // the colour transform needs the lines of the components interleaved + const bool planar = !setting.color_transform; + cs.set_planar(planar); j2c_outfile file; file.open(filename.c_str()); @@ -540,14 +549,15 @@ namespace { ui32 next_comp; line_buf* cur_line = cs.exchange(NULL, next_comp); ASSERT_TRUE(cur_line != NULL) << filename; - for (ui32 c = 0; c < img.num_comps; ++c) - for (ui32 y = 0; y < img.height; ++y) - { - ASSERT_EQ(next_comp, c) << filename; - for (ui32 x = 0; x < img.width; ++x) - cur_line->i32[x] = img.samples[c][(size_t)y * img.width + x]; - cur_line = cs.exchange(cur_line, next_comp); - } + for (ui32 n = 0; n < img.num_comps * img.height; ++n) + { + ui32 c = planar ? n / img.height : n % img.num_comps; + ui32 y = planar ? n % img.height : n / img.num_comps; + ASSERT_EQ(next_comp, c) << filename; + for (ui32 x = 0; x < img.width; ++x) + cur_line->i32[x] = img.samples[c][(size_t)y * img.width + x]; + cur_line = cs.exchange(cur_line, next_comp); + } cs.flush(); cs.close(); @@ -580,25 +590,30 @@ namespace { param_siz siz = cs.access_siz(); img.num_comps = siz.get_num_components(); + img.bit_depth = siz.get_bit_depth(0); + img.is_signed = siz.is_signed(0); img.width = siz.get_recon_width(0); img.height = siz.get_recon_height(0); img.samples.assign(img.num_comps, std::vector((size_t)img.width * img.height, 0)); cs.restrict_input_resolution(0, 0); - cs.set_planar(true); + // the colour transform needs the lines of the components interleaved + const bool planar = !cs.access_cod().is_using_color_transform(); + cs.set_planar(planar); cs.create(); - for (ui32 c = 0; c < img.num_comps; ++c) - for (ui32 y = 0; y < img.height; ++y) - { - ui32 comp_num = 0; - line_buf* line = cs.pull(comp_num); - ASSERT_TRUE(line != NULL) << filename; - ASSERT_EQ(comp_num, c) << filename; - for (ui32 x = 0; x < img.width; ++x) - img.samples[c][(size_t)y * img.width + x] = line->i32[x]; - } + for (ui32 n = 0; n < img.num_comps * img.height; ++n) + { + ui32 c = planar ? n / img.height : n % img.num_comps; + ui32 y = planar ? n % img.height : n / img.num_comps; + ui32 comp_num = 0; + line_buf* line = cs.pull(comp_num); + ASSERT_TRUE(line != NULL) << filename; + ASSERT_EQ(comp_num, c) << filename; + for (ui32 x = 0; x < img.width; ++x) + img.samples[c][(size_t)y * img.width + x] = line->i32[x]; + } cs.close(); } @@ -833,12 +848,11 @@ namespace { } /////////////////////////////////////////////////////////////////////////// - // Inserts an NLT marker segment for a LUT style nonlinearity into a - // codestream, right before its first tile part. The library refuses to - // write that combination, so a codestream that carries it has to be put - // together here, the way another encoder may have produced it. + // Inserts a marker segment into a codestream, right before its first tile + // part /////////////////////////////////////////////////////////////////////////// - bool insert_lut_nlt_marker(const std::string& filename, ui8 nlt_type) + bool insert_main_header_marker(const std::string& filename, + const std::vector& marker) { FILE* f = fopen(filename.c_str(), "rb"); if (f == NULL) @@ -862,6 +876,24 @@ namespace { if (sot == data.size()) return false; + data.insert(data.begin() + (long)sot, marker.begin(), marker.end()); + + f = fopen(filename.c_str(), "wb"); + if (f == NULL) + return false; + bool ok = fwrite(&data[0], 1, data.size(), f) == data.size(); + fclose(f); + return ok; + } + + /////////////////////////////////////////////////////////////////////////// + // Inserts an NLT marker segment for a LUT style nonlinearity into a + // codestream, right before its first tile part. The library refuses to + // write that combination, so a codestream that carries it has to be put + // together here, the way another encoder may have produced it. + /////////////////////////////////////////////////////////////////////////// + bool insert_lut_nlt_marker(const std::string& filename, ui8 nlt_type) + { const ui16 num_points = 17; const ui32 d_min = 0, d_max = 0xFFFFFFFFu; const ui32 length = 17u + 4u * (ui32)num_points; // as the library does @@ -890,14 +922,27 @@ namespace { marker.push_back((ui8)(point >> (8 * b))); } - data.insert(data.begin() + (long)sot, marker.begin(), marker.end()); + return insert_main_header_marker(filename, marker); + } - f = fopen(filename.c_str(), "wb"); - if (f == NULL) - return false; - bool ok = fwrite(&data[0], 1, data.size(), f) == data.size(); - fclose(f); - return ok; + /////////////////////////////////////////////////////////////////////////// + // Inserts an NLT marker segment of type 0, no nonlinearity, for all the + // components into a codestream whose components are 32 bit signed samples, + // right before its first tile part. Type 0 is a legal value of Tnlt, so + // another encoder may write such a marker segment. + /////////////////////////////////////////////////////////////////////////// + bool insert_no_nlt_marker(const std::string& filename) + { + std::vector marker; + marker.push_back(0xFF); + marker.push_back(0x76); // NLT + marker.push_back(0x00); + marker.push_back(0x06); // Lnlt = 6 + marker.push_back(0xFF); + marker.push_back(0xFF); // Cnlt = ALL_COMPS + marker.push_back(0x9F); // BDnlt: 32 bits, signed + marker.push_back(param_nlt::OJPH_NLT_NO_NLT); + return insert_main_header_marker(filename, marker); } /////////////////////////////////////////////////////////////////////////// @@ -1607,3 +1652,162 @@ TEST(NltTest, LutStyleWithReversibleWaveletIsReportedWhenRead) EXPECT_EQ((int)type, (int)param_nlt::OJPH_NLT_LUT_STYLE_NLT); cs.close(); } + +/////////////////////////////////////////////////////////////////////////////// +// A component can be given an NLT record of type 0, no nonlinearity, of its +// own, to keep it out of the nonlinearity the other components use. Such a +// component is coded as if the codestream had no nonlinearity, so its samples +// have to come back exactly as they come back from a codestream without a +// nonlinearity, with either wavelet; with the reversible wavelet, that means +// bit for bit. +/////////////////////////////////////////////////////////////////////////////// +TEST(NltTest, TypeZeroRecordOfOneComponentKeepsSamples) +{ + test_image img; + make_synthetic_image(img, 64, 64); + // a second component, which holds the samples of the first in reverse + img.num_comps = 2; + img.samples.push_back(std::vector(img.samples[0].rbegin(), + img.samples[0].rend())); + + for (int reversible = 0; reversible < 2; ++reversible) + { + nlt_setting plain; + plain.type = param_nlt::OJPH_NLT_NO_NLT; + plain.use_pfm_lut = false; + plain.reversible = reversible != 0; + plain.qstep = default_qstep(); + + // type 3 for all the components, except component 1, which gets type 0 + nlt_setting mixed = plain; + mixed.type = param_nlt::OJPH_NLT_BINARY_COMPLEMENT_NLT; + mixed.no_nlt_comp = 1; + + const std::string tag = reversible ? "_rev" : "_irv"; + const std::string plain_file = + std::string(OUT_FILE_DIR) + "nlt_type0_plain" + tag + ".j2c"; + const std::string mixed_file = + std::string(OUT_FILE_DIR) + "nlt_type0_mixed" + tag + ".j2c"; + encode_image(plain_file, img, plain); + encode_image(mixed_file, img, mixed); + + { + codestream cs; + j2c_infile file; + file.open(mixed_file.c_str()); + cs.read_headers(&file); + ui8 bit_depth = 0, type = 0xFF; + bool is_signed = false; + EXPECT_TRUE(cs.access_nlt().get_nonlinear_transform(1, bit_depth, + is_signed, type)) << tag; + EXPECT_EQ((int)type, (int)param_nlt::OJPH_NLT_NO_NLT) << tag; + cs.close(); + } + + test_image from_plain, from_mixed; + decode_image(plain_file, from_plain, NULL, NULL, NULL, NULL); + decode_image(mixed_file, from_mixed, NULL, NULL, NULL, NULL); + ASSERT_EQ(from_plain.num_comps, 2u) << tag; + ASSERT_EQ(from_mixed.num_comps, 2u) << tag; + + size_t num_changed = 0; + for (size_t i = 0; i < from_plain.samples[1].size(); ++i) + if (from_mixed.samples[1][i] != from_plain.samples[1][i]) + ++num_changed; + EXPECT_EQ(num_changed, (size_t)0) << tag << ": " << num_changed + << " samples of component 1 differ from those of a codestream without " + << "a nonlinearity"; + + if (reversible) + { + comparison result = compare_images(img, from_mixed); + EXPECT_TRUE(result.is_bit_exact()) << tag << ": " + << (result.num_samples - result.num_bit_exact) << " of " + << result.num_samples << " samples changed"; + } + } +} + +/////////////////////////////////////////////////////////////////////////////// +// Another encoder may write an NLT marker segment of type 0, no nonlinearity. +// A codestream that carries one has to decode to the same samples as the same +// codestream without it, with either wavelet. +/////////////////////////////////////////////////////////////////////////////// +TEST(NltTest, TypeZeroMarkerSegmentKeepsSamples) +{ + test_image img; + make_synthetic_image(img, 64, 64); + + for (int reversible = 0; reversible < 2; ++reversible) + { + nlt_setting setting; + setting.type = param_nlt::OJPH_NLT_NO_NLT; + setting.use_pfm_lut = false; + setting.reversible = reversible != 0; + setting.qstep = default_qstep(); + + const std::string tag = reversible ? "_rev" : "_irv"; + const std::string filename = + std::string(OUT_FILE_DIR) + "nlt_type0_marker" + tag + ".j2c"; + encode_image(filename, img, setting); + + test_image without; + decode_image(filename, without, NULL, NULL, NULL, NULL); + + ASSERT_TRUE(insert_no_nlt_marker(filename)) << tag; + bool has_nlt = false; + ui8 type = 0xFF; + test_image with; + decode_image(filename, with, &has_nlt, &type, NULL, NULL); + EXPECT_TRUE(has_nlt) << tag; + EXPECT_EQ((int)type, (int)param_nlt::OJPH_NLT_NO_NLT) << tag; + + comparison result = compare_images(without, with); + EXPECT_TRUE(result.is_bit_exact()) << tag << ": " + << (result.num_samples - result.num_bit_exact) << " of " + << result.num_samples << " samples differ from those decoded without " + << "the marker segment"; + } +} + +/////////////////////////////////////////////////////////////////////////////// +// The binary complement nonlinearity (type 3) leaves unsigned samples as they +// are, so a reversible round trip of unsigned samples with it in effect +// returns them bit for bit; so does one in which a component is given a type +// 0 record of its own. Both are checked with and without the colour +// transform, which takes its own path through the library. +/////////////////////////////////////////////////////////////////////////////// +TEST(NltTest, BinaryComplementOfUnsignedSamplesIsLossless) +{ + test_image img; + img.width = 64; + img.height = 64; + img.num_comps = 3; + img.bit_depth = 8; + img.is_signed = false; + img.samples.assign(3, std::vector((size_t)img.width * img.height)); + for (ui32 c = 0; c < 3; ++c) + for (size_t i = 0; i < img.samples[c].size(); ++i) + img.samples[c][i] = + (si32)((i * (7 + 2 * c) + (i / img.width) * (3 + c)) & 0xFF); + + for (int color_transform = 0; color_transform < 2; ++color_transform) + for (int type0 = 0; type0 < 2; ++type0) + { + nlt_setting setting; + setting.type = param_nlt::OJPH_NLT_BINARY_COMPLEMENT_NLT; + setting.use_pfm_lut = false; + setting.no_nlt_comp = type0 ? 1 : -1; + setting.color_transform = color_transform != 0; + setting.reversible = true; + setting.qstep = default_qstep(); + + const std::string tag = std::string("nlt_type3_unsigned") + + (color_transform ? "_ct" : "") + (type0 ? "_type0" : ""); + comparison result = round_trip(tag, img, setting); + EXPECT_TRUE(result.is_bit_exact()) << tag << ": " + << (result.num_samples - result.num_bit_exact) << " of " + << result.num_samples << " samples changed; the largest change is " + << result.max_abs_error; + } +}