../cdk-pixbuf/cdk-pixbuf-io.c

Bug Summary

File:	_build/../cdk-pixbuf/cdk-pixbuf-io.c
Warning:	line 546, column 9 Potential leak of memory pointed to by 'module'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -O2 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name cdk-pixbuf-io.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/rootdir/_build -fcoverage-compilation-dir=/rootdir/_build -resource-dir /usr/lib/llvm-21/lib/clang/21 -I cdk-pixbuf/libcdk_pixbuf-2.0.so.0.4500.0.p -I cdk-pixbuf -I ../cdk-pixbuf -I . -I .. -I cdk-pixbuf/pixops -I ../cdk-pixbuf/pixops -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/libmount -I /usr/include/blkid -D _FILE_OFFSET_BITS=64 -D _POSIX_C_SOURCE=200809L -D _DEFAULT_SOURCE -D _XOPEN_SOURCE=700 -D HAVE_CONFIG_H=1 -D G_LOG_STRUCTURED=1 -D G_LOG_DOMAIN="CdkPixbuf" -D CDK_PIXBUF_COMPILATION -D CDK_PIXBUF_PREFIX="/usr/local" -D CDK_PIXBUF_LOCALEDIR="/usr/local/share/locale" -D CDK_PIXBUF_LIBDIR="/usr/local/lib/x86_64-linux-gnu" -D CDK_PIXBUF_BINARY_VERSION="2.10.0" -D CDK_PIXBUF_ENABLE_BACKEND -D PIXBUF_LIBDIR="/usr/local/lib/x86_64-linux-gnu/cdk-pixbuf-2.0/2.10.0/loaders" -D BUILT_MODULES_DIR="/rootdir/_build/cdk-pixbuf" -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/15/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-int-conversion -Wno-uninitialized -Wno-discarded-qualifiers -std=gnu99 -ferror-limit 19 -fvisibility=hidden -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-checker deadcode.DeadStores -analyzer-checker security.ArrayBound -analyzer-checker unix.cstring.NotNullTerminated -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2026-06-05-101004-8567-1 -x c ../cdk-pixbuf/cdk-pixbuf-io.c
1/* CdkPixbuf library - Main loading interface.
*
* Copyright (C) 1999 The Free Software Foundation
*
* Authors: Miguel de Icaza <miguel@gnu.org>
*          Federico Mena-Quintero <federico@gimp.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/

22#include "config.h"

24#include <stdlib.h>
25#include <stdio.h>
26#include <string.h>
27#include <errno(*__errno_location ()).h>
28#ifdef HAVE_UNISTD_H1
29#include <unistd.h>
30#endif

32#include <glib.h>
33#include <gio/gio.h>

35#include "cdk-pixbuf-private.h"
36#include "cdk-pixbuf-loader.h"
37#include "cdk-pixdata.h"

39#include <glib/gstdio.h>

41#ifdef G_OS_WIN32
42#define STRICT
43#include <windows.h>
44#undef STRICT
45#endif
46#ifdef OS_DARWIN
47#include <mach-o/dyld.h>
48#endif

50G_GNUC_BEGIN_IGNORE_DEPRECATIONSclang diagnostic push
 clang diagnostic ignored "-Wdeprecated-declarations"


52/**
* CdkPixbufModule:
* @module_name: the name of the module, usually the same as the
*  usual file extension for images of this type, eg. "xpm", "jpeg" or "png".
* @module_path: the path from which the module is loaded.
* @module: the loaded `GModule`.
* @info: a `CdkPixbufFormat` holding information about the module.
* @load: loads an image from a file.
* @load_xpm_data: loads an image from data in memory.
* @begin_load: begins an incremental load.
* @stop_load: stops an incremental load.
* @load_increment: continues an incremental load.
* @load_animation: loads an animation from a file.
* @save: saves a `CdkPixbuf` to a file.
* @save_to_callback: saves a `CdkPixbuf` by calling the given `CdkPixbufSaveFunc`.
* @is_save_option_supported: returns whether a save option key is supported by the module
* 
* A `CdkPixbufModule` contains the necessary functions to load and save
* images in a certain file format.
* 
* If `CdkPixbuf` has been compiled with `GModule` support, it can be extended
* by modules which can load (and perhaps also save) new image and animation
* formats.
*
* ## Implementing modules
* 
* The `CdkPixbuf` interfaces needed for implementing modules are contained in
* `cdk-pixbuf-io.h` (and `cdk-pixbuf-animation.h` if the module supports
* animations). They are not covered by the same stability guarantees as the
* regular CdkPixbuf API. To underline this fact, they are protected by the
* `CDK_PIXBUF_ENABLE_BACKEND` pre-processor symbol.
*
* Each loadable module must contain a `CdkPixbufModuleFillVtableFunc` function
* named `fill_vtable`, which will get called when the module
* is loaded and must set the function pointers of the `CdkPixbufModule`.
* 
* In order to make format-checking work before actually loading the modules
* (which may require calling `dlopen` to load image libraries), modules export
* their signatures (and other information) via the `fill_info` function. An
* external utility, `cdk-pixbuf-query-loaders`, uses this to create a text
* file containing a list of all available loaders and  their signatures.
* This file is then read at runtime by `CdkPixbuf` to obtain the list of
* available loaders and their signatures. 
* 
* Modules may only implement a subset of the functionality available via
* `CdkPixbufModule`. If a particular functionality is not implemented, the
* `fill_vtable` function will simply not set the corresponding
* function pointers of the `CdkPixbufModule` structure. If a module supports
* incremental loading (i.e. provides `begin_load`, `stop_load` and
* `load_increment`), it doesn't have to implement `load`, since `CdkPixbuf`
* can supply a generic `load` implementation wrapping the incremental loading.
*
* ## Installing modules
* 
* Installing a module is a two-step process:
*
*  - copy the module file(s) to the loader directory (normally
*    `$libdir/cdk-pixbuf-2.0/$version/loaders`, unless overridden by the
*    environment variable `CDK_PIXBUF_MODULEDIR`)
*  - call `cdk-pixbuf-query-loaders` to update the module file (normally
*    `$libdir/cdk-pixbuf-2.0/$version/loaders.cache`, unless overridden
*    by the environment variable `CDK_PIXBUF_MODULE_FILE`)
*/

116static gint 
117format_check (CdkPixbufModule *module, guchar *buffer, int size)
118{
      int i, j;
      gchar m;
      CdkPixbufModulePattern *pattern;
      gboolean anchored;
      guchar *prefix;
      gchar *mask;

      for (pattern = module->info->signature; pattern->prefix; pattern++) {
              if (pattern->mask && pattern->mask[0] == '*') {
                      prefix = (guchar *)pattern->prefix + 1;
                      mask = pattern->mask + 1;
                      anchored = FALSE(0);
              }
              else {
                      prefix = (guchar *)pattern->prefix;
                      mask = pattern->mask;
                      anchored = TRUE(!(0));
              }
              for (i = 0; i < size; i++) {
                      for (j = 0; i + j < size && prefix[j] != 0; j++) {
                              m = mask ? mask[j] : ' ';
                              if (m == ' ') {
                                      if (buffer[i + j] != prefix[j])
                                              break;
                              }
                              else if (m == '!') {
                                      if (buffer[i + j] == prefix[j])
                                              break;
                              }
                              else if (m == 'z') {
                                      if (buffer[i + j] != 0)
                                              break;
                              }
                              else if (m == 'n') {
                                      if (buffer[i + j] == 0)
                                              break;
                              }
                      } 

                      if (prefix[j] == 0) 
                              return pattern->relevance;

                      if (anchored)
                              break;
              }
      }
      return 0;
166}

168G_LOCK_DEFINE_STATIC (init_lock)static GMutex g__init_lock_lock;

170static gboolean file_formats_inited;
171static GSList *file_formats = NULL((void*)0);

173static gboolean cdk_pixbuf_io_init (void);

175static GSList *
176get_file_formats (void)
177{
      G_LOCK (init_lock)g_mutex_lock (&g__init_lock_lock);
      if (file_formats == NULL((void*)0) ||
11
←
Assuming 'file_formats' is equal to NULL→
          !file_formats_inited)
              file_formats_inited = cdk_pixbuf_io_init ();
12
←
Calling 'cdk_pixbuf_io_init'→
      G_UNLOCK (init_lock)g_mutex_unlock (&g__init_lock_lock);
      
      return file_formats;
185}

187#ifdef CDK_PIXBUF_RELOCATABLE // implies that cdk-pixbuf is built as a dll on windows

189#ifdef G_OS_WIN32

191/* DllMain function needed to tuck away the cdk-pixbuf DLL handle */

193static HMODULE cdk_pixbuf_dll;

195BOOL WINAPI
196DllMain (HINSTANCE hinstDLL,
       DWORD     fdwReason,
       LPVOID    lpvReserved)
199{
      switch (fdwReason) {
      case DLL_PROCESS_ATTACH:
              cdk_pixbuf_dll = (HMODULE) hinstDLL;
              break;
      }

return TRUE(!(0));
207}
208#endif

210gchar *
211cdk_pixbuf_get_toplevel (void)
212{
static gchar *toplevel = NULL((void*)0);

if (toplevel == NULL((void*)0)) {
216#if defined(G_OS_WIN32)
  toplevel = g_win32_get_package_installation_directory_of_module (cdk_pixbuf_dll);
218#elif defined(OS_DARWIN)
  char pathbuf[PATH_MAX4096 + 1];
  uint32_t  bufsize = sizeof(pathbuf);
  gchar *bin_dir;

  _NSGetExecutablePath(pathbuf, &bufsize);
  bin_dir = g_dirnameg_path_get_dirname GCC warning "Deprecated pre-processor symbol: replace with \"g_path_get_dirname\""

(pathbuf);
  toplevel = g_build_path (G_DIR_SEPARATOR_S"/", bin_dir, "..", NULL((void*)0));
  g_free (bin_dir);
227#elif defined (OS_LINUX1)
  gchar *exe_path, *bin_dir;

  exe_path = g_file_read_link ("/proc/self/exe", NULL((void*)0));
  bin_dir = g_dirnameg_path_get_dirname GCC warning "Deprecated pre-processor symbol: replace with \"g_path_get_dirname\""

(exe_path);
  toplevel = g_build_path (G_DIR_SEPARATOR_S"/", bin_dir, "..", NULL((void*)0));
  g_free (exe_path);
  g_free (bin_dir);
235#else
236#error "Relocations not supported for this platform"
237#endif
}
return toplevel;
240}

242#endif  /* CDK_PIXBUF_RELOCATABLE */


245#ifdef USE_GMODULE 

247static gboolean
248scan_string (const char **pos, GString *out)
249{
      const char *p = *pos, *q = *pos;
      char *tmp, *tmp2;
      gboolean quoted;
      
      while (g_ascii_isspace (*p)((g_ascii_table[(guchar) (*p)] & G_ASCII_SPACE) != 0))
              p++;
      
      if (!*p)
              return FALSE(0);
      else if (*p == '"') {
              p++;
              quoted = FALSE(0);
              for (q = p; (*q != '"') || quoted; q++) {
                      if (!*q)
                              return FALSE(0);
                      quoted = (*q == '\\') && !quoted;
              }
              
              tmp = g_strndup (p, q - p);
              tmp2 = g_strcompress (tmp);
              g_string_truncate (out, 0)g_string_truncate_inline (out, 0);
              g_string_append (out, tmp2)(__builtin_constant_p (tmp2) ? __extension__ ({ const char * const
 __val = (tmp2); g_string_append_len_inline (out, __val, (__builtin_expect
 (__extension__ ({ int _g_boolean_var_88 = 0; if (__val != ((
void*)0)) _g_boolean_var_88 = 1; _g_boolean_var_88; }), 1)) ?
 (gssize) strlen (((__val) + !(__val))) : (gssize) -1); }) : g_string_append_len_inline
 (out, tmp2, (gssize) -1));
              g_free (tmp);
              g_free (tmp2);
      }
      
      q++;
      *pos = q;
      
      return TRUE(!(0));
280}

282static gboolean
283scan_int (const char **pos, int *out)
284{
      int i = 0;
      char buf[32];
      const char *p = *pos;
      
      while (g_ascii_isspace (*p)((g_ascii_table[(guchar) (*p)] & G_ASCII_SPACE) != 0))
              p++;
      
      if (*p < '0' || *p > '9')
              return FALSE(0);
      
      while ((*p >= '0') && (*p <= '9') && i < sizeof (buf)) {
              buf[i] = *p;
              i++;
              p++;
      }
      
      if (i == sizeof (buf))
              return FALSE(0);
      else
              buf[i] = '\0';
      
      *out = atoi (buf);
      
      *pos = p;

      return TRUE(!(0));
311}

313static gboolean
314skip_space (const char **pos)
315{
      const char *p = *pos;
      
      while (g_ascii_isspace (*p)((g_ascii_table[(guchar) (*p)] & G_ASCII_SPACE) != 0))
              p++;

      *pos = p;
      
      return !(*p == '\0');
324}

326#ifdef CDK_PIXBUF_RELOCATABLE

328static char *
329get_libdir (void)
330{
static char *libdir = NULL((void*)0);

if (libdir == NULL((void*)0))
        libdir = g_build_filename (cdk_pixbuf_get_toplevel (), "lib", NULL((void*)0));

return libdir;
337}

339#undef CDK_PIXBUF_LIBDIR"/usr/local/lib/x86_64-linux-gnu"
340#define CDK_PIXBUF_LIBDIR"/usr/local/lib/x86_64-linux-gnu" get_libdir()

342#endif  /* CDK_PIXBUF_RELOCATABLE */

344/* In case we have a relative module path in the loaders cache
* prepend the toplevel dir */
346static gchar *
347build_module_path (const gchar *path)
348{
349#ifdef CDK_PIXBUF_RELOCATABLE
      if (g_path_is_absolute (path)) {
              return g_strdup (path)g_strdup_inline (path);
      } else {
              return g_build_filename (cdk_pixbuf_get_toplevel (), path, NULL((void*)0));
      }
355#else
      return g_strdup (path)g_strdup_inline (path);
357#endif
358}

360static gchar *
361cdk_pixbuf_get_module_file (void)
362{
gchar *result = g_strdup (g_getenv ("CDK_PIXBUF_MODULE_FILE"))g_strdup_inline (g_getenv ("CDK_PIXBUF_MODULE_FILE"));

if (!result)
        result = g_build_filename (CDK_PIXBUF_LIBDIR"/usr/local/lib/x86_64-linux-gnu", "cdk-pixbuf-2.0", CDK_PIXBUF_BINARY_VERSION"2.10.0", "loaders.cache", NULL((void*)0));

return result;
369}

371#endif  /* USE_GMODULE */


374static gboolean
375cdk_pixbuf_load_module_unlocked (CdkPixbufModule *image_module,
                               GError         **error);

378static gboolean
379cdk_pixbuf_io_init_modules (const char  *filename,
                          GError     **error)
