cpp/charls
1
0
Fork 0
mirror of https://github.com/team-charls/charls synced 2025-03-28 21:03:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Mask high input bits during encoding

Browse Source 
When encoding images ensure that only the valid bits are used. For bit size 16 and 8 there is no change and memcpy will be used.
Encoding with masking is not measurable slower.

Setting explicit InlineFunctionExpansion for debug needs to be removed as it prevents debugging.  For release mode it is also not needed as MaxSpeed will already enable it.

Mask high input bits during encoding (interleave_mode::sample)

Mask high input bits during encoding
This commit is contained in:
Victor Derks 2021-01-01 23:00:03 +01:00
parent 54a9581fab
commit 6a30e19167
No known key found for this signature in database
GPG Key ID: 3CAD1C98620F0A27
13 changed files with 438 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CharLS.sln
View File

@ -7,8 +7,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CharLSTest", "test\CharLSTe
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Samples", "Samples", "{BE733144-010D-4F7F-A619-0B73D8461D60}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Native", "Native", "{1C1CF63C-A53A-449F-90D3-63321015FD65}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CharLS", "src\CharLS.vcxproj", "{1E31F9F1-F175-4082-B3E2-B1F0ECA3F44C}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{5F4C6204-36F8-4D63-BF33-ECFCB5D1D114}"
@ -119,12 +117,8 @@ Global
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{7185AD7F-57BA-42C7-A715-239CEA8ADC31} = {1C1CF63C-A53A-449F-90D3-63321015FD65}
{1E31F9F1-F175-4082-B3E2-B1F0ECA3F44C} = {1C1CF63C-A53A-449F-90D3-63321015FD65}
{F42C0547-FEB3-40F4-9379-0FF87B44FA0F} = {BE733144-010D-4F7F-A619-0B73D8461D60}
{4A912445-1E83-41FA-8B80-C0A9BD4E9289} = {1C1CF63C-A53A-449F-90D3-63321015FD65}
{E09F024E-A125-48AA-8E9D-7D1302BEAC97} = {BE733144-010D-4F7F-A619-0B73D8461D60}
{5637C116-ABF5-4274-A71F-34433713A538} = {1C1CF63C-A53A-449F-90D3-63321015FD65}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {9F2834D1-0A89-4C7C-93FC-B6B97410B1B7}

6
Directory.Build.props
View File

@ -89,11 +89,14 @@
This checks consist of compile-time checks and runtime checks. -->
<SDLCheck>true</SDLCheck>
<GenerateDebugInformation>true</GenerateDebugInformation>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<TreatLinkerWarningAsErrors>true</TreatLinkerWarningAsErrors>
<!-- use FULL debug info to ensure code coverage works out of the box. -->
<GenerateDebugInformation>DebugFull</GenerateDebugInformation>
</Link>
<ResourceCompile>
@ -101,7 +104,6 @@
</ResourceCompile>
</ItemDefinitionGroup>
<PropertyGroup Condition="'$(Configuration)'=='Debug' OR '$(Configuration)'=='Checked'">
<UseDebugLibraries>true</UseDebugLibraries>
</PropertyGroup>

10
src/CharLS.vcxproj
View File

@ -80,7 +80,6 @@
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<TargetName>charls-2-x64</TargetName>
</PropertyGroup>
<ItemDefinitionGroup>
<ClCompile>
<PreprocessorDefinitions>CHARLS_LIBRARY_BUILD;%(PreprocessorDefinitions)</PreprocessorDefinitions>
@ -91,11 +90,9 @@
<Link>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<EnforceTypeConversionRules>true</EnforceTypeConversionRules>
</ClCompile>
<Link>
@ -107,7 +104,6 @@
<ClCompile>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<SmallerTypeCheck>false</SmallerTypeCheck>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<EnablePREfast>true</EnablePREfast>
</ClCompile>
<Link>
@ -117,7 +113,6 @@
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<OmitFramePointers>true</OmitFramePointers>
<EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
<StringPooling>true</StringPooling>
@ -130,10 +125,8 @@
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<SmallerTypeCheck>false</SmallerTypeCheck>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<TargetMachine>MachineX64</TargetMachine>
@ -143,7 +136,6 @@
<ClCompile>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<SmallerTypeCheck>false</SmallerTypeCheck>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<EnablePREfast>true</EnablePREfast>
</ClCompile>
<Link>
@ -152,12 +144,10 @@
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<OmitFramePointers>true</OmitFramePointers>
<EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
<StringPooling>true</StringPooling>
<BasicRuntimeChecks>Default</BasicRuntimeChecks>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<TargetMachine>MachineX64</TargetMachine>

