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

Re-order the failure values of the enum jpegls_errc (breaking change) (#318)

Browse Source 
Group the error IDs in errors that cannot be prevented and can be reported at runtime and in a set of errors that can be prevented.

Note 1: the error destination_too_small is considerd a runtime failure, but can in many cases be prevented.
Note 2: unexpected exceptions will now trigger a call to std::terminate (improved crash dumps)
This commit is contained in:
Victor Derks 2024-08-15 16:36:03 +02:00 committed by GitHub
parent 256ad01358
commit e462982106
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
26 changed files with 341 additions and 343 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG.md
View File

@ -15,6 +15,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
- BREAKING: Updated the minimal required C++ language version to C++17. - BREAKING: Updated the minimal required C++ language version to C++17.
- BREAKING: encoding_options::include_pc_parameters_jai is not enabled by default anymore. - BREAKING: encoding_options::include_pc_parameters_jai is not enabled by default anymore.
- BREAKING: charls::jpegls_decoder and charls::jpegls_encoder follow the same const pattern as the C API. - BREAKING: charls::jpegls_decoder and charls::jpegls_encoder follow the same const pattern as the C API.
- BREAKING: the failure values of the enum charls::jpegls_errc are now divided in 2 groups: runtime failures and logic.
### Removed ### Removed
@ -30,7 +31,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
### Fixed ### Fixed
- Fixed [#221](https://github.com/team-charls/charls/issues/221), jpegls_errc::destination_buffer_too_small incorrectly thrown for 8 bit 2*2 image with stride = 4 during decoding. - Fixed [#221](https://github.com/team-charls/charls/issues/221), jpegls_errc::destination_too_small incorrectly thrown for 8 bit 2*2 image with stride = 4 during decoding.
## [2.4.0] - 2022-12-29 ## [2.4.0] - 2022-12-29

4
include/charls/charls.h
View File

@ -9,7 +9,8 @@
#include "version.h" #include "version.h"
// Undefine CHARLS macros to prevent global macro namespace pollution // Undefine CHARLS macros to prevent global macro namespace pollution and usage by client code.
// The macros are not part of the official API.
#if !defined(CHARLS_LIBRARY_BUILD) #if !defined(CHARLS_LIBRARY_BUILD)
#undef CHARLS_API_IMPORT_EXPORT #undef CHARLS_API_IMPORT_EXPORT
@ -17,6 +18,7 @@
#undef CHARLS_NOEXCEPT #undef CHARLS_NOEXCEPT
#undef CHARLS_ATTRIBUTE #undef CHARLS_ATTRIBUTE
#undef CHARLS_C_VOID #undef CHARLS_C_VOID
#undef CHARLS_NO_INLINE
#undef CHARLS_IN #undef CHARLS_IN
#undef CHARLS_IN_OPT #undef CHARLS_IN_OPT
#undef CHARLS_IN_Z #undef CHARLS_IN_Z

24
include/charls/charls_jpegls_encoder.h
View File

@ -111,15 +111,15 @@ charls_jpegls_encoder_set_color_transformation(CHARLS_IN charls_jpegls_encoder*
CHARLS_ATTRIBUTE((nonnull)); CHARLS_ATTRIBUTE((nonnull));
/// <summary> /// <summary>
/// Configures the table ID the encoder should reference when encoding a component. /// Configures the mapping table ID the encoder should reference when encoding a component.
/// The referenced table can be included in the stream or provided in another JPEG-LS abbreviated format stream. /// The referenced mapping table can be included in the stream or provided in another JPEG-LS abbreviated format stream.
/// </summary> /// </summary>
/// <param name="encoder">Reference to the encoder instance.</param> /// <param name="encoder">Reference to the encoder instance.</param>
/// <param name="component_index">Index of the component. Component 0 is the start index.</param> /// <param name="component_index">Index of the component. Component 0 is the start index.</param>
/// <param name="table_id">Table ID that will be referenced by this component.</param> /// <param name="table_id">Mapping table ID that will be referenced by this component.</param>
CHARLS_CHECK_RETURN CHARLS_API_IMPORT_EXPORT charls_jpegls_errc CHARLS_API_CALLING_CONVENTION CHARLS_CHECK_RETURN CHARLS_API_IMPORT_EXPORT charls_jpegls_errc CHARLS_API_CALLING_CONVENTION
charls_jpegls_encoder_set_table_id(CHARLS_IN charls_jpegls_encoder* encoder, int32_t component_index, charls_jpegls_encoder_set_mapping_table_id(CHARLS_IN charls_jpegls_encoder* encoder, int32_t component_index,
int32_t table_id) CHARLS_NOEXCEPT CHARLS_ATTRIBUTE((nonnull)); int32_t table_id) CHARLS_NOEXCEPT CHARLS_ATTRIBUTE((nonnull));
/// <summary> /// <summary>
/// Returns the size in bytes, that the encoder expects are needed to hold the encoded image. /// Returns the size in bytes, that the encoder expects are needed to hold the encoded image.
@ -252,7 +252,7 @@ charls_jpegls_encoder_write_application_data(CHARLS_IN charls_jpegls_encoder* en
/// During decoding the active maximum value determines the required size of the table. /// During decoding the active maximum value determines the required size of the table.
/// </remarks> /// </remarks>
/// <param name="encoder">Reference to the encoder instance.</param> /// <param name="encoder">Reference to the encoder instance.</param>
/// <param name="table_id">Table ID. Unique identifier of the mapping table in the range [1..255]</param> /// <param name="table_id">Mapping table ID. Unique identifier of the mapping table in the range [1..255]</param>
/// <param name="entry_size">Size in bytes of a single table entry.</param> /// <param name="entry_size">Size in bytes of a single table entry.</param>
/// <param name="table_data">Byte array that holds the mapping table.</param> /// <param name="table_data">Byte array that holds the mapping table.</param>
/// <param name="table_data_size_bytes">The size in bytes of the table data.</param> /// <param name="table_data_size_bytes">The size in bytes of the table data.</param>
@ -424,14 +424,14 @@ public:
} }
/// <summary> /// <summary>
/// Configures the table ID the encoder should reference when encoding a component. /// Configures the mapping table ID the encoder should reference when encoding a component.
/// The referenced table can be included in the stream or provided in another JPEG-LS abbreviated format stream. /// The referenced mapping table can be included in the stream or provided in another JPEG-LS abbreviated format stream.
/// </summary> /// </summary>
/// <param name="component_index">Index of the component. Component 0 is the start index.</param> /// <param name="component_index">Index of the component. Component 0 is the start index.</param>
/// <param name="table_id">Table ID that will be referenced by this component.</param> /// <param name="table_id">Mapping table ID that will be referenced by this component.</param>
jpegls_encoder& set_table_id(const int32_t component_index, const int32_t table_id) jpegls_encoder& set_mapping_table_id(const int32_t component_index, const int32_t table_id)
{ {
check_jpegls_errc(charls_jpegls_encoder_set_table_id(encoder(), component_index, table_id)); check_jpegls_errc(charls_jpegls_encoder_set_mapping_table_id(encoder(), component_index, table_id));
return *this; return *this;
} }
@ -589,7 +589,7 @@ public:
/// <remarks> /// <remarks>
/// No validation is performed if the table ID is unique and if the table size matches the required size. /// No validation is performed if the table ID is unique and if the table size matches the required size.
/// </remarks> /// </remarks>
/// <param name="table_id">Table ID. Unique identifier of the mapping table in the range [1..255]</param> /// <param name="table_id">Mapping table ID. Unique identifier of the mapping table in the range [1..255]</param>
/// <param name="entry_size">Size in bytes of a single table entry.</param> /// <param name="entry_size">Size in bytes of a single table entry.</param>
/// <param name="table_data">Byte buffer that holds the mapping table.</param> /// <param name="table_data">Byte buffer that holds the mapping table.</param>
/// <param name="size">The size of the buffer in bytes.</param> /// <param name="size">The size of the buffer in bytes.</param>

2
include/charls/jpegls_error.h
View File

@ -66,8 +66,6 @@ inline CHARLS_NO_INLINE void throw_jpegls_error(const jpegls_errc error_value)
throw jpegls_error(error_value); throw jpegls_error(error_value);
} }
#undef CHARLS_NO_INLINE
} // namespace impl } // namespace impl
inline void check_jpegls_errc(const jpegls_errc error_value) inline void check_jpegls_errc(const jpegls_errc error_value)

365
include/charls/public_types.h
View File