381{
382#ifdef USE_GMODULE
      GIOChannel *channel;
      gchar *line_buf;
      gsize term;
      GString *tmp_buf = g_string_new (NULL((void*)0));
      gboolean have_error = FALSE(0);
      CdkPixbufModule *module = NULL((void*)0);
      int flags = 0;
      int n_patterns = 0;
      CdkPixbufModulePattern *pattern;
      GError *local_error = NULL((void*)0);
      guint num_formats;

      channel = g_io_channel_new_file (filename, "r",  &local_error);
      if (!channel) {
14
←
Assuming 'channel' is non-null→
15
←
Taking false branch→
              char *filename_utf8 = g_filename_display_name (filename);
              g_set_error (error,
                           G_IO_ERRORg_io_error_quark(),
                           G_IO_ERROR_INVALID_ARGUMENT,
                           "Cannot open pixbuf loader module file '%s': %s\n\n"
                           "This likely means that your installation is broken.\n"
                           "Try running the command\n"
                           "  cdk-pixbuf-query-loaders > %s\n"
                           "to make things work again for the time being.",
                           filename_utf8, local_error->message, filename_utf8);
              g_clear_error (&local_error);
              g_string_free (tmp_buf, TRUE)(__builtin_constant_p ((!(0))) ? (((!(0))) ? (g_string_free) (
(tmp_buf), ((!(0)))) : g_string_free_and_steal (tmp_buf)) : (
g_string_free) ((tmp_buf), ((!(0)))));
              g_free (filename_utf8);
              return FALSE(0);
      }

      num_formats = g_slist_length (file_formats);
      
      while (!have_error15.1
'have_error' is 0
1
'have_error' is 0
 && g_io_channel_read_line (channel, &line_buf, NULL((void*)0), &term, NULL((void*)0)) == G_IO_STATUS_NORMAL) {
16
←
Assuming the condition is true→
17
←
Loop condition is true.  Entering loop body→
27
←
Assuming the condition is false→
28
←
Loop condition is false. Execution jumps to the end of the function→
              const char *p;
              
              p = line_buf;

              line_buf[term] = 0;

              if (!skip_space (&p)) {
18
←
Assuming the condition is false→
19
←
Taking false branch→
                      /* Blank line marking the end of a module */
                      if (module && *p != '#') {
                              file_formats = g_slist_prepend (file_formats, module);
                              module = NULL((void*)0);
                      }
                      
                      goto next_line;
              }

              if (*p == '#') 
20
←
Assuming the condition is false→
21
←
Taking false branch→
                      goto next_line;
              
              if (!module21.1
'module' is null
) {
22
←
Taking true branch→
                      /* Read a module location */
                      module = g_new0 (CdkPixbufModule, 1)(CdkPixbufModule *) (__extension__ ({ gsize __n = (gsize) (1)
; gsize __s = sizeof (CdkPixbufModule); gpointer __p; if (__s
 == 1) __p = g_malloc0 (__n); else if (__builtin_constant_p (
__n) && (__s == 0 || __n <= (9223372036854775807L *
2UL+1UL) / __s)) __p = g_malloc0 (__n * __s); else __p = g_malloc0_n
 (__n, __s); __p; }));
23
←
Taking false branch→
24
←
Memory is allocated→
                      n_patterns = 0;
                      
                      if (!scan_string (&p, tmp_buf)) {
25
←
Assuming the condition is false→
26
←
Taking false branch→
                              g_warning ("Error parsing loader info in '%s'\n  %s", 
                                         filename, line_buf);
                              have_error = TRUE(!(0));
                      }
                      module->module_path = build_module_path (tmp_buf->str);
              }
              else if (!module->module_name) {
                      module->info = g_new0 (CdkPixbufFormat, 1)(CdkPixbufFormat *) (__extension__ ({ gsize __n = (gsize) (1)
; gsize __s = sizeof (CdkPixbufFormat); gpointer __p; if (__s
 == 1) __p = g_malloc0 (__n); else if (__builtin_constant_p (
__n) && (__s == 0 || __n <= (9223372036854775807L *
2UL+1UL) / __s)) __p = g_malloc0 (__n * __s); else __p = g_malloc0_n
 (__n, __s); __p; }));
                      if (!scan_string (&p, tmp_buf)) {
                              g_warning ("Error parsing loader info in '%s'\n  %s", 
                                         filename, line_buf);
                              have_error = TRUE(!(0));
                      }
                      module->info->name =  g_strdup (tmp_buf->str)g_strdup_inline (tmp_buf->str);
                      module->module_name = module->info->name;

                      flags = 0;
                      if (!scan_int (&p, &flags)) {
                              g_warning ("Error parsing loader info in '%s'\n  %s", 
                                         filename, line_buf);
                              have_error = TRUE(!(0));
                      }
                      module->info->flags = flags;
                      
                      if (!scan_string (&p, tmp_buf)) {
                              g_warning ("Error parsing loader info in '%s'\n  %s", 
                                         filename, line_buf);
                              have_error = TRUE(!(0));
                      }                       
                      if (tmp_buf->str[0] != 0)
                              module->info->domain = g_strdup (tmp_buf->str)g_strdup_inline (tmp_buf->str);

                      if (!scan_string (&p, tmp_buf)) {
                              g_warning ("Error parsing loader info in '%s'\n  %s", 
                                         filename, line_buf);
                              have_error = TRUE(!(0));
                      }                       
                      module->info->description = g_strdup (tmp_buf->str)g_strdup_inline (tmp_buf->str);

                      if (scan_string (&p, tmp_buf)) {
                              module->info->license = g_strdup (tmp_buf->str)g_strdup_inline (tmp_buf->str);
                      }
              }
              else if (!module->info->mime_types) {
                      int n = 1;
                      module->info->mime_types = g_new0 (gchar*, 1)(gchar* *) (__extension__ ({ gsize __n = (gsize) (1); gsize __s
 = sizeof (gchar*); gpointer __p; if (__s == 1) __p = g_malloc0
 (__n); else if (__builtin_constant_p (__n) && (__s ==
|| __n <= (9223372036854775807L *2UL+1UL) / __s)) __p =
 g_malloc0 (__n * __s); else __p = g_malloc0_n (__n, __s); __p
; }));
                      while (scan_string (&p, tmp_buf)) {
                              if (tmp_buf->str[0] != 0) {
                                      module->info->mime_types =
                                              g_realloc (module->info->mime_types, (n + 1) * sizeof (gchar*));
                                      module->info->mime_types[n - 1] = g_strdup (tmp_buf->str)g_strdup_inline (tmp_buf->str);
                                      module->info->mime_types[n] = NULL((void*)0);
                                      n++;
                              }
                      }
              }
              else if (!module->info->extensions) {
                      int n = 1;
                      module->info->extensions = g_new0 (gchar*, 1)(gchar* *) (__extension__ ({ gsize __n = (gsize) (1); gsize __s
 = sizeof (gchar*); gpointer __p; if (__s == 1) __p = g_malloc0
 (__n); else if (__builtin_constant_p (__n) && (__s ==
|| __n <= (9223372036854775807L *2UL+1UL) / __s)) __p =
 g_malloc0 (__n * __s); else __p = g_malloc0_n (__n, __s); __p
; }));
                      while (scan_string (&p, tmp_buf)) {
                              if (tmp_buf->str[0] != 0) {
                                      module->info->extensions =
                                              g_realloc (module->info->extensions, (n + 1) * sizeof (gchar*));
                                      module->info->extensions[n - 1] = g_strdup (tmp_buf->str)g_strdup_inline (tmp_buf->str);
                                      module->info->extensions[n] = NULL((void*)0);
                                      n++;
                              }
                      }
              }
              else {
                      n_patterns++;
                      module->info->signature = (CdkPixbufModulePattern *)
                              g_realloc (module->info->signature, (n_patterns + 1) * sizeof (CdkPixbufModulePattern));
                      pattern = module->info->signature + n_patterns;
                      pattern->prefix = NULL((void*)0);
                      pattern->mask = NULL((void*)0);
                      pattern->relevance = 0;
                      pattern--;
                      if (!scan_string (&p, tmp_buf))
                              goto context_error;
                      pattern->prefix = g_strdup (tmp_buf->str)g_strdup_inline (tmp_buf->str);
                      
                      if (!scan_string (&p, tmp_buf))
                              goto context_error;
                      if (*tmp_buf->str)
                              pattern->mask = g_strdup (tmp_buf->str)g_strdup_inline (tmp_buf->str);
                      else
                              pattern->mask = NULL((void*)0);
                      
                      if (!scan_int (&p, &pattern->relevance))
                              goto context_error;
                      
                      goto next_line;

              context_error:
                      g_free (pattern->prefix);
                      g_free (pattern->mask);
                      g_free (pattern);
                      g_warning ("Error parsing loader info in '%s'\n  %s", 
                                 filename, line_buf);
                      have_error = TRUE(!(0));
              }
      next_line:
              g_free (line_buf);
      }
      g_string_free (tmp_buf, TRUE)(__builtin_constant_p ((!(0))) ? (((!(0))) ? (g_string_free) (
(tmp_buf), ((!(0)))) : g_string_free_and_steal (tmp_buf)) : (
g_string_free) ((tmp_buf), ((!(0)))));
29
←
Potential leak of memory pointed to by 'module'
      g_io_channel_unref (channel);

      if (g_slist_length (file_formats) <= num_formats) {
              char *filename_utf8 = g_filename_display_name (filename);
              g_set_error (error,
                           G_IO_ERRORg_io_error_quark(),
                           G_IO_ERROR_NOT_INITIALIZED,
                           "No new CdkPixbufModule loaded from '%s'",
                           filename_utf8);
              g_free (filename_utf8);
              return FALSE(0);
      }
559#endif
      return TRUE(!(0));
561}

563/**
* cdk_pixbuf_init_modules:
* @path: Path to directory where the `loaders.cache` is installed
* @error: return location for a `GError`
*
* Initalizes the cdk-pixbuf loader modules referenced by the `loaders.cache`
* file present inside that directory.
*
* This is to be used by applications that want to ship certain loaders
* in a different location from the system ones.
*
* This is needed when the OS or runtime ships a minimal number of loaders
* so as to reduce the potential attack surface of carefully crafted image
* files, especially for uncommon file types. Applications that require
* broader image file types coverage, such as image viewers, would be
* expected to ship the cdk-pixbuf modules in a separate location, bundled
* with the application in a separate directory from the OS or runtime-
* provided modules.
*
* Since: 2.40
*/
584gboolean
585cdk_pixbuf_init_modules (const char  *path,
	 GError     **error)
587{
char *filename;
gboolean ret;

g_return_val_if_fail (path != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_89
 = 0; if (path != ((void*)0)) _g_boolean_var_89 = 1; _g_boolean_var_89
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "path != NULL"); return ((0)); } }
 while (0);
filename = g_build_filename (path, "loaders.cache", NULL((void*)0));
ret = cdk_pixbuf_io_init_modules (filename, error);
g_free (filename);
return ret;
596}

598static void
599cdk_pixbuf_io_init_builtin (void)
600{
601#define load_one_builtin_module(format)                                 G_STMT_STARTdo { \
      CdkPixbufModule *__builtin_module = g_new0 (CdkPixbufModule, 1)(CdkPixbufModule *) (__extension__ ({ gsize __n = (gsize) (1)
; gsize __s = sizeof (CdkPixbufModule); gpointer __p; if (__s
 == 1) __p = g_malloc0 (__n); else if (__builtin_constant_p (
__n) && (__s == 0 || __n <= (9223372036854775807L *
2UL+1UL) / __s)) __p = g_malloc0 (__n * __s); else __p = g_malloc0_n
 (__n, __s); __p; }));               \
      __builtin_module->module_name = #format;                                       \
      if (cdk_pixbuf_load_module_unlocked (__builtin_module, NULL((void*)0)))                  \
              file_formats = g_slist_prepend (file_formats, __builtin_module);       \
      else                                                                           \
              g_free (__builtin_module);                              } G_STMT_ENDwhile (0)

609#ifdef INCLUDE_ani
      load_one_builtin_module (ani);
611#endif
612#ifdef INCLUDE_png
      load_one_builtin_module (png);
614#endif
615#ifdef INCLUDE_bmp
      load_one_builtin_module (bmp);
617#endif
618#ifdef INCLUDE_gif
      load_one_builtin_module (gif);
620#endif
621#ifdef INCLUDE_ico
      load_one_builtin_module (ico);
623#endif
624#ifdef INCLUDE_jpeg
      load_one_builtin_module (jpeg);
626#endif
627#ifdef INCLUDE_pnm
      load_one_builtin_module (pnm);
629#endif
630#ifdef INCLUDE_tiff
      load_one_builtin_module (tiff);
632#endif
633#ifdef INCLUDE_xpm
      load_one_builtin_module (xpm);
635#endif
636#ifdef INCLUDE_xbm
      load_one_builtin_module (xbm);
638#endif
639#ifdef INCLUDE_tga
      load_one_builtin_module (tga);
641#endif
642#ifdef INCLUDE_icns
      load_one_builtin_module (icns);
644#endif
645#ifdef INCLUDE_qtif
      load_one_builtin_module (qtif);
647#endif
648#ifdef INCLUDE_gdiplus
      /* We don't bother having the GDI+ loaders individually selectable
       * for building in or not.
       */
      load_one_builtin_module (ico);
      load_one_builtin_module (wmf);
      load_one_builtin_module (emf);
      load_one_builtin_module (bmp);
      load_one_builtin_module (gif);
      load_one_builtin_module (jpeg);
      load_one_builtin_module (tiff);
659#endif
660#ifdef INCLUDE_gdip_png
      /* Except the gdip-png loader which normally isn't built at all even */
      load_one_builtin_module (png);
663#endif
664#ifdef INCLUDE_glycin
      load_one_builtin_module (avif);
      load_one_builtin_module (bmp);
      load_one_builtin_module (dds);
      load_one_builtin_module (gif);
      load_one_builtin_module (heic);
      load_one_builtin_module (ico);
      load_one_builtin_module (jpeg);
      load_one_builtin_module (jxl);
      load_one_builtin_module (openexr);
      load_one_builtin_module (png);
      load_one_builtin_module (pnm);
      load_one_builtin_module (qoi);
      load_one_builtin_module (raw);
      load_one_builtin_module (svg);
      load_one_builtin_module (tga);
      load_one_builtin_module (tiff);
      load_one_builtin_module (webp);
      load_one_builtin_module (xbm);
      load_one_builtin_module (xpm);
684#endif
685#ifdef INCLUDE_android
load_one_builtin_module (jpeg);
load_one_builtin_module (png);
load_one_builtin_module (gif);
load_one_builtin_module (webp);
load_one_builtin_module (bmp);
load_one_builtin_module (ico);
load_one_builtin_module (wbmp);
load_one_builtin_module (heif);
694#endif

696#undef load_one_builtin_module
697}

699static gboolean
700cdk_pixbuf_io_init (void)
701{
702#ifdef USE_GMODULE
char *module_file;

module_file = cdk_pixbuf_get_module_file ();
cdk_pixbuf_io_init_modules (module_file, NULL((void*)0));
13
←
Calling 'cdk_pixbuf_io_init_modules'→
g_free (module_file);
708#endif

cdk_pixbuf_io_init_builtin ();

return file_formats != NULL((void*)0);
713}

715#define module(type) \
extern void _cdk_pixbuf__##type##_fill_info   (CdkPixbufFormat *info);   \
extern void _cdk_pixbuf__##type##_fill_vtable (CdkPixbufModule *module)

719module (png);
720module (jpeg);
721module (gif);
722module (ico);
723module (ani);
724module (xpm);
725module (tiff);
726module (pnm);
727module (bmp);
728module (xbm);
729module (tga);
730module (icns);
731module (qtif);
732module (gdip_ico);
733module (gdip_wmf);
734module (gdip_emf);
735module (gdip_bmp);
736module (gdip_gif);
737module (gdip_jpeg);
738module (gdip_png);
739module (gdip_tiff);

741module (glycin_avif);
742module (glycin_bmp);
743module (glycin_dds);
744module (glycin_gif);
745module (glycin_heic);
746module (glycin_ico);
747module (glycin_jpeg);
748module (glycin_jxl);
749module (glycin_openexr);
750module (glycin_png);
751module (glycin_pnm);
752module (glycin_qoi);
753module (glycin_raw);
754module (glycin_svg);
755module (glycin_tga);
756module (glycin_tiff);
757module (glycin_webp);
758module (glycin_xbm);
759module (glycin_xpm);

761module (android_jpeg);
762module (android_png);
763module (android_gif);
764module (android_webp);
765module (android_bmp);
766module (android_ico);
767module (android_wbmp);
768module (android_heif);

770#undef module

772/* actually load the image handler - cdk_pixbuf_get_module only get a */
773/* reference to the module to load, it doesn't actually load it       */
774/* perhaps these actions should be combined in one function           */
775static gboolean
776cdk_pixbuf_load_module_unlocked (CdkPixbufModule *image_module,
                               GError         **error)
