diff options
Diffstat (limited to 'drivers/png')
| -rw-r--r-- | drivers/png/image_loader_png.cpp | 355 | ||||
| -rw-r--r-- | drivers/png/image_loader_png.h | 9 | ||||
| -rw-r--r-- | drivers/png/png_driver_common.cpp | 205 | ||||
| -rw-r--r-- | drivers/png/png_driver_common.h | 48 | ||||
| -rw-r--r-- | drivers/png/resource_saver_png.cpp | 137 |
5 files changed, 306 insertions, 448 deletions
diff --git a/drivers/png/image_loader_png.cpp b/drivers/png/image_loader_png.cpp index 0bf432c78a..f257fafd93 100644 --- a/drivers/png/image_loader_png.cpp +++ b/drivers/png/image_loader_png.cpp @@ -32,186 +32,26 @@ #include "core/os/os.h" #include "core/print_string.h" +#include "drivers/png/png_driver_common.h" #include <string.h> -void ImageLoaderPNG::_read_png_data(png_structp png_ptr, png_bytep data, png_size_t p_length) { - - FileAccess *f = (FileAccess *)png_get_io_ptr(png_ptr); - f->get_buffer((uint8_t *)data, p_length); -} - -/* -png_structp png_ptr = png_create_read_struct_2 - (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, - user_error_fn, user_warning_fn, (png_voidp) - user_mem_ptr, user_malloc_fn, user_free_fn); -*/ -static png_voidp _png_malloc_fn(png_structp png_ptr, png_size_t size) { - - return memalloc(size); -} - -static void _png_free_fn(png_structp png_ptr, png_voidp ptr) { - - memfree(ptr); -} - -static void _png_error_function(png_structp, png_const_charp text) { - - ERR_PRINT(text); -} - -static void _png_warn_function(png_structp, png_const_charp text) { -#ifdef TOOLS_ENABLED - if (Engine::get_singleton()->is_editor_hint()) { - if (String(text).begins_with("iCCP")) return; // silences annoying spam emitted to output every time the user opened assetlib - } -#endif - WARN_PRINT(text); -} - -typedef void(PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); - -Error ImageLoaderPNG::_load_image(void *rf_up, png_rw_ptr p_func, Ref<Image> p_image) { - - png_structp png; - png_infop info; - - //png = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, NULL, NULL); - - png = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, _png_error_function, _png_warn_function, (png_voidp)NULL, - _png_malloc_fn, _png_free_fn); - - ERR_FAIL_COND_V(!png, ERR_OUT_OF_MEMORY); - - info = png_create_info_struct(png); - if (!info) { - png_destroy_read_struct(&png, NULL, NULL); - ERR_PRINT("Out of Memory"); - return ERR_OUT_OF_MEMORY; - } - - if (setjmp(png_jmpbuf(png))) { - - png_destroy_read_struct(&png, NULL, NULL); - ERR_PRINT("PNG Corrupted"); - return ERR_FILE_CORRUPT; - } - - png_set_read_fn(png, (void *)rf_up, p_func); - - png_uint_32 width, height; - int depth, color; - - png_read_info(png, info); - png_get_IHDR(png, info, &width, &height, &depth, &color, NULL, NULL, NULL); - - //https://svn.gov.pt/projects/ccidadao/repository/middleware-offline/trunk/_src/eidmw/FreeImagePTEiD/Source/FreeImage/PluginPNG.cpp - //png_get_text(png,info,) - /* - printf("Image width:%i\n", width); - printf("Image Height:%i\n", height); - printf("Bit depth:%i\n", depth); - printf("Color type:%i\n", color); - */ - - bool update_info = false; - - if (depth < 8) { //only bit dept 8 per channel is handled - - png_set_packing(png); - update_info = true; - }; - - if (png_get_color_type(png, info) == PNG_COLOR_TYPE_PALETTE) { - png_set_palette_to_rgb(png); - update_info = true; - } - - if (depth > 8) { - png_set_strip_16(png); - update_info = true; - } - - if (png_get_valid(png, info, PNG_INFO_tRNS)) { - //png_set_expand_gray_1_2_4_to_8(png); - png_set_tRNS_to_alpha(png); - update_info = true; - } - - if (update_info) { - png_read_update_info(png, info); - png_get_IHDR(png, info, &width, &height, &depth, &color, NULL, NULL, NULL); - } - - int components = 0; - - Image::Format fmt; - switch (color) { - - case PNG_COLOR_TYPE_GRAY: { - - fmt = Image::FORMAT_L8; - components = 1; - } break; - case PNG_COLOR_TYPE_GRAY_ALPHA: { - - fmt = Image::FORMAT_LA8; - components = 2; - } break; - case PNG_COLOR_TYPE_RGB: { - - fmt = Image::FORMAT_RGB8; - components = 3; - } break; - case PNG_COLOR_TYPE_RGB_ALPHA: { - - fmt = Image::FORMAT_RGBA8; - components = 4; - } break; - default: { +Error ImageLoaderPNG::load_image(Ref<Image> p_image, FileAccess *f, bool p_force_linear, float p_scale) { - ERR_PRINT("INVALID PNG TYPE"); - png_destroy_read_struct(&png, &info, NULL); - return ERR_UNAVAILABLE; - } break; + const size_t buffer_size = f->get_len(); + PoolVector<uint8_t> file_buffer; + Error err = file_buffer.resize(buffer_size); + if (err) { + f->close(); + return err; } - - //int rowsize = png_get_rowbytes(png, info); - int rowsize = components * width; - - PoolVector<uint8_t> dstbuff; - - dstbuff.resize(rowsize * height); - - PoolVector<uint8_t>::Write dstbuff_write = dstbuff.write(); - - uint8_t *data = dstbuff_write.ptr(); - - uint8_t **row_p = memnew_arr(uint8_t *, height); - - for (unsigned int i = 0; i < height; i++) { - row_p[i] = &data[components * width * i]; + { + PoolVector<uint8_t>::Write writer = file_buffer.write(); + f->get_buffer(writer.ptr(), buffer_size); + f->close(); } - - png_read_image(png, (png_bytep *)row_p); - - memdelete_arr(row_p); - - p_image->create(width, height, 0, fmt, dstbuff); - - png_destroy_read_struct(&png, &info, NULL); - - return OK; -} - -Error ImageLoaderPNG::load_image(Ref<Image> p_image, FileAccess *f, bool p_force_linear, float p_scale) { - - Error err = _load_image(f, _read_png_data, p_image); - f->close(); - - return err; + PoolVector<uint8_t>::Read reader = file_buffer.read(); + return PNGDriverCommon::png_to_image(reader.ptr(), buffer_size, p_image); } void ImageLoaderPNG::get_recognized_extensions(List<String> *p_extensions) const { @@ -219,178 +59,53 @@ void ImageLoaderPNG::get_recognized_extensions(List<String> *p_extensions) const p_extensions->push_back("png"); } -struct PNGReadStatus { - - uint32_t offset; - uint32_t size; - const unsigned char *image; -}; - -static void user_read_data(png_structp png_ptr, png_bytep data, png_size_t p_length) { - - PNGReadStatus *rstatus; - rstatus = (PNGReadStatus *)png_get_io_ptr(png_ptr); - - png_size_t to_read = MIN(p_length, rstatus->size - rstatus->offset); - memcpy(data, &rstatus->image[rstatus->offset], to_read); - rstatus->offset += to_read; - - if (to_read < p_length) { - memset(&data[to_read], 0, p_length - to_read); - } -} - -static Ref<Image> _load_mem_png(const uint8_t *p_png, int p_size) { - - PNGReadStatus prs; - prs.image = p_png; - prs.offset = 0; - prs.size = p_size; +Ref<Image> ImageLoaderPNG::load_mem_png(const uint8_t *p_png, int p_size) { Ref<Image> img; img.instance(); - Error err = ImageLoaderPNG::_load_image(&prs, user_read_data, img); + + Error err = PNGDriverCommon::png_to_image(p_png, p_size, img); ERR_FAIL_COND_V(err, Ref<Image>()); return img; } -static Ref<Image> _lossless_unpack_png(const PoolVector<uint8_t> &p_data) { +Ref<Image> ImageLoaderPNG::lossless_unpack_png(const PoolVector<uint8_t> &p_data) { - int len = p_data.size(); + const int len = p_data.size(); ERR_FAIL_COND_V(len < 4, Ref<Image>()); PoolVector<uint8_t>::Read r = p_data.read(); ERR_FAIL_COND_V(r[0] != 'P' || r[1] != 'N' || r[2] != 'G' || r[3] != ' ', Ref<Image>()); - return _load_mem_png(&r[4], len - 4); -} - -static void _write_png_data(png_structp png_ptr, png_bytep data, png_size_t p_length) { - - PoolVector<uint8_t> &v = *(PoolVector<uint8_t> *)png_get_io_ptr(png_ptr); - int vs = v.size(); - - v.resize(vs + p_length); - PoolVector<uint8_t>::Write w = v.write(); - copymem(&w[vs], data, p_length); + return load_mem_png(&r[4], len - 4); } -static PoolVector<uint8_t> _lossless_pack_png(const Ref<Image> &p_image) { - - Ref<Image> img = p_image->duplicate(); - - if (img->is_compressed()) - img->decompress(); - - ERR_FAIL_COND_V(img->is_compressed(), PoolVector<uint8_t>()); - - png_structp png_ptr; - png_infop info_ptr; - png_bytep *row_pointers; - - /* initialize stuff */ - png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); +PoolVector<uint8_t> ImageLoaderPNG::lossless_pack_png(const Ref<Image> &p_image) { - ERR_FAIL_COND_V(!png_ptr, PoolVector<uint8_t>()); + PoolVector<uint8_t> out_buffer; - info_ptr = png_create_info_struct(png_ptr); - - ERR_FAIL_COND_V(!info_ptr, PoolVector<uint8_t>()); - - if (setjmp(png_jmpbuf(png_ptr))) { + // add Godot's own "PNG " prefix + if (out_buffer.resize(4) != OK) { ERR_FAIL_V(PoolVector<uint8_t>()); } - PoolVector<uint8_t> ret; - ret.push_back('P'); - ret.push_back('N'); - ret.push_back('G'); - ret.push_back(' '); - png_set_write_fn(png_ptr, &ret, _write_png_data, NULL); - - /* write header */ - if (setjmp(png_jmpbuf(png_ptr))) { - ERR_FAIL_V(PoolVector<uint8_t>()); + // scope for writer lifetime + { + // must be closed before call to image_to_png + PoolVector<uint8_t>::Write writer = out_buffer.write(); + copymem(writer.ptr(), "PNG ", 4); } - int pngf = 0; - int cs = 0; - - switch (img->get_format()) { - - case Image::FORMAT_L8: { - - pngf = PNG_COLOR_TYPE_GRAY; - cs = 1; - } break; - case Image::FORMAT_LA8: { - - pngf = PNG_COLOR_TYPE_GRAY_ALPHA; - cs = 2; - } break; - case Image::FORMAT_RGB8: { - - pngf = PNG_COLOR_TYPE_RGB; - cs = 3; - } break; - case Image::FORMAT_RGBA8: { - - pngf = PNG_COLOR_TYPE_RGB_ALPHA; - cs = 4; - } break; - default: { - - if (img->detect_alpha()) { - - img->convert(Image::FORMAT_RGBA8); - pngf = PNG_COLOR_TYPE_RGB_ALPHA; - cs = 4; - } else { - - img->convert(Image::FORMAT_RGB8); - pngf = PNG_COLOR_TYPE_RGB; - cs = 3; - } - } - } - - int w = img->get_width(); - int h = img->get_height(); - png_set_IHDR(png_ptr, info_ptr, w, h, - 8, pngf, PNG_INTERLACE_NONE, - PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); - - png_write_info(png_ptr, info_ptr); - - /* write bytes */ - if (setjmp(png_jmpbuf(png_ptr))) { + Error err = PNGDriverCommon::image_to_png(p_image, out_buffer); + if (err) { ERR_FAIL_V(PoolVector<uint8_t>()); } - PoolVector<uint8_t>::Read r = img->get_data().read(); - - row_pointers = (png_bytep *)memalloc(sizeof(png_bytep) * h); - for (int i = 0; i < h; i++) { - - row_pointers[i] = (png_bytep)&r[i * w * cs]; - } - png_write_image(png_ptr, row_pointers); - - memfree(row_pointers); - - /* end write */ - if (setjmp(png_jmpbuf(png_ptr))) { - - ERR_FAIL_V(PoolVector<uint8_t>()); - } - - png_write_end(png_ptr, NULL); - - return ret; + return out_buffer; } ImageLoaderPNG::ImageLoaderPNG() { - Image::_png_mem_loader_func = _load_mem_png; - Image::lossless_unpacker = _lossless_unpack_png; - Image::lossless_packer = _lossless_pack_png; + Image::_png_mem_loader_func = load_mem_png; + Image::lossless_unpacker = lossless_unpack_png; + Image::lossless_packer = lossless_pack_png; } diff --git a/drivers/png/image_loader_png.h b/drivers/png/image_loader_png.h index c3951979c3..cc789f95d6 100644 --- a/drivers/png/image_loader_png.h +++ b/drivers/png/image_loader_png.h @@ -33,17 +33,16 @@ #include "core/io/image_loader.h" -#include <png.h> - /** @author Juan Linietsky <reduzio@gmail.com> */ class ImageLoaderPNG : public ImageFormatLoader { - - static void _read_png_data(png_structp png_ptr, png_bytep data, png_size_t p_length); +private: + static PoolVector<uint8_t> lossless_pack_png(const Ref<Image> &p_image); + static Ref<Image> lossless_unpack_png(const PoolVector<uint8_t> &p_data); + static Ref<Image> load_mem_png(const uint8_t *p_png, int p_size); public: - static Error _load_image(void *rf_up, png_rw_ptr p_func, Ref<Image> p_image); virtual Error load_image(Ref<Image> p_image, FileAccess *f, bool p_force_linear, float p_scale); virtual void get_recognized_extensions(List<String> *p_extensions) const; ImageLoaderPNG(); diff --git a/drivers/png/png_driver_common.cpp b/drivers/png/png_driver_common.cpp new file mode 100644 index 0000000000..0e849bf2fe --- /dev/null +++ b/drivers/png/png_driver_common.cpp @@ -0,0 +1,205 @@ +/*************************************************************************/ +/* png_driver_common.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#include "png_driver_common.h" + +#include "core/os/os.h" + +#include <png.h> +#include <string.h> + +namespace PNGDriverCommon { + +// Print any warnings. +// On error, set explain and return true. +// Call should be wrapped in ERR_FAIL_COND +static bool check_error(const png_image &image) { + const png_uint_32 failed = PNG_IMAGE_FAILED(image); + if (failed & PNG_IMAGE_ERROR) { + ERR_EXPLAINC(image.message); + return true; + } else if (failed) { +#ifdef TOOLS_ENABLED + // suppress this warning, to avoid log spam when opening assetlib + const static char *const noisy = "iCCP: known incorrect sRGB profile"; + const Engine *const eng = Engine::get_singleton(); + if (eng && eng->is_editor_hint() && !strcmp(image.message, noisy)) { + return false; + } +#endif + WARN_PRINT(image.message); + } + return false; +} + +Error png_to_image(const uint8_t *p_source, size_t p_size, Ref<Image> p_image) { + + png_image png_img; + zeromem(&png_img, sizeof(png_img)); + png_img.version = PNG_IMAGE_VERSION; + + // fetch image properties + int success = png_image_begin_read_from_memory(&png_img, p_source, p_size); + ERR_FAIL_COND_V(check_error(png_img), ERR_FILE_CORRUPT); + ERR_FAIL_COND_V(!success, ERR_FILE_CORRUPT); + + // flags to be masked out of input format to give target format + const png_uint_32 format_mask = ~( + // convert component order to RGBA + PNG_FORMAT_FLAG_BGR | PNG_FORMAT_FLAG_AFIRST + // convert 16 bit components to 8 bit + | PNG_FORMAT_FLAG_LINEAR + // convert indexed image to direct color + | PNG_FORMAT_FLAG_COLORMAP); + + png_img.format &= format_mask; + + Image::Format dest_format; + switch (png_img.format) { + case PNG_FORMAT_GRAY: + dest_format = Image::FORMAT_L8; + break; + case PNG_FORMAT_GA: + dest_format = Image::FORMAT_LA8; + break; + case PNG_FORMAT_RGB: + dest_format = Image::FORMAT_RGB8; + break; + case PNG_FORMAT_RGBA: + dest_format = Image::FORMAT_RGBA8; + break; + default: + png_image_free(&png_img); // only required when we return before finish_read + ERR_PRINT("Unsupported png format"); + return ERR_UNAVAILABLE; + } + + const png_uint_32 stride = PNG_IMAGE_ROW_STRIDE(png_img); + PoolVector<uint8_t> buffer; + Error err = buffer.resize(PNG_IMAGE_BUFFER_SIZE(png_img, stride)); + if (err) { + png_image_free(&png_img); // only required when we return before finish_read + return err; + } + PoolVector<uint8_t>::Write writer = buffer.write(); + + // read image data to buffer and release libpng resources + success = png_image_finish_read(&png_img, NULL, writer.ptr(), stride, NULL); + ERR_FAIL_COND_V(check_error(png_img), ERR_FILE_CORRUPT); + ERR_FAIL_COND_V(!success, ERR_FILE_CORRUPT); + + p_image->create(png_img.width, png_img.height, 0, dest_format, buffer); + + return OK; +} + +Error image_to_png(const Ref<Image> &p_image, PoolVector<uint8_t> &p_buffer) { + + Ref<Image> source_image = p_image->duplicate(); + + if (source_image->is_compressed()) + source_image->decompress(); + + ERR_FAIL_COND_V(source_image->is_compressed(), FAILED); + + png_image png_img; + zeromem(&png_img, sizeof(png_img)); + png_img.version = PNG_IMAGE_VERSION; + png_img.width = source_image->get_width(); + png_img.height = source_image->get_height(); + + switch (source_image->get_format()) { + case Image::FORMAT_L8: + png_img.format = PNG_FORMAT_GRAY; + break; + case Image::FORMAT_LA8: + png_img.format = PNG_FORMAT_GA; + break; + case Image::FORMAT_RGB8: + png_img.format = PNG_FORMAT_RGB; + break; + case Image::FORMAT_RGBA8: + png_img.format = PNG_FORMAT_RGBA; + break; + default: + if (source_image->detect_alpha()) { + source_image->convert(Image::FORMAT_RGBA8); + png_img.format = PNG_FORMAT_RGBA; + } else { + source_image->convert(Image::FORMAT_RGB8); + png_img.format = PNG_FORMAT_RGB; + } + } + + const PoolVector<uint8_t> image_data = source_image->get_data(); + const PoolVector<uint8_t>::Read reader = image_data.read(); + + // we may be passed a buffer with existing content we're expected to append to + const int buffer_offset = p_buffer.size(); + + const size_t png_size_estimate = PNG_IMAGE_PNG_SIZE_MAX(png_img); + + // try with estimated size + size_t compressed_size = png_size_estimate; + int success = 0; + { // scope writer lifetime + Error err = p_buffer.resize(buffer_offset + png_size_estimate); + ERR_FAIL_COND_V(err, err); + + PoolVector<uint8_t>::Write writer = p_buffer.write(); + success = png_image_write_to_memory(&png_img, &writer[buffer_offset], + &compressed_size, 0, reader.ptr(), 0, NULL); + ERR_FAIL_COND_V(check_error(png_img), FAILED); + } + if (!success) { + if (compressed_size <= png_size_estimate) { + // buffer was big enough, must be some other error + ERR_FAIL_V(FAILED); + } + + // write failed due to buffer size, resize and retry + Error err = p_buffer.resize(buffer_offset + compressed_size); + ERR_FAIL_COND_V(err, err); + + PoolVector<uint8_t>::Write writer = p_buffer.write(); + success = png_image_write_to_memory(&png_img, &writer[buffer_offset], + &compressed_size, 0, reader.ptr(), 0, NULL); + ERR_FAIL_COND_V(check_error(png_img), FAILED); + ERR_FAIL_COND_V(!success, FAILED); + } + + // trim buffer size to content + Error err = p_buffer.resize(buffer_offset + compressed_size); + ERR_FAIL_COND_V(err, err); + + return OK; +} + +} // namespace PNGDriverCommon diff --git a/drivers/png/png_driver_common.h b/drivers/png/png_driver_common.h new file mode 100644 index 0000000000..3ff87759fb --- /dev/null +++ b/drivers/png/png_driver_common.h @@ -0,0 +1,48 @@ +/*************************************************************************/ +/* png_driver_common.h */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */ +/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ + +#ifndef PNG_DRIVER_COMMON_H +#define PNG_DRIVER_COMMON_H + +#include "core/image.h" +#include "core/pool_vector.h" + +namespace PNGDriverCommon { + +// Attempt to load png from buffer (p_source, p_size) into p_image +Error png_to_image(const uint8_t *p_source, size_t p_size, Ref<Image> p_image); + +// Append p_image, as a png, to p_buffer. +// Contents of p_buffer is unspecified if error returned. +Error image_to_png(const Ref<Image> &p_image, PoolVector<uint8_t> &p_buffer); + +} // namespace PNGDriverCommon + +#endif diff --git a/drivers/png/resource_saver_png.cpp b/drivers/png/resource_saver_png.cpp index 9e8043cbea..89e8ee32cc 100644 --- a/drivers/png/resource_saver_png.cpp +++ b/drivers/png/resource_saver_png.cpp @@ -32,17 +32,9 @@ #include "core/image.h" #include "core/os/file_access.h" -#include "core/project_settings.h" +#include "drivers/png/png_driver_common.h" #include "scene/resources/texture.h" -#include <png.h> - -static void _write_png_data(png_structp png_ptr, png_bytep data, png_size_t p_length) { - - FileAccess *f = (FileAccess *)png_get_io_ptr(png_ptr); - f->store_buffer((const uint8_t *)data, p_length); -} - Error ResourceSaverPNG::save(const String &p_path, const RES &p_resource, uint32_t p_flags) { Ref<ImageTexture> texture = p_resource; @@ -55,129 +47,27 @@ Error ResourceSaverPNG::save(const String &p_path, const RES &p_resource, uint32 Error err = save_image(p_path, img); - if (err == OK) { - } - return err; }; Error ResourceSaverPNG::save_image(const String &p_path, const Ref<Image> &p_img) { - Ref<Image> img = p_img->duplicate(); - - if (img->is_compressed()) - img->decompress(); - - ERR_FAIL_COND_V(img->is_compressed(), ERR_INVALID_PARAMETER); - - png_structp png_ptr; - png_infop info_ptr; - png_bytep *row_pointers; - - /* initialize stuff */ - png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); - - ERR_FAIL_COND_V(!png_ptr, ERR_CANT_CREATE); + PoolVector<uint8_t> buffer; + Error err = PNGDriverCommon::image_to_png(p_img, buffer); + ERR_FAIL_COND_V(err, err); + FileAccess *file = FileAccess::open(p_path, FileAccess::WRITE, &err); + ERR_FAIL_COND_V(err, err); - info_ptr = png_create_info_struct(png_ptr); + PoolVector<uint8_t>::Read reader = buffer.read(); - ERR_FAIL_COND_V(!info_ptr, ERR_CANT_CREATE); - - if (setjmp(png_jmpbuf(png_ptr))) { - ERR_FAIL_V(ERR_CANT_OPEN); - } - //change this - Error err; - FileAccess *f = FileAccess::open(p_path, FileAccess::WRITE, &err); - if (err) { - ERR_FAIL_V(err); - } - - png_set_write_fn(png_ptr, f, _write_png_data, NULL); - - /* write header */ - if (setjmp(png_jmpbuf(png_ptr))) { - ERR_FAIL_V(ERR_CANT_OPEN); + file->store_buffer(reader.ptr(), buffer.size()); + if (file->get_error() != OK && file->get_error() != ERR_FILE_EOF) { + memdelete(file); + return ERR_CANT_CREATE; } - int pngf = 0; - int cs = 0; - - switch (img->get_format()) { - - case Image::FORMAT_L8: { - - pngf = PNG_COLOR_TYPE_GRAY; - cs = 1; - } break; - case Image::FORMAT_LA8: { - - pngf = PNG_COLOR_TYPE_GRAY_ALPHA; - cs = 2; - } break; - case Image::FORMAT_RGB8: { - - pngf = PNG_COLOR_TYPE_RGB; - cs = 3; - } break; - case Image::FORMAT_RGBA8: { - - pngf = PNG_COLOR_TYPE_RGB_ALPHA; - cs = 4; - } break; - default: { - - if (img->detect_alpha()) { - - img->convert(Image::FORMAT_RGBA8); - pngf = PNG_COLOR_TYPE_RGB_ALPHA; - cs = 4; - } else { - - img->convert(Image::FORMAT_RGB8); - pngf = PNG_COLOR_TYPE_RGB; - cs = 3; - } - } - } - - int w = img->get_width(); - int h = img->get_height(); - png_set_IHDR(png_ptr, info_ptr, w, h, - 8, pngf, PNG_INTERLACE_NONE, - PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); - - png_write_info(png_ptr, info_ptr); - - /* write bytes */ - if (setjmp(png_jmpbuf(png_ptr))) { - memdelete(f); - ERR_FAIL_V(ERR_CANT_OPEN); - } - - PoolVector<uint8_t>::Read r = img->get_data().read(); - - row_pointers = (png_bytep *)memalloc(sizeof(png_bytep) * h); - for (int i = 0; i < h; i++) { - - row_pointers[i] = (png_bytep)&r[i * w * cs]; - } - png_write_image(png_ptr, row_pointers); - - memfree(row_pointers); - - /* end write */ - if (setjmp(png_jmpbuf(png_ptr))) { - - memdelete(f); - ERR_FAIL_V(ERR_CANT_OPEN); - } - - png_write_end(png_ptr, NULL); - memdelete(f); - - /* cleanup heap allocation */ - png_destroy_write_struct(&png_ptr, &info_ptr); + file->close(); + memdelete(file); return OK; } @@ -186,6 +76,7 @@ bool ResourceSaverPNG::recognize(const RES &p_resource) const { return (p_resource.is_valid() && p_resource->is_class("ImageTexture")); } + void ResourceSaverPNG::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const { if (Object::cast_to<Texture>(*p_resource)) { |