mirror of
https://github.com/team-charls/charls
synced 2025-03-28 21:03:13 +00:00
Refactor jpeg_stream_reader (#133)
- Use a span to manage the segment data - Use a forward iterator - Parse the SOS segment directly. - Do a size check when segment size is known, then read without size checks. - Don't use std::vector to read bytes.
This commit is contained in:
Victor Derks
GitHub
parent
b16aa20c5a
commit
2613ab21e6
@ -108,14 +108,10 @@
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)'=='Debug' OR '$(Configuration)'=='Checked'">
|
||||
<ClCompile>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<RandomizedBaseAddress>false</RandomizedBaseAddress>
|
||||
</Link>
|
||||
<ResourceCompile>
|
||||
<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
</ResourceCompile>
|
||||
</ItemDefinitionGroup>
|
||||
|
||||
<PropertyGroup Condition="'$(Configuration)'=='Checked'">
|
||||
@ -149,6 +145,9 @@
|
||||
<!-- Mark executable image compatible with the Control-flow Enforcement Technology (CET) Shadow Stack. -->
|
||||
<CETCompat>true</CETCompat>
|
||||
</Link>
|
||||
<ResourceCompile>
|
||||
<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
</ResourceCompile>
|
||||
</ItemDefinitionGroup>
|
||||
|
||||
</Project>
|
||||
@ -5,6 +5,7 @@
|
||||
<Rule Id="C26426" Action="None" />
|
||||
<Rule Id="C26429" Action="None" />
|
||||
<Rule Id="C26446" Action="None" />
|
||||
<Rule Id="C26459" Action="None" />
|
||||
<Rule Id="C26472" Action="None" />
|
||||
<Rule Id="C26481" Action="None" />
|
||||
<Rule Id="C26482" Action="None" />
|
||||
|
||||
@ -9,6 +9,9 @@ C26429: Symbol 'xxx' is never tested for nullness, it can be marked as not_null
|
||||
C26446: Prefer to use gsl::at() instead of unchecked subscript operator.
|
||||
-> Rationale: CharLS require good performance, gsl:at() cannot be used. debug STL already checks.
|
||||
|
||||
C26459: You called an STL function '' with a raw pointer parameter. Consider wrapping your range in a gsl::span and pass as a span iterator (stl.1)
|
||||
Rationale: gsl:span() cannot be used. Update to std:span when available (C++20).
|
||||
|
||||
C26472: Don't use static_cast for arithmetic conversions
|
||||
-> Rationale: can only be solved with gsl::narrow_cast
|
||||
|
||||
|
||||
@ -3,6 +3,8 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "charls/annotations.h"
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
|
||||
@ -13,15 +15,25 @@ struct byte_span final
|
||||
{
|
||||
byte_span() = default;
|
||||
|
||||
byte_span(void* data_arg, const size_t size_arg) noexcept : data{static_cast<uint8_t*>(data_arg)}, size{size_arg}
|
||||
constexpr byte_span(void* data_arg, const size_t size_arg) noexcept : data{static_cast<uint8_t*>(data_arg)}, size{size_arg}
|
||||
{
|
||||
}
|
||||
|
||||
byte_span(const void* data_arg, const size_t size_arg) noexcept :
|
||||
constexpr byte_span(const void* data_arg, const size_t size_arg) noexcept :
|
||||
data{static_cast<uint8_t*>(const_cast<void*>(data_arg))}, size{size_arg}
|
||||
{
|
||||
}
|
||||
|
||||
CHARLS_CHECK_RETURN constexpr uint8_t* begin() const noexcept
|
||||
{
|
||||
return data;
|
||||
}
|
||||
|
||||
CHARLS_CHECK_RETURN constexpr uint8_t* end() const noexcept
|
||||
{
|
||||
return data + size;
|
||||
}
|
||||
|
||||
uint8_t* data{};
|
||||
size_t size{};
|
||||
};
|
||||
@ -31,22 +43,43 @@ struct byte_span final
|
||||
class const_byte_span final
|
||||
{
|
||||
public:
|
||||
using iterator = const uint8_t*;
|
||||
|
||||
const_byte_span() = default;
|
||||
|
||||
const_byte_span(const void* data, const size_t size) noexcept : data_{static_cast<const uint8_t*>(data)}, size_{size}
|
||||
constexpr const_byte_span(const void* data, const size_t size) noexcept : data_{static_cast<const uint8_t*>(data)}, size_{size}
|
||||
{
|
||||
}
|
||||
|
||||
constexpr size_t size() const noexcept
|
||||
explicit constexpr const_byte_span(const uint8_t* first, const uint8_t* last) noexcept :
|
||||
const_byte_span(first, last - first)
|
||||
{}
|
||||
|
||||
CHARLS_CHECK_RETURN constexpr size_t size() const noexcept
|
||||
{
|
||||
return size_;
|
||||
}
|
||||
|
||||
constexpr const uint8_t* data() const noexcept
|
||||
CHARLS_CHECK_RETURN constexpr const uint8_t* data() const noexcept
|
||||
{
|
||||
return data_;
|
||||
}
|
||||
|
||||
CHARLS_CHECK_RETURN constexpr iterator begin() const noexcept
|
||||
{
|
||||
return data_;
|
||||
}
|
||||
|
||||
CHARLS_CHECK_RETURN constexpr iterator end() const noexcept
|
||||
{
|
||||
return data_ + size_;
|
||||
}
|
||||
|
||||
CHARLS_CHECK_RETURN constexpr bool empty() const noexcept
|
||||
{
|
||||
return size_ == 0;
|
||||
}
|
||||
|
||||
private:
|
||||
const uint8_t* data_{};
|
||||
size_t size_{};
|
||||
|
||||
@ -23,7 +23,7 @@ VS_VERSION_INFO VERSIONINFO
|
||||
FILEVERSION CHARLS_VERSION_MAJOR, CHARLS_VERSION_MINOR, CHARLS_VERSION_PATCH, 0
|
||||
PRODUCTVERSION CHARLS_VERSION_MAJOR, CHARLS_VERSION_MINOR, CHARLS_VERSION_PATCH, 0
|
||||
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
|
||||
#ifdef _DEBUG
|
||||
#ifndef NDEBUG
|
||||
FILEFLAGS VS_FF_DEBUG
|
||||
#else
|
||||
FILEFLAGS 0x0L
|
||||
|
||||
@ -14,7 +14,7 @@ struct charls_jpegls_decoder final
|
||||
{
|
||||
void source(const const_byte_span source)
|
||||
{
|
||||
check_argument(source.data() || source.size() == 0);
|
||||
check_argument(source.data() || source.empty());
|
||||
check_operation(state_ == state::initial);
|
||||
|
||||
reader_.source({source.data(), source.size()});
|
||||
@ -41,7 +41,6 @@ struct charls_jpegls_decoder final
|
||||
reader_.read_header();
|
||||
}
|
||||
|
||||
reader_.read_start_of_scan();
|
||||
state_ = state::header_read;
|
||||
}
|
||||
|
||||
@ -114,8 +113,9 @@ struct charls_jpegls_decoder final
|
||||
check_argument(destination.data || destination.size == 0);
|
||||
check_operation(state_ == state::header_read);
|
||||
|
||||
reader_.read(destination, stride);
|
||||
reader_.decode(destination, stride);
|
||||
reader_.read_end_of_image();
|
||||
|
||||
state_ = state::completed;
|
||||
}
|
||||
|
||||
|
||||
@ -130,7 +130,7 @@ struct charls_jpegls_encoder final
|
||||
|
||||
void write_comment(const const_byte_span comment)
|
||||
{
|
||||
check_argument(comment.data() || comment.size() == 0);
|
||||
check_argument(comment.data() || comment.empty());
|
||||
check_argument(comment.size() <= segment_max_data_size, jpegls_errc::invalid_argument_size);
|
||||
check_operation(state_ >= state::destination_set && state_ < state::completed);
|
||||
|
||||
|
||||
@ -31,12 +31,12 @@ public:
|
||||
|
||||
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, uint32_t restart_interval) = 0;
|
||||
virtual void decode_scan(std::unique_ptr<process_line> output_data, const JlsRect& size, byte_span& compressed_data) = 0;
|
||||
virtual size_t decode_scan(std::unique_ptr<process_line> output_data, const JlsRect& size, const_byte_span encoded_source) = 0;
|
||||
|
||||
void initialize(const byte_span source)
|
||||
void initialize(const const_byte_span source)
|
||||
{
|
||||
position_ = source.data;
|
||||
end_position_ = position_ + source.size;
|
||||
position_ = source.data();
|
||||
end_position_ = source.end();
|
||||
|
||||
find_jpeg_marker_start_byte();
|
||||
fill_read_cache();
|
||||
|
||||
@ -23,7 +23,6 @@ using std::array;
|
||||
using std::equal;
|
||||
using std::find;
|
||||
using std::unique_ptr;
|
||||
using std::vector;
|
||||
|
||||
namespace {
|
||||
|
||||
@ -36,10 +35,12 @@ constexpr bool is_restart_marker_code(const jpeg_marker_code marker_code) noexce
|
||||
} // namespace
|
||||
|
||||
|
||||
void jpeg_stream_reader::source(const byte_span source) noexcept
|
||||
void jpeg_stream_reader::source(const const_byte_span source) noexcept
|
||||
{
|
||||
ASSERT(state_ == state::before_start_of_image);
|
||||
source_ = source;
|
||||
|
||||
position_ = source.begin();
|
||||
end_position_ = source.end();
|
||||
}
|
||||
|
||||
|
||||
@ -52,6 +53,7 @@ void jpeg_stream_reader::read_header(spiff_header* header, bool* spiff_header_fo
|
||||
if (UNLIKELY(read_next_marker_code() != jpeg_marker_code::start_of_image))
|
||||
throw_jpegls_error(jpegls_errc::start_of_image_marker_not_found);
|
||||
|
||||
component_ids_.reserve(4); // expect 4 components or less.
|
||||
state_ = state::header_section;
|
||||
}
|
||||
|
||||
@ -59,45 +61,36 @@ void jpeg_stream_reader::read_header(spiff_header* header, bool* spiff_header_fo
|
||||
{
|
||||
const jpeg_marker_code marker_code = read_next_marker_code();
|
||||
validate_marker_code(marker_code);
|
||||
read_segment_size();
|
||||
|
||||
if (marker_code == jpeg_marker_code::start_of_scan)
|
||||
{
|
||||
state_ = state::scan_section;
|
||||
return;
|
||||
}
|
||||
|
||||
const int32_t segment_size{read_segment_size()};
|
||||
int bytes_read;
|
||||
switch (state_)
|
||||
{
|
||||
case state::spiff_header_section:
|
||||
bytes_read = read_spiff_directory_entry(marker_code, segment_size - 2) + 2;
|
||||
read_spiff_directory_entry(marker_code);
|
||||
break;
|
||||
|
||||
default:
|
||||
bytes_read = read_marker_segment(marker_code, segment_size - 2, header, spiff_header_found) + 2;
|
||||
read_marker_segment(marker_code, header, spiff_header_found);
|
||||
break;
|
||||
}
|
||||
|
||||
const int padding_to_read{segment_size - bytes_read};
|
||||
if (UNLIKELY(padding_to_read < 0))
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
|
||||
for (int i{}; i != padding_to_read; ++i)
|
||||
{
|
||||
skip_byte();
|
||||
}
|
||||
ASSERT(segment_data_.end() - position_ == 0); // All segment data should be processed.
|
||||
|
||||
if (state_ == state::header_section && spiff_header_found && *spiff_header_found)
|
||||
{
|
||||
state_ = state::spiff_header_section;
|
||||
return;
|
||||
}
|
||||
|
||||
if (state_ == state::bit_stream_section)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void jpeg_stream_reader::read(byte_span destination, size_t stride)
|
||||
void jpeg_stream_reader::decode(byte_span destination, size_t stride)
|
||||
{
|
||||
ASSERT(state_ == state::bit_stream_section);
|
||||
|
||||
@ -135,8 +128,9 @@ void jpeg_stream_reader::read(byte_span destination, size_t stride)
|
||||
const unique_ptr<decoder_strategy> codec{jls_codec_factory<decoder_strategy>().create_codec(
|
||||
frame_info_, parameters_, get_validated_preset_coding_parameters())};
|
||||
unique_ptr<process_line> process_line(codec->create_process_line(destination, stride));
|
||||
codec->decode_scan(move(process_line), rect_, source_);
|
||||
skip_bytes(destination, static_cast<size_t>(bytes_per_plane));
|
||||
const size_t bytes_read = codec->decode_scan(move(process_line), rect_, const_byte_span{position_, end_position_});
|
||||
advance_position(bytes_read);
|
||||
charls::skip_bytes(destination, static_cast<size_t>(bytes_per_plane));
|
||||
state_ = state::scan_section;
|
||||
|
||||
if (parameters_.interleave_mode != interleave_mode::none)
|
||||
@ -161,60 +155,32 @@ void jpeg_stream_reader::read_end_of_image()
|
||||
}
|
||||
|
||||
|
||||
vector<uint8_t> jpeg_stream_reader::read_bytes(const size_t byte_count)
|
||||
{
|
||||
vector<uint8_t> result;
|
||||
result.reserve(byte_count);
|
||||
|
||||
for (size_t i{}; i != byte_count; ++i)
|
||||
{
|
||||
result.push_back(read_byte());
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
void jpeg_stream_reader::read_next_start_of_scan()
|
||||
{
|
||||
ASSERT(state_ == state::scan_section);
|
||||
|
||||
for (;;)
|
||||
do
|
||||
{
|
||||
const jpeg_marker_code marker_code{read_next_marker_code()};
|
||||
validate_marker_code(marker_code);
|
||||
read_segment_size();
|
||||
read_marker_segment(marker_code);
|
||||
|
||||
if (marker_code == jpeg_marker_code::start_of_scan)
|
||||
{
|
||||
read_start_of_scan();
|
||||
return;
|
||||
}
|
||||
|
||||
const int32_t segment_size{read_segment_size()};
|
||||
const int bytes_read{read_marker_segment(marker_code, segment_size - 2) + 2};
|
||||
|
||||
const int padding_to_read{segment_size - bytes_read};
|
||||
if (UNLIKELY(padding_to_read < 0))
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
|
||||
for (int i{}; i != padding_to_read; ++i)
|
||||
{
|
||||
skip_byte();
|
||||
}
|
||||
}
|
||||
ASSERT(segment_data_.end() - position_ == 0); // All segment data should be processed.
|
||||
} while (state_ == state::scan_section);
|
||||
}
|
||||
|
||||
|
||||
jpeg_marker_code jpeg_stream_reader::read_next_marker_code()
|
||||
USE_DECL_ANNOTATIONS jpeg_marker_code jpeg_stream_reader::read_next_marker_code()
|
||||
{
|
||||
auto byte{read_byte()};
|
||||
auto byte{read_byte_checked()};
|
||||
if (UNLIKELY(byte != jpeg_marker_start_byte))
|
||||
throw_jpegls_error(jpegls_errc::jpeg_marker_start_byte_not_found);
|
||||
|
||||
// Read all preceding 0xFF fill values until a non 0xFF value has been found. (see T.81, B.1.1.2)
|
||||
// Read all preceding 0xFF fill values until a non 0xFF value has been found. (see ISO/IEC 10918-1, B.1.1.2)
|
||||
do
|
||||
{
|
||||
byte = read_byte();
|
||||
byte = read_byte_checked();
|
||||
} while (byte == jpeg_marker_start_byte);
|
||||
|
||||
return static_cast<jpeg_marker_code>(byte);
|
||||
@ -289,34 +255,46 @@ void jpeg_stream_reader::validate_marker_code(const jpeg_marker_code marker_code
|
||||
}
|
||||
|
||||
|
||||
jpegls_pc_parameters jpeg_stream_reader::get_validated_preset_coding_parameters() const
|
||||
USE_DECL_ANNOTATIONS jpegls_pc_parameters jpeg_stream_reader::get_validated_preset_coding_parameters() const
|
||||
{
|
||||
jpegls_pc_parameters preset_coding_parameters;
|
||||
|
||||
if (UNLIKELY(!is_valid(preset_coding_parameters_, calculate_maximum_sample_value(frame_info_.bits_per_sample),
|
||||
parameters_.near_lossless, &preset_coding_parameters)))
|
||||
parameters_.near_lossless, &preset_coding_parameters)))
|
||||
throw_jpegls_error(jpegls_errc::invalid_parameter_jpegls_pc_parameters);
|
||||
|
||||
return preset_coding_parameters;
|
||||
}
|
||||
|
||||
|
||||
int jpeg_stream_reader::read_marker_segment(const jpeg_marker_code marker_code, const int32_t segment_size,
|
||||
spiff_header* header, bool* spiff_header_found)
|
||||
void jpeg_stream_reader::read_marker_segment(const jpeg_marker_code marker_code, spiff_header* header,
|
||||
bool* spiff_header_found)
|
||||
{
|
||||
switch (marker_code)
|
||||
{
|
||||
case jpeg_marker_code::start_of_frame_jpegls:
|
||||
return read_start_of_frame_segment(segment_size);
|
||||
read_start_of_frame_segment();
|
||||
break;
|
||||
|
||||
case jpeg_marker_code::comment:
|
||||
return read_comment(segment_size);
|
||||
case jpeg_marker_code::start_of_scan:
|
||||
read_start_of_scan();
|
||||
break;
|
||||
|
||||
case jpeg_marker_code::jpegls_preset_parameters:
|
||||
return read_preset_parameters_segment(segment_size);
|
||||
read_preset_parameters_segment();
|
||||
break;
|
||||
|
||||
case jpeg_marker_code::define_restart_interval:
|
||||
return read_define_restart_interval(segment_size);
|
||||
read_define_restart_interval();
|
||||
break;
|
||||
|
||||
case jpeg_marker_code::application_data8:
|
||||
try_read_application_data8_segment(header, spiff_header_found);
|
||||
break;
|
||||
|
||||
case jpeg_marker_code::comment:
|
||||
read_comment();
|
||||
break;
|
||||
|
||||
case jpeg_marker_code::application_data0:
|
||||
case jpeg_marker_code::application_data1:
|
||||
@ -333,46 +311,43 @@ int jpeg_stream_reader::read_marker_segment(const jpeg_marker_code marker_code,
|
||||
case jpeg_marker_code::application_data13:
|
||||
case jpeg_marker_code::application_data14:
|
||||
case jpeg_marker_code::application_data15:
|
||||
return 0;
|
||||
|
||||
case jpeg_marker_code::application_data8:
|
||||
return try_read_application_data8_segment(segment_size, header, spiff_header_found);
|
||||
read_application_data();
|
||||
break;
|
||||
|
||||
// Other tags not supported (among which DNL)
|
||||
default:
|
||||
ASSERT(false);
|
||||
return 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
int jpeg_stream_reader::read_spiff_directory_entry(const jpeg_marker_code marker_code, const int32_t segment_size)
|
||||
void jpeg_stream_reader::read_spiff_directory_entry(const jpeg_marker_code marker_code)
|
||||
{
|
||||
if (UNLIKELY(marker_code != jpeg_marker_code::application_data8))
|
||||
throw_jpegls_error(jpegls_errc::missing_end_of_spiff_directory);
|
||||
|
||||
if (UNLIKELY(segment_size < 4))
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
|
||||
check_minimal_segment_size(4);
|
||||
const uint32_t spiff_directory_type{read_uint32()};
|
||||
if (spiff_directory_type == spiff_end_of_directory_entry_type)
|
||||
{
|
||||
check_segment_size(6); // 4 + 2 for dummy SOI.
|
||||
state_ = state::image_section;
|
||||
}
|
||||
|
||||
return 4;
|
||||
skip_remaining_segment_data();
|
||||
}
|
||||
|
||||
int jpeg_stream_reader::read_start_of_frame_segment(const int32_t segment_size)
|
||||
|
||||
void jpeg_stream_reader::read_start_of_frame_segment()
|
||||
{
|
||||
// A JPEG-LS Start of Frame (SOF) segment is documented in ISO/IEC 14495-1, C.2.2
|
||||
// This section references ISO/IEC 10918-1, B.2.2, which defines the normal JPEG SOF,
|
||||
// with some modifications.
|
||||
|
||||
if (UNLIKELY(segment_size < 6))
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
check_minimal_segment_size(6);
|
||||
|
||||
frame_info_.bits_per_sample = read_byte();
|
||||
if (UNLIKELY(frame_info_.bits_per_sample < minimum_bits_per_sample || frame_info_.bits_per_sample > maximum_bits_per_sample))
|
||||
if (UNLIKELY(frame_info_.bits_per_sample < minimum_bits_per_sample ||
|
||||
frame_info_.bits_per_sample > maximum_bits_per_sample))
|
||||
throw_jpegls_error(jpegls_errc::invalid_parameter_bits_per_sample);
|
||||
|
||||
frame_info_.height = read_uint16();
|
||||
@ -387,9 +362,7 @@ int jpeg_stream_reader::read_start_of_frame_segment(const int32_t segment_size)
|
||||
if (UNLIKELY(frame_info_.component_count < 1))
|
||||
throw_jpegls_error(jpegls_errc::invalid_parameter_component_count);
|
||||
|
||||
if (UNLIKELY(segment_size != 6 + (frame_info_.component_count * 3)))
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
|
||||
check_segment_size((static_cast<size_t>(frame_info_.component_count) * 3) + 6);
|
||||
for (int32_t i{}; i != frame_info_.component_count; ++i)
|
||||
{
|
||||
// Component specification parameters
|
||||
@ -403,36 +376,34 @@ int jpeg_stream_reader::read_start_of_frame_segment(const int32_t segment_size)
|
||||
}
|
||||
|
||||
state_ = state::scan_section;
|
||||
|
||||
return segment_size;
|
||||
}
|
||||
|
||||
|
||||
int jpeg_stream_reader::read_comment(const int32_t segment_size) const
|
||||
void jpeg_stream_reader::read_comment()
|
||||
{
|
||||
if (UNLIKELY(static_cast<size_t>(segment_size) > source_.size))
|
||||
throw_jpegls_error(jpegls_errc::source_buffer_too_small);
|
||||
|
||||
if (UNLIKELY(comment_handler_ && static_cast<bool>(comment_handler_(segment_size > 0 ? source_.data : nullptr, segment_size,
|
||||
comment_handler_user_context_))))
|
||||
if (comment_handler_ &&
|
||||
UNLIKELY(static_cast<bool>(comment_handler_(segment_data_.empty() ? nullptr : position_, segment_data_.size(),
|
||||
comment_handler_user_context_))))
|
||||
throw_jpegls_error(jpegls_errc::callback_failed);
|
||||
|
||||
return 0;
|
||||
skip_remaining_segment_data();
|
||||
}
|
||||
|
||||
|
||||
int jpeg_stream_reader::read_preset_parameters_segment(const int32_t segment_size)
|
||||
void jpeg_stream_reader::read_application_data() noexcept
|
||||
{
|
||||
if (UNLIKELY(segment_size < 1))
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
skip_remaining_segment_data();
|
||||
}
|
||||
|
||||
|
||||
void jpeg_stream_reader::read_preset_parameters_segment()
|
||||
{
|
||||
check_minimal_segment_size(1);
|
||||
const auto type{static_cast<jpegls_preset_parameters_type>(read_byte())};
|
||||
switch (type)
|
||||
{
|
||||
case jpegls_preset_parameters_type::preset_coding_parameters: {
|
||||
constexpr int32_t coding_parameter_segment_size = 11;
|
||||
if (UNLIKELY(segment_size != coding_parameter_segment_size))
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
case jpegls_preset_parameters_type::preset_coding_parameters:
|
||||
check_segment_size(1 + (5 * sizeof(uint16_t)));
|
||||
|
||||
// Note: validation will be done, just before decoding as more info is needed for validation.
|
||||
preset_coding_parameters_.maximum_sample_value = read_uint16();
|
||||
@ -440,9 +411,7 @@ int jpeg_stream_reader::read_preset_parameters_segment(const int32_t segment_siz
|
||||
preset_coding_parameters_.threshold2 = read_uint16();
|
||||
preset_coding_parameters_.threshold3 = read_uint16();
|
||||
preset_coding_parameters_.reset_value = read_uint16();
|
||||
|
||||
return coding_parameter_segment_size;
|
||||
}
|
||||
return;
|
||||
|
||||
case jpegls_preset_parameters_type::mapping_table_specification:
|
||||
case jpegls_preset_parameters_type::mapping_table_continuation:
|
||||
@ -464,23 +433,23 @@ 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)
|
||||
void jpeg_stream_reader::read_define_restart_interval()
|
||||
{
|
||||
// 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)
|
||||
switch (segment_data_.size())
|
||||
{
|
||||
case 2:
|
||||
parameters_.restart_interval = read_uint16();
|
||||
return 2;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
parameters_.restart_interval = read_uint24();
|
||||
return 3;
|
||||
break;
|
||||
|
||||
case 4:
|
||||
parameters_.restart_interval = read_uint32();
|
||||
return 4;
|
||||
break;
|
||||
|
||||
default:
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
@ -490,18 +459,15 @@ int jpeg_stream_reader::read_define_restart_interval(const int32_t segment_size)
|
||||
|
||||
void jpeg_stream_reader::read_start_of_scan()
|
||||
{
|
||||
const int32_t segment_size{read_segment_size()};
|
||||
if (UNLIKELY(segment_size < 3))
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
|
||||
const int component_count_in_scan{read_byte()};
|
||||
if (UNLIKELY(component_count_in_scan != 1 && component_count_in_scan != frame_info_.component_count))
|
||||
check_minimal_segment_size(1);
|
||||
const size_t component_count_in_scan{read_byte()};
|
||||
if (UNLIKELY(component_count_in_scan != 1 &&
|
||||
component_count_in_scan != static_cast<size_t>(frame_info_.component_count)))
|
||||
throw_jpegls_error(jpegls_errc::parameter_value_not_supported);
|
||||
|
||||
if (UNLIKELY(segment_size != 6 + (2 * component_count_in_scan)))
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
check_segment_size((component_count_in_scan * 2) + 4);
|
||||
|
||||
for (int i{}; i != component_count_in_scan; ++i)
|
||||
for (size_t i{}; i != component_count_in_scan; ++i)
|
||||
{
|
||||
skip_byte(); // Skip scan component selector
|
||||
const uint8_t mapping_table_selector{read_byte()};
|
||||
@ -524,63 +490,103 @@ void jpeg_stream_reader::read_start_of_scan()
|
||||
}
|
||||
|
||||
|
||||
uint8_t jpeg_stream_reader::read_byte()
|
||||
USE_DECL_ANNOTATIONS uint8_t jpeg_stream_reader::read_byte_checked()
|
||||
{
|
||||
if (UNLIKELY(source_.size == 0))
|
||||
if (UNLIKELY(position_ == end_position_))
|
||||
throw_jpegls_error(jpegls_errc::source_buffer_too_small);
|
||||
|
||||
const uint8_t value{source_.data[0]};
|
||||
skip_bytes(source_, 1);
|
||||
return read_byte();
|
||||
}
|
||||
|
||||
|
||||
USE_DECL_ANNOTATIONS uint16_t jpeg_stream_reader::read_uint16_checked()
|
||||
{
|
||||
if (UNLIKELY(position_ + sizeof(uint16_t) > end_position_))
|
||||
throw_jpegls_error(jpegls_errc::source_buffer_too_small);
|
||||
|
||||
return read_uint16();
|
||||
}
|
||||
|
||||
|
||||
USE_DECL_ANNOTATIONS uint8_t jpeg_stream_reader::read_byte() noexcept
|
||||
{
|
||||
ASSERT(position_ != end_position_);
|
||||
|
||||
const uint8_t value{*position_};
|
||||
advance_position(1);
|
||||
return value;
|
||||
}
|
||||
|
||||
|
||||
void jpeg_stream_reader::skip_byte()
|
||||
void jpeg_stream_reader::skip_byte() noexcept
|
||||
{
|
||||
std::ignore = read_byte();
|
||||
advance_position(1);
|
||||
}
|
||||
|
||||
|
||||
uint16_t jpeg_stream_reader::read_uint16()
|
||||
USE_DECL_ANNOTATIONS uint16_t jpeg_stream_reader::read_uint16() noexcept
|
||||
{
|
||||
if (UNLIKELY(source_.size < 2))
|
||||
throw_jpegls_error(jpegls_errc::source_buffer_too_small);
|
||||
ASSERT(position_ + sizeof(uint16_t) <= end_position_);
|
||||
|
||||
const auto value{read_unaligned<uint16_t>(source_.data)};
|
||||
skip_bytes(source_, 2);
|
||||
return byte_swap(value);
|
||||
const auto value{byte_swap(read_unaligned<uint16_t>(position_))};
|
||||
advance_position(2);
|
||||
return value;
|
||||
}
|
||||
|
||||
|
||||
uint32_t jpeg_stream_reader::read_uint24()
|
||||
USE_DECL_ANNOTATIONS uint32_t jpeg_stream_reader::read_uint24() noexcept
|
||||
{
|
||||
const uint32_t value{static_cast<uint32_t>(read_byte()) << 16U};
|
||||
const uint32_t value{static_cast<uint32_t>(read_uint8()) << 16U};
|
||||
return value + read_uint16();
|
||||
}
|
||||
|
||||
|
||||
uint32_t jpeg_stream_reader::read_uint32()
|
||||
USE_DECL_ANNOTATIONS uint32_t jpeg_stream_reader::read_uint32() noexcept
|
||||
{
|
||||
if (UNLIKELY(source_.size < 4))
|
||||
throw_jpegls_error(jpegls_errc::source_buffer_too_small);
|
||||
ASSERT(position_ + sizeof(uint32_t) <= end_position_);
|
||||
|
||||
const auto value{read_unaligned<uint32_t>(source_.data)};
|
||||
skip_bytes(source_, 4);
|
||||
return byte_swap(value);
|
||||
const auto value{byte_swap(read_unaligned<uint32_t>(position_))};
|
||||
advance_position(4);
|
||||
return value;
|
||||
}
|
||||
|
||||
|
||||
int32_t jpeg_stream_reader::read_segment_size()
|
||||
USE_DECL_ANNOTATIONS const_byte_span jpeg_stream_reader::read_bytes(const size_t byte_count) noexcept
|
||||
{
|
||||
const int32_t segment_size{read_uint16()};
|
||||
if (UNLIKELY(segment_size < 2))
|
||||
ASSERT(position_ + byte_count <= end_position_);
|
||||
|
||||
const const_byte_span bytes{position_, byte_count};
|
||||
advance_position(byte_count);
|
||||
return bytes;
|
||||
}
|
||||
|
||||
|
||||
void jpeg_stream_reader::read_segment_size()
|
||||
{
|
||||
constexpr size_t segment_length{2}; // The segment size also includes the length of the segment length bytes.
|
||||
const size_t segment_size{read_uint16_checked()};
|
||||
segment_data_ = {position_, segment_size - segment_length};
|
||||
|
||||
if (UNLIKELY(segment_size < segment_length || position_ + segment_data_.size() > end_position_))
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
|
||||
return segment_size;
|
||||
}
|
||||
|
||||
int jpeg_stream_reader::try_read_application_data8_segment(const int32_t segment_size, spiff_header* header,
|
||||
bool* spiff_header_found)
|
||||
|
||||
void jpeg_stream_reader::check_minimal_segment_size(const size_t minimum_size) const
|
||||
{
|
||||
if (UNLIKELY(minimum_size > segment_data_.size()))
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
}
|
||||
|
||||
|
||||
void jpeg_stream_reader::check_segment_size(const size_t expected_size) const
|
||||
{
|
||||
if (UNLIKELY(expected_size != segment_data_.size()))
|
||||
throw_jpegls_error(jpegls_errc::invalid_marker_segment_size);
|
||||
}
|
||||
|
||||
|
||||
void jpeg_stream_reader::try_read_application_data8_segment(spiff_header* header, bool* spiff_header_found)
|
||||
{
|
||||
if (spiff_header_found)
|
||||
{
|
||||
@ -588,21 +594,26 @@ int jpeg_stream_reader::try_read_application_data8_segment(const int32_t segment
|
||||
*spiff_header_found = false;
|
||||
}
|
||||
|
||||
if (segment_size == 5)
|
||||
return try_read_hp_color_transform_segment();
|
||||
if (segment_data_.size() == 5)
|
||||
{
|
||||
try_read_hp_color_transform_segment();
|
||||
}
|
||||
else if (header && spiff_header_found && segment_data_.size() >= 30)
|
||||
{
|
||||
try_read_spiff_header_segment(*header, *spiff_header_found);
|
||||
}
|
||||
|
||||
if (header && spiff_header_found && segment_size >= 30)
|
||||
return try_read_spiff_header_segment(*header, *spiff_header_found);
|
||||
|
||||
return 0;
|
||||
skip_remaining_segment_data();
|
||||
}
|
||||
|
||||
|
||||
int jpeg_stream_reader::try_read_hp_color_transform_segment()
|
||||
void jpeg_stream_reader::try_read_hp_color_transform_segment()
|
||||
{
|
||||
ASSERT(segment_data_.size() == 5);
|
||||
|
||||
const array<uint8_t, 4> mrfx_tag{'m', 'r', 'f', 'x'}; // mrfx = xfrm (in big endian) = colorXFoRM
|
||||
if (!equal(mrfx_tag.cbegin(), mrfx_tag.cend(), read_bytes(4).cbegin()))
|
||||
return 4;
|
||||
if (!equal(mrfx_tag.cbegin(), mrfx_tag.cend(), read_bytes(4).begin()))
|
||||
return;
|
||||
|
||||
const auto transformation{read_byte()};
|
||||
switch (transformation)
|
||||
@ -612,7 +623,7 @@ int jpeg_stream_reader::try_read_hp_color_transform_segment()
|
||||
case static_cast<uint8_t>(color_transformation::hp2):
|
||||
case static_cast<uint8_t>(color_transformation::hp3):
|
||||
parameters_.transformation = static_cast<color_transformation>(transformation);
|
||||
return 5;
|
||||
return;
|
||||
|
||||
case 4: // RgbAsYuvLossy (The standard lossy RGB to YCbCr transform used in JPEG.)
|
||||
case 5: // Matrix (transformation is controlled using a matrix that is also stored in the segment.
|
||||
@ -623,26 +634,17 @@ int jpeg_stream_reader::try_read_hp_color_transform_segment()
|
||||
}
|
||||
}
|
||||
|
||||
template<typename EnumType, EnumType Low, EnumType High>
|
||||
EnumType enum_cast(uint8_t value)
|
||||
|
||||
USE_DECL_ANNOTATIONS void jpeg_stream_reader::try_read_spiff_header_segment(spiff_header& header, bool& spiff_header_found)
|
||||
{
|
||||
if (UNLIKELY(value < static_cast<uint8_t>(Low)))
|
||||
throw_jpegls_error(jpegls_errc::invalid_encoded_data);
|
||||
ASSERT(segment_data_.size() >= 30);
|
||||
|
||||
if (UNLIKELY(value > static_cast<uint8_t>(High)))
|
||||
throw_jpegls_error(jpegls_errc::invalid_encoded_data);
|
||||
|
||||
return static_cast<EnumType>(value);
|
||||
}
|
||||
|
||||
USE_DECL_ANNOTATIONS int jpeg_stream_reader::try_read_spiff_header_segment(spiff_header& header, bool& spiff_header_found)
|
||||
{
|
||||
const array<uint8_t, 6> spiff_tag{'S', 'P', 'I', 'F', 'F', 0};
|
||||
if (!equal(spiff_tag.cbegin(), spiff_tag.cend(), read_bytes(6).cbegin()))
|
||||
if (!equal(spiff_tag.cbegin(), spiff_tag.cend(), read_bytes(6).begin()))
|
||||
{
|
||||
header = {};
|
||||
spiff_header_found = false;
|
||||
return 6;
|
||||
return;
|
||||
}
|
||||
|
||||
const auto high_version{read_byte()};
|
||||
@ -650,7 +652,7 @@ USE_DECL_ANNOTATIONS int jpeg_stream_reader::try_read_spiff_header_segment(spiff
|
||||
{
|
||||
header = {};
|
||||
spiff_header_found = false;
|
||||
return 7; // Treat unknown versions as if the SPIFF header doesn't exists.
|
||||
return; // Treat unknown versions as if the SPIFF header doesn't exists.
|
||||
}
|
||||
|
||||
skip_byte(); // low version
|
||||
@ -667,7 +669,6 @@ USE_DECL_ANNOTATIONS int jpeg_stream_reader::try_read_spiff_header_segment(spiff
|
||||
header.horizontal_resolution = read_uint32();
|
||||
|
||||
spiff_header_found = true;
|
||||
return 30;
|
||||
}
|
||||
|
||||
|
||||
@ -705,7 +706,7 @@ void jpeg_stream_reader::check_interleave_mode(const interleave_mode mode) const
|
||||
}
|
||||
|
||||
|
||||
uint32_t jpeg_stream_reader::maximum_sample_value() const noexcept
|
||||
USE_DECL_ANNOTATIONS uint32_t jpeg_stream_reader::maximum_sample_value() const noexcept
|
||||
{
|
||||
if (preset_coding_parameters_.maximum_sample_value != 0)
|
||||
return static_cast<uint32_t>(preset_coding_parameters_.maximum_sample_value);
|
||||
@ -714,4 +715,11 @@ uint32_t jpeg_stream_reader::maximum_sample_value() const noexcept
|
||||
}
|
||||
|
||||
|
||||
void jpeg_stream_reader::skip_remaining_segment_data() noexcept
|
||||
{
|
||||
const auto bytes_still_to_read{segment_data_.end() - position_};
|
||||
advance_position(bytes_still_to_read);
|
||||
}
|
||||
|
||||
|
||||
} // namespace charls
|
||||
|
||||
@ -3,12 +3,13 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "byte_span.h"
|
||||
#include "charls/public_types.h"
|
||||
|
||||
#include "byte_span.h"
|
||||
#include "coding_parameters.h"
|
||||
#include "util.h"
|
||||
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
namespace charls {
|
||||
|
||||
@ -26,7 +27,7 @@ public:
|
||||
jpeg_stream_reader(jpeg_stream_reader&&) = default;
|
||||
jpeg_stream_reader& operator=(jpeg_stream_reader&&) = default;
|
||||
|
||||
void source(byte_span source) noexcept;
|
||||
void source(const_byte_span source) noexcept;
|
||||
|
||||
const charls::frame_info& frame_info() const noexcept
|
||||
{
|
||||
@ -60,39 +61,55 @@ public:
|
||||
}
|
||||
|
||||
void read_header(spiff_header* header = nullptr, bool* spiff_header_found = nullptr);
|
||||
void read(byte_span destination, size_t stride);
|
||||
void decode(byte_span destination, size_t stride);
|
||||
void read_end_of_image();
|
||||
|
||||
void read_start_of_scan();
|
||||
|
||||
private:
|
||||
uint8_t read_byte();
|
||||
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);
|
||||
void advance_position(const size_t count) noexcept
|
||||
{
|
||||
ASSERT(position_ + count <= end_position_);
|
||||
position_ += count;
|
||||
}
|
||||
|
||||
CHARLS_CHECK_RETURN uint8_t read_byte_checked();
|
||||
CHARLS_CHECK_RETURN uint16_t read_uint16_checked();
|
||||
|
||||
CHARLS_CHECK_RETURN uint8_t read_byte() noexcept;
|
||||
void skip_byte() noexcept;
|
||||
|
||||
CHARLS_CHECK_RETURN uint8_t read_uint8() noexcept
|
||||
{
|
||||
return read_byte();
|
||||
}
|
||||
|
||||
CHARLS_CHECK_RETURN uint16_t read_uint16() noexcept;
|
||||
CHARLS_CHECK_RETURN uint32_t read_uint24() noexcept;
|
||||
CHARLS_CHECK_RETURN uint32_t read_uint32() noexcept;
|
||||
CHARLS_CHECK_RETURN const_byte_span read_bytes(size_t byte_count) noexcept;
|
||||
void read_segment_size();
|
||||
void check_minimal_segment_size(size_t minimum_size) const;
|
||||
void check_segment_size(size_t expected_size) const;
|
||||
void read_next_start_of_scan();
|
||||
jpeg_marker_code read_next_marker_code();
|
||||
CHARLS_CHECK_RETURN jpeg_marker_code read_next_marker_code();
|
||||
void validate_marker_code(jpeg_marker_code marker_code) const;
|
||||
jpegls_pc_parameters get_validated_preset_coding_parameters() const;
|
||||
|
||||
int read_marker_segment(jpeg_marker_code marker_code, int32_t segment_size, spiff_header* header = nullptr,
|
||||
bool* spiff_header_found = nullptr);
|
||||
int read_spiff_directory_entry(jpeg_marker_code marker_code, int32_t segment_size);
|
||||
int read_start_of_frame_segment(int32_t segment_size);
|
||||
int read_comment(int32_t segment_size) const;
|
||||
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(CHARLS_OUT spiff_header& header, CHARLS_OUT bool& spiff_header_found);
|
||||
|
||||
int try_read_hp_color_transform_segment();
|
||||
CHARLS_CHECK_RETURN jpegls_pc_parameters get_validated_preset_coding_parameters() const;
|
||||
void read_marker_segment(jpeg_marker_code marker_code, spiff_header* header = nullptr,
|
||||
bool* spiff_header_found = nullptr);
|
||||
void read_spiff_directory_entry(jpeg_marker_code marker_code);
|
||||
void read_start_of_frame_segment();
|
||||
void read_start_of_scan();
|
||||
void read_comment();
|
||||
void read_application_data() noexcept;
|
||||
void read_preset_parameters_segment();
|
||||
void read_define_restart_interval();
|
||||
void try_read_application_data8_segment(spiff_header* header, bool* spiff_header_found);
|
||||
void try_read_spiff_header_segment(CHARLS_OUT spiff_header& header, CHARLS_OUT bool& spiff_header_found);
|
||||
void try_read_hp_color_transform_segment();
|
||||
void add_component(uint8_t component_id);
|
||||
void check_parameter_coherent() const;
|
||||
void check_interleave_mode(interleave_mode mode) const;
|
||||
uint32_t maximum_sample_value() const noexcept;
|
||||
CHARLS_CHECK_RETURN uint32_t maximum_sample_value() const noexcept;
|
||||
void skip_remaining_segment_data() noexcept;
|
||||
|
||||
enum class state
|
||||
{
|
||||
@ -106,14 +123,15 @@ private:
|
||||
after_end_of_image
|
||||
};
|
||||
|
||||
byte_span source_;
|
||||
const_byte_span::iterator position_{};
|
||||
const_byte_span::iterator end_position_{};
|
||||
const_byte_span segment_data_;
|
||||
charls::frame_info frame_info_{};
|
||||
coding_parameters parameters_{};
|
||||
jpegls_pc_parameters preset_coding_parameters_{};
|
||||
JlsRect rect_{};
|
||||
std::vector<uint8_t> component_ids_;
|
||||
state state_{};
|
||||
|
||||
at_comment_handler comment_handler_{};
|
||||
void* comment_handler_user_context_{};
|
||||
};
|
||||
|
||||
@ -445,14 +445,14 @@ private:
|
||||
}
|
||||
|
||||
// NOLINTNEXTLINE(cppcoreguidelines-explicit-virtual-functions, hicpp-use-override, modernize-use-override, clang-diagnostic-suggest-override)
|
||||
void decode_scan(std::unique_ptr<process_line> process_line, const JlsRect& rect, byte_span& compressed_data)
|
||||
size_t decode_scan(std::unique_ptr<process_line> process_line, const JlsRect& rect, const_byte_span encoded_source)
|
||||
{
|
||||
Strategy::process_line_ = std::move(process_line);
|
||||
|
||||
const uint8_t* compressed_bytes{compressed_data.data};
|
||||
const auto* scan_begin{encoded_source.begin()};
|
||||
rect_ = rect;
|
||||
|
||||
Strategy::initialize(compressed_data);
|
||||
Strategy::initialize(encoded_source);
|
||||
|
||||
// Process images without a restart interval, as 1 large restart interval.
|
||||
if (restart_interval_ == 0)
|
||||
@ -462,7 +462,7 @@ private:
|
||||
|
||||
decode_lines();
|
||||
|
||||
skip_bytes(compressed_data, static_cast<size_t>(Strategy::get_cur_byte_pos() - compressed_bytes));
|
||||
return Strategy::get_cur_byte_pos() - scan_begin;
|
||||
}
|
||||
|
||||
// clang-format on
|
||||
|
||||
@ -37,9 +37,10 @@ public:
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void decode_scan(unique_ptr<charls::process_line> /*output_data*/, const JlsRect& /*size*/,
|
||||
charls::byte_span& /*compressed_data*/) noexcept(false) override
|
||||
size_t decode_scan(unique_ptr<charls::process_line> /*process_line*/, const JlsRect& /*size*/,
|
||||
charls::const_byte_span /*encoded_source*/) noexcept(false) override
|
||||
{
|
||||
return {};
|
||||
}
|
||||
|
||||
int32_t read(const int32_t length)
|
||||
|
||||
@ -28,7 +28,7 @@ public:
|
||||
{
|
||||
array<uint8_t, 1> buffer{};
|
||||
jpeg_stream_reader reader;
|
||||
reader.source({buffer.data(), 0});
|
||||
reader.source({buffer.data(), static_cast<size_t>(0)});
|
||||
|
||||
assert_expect_exception(jpegls_errc::source_buffer_too_small, [&reader] { reader.read_header(); });
|
||||
}
|
||||
@ -45,7 +45,7 @@ public:
|
||||
writer.write_start_of_frame_segment(1, 1, 2, 1);
|
||||
|
||||
writer.write_byte(extra_start_byte);
|
||||
writer.write_start_of_scan_segment(0, 1, 128, interleave_mode::none);
|
||||
writer.write_start_of_scan_segment(0, 1, 1, interleave_mode::none);
|
||||
|
||||
jpeg_stream_reader reader;
|
||||
reader.source({writer.buffer.data(), writer.buffer.size()});
|
||||
@ -236,9 +236,8 @@ public:
|
||||
|
||||
jpeg_stream_reader reader;
|
||||
reader.source({writer.buffer.data(), writer.buffer.size()});
|
||||
reader.read_header();
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_parameter_near_lossless, [&reader] { reader.read_start_of_scan(); });
|
||||
assert_expect_exception(jpegls_errc::invalid_parameter_near_lossless, [&reader] { reader.read_header(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_too_large_near_lossless_in_sos_should_throw2) // NOLINT
|
||||
@ -255,9 +254,8 @@ public:
|
||||
|
||||
jpeg_stream_reader reader;
|
||||
reader.source({writer.buffer.data(), writer.buffer.size()});
|
||||
reader.read_header();
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_parameter_near_lossless, [&reader] { reader.read_start_of_scan(); });
|
||||
assert_expect_exception(jpegls_errc::invalid_parameter_near_lossless, [&reader] { reader.read_header(); });
|
||||
}
|
||||
|
||||
TEST_METHOD(read_header_line_interleave_in_sos_for_single_component_should_throw) // NOLINT
|
||||
@ -602,7 +600,7 @@ private:
|
||||
writer.write_byte(0x02);
|
||||
|
||||
writer.write_start_of_frame_segment(1, 1, 2, 1);
|
||||
writer.write_start_of_scan_segment(0, 1, 128, interleave_mode::none);
|
||||
writer.write_start_of_scan_segment(0, 1, 1, interleave_mode::none);
|
||||
|
||||
jpeg_stream_reader reader;
|
||||
reader.source({writer.buffer.data(), writer.buffer.size()});
|
||||
@ -619,9 +617,8 @@ private:
|
||||
|
||||
jpeg_stream_reader reader;
|
||||
reader.source({writer.buffer.data(), writer.buffer.size()});
|
||||
reader.read_header();
|
||||
|
||||
assert_expect_exception(jpegls_errc::invalid_parameter_interleave_mode, [&reader] { reader.read_start_of_scan(); });
|
||||
assert_expect_exception(jpegls_errc::invalid_parameter_interleave_mode, [&reader] { reader.read_header(); });
|
||||
}
|
||||
|
||||
static void read_header_with_jpeg_ls_preset_parameter_with_extended_id_should_throw(const uint8_t id)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user