778{
      CdkPixbufModuleFillInfoFunc fill_info = NULL((void*)0);
      CdkPixbufModuleFillVtableFunc fill_vtable = NULL((void*)0);
              
      if (image_module->module != NULL((void*)0))
             return TRUE(!(0));

785#define try_module(format,id)                                           \
      if (fill_info == NULL((void*)0) &&                                        \
          strcmp (image_module->module_name, #format) == 0) {         \
              fill_info = _cdk_pixbuf__##id##_fill_info;              \
              fill_vtable = _cdk_pixbuf__##id##_fill_vtable;  \
      }

792#ifdef INCLUDE_gdiplus
      try_module (ico,gdip_ico);
      try_module (wmf,gdip_wmf);
      try_module (emf,gdip_emf);
      try_module (bmp,gdip_bmp);
      try_module (gif,gdip_gif);
      try_module (jpeg,gdip_jpeg);
      try_module (tiff,gdip_tiff);
800#endif
801#ifdef INCLUDE_gdip_png
      try_module (png,gdip_png);
803#endif
804#ifdef INCLUDE_glycin
      try_module (avif,    glycin_avif);
      try_module (bmp,     glycin_bmp);
      try_module (dds,     glycin_dds);
      try_module (gif,     glycin_gif);
      try_module (heic,    glycin_heic);
      try_module (ico,     glycin_ico);
      try_module (jpeg,    glycin_jpeg);
      try_module (jxl,     glycin_jxl);
      try_module (openexr, glycin_openexr);
      try_module (png,     glycin_png);
      try_module (pnm,     glycin_pnm);
      try_module (qoi,     glycin_qoi);
      try_module (raw,     glycin_raw);
      try_module (svg,     glycin_svg);
      try_module (tga,     glycin_tga);
      try_module (tiff,    glycin_tiff);
      try_module (webp,    glycin_webp);
      try_module (xbm,     glycin_xbm);
      try_module (xpm,     glycin_xpm);
824#endif
825#ifdef INCLUDE_android
try_module (jpeg,android_jpeg);
try_module (png,android_png);
try_module (gif,android_gif);
try_module (webp,android_webp);
try_module (bmp,android_bmp);
try_module (ico,android_ico);
try_module (wbmp,android_wbmp);
try_module (heif,android_heif);
834#endif
835#ifdef INCLUDE_png
      try_module (png,png);
837#endif
838#ifdef INCLUDE_bmp
      try_module (bmp,bmp);
840#endif
841#ifdef INCLUDE_gif
      try_module (gif,gif);
843#endif
844#ifdef INCLUDE_ico
      try_module (ico,ico);
846#endif
847#ifdef INCLUDE_ani
      try_module (ani,ani);
849#endif
850#ifdef INCLUDE_jpeg
      try_module (jpeg,jpeg);
852#endif
853#ifdef INCLUDE_pnm
      try_module (pnm,pnm);
855#endif
856#ifdef INCLUDE_tiff
      try_module (tiff,tiff);
858#endif
859#ifdef INCLUDE_xpm
      try_module (xpm,xpm);
861#endif
862#ifdef INCLUDE_xbm
      try_module (xbm,xbm);
864#endif
865#ifdef INCLUDE_tga
      try_module (tga,tga);
867#endif
868#ifdef INCLUDE_icns
      try_module (icns,icns);
870#endif
871#ifdef INCLUDE_qtif
      try_module (qtif,qtif);
873#endif

875#undef try_module
      
      if (fill_vtable) {
              image_module->module = (void *) 1;
              (* fill_vtable) (image_module);
              if (image_module->info == NULL((void*)0)) {
                      image_module->info = g_new0 (CdkPixbufFormat, 1)(CdkPixbufFormat *) (__extension__ ({ gsize __n = (gsize) (1)
; gsize __s = sizeof (CdkPixbufFormat); gpointer __p; if (__s
 == 1) __p = g_malloc0 (__n); else if (__builtin_constant_p (
__n) && (__s == 0 || __n <= (9223372036854775807L *
2UL+1UL) / __s)) __p = g_malloc0 (__n * __s); else __p = g_malloc0_n
 (__n, __s); __p; }));
                      (* fill_info) (image_module->info);
              }
              return TRUE(!(0));
      }
      else 
887#ifdef USE_GMODULE
      {
              char *path;
              GModule *module;
              gpointer sym;

              path = image_module->module_path;
              module = g_module_open (path, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);

              if (!module) {
                      char *path_utf8 = g_filename_display_name (path);
                      g_set_error (error,
                                   CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                   CDK_PIXBUF_ERROR_FAILED,
                                   _("Unable to load image-loading module: %s: %s")((char *) g_dgettext ("cdk-pixbuf", "Unable to load image-loading module: %s: %s"
)),
                                   path_utf8, g_module_error ());
                      g_free (path_utf8);
                      return FALSE(0);
              }

              image_module->module = module;        
      

              if (g_module_symbol (module, "fill_vtable", &sym)) {
                      fill_vtable = (CdkPixbufModuleFillVtableFunc) sym;
                      (* fill_vtable) (image_module);
                      return TRUE(!(0));
              } else {
                      char *path_utf8 = g_filename_display_name (path);
                      g_set_error (error,
                                   CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                   CDK_PIXBUF_ERROR_FAILED,
                                   _("Image-loading module %s does not export the proper interface; perhaps it’s from a different cdk-pixbuf version?")((char *) g_dgettext ("cdk-pixbuf", "Image-loading module %s does not export the proper interface; perhaps it’s from a different cdk-pixbuf version?"
)),
                                   path_utf8);
                      g_free (path_utf8);
                      return FALSE(0);
              }
      }
925#else
      g_set_error (error,
                   CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                   CDK_PIXBUF_ERROR_UNKNOWN_TYPE,
                   _("Image type “%s” is not supported")((char *) g_dgettext ("cdk-pixbuf", "Image type “%s” is not supported"
)),
                   image_module->module_name);
      return FALSE(0);
932#endif  /* !USE_GMODULE */
933}


936gboolean
937_cdk_pixbuf_load_module (CdkPixbufModule *image_module,
                       GError         **error)
939{
      gboolean ret;

      G_LOCK (init_lock)g_mutex_lock (&g__init_lock_lock);

      ret = cdk_pixbuf_load_module_unlocked (image_module, error);

      G_UNLOCK (init_lock)g_mutex_unlock (&g__init_lock_lock);

      return ret;
949}

951

953CdkPixbufModule *
954_cdk_pixbuf_get_named_module (const char *name,
                            GError **error)
956{
      GSList *modules;

      for (modules = get_file_formats (); modules; modules = g_slist_next (modules)((modules) ? (((GSList *)(modules))->next) : ((void*)0))) {
10
←
Calling 'get_file_formats'→
              CdkPixbufModule *module = (CdkPixbufModule *)modules->data;

              if (module->info->disabled)
                      continue;

              if (!strcmp (name, module->module_name))
                      return module;
      }

      g_set_error (error,
                   CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                   CDK_PIXBUF_ERROR_UNKNOWN_TYPE,
                   _("Image type “%s” is not supported")((char *) g_dgettext ("cdk-pixbuf", "Image type “%s” is not supported"
)),
                   name);
      
      return NULL((void*)0);
976}

978CdkPixbufModule *
979_cdk_pixbuf_get_module (guchar *buffer, guint size,
                      const gchar *filename,
                      GError **error)
982{
      GSList *modules;

      CdkPixbufModule *selected = NULL((void*)0);
      gchar *display_name = NULL((void*)0);
987#ifdef CDK_PIXBUF_USE_GIO_MIME1
      gchar *mime_type;
      gchar **mimes;
      gchar *type;
      gint j;
      gboolean uncertain;

      mime_type = g_content_type_guess (NULL((void*)0), buffer, size, &uncertain);
      if ((uncertain || g_str_equal (mime_type, "text/plain")(strcmp ((const char *) (mime_type), (const char *) ("text/plain"
)) == 0) || g_str_equal (mime_type, "application/gzip")(strcmp ((const char *) (mime_type), (const char *) ("application/gzip"
)) == 0)) && filename != NULL((void*)0)) {
              g_free (mime_type);
              mime_type = g_content_type_guess (filename, buffer, size, NULL((void*)0));
      }

      for (modules = get_file_formats (); modules; modules = g_slist_next (modules)((modules) ? (((GSList *)(modules))->next) : ((void*)0))) {
              CdkPixbufModule *module = (CdkPixbufModule *)modules->data;
              CdkPixbufFormat *info = module->info;

              if (info->disabled)
                      continue;

              mimes = info->mime_types;
              for (j = 0; mimes[j] != NULL((void*)0); j++) {
                      type = g_content_type_from_mime_type (mimes[j]);
                      if (g_content_type_equals (type, mime_type)) {
                              g_free (type);
                              selected = module;
                              break;
                      }
                      g_free (type);
              }

              if (selected != NULL((void*)0))
                      break;

/* Make sure the builtin CdkPixdata support works even without mime sniffing */
if (strcmp (info->name, "CdkPixdata") == 0 &&
    format_check (module, buffer, size) == 100) {
	selected = module;
	break;
}
      }
      g_free (mime_type);
1029#else
      gint score, best = 0;

      for (modules = get_file_formats (); modules; modules = g_slist_next (modules)((modules) ? (((GSList *)(modules))->next) : ((void*)0))) {
              CdkPixbufModule *module = (CdkPixbufModule *)modules->data;

              if (module->info->disabled)
                      continue;

              score = format_check (module, buffer, size);
              if (score > best) {
                      best = score; 
                      selected = module;
              }
              if (score >= 100) 
                      break;
      }
1046#endif

      if (selected != NULL((void*)0))
              return selected;

      if (filename)
      {
              display_name = g_filename_display_name (filename);
              g_set_error (error,
                           CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                           CDK_PIXBUF_ERROR_UNKNOWN_TYPE,
                           _("Couldn’t recognize the image file format for file “%s”")((char *) g_dgettext ("cdk-pixbuf", "Couldn’t recognize the image file format for file “%s”"
)),
                           display_name);
              g_free (display_name);
      }
      else
              g_set_error_literal (error,
                                   CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                   CDK_PIXBUF_ERROR_UNKNOWN_TYPE,
                                   _("Unrecognized image file format")((char *) g_dgettext ("cdk-pixbuf", "Unrecognized image file format"
)));


      return NULL((void*)0);
1069}

1071static
1072CdkPixbufModule *
1073_cdk_pixbuf_get_module_for_file (FILE *f, const gchar *filename, GError **error)
1074{
      guchar buffer[SNIFF_BUFFER_SIZE4096];
      int size;

      size = fread (&buffer, 1, sizeof (buffer), f);
      if (size == 0) {
gchar *display_name;
      	display_name = g_filename_display_name (filename);      
              g_set_error (error,
                           CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                           CDK_PIXBUF_ERROR_CORRUPT_IMAGE,
                           _("Image file “%s” contains no data")((char *) g_dgettext ("cdk-pixbuf", "Image file “%s” contains no data"
)),
                           display_name);
              g_free (display_name);
              return NULL((void*)0);
      }

return _cdk_pixbuf_get_module (buffer, size, filename, error);
1092}

1094static void
1095noop_size_notify (gint     *width,
  gint     *height,
  gpointer  data)
1098{
1099}

1101static void
1102prepared_notify (CdkPixbuf *pixbuf, 
               CdkPixbufAnimation *anim, 
               gpointer user_data)
1105{
      if (pixbuf != NULL((void*)0))
              g_object_ref (pixbuf)((__typeof__ (pixbuf)) (g_object_ref) (pixbuf));
      *((CdkPixbuf **)user_data) = pixbuf;
1109}

1111static void
1112noop_updated_notify (CdkPixbuf *pixbuf,
     int        x,
     int        y,
     int        width,
     int        height,
     gpointer   user_data)
1118{
1119}

1121static CdkPixbuf *
1122generic_load_incrementally (CdkPixbufModule *module, FILE *f, GError **error)
1123{
      CdkPixbuf *pixbuf = NULL((void*)0);
gpointer context;

context = module->begin_load (noop_size_notify, prepared_notify, noop_updated_notify, &pixbuf, error);
      
if (!context)
goto out;
              
while (!feof (f) && !ferror (f)) {
guchar buffer[LOAD_BUFFER_SIZE65536];
size_t length;

length = fread (buffer, 1, sizeof (buffer), f);
if (length > 0) {
	if (!module->load_increment (context, buffer, length, error)) {
		module->stop_load (context, NULL((void*)0));
		if (pixbuf != NULL((void*)0)) {
			g_object_unref (pixbuf);
			pixbuf = NULL((void*)0);
		}
		goto out;
	}
}
}

if (!module->stop_load (context, error)) {
if (pixbuf != NULL((void*)0)) {
	g_object_unref (pixbuf);
	pixbuf = NULL((void*)0);
}
}

1156out:
return pixbuf;
1158}

1160CdkPixbuf *
1161_cdk_pixbuf_generic_image_load (CdkPixbufModule *module, FILE *f, GError **error)
1162{
      CdkPixbuf *pixbuf = NULL((void*)0);

      if (module->load != NULL((void*)0)) {
              pixbuf = (* module->load) (f, error);
      } else if (module->begin_load != NULL((void*)0)) {
      	pixbuf = generic_load_incrementally (module, f, error);
      } else if (module->load_animation != NULL((void*)0)) {
CdkPixbufAnimation *animation;

              animation = (* module->load_animation) (f, error);
              if (animation != NULL((void*)0)) {
                      pixbuf = cdk_pixbuf_animation_get_static_image (animation);

                      g_object_ref (pixbuf)((__typeof__ (pixbuf)) (g_object_ref) (pixbuf));
                      g_object_unref (animation);
              }
      }

      return pixbuf;
1182}

1184/**
* cdk_pixbuf_new_from_file: (constructor)
* @filename: (type filename): Name of file to load, in the GLib file
*   name encoding
* @error: (out): Return location for an error
*
* Creates a new pixbuf by loading an image from a file.
*
* The file format is detected automatically.
*
* If `NULL` is returned, then @error will be set. Possible errors are:
*
*  - the file could not be opened
*  - there is no loader for the file's format
*  - there is not enough memory to allocate the image buffer
*  - the image buffer contains invalid data
*
* The error domains are `CDK_PIXBUF_ERROR` and `G_FILE_ERROR`.
*
* Returns: (nullable): A newly-created pixbuf
*/
1205CdkPixbuf *
1206cdk_pixbuf_new_from_file (const char *filename,
                        GError    **error)
1208{
      CdkPixbuf *pixbuf;
      FILE *f;
      CdkPixbufModule *image_module;

      g_return_val_if_fail (filename != NULL, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_90
 = 0; if (filename != ((void*)0)) _g_boolean_var_90 = 1; _g_boolean_var_90
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "filename != NULL"); return (((void
*)0)); } } while (0);
      g_return_val_if_fail (error == NULL || *error == NULL, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_91
 = 0; if (error == ((void*)0) || *error == ((void*)0)) _g_boolean_var_91
 = 1; _g_boolean_var_91; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "error == NULL || *error == NULL"
); return (((void*)0)); } } while (0);
      
      f = g_fopenfopen (filename, "rb");
      if (!f) {
              gint save_errno = errno(*__errno_location ());
gchar *display_name;
      	display_name = g_filename_display_name (filename);      
              g_set_error (error,
                           G_FILE_ERRORg_file_error_quark (),
                           g_file_error_from_errno (save_errno),
                           _("Failed to open file “%s”: %s")((char *) g_dgettext ("cdk-pixbuf", "Failed to open file “%s”: %s"
)),
                           display_name,
                           g_strerror (save_errno));
              g_free (display_name);
              return NULL((void*)0);
      }

      image_module = _cdk_pixbuf_get_module_for_file (f, filename, error);
      if (image_module == NULL((void*)0)) {
              fclose (f);
              return NULL((void*)0);
      }

      if (!_cdk_pixbuf_load_module (image_module, error)) {
              fclose (f);
              return NULL((void*)0);
      }

      fseek (f, 0, SEEK_SET0);
      pixbuf = _cdk_pixbuf_generic_image_load (image_module, f, error);
      fclose (f);

      if (pixbuf == NULL((void*)0) && error != NULL((void*)0) && *error == NULL((void*)0)) {

              /* I don't trust these crufty longjmp()'ing image libs
               * to maintain proper error invariants, and I don't
               * want user code to segfault as a result. We need to maintain
               * the invariant that error gets set if NULL is returned.
               */

gchar *display_name;
      	display_name = g_filename_display_name (filename);      
              g_warning ("Bug! cdk-pixbuf loader '%s' didn't set an error on failure.", image_module->module_name);
              g_set_error (error,
                           CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                           CDK_PIXBUF_ERROR_FAILED,
                           _("Failed to load image “%s”: reason not known, probably a corrupt image file")((char *) g_dgettext ("cdk-pixbuf", "Failed to load image “%s”: reason not known, probably a corrupt image file"
)),
                           display_name);
g_free (display_name);
      } else if (error != NULL((void*)0) && *error != NULL((void*)0)) {
/* Add the filename to the error message */
GError *e = *error;
gchar  *old;
gchar *display_name;

      	display_name = g_filename_display_name (filename);      
old = e->message;
e->message = g_strdup_printf (_("Failed to load image “%s”: %s")((char *) g_dgettext ("cdk-pixbuf", "Failed to load image “%s”: %s"
)),
			      display_name,
			      old);
g_free (old);
g_free (display_name);
      }

      return pixbuf;
1279}

1281#ifdef G_OS_WIN32

1283/**
* cdk_pixbuf_new_from_file_utf8: (constructor)
* @filename: (type filename): Name of file to load, in the GLib file name encoding
* @error: Return location for an error
*
* Same as cdk_pixbuf_new_from_file()
*
* Returns: (nullable): A newly-created pixbuf with a reference count of 1,
* or `NULL` if any of several error conditions occurred:  the file could not be opened,
* there was no loader for the file's format, there was not enough memory to
* allocate the image buffer, or the image file contained invalid data.
**/
1295CdkPixbuf *
1296cdk_pixbuf_new_from_file_utf8 (const char *filename,
                              GError    **error)
1298{
  return cdk_pixbuf_new_from_file (filename, error);
1300}

1302#endif


1305/**
* cdk_pixbuf_new_from_file_at_size: (constructor)
* @filename: (type filename): Name of file to load, in the GLib file
*     name encoding
* @width: The width the image should have or -1 to not constrain the width
* @height: The height the image should have or -1 to not constrain the height
* @error: (out): Return location for an error
*
* Creates a new pixbuf by loading an image from a file.
*
* The file format is detected automatically.
*
* If `NULL` is returned, then @error will be set. Possible errors are:
*
*  - the file could not be opened
*  - there is no loader for the file's format
*  - there is not enough memory to allocate the image buffer
*  - the image buffer contains invalid data
*
* The error domains are `CDK_PIXBUF_ERROR` and `G_FILE_ERROR`.
*
* The image will be scaled to fit in the requested size, preserving
* the image's aspect ratio. Note that the returned pixbuf may be smaller
* than `width` x `height`, if the aspect ratio requires it. To load
* and image at the requested size, regardless of aspect ratio, use
* [ctor@CdkPixbuf.Pixbuf.new_from_file_at_scale].
*
* Returns: (nullable): A newly-created pixbuf
*
* Since: 2.4
**/
1336CdkPixbuf *
1337cdk_pixbuf_new_from_file_at_size (const char *filename,
                                int         width, 
                                int         height,
                                GError    **error)
1341{
      return cdk_pixbuf_new_from_file_at_scale (filename, 
                                                width, height, 
                                                TRUE(!(0)), error);
1345}

1347#ifdef G_OS_WIN32

1349/**
* cdk_pixbuf_new_from_file_at_size_utf8: (constructor)
* @filename: (type filename): Name of file to load, in the GLib file name encoding
* @width: The width the image should have or -1 to not constrain the width
* @height: The height the image should have or -1 to not constrain the height
* @error: Return location for an error
*
* Same as cdk_pixbuf_new_from_file_at_size()
*
* Returns: (nullable): A newly-created pixbuf with a reference count of 1, or
* `NULL` if any of several error conditions occurred:  the file could not
* be opened, there was no loader for the file's format, there was not
* enough memory to allocate the image buffer, or the image file contained
* invalid data.
*
* Since: 2.4
**/
1366CdkPixbuf *
1367cdk_pixbuf_new_from_file_at_size_utf8 (const char *filename,
                                     int         width,
                                     int         height,
                                     GError    **error)
1371{
  return cdk_pixbuf_new_from_file_at_size (filename, width, height, error);
1373}

1375#endif

1377typedef struct {
      gint width;
      gint height;
      gboolean preserve_aspect_ratio;
1381} AtScaleData; 

1383static void
1384at_scale_data_async_data_free (AtScaleData *data)
1385{
g_slice_free (AtScaleData, data)do { if (1) g_slice_free1 (sizeof (AtScaleData), (data)); else
 (void) ((AtScaleData*) 0 == (data)); } while (0);
1387}

1389static void
1390at_scale_size_prepared_cb (CdkPixbufLoader *loader, 
                         int              width,
                         int              height,
                         gpointer         data)
1394{
      AtScaleData *info = data;

      g_return_if_fail (width > 0 && height > 0)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_92
 = 0; if (width > 0 && height > 0) _g_boolean_var_92
 = 1; _g_boolean_var_92; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "width > 0 && height > 0"
); return; } } while (0);

      if (info->preserve_aspect_ratio && 
          (info->width > 0 || info->height > 0)) {
              if (info->width < 0)
              {
                      width = width * (double)info->height/(double)height;
                      height = info->height;
              }
              else if (info->height < 0)
              {
                      height = height * (double)info->width/(double)width;
                      width = info->width;
              }
              else if ((double)height * (double)info->width >
                       (double)width * (double)info->height) {
                      width = 0.5 + (double)width * (double)info->height / (double)height;
                      height = info->height;
              } else {
                      height = 0.5 + (double)height * (double)info->width / (double)width;
                      width = info->width;
              }
      } else {
              if (info->width > 0)
                      width = info->width;
              if (info->height > 0)
                      height = info->height;
      }
      
      width = MAX (width, 1)(((width) > (1)) ? (width) : (1));
      height = MAX (height, 1)(((height) > (1)) ? (height) : (1));

      cdk_pixbuf_loader_set_size (loader, width, height);
1430}

1432/**
* cdk_pixbuf_new_from_file_at_scale: (constructor)
* @filename: (type filename): Name of file to load, in the GLib file
*     name encoding
* @width: The width the image should have or -1 to not constrain the width
* @height: The height the image should have or -1 to not constrain the height
* @preserve_aspect_ratio: `TRUE` to preserve the image's aspect ratio
* @error: Return location for an error
*
* Creates a new pixbuf by loading an image from a file.
*
* The file format is detected automatically.
*
* If `NULL` is returned, then @error will be set. Possible errors are:
*
*  - the file could not be opened
*  - there is no loader for the file's format
*  - there is not enough memory to allocate the image buffer
*  - the image buffer contains invalid data
*
* The error domains are `CDK_PIXBUF_ERROR` and `G_FILE_ERROR`.
*
* The image will be scaled to fit in the requested size, optionally preserving
* the image's aspect ratio. 
*
* When preserving the aspect ratio, a `width` of -1 will cause the image
* to be scaled to the exact given height, and a `height` of -1 will cause
* the image to be scaled to the exact given width. When not preserving
* aspect ratio, a `width` or `height` of -1 means to not scale the image
* at all in that dimension. Negative values for `width` and `height` are
* allowed since 2.8.
*
* Returns: (nullable): A newly-created pixbuf
*
* Since: 2.6
**/
1468CdkPixbuf *
1469cdk_pixbuf_new_from_file_at_scale (const char *filename,
                                 int         width, 
                                 int         height,
                                 gboolean    preserve_aspect_ratio,
                                 GError    **error)
1474{

      CdkPixbufLoader *loader;
      CdkPixbuf       *pixbuf;
      guchar buffer[LOAD_BUFFER_SIZE65536];
      int length;
      FILE *f;
      AtScaleData info;
      CdkPixbufAnimation *animation;
      CdkPixbufAnimationIter *iter;
      gboolean has_frame;

      g_return_val_if_fail (filename != NULL, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_93
 = 0; if (filename != ((void*)0)) _g_boolean_var_93 = 1; _g_boolean_var_93
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "filename != NULL"); return (((void
*)0)); } } while (0);
      g_return_val_if_fail (width > 0 || width == -1, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_94
 = 0; if (width > 0 || width == -1) _g_boolean_var_94 = 1;
 _g_boolean_var_94; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "width > 0 || width == -1"
); return (((void*)0)); } } while (0);
      g_return_val_if_fail (height > 0 || height == -1, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_95
 = 0; if (height > 0 || height == -1) _g_boolean_var_95 = 1
; _g_boolean_var_95; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "height > 0 || height == -1"
); return (((void*)0)); } } while (0);

      f = g_fopenfopen (filename, "rb");
      if (!f) {
              gint save_errno = errno(*__errno_location ());
              gchar *display_name = g_filename_display_name (filename);
              g_set_error (error,
                           G_FILE_ERRORg_file_error_quark (),
                           g_file_error_from_errno (save_errno),
                           _("Failed to open file “%s”: %s")((char *) g_dgettext ("cdk-pixbuf", "Failed to open file “%s”: %s"
)),
                           display_name,
                           g_strerror (save_errno));
              g_free (display_name);
              return NULL((void*)0);
      }

      loader = _cdk_pixbuf_loader_new_with_filename (filename);

      info.width = width;
      info.height = height;
      info.preserve_aspect_ratio = preserve_aspect_ratio;

      g_signal_connect (loader, "size-prepared",g_signal_connect_data ((loader), ("size-prepared"), (((GCallback
) (at_scale_size_prepared_cb))), (&info), ((void*)0), (GConnectFlags
) 0) 
                        G_CALLBACK (at_scale_size_prepared_cb), &info)g_signal_connect_data ((loader), ("size-prepared"), (((GCallback
) (at_scale_size_prepared_cb))), (&info), ((void*)0), (GConnectFlags
) 0);

      has_frame = FALSE(0);
      while (!has_frame && !feof (f) && !ferror (f)) {
              length = fread (buffer, 1, sizeof (buffer), f);
              if (length > 0)
                      if (!cdk_pixbuf_loader_write (loader, buffer, length, error)) {
                              cdk_pixbuf_loader_close (loader, NULL((void*)0));
                              fclose (f);
                              g_object_unref (loader);
                              return NULL((void*)0);
                      }
              
              animation = cdk_pixbuf_loader_get_animation (loader);
              if (animation) {
                      iter = cdk_pixbuf_animation_get_iter (animation, NULL((void*)0));
                      if (!cdk_pixbuf_animation_iter_on_currently_loading_frame (iter)) {
                              has_frame = TRUE(!(0));
                      }
                      g_object_unref (iter);
              }
      }

      fclose (f);

      if (!cdk_pixbuf_loader_close (loader, error) && !has_frame) {
              g_object_unref (loader);
              return NULL((void*)0);
      }

      pixbuf = cdk_pixbuf_loader_get_pixbuf (loader);

      if (!pixbuf) {
              gchar *display_name = g_filename_display_name (filename);
              g_object_unref (loader);
              g_set_error (error,
                           CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                           CDK_PIXBUF_ERROR_FAILED,
                           _("Failed to load image “%s”: reason not known, probably a corrupt image file")((char *) g_dgettext ("cdk-pixbuf", "Failed to load image “%s”: reason not known, probably a corrupt image file"
)),
                           display_name);
              g_free (display_name);
              return NULL((void*)0);
      }

      g_object_ref (pixbuf)((__typeof__ (pixbuf)) (g_object_ref) (pixbuf));

      g_object_unref (loader);

      return pixbuf;
