mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-19 00:38:14 +01:00
Add DecodeImageCallbacks::SelectPixfmt
This commit is contained in:
1 parent
441e96a8d4
commit
5767f030a3
5 files changed
+175
-155
No files matched your search
@@ -111,7 +111,7 @@ load_image(const char* filename) {
|
||||
wuffs_aux::DecodeImageCallbacks callbacks;
|
||||
wuffs_aux::sync_io::FileInput input(file);
|
||||
wuffs_aux::DecodeImageResult res = wuffs_aux::DecodeImage(
|
||||
callbacks, input, WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL,
|
||||
callbacks, input,
|
||||
// Use PIXEL_BLEND__SRC_OVER, not the default PIXEL_BLEND__SRC, because
|
||||
// we also pass a background color.
|
||||
WUFFS_BASE__PIXEL_BLEND__SRC_OVER,
|
||||
|
||||
@@ -49,7 +49,7 @@ DecodeImageCallbacks::AllocResult::AllocResult(std::string&& error_message0)
|
||||
error_message(std::move(error_message0)) {}
|
||||
|
||||
wuffs_base__image_decoder::unique_ptr //
|
||||
DecodeImageCallbacks::OnImageFormat(uint32_t fourcc,
|
||||
DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
|
||||
wuffs_base__slice_u8 prefix) {
|
||||
switch (fourcc) {
|
||||
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BMP)
|
||||
@@ -85,10 +85,16 @@ DecodeImageCallbacks::OnImageFormat(uint32_t fourcc,
|
||||
return wuffs_base__image_decoder::unique_ptr(nullptr, &free);
|
||||
}
|
||||
|
||||
wuffs_base__pixel_format //
|
||||
DecodeImageCallbacks::SelectPixfmt(
|
||||
const wuffs_base__image_config& image_config) {
|
||||
return wuffs_base__make_pixel_format(
|
||||
WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL);
|
||||
}
|
||||
|
||||
DecodeImageCallbacks::AllocResult //
|
||||
DecodeImageCallbacks::OnImageConfig(
|
||||
const wuffs_base__image_config& image_config,
|
||||
bool allow_uninitialized_memory) {
|
||||
DecodeImageCallbacks::AllocPixbuf(const wuffs_base__image_config& image_config,
|
||||
bool allow_uninitialized_memory) {
|
||||
uint32_t w = image_config.pixcfg.width();
|
||||
uint32_t h = image_config.pixcfg.height();
|
||||
if ((w == 0) || (h == 0)) {
|
||||
@@ -186,21 +192,10 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
|
||||
DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
uint32_t override_pixel_format_repr,
|
||||
wuffs_base__pixel_blend pixel_blend,
|
||||
wuffs_base__color_u32_argb_premul background_color,
|
||||
uint32_t max_incl_dimension) {
|
||||
// Check args.
|
||||
switch (override_pixel_format_repr) {
|
||||
case 0:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
||||
break;
|
||||
default:
|
||||
return DecodeImageResult(DecodeImage_UnsupportedPixelFormat);
|
||||
}
|
||||
switch (pixel_blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
|
||||
@@ -256,8 +251,8 @@ redirect:
|
||||
image_decoder.reset();
|
||||
}
|
||||
|
||||
// Make the image decoder.
|
||||
image_decoder = callbacks.OnImageFormat(
|
||||
// Select the image decoder.
|
||||
image_decoder = callbacks.SelectDecoder(
|
||||
(uint32_t)fourcc,
|
||||
fourcc ? wuffs_base__empty_slice_u8() : io_buf.reader_slice());
|
||||
if (!image_decoder) {
|
||||
@@ -289,14 +284,24 @@ redirect:
|
||||
}
|
||||
} while (false);
|
||||
|
||||
// Apply the override pixel format.
|
||||
// Select the pixel format.
|
||||
uint32_t w = image_config.pixcfg.width();
|
||||
uint32_t h = image_config.pixcfg.height();
|
||||
if ((w > max_incl_dimension) || (h > max_incl_dimension)) {
|
||||
return DecodeImageResult(DecodeImage_MaxInclDimensionExceeded);
|
||||
}
|
||||
if (override_pixel_format_repr != 0) {
|
||||
image_config.pixcfg.set(override_pixel_format_repr,
|
||||
wuffs_base__pixel_format pixel_format = callbacks.SelectPixfmt(image_config);
|
||||
if (pixel_format.repr != image_config.pixcfg.pixel_format().repr) {
|
||||
switch (pixel_format.repr) {
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
||||
break;
|
||||
default:
|
||||
return DecodeImageResult(DecodeImage_UnsupportedPixelFormat);
|
||||
}
|
||||
image_config.pixcfg.set(pixel_format.repr,
|
||||
WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, w, h);
|
||||
}
|
||||
|
||||
@@ -310,16 +315,16 @@ redirect:
|
||||
}
|
||||
bool valid_background_color =
|
||||
wuffs_base__color_u32_argb_premul__is_valid(background_color);
|
||||
DecodeImageCallbacks::AllocResult oic_result =
|
||||
callbacks.OnImageConfig(image_config, valid_background_color);
|
||||
if (!oic_result.error_message.empty()) {
|
||||
return DecodeImageResult(std::move(oic_result.error_message));
|
||||
} else if (oic_result.mem_slice.len < pixbuf_len_min_incl) {
|
||||
DecodeImageCallbacks::AllocResult alloc_pixbuf_result =
|
||||
callbacks.AllocPixbuf(image_config, valid_background_color);
|
||||
if (!alloc_pixbuf_result.error_message.empty()) {
|
||||
return DecodeImageResult(std::move(alloc_pixbuf_result.error_message));
|
||||
} else if (alloc_pixbuf_result.mem_slice.len < pixbuf_len_min_incl) {
|
||||
return DecodeImageResult(DecodeImage_BufferIsTooShort);
|
||||
}
|
||||
wuffs_base__pixel_buffer pixel_buffer;
|
||||
wuffs_base__status pb_sfs_status =
|
||||
pixel_buffer.set_from_slice(&image_config.pixcfg, oic_result.mem_slice);
|
||||
wuffs_base__status pb_sfs_status = pixel_buffer.set_from_slice(
|
||||
&image_config.pixcfg, alloc_pixbuf_result.mem_slice);
|
||||
if (!pb_sfs_status.is_ok()) {
|
||||
return DecodeImageResult(pb_sfs_status.message());
|
||||
}
|
||||
@@ -390,8 +395,8 @@ redirect:
|
||||
}
|
||||
}
|
||||
}
|
||||
return DecodeImageResult(std::move(oic_result.mem_owner),
|
||||
oic_result.mem_slice, pixel_buffer,
|
||||
return DecodeImageResult(std::move(alloc_pixbuf_result.mem_owner),
|
||||
alloc_pixbuf_result.mem_slice, pixel_buffer,
|
||||
std::move(message));
|
||||
}
|
||||
|
||||
@@ -400,7 +405,6 @@ redirect:
|
||||
DecodeImageResult //
|
||||
DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
uint32_t override_pixel_format_repr,
|
||||
wuffs_base__pixel_blend pixel_blend,
|
||||
wuffs_base__color_u32_argb_premul background_color,
|
||||
uint32_t max_incl_dimension) {
|
||||
@@ -415,9 +419,9 @@ DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
}
|
||||
|
||||
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);
|
||||
DecodeImageResult result = DecodeImage0(
|
||||
image_decoder, callbacks, input, *io_buf, override_pixel_format_repr,
|
||||
pixel_blend, background_color, max_incl_dimension);
|
||||
DecodeImageResult result =
|
||||
DecodeImage0(image_decoder, callbacks, input, *io_buf, pixel_blend,
|
||||
background_color, max_incl_dimension);
|
||||
callbacks.Done(result, input, *io_buf, std::move(image_decoder));
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -33,14 +33,14 @@ struct DecodeImageResult {
|
||||
|
||||
// DecodeImageCallbacks are the callbacks given to DecodeImage. They are always
|
||||
// called in this order:
|
||||
// 1. OnImageFormat
|
||||
// 2. OnImageConfig
|
||||
// 3. AllocWorkbuf
|
||||
// 4. Done
|
||||
// 1. SelectDecoder
|
||||
// 2. SelectPixfmt
|
||||
// 3. AllocPixbuf
|
||||
// 4. AllocWorkbuf
|
||||
// 5. Done
|
||||
//
|
||||
// It may return early - the third callback might not be invoked if the second
|
||||
// one fails (returns a non-empty error message) - but the final callback
|
||||
// (Done) is always invoked.
|
||||
// one fails - but the final callback (Done) is always invoked.
|
||||
class DecodeImageCallbacks {
|
||||
public:
|
||||
// AllocResult holds a memory allocation (the result of malloc or new, a
|
||||
@@ -55,19 +55,19 @@ class DecodeImageCallbacks {
|
||||
std::string error_message;
|
||||
};
|
||||
|
||||
// OnImageFormat returns the image decoder for the input data's file format.
|
||||
// SelectDecoder returns the image decoder for the input data's file format.
|
||||
// Returning a nullptr means failure (DecodeImage_UnsupportedImageFormat).
|
||||
//
|
||||
// Common formats will have a FourCC value in the range [1 ..= 0x7FFF_FFFF],
|
||||
// such as WUFFS_BASE__FOURCC__JPEG. A zero FourCC value means that the
|
||||
// caller is responsible for examining the opening bytes (a prefix) of the
|
||||
// input data. OnImageFormat implementations should not modify those bytes.
|
||||
// input data. SelectDecoder implementations should not modify those bytes.
|
||||
//
|
||||
// OnImageFormat might be called more than once, since some image file
|
||||
// SelectDecoder might be called more than once, since some image file
|
||||
// formats can wrap others. For example, a nominal BMP file can actually
|
||||
// contain a JPEG or a PNG.
|
||||
//
|
||||
// The default OnImageFormat accepts the FOURCC codes listed below. For
|
||||
// The default SelectDecoder accepts the FOURCC codes listed below. For
|
||||
// modular builds (i.e. when #define'ing WUFFS_CONFIG__MODULES), acceptance
|
||||
// of the ETC file format is optional (for each value of ETC) and depends on
|
||||
// the corresponding module to be enabled at compile time (i.e. #define'ing
|
||||
@@ -78,20 +78,38 @@ class DecodeImageCallbacks {
|
||||
// - WUFFS_BASE__FOURCC__PNG
|
||||
// - WUFFS_BASE__FOURCC__WBMP
|
||||
virtual wuffs_base__image_decoder::unique_ptr //
|
||||
OnImageFormat(uint32_t fourcc, wuffs_base__slice_u8 prefix);
|
||||
SelectDecoder(uint32_t fourcc, wuffs_base__slice_u8 prefix);
|
||||
|
||||
// OnImageConfig allocates the pixel buffer.
|
||||
// SelectPixfmt returns the destination pixel format for AllocPixbuf. It
|
||||
// should return wuffs_base__make_pixel_format(etc) called with one of:
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGR_565
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGR
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL
|
||||
// or return image_config.pixcfg.pixel_format(). The latter means to use the
|
||||
// image file's natural pixel format. For example, GIF images' natural pixel
|
||||
// format is an indexed one.
|
||||
//
|
||||
// Returning otherwise means failure (DecodeImage_UnsupportedPixelFormat).
|
||||
//
|
||||
// The default SelectPixfmt implementation returns
|
||||
// wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL)
|
||||
// which is 4 bytes per pixel (8 bits per channel × 4 channels).
|
||||
virtual wuffs_base__pixel_format //
|
||||
SelectPixfmt(const wuffs_base__image_config& image_config);
|
||||
|
||||
// AllocPixbuf allocates the pixel buffer.
|
||||
//
|
||||
// allow_uninitialized_memory will be true if a valid background_color was
|
||||
// passed to DecodeImage, since the pixel buffer's contents will be
|
||||
// overwritten with that color after OnImageConfig returns.
|
||||
// overwritten with that color after AllocPixbuf returns.
|
||||
//
|
||||
// The default OnImageConfig implementation allocates either uninitialized or
|
||||
// The default AllocPixbuf implementation allocates either uninitialized or
|
||||
// zeroed memory. Zeroed memory typically corresponds to filling with opaque
|
||||
// black or transparent black, depending on the pixel format.
|
||||
virtual AllocResult //
|
||||
OnImageConfig(const wuffs_base__image_config& image_config,
|
||||
bool allow_uninitialized_memory);
|
||||
AllocPixbuf(const wuffs_base__image_config& image_config,
|
||||
bool allow_uninitialized_memory);
|
||||
|
||||
// AllocWorkbuf allocates the work buffer. The allocated buffer's length
|
||||
// should be at least len_range.min_incl, but larger allocations (up to
|
||||
@@ -107,7 +125,7 @@ class DecodeImageCallbacks {
|
||||
// not parsing the input encountered an error. Even when successful, trailing
|
||||
// data may remain in input and buffer.
|
||||
//
|
||||
// The image_decoder is the one returned by OnImageFormat (if OnImageFormat
|
||||
// The image_decoder is the one returned by SelectDecoder (if SelectDecoder
|
||||
// was successful), or a no-op unique_ptr otherwise. Like any unique_ptr,
|
||||
// ownership moves to the Done implementation.
|
||||
//
|
||||
@@ -133,7 +151,7 @@ extern const char DecodeImage_UnsupportedPixelConfiguration[];
|
||||
extern const char DecodeImage_UnsupportedPixelFormat[];
|
||||
|
||||
// DecodeImage decodes the image data in input. A variety of image file formats
|
||||
// can be decoded, depending on what callbacks.OnImageFormat returns.
|
||||
// can be decoded, depending on what callbacks.SelectDecoder returns.
|
||||
//
|
||||
// For animated formats, only the first frame is returned, since the API is
|
||||
// simpler for synchronous I/O and having DecodeImage only return when
|
||||
@@ -158,25 +176,14 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
|
||||
// as the returned pixbuf_mem_owner. Regardless of success or failure, the work
|
||||
// buffer memory is deleted.
|
||||
//
|
||||
// If override_pixel_format_repr is zero then the pixel buffer will have the
|
||||
// image file's natural pixel format. For example, GIF images' natural pixel
|
||||
// format is an indexed one.
|
||||
//
|
||||
// If override_pixel_format_repr is non-zero (and one of the constants listed
|
||||
// below) then the image will be decoded to that particular pixel format:
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGR_565
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGR
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL
|
||||
//
|
||||
// The pixel_blend (one of the constants listed below) determines how to
|
||||
// composite the decoded image over the pixel buffer's original pixels (as
|
||||
// returned by callbacks.OnImageConfig):
|
||||
// returned by callbacks.AllocPixbuf):
|
||||
// - WUFFS_BASE__PIXEL_BLEND__SRC
|
||||
// - WUFFS_BASE__PIXEL_BLEND__SRC_OVER
|
||||
//
|
||||
// The background_color is used to fill the pixel buffer after
|
||||
// callbacks.OnImageConfig returns, if it is valid in the
|
||||
// callbacks.AllocPixbuf returns, if it is valid in the
|
||||
// wuffs_base__color_u32_argb_premul__is_valid sense. The default value,
|
||||
// 0x0000_0001, is not valid since its Blue channel value (0x01) is greater
|
||||
// than its Alpha channel value (0x00). A valid background_color will typically
|
||||
@@ -189,7 +196,6 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
|
||||
DecodeImageResult //
|
||||
DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
uint32_t override_pixel_format_repr,
|
||||
wuffs_base__pixel_blend pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
wuffs_base__color_u32_argb_premul background_color = 1, // Invalid.
|
||||
uint32_t max_incl_dimension = 1048575); // 0x000F_FFFF
|
||||
|
||||
+24
-24
@@ -740,35 +740,35 @@ const AuxCborHh = "" +
|
||||
|
||||
const AuxImageCc = "" +
|
||||
"// ---------------- Auxiliary - Image\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__IMAGE)\n\n#include <utility>\n\nnamespace wuffs_aux {\n\nDecodeImageResult::DecodeImageResult(MemOwner&& pixbuf_mem_owner0,\n wuffs_base__slice_u8 pixbuf_mem_slice0,\n wuffs_base__pixel_buffer pixbuf0,\n std::string&& error_message0)\n : pixbuf_mem_owner(std::move(pixbuf_mem_owner0)),\n pixbuf_mem_slice(pixbuf_mem_slice0),\n pixbuf(pixbuf0),\n error_message(std::move(error_message0)) {}\n\nDecodeImageResult::DecodeImageResult(std::string&& error_message0)\n : pixbuf_mem_owner(nullptr, &free),\n pixbuf_mem_slice(wuffs_base__empty_slice_u8()),\n pixbuf(wuffs_base__null_pixel_buffer()),\n error_message(std::move(error_message0)) {}\n\nDecodeImageCallbacks::AllocResult::AllocResult(MemOwner&& mem_owner0,\n wuffs_base__slice_u8 mem_slice0" +
|
||||
")\n : mem_owner(std::move(mem_owner0)),\n mem_slice(mem_slice0),\n error_message(\"\") {}\n\nDecodeImageCallbacks::AllocResult::AllocResult(std::string&& error_message0)\n : mem_owner(nullptr, &free),\n mem_slice(wuffs_base__empty_slice_u8()),\n error_message(std::move(error_message0)) {}\n\nwuffs_base__image_decoder::unique_ptr //\nDecodeImageCallbacks::OnImageFormat(uint32_t fourcc,\n wuffs_base__slice_u8 prefix) {\n switch (fourcc) {\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BMP)\n case WUFFS_BASE__FOURCC__BMP:\n return wuffs_bmp__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GIF)\n case WUFFS_BASE__FOURCC__GIF:\n return wuffs_gif__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__NIE)\n case WUFFS_BASE__FOURCC__NIE:\n return wuffs_nie__decoder::alloc_as__wuffs_ba" +
|
||||
"se__image_decoder();\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__PNG)\n case WUFFS_BASE__FOURCC__PNG: {\n auto dec = wuffs_png__decoder::alloc_as__wuffs_base__image_decoder();\n // Favor faster decodes over rejecting invalid checksums.\n dec->set_quirk_enabled(WUFFS_BASE__QUIRK_IGNORE_CHECKSUM, true);\n return dec;\n }\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP)\n case WUFFS_BASE__FOURCC__WBMP:\n return wuffs_wbmp__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n }\n\n return wuffs_base__image_decoder::unique_ptr(nullptr, &free);\n}\n\nDecodeImageCallbacks::AllocResult //\nDecodeImageCallbacks::OnImageConfig(\n const wuffs_base__image_config& image_config,\n bool allow_uninitialized_memory) {\n uint32_t w = image_config.pixcfg.width();\n uint32_t h = image_config.pixcfg.height();\n if ((w == 0) || (h == 0)) {\n return AllocResult(\"\");\n }\n uint64_t len = image_config.pixcfg.pixbuf_len();\n if ((len == " +
|
||||
"0) || (SIZE_MAX < len)) {\n return AllocResult(DecodeImage_UnsupportedPixelConfiguration);\n }\n void* ptr =\n allow_uninitialized_memory ? malloc((size_t)len) : calloc((size_t)len, 1);\n return ptr ? AllocResult(\n MemOwner(ptr, &free),\n wuffs_base__make_slice_u8((uint8_t*)ptr, (size_t)len))\n : AllocResult(DecodeImage_OutOfMemory);\n}\n\nDecodeImageCallbacks::AllocResult //\nDecodeImageCallbacks::AllocWorkbuf(wuffs_base__range_ii_u64 len_range,\n bool allow_uninitialized_memory) {\n uint64_t len = len_range.max_incl;\n if (len == 0) {\n return AllocResult(\"\");\n } else if (SIZE_MAX < len) {\n return AllocResult(DecodeImage_OutOfMemory);\n }\n void* ptr =\n allow_uninitialized_memory ? malloc((size_t)len) : calloc((size_t)len, 1);\n return ptr ? AllocResult(\n MemOwner(ptr, &free),\n wuffs_base__make_slice_u8((uint8_t*)ptr, (size_t)len))\n : AllocResult(DecodeImage_OutOfMemor" +
|
||||
"y);\n}\n\nvoid //\nDecodeImageCallbacks::Done(\n DecodeImageResult& result,\n sync_io::Input& input,\n IOBuffer& buffer,\n wuffs_base__image_decoder::unique_ptr image_decoder) {}\n\nconst char DecodeImage_BufferIsTooShort[] = //\n \"wuffs_aux::DecodeImage: buffer is too short\";\nconst char DecodeImage_MaxInclDimensionExceeded[] = //\n \"wuffs_aux::DecodeImage: max_incl_dimension exceeded\";\nconst char DecodeImage_OutOfMemory[] = //\n \"wuffs_aux::DecodeImage: out of memory\";\nconst char DecodeImage_UnexpectedEndOfFile[] = //\n \"wuffs_aux::DecodeImage: unexpected end of file\";\nconst char DecodeImage_UnsupportedImageFormat[] = //\n \"wuffs_aux::DecodeImage: unsupported image format\";\nconst char DecodeImage_UnsupportedPixelBlend[] = //\n \"wuffs_aux::DecodeImage: unsupported pixel blend\";\nconst char DecodeImage_UnsupportedPixelConfiguration[] = //\n \"wuffs_aux::DecodeImage: unsupported pixel configuration\";\nconst char DecodeImage_UnsupportedPixelFormat[] = //\n \"wuffs_aux::DecodeImage: unsuppo" +
|
||||
"rted pixel format\";\n\n" +
|
||||
")\n : mem_owner(std::move(mem_owner0)),\n mem_slice(mem_slice0),\n error_message(\"\") {}\n\nDecodeImageCallbacks::AllocResult::AllocResult(std::string&& error_message0)\n : mem_owner(nullptr, &free),\n mem_slice(wuffs_base__empty_slice_u8()),\n error_message(std::move(error_message0)) {}\n\nwuffs_base__image_decoder::unique_ptr //\nDecodeImageCallbacks::SelectDecoder(uint32_t fourcc,\n wuffs_base__slice_u8 prefix) {\n switch (fourcc) {\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BMP)\n case WUFFS_BASE__FOURCC__BMP:\n return wuffs_bmp__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GIF)\n case WUFFS_BASE__FOURCC__GIF:\n return wuffs_gif__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__NIE)\n case WUFFS_BASE__FOURCC__NIE:\n return wuffs_nie__decoder::alloc_as__wuffs_ba" +
|
||||
"se__image_decoder();\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__PNG)\n case WUFFS_BASE__FOURCC__PNG: {\n auto dec = wuffs_png__decoder::alloc_as__wuffs_base__image_decoder();\n // Favor faster decodes over rejecting invalid checksums.\n dec->set_quirk_enabled(WUFFS_BASE__QUIRK_IGNORE_CHECKSUM, true);\n return dec;\n }\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP)\n case WUFFS_BASE__FOURCC__WBMP:\n return wuffs_wbmp__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n }\n\n return wuffs_base__image_decoder::unique_ptr(nullptr, &free);\n}\n\nwuffs_base__pixel_format //\nDecodeImageCallbacks::SelectPixfmt(\n const wuffs_base__image_config& image_config) {\n return wuffs_base__make_pixel_format(\n WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL);\n}\n\nDecodeImageCallbacks::AllocResult //\nDecodeImageCallbacks::AllocPixbuf(const wuffs_base__image_config& image_config,\n bool allow_uninitia" +
|
||||
"lized_memory) {\n uint32_t w = image_config.pixcfg.width();\n uint32_t h = image_config.pixcfg.height();\n if ((w == 0) || (h == 0)) {\n return AllocResult(\"\");\n }\n uint64_t len = image_config.pixcfg.pixbuf_len();\n if ((len == 0) || (SIZE_MAX < len)) {\n return AllocResult(DecodeImage_UnsupportedPixelConfiguration);\n }\n void* ptr =\n allow_uninitialized_memory ? malloc((size_t)len) : calloc((size_t)len, 1);\n return ptr ? AllocResult(\n MemOwner(ptr, &free),\n wuffs_base__make_slice_u8((uint8_t*)ptr, (size_t)len))\n : AllocResult(DecodeImage_OutOfMemory);\n}\n\nDecodeImageCallbacks::AllocResult //\nDecodeImageCallbacks::AllocWorkbuf(wuffs_base__range_ii_u64 len_range,\n bool allow_uninitialized_memory) {\n uint64_t len = len_range.max_incl;\n if (len == 0) {\n return AllocResult(\"\");\n } else if (SIZE_MAX < len) {\n return AllocResult(DecodeImage_OutOfMemory);\n }\n void* ptr =\n allow_uninitialized_memory ? malloc" +
|
||||
"((size_t)len) : calloc((size_t)len, 1);\n return ptr ? AllocResult(\n MemOwner(ptr, &free),\n wuffs_base__make_slice_u8((uint8_t*)ptr, (size_t)len))\n : AllocResult(DecodeImage_OutOfMemory);\n}\n\nvoid //\nDecodeImageCallbacks::Done(\n DecodeImageResult& result,\n sync_io::Input& input,\n IOBuffer& buffer,\n wuffs_base__image_decoder::unique_ptr image_decoder) {}\n\nconst char DecodeImage_BufferIsTooShort[] = //\n \"wuffs_aux::DecodeImage: buffer is too short\";\nconst char DecodeImage_MaxInclDimensionExceeded[] = //\n \"wuffs_aux::DecodeImage: max_incl_dimension exceeded\";\nconst char DecodeImage_OutOfMemory[] = //\n \"wuffs_aux::DecodeImage: out of memory\";\nconst char DecodeImage_UnexpectedEndOfFile[] = //\n \"wuffs_aux::DecodeImage: unexpected end of file\";\nconst char DecodeImage_UnsupportedImageFormat[] = //\n \"wuffs_aux::DecodeImage: unsupported image format\";\nconst char DecodeImage_UnsupportedPixelBlend[] = //\n \"wuffs_aux::DecodeImage: unsuppor" +
|
||||
"ted pixel blend\";\nconst char DecodeImage_UnsupportedPixelConfiguration[] = //\n \"wuffs_aux::DecodeImage: unsupported pixel configuration\";\nconst char DecodeImage_UnsupportedPixelFormat[] = //\n \"wuffs_aux::DecodeImage: unsupported pixel format\";\n\n" +
|
||||
"" +
|
||||
"// --------\n\nnamespace {\n\nstd::string //\nDecodeImageAdvanceIOBuf(sync_io::Input& input,\n wuffs_base__io_buffer& io_buf,\n bool compactable,\n uint64_t min_excl_pos,\n uint64_t pos) {\n if ((pos <= min_excl_pos) || (pos < io_buf.reader_position())) {\n // Redirects must go forward.\n return DecodeImage_UnsupportedImageFormat;\n }\n while (true) {\n uint64_t relative_pos = pos - io_buf.reader_position();\n if (relative_pos <= io_buf.reader_length()) {\n io_buf.meta.ri += (size_t)relative_pos;\n break;\n } else if (io_buf.meta.closed) {\n return DecodeImage_UnexpectedEndOfFile;\n }\n io_buf.meta.ri = io_buf.meta.wi;\n if (compactable) {\n io_buf.compact();\n }\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return error_message;\n }\n }\n return \"\";\n}\n\nDecodeImageResult //\nDecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,\n " +
|
||||
" DecodeImageCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__io_buffer& io_buf,\n uint32_t override_pixel_format_repr,\n wuffs_base__pixel_blend pixel_blend,\n wuffs_base__color_u32_argb_premul background_color,\n uint32_t max_incl_dimension) {\n // Check args.\n switch (override_pixel_format_repr) {\n case 0:\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n break;\n default:\n return DecodeImageResult(DecodeImage_UnsupportedPixelFormat);\n }\n switch (pixel_blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n break;\n default:\n return DecodeImageResult(DecodeImage_UnsupportedPixelBlend);\n }\n\n wuffs_base__image_config image_config = wuffs_base__null_image_config();\n uint64_t start_pos = io_buf.reader_position();\n bool redi" +
|
||||
"rected = false;\n int32_t fourcc = 0;\nredirect:\n do {\n // Determine the image format.\n if (!redirected) {\n while (true) {\n fourcc = wuffs_base__magic_number_guess_fourcc(io_buf.reader_slice());\n if (fourcc > 0) {\n break;\n } else if ((fourcc == 0) && (io_buf.reader_length() >= 64)) {\n break;\n } else if (io_buf.meta.closed || (io_buf.writer_length() == 0)) {\n fourcc = 0;\n break;\n }\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n }\n } else {\n wuffs_base__io_buffer empty = wuffs_base__empty_io_buffer();\n wuffs_base__more_information minfo = wuffs_base__empty_more_information();\n wuffs_base__status tmm_status =\n image_decoder->tell_me_more(&empty, &minfo, &io_buf);\n if (tmm_status.repr != nullptr) {\n return DecodeImageResult(tmm_status.message());\n }\n if (minf" +
|
||||
"o.flavor != WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n uint64_t pos = minfo.io_redirect__range().min_incl;\n std::string error_message = DecodeImageAdvanceIOBuf(\n input, io_buf, !input.BringsItsOwnIOBuffer(), start_pos, pos);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n fourcc = (int32_t)(minfo.io_redirect__fourcc());\n if (fourcc == 0) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n image_decoder.reset();\n }\n\n // Make the image decoder.\n image_decoder = callbacks.OnImageFormat(\n (uint32_t)fourcc,\n fourcc ? wuffs_base__empty_slice_u8() : io_buf.reader_slice());\n if (!image_decoder) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n\n // Decode the image config.\n while (true) {\n wuffs_base__status id_dic_status =\n image_decoder->d" +
|
||||
"ecode_image_config(&image_config, &io_buf);\n if (id_dic_status.repr == nullptr) {\n break;\n } else if (id_dic_status.repr == wuffs_base__note__i_o_redirect) {\n if (redirected) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n redirected = true;\n goto redirect;\n } else if (id_dic_status.repr != wuffs_base__suspension__short_read) {\n return DecodeImageResult(id_dic_status.message());\n } else if (io_buf.meta.closed) {\n return DecodeImageResult(DecodeImage_UnexpectedEndOfFile);\n } else {\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n }\n }\n } while (false);\n\n // Apply the override pixel format.\n uint32_t w = image_config.pixcfg.width();\n uint32_t h = image_config.pixcfg.height();\n if ((w > max_incl_dimension) || (h > max_incl_dimension)) {\n return DecodeImageResult(DecodeImage_M" +
|
||||
"axInclDimensionExceeded);\n }\n if (override_pixel_format_repr != 0) {\n image_config.pixcfg.set(override_pixel_format_repr,\n WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, w, h);\n }\n\n // Allocate the pixel buffer.\n uint64_t pixbuf_len_min_incl = 0;\n if ((w > 0) && (h > 0)) {\n pixbuf_len_min_incl = image_config.pixcfg.pixbuf_len();\n if (pixbuf_len_min_incl == 0) {\n return DecodeImageResult(DecodeImage_UnsupportedPixelFormat);\n }\n }\n bool valid_background_color =\n wuffs_base__color_u32_argb_premul__is_valid(background_color);\n DecodeImageCallbacks::AllocResult oic_result =\n callbacks.OnImageConfig(image_config, valid_background_color);\n if (!oic_result.error_message.empty()) {\n return DecodeImageResult(std::move(oic_result.error_message));\n } else if (oic_result.mem_slice.len < pixbuf_len_min_incl) {\n return DecodeImageResult(DecodeImage_BufferIsTooShort);\n }\n wuffs_base__pixel_buffer pixel_buffer;\n wuffs_base__status pb_sfs_status =\n pixel_buff" +
|
||||
"er.set_from_slice(&image_config.pixcfg, oic_result.mem_slice);\n if (!pb_sfs_status.is_ok()) {\n return DecodeImageResult(pb_sfs_status.message());\n }\n if (valid_background_color) {\n wuffs_base__status pb_scufr_status = pixel_buffer.set_color_u32_fill_rect(\n pixel_buffer.pixcfg.bounds(), background_color);\n if (pb_scufr_status.repr != nullptr) {\n return DecodeImageResult(pb_scufr_status.message());\n }\n }\n\n // Allocate the work buffer. Wuffs' decoders conventionally assume that this\n // can be uninitialized memory.\n wuffs_base__range_ii_u64 workbuf_len = image_decoder->workbuf_len();\n DecodeImageCallbacks::AllocResult alloc_workbuf_result =\n callbacks.AllocWorkbuf(workbuf_len, true);\n if (!alloc_workbuf_result.error_message.empty()) {\n return DecodeImageResult(std::move(alloc_workbuf_result.error_message));\n } else if (alloc_workbuf_result.mem_slice.len < workbuf_len.min_incl) {\n return DecodeImageResult(DecodeImage_BufferIsTooShort);\n }\n\n // Decode the frame config" +
|
||||
".\n wuffs_base__frame_config frame_config = wuffs_base__null_frame_config();\n while (true) {\n wuffs_base__status id_dfc_status =\n image_decoder->decode_frame_config(&frame_config, &io_buf);\n if (id_dfc_status.repr == nullptr) {\n break;\n } else if (id_dfc_status.repr != wuffs_base__suspension__short_read) {\n return DecodeImageResult(id_dfc_status.message());\n } else if (io_buf.meta.closed) {\n return DecodeImageResult(DecodeImage_UnexpectedEndOfFile);\n } else {\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n }\n }\n\n // Decode the frame (the pixels).\n //\n // From here on, always returns the pixel_buffer. If we get this far, we can\n // still display a partial image, even if we encounter an error.\n std::string message(\"\");\n if ((pixel_blend == WUFFS_BASE__PIXEL_BLEND__SRC_OVER) &&\n frame_config.overwrite_instead_of_blend()) {\n pixel_blend = WUFFS_B" +
|
||||
"ASE__PIXEL_BLEND__SRC;\n }\n while (true) {\n wuffs_base__status id_df_status =\n image_decoder->decode_frame(&pixel_buffer, &io_buf, pixel_blend,\n alloc_workbuf_result.mem_slice, nullptr);\n if (id_df_status.repr == nullptr) {\n break;\n } else if (id_df_status.repr != wuffs_base__suspension__short_read) {\n message = id_df_status.message();\n break;\n } else if (io_buf.meta.closed) {\n message = DecodeImage_UnexpectedEndOfFile;\n break;\n } else {\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n message = std::move(error_message);\n break;\n }\n }\n }\n return DecodeImageResult(std::move(oic_result.mem_owner),\n oic_result.mem_slice, pixel_buffer,\n std::move(message));\n}\n\n} // namespace\n\nDecodeImageResult //\nDecodeImage(DecodeImageCallbacks& callbacks,\n sync_io::Input& input,\n uint32_t override_pixel_" +
|
||||
"format_repr,\n wuffs_base__pixel_blend pixel_blend,\n wuffs_base__color_u32_argb_premul background_color,\n uint32_t max_incl_dimension) {\n wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();\n wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();\n std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);\n if (!io_buf) {\n fallback_io_array = std::unique_ptr<uint8_t[]>(new uint8_t[32768]);\n fallback_io_buf =\n wuffs_base__ptr_u8__writer(fallback_io_array.get(), 32768);\n io_buf = &fallback_io_buf;\n }\n\n wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);\n DecodeImageResult result = DecodeImage0(\n image_decoder, callbacks, input, *io_buf, override_pixel_format_repr,\n pixel_blend, background_color, max_incl_dimension);\n callbacks.Done(result, input, *io_buf, std::move(image_decoder));\n return result;\n}\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODU" +
|
||||
"LE__AUX__IMAGE)\n" +
|
||||
" DecodeImageCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__io_buffer& io_buf,\n wuffs_base__pixel_blend pixel_blend,\n wuffs_base__color_u32_argb_premul background_color,\n uint32_t max_incl_dimension) {\n // Check args.\n switch (pixel_blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n break;\n default:\n return DecodeImageResult(DecodeImage_UnsupportedPixelBlend);\n }\n\n wuffs_base__image_config image_config = wuffs_base__null_image_config();\n uint64_t start_pos = io_buf.reader_position();\n bool redirected = false;\n int32_t fourcc = 0;\nredirect:\n do {\n // Determine the image format.\n if (!redirected) {\n while (true) {\n fourcc = wuffs_base__magic_number_guess_fourcc(io_buf.reader_slice());\n if (fourcc > 0) {\n break;\n } else if ((fourcc == 0) && (io_buf.reader_length() >= 64)) {\n break;\n } else if (io_buf.meta.closed ||" +
|
||||
" (io_buf.writer_length() == 0)) {\n fourcc = 0;\n break;\n }\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n }\n } else {\n wuffs_base__io_buffer empty = wuffs_base__empty_io_buffer();\n wuffs_base__more_information minfo = wuffs_base__empty_more_information();\n wuffs_base__status tmm_status =\n image_decoder->tell_me_more(&empty, &minfo, &io_buf);\n if (tmm_status.repr != nullptr) {\n return DecodeImageResult(tmm_status.message());\n }\n if (minfo.flavor != WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n uint64_t pos = minfo.io_redirect__range().min_incl;\n std::string error_message = DecodeImageAdvanceIOBuf(\n input, io_buf, !input.BringsItsOwnIOBuffer(), start_pos, pos);\n if (!error_message.empty()) {\n return" +
|
||||
" DecodeImageResult(std::move(error_message));\n }\n fourcc = (int32_t)(minfo.io_redirect__fourcc());\n if (fourcc == 0) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n image_decoder.reset();\n }\n\n // Select the image decoder.\n image_decoder = callbacks.SelectDecoder(\n (uint32_t)fourcc,\n fourcc ? wuffs_base__empty_slice_u8() : io_buf.reader_slice());\n if (!image_decoder) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n\n // Decode the image config.\n while (true) {\n wuffs_base__status id_dic_status =\n image_decoder->decode_image_config(&image_config, &io_buf);\n if (id_dic_status.repr == nullptr) {\n break;\n } else if (id_dic_status.repr == wuffs_base__note__i_o_redirect) {\n if (redirected) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n redirected = true;\n goto redirect;\n } else if (id_dic_status.repr != wuffs_bas" +
|
||||
"e__suspension__short_read) {\n return DecodeImageResult(id_dic_status.message());\n } else if (io_buf.meta.closed) {\n return DecodeImageResult(DecodeImage_UnexpectedEndOfFile);\n } else {\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n }\n }\n } while (false);\n\n // Select the pixel format.\n uint32_t w = image_config.pixcfg.width();\n uint32_t h = image_config.pixcfg.height();\n if ((w > max_incl_dimension) || (h > max_incl_dimension)) {\n return DecodeImageResult(DecodeImage_MaxInclDimensionExceeded);\n }\n wuffs_base__pixel_format pixel_format = callbacks.SelectPixfmt(image_config);\n if (pixel_format.repr != image_config.pixcfg.pixel_format().repr) {\n switch (pixel_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT" +
|
||||
"__BGRA_PREMUL:\n break;\n default:\n return DecodeImageResult(DecodeImage_UnsupportedPixelFormat);\n }\n image_config.pixcfg.set(pixel_format.repr,\n WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, w, h);\n }\n\n // Allocate the pixel buffer.\n uint64_t pixbuf_len_min_incl = 0;\n if ((w > 0) && (h > 0)) {\n pixbuf_len_min_incl = image_config.pixcfg.pixbuf_len();\n if (pixbuf_len_min_incl == 0) {\n return DecodeImageResult(DecodeImage_UnsupportedPixelFormat);\n }\n }\n bool valid_background_color =\n wuffs_base__color_u32_argb_premul__is_valid(background_color);\n DecodeImageCallbacks::AllocResult alloc_pixbuf_result =\n callbacks.AllocPixbuf(image_config, valid_background_color);\n if (!alloc_pixbuf_result.error_message.empty()) {\n return DecodeImageResult(std::move(alloc_pixbuf_result.error_message));\n } else if (alloc_pixbuf_result.mem_slice.len < pixbuf_len_min_incl) {\n return DecodeImageResult(DecodeImage_BufferIsTooShort);\n }\n wuffs_base__pixel" +
|
||||
"_buffer pixel_buffer;\n wuffs_base__status pb_sfs_status = pixel_buffer.set_from_slice(\n &image_config.pixcfg, alloc_pixbuf_result.mem_slice);\n if (!pb_sfs_status.is_ok()) {\n return DecodeImageResult(pb_sfs_status.message());\n }\n if (valid_background_color) {\n wuffs_base__status pb_scufr_status = pixel_buffer.set_color_u32_fill_rect(\n pixel_buffer.pixcfg.bounds(), background_color);\n if (pb_scufr_status.repr != nullptr) {\n return DecodeImageResult(pb_scufr_status.message());\n }\n }\n\n // Allocate the work buffer. Wuffs' decoders conventionally assume that this\n // can be uninitialized memory.\n wuffs_base__range_ii_u64 workbuf_len = image_decoder->workbuf_len();\n DecodeImageCallbacks::AllocResult alloc_workbuf_result =\n callbacks.AllocWorkbuf(workbuf_len, true);\n if (!alloc_workbuf_result.error_message.empty()) {\n return DecodeImageResult(std::move(alloc_workbuf_result.error_message));\n } else if (alloc_workbuf_result.mem_slice.len < workbuf_len.min_incl) {\n retu" +
|
||||
"rn DecodeImageResult(DecodeImage_BufferIsTooShort);\n }\n\n // Decode the frame config.\n wuffs_base__frame_config frame_config = wuffs_base__null_frame_config();\n while (true) {\n wuffs_base__status id_dfc_status =\n image_decoder->decode_frame_config(&frame_config, &io_buf);\n if (id_dfc_status.repr == nullptr) {\n break;\n } else if (id_dfc_status.repr != wuffs_base__suspension__short_read) {\n return DecodeImageResult(id_dfc_status.message());\n } else if (io_buf.meta.closed) {\n return DecodeImageResult(DecodeImage_UnexpectedEndOfFile);\n } else {\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n }\n }\n\n // Decode the frame (the pixels).\n //\n // From here on, always returns the pixel_buffer. If we get this far, we can\n // still display a partial image, even if we encounter an error.\n std::string message(\"\");\n if ((pixel_blend == WUFFS_BASE__PIXEL_BLEND__SRC_" +
|
||||
"OVER) &&\n frame_config.overwrite_instead_of_blend()) {\n pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC;\n }\n while (true) {\n wuffs_base__status id_df_status =\n image_decoder->decode_frame(&pixel_buffer, &io_buf, pixel_blend,\n alloc_workbuf_result.mem_slice, nullptr);\n if (id_df_status.repr == nullptr) {\n break;\n } else if (id_df_status.repr != wuffs_base__suspension__short_read) {\n message = id_df_status.message();\n break;\n } else if (io_buf.meta.closed) {\n message = DecodeImage_UnexpectedEndOfFile;\n break;\n } else {\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n message = std::move(error_message);\n break;\n }\n }\n }\n return DecodeImageResult(std::move(alloc_pixbuf_result.mem_owner),\n alloc_pixbuf_result.mem_slice, pixel_buffer,\n std::move(message));\n}\n\n} // namespace\n\nDecodeImageResult //\nDecodeImage(D" +
|
||||
"ecodeImageCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__pixel_blend pixel_blend,\n wuffs_base__color_u32_argb_premul background_color,\n uint32_t max_incl_dimension) {\n wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();\n wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();\n std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);\n if (!io_buf) {\n fallback_io_array = std::unique_ptr<uint8_t[]>(new uint8_t[32768]);\n fallback_io_buf =\n wuffs_base__ptr_u8__writer(fallback_io_array.get(), 32768);\n io_buf = &fallback_io_buf;\n }\n\n wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);\n DecodeImageResult result =\n DecodeImage0(image_decoder, callbacks, input, *io_buf, pixel_blend,\n background_color, max_incl_dimension);\n callbacks.Done(result, input, *io_buf, std::move(image_decoder));\n return result;\n}\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||" +
|
||||
"\n // defined(WUFFS_CONFIG__MODULE__AUX__IMAGE)\n" +
|
||||
""
|
||||
|
||||
const AuxImageHh = "" +
|
||||
"// ---------------- Auxiliary - Image\n\nnamespace wuffs_aux {\n\nstruct DecodeImageResult {\n DecodeImageResult(MemOwner&& pixbuf_mem_owner0,\n wuffs_base__slice_u8 pixbuf_mem_slice0,\n wuffs_base__pixel_buffer pixbuf0,\n std::string&& error_message0);\n DecodeImageResult(std::string&& error_message0);\n\n MemOwner pixbuf_mem_owner;\n wuffs_base__slice_u8 pixbuf_mem_slice;\n wuffs_base__pixel_buffer pixbuf;\n std::string error_message;\n};\n\n// DecodeImageCallbacks are the callbacks given to DecodeImage. They are always\n// called in this order:\n// 1. OnImageFormat\n// 2. OnImageConfig\n// 3. AllocWorkbuf\n// 4. Done\n//\n// It may return early - the third callback might not be invoked if the second\n// one fails (returns a non-empty error message) - but the final callback\n// (Done) is always invoked.\nclass DecodeImageCallbacks {\n public:\n // AllocResult holds a memory allocation (the result of malloc or new, a\n // statically allocated pointer, etc), or an error " +
|
||||
"message. The memory is\n // de-allocated when mem_owner goes out of scope and is destroyed.\n struct AllocResult {\n AllocResult(MemOwner&& mem_owner0, wuffs_base__slice_u8 mem_slice0);\n AllocResult(std::string&& error_message0);\n\n MemOwner mem_owner;\n wuffs_base__slice_u8 mem_slice;\n std::string error_message;\n };\n\n // OnImageFormat returns the image decoder for the input data's file format.\n // Returning a nullptr means failure (DecodeImage_UnsupportedImageFormat).\n //\n // Common formats will have a FourCC value in the range [1 ..= 0x7FFF_FFFF],\n // such as WUFFS_BASE__FOURCC__JPEG. A zero FourCC value means that the\n // caller is responsible for examining the opening bytes (a prefix) of the\n // input data. OnImageFormat implementations should not modify those bytes.\n //\n // OnImageFormat might be called more than once, since some image file\n // formats can wrap others. For example, a nominal BMP file can actually\n // contain a JPEG or a PNG.\n //\n // The default OnImageFormat acc" +
|
||||
"epts the FOURCC codes listed below. For\n // modular builds (i.e. when #define'ing WUFFS_CONFIG__MODULES), acceptance\n // of the ETC file format is optional (for each value of ETC) and depends on\n // the corresponding module to be enabled at compile time (i.e. #define'ing\n // WUFFS_CONFIG__MODULE__ETC).\n // - WUFFS_BASE__FOURCC__BMP\n // - WUFFS_BASE__FOURCC__GIF\n // - WUFFS_BASE__FOURCC__NIE\n // - WUFFS_BASE__FOURCC__PNG\n // - WUFFS_BASE__FOURCC__WBMP\n virtual wuffs_base__image_decoder::unique_ptr //\n OnImageFormat(uint32_t fourcc, wuffs_base__slice_u8 prefix);\n\n // OnImageConfig allocates the pixel buffer.\n //\n // allow_uninitialized_memory will be true if a valid background_color was\n // passed to DecodeImage, since the pixel buffer's contents will be\n // overwritten with that color after OnImageConfig returns.\n //\n // The default OnImageConfig implementation allocates either uninitialized or\n // zeroed memory. Zeroed memory typically corresponds to filling with opaque\n // black or " +
|
||||
"transparent black, depending on the pixel format.\n virtual AllocResult //\n OnImageConfig(const wuffs_base__image_config& image_config,\n bool allow_uninitialized_memory);\n\n // AllocWorkbuf allocates the work buffer. The allocated buffer's length\n // should be at least len_range.min_incl, but larger allocations (up to\n // len_range.max_incl) may have better performance (by using more memory).\n //\n // The default AllocWorkbuf implementation allocates len_range.max_incl bytes\n // of either uninitialized or zeroed memory.\n virtual AllocResult //\n AllocWorkbuf(wuffs_base__range_ii_u64 len_range,\n bool allow_uninitialized_memory);\n\n // Done is always the last Callback method called by DecodeImage, whether or\n // not parsing the input encountered an error. Even when successful, trailing\n // data may remain in input and buffer.\n //\n // The image_decoder is the one returned by OnImageFormat (if OnImageFormat\n // was successful), or a no-op unique_ptr otherwise. Like any un" +
|
||||
"ique_ptr,\n // ownership moves to the Done implementation.\n //\n // Do not keep a reference to buffer or buffer.data.ptr after Done returns,\n // as DecodeImage may then de-allocate the backing array.\n //\n // The default Done implementation is a no-op, other than running the\n // image_decoder unique_ptr destructor.\n virtual void //\n Done(DecodeImageResult& result,\n sync_io::Input& input,\n IOBuffer& buffer,\n wuffs_base__image_decoder::unique_ptr image_decoder);\n};\n\nextern const char DecodeImage_BufferIsTooShort[];\nextern const char DecodeImage_MaxInclDimensionExceeded[];\nextern const char DecodeImage_OutOfMemory[];\nextern const char DecodeImage_UnexpectedEndOfFile[];\nextern const char DecodeImage_UnsupportedImageFormat[];\nextern const char DecodeImage_UnsupportedPixelBlend[];\nextern const char DecodeImage_UnsupportedPixelConfiguration[];\nextern const char DecodeImage_UnsupportedPixelFormat[];\n\n// DecodeImage decodes the image data in input. A variety of image file formats\n// can be dec" +
|
||||
"oded, depending on what callbacks.OnImageFormat returns.\n//\n// For animated formats, only the first frame is returned, since the API is\n// simpler for synchronous I/O and having DecodeImage only return when\n// completely done, but rendering animation often involves handling other\n// events in between animation frames. To decode multiple frames of animated\n// images, or for asynchronous I/O (e.g. when decoding an image streamed over\n// the network), use Wuffs' lower level C API instead of its higher level,\n// simplified C++ API (the wuffs_aux API).\n//\n// The DecodeImageResult's fields depend on whether decoding succeeded:\n// - On total success, the error_message is empty and pixbuf.pixcfg.is_valid()\n// is true.\n// - On partial success (e.g. the input file was truncated but we are still\n// able to decode some of the pixels), error_message is non-empty but\n// pixbuf.pixcfg.is_valid() is still true. It is up to the caller whether to\n// accept or reject partial success.\n// - On failure, the error_me" +
|
||||
"ssage is non_empty and pixbuf.pixcfg.is_valid()\n// is false.\n//\n// The callbacks allocate the pixel buffer memory and work buffer memory. On\n// success, pixel buffer memory ownership is passed to the DecodeImage caller\n// as the returned pixbuf_mem_owner. Regardless of success or failure, the work\n// buffer memory is deleted.\n//\n// If override_pixel_format_repr is zero then the pixel buffer will have the\n// image file's natural pixel format. For example, GIF images' natural pixel\n// format is an indexed one.\n//\n// If override_pixel_format_repr is non-zero (and one of the constants listed\n// below) then the image will be decoded to that particular pixel format:\n// - WUFFS_BASE__PIXEL_FORMAT__BGR_565\n// - WUFFS_BASE__PIXEL_FORMAT__BGR\n// - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL\n// - WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL\n//\n// The pixel_blend (one of the constants listed below) determines how to\n// composite the decoded image over the pixel buffer's original pixels (as\n// returned by callbacks.OnImageCo" +
|
||||
"nfig):\n// - WUFFS_BASE__PIXEL_BLEND__SRC\n// - WUFFS_BASE__PIXEL_BLEND__SRC_OVER\n//\n// The background_color is used to fill the pixel buffer after\n// callbacks.OnImageConfig returns, if it is valid in the\n// wuffs_base__color_u32_argb_premul__is_valid sense. The default value,\n// 0x0000_0001, is not valid since its Blue channel value (0x01) is greater\n// than its Alpha channel value (0x00). A valid background_color will typically\n// be overwritten when pixel_blend is WUFFS_BASE__PIXEL_BLEND__SRC, but might\n// still be visible on partial (not total) success or when pixel_blend is\n// WUFFS_BASE__PIXEL_BLEND__SRC_OVER and the decoded image is not fully opaque.\n//\n// Decoding fails (with DecodeImage_MaxInclDimensionExceeded) if the image's\n// width or height is greater than max_incl_dimension.\nDecodeImageResult //\nDecodeImage(DecodeImageCallbacks& callbacks,\n sync_io::Input& input,\n uint32_t override_pixel_format_repr,\n wuffs_base__pixel_blend pixel_blend = WUFFS_BASE__PIXEL_BLE" +
|
||||
"ND__SRC,\n wuffs_base__color_u32_argb_premul background_color = 1, // Invalid.\n uint32_t max_incl_dimension = 1048575); // 0x000F_FFFF\n\n} // namespace wuffs_aux\n" +
|
||||
"// ---------------- Auxiliary - Image\n\nnamespace wuffs_aux {\n\nstruct DecodeImageResult {\n DecodeImageResult(MemOwner&& pixbuf_mem_owner0,\n wuffs_base__slice_u8 pixbuf_mem_slice0,\n wuffs_base__pixel_buffer pixbuf0,\n std::string&& error_message0);\n DecodeImageResult(std::string&& error_message0);\n\n MemOwner pixbuf_mem_owner;\n wuffs_base__slice_u8 pixbuf_mem_slice;\n wuffs_base__pixel_buffer pixbuf;\n std::string error_message;\n};\n\n// DecodeImageCallbacks are the callbacks given to DecodeImage. They are always\n// called in this order:\n// 1. SelectDecoder\n// 2. SelectPixfmt\n// 3. AllocPixbuf\n// 4. AllocWorkbuf\n// 5. Done\n//\n// It may return early - the third callback might not be invoked if the second\n// one fails - but the final callback (Done) is always invoked.\nclass DecodeImageCallbacks {\n public:\n // AllocResult holds a memory allocation (the result of malloc or new, a\n // statically allocated pointer, etc), or an error message. The memory i" +
|
||||
"s\n // de-allocated when mem_owner goes out of scope and is destroyed.\n struct AllocResult {\n AllocResult(MemOwner&& mem_owner0, wuffs_base__slice_u8 mem_slice0);\n AllocResult(std::string&& error_message0);\n\n MemOwner mem_owner;\n wuffs_base__slice_u8 mem_slice;\n std::string error_message;\n };\n\n // SelectDecoder returns the image decoder for the input data's file format.\n // Returning a nullptr means failure (DecodeImage_UnsupportedImageFormat).\n //\n // Common formats will have a FourCC value in the range [1 ..= 0x7FFF_FFFF],\n // such as WUFFS_BASE__FOURCC__JPEG. A zero FourCC value means that the\n // caller is responsible for examining the opening bytes (a prefix) of the\n // input data. SelectDecoder implementations should not modify those bytes.\n //\n // SelectDecoder might be called more than once, since some image file\n // formats can wrap others. For example, a nominal BMP file can actually\n // contain a JPEG or a PNG.\n //\n // The default SelectDecoder accepts the FOURCC codes" +
|
||||
" listed below. For\n // modular builds (i.e. when #define'ing WUFFS_CONFIG__MODULES), acceptance\n // of the ETC file format is optional (for each value of ETC) and depends on\n // the corresponding module to be enabled at compile time (i.e. #define'ing\n // WUFFS_CONFIG__MODULE__ETC).\n // - WUFFS_BASE__FOURCC__BMP\n // - WUFFS_BASE__FOURCC__GIF\n // - WUFFS_BASE__FOURCC__NIE\n // - WUFFS_BASE__FOURCC__PNG\n // - WUFFS_BASE__FOURCC__WBMP\n virtual wuffs_base__image_decoder::unique_ptr //\n SelectDecoder(uint32_t fourcc, wuffs_base__slice_u8 prefix);\n\n // SelectPixfmt returns the destination pixel format for AllocPixbuf. It\n // should return wuffs_base__make_pixel_format(etc) called with one of:\n // - WUFFS_BASE__PIXEL_FORMAT__BGR_565\n // - WUFFS_BASE__PIXEL_FORMAT__BGR\n // - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL\n // - WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL\n // or return image_config.pixcfg.pixel_format(). The latter means to use the\n // image file's natural pixel format. For example, GIF " +
|
||||
"images' natural pixel\n // format is an indexed one.\n //\n // Returning otherwise means failure (DecodeImage_UnsupportedPixelFormat).\n //\n // The default SelectPixfmt implementation returns\n // wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL)\n // which is 4 bytes per pixel (8 bits per channel × 4 channels).\n virtual wuffs_base__pixel_format //\n SelectPixfmt(const wuffs_base__image_config& image_config);\n\n // AllocPixbuf allocates the pixel buffer.\n //\n // allow_uninitialized_memory will be true if a valid background_color was\n // passed to DecodeImage, since the pixel buffer's contents will be\n // overwritten with that color after AllocPixbuf returns.\n //\n // The default AllocPixbuf implementation allocates either uninitialized or\n // zeroed memory. Zeroed memory typically corresponds to filling with opaque\n // black or transparent black, depending on the pixel format.\n virtual AllocResult //\n AllocPixbuf(const wuffs_base__image_config& image_config,\n b" +
|
||||
"ool allow_uninitialized_memory);\n\n // AllocWorkbuf allocates the work buffer. The allocated buffer's length\n // should be at least len_range.min_incl, but larger allocations (up to\n // len_range.max_incl) may have better performance (by using more memory).\n //\n // The default AllocWorkbuf implementation allocates len_range.max_incl bytes\n // of either uninitialized or zeroed memory.\n virtual AllocResult //\n AllocWorkbuf(wuffs_base__range_ii_u64 len_range,\n bool allow_uninitialized_memory);\n\n // Done is always the last Callback method called by DecodeImage, whether or\n // not parsing the input encountered an error. Even when successful, trailing\n // data may remain in input and buffer.\n //\n // The image_decoder is the one returned by SelectDecoder (if SelectDecoder\n // was successful), or a no-op unique_ptr otherwise. Like any unique_ptr,\n // ownership moves to the Done implementation.\n //\n // Do not keep a reference to buffer or buffer.data.ptr after Done returns,\n // as Decod" +
|
||||
"eImage may then de-allocate the backing array.\n //\n // The default Done implementation is a no-op, other than running the\n // image_decoder unique_ptr destructor.\n virtual void //\n Done(DecodeImageResult& result,\n sync_io::Input& input,\n IOBuffer& buffer,\n wuffs_base__image_decoder::unique_ptr image_decoder);\n};\n\nextern const char DecodeImage_BufferIsTooShort[];\nextern const char DecodeImage_MaxInclDimensionExceeded[];\nextern const char DecodeImage_OutOfMemory[];\nextern const char DecodeImage_UnexpectedEndOfFile[];\nextern const char DecodeImage_UnsupportedImageFormat[];\nextern const char DecodeImage_UnsupportedPixelBlend[];\nextern const char DecodeImage_UnsupportedPixelConfiguration[];\nextern const char DecodeImage_UnsupportedPixelFormat[];\n\n// DecodeImage decodes the image data in input. A variety of image file formats\n// can be decoded, depending on what callbacks.SelectDecoder returns.\n//\n// For animated formats, only the first frame is returned, since the API is\n// simpler for sync" +
|
||||
"hronous I/O and having DecodeImage only return when\n// completely done, but rendering animation often involves handling other\n// events in between animation frames. To decode multiple frames of animated\n// images, or for asynchronous I/O (e.g. when decoding an image streamed over\n// the network), use Wuffs' lower level C API instead of its higher level,\n// simplified C++ API (the wuffs_aux API).\n//\n// The DecodeImageResult's fields depend on whether decoding succeeded:\n// - On total success, the error_message is empty and pixbuf.pixcfg.is_valid()\n// is true.\n// - On partial success (e.g. the input file was truncated but we are still\n// able to decode some of the pixels), error_message is non-empty but\n// pixbuf.pixcfg.is_valid() is still true. It is up to the caller whether to\n// accept or reject partial success.\n// - On failure, the error_message is non_empty and pixbuf.pixcfg.is_valid()\n// is false.\n//\n// The callbacks allocate the pixel buffer memory and work buffer memory. On\n// success," +
|
||||
" pixel buffer memory ownership is passed to the DecodeImage caller\n// as the returned pixbuf_mem_owner. Regardless of success or failure, the work\n// buffer memory is deleted.\n//\n// The pixel_blend (one of the constants listed below) determines how to\n// composite the decoded image over the pixel buffer's original pixels (as\n// returned by callbacks.AllocPixbuf):\n// - WUFFS_BASE__PIXEL_BLEND__SRC\n// - WUFFS_BASE__PIXEL_BLEND__SRC_OVER\n//\n// The background_color is used to fill the pixel buffer after\n// callbacks.AllocPixbuf returns, if it is valid in the\n// wuffs_base__color_u32_argb_premul__is_valid sense. The default value,\n// 0x0000_0001, is not valid since its Blue channel value (0x01) is greater\n// than its Alpha channel value (0x00). A valid background_color will typically\n// be overwritten when pixel_blend is WUFFS_BASE__PIXEL_BLEND__SRC, but might\n// still be visible on partial (not total) success or when pixel_blend is\n// WUFFS_BASE__PIXEL_BLEND__SRC_OVER and the decoded image is not fully opaque.\n" +
|
||||
"//\n// Decoding fails (with DecodeImage_MaxInclDimensionExceeded) if the image's\n// width or height is greater than max_incl_dimension.\nDecodeImageResult //\nDecodeImage(DecodeImageCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__pixel_blend pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC,\n wuffs_base__color_u32_argb_premul background_color = 1, // Invalid.\n uint32_t max_incl_dimension = 1048575); // 0x000F_FFFF\n\n} // namespace wuffs_aux\n" +
|
||||
""
|
||||
|
||||
const AuxJsonCc = "" +
|
||||
|
||||
@@ -9469,14 +9469,14 @@ struct DecodeImageResult {
|
||||
|
||||
// DecodeImageCallbacks are the callbacks given to DecodeImage. They are always
|
||||
// called in this order:
|
||||
// 1. OnImageFormat
|
||||
// 2. OnImageConfig
|
||||
// 3. AllocWorkbuf
|
||||
// 4. Done
|
||||
// 1. SelectDecoder
|
||||
// 2. SelectPixfmt
|
||||
// 3. AllocPixbuf
|
||||
// 4. AllocWorkbuf
|
||||
// 5. Done
|
||||
//
|
||||
// It may return early - the third callback might not be invoked if the second
|
||||
// one fails (returns a non-empty error message) - but the final callback
|
||||
// (Done) is always invoked.
|
||||
// one fails - but the final callback (Done) is always invoked.
|
||||
class DecodeImageCallbacks {
|
||||
public:
|
||||
// AllocResult holds a memory allocation (the result of malloc or new, a
|
||||
@@ -9491,19 +9491,19 @@ class DecodeImageCallbacks {
|
||||
std::string error_message;
|
||||
};
|
||||
|
||||
// OnImageFormat returns the image decoder for the input data's file format.
|
||||
// SelectDecoder returns the image decoder for the input data's file format.
|
||||
// Returning a nullptr means failure (DecodeImage_UnsupportedImageFormat).
|
||||
//
|
||||
// Common formats will have a FourCC value in the range [1 ..= 0x7FFF_FFFF],
|
||||
// such as WUFFS_BASE__FOURCC__JPEG. A zero FourCC value means that the
|
||||
// caller is responsible for examining the opening bytes (a prefix) of the
|
||||
// input data. OnImageFormat implementations should not modify those bytes.
|
||||
// input data. SelectDecoder implementations should not modify those bytes.
|
||||
//
|
||||
// OnImageFormat might be called more than once, since some image file
|
||||
// SelectDecoder might be called more than once, since some image file
|
||||
// formats can wrap others. For example, a nominal BMP file can actually
|
||||
// contain a JPEG or a PNG.
|
||||
//
|
||||
// The default OnImageFormat accepts the FOURCC codes listed below. For
|
||||
// The default SelectDecoder accepts the FOURCC codes listed below. For
|
||||
// modular builds (i.e. when #define'ing WUFFS_CONFIG__MODULES), acceptance
|
||||
// of the ETC file format is optional (for each value of ETC) and depends on
|
||||
// the corresponding module to be enabled at compile time (i.e. #define'ing
|
||||
@@ -9514,20 +9514,38 @@ class DecodeImageCallbacks {
|
||||
// - WUFFS_BASE__FOURCC__PNG
|
||||
// - WUFFS_BASE__FOURCC__WBMP
|
||||
virtual wuffs_base__image_decoder::unique_ptr //
|
||||
OnImageFormat(uint32_t fourcc, wuffs_base__slice_u8 prefix);
|
||||
SelectDecoder(uint32_t fourcc, wuffs_base__slice_u8 prefix);
|
||||
|
||||
// OnImageConfig allocates the pixel buffer.
|
||||
// SelectPixfmt returns the destination pixel format for AllocPixbuf. It
|
||||
// should return wuffs_base__make_pixel_format(etc) called with one of:
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGR_565
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGR
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL
|
||||
// or return image_config.pixcfg.pixel_format(). The latter means to use the
|
||||
// image file's natural pixel format. For example, GIF images' natural pixel
|
||||
// format is an indexed one.
|
||||
//
|
||||
// Returning otherwise means failure (DecodeImage_UnsupportedPixelFormat).
|
||||
//
|
||||
// The default SelectPixfmt implementation returns
|
||||
// wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL)
|
||||
// which is 4 bytes per pixel (8 bits per channel × 4 channels).
|
||||
virtual wuffs_base__pixel_format //
|
||||
SelectPixfmt(const wuffs_base__image_config& image_config);
|
||||
|
||||
// AllocPixbuf allocates the pixel buffer.
|
||||
//
|
||||
// allow_uninitialized_memory will be true if a valid background_color was
|
||||
// passed to DecodeImage, since the pixel buffer's contents will be
|
||||
// overwritten with that color after OnImageConfig returns.
|
||||
// overwritten with that color after AllocPixbuf returns.
|
||||
//
|
||||
// The default OnImageConfig implementation allocates either uninitialized or
|
||||
// The default AllocPixbuf implementation allocates either uninitialized or
|
||||
// zeroed memory. Zeroed memory typically corresponds to filling with opaque
|
||||
// black or transparent black, depending on the pixel format.
|
||||
virtual AllocResult //
|
||||
OnImageConfig(const wuffs_base__image_config& image_config,
|
||||
bool allow_uninitialized_memory);
|
||||
AllocPixbuf(const wuffs_base__image_config& image_config,
|
||||
bool allow_uninitialized_memory);
|
||||
|
||||
// AllocWorkbuf allocates the work buffer. The allocated buffer's length
|
||||
// should be at least len_range.min_incl, but larger allocations (up to
|
||||
@@ -9543,7 +9561,7 @@ class DecodeImageCallbacks {
|
||||
// not parsing the input encountered an error. Even when successful, trailing
|
||||
// data may remain in input and buffer.
|
||||
//
|
||||
// The image_decoder is the one returned by OnImageFormat (if OnImageFormat
|
||||
// The image_decoder is the one returned by SelectDecoder (if SelectDecoder
|
||||
// was successful), or a no-op unique_ptr otherwise. Like any unique_ptr,
|
||||
// ownership moves to the Done implementation.
|
||||
//
|
||||
@@ -9569,7 +9587,7 @@ extern const char DecodeImage_UnsupportedPixelConfiguration[];
|
||||
extern const char DecodeImage_UnsupportedPixelFormat[];
|
||||
|
||||
// DecodeImage decodes the image data in input. A variety of image file formats
|
||||
// can be decoded, depending on what callbacks.OnImageFormat returns.
|
||||
// can be decoded, depending on what callbacks.SelectDecoder returns.
|
||||
//
|
||||
// For animated formats, only the first frame is returned, since the API is
|
||||
// simpler for synchronous I/O and having DecodeImage only return when
|
||||
@@ -9594,25 +9612,14 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
|
||||
// as the returned pixbuf_mem_owner. Regardless of success or failure, the work
|
||||
// buffer memory is deleted.
|
||||
//
|
||||
// If override_pixel_format_repr is zero then the pixel buffer will have the
|
||||
// image file's natural pixel format. For example, GIF images' natural pixel
|
||||
// format is an indexed one.
|
||||
//
|
||||
// If override_pixel_format_repr is non-zero (and one of the constants listed
|
||||
// below) then the image will be decoded to that particular pixel format:
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGR_565
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGR
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL
|
||||
//
|
||||
// The pixel_blend (one of the constants listed below) determines how to
|
||||
// composite the decoded image over the pixel buffer's original pixels (as
|
||||
// returned by callbacks.OnImageConfig):
|
||||
// returned by callbacks.AllocPixbuf):
|
||||
// - WUFFS_BASE__PIXEL_BLEND__SRC
|
||||
// - WUFFS_BASE__PIXEL_BLEND__SRC_OVER
|
||||
//
|
||||
// The background_color is used to fill the pixel buffer after
|
||||
// callbacks.OnImageConfig returns, if it is valid in the
|
||||
// callbacks.AllocPixbuf returns, if it is valid in the
|
||||
// wuffs_base__color_u32_argb_premul__is_valid sense. The default value,
|
||||
// 0x0000_0001, is not valid since its Blue channel value (0x01) is greater
|
||||
// than its Alpha channel value (0x00). A valid background_color will typically
|
||||
@@ -9625,7 +9632,6 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
|
||||
DecodeImageResult //
|
||||
DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
uint32_t override_pixel_format_repr,
|
||||
wuffs_base__pixel_blend pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
wuffs_base__color_u32_argb_premul background_color = 1, // Invalid.
|
||||
uint32_t max_incl_dimension = 1048575); // 0x000F_FFFF
|
||||
@@ -36910,7 +36916,7 @@ DecodeImageCallbacks::AllocResult::AllocResult(std::string&& error_message0)
|
||||
error_message(std::move(error_message0)) {}
|
||||
|
||||
wuffs_base__image_decoder::unique_ptr //
|
||||
DecodeImageCallbacks::OnImageFormat(uint32_t fourcc,
|
||||
DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
|
||||
wuffs_base__slice_u8 prefix) {
|
||||
switch (fourcc) {
|
||||
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BMP)
|
||||
@@ -36946,10 +36952,16 @@ DecodeImageCallbacks::OnImageFormat(uint32_t fourcc,
|
||||
return wuffs_base__image_decoder::unique_ptr(nullptr, &free);
|
||||
}
|
||||
|
||||
wuffs_base__pixel_format //
|
||||
DecodeImageCallbacks::SelectPixfmt(
|
||||
const wuffs_base__image_config& image_config) {
|
||||
return wuffs_base__make_pixel_format(
|
||||
WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL);
|
||||
}
|
||||
|
||||
DecodeImageCallbacks::AllocResult //
|
||||
DecodeImageCallbacks::OnImageConfig(
|
||||
const wuffs_base__image_config& image_config,
|
||||
bool allow_uninitialized_memory) {
|
||||
DecodeImageCallbacks::AllocPixbuf(const wuffs_base__image_config& image_config,
|
||||
bool allow_uninitialized_memory) {
|
||||
uint32_t w = image_config.pixcfg.width();
|
||||
uint32_t h = image_config.pixcfg.height();
|
||||
if ((w == 0) || (h == 0)) {
|
||||
@@ -37047,21 +37059,10 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
|
||||
DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
uint32_t override_pixel_format_repr,
|
||||
wuffs_base__pixel_blend pixel_blend,
|
||||
wuffs_base__color_u32_argb_premul background_color,
|
||||
uint32_t max_incl_dimension) {
|
||||
// Check args.
|
||||
switch (override_pixel_format_repr) {
|
||||
case 0:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
||||
break;
|
||||
default:
|
||||
return DecodeImageResult(DecodeImage_UnsupportedPixelFormat);
|
||||
}
|
||||
switch (pixel_blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
|
||||
@@ -37117,8 +37118,8 @@ redirect:
|
||||
image_decoder.reset();
|
||||
}
|
||||
|
||||
// Make the image decoder.
|
||||
image_decoder = callbacks.OnImageFormat(
|
||||
// Select the image decoder.
|
||||
image_decoder = callbacks.SelectDecoder(
|
||||
(uint32_t)fourcc,
|
||||
fourcc ? wuffs_base__empty_slice_u8() : io_buf.reader_slice());
|
||||
if (!image_decoder) {
|
||||
@@ -37150,14 +37151,24 @@ redirect:
|
||||
}
|
||||
} while (false);
|
||||
|
||||
// Apply the override pixel format.
|
||||
// Select the pixel format.
|
||||
uint32_t w = image_config.pixcfg.width();
|
||||
uint32_t h = image_config.pixcfg.height();
|
||||
if ((w > max_incl_dimension) || (h > max_incl_dimension)) {
|
||||
return DecodeImageResult(DecodeImage_MaxInclDimensionExceeded);
|
||||
}
|
||||
if (override_pixel_format_repr != 0) {
|
||||
image_config.pixcfg.set(override_pixel_format_repr,
|
||||
wuffs_base__pixel_format pixel_format = callbacks.SelectPixfmt(image_config);
|
||||
if (pixel_format.repr != image_config.pixcfg.pixel_format().repr) {
|
||||
switch (pixel_format.repr) {
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
||||
break;
|
||||
default:
|
||||
return DecodeImageResult(DecodeImage_UnsupportedPixelFormat);
|
||||
}
|
||||
image_config.pixcfg.set(pixel_format.repr,
|
||||
WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, w, h);
|
||||
}
|
||||
|
||||
@@ -37171,16 +37182,16 @@ redirect:
|
||||
}
|
||||
bool valid_background_color =
|
||||
wuffs_base__color_u32_argb_premul__is_valid(background_color);
|
||||
DecodeImageCallbacks::AllocResult oic_result =
|
||||
callbacks.OnImageConfig(image_config, valid_background_color);
|
||||
if (!oic_result.error_message.empty()) {
|
||||
return DecodeImageResult(std::move(oic_result.error_message));
|
||||
} else if (oic_result.mem_slice.len < pixbuf_len_min_incl) {
|
||||
DecodeImageCallbacks::AllocResult alloc_pixbuf_result =
|
||||
callbacks.AllocPixbuf(image_config, valid_background_color);
|
||||
if (!alloc_pixbuf_result.error_message.empty()) {
|
||||
return DecodeImageResult(std::move(alloc_pixbuf_result.error_message));
|
||||
} else if (alloc_pixbuf_result.mem_slice.len < pixbuf_len_min_incl) {
|
||||
return DecodeImageResult(DecodeImage_BufferIsTooShort);
|
||||
}
|
||||
wuffs_base__pixel_buffer pixel_buffer;
|
||||
wuffs_base__status pb_sfs_status =
|
||||
pixel_buffer.set_from_slice(&image_config.pixcfg, oic_result.mem_slice);
|
||||
wuffs_base__status pb_sfs_status = pixel_buffer.set_from_slice(
|
||||
&image_config.pixcfg, alloc_pixbuf_result.mem_slice);
|
||||
if (!pb_sfs_status.is_ok()) {
|
||||
return DecodeImageResult(pb_sfs_status.message());
|
||||
}
|
||||
@@ -37251,8 +37262,8 @@ redirect:
|
||||
}
|
||||
}
|
||||
}
|
||||
return DecodeImageResult(std::move(oic_result.mem_owner),
|
||||
oic_result.mem_slice, pixel_buffer,
|
||||
return DecodeImageResult(std::move(alloc_pixbuf_result.mem_owner),
|
||||
alloc_pixbuf_result.mem_slice, pixel_buffer,
|
||||
std::move(message));
|
||||
}
|
||||
|
||||
@@ -37261,7 +37272,6 @@ redirect:
|
||||
DecodeImageResult //
|
||||
DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
uint32_t override_pixel_format_repr,
|
||||
wuffs_base__pixel_blend pixel_blend,
|
||||
wuffs_base__color_u32_argb_premul background_color,
|
||||
uint32_t max_incl_dimension) {
|
||||
@@ -37276,9 +37286,9 @@ DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
}
|
||||
|
||||
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);
|
||||
DecodeImageResult result = DecodeImage0(
|
||||
image_decoder, callbacks, input, *io_buf, override_pixel_format_repr,
|
||||
pixel_blend, background_color, max_incl_dimension);
|
||||
DecodeImageResult result =
|
||||
DecodeImage0(image_decoder, callbacks, input, *io_buf, pixel_blend,
|
||||
background_color, max_incl_dimension);
|
||||
callbacks.Done(result, input, *io_buf, std::move(image_decoder));
|
||||
return result;
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user