@ -28,57 +28,61 @@ CHARLS_RETURN_TYPE_SUCCESS(return == 0)
enum charls_jpegls_errc enum charls_jpegls_errc
{ {
CHARLS_JPEGLS_ERRC_SUCCESS = 0, CHARLS_JPEGLS_ERRC_SUCCESS = 0,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT = 1,
CHARLS_JPEGLS_ERRC_PARAMETER_VALUE_NOT_SUPPORTED = 2, // Runtime errors:
CHARLS_JPEGLS_ERRC_DESTINATION_BUFFER_TOO_SMALL = 3,
CHARLS_JPEGLS_ERRC_SOURCE_BUFFER_TOO_SMALL = 4, CHARLS_JPEGLS_ERRC_NOT_ENOUGH_MEMORY = 1,
CHARLS_JPEGLS_ERRC_INVALID_ENCODED_DATA = 5, CHARLS_JPEGLS_ERRC_CALLBACK_FAILED = 2,
CHARLS_JPEGLS_ERRC_TOO_MUCH_ENCODED_DATA = 6, CHARLS_JPEGLS_ERRC_DESTINATION_TOO_SMALL = 3,
CHARLS_JPEGLS_ERRC_INVALID_OPERATION = 7, CHARLS_JPEGLS_ERRC_NEED_MORE_DATA = 4,
CHARLS_JPEGLS_ERRC_COLOR_TRANSFORM_NOT_SUPPORTED = 9, CHARLS_JPEGLS_ERRC_INVALID_DATA = 5,
CHARLS_JPEGLS_ERRC_ENCODING_NOT_SUPPORTED = 10, CHARLS_JPEGLS_ERRC_ENCODING_NOT_SUPPORTED = 6,
CHARLS_JPEGLS_ERRC_UNKNOWN_JPEG_MARKER_FOUND = 11, CHARLS_JPEGLS_ERRC_PARAMETER_VALUE_NOT_SUPPORTED = 7,
CHARLS_JPEGLS_ERRC_JPEG_MARKER_START_BYTE_NOT_FOUND = 12, CHARLS_JPEGLS_ERRC_COLOR_TRANSFORM_NOT_SUPPORTED = 8,
CHARLS_JPEGLS_ERRC_NOT_ENOUGH_MEMORY = 13, CHARLS_JPEGLS_ERRC_JPEGLS_PRESET_EXTENDED_PARAMETER_TYPE_NOT_SUPPORTED = 9,
CHARLS_JPEGLS_ERRC_UNEXPECTED_FAILURE = 14, CHARLS_JPEGLS_ERRC_JPEG_MARKER_START_BYTE_NOT_FOUND = 10,
CHARLS_JPEGLS_ERRC_START_OF_IMAGE_MARKER_NOT_FOUND = 15, CHARLS_JPEGLS_ERRC_START_OF_IMAGE_MARKER_NOT_FOUND = 11,
CHARLS_JPEGLS_ERRC_UNEXPECTED_MARKER_FOUND = 16, CHARLS_JPEGLS_ERRC_INVALID_SPIFF_HEADER = 12,
CHARLS_JPEGLS_ERRC_INVALID_MARKER_SEGMENT_SIZE = 17, CHARLS_JPEGLS_ERRC_UNKNOWN_JPEG_MARKER_FOUND = 13,
CHARLS_JPEGLS_ERRC_DUPLICATE_START_OF_IMAGE_MARKER = 18, CHARLS_JPEGLS_ERRC_UNEXPECTED_MARKER_FOUND = 14,
CHARLS_JPEGLS_ERRC_DUPLICATE_START_OF_FRAME_MARKER = 19, CHARLS_JPEGLS_ERRC_INVALID_MARKER_SEGMENT_SIZE = 15,
CHARLS_JPEGLS_ERRC_DUPLICATE_COMPONENT_ID_IN_SOF_SEGMENT = 20, CHARLS_JPEGLS_ERRC_DUPLICATE_START_OF_IMAGE_MARKER = 16,
CHARLS_JPEGLS_ERRC_UNEXPECTED_END_OF_IMAGE_MARKER = 21, CHARLS_JPEGLS_ERRC_DUPLICATE_START_OF_FRAME_MARKER = 17,
CHARLS_JPEGLS_ERRC_INVALID_JPEGLS_PRESET_PARAMETER_TYPE = 22, CHARLS_JPEGLS_ERRC_DUPLICATE_COMPONENT_ID_IN_SOF_SEGMENT = 18,
CHARLS_JPEGLS_ERRC_JPEGLS_PRESET_EXTENDED_PARAMETER_TYPE_NOT_SUPPORTED = 23, CHARLS_JPEGLS_ERRC_UNEXPECTED_END_OF_IMAGE_MARKER = 19,
CHARLS_JPEGLS_ERRC_MISSING_END_OF_SPIFF_DIRECTORY = 24, CHARLS_JPEGLS_ERRC_INVALID_JPEGLS_PRESET_PARAMETER_TYPE = 20,
CHARLS_JPEGLS_ERRC_UNEXPECTED_RESTART_MARKER = 25, CHARLS_JPEGLS_ERRC_MISSING_END_OF_SPIFF_DIRECTORY = 21,
CHARLS_JPEGLS_ERRC_RESTART_MARKER_NOT_FOUND = 26, CHARLS_JPEGLS_ERRC_UNEXPECTED_RESTART_MARKER = 22,
CHARLS_JPEGLS_ERRC_CALLBACK_FAILED = 27, CHARLS_JPEGLS_ERRC_RESTART_MARKER_NOT_FOUND = 23,
CHARLS_JPEGLS_ERRC_END_OF_IMAGE_MARKER_NOT_FOUND = 28, CHARLS_JPEGLS_ERRC_END_OF_IMAGE_MARKER_NOT_FOUND = 24,
CHARLS_JPEGLS_ERRC_INVALID_SPIFF_HEADER = 29, CHARLS_JPEGLS_ERRC_UNKNOWN_COMPONENT_ID = 25,
CHARLS_JPEGLS_ERRC_UNKNOWN_COMPONENT_ID = 30, CHARLS_JPEGLS_ERRC_ABBREVIATED_FORMAT_AND_SPIFF_HEADER = 26,
CHARLS_JPEGLS_ERRC_MAPPING_TABLES_AND_SPIFF_HEADER = 31, CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_WIDTH = 27,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_WIDTH = 100, CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_HEIGHT = 28,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_HEIGHT = 101, CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_BITS_PER_SAMPLE = 29,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_COMPONENT_COUNT = 102, CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_COMPONENT_COUNT = 30,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_BITS_PER_SAMPLE = 103, CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_INTERLEAVE_MODE = 31,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_INTERLEAVE_MODE = 104, CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_NEAR_LOSSLESS = 32,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_NEAR_LOSSLESS = 105, CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_JPEGLS_PRESET_PARAMETERS = 33,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_JPEGLS_PC_PARAMETERS = 106, CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_COLOR_TRANSFORMATION = 34,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_COLOR_TRANSFORMATION = 107, CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_MAPPING_TABLE_ID = 35,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_SIZE = 108, CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_MAPPING_TABLE_CONTINUATION = 36,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_STRIDE = 109,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_ENCODING_OPTIONS = 110, // Logic errors:
CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_WIDTH = 200,
CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_HEIGHT = 201, CHARLS_JPEGLS_ERRC_INVALID_OPERATION = 100,
CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_COMPONENT_COUNT = 202, CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT = 101,
CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_BITS_PER_SAMPLE = 203, CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_WIDTH = 102,
CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_INTERLEAVE_MODE = 204, CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_HEIGHT = 103,
CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_NEAR_LOSSLESS = 205, CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_BITS_PER_SAMPLE = 104,
CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_JPEGLS_PRESET_PARAMETERS = 206, CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_COMPONENT_COUNT = 105,
CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_COLOR_TRANSFORMATION = 207, CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_INTERLEAVE_MODE = 106,
CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_MAPPING_TABLE_ID = 208, CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_NEAR_LOSSLESS = 107,
CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_MAPPING_TABLE_CONTINUATION = 209 CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_JPEGLS_PC_PARAMETERS = 108,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_COLOR_TRANSFORMATION = 109,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_SIZE = 110,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_STRIDE = 111,
CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_ENCODING_OPTIONS = 112,
}; };
enum charls_interleave_mode enum charls_interleave_mode
@ -189,60 +193,7 @@ enum class [[nodiscard]] jpegls_errc
/// </summary> /// </summary>
success = impl::CHARLS_JPEGLS_ERRC_SUCCESS, success = impl::CHARLS_JPEGLS_ERRC_SUCCESS,
/// <summary> // Runtime errors:
/// This error is returned when one of the passed arguments is invalid.
/// </summary>
invalid_argument = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT,
/// <summary>
/// This error is returned when the JPEG stream contains a parameter value that is not supported by this implementation.
/// </summary>
parameter_value_not_supported = impl::CHARLS_JPEGLS_ERRC_PARAMETER_VALUE_NOT_SUPPORTED,
/// <summary>
/// The destination buffer is too small to hold all the output.
/// </summary>
destination_buffer_too_small = impl::CHARLS_JPEGLS_ERRC_DESTINATION_BUFFER_TOO_SMALL,
/// <summary>
/// The source buffer is too small, more input data was expected.
/// </summary>
source_buffer_too_small = impl::CHARLS_JPEGLS_ERRC_SOURCE_BUFFER_TOO_SMALL,
/// <summary>
/// This error is returned when the encoded bit stream contains a general structural problem.
/// </summary>
invalid_encoded_data = impl::CHARLS_JPEGLS_ERRC_INVALID_ENCODED_DATA,
/// <summary>
/// Too much compressed data.The decoding process is ready but the input buffer still contains encoded data.
/// </summary>
too_much_encoded_data = impl::CHARLS_JPEGLS_ERRC_TOO_MUCH_ENCODED_DATA,
/// <summary>
/// This error is returned when a method call is invalid for the current state.
/// </summary>
invalid_operation = impl::CHARLS_JPEGLS_ERRC_INVALID_OPERATION,
/// <summary>
/// The color transform is not supported.
/// </summary>
color_transform_not_supported = impl::CHARLS_JPEGLS_ERRC_COLOR_TRANSFORM_NOT_SUPPORTED,
/// <summary>
/// This error is returned when an encoded frame is found that is not encoded with the JPEG-LS algorithm.
/// </summary>
encoding_not_supported = impl::CHARLS_JPEGLS_ERRC_ENCODING_NOT_SUPPORTED,
/// <summary>
/// This error is returned when an unknown JPEG marker code is found in the encoded bit stream.
/// </summary>
unknown_jpeg_marker_found = impl::CHARLS_JPEGLS_ERRC_UNKNOWN_JPEG_MARKER_FOUND,
/// <summary>
/// This error is returned when the algorithm expect a 0xFF code (indicates start of a JPEG marker) but none was found.
/// </summary>
jpeg_marker_start_byte_not_found = impl::CHARLS_JPEGLS_ERRC_JPEG_MARKER_START_BYTE_NOT_FOUND,
/// <summary> /// <summary>
/// This error is returned when the implementation could not allocate memory for its internal buffers. /// This error is returned when the implementation could not allocate memory for its internal buffers.
@ -250,16 +201,66 @@ enum class [[nodiscard]] jpegls_errc
not_enough_memory = impl::CHARLS_JPEGLS_ERRC_NOT_ENOUGH_MEMORY, not_enough_memory = impl::CHARLS_JPEGLS_ERRC_NOT_ENOUGH_MEMORY,
/// <summary> /// <summary>
/// This error is returned when the implementation encountered a failure it did not expect. No guarantees can be given /// This error is returned when a callback function returns a nonzero value.
/// for the state after this error.
/// </summary> /// </summary>
unexpected_failure = impl::CHARLS_JPEGLS_ERRC_UNEXPECTED_FAILURE, callback_failed = impl::CHARLS_JPEGLS_ERRC_CALLBACK_FAILED,
/// <summary>
/// The destination buffer is too small to hold all the output.
/// </summary>
destination_too_small = impl::CHARLS_JPEGLS_ERRC_DESTINATION_TOO_SMALL,
/// <summary>
/// The source buffer is too small, more input data was expected.
/// </summary>
need_more_data = impl::CHARLS_JPEGLS_ERRC_NEED_MORE_DATA,
/// <summary>
/// This error is returned when the encoded bit stream contains a general structural problem.
/// </summary>
invalid_data = impl::CHARLS_JPEGLS_ERRC_INVALID_DATA,
/// <summary>
/// This error is returned when an encoded frame is found that is not encoded with the JPEG-LS algorithm.
/// </summary>
encoding_not_supported = impl::CHARLS_JPEGLS_ERRC_ENCODING_NOT_SUPPORTED,
/// <summary>
/// This error is returned when the JPEG stream contains a parameter value that is not supported by this implementation.
/// </summary>
parameter_value_not_supported = impl::CHARLS_JPEGLS_ERRC_PARAMETER_VALUE_NOT_SUPPORTED,
/// <summary>
/// The color transform is not supported.
/// </summary>
color_transform_not_supported = impl::CHARLS_JPEGLS_ERRC_COLOR_TRANSFORM_NOT_SUPPORTED,
/// <summary>
/// This error is returned when the stream contains an unsupported type parameter in the JPEG-LS segment.
/// </summary>
jpegls_preset_extended_parameter_type_not_supported =
impl::CHARLS_JPEGLS_ERRC_JPEGLS_PRESET_EXTENDED_PARAMETER_TYPE_NOT_SUPPORTED,
/// <summary>
/// This error is returned when the algorithm expect a 0xFF code (indicates start of a JPEG marker) but none was found.
/// </summary>
jpeg_marker_start_byte_not_found = impl::CHARLS_JPEGLS_ERRC_JPEG_MARKER_START_BYTE_NOT_FOUND,
/// <summary> /// <summary>
/// This error is returned when the first JPEG marker is not the SOI marker. /// This error is returned when the first JPEG marker is not the SOI marker.
/// </summary> /// </summary>
start_of_image_marker_not_found = impl::CHARLS_JPEGLS_ERRC_START_OF_IMAGE_MARKER_NOT_FOUND, start_of_image_marker_not_found = impl::CHARLS_JPEGLS_ERRC_START_OF_IMAGE_MARKER_NOT_FOUND,
/// <summary>
/// This error is returned when the SPIFF header is invalid.
/// </summary>
invalid_spiff_header = impl::CHARLS_JPEGLS_ERRC_INVALID_SPIFF_HEADER,
/// <summary>
/// This error is returned when an unknown JPEG marker code is found in the encoded bit stream.
/// </summary>
unknown_jpeg_marker_found = impl::CHARLS_JPEGLS_ERRC_UNKNOWN_JPEG_MARKER_FOUND,
/// <summary> /// <summary>
/// This error is returned when a JPEG marker is found that is not valid for the current state. /// This error is returned when a JPEG marker is found that is not valid for the current state.
/// </summary> /// </summary>
@ -295,12 +296,6 @@ enum class [[nodiscard]] jpegls_errc
/// </summary> /// </summary>
invalid_jpegls_preset_parameter_type = impl::CHARLS_JPEGLS_ERRC_INVALID_JPEGLS_PRESET_PARAMETER_TYPE, invalid_jpegls_preset_parameter_type = impl::CHARLS_JPEGLS_ERRC_INVALID_JPEGLS_PRESET_PARAMETER_TYPE,
/// <summary>
/// This error is returned when the stream contains an unsupported type parameter in the JPEG-LS segment.
/// </summary>
jpegls_preset_extended_parameter_type_not_supported =
impl::CHARLS_JPEGLS_ERRC_JPEGLS_PRESET_EXTENDED_PARAMETER_TYPE_NOT_SUPPORTED,
/// <summary> /// <summary>
/// This error is returned when the stream contains a SPIFF header but not an SPIFF end-of-directory entry. /// This error is returned when the stream contains a SPIFF header but not an SPIFF end-of-directory entry.
/// </summary> /// </summary>
@ -317,21 +312,11 @@ enum class [[nodiscard]] jpegls_errc
/// </summary> /// </summary>
restart_marker_not_found = impl::CHARLS_JPEGLS_ERRC_RESTART_MARKER_NOT_FOUND, restart_marker_not_found = impl::CHARLS_JPEGLS_ERRC_RESTART_MARKER_NOT_FOUND,
/// <summary>
/// This error is returned when a callback function returns a nonzero value.
/// </summary>
callback_failed = impl::CHARLS_JPEGLS_ERRC_CALLBACK_FAILED,
/// <summary> /// <summary>
/// This error is returned when the End of Image (EOI) marker could not be found. /// This error is returned when the End of Image (EOI) marker could not be found.
/// </summary> /// </summary>
end_of_image_marker_not_found = impl::CHARLS_JPEGLS_ERRC_END_OF_IMAGE_MARKER_NOT_FOUND, end_of_image_marker_not_found = impl::CHARLS_JPEGLS_ERRC_END_OF_IMAGE_MARKER_NOT_FOUND,
/// <summary>
/// This error is returned when the SPIFF header is invalid.
/// </summary>
invalid_spiff_header = impl::CHARLS_JPEGLS_ERRC_INVALID_SPIFF_HEADER,
/// <summary> /// <summary>
/// This error is returned when an unknown component ID in a scan is detected. /// This error is returned when an unknown component ID in a scan is detected.
/// </summary> /// </summary>
@ -340,7 +325,72 @@ enum class [[nodiscard]] jpegls_errc
/// <summary> /// <summary>
/// This error is returned for stream with only mapping tables and a spiff header. /// This error is returned for stream with only mapping tables and a spiff header.
/// </summary> /// </summary>
mapping_tables_and_spiff_header = impl::CHARLS_JPEGLS_ERRC_MAPPING_TABLES_AND_SPIFF_HEADER, abbreviated_format_and_spiff_header = impl::CHARLS_JPEGLS_ERRC_ABBREVIATED_FORMAT_AND_SPIFF_HEADER,
/// <summary>
/// This error is returned when the stream contains a width parameter defined more than once or in an incompatible way.
/// </summary>
invalid_parameter_width = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_WIDTH,
/// <summary>
/// This error is returned when the stream contains a height parameter defined more than once in an incompatible way.
/// </summary>
invalid_parameter_height = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_HEIGHT,
/// <summary>
/// This error is returned when the stream contains a bits per sample (sample precision) parameter outside the range
/// [2,16]
/// </summary>
invalid_parameter_bits_per_sample = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_BITS_PER_SAMPLE,
/// <summary>
/// This error is returned when the stream contains a component count parameter outside the range [1,255] for SOF or
/// [1,4] for SOS.
/// </summary>
invalid_parameter_component_count = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_COMPONENT_COUNT,
/// <summary>
/// This error is returned when the stream contains an interleave mode (ILV) parameter outside the range [0, 2]
/// </summary>
invalid_parameter_interleave_mode = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_INTERLEAVE_MODE,
/// <summary>
/// This error is returned when the stream contains a near-lossless (NEAR)
/// parameter outside the range [0, min(255, MAXVAL/2)]
/// </summary>
invalid_parameter_near_lossless = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_NEAR_LOSSLESS,
/// <summary>
/// This error is returned when the stream contains an invalid JPEG-LS preset parameters segment.
/// </summary>
invalid_parameter_jpegls_preset_parameters = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_JPEGLS_PRESET_PARAMETERS,
/// <summary>
/// This error is returned when the stream contains an invalid color transformation segment or one that doesn't match with frame info.
/// </summary>
invalid_parameter_color_transformation = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_COLOR_TRANSFORMATION,
/// <summary>
/// This error is returned when the stream contains a mapping table with an invalid ID.
/// </summary>
invalid_parameter_mapping_table_id = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_MAPPING_TABLE_ID,
/// <summary>
/// This error is returned when the stream contains an invalid mapping table continuation.
/// </summary>
invalid_parameter_mapping_table_continuation = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_MAPPING_TABLE_CONTINUATION,
// Logic errors:
/// <summary>
/// This error is returned when a method call is invalid for the current state.
/// </summary>
invalid_operation = impl::CHARLS_JPEGLS_ERRC_INVALID_OPERATION,
/// <summary>
/// This error is returned when one of the passed arguments is invalid.
/// </summary>
invalid_argument = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT,
/// <summary> /// <summary>
/// The argument for the width parameter is outside the range [1, 65535]. /// The argument for the width parameter is outside the range [1, 65535].
@ -352,23 +402,23 @@ enum class [[nodiscard]] jpegls_errc
/// </summary> /// </summary>
invalid_argument_height = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_HEIGHT, invalid_argument_height = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_HEIGHT,
/// <summary>
/// The argument for the component count parameter is outside the range [1, 255].
/// </summary>
invalid_argument_component_count = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_COMPONENT_COUNT,
/// <summary> /// <summary>
/// The argument for the bit per sample parameter is outside the range [2, 16]. /// The argument for the bit per sample parameter is outside the range [2, 16].
/// </summary> /// </summary>
invalid_argument_bits_per_sample = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_BITS_PER_SAMPLE, invalid_argument_bits_per_sample = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_BITS_PER_SAMPLE,
/// <summary>
/// The argument for the component count parameter is outside the range [1, 255].
/// </summary>
invalid_argument_component_count = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_COMPONENT_COUNT,
/// <summary> /// <summary>
/// The argument for the interleave mode is not (None, Sample, Line) or invalid in combination with component count. /// The argument for the interleave mode is not (None, Sample, Line) or invalid in combination with component count.
/// </summary> /// </summary>
invalid_argument_interleave_mode = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_INTERLEAVE_MODE, invalid_argument_interleave_mode = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_INTERLEAVE_MODE,
/// <summary> /// <summary>
/// The argument for the near lossless parameter is outside the range [0, 255]. /// The argument for the near lossless parameter is outside the range [0, min(255, MAXVAL/2)].
/// </summary> /// </summary>
invalid_argument_near_lossless = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_NEAR_LOSSLESS, invalid_argument_near_lossless = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_NEAR_LOSSLESS,
@ -397,59 +447,6 @@ enum class [[nodiscard]] jpegls_errc
/// The encoding options argument has an invalid value. /// The encoding options argument has an invalid value.
/// </summary> /// </summary>
invalid_argument_encoding_options = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_ENCODING_OPTIONS, invalid_argument_encoding_options = impl::CHARLS_JPEGLS_ERRC_INVALID_ARGUMENT_ENCODING_OPTIONS,
/// <summary>
/// This error is returned when the stream contains a width parameter defined more than once or in an incompatible way.
/// </summary>
invalid_parameter_width = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_WIDTH,
/// <summary>
/// This error is returned when the stream contains a height parameter defined more than once in an incompatible way.
/// </summary>
invalid_parameter_height = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_HEIGHT,
/// <summary>
/// This error is returned when the stream contains a component count parameter outside the range [1,255] for SOF or
/// [1,4] for SOS.
/// </summary>
invalid_parameter_component_count = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_COMPONENT_COUNT,
/// <summary>
/// This error is returned when the stream contains a bits per sample (sample precision) parameter outside the range
/// [2,16]
/// </summary>
invalid_parameter_bits_per_sample = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_BITS_PER_SAMPLE,
/// <summary>
/// This error is returned when the stream contains an interleave mode (ILV) parameter outside the range [0, 2]
/// </summary>
invalid_parameter_interleave_mode = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_INTERLEAVE_MODE,
/// <summary>
/// This error is returned when the stream contains a near-lossless (NEAR) parameter outside the range [0, min(255,
/// MAXVAL/2)]
/// </summary>
invalid_parameter_near_lossless = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_NEAR_LOSSLESS,
/// <summary>
/// This error is returned when the stream contains an invalid JPEG-LS preset parameters segment.
/// </summary>
invalid_parameter_jpegls_preset_parameters = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_JPEGLS_PRESET_PARAMETERS,
/// <summary>
/// This error is returned when the stream contains an invalid color transformation segment or one that doesn't match with frame info.
/// </summary>
invalid_parameter_color_transformation = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_COLOR_TRANSFORMATION,
/// <summary>
/// This error is returned when the stream contains a mapping table with an invalid ID.
/// </summary>
invalid_parameter_mapping_table_id = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_MAPPING_TABLE_ID,
/// <summary>
/// This error is returned when the stream contains an invalid mapping table continuation.
/// </summary>
invalid_parameter_mapping_table_continuation = impl::CHARLS_JPEGLS_ERRC_INVALID_PARAMETER_MAPPING_TABLE_CONTINUATION
}; };