1560}

1562#ifdef G_OS_WIN32

1564/**
* cdk_pixbuf_new_from_file_at_scale_utf8: (constructor)
* @filename: (type filename): Name of file to load, in the GLib file name encoding
* @width: The width the image should have or -1 to not constrain the width
* @height: The height the image should have or -1 to not constrain the height
* @preserve_aspect_ratio: `TRUE` to preserve the image's aspect ratio
* @error: Return location for an error
*
* Same as cdk_pixbuf_new_from_file_at_scale().
*
* Returns: (nullable): A newly-created pixbuf with a reference count of 1,
* or `NULL` if any of several error conditions occurred:  the file could not be opened,
* there was no loader for the file's format, there was not enough memory to
* allocate the image buffer, or the image file contained invalid data.
*
* Since: 2.6
**/
1581CdkPixbuf *
1582cdk_pixbuf_new_from_file_at_scale_utf8 (const char *filename,
                                      int         width,
                                      int         height,
                                      gboolean    preserve_aspect_ratio,
                                      GError    **error)
1587{
  return cdk_pixbuf_new_from_file_at_scale (filename, width, height,
                                            preserve_aspect_ratio, error);
1590}
1591#endif


1594static CdkPixbuf *
1595load_from_stream (CdkPixbufLoader  *loader,
                GInputStream     *stream,
                GCancellable     *cancellable,
                GError          **error)
1599{
      CdkPixbuf *pixbuf;
      gssize n_read;
      guchar buffer[LOAD_BUFFER_SIZE65536];

      while (1) { 
              n_read = g_input_stream_read (stream, 
                                            buffer, 
                                            sizeof (buffer), 
                                            cancellable, 
                                            error);
              if (n_read < 0) {
                      cdk_pixbuf_loader_close (loader, NULL((void*)0));
                      return NULL((void*)0);
              }

              if (n_read == 0)
                      break;

              if (!cdk_pixbuf_loader_write (loader, 
                                            buffer, 
                                            n_read, 
                                            error)) {
                      cdk_pixbuf_loader_close (loader, NULL((void*)0));
                      return NULL((void*)0);
              }
      }

      if (!cdk_pixbuf_loader_close (loader, error))
              return NULL((void*)0);

      pixbuf = cdk_pixbuf_loader_get_pixbuf (loader);
      if (pixbuf == NULL((void*)0))
              return NULL((void*)0);

      return g_object_ref (pixbuf)((__typeof__ (pixbuf)) (g_object_ref) (pixbuf));
1635}


1638/**
* cdk_pixbuf_new_from_stream_at_scale: (constructor)
* @stream:  a `GInputStream` to load the pixbuf from
* @width: The width the image should have or -1 to not constrain the width
* @height: The height the image should have or -1 to not constrain the height
* @preserve_aspect_ratio: `TRUE` to preserve the image's aspect ratio
* @cancellable: (allow-none): optional `GCancellable` object, `NULL` to ignore
* @error: Return location for an error
*
* Creates a new pixbuf by loading an image from an input stream.  
*
* The file format is detected automatically. If `NULL` is returned, then
* @error will be set. The @cancellable can be used to abort the operation
* from another thread. If the operation was cancelled, the error 
* `G_IO_ERROR_CANCELLED` will be returned. Other possible errors are in
* the `CDK_PIXBUF_ERROR` and `G_IO_ERROR` domains.
*
* The image will be scaled to fit in the requested size, optionally 
* preserving the image's aspect ratio.
*
* When preserving the aspect ratio, a `width` of -1 will cause the image to be
* scaled to the exact given height, and a `height` of -1 will cause the image
* to be scaled to the exact given width. If both `width` and `height` are
* given, this function will behave as if the smaller of the two values
* is passed as -1.
*
* When not preserving aspect ratio, a `width` or `height` of -1 means to not
* scale the image at all in that dimension.
*
* The stream is not closed.
*
* Returns: (nullable): A newly-created pixbuf
*
* Since: 2.14
*/
1673CdkPixbuf *
1674cdk_pixbuf_new_from_stream_at_scale (GInputStream  *stream,
                                   gint           width,
                                   gint           height,
                                   gboolean       preserve_aspect_ratio,
                                   GCancellable  *cancellable,
                                   GError       **error)
1680{
      CdkPixbufLoader *loader;
      CdkPixbuf *pixbuf;
      AtScaleData info;

      loader = cdk_pixbuf_loader_new ();
      info.width = width;
      info.height = height;
      info.preserve_aspect_ratio = preserve_aspect_ratio;

      g_signal_connect (loader, "size-prepared",g_signal_connect_data ((loader), ("size-prepared"), (((GCallback
) (at_scale_size_prepared_cb))), (&info), ((void*)0), (GConnectFlags
) 0) 
                        G_CALLBACK (at_scale_size_prepared_cb), &info)g_signal_connect_data ((loader), ("size-prepared"), (((GCallback
) (at_scale_size_prepared_cb))), (&info), ((void*)0), (GConnectFlags
) 0);

      pixbuf = load_from_stream (loader, stream, cancellable, error);
      g_object_unref (loader);

      return pixbuf;
1697}


1700static void
1701load_from_stream_async_cb (GObject      *stream,
                         GAsyncResult *res,
                         gpointer      data)
1704{
      GTask *task = data;
      CdkPixbufLoader *loader;
      CdkPixbuf *pixbuf;
      GError *error = NULL((void*)0);
      GBytes *bytes = NULL((void*)0);

      loader = g_task_get_task_data (task);

      bytes = g_input_stream_read_bytes_finish (G_INPUT_STREAM (stream)((((GInputStream*) (void *) ((stream))))), res, &error);

      if (bytes == NULL((void*)0)) {
              cdk_pixbuf_loader_close (loader, NULL((void*)0));
              g_task_return_error (task, error);
      } else if (g_bytes_get_size (bytes) > 0) {
              if (!cdk_pixbuf_loader_write (loader, 
                                            g_bytes_get_data (bytes, NULL((void*)0)),
                                            g_bytes_get_size (bytes),
                                            &error)) {
                      cdk_pixbuf_loader_close (loader, NULL((void*)0));
                      g_task_return_error (task, error);
                      goto out;
              }
              g_input_stream_read_bytes_async (G_INPUT_STREAM (stream)((((GInputStream*) (void *) ((stream))))),
                                               LOAD_BUFFER_SIZE65536, 
                                               G_PRIORITY_DEFAULT0,
                                               g_task_get_cancellable (task),
                                               load_from_stream_async_cb,
                                               g_object_ref (task)((__typeof__ (task)) (g_object_ref) (task)));

      } else {
              if (!cdk_pixbuf_loader_close (loader, &error)) {
                      g_task_return_error (task, error);
                      goto out;
              }

              pixbuf = cdk_pixbuf_loader_get_pixbuf (loader);
              g_task_return_pointer (task, g_object_ref (pixbuf)((__typeof__ (pixbuf)) (g_object_ref) (pixbuf)), g_object_unref);
      }

1744out:
      g_bytes_unref (bytes);
      g_object_unref (task);
1747}


1750/**
* cdk_pixbuf_new_from_stream_at_scale_async: (finish-func cdk_pixbuf_new_from_stream_finish)
* @stream: a `GInputStream` from which to load the pixbuf
* @width: the width the image should have or -1 to not constrain the width
* @height: the height the image should have or -1 to not constrain the height
* @preserve_aspect_ratio: `TRUE` to preserve the image's aspect ratio
* @cancellable: (nullable): optional `GCancellable` object, `NULL` to ignore
* @callback: (scope async) (closure user_data): a `GAsyncReadyCallback` to call when the pixbuf is loaded
* @user_data: the data to pass to the callback function
*
* Creates a new pixbuf by asynchronously loading an image from an input stream.
*
* For more details see cdk_pixbuf_new_from_stream_at_scale(), which is the synchronous
* version of this function.
*
* When the operation is finished, @callback will be called in the main thread.
* You can then call cdk_pixbuf_new_from_stream_finish() to get the result of the operation.
*
* Since: 2.24
**/
1770void
1771cdk_pixbuf_new_from_stream_at_scale_async (GInputStream        *stream,
			   gint                 width,
			   gint                 height,
			   gboolean             preserve_aspect_ratio,
			   GCancellable        *cancellable,
			   GAsyncReadyCallback  callback,
			   gpointer             user_data)
1778{
GTask *task;
AtScaleData *data;
      CdkPixbufLoader *loader;

g_return_if_fail (G_IS_INPUT_STREAM (stream))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_96
 = 0; if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((stream)); GType __t = ((g_input_stream_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; }))))) _g_boolean_var_96
 = 1; _g_boolean_var_96; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "G_IS_INPUT_STREAM (stream)"
); return; } } while (0);
g_return_if_fail (callback != NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_97
 = 0; if (callback != ((void*)0)) _g_boolean_var_97 = 1; _g_boolean_var_97
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "callback != NULL"); return; } } while
 (0);
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_98
 = 0; if (!cancellable || (((__extension__ ({ GTypeInstance *
__inst = (GTypeInstance*) ((cancellable)); GType __t = ((g_cancellable_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; }))))) _g_boolean_var_98 = 1; _g_boolean_var_98; }), 1)
)) { } else { g_return_if_fail_warning ("CdkPixbuf", ((const char
*) (__func__)), "!cancellable || G_IS_CANCELLABLE (cancellable)"
); return; } } while (0);

data = g_slice_new (AtScaleData)((AtScaleData*) g_slice_alloc ((sizeof (AtScaleData) > 0 ?
 sizeof (AtScaleData) : 1)));
data->width = width;
data->height = height;
data->preserve_aspect_ratio = preserve_aspect_ratio;

      loader = cdk_pixbuf_loader_new ();
      g_signal_connect (loader, "size-prepared",g_signal_connect_data ((loader), ("size-prepared"), (((GCallback
) (at_scale_size_prepared_cb))), (data), ((void*)0), (GConnectFlags
) 0) 
                        G_CALLBACK (at_scale_size_prepared_cb), data)g_signal_connect_data ((loader), ("size-prepared"), (((GCallback
) (at_scale_size_prepared_cb))), (data), ((void*)0), (GConnectFlags
) 0);
      g_object_set_data_full (G_OBJECT (loader)((((GObject*) (void *) ((loader))))),
                              "cdk-pixbuf-please-kill-me-later", 
                              data,
                              (GDestroyNotify) at_scale_data_async_data_free);

task = g_task_new (stream, cancellable, callback, user_data);
g_task_set_source_tag (task, cdk_pixbuf_new_from_stream_at_scale_async)do { GTask *_task = (task); (g_task_set_source_tag) (_task, cdk_pixbuf_new_from_stream_at_scale_async
); if (g_task_get_name (_task) == ((void*)0)) g_task_set_static_name
 (_task, "cdk_pixbuf_new_from_stream_at_scale_async"); } while
 (0);
g_task_set_task_data (task, loader, g_object_unref);

      g_input_stream_read_bytes_async (stream,
                                       LOAD_BUFFER_SIZE65536, 
                                       G_PRIORITY_DEFAULT0,
                                       cancellable,
                                       load_from_stream_async_cb,
                                       task);
1810}

1812/**
* cdk_pixbuf_new_from_stream:
* @stream:  a `GInputStream` to load the pixbuf from
* @cancellable: (allow-none): optional `GCancellable` object, `NULL` to ignore
* @error: Return location for an error
*
* Creates a new pixbuf by loading an image from an input stream.  
*
* The file format is detected automatically.
*
* If `NULL` is returned, then `error` will be set.
*
* The `cancellable` can be used to abort the operation from another thread.
* If the operation was cancelled, the error `G_IO_ERROR_CANCELLED` will be
* returned. Other possible errors are in the `CDK_PIXBUF_ERROR` and
* `G_IO_ERROR` domains.
*
* The stream is not closed.
*
* Returns: (nullable): A newly-created pixbuf
*
* Since: 2.14
**/
1835CdkPixbuf *
1836cdk_pixbuf_new_from_stream (GInputStream  *stream,
                          GCancellable  *cancellable,
                          GError       **error)
1839{
      CdkPixbuf *pixbuf;
      CdkPixbufLoader *loader;

      loader = cdk_pixbuf_loader_new ();
      pixbuf = load_from_stream (loader, stream, cancellable, error);
      g_object_unref (loader);

      return pixbuf;
1848}

1850CdkPixbuf *
1851_cdk_pixbuf_new_from_resource_try_pixdata (const char *resource_path)
1852{
gsize data_size;
GBytes *bytes;

1856G_GNUC_BEGIN_IGNORE_DEPRECATIONSclang diagnostic push
 clang diagnostic ignored "-Wdeprecated-declarations"

/* We specialize CdkPixdata files, making these a reference to the
* compiled-in resource data, whether uncompressed and mmap'ed, or
* compressed, and uncompressed on-the-fly.
       */
if (g_resources_get_info  (resource_path, 0, &data_size, NULL((void*)0), NULL((void*)0)) &&
   data_size > sizeof (guint32) &&
   (bytes = g_resources_lookup_data (resource_path, 0, NULL((void*)0))) != NULL((void*)0)) {
CdkPixbuf *pixbuf = NULL((void*)0);
const guint8 *stream = g_bytes_get_data (bytes, NULL((void*)0));
CdkPixdata pixdata;
guint32 magic;

              magic = ((guint32) stream[0] << 24)
                    + ((guint32) stream[1] << 16)
                    + ((guint32) stream[2] << 8)
                    +  (guint32) stream[3];
if (magic == CDK_PIXBUF_MAGIC_NUMBER(0x47646b50) &&
    cdk_pixdata_deserialize (&pixdata, data_size, stream, NULL((void*)0))) {
	pixbuf = cdk_pixbuf_from_pixdata (&pixdata, FALSE(0), NULL((void*)0));
}

if (pixbuf) {
	/* Free the GBytes with the pixbuf */
	g_object_set_data_full (G_OBJECT (pixbuf)((((GObject*) (void *) ((pixbuf))))), "cdk-pixbuf-resource-bytes", bytes, (GDestroyNotify) g_bytes_unref);
	return pixbuf;
} else {
	g_bytes_unref (bytes);
}
}
1886G_GNUC_END_IGNORE_DEPRECATIONSclang diagnostic pop

      return NULL((void*)0);
1889}

1891/**
* cdk_pixbuf_new_from_resource: (constructor)
* @resource_path: the path of the resource file
* @error: Return location for an error
*
* Creates a new pixbuf by loading an image from an resource.
*
* The file format is detected automatically. If `NULL` is returned, then
* @error will be set.
*
* Returns: (nullable): A newly-created pixbuf
*
* Since: 2.26
**/
1905CdkPixbuf *
1906cdk_pixbuf_new_from_resource (const gchar  *resource_path,
	      GError      **error)
1908{
GInputStream *stream;
CdkPixbuf *pixbuf;

      pixbuf = _cdk_pixbuf_new_from_resource_try_pixdata (resource_path);
      if (pixbuf)
              return pixbuf;

stream = g_resources_open_stream (resource_path, 0, error);
if (stream == NULL((void*)0))
return NULL((void*)0);

pixbuf = cdk_pixbuf_new_from_stream (stream, NULL((void*)0), error);
g_object_unref (stream);
return pixbuf;
1923}

1925/**
* cdk_pixbuf_new_from_resource_at_scale: (constructor)
* @resource_path: the path of the resource file
* @width: The width the image should have or -1 to not constrain the width
* @height: The height the image should have or -1 to not constrain the height
* @preserve_aspect_ratio: `TRUE` to preserve the image's aspect ratio
* @error: Return location for an error
*
* Creates a new pixbuf by loading an image from an resource.
*
* The file format is detected automatically. If `NULL` is returned, then
* @error will be set.
*
* The image will be scaled to fit in the requested size, optionally
* preserving the image's aspect ratio. When preserving the aspect ratio,
* a @width of -1 will cause the image to be scaled to the exact given
* height, and a @height of -1 will cause the image to be scaled to the
* exact given width. When not preserving aspect ratio, a @width or
* @height of -1 means to not scale the image at all in that dimension.
*
* The stream is not closed.
*
* Returns: (nullable): A newly-created pixbuf
*
* Since: 2.26
*/
1951CdkPixbuf *
1952cdk_pixbuf_new_from_resource_at_scale (const char *resource_path,
		       int         width,
		       int         height,
		       gboolean    preserve_aspect_ratio,
		       GError    **error)
1957{
GInputStream *stream;
CdkPixbuf *pixbuf;

stream = g_resources_open_stream (resource_path, 0, error);
if (stream == NULL((void*)0))
return NULL((void*)0);

pixbuf = cdk_pixbuf_new_from_stream_at_scale (stream, width, height, preserve_aspect_ratio, NULL((void*)0), error);
g_object_unref (stream);
return pixbuf;
1968}

1970/**
* cdk_pixbuf_new_from_stream_async: (finish-func cdk_pixbuf_new_from_stream_finish)
* @stream: a `GInputStream` from which to load the pixbuf
* @cancellable: (nullable): optional `GCancellable` object, `NULL` to ignore
* @callback: (scope async) (closure user_data): a `GAsyncReadyCallback` to call when the pixbuf is loaded
* @user_data: the data to pass to the callback function
*
* Creates a new pixbuf by asynchronously loading an image from an input stream.
*
* For more details see cdk_pixbuf_new_from_stream(), which is the synchronous
* version of this function.
*
* When the operation is finished, @callback will be called in the main thread.
* You can then call cdk_pixbuf_new_from_stream_finish() to get the result of
* the operation.
*
* Since: 2.24
**/
1988void
1989cdk_pixbuf_new_from_stream_async (GInputStream        *stream,
		  GCancellable        *cancellable,
		  GAsyncReadyCallback  callback,
		  gpointer             user_data)
