mirror of
https://github.com/team-charls/charls
synced 2025-03-28 21:03:13 +00:00
Add support to decode JPEG-LS images with restart markers (#99)
* Add support to parse DRI segments * Add support to decode restart markers * Update CharLSTest to also decode color images none interleaved to ppm * Replace static_cast<void> with std::ignore * Update readme, changelog and refactor
This commit is contained in:
Victor Derks
GitHub
parent
3239c6fe80
commit
cb44fab24d
@ -19,6 +19,7 @@
|
||||
# -clang-diagnostic-switch-enum => Rationale: options are handled by default case
|
||||
# -clang-diagnostic-exit-time-destructors => Rationale: Acceptable construction
|
||||
# -clang-diagnostic-pragma-once-outside-header => Rationale: Generates false warnings for usage in header files
|
||||
# -clang-diagnostic-unused-const-variable => Rationale: false warnings for constexpr in .h files
|
||||
# -clang-analyzer-core.NonNullParamChecker => Rationale: cannot be effective disabled, already checked by other checkers.
|
||||
# -misc-non-private-member-variables-in-classes => Rationale: design can be ok, manual review is better
|
||||
# -modernize-use-trailing-return-type => Rationale: A style recommendation, this style is selected for CharLS
|
||||
@ -58,6 +59,7 @@ Checks: '*,
|
||||
-clang-diagnostic-switch-enum,
|
||||
-clang-diagnostic-exit-time-destructors,
|
||||
-clang-diagnostic-pragma-once-outside-header,
|
||||
-clang-diagnostic-unused-const-variable,
|
||||
-clang-analyzer-core.NonNullParamChecker,
|
||||
-misc-non-private-member-variables-in-classes,
|
||||
-modernize-use-trailing-return-type,
|
||||
|
||||
@ -6,6 +6,11 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
|
||||
|
||||
## [Next-Release]
|
||||
|
||||
### Added
|
||||
|
||||
- The encoder API has been extended with a rewind method that can be used to re-use a configered encoder to encode multiple images in a loop.
|
||||
- Added support to decode JPEG-LS images that use restart markers [#92](https://github.com/team-charls/charls/issues/92)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fixed [#84](https://github.com/team-charls/charls/issues/84), Default preset coding parameters not computed for unset values.
|
||||
@ -13,7 +18,6 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
|
||||
### Changed
|
||||
|
||||
- CMakeSettings.json has been replaced with CMakePresets.json.
|
||||
- The encoder API has been extended with a rewind method that can be used to re-use a configered encoder to encode multiple images in a loop.
|
||||
|
||||
## [2.2.0] - 2021-1-10
|
||||
|
||||
|
||||
@ -6,6 +6,7 @@
|
||||
<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClangTidyClangDiagnosticExitTimeDestructors/@EntryIndexedValue">DO_NOT_SHOW</s:String>
|
||||
<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClangTidyClangDiagnosticMissingBraces/@EntryIndexedValue">DO_NOT_SHOW</s:String>
|
||||
<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClangTidyClangDiagnosticSwitchEnum/@EntryIndexedValue">DO_NOT_SHOW</s:String>
|
||||
<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClangTidyClangDiagnosticUnusedConstVariable/@EntryIndexedValue">DO_NOT_SHOW</s:String>
|
||||
<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClangTidyCppcoreguidelinesAvoidMagicNumbers/@EntryIndexedValue">DO_NOT_SHOW</s:String>
|
||||
<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClangTidyCppcoreguidelinesInitVariables/@EntryIndexedValue">DO_NOT_SHOW</s:String>
|
||||
<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClangTidyCppcoreguidelinesMacroUsage/@EntryIndexedValue">DO_NOT_SHOW</s:String>
|
||||
@ -46,6 +47,7 @@
|
||||
<s:Boolean x:Key="/Default/UserDictionary/Words/=bugprone/@EntryIndexedValue">True</s:Boolean>
|
||||
<s:Boolean x:Key="/Default/UserDictionary/Words/=CHARLS/@EntryIndexedValue">True</s:Boolean>
|
||||
<s:Boolean x:Key="/Default/UserDictionary/Words/=charlstest/@EntryIndexedValue">True</s:Boolean>
|
||||
<s:Boolean x:Key="/Default/UserDictionary/Words/=cmove/@EntryIndexedValue">True</s:Boolean>
|
||||
<s:Boolean x:Key="/Default/UserDictionary/Words/=cmyk/@EntryIndexedValue">True</s:Boolean>
|
||||
<s:Boolean x:Key="/Default/UserDictionary/Words/=cpixel/@EntryIndexedValue">True</s:Boolean>
|
||||
<s:Boolean x:Key="/Default/UserDictionary/Words/=cppcoreguidelines/@EntryIndexedValue">True</s:Boolean>
|
||||
|
||||
@ -34,8 +34,8 @@ According to preliminary test results published on <http://imagecompression.info
|
||||
|
||||
The following JPEG-LS options are not supported by the CharLS implementation. Most of these options are rarely used in practice.
|
||||
|
||||
* No support for JPEG restart markers (RST).
|
||||
Restart markers make it possible to recover from corrupted JPEG files, but are seldom used for data recovery scenarios.
|
||||
* No support to encode JPEG restart markers
|
||||
Decoding is supported, but no recovery mechanisme is implemented for corrupted JPEG-LS files.
|
||||
* No support for sub-sampled scans.
|
||||
Sub-sampling is a lossly encoding mechanism and not used in lossless scenarios.
|
||||
* No support for multi component frames with mixed component counts in a single scan.
|
||||
|
||||
@ -50,6 +50,8 @@ enum charls_jpegls_errc
|
||||
CHARLS_JPEGLS_ERRC_INVALID_JPEGLS_PRESET_PARAMETER_TYPE = 22,
|
||||
CHARLS_JPEGLS_ERRC_JPEGLS_PRESET_EXTENDED_PARAMETER_TYPE_NOT_SUPPORTED = 23,
|
||||
CHARLS_JPEGLS_ERRC_MISSING_END_OF_SPIFF_DIRECTORY = 24,
|
||||
CHARLS_JPEGLS_ERRC_UNEXPECTED_RESTART_MARKER = 25,
|
||||
CHARLS_JPEGLS_ERRC_RESTART_MARKER_NOT_FOUND = 26,
|
||||
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_WIDTH = 100,
|
||||
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_HEIGHT = 101,
|
||||
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_COMPONENT_COUNT = 102,
|
||||
@ -285,6 +287,16 @@ enum class CHARLS_NO_DISCARD jpegls_errc
|
||||
/// </summary>
|
||||
missing_end_of_spiff_directory = impl::CHARLS_JPEGLS_ERRC_MISSING_END_OF_SPIFF_DIRECTORY,
|
||||
|
||||
/// <summary>
|
||||
/// This error is returned when a restart marker is found outside the encoded entropy data.
|
||||
/// </summary>
|
||||
unexpected_restart_marker = impl::CHARLS_JPEGLS_ERRC_UNEXPECTED_RESTART_MARKER,
|
||||
|
||||
/// <summary>
|
||||
/// This error is returned when an expected restart marker is not found. It may indicate data corruption in the JPEG-LS byte stream.
|
||||
/// </summary>
|
||||
restart_marker_not_found = impl::CHARLS_JPEGLS_ERRC_RESTART_MARKER_NOT_FOUND,
|
||||
|
||||
/// <summary>
|
||||
/// The argument for the width parameter is outside the range [1, 65535].
|
||||
/// </summary>
|
||||
|
||||
@ -210,7 +210,7 @@ private:
|
||||
component_count};
|
||||
|
||||
const auto codec{jls_codec_factory<encoder_strategy>().create_codec(
|
||||
frame_info, {near_lossless_, interleave_mode_, color_transformation_, false}, validated_pc_parameters_)};
|
||||
frame_info, {near_lossless_, 0, interleave_mode_, color_transformation_, false}, validated_pc_parameters_)};
|
||||
std::unique_ptr<process_line> process_line(codec->create_process_line(source, stride));
|
||||
const size_t bytes_written{codec->encode_scan(move(process_line), writer_.remaining_destination())};
|
||||
|
||||
|
||||
@ -10,6 +10,7 @@ namespace charls {
|
||||
struct coding_parameters final
|
||||
{
|
||||
int32_t near_lossless;
|
||||
uint32_t restart_interval;
|
||||
charls::interleave_mode interleave_mode;
|
||||
color_transformation transformation;
|
||||
bool output_bgr;
|
||||
|
||||
@ -64,7 +64,7 @@ struct jls_context final
|
||||
{
|
||||
b = -n + 1;
|
||||
}
|
||||
C = C - (C > -128);
|
||||
C = C - static_cast<int16_t>(C > -128);
|
||||
}
|
||||
else if (b > 0)
|
||||
{
|
||||
@ -73,7 +73,7 @@ struct jls_context final
|
||||
{
|
||||
b = 0;
|
||||
}
|
||||
C = C + (C < 127);
|
||||
C = C + static_cast<int16_t>(C < 127);
|
||||
}
|
||||
B = b;
|
||||
|
||||
|
||||
@ -30,7 +30,7 @@ public:
|
||||
decoder_strategy& operator=(decoder_strategy&&) = delete;
|
||||
|
||||
virtual std::unique_ptr<process_line> create_process_line(byte_span destination, size_t stride) = 0;
|
||||
virtual void set_presets(const jpegls_pc_parameters& preset_coding_parameters) = 0;
|
||||
virtual void set_presets(const jpegls_pc_parameters& preset_coding_parameters, uint32_t restart_interval) = 0;
|
||||
virtual void decode_scan(std::unique_ptr<process_line> output_data, const JlsRect& size, byte_span& compressed_data) = 0;
|
||||
|
||||
void initialize(const byte_span source)
|
||||
@ -45,6 +45,15 @@ public:
|
||||
make_valid();
|
||||
}
|
||||
|
||||
void reset()
|
||||
{
|
||||
valid_bits_ = 0;
|
||||
read_cache_ = 0;
|
||||
|
||||
next_ff_position_ = find_next_ff();
|
||||
make_valid();
|
||||
}
|
||||
|
||||
FORCE_INLINE void skip(const int32_t length) noexcept
|
||||
{
|
||||
valid_bits_ -= length;
|
||||
@ -246,6 +255,14 @@ public:
|
||||
return (read_value(length - 24) << 24) + read_value(24);
|
||||
}
|
||||
|
||||
uint8_t read_byte() noexcept
|
||||
{
|
||||
// TODO: check end_position first.
|
||||
const uint8_t value = *position_;
|
||||
++position_;
|
||||
return value;
|
||||
}
|
||||
|
||||
protected:
|
||||
frame_info frame_info_;
|
||||
coding_parameters parameters_;
|
||||
|
||||
@ -25,7 +25,7 @@ public:
|
||||
encoder_strategy& operator=(encoder_strategy&&) = delete;
|
||||
|
||||
virtual std::unique_ptr<process_line> create_process_line(byte_span stream_info, size_t stride) = 0;
|
||||
virtual void set_presets(const jpegls_pc_parameters& preset_coding_parameters) = 0;
|
||||
virtual void set_presets(const jpegls_pc_parameters& preset_coding_parameters, uint32_t restart_interval) = 0;
|
||||
virtual size_t encode_scan(std::unique_ptr<process_line> raw_data, byte_span destination) = 0;
|
||||
|
||||
int32_t peek_byte();
|
||||
|
||||
@ -16,12 +16,15 @@ namespace charls {
|
||||
// 0x4F - 0x6F, 0x90 - 0x93 are defined in ISO/IEC 15444-1: JPEG 2000
|
||||
|
||||
constexpr uint8_t jpeg_marker_start_byte{0xFF};
|
||||
constexpr uint8_t jpeg_restart_marker_base{0xD0}; // RSTm: Marks the next restart interval (range is D0..D7)
|
||||
constexpr uint32_t jpeg_restart_marker_range{8};
|
||||
|
||||
enum class jpeg_marker_code : uint8_t
|
||||
{
|
||||
start_of_image = 0xD8, // SOI: Marks the start of an image.
|
||||
end_of_image = 0xD9, // EOI: Marks the end of an image.
|
||||
start_of_scan = 0xDA, // SOS: Marks the start of scan.
|
||||
start_of_image = 0xD8, // SOI: Marks the start of an image.
|
||||
end_of_image = 0xD9, // EOI: Marks the end of an image.
|
||||
start_of_scan = 0xDA, // SOS: Marks the start of scan.
|
||||
define_restart_interval = 0xDD, // DRI: Defines the restart interval used in succeeding scans.
|
||||
|
||||
// The following markers are defined in ISO/IEC 10918-1 | ITU T.81.
|
||||
start_of_frame_baseline_jpeg = 0xC0, // SOF_0: Marks the start of a baseline jpeg encoded frame.
|
||||
@ -55,8 +58,8 @@ enum class jpeg_marker_code : uint8_t
|
||||
application_data10 = 0xEA, // APP10: Application data 10.
|
||||
application_data11 = 0xEB, // APP11: Application data 11.
|
||||
application_data12 = 0xEC, // APP12: Application data 12: used for Picture info.
|
||||
application_data13 = 0xEE, // APP13: Application data 13: used by PhotoShop IRB
|
||||
application_data14 = 0xED, // APP14: Application data 14: used by Adobe
|
||||
application_data13 = 0xED, // APP13: Application data 13: used by PhotoShop IRB
|
||||
application_data14 = 0xEE, // APP14: Application data 14: used by Adobe
|
||||
application_data15 = 0xEF, // APP15: Application data 15.
|
||||
comment = 0xFE // COM: Comment block.
|
||||
};
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <memory>
|
||||
#include <tuple>
|
||||
|
||||
namespace charls {
|
||||
|
||||
@ -24,6 +25,16 @@ using std::find;
|
||||
using std::unique_ptr;
|
||||
using std::vector;
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr bool is_restart_marker_code(const jpeg_marker_code marker_code) noexcept
|
||||
{
|
||||
return static_cast<uint8_t>(marker_code) >= jpeg_restart_marker_base &&
|
||||
static_cast<uint8_t>(marker_code) < jpeg_restart_marker_base + jpeg_restart_marker_range;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
jpeg_stream_reader::jpeg_stream_reader(const byte_span source) noexcept : source_{source}
|
||||
{
|
||||
}
|
||||
@ -212,6 +223,7 @@ void jpeg_stream_reader::validate_marker_code(const jpeg_marker_code marker_code
|
||||
|
||||
return;
|
||||
|
||||
case jpeg_marker_code::define_restart_interval:
|
||||
case jpeg_marker_code::jpegls_preset_parameters:
|
||||
case jpeg_marker_code::comment:
|
||||
case jpeg_marker_code::application_data0:
|
||||
@ -253,6 +265,9 @@ void jpeg_stream_reader::validate_marker_code(const jpeg_marker_code marker_code
|
||||
throw_jpegls_error(jpegls_errc::unexpected_end_of_image_marker);
|
||||
}
|
||||
|
||||
if (is_restart_marker_code(marker_code))
|
||||
throw_jpegls_error(jpegls_errc::unexpected_restart_marker);
|
||||
|
||||
throw_jpegls_error(jpegls_errc::unknown_jpeg_marker_found);
|
||||
}
|
||||
|
||||
@ -283,6 +298,9 @@ int jpeg_stream_reader::read_marker_segment(const jpeg_marker_code marker_code,
|
||||
case jpeg_marker_code::jpegls_preset_parameters:
|
||||
return read_preset_parameters_segment(segment_size);
|
||||
|
||||
case jpeg_marker_code::define_restart_interval:
|
||||
return read_define_restart_interval(segment_size);
|
||||
|
||||
case jpeg_marker_code::application_data0:
|
||||
case jpeg_marker_code::application_data1:
|
||||
case jpeg_marker_code::application_data2:
|
||||
@ -422,6 +440,30 @@ int jpeg_stream_reader::read_preset_parameters_segment(const int32_t segment_siz
|
||||
}
|
||||
|
||||
|
||||
int jpeg_stream_reader::read_define_restart_interval(const int32_t segment_size)
|
||||
{
|
||||
// Note: The JPEG-LS standard supports a 2,3 or 4 byte restart interval (see ISO/IEC 14495-1, C.2.5)
|
||||
// The original JPEG standard only supports 2 bytes (16 bit big endian).
|
||||
switch (segment_size)
|
||||
{
|
||||
case 2:
|
||||
parameters_.restart_interval = read_uint16();
|
||||
return 2;
|
||||
|
||||
case 3:
|
||||
parameters_.restart_interval = read_uint24();
|
||||
return 3;
|
||||
|
||||
case 4:
|
||||
parameters_.restart_interval = read_uint32();
|
||||
return 4;
|
||||
|
||||
default:
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void jpeg_stream_reader::read_start_of_scan()
|
||||
{
|
||||
const int32_t segment_size{read_segment_size()};
|
||||
@ -472,16 +514,24 @@ uint8_t jpeg_stream_reader::read_byte()
|
||||
|
||||
void jpeg_stream_reader::skip_byte()
|
||||
{
|
||||
static_cast<void>(read_byte());
|
||||
std::ignore = read_byte();
|
||||
}
|
||||
|
||||
|
||||
uint16_t jpeg_stream_reader::read_uint16()
|
||||
{
|
||||
const uint16_t value = read_byte() * 256U;
|
||||
const uint32_t value{read_byte() * 256U};
|
||||
return static_cast<uint16_t>(value + read_byte());
|
||||
}
|
||||
|
||||
|
||||
uint32_t jpeg_stream_reader::read_uint24()
|
||||
{
|
||||
const uint32_t value{static_cast<uint32_t>(read_byte()) << 16U};
|
||||
return value + read_uint16();
|
||||
}
|
||||
|
||||
|
||||
uint32_t jpeg_stream_reader::read_uint32()
|
||||
{
|
||||
uint32_t value{read_uint16()};
|
||||
@ -491,6 +541,7 @@ uint32_t jpeg_stream_reader::read_uint32()
|
||||
return value;
|
||||
}
|
||||
|
||||
|
||||
int32_t jpeg_stream_reader::read_segment_size()
|
||||
{
|
||||
const int32_t segment_size{read_uint16()};
|
||||
|
||||
@ -60,6 +60,7 @@ public:
|
||||
private:
|
||||
void skip_byte();
|
||||
uint16_t read_uint16();
|
||||
uint32_t read_uint24();
|
||||
uint32_t read_uint32();
|
||||
int32_t read_segment_size();
|
||||
std::vector<uint8_t> read_bytes(size_t byte_count);
|
||||
@ -74,6 +75,7 @@ private:
|
||||
int read_start_of_frame_segment(int32_t segment_size);
|
||||
static int read_comment() noexcept;
|
||||
int read_preset_parameters_segment(int32_t segment_size);
|
||||
int read_define_restart_interval(int32_t segment_size);
|
||||
int try_read_application_data8_segment(int32_t segment_size, spiff_header* header, bool* spiff_header_found);
|
||||
int try_read_spiff_header_segment(OUT_ spiff_header& header, OUT_ bool& spiff_header_found);
|
||||
|
||||
|
||||
@ -111,7 +111,7 @@ void jpeg_stream_writer::write_start_of_frame_segment(const uint32_t width, cons
|
||||
|
||||
void jpeg_stream_writer::write_color_transform_segment(const color_transformation transformation)
|
||||
{
|
||||
array<uint8_t, 5> segment{'m', 'r', 'f', 'x', static_cast<uint8_t>(transformation)};
|
||||
const array<uint8_t, 5> segment{'m', 'r', 'f', 'x', static_cast<uint8_t>(transformation)};
|
||||
|
||||
write_segment_header(jpeg_marker_code::application_data8, segment.size());
|
||||
write_bytes(segment.data(), segment.size());
|
||||
|
||||
@ -125,7 +125,7 @@ unique_ptr<Strategy> jls_codec_factory<Strategy>::create_codec(const frame_info&
|
||||
}
|
||||
}
|
||||
|
||||
codec->set_presets(preset_coding_parameters);
|
||||
codec->set_presets(preset_coding_parameters, parameters.restart_interval);
|
||||
return codec;
|
||||
}
|
||||
|
||||
|
||||
@ -102,6 +102,12 @@ const char* CHARLS_API_CALLING_CONVENTION charls_get_error_message(const charls_
|
||||
case jpegls_errc::missing_end_of_spiff_directory:
|
||||
return "Invalid JPEG-LS stream, SPIFF header without End Of Directory (EOD) entry";
|
||||
|
||||
case jpegls_errc::unexpected_restart_marker:
|
||||
return "Invalid JPEG-LS stream, restart (RTSm) marker found outside encoded entropy data";
|
||||
|
||||
case jpegls_errc::restart_marker_not_found:
|
||||
return "Invalid JPEG-LS stream, missing expected restart (RTSm) marker";
|
||||
|
||||
case jpegls_errc::invalid_parameter_bits_per_sample:
|
||||
return "Invalid JPEG-LS stream, The bit per sample (sample precision) parameter is not in the range [2, 16]";
|
||||
|
||||
|
||||
106
src/scan.h
106
src/scan.h
@ -8,6 +8,7 @@
|
||||
#include "constants.h"
|
||||
#include "context.h"
|
||||
#include "context_run_mode.h"
|
||||
#include "jpeg_marker_code.h"
|
||||
#include "lookup_table.h"
|
||||
#include "process_line.h"
|
||||
|
||||
@ -175,9 +176,10 @@ public:
|
||||
}
|
||||
|
||||
private:
|
||||
void set_presets(const jpegls_pc_parameters& presets) override
|
||||
void set_presets(const jpegls_pc_parameters& presets, const uint32_t restart_interval) override
|
||||
{
|
||||
initialize_parameters(presets.threshold1, presets.threshold2, presets.threshold3, presets.reset_value);
|
||||
restart_interval_ = restart_interval;
|
||||
}
|
||||
|
||||
bool is_interleaved() noexcept
|
||||
@ -475,7 +477,15 @@ private:
|
||||
rect_ = rect;
|
||||
|
||||
Strategy::initialize(compressed_data);
|
||||
do_scan();
|
||||
|
||||
// Process images without a restart interval, as 1 large restart interval.
|
||||
if (restart_interval_ == 0)
|
||||
{
|
||||
restart_interval_ = frame_info().height;
|
||||
}
|
||||
|
||||
decode_lines();
|
||||
|
||||
skip_bytes(compressed_data, static_cast<size_t>(Strategy::get_cur_byte_pos() - compressed_bytes));
|
||||
}
|
||||
|
||||
@ -491,17 +501,22 @@ private:
|
||||
t1_ = t1;
|
||||
t2_ = t2;
|
||||
t3_ = t3;
|
||||
reset_threshold_ = reset_threshold;
|
||||
|
||||
initialize_quantization_lut();
|
||||
reset_parameters();
|
||||
}
|
||||
|
||||
void reset_parameters() noexcept
|
||||
{
|
||||
const jls_context context_initial_value(std::max(2, (traits_.range + 32) / 64));
|
||||
for (auto& context : contexts_)
|
||||
{
|
||||
context = context_initial_value;
|
||||
}
|
||||
|
||||
context_runmode_[0] = context_run_mode(0, std::max(2, (traits_.range + 32) / 64), reset_threshold);
|
||||
context_runmode_[1] = context_run_mode(1, std::max(2, (traits_.range + 32) / 64), reset_threshold);
|
||||
context_runmode_[0] = context_run_mode(0, std::max(2, (traits_.range + 32) / 64), reset_threshold_);
|
||||
context_runmode_[1] = context_run_mode(1, std::max(2, (traits_.range + 32) / 64), reset_threshold_);
|
||||
run_index_ = 0;
|
||||
}
|
||||
|
||||
@ -515,7 +530,7 @@ private:
|
||||
return frame;
|
||||
}
|
||||
|
||||
// do_scan: Encodes or decodes a scan.
|
||||
// do_scan: Encodes a scan.
|
||||
// In ILV_SAMPLE mode, multiple components are handled in do_line
|
||||
// In ILV_LINE mode, a call do do_line is made for every component
|
||||
// In ILV_NONE mode, do_scan is called for each component
|
||||
@ -564,6 +579,84 @@ private:
|
||||
Strategy::end_scan();
|
||||
}
|
||||
|
||||
void decode_lines()
|
||||
{
|
||||
const uint32_t pixel_stride{width_ + 4U};
|
||||
const size_t component_count{
|
||||
parameters().interleave_mode == interleave_mode::line ? static_cast<size_t>(frame_info().component_count) : 1U};
|
||||
|
||||
std::vector<pixel_type> line_buffer(static_cast<size_t>(2) * component_count * pixel_stride);
|
||||
std::vector<int32_t> run_index(component_count);
|
||||
|
||||
for (uint32_t line{};;)
|
||||
{
|
||||
const uint32_t lines_in_interval{std::min(frame_info().height - line, restart_interval_)};
|
||||
|
||||
for (uint32_t mcu{}; mcu < lines_in_interval; ++mcu, ++line)
|
||||
{
|
||||
previous_line_ = &line_buffer[1];
|
||||
current_line_ = &line_buffer[1 + static_cast<size_t>(component_count) * pixel_stride];
|
||||
if ((line & 1) == 1)
|
||||
{
|
||||
std::swap(previous_line_, current_line_);
|
||||
}
|
||||
|
||||
Strategy::on_line_begin(width_, current_line_, pixel_stride);
|
||||
|
||||
for (size_t component{}; component < component_count; ++component)
|
||||
{
|
||||
run_index_ = run_index[component];
|
||||
|
||||
// initialize edge pixels used for prediction
|
||||
previous_line_[width_] = previous_line_[width_ - 1];
|
||||
current_line_[-1] = previous_line_[0];
|
||||
do_line(static_cast<pixel_type*>(nullptr)); // dummy argument for overload resolution
|
||||
|
||||
run_index[component] = run_index_;
|
||||
previous_line_ += pixel_stride;
|
||||
current_line_ += pixel_stride;
|
||||
}
|
||||
|
||||
if (static_cast<uint32_t>(rect_.Y) <= line && line < static_cast<uint32_t>(rect_.Y + rect_.Height))
|
||||
{
|
||||
Strategy::on_line_end(rect_.Width,
|
||||
current_line_ + rect_.X - (static_cast<size_t>(component_count) * pixel_stride),
|
||||
pixel_stride);
|
||||
}
|
||||
}
|
||||
|
||||
if (line == frame_info().height)
|
||||
break;
|
||||
|
||||
read_restart_marker();
|
||||
restart_interval_counter_ = (restart_interval_counter_ + 1) % jpeg_restart_marker_range;
|
||||
|
||||
// After a restart marker it is required to reset the decoder.
|
||||
Strategy::reset();
|
||||
std::fill(line_buffer.begin(), line_buffer.end(), pixel_type{});
|
||||
std::fill(run_index.begin(), run_index.end(), 0);
|
||||
reset_parameters();
|
||||
}
|
||||
|
||||
Strategy::end_scan();
|
||||
}
|
||||
|
||||
void read_restart_marker()
|
||||
{
|
||||
auto byte{Strategy::read_byte()};
|
||||
if (byte != jpeg_marker_start_byte)
|
||||
impl::throw_jpegls_error(jpegls_errc::restart_marker_not_found);
|
||||
|
||||
// Read all preceding 0xFF fill values until a non 0xFF value has been found. (see T.81, B.1.1.2)
|
||||
do
|
||||
{
|
||||
byte = Strategy::read_byte();
|
||||
} while (byte == jpeg_marker_start_byte);
|
||||
|
||||
if (byte != jpeg_restart_marker_base + restart_interval_counter_)
|
||||
impl::throw_jpegls_error(jpegls_errc::restart_marker_not_found);
|
||||
}
|
||||
|
||||
/// <summary>Encodes/Decodes a scan line of quads in ILV_SAMPLE mode</summary>
|
||||
void do_line(quad<sample_type>*)
|
||||
{
|
||||
@ -826,6 +919,9 @@ private:
|
||||
int32_t t1_{};
|
||||
int32_t t2_{};
|
||||
int32_t t3_{};
|
||||
int32_t reset_threshold_{};
|
||||
uint32_t restart_interval_{};
|
||||
uint32_t restart_interval_counter_{};
|
||||
|
||||
// compression context
|
||||
std::array<jls_context, 365> contexts_;
|
||||
|
||||
@ -285,7 +285,7 @@ inline void skip_bytes(byte_span& stream_info, const size_t count) noexcept
|
||||
|
||||
|
||||
template<typename T>
|
||||
std::ostream& operator<<(typename std::enable_if<std::is_enum<T>::value, std::ostream>::type& stream, const T& e)
|
||||
std::ostream& operator<<(std::enable_if_t<std::is_enum<T>::value, std::ostream>& stream, const T& e)
|
||||
{
|
||||
return stream << static_cast<typename std::underlying_type<T>::type>(e);
|
||||
}
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
#include <array>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
|
||||
using std::array;
|
||||
@ -48,7 +49,7 @@ bool verify_encoded_bytes(const void* uncompressed_data, const size_t uncompress
|
||||
encoder.interleave_mode(decoder.interleave_mode());
|
||||
encoder.near_lossless(decoder.near_lossless());
|
||||
encoder.preset_coding_parameters(decoder.preset_coding_parameters());
|
||||
static_cast<void>(encoder.encode(uncompressed_data, uncompressed_length));
|
||||
std::ignore = encoder.encode(uncompressed_data, uncompressed_length);
|
||||
|
||||
for (size_t i{}; i != compressed_length; ++i)
|
||||
{
|
||||
|
||||
@ -50,7 +50,7 @@ void test_dicom_sample_image(const char* name)
|
||||
data.erase(data.begin(), data.begin() + offset - 4);
|
||||
|
||||
// remove the DICOM fragment headers (in the concerned images they occur every 64k)
|
||||
for (unsigned int i{}; i != data.size(); i += 64 * 1024)
|
||||
for (unsigned int i{}; i < data.size(); i += 64 * 1024)
|
||||
{
|
||||
data.erase(data.begin() + static_cast<int>(i), data.begin() + static_cast<int>(i) + 8);
|
||||
}
|
||||
|
||||
@ -24,7 +24,7 @@ void test_jpegls_read_header(const char* filename, const int width, const int he
|
||||
{
|
||||
cout << "LegacyAPI JpegLsReadHeader:" << filename << "\n";
|
||||
|
||||
vector<uint8_t> encoded_buffer = read_file(filename);
|
||||
const vector<uint8_t> encoded_buffer{read_file(filename)};
|
||||
|
||||
array<char, ErrorMessageSize> error_message{};
|
||||
JlsParameters parameters{};
|
||||
|
||||
156
test/main.cpp
156
test/main.cpp
@ -47,12 +47,33 @@ namespace {
|
||||
constexpr ios::openmode mode_input = ios::in | ios::binary;
|
||||
constexpr ios::openmode mode_output = ios::out | ios::binary;
|
||||
|
||||
ifstream open_input_stream(const char* filename)
|
||||
{
|
||||
ifstream stream;
|
||||
stream.exceptions(ios::eofbit | ios::failbit | ios::badbit);
|
||||
stream.open(filename, mode_input);
|
||||
|
||||
return stream;
|
||||
}
|
||||
|
||||
|
||||
ofstream open_output_stream(const char* filename)
|
||||
{
|
||||
ofstream stream;
|
||||
stream.exceptions(ios::eofbit | ios::failbit | ios::badbit);
|
||||
stream.open(filename, mode_output);
|
||||
|
||||
return stream;
|
||||
}
|
||||
|
||||
|
||||
template<typename Container>
|
||||
void read(istream& input, Container& destination_container)
|
||||
{
|
||||
input.read(reinterpret_cast<char*>(destination_container.data()), destination_container.size());
|
||||
}
|
||||
|
||||
|
||||
size_t get_stream_length(istream& stream, const size_t end_offset = 0)
|
||||
{
|
||||
stream.seekg(0, ios::end);
|
||||
@ -62,6 +83,34 @@ size_t get_stream_length(istream& stream, const size_t end_offset = 0)
|
||||
return length;
|
||||
}
|
||||
|
||||
|
||||
template<typename SizeType>
|
||||
void convert_planar_to_pixel(const size_t width, const size_t height, const void* source, void* destination) noexcept
|
||||
{
|
||||
const size_t stride_in_pixels = width * 3;
|
||||
const auto* plane0{static_cast<const SizeType*>(source)};
|
||||
const auto* plane1{static_cast<const SizeType*>(source) + (width * height)};
|
||||
const auto* plane2{static_cast<const SizeType*>(source) + (width * height * 2)};
|
||||
|
||||
auto* pixels{static_cast<SizeType*>(destination)};
|
||||
|
||||
for (size_t row{}; row != height; ++row)
|
||||
{
|
||||
for (size_t column{}, offset = 0; column != width; ++column, offset += 3)
|
||||
{
|
||||
pixels[offset + 0] = plane0[column];
|
||||
pixels[offset + 1] = plane1[column];
|
||||
pixels[offset + 2] = plane2[column];
|
||||
}
|
||||
|
||||
plane0 += width;
|
||||
plane1 += width;
|
||||
plane2 += width;
|
||||
pixels += stride_in_pixels;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void test_traits16_bit()
|
||||
{
|
||||
const auto traits1 = default_traits<uint16_t, uint16_t>(4095, 0);
|
||||
@ -149,7 +198,7 @@ vector<uint8_t> make_some_noise16_bit(const size_t length, const int bit_count,
|
||||
|
||||
void test_noise_image()
|
||||
{
|
||||
const rect_size size2 = rect_size(512, 512);
|
||||
const rect_size size2{512, 512};
|
||||
|
||||
for (size_t bit_depth{8}; bit_depth >= 2; --bit_depth)
|
||||
{
|
||||
@ -200,7 +249,7 @@ void test_fail_on_too_small_output_buffer()
|
||||
jpegls_encoder encoder;
|
||||
encoder.destination(output_buffer);
|
||||
encoder.frame_info({8, 8, 8, 1});
|
||||
static_cast<void>(encoder.encode(input_buffer));
|
||||
std::ignore = encoder.encode(input_buffer);
|
||||
assert::is_true(false);
|
||||
}
|
||||
catch (const jpegls_error& e)
|
||||
@ -215,7 +264,7 @@ void test_fail_on_too_small_output_buffer()
|
||||
jpegls_encoder encoder;
|
||||
encoder.destination(output_buffer);
|
||||
encoder.frame_info({8, 8, 8, 1});
|
||||
static_cast<void>(encoder.encode(input_buffer));
|
||||
std::ignore = encoder.encode(input_buffer);
|
||||
assert::is_true(false);
|
||||
}
|
||||
catch (const jpegls_error& e)
|
||||
@ -238,7 +287,7 @@ void test_bgra()
|
||||
|
||||
void test_bgr()
|
||||
{
|
||||
vector<uint8_t> encoded_source = read_file("test/conformance/t8c2e3.jls");
|
||||
const vector<uint8_t> encoded_source{read_file("test/conformance/t8c2e3.jls")};
|
||||
|
||||
jpegls_decoder decoder;
|
||||
decoder.source(encoded_source);
|
||||
@ -364,24 +413,21 @@ void test_decode_bit_stream_with_unknown_jpeg_marker()
|
||||
|
||||
void test_decode_rect()
|
||||
{
|
||||
vector<uint8_t> encoded_source{read_file("test/lena8b.jls")};
|
||||
|
||||
jpegls_decoder decoder;
|
||||
decoder.source(encoded_source);
|
||||
decoder.read_header();
|
||||
const vector<uint8_t> encoded_source{read_file("test/lena8b.jls")};
|
||||
|
||||
const jpegls_decoder decoder{encoded_source, true};
|
||||
vector<uint8_t> decoded_buffer(decoder.destination_size());
|
||||
|
||||
// ReSharper disable CppDeprecatedEntity
|
||||
DISABLE_DEPRECATED_WARNING
|
||||
|
||||
JlsParameters params{};
|
||||
constexpr JlsParameters params{};
|
||||
|
||||
error_code error = JpegLsDecode(decoded_buffer.data(), decoded_buffer.size(), encoded_source.data(),
|
||||
encoded_source.size(), ¶ms, nullptr);
|
||||
assert::is_true(!error);
|
||||
|
||||
const JlsRect rect{128, 128, 256, 1};
|
||||
constexpr JlsRect rect{128, 128, 256, 1};
|
||||
vector<uint8_t> decoded_data(static_cast<size_t>(rect.Width) * rect.Height);
|
||||
decoded_data.push_back(0x1f);
|
||||
|
||||
@ -403,8 +449,7 @@ void test_encode_from_stream(const char* filename, const size_t offset, const ui
|
||||
const int32_t bits_per_sample, const int32_t component_count,
|
||||
const interleave_mode interleave_mode, const size_t expected_length)
|
||||
{
|
||||
ifstream source_file{filename, ios::in | ios::binary};
|
||||
assert::is_true(source_file.good());
|
||||
ifstream source_file{open_input_stream(filename)};
|
||||
|
||||
size_t length{get_stream_length(source_file, offset)};
|
||||
assert::is_true(length >= offset);
|
||||
@ -424,8 +469,11 @@ void test_encode_from_stream(const char* filename, const size_t offset, const ui
|
||||
}
|
||||
|
||||
|
||||
bool decode_to_pnm(istream& input, ostream& output)
|
||||
bool decode_to_pnm(const char* filename_input, const char* filename_output)
|
||||
try
|
||||
{
|
||||
ifstream input{open_input_stream(filename_input)};
|
||||
|
||||
const size_t length{get_stream_length(input)};
|
||||
vector<uint8_t> encoded_source(length);
|
||||
read(input, encoded_source);
|
||||
@ -435,8 +483,27 @@ bool decode_to_pnm(istream& input, ostream& output)
|
||||
interleave_mode interleave_mode;
|
||||
std::tie(frame_info, interleave_mode) = jpegls_decoder::decode(encoded_source, decoded_destination);
|
||||
|
||||
if (frame_info.component_count > 1 && interleave_mode == charls::interleave_mode::none)
|
||||
return false; // Unsupported at the moment.
|
||||
if (!(frame_info.component_count == 1 || frame_info.component_count == 3))
|
||||
{
|
||||
cout << "Only JPEG-LS images with component count 1 or 3 are supported to decode to pnm\n";
|
||||
return false;
|
||||
}
|
||||
|
||||
// PPM format only supports by-pixel, convert if needed.
|
||||
if (interleave_mode == charls::interleave_mode::none && frame_info.component_count == 3)
|
||||
{
|
||||
vector<uint8_t> pixels(decoded_destination.size());
|
||||
if (frame_info.bits_per_sample > 8)
|
||||
{
|
||||
convert_planar_to_pixel<uint16_t>(frame_info.width, frame_info.height, decoded_destination.data(), pixels.data());
|
||||
}
|
||||
else
|
||||
{
|
||||
convert_planar_to_pixel<uint8_t>(frame_info.width, frame_info.height, decoded_destination.data(), pixels.data());
|
||||
}
|
||||
|
||||
swap(decoded_destination, pixels);
|
||||
}
|
||||
|
||||
// PNM format requires most significant byte first (big endian).
|
||||
const int max_value = (1 << frame_info.bits_per_sample) - 1;
|
||||
@ -451,11 +518,18 @@ bool decode_to_pnm(istream& input, ostream& output)
|
||||
}
|
||||
|
||||
const int magic_number = frame_info.component_count == 3 ? 6 : 5;
|
||||
|
||||
ofstream output{open_output_stream(filename_output)};
|
||||
output << 'P' << magic_number << "\n" << frame_info.width << ' ' << frame_info.height << "\n" << max_value << "\n";
|
||||
write(output, decoded_destination, decoded_destination.size());
|
||||
|
||||
return true;
|
||||
}
|
||||
catch (const system_error& error)
|
||||
{
|
||||
cout << "Failed to decode " << filename_input << " to " << filename_output << ", reason: " << error.what() << '\n';
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
vector<int> read_pnm_header(istream& pnm_file)
|
||||
@ -492,9 +566,12 @@ vector<int> read_pnm_header(istream& pnm_file)
|
||||
// into the JPEG-LS format. The 2 binary formats P5 and P6 are supported:
|
||||
// Portable GrayMap: P5 = binary, extension = .pgm, 0-2^16 (gray scale)
|
||||
// Portable PixMap: P6 = binary, extension.ppm, range 0-2^16 (RGB)
|
||||
bool encode_pnm(istream& pnm_file, ostream& jls_file_stream)
|
||||
bool encode_pnm(const char* filename_input, const char* filename_output)
|
||||
try
|
||||
{
|
||||
vector<int> read_values{read_pnm_header(pnm_file)};
|
||||
ifstream pnm_file(open_input_stream(filename_input));
|
||||
|
||||
const vector<int> read_values{read_pnm_header(pnm_file)};
|
||||
if (read_values.size() != 4)
|
||||
return false;
|
||||
|
||||
@ -525,21 +602,27 @@ bool encode_pnm(istream& pnm_file, ostream& jls_file_stream)
|
||||
encoder.destination(destination);
|
||||
const size_t bytes_encoded{encoder.encode(input_buffer)};
|
||||
|
||||
ofstream jls_file_stream(open_output_stream(filename_output));
|
||||
write(jls_file_stream, destination, bytes_encoded);
|
||||
return jls_file_stream.good();
|
||||
return true;
|
||||
}
|
||||
catch (const system_error& error)
|
||||
{
|
||||
cout << "Failed to encode " << filename_input << " to " << filename_output << ", reason: " << error.what() << '\n';
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool compare_pnm(istream& pnm_file1, istream& pnm_file2)
|
||||
{
|
||||
vector<int> header1{read_pnm_header(pnm_file1)};
|
||||
const vector<int> header1{read_pnm_header(pnm_file1)};
|
||||
if (header1.size() != 4)
|
||||
{
|
||||
cout << "Cannot read header from input file 1\n";
|
||||
return false;
|
||||
}
|
||||
|
||||
vector<int> header2 = read_pnm_header(pnm_file2);
|
||||
const vector<int> header2 = read_pnm_header(pnm_file2);
|
||||
if (header2.size() != 4)
|
||||
{
|
||||
cout << "Cannot read header from input file 2\n";
|
||||
@ -610,19 +693,18 @@ bool compare_pnm(istream& pnm_file1, istream& pnm_file2)
|
||||
|
||||
|
||||
bool decode_raw(const char* filename_encoded, const char* filename_output)
|
||||
try
|
||||
{
|
||||
try
|
||||
{
|
||||
const vector<uint8_t> encoded_source{read_file(filename_encoded)};
|
||||
vector<uint8_t> decoded_destination;
|
||||
jpegls_decoder::decode(encoded_source, decoded_destination);
|
||||
write_file(filename_output, decoded_destination.data(), decoded_destination.size());
|
||||
return true;
|
||||
}
|
||||
catch (const system_error&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
const vector<uint8_t> encoded_source{read_file(filename_encoded)};
|
||||
vector<uint8_t> decoded_destination;
|
||||
jpegls_decoder::decode(encoded_source, decoded_destination);
|
||||
write_file(filename_output, decoded_destination.data(), decoded_destination.size());
|
||||
return true;
|
||||
}
|
||||
catch (const system_error& error)
|
||||
{
|
||||
cout << "Failed to decode " << filename_encoded << " to " << filename_output << ", reason: " << error.what() << '\n';
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@ -723,10 +805,8 @@ int main(const int argc, const char* const argv[]) // NOLINT(bugprone-exception-
|
||||
cout << "Syntax: -decodetopnm input-file output-file\n";
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
ofstream pnm_file(argv[3], mode_output);
|
||||
ifstream jls_file(argv[2], mode_input);
|
||||
|
||||
return decode_to_pnm(jls_file, pnm_file) ? EXIT_SUCCESS : EXIT_FAILURE;
|
||||
return decode_to_pnm(argv[2], argv[3]) ? EXIT_SUCCESS : EXIT_FAILURE;
|
||||
}
|
||||
|
||||
if (str == "-encodepnm")
|
||||
@ -736,10 +816,8 @@ int main(const int argc, const char* const argv[]) // NOLINT(bugprone-exception-
|
||||
cout << "Syntax: -encodepnm input-file output-file\n";
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
ifstream pnm_file(argv[2], mode_input);
|
||||
ofstream jls_file(argv[3], mode_output);
|
||||
|
||||
return encode_pnm(pnm_file, jls_file) ? EXIT_SUCCESS : EXIT_FAILURE;
|
||||
return encode_pnm(argv[2], argv[3]) ? EXIT_SUCCESS : EXIT_FAILURE;
|
||||
}
|
||||
|
||||
if (str == "-comparepnm")
|
||||
|
||||
@ -9,6 +9,7 @@
|
||||
#include <chrono>
|
||||
#include <iostream>
|
||||
#include <ratio>
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
|
||||
using charls::frame_info;
|
||||
@ -47,8 +48,8 @@ void test_performance(const int loop_count)
|
||||
// RGBA image (This is a common PNG sample)
|
||||
test_file("test/alphatest.raw", 0, rect_size(380, 287), 8, 4, false, loop_count);
|
||||
|
||||
const rect_size size1024 = rect_size(1024, 1024);
|
||||
const rect_size size512 = rect_size(512, 512);
|
||||
const rect_size size1024{1024, 1024};
|
||||
const rect_size size512{512, 512};
|
||||
|
||||
// 16 bit mono
|
||||
test_file("test/MR2_UNC", 1728, size1024, 16, 1, true, loop_count);
|
||||
@ -164,7 +165,7 @@ void encode_performance_tests(const int loop_count)
|
||||
encoder2.frame_info(info).interleave_mode(interleave_mode);
|
||||
encoder2.destination(destination);
|
||||
|
||||
static_cast<void>(encoder2.encode(anymap_file.image_data()));
|
||||
std::ignore = encoder2.encode(anymap_file.image_data());
|
||||
}
|
||||
|
||||
const auto end{steady_clock::now()};
|
||||
|
||||
@ -191,6 +191,26 @@
|
||||
<FileType>Document</FileType>
|
||||
<DestinationFolders>$(OutDir)DataFiles</DestinationFolders>
|
||||
</CopyFileToFolders>
|
||||
<CopyFileToFolders Include="test8_ilv_none_rm_7.jls">
|
||||
<FileType>Document</FileType>
|
||||
<DestinationFolders>$(OutDir)DataFiles</DestinationFolders>
|
||||
</CopyFileToFolders>
|
||||
<CopyFileToFolders Include="test8_ilv_line_rm_7.jls">
|
||||
<FileType>Document</FileType>
|
||||
<DestinationFolders>$(OutDir)DataFiles</DestinationFolders>
|
||||
</CopyFileToFolders>
|
||||
<CopyFileToFolders Include="test8_ilv_sample_rm_7.jls">
|
||||
<FileType>Document</FileType>
|
||||
<DestinationFolders>$(OutDir)DataFiles</DestinationFolders>
|
||||
</CopyFileToFolders>
|
||||
<CopyFileToFolders Include="test8_ilv_sample_rm_300.jls">
|
||||
<FileType>Document</FileType>
|
||||
<DestinationFolders>$(OutDir)DataFiles</DestinationFolders>
|
||||
</CopyFileToFolders>
|
||||
<CopyFileToFolders Include="test16_rm_5.jls">
|
||||
<FileType>Document</FileType>
|
||||
<DestinationFolders>$(OutDir)DataFiles</DestinationFolders>
|
||||
</CopyFileToFolders>
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
|
||||
@ -166,5 +166,20 @@
|
||||
<CopyFileToFolders Include="2bit_parrot_150x200.pgm">
|
||||
<Filter>Test Images</Filter>
|
||||
</CopyFileToFolders>
|
||||
<CopyFileToFolders Include="test8_ilv_line_rm_7.jls">
|
||||
<Filter>Test Images</Filter>
|
||||
</CopyFileToFolders>
|
||||
<CopyFileToFolders Include="test8_ilv_none_rm_7.jls">
|
||||
<Filter>Test Images</Filter>
|
||||
</CopyFileToFolders>
|
||||
<CopyFileToFolders Include="test8_ilv_sample_rm_7.jls">
|
||||
<Filter>Test Images</Filter>
|
||||
</CopyFileToFolders>
|
||||
<CopyFileToFolders Include="test8_ilv_sample_rm_300.jls">
|
||||
<Filter>Test Images</Filter>
|
||||
</CopyFileToFolders>
|
||||
<CopyFileToFolders Include="test16_rm_5.jls">
|
||||
<Filter>Test Images</Filter>
|
||||
</CopyFileToFolders>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
@ -36,7 +36,7 @@ public:
|
||||
|
||||
TEST_METHOD(set_source_buffer_nullptr) // NOLINT
|
||||
{
|
||||
const array<uint8_t, 10> buffer{};
|
||||
constexpr array<uint8_t, 10> buffer{};
|
||||
|
||||
auto error = charls_jpegls_decoder_set_source_buffer(nullptr, buffer.data(), buffer.size());
|
||||
Assert::AreEqual(jpegls_errc::invalid_argument, error);
|
||||
|
||||
@ -46,7 +46,7 @@ public:
|
||||
|
||||
TEST_METHOD(set_frame_info_buffer_nullptr) // NOLINT
|
||||
{
|
||||
charls_frame_info frame_info{};
|
||||
constexpr charls_frame_info frame_info{};
|
||||
auto error = charls_jpegls_encoder_set_frame_info(nullptr, &frame_info);
|
||||
Assert::AreEqual(jpegls_errc::invalid_argument, error);
|
||||
|
||||
@ -70,7 +70,7 @@ public:
|
||||
|
||||
TEST_METHOD(set_preset_coding_parameters_nullptr) // NOLINT
|
||||
{
|
||||
jpegls_pc_parameters parameters{};
|
||||
constexpr jpegls_pc_parameters parameters{};
|
||||
auto error = charls_jpegls_encoder_set_preset_coding_parameters(nullptr, ¶meters);
|
||||
Assert::AreEqual(jpegls_errc::invalid_argument, error);
|
||||
|
||||
@ -94,7 +94,7 @@ public:
|
||||
|
||||
charls_jpegls_encoder* const encoder = charls_jpegls_encoder_create();
|
||||
|
||||
charls_frame_info frame_info{1, 1, 2, 1};
|
||||
constexpr charls_frame_info frame_info{1, 1, 2, 1};
|
||||
error = charls_jpegls_encoder_set_frame_info(encoder, &frame_info);
|
||||
Assert::AreEqual(jpegls_errc::success, error);
|
||||
|
||||
@ -117,7 +117,7 @@ public:
|
||||
|
||||
TEST_METHOD(encode_from_buffer_nullptr) // NOLINT
|
||||
{
|
||||
const array<uint8_t, 10> source_buffer{};
|
||||
constexpr array<uint8_t, 10> source_buffer{};
|
||||
auto error = charls_jpegls_encoder_encode_from_buffer(nullptr, source_buffer.data(), source_buffer.size(), 0);
|
||||
Assert::AreEqual(jpegls_errc::invalid_argument, error);
|
||||
|
||||
@ -129,7 +129,7 @@ public:
|
||||
|
||||
TEST_METHOD(write_spiff_header_nullptr) // NOLINT
|
||||
{
|
||||
charls_spiff_header spiff_header{};
|
||||
constexpr charls_spiff_header spiff_header{};
|
||||
auto error = charls_jpegls_encoder_write_spiff_header(nullptr, &spiff_header);
|
||||
Assert::AreEqual(jpegls_errc::invalid_argument, error);
|
||||
|
||||
@ -148,7 +148,7 @@ public:
|
||||
|
||||
TEST_METHOD(write_spiff_entry_nullptr) // NOLINT
|
||||
{
|
||||
const array<uint8_t, 10> entry_data{};
|
||||
constexpr array<uint8_t, 10> entry_data{};
|
||||
auto error = charls_jpegls_encoder_write_spiff_entry(nullptr, 5, entry_data.data(), entry_data.size());
|
||||
Assert::AreEqual(jpegls_errc::invalid_argument, error);
|
||||
|
||||
@ -170,11 +170,11 @@ public:
|
||||
auto error = charls_jpegls_encoder_set_destination_buffer(encoder, nullptr, 0);
|
||||
Assert::AreEqual(jpegls_errc::success, error);
|
||||
|
||||
charls_frame_info frame_info{1, 1, 2, 1};
|
||||
constexpr charls_frame_info frame_info{1, 1, 2, 1};
|
||||
error = charls_jpegls_encoder_set_frame_info(encoder, &frame_info);
|
||||
Assert::AreEqual(jpegls_errc::success, error);
|
||||
|
||||
array<uint8_t, 10> buffer{};
|
||||
constexpr array<uint8_t, 10> buffer{};
|
||||
error = charls_jpegls_encoder_encode_from_buffer(encoder, buffer.data(), buffer.size(), 0);
|
||||
Assert::AreEqual(jpegls_errc::destination_buffer_too_small, error);
|
||||
|
||||
@ -189,7 +189,7 @@ public:
|
||||
auto error = charls_jpegls_encoder_set_destination_buffer(encoder, buffer.data(), buffer.size());
|
||||
Assert::AreEqual(jpegls_errc::success, error);
|
||||
|
||||
charls_frame_info frame_info{1, 1, 2, 1};
|
||||
constexpr charls_frame_info frame_info{1, 1, 2, 1};
|
||||
error = charls_jpegls_encoder_set_frame_info(encoder, &frame_info);
|
||||
Assert::AreEqual(jpegls_errc::success, error);
|
||||
|
||||
|
||||
@ -9,6 +9,7 @@
|
||||
|
||||
#include <charls/charls.h>
|
||||
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
|
||||
using Microsoft::VisualStudio::CppUnitTestFramework::Assert;
|
||||
@ -32,7 +33,7 @@ public:
|
||||
{
|
||||
for (int blue{}; blue != 255; ++blue)
|
||||
{
|
||||
const transform_hp1<uint8_t> transform;
|
||||
constexpr transform_hp1<uint8_t> transform{};
|
||||
const auto sample = transform(red, green, blue);
|
||||
const transform_hp1<uint8_t>::inverse inverse(transform);
|
||||
|
||||
@ -59,7 +60,7 @@ public:
|
||||
{
|
||||
for (int blue{}; blue != 255; ++blue)
|
||||
{
|
||||
const transform_hp2<uint8_t> transform;
|
||||
constexpr transform_hp2<uint8_t> transform{};
|
||||
const auto sample = transform(red, green, blue);
|
||||
const transform_hp2<uint8_t>::inverse inverse(transform);
|
||||
|
||||
@ -86,7 +87,7 @@ public:
|
||||
{
|
||||
for (int blue{}; blue != 255; ++blue)
|
||||
{
|
||||
const transform_hp3<uint8_t> transformation;
|
||||
constexpr transform_hp3<uint8_t> transformation{};
|
||||
const auto sample = transformation(red, green, blue);
|
||||
const transform_hp3<uint8_t>::inverse inverse(transformation);
|
||||
const auto round_trip = inverse(sample.v1, sample.v2, sample.v3);
|
||||
@ -107,19 +108,20 @@ public:
|
||||
|
||||
vector<uint8_t> destination(decoder.destination_size());
|
||||
|
||||
assert_expect_exception(jpegls_errc::bit_depth_for_transform_not_supported, [&] { decoder.decode(destination); });
|
||||
assert_expect_exception(jpegls_errc::bit_depth_for_transform_not_supported,
|
||||
[&decoder, &destination] { decoder.decode(destination); });
|
||||
}
|
||||
|
||||
TEST_METHOD(encode_non_8_or_16_bit_is_not_supported) // NOLINT
|
||||
{
|
||||
const frame_info frame_info{2, 1, 10, 3};
|
||||
constexpr frame_info frame_info{2, 1, 10, 3};
|
||||
jpegls_encoder encoder;
|
||||
|
||||
vector<uint8_t> destination(40);
|
||||
encoder.destination(destination).frame_info(frame_info).color_transformation(color_transformation::hp3);
|
||||
const vector<uint8_t> source(20);
|
||||
assert_expect_exception(jpegls_errc::bit_depth_for_transform_not_supported,
|
||||
[&] { static_cast<void>(encoder.encode(source)); });
|
||||
[&encoder, &source] { std::ignore = encoder.encode(source); });
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@ -89,81 +89,50 @@ public:
|
||||
decompress_file("DataFiles/lena8b.jls", "DataFiles/lena8b.pgm");
|
||||
}
|
||||
|
||||
TEST_METHOD(decompress_color_8_bit_interleave_none_lossless_restart_7) // NOLINT
|
||||
{
|
||||
// ISO 14495-1: official test image 1 but with restart markers.
|
||||
decompress_file("DataFiles/test8_ilv_none_rm_7.jls", "DataFiles/test8.ppm", false);
|
||||
}
|
||||
|
||||
TEST_METHOD(decompress_color_8_bit_interleave_line_lossless_restart_7) // NOLINT
|
||||
{
|
||||
// ISO 14495-1: official test image 2 but with restart markers.
|
||||
decompress_file("DataFiles/test8_ilv_line_rm_7.jls", "DataFiles/test8.ppm", false);
|
||||
}
|
||||
|
||||
TEST_METHOD(decompress_color_8_bit_interleave_sample_lossless_restart_7) // NOLINT
|
||||
{
|
||||
// ISO 14495-1: official test image 3 but with restart markers.
|
||||
decompress_file("DataFiles/test8_ilv_sample_rm_7.jls", "DataFiles/test8.ppm", false);
|
||||
}
|
||||
|
||||
TEST_METHOD(decompress_color_8_bit_interleave_sample_lossless_restart_300) // NOLINT
|
||||
{
|
||||
// ISO 14495-1: official test image 3 but with restart markers and restart interval 300
|
||||
decompress_file("DataFiles/test8_ilv_sample_rm_300.jls", "DataFiles/test8.ppm", false);
|
||||
}
|
||||
|
||||
TEST_METHOD(decompress_monochrome_16_bit_restart_5) // NOLINT
|
||||
{
|
||||
// ISO 14495-1: official test image 12 but with restart markers and restart interval 5
|
||||
decompress_file("DataFiles/test16_rm_5.jls", "DataFiles/test16.pgm", false);
|
||||
}
|
||||
|
||||
private:
|
||||
static void decompress_file(const char* encoded_filename, const char* raw_filename, const bool check_encode = true)
|
||||
{
|
||||
vector<uint8_t> encoded_source = read_file(encoded_filename);
|
||||
const vector<uint8_t> encoded_source{read_file(encoded_filename)};
|
||||
const jpegls_decoder decoder{encoded_source, true};
|
||||
|
||||
jpegls_decoder decoder;
|
||||
decoder.source(encoded_source);
|
||||
decoder.read_header();
|
||||
|
||||
portable_anymap_file reference_file =
|
||||
read_anymap_reference_file(raw_filename, decoder.interleave_mode(), decoder.frame_info());
|
||||
portable_anymap_file reference_file{
|
||||
read_anymap_reference_file(raw_filename, decoder.interleave_mode(), decoder.frame_info())};
|
||||
|
||||
test_compliance(encoded_source, reference_file.image_data(), check_encode);
|
||||
test_compliance_legacy_api(encoded_source.data(), encoded_source.size(), reference_file.image_data().data(),
|
||||
reference_file.image_data().size(), check_encode);
|
||||
}
|
||||
|
||||
static void test_compliance(const vector<uint8_t>& encoded_source, const vector<uint8_t>& uncompressed_source,
|
||||
const bool check_encode)
|
||||
{
|
||||
jpegls_decoder decoder;
|
||||
decoder.source(encoded_source);
|
||||
decoder.read_header();
|
||||
|
||||
if (check_encode)
|
||||
{
|
||||
Assert::IsTrue(verify_encoded_bytes(uncompressed_source, encoded_source));
|
||||
}
|
||||
|
||||
vector<uint8_t> destination(decoder.destination_size());
|
||||
decoder.decode(destination);
|
||||
|
||||
if (decoder.near_lossless() == 0)
|
||||
{
|
||||
for (size_t i{}; i != uncompressed_source.size(); ++i)
|
||||
{
|
||||
if (uncompressed_source[i] != destination[i]) // AreEqual is very slow, pre-test to speed up 50X
|
||||
{
|
||||
Assert::AreEqual(uncompressed_source[i], destination[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
const frame_info frame_info{decoder.frame_info()};
|
||||
const auto near_lossless{decoder.near_lossless()};
|
||||
|
||||
if (frame_info.bits_per_sample <= 8)
|
||||
{
|
||||
for (size_t i{}; i != uncompressed_source.size(); ++i)
|
||||
{
|
||||
if (abs(uncompressed_source[i] - destination[i]) >
|
||||
near_lossless) // AreEqual is very slow, pre-test to speed up 50X
|
||||
{
|
||||
Assert::AreEqual(uncompressed_source[i], destination[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
const auto* source16 = reinterpret_cast<const uint16_t*>(uncompressed_source.data());
|
||||
const auto* destination16 = reinterpret_cast<const uint16_t*>(destination.data());
|
||||
|
||||
for (size_t i{}; i != uncompressed_source.size() / 2; ++i)
|
||||
{
|
||||
if (abs(source16[i] - destination16[i]) >
|
||||
near_lossless) // AreEqual is very slow, pre-test to speed up 50X
|
||||
{
|
||||
Assert::AreEqual(static_cast<int>(source16[i]), static_cast<int>(destination16[i]));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void test_compliance_legacy_api(const uint8_t* compressed_bytes, const size_t compressed_length,
|
||||
const uint8_t* uncompressed_data, const size_t uncompressed_length,
|
||||
const bool check_encode)
|
||||
@ -233,36 +202,6 @@ private:
|
||||
// ReSharper restore CppDeprecatedEntity
|
||||
RESTORE_DEPRECATED_WARNING
|
||||
}
|
||||
|
||||
static bool verify_encoded_bytes(const vector<uint8_t>& uncompressed_source, const vector<uint8_t>& encoded_source)
|
||||
{
|
||||
jpegls_decoder decoder;
|
||||
decoder.source(encoded_source);
|
||||
decoder.read_header();
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(decoder.frame_info())
|
||||
.interleave_mode(decoder.interleave_mode())
|
||||
.near_lossless(decoder.near_lossless())
|
||||
.preset_coding_parameters(decoder.preset_coding_parameters());
|
||||
|
||||
vector<uint8_t> our_encoded_bytes(encoded_source.size() + 16);
|
||||
encoder.destination(our_encoded_bytes);
|
||||
|
||||
const size_t bytes_written{encoder.encode(uncompressed_source)};
|
||||
if (bytes_written != encoded_source.size())
|
||||
return false;
|
||||
|
||||
for (size_t i{}; i != encoded_source.size(); ++i)
|
||||
{
|
||||
if (encoded_source[i] != our_encoded_bytes[i])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
}} // namespace charls::test
|
||||
|
||||
@ -26,7 +26,8 @@ public:
|
||||
initialize({destination, count});
|
||||
}
|
||||
|
||||
void set_presets(const charls::jpegls_pc_parameters& /*preset_coding_parameters*/) noexcept(false) override
|
||||
void set_presets(const charls::jpegls_pc_parameters& /*preset_coding_parameters*/,
|
||||
uint32_t /*restart_interval*/) noexcept(false) override
|
||||
{
|
||||
}
|
||||
|
||||
@ -63,11 +64,11 @@ public:
|
||||
int bits;
|
||||
};
|
||||
|
||||
const array<data_t, 5> in_data{{{0x00, 24}, {0xFF, 8}, {0xFFFF, 16}, {0xFFFF, 16}, {0x12345678, 31}}};
|
||||
constexpr array<data_t, 5> in_data{{{0x00, 24}, {0xFF, 8}, {0xFFFF, 16}, {0xFFFF, 16}, {0x12345678, 31}}};
|
||||
|
||||
array<uint8_t, 100> enc_buf{};
|
||||
const frame_info frame_info{};
|
||||
const coding_parameters parameters{};
|
||||
constexpr frame_info frame_info{};
|
||||
constexpr coding_parameters parameters{};
|
||||
|
||||
encoder_strategy_tester encoder(frame_info, parameters);
|
||||
|
||||
|
||||
@ -29,7 +29,7 @@ std::vector<uint8_t> decode_simple_8_bit_monochrome(const std::vector<uint8_t>&
|
||||
std::tie(frame_info, std::ignore) = charls::jpegls_decoder::decode(source, destination);
|
||||
|
||||
if (frame_info.component_count != 1 || frame_info.bits_per_sample != 8)
|
||||
throw std::exception("Not a 8 bit monochrome image");
|
||||
throw std::runtime_error("Not a 8 bit monochrome image");
|
||||
|
||||
return destination;
|
||||
}
|
||||
@ -40,7 +40,7 @@ std::vector<uint8_t> decode_advanced(const std::vector<uint8_t>& source)
|
||||
|
||||
// Standalone JPEG-LS files may have a SPIFF header (color space info, etc.)
|
||||
if (decoder.spiff_header_has_value() && decoder.spiff_header().color_space != charls::spiff_color_space::grayscale)
|
||||
throw std::exception("Not a grayscale image");
|
||||
throw std::runtime_error("Not a grayscale image");
|
||||
|
||||
// After read_header() other properties can also be retrieved.
|
||||
if (decoder.near_lossless() != 0)
|
||||
@ -57,10 +57,10 @@ std::vector<uint8_t> decode_simple_8_bit_monochrome_legacy(const std::vector<uin
|
||||
JlsParameters parameters{};
|
||||
auto error = JpegLsReadHeader(source.data(), source.size(), ¶meters, error_message.data());
|
||||
if (error != CharlsApiResultType::OK)
|
||||
throw std::exception(error_message.data());
|
||||
throw std::runtime_error(error_message.data());
|
||||
|
||||
if (parameters.components != 1 || parameters.bitsPerSample != 8)
|
||||
throw std::exception("Not a 8 bit monochrome image");
|
||||
throw std::runtime_error("Not a 8 bit monochrome image");
|
||||
|
||||
const size_t destination_size = static_cast<size_t>(parameters.width) * static_cast<uint32_t>(parameters.height);
|
||||
std::vector<uint8_t> destination(destination_size);
|
||||
@ -68,7 +68,7 @@ std::vector<uint8_t> decode_simple_8_bit_monochrome_legacy(const std::vector<uin
|
||||
error = JpegLsDecode(destination.data(), destination.size(), source.data(), source.size(), ¶meters,
|
||||
error_message.data());
|
||||
if (error != CharlsApiResultType::OK)
|
||||
throw std::exception(error_message.data());
|
||||
throw std::runtime_error(error_message.data());
|
||||
|
||||
return destination;
|
||||
}
|
||||
@ -115,7 +115,7 @@ std::vector<uint8_t> encode_simple_8_bit_monochrome_legacy(const std::vector<uin
|
||||
const auto error = JpegLsEncode(destination.data(), destination.size(), &bytes_written, source.data(), source.size(),
|
||||
¶meters, error_message.data());
|
||||
if (error != CharlsApiResultType::OK)
|
||||
throw std::exception(error_message.data());
|
||||
throw std::runtime_error(error_message.data());
|
||||
|
||||
destination.resize(bytes_written);
|
||||
return destination;
|
||||
|
||||
@ -15,7 +15,7 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
void set_presets(const jpegls_pc_parameters&) noexcept(false) override
|
||||
void set_presets(const jpegls_pc_parameters&, uint32_t /*restart_interval*/) noexcept(false) override
|
||||
{
|
||||
}
|
||||
|
||||
@ -29,9 +29,9 @@ public:
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void initialize_forward(const byte_span info) noexcept
|
||||
void initialize_forward(const byte_span destination) noexcept
|
||||
{
|
||||
initialize(info);
|
||||
initialize(destination);
|
||||
}
|
||||
|
||||
void append_to_bit_stream_forward(const uint32_t bits, const int32_t bit_count)
|
||||
|
||||
@ -37,7 +37,7 @@ public:
|
||||
{
|
||||
const std::error_category& category{jpegls_category()};
|
||||
|
||||
std::string message{category.message(0)};
|
||||
const std::string message{category.message(0)};
|
||||
Assert::IsTrue(message.size() > 0);
|
||||
}
|
||||
};
|
||||
|
||||
@ -133,7 +133,7 @@ public:
|
||||
jpeg_stream_writer writer({source.data(), source.size()});
|
||||
writer.write_start_of_image();
|
||||
|
||||
const jpegls_pc_parameters presets{1, 2, 3, 4, 5};
|
||||
constexpr jpegls_pc_parameters presets{1, 2, 3, 4, 5};
|
||||
writer.write_jpegls_preset_parameters_segment(presets);
|
||||
writer.write_start_of_frame_segment(1, 1, 2, 1);
|
||||
writer.write_start_of_scan_segment(1, 0, interleave_mode::none);
|
||||
@ -375,7 +375,7 @@ public:
|
||||
|
||||
jpeg_stream_reader reader({writer.buffer.data(), writer.buffer.size()});
|
||||
|
||||
assert_expect_exception(jpegls_errc::unexpected_marker_found, [&]() { reader.read_header(); });
|
||||
assert_expect_exception(jpegls_errc::unexpected_marker_found, [&reader]() { reader.read_header(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_extra_sof_should_throw) // NOLINT
|
||||
@ -387,7 +387,7 @@ public:
|
||||
|
||||
jpeg_stream_reader reader({writer.buffer.data(), writer.buffer.size()});
|
||||
|
||||
assert_expect_exception(jpegls_errc::duplicate_start_of_frame_marker, [&]() { reader.read_header(); });
|
||||
assert_expect_exception(jpegls_errc::duplicate_start_of_frame_marker, [&reader]() { reader.read_header(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_too_large_near_lossless_in_sos_should_throw) // NOLINT
|
||||
@ -400,7 +400,7 @@ public:
|
||||
jpeg_stream_reader reader({writer.buffer.data(), writer.buffer.size()});
|
||||
reader.read_header();
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_parameter_near_lossless, [&]() { reader.read_start_of_scan(); });
|
||||
assert_expect_exception(jpegls_errc::invalid_parameter_near_lossless, [&reader]() { reader.read_start_of_scan(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_too_large_near_lossless_in_sos_should_throw2) // NOLINT
|
||||
@ -418,7 +418,7 @@ public:
|
||||
jpeg_stream_reader reader({writer.buffer.data(), writer.buffer.size()});
|
||||
reader.read_header();
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_parameter_near_lossless, [&]() { reader.read_start_of_scan(); });
|
||||
assert_expect_exception(jpegls_errc::invalid_parameter_near_lossless, [&reader]() { reader.read_start_of_scan(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_with_duplicate_component_id_in_start_of_frame_segment_should_throw) // NOLINT
|
||||
@ -603,6 +603,89 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_with_define_restart_interval_16bit) // NOLINT
|
||||
{
|
||||
jpeg_test_stream_writer writer;
|
||||
writer.write_start_of_image();
|
||||
writer.write_start_of_frame_segment(512, 512, 8, 3);
|
||||
writer.write_define_restart_interval(UINT16_MAX - 5, 2);
|
||||
writer.write_start_of_scan_segment(0, 1, 0, interleave_mode::none);
|
||||
|
||||
jpeg_stream_reader reader({writer.buffer.data(), writer.buffer.size()});
|
||||
reader.read_header();
|
||||
|
||||
Assert::AreEqual(static_cast<uint32_t>(UINT16_MAX - 5), reader.parameters().restart_interval);
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_with_define_restart_interval_24bit) // NOLINT
|
||||
{
|
||||
jpeg_test_stream_writer writer;
|
||||
writer.write_start_of_image();
|
||||
writer.write_start_of_frame_segment(512, 512, 8, 3);
|
||||
writer.write_define_restart_interval(UINT16_MAX + 5, 3);
|
||||
writer.write_start_of_scan_segment(0, 1, 0, interleave_mode::none);
|
||||
|
||||
jpeg_stream_reader reader({writer.buffer.data(), writer.buffer.size()});
|
||||
reader.read_header();
|
||||
|
||||
Assert::AreEqual(static_cast<uint32_t>(UINT16_MAX + 5), reader.parameters().restart_interval);
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_with_define_restart_interval_32bit) // NOLINT
|
||||
{
|
||||
jpeg_test_stream_writer writer;
|
||||
writer.write_start_of_image();
|
||||
writer.write_start_of_frame_segment(512, 512, 8, 3);
|
||||
writer.write_define_restart_interval(UINT32_MAX - 7, 4);
|
||||
writer.write_start_of_scan_segment(0, 1, 0, interleave_mode::none);
|
||||
|
||||
jpeg_stream_reader reader({writer.buffer.data(), writer.buffer.size()});
|
||||
reader.read_header();
|
||||
|
||||
Assert::AreEqual(UINT32_MAX - 7, reader.parameters().restart_interval);
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_with_2_define_restart_intervals) // NOLINT
|
||||
{
|
||||
jpeg_test_stream_writer writer;
|
||||
writer.write_start_of_image();
|
||||
writer.write_define_restart_interval(UINT32_MAX, 4);
|
||||
writer.write_start_of_frame_segment(512, 512, 8, 3);
|
||||
writer.write_define_restart_interval(0, 3);
|
||||
writer.write_start_of_scan_segment(0, 1, 0, interleave_mode::none);
|
||||
|
||||
jpeg_stream_reader reader({writer.buffer.data(), writer.buffer.size()});
|
||||
reader.read_header();
|
||||
|
||||
Assert::AreEqual(0U, reader.parameters().restart_interval);
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_with_bad_define_restart_interval) // NOLINT
|
||||
{
|
||||
jpeg_test_stream_writer writer;
|
||||
writer.write_start_of_image();
|
||||
writer.write_start_of_frame_segment(512, 512, 8, 3);
|
||||
|
||||
constexpr array<uint8_t, 1> buffer{};
|
||||
writer.write_segment(jpeg_marker_code::define_restart_interval, buffer.data(), buffer.size());
|
||||
writer.write_start_of_scan_segment(0, 1, 0, interleave_mode::none);
|
||||
|
||||
jpeg_stream_reader reader({writer.buffer.data(), writer.buffer.size()});
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_marker_segment_size, [&reader] { reader.read_header(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(read_jpegls_stream_with_restart_marker_outside_entropy_data) // NOLINT
|
||||
{
|
||||
jpeg_test_stream_writer writer;
|
||||
writer.write_start_of_image();
|
||||
writer.write_restart_marker(0);
|
||||
|
||||
jpeg_stream_reader reader({writer.buffer.data(), writer.buffer.size()});
|
||||
|
||||
assert_expect_exception(jpegls_errc::unexpected_restart_marker, [&reader] { reader.read_header(); });
|
||||
}
|
||||
|
||||
private:
|
||||
static void read_spiff_header(const uint8_t low_version)
|
||||
{
|
||||
|
||||
@ -42,7 +42,7 @@ public:
|
||||
array<uint8_t, 1> buffer{};
|
||||
jpeg_stream_writer writer({buffer.data(), buffer.size()});
|
||||
|
||||
assert_expect_exception(jpegls_errc::destination_buffer_too_small, [&] { writer.write_start_of_image(); });
|
||||
assert_expect_exception(jpegls_errc::destination_buffer_too_small, [&writer] { writer.write_start_of_image(); });
|
||||
Assert::AreEqual(static_cast<size_t>(0), writer.bytes_written());
|
||||
}
|
||||
|
||||
@ -63,7 +63,7 @@ public:
|
||||
array<uint8_t, 1> buffer{};
|
||||
jpeg_stream_writer writer({buffer.data(), buffer.size()});
|
||||
|
||||
assert_expect_exception(jpegls_errc::destination_buffer_too_small, [&] { writer.write_end_of_image(); });
|
||||
assert_expect_exception(jpegls_errc::destination_buffer_too_small, [&writer] { writer.write_end_of_image(); });
|
||||
Assert::AreEqual(static_cast<size_t>(0), writer.bytes_written());
|
||||
}
|
||||
|
||||
@ -131,7 +131,7 @@ public:
|
||||
Assert::AreEqual(static_cast<uint8_t>(0), buffer[28]);
|
||||
Assert::AreEqual(static_cast<uint8_t>(96), buffer[29]);
|
||||
|
||||
// header.horizontal_resolution = 1024;
|
||||
// header.horizontal_resolution = 1024
|
||||
Assert::AreEqual(static_cast<uint8_t>(0), buffer[30]);
|
||||
Assert::AreEqual(static_cast<uint8_t>(0), buffer[31]);
|
||||
Assert::AreEqual(static_cast<uint8_t>(4), buffer[32]);
|
||||
@ -155,7 +155,7 @@ public:
|
||||
1024};
|
||||
|
||||
assert_expect_exception(jpegls_errc::destination_buffer_too_small,
|
||||
[&] { writer.write_spiff_header_segment(header); });
|
||||
[&writer, &header] { writer.write_spiff_header_segment(header); });
|
||||
Assert::AreEqual(static_cast<size_t>(0), writer.bytes_written());
|
||||
}
|
||||
|
||||
@ -192,7 +192,7 @@ public:
|
||||
array<uint8_t, 10> buffer{};
|
||||
jpeg_stream_writer writer{{buffer.data(), buffer.size()}};
|
||||
|
||||
array<uint8_t, 2> data{0x77, 0x66};
|
||||
const array<uint8_t, 2> data{0x77, 0x66};
|
||||
|
||||
writer.write_spiff_directory_entry(2, data.data(), data.size());
|
||||
|
||||
@ -275,14 +275,14 @@ public:
|
||||
|
||||
Assert::AreEqual(buffer.size(), writer.bytes_written());
|
||||
Assert::AreEqual(static_cast<uint8_t>(16), buffer[4]);
|
||||
Assert::AreEqual(static_cast<uint8_t>(UINT8_MAX), buffer[9]);
|
||||
Assert::AreEqual(UINT8_MAX, buffer[9]);
|
||||
|
||||
Assert::AreEqual(static_cast<uint8_t>(UINT8_MAX), buffer[buffer.size() - 3]); // Last component index.
|
||||
Assert::AreEqual(UINT8_MAX, buffer[buffer.size() - 3]); // Last component index.
|
||||
}
|
||||
|
||||
TEST_METHOD(write_color_transform_segment) // NOLINT
|
||||
{
|
||||
const color_transformation transformation = color_transformation::hp1;
|
||||
constexpr color_transformation transformation = color_transformation::hp1;
|
||||
|
||||
array<uint8_t, 9> buffer{};
|
||||
jpeg_stream_writer writer({buffer.data(), buffer.size()});
|
||||
@ -301,7 +301,7 @@ public:
|
||||
|
||||
TEST_METHOD(write_jpegls_extended_parameters_marker_and_serialize) // NOLINT
|
||||
{
|
||||
const jpegls_pc_parameters presets{2, 1, 2, 3, 7};
|
||||
constexpr jpegls_pc_parameters presets{2, 1, 2, 3, 7};
|
||||
|
||||
array<uint8_t, 15> buffer{};
|
||||
jpeg_stream_writer writer({buffer.data(), buffer.size()});
|
||||
|
||||
@ -82,6 +82,36 @@ public:
|
||||
write_segment(jpeg_marker_code::start_of_scan, segment.data(), segment.size());
|
||||
}
|
||||
|
||||
void write_define_restart_interval(const uint32_t restart_interval, const int size)
|
||||
{
|
||||
std::vector<uint8_t> segment;
|
||||
switch (size)
|
||||
{
|
||||
case 2:
|
||||
push_back(segment, static_cast<uint16_t>(restart_interval));
|
||||
break;
|
||||
|
||||
case 3:
|
||||
push_back_uint24(segment, restart_interval);
|
||||
break;
|
||||
|
||||
case 4:
|
||||
push_back(segment, restart_interval);
|
||||
break;
|
||||
|
||||
default:
|
||||
assert(false);
|
||||
break;
|
||||
}
|
||||
|
||||
write_segment(jpeg_marker_code::define_restart_interval, segment.data(), segment.size());
|
||||
}
|
||||
|
||||
void write_restart_marker(const uint8_t interval_index)
|
||||
{
|
||||
write_marker(static_cast<jpeg_marker_code>(jpeg_restart_marker_base + interval_index));
|
||||
}
|
||||
|
||||
void write_segment(const jpeg_marker_code marker_code, const void* data, const size_t data_size)
|
||||
{
|
||||
write_marker(marker_code);
|
||||
@ -119,6 +149,14 @@ public:
|
||||
int componentIdOverride{};
|
||||
uint8_t mapping_table_selector{};
|
||||
std::vector<uint8_t> buffer;
|
||||
|
||||
private:
|
||||
static void push_back_uint24(std::vector<uint8_t>& values, const uint32_t value)
|
||||
{
|
||||
values.push_back(static_cast<uint8_t>(value >> 16));
|
||||
values.push_back(static_cast<uint8_t>(value >> 8));
|
||||
values.push_back(static_cast<uint8_t>(value));
|
||||
}
|
||||
};
|
||||
|
||||
}} // namespace charls::test
|
||||
|
||||
@ -19,6 +19,7 @@
|
||||
using Microsoft::VisualStudio::CppUnitTestFramework::Assert;
|
||||
using std::array;
|
||||
using std::error_code;
|
||||
using std::ignore;
|
||||
using std::tie;
|
||||
using std::vector;
|
||||
using namespace charls_test;
|
||||
@ -50,7 +51,7 @@ public:
|
||||
jpegls_decoder decoder2(std::move(decoder1));
|
||||
|
||||
jpegls_decoder decoder3;
|
||||
const array<uint8_t, 10> buffer{};
|
||||
constexpr array<uint8_t, 10> buffer{};
|
||||
decoder3.source(buffer.data(), buffer.size());
|
||||
decoder3 = std::move(decoder2);
|
||||
}
|
||||
@ -59,30 +60,30 @@ public:
|
||||
{
|
||||
jpegls_decoder decoder;
|
||||
|
||||
vector<uint8_t> source(2000);
|
||||
const vector<uint8_t> source(2000);
|
||||
decoder.source(source);
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&] { decoder.source(source); });
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&decoder, &source] { decoder.source(source); });
|
||||
}
|
||||
|
||||
TEST_METHOD(read_spiff_header_without_source) // NOLINT
|
||||
{
|
||||
jpegls_decoder decoder;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&] { decoder.read_spiff_header(); });
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&decoder] { decoder.read_spiff_header(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(destination_size_without_reading_header) // NOLINT
|
||||
{
|
||||
jpegls_decoder decoder;
|
||||
const jpegls_decoder decoder;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&] { static_cast<void>(decoder.destination_size()); });
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&decoder] { ignore = decoder.destination_size(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_without_source) // NOLINT
|
||||
{
|
||||
jpegls_decoder decoder;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&] { decoder.read_header(); });
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&decoder] { decoder.read_header(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_from_non_jpegls_data) // NOLINT
|
||||
@ -120,17 +121,17 @@ public:
|
||||
TEST_METHOD(interleave_mode_without_read_header) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source(2000);
|
||||
jpegls_decoder decoder{source, false};
|
||||
const jpegls_decoder decoder{source, false};
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&] { static_cast<void>(decoder.interleave_mode()); });
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&decoder] { ignore = decoder.interleave_mode(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(near_lossless_without_read_header) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source(2000);
|
||||
jpegls_decoder decoder{source, false};
|
||||
const jpegls_decoder decoder{source, false};
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&] { static_cast<void>(decoder.near_lossless()); });
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&decoder] { ignore = decoder.near_lossless(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(preset_coding_parameters_without_read_header) // NOLINT
|
||||
@ -140,8 +141,7 @@ public:
|
||||
const vector<uint8_t> source(2000);
|
||||
decoder.source(source);
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation,
|
||||
[&] { static_cast<void>(decoder.preset_coding_parameters()); });
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&decoder] { ignore = decoder.preset_coding_parameters(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(destination_size) // NOLINT
|
||||
@ -261,10 +261,10 @@ public:
|
||||
|
||||
TEST_METHOD(decode_without_reading_header) // NOLINT
|
||||
{
|
||||
jpegls_decoder decoder;
|
||||
const jpegls_decoder decoder;
|
||||
|
||||
vector<uint8_t> buffer(1000);
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&] { decoder.decode(buffer); });
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&decoder, &buffer] { decoder.decode(buffer); });
|
||||
}
|
||||
|
||||
TEST_METHOD(decode_reference_to_mapping_table_selector) // NOLINT
|
||||
@ -278,7 +278,7 @@ public:
|
||||
|
||||
jpegls_decoder decoder{writer.buffer, false};
|
||||
|
||||
assert_expect_exception(jpegls_errc::parameter_value_not_supported, [&] { decoder.read_header(); });
|
||||
assert_expect_exception(jpegls_errc::parameter_value_not_supported, [&decoder] { decoder.read_header(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(read_spiff_header) // NOLINT
|
||||
@ -327,7 +327,7 @@ public:
|
||||
jpegls_decoder decoder{source, false};
|
||||
|
||||
error_code ec;
|
||||
static_cast<void>(decoder.read_spiff_header(ec));
|
||||
ignore = decoder.read_spiff_header(ec);
|
||||
|
||||
Assert::IsTrue(ec == jpegls_errc::jpeg_marker_start_byte_not_found);
|
||||
}
|
||||
@ -354,7 +354,7 @@ public:
|
||||
|
||||
jpegls_decoder decoder{source, true};
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&] { static_cast<void>(decoder.read_header()); });
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&decoder] { ignore = decoder.read_header(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(simple_decode) // NOLINT
|
||||
@ -399,7 +399,7 @@ public:
|
||||
{
|
||||
const vector<uint8_t> source{read_file("ff_in_entropy_data.jls")};
|
||||
|
||||
jpegls_decoder decoder{source, true};
|
||||
const jpegls_decoder decoder{source, true};
|
||||
|
||||
const auto& frame_info{decoder.frame_info()};
|
||||
Assert::AreEqual(1, frame_info.component_count);
|
||||
@ -409,14 +409,15 @@ public:
|
||||
|
||||
vector<uint8_t> destination(decoder.destination_size());
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_encoded_data, [&] { static_cast<void>(decoder.decode(destination)); });
|
||||
assert_expect_exception(jpegls_errc::invalid_encoded_data,
|
||||
[&decoder, &destination] { decoder.decode(destination); });
|
||||
}
|
||||
|
||||
TEST_METHOD(decode_file_with_golomb_large_then_k_max) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source{read_file("fuzzy_input_golomb_16.jls")};
|
||||
|
||||
jpegls_decoder decoder{source, true};
|
||||
const jpegls_decoder decoder{source, true};
|
||||
|
||||
const auto& frame_info{decoder.frame_info()};
|
||||
Assert::AreEqual(3, frame_info.component_count);
|
||||
@ -426,9 +427,58 @@ public:
|
||||
|
||||
vector<uint8_t> destination(decoder.destination_size());
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_encoded_data, [&] { static_cast<void>(decoder.decode(destination)); });
|
||||
assert_expect_exception(jpegls_errc::invalid_encoded_data,
|
||||
[&decoder, &destination] { decoder.decode(destination); });
|
||||
}
|
||||
|
||||
TEST_METHOD(decode_file_with_missing_restart_marker) // NOLINT
|
||||
{
|
||||
vector<uint8_t> source{read_file("DataFiles/t8c0e0.jls")};
|
||||
|
||||
// Insert a DRI marker segment to trigger that restart markers are used.
|
||||
jpeg_test_stream_writer stream_writer;
|
||||
stream_writer.write_define_restart_interval(10, 3);
|
||||
const auto it = source.begin() + 2;
|
||||
source.insert(it, stream_writer.buffer.cbegin(), stream_writer.buffer.cend());
|
||||
|
||||
const jpegls_decoder decoder{source, true};
|
||||
vector<uint8_t> destination(decoder.destination_size());
|
||||
|
||||
assert_expect_exception(jpegls_errc::restart_marker_not_found, [&decoder, &destination] { decoder.decode(destination); });
|
||||
}
|
||||
|
||||
TEST_METHOD(decode_file_with_incorrect_restart_marker) // NOLINT
|
||||
{
|
||||
vector<uint8_t> source{read_file("DataFiles/test8_ilv_none_rm_7.jls")};
|
||||
|
||||
// Change the first restart marker to the second.
|
||||
auto it{find_scan_header(source.begin(), source.end())};
|
||||
it = find_first_restart_marker(it + 1, source.end());
|
||||
++it;
|
||||
*it = 0xD1;
|
||||
|
||||
const jpegls_decoder decoder{source, true};
|
||||
vector<uint8_t> destination(decoder.destination_size());
|
||||
|
||||
assert_expect_exception(jpegls_errc::restart_marker_not_found, [&decoder, &destination] { decoder.decode(destination); });
|
||||
}
|
||||
|
||||
TEST_METHOD(decode_file_with_extra_begin_bytes_for_restart_marker_code) // NOLINT
|
||||
{
|
||||
vector<uint8_t> source{read_file("DataFiles/test8_ilv_none_rm_7.jls")};
|
||||
|
||||
// Add additional 0xFF marker begin bytes
|
||||
auto it{find_scan_header(source.begin(), source.end())};
|
||||
it = find_first_restart_marker(it + 1, source.end());
|
||||
const array<uint8_t, 7> extra_begin_bytes{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
|
||||
source.insert(it, extra_begin_bytes.cbegin(), extra_begin_bytes.cend());
|
||||
|
||||
const jpegls_decoder decoder{source, true};
|
||||
portable_anymap_file reference_file{
|
||||
read_anymap_reference_file("DataFiles/test8.ppm", decoder.interleave_mode(), decoder.frame_info())};
|
||||
|
||||
test_compliance(source, reference_file.image_data(), false);
|
||||
}
|
||||
|
||||
private:
|
||||
static vector<uint8_t>::iterator find_scan_header(const vector<uint8_t>::iterator& begin,
|
||||
@ -445,6 +495,20 @@ private:
|
||||
return end;
|
||||
}
|
||||
|
||||
static vector<uint8_t>::iterator find_first_restart_marker(const vector<uint8_t>::iterator& begin,
|
||||
const vector<uint8_t>::iterator& end) noexcept
|
||||
{
|
||||
constexpr uint8_t first_restart_marker{0xD0};
|
||||
|
||||
for (auto it{begin}; it != end; ++it)
|
||||
{
|
||||
if (*it == 0xFF && it + 1 != end && *(it + 1) == first_restart_marker)
|
||||
return it;
|
||||
}
|
||||
|
||||
return end;
|
||||
}
|
||||
|
||||
static vector<uint8_t> create_default_pc_parameters_segment()
|
||||
{
|
||||
vector<uint8_t> segment;
|
||||
|
||||
@ -14,8 +14,8 @@
|
||||
|
||||
using Microsoft::VisualStudio::CppUnitTestFramework::Assert;
|
||||
using std::array;
|
||||
using std::vector;
|
||||
using std::ignore;
|
||||
using std::vector;
|
||||
|
||||
constexpr size_t serialized_spiff_header_size = 34;
|
||||
|
||||
@ -54,16 +54,18 @@ public:
|
||||
{
|
||||
jpegls_encoder encoder;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_width, [&] { encoder.frame_info({0, 1, 2, 1}); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_width, [&] { encoder.frame_info({UINT16_MAX + 1, 1, 2, 1}); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_width, [&encoder] { encoder.frame_info({0, 1, 2, 1}); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_width, [&encoder] {
|
||||
encoder.frame_info({UINT16_MAX + 1, 1, 2, 1});
|
||||
});
|
||||
}
|
||||
|
||||
TEST_METHOD(frame_info_bad_height) // NOLINT
|
||||
{
|
||||
jpegls_encoder encoder;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_height, [&] { encoder.frame_info({1, 0, 2, 1}); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_height, [&] {
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_height, [&encoder] { encoder.frame_info({1, 0, 2, 1}); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_height, [&encoder] {
|
||||
encoder.frame_info({1, UINT16_MAX + 1, 2, 1});
|
||||
});
|
||||
}
|
||||
@ -72,16 +74,24 @@ public:
|
||||
{
|
||||
jpegls_encoder encoder;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_bits_per_sample, [&] { encoder.frame_info({1, 1, 1, 1}); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_bits_per_sample, [&] { encoder.frame_info({1, 1, 17, 1}); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_bits_per_sample, [&encoder] {
|
||||
encoder.frame_info({1, 1, 1, 1});
|
||||
});
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_bits_per_sample, [&encoder] {
|
||||
encoder.frame_info({1, 1, 17, 1});
|
||||
});
|
||||
}
|
||||
|
||||
TEST_METHOD(frame_info_bad_component_count) // NOLINT
|
||||
{
|
||||
jpegls_encoder encoder;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_component_count, [&] { encoder.frame_info({1, 1, 2, 0}); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_component_count, [&] { encoder.frame_info({1, 1, 2, 256}); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_component_count, [&encoder] {
|
||||
encoder.frame_info({1, 1, 2, 0});
|
||||
});
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_component_count, [&encoder] {
|
||||
encoder.frame_info({1, 1, 2, 256});
|
||||
});
|
||||
}
|
||||
|
||||
TEST_METHOD(interleave_mode) // NOLINT
|
||||
@ -98,9 +108,9 @@ public:
|
||||
jpegls_encoder encoder;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_interleave_mode,
|
||||
[&] { encoder.interleave_mode(static_cast<charls::interleave_mode>(-1)); });
|
||||
[&encoder] { encoder.interleave_mode(static_cast<charls::interleave_mode>(-1)); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_interleave_mode,
|
||||
[&] { encoder.interleave_mode(static_cast<charls::interleave_mode>(3)); });
|
||||
[&encoder] { encoder.interleave_mode(static_cast<charls::interleave_mode>(3)); });
|
||||
}
|
||||
|
||||
TEST_METHOD(near_lossless) // NOLINT
|
||||
@ -115,8 +125,8 @@ public:
|
||||
{
|
||||
jpegls_encoder encoder;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_near_lossless, [&] { encoder.near_lossless(-1); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_near_lossless, [&] { encoder.near_lossless(256); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_near_lossless, [&encoder] { encoder.near_lossless(-1); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_near_lossless, [&encoder] { encoder.near_lossless(256); });
|
||||
}
|
||||
|
||||
TEST_METHOD(estimated_destination_size_minimal_frame_info) // NOLINT
|
||||
@ -179,7 +189,7 @@ public:
|
||||
const jpegls_encoder encoder;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation,
|
||||
[&] { static_cast<void>(encoder.estimated_destination_size()); });
|
||||
[&encoder] { ignore = encoder.estimated_destination_size(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(destination) // NOLINT
|
||||
@ -197,7 +207,8 @@ public:
|
||||
vector<uint8_t> destination(200);
|
||||
encoder.destination(destination);
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&] { encoder.destination(destination); });
|
||||
assert_expect_exception(jpegls_errc::invalid_operation,
|
||||
[&encoder, &destination] { encoder.destination(destination); });
|
||||
}
|
||||
|
||||
TEST_METHOD(write_standard_spiff_header) // NOLINT
|
||||
@ -237,7 +248,7 @@ public:
|
||||
encoder.frame_info({1, 1, 2, 1});
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation,
|
||||
[&] { encoder.write_standard_spiff_header(spiff_color_space::cmyk); });
|
||||
[&encoder] { encoder.write_standard_spiff_header(spiff_color_space::cmyk); });
|
||||
}
|
||||
|
||||
TEST_METHOD(write_standard_spiff_header_without_frame_info) // NOLINT
|
||||
@ -248,7 +259,7 @@ public:
|
||||
encoder.destination(destination);
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation,
|
||||
[&] { encoder.write_standard_spiff_header(spiff_color_space::cmyk); });
|
||||
[&encoder] { encoder.write_standard_spiff_header(spiff_color_space::cmyk); });
|
||||
}
|
||||
|
||||
TEST_METHOD(write_standard_spiff_header_twice) // NOLINT
|
||||
@ -262,7 +273,7 @@ public:
|
||||
encoder.write_standard_spiff_header(spiff_color_space::cmyk);
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation,
|
||||
[&] { encoder.write_standard_spiff_header(spiff_color_space::cmyk); });
|
||||
[&encoder] { encoder.write_standard_spiff_header(spiff_color_space::cmyk); });
|
||||
}
|
||||
|
||||
TEST_METHOD(write_spiff_header) // NOLINT
|
||||
@ -310,7 +321,8 @@ public:
|
||||
spiff_header spiff_header{};
|
||||
spiff_header.width = 1;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_height, [&] { encoder.write_spiff_header(spiff_header); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_height,
|
||||
[&encoder, &spiff_header] { encoder.write_spiff_header(spiff_header); });
|
||||
Assert::AreEqual(static_cast<size_t>(0), encoder.bytes_written());
|
||||
}
|
||||
|
||||
@ -326,7 +338,8 @@ public:
|
||||
spiff_header spiff_header{};
|
||||
spiff_header.height = 1;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_width, [&] { encoder.write_spiff_header(spiff_header); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_width,
|
||||
[&encoder, &spiff_header] { encoder.write_spiff_header(spiff_header); });
|
||||
Assert::AreEqual(static_cast<size_t>(0), encoder.bytes_written());
|
||||
}
|
||||
|
||||
@ -386,7 +399,7 @@ public:
|
||||
encoder.destination(destination);
|
||||
encoder.write_standard_spiff_header(spiff_color_space::cmyk);
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_argument, [&] { encoder.write_spiff_entry(1, "test", 4); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument, [&encoder] { encoder.write_spiff_entry(1, "test", 4); });
|
||||
}
|
||||
|
||||
TEST_METHOD(write_spiff_entry_with_invalid_size) // NOLINT
|
||||
@ -399,8 +412,8 @@ public:
|
||||
encoder.destination(destination);
|
||||
encoder.write_standard_spiff_header(spiff_color_space::cmyk);
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_spiff_entry_size, [&] {
|
||||
vector<uint8_t> spiff_entry(65528 + 1);
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_spiff_entry_size, [&encoder] {
|
||||
const vector<uint8_t> spiff_entry(65528 + 1);
|
||||
encoder.write_spiff_entry(spiff_entry_tag::image_title, spiff_entry.data(), spiff_entry.size());
|
||||
});
|
||||
}
|
||||
@ -414,8 +427,8 @@ public:
|
||||
vector<uint8_t> destination(encoder.estimated_destination_size());
|
||||
encoder.destination(destination);
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&] {
|
||||
vector<uint8_t> spiff_entry(65528);
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&encoder] {
|
||||
const vector<uint8_t> spiff_entry(65528);
|
||||
encoder.write_spiff_entry(spiff_entry_tag::image_title, spiff_entry.data(), spiff_entry.size());
|
||||
});
|
||||
}
|
||||
@ -424,7 +437,7 @@ public:
|
||||
{
|
||||
jpegls_encoder encoder;
|
||||
|
||||
const jpegls_pc_parameters pc_parameters{};
|
||||
constexpr jpegls_pc_parameters pc_parameters{};
|
||||
encoder.preset_coding_parameters(pc_parameters);
|
||||
|
||||
// No explicit test possible, code should remain stable.
|
||||
@ -434,17 +447,18 @@ public:
|
||||
TEST_METHOD(set_preset_coding_parameters_bad_values) // NOLINT
|
||||
{
|
||||
const array<uint8_t, 5> source{0, 1, 1, 1, 0};
|
||||
const frame_info frame_info{5, 1, 8, 1};
|
||||
constexpr frame_info frame_info{5, 1, 8, 1};
|
||||
jpegls_encoder encoder;
|
||||
|
||||
encoder.frame_info(frame_info);
|
||||
vector<uint8_t> destination(encoder.estimated_destination_size());
|
||||
encoder.destination(destination);
|
||||
|
||||
const jpegls_pc_parameters bad_pc_parameters{1, 1, 1, 1, 1};
|
||||
constexpr jpegls_pc_parameters bad_pc_parameters{1, 1, 1, 1, 1};
|
||||
encoder.preset_coding_parameters(bad_pc_parameters);
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_jpegls_pc_parameters, [&] { ignore = encoder.encode(source); });
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_jpegls_pc_parameters,
|
||||
[&encoder, &source] { ignore = encoder.encode(source); });
|
||||
}
|
||||
|
||||
TEST_METHOD(encode_with_preset_coding_parameters_non_default_values) // NOLINT
|
||||
@ -462,7 +476,7 @@ public:
|
||||
jpegls_encoder encoder;
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_argument_color_transformation,
|
||||
[&] { encoder.color_transformation(static_cast<color_transformation>(100)); });
|
||||
[&encoder] { encoder.color_transformation(static_cast<color_transformation>(100)); });
|
||||
}
|
||||
|
||||
TEST_METHOD(encode_without_destination) // NOLINT
|
||||
@ -471,7 +485,7 @@ public:
|
||||
|
||||
encoder.frame_info({1, 1, 2, 1});
|
||||
vector<uint8_t> source(20);
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&] { ignore = encoder.encode(source); });
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&encoder, &source] { ignore = encoder.encode(source); });
|
||||
}
|
||||
|
||||
TEST_METHOD(encode_without_frame_info) // NOLINT
|
||||
@ -481,13 +495,13 @@ public:
|
||||
vector<uint8_t> destination(20);
|
||||
encoder.destination(destination);
|
||||
const vector<uint8_t> source(20);
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&] { ignore = encoder.encode(source); });
|
||||
assert_expect_exception(jpegls_errc::invalid_operation, [&encoder, &source] { ignore = encoder.encode(source); });
|
||||
}
|
||||
|
||||
TEST_METHOD(encode_with_spiff_header) // NOLINT
|
||||
{
|
||||
const array<uint8_t, 5> source{0, 1, 2, 3, 4};
|
||||
const frame_info frame_info{5, 1, 8, 1};
|
||||
constexpr frame_info frame_info{5, 1, 8, 1};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info);
|
||||
@ -505,7 +519,7 @@ public:
|
||||
TEST_METHOD(encode_with_color_transformation) // NOLINT
|
||||
{
|
||||
const array<uint8_t, 6> source{0, 1, 2, 3, 4, 5};
|
||||
const frame_info frame_info{2, 1, 8, 3};
|
||||
constexpr frame_info frame_info{2, 1, 8, 3};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info);
|
||||
@ -522,7 +536,7 @@ public:
|
||||
TEST_METHOD(encode_16_bit) // NOLINT
|
||||
{
|
||||
const array<uint8_t, 6> source{0, 1, 2, 3, 4, 5};
|
||||
const frame_info frame_info{3, 1, 16, 1};
|
||||
constexpr frame_info frame_info{3, 1, 16, 1};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info);
|
||||
@ -540,7 +554,7 @@ public:
|
||||
{
|
||||
const vector<uint8_t> source{0, 1, 2, 3, 4, 5};
|
||||
|
||||
const frame_info frame_info{3, 1, 16, 1};
|
||||
constexpr frame_info frame_info{3, 1, 16, 1};
|
||||
const auto encoded{jpegls_encoder::encode(source, frame_info)};
|
||||
|
||||
test_by_decoding(encoded, frame_info, source.data(), source.size(), interleave_mode::none);
|
||||
@ -550,7 +564,7 @@ public:
|
||||
{
|
||||
const array<uint8_t, 30> source{100, 100, 100, 0, 0, 0, 0, 0, 0, 0, 150, 150,
|
||||
150, 0, 0, 0, 0, 0, 0, 0, 200, 200, 200};
|
||||
const frame_info frame_info{3, 1, 8, 3};
|
||||
constexpr frame_info frame_info{3, 1, 8, 3};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info);
|
||||
@ -567,7 +581,7 @@ public:
|
||||
TEST_METHOD(encode_1_component_4_bit_with_high_bits_set) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source(512 * 512, 0xFF);
|
||||
const frame_info frame_info{512, 512, 4, 1};
|
||||
constexpr frame_info frame_info{512, 512, 4, 1};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info);
|
||||
@ -585,7 +599,7 @@ public:
|
||||
TEST_METHOD(encode_1_component_12_bit_with_high_bits_set) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source(512 * 512 * 2, 0xFF);
|
||||
const frame_info frame_info{512, 512, 12, 1};
|
||||
constexpr frame_info frame_info{512, 512, 12, 1};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info);
|
||||
@ -603,7 +617,7 @@ public:
|
||||
TEST_METHOD(encode_3_components_6_bit_with_high_bits_set_interleave_mode_sample) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source(512 * 512 * 3, 0xFF);
|
||||
const frame_info frame_info{512, 512, 6, 3};
|
||||
constexpr frame_info frame_info{512, 512, 6, 3};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info).interleave_mode(interleave_mode::sample);
|
||||
@ -621,7 +635,7 @@ public:
|
||||
TEST_METHOD(encode_3_components_6_bit_with_high_bits_set_interleave_mode_line) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source(512 * 512 * 3, 0xFF);
|
||||
const frame_info frame_info{512, 512, 6, 3};
|
||||
constexpr frame_info frame_info{512, 512, 6, 3};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info).interleave_mode(interleave_mode::line);
|
||||
@ -639,7 +653,7 @@ public:
|
||||
TEST_METHOD(encode_3_components_10_bit_with_high_bits_set_interleave_mode_sample) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source(512 * 512 * 2 * 3, 0xFF);
|
||||
const frame_info frame_info{512, 512, 10, 3};
|
||||
constexpr frame_info frame_info{512, 512, 10, 3};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info).interleave_mode(interleave_mode::sample);
|
||||
@ -657,7 +671,7 @@ public:
|
||||
TEST_METHOD(encode_3_components_10_bit_with_high_bits_set_interleave_mode_line) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source(512 * 512 * 2 * 3, 0xFF);
|
||||
const frame_info frame_info{512, 512, 10, 3};
|
||||
constexpr frame_info frame_info{512, 512, 10, 3};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info).interleave_mode(interleave_mode::line);
|
||||
@ -675,7 +689,7 @@ public:
|
||||
TEST_METHOD(encode_4_components_6_bit_with_high_bits_set_interleave_mode_sample) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source(512 * 512 * 4, 0xFF);
|
||||
const frame_info frame_info{512, 512, 6, 4};
|
||||
constexpr frame_info frame_info{512, 512, 6, 4};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info).interleave_mode(interleave_mode::sample);
|
||||
@ -693,7 +707,7 @@ public:
|
||||
TEST_METHOD(encode_4_components_6_bit_with_high_bits_set_interleave_mode_line) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source(512 * 512 * 4, 0xFF);
|
||||
const frame_info frame_info{512, 512, 6, 4};
|
||||
constexpr frame_info frame_info{512, 512, 6, 4};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info).interleave_mode(interleave_mode::line);
|
||||
@ -711,7 +725,7 @@ public:
|
||||
TEST_METHOD(encode_4_components_10_bit_with_high_bits_set_interleave_mode_sample) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source(512 * 512 * 2 * 4, 0xFF);
|
||||
const frame_info frame_info{512, 512, 10, 4};
|
||||
constexpr frame_info frame_info{512, 512, 10, 4};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info).interleave_mode(interleave_mode::sample);
|
||||
@ -729,7 +743,7 @@ public:
|
||||
TEST_METHOD(encode_4_components_10_bit_with_high_bits_set_interleave_mode_line) // NOLINT
|
||||
{
|
||||
const vector<uint8_t> source(512 * 512 * 2 * 4, 0xFF);
|
||||
const frame_info frame_info{512, 512, 10, 4};
|
||||
constexpr frame_info frame_info{512, 512, 10, 4};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info).interleave_mode(interleave_mode::line);
|
||||
@ -747,7 +761,7 @@ public:
|
||||
TEST_METHOD(rewind) // NOLINT
|
||||
{
|
||||
const array<uint8_t, 6> source{0, 1, 2, 3, 4, 5};
|
||||
const frame_info frame_info{3, 1, 16, 1};
|
||||
constexpr frame_info frame_info{3, 1, 16, 1};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info);
|
||||
@ -772,7 +786,7 @@ public:
|
||||
TEST_METHOD(rewind_before_destination) // NOLINT
|
||||
{
|
||||
const array<uint8_t, 6> source{0, 1, 2, 3, 4, 5};
|
||||
const frame_info frame_info{3, 1, 16, 1};
|
||||
constexpr frame_info frame_info{3, 1, 16, 1};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info);
|
||||
@ -828,7 +842,7 @@ private:
|
||||
static void encode_with_custom_preset_coding_parameters(const jpegls_pc_parameters& pc_parameters)
|
||||
{
|
||||
const array<uint8_t, 5> source{0, 1, 1, 1, 0};
|
||||
const frame_info frame_info{5, 1, 8, 1};
|
||||
constexpr frame_info frame_info{5, 1, 8, 1};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(frame_info);
|
||||
|
||||
@ -17,13 +17,12 @@ public:
|
||||
{
|
||||
using lossless_traits = lossless_traits<uint16_t, 12>;
|
||||
const auto traits1{default_traits<uint16_t, uint16_t>(4095, 0)};
|
||||
const lossless_traits traits2{};
|
||||
|
||||
Assert::IsTrue(traits1.limit == traits2.limit);
|
||||
Assert::IsTrue(traits1.maximum_sample_value == traits2.maximum_sample_value);
|
||||
Assert::IsTrue(traits1.reset_threshold == traits2.reset_threshold);
|
||||
Assert::IsTrue(traits1.bits_per_pixel == traits2.bits_per_pixel);
|
||||
Assert::IsTrue(traits1.quantized_bits_per_pixel == traits2.quantized_bits_per_pixel);
|
||||
Assert::IsTrue(traits1.limit == lossless_traits::limit);
|
||||
Assert::IsTrue(traits1.maximum_sample_value == lossless_traits::maximum_sample_value);
|
||||
Assert::IsTrue(traits1.reset_threshold == lossless_traits::reset_threshold);
|
||||
Assert::IsTrue(traits1.bits_per_pixel == lossless_traits::bits_per_pixel);
|
||||
Assert::IsTrue(traits1.quantized_bits_per_pixel == lossless_traits::quantized_bits_per_pixel);
|
||||
|
||||
for (int i{-4096}; i <= 4096; ++i)
|
||||
{
|
||||
@ -42,13 +41,12 @@ public:
|
||||
{
|
||||
using lossless_traits = lossless_traits<uint8_t, 8>;
|
||||
const auto traits1{default_traits<uint8_t, uint8_t>(255, 0)};
|
||||
const lossless_traits traits2{};
|
||||
|
||||
Assert::IsTrue(traits1.limit == traits2.limit);
|
||||
Assert::IsTrue(traits1.maximum_sample_value == traits2.maximum_sample_value);
|
||||
Assert::IsTrue(traits1.reset_threshold == traits2.reset_threshold);
|
||||
Assert::IsTrue(traits1.bits_per_pixel == traits2.bits_per_pixel);
|
||||
Assert::IsTrue(traits1.quantized_bits_per_pixel == traits2.quantized_bits_per_pixel);
|
||||
Assert::IsTrue(traits1.limit == lossless_traits::limit);
|
||||
Assert::IsTrue(traits1.maximum_sample_value == lossless_traits::maximum_sample_value);
|
||||
Assert::IsTrue(traits1.reset_threshold == lossless_traits::reset_threshold);
|
||||
Assert::IsTrue(traits1.bits_per_pixel == lossless_traits::bits_per_pixel);
|
||||
Assert::IsTrue(traits1.quantized_bits_per_pixel == lossless_traits::quantized_bits_per_pixel);
|
||||
|
||||
for (int i{-255}; i <= 255; ++i)
|
||||
{
|
||||
|
||||
@ -15,7 +15,7 @@ namespace {
|
||||
|
||||
/// <summary>
|
||||
/// This is the original algorithm of ISO/IEC 14495-1, A.5.2, Code Segment A.11 (second else branch)
|
||||
/// It will map signed values to unsiged values.
|
||||
/// It will map signed values to unsigned values.
|
||||
/// </summary>
|
||||
int32_t map_error_value_original(const int32_t error_value) noexcept
|
||||
{
|
||||
|
||||
BIN
unittest/test16_rm_5.jls
Normal file
BIN
unittest/test16_rm_5.jls
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 67 KiB |
BIN
unittest/test8_ilv_line_rm_7.jls
Normal file
BIN
unittest/test8_ilv_line_rm_7.jls
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 112 KiB |
BIN
unittest/test8_ilv_none_rm_7.jls
Normal file
BIN
unittest/test8_ilv_none_rm_7.jls
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 117 KiB |
BIN
unittest/test8_ilv_sample_rm_300.jls
Normal file
BIN
unittest/test8_ilv_sample_rm_300.jls
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 97 KiB |
BIN
unittest/test8_ilv_sample_rm_7.jls
Normal file
BIN
unittest/test8_ilv_sample_rm_7.jls
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 108 KiB |
@ -130,7 +130,7 @@ vector<uint8_t> create_test_spiff_header(const uint8_t high_version, const uint8
|
||||
buffer.push_back(0);
|
||||
buffer.push_back(96);
|
||||
|
||||
// header.horizontal_resolution = 1024;
|
||||
// header.horizontal_resolution = 1024
|
||||
buffer.push_back(0);
|
||||
buffer.push_back(0);
|
||||
buffer.push_back(4);
|
||||
@ -202,4 +202,89 @@ void test_round_trip_legacy(const vector<uint8_t>& source, const JlsParameters&
|
||||
RESTORE_DEPRECATED_WARNING
|
||||
}
|
||||
|
||||
bool verify_encoded_bytes(const vector<uint8_t>& uncompressed_source, const vector<uint8_t>& encoded_source)
|
||||
{
|
||||
const jpegls_decoder decoder{encoded_source, true};
|
||||
|
||||
jpegls_encoder encoder;
|
||||
encoder.frame_info(decoder.frame_info())
|
||||
.interleave_mode(decoder.interleave_mode())
|
||||
.near_lossless(decoder.near_lossless())
|
||||
.preset_coding_parameters(decoder.preset_coding_parameters());
|
||||
|
||||
vector<uint8_t> our_encoded_bytes(encoded_source.size() + 16);
|
||||
encoder.destination(our_encoded_bytes);
|
||||
|
||||
const size_t bytes_written{encoder.encode(uncompressed_source)};
|
||||
if (bytes_written != encoded_source.size())
|
||||
return false;
|
||||
|
||||
for (size_t i{}; i != encoded_source.size(); ++i)
|
||||
{
|
||||
if (encoded_source[i] != our_encoded_bytes[i])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void test_compliance(const vector<uint8_t>& encoded_source, const vector<uint8_t>& uncompressed_source,
|
||||
const bool check_encode)
|
||||
{
|
||||
const jpegls_decoder decoder{encoded_source, true};
|
||||
|
||||
if (check_encode)
|
||||
{
|
||||
Assert::IsTrue(verify_encoded_bytes(uncompressed_source, encoded_source));
|
||||
}
|
||||
|
||||
vector<uint8_t> destination(decoder.destination_size());
|
||||
decoder.decode(destination);
|
||||
|
||||
if (decoder.near_lossless() == 0)
|
||||
{
|
||||
for (size_t i{}; i != uncompressed_source.size(); ++i)
|
||||
{
|
||||
if (uncompressed_source[i] != destination[i]) // AreEqual is very slow, pre-test to speed up 50X
|
||||
{
|
||||
Assert::AreEqual(uncompressed_source[i], destination[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
const frame_info frame_info{decoder.frame_info()};
|
||||
const auto near_lossless{decoder.near_lossless()};
|
||||
|
||||
if (frame_info.bits_per_sample <= 8)
|
||||
{
|
||||
for (size_t i{}; i != uncompressed_source.size(); ++i)
|
||||
{
|
||||
if (abs(uncompressed_source[i] - destination[i]) >
|
||||
near_lossless) // AreEqual is very slow, pre-test to speed up 50X
|
||||
{
|
||||
Assert::AreEqual(uncompressed_source[i], destination[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
const auto* source16 = reinterpret_cast<const uint16_t*>(uncompressed_source.data());
|
||||
const auto* destination16 = reinterpret_cast<const uint16_t*>(destination.data());
|
||||
|
||||
for (size_t i{}; i != uncompressed_source.size() / 2; ++i)
|
||||
{
|
||||
if (abs(source16[i] - destination16[i]) > near_lossless) // AreEqual is very slow, pre-test to speed up 50X
|
||||
{
|
||||
Assert::AreEqual(static_cast<int>(source16[i]), static_cast<int>(destination16[i]));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}} // namespace charls::test
|
||||
|
||||
@ -52,6 +52,10 @@ std::vector<uint8_t> create_test_spiff_header(uint8_t high_version = 2, uint8_t
|
||||
bool end_of_directory = true);
|
||||
std::vector<uint8_t> create_noise_image_16_bit(size_t pixel_count, int bit_count, uint32_t seed);
|
||||
void test_round_trip_legacy(const std::vector<uint8_t>& source, const JlsParameters& params);
|
||||
bool verify_encoded_bytes(const std::vector<uint8_t>& uncompressed_source, const std::vector<uint8_t>& encoded_source);
|
||||
void test_compliance(const std::vector<uint8_t>& encoded_source, const std::vector<uint8_t>& uncompressed_source,
|
||||
bool check_encode);
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Computes how many bytes are needed to hold the number of bits.
|
||||
@ -61,29 +65,6 @@ constexpr uint32_t bit_to_byte_count(const int32_t bit_count) noexcept
|
||||
return static_cast<uint32_t>((bit_count + 7) / 8);
|
||||
}
|
||||
|
||||
}} // namespace charls::test
|
||||
|
||||
// ReSharper disable CppInconsistentNaming
|
||||
namespace Microsoft { namespace VisualStudio { namespace CppUnitTestFramework {
|
||||
// ReSharper restore CppInconsistentNaming
|
||||
|
||||
template<>
|
||||
inline std::wstring ToString<charls::jpegls_errc>(const charls::jpegls_errc& q)
|
||||
{
|
||||
RETURN_WIDE_STRING(static_cast<int>(q));
|
||||
}
|
||||
|
||||
template<>
|
||||
inline std::wstring ToString<charls::interleave_mode>(const charls::interleave_mode& q)
|
||||
{
|
||||
RETURN_WIDE_STRING(static_cast<int>(q));
|
||||
}
|
||||
|
||||
}}} // namespace Microsoft::VisualStudio::CppUnitTestFramework
|
||||
|
||||
|
||||
namespace charls { namespace test {
|
||||
|
||||
template<typename Functor>
|
||||
void assert_expect_exception(const jpegls_errc error_value, Functor functor)
|
||||
{
|
||||
@ -106,4 +87,23 @@ void assert_expect_exception(const jpegls_errc error_value, Functor functor)
|
||||
Microsoft::VisualStudio::CppUnitTestFramework::Assert::Fail();
|
||||
}
|
||||
|
||||
|
||||
}} // namespace charls::test
|
||||
|
||||
// ReSharper disable CppInconsistentNaming
|
||||
namespace Microsoft { namespace VisualStudio { namespace CppUnitTestFramework {
|
||||
// ReSharper restore CppInconsistentNaming
|
||||
|
||||
template<>
|
||||
inline std::wstring ToString<charls::jpegls_errc>(const charls::jpegls_errc& q)
|
||||
{
|
||||
RETURN_WIDE_STRING(static_cast<int>(q));
|
||||
}
|
||||
|
||||
template<>
|
||||
inline std::wstring ToString<charls::interleave_mode>(const charls::interleave_mode& q)
|
||||
{
|
||||
RETURN_WIDE_STRING(static_cast<int>(q));
|
||||
}
|
||||
|
||||
}}} // namespace Microsoft::VisualStudio::CppUnitTestFramework
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user