3
spelling.dic
View File

@ -15,3 +15,6 @@ cppcoreguidelines
mrfx mrfx
subspan subspan
cppcoreguidelines cppcoreguidelines
uint
json
intrinsics

2
src/charls_jpegls_decoder.cpp
View File

@ -191,7 +191,7 @@ struct charls_jpegls_decoder final
: 1U}; : 1U};
if (const size_t minimum_destination_size = bytes_per_plane * plane_count - (stride - minimum_stride); if (const size_t minimum_destination_size = bytes_per_plane * plane_count - (stride - minimum_stride);
UNLIKELY(destination.size() < minimum_destination_size)) UNLIKELY(destination.size() < minimum_destination_size))
throw_jpegls_error(jpegls_errc::destination_buffer_too_small); throw_jpegls_error(jpegls_errc::destination_too_small);
for (size_t plane{};;) for (size_t plane{};;)
{ {

12
src/charls_jpegls_encoder.cpp
View File

@ -90,12 +90,12 @@ struct charls_jpegls_encoder final
color_transformation_ = color_transformation; color_transformation_ = color_transformation;
} }
void set_table_id(const int32_t component_index, const int32_t table_id) void set_mapping_table_id(const int32_t component_index, const int32_t table_id)
{ {
check_argument_range(minimum_component_index, maximum_component_index, component_index); check_argument_range(minimum_component_index, maximum_component_index, component_index);
check_argument_range(0, maximum_table_id, table_id); check_argument_range(0, maximum_table_id, table_id);
writer_.set_table_id(static_cast<size_t>(component_index), table_id); writer_.set_mapping_table_id(static_cast<size_t>(component_index), table_id);
} }
[[nodiscard]] [[nodiscard]]
@ -223,7 +223,7 @@ struct charls_jpegls_encoder final
write_end_of_image(); write_end_of_image();
} }
void create_tables_only() void create_abbreviated_format()
{ {
check_operation(state_ == state::tables_and_miscellaneous); check_operation(state_ == state::tables_and_miscellaneous);
write_end_of_image(); write_end_of_image();
@ -507,11 +507,11 @@ catch (...)
} }
USE_DECL_ANNOTATIONS jpegls_errc CHARLS_API_CALLING_CONVENTION charls_jpegls_encoder_set_table_id( USE_DECL_ANNOTATIONS jpegls_errc CHARLS_API_CALLING_CONVENTION charls_jpegls_encoder_set_mapping_table_id(
charls_jpegls_encoder* encoder, const int32_t component_index, const int32_t table_id) noexcept charls_jpegls_encoder* encoder, const int32_t component_index, const int32_t table_id) noexcept
try try
{ {
check_pointer(encoder)->set_table_id(component_index, table_id); check_pointer(encoder)->set_mapping_table_id(component_index, table_id);
return jpegls_errc::success; return jpegls_errc::success;
} }
catch (...) catch (...)
@ -650,7 +650,7 @@ USE_DECL_ANNOTATIONS charls_jpegls_errc CHARLS_API_CALLING_CONVENTION
charls_jpegls_encoder_create_abbreviated_format(charls_jpegls_encoder* encoder) noexcept charls_jpegls_encoder_create_abbreviated_format(charls_jpegls_encoder* encoder) noexcept
try try
{ {
check_pointer(encoder)->create_tables_only(); check_pointer(encoder)->create_abbreviated_format();
return jpegls_errc::success; return jpegls_errc::success;
} }
catch (...) catch (...)