1993{
GTask *task;

g_return_if_fail (G_IS_INPUT_STREAM (stream))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_99
 = 0; if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((stream)); GType __t = ((g_input_stream_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; }))))) _g_boolean_var_99
 = 1; _g_boolean_var_99; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "G_IS_INPUT_STREAM (stream)"
); return; } } while (0);
g_return_if_fail (callback != NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_100
 = 0; if (callback != ((void*)0)) _g_boolean_var_100 = 1; _g_boolean_var_100
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "callback != NULL"); return; } } while
 (0);
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_101
 = 0; if (!cancellable || (((__extension__ ({ GTypeInstance *
__inst = (GTypeInstance*) ((cancellable)); GType __t = ((g_cancellable_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; }))))) _g_boolean_var_101 = 1; _g_boolean_var_101; }), 1
))) { } else { g_return_if_fail_warning ("CdkPixbuf", ((const
 char*) (__func__)), "!cancellable || G_IS_CANCELLABLE (cancellable)"
); return; } } while (0);

task = g_task_new (stream, cancellable, callback, user_data);
g_task_set_source_tag (task, cdk_pixbuf_new_from_stream_async)do { GTask *_task = (task); (g_task_set_source_tag) (_task, cdk_pixbuf_new_from_stream_async
); if (g_task_get_name (_task) == ((void*)0)) g_task_set_static_name
 (_task, "cdk_pixbuf_new_from_stream_async"); } while (0);
      g_task_set_task_data (task, cdk_pixbuf_loader_new (), g_object_unref);

      g_input_stream_read_bytes_async (stream,
                                       LOAD_BUFFER_SIZE65536, 
                                       G_PRIORITY_DEFAULT0,
                                       cancellable,
                                       load_from_stream_async_cb,
                                       task);
2010}

2012/**
* cdk_pixbuf_new_from_stream_finish: (constructor)
* @async_result: a `GAsyncResult`
* @error: a `GError`, or `NULL`
*
* Finishes an asynchronous pixbuf creation operation started with
* cdk_pixbuf_new_from_stream_async().
*
* Returns: (nullable): the newly created pixbuf
*
* Since: 2.24
**/
2024CdkPixbuf *
2025cdk_pixbuf_new_from_stream_finish (GAsyncResult  *async_result,
		   GError       **error)
2027{
GTask *task;

g_return_val_if_fail (G_IS_TASK (async_result), NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_102
 = 0; if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((async_result)); GType __t = ((g_task_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; }))))) _g_boolean_var_102
 = 1; _g_boolean_var_102; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "G_IS_TASK (async_result)"
); return (((void*)0)); } } while (0);
g_return_val_if_fail (!error || (error && !*error), NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_103
 = 0; if (!error || (error && !*error)) _g_boolean_var_103
 = 1; _g_boolean_var_103; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "!error || (error && !*error)"
); return (((void*)0)); } } while (0);

task = G_TASK (async_result)((((GTask*) (void *) ((async_result)))));

g_warn_if_fail (g_task_get_source_tag (task) == cdk_pixbuf_new_from_stream_async ||do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_104
 = 0; if (g_task_get_source_tag (task) == cdk_pixbuf_new_from_stream_async
 || g_task_get_source_tag (task) == cdk_pixbuf_new_from_stream_at_scale_async
) _g_boolean_var_104 = 1; _g_boolean_var_104; }), 1)) ; else g_warn_message
 ("CdkPixbuf", "../cdk-pixbuf/cdk-pixbuf-io.c", 2036, ((const
 char*) (__func__)), "g_task_get_source_tag (task) == cdk_pixbuf_new_from_stream_async || g_task_get_source_tag (task) == cdk_pixbuf_new_from_stream_at_scale_async"
); } while (0)
	g_task_get_source_tag (task) == cdk_pixbuf_new_from_stream_at_scale_async)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_104
 = 0; if (g_task_get_source_tag (task) == cdk_pixbuf_new_from_stream_async
 || g_task_get_source_tag (task) == cdk_pixbuf_new_from_stream_at_scale_async
) _g_boolean_var_104 = 1; _g_boolean_var_104; }), 1)) ; else g_warn_message
 ("CdkPixbuf", "../cdk-pixbuf/cdk-pixbuf-io.c", 2036, ((const
 char*) (__func__)), "g_task_get_source_tag (task) == cdk_pixbuf_new_from_stream_async || g_task_get_source_tag (task) == cdk_pixbuf_new_from_stream_at_scale_async"
); } while (0);

return g_task_propagate_pointer (task, error);
2039}

2041static void
2042info_cb (CdkPixbufLoader *loader, 
       int              width,
       int              height,
       gpointer         data)
2046{
      struct {
              CdkPixbufFormat *format;
              int width;
              int height;
      } *info = data;

      g_return_if_fail (width > 0 && height > 0)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_105
 = 0; if (width > 0 && height > 0) _g_boolean_var_105
 = 1; _g_boolean_var_105; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "width > 0 && height > 0"
); return; } } while (0);

      info->format = cdk_pixbuf_loader_get_format (loader);
      info->width = width;
      info->height = height;

      cdk_pixbuf_loader_set_size (loader, 0, 0);
2060}

2062/**
* cdk_pixbuf_get_file_info:
* @filename: (type filename): The name of the file to identify.
* @width: (optional) (out): Return location for the width of the image
* @height: (optional) (out): Return location for the height of the image
* 
* Parses an image file far enough to determine its format and size.
* 
* Returns: (nullable) (transfer none): A `CdkPixbufFormat` describing
*   the image format of the file
*
* Since: 2.4
**/
2075CdkPixbufFormat *
2076cdk_pixbuf_get_file_info (const gchar  *filename,
                        gint         *width, 
                        gint         *height)
2079{
      CdkPixbufLoader *loader;
      guchar buffer[SNIFF_BUFFER_SIZE4096];
      int length;
      FILE *f;
      struct {
              CdkPixbufFormat *format;
              gint width;
              gint height;
      } info;

      g_return_val_if_fail (filename != NULL, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_106
 = 0; if (filename != ((void*)0)) _g_boolean_var_106 = 1; _g_boolean_var_106
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "filename != NULL"); return (((void
*)0)); } } while (0);

      f = g_fopenfopen (filename, "rb");
      if (!f)
              return NULL((void*)0);

      loader = _cdk_pixbuf_loader_new_with_filename (filename);

      info.format = NULL((void*)0);
      info.width = -1;
      info.height = -1;
              
      g_signal_connect (loader, "size-prepared", G_CALLBACK (info_cb), &info)g_signal_connect_data ((loader), ("size-prepared"), (((GCallback
) (info_cb))), (&info), ((void*)0), (GConnectFlags) 0);

      while (!feof (f) && !ferror (f)) {
              length = fread (buffer, 1, sizeof (buffer), f);
              if (length > 0) {
                      if (!cdk_pixbuf_loader_write (loader, buffer, length, NULL((void*)0)))
                              break;
              }
              if (info.format != NULL((void*)0))
                      break;
      }

      fclose (f);
      cdk_pixbuf_loader_close (loader, NULL((void*)0));
      g_object_unref (loader);

      if (width) 
              *width = info.width;
      if (height) 
              *height = info.height;

      return info.format;
2124}

2126typedef struct {
      gchar *filename;
      gint width;
      gint height;
2130} GetFileInfoAsyncData;

2132static void
2133get_file_info_async_data_free (GetFileInfoAsyncData *data)
2134{
      g_free (data->filename);
      g_slice_free (GetFileInfoAsyncData, data)do { if (1) g_slice_free1 (sizeof (GetFileInfoAsyncData), (data
)); else (void) ((GetFileInfoAsyncData*) 0 == (data)); } while
 (0);
2137}

2139static void
2140get_file_info_thread (GTask                *task,
                    gpointer              source_object,
                    GetFileInfoAsyncData *data,
                    GCancellable         *cancellable)
2144{
      CdkPixbufFormat *format;

      format = cdk_pixbuf_get_file_info (data->filename, &data->width, &data->height);
      if (format == NULL((void*)0)) {
              g_task_return_new_error (task,
                                       CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                       CDK_PIXBUF_ERROR_UNKNOWN_TYPE,
                                       "Failed to recognize image format");
      } else {
              g_task_return_pointer (task,
                                     cdk_pixbuf_format_copy (format),
                                     (GDestroyNotify) cdk_pixbuf_format_free);
      }
2158}

2160/**
* cdk_pixbuf_get_file_info_async:
* @filename: (type filename): The name of the file to identify
* @cancellable: (allow-none): optional `GCancellable` object, `NULL` to ignore
* @callback: a `GAsyncReadyCallback` to call when the file info is available
* @user_data: the data to pass to the callback function
*
* Asynchronously parses an image file far enough to determine its
* format and size.
*
* For more details see cdk_pixbuf_get_file_info(), which is the synchronous
* version of this function.
*
* When the operation is finished, @callback will be called in the
* main thread. You can then call cdk_pixbuf_get_file_info_finish() to
* get the result of the operation.
*
* Since: 2.32
**/
2179void
2180cdk_pixbuf_get_file_info_async  (const gchar          *filename,
                               GCancellable         *cancellable,
                               GAsyncReadyCallback   callback,
                               gpointer              user_data)
2184{
      GetFileInfoAsyncData *data;
      GTask *task;

      g_return_if_fail (filename != NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_107
 = 0; if (filename != ((void*)0)) _g_boolean_var_107 = 1; _g_boolean_var_107
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "filename != NULL"); return; } } while
 (0);
      g_return_if_fail (callback != NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_108
 = 0; if (callback != ((void*)0)) _g_boolean_var_108 = 1; _g_boolean_var_108
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "callback != NULL"); return; } } while
 (0);
      g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_109
 = 0; if (!cancellable || (((__extension__ ({ GTypeInstance *
__inst = (GTypeInstance*) ((cancellable)); GType __t = ((g_cancellable_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; }))))) _g_boolean_var_109 = 1; _g_boolean_var_109; }), 1
))) { } else { g_return_if_fail_warning ("CdkPixbuf", ((const
 char*) (__func__)), "!cancellable || G_IS_CANCELLABLE (cancellable)"
); return; } } while (0);

      data = g_slice_new0 (GetFileInfoAsyncData)(GetFileInfoAsyncData *) (__extension__ ({ gsize __s = (sizeof
 (GetFileInfoAsyncData) > 0 ? sizeof (GetFileInfoAsyncData
) : 1); gpointer __p; __p = g_slice_alloc (__s); memset (__p,
 0, __s); __p; }));
      data->filename = g_strdup (filename)g_strdup_inline (filename);

      task = g_task_new (NULL((void*)0), cancellable, callback, user_data);
      g_task_set_return_on_cancel (task, TRUE(!(0)));
      g_task_set_source_tag (task, cdk_pixbuf_get_file_info_async)do { GTask *_task = (task); (g_task_set_source_tag) (_task, cdk_pixbuf_get_file_info_async
); if (g_task_get_name (_task) == ((void*)0)) g_task_set_static_name
 (_task, "cdk_pixbuf_get_file_info_async"); } while (0);
      g_task_set_task_data (task, data, (GDestroyNotify) get_file_info_async_data_free);
      g_task_run_in_thread (task, (GTaskThreadFunc) get_file_info_thread);
      g_object_unref (task);
2201}

2203/**
* cdk_pixbuf_get_file_info_finish:
* @async_result: a `GAsyncResult`
* @width: (out): Return location for the width of the image, or `NULL`
* @height: (out): Return location for the height of the image, or `NULL`
* @error: a `GError`, or `NULL`
*
* Finishes an asynchronous pixbuf parsing operation started with
* cdk_pixbuf_get_file_info_async().
*
* Returns: (transfer none) (nullable): A `CdkPixbufFormat` describing the
*   image format of the file
*
* Since: 2.32
**/
2218CdkPixbufFormat *
2219cdk_pixbuf_get_file_info_finish (GAsyncResult         *async_result,
                               gint                 *width,
                               gint                 *height,
                               GError              **error)
2223{
      GetFileInfoAsyncData *data;
      GTask *task;

      g_return_val_if_fail (g_task_is_valid (async_result, NULL), NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_110
 = 0; if (g_task_is_valid (async_result, ((void*)0))) _g_boolean_var_110
 = 1; _g_boolean_var_110; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "g_task_is_valid (async_result, NULL)"
); return (((void*)0)); } } while (0);

      task = G_TASK (async_result)((((GTask*) (void *) ((async_result)))));

      g_return_val_if_fail (!error || (error && !*error), NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_111
 = 0; if (!error || (error && !*error)) _g_boolean_var_111
 = 1; _g_boolean_var_111; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "!error || (error && !*error)"
); return (((void*)0)); } } while (0);
      g_warn_if_fail (g_task_get_source_tag (task) == cdk_pixbuf_get_file_info_async)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_112
 = 0; if (g_task_get_source_tag (task) == cdk_pixbuf_get_file_info_async
) _g_boolean_var_112 = 1; _g_boolean_var_112; }), 1)) ; else g_warn_message
 ("CdkPixbuf", "../cdk-pixbuf/cdk-pixbuf-io.c", 2232, ((const
 char*) (__func__)), "g_task_get_source_tag (task) == cdk_pixbuf_get_file_info_async"
); } while (0);

      data = g_task_get_task_data (task);

      if (!g_task_had_error (task)) {
              if (width)
                      *width = data->width;
              if (height)
                      *height = data->height;
      }

      return g_task_propagate_pointer (task, error);
2244}

2246/**
* cdk_pixbuf_new_from_xpm_data: (constructor)
* @data: (array zero-terminated=1): Pointer to inline XPM data.
*
* Creates a new pixbuf by parsing XPM data in memory.
*
* This data is commonly the result of including an XPM file into a
* program's C source.
*
* Returns: (nullable): A newly-created pixbuf
* 
* Deprecated: 2.44: Use [ctor@CdkPixbuf.Pixbuf.new_from_stream] with
*   a [class@Gio.MemoryInputStream], making sure to handle errors in
*   case the XPM format loader is not available
**/
2261CdkPixbuf *
2262cdk_pixbuf_new_from_xpm_data (const char **data)
2263{
      CdkPixbuf *(* load_xpm_data) (const char **data);
      CdkPixbuf *pixbuf;
      GError *error = NULL((void*)0);
      CdkPixbufModule *xpm_module;

      g_return_val_if_fail (data != NULL, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_113
 = 0; if (data != ((void*)0)) _g_boolean_var_113 = 1; _g_boolean_var_113
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "data != NULL"); return (((void*)0
)); } } while (0);

      xpm_module = _cdk_pixbuf_get_named_module ("xpm", &error);
      if (xpm_module == NULL((void*)0)) {
              g_warning ("Error loading XPM image loader: %s", error->message);
              g_error_free (error);
              return NULL((void*)0);
      }

      if (!_cdk_pixbuf_load_module (xpm_module, &error)) {
              g_warning ("Error loading XPM image loader: %s", error->message);
              g_error_free (error);
              return NULL((void*)0);
      }

      if (xpm_module->load_xpm_data == NULL((void*)0)) {
              g_warning ("cdk-pixbuf XPM module lacks XPM data capability");
              pixbuf = NULL((void*)0);
      } else {
              load_xpm_data = xpm_module->load_xpm_data;
              pixbuf = (* load_xpm_data) (data);
      }

      return pixbuf;
2293}

2295static void
2296collect_save_options (va_list   opts,
                    gchar  ***keys,
                    gchar  ***vals)
2299{
gchar *key;
gchar *val;
gchar *next;
gint count;

count = 0;
*keys = NULL((void*)0);
*vals = NULL((void*)0);

next = va_arg (opts, gchar*)__builtin_va_arg(opts, gchar*);
while (next)
  {
    key = next;
    val = va_arg (opts, gchar*)__builtin_va_arg(opts, gchar*);

    ++count;

    /* woo, slow */
    *keys = g_realloc (*keys, sizeof(gchar*) * (count + 1));
    *vals = g_realloc (*vals, sizeof(gchar*) * (count + 1));
    
    (*keys)[count-1] = g_strdup (key)g_strdup_inline (key);
    (*vals)[count-1] = g_strdup (val)g_strdup_inline (val);

    (*keys)[count] = NULL((void*)0);
    (*vals)[count] = NULL((void*)0);
    
    next = va_arg (opts, gchar*)__builtin_va_arg(opts, gchar*);
  }
2329}

2331static gboolean
2332save_to_file_callback (const gchar *buf,
                     gsize        count,
                     GError     **error,
                     gpointer     data)
2336{
      FILE *filehandle = data;
      gsize n;

      n = fwrite (buf, 1, count, filehandle);
      if (n != count) {
              gint save_errno = errno(*__errno_location ());
              g_set_error (error,
                           G_FILE_ERRORg_file_error_quark (),
                           g_file_error_from_errno (save_errno),
                           _("Error writing to image file: %s")((char *) g_dgettext ("cdk-pixbuf", "Error writing to image file: %s"
)),
                           g_strerror (save_errno));
              return FALSE(0);
      }
      return TRUE(!(0));
2351}

2353static gboolean
2354cdk_pixbuf_real_save (CdkPixbuf     *pixbuf, 
                    FILE          *filehandle, 
                    const char    *type, 
                    gchar        **keys,
                    gchar        **values,
                    GError       **error)
2360{
      gboolean ret;
      CdkPixbufModule *image_module = NULL((void*)0);       

      image_module = _cdk_pixbuf_get_named_module (type, error);

      if (image_module == NULL((void*)0))
              return FALSE(0);
     
      if (!_cdk_pixbuf_load_module (image_module, error))
              return FALSE(0);

      if (image_module->save) {
              /* save normally */
              ret = (* image_module->save) (filehandle, pixbuf,
                                            keys, values,
                                            error);
      } else if (image_module->save_to_callback) {
              /* save with simple callback */
              ret = (* image_module->save_to_callback) (save_to_file_callback,
                                                        filehandle, pixbuf,
                                                        keys, values,
                                                        error);
      } else {
              /* can't save */
              g_set_error (error,
                           CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                           CDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION,
                           _("This build of cdk-pixbuf does not support saving the image format: %s")((char *) g_dgettext ("cdk-pixbuf", "This build of cdk-pixbuf does not support saving the image format: %s"
)),
                           type);
              ret = FALSE(0);
      }

      return ret;
2394}

2396#define TMP_FILE_BUF_SIZE4096 4096

2398static gboolean
2399save_to_callback_with_tmp_file (CdkPixbufModule   *image_module,
                              CdkPixbuf         *pixbuf,
                              CdkPixbufSaveFunc  save_func,
                              gpointer           user_data,
                              gchar            **keys,
                              gchar            **values,
                              GError           **error)