2
src/jls_codec_factory.h
View File

@ -21,7 +21,7 @@ public:
const jpegls_pc_parameters& preset_coding_parameters);
private:
std::unique_ptr<Strategy> create_optimized_codec(const frame_info& frame, const coding_parameters& parameters);
std::unique_ptr<Strategy> try_create_optimized_codec(const frame_info& frame, const coding_parameters& parameters);
};
extern template class jls_codec_factory<decoder_strategy>;

45
src/jpegls.cpp
View File

@ -73,22 +73,25 @@ unique_ptr<Strategy> make_codec(const Traits& traits, const frame_info& frame_in
// To avoid threading issues, all tables are created when the program is loaded.
// Lookup table: decode symbols that are smaller or equal to 8 bit (16 tables for each value of k)
const array<golomb_code_table, 16> decoding_tables{initialize_table(0), initialize_table(1), initialize_table(2),
initialize_table(3), // NOLINT(clang-diagnostic-global-constructors)
initialize_table(4), initialize_table(5), initialize_table(6),
initialize_table(7), initialize_table(8), initialize_table(9),
initialize_table(10), initialize_table(11), initialize_table(12),
initialize_table(13), initialize_table(14), initialize_table(15)};
// NOLINTNEXTLINE(clang-diagnostic-global-constructors)
const array<golomb_code_table, 16> decoding_tables{
initialize_table(0), initialize_table(1), initialize_table(2), initialize_table(3),
initialize_table(4), initialize_table(5), initialize_table(6), initialize_table(7),
initialize_table(8), initialize_table(9), initialize_table(10), initialize_table(11),
initialize_table(12), initialize_table(13), initialize_table(14), initialize_table(15)};
// Lookup tables: sample differences to bin indexes.
const vector<int8_t> quantization_lut_lossless_8{
create_quantize_lut_lossless(8)}; // NOLINT(clang-diagnostic-global-constructors)
const vector<int8_t> quantization_lut_lossless_10{
create_quantize_lut_lossless(10)}; // NOLINT(clang-diagnostic-global-constructors)
const vector<int8_t> quantization_lut_lossless_12{
create_quantize_lut_lossless(12)}; // NOLINT(clang-diagnostic-global-constructors)
const vector<int8_t> quantization_lut_lossless_16{
create_quantize_lut_lossless(16)}; // NOLINT(clang-diagnostic-global-constructors)
// NOLINTNEXTLINE(clang-diagnostic-global-constructors)
const vector<int8_t> quantization_lut_lossless_8{create_quantize_lut_lossless(8)};
// NOLINTNEXTLINE(clang-diagnostic-global-constructors)
const vector<int8_t> quantization_lut_lossless_10{create_quantize_lut_lossless(10)};
// NOLINTNEXTLINE(clang-diagnostic-global-constructors)
const vector<int8_t> quantization_lut_lossless_12{create_quantize_lut_lossless(12)};
// NOLINTNEXTLINE(clang-diagnostic-global-constructors)
const vector<int8_t> quantization_lut_lossless_16{create_quantize_lut_lossless(16)};
template<typename Strategy>
@ -99,7 +102,7 @@ unique_ptr<Strategy> jls_codec_factory<Strategy>::create_codec(const frame_info&
if (preset_coding_parameters.reset_value == 0 || preset_coding_parameters.reset_value == default_reset_value)
{
codec = create_optimized_codec(frame, parameters);
codec = try_create_optimized_codec(frame, parameters);
}
if (!codec)
@ -127,7 +130,7 @@ unique_ptr<Strategy> jls_codec_factory<Strategy>::create_codec(const frame_info&
}
template<typename Strategy>
unique_ptr<Strategy> jls_codec_factory<Strategy>::create_optimized_codec(const frame_info& frame,
unique_ptr<Strategy> jls_codec_factory<Strategy>::try_create_optimized_codec(const frame_info& frame,
const coding_parameters& parameters)
{
if (parameters.interleave_mode == interleave_mode::sample && frame.component_count != 3 && frame.component_count != 4)
@ -170,11 +173,16 @@ unique_ptr<Strategy> jls_codec_factory<Strategy>::create_optimized_codec(const f
if (parameters.interleave_mode == interleave_mode::sample)
{
if (frame.component_count == 3)
{
return make_codec<Strategy>(default_traits<uint8_t, triplet<uint8_t>>(maxval, parameters.near_lossless),
frame, parameters);
}
if (frame.component_count == 4)
{
return make_codec<Strategy>(default_traits<uint8_t, quad<uint8_t>>(maxval, parameters.near_lossless), frame,
parameters);
}
}
return make_codec<Strategy>(default_traits<uint8_t, uint8_t>(maxval, parameters.near_lossless), frame, parameters);
@ -184,11 +192,16 @@ unique_ptr<Strategy> jls_codec_factory<Strategy>::create_optimized_codec(const f
if (parameters.interleave_mode == interleave_mode::sample)
{
if (frame.component_count == 3)
{
return make_codec<Strategy>(default_traits<uint16_t, triplet<uint16_t>>(maxval, parameters.near_lossless),
frame, parameters);
}
if (frame.component_count == 4)
{
return make_codec<Strategy>(default_traits<uint16_t, quad<uint16_t>>(maxval, parameters.near_lossless),
frame, parameters);
}
}
return make_codec<Strategy>(default_traits<uint16_t, uint16_t>(maxval, parameters.near_lossless), frame, parameters);

165
src/process_line.h
View File

@ -47,27 +47,82 @@ class post_process_single_component final : public process_line
{
public:
post_process_single_component(void* raw_data, const size_t stride, const size_t bytes_per_pixel) noexcept :
raw_data_{static_cast<uint8_t*>(raw_data)}, bytes_per_pixel_{bytes_per_pixel}, bytes_per_line_{stride}
raw_data_{static_cast<uint8_t*>(raw_data)}, bytes_per_pixel_{bytes_per_pixel}, stride_{stride}
{
ASSERT(bytes_per_pixel == sizeof(uint8_t) || bytes_per_pixel == sizeof(uint16_t));
}
void new_line_requested(void* destination, const size_t pixel_count,
size_t /* destination_stride */) noexcept(false) override
{
std::memcpy(destination, raw_data_, pixel_count * bytes_per_pixel_);
raw_data_ += bytes_per_line_;
memcpy(destination, raw_data_, pixel_count * bytes_per_pixel_);
raw_data_ += stride_;
}
void new_line_decoded(const void* source, const size_t pixel_count, size_t /* source_stride */) noexcept(false) override
{
std::memcpy(raw_data_, source, pixel_count * bytes_per_pixel_);
raw_data_ += bytes_per_line_;
memcpy(raw_data_, source, pixel_count * bytes_per_pixel_);
raw_data_ += stride_;
}
private:
uint8_t* raw_data_;
size_t bytes_per_pixel_;
size_t bytes_per_line_;
size_t stride_;
};
class post_process_single_component_masked final : public process_line
{
public:
post_process_single_component_masked(void* raw_data, const size_t stride, const size_t bytes_per_pixel,
const uint32_t bits_per_pixel) noexcept :
raw_data_{raw_data},
bytes_per_pixel_{bytes_per_pixel},
stride_{stride},
mask_{(1U << bits_per_pixel) - 1U},
single_byte_pixel_{bytes_per_pixel_ == sizeof(uint8_t)}
{
ASSERT(bytes_per_pixel == sizeof(uint8_t) || bytes_per_pixel == sizeof(uint16_t));
}
void new_line_requested(void* destination, const size_t pixel_count,
size_t /* destination_stride */) noexcept(false) override
{
if (single_byte_pixel_)
{
const auto* pixel_source{static_cast<uint8_t*>(raw_data_)};
auto* pixel_destination{static_cast<uint8_t*>(destination)};
for (size_t i{}; i < pixel_count; ++i)
{
pixel_destination[i] = pixel_source[i] & mask_;
}
}
else
{
const auto* pixel_source{static_cast<uint16_t*>(raw_data_)};
auto* pixel_destination{static_cast<uint16_t*>(destination)};
for (size_t i{}; i < pixel_count; ++i)
{
pixel_destination[i] = pixel_source[i] & mask_;
}
}
raw_data_ = static_cast<uint8_t*>(raw_data_) + stride_;
}
void new_line_decoded(const void* source, const size_t pixel_count, size_t /* source_stride */) noexcept(false) override
{
memcpy(raw_data_, source, pixel_count * bytes_per_pixel_);
raw_data_ = static_cast<uint8_t*>(raw_data_) + stride_;
}
private:
void* raw_data_;
size_t bytes_per_pixel_;
size_t stride_;
uint32_t mask_;
bool single_byte_pixel_;
};
@ -91,31 +146,53 @@ inline void byte_swap(void* data, const size_t count)
}
template<typename Transform, typename T>
void transform_line_to_quad(const T* source, const size_t pixel_stride_in, quad<T>* destination, const size_t pixel_stride,
template<typename Transform, typename PixelType>
void transform_line_to_quad(const PixelType* source, const size_t pixel_stride_in, quad<PixelType>* destination,
const size_t pixel_stride,
Transform& transform) noexcept
{
const auto pixel_count{std::min(pixel_stride, pixel_stride_in)};
for (size_t i{}; i < pixel_count; ++i)
{
const quad<T> pixel(transform(source[i], source[i + pixel_stride_in], source[i + 2 * pixel_stride_in]),
const quad<PixelType> pixel(transform(source[i], source[i + pixel_stride_in], source[i + 2 * pixel_stride_in]),
source[i + 3 * pixel_stride_in]);
destination[i] = pixel;
}
}
template<typename Transform, typename T>
void transform_quad_to_line(const quad<T>* source, const size_t pixel_stride_in, T* destination, const size_t pixel_stride,
template<typename Transform, typename PixelType>
void transform_quad_to_line(const quad<PixelType>* source, const size_t pixel_stride_in, PixelType* destination,
const size_t pixel_stride,
Transform& transform) noexcept
{
const auto pixel_count{std::min(pixel_stride, pixel_stride_in)};
for (size_t i{}; i < pixel_count; ++i)
{
const quad<T> color{source[i]};
const quad<T> color_transformed(transform(color.v1, color.v2, color.v3), color.v4);
const quad<PixelType> color{source[i]};
const quad<PixelType> color_transformed(transform(color.v1, color.v2, color.v3), color.v4);
destination[i] = color_transformed.v1;
destination[i + pixel_stride] = color_transformed.v2;
destination[i + 2 * pixel_stride] = color_transformed.v3;
destination[i + 3 * pixel_stride] = color_transformed.v4;
}
}
template<typename Transform, typename PixelType>
void transform_quad_to_line(const quad<PixelType>* source, const size_t pixel_stride_in, PixelType* destination,
const size_t pixel_stride, Transform& transform, const uint32_t mask) noexcept
{
const auto pixel_count{std::min(pixel_stride, pixel_stride_in)};
for (size_t i{}; i < pixel_count; ++i)
{
const quad<PixelType> color{source[i]};
const quad<PixelType> color_transformed(transform(color.v1 & mask, color.v2 & mask, color.v3 & mask),
color.v4 & mask);
destination[i] = color_transformed.v1;
destination[i + pixel_stride] = color_transformed.v2;
@ -136,8 +213,8 @@ void transform_rgb_to_bgr(T* buffer, int samples_per_pixel, const size_t pixel_c
}
template<typename Transform, typename T>
void transform_line(triplet<T>* destination, const triplet<T>* source, const size_t pixel_count,
template<typename Transform, typename PixelType>
void transform_line(triplet<PixelType>* destination, const triplet<PixelType>* source, const size_t pixel_count,
Transform& transform) noexcept
{
for (size_t i{}; i < pixel_count; ++i)
@ -147,6 +224,17 @@ void transform_line(triplet<T>* destination, const triplet<T>* source, const siz
}
template<typename Transform, typename PixelType>
void transform_line(triplet<PixelType>* destination, const triplet<PixelType>* source, const size_t pixel_count,
Transform& transform, const uint32_t mask) noexcept
{
for (size_t i{}; i < pixel_count; ++i)
{
destination[i] = transform(source[i].v1 & mask, source[i].v2 & mask, source[i].v3 & mask);
}
}
template<typename Transform, typename PixelType>
void transform_line(quad<PixelType>* destination, const quad<PixelType>* source, const size_t pixel_count,
Transform& transform) noexcept
@ -158,6 +246,18 @@ void transform_line(quad<PixelType>* destination, const quad<PixelType>* source,
}
template<typename Transform, typename PixelType>
void transform_line(quad<PixelType>* destination, const quad<PixelType>* source, const size_t pixel_count,
Transform& transform, const uint32_t mask) noexcept
{
for (size_t i{}; i < pixel_count; ++i)
{
destination[i] =
quad<PixelType>(transform(source[i].v1 & mask, source[i].v2 & mask, source[i].v3 & mask), source[i].v4 & mask);
}
}
template<typename Transform, typename PixelType>
void transform_line_to_triplet(const PixelType* source, const size_t pixel_stride_in, triplet<PixelType>* destination,
const size_t pixel_stride, Transform& transform) noexcept
@ -191,6 +291,25 @@ void transform_triplet_to_line(const triplet<PixelType>* source, const size_t pi
}
template<typename Transform, typename PixelType>
void transform_triplet_to_line(const triplet<PixelType>* source, const size_t pixel_stride_in, PixelType* destination,
const size_t pixel_stride, Transform& transform, const uint32_t mask) noexcept
{
const auto pixel_count{std::min(pixel_stride, pixel_stride_in)};
const triplet<PixelType>* type_buffer_in{source};
for (size_t i{}; i < pixel_count; ++i)
{
const triplet<PixelType> color = type_buffer_in[i];
const triplet<PixelType> color_transformed = transform(color.v1 & mask, color.v2 & mask, color.v3 & mask);
destination[i] = color_transformed.v1;
destination[i + pixel_stride] = color_transformed.v2;
destination[i + 2 * pixel_stride] = color_transformed.v3;
}
}
template<typename TransformType>
class process_transformed final : public process_line
{
@ -204,18 +323,19 @@ public:
buffer_(static_cast<size_t>(info.component_count) * info.width * sizeof(size_type)),
transform_{transform},
inverse_transform_{transform},
raw_pixels_{source_pixels}
raw_pixels_{source_pixels},
mask_{(1U << info.bits_per_sample) - 1U}
{
}
void new_line_requested(void* destination, const size_t pixel_count,
const size_t destination_stride) noexcept(false) override
{
transform(raw_pixels_.data, destination, pixel_count, destination_stride);
encode_transform(raw_pixels_.data, destination, pixel_count, destination_stride);
raw_pixels_.data += stride_;
}
void transform(const void* source, void* destination, const size_t pixel_count, const size_t destination_stride) noexcept
void encode_transform(const void* source, void* destination, const size_t pixel_count, const size_t destination_stride) noexcept
{
if (parameters_.output_bgr)
{
@ -229,12 +349,12 @@ public:
if (parameters_.interleave_mode == interleave_mode::sample)
{
transform_line(static_cast<triplet<size_type>*>(destination), static_cast<const triplet<size_type>*>(source),
pixel_count, transform_);
pixel_count, transform_, mask_);
}
else
{
transform_triplet_to_line(static_cast<const triplet<size_type>*>(source), pixel_count,
static_cast<size_type*>(destination), destination_stride, transform_);
static_cast<size_type*>(destination), destination_stride, transform_, mask_);
}
}
else if (frame_info_.component_count == 4)
@ -242,12 +362,12 @@ public:
if (parameters_.interleave_mode == interleave_mode::sample)
{
transform_line(static_cast<quad<size_type>*>(destination), static_cast<const quad<size_type>*>(source),
pixel_count, transform_);
pixel_count, transform_, mask_);
}
else if (parameters_.interleave_mode == interleave_mode::line)
{
transform_quad_to_line(static_cast<const quad<size_type>*>(source), pixel_count,
static_cast<size_type*>(destination), destination_stride, transform_);
static_cast<size_type*>(destination), destination_stride, transform_, mask_);
}
}
}
@ -304,6 +424,7 @@ private:
TransformType transform_;
typename TransformType::inverse inverse_transform_;
byte_span raw_pixels_;
uint32_t mask_;
};
} // namespace charls

10
src/scan.h
View File

@ -126,8 +126,14 @@ public:
{
if (!is_interleaved())
{
return std::unique_ptr<process_line>(
std::make_unique<post_process_single_component>(info.data, stride, sizeof(typename Traits::pixel_type)));
if (frame_info().bits_per_sample == sizeof(sample_type) * 8)
{
return std::make_unique<post_process_single_component>(info.data, stride,
sizeof(typename Traits::pixel_type));
}
return std::make_unique<post_process_single_component_masked>(
info.data, stride, sizeof(typename Traits::pixel_type), frame_info().bits_per_sample);
}
if (parameters().transformation == color_transformation::none)

8
test/CharLSTest.vcxproj
View File

@ -72,7 +72,6 @@
<ClCompile>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
</ClCompile>
<Link>
<TargetMachine>MachineX86</TargetMachine>
@ -83,7 +82,6 @@
<ClCompile>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
<EnablePREfast>true</EnablePREfast>
</ClCompile>
<Link>
@ -95,7 +93,6 @@
<ClCompile>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<TargetMachine>MachineX64</TargetMachine>
@ -105,7 +102,6 @@
<ClCompile>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<TargetMachine>MachineX64</TargetMachine>
@ -113,11 +109,9 @@
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<OmitFramePointers>true</OmitFramePointers>
<StringPooling>true</StringPooling>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<TargetMachine>MachineX86</TargetMachine>
@ -125,11 +119,9 @@
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<OmitFramePointers>true</OmitFramePointers>
<StringPooling>true</StringPooling>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<WholeProgramOptimization>true</WholeProgramOptimization>
</ClCompile>
<Link>

21
test/main.cpp
View File

@ -824,6 +824,27 @@ int main(const int argc, const char* const argv[]) // NOLINT(bugprone-exception-
continue;
}
if (str.compare(0, 19, "-encode-performance") == 0)
{
int loop_count{1};
// Extract the optional loop count from the command line. Longer running tests make the measurements more
// reliable.
auto index = str.find(':');
if (index != string::npos)
{
loop_count = stoi(str.substr(++index));
if (loop_count < 1)
{
cout << "Loop count not understood or invalid: " << str << "\n";
break;
}
}
encode_performance_tests(loop_count);
continue;
}
if (str == "-dicom")
{
test_dicom_wg4_images();

44
test/performance.cpp
View File

@ -2,6 +2,8 @@
// SPDX-License-Identifier: BSD-3-Clause
#include "performance.h"
#include "portable_anymap_file.h"
#include "util.h"
#include <chrono>
@ -9,7 +11,9 @@
#include <ratio>
#include <vector>
using charls::frame_info;
using charls::jpegls_decoder;
using charls::jpegls_encoder;
using charls::jpegls_error;
using std::cout;
using std::istream;
@ -114,7 +118,7 @@ void test_large_image_performance_rgb8(const int loop_count)
void decode_performance_tests(const int loop_count)
{
cout << "Test decode Perf (with loop count " << loop_count << ")\n";
cout << "Test decode performance with loop count " << loop_count << "\n";
const vector<uint8_t> jpegls_compressed = read_file("decodetest.jls");
@ -138,3 +142,41 @@ void decode_performance_tests(const int loop_count)
cout << "Decode failure: " << e.what() << "\n";
}
}
void encode_performance_tests(const int loop_count)
{
cout << "Test encode performance with loop count " << loop_count << "\n";
const charls_test::portable_anymap_file anymap_file("encode-test.pnm");
try
{
const frame_info info{static_cast<uint32_t>(anymap_file.width()), static_cast<uint32_t>(anymap_file.height()),
anymap_file.bits_per_sample(), anymap_file.component_count()};
const auto interleave_mode =
anymap_file.component_count() > 1 ? charls::interleave_mode::sample : charls::interleave_mode::none;
jpegls_encoder encoder1;
encoder1.frame_info(info).interleave_mode(interleave_mode);
vector<uint8_t> destination(encoder1.estimated_destination_size());
const auto start = steady_clock::now();
for (int i = 0; i < loop_count; ++i)
{
jpegls_encoder encoder2;
encoder2.frame_info(info).interleave_mode(interleave_mode);
encoder2.destination(destination);
static_cast<void>(encoder2.encode(anymap_file.image_data()));
}
const auto end = steady_clock::now();
const auto diff = end - start;
cout << "Total encoding time is: " << duration<double, milli>(diff).count() << " ms\n";
cout << "Encoding time per image: " << duration<double, milli>(diff).count() / loop_count << " ms\n";
}
catch (const jpegls_error& e)
{
cout << "Encoding failure: " << e.what() << "\n";
}
}

1
test/performance.h
View File

@ -5,4 +5,5 @@
void performance_tests(int loop_count);
void decode_performance_tests(int loop_count);
void encode_performance_tests(int loop_count);
void test_large_image_performance_rgb8(int loop_count);

2
unittest/encode_test.cpp
View File

@ -25,7 +25,7 @@ public:
TEST_METHOD(encode_monochrome_12_bit_lossless) // NOLINT
{
encode("DataFiles/TEST16.pgm");
encode("DataFiles/test16.pgm");
}
TEST_METHOD(encode_monochrome_16_bit_lossless) // NOLINT

192
unittest/jpegls_encoder_test.cpp
View File

@ -545,9 +545,189 @@ public:
test_by_decoding(destination, frame_info, expected.data(), expected.size(), interleave_mode::none);
}
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};
jpegls_encoder encoder;
encoder.frame_info(frame_info);
vector<uint8_t> destination(encoder.estimated_destination_size());
encoder.destination(destination);
const size_t bytes_written{encoder.encode(source)};
destination.resize(bytes_written);
const vector<uint8_t> expected(512 * 512, 15);
test_by_decoding(destination, frame_info, expected.data(), expected.size(), interleave_mode::none);
}
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};
jpegls_encoder encoder;
encoder.frame_info(frame_info);
vector<uint8_t> destination(encoder.estimated_destination_size());
encoder.destination(destination);
const size_t bytes_written{encoder.encode(source)};
destination.resize(bytes_written);
const vector<uint16_t> expected(512 * 512, 4095);
test_by_decoding(destination, frame_info, expected.data(), expected.size() * 2, interleave_mode::none);
}
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};
jpegls_encoder encoder;
encoder.frame_info(frame_info).interleave_mode(interleave_mode::sample);
vector<uint8_t> destination(encoder.estimated_destination_size());
encoder.destination(destination);
const size_t bytes_written{encoder.encode(source)};
destination.resize(bytes_written);
const vector<uint8_t> expected(512 * 512 * 3, 63);
test_by_decoding(destination, frame_info, expected.data(), expected.size(), interleave_mode::sample);
}
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};
jpegls_encoder encoder;
encoder.frame_info(frame_info).interleave_mode(interleave_mode::line);
vector<uint8_t> destination(encoder.estimated_destination_size());
encoder.destination(destination);
const size_t bytes_written{encoder.encode(source)};
destination.resize(bytes_written);
const vector<uint8_t> expected(512 * 512 * 3, 63);
test_by_decoding(destination, frame_info, expected.data(), expected.size(), interleave_mode::line);
}
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};
jpegls_encoder encoder;
encoder.frame_info(frame_info).interleave_mode(interleave_mode::sample);
vector<uint8_t> destination(encoder.estimated_destination_size());
encoder.destination(destination);
const size_t bytes_written{encoder.encode(source)};
destination.resize(bytes_written);
const vector<uint16_t> expected(512 * 512 * 3, 1023);
test_by_decoding(destination, frame_info, expected.data(), expected.size() * 2, interleave_mode::sample);
}
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};
jpegls_encoder encoder;
encoder.frame_info(frame_info).interleave_mode(interleave_mode::line);
vector<uint8_t> destination(encoder.estimated_destination_size());
encoder.destination(destination);
const size_t bytes_written{encoder.encode(source)};
destination.resize(bytes_written);
const vector<uint16_t> expected(512 * 512 * 3, 1023);
test_by_decoding(destination, frame_info, expected.data(), expected.size() * 2, interleave_mode::line);
}
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};
jpegls_encoder encoder;
encoder.frame_info(frame_info).interleave_mode(interleave_mode::sample);
vector<uint8_t> destination(encoder.estimated_destination_size());
encoder.destination(destination);
const size_t bytes_written{encoder.encode(source)};
destination.resize(bytes_written);
const vector<uint8_t> expected(512 * 512 * 4, 63);
test_by_decoding(destination, frame_info, expected.data(), expected.size(), interleave_mode::sample);
}
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};
jpegls_encoder encoder;
encoder.frame_info(frame_info).interleave_mode(interleave_mode::line);
vector<uint8_t> destination(encoder.estimated_destination_size());
encoder.destination(destination);
const size_t bytes_written{encoder.encode(source)};
destination.resize(bytes_written);
const vector<uint8_t> expected(512 * 512 * 4, 63);
test_by_decoding(destination, frame_info, expected.data(), expected.size(), interleave_mode::line);
}
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};
jpegls_encoder encoder;
encoder.frame_info(frame_info).interleave_mode(interleave_mode::sample);
vector<uint8_t> destination(encoder.estimated_destination_size());
encoder.destination(destination);
const size_t bytes_written{encoder.encode(source)};
destination.resize(bytes_written);
const vector<uint16_t> expected(512 * 512 * 4, 1023);
test_by_decoding(destination, frame_info, expected.data(), expected.size() * 2, interleave_mode::sample);
}
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};
jpegls_encoder encoder;
encoder.frame_info(frame_info).interleave_mode(interleave_mode::line);
vector<uint8_t> destination(encoder.estimated_destination_size());
encoder.destination(destination);
const size_t bytes_written{encoder.encode(source)};
destination.resize(bytes_written);
const vector<uint16_t> expected(512 * 512 * 4, 1023);
test_by_decoding(destination, frame_info, expected.data(), expected.size() * 2, interleave_mode::line);
}
private:
static void test_by_decoding(const vector<uint8_t>& encoded_source, const frame_info& source_frame_info,
const uint8_t* source, const size_t source_size,
const void* expected_destination, const size_t expected_destination_size,
const charls::interleave_mode interleave_mode)
{
jpegls_decoder decoder;
@ -564,15 +744,17 @@ private:
vector<uint8_t> destination(decoder.destination_size());
decoder.decode(destination);
Assert::AreEqual(destination.size(), source_size);
Assert::AreEqual(destination.size(), expected_destination_size);
if (decoder.near_lossless() == 0)
{
for (size_t i{}; i < source_size; ++i)
const auto* expected_destination_byte{static_cast<const uint8_t *>(expected_destination)};
for (size_t i{}; i < expected_destination_size; ++i)
{
if (destination[i] != source[i]) // AreEqual is very slow, pre-test to speed up 50X
if (expected_destination_byte[i] != destination[i]) // AreEqual is very slow, pre-test to speed up 50X
{
Assert::AreEqual(destination[i], source[i]);
Assert::AreEqual(expected_destination_byte[i], destination[i]);
}
}
}