6
src/jpeg_stream_reader.cpp
View File

@ -283,7 +283,7 @@ void jpeg_stream_reader::get_mapping_table_data(const size_t index, const span<b
{ {
const auto& mapping_table{mapping_tables_[index]}; const auto& mapping_table{mapping_tables_[index]};
if (mapping_table.data_size() > table.size()) if (mapping_table.data_size() > table.size())
throw_jpegls_error(jpegls_errc::destination_buffer_too_small); throw_jpegls_error(jpegls_errc::destination_too_small);
mapping_table.copy(table.data()); mapping_table.copy(table.data());
} }
@ -581,7 +581,7 @@ void jpeg_stream_reader::read_start_of_scan_segment()
byte jpeg_stream_reader::read_byte_checked() byte jpeg_stream_reader::read_byte_checked()
{ {
if (UNLIKELY(position_ == end_position_)) if (UNLIKELY(position_ == end_position_))
throw_jpegls_error(jpegls_errc::source_buffer_too_small); throw_jpegls_error(jpegls_errc::need_more_data);
return read_byte(); return read_byte();
} }
@ -590,7 +590,7 @@ byte jpeg_stream_reader::read_byte_checked()
uint16_t jpeg_stream_reader::read_uint16_checked() uint16_t jpeg_stream_reader::read_uint16_checked()
{ {
if (UNLIKELY(position_ + sizeof(uint16_t) > end_position_)) if (UNLIKELY(position_ + sizeof(uint16_t) > end_position_))
throw_jpegls_error(jpegls_errc::source_buffer_too_small); throw_jpegls_error(jpegls_errc::need_more_data);
return read_uint16(); return read_uint16();
} }

2
src/jpeg_stream_reader.h
View File

@ -184,7 +184,7 @@ private:
{ {
if (state_ == state::frame_section) if (state_ == state::frame_section)
{ {
impl::throw_jpegls_error(jpegls_errc::mapping_tables_and_spiff_header); impl::throw_jpegls_error(jpegls_errc::abbreviated_format_and_spiff_header);
} }
// ISO/IEC 14495-1, Annex C defines 3 data formats. // ISO/IEC 14495-1, Annex C defines 3 data formats.

2
src/jpeg_stream_writer.cpp
View File

@ -234,7 +234,7 @@ void jpeg_stream_writer::write_segment_header(const jpeg_marker_code marker_code
constexpr size_t marker_code_size{2}; constexpr size_t marker_code_size{2};
if (const size_t total_segment_size{marker_code_size + segment_length_size + data_size}; if (const size_t total_segment_size{marker_code_size + segment_length_size + data_size};
UNLIKELY(byte_offset_ + total_segment_size > destination_.size())) UNLIKELY(byte_offset_ + total_segment_size > destination_.size()))
impl::throw_jpegls_error(jpegls_errc::destination_buffer_too_small); impl::throw_jpegls_error(jpegls_errc::destination_too_small);
write_marker(marker_code); write_marker(marker_code);
write_uint16(static_cast<uint16_t>(segment_length_size + data_size)); write_uint16(static_cast<uint16_t>(segment_length_size + data_size));

4
src/jpeg_stream_writer.h
View File

@ -131,7 +131,7 @@ public:
component_index_ = 0; component_index_ = 0;
} }
void set_table_id(const size_t component_index, const int32_t table_id) void set_mapping_table_id(const size_t component_index, const int32_t table_id)
{ {
ASSERT(component_index < maximum_component_count); ASSERT(component_index < maximum_component_count);
ASSERT(0 <= table_id && table_id <= maximum_table_id); ASSERT(0 <= table_id && table_id <= maximum_table_id);
@ -153,7 +153,7 @@ private:
void write_segment_without_data(const jpeg_marker_code marker_code) void write_segment_without_data(const jpeg_marker_code marker_code)
{ {
if (UNLIKELY(byte_offset_ + 2 > destination_.size())) if (UNLIKELY(byte_offset_ + 2 > destination_.size()))
impl::throw_jpegls_error(jpegls_errc::destination_buffer_too_small); impl::throw_jpegls_error(jpegls_errc::destination_too_small);
write_marker(marker_code); write_marker(marker_code);
} }

153
src/jpegls_error.cpp
View File

@ -42,46 +42,48 @@ const char* CHARLS_API_CALLING_CONVENTION charls_get_error_message(const charls_
case jpegls_errc::success: case jpegls_errc::success:
return "Success"; return "Success";
case jpegls_errc::invalid_argument: // Runtime errors:
return "Invalid argument";
case jpegls_errc::invalid_argument_width: case jpegls_errc::not_enough_memory:
return "The width argument is outside the supported range [1, 4294967295]"; return "No memory could be allocated for an internal buffer";
case jpegls_errc::invalid_argument_height: case jpegls_errc::callback_failed:
return "The height argument is outside the supported range [1, 4294967295]"; return "Callback function returned a failure";
case jpegls_errc::invalid_argument_component_count: case jpegls_errc::destination_too_small:
return "The component count argument is outside the range [1, 255]"; return "The destination buffer is too small to hold all the output";
case jpegls_errc::invalid_argument_bits_per_sample: case jpegls_errc::need_more_data:
return "The bit per sample argument is outside the range [2, 16]"; return "The source buffer is too small, more input data was expected";
case jpegls_errc::invalid_argument_interleave_mode: case jpegls_errc::invalid_data:
return "The interleave mode is not None, Sample, Line) or invalid in combination with component count"; return "Invalid JPEG-LS stream, the encoded bit stream contains a general structural problem";
case jpegls_errc::invalid_argument_near_lossless: case jpegls_errc::encoding_not_supported:
return "The near lossless argument is outside the range [0, 255]"; return "Invalid JPEG-LS stream: the JPEG stream is not encoded with the JPEG-LS algorithm";
case jpegls_errc::invalid_argument_size: case jpegls_errc::parameter_value_not_supported:
return "The passed size is outside the valid range"; return "The JPEG-LS stream is encoded with a parameter value that is not supported by the CharLS decoder";
case jpegls_errc::invalid_argument_color_transformation: case jpegls_errc::color_transform_not_supported:
return "The argument for the color component is not (None, Hp1, Hp2, Hp3) or invalid in combination with component " return "The color transform is not supported";
"count";
case jpegls_errc::invalid_argument_jpegls_pc_parameters: case jpegls_errc::jpegls_preset_extended_parameter_type_not_supported:
return "The argument for the JPEG-LS preset coding parameters is not valid"; return "Unsupported JPEG-LS stream: JPEG-LS preset parameters segment contains a JPEG-LS Extended (ISO/IEC "
"14495-2) type";
case jpegls_errc::invalid_argument_stride: case jpegls_errc::jpeg_marker_start_byte_not_found:
return "The stride argument does not match with the frame info and buffer size"; return "Invalid JPEG-LS stream: the leading start byte (0xFF) for a JPEG marker was not found";
case jpegls_errc::invalid_argument_encoding_options:
return "The encoding options argument has an invalid value";
case jpegls_errc::start_of_image_marker_not_found: case jpegls_errc::start_of_image_marker_not_found:
return "Invalid JPEG-LS stream: first JPEG marker is not a Start Of Image (SOI) marker"; return "Invalid JPEG-LS stream: first JPEG marker is not a Start Of Image (SOI) marker";
case jpegls_errc::invalid_spiff_header:
return "Invalid JPEG-LS stream: invalid SPIFF header";
case jpegls_errc::unknown_jpeg_marker_found:
return "Invalid JPEG-LS stream: an unknown JPEG marker code was found";
case jpegls_errc::unexpected_marker_found: case jpegls_errc::unexpected_marker_found:
return "Invalid JPEG-LS stream: unexpected marker found"; return "Invalid JPEG-LS stream: unexpected marker found";
@ -103,10 +105,6 @@ const char* CHARLS_API_CALLING_CONVENTION charls_get_error_message(const charls_
case jpegls_errc::invalid_jpegls_preset_parameter_type: case jpegls_errc::invalid_jpegls_preset_parameter_type:
return "Invalid JPEG-LS stream: JPEG-LS preset parameters segment contains an invalid type"; return "Invalid JPEG-LS stream: JPEG-LS preset parameters segment contains an invalid type";
case jpegls_errc::jpegls_preset_extended_parameter_type_not_supported:
return "Unsupported JPEG-LS stream: JPEG-LS preset parameters segment contains a JPEG-LS Extended (ISO/IEC "
"14495-2) type";
case jpegls_errc::missing_end_of_spiff_directory: case jpegls_errc::missing_end_of_spiff_directory:
return "Invalid JPEG-LS stream: SPIFF header without End Of Directory (EOD) entry"; return "Invalid JPEG-LS stream: SPIFF header without End Of Directory (EOD) entry";
@ -116,66 +114,24 @@ const char* CHARLS_API_CALLING_CONVENTION charls_get_error_message(const charls_
case jpegls_errc::restart_marker_not_found: case jpegls_errc::restart_marker_not_found:
return "Invalid JPEG-LS stream: missing expected restart (RTSm) marker"; return "Invalid JPEG-LS stream: missing expected restart (RTSm) marker";
case jpegls_errc::callback_failed:
return "Callback function returned a failure";
case jpegls_errc::end_of_image_marker_not_found: case jpegls_errc::end_of_image_marker_not_found:
return "Invalid JPEG-LS stream: missing End Of Image (EOI) marker"; return "Invalid JPEG-LS stream: missing End Of Image (EOI) marker";
case jpegls_errc::invalid_spiff_header:
return "Invalid JPEG-LS stream: invalid SPIFF header";
case jpegls_errc::unknown_component_id: case jpegls_errc::unknown_component_id:
return "Invalid JPEG-LS stream: unknown component ID in scan segment"; return "Invalid JPEG-LS stream: unknown component ID in scan segment";
case jpegls_errc::mapping_tables_and_spiff_header: case jpegls_errc::abbreviated_format_and_spiff_header:
return "Invalid JPEG-LS stream: mapping tables without SOF but with spiff header"; return "Invalid JPEG-LS stream: mapping tables without SOF but with spiff header";
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]";
case jpegls_errc::parameter_value_not_supported:
return "The JPEG-LS stream is encoded with a parameter value that is not supported by the CharLS decoder";
case jpegls_errc::destination_buffer_too_small:
return "The destination buffer is too small to hold all the output";
case jpegls_errc::source_buffer_too_small:
return "The source buffer is too small, more input data was expected";
case jpegls_errc::invalid_encoded_data:
return "Invalid JPEG-LS stream, the encoded bit stream contains a general structural problem";
case jpegls_errc::too_much_encoded_data:
return "Invalid JPEG-LS stream, the decoding process is ready but the source buffer still contains encoded data";
case jpegls_errc::invalid_operation:
return "Method call is invalid for the current state";
case jpegls_errc::color_transform_not_supported:
return "The color transform is not supported";
case jpegls_errc::encoding_not_supported:
return "Invalid JPEG-LS stream: the JPEG stream is not encoded with the JPEG-LS algorithm";
case jpegls_errc::unknown_jpeg_marker_found:
return "Invalid JPEG-LS stream: an unknown JPEG marker code was found";
case jpegls_errc::jpeg_marker_start_byte_not_found:
return "Invalid JPEG-LS stream: the leading start byte (0xFF) for a JPEG marker was not found";
case jpegls_errc::not_enough_memory:
return "No memory could be allocated for an internal buffer";
case jpegls_errc::unexpected_failure:
return "An unexpected internal failure occurred";
case jpegls_errc::invalid_parameter_width: case jpegls_errc::invalid_parameter_width:
return "Invalid JPEG-LS stream: the width (Number of samples per line) is already defined"; return "Invalid JPEG-LS stream: the width (Number of samples per line) is already defined";
case jpegls_errc::invalid_parameter_height: case jpegls_errc::invalid_parameter_height:
return "Invalid JPEG-LS stream: the height (Number of lines) is already defined"; return "Invalid JPEG-LS stream: the height (Number of lines) is already defined";
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]";
case jpegls_errc::invalid_parameter_component_count: case jpegls_errc::invalid_parameter_component_count:
return "Invalid JPEG-LS stream: component count in the SOF segment is outside the range [1, 255]"; return "Invalid JPEG-LS stream: component count in the SOF segment is outside the range [1, 255]";
@ -189,13 +145,56 @@ const char* CHARLS_API_CALLING_CONVENTION charls_get_error_message(const charls_
return "Invalid JPEG-LS stream: JPEG-LS preset parameters segment contains invalid values"; return "Invalid JPEG-LS stream: JPEG-LS preset parameters segment contains invalid values";
case jpegls_errc::invalid_parameter_color_transformation: case jpegls_errc::invalid_parameter_color_transformation:
return "Invalid JPEG-LS stream: Color transformation segment contains invalid values or doesn't match with frame info"; return "Invalid JPEG-LS stream: Color transformation segment contains invalid values or doesn't match with frame "
"info";
case jpegls_errc::invalid_parameter_mapping_table_id: case jpegls_errc::invalid_parameter_mapping_table_id:
return "Invalid JPEG-LS stream: mapping table ID outside valid range or duplicate"; return "Invalid JPEG-LS stream: mapping table ID outside valid range or duplicate";
case jpegls_errc::invalid_parameter_mapping_table_continuation: case jpegls_errc::invalid_parameter_mapping_table_continuation:
return "Invalid JPEG-LS stream: mapping table continuation without matching mapping table specification"; return "Invalid JPEG-LS stream: mapping table continuation without matching mapping table specification";
// Logic errors:
case jpegls_errc::invalid_operation:
return "Method call is invalid for the current state";
case jpegls_errc::invalid_argument:
return "Invalid argument";
case jpegls_errc::invalid_argument_width:
return "The width argument is outside the supported range [1, 4294967295]";
case jpegls_errc::invalid_argument_height:
return "The height argument is outside the supported range [1, 4294967295]";
case jpegls_errc::invalid_argument_bits_per_sample:
return "The bit per sample argument is outside the range [2, 16]";
case jpegls_errc::invalid_argument_component_count:
return "The component count argument is outside the range [1, 255]";
case jpegls_errc::invalid_argument_interleave_mode:
return "The interleave mode is not None, Sample, Line) or invalid in combination with component count";
case jpegls_errc::invalid_argument_near_lossless:
return "The near lossless argument is outside the range [0, min(255, MAXVAL/2)]";
case jpegls_errc::invalid_argument_size:
return "The passed size is outside the valid range";
case jpegls_errc::invalid_argument_jpegls_pc_parameters:
return "The argument for the JPEG-LS preset coding parameters is not valid";
case jpegls_errc::invalid_argument_color_transformation:
return "The argument for the color component is not (None, Hp1, Hp2, Hp3) or invalid in combination with component "
"count";
case jpegls_errc::invalid_argument_stride:
return "The stride argument does not match with the frame info and buffer size";
case jpegls_errc::invalid_argument_encoding_options:
return "The encoding options argument has an invalid value";
} }
return "Unknown"; return "Unknown";

4
src/regular_mode_context.h
View File

@ -50,7 +50,7 @@ public:
b_ += error_value * (2 * near_lossless + 1); b_ += error_value * (2 * near_lossless + 1);
if (constexpr int limit{65536 * 256}; UNLIKELY(a_ >= limit || std::abs(b_) >= limit)) if (constexpr int limit{65536 * 256}; UNLIKELY(a_ >= limit || std::abs(b_) >= limit))
impl::throw_jpegls_error(jpegls_errc::invalid_encoded_data); impl::throw_jpegls_error(jpegls_errc::invalid_data);
if (n_ == reset_threshold) if (n_ == reset_threshold)
{ {
@ -104,7 +104,7 @@ public:
} }
if (UNLIKELY(k == max_k_value)) if (UNLIKELY(k == max_k_value))
impl::throw_jpegls_error(jpegls_errc::invalid_encoded_data); impl::throw_jpegls_error(jpegls_errc::invalid_data);
return k; return k;
} }

16
src/scan_decoder.h
View File

@ -70,21 +70,21 @@ protected:
void end_scan() void end_scan()
{ {
if (UNLIKELY(position_ >= end_position_)) if (UNLIKELY(position_ >= end_position_))
impl::throw_jpegls_error(jpegls_errc::source_buffer_too_small); impl::throw_jpegls_error(jpegls_errc::need_more_data);
if (*position_ != jpeg_marker_start_byte) if (*position_ != jpeg_marker_start_byte)
{ {
read_bit(); read_bit();
if (UNLIKELY(position_ >= end_position_)) if (UNLIKELY(position_ >= end_position_))
impl::throw_jpegls_error(jpegls_errc::source_buffer_too_small); impl::throw_jpegls_error(jpegls_errc::need_more_data);
if (UNLIKELY(*position_ != jpeg_marker_start_byte)) if (UNLIKELY(*position_ != jpeg_marker_start_byte))
impl::throw_jpegls_error(jpegls_errc::too_much_encoded_data); impl::throw_jpegls_error(jpegls_errc::invalid_data);
} }
if (UNLIKELY(read_cache_ != 0)) if (UNLIKELY(read_cache_ != 0))
impl::throw_jpegls_error(jpegls_errc::too_much_encoded_data); impl::throw_jpegls_error(jpegls_errc::invalid_data);
} }
[[nodiscard]] [[nodiscard]]
@ -127,7 +127,7 @@ protected:
{ {
fill_read_cache(); fill_read_cache();
if (UNLIKELY(valid_bits_ < bit_count)) if (UNLIKELY(valid_bits_ < bit_count))
impl::throw_jpegls_error(jpegls_errc::invalid_encoded_data); impl::throw_jpegls_error(jpegls_errc::invalid_data);
} }
ASSERT(bit_count <= valid_bits_); ASSERT(bit_count <= valid_bits_);
@ -209,7 +209,7 @@ protected:
std::byte read_byte() std::byte read_byte()
{ {
if (UNLIKELY(position_ == end_position_)) if (UNLIKELY(position_ == end_position_))
impl::throw_jpegls_error(jpegls_errc::source_buffer_too_small); impl::throw_jpegls_error(jpegls_errc::need_more_data);
const std::byte value = *position_; const std::byte value = *position_;
++position_; ++position_;
@ -251,7 +251,7 @@ private:
if (UNLIKELY(valid_bits_ == 0)) if (UNLIKELY(valid_bits_ == 0))
{ {
// Decoding process expects at least some bits to be added to the cache. // Decoding process expects at least some bits to be added to the cache.
impl::throw_jpegls_error(jpegls_errc::invalid_encoded_data); impl::throw_jpegls_error(jpegls_errc::invalid_data);
} }
return; return;
@ -266,7 +266,7 @@ private:
if (UNLIKELY(valid_bits_ <= 0)) if (UNLIKELY(valid_bits_ <= 0))
{ {
// Decoding process expects at least some bits to be added to the cache. // Decoding process expects at least some bits to be added to the cache.
impl::throw_jpegls_error(jpegls_errc::invalid_encoded_data); impl::throw_jpegls_error(jpegls_errc::invalid_data);
} }
// End of buffer or marker detected. Typical found markers are EOI, SOS (next scan) or RSTm. // End of buffer or marker detected. Typical found markers are EOI, SOS (next scan) or RSTm.

4
src/scan_decoder_impl.h
View File

@ -291,7 +291,7 @@ private:
{ {
error_value = unmap_error_value(decode_value(k, traits_.limit, traits_.quantized_bits_per_sample)); error_value = unmap_error_value(decode_value(k, traits_.limit, traits_.quantized_bits_per_sample));
if (UNLIKELY(std::abs(error_value) > 65535)) if (UNLIKELY(std::abs(error_value) > 65535))
impl::throw_jpegls_error(jpegls_errc::invalid_encoded_data); impl::throw_jpegls_error(jpegls_errc::invalid_data);
} }
if (k == 0) if (k == 0)
@ -380,7 +380,7 @@ private:
} }
if (UNLIKELY(index > pixel_count)) if (UNLIKELY(index > pixel_count))
impl::throw_jpegls_error(jpegls_errc::invalid_encoded_data); impl::throw_jpegls_error(jpegls_errc::invalid_data);
for (int32_t i{}; i < index; ++i) for (int32_t i{}; i < index; ++i)
{ {

2
src/scan_encoder.h
View File

@ -113,7 +113,7 @@ protected:
void flush() void flush()
{ {
if (UNLIKELY(compressed_length_ < 4)) if (UNLIKELY(compressed_length_ < 4))
impl::throw_jpegls_error(jpegls_errc::destination_buffer_too_small); impl::throw_jpegls_error(jpegls_errc::destination_too_small);
for (int i{}; i < 4; ++i) for (int i{}; i < 4; ++i)
{ {

8
src/util.h
View File

@ -86,7 +86,7 @@
namespace charls { namespace charls {
inline jpegls_errc to_jpegls_errc() noexcept inline CHARLS_NO_INLINE jpegls_errc to_jpegls_errc() noexcept
{ {
try try
{ {
@ -101,10 +101,8 @@ inline jpegls_errc to_jpegls_errc() noexcept
{ {
return jpegls_errc::not_enough_memory; return jpegls_errc::not_enough_memory;
} }
catch (...)
{ // Don't catch exceptions that are not expected: it is safer to terminate then continue in an unknown state.
return jpegls_errc::unexpected_failure;
}
} }

6
test/bitstreamdamage.cpp
View File

@ -35,7 +35,7 @@ void test_damaged_bit_stream1()
error = e.code(); error = e.code();
} }
assert::is_true(error == jpegls_errc::invalid_encoded_data); assert::is_true(error == jpegls_errc::invalid_data);
} }
@ -58,7 +58,7 @@ void test_damaged_bit_stream2()
error = e.code(); error = e.code();
} }
assert::is_true(error == jpegls_errc::invalid_encoded_data); assert::is_true(error == jpegls_errc::invalid_data);
} }
@ -81,7 +81,7 @@ void test_damaged_bit_stream3()
error = e.code(); error = e.code();
} }
assert::is_true(error == jpegls_errc::invalid_encoded_data); assert::is_true(error == jpegls_errc::invalid_data);
} }

