Remove ImageLoaderBackendFuncLoad.
Also move static functions to anonymous namespace.
#include "options.h"
#include "ui-fileops.h"
+namespace
+{
+
struct ImageLoaderCOLLECTION {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
ImageLoaderBackendCbSize size_cb;
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<ImageLoaderCOLLECTION *>(loader);
auto il = static_cast<ImageLoader *>(ld->data);
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;
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<ImageLoaderCOLLECTION *>(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<ImageLoaderCOLLECTION *>(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<gchar **>(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<ImageLoaderCOLLECTION *>(loader);
ld->abort = TRUE;
}
-static void image_loader_collection_free(gpointer loader)
+void image_loader_collection_free(gpointer loader)
{
auto ld = static_cast<ImageLoaderCOLLECTION *>(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;
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
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)
{
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;
#include "image-load.h"
+namespace
+{
+
struct ImageLoaderDDS {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
ImageLoaderBackendCbSize size_cb;
gboolean abort;
};
-static void free_buffer(guchar *pixels, gpointer)
+void free_buffer(guchar *pixels, gpointer)
{
g_free(pixels);
}
};
// 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) {
return reinterpret_cast<guchar *>(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<ImageLoaderDDS *>(loader);
uint width = ddsGetWidth(buf);
}
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;
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<ImageLoaderDDS *>(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<ImageLoaderDDS *>(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<gchar **>(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<ImageLoaderDDS *>(loader);
ld->abort = TRUE;
}
-static void image_loader_dds_free(gpointer loader)
+void image_loader_dds_free(gpointer loader)
{
auto ld = static_cast<ImageLoaderDDS *>(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;
#include "image-load.h"
+namespace
+{
+
struct ImageLoaderDJVU {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
ImageLoaderBackendCbSize size_cb;
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<ImageLoaderDJVU *>(loader);
ddjvu_context_t *ctx;
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;
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<ImageLoaderDJVU *>(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<ImageLoaderDJVU *>(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<gchar **>(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<ImageLoaderDJVU *>(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<ImageLoaderDJVU *>(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<ImageLoaderDJVU *>(loader);
ld->abort = TRUE;
}
-static void image_loader_djvu_free(gpointer loader)
+void image_loader_djvu_free(gpointer loader)
{
auto ld = static_cast<ImageLoaderDJVU *>(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;
#include "options.h"
#include "ui-fileops.h"
+namespace
+{
+
struct ImageLoaderExternal {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
ImageLoaderBackendCbSize size_cb;
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<ImageLoaderExternal *>(loader);
auto il = static_cast<ImageLoader *>(ld->data);
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;
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<ImageLoaderExternal *>(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<ImageLoaderExternal *>(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<gchar **>(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<ImageLoaderExternal *>(loader);
ld->abort = TRUE;
}
-static void image_loader_external_free(gpointer loader)
+void image_loader_external_free(gpointer loader)
{
auto ld = static_cast<ImageLoaderExternal *>(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;
#include "image-load.h"
#include "options.h"
+namespace
+{
+
struct ImageLoaderFT {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
ImageLoaderBackendCbSize size_cb;
};
#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);
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<gchar **>(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);
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<ImageLoaderFT *>(loader);
lft->requested_width = width;
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<ImageLoaderFT *>(loader);
auto il = static_cast<ImageLoader *>(lft->data);
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);
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<ImageLoaderFT *>(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<ImageLoaderFT *>(loader);
if (lft->pixbuf) g_object_unref(lft->pixbuf);
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;
#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;
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<ImageLoader *>(data);
GdkPixbufLoader *loader;
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<ImageLoaderBackendFuncSetSize>(gdk_pixbuf_loader_set_size);
- funcs->load = nullptr;
- funcs->write = reinterpret_cast<ImageLoaderBackendFuncWrite>(gdk_pixbuf_loader_write);
+ funcs->write = image_loader_gdk_write;
funcs->get_pixbuf = reinterpret_cast<ImageLoaderBackendFuncGetPixbuf>(gdk_pixbuf_loader_get_pixbuf);
funcs->close = reinterpret_cast<ImageLoaderBackendFuncClose>(gdk_pixbuf_loader_close);
funcs->abort = image_loader_gdk_abort;
funcs->get_format_mime_types = image_loader_gdk_get_format_mime_types;
}
-
/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */
#include "debug.h"
#include "image-load.h"
+namespace
+{
+
struct ImageLoaderHEIF {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
ImageLoaderBackendCbSize size_cb;
gint page_total;
};
-static void free_buffer(guchar *, gpointer data)
+void free_buffer(guchar *, gpointer data)
{
heif_image_release(static_cast<const struct heif_image*>(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<ImageLoaderHEIF *>(loader);
struct heif_context* ctx;
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;
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<ImageLoaderHEIF *>(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<ImageLoaderHEIF *>(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<gchar **>(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<ImageLoaderHEIF *>(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<ImageLoaderHEIF *>(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<ImageLoaderHEIF *>(loader);
ld->abort = TRUE;
}
-static void image_loader_heif_free(gpointer loader)
+void image_loader_heif_free(gpointer loader)
{
auto ld = static_cast<ImageLoaderHEIF *>(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;
#include "intl.h"
#include "misc.h"
+namespace
+{
+
struct ImageLoaderJ2K {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
ImageLoaderBackendCbSize size_cb;
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<OPJ_SIZE_T>(-1);
+ memcpy (pdst, psrc->cur, n);
+ psrc->cur += n;
+ }
+ else
+ n = static_cast<OPJ_SIZE_T>(-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<guchar *>(pcur) - static_cast<guchar *>(pbuf);
- OPJ_SIZE_T n = len - dist;
- g_assert (dist <= len);
+ OPJ_SIZE_T dist = static_cast<guchar *>(pcur) - static_cast<guchar *>(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<OPJ_SIZE_T>(-1);
+ if (nullptr == pbuf)
+ return static_cast<OPJ_SIZE_T>(-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<OPJ_BYTE *>(pbuf);
- p_source_buffer->cur = static_cast<guchar *>(pbuf) + dist;
- p_source_buffer->len = len;
- }
+ p_source_buffer->buf = static_cast<OPJ_BYTE *>(pbuf);
+ p_source_buffer->cur = static_cast<guchar *>(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<OPJ_SIZE_T>(-1);
+ psrc->cur += len;
+ }
+ else
+ n = static_cast<OPJ_SIZE_T>(-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<gulong>(len))
- n = len;
+ if (n > static_cast<gulong>(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_stream_read_fn>(opj_read_from_buffer));
- else
- opj_stream_set_write_function(
- ps,reinterpret_cast<opj_stream_write_fn>(opj_write_to_buffer));
+ if (input)
+ opj_stream_set_read_function (
+ ps, reinterpret_cast<opj_stream_read_fn>(opj_read_from_buffer));
+ else
+ opj_stream_set_write_function(
+ ps,reinterpret_cast<opj_stream_write_fn>(opj_write_to_buffer));
- opj_stream_set_skip_function (
- ps, reinterpret_cast<opj_stream_skip_fn>(opj_skip_from_buffer));
+ opj_stream_set_skip_function (
+ ps, reinterpret_cast<opj_stream_skip_fn>(opj_skip_from_buffer));
- opj_stream_set_seek_function (
- ps, reinterpret_cast<opj_stream_seek_fn>(opj_seek_from_buffer));
+ opj_stream_set_seek_function (
+ ps, reinterpret_cast<opj_stream_seek_fn>(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<ImageLoaderJ2K *>(loader);
opj_stream_t *stream;
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;
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<ImageLoaderJ2K *>(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<ImageLoaderJ2K *>(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<gchar **>(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<ImageLoaderJ2K *>(loader);
ld->abort = TRUE;
}
-static void image_loader_j2k_free(gpointer loader)
+void image_loader_j2k_free(gpointer loader)
{
auto ld = static_cast<ImageLoaderJ2K *>(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;
}
-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<ImageLoaderJpeg *>(loader);
struct jpeg_decompress_struct cinfo;
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))
{
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);
jpeg_destroy_decompress(&cinfo);
}
+ chunk_size = count;
return TRUE;
}
{
return g_strdup("jpeg");
}
+
static gchar** image_loader_jpeg_get_format_mime_types(gpointer)
{
static const gchar *mime[] = {"image/jpeg", nullptr};
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;
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
#include "debug.h"
#include "image-load.h"
+namespace
+{
+
struct ImageLoaderJPEGXL {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
ImageLoaderBackendCbSize size_cb;
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<JxlDecoder, decltype(&JxlDecoderDestroy)> dec{JxlDecoderCreate(nullptr), JxlDecoderDestroy};
if (!dec)
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<ImageLoaderJPEGXL *>(loader);
gboolean ret = FALSE;
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;
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<ImageLoaderJPEGXL *>(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<ImageLoaderJPEGXL *>(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<gchar **>(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<ImageLoaderJPEGXL *>(loader);
ld->abort = TRUE;
}
-static void image_loader_jpegxl_free(gpointer loader)
+void image_loader_jpegxl_free(gpointer loader)
{
auto ld = static_cast<ImageLoaderJPEGXL *>(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;
#include "debug.h"
#include "image-load.h"
+namespace
+{
+
struct ImageLoaderPDF {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
ImageLoaderBackendCbSize size_cb;
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<ImageLoaderPDF *>(loader);
GError *poppler_error = nullptr;
cairo_destroy (cr);
cairo_surface_destroy(surface);
g_object_unref(page);
+ chunk_size = count;
ret = TRUE;
}
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;
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<ImageLoaderPDF *>(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<ImageLoaderPDF *>(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<gchar **>(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<ImageLoaderPDF *>(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<ImageLoaderPDF *>(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<ImageLoaderPDF *>(loader);
ld->abort = TRUE;
}
-static void image_loader_pdf_free(gpointer loader)
+void image_loader_pdf_free(gpointer loader)
{
auto ld = static_cast<ImageLoaderPDF *>(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;
#include "debug.h"
#include "image-load.h"
+namespace
+{
+
struct ImageLoaderPSD {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
ImageLoaderBackendCbSize size_cb;
};
-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];
}
*
* 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;
* 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,
* 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;
/*
* 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;
}
}
-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);
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<ImageLoaderPSD *>(loader);
auto ctx = g_new0(PsdContext, 1);
ld->area_updated_cb(loader, 0, 0, ctx->width, ctx->height, ld->data);
free_context(ctx);
+ chunk_size = count;
return TRUE;
}
/* ------- 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;
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<ImageLoaderPSD *>(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<ImageLoaderPSD *>(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<gchar **>(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<ImageLoaderPSD *>(loader);
ld->abort = TRUE;
}
-static void image_loader_psd_free(gpointer loader)
+void image_loader_psd_free(gpointer loader)
{
auto ld = static_cast<ImageLoaderPSD *>(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;
#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<gchar **>(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;
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<ImageLoaderBackendFuncSetSize>(gdk_pixbuf_loader_set_size);
- funcs->load = nullptr;
- funcs->write = reinterpret_cast<ImageLoaderBackendFuncWrite>(gdk_pixbuf_loader_write);
+ funcs->write = image_loader_svgz_write;
funcs->get_pixbuf = reinterpret_cast<ImageLoaderBackendFuncGetPixbuf>(gdk_pixbuf_loader_get_pixbuf);
funcs->close = reinterpret_cast<ImageLoaderBackendFuncClose>(gdk_pixbuf_loader_close);
funcs->abort = image_loader_svgz_abort;
funcs->get_format_mime_types = image_loader_svgz_get_format_mime_types;
}
-
/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */
#include "debug.h"
#include "image-load.h"
+namespace
+{
+
struct ImageLoaderTiff {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
ImageLoaderBackendCbSize size_cb;
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<ImageLoaderTiff *>(handle);
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<ImageLoaderTiff *>(handle);
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<ImageLoaderTiff *>(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<ImageLoaderTiff *>(handle);
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<ImageLoaderTiff *>(loader);
}
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);
}
-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<ImageLoaderTiff *>(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<ImageLoaderTiff *>(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<gchar **>(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<ImageLoaderTiff *>(loader);
lt->abort = TRUE;
}
-static void image_loader_tiff_free(gpointer loader)
+void image_loader_tiff_free(gpointer loader)
{
auto lt = static_cast<ImageLoaderTiff *>(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<ImageLoaderTiff *>(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<ImageLoaderTiff *>(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;
funcs->get_page_total = image_loader_tiff_get_page_total;
}
-
-
#endif
/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */
#include "debug.h"
#include "image-load.h"
+namespace
+{
+
using ImageLoaderWEBP = struct _ImageLoaderWEBP;
struct _ImageLoaderWEBP {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
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;
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;
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<gchar **>(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;
#include "debug.h"
#include "image-load.h"
+namespace
+{
+
struct ImageLoaderZXSCR {
ImageLoaderBackendCbAreaUpdated area_updated_cb;
ImageLoaderBackendCbSize size_cb;
gboolean abort;
};
-const guchar palette[2][8][3] = {
+constexpr guchar palette[2][8][3] = {
{
{0x00, 0x00, 0x00},
{0x00, 0x00, 0xbf},
}
};
-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<ImageLoaderZXSCR *>(loader);
guint8 *pixels;
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;
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<ImageLoaderZXSCR *>(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<ImageLoaderZXSCR *>(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<gchar **>(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<ImageLoaderZXSCR *>(loader);
ld->abort = TRUE;
}
-static void image_loader_zxscr_free(gpointer loader)
+void image_loader_zxscr_free(gpointer loader)
{
auto ld = static_cast<ImageLoaderZXSCR *>(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;
static gboolean image_loader_continue(ImageLoader *il)
{
- gint b;
gint c;
if (!il) return G_SOURCE_REMOVE;
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;
#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;
/* 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;
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);
{
ImageLoaderBackendFuncLoaderNew loader_new;
ImageLoaderBackendFuncSetSize set_size;
- ImageLoaderBackendFuncLoad load;
ImageLoaderBackendFuncWrite write;
ImageLoaderBackendFuncGetPixbuf get_pixbuf;
ImageLoaderBackendFuncClose close;
projects / geeqie.git / commitdiff