2406{
      int fd;
      FILE *f = NULL((void*)0);
      gboolean retval = FALSE(0);
      gchar *buf = NULL((void*)0);
      gsize n;
      gchar *filename = NULL((void*)0);

      buf = g_try_malloc (TMP_FILE_BUF_SIZE4096);
      if (buf == NULL((void*)0)) {
              g_set_error_literal (error,
                                   CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                   CDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
                                   _("Insufficient memory to save image to callback")((char *) g_dgettext ("cdk-pixbuf", "Insufficient memory to save image to callback"
)));
              goto end;
      }

      fd = g_file_open_tmp ("cdkpixbuf-save-tmp.XXXXXX", &filename, error);
      if (fd == -1)
              goto end;
      f = fdopen (fd, "wb+");
      if (f == NULL((void*)0)) {
              gint save_errno = errno(*__errno_location ());
              g_set_error_literal (error,
                                   G_FILE_ERRORg_file_error_quark (),
                                   g_file_error_from_errno (save_errno),
                                   _("Failed to open temporary file")((char *) g_dgettext ("cdk-pixbuf", "Failed to open temporary file"
)));
              goto end;
      }

      retval = (image_module->save) (f, pixbuf, keys, values, error);
      if (!retval)
              goto end;

      rewind (f);
      for (;;) {
              n = fread (buf, 1, TMP_FILE_BUF_SIZE4096, f);
              if (n > 0) {
                      if (!save_func (buf, n, error, user_data))
                              goto end;
              }
              if (n != TMP_FILE_BUF_SIZE4096) 
                      break;
      }
      if (ferror (f)) {
              gint save_errno = errno(*__errno_location ());
              g_set_error_literal (error,
                                   G_FILE_ERRORg_file_error_quark (),
                                   g_file_error_from_errno (save_errno),
                                   _("Failed to read from temporary file")((char *) g_dgettext ("cdk-pixbuf", "Failed to read from temporary file"
)));
              goto end;
      }
      retval = TRUE(!(0));

end:
      /* cleanup and return retval */
      if (f)
              fclose (f);
      if (filename) {
              g_unlink (filename);
              g_free (filename);
      }
      g_free (buf);

      return retval;
2471}

2473static gboolean
2474cdk_pixbuf_real_save_to_callback (CdkPixbuf         *pixbuf,
                                CdkPixbufSaveFunc  save_func,
                                gpointer           user_data,
                                const char        *type, 
                                gchar            **keys,
                                gchar            **values,
                                GError           **error)
2481{
      gboolean ret;
      CdkPixbufModule *image_module = NULL((void*)0);       

      image_module = _cdk_pixbuf_get_named_module (type, error);

      if (image_module == NULL((void*)0))
              return FALSE(0);
     
      if (!_cdk_pixbuf_load_module (image_module, error))
              return FALSE(0);

      if (image_module->save_to_callback) {
              /* save normally */
              ret = (* image_module->save_to_callback) (save_func, user_data, 
                                                        pixbuf, keys, values,
                                                        error);
      } else if (image_module->save) {
              /* use a temporary file */
              ret = save_to_callback_with_tmp_file (image_module, pixbuf,
                                                    save_func, user_data, 
                                                    keys, values,
                                                    error);
      } else {
              /* can't save */
              g_set_error (error,
                           CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                           CDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION,
                           _("This build of cdk-pixbuf does not support saving the image format: %s")((char *) g_dgettext ("cdk-pixbuf", "This build of cdk-pixbuf does not support saving the image format: %s"
)),
                           type);
              ret = FALSE(0);
      }

      return ret;
2515}


2518/**
* cdk_pixbuf_save:
* @pixbuf: a `CdkPixbuf`.
* @filename: (type filename): name of file to save.
* @type: name of file format.
* @error: (nullable): return location for error
* @...: list of key-value save options, followed by `NULL`
*
* Saves pixbuf to a file in format @type. By default, "jpeg", "png", "ico" 
* and "bmp" are possible file formats to save in, but more formats may be
* installed. The list of all writable formats can be determined in the 
* following way:
*
* ```c
* void add_if_writable (CdkPixbufFormat *data, GSList **list)
* {
*   if (cdk_pixbuf_format_is_writable (data))
*     *list = g_slist_prepend (*list, data);
* }
* 
* GSList *formats = cdk_pixbuf_get_formats ();
* GSList *writable_formats = NULL;
* g_slist_foreach (formats, add_if_writable, &writable_formats);
* g_slist_free (formats);
* ```
*
* If `error` is set, `FALSE` will be returned. Possible errors include
* those in the `CDK_PIXBUF_ERROR` domain and those in the `G_FILE_ERROR`
* domain.
*
* The variable argument list should be `NULL`-terminated; if not empty,
* it should contain pairs of strings that modify the save
* parameters. For example:
*
* ```c
* cdk_pixbuf_save (pixbuf, handle, "jpeg", &error, "quality", "100", NULL);
* ```
*
* Currently only few parameters exist.
*
* JPEG images can be saved with a "quality" parameter; its value should be
* in the range `[0, 100]`. JPEG and PNG density can be set by setting the
* "x-dpi" and "y-dpi" parameters to the appropriate values in dots per inch.
*
* Text chunks can be attached to PNG images by specifying parameters of
* the form "tEXt::key", where key is an ASCII string of length 1-79.
* The values are UTF-8 encoded strings. The PNG compression level can
* be specified using the "compression" parameter; it's value is in an
* integer in the range of `[0, 9]`.
*
* ICC color profiles can also be embedded into PNG, JPEG and TIFF images.
* The "icc-profile" value should be the complete ICC profile encoded
* into base64.
*
* ```c
* char *contents;
* gsize length;
*
* // icm_path is set elsewhere
* g_file_get_contents (icm_path, &contents, &length, NULL);
*
* char *contents_encode = g_base64_encode ((const guchar *) contents, length);
*
* cdk_pixbuf_save (pixbuf, handle, "png", &error, "icc-profile", contents_encode, NULL);
* ```
*
* TIFF images recognize:
*
*  1. a "bits-per-sample" option (integer) which can be either 1 for saving
*     bi-level CCITTFAX4 images, or 8 for saving 8-bits per sample
*  2. a "compression" option (integer) which can be 1 for no compression,
*     2 for Huffman, 5 for LZW, 7 for JPEG and 8 for DEFLATE (see the libtiff
*     documentation and tiff.h for all supported codec values)
*  3. an "icc-profile" option (zero-terminated string) containing a base64
*     encoded ICC color profile.
*
* ICO images can be saved in depth 16, 24, or 32, by using the "depth"
* parameter. When the ICO saver is given "x_hot" and "y_hot" parameters,
* it produces a CUR instead of an ICO.
*
* Returns: `TRUE` on success, and `FALSE` otherwise
**/
2600gboolean
2601cdk_pixbuf_save (CdkPixbuf  *pixbuf, 
               const char *filename, 
               const char *type, 
               GError    **error,
               ...)
2606{
      gchar **keys = NULL((void*)0);
      gchar **values = NULL((void*)0);
      va_list args;
      gboolean result;

      g_return_val_if_fail (error == NULL || *error == NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_114
 = 0; if (error == ((void*)0) || *error == ((void*)0)) _g_boolean_var_114
 = 1; _g_boolean_var_114; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "error == NULL || *error == NULL"
); return ((0)); } } while (0);
      
      va_start (args, error)__builtin_va_start(args, error);
      
      collect_save_options (args, &keys, &values);
      
      va_end (args)__builtin_va_end(args);

      result = cdk_pixbuf_savev (pixbuf, filename, type,
                                 keys, values,
                                 error);

      g_strfreev (keys);
      g_strfreev (values);

      return result;
2628}

2630/**
* cdk_pixbuf_savev:
* @pixbuf: a `CdkPixbuf`.
* @filename: (type filename): name of file to save.
* @type: name of file format.
* @option_keys: (array zero-terminated=1) (element-type utf8) (nullable): name of options to set
* @option_values: (array zero-terminated=1) (element-type utf8) (nullable): values for named options
* @error: (allow-none): return location for error, or `NULL`
*
* Vector version of `cdk_pixbuf_save()`.
*
* Saves pixbuf to a file in `type`, which is currently "jpeg", "png", "tiff", "ico" or "bmp".
*
* If @error is set, `FALSE` will be returned.
*
* See [method@CdkPixbuf.Pixbuf.save] for more details.
*
* Returns: whether an error was set
**/

2650gboolean
2651cdk_pixbuf_savev (CdkPixbuf  *pixbuf, 
                const char *filename, 
                const char *type,
                char      **option_keys,
                char      **option_values,
                GError    **error)
2657{
      FILE *f = NULL((void*)0);
      gboolean result;
     
      g_return_val_if_fail (CDK_IS_PIXBUF (pixbuf), FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_115
 = 0; if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((pixbuf)); GType __t = ((cdk_pixbuf_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; }))))) _g_boolean_var_115
 = 1; _g_boolean_var_115; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "CDK_IS_PIXBUF (pixbuf)"
); return ((0)); } } while (0);
      g_return_val_if_fail (cdk_pixbuf_get_width (pixbuf) >= 0, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_116
 = 0; if (cdk_pixbuf_get_width (pixbuf) >= 0) _g_boolean_var_116
 = 1; _g_boolean_var_116; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cdk_pixbuf_get_width (pixbuf) >= 0"
); return ((0)); } } while (0);
      g_return_val_if_fail (cdk_pixbuf_get_height (pixbuf) >= 0, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_117
 = 0; if (cdk_pixbuf_get_height (pixbuf) >= 0) _g_boolean_var_117
 = 1; _g_boolean_var_117; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cdk_pixbuf_get_height (pixbuf) >= 0"
); return ((0)); } } while (0);
      g_return_val_if_fail (cdk_pixbuf_get_n_channels (pixbuf) >= 0, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_118
 = 0; if (cdk_pixbuf_get_n_channels (pixbuf) >= 0) _g_boolean_var_118
 = 1; _g_boolean_var_118; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cdk_pixbuf_get_n_channels (pixbuf) >= 0"
); return ((0)); } } while (0);
      g_return_val_if_fail (filename != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_119
 = 0; if (filename != ((void*)0)) _g_boolean_var_119 = 1; _g_boolean_var_119
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "filename != NULL"); return ((0));
 } } while (0);
      g_return_val_if_fail (type != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_120
 = 0; if (type != ((void*)0)) _g_boolean_var_120 = 1; _g_boolean_var_120
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "type != NULL"); return ((0)); } }
 while (0);
      g_return_val_if_fail (error == NULL || *error == NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_121
 = 0; if (error == ((void*)0) || *error == ((void*)0)) _g_boolean_var_121
 = 1; _g_boolean_var_121; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "error == NULL || *error == NULL"
); return ((0)); } } while (0);
     
      f = g_fopenfopen (filename, "wb");
      
      if (f == NULL((void*)0)) {
              gint save_errno = errno(*__errno_location ());
              gchar *display_name = g_filename_display_name (filename);
              g_set_error (error,
                           G_FILE_ERRORg_file_error_quark (),
                           g_file_error_from_errno (save_errno),
                           _("Failed to open “%s” for writing: %s")((char *) g_dgettext ("cdk-pixbuf", "Failed to open “%s” for writing: %s"
)),
                           display_name,
                           g_strerror (save_errno));
              g_free (display_name);
              return FALSE(0);
      }

     
     result = cdk_pixbuf_real_save (pixbuf, f, type,
                                    option_keys, option_values,
                                    error);
     
     
     if (!result) {
             g_return_val_if_fail (error == NULL || *error != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_122
 = 0; if (error == ((void*)0) || *error != ((void*)0)) _g_boolean_var_122
 = 1; _g_boolean_var_122; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "error == NULL || *error != NULL"
); return ((0)); } } while (0);
             fclose (f);
             g_unlink (filename);
             return FALSE(0);
     }

     if (fclose (f) < 0) {
             gint save_errno = errno(*__errno_location ());
             gchar *display_name = g_filename_display_name (filename);
             g_set_error (error,
                          G_FILE_ERRORg_file_error_quark (),
                          g_file_error_from_errno (save_errno),
                          _("Failed to close “%s” while writing image, all data may not have been saved: %s")((char *) g_dgettext ("cdk-pixbuf", "Failed to close “%s” while writing image, all data may not have been saved: %s"
)),
                          display_name,
                          g_strerror (save_errno));
             g_free (display_name);
             return FALSE(0);
     }
     
     return TRUE(!(0));
2711}

2713#ifdef G_OS_WIN32

2715/**
* cdk_pixbuf_savev_utf8:
* @pixbuf: a `CdkPixbuf`.
* @filename: name of file to save.
* @type: name of file format.
* @option_keys: (array zero-terminated=1) (element-type utf8) (nullable): name of options to set
* @option_values: (array zero-terminated=1) (element-type utf8) (nullable): values for named options
* @error: (allow-none): return location for error, or `NULL`
*
* Same as cdk_pixbuf_savev()
*
* Returns: whether an error was set
**/
2728gboolean
2729cdk_pixbuf_savev_utf8 (CdkPixbuf  *pixbuf,
                     const char *filename,
                     const char *type,
                     char      **option_keys,
                     char      **option_values,
                     GError    **error)
2735{
  return cdk_pixbuf_savev (pixbuf, filename, type, option_keys,
                           option_values, error);
2738}

2740#endif

2742/**
* cdk_pixbuf_save_to_callback:
* @pixbuf: a `CdkPixbuf`.
* @save_func: (scope call): a function that is called to save each block of data that
*   the save routine generates.
* @user_data: user data to pass to the save function.
* @type: name of file format.
* @error: (allow-none): return location for error, or `NULL`
* @...: list of key-value save options
*
* Saves pixbuf in format `type` by feeding the produced data to a
* callback.
*
* This function can be used when you want to store the image to something
* other than a file, such as an in-memory buffer or a socket.
*
* If @error is set, `FALSE` will be returned. Possible errors
* include those in the `CDK_PIXBUF_ERROR` domain and whatever the save
* function generates.
*
* See [method@CdkPixbuf.Pixbuf.save] for more details.
*
* Returns: whether an error was set
*
* Since: 2.4
**/
2768gboolean
2769cdk_pixbuf_save_to_callback    (CdkPixbuf  *pixbuf,
                              CdkPixbufSaveFunc save_func,
                              gpointer user_data,
                              const char *type, 
                              GError    **error,
                              ...)
2775{
      gchar **keys = NULL((void*)0);
      gchar **values = NULL((void*)0);
      va_list args;
      gboolean result;
      
      g_return_val_if_fail (error == NULL || *error == NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_123
 = 0; if (error == ((void*)0) || *error == ((void*)0)) _g_boolean_var_123
 = 1; _g_boolean_var_123; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "error == NULL || *error == NULL"
); return ((0)); } } while (0);
      
      va_start (args, error)__builtin_va_start(args, error);
      
      collect_save_options (args, &keys, &values);
      
      va_end (args)__builtin_va_end(args);

      result = cdk_pixbuf_save_to_callbackv (pixbuf, save_func, user_data,
                                             type, keys, values,
                                             error);

      g_strfreev (keys);
      g_strfreev (values);

      return result;
2797}

2799/**
* cdk_pixbuf_save_to_callbackv:
* @pixbuf: a `CdkPixbuf`
* @save_func: (scope call) (closure user_data): a function that is called to
*   save each block of data that the save routine generates
* @user_data: user data to pass to the save function
* @type: name of file format
* @option_keys: (array zero-terminated=1) (element-type utf8) (nullable): name of options to set
* @option_values: (array zero-terminated=1) (element-type utf8) (nullable): values for named options
* @error: return location for error, or `NULL`
*
* Vector version of `cdk_pixbuf_save_to_callback()`.
*
* Saves pixbuf to a callback in format @type, which is currently "jpeg",
* "png", "tiff", "ico" or "bmp".
*
* If @error is set, `FALSE` will be returned.
*
* See [method@CdkPixbuf.Pixbuf.save_to_callback] for more details.
*
* Returns: whether an error was set
*
* Since: 2.4
**/
2823gboolean
2824cdk_pixbuf_save_to_callbackv   (CdkPixbuf  *pixbuf, 
                              CdkPixbufSaveFunc save_func,
                              gpointer user_data,
                              const char *type,
                              char      **option_keys,
                              char      **option_values,
                              GError    **error)
2831{
      gboolean result;
      
      g_return_val_if_fail (CDK_IS_PIXBUF (pixbuf), FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_124
 = 0; if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((pixbuf)); GType __t = ((cdk_pixbuf_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; }))))) _g_boolean_var_124
 = 1; _g_boolean_var_124; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "CDK_IS_PIXBUF (pixbuf)"
); return ((0)); } } while (0);
      g_return_val_if_fail (cdk_pixbuf_get_width (pixbuf) >= 0, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_125
 = 0; if (cdk_pixbuf_get_width (pixbuf) >= 0) _g_boolean_var_125
 = 1; _g_boolean_var_125; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cdk_pixbuf_get_width (pixbuf) >= 0"
); return ((0)); } } while (0);
      g_return_val_if_fail (cdk_pixbuf_get_height (pixbuf) >= 0, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_126
 = 0; if (cdk_pixbuf_get_height (pixbuf) >= 0) _g_boolean_var_126
 = 1; _g_boolean_var_126; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cdk_pixbuf_get_height (pixbuf) >= 0"
); return ((0)); } } while (0);
      g_return_val_if_fail (cdk_pixbuf_get_n_channels (pixbuf) >= 0, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_127
 = 0; if (cdk_pixbuf_get_n_channels (pixbuf) >= 0) _g_boolean_var_127
 = 1; _g_boolean_var_127; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cdk_pixbuf_get_n_channels (pixbuf) >= 0"
); return ((0)); } } while (0);
      g_return_val_if_fail (save_func != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_128
 = 0; if (save_func != ((void*)0)) _g_boolean_var_128 = 1; _g_boolean_var_128
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "save_func != NULL"); return ((0))
; } } while (0);
      g_return_val_if_fail (type != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_129
 = 0; if (type != ((void*)0)) _g_boolean_var_129 = 1; _g_boolean_var_129
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "type != NULL"); return ((0)); } }
 while (0);
      g_return_val_if_fail (error == NULL || *error == NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_130
 = 0; if (error == ((void*)0) || *error == ((void*)0)) _g_boolean_var_130
 = 1; _g_boolean_var_130; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "error == NULL || *error == NULL"
); return ((0)); } } while (0);
     
     result = cdk_pixbuf_real_save_to_callback (pixbuf,
                                                save_func, user_data, type,
                                                option_keys, option_values,
                                                error);
     
     if (!result) {
             g_return_val_if_fail (error == NULL || *error != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_131
 = 0; if (error == ((void*)0) || *error != ((void*)0)) _g_boolean_var_131
 = 1; _g_boolean_var_131; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "error == NULL || *error != NULL"
); return ((0)); } } while (0);
             return FALSE(0);
     }

     return TRUE(!(0));
2853}