6
test/main.cpp
View File

@ -254,7 +254,7 @@ void test_fail_on_too_small_output_buffer()
} }
catch (const jpegls_error& e) catch (const jpegls_error& e)
{ {
assert::is_true(e.code() == jpegls_errc::destination_buffer_too_small); assert::is_true(e.code() == jpegls_errc::destination_too_small);
} }
// Trigger a "destination buffer too small" when writing the encoded pixel bytes. // Trigger a "destination buffer too small" when writing the encoded pixel bytes.
@ -269,7 +269,7 @@ void test_fail_on_too_small_output_buffer()
} }
catch (const jpegls_error& e) catch (const jpegls_error& e)
{ {
assert::is_true(e.code() == jpegls_errc::destination_buffer_too_small); assert::is_true(e.code() == jpegls_errc::destination_too_small);
} }
} }
@ -292,7 +292,7 @@ void test_too_small_output_buffer()
error = e.code(); error = e.code();
} }
assert::is_true(error == jpegls_errc::destination_buffer_too_small); assert::is_true(error == jpegls_errc::destination_too_small);
} }

4
unittest/charls_jpegls_decoder_test.cpp
View File

@ -160,7 +160,7 @@ public:
Assert::AreEqual(jpegls_errc::success, error); Assert::AreEqual(jpegls_errc::success, error);
error = charls_jpegls_decoder_read_header(decoder); error = charls_jpegls_decoder_read_header(decoder);
Assert::AreEqual(jpegls_errc::source_buffer_too_small, error); Assert::AreEqual(jpegls_errc::need_more_data, error);
charls_jpegls_decoder_destroy(decoder); charls_jpegls_decoder_destroy(decoder);
} }
@ -170,7 +170,7 @@ public:
auto decoder{get_initialized_decoder()}; auto decoder{get_initialized_decoder()};
const auto error{charls_jpegls_decoder_decode_to_buffer(decoder.get(), nullptr, 0, 0)}; const auto error{charls_jpegls_decoder_decode_to_buffer(decoder.get(), nullptr, 0, 0)};
Assert::AreEqual(jpegls_errc::destination_buffer_too_small, error); Assert::AreEqual(jpegls_errc::destination_too_small, error);
} }
TEST_METHOD(at_comment_nullptr) // NOLINT TEST_METHOD(at_comment_nullptr) // NOLINT

