From 5c0985aeec8970145f3fb30493b1317497f28fde Mon Sep 17 00:00:00 2001 From: Arkadiy Illarionov Date: Fri, 23 Feb 2024 16:16:22 +0300 Subject: [PATCH] Let image loader backend decide how to process image buffer Remove ImageLoaderBackendFuncLoad. Also move static functions to anonymous namespace. --- src/image-load-collection.cc | 28 +++-- src/image-load-cr3.cc | 11 +- src/image-load-dds.cc | 56 +++++---- src/image-load-djvu.cc | 35 +++--- src/image-load-external.cc | 27 ++-- src/image-load-ffmpegthumbnailer.cc | 49 ++++---- src/image-load-gdk.cc | 23 ++-- src/image-load-heif.cc | 33 ++--- src/image-load-j2k.cc | 186 +++++++++++++++------------- src/image-load-jpeg.cc | 14 +-- src/image-load-jpeg.h | 2 +- src/image-load-jpegxl.cc | 31 +++-- src/image-load-pdf.cc | 31 +++-- src/image-load-psd.cc | 49 ++++---- src/image-load-svgz.cc | 24 ++-- src/image-load-tiff.cc | 57 ++++----- src/image-load-webp.cc | 29 +++-- src/image-load-zxscr.cc | 31 +++-- src/image-load.cc | 39 +++--- src/image-load.h | 4 +- 20 files changed, 419 insertions(+), 340 deletions(-) diff --git a/src/image-load-collection.cc b/src/image-load-collection.cc index 88da33e7..6aaa2691 100644 --- a/src/image-load-collection.cc +++ b/src/image-load-collection.cc @@ -35,6 +35,9 @@ #include "options.h" #include "ui-fileops.h" +namespace +{ + struct ImageLoaderCOLLECTION { ImageLoaderBackendCbAreaUpdated area_updated_cb; ImageLoaderBackendCbSize size_cb; @@ -46,7 +49,7 @@ struct ImageLoaderCOLLECTION { gboolean abort; }; -static gboolean image_loader_collection_load(gpointer loader, const guchar *, gsize, GError **) +gboolean image_loader_collection_write(gpointer loader, const guchar *, gsize &chunk_size, gsize count, GError **) { auto ld = static_cast(loader); auto il = static_cast(ld->data); @@ -116,10 +119,11 @@ static gboolean image_loader_collection_load(gpointer loader, const guchar *, gs g_string_free(file_names, TRUE); } } + chunk_size = count; return ret; } -static gpointer image_loader_collection_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_collection_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto loader = g_new0(ImageLoaderCOLLECTION, 1); loader->area_updated_cb = area_updated_cb; @@ -129,53 +133,55 @@ static gpointer image_loader_collection_new(ImageLoaderBackendCbAreaUpdated area return loader; } -static void image_loader_collection_set_size(gpointer loader, int width, int height) +void image_loader_collection_set_size(gpointer loader, int width, int height) { auto ld = static_cast(loader); ld->requested_width = width; ld->requested_height = height; } -static GdkPixbuf* image_loader_collection_get_pixbuf(gpointer loader) +GdkPixbuf* image_loader_collection_get_pixbuf(gpointer loader) { auto ld = static_cast(loader); return ld->pixbuf; } -static gchar* image_loader_collection_get_format_name(gpointer) +gchar* image_loader_collection_get_format_name(gpointer) { return g_strdup("collection"); } -static gchar** image_loader_collection_get_format_mime_types(gpointer) + +gchar** image_loader_collection_get_format_mime_types(gpointer) { static const gchar *mime[] = {"image/png", nullptr}; return g_strdupv(const_cast(mime)); } -static gboolean image_loader_collection_close(gpointer, GError **) +gboolean image_loader_collection_close(gpointer, GError **) { return TRUE; } -static void image_loader_collection_abort(gpointer loader) +void image_loader_collection_abort(gpointer loader) { auto ld = static_cast(loader); ld->abort = TRUE; } -static void image_loader_collection_free(gpointer loader) +void image_loader_collection_free(gpointer loader) { auto ld = static_cast(loader); if (ld->pixbuf) g_object_unref(ld->pixbuf); g_free(ld); } +} // namespace + void image_loader_backend_set_collection(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_collection_new; funcs->set_size = image_loader_collection_set_size; - funcs->load = image_loader_collection_load; - funcs->write = nullptr; + funcs->write = image_loader_collection_write; funcs->get_pixbuf = image_loader_collection_get_pixbuf; funcs->close = image_loader_collection_close; funcs->abort = image_loader_collection_abort; diff --git a/src/image-load-cr3.cc b/src/image-load-cr3.cc index f3a0a477..7cbdcde8 100644 --- a/src/image-load-cr3.cc +++ b/src/image-load-cr3.cc @@ -36,7 +36,7 @@ namespace { -gboolean image_loader_cr3_load(gpointer loader, const guchar *buf, gsize count, GError **error) +gboolean image_loader_cr3_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **error) { /** @FIXME Just start search at where full size jpeg should be, * then search through the file looking for a jpeg end-marker @@ -78,7 +78,12 @@ gboolean image_loader_cr3_load(gpointer loader, const guchar *buf, gsize count, return FALSE; } - return image_loader_jpeg_load(loader, buf + n + 12, i, error); + gboolean ret = image_loader_jpeg_write(loader, buf + n + 12, chunk_size, i, error);; + if (ret) + { + chunk_size = count; + } + return ret; } gchar* image_loader_cr3_get_format_name(gpointer) @@ -98,7 +103,7 @@ void image_loader_backend_set_cr3(ImageLoaderBackend *funcs) { image_loader_backend_set_jpeg(funcs); - funcs->load = image_loader_cr3_load; + funcs->write = image_loader_cr3_write; funcs->get_format_name = image_loader_cr3_get_format_name; funcs->get_format_mime_types = image_loader_cr3_get_format_mime_types; diff --git a/src/image-load-dds.cc b/src/image-load-dds.cc index 1ed14a71..af8b8583 100644 --- a/src/image-load-dds.cc +++ b/src/image-load-dds.cc @@ -34,6 +34,9 @@ #include "image-load.h" +namespace +{ + struct ImageLoaderDDS { ImageLoaderBackendCbAreaUpdated area_updated_cb; ImageLoaderBackendCbSize size_cb; @@ -45,7 +48,7 @@ struct ImageLoaderDDS { gboolean abort; }; -static void free_buffer(guchar *pixels, gpointer) +void free_buffer(guchar *pixels, gpointer) { g_free(pixels); } @@ -113,22 +116,22 @@ enum { }; // RGBA Masks -static const uint A1R5G5B5_MASKS[] = { 0x7C00, 0x03E0, 0x001F, 0x8000 }; -static const uint X1R5G5B5_MASKS[] = { 0x7C00, 0x03E0, 0x001F, 0x0000 }; -static const uint A4R4G4B4_MASKS[] = { 0x0F00, 0x00F0, 0x000F, 0xF000 }; -static const uint X4R4G4B4_MASKS[] = { 0x0F00, 0x00F0, 0x000F, 0x0000 }; -static const uint R5G6B5_MASKS[] = { 0xF800, 0x07E0, 0x001F, 0x0000 }; -static const uint R8G8B8_MASKS[] = { 0xFF0000, 0x00FF00, 0x0000FF, 0x000000 }; -static const uint A8B8G8R8_MASKS[] = { 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000 }; -static const uint X8B8G8R8_MASKS[] = { 0x000000FF, 0x0000FF00, 0x00FF0000, 0x00000000 }; -static const uint A8R8G8B8_MASKS[] = { 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000 }; -static const uint X8R8G8B8_MASKS[] = { 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000 }; +constexpr uint A1R5G5B5_MASKS[] = { 0x7C00, 0x03E0, 0x001F, 0x8000 }; +constexpr uint X1R5G5B5_MASKS[] = { 0x7C00, 0x03E0, 0x001F, 0x0000 }; +constexpr uint A4R4G4B4_MASKS[] = { 0x0F00, 0x00F0, 0x000F, 0xF000 }; +constexpr uint X4R4G4B4_MASKS[] = { 0x0F00, 0x00F0, 0x000F, 0x0000 }; +constexpr uint R5G6B5_MASKS[] = { 0xF800, 0x07E0, 0x001F, 0x0000 }; +constexpr uint R8G8B8_MASKS[] = { 0xFF0000, 0x00FF00, 0x0000FF, 0x000000 }; +constexpr uint A8B8G8R8_MASKS[] = { 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000 }; +constexpr uint X8B8G8R8_MASKS[] = { 0x000000FF, 0x0000FF00, 0x00FF0000, 0x00000000 }; +constexpr uint A8R8G8B8_MASKS[] = { 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000 }; +constexpr uint X8R8G8B8_MASKS[] = { 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000 }; // BIT4 = 17 * index; -static const uint BIT5[] = { 0, 8, 16, 25, 33, 41, 49, 58, 66, 74, 82, 90, 99, 107, 115, 123, 132, 140, 148, 156, 165, 173, 181, 189, 197, 206, 214, 222, 230, 239, 247, 255 }; -static const uint BIT6[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 130, 134, 138, 142, 146, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 255 }; +constexpr uint BIT5[] = { 0, 8, 16, 25, 33, 41, 49, 58, 66, 74, 82, 90, 99, 107, 115, 123, 132, 140, 148, 156, 165, 173, 181, 189, 197, 206, 214, 222, 230, 239, 247, 255 }; +constexpr uint BIT6[] = { 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 130, 134, 138, 142, 146, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 255 }; -static uint ddsGetType(const unsigned char *buffer) { +uint ddsGetType(const unsigned char *buffer) { uint type = 0; uint flags = ddsGetPixelFormatFlags(buffer); if ((flags & 0x04) != 0) { @@ -534,7 +537,7 @@ guchar *ddsReadX8R8G8B8(uint width, uint height, const unsigned char *buffer) { return reinterpret_cast(pixels); } -static gboolean image_loader_dds_load (gpointer loader, const guchar *buf, gsize, GError **) +gboolean image_loader_dds_write (gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **) { auto ld = static_cast(loader); uint width = ddsGetWidth(buf); @@ -563,11 +566,12 @@ static gboolean image_loader_dds_load (gpointer loader, const guchar *buf, gsize } ld->pixbuf = gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, TRUE, 8, width, height, rowstride, free_buffer, nullptr); ld->area_updated_cb(loader, 0, 0, width, height, ld->data); + chunk_size = count; return TRUE; } } -static gpointer image_loader_dds_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_dds_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto loader = g_new0(ImageLoaderDDS, 1); loader->area_updated_cb = area_updated_cb; @@ -577,53 +581,55 @@ static gpointer image_loader_dds_new(ImageLoaderBackendCbAreaUpdated area_update return loader; } -static void image_loader_dds_set_size(gpointer loader, int width, int height) +void image_loader_dds_set_size(gpointer loader, int width, int height) { auto ld = static_cast(loader); ld->requested_width = width; ld->requested_height = height; } -static GdkPixbuf* image_loader_dds_get_pixbuf(gpointer loader) +GdkPixbuf* image_loader_dds_get_pixbuf(gpointer loader) { auto ld = static_cast(loader); return ld->pixbuf; } -static gchar* image_loader_dds_get_format_name(gpointer) +gchar* image_loader_dds_get_format_name(gpointer) { return g_strdup("dds"); } -static gchar** image_loader_dds_get_format_mime_types(gpointer) + +gchar** image_loader_dds_get_format_mime_types(gpointer) { static const gchar *mime[] = {"image/vnd-ms.dds", nullptr}; return g_strdupv(const_cast(mime)); } -static gboolean image_loader_dds_close(gpointer, GError **) +gboolean image_loader_dds_close(gpointer, GError **) { return TRUE; } -static void image_loader_dds_abort(gpointer loader) +void image_loader_dds_abort(gpointer loader) { auto ld = static_cast(loader); ld->abort = TRUE; } -static void image_loader_dds_free(gpointer loader) +void image_loader_dds_free(gpointer loader) { auto ld = static_cast(loader); if (ld->pixbuf) g_object_unref(ld->pixbuf); g_free(ld); } +} // namespace + void image_loader_backend_set_dds(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_dds_new; funcs->set_size = image_loader_dds_set_size; - funcs->load = image_loader_dds_load; - funcs->write = nullptr; + funcs->write = image_loader_dds_write; funcs->get_pixbuf = image_loader_dds_get_pixbuf; funcs->close = image_loader_dds_close; funcs->abort = image_loader_dds_abort; diff --git a/src/image-load-djvu.cc b/src/image-load-djvu.cc index b15391e4..36c9b432 100644 --- a/src/image-load-djvu.cc +++ b/src/image-load-djvu.cc @@ -32,6 +32,9 @@ #include "image-load.h" +namespace +{ + struct ImageLoaderDJVU { ImageLoaderBackendCbAreaUpdated area_updated_cb; ImageLoaderBackendCbSize size_cb; @@ -45,12 +48,12 @@ struct ImageLoaderDJVU { gint page_total; }; -static void free_buffer(guchar *pixels, gpointer) +void free_buffer(guchar *pixels, gpointer) { - g_free (pixels);; + g_free (pixels); } -static gboolean image_loader_djvu_load(gpointer loader, const guchar *buf, gsize count, GError **) +gboolean image_loader_djvu_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **) { auto ld = static_cast(loader); ddjvu_context_t *ctx; @@ -114,10 +117,11 @@ static gboolean image_loader_djvu_load(gpointer loader, const guchar *buf, gsize ddjvu_document_release(doc); ddjvu_context_release(ctx); + chunk_size = count; return TRUE; } -static gpointer image_loader_djvu_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_djvu_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto loader = g_new0(ImageLoaderDJVU, 1); loader->area_updated_cb = area_updated_cb; @@ -127,68 +131,69 @@ static gpointer image_loader_djvu_new(ImageLoaderBackendCbAreaUpdated area_updat return loader; } -static void image_loader_djvu_set_size(gpointer loader, int width, int height) +void image_loader_djvu_set_size(gpointer loader, int width, int height) { auto ld = static_cast(loader); ld->requested_width = width; ld->requested_height = height; } -static GdkPixbuf* image_loader_djvu_get_pixbuf(gpointer loader) +GdkPixbuf* image_loader_djvu_get_pixbuf(gpointer loader) { auto ld = static_cast(loader); return ld->pixbuf; } -static gchar* image_loader_djvu_get_format_name(gpointer) +gchar* image_loader_djvu_get_format_name(gpointer) { return g_strdup("djvu"); } -static gchar** image_loader_djvu_get_format_mime_types(gpointer) +gchar** image_loader_djvu_get_format_mime_types(gpointer) { static const gchar *mime[] = {"image/vnd.djvu", nullptr}; return g_strdupv(const_cast(mime)); } -static void image_loader_djvu_set_page_num(gpointer loader, gint page_num) +void image_loader_djvu_set_page_num(gpointer loader, gint page_num) { auto ld = static_cast(loader); ld->page_num = page_num; } -static gint image_loader_djvu_get_page_total(gpointer loader) +gint image_loader_djvu_get_page_total(gpointer loader) { auto ld = static_cast(loader); return ld->page_total; } -static gboolean image_loader_djvu_close(gpointer, GError **) +gboolean image_loader_djvu_close(gpointer, GError **) { return TRUE; } -static void image_loader_djvu_abort(gpointer loader) +void image_loader_djvu_abort(gpointer loader) { auto ld = static_cast(loader); ld->abort = TRUE; } -static void image_loader_djvu_free(gpointer loader) +void image_loader_djvu_free(gpointer loader) { auto ld = static_cast(loader); if (ld->pixbuf) g_object_unref(ld->pixbuf); g_free(ld); } +} // namespace + void image_loader_backend_set_djvu(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_djvu_new; funcs->set_size = image_loader_djvu_set_size; - funcs->load = image_loader_djvu_load; - funcs->write = nullptr; + funcs->write = image_loader_djvu_write; funcs->get_pixbuf = image_loader_djvu_get_pixbuf; funcs->close = image_loader_djvu_close; funcs->abort = image_loader_djvu_abort; diff --git a/src/image-load-external.cc b/src/image-load-external.cc index 6118e6eb..3f285ce7 100644 --- a/src/image-load-external.cc +++ b/src/image-load-external.cc @@ -30,6 +30,9 @@ #include "options.h" #include "ui-fileops.h" +namespace +{ + struct ImageLoaderExternal { ImageLoaderBackendCbAreaUpdated area_updated_cb; ImageLoaderBackendCbSize size_cb; @@ -41,7 +44,7 @@ struct ImageLoaderExternal { gboolean abort; }; -static gboolean image_loader_external_load(gpointer loader, const guchar *, gsize, GError **) +gboolean image_loader_external_write(gpointer loader, const guchar *, gsize &chunk_size, gsize count, GError **) { auto ld = static_cast(loader); auto il = static_cast(ld->data); @@ -67,10 +70,11 @@ static gboolean image_loader_external_load(gpointer loader, const guchar *, gsiz g_free(randname); g_free(tilde_filename); + chunk_size = count; return TRUE; } -static gpointer image_loader_external_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_external_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto loader = g_new0(ImageLoaderExternal, 1); loader->area_updated_cb = area_updated_cb; @@ -80,54 +84,55 @@ static gpointer image_loader_external_new(ImageLoaderBackendCbAreaUpdated area_u return loader; } -static void image_loader_external_set_size(gpointer loader, int width, int height) +void image_loader_external_set_size(gpointer loader, int width, int height) { auto ld = static_cast(loader); ld->requested_width = width; ld->requested_height = height; } -static GdkPixbuf* image_loader_external_get_pixbuf(gpointer loader) +GdkPixbuf* image_loader_external_get_pixbuf(gpointer loader) { auto ld = static_cast(loader); return ld->pixbuf; } -static gchar* image_loader_external_get_format_name(gpointer) +gchar* image_loader_external_get_format_name(gpointer) { return g_strdup("external"); } -static gchar** image_loader_external_get_format_mime_types(gpointer) +gchar** image_loader_external_get_format_mime_types(gpointer) { static const gchar *mime[] = {"application/octet-stream", nullptr}; return g_strdupv(const_cast(mime)); } -static gboolean image_loader_external_close(gpointer, GError **) +gboolean image_loader_external_close(gpointer, GError **) { return TRUE; } -static void image_loader_external_abort(gpointer loader) +void image_loader_external_abort(gpointer loader) { auto ld = static_cast(loader); ld->abort = TRUE; } -static void image_loader_external_free(gpointer loader) +void image_loader_external_free(gpointer loader) { auto ld = static_cast(loader); if (ld->pixbuf) g_object_unref(ld->pixbuf); g_free(ld); } +} // namespace + void image_loader_backend_set_external(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_external_new; funcs->set_size = image_loader_external_set_size; - funcs->load = image_loader_external_load; - funcs->write = nullptr; + funcs->write = image_loader_external_write; funcs->get_pixbuf = image_loader_external_get_pixbuf; funcs->close = image_loader_external_close; funcs->abort = image_loader_external_abort; diff --git a/src/image-load-ffmpegthumbnailer.cc b/src/image-load-ffmpegthumbnailer.cc index 446ec804..29ffaa4b 100644 --- a/src/image-load-ffmpegthumbnailer.cc +++ b/src/image-load-ffmpegthumbnailer.cc @@ -36,6 +36,9 @@ #include "image-load.h" #include "options.h" +namespace +{ + struct ImageLoaderFT { ImageLoaderBackendCbAreaUpdated area_updated_cb; ImageLoaderBackendCbSize size_cb; @@ -52,7 +55,7 @@ struct ImageLoaderFT { }; #if HAVE_FFMPEGTHUMBNAILER_RGB -static void image_loader_ft_log_cb(ThumbnailerLogLevel log_level, const char* msg) +void image_loader_ft_log_cb(ThumbnailerLogLevel log_level, const char* msg) { if (log_level == ThumbnailerLogLevelError) log_printf("ImageLoaderFFmpegthumbnailer: %s",msg); @@ -68,18 +71,18 @@ void image_loader_ft_destroy_image_data(guchar *, gpointer data) video_thumbnailer_destroy_image_data (image); } -static gchar* image_loader_ft_get_format_name(gpointer) +gchar* image_loader_ft_get_format_name(gpointer) { return g_strdup("ffmpeg"); } -static gchar** image_loader_ft_get_format_mime_types(gpointer) +gchar** image_loader_ft_get_format_mime_types(gpointer) { static const gchar *mime[] = {"video/mp4", nullptr}; return g_strdupv(const_cast(mime)); } -static gpointer image_loader_ft_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_ft_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto loader = g_new0(ImageLoaderFT, 1); @@ -98,7 +101,7 @@ static gpointer image_loader_ft_new(ImageLoaderBackendCbAreaUpdated area_updated return loader; } -static void image_loader_ft_set_size(gpointer loader, int width, int height) +void image_loader_ft_set_size(gpointer loader, int width, int height) { auto lft = static_cast(loader); lft->requested_width = width; @@ -106,7 +109,7 @@ static void image_loader_ft_set_size(gpointer loader, int width, int height) DEBUG_1("TG: setting size, w=%d, h=%d", width, height); } -static gboolean image_loader_ft_load (gpointer loader, const guchar *, gsize, GError **) +gboolean image_loader_ft_write (gpointer loader, const guchar *, gsize &chunk_size, gsize count, GError **) { auto lft = static_cast(loader); auto il = static_cast(lft->data); @@ -140,11 +143,11 @@ static gboolean image_loader_ft_load (gpointer loader, const guchar *, gsize, GE image_stream = g_memory_input_stream_new_from_data (image->image_data_ptr, image->image_data_size, nullptr); if (image_stream == nullptr) - { - video_thumbnailer_destroy_image_data (image); - DEBUG_1("FFmpegthumbnailer: cannot open stream for %s", il->fd->path); - return FALSE; - } + { + video_thumbnailer_destroy_image_data (image); + DEBUG_1("FFmpegthumbnailer: cannot open stream for %s", il->fd->path); + return FALSE; + } lft->pixbuf = gdk_pixbuf_new_from_stream (image_stream, nullptr, nullptr); lft->size_cb(loader, gdk_pixbuf_get_width(lft->pixbuf), gdk_pixbuf_get_height(lft->pixbuf), lft->data); @@ -158,32 +161,33 @@ static gboolean image_loader_ft_load (gpointer loader, const guchar *, gsize, GE return FALSE; } -/** See comment in image_loader_area_prepared_cb - * Geeqie uses area_prepared signal to fill pixbuf with background color. - * We can't do it here as pixbuf already contains the data - * lft->area_prepared_cb(loader, lft->data); - */ + /** See comment in image_loader_area_prepared_cb + * Geeqie uses area_prepared signal to fill pixbuf with background color. + * We can't do it here as pixbuf already contains the data + * lft->area_prepared_cb(loader, lft->data); + */ lft->area_updated_cb(loader, 0, 0, gdk_pixbuf_get_width(lft->pixbuf), gdk_pixbuf_get_height(lft->pixbuf), lft->data); + chunk_size = count; return TRUE; } -static GdkPixbuf* image_loader_ft_get_pixbuf(gpointer loader) +GdkPixbuf* image_loader_ft_get_pixbuf(gpointer loader) { auto lft = static_cast(loader); return lft->pixbuf; } -static void image_loader_ft_abort(gpointer) +void image_loader_ft_abort(gpointer) { } -static gboolean image_loader_ft_close(gpointer, GError **) +gboolean image_loader_ft_close(gpointer, GError **) { return TRUE; } -static void image_loader_ft_free(gpointer loader) +void image_loader_ft_free(gpointer loader) { auto lft = static_cast(loader); if (lft->pixbuf) g_object_unref(lft->pixbuf); @@ -192,12 +196,13 @@ static void image_loader_ft_free(gpointer loader) g_free(lft); } +} // namespace + void image_loader_backend_set_ft(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_ft_new; funcs->set_size = image_loader_ft_set_size; - funcs->load = image_loader_ft_load; - funcs->write = nullptr; + funcs->write = image_loader_ft_write; funcs->get_pixbuf = image_loader_ft_get_pixbuf; funcs->close = image_loader_ft_close; funcs->abort = image_loader_ft_abort; diff --git a/src/image-load-gdk.cc b/src/image-load-gdk.cc index 802cd1cf..b2773499 100644 --- a/src/image-load-gdk.cc +++ b/src/image-load-gdk.cc @@ -28,8 +28,10 @@ #include "filedata.h" #include "image-load.h" +namespace +{ -static gchar* image_loader_gdk_get_format_name(gpointer loader) +gchar* image_loader_gdk_get_format_name(gpointer loader) { GdkPixbufFormat *format; @@ -42,12 +44,12 @@ static gchar* image_loader_gdk_get_format_name(gpointer loader) return nullptr; } -static gchar** image_loader_gdk_get_format_mime_types(gpointer loader) +gchar** image_loader_gdk_get_format_mime_types(gpointer loader) { return gdk_pixbuf_format_get_mime_types(gdk_pixbuf_loader_get_format(GDK_PIXBUF_LOADER(loader))); } -static gpointer image_loader_gdk_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_gdk_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto il = static_cast(data); GdkPixbufLoader *loader; @@ -69,21 +71,27 @@ static gpointer image_loader_gdk_new(ImageLoaderBackendCbAreaUpdated area_update return loader; } -static void image_loader_gdk_abort(gpointer) +gboolean image_loader_gdk_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize, GError **error) +{ + return gdk_pixbuf_loader_write(GDK_PIXBUF_LOADER(loader), buf, chunk_size, error); +} + +void image_loader_gdk_abort(gpointer) { } -static void image_loader_gdk_free(gpointer loader) +void image_loader_gdk_free(gpointer loader) { g_object_unref(G_OBJECT(loader)); } +} // namespace + void image_loader_backend_set_default(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_gdk_new; funcs->set_size = reinterpret_cast(gdk_pixbuf_loader_set_size); - funcs->load = nullptr; - funcs->write = reinterpret_cast(gdk_pixbuf_loader_write); + funcs->write = image_loader_gdk_write; funcs->get_pixbuf = reinterpret_cast(gdk_pixbuf_loader_get_pixbuf); funcs->close = reinterpret_cast(gdk_pixbuf_loader_close); funcs->abort = image_loader_gdk_abort; @@ -93,5 +101,4 @@ void image_loader_backend_set_default(ImageLoaderBackend *funcs) funcs->get_format_mime_types = image_loader_gdk_get_format_mime_types; } - /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */ diff --git a/src/image-load-heif.cc b/src/image-load-heif.cc index 296a5b8d..e013e154 100644 --- a/src/image-load-heif.cc +++ b/src/image-load-heif.cc @@ -33,6 +33,9 @@ #include "debug.h" #include "image-load.h" +namespace +{ + struct ImageLoaderHEIF { ImageLoaderBackendCbAreaUpdated area_updated_cb; ImageLoaderBackendCbSize size_cb; @@ -46,12 +49,12 @@ struct ImageLoaderHEIF { gint page_total; }; -static void free_buffer(guchar *, gpointer data) +void free_buffer(guchar *, gpointer data) { heif_image_release(static_cast(data)); } -static gboolean image_loader_heif_load(gpointer loader, const guchar *buf, gsize count, GError **) +gboolean image_loader_heif_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **) { auto ld = static_cast(loader); struct heif_context* ctx; @@ -113,10 +116,11 @@ static gboolean image_loader_heif_load(gpointer loader, const guchar *buf, gsize heif_context_free(ctx); + chunk_size = count; return TRUE; } -static gpointer image_loader_heif_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_heif_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto loader = g_new0(ImageLoaderHEIF, 1); loader->area_updated_cb = area_updated_cb; @@ -127,68 +131,69 @@ static gpointer image_loader_heif_new(ImageLoaderBackendCbAreaUpdated area_updat return loader; } -static void image_loader_heif_set_size(gpointer loader, int width, int height) +void image_loader_heif_set_size(gpointer loader, int width, int height) { auto ld = static_cast(loader); ld->requested_width = width; ld->requested_height = height; } -static GdkPixbuf* image_loader_heif_get_pixbuf(gpointer loader) +GdkPixbuf* image_loader_heif_get_pixbuf(gpointer loader) { auto ld = static_cast(loader); return ld->pixbuf; } -static gchar* image_loader_heif_get_format_name(gpointer) +gchar* image_loader_heif_get_format_name(gpointer) { return g_strdup("heif"); } -static gchar** image_loader_heif_get_format_mime_types(gpointer) +gchar** image_loader_heif_get_format_mime_types(gpointer) { static const gchar *mime[] = {"image/heic", nullptr}; return g_strdupv(const_cast(mime)); } -static void image_loader_heif_set_page_num(gpointer loader, gint page_num) +void image_loader_heif_set_page_num(gpointer loader, gint page_num) { auto ld = static_cast(loader); ld->page_num = page_num; } -static gint image_loader_heif_get_page_total(gpointer loader) +gint image_loader_heif_get_page_total(gpointer loader) { auto ld = static_cast(loader); return ld->page_total; } -static gboolean image_loader_heif_close(gpointer, GError **) +gboolean image_loader_heif_close(gpointer, GError **) { return TRUE; } -static void image_loader_heif_abort(gpointer loader) +void image_loader_heif_abort(gpointer loader) { auto ld = static_cast(loader); ld->abort = TRUE; } -static void image_loader_heif_free(gpointer loader) +void image_loader_heif_free(gpointer loader) { auto ld = static_cast(loader); if (ld->pixbuf) g_object_unref(ld->pixbuf); g_free(ld); } +} // namespace + void image_loader_backend_set_heif(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_heif_new; funcs->set_size = image_loader_heif_set_size; - funcs->load = image_loader_heif_load; - funcs->write = nullptr; + funcs->write = image_loader_heif_write; funcs->get_pixbuf = image_loader_heif_get_pixbuf; funcs->close = image_loader_heif_close; funcs->abort = image_loader_heif_abort; diff --git a/src/image-load-j2k.cc b/src/image-load-j2k.cc index 66892015..84aa03b6 100644 --- a/src/image-load-j2k.cc +++ b/src/image-load-j2k.cc @@ -37,6 +37,9 @@ #include "intl.h" #include "misc.h" +namespace +{ + struct ImageLoaderJ2K { ImageLoaderBackendCbAreaUpdated area_updated_cb; ImageLoaderBackendCbSize size_cb; @@ -48,134 +51,139 @@ struct ImageLoaderJ2K { gboolean abort; }; -static void free_buffer(guchar *pixels, gpointer) +void free_buffer(guchar *pixels, gpointer) { g_free (pixels); } struct opj_buffer_info_t { - OPJ_BYTE* buf; - OPJ_BYTE* cur; - OPJ_SIZE_T len; + OPJ_BYTE* buf; + OPJ_BYTE* cur; + OPJ_SIZE_T len; }; -static OPJ_SIZE_T opj_read_from_buffer (void* pdst, OPJ_SIZE_T len, opj_buffer_info_t* psrc) +OPJ_SIZE_T opj_read_from_buffer (void* pdst, OPJ_SIZE_T len, opj_buffer_info_t* psrc) { - OPJ_SIZE_T n = psrc->buf + psrc->len - psrc->cur; + OPJ_SIZE_T n = psrc->buf + psrc->len - psrc->cur; - if (n) { - if (n > len) - n = len; + if (n) + { + if (n > len) + n = len; - memcpy (pdst, psrc->cur, n); - psrc->cur += n; - } - else - n = static_cast(-1); + memcpy (pdst, psrc->cur, n); + psrc->cur += n; + } + else + n = static_cast(-1); - return n; + return n; } -static OPJ_SIZE_T opj_write_to_buffer (void* p_buffer, OPJ_SIZE_T p_nb_bytes, +OPJ_SIZE_T opj_write_to_buffer (void* p_buffer, OPJ_SIZE_T p_nb_bytes, opj_buffer_info_t* p_source_buffer) { - void* pbuf = p_source_buffer->buf; - void* pcur = p_source_buffer->cur; + void* pbuf = p_source_buffer->buf; + void* pcur = p_source_buffer->cur; - OPJ_SIZE_T len = p_source_buffer->len; + OPJ_SIZE_T len = p_source_buffer->len; - if (0 == len) - len = 1; + if (0 == len) + len = 1; - OPJ_SIZE_T dist = static_cast(pcur) - static_cast(pbuf); - OPJ_SIZE_T n = len - dist; - g_assert (dist <= len); + OPJ_SIZE_T dist = static_cast(pcur) - static_cast(pbuf); + OPJ_SIZE_T n = len - dist; + g_assert (dist <= len); - while (n < p_nb_bytes) { - len *= 2; - n = len - dist; - } + while (n < p_nb_bytes) + { + len *= 2; + n = len - dist; + } - if (len != p_source_buffer->len) { - pbuf = malloc (len); + if (len != p_source_buffer->len) + { + pbuf = malloc (len); - if (nullptr == pbuf) - return static_cast(-1); + if (nullptr == pbuf) + return static_cast(-1); - if (p_source_buffer->buf) { - memcpy (pbuf, p_source_buffer->buf, dist); - free (p_source_buffer->buf); - } + if (p_source_buffer->buf) + { + memcpy (pbuf, p_source_buffer->buf, dist); + free (p_source_buffer->buf); + } - p_source_buffer->buf = static_cast(pbuf); - p_source_buffer->cur = static_cast(pbuf) + dist; - p_source_buffer->len = len; - } + p_source_buffer->buf = static_cast(pbuf); + p_source_buffer->cur = static_cast(pbuf) + dist; + p_source_buffer->len = len; + } - memcpy (p_source_buffer->cur, p_buffer, p_nb_bytes); - p_source_buffer->cur += p_nb_bytes; + memcpy (p_source_buffer->cur, p_buffer, p_nb_bytes); + p_source_buffer->cur += p_nb_bytes; - return p_nb_bytes; + return p_nb_bytes; } -static OPJ_SIZE_T opj_skip_from_buffer (OPJ_SIZE_T len, opj_buffer_info_t* psrc) +OPJ_SIZE_T opj_skip_from_buffer (OPJ_SIZE_T len, opj_buffer_info_t* psrc) { - OPJ_SIZE_T n = psrc->buf + psrc->len - psrc->cur; + OPJ_SIZE_T n = psrc->buf + psrc->len - psrc->cur; - if (n) { - if (n > len) - n = len; + if (n) + { + if (n > len) + n = len; - psrc->cur += len; - } - else - n = static_cast(-1); + psrc->cur += len; + } + else + n = static_cast(-1); - return n; + return n; } -static OPJ_BOOL opj_seek_from_buffer (OPJ_OFF_T len, opj_buffer_info_t* psrc) +OPJ_BOOL opj_seek_from_buffer (OPJ_OFF_T len, opj_buffer_info_t* psrc) { - OPJ_SIZE_T n = psrc->len; + OPJ_SIZE_T n = psrc->len; - if (n > static_cast(len)) - n = len; + if (n > static_cast(len)) + n = len; - psrc->cur = psrc->buf + n; + psrc->cur = psrc->buf + n; - return OPJ_TRUE; + return OPJ_TRUE; } opj_stream_t* OPJ_CALLCONV opj_stream_create_buffer_stream (opj_buffer_info_t* psrc, OPJ_BOOL input) { - if (!psrc) - return nullptr; + if (!psrc) + return nullptr; - opj_stream_t* ps = opj_stream_default_create (input); + opj_stream_t* ps = opj_stream_default_create (input); - if (nullptr == ps) - return nullptr; + if (nullptr == ps) + return nullptr; - opj_stream_set_user_data (ps, psrc, nullptr); - opj_stream_set_user_data_length (ps, psrc->len); + opj_stream_set_user_data (ps, psrc, nullptr); + opj_stream_set_user_data_length (ps, psrc->len); - if (input) - opj_stream_set_read_function ( - ps, reinterpret_cast(opj_read_from_buffer)); - else - opj_stream_set_write_function( - ps,reinterpret_cast(opj_write_to_buffer)); + if (input) + opj_stream_set_read_function ( + ps, reinterpret_cast(opj_read_from_buffer)); + else + opj_stream_set_write_function( + ps,reinterpret_cast(opj_write_to_buffer)); - opj_stream_set_skip_function ( - ps, reinterpret_cast(opj_skip_from_buffer)); + opj_stream_set_skip_function ( + ps, reinterpret_cast(opj_skip_from_buffer)); - opj_stream_set_seek_function ( - ps, reinterpret_cast(opj_seek_from_buffer)); + opj_stream_set_seek_function ( + ps, reinterpret_cast(opj_seek_from_buffer)); - return ps; + return ps; } -static gboolean image_loader_j2k_load(gpointer loader, const guchar *buf, gsize count, GError **) +gboolean image_loader_j2k_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **) { auto ld = static_cast(loader); opj_stream_t *stream; @@ -287,10 +295,11 @@ static gboolean image_loader_j2k_load(gpointer loader, const guchar *buf, gsize if (stream) opj_stream_destroy (stream); + chunk_size = count; return TRUE; } -static gpointer image_loader_j2k_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_j2k_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto loader = g_new0(ImageLoaderJ2K, 1); loader->area_updated_cb = area_updated_cb; @@ -300,54 +309,55 @@ static gpointer image_loader_j2k_new(ImageLoaderBackendCbAreaUpdated area_update return loader; } -static void image_loader_j2k_set_size(gpointer loader, int width, int height) +void image_loader_j2k_set_size(gpointer loader, int width, int height) { auto ld = static_cast(loader); ld->requested_width = width; ld->requested_height = height; } -static GdkPixbuf* image_loader_j2k_get_pixbuf(gpointer loader) +GdkPixbuf* image_loader_j2k_get_pixbuf(gpointer loader) { auto ld = static_cast(loader); return ld->pixbuf; } -static gchar* image_loader_j2k_get_format_name(gpointer) +gchar* image_loader_j2k_get_format_name(gpointer) { return g_strdup("j2k"); } -static gchar** image_loader_j2k_get_format_mime_types(gpointer) +gchar** image_loader_j2k_get_format_mime_types(gpointer) { static const gchar *mime[] = {"image/jp2", nullptr}; return g_strdupv(const_cast(mime)); } -static gboolean image_loader_j2k_close(gpointer, GError **) +gboolean image_loader_j2k_close(gpointer, GError **) { return TRUE; } -static void image_loader_j2k_abort(gpointer loader) +void image_loader_j2k_abort(gpointer loader) { auto ld = static_cast(loader); ld->abort = TRUE; } -static void image_loader_j2k_free(gpointer loader) +void image_loader_j2k_free(gpointer loader) { auto ld = static_cast(loader); if (ld->pixbuf) g_object_unref(ld->pixbuf); g_free(ld); } +} // namespace + void image_loader_backend_set_j2k(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_j2k_new; funcs->set_size = image_loader_j2k_set_size; - funcs->load = image_loader_j2k_load; - funcs->write = nullptr; + funcs->write = image_loader_j2k_write; funcs->get_pixbuf = image_loader_j2k_get_pixbuf; funcs->close = image_loader_j2k_close; funcs->abort = image_loader_j2k_abort; diff --git a/src/image-load-jpeg.cc b/src/image-load-jpeg.cc index 6ee2b4ab..07f471fc 100644 --- a/src/image-load-jpeg.cc +++ b/src/image-load-jpeg.cc @@ -270,7 +270,7 @@ static void set_mem_src (j_decompress_ptr cinfo, void* buffer, long nbytes) } -gboolean image_loader_jpeg_load (gpointer loader, const guchar *buf, gsize count, GError **error) +gboolean image_loader_jpeg_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **error) { auto lj = static_cast(loader); struct jpeg_decompress_struct cinfo; @@ -324,9 +324,9 @@ gboolean image_loader_jpeg_load (gpointer loader, const guchar *buf, gsize count cinfo.err = jpeg_std_error (&jerr.pub); if (lj->stereo) cinfo2.err = jpeg_std_error (&jerr.pub); jerr.pub.error_exit = fatal_error_handler; - jerr.pub.output_message = output_message_handler; + jerr.pub.output_message = output_message_handler; - jerr.error = error; + jerr.error = error; if (sigsetjmp(jerr.setjmp_buffer, 0)) @@ -409,7 +409,7 @@ gboolean image_loader_jpeg_load (gpointer loader, const guchar *buf, gsize count { jpeg_destroy_decompress (&cinfo); if (lj->stereo) jpeg_destroy_decompress (&cinfo2); - return 0; + return FALSE; } if (lj->stereo) g_object_set_data(G_OBJECT(lj->pixbuf), "stereo_data", GINT_TO_POINTER(STEREO_PIXBUF_CROSS)); lj->area_prepared_cb(loader, lj->data); @@ -440,6 +440,7 @@ gboolean image_loader_jpeg_load (gpointer loader, const guchar *buf, gsize count jpeg_destroy_decompress(&cinfo); } + chunk_size = count; return TRUE; } @@ -460,6 +461,7 @@ static gchar* image_loader_jpeg_get_format_name(gpointer) { return g_strdup("jpeg"); } + static gchar** image_loader_jpeg_get_format_mime_types(gpointer) { static const gchar *mime[] = {"image/jpeg", nullptr}; @@ -484,13 +486,11 @@ static void image_loader_jpeg_free(gpointer loader) g_free(lj); } - void image_loader_backend_set_jpeg(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_jpeg_new; funcs->set_size = image_loader_jpeg_set_size; - funcs->load = image_loader_jpeg_load; - funcs->write = nullptr; + funcs->write = image_loader_jpeg_write; funcs->get_pixbuf = image_loader_jpeg_get_pixbuf; funcs->close = image_loader_jpeg_close; funcs->abort = image_loader_jpeg_abort; diff --git a/src/image-load-jpeg.h b/src/image-load-jpeg.h index 3123ac0c..e60790da 100644 --- a/src/image-load-jpeg.h +++ b/src/image-load-jpeg.h @@ -29,7 +29,7 @@ struct ImageLoaderBackend; -gboolean image_loader_jpeg_load(gpointer loader, const guchar *buf, gsize count, GError **error); +gboolean image_loader_jpeg_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **error); void image_loader_backend_set_jpeg(ImageLoaderBackend *funcs); #endif diff --git a/src/image-load-jpegxl.cc b/src/image-load-jpegxl.cc index e64f9390..36ef7036 100644 --- a/src/image-load-jpegxl.cc +++ b/src/image-load-jpegxl.cc @@ -70,6 +70,9 @@ #include "debug.h" #include "image-load.h" +namespace +{ + struct ImageLoaderJPEGXL { ImageLoaderBackendCbAreaUpdated area_updated_cb; ImageLoaderBackendCbSize size_cb; @@ -81,12 +84,12 @@ struct ImageLoaderJPEGXL { gboolean abort; }; -static void free_buffer(guchar *pixels, gpointer) +void free_buffer(guchar *pixels, gpointer) { g_free(pixels); } -static uint8_t *JxlMemoryToPixels(const uint8_t *next_in, size_t size, size_t &xsize, size_t &ysize, size_t &stride) +uint8_t *JxlMemoryToPixels(const uint8_t *next_in, size_t size, size_t &xsize, size_t &ysize, size_t &stride) { std::unique_ptr dec{JxlDecoderCreate(nullptr), JxlDecoderDestroy}; if (!dec) @@ -169,7 +172,7 @@ static uint8_t *JxlMemoryToPixels(const uint8_t *next_in, size_t size, size_t &x return nullptr; } -static gboolean image_loader_jpegxl_load(gpointer loader, const guchar *buf, gsize count, GError **) +gboolean image_loader_jpegxl_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **) { auto ld = static_cast(loader); gboolean ret = FALSE; @@ -186,13 +189,14 @@ static gboolean image_loader_jpegxl_load(gpointer loader, const guchar *buf, gsi ld->area_updated_cb(loader, 0, 0, xsize, ysize, ld->data); + chunk_size = count; ret = TRUE; } return ret; } -static gpointer image_loader_jpegxl_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_jpegxl_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto loader = g_new0(ImageLoaderJPEGXL, 1); loader->area_updated_cb = area_updated_cb; @@ -202,54 +206,55 @@ static gpointer image_loader_jpegxl_new(ImageLoaderBackendCbAreaUpdated area_upd return loader; } -static void image_loader_jpegxl_set_size(gpointer loader, int width, int height) +void image_loader_jpegxl_set_size(gpointer loader, int width, int height) { auto ld = static_cast(loader); ld->requested_width = width; ld->requested_height = height; } -static GdkPixbuf* image_loader_jpegxl_get_pixbuf(gpointer loader) +GdkPixbuf* image_loader_jpegxl_get_pixbuf(gpointer loader) { auto ld = static_cast(loader); return ld->pixbuf; } -static gchar* image_loader_jpegxl_get_format_name(gpointer) +gchar* image_loader_jpegxl_get_format_name(gpointer) { return g_strdup("jxl"); } -static gchar** image_loader_jpegxl_get_format_mime_types(gpointer) +gchar** image_loader_jpegxl_get_format_mime_types(gpointer) { static const gchar *mime[] = {"image/jxl", nullptr}; return g_strdupv(const_cast(mime)); } -static gboolean image_loader_jpegxl_close(gpointer, GError **) +gboolean image_loader_jpegxl_close(gpointer, GError **) { return TRUE; } -static void image_loader_jpegxl_abort(gpointer loader) +void image_loader_jpegxl_abort(gpointer loader) { auto ld = static_cast(loader); ld->abort = TRUE; } -static void image_loader_jpegxl_free(gpointer loader) +void image_loader_jpegxl_free(gpointer loader) { auto ld = static_cast(loader); if (ld->pixbuf) g_object_unref(ld->pixbuf); g_free(ld); } +} // namespace + void image_loader_backend_set_jpegxl(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_jpegxl_new; funcs->set_size = image_loader_jpegxl_set_size; - funcs->load = image_loader_jpegxl_load; - funcs->write = nullptr; + funcs->write = image_loader_jpegxl_write; funcs->get_pixbuf = image_loader_jpegxl_get_pixbuf; funcs->close = image_loader_jpegxl_close; funcs->abort = image_loader_jpegxl_abort; diff --git a/src/image-load-pdf.cc b/src/image-load-pdf.cc index 0345f0dc..d1013372 100644 --- a/src/image-load-pdf.cc +++ b/src/image-load-pdf.cc @@ -33,6 +33,9 @@ #include "debug.h" #include "image-load.h" +namespace +{ + struct ImageLoaderPDF { ImageLoaderBackendCbAreaUpdated area_updated_cb; ImageLoaderBackendCbSize size_cb; @@ -46,7 +49,7 @@ struct ImageLoaderPDF { gint page_total; }; -static gboolean image_loader_pdf_load(gpointer loader, const guchar *buf, gsize count, GError **) +gboolean image_loader_pdf_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **) { auto ld = static_cast(loader); GError *poppler_error = nullptr; @@ -91,6 +94,7 @@ static gboolean image_loader_pdf_load(gpointer loader, const guchar *buf, gsize cairo_destroy (cr); cairo_surface_destroy(surface); g_object_unref(page); + chunk_size = count; ret = TRUE; } @@ -99,7 +103,7 @@ static gboolean image_loader_pdf_load(gpointer loader, const guchar *buf, gsize return ret; } -static gpointer image_loader_pdf_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_pdf_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto loader = g_new0(ImageLoaderPDF, 1); loader->area_updated_cb = area_updated_cb; @@ -110,68 +114,69 @@ static gpointer image_loader_pdf_new(ImageLoaderBackendCbAreaUpdated area_update return loader; } -static void image_loader_pdf_set_size(gpointer loader, int width, int height) +void image_loader_pdf_set_size(gpointer loader, int width, int height) { auto ld = static_cast(loader); ld->requested_width = width; ld->requested_height = height; } -static GdkPixbuf* image_loader_pdf_get_pixbuf(gpointer loader) +GdkPixbuf* image_loader_pdf_get_pixbuf(gpointer loader) { auto ld = static_cast(loader); return ld->pixbuf; } -static gchar* image_loader_pdf_get_format_name(gpointer) +gchar* image_loader_pdf_get_format_name(gpointer) { return g_strdup("pdf"); } -static gchar** image_loader_pdf_get_format_mime_types(gpointer) +gchar** image_loader_pdf_get_format_mime_types(gpointer) { static const gchar *mime[] = {"application/pdf", nullptr}; return g_strdupv(const_cast(mime)); } -static void image_loader_pdf_set_page_num(gpointer loader, gint page_num) +void image_loader_pdf_set_page_num(gpointer loader, gint page_num) { auto ld = static_cast(loader); ld->page_num = page_num; } -static gint image_loader_pdf_get_page_total(gpointer loader) +gint image_loader_pdf_get_page_total(gpointer loader) { auto ld = static_cast(loader); return ld->page_total; } -static gboolean image_loader_pdf_close(gpointer, GError **) +gboolean image_loader_pdf_close(gpointer, GError **) { return TRUE; } -static void image_loader_pdf_abort(gpointer loader) +void image_loader_pdf_abort(gpointer loader) { auto ld = static_cast(loader); ld->abort = TRUE; } -static void image_loader_pdf_free(gpointer loader) +void image_loader_pdf_free(gpointer loader) { auto ld = static_cast(loader); if (ld->pixbuf) g_object_unref(ld->pixbuf); g_free(ld); } +} // namespace + void image_loader_backend_set_pdf(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_pdf_new; funcs->set_size = image_loader_pdf_set_size; - funcs->load = image_loader_pdf_load; - funcs->write = nullptr; + funcs->write = image_loader_pdf_write; funcs->get_pixbuf = image_loader_pdf_get_pixbuf; funcs->close = image_loader_pdf_close; funcs->abort = image_loader_pdf_abort; diff --git a/src/image-load-psd.cc b/src/image-load-psd.cc index 62dfdc97..8ced9daf 100644 --- a/src/image-load-psd.cc +++ b/src/image-load-psd.cc @@ -59,6 +59,9 @@ #include "debug.h" #include "image-load.h" +namespace +{ + struct ImageLoaderPSD { ImageLoaderBackendCbAreaUpdated area_updated_cb; ImageLoaderBackendCbSize size_cb; @@ -145,14 +148,12 @@ struct PsdContext }; -static guint16 -read_uint16 (const guchar* buf) +guint16 read_uint16 (const guchar* buf) { return (buf[0] << 8) | buf[1]; } -static guint32 -read_uint32 (const guchar* buf) +guint32 read_uint32 (const guchar* buf) { return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]; } @@ -163,8 +164,7 @@ read_uint32 (const guchar* buf) * * str is expected to be at least PSD_HEADER_SIZE long */ -static PsdHeader -psd_parse_header (guchar* str) +PsdHeader psd_parse_header (guchar* str) { PsdHeader hd; @@ -185,7 +185,7 @@ psd_parse_header (guchar* str) * Returns true if there were enough bytes and false otherwise * (which means we need to call feed_buffer again) */ -static gboolean +gboolean feed_buffer (guchar* buffer, guint* bytes_read, const guchar** data, @@ -209,8 +209,7 @@ feed_buffer (guchar* buffer, * Returns true when finishes consuming block data, otherwise false * (false means we need to call skip_block again) */ -static gboolean -skip_block (PsdContext* context, const guchar** data, guint* size) +gboolean skip_block (PsdContext* context, const guchar** data, guint* size) { if (!context->bytes_to_skip_known) { context->bytes_read = 0; @@ -238,8 +237,7 @@ skip_block (PsdContext* context, const guchar** data, guint* size) /* * Decodes RLE-compressed data */ -static void -decompress_line(const guchar* src, guint line_length, guchar* dest) +void decompress_line(const guchar* src, guint line_length, guchar* dest) { guint16 bytes_read = 0; int k; @@ -281,15 +279,14 @@ decompress_line(const guchar* src, guint line_length, guchar* dest) } } -static void -reset_context_buffer(PsdContext* ctx) +void reset_context_buffer(PsdContext* ctx) { ctx->bytes_read = 0; ctx->bytes_to_skip = 0; ctx->bytes_to_skip_known = FALSE; } -static void free_context(PsdContext *ctx) +void free_context(PsdContext *ctx) { g_free(ctx->buffer); g_free(ctx->lines_lengths); @@ -302,7 +299,7 @@ static void free_context(PsdContext *ctx) g_free(ctx); } -static gboolean image_loader_psd_load(gpointer loader, const guchar *buf, gsize count, GError **) +gboolean image_loader_psd_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **) { auto ld = static_cast(loader); auto ctx = g_new0(PsdContext, 1); @@ -536,6 +533,7 @@ static gboolean image_loader_psd_load(gpointer loader, const guchar *buf, gsize ld->area_updated_cb(loader, 0, 0, ctx->width, ctx->height, ld->data); free_context(ctx); + chunk_size = count; return TRUE; } @@ -545,7 +543,7 @@ static gboolean image_loader_psd_load(gpointer loader, const guchar *buf, gsize /* ------- Geeqie ------------ */ -static gpointer image_loader_psd_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_psd_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto loader = g_new0(ImageLoaderPSD, 1); loader->area_updated_cb = area_updated_cb; @@ -555,54 +553,55 @@ static gpointer image_loader_psd_new(ImageLoaderBackendCbAreaUpdated area_update return loader; } -static void image_loader_psd_set_size(gpointer loader, int width, int height) +void image_loader_psd_set_size(gpointer loader, int width, int height) { auto ld = static_cast(loader); ld->requested_width = width; ld->requested_height = height; } -static GdkPixbuf* image_loader_psd_get_pixbuf(gpointer loader) +GdkPixbuf* image_loader_psd_get_pixbuf(gpointer loader) { auto ld = static_cast(loader); return ld->pixbuf; } -static gchar* image_loader_psd_get_format_name(gpointer) +gchar* image_loader_psd_get_format_name(gpointer) { return g_strdup("psd"); } -static gchar** image_loader_psd_get_format_mime_types(gpointer) +gchar** image_loader_psd_get_format_mime_types(gpointer) { static const gchar *mime[] = {"application/psd", nullptr}; return g_strdupv(const_cast(mime)); } -static gboolean image_loader_psd_close(gpointer, GError **) +gboolean image_loader_psd_close(gpointer, GError **) { return TRUE; } -static void image_loader_psd_abort(gpointer loader) +void image_loader_psd_abort(gpointer loader) { auto ld = static_cast(loader); ld->abort = TRUE; } -static void image_loader_psd_free(gpointer loader) +void image_loader_psd_free(gpointer loader) { auto ld = static_cast(loader); if (ld->pixbuf) g_object_unref(ld->pixbuf); g_free(ld); } +} // namespace + void image_loader_backend_set_psd(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_psd_new; funcs->set_size = image_loader_psd_set_size; - funcs->load = image_loader_psd_load; - funcs->write = nullptr; + funcs->write = image_loader_psd_write; funcs->get_pixbuf = image_loader_psd_get_pixbuf; funcs->close = image_loader_psd_close; funcs->abort = image_loader_psd_abort; diff --git a/src/image-load-svgz.cc b/src/image-load-svgz.cc index 534eddf8..a94af709 100644 --- a/src/image-load-svgz.cc +++ b/src/image-load-svgz.cc @@ -26,19 +26,22 @@ #include "image-load.h" +namespace +{ -static gchar* image_loader_svgz_get_format_name(gpointer) +gchar* image_loader_svgz_get_format_name(gpointer) { return g_strdup("svg"); } -static gchar** image_loader_svgz_get_format_mime_types(gpointer) + +gchar** image_loader_svgz_get_format_mime_types(gpointer) { static const gchar *mime[] = {"image/svg", nullptr}; return g_strdupv(const_cast(mime)); } -static gpointer image_loader_svgz_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_svgz_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { GError *error = nullptr; @@ -55,21 +58,27 @@ static gpointer image_loader_svgz_new(ImageLoaderBackendCbAreaUpdated area_updat return loader; } -static void image_loader_svgz_abort(gpointer) +gboolean image_loader_svgz_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize, GError **error) { + return gdk_pixbuf_loader_write(GDK_PIXBUF_LOADER(loader), buf, chunk_size, error); } -static void image_loader_svgz_free(gpointer loader) +void image_loader_svgz_abort(gpointer) +{ +} + +void image_loader_svgz_free(gpointer loader) { g_object_unref(G_OBJECT(loader)); } +} // namespace + void image_loader_backend_set_svgz(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_svgz_new; funcs->set_size = reinterpret_cast(gdk_pixbuf_loader_set_size); - funcs->load = nullptr; - funcs->write = reinterpret_cast(gdk_pixbuf_loader_write); + funcs->write = image_loader_svgz_write; funcs->get_pixbuf = reinterpret_cast(gdk_pixbuf_loader_get_pixbuf); funcs->close = reinterpret_cast(gdk_pixbuf_loader_close); funcs->abort = image_loader_svgz_abort; @@ -79,5 +88,4 @@ void image_loader_backend_set_svgz(ImageLoaderBackend *funcs) funcs->get_format_mime_types = image_loader_svgz_get_format_mime_types; } - /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */ diff --git a/src/image-load-tiff.cc b/src/image-load-tiff.cc index 287c5a2d..1b5ef7bc 100644 --- a/src/image-load-tiff.cc +++ b/src/image-load-tiff.cc @@ -44,6 +44,9 @@ #include "debug.h" #include "image-load.h" +namespace +{ + struct ImageLoaderTiff { ImageLoaderBackendCbAreaUpdated area_updated_cb; ImageLoaderBackendCbSize size_cb; @@ -64,13 +67,12 @@ struct ImageLoaderTiff { gint page_total; }; -static void free_buffer (guchar *pixels, gpointer) +void free_buffer (guchar *pixels, gpointer) { g_free (pixels); } -static tsize_t -tiff_load_read (thandle_t handle, tdata_t buf, tsize_t size) +tsize_t tiff_load_read (thandle_t handle, tdata_t buf, tsize_t size) { auto context = static_cast(handle); @@ -82,14 +84,12 @@ tiff_load_read (thandle_t handle, tdata_t buf, tsize_t size) return size; } -static tsize_t -tiff_load_write (thandle_t, tdata_t, tsize_t) +tsize_t tiff_load_write (thandle_t, tdata_t, tsize_t) { return -1; } -static toff_t -tiff_load_seek (thandle_t handle, toff_t offset, int whence) +toff_t tiff_load_seek (thandle_t handle, toff_t offset, int whence) { auto context = static_cast(handle); @@ -117,21 +117,18 @@ tiff_load_seek (thandle_t handle, toff_t offset, int whence) return context->pos; } -static int -tiff_load_close (thandle_t) +int tiff_load_close (thandle_t) { return 0; } -static toff_t -tiff_load_size (thandle_t handle) +toff_t tiff_load_size (thandle_t handle) { auto context = static_cast(handle); return context->used; } -static int -tiff_load_map_file (thandle_t handle, tdata_t *buf, toff_t *size) +int tiff_load_map_file (thandle_t handle, tdata_t *buf, toff_t *size) { auto context = static_cast(handle); @@ -141,12 +138,11 @@ tiff_load_map_file (thandle_t handle, tdata_t *buf, toff_t *size) return 0; } -static void -tiff_load_unmap_file (thandle_t, tdata_t, toff_t) +void tiff_load_unmap_file (thandle_t, tdata_t, toff_t) { } -static gboolean image_loader_tiff_load (gpointer loader, const guchar *buf, gsize count, GError **) +gboolean image_loader_tiff_write (gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **) { auto lt = static_cast(loader); @@ -335,11 +331,12 @@ static gboolean image_loader_tiff_load (gpointer loader, const guchar *buf, gsiz } TIFFClose(tiff); + chunk_size = count; return TRUE; } -static gpointer image_loader_tiff_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_tiff_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto loader = g_new0(ImageLoaderTiff, 1); @@ -351,67 +348,69 @@ static gpointer image_loader_tiff_new(ImageLoaderBackendCbAreaUpdated area_updat } -static void image_loader_tiff_set_size(gpointer loader, int width, int height) +void image_loader_tiff_set_size(gpointer loader, int width, int height) { auto lt = static_cast(loader); lt->requested_width = width; lt->requested_height = height; } -static GdkPixbuf* image_loader_tiff_get_pixbuf(gpointer loader) +GdkPixbuf* image_loader_tiff_get_pixbuf(gpointer loader) { auto lt = static_cast(loader); return lt->pixbuf; } -static gchar* image_loader_tiff_get_format_name(gpointer) +gchar* image_loader_tiff_get_format_name(gpointer) { return g_strdup("tiff"); } -static gchar** image_loader_tiff_get_format_mime_types(gpointer) + +gchar** image_loader_tiff_get_format_mime_types(gpointer) { static const gchar *mime[] = {"image/tiff", nullptr}; return g_strdupv(const_cast(mime)); } -static gboolean image_loader_tiff_close(gpointer, GError **) +gboolean image_loader_tiff_close(gpointer, GError **) { return TRUE; } -static void image_loader_tiff_abort(gpointer loader) +void image_loader_tiff_abort(gpointer loader) { auto lt = static_cast(loader); lt->abort = TRUE; } -static void image_loader_tiff_free(gpointer loader) +void image_loader_tiff_free(gpointer loader) { auto lt = static_cast(loader); if (lt->pixbuf) g_object_unref(lt->pixbuf); g_free(lt); } -static void image_loader_tiff_set_page_num(gpointer loader, gint page_num) +void image_loader_tiff_set_page_num(gpointer loader, gint page_num) { auto lt = static_cast(loader); lt->page_num = page_num; } -static gint image_loader_tiff_get_page_total(gpointer loader) +gint image_loader_tiff_get_page_total(gpointer loader) { auto lt = static_cast(loader); return lt->page_total; } +} // namespace + void image_loader_backend_set_tiff(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_tiff_new; funcs->set_size = image_loader_tiff_set_size; - funcs->load = image_loader_tiff_load; - funcs->write = nullptr; + funcs->write = image_loader_tiff_write; funcs->get_pixbuf = image_loader_tiff_get_pixbuf; funcs->close = image_loader_tiff_close; funcs->abort = image_loader_tiff_abort; @@ -424,7 +423,5 @@ void image_loader_backend_set_tiff(ImageLoaderBackend *funcs) funcs->get_page_total = image_loader_tiff_get_page_total; } - - #endif /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */ diff --git a/src/image-load-webp.cc b/src/image-load-webp.cc index 99511423..780964cc 100644 --- a/src/image-load-webp.cc +++ b/src/image-load-webp.cc @@ -31,6 +31,9 @@ #include "debug.h" #include "image-load.h" +namespace +{ + using ImageLoaderWEBP = struct _ImageLoaderWEBP; struct _ImageLoaderWEBP { ImageLoaderBackendCbAreaUpdated area_updated_cb; @@ -43,12 +46,12 @@ struct _ImageLoaderWEBP { gboolean abort; }; -static void free_buffer(guchar *pixels, gpointer) +void free_buffer(guchar *pixels, gpointer) { g_free(pixels); } -static gboolean image_loader_webp_load(gpointer loader, const guchar *buf, gsize count, GError **) +gboolean image_loader_webp_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **) { auto *ld = (ImageLoaderWEBP *) loader; guint8* data; @@ -85,10 +88,11 @@ static gboolean image_loader_webp_load(gpointer loader, const guchar *buf, gsize ld->area_updated_cb(loader, 0, 0, width, height, ld->data); + chunk_size = count; return TRUE; } -static gpointer image_loader_webp_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_webp_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto *loader = g_new0(ImageLoaderWEBP, 1); loader->area_updated_cb = area_updated_cb; @@ -99,55 +103,56 @@ static gpointer image_loader_webp_new(ImageLoaderBackendCbAreaUpdated area_updat return (gpointer) loader; } -static void image_loader_webp_set_size(gpointer loader, int width, int height) +void image_loader_webp_set_size(gpointer loader, int width, int height) { auto *ld = (ImageLoaderWEBP *) loader; ld->requested_width = width; ld->requested_height = height; } -static GdkPixbuf* image_loader_webp_get_pixbuf(gpointer loader) +GdkPixbuf* image_loader_webp_get_pixbuf(gpointer loader) { auto *ld = (ImageLoaderWEBP *) loader; return ld->pixbuf; } -static gchar* image_loader_webp_get_format_name(gpointer) +gchar* image_loader_webp_get_format_name(gpointer) { return g_strdup("webp"); } -static gchar** image_loader_webp_get_format_mime_types(gpointer) +gchar** image_loader_webp_get_format_mime_types(gpointer) { static const gchar *mime[] = {"image/webp", nullptr}; return g_strdupv(const_cast(mime)); } -static gboolean image_loader_webp_close(gpointer, GError **) +gboolean image_loader_webp_close(gpointer, GError **) { return TRUE; } -static void image_loader_webp_abort(gpointer loader) +void image_loader_webp_abort(gpointer loader) { auto *ld = (ImageLoaderWEBP *) loader; ld->abort = TRUE; } -static void image_loader_webp_free(gpointer loader) +void image_loader_webp_free(gpointer loader) { auto *ld = (ImageLoaderWEBP *) loader; if (ld->pixbuf) g_object_unref(ld->pixbuf); g_free(ld); } +} // namespace + void image_loader_backend_set_webp(ImageLoaderBackend *funcs) { DEBUG_0(" " ); funcs->loader_new = image_loader_webp_new; funcs->set_size = image_loader_webp_set_size; - funcs->load = image_loader_webp_load; - funcs->write = nullptr; + funcs->write = image_loader_webp_write; funcs->get_pixbuf = image_loader_webp_get_pixbuf; funcs->close = image_loader_webp_close; funcs->abort = image_loader_webp_abort; diff --git a/src/image-load-zxscr.cc b/src/image-load-zxscr.cc index c3651e66..96b707aa 100644 --- a/src/image-load-zxscr.cc +++ b/src/image-load-zxscr.cc @@ -27,6 +27,9 @@ #include "debug.h" #include "image-load.h" +namespace +{ + struct ImageLoaderZXSCR { ImageLoaderBackendCbAreaUpdated area_updated_cb; ImageLoaderBackendCbSize size_cb; @@ -38,7 +41,7 @@ struct ImageLoaderZXSCR { gboolean abort; }; -const guchar palette[2][8][3] = { +constexpr guchar palette[2][8][3] = { { {0x00, 0x00, 0x00}, {0x00, 0x00, 0xbf}, @@ -60,12 +63,12 @@ const guchar palette[2][8][3] = { } }; -static void free_buffer(guchar *pixels, gpointer) +void free_buffer(guchar *pixels, gpointer) { g_free(pixels); } -static gboolean image_loader_zxscr_load(gpointer loader, const guchar *buf, gsize count, GError **) +gboolean image_loader_zxscr_write(gpointer loader, const guchar *buf, gsize &chunk_size, gsize count, GError **) { auto ld = static_cast(loader); guint8 *pixels; @@ -152,10 +155,11 @@ static gboolean image_loader_zxscr_load(gpointer loader, const guchar *buf, gsiz ld->area_updated_cb(loader, 0, 0, width, height, ld->data); + chunk_size = count; return TRUE; } -static gpointer image_loader_zxscr_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) +gpointer image_loader_zxscr_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data) { auto loader = g_new0(ImageLoaderZXSCR, 1); loader->area_updated_cb = area_updated_cb; @@ -165,54 +169,55 @@ static gpointer image_loader_zxscr_new(ImageLoaderBackendCbAreaUpdated area_upda return loader; } -static void image_loader_zxscr_set_size(gpointer loader, int width, int height) +void image_loader_zxscr_set_size(gpointer loader, int width, int height) { auto ld = static_cast(loader); ld->requested_width = width; ld->requested_height = height; } -static GdkPixbuf *image_loader_zxscr_get_pixbuf(gpointer loader) +GdkPixbuf *image_loader_zxscr_get_pixbuf(gpointer loader) { auto ld = static_cast(loader); return ld->pixbuf; } -static gchar *image_loader_zxscr_get_format_name(gpointer) +gchar *image_loader_zxscr_get_format_name(gpointer) { return g_strdup("zxscr"); } -static gchar **image_loader_zxscr_get_format_mime_types(gpointer) +gchar **image_loader_zxscr_get_format_mime_types(gpointer) { static const gchar *mime[] = {"application/octet-stream", nullptr}; return g_strdupv(const_cast(mime)); } -static gboolean image_loader_zxscr_close(gpointer, GError **) +gboolean image_loader_zxscr_close(gpointer, GError **) { return TRUE; } -static void image_loader_zxscr_abort(gpointer loader) +void image_loader_zxscr_abort(gpointer loader) { auto ld = static_cast(loader); ld->abort = TRUE; } -static void image_loader_zxscr_free(gpointer loader) +void image_loader_zxscr_free(gpointer loader) { auto ld = static_cast(loader); if (ld->pixbuf) g_object_unref(ld->pixbuf); g_free(ld); } +} // namespace + void image_loader_backend_set_zxscr(ImageLoaderBackend *funcs) { funcs->loader_new = image_loader_zxscr_new; funcs->set_size = image_loader_zxscr_set_size; - funcs->load = image_loader_zxscr_load; - funcs->write = nullptr; + funcs->write = image_loader_zxscr_write; funcs->get_pixbuf = image_loader_zxscr_get_pixbuf; funcs->close = image_loader_zxscr_close; funcs->abort = image_loader_zxscr_abort; diff --git a/src/image-load.cc b/src/image-load.cc index aa225acf..3d969fda 100644 --- a/src/image-load.cc +++ b/src/image-load.cc @@ -878,7 +878,6 @@ static void image_loader_error(ImageLoader *il) static gboolean image_loader_continue(ImageLoader *il) { - gint b; gint c; if (!il) return G_SOURCE_REMOVE; @@ -886,15 +885,21 @@ static gboolean image_loader_continue(ImageLoader *il) c = il->idle_read_loop_count ? il->idle_read_loop_count : 1; while (c > 0 && !image_loader_get_stopping(il)) { - b = MIN(il->read_buffer_size, il->bytes_total - il->bytes_read); - - if (b == 0) + if (il->bytes_total == il->bytes_read) { image_loader_done(il); return G_SOURCE_REMOVE; } - if (b < 0 || (b > 0 && !il->backend.write(il->loader, il->mapped_file + il->bytes_read, b, &il->error))) + if (il->bytes_total < il->bytes_read) + { + image_loader_error(il); + return G_SOURCE_REMOVE; + } + + gsize b = MIN(il->read_buffer_size, il->bytes_total - il->bytes_read); + + if (!il->backend.write(il->loader, il->mapped_file + il->bytes_read, b, il->bytes_total, &il->error)) { image_loader_error(il); return G_SOURCE_REMOVE; @@ -918,25 +923,17 @@ static gboolean image_loader_begin(ImageLoader *il) #if HAVE_TIFF || HAVE_PDF || HAVE_HEIF || HAVE_DJVU gchar *format; #endif - gssize b; if (il->pixbuf) return FALSE; - b = MIN(il->read_buffer_size, il->bytes_total - il->bytes_read); - if (b < 1) return FALSE; + if (il->bytes_total <= il->bytes_read) return FALSE; + + gsize b = MIN(il->read_buffer_size, il->bytes_total - il->bytes_read); image_loader_setup_loader(il); g_assert(il->bytes_read == 0); - if (il->backend.load) { - b = il->bytes_total; - if (!il->backend.load(il->loader, il->mapped_file, b, &il->error)) - { - image_loader_stop_loader(il); - return FALSE; - } - } - else if (!il->backend.write(il->loader, il->mapped_file, b, &il->error)) + if (!il->backend.write(il->loader, il->mapped_file, b, il->bytes_total, &il->error)) { image_loader_stop_loader(il); return FALSE; @@ -984,8 +981,14 @@ static gboolean image_loader_begin(ImageLoader *il) /* read until size is known */ while (il->loader && !il->backend.get_pixbuf(il->loader) && b > 0 && !image_loader_get_stopping(il)) { + if (il->bytes_total < il->bytes_read) + { + image_loader_stop_loader(il); + return FALSE; + } + b = MIN(il->read_buffer_size, il->bytes_total - il->bytes_read); - if (b < 0 || (b > 0 && !il->backend.write(il->loader, il->mapped_file + il->bytes_read, b, &il->error))) + if (b > 0 && !il->backend.write(il->loader, il->mapped_file + il->bytes_read, b, il->bytes_total, &il->error)) { image_loader_stop_loader(il); return FALSE; diff --git a/src/image-load.h b/src/image-load.h index b59c4e17..d77bf472 100644 --- a/src/image-load.h +++ b/src/image-load.h @@ -36,8 +36,7 @@ using ImageLoaderBackendCbAreaUpdated = void (*)(gpointer, guint, guint, guint, using ImageLoaderBackendFuncLoaderNew = gpointer (*)(ImageLoaderBackendCbAreaUpdated, ImageLoaderBackendCbSize, ImageLoaderBackendCbAreaPrepared, gpointer); using ImageLoaderBackendFuncSetSize = void (*)(gpointer, int, int); -using ImageLoaderBackendFuncLoad = gboolean (*)(gpointer, const guchar *, gsize, GError **); /* optional, load whole image at once */ -using ImageLoaderBackendFuncWrite = gboolean (*)(gpointer, const guchar *, gsize, GError **); +using ImageLoaderBackendFuncWrite = gboolean (*)(gpointer, const guchar *, gsize &, gsize, GError **); using ImageLoaderBackendFuncGetPixbuf = GdkPixbuf *(*)(gpointer); using ImageLoaderBackendFuncClose = gboolean (*)(gpointer, GError **); using ImageLoaderBackendFuncAbort = void (*)(gpointer); @@ -51,7 +50,6 @@ struct ImageLoaderBackend { ImageLoaderBackendFuncLoaderNew loader_new; ImageLoaderBackendFuncSetSize set_size; - ImageLoaderBackendFuncLoad load; ImageLoaderBackendFuncWrite write; ImageLoaderBackendFuncGetPixbuf get_pixbuf; ImageLoaderBackendFuncClose close; -- 2.20.1