2855/**
* cdk_pixbuf_save_to_buffer:
* @pixbuf: a `CdkPixbuf`.
* @buffer: (array length=buffer_size) (out) (element-type guint8): location to receive a pointer
*   to the new buffer.
* @buffer_size: location to receive the size of the new buffer.
* @type: name of file format.
* @error: return location for error, or `NULL`
* @...: list of key-value save options
*
* Saves pixbuf to a new buffer in format `type`, which is currently "jpeg",
* "png", "tiff", "ico" or "bmp".
*
* This is a convenience function that uses `cdk_pixbuf_save_to_callback()`
* to do the real work.
*
* Note that the buffer is not `NUL`-terminated and may contain embedded `NUL`
* characters.
*
* If @error is set, `FALSE` will be returned and @buffer will be set to
* `NULL`. Possible errors include those in the `CDK_PIXBUF_ERROR`
* domain.
*
* See `cdk_pixbuf_save()` for more details.
*
* Returns: whether an error was set
*
* Since: 2.4
**/
2884gboolean
2885cdk_pixbuf_save_to_buffer      (CdkPixbuf  *pixbuf,
                              gchar     **buffer,
                              gsize      *buffer_size,
                              const char *type, 
                              GError    **error,
                              ...)
2891{
      gchar **keys = NULL((void*)0);
      gchar **values = NULL((void*)0);
      va_list args;
      gboolean result;
      
      g_return_val_if_fail (error == NULL || *error == NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_132
 = 0; if (error == ((void*)0) || *error == ((void*)0)) _g_boolean_var_132
 = 1; _g_boolean_var_132; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "error == NULL || *error == NULL"
); return ((0)); } } while (0);
      
      va_start (args, error)__builtin_va_start(args, error);
      
      collect_save_options (args, &keys, &values);
      
      va_end (args)__builtin_va_end(args);

      result = cdk_pixbuf_save_to_bufferv (pixbuf, buffer, buffer_size,
                                           type, keys, values,
                                           error);

      g_strfreev (keys);
      g_strfreev (values);

      return result;
2913}

2915struct SaveToBufferData {
      gchar *buffer;
      gsize len, max;
2918};

2920static gboolean
2921save_to_buffer_callback (const gchar *data,
                       gsize count,
                       GError **error,
                       gpointer user_data)
2925{
      struct SaveToBufferData *sdata = user_data;
      gchar *new_buffer;
      gsize new_max;

      if (sdata->len + count > sdata->max) {
              new_max = MAX (sdata->max*2, sdata->len + count)(((sdata->max*2) > (sdata->len + count)) ? (sdata->
max*2) : (sdata->len + count));
              new_buffer = g_try_realloc (sdata->buffer, new_max);
              if (!new_buffer) {
                      g_set_error_literal (error,
                                           CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                           CDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
                                           _("Insufficient memory to save image into a buffer")((char *) g_dgettext ("cdk-pixbuf", "Insufficient memory to save image into a buffer"
)));
                      return FALSE(0);
              }
              sdata->buffer = new_buffer;
              sdata->max = new_max;
      }
      memcpy (sdata->buffer + sdata->len, data, count);
      sdata->len += count;
      return TRUE(!(0));
2946}

2948/**
* cdk_pixbuf_save_to_bufferv:
* @pixbuf: a `CdkPixbuf`.
* @buffer: (array length=buffer_size) (out) (element-type guint8):
*   location to receive a pointer to the new buffer.
* @buffer_size: location to receive the size of the new buffer.
* @type: name of file format.
* @option_keys: (array zero-terminated=1) (element-type utf8) (nullable): name of options to set
* @option_values: (array zero-terminated=1) (element-type utf8) (nullable): values for named options
* @error: (allow-none): return location for error, or `NULL`
*
* Vector version of `cdk_pixbuf_save_to_buffer()`.
*
* Saves pixbuf to a new buffer in format @type, which is currently "jpeg",
* "tiff", "png", "ico" or "bmp".
*
* See [method@CdkPixbuf.Pixbuf.save_to_buffer] for more details.
*
* Returns: whether an error was set
*
* Since: 2.4
**/
2970gboolean
2971cdk_pixbuf_save_to_bufferv     (CdkPixbuf  *pixbuf,
                              gchar     **buffer,
                              gsize      *buffer_size,
                              const char *type, 
                              char      **option_keys,
                              char      **option_values,
                              GError    **error)
2978{
      static const gint initial_max = 1024;
      struct SaveToBufferData sdata;

      *buffer = NULL((void*)0);
      *buffer_size = 0;

      sdata.buffer = g_try_malloc (initial_max);
      sdata.max = initial_max;
      sdata.len = 0;
      if (!sdata.buffer) {
              g_set_error_literal (error,
                                   CDK_PIXBUF_ERRORcdk_pixbuf_error_quark (),
                                   CDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
                                   _("Insufficient memory to save image into a buffer")((char *) g_dgettext ("cdk-pixbuf", "Insufficient memory to save image into a buffer"
)));
              return FALSE(0);
      }

      if (!cdk_pixbuf_save_to_callbackv (pixbuf,
                                         save_to_buffer_callback, &sdata,
                                         type, option_keys, option_values,
                                         error)) {
              g_free (sdata.buffer);
              return FALSE(0);
      }

      *buffer = sdata.buffer;
      *buffer_size = sdata.len;
      return TRUE(!(0));
3007}

3009typedef struct {
      GOutputStream *stream;
      GCancellable  *cancellable;
3012} SaveToStreamData;

3014static gboolean
3015save_to_stream (const gchar  *buffer,
              gsize         count,
              GError      **error,
              gpointer      data)
3019{
      SaveToStreamData *sdata = (SaveToStreamData *)data;
      gsize remaining;
      gssize written;
      GError *my_error = NULL((void*)0);

      remaining = count;
      written = 0;
      while (remaining > 0) {
              buffer += written;
              remaining -= written;
              written = g_output_stream_write (sdata->stream, 
                                               buffer, remaining, 
                                               sdata->cancellable, 
                                               &my_error);
              if (written < 0) {
                      if (!my_error) {
                              g_set_error_literal (error,
                                                   G_IO_ERRORg_io_error_quark(), 0,
                                                   _("Error writing to image stream")((char *) g_dgettext ("cdk-pixbuf", "Error writing to image stream"
)));
                      }
                      else {
                              g_propagate_error (error, my_error);
                      }
                      return FALSE(0);
              }
      }

      return TRUE(!(0));
3048}

3050/**
* cdk_pixbuf_save_to_streamv:
* @pixbuf: a `CdkPixbuf`
* @stream: a `GOutputStream` to save the pixbuf to
* @type: name of file format
* @option_keys: (array zero-terminated=1) (element-type utf8) (nullable): name of options to set
* @option_values: (array zero-terminated=1) (element-type utf8) (nullable): values for named options
* @cancellable: (nullable): optional `GCancellable` object, `NULL` to ignore
* @error: return location for error
*
* Saves `pixbuf` to an output stream.
*
* Supported file formats are currently "jpeg", "tiff", "png", "ico" or
* "bmp".
*
* See [method@CdkPixbuf.Pixbuf.save_to_stream] for more details.
*
* Returns: `TRUE` if the pixbuf was saved successfully, `FALSE` if an
*   error was set.
*
* Since: 2.36
*/
3072gboolean
3073cdk_pixbuf_save_to_streamv (CdkPixbuf      *pixbuf,
                          GOutputStream  *stream,
                          const char     *type,
                          char          **option_keys,
                          char          **option_values,
                          GCancellable   *cancellable,
                          GError        **error)
3080{
      SaveToStreamData data;

      data.stream = stream;
      data.cancellable = cancellable;

      return cdk_pixbuf_save_to_callbackv (pixbuf, save_to_stream,
                                           &data, type,
                                           option_keys, option_values,
                                           error);
3090}

3092/**
* cdk_pixbuf_save_to_stream:
* @pixbuf: a `CdkPixbuf`
* @stream: a `GOutputStream` to save the pixbuf to
* @type: name of file format
* @cancellable: (allow-none): optional `GCancellable` object, `NULL` to ignore
* @error: (allow-none): return location for error, or `NULL`
* @...: list of key-value save options
*
* Saves `pixbuf` to an output stream.
*
* Supported file formats are currently "jpeg", "tiff", "png", "ico" or 
* "bmp". See `cdk_pixbuf_save_to_buffer()` for more details.
*
* The `cancellable` can be used to abort the operation from another
* thread. If the operation was cancelled, the error `G_IO_ERROR_CANCELLED`
* will be returned. Other possible errors are in the `CDK_PIXBUF_ERROR`
* and `G_IO_ERROR` domains.
*
* The stream is not closed at the end of this call.
*
* Returns: `TRUE` if the pixbuf was saved successfully, `FALSE` if an
*   error was set.
*
* Since: 2.14
*/
3118gboolean
3119cdk_pixbuf_save_to_stream (CdkPixbuf      *pixbuf,
                         GOutputStream  *stream,
                         const char     *type,
                         GCancellable   *cancellable,
                         GError        **error,
                         ...)
3125{
      gboolean res;
      gchar **keys = NULL((void*)0);
      gchar **values = NULL((void*)0);
      va_list args;

      va_start (args, error)__builtin_va_start(args, error);
      collect_save_options (args, &keys, &values);
      va_end (args)__builtin_va_end(args);

      res = cdk_pixbuf_save_to_streamv (pixbuf, stream, type,
                                        keys, values,
                                        cancellable, error);

      g_strfreev (keys);
      g_strfreev (values);

      return res;
3143}

3145typedef struct {
GOutputStream *stream;
gchar *type;
gchar **keys;
gchar **values;
3150} SaveToStreamAsyncData;

3152static void
3153save_to_stream_async_data_free (SaveToStreamAsyncData *data)
3154{
if (data->stream)
g_object_unref (data->stream);
g_strfreev (data->keys);
g_strfreev (data->values);
g_free (data->type);
g_slice_free (SaveToStreamAsyncData, data)do { if (1) g_slice_free1 (sizeof (SaveToStreamAsyncData), (data
)); else (void) ((SaveToStreamAsyncData*) 0 == (data)); } while
 (0);
3161}

3163static void
3164save_to_stream_thread (GTask                 *task,
       CdkPixbuf             *pixbuf,
       SaveToStreamAsyncData *data,
       GCancellable          *cancellable)
3168{
SaveToStreamData sync_data;
gboolean retval;
GError *error = NULL((void*)0);

sync_data.stream = data->stream;
sync_data.cancellable = cancellable;

retval = cdk_pixbuf_save_to_callbackv (pixbuf, save_to_stream,
			       &sync_data, data->type,
			       data->keys, data->values,
			       &error);

if (retval == FALSE(0)) {
g_task_return_error (task, error);
} else {
g_task_return_boolean (task, TRUE(!(0)));
}
3186}

3188/**
* cdk_pixbuf_save_to_streamv_async: (finish-func cdk_pixbuf_save_to_stream_finish)
* @pixbuf: a `CdkPixbuf`
* @stream: a `GOutputStream` to which to save the pixbuf
* @type: name of file format
* @option_keys: (array zero-terminated=1) (element-type utf8) (nullable): name of options to set
* @option_values: (array zero-terminated=1) (element-type utf8) (nullable): values for named options
* @cancellable: (allow-none): optional `GCancellable` object, `NULL` to ignore
* @callback: a `GAsyncReadyCallback` to call when the pixbuf is saved
* @user_data: the data to pass to the callback function
*
* Saves `pixbuf` to an output stream asynchronously.
*
* For more details see cdk_pixbuf_save_to_streamv(), which is the synchronous
* version of this function.
*
* When the operation is finished, `callback` will be called in the main thread.
*
* You can then call cdk_pixbuf_save_to_stream_finish() to get the result of
* the operation.
*
* Since: 2.36
**/
3211void
3212cdk_pixbuf_save_to_streamv_async (CdkPixbuf           *pixbuf,
                                GOutputStream       *stream,
                                const gchar         *type,
                                gchar              **option_keys,
                                gchar              **option_values,
                                GCancellable        *cancellable,
                                GAsyncReadyCallback  callback,
                                gpointer             user_data)
3220{
      GTask *task;
      SaveToStreamAsyncData *data;

      g_return_if_fail (CDK_IS_PIXBUF (pixbuf))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_133
 = 0; if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((pixbuf)); GType __t = ((cdk_pixbuf_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; }))))) _g_boolean_var_133
 = 1; _g_boolean_var_133; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "CDK_IS_PIXBUF (pixbuf)"
); return; } } while (0);
      g_return_if_fail (cdk_pixbuf_get_width (pixbuf) >= 0)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_134
 = 0; if (cdk_pixbuf_get_width (pixbuf) >= 0) _g_boolean_var_134
 = 1; _g_boolean_var_134; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cdk_pixbuf_get_width (pixbuf) >= 0"
); return; } } while (0);
      g_return_if_fail (cdk_pixbuf_get_height (pixbuf) >= 0)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_135
 = 0; if (cdk_pixbuf_get_height (pixbuf) >= 0) _g_boolean_var_135
 = 1; _g_boolean_var_135; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cdk_pixbuf_get_height (pixbuf) >= 0"
); return; } } while (0);
      g_return_if_fail (cdk_pixbuf_get_n_channels (pixbuf) >= 0)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_136
 = 0; if (cdk_pixbuf_get_n_channels (pixbuf) >= 0) _g_boolean_var_136
 = 1; _g_boolean_var_136; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cdk_pixbuf_get_n_channels (pixbuf) >= 0"
); return; } } while (0);
      g_return_if_fail (G_IS_OUTPUT_STREAM (stream))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_137
 = 0; if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((stream)); GType __t = ((g_output_stream_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; }))))) _g_boolean_var_137
 = 1; _g_boolean_var_137; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "G_IS_OUTPUT_STREAM (stream)"
); return; } } while (0);
      g_return_if_fail (type != NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_138
 = 0; if (type != ((void*)0)) _g_boolean_var_138 = 1; _g_boolean_var_138
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "type != NULL"); return; } } while
 (0);
      g_return_if_fail (callback != NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_139
 = 0; if (callback != ((void*)0)) _g_boolean_var_139 = 1; _g_boolean_var_139
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "callback != NULL"); return; } } while
 (0);
      g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_140
 = 0; if (!cancellable || (((__extension__ ({ GTypeInstance *
__inst = (GTypeInstance*) ((cancellable)); GType __t = ((g_cancellable_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; }))))) _g_boolean_var_140 = 1; _g_boolean_var_140; }), 1
))) { } else { g_return_if_fail_warning ("CdkPixbuf", ((const
 char*) (__func__)), "!cancellable || G_IS_CANCELLABLE (cancellable)"
); return; } } while (0);

      data = g_slice_new (SaveToStreamAsyncData)((SaveToStreamAsyncData*) g_slice_alloc ((sizeof (SaveToStreamAsyncData
) > 0 ? sizeof (SaveToStreamAsyncData) : 1)));
      data->stream = g_object_ref (stream)((__typeof__ (stream)) (g_object_ref) (stream));
      data->type = g_strdup (type)g_strdup_inline (type);
      data->keys = g_strdupv (option_keys);
      data->values = g_strdupv (option_values);

      task = g_task_new (pixbuf, cancellable, callback, user_data);
      g_task_set_source_tag (task, cdk_pixbuf_save_to_streamv_async)do { GTask *_task = (task); (g_task_set_source_tag) (_task, cdk_pixbuf_save_to_streamv_async
); if (g_task_get_name (_task) == ((void*)0)) g_task_set_static_name
 (_task, "cdk_pixbuf_save_to_streamv_async"); } while (0);
      g_task_set_task_data (task, data, (GDestroyNotify) save_to_stream_async_data_free);
      g_task_run_in_thread (task, (GTaskThreadFunc) save_to_stream_thread);
      g_object_unref (task);
3244}

3246/**
* cdk_pixbuf_save_to_stream_async: (finish-func cdk_pixbuf_save_to_stream_finish)
* @pixbuf: a `CdkPixbuf`
* @stream: a `GOutputStream` to which to save the pixbuf
* @type: name of file format
* @cancellable: (allow-none): optional `GCancellable` object, `NULL` to ignore
* @callback: a `GAsyncReadyCallback` to call when the pixbuf is saved
* @user_data: the data to pass to the callback function
* @...: list of key-value save options
*
* Saves `pixbuf` to an output stream asynchronously.
*
* For more details see cdk_pixbuf_save_to_stream(), which is the synchronous
* version of this function.
*
* When the operation is finished, `callback` will be called in the main thread.
*
* You can then call cdk_pixbuf_save_to_stream_finish() to get the result of
* the operation.
*
* Since: 2.24
**/
3268void
3269cdk_pixbuf_save_to_stream_async (CdkPixbuf           *pixbuf,
		 GOutputStream       *stream,
		 const gchar         *type,
		 GCancellable        *cancellable,
		 GAsyncReadyCallback  callback,
		 gpointer             user_data,
		 ...)
3276{
      gchar **keys = NULL((void*)0);
      gchar **values = NULL((void*)0);
      va_list args;

      g_return_if_fail (CDK_IS_PIXBUF (pixbuf))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_141
 = 0; if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((pixbuf)); GType __t = ((cdk_pixbuf_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; }))))) _g_boolean_var_141
 = 1; _g_boolean_var_141; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "CDK_IS_PIXBUF (pixbuf)"
); return; } } while (0);
      g_return_if_fail (cdk_pixbuf_get_width (pixbuf) >= 0)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_142
 = 0; if (cdk_pixbuf_get_width (pixbuf) >= 0) _g_boolean_var_142
 = 1; _g_boolean_var_142; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cdk_pixbuf_get_width (pixbuf) >= 0"
); return; } } while (0);
      g_return_if_fail (cdk_pixbuf_get_height (pixbuf) >= 0)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_143
 = 0; if (cdk_pixbuf_get_height (pixbuf) >= 0) _g_boolean_var_143
 = 1; _g_boolean_var_143; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cdk_pixbuf_get_height (pixbuf) >= 0"
); return; } } while (0);
      g_return_if_fail (cdk_pixbuf_get_n_channels (pixbuf) >= 0)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_144
 = 0; if (cdk_pixbuf_get_n_channels (pixbuf) >= 0) _g_boolean_var_144
 = 1; _g_boolean_var_144; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "cdk_pixbuf_get_n_channels (pixbuf) >= 0"
); return; } } while (0);
      g_return_if_fail (G_IS_OUTPUT_STREAM (stream))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_145
 = 0; if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((stream)); GType __t = ((g_output_stream_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; }))))) _g_boolean_var_145
 = 1; _g_boolean_var_145; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "G_IS_OUTPUT_STREAM (stream)"
); return; } } while (0);
      g_return_if_fail (type != NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_146
 = 0; if (type != ((void*)0)) _g_boolean_var_146 = 1; _g_boolean_var_146
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "type != NULL"); return; } } while
 (0);
      g_return_if_fail (callback != NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_147
 = 0; if (callback != ((void*)0)) _g_boolean_var_147 = 1; _g_boolean_var_147
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "callback != NULL"); return; } } while
 (0);
      g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable))do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_148
 = 0; if (!cancellable || (((__extension__ ({ GTypeInstance *
__inst = (GTypeInstance*) ((cancellable)); GType __t = ((g_cancellable_get_type
 ())); gboolean __r; if (!__inst) __r = (0); else if (__inst->
g_class && __inst->g_class->g_type == __t) __r =
 (!(0)); else __r = g_type_check_instance_is_a (__inst, __t);
 __r; }))))) _g_boolean_var_148 = 1; _g_boolean_var_148; }), 1
))) { } else { g_return_if_fail_warning ("CdkPixbuf", ((const
 char*) (__func__)), "!cancellable || G_IS_CANCELLABLE (cancellable)"
); return; } } while (0);

      va_start (args, user_data)__builtin_va_start(args, user_data);
      collect_save_options (args, &keys, &values);
      va_end (args)__builtin_va_end(args);

      cdk_pixbuf_save_to_streamv_async (pixbuf, stream, type,
                                        keys, values,
                                        cancellable, callback, user_data);
      g_strfreev (keys);
      g_strfreev (values);