6
unittest/charls_jpegls_encoder_test.cpp
View File

@ -89,7 +89,7 @@ public:
TEST_METHOD(charls_jpegls_encoder_set_table_id_nullptr) // NOLINT TEST_METHOD(charls_jpegls_encoder_set_table_id_nullptr) // NOLINT
{ {
const auto error{charls_jpegls_encoder_set_table_id(nullptr, 0, 0)}; const auto error{charls_jpegls_encoder_set_mapping_table_id(nullptr, 0, 0)};
Assert::AreEqual(jpegls_errc::invalid_argument, error); Assert::AreEqual(jpegls_errc::invalid_argument, error);
} }
@ -210,7 +210,7 @@ public:
constexpr array<byte, 10> buffer{}; constexpr array<byte, 10> buffer{};
error = charls_jpegls_encoder_encode_from_buffer(encoder, buffer.data(), buffer.size(), 0); error = charls_jpegls_encoder_encode_from_buffer(encoder, buffer.data(), buffer.size(), 0);
Assert::AreEqual(jpegls_errc::destination_buffer_too_small, error); Assert::AreEqual(jpegls_errc::destination_too_small, error);
charls_jpegls_encoder_destroy(encoder); charls_jpegls_encoder_destroy(encoder);
} }
@ -228,7 +228,7 @@ public:
Assert::AreEqual(jpegls_errc::success, error); Assert::AreEqual(jpegls_errc::success, error);
error = charls_jpegls_encoder_encode_from_buffer(encoder, nullptr, 0, 0); error = charls_jpegls_encoder_encode_from_buffer(encoder, nullptr, 0, 0);
Assert::AreEqual(jpegls_errc::destination_buffer_too_small, error); Assert::AreEqual(jpegls_errc::destination_too_small, error);
charls_jpegls_encoder_destroy(encoder); charls_jpegls_encoder_destroy(encoder);
} }

8
unittest/jpeg_stream_reader_test.cpp
View File

@ -30,7 +30,7 @@ public:
jpeg_stream_reader reader; jpeg_stream_reader reader;
reader.source({buffer.data(), 0}); reader.source({buffer.data(), 0});
assert_expect_exception(jpegls_errc::source_buffer_too_small, [&reader] { reader.read_header(); }); assert_expect_exception(jpegls_errc::need_more_data, [&reader] { reader.read_header(); });
} }
TEST_METHOD(read_header_from_buffer_preceded_with_fill_bytes) // NOLINT TEST_METHOD(read_header_from_buffer_preceded_with_fill_bytes) // NOLINT
@ -589,7 +589,7 @@ public:
}, },
&called}); &called});
assert_expect_exception(jpegls_errc::source_buffer_too_small, [&reader] { reader.read_header(); }); assert_expect_exception(jpegls_errc::need_more_data, [&reader] { reader.read_header(); });
Assert::IsFalse(called); Assert::IsFalse(called);
} }
@ -682,7 +682,7 @@ public:
}, },
&called}); &called});
assert_expect_exception(jpegls_errc::source_buffer_too_small, [&reader] { reader.read_header(); }); assert_expect_exception(jpegls_errc::need_more_data, [&reader] { reader.read_header(); });
Assert::IsFalse(called); Assert::IsFalse(called);
} }
@ -734,7 +734,7 @@ public:
reader.source({source.data(), source.size()}); reader.source({source.data(), source.size()});
reader.read_header(); reader.read_header();
assert_expect_exception(jpegls_errc::destination_buffer_too_small, [&reader] { assert_expect_exception(jpegls_errc::destination_too_small, [&reader] {
vector<byte> table_data(1); vector<byte> table_data(1);
reader.get_mapping_table_data(0, {table_data.data(), table_data.size()}); reader.get_mapping_table_data(0, {table_data.data(), table_data.size()});
}); });