3299}

3301/**
* cdk_pixbuf_save_to_stream_finish:
* @async_result: a `GAsyncResult`
* @error: a `GError`, or `NULL`
*
* Finishes an asynchronous pixbuf save operation started with
* cdk_pixbuf_save_to_stream_async().
*
* Returns: `TRUE` if the pixbuf was saved successfully, `FALSE` if an error was set.
*
* Since: 2.24
**/
3313gboolean
3314cdk_pixbuf_save_to_stream_finish (GAsyncResult  *async_result,
		  GError       **error)
3316{
GTask *task;

/* Can not use g_task_is_valid because our GTask has a
* source_object which is not available to us anymore.
*/
g_return_val_if_fail (G_IS_TASK (async_result), FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_149
 = 0; if ((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((async_result)); GType __t = ((g_task_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; }))))) _g_boolean_var_149
 = 1; _g_boolean_var_149; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "G_IS_TASK (async_result)"
); return ((0)); } } while (0);

task = G_TASK (async_result)((((GTask*) (void *) ((async_result)))));

g_return_val_if_fail (!error || (error && !*error), FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_150
 = 0; if (!error || (error && !*error)) _g_boolean_var_150
 = 1; _g_boolean_var_150; }), 1))) { } else { g_return_if_fail_warning
 ("CdkPixbuf", ((const char*) (__func__)), "!error || (error && !*error)"
); return ((0)); } } while (0);
g_warn_if_fail (g_task_get_source_tag (task) == cdk_pixbuf_save_to_stream_async ||do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_151
 = 0; if (g_task_get_source_tag (task) == cdk_pixbuf_save_to_stream_async
 || g_task_get_source_tag (task) == cdk_pixbuf_save_to_streamv_async
) _g_boolean_var_151 = 1; _g_boolean_var_151; }), 1)) ; else g_warn_message
 ("CdkPixbuf", "../cdk-pixbuf/cdk-pixbuf-io.c", 3328, ((const
 char*) (__func__)), "g_task_get_source_tag (task) == cdk_pixbuf_save_to_stream_async || g_task_get_source_tag (task) == cdk_pixbuf_save_to_streamv_async"
); } while (0)
	g_task_get_source_tag (task) == cdk_pixbuf_save_to_streamv_async)do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_151
 = 0; if (g_task_get_source_tag (task) == cdk_pixbuf_save_to_stream_async
 || g_task_get_source_tag (task) == cdk_pixbuf_save_to_streamv_async
) _g_boolean_var_151 = 1; _g_boolean_var_151; }), 1)) ; else g_warn_message
 ("CdkPixbuf", "../cdk-pixbuf/cdk-pixbuf-io.c", 3328, ((const
 char*) (__func__)), "g_task_get_source_tag (task) == cdk_pixbuf_save_to_stream_async || g_task_get_source_tag (task) == cdk_pixbuf_save_to_streamv_async"
); } while (0);

return g_task_propagate_boolean (task, error);
3331}

3333/**
* cdk_pixbuf_format_get_name:
* @format: a `CdkPixbufFormat`
*
* Returns the name of the format.
* 
* Returns: (transfer full) (nullable): the name of the format. 
*
* Since: 2.2
*/
3343gchar *
3344cdk_pixbuf_format_get_name (CdkPixbufFormat *format)
3345{
      g_return_val_if_fail (format != NULL, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_152
 = 0; if (format != ((void*)0)) _g_boolean_var_152 = 1; _g_boolean_var_152
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "format != NULL"); return (((void*
)0)); } } while (0);

      return g_strdup (format->name)g_strdup_inline (format->name);
3349}

3351/**
* cdk_pixbuf_format_get_description:
* @format: a `CdkPixbufFormat`
*
* Returns a description of the format.
* 
* Returns: (transfer full) (nullable): a description of the format.
*
* Since: 2.2
*/
3361gchar *
3362cdk_pixbuf_format_get_description (CdkPixbufFormat *format)
3363{
      gchar *domain;
      const gchar *description;
      g_return_val_if_fail (format != NULL, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_153
 = 0; if (format != ((void*)0)) _g_boolean_var_153 = 1; _g_boolean_var_153
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "format != NULL"); return (((void*
)0)); } } while (0);

      if (format->domain != NULL((void*)0)) 
              domain = format->domain;
      else 
              domain = GETTEXT_PACKAGE"cdk-pixbuf";
      description = g_dgettext (domain, format->description);

      return g_strdup (description)g_strdup_inline (description);
3375}

3377/**
* cdk_pixbuf_format_get_mime_types:
* @format: a `CdkPixbufFormat`
*
* Returns the mime types supported by the format.
* 
* Returns: (transfer full) (array zero-terminated=1) (nullable): an array of mime types
*
* Since: 2.2
*/
3387gchar **
3388cdk_pixbuf_format_get_mime_types (CdkPixbufFormat *format)
3389{
      g_return_val_if_fail (format != NULL, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_154
 = 0; if (format != ((void*)0)) _g_boolean_var_154 = 1; _g_boolean_var_154
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "format != NULL"); return (((void*
)0)); } } while (0);

      return g_strdupv (format->mime_types);
3393}

3395/**
* cdk_pixbuf_format_get_extensions:
* @format: a `CdkPixbufFormat`
*
* Returns the filename extensions typically used for files in the 
* given format.
* 
* Returns: (transfer full) (array zero-terminated=1) (nullable): an array of
*   filename extensions
*
* Since: 2.2
*/
3407gchar **
3408cdk_pixbuf_format_get_extensions (CdkPixbufFormat *format)
3409{
      g_return_val_if_fail (format != NULL, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_155
 = 0; if (format != ((void*)0)) _g_boolean_var_155 = 1; _g_boolean_var_155
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "format != NULL"); return (((void*
)0)); } } while (0);

      return g_strdupv (format->extensions);
3413}

3415/**
* cdk_pixbuf_format_is_writable:
* @format: a `CdkPixbufFormat`
*
* Returns whether pixbufs can be saved in the given format.
* 
* Returns: whether pixbufs can be saved in the given format.
*
* Since: 2.2
*/
3425gboolean
3426cdk_pixbuf_format_is_writable (CdkPixbufFormat *format)
3427{
      g_return_val_if_fail (format != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_156
 = 0; if (format != ((void*)0)) _g_boolean_var_156 = 1; _g_boolean_var_156
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "format != NULL"); return ((0)); }
 } while (0);

      return (format->flags & CDK_PIXBUF_FORMAT_WRITABLE) != 0;
3431}

3433/**
* cdk_pixbuf_format_is_scalable:
* @format: a `CdkPixbufFormat`
*
* Returns whether this image format is scalable.
*
* If a file is in a scalable format, it is preferable to load it at
* the desired size, rather than loading it at the default size and
* scaling the resulting pixbuf to the desired size.
* 
* Returns: whether this image format is scalable.
*
* Since: 2.6
*/
3447gboolean
3448cdk_pixbuf_format_is_scalable (CdkPixbufFormat *format)
3449{
      g_return_val_if_fail (format != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_157
 = 0; if (format != ((void*)0)) _g_boolean_var_157 = 1; _g_boolean_var_157
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "format != NULL"); return ((0)); }
 } while (0);

      return (format->flags & CDK_PIXBUF_FORMAT_SCALABLE) != 0;
3453}

3455/**
* cdk_pixbuf_format_is_disabled:
* @format: a `CdkPixbufFormat`
*
* Returns whether this image format is disabled.
*
* See cdk_pixbuf_format_set_disabled().
* 
* Returns: whether this image format is disabled.
*
* Since: 2.6
*/
3467gboolean   
3468cdk_pixbuf_format_is_disabled (CdkPixbufFormat *format)
3469{
      g_return_val_if_fail (format != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_158
 = 0; if (format != ((void*)0)) _g_boolean_var_158 = 1; _g_boolean_var_158
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "format != NULL"); return ((0)); }
 } while (0);

      return format->disabled;        
3473}

3475/**
* cdk_pixbuf_format_set_disabled:
* @format: a `CdkPixbufFormat`
* @disabled: `TRUE` to disable the format @format
*
* Disables or enables an image format.
*
* If a format is disabled, CdkPixbuf won't use the image loader for
* this format to load images.
*
* Applications can use this to avoid using image loaders with an
* inappropriate license, see cdk_pixbuf_format_get_license().
*
* Since: 2.6
*/
3490void 
3491cdk_pixbuf_format_set_disabled (CdkPixbufFormat *format,
                              gboolean         disabled)
3493{
      g_return_if_fail (format != NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_159
 = 0; if (format != ((void*)0)) _g_boolean_var_159 = 1; _g_boolean_var_159
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "format != NULL"); return; } } while
 (0);
      
      format->disabled = disabled != FALSE(0);
3497}

3499/**
* cdk_pixbuf_format_get_license:
* @format: a pixbuf format
*
* Returns information about the license of the image loader for the format.
*
* The returned string should be a shorthand for a well known license, e.g.
* "LGPL", "GPL", "QPL", "GPL/QPL", or "other" to indicate some other license.
*
* Returns: (transfer full) (nullable): a string describing the license of the pixbuf format
*
* Since: 2.6
*/
3512gchar*
3513cdk_pixbuf_format_get_license (CdkPixbufFormat *format)
3514{
      g_return_val_if_fail (format != NULL, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_160
 = 0; if (format != ((void*)0)) _g_boolean_var_160 = 1; _g_boolean_var_160
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "format != NULL"); return (((void*
)0)); } } while (0);

      return g_strdup (format->license)g_strdup_inline (format->license);
3518}

3520CdkPixbufFormat *
3521_cdk_pixbuf_get_format (CdkPixbufModule *module)
3522{
      g_return_val_if_fail (module != NULL, NULL)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_161
 = 0; if (module != ((void*)0)) _g_boolean_var_161 = 1; _g_boolean_var_161
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "module != NULL"); return (((void*
)0)); } } while (0);

      return module->info;
3526}

3528/**
* cdk_pixbuf_get_formats:
*
* Obtains the available information about the image formats supported
* by CdkPixbuf.
*
* Returns: (transfer container) (element-type CdkPixbufFormat): A list of
*   support image formats.
*
* Since: 2.2
*/
3539GSList *
3540cdk_pixbuf_get_formats (void)
3541{
      GSList *result = NULL((void*)0);
      GSList *modules;

      for (modules = get_file_formats (); modules; modules = g_slist_next (modules)((modules) ? (((GSList *)(modules))->next) : ((void*)0))) {
              CdkPixbufModule *module = (CdkPixbufModule *)modules->data;
              CdkPixbufFormat *info = _cdk_pixbuf_get_format (module);
              result = g_slist_prepend (result, info);
      }

      return result;
3552}

3554/**
* cdk_pixbuf_format_copy:
* @format: a pixbuf format
*
* Creates a copy of `format`.
*
* Returns: (transfer full) (nullable): the newly allocated copy of a `CdkPixbufFormat`. Use
*   cdk_pixbuf_format_free() to free the resources when done
*
* Since: 2.22
*/
3565CdkPixbufFormat *
3566cdk_pixbuf_format_copy (const CdkPixbufFormat *format)
3567{
      if (G_LIKELY (format != NULL)(__builtin_expect (__extension__ ({ int _g_boolean_var_162 = 0
; if (format != ((void*)0)) _g_boolean_var_162 = 1; _g_boolean_var_162
; }), 1)))
              return g_slice_dup (CdkPixbufFormat, format)(1 ? (CdkPixbufFormat*) g_slice_copy ((sizeof (CdkPixbufFormat
) > 0 ? sizeof (CdkPixbufFormat) : 1), (format)) : ((void)
 ((CdkPixbufFormat*) 0 == (format)), (CdkPixbufFormat*) 0));

      return NULL((void*)0);
3572}

3574/**
* cdk_pixbuf_format_free:
* @format: a pixbuf format
*
* Frees the resources allocated when copying a `CdkPixbufFormat`
* using cdk_pixbuf_format_copy()
*
* Since: 2.22
*/
3583void
3584cdk_pixbuf_format_free (CdkPixbufFormat *format)
3585{
      if (G_LIKELY (format != NULL)(__builtin_expect (__extension__ ({ int _g_boolean_var_163 = 0
; if (format != ((void*)0)) _g_boolean_var_163 = 1; _g_boolean_var_163
; }), 1)))
              g_slice_free (CdkPixbufFormat, format)do { if (1) g_slice_free1 (sizeof (CdkPixbufFormat), (format)
); else (void) ((CdkPixbufFormat*) 0 == (format)); } while (0
);
3588}

3590/**
* cdk_pixbuf_format_is_save_option_supported:
* @format: a pixbuf format
* @option_key: the name of an option
*
* Returns `TRUE` if the save option specified by @option_key is supported when
* saving a pixbuf using the module implementing @format.
*
* See cdk_pixbuf_save() for more information about option keys.
*
* Returns: `TRUE` if the specified option is supported
*
* Since: 2.36
*/
3604gboolean
3605cdk_pixbuf_format_is_save_option_supported (CdkPixbufFormat *format,
                                          const gchar *option_key)
3607{
      CdkPixbufModule *module;

      g_return_val_if_fail (format != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_164
 = 0; if (format != ((void*)0)) _g_boolean_var_164 = 1; _g_boolean_var_164
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "format != NULL"); return ((0)); }
 } while (0);
1
Assuming 'format' is not equal to null→
2
←
Taking true branch→
3
←
Taking true branch→
4
←
Loop condition is false.  Exiting loop→
      g_return_val_if_fail (option_key != NULL, FALSE)do { if ((__builtin_expect (__extension__ ({ int _g_boolean_var_165
 = 0; if (option_key != ((void*)0)) _g_boolean_var_165 = 1; _g_boolean_var_165
; }), 1))) { } else { g_return_if_fail_warning ("CdkPixbuf", (
(const char*) (__func__)), "option_key != NULL"); return ((0)
); } } while (0);
5
←
Assuming 'option_key' is not equal to null→
6
←
Taking true branch→
7
←
Taking true branch→
8
←
Loop condition is false.  Exiting loop→

      module = _cdk_pixbuf_get_named_module (format->name, NULL((void*)0));
9
←
Calling '_cdk_pixbuf_get_named_module'→
      if (!module)
              return FALSE(0);

      if (!_cdk_pixbuf_load_module (module, NULL((void*)0)))
              return FALSE(0);

      if (!module->is_save_option_supported)
              return FALSE(0);

      return (* module->is_save_option_supported) (option_key);
3624}

3626G_DEFINE_BOXED_TYPE (CdkPixbufFormat, cdk_pixbuf_format,static GType cdk_pixbuf_format_get_type_once (void); GType cdk_pixbuf_format_get_type
 (void) { static GType static_g_define_type_id = 0; if ((__extension__
 ({ _Static_assert (sizeof *(&static_g_define_type_id) ==
 sizeof (gpointer), "Expression evaluates to false"); (void) (
? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
 ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
 = cdk_pixbuf_format_get_type_once (); (__extension__ ({ _Static_assert
 (sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id
) = (g_define_type_id)) : (void) 0; g_once_init_leave_pointer
 ((&static_g_define_type_id), (gpointer) (guintptr) (g_define_type_id
)); })) ; } return static_g_define_type_id; } __attribute__ (
(__noinline__)) static GType cdk_pixbuf_format_get_type_once (
void) { GType (* _g_register_boxed) (const gchar *, union { CdkPixbufFormat
 * (*do_copy_type) (CdkPixbufFormat *); CdkPixbufFormat * (*do_const_copy_type
) (const CdkPixbufFormat *); GBoxedCopyFunc do_copy_boxed; } __attribute__
((__transparent_union__)), union { void (* do_free_type) (CdkPixbufFormat
 *); GBoxedFreeFunc do_free_boxed; } __attribute__((__transparent_union__
)) ) = g_boxed_type_register_static; GType g_define_type_id =
 _g_register_boxed (g_intern_static_string ("CdkPixbufFormat"
), cdk_pixbuf_format_copy, cdk_pixbuf_format_free); { {{};} }
 return g_define_type_id; }
     cdk_pixbuf_format_copy,static GType cdk_pixbuf_format_get_type_once (void); GType cdk_pixbuf_format_get_type
 (void) { static GType static_g_define_type_id = 0; if ((__extension__
 ({ _Static_assert (sizeof *(&static_g_define_type_id) ==
 sizeof (gpointer), "Expression evaluates to false"); (void) (
? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
 ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
 = cdk_pixbuf_format_get_type_once (); (__extension__ ({ _Static_assert
 (sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id
) = (g_define_type_id)) : (void) 0; g_once_init_leave_pointer
 ((&static_g_define_type_id), (gpointer) (guintptr) (g_define_type_id
)); })) ; } return static_g_define_type_id; } __attribute__ (
(__noinline__)) static GType cdk_pixbuf_format_get_type_once (
void) { GType (* _g_register_boxed) (const gchar *, union { CdkPixbufFormat
 * (*do_copy_type) (CdkPixbufFormat *); CdkPixbufFormat * (*do_const_copy_type
) (const CdkPixbufFormat *); GBoxedCopyFunc do_copy_boxed; } __attribute__
((__transparent_union__)), union { void (* do_free_type) (CdkPixbufFormat
 *); GBoxedFreeFunc do_free_boxed; } __attribute__((__transparent_union__
)) ) = g_boxed_type_register_static; GType g_define_type_id =
 _g_register_boxed (g_intern_static_string ("CdkPixbufFormat"
), cdk_pixbuf_format_copy, cdk_pixbuf_format_free); { {{};} }
 return g_define_type_id; }
     cdk_pixbuf_format_free)static GType cdk_pixbuf_format_get_type_once (void); GType cdk_pixbuf_format_get_type
 (void) { static GType static_g_define_type_id = 0; if ((__extension__
 ({ _Static_assert (sizeof *(&static_g_define_type_id) ==
 sizeof (gpointer), "Expression evaluates to false"); (void) (
? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
 ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
 = cdk_pixbuf_format_get_type_once (); (__extension__ ({ _Static_assert
 (sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id
) = (g_define_type_id)) : (void) 0; g_once_init_leave_pointer
 ((&static_g_define_type_id), (gpointer) (guintptr) (g_define_type_id
)); })) ; } return static_g_define_type_id; } __attribute__ (
(__noinline__)) static GType cdk_pixbuf_format_get_type_once (
void) { GType (* _g_register_boxed) (const gchar *, union { CdkPixbufFormat
 * (*do_copy_type) (CdkPixbufFormat *); CdkPixbufFormat * (*do_const_copy_type
) (const CdkPixbufFormat *); GBoxedCopyFunc do_copy_boxed; } __attribute__
((__transparent_union__)), union { void (* do_free_type) (CdkPixbufFormat
 *); GBoxedFreeFunc do_free_boxed; } __attribute__((__transparent_union__
)) ) = g_boxed_type_register_static; GType g_define_type_id =
 _g_register_boxed (g_intern_static_string ("CdkPixbufFormat"
), cdk_pixbuf_format_copy, cdk_pixbuf_format_free); { {{};} }
 return g_define_type_id; }