10
unittest/jpeg_stream_writer_test.cpp
View File

@ -48,7 +48,7 @@ public:
jpeg_stream_writer writer; jpeg_stream_writer writer;
writer.destination({buffer.data(), buffer.size()}); writer.destination({buffer.data(), buffer.size()});
assert_expect_exception(jpegls_errc::destination_buffer_too_small, [&writer] { writer.write_start_of_image(); }); assert_expect_exception(jpegls_errc::destination_too_small, [&writer] { writer.write_start_of_image(); });
Assert::AreEqual(size_t{}, writer.bytes_written()); Assert::AreEqual(size_t{}, writer.bytes_written());
} }
@ -127,7 +127,7 @@ public:
jpeg_stream_writer writer; jpeg_stream_writer writer;
writer.destination({buffer.data(), buffer.size()}); writer.destination({buffer.data(), buffer.size()});
assert_expect_exception(jpegls_errc::destination_buffer_too_small, [&writer] { writer.write_end_of_image(false); }); assert_expect_exception(jpegls_errc::destination_too_small, [&writer] { writer.write_end_of_image(false); });
Assert::AreEqual(size_t{}, writer.bytes_written()); Assert::AreEqual(size_t{}, writer.bytes_written());
} }
@ -220,7 +220,7 @@ public:
96, 96,
1024}; 1024};
assert_expect_exception(jpegls_errc::destination_buffer_too_small, assert_expect_exception(jpegls_errc::destination_too_small,
[&writer, &header] { writer.write_spiff_header_segment(header); }); [&writer, &header] { writer.write_spiff_header_segment(header); });
Assert::AreEqual(size_t{}, writer.bytes_written()); Assert::AreEqual(size_t{}, writer.bytes_written());
} }
@ -537,7 +537,7 @@ public:
array<byte, 10> buffer{}; array<byte, 10> buffer{};
jpeg_stream_writer writer; jpeg_stream_writer writer;
writer.destination({buffer.data(), buffer.size()}); writer.destination({buffer.data(), buffer.size()});
writer.set_table_id(0, 77); writer.set_mapping_table_id(0, 77);
writer.write_start_of_scan_segment(1, 2, interleave_mode::none); writer.write_start_of_scan_segment(1, 2, interleave_mode::none);
@ -555,7 +555,7 @@ public:
array<byte, 10> buffer{}; array<byte, 10> buffer{};
jpeg_stream_writer writer; jpeg_stream_writer writer;
writer.destination({buffer.data(), buffer.size()}); writer.destination({buffer.data(), buffer.size()});
writer.set_table_id(0, 77); writer.set_mapping_table_id(0, 77);
writer.rewind(); writer.rewind();
writer.write_start_of_scan_segment(1, 2, interleave_mode::none); writer.write_start_of_scan_segment(1, 2, interleave_mode::none);

16
unittest/jpegls_decoder_test.cpp
View File

@ -598,7 +598,7 @@ public:
vector<byte> destination(decoder.destination_size()); vector<byte> destination(decoder.destination_size());
assert_expect_exception(jpegls_errc::invalid_encoded_data, assert_expect_exception(jpegls_errc::invalid_data,
[&decoder, &destination] { decoder.decode(destination); }); [&decoder, &destination] { decoder.decode(destination); });
} }
@ -616,7 +616,7 @@ public:
jpegls_decoder decoder{source, true}; jpegls_decoder decoder{source, true};
vector<byte> destination(decoder.destination_size()); vector<byte> destination(decoder.destination_size());
assert_expect_exception(jpegls_errc::source_buffer_too_small, assert_expect_exception(jpegls_errc::need_more_data,
[&decoder, &destination] { decoder.decode(destination); }); [&decoder, &destination] { decoder.decode(destination); });
} }
@ -625,7 +625,7 @@ public:
jpegls_decoder decoder{source, true}; jpegls_decoder decoder{source, true};
vector<byte> destination(decoder.destination_size()); vector<byte> destination(decoder.destination_size());
assert_expect_exception(jpegls_errc::source_buffer_too_small, assert_expect_exception(jpegls_errc::need_more_data,
[&decoder, &destination] { decoder.decode(destination); }); [&decoder, &destination] { decoder.decode(destination); });
} }
@ -654,7 +654,7 @@ public:
vector<byte> destination(decoder.destination_size()); vector<byte> destination(decoder.destination_size());
assert_expect_exception(jpegls_errc::invalid_encoded_data, assert_expect_exception(jpegls_errc::invalid_data,
[&decoder, &destination] { decoder.decode(destination); }); [&decoder, &destination] { decoder.decode(destination); });
} }
@ -672,7 +672,7 @@ public:
vector<byte> destination(decoder.destination_size()); vector<byte> destination(decoder.destination_size());
assert_expect_exception(jpegls_errc::source_buffer_too_small, assert_expect_exception(jpegls_errc::need_more_data,
[&decoder, &destination] { decoder.decode(destination); }); [&decoder, &destination] { decoder.decode(destination); });
} }
@ -742,7 +742,7 @@ public:
jpegls_decoder decoder{too_small_source, true}; jpegls_decoder decoder{too_small_source, true};
vector<byte> destination(decoder.destination_size()); vector<byte> destination(decoder.destination_size());
assert_expect_exception(jpegls_errc::source_buffer_too_small, assert_expect_exception(jpegls_errc::need_more_data,
[&decoder, &destination] { decoder.decode(destination); }); [&decoder, &destination] { decoder.decode(destination); });
} }
@ -1050,7 +1050,7 @@ public:
decoder.source(writer.buffer); decoder.source(writer.buffer);
decoder.read_spiff_header(); decoder.read_spiff_header();
assert_expect_exception(jpegls_errc::mapping_tables_and_spiff_header, assert_expect_exception(jpegls_errc::abbreviated_format_and_spiff_header,
[&decoder] { ignore = decoder.read_header(); }); [&decoder] { ignore = decoder.read_header(); });
} }
@ -1342,7 +1342,7 @@ private:
jpegls_decoder decoder{source, true}; jpegls_decoder decoder{source, true};
vector<byte> destination(decoder.destination_size(stride) - 1); vector<byte> destination(decoder.destination_size(stride) - 1);
assert_expect_exception(jpegls_errc::destination_buffer_too_small, assert_expect_exception(jpegls_errc::destination_too_small,
[&decoder, &destination, &stride] { decoder.decode(destination, stride); }); [&decoder, &destination, &stride] { decoder.decode(destination, stride); });
} }
}; };

12
unittest/jpegls_encoder_test.cpp
View File

@ -1052,7 +1052,7 @@ public:
Assert::AreEqual(static_cast<byte>(jpeg_marker_code::end_of_image), destination[11]); Assert::AreEqual(static_cast<byte>(jpeg_marker_code::end_of_image), destination[11]);
} }
TEST_METHOD(create_tables_only_with_no_tables_throws) // NOLINT TEST_METHOD(create_abbreviated_format_with_no_tables_throws) // NOLINT
{ {
jpegls_encoder encoder; jpegls_encoder encoder;
@ -1117,7 +1117,7 @@ public:
vector<byte> destination(encoder.estimated_destination_size()); vector<byte> destination(encoder.estimated_destination_size());
encoder.destination(destination); encoder.destination(destination);
encoder.set_table_id(0, 1); encoder.set_mapping_table_id(0, 1);
const size_t bytes_written{encoder.encode(source)}; const size_t bytes_written{encoder.encode(source)};
destination.resize(bytes_written); destination.resize(bytes_written);
@ -1136,8 +1136,8 @@ public:
vector<byte> destination(encoder.estimated_destination_size()); vector<byte> destination(encoder.estimated_destination_size());
encoder.destination(destination); encoder.destination(destination);
encoder.set_table_id(0, 1); encoder.set_mapping_table_id(0, 1);
encoder.set_table_id(0, 0); encoder.set_mapping_table_id(0, 0);
const size_t bytes_written{encoder.encode(source)}; const size_t bytes_written{encoder.encode(source)};
destination.resize(bytes_written); destination.resize(bytes_written);
@ -1151,14 +1151,14 @@ public:
{ {
jpegls_encoder encoder; jpegls_encoder encoder;
assert_expect_exception(jpegls_errc::invalid_argument, [&encoder] { encoder.set_table_id(-1, 0); }); assert_expect_exception(jpegls_errc::invalid_argument, [&encoder] { encoder.set_mapping_table_id(-1, 0); });
} }
TEST_METHOD(set_table_id_bad_id_throws) // NOLINT TEST_METHOD(set_table_id_bad_id_throws) // NOLINT
{ {
jpegls_encoder encoder; jpegls_encoder encoder;
assert_expect_exception(jpegls_errc::invalid_argument, [&encoder] { encoder.set_table_id(0, -1); }); assert_expect_exception(jpegls_errc::invalid_argument, [&encoder] { encoder.set_mapping_table_id(0, -1); });
} }
TEST_METHOD(encode_without_destination_throws) // NOLINT TEST_METHOD(encode_without_destination_throws) // NOLINT