libextractor

thumbnailgtk_extractor.c (10229B)

---

 /*
      This file is part of libextractor.
      Copyright (C) 2005, 2009, 2012 Vidyut Samanta and Christian Grothoff
 
      libextractor is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
      by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      libextractor 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
      General Public License for more details.
 
      You should have received a copy of the GNU General Public License
      along with libextractor; see the file COPYING.  If not, write to the
      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      Boston, MA 02110-1301, USA.
  */
 /**
  * @file plugins/thumbnailgtk_extractor.c
  * @author Christian Grothoff
  * @brief this extractor produces a binary (!) encoded
  * thumbnail of images (using gdk pixbuf).  The bottom
  * of the file includes a decoder method that can be used
  * to reproduce the 128x128 PNG thumbnails.  We use
  * libmagic to test if the input data is actually an
  * image before trying to give it to gdk-pixbuf.
  */
 #include "platform.h"
 #include "extractor.h"
 #include <magic.h>
 #include <glib.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
 
 /**
  * Target size for the thumbnails (width and height).
  */
 #define THUMBSIZE 128
 
 /**
  * Maximum image size supported (to avoid unreasonable
  * allocations)
  */
 #define MAX_IMAGE_SIZE (32 * 1024 * 1024)
 
 /**
  * Largest decoded image we are willing to let gdk-pixbuf allocate,
  * in pixels.  At four bytes per pixel this caps the decode at 128 MB.
  * Anything past it gets its dimensions reported but no thumbnail.
  */
 #define MAX_IMAGE_PIXELS (32 * 1024 * 1024)
 
 
 /**
  * Global handle to MAGIC data.
  */
 static magic_t magic;
 
 
 /**
  * What #handle_size_prepared saw in the image header, so that the
  * dimensions we report are the ones the file claims and not the ones
  * we asked the loader to decode at.
  */
 struct SizeInfo
 {
   /**
    * Width from the image header, in pixels.
    */
   gint width;
 
   /**
    * Height from the image header, in pixels.
    */
   gint height;
 
   /**
    * Set once the header announces more than #MAX_IMAGE_PIXELS pixels.
    * The caller stops feeding the loader when it sees this, which is
    * what actually prevents the allocation.
    */
   int too_big;
 };
 
 
 /**
  * Called by the loader once it has parsed the image header and knows
  * how big the image claims to be, but before it decodes any of it.
  *
  * #MAX_IMAGE_SIZE bounds the *compressed* file, which says nothing at
  * all about the decoded size: GIF stores its dimensions in 16 bits, so
  * a four-kilobyte file can legally announce 65535x65535 and cost
  * 65535 * 65535 * 4 bytes -- about 17 GB -- to decode.
  *
  * Note that #gdk_pixbuf_loader_set_size does NOT help here.  It is
  * documented as scaling the image while loading, but the GIF loader
  * decodes at full size and calls #gdk_pixbuf_scale_simple itself
  * afterwards, so the peak allocation is unchanged -- measured at 16 GB
  * for the reproducer either way.  The only thing that keeps the memory
  * from being allocated is to stop handing the loader data, which is
  * why this merely raises a flag and the feeding loop acts on it.
  *
  * @param loader the loader parsing the image
  * @param width width the image header claims
  * @param height height the image header claims
  * @param cls our `struct SizeInfo *'
  */
 static void
 handle_size_prepared (GdkPixbufLoader *loader,
                       gint width,
                       gint height,
                       gpointer cls)
 {
   struct SizeInfo *si = cls;
 
   (void) loader;
   si->width = width;
   si->height = height;
   if ( (0 >= width) ||
        (0 >= height) ||
        (((gint64) width) * ((gint64) height) > MAX_IMAGE_PIXELS) )
     si->too_big = 1;
 }
 
 
 /**
  * Main method for the gtk-thumbnailer plugin.
  *
  * @param ec extraction context
  */
 void
 EXTRACTOR_thumbnailgtk_extract_method (struct EXTRACTOR_ExtractContext *ec);
 
 void
 EXTRACTOR_thumbnailgtk_extract_method (struct EXTRACTOR_ExtractContext *ec)
 {
   GdkPixbufLoader *loader;
   struct SizeInfo si;
   GdkPixbuf *in;
   GdkPixbuf *out;
   size_t length;
   char *thumb;
   unsigned long width;
   unsigned long height;
   char format[64];
   void *data;
   uint64_t size;
   size_t off;
   ssize_t iret;
   void *buf;
   const char *mime;
 
   if (-1 == (iret = ec->read (ec->cls,
                               &data,
                               16 * 1024)))
     return;
   if (NULL == (mime = magic_buffer (magic, data, iret)))
     return;
   if (0 != strncmp (mime,
                     "image/",
                     strlen ("image/")))
     return; /* not an image */
 
   /* read entire image into memory */
   size = ec->get_size (ec->cls);
   if (UINT64_MAX == size)
     size = MAX_IMAGE_SIZE; /* unknown size, cap at max */
   if (size > MAX_IMAGE_SIZE)
     return; /* FAR too big to be an image */
   if (NULL == (buf = malloc (size)))
     return; /* too big to fit into memory on this system */
 
   /* start with data already read */
   memcpy (buf, data, iret);
   off = iret;
   while (off < size)
   {
     iret = ec->read (ec->cls, &data, size - off);
     if (iret <= 0)
     {
       /* io error */
       free (buf);
       return;
     }
     memcpy (buf + off, data, iret);
     off += iret;
   }
 
   loader = gdk_pixbuf_loader_new ();
   si.width = 0;
   si.height = 0;
   si.too_big = 0;
   g_signal_connect (loader,
                     "size-prepared",
                     G_CALLBACK (&handle_size_prepared),
                     &si);
   /* Feed the loader in chunks rather than in one call, so that
      #handle_size_prepared -- which fires as soon as the header has been
      parsed -- can stop us before the image body is decoded.  A single
      write of the whole buffer would decode everything before returning
      and the flag would come too late to be of any use. */
   off = 0;
   while (off < size)
   {
     size_t chunk = size - off;
 
     if (chunk > 4096)
       chunk = 4096;
     if (! gdk_pixbuf_loader_write (loader,
                                    ((const guchar *) buf) + off,
                                    chunk,
                                    NULL))
       break;
     if (si.too_big)
       break;
     off += chunk;
   }
   free (buf);
   gdk_pixbuf_loader_close (loader,
                            NULL);
   if (si.too_big)
   {
     /* Report what the header claimed, but do not decode it. */
     if (0 < si.width)
     {
       snprintf (format,
                 sizeof (format),
                 "%ux%u",
                 (unsigned int) si.width,
                 (unsigned int) si.height);
       (void) ec->proc (ec->cls,
                        "thumbnailgtk",
                        EXTRACTOR_METATYPE_IMAGE_DIMENSIONS,
                        EXTRACTOR_METAFORMAT_UTF8,
                        "text/plain",
                        format,
                        strlen (format) + 1);
     }
     g_object_unref (loader);
     return;
   }
   in = gdk_pixbuf_loader_get_pixbuf (loader);
   if (NULL == in)
   {
     g_object_unref (loader);
     return;
   }
   g_object_ref (in);
   g_object_unref (loader);
   /* The pixbuf may have been decoded smaller than the file asked for
      (see #handle_size_prepared), so report what the header said. */
   height = (0 < si.height) ? (unsigned long) si.height
            : (unsigned long) gdk_pixbuf_get_height (in);
   width = (0 < si.width) ? (unsigned long) si.width
           : (unsigned long) gdk_pixbuf_get_width (in);
   snprintf (format,
             sizeof (format),
             "%ux%u",
             (unsigned int) width,
             (unsigned int) height);
   if (0 != ec->proc (ec->cls,
                      "thumbnailgtk",
                      EXTRACTOR_METATYPE_IMAGE_DIMENSIONS,
                      EXTRACTOR_METAFORMAT_UTF8,
                      "text/plain",
                      format,
                      strlen (format) + 1))
   {
     g_object_unref (in);
     return;
   }
   if ((height <= THUMBSIZE) && (width <= THUMBSIZE))
   {
     g_object_unref (in);
     return;
   }
   if (height > THUMBSIZE)
   {
     width = width * THUMBSIZE / height;
     height = THUMBSIZE;
   }
   if (width > THUMBSIZE)
   {
     height = height * THUMBSIZE / width;
     width = THUMBSIZE;
   }
   if ( (0 == height) || (0 == width) )
   {
     g_object_unref (in);
     return;
   }
   out = gdk_pixbuf_scale_simple (in, width, height,
                                  GDK_INTERP_BILINEAR);
   g_object_unref (in);
   thumb = NULL;
   length = 0;
   if (NULL == out)
     return;
   if (! gdk_pixbuf_save_to_buffer (out, &thumb,
                                    &length,
                                    "png", NULL,
                                    "compression", "9",
                                    NULL))
   {
     g_object_unref (out);
     return;
   }
   g_object_unref (out);
   if (NULL == thumb)
     return;
   ec->proc (ec->cls,
             "thumbnailgtk",
             EXTRACTOR_METATYPE_THUMBNAIL,
             EXTRACTOR_METAFORMAT_BINARY,
             "image/png",
             thumb, length);
   free (thumb);
 }
 
 
 /**
  * This plugin sometimes is installed under the alias 'thumbnail'.
  * So we need to provide a second entry method.
  *
  * @param ec extraction context
  */
 void
 EXTRACTOR_thumbnail_extract_method (struct EXTRACTOR_ExtractContext *ec);
 
 void
 EXTRACTOR_thumbnail_extract_method (struct EXTRACTOR_ExtractContext *ec)
 {
   EXTRACTOR_thumbnailgtk_extract_method (ec);
 }
 
 
 /**
  * Initialize glib and load magic file.
  */
 void __attribute__ ((constructor))
 thumbnailgtk_gobject_init (void);
 
 void __attribute__ ((constructor))
 thumbnailgtk_gobject_init ()
 {
 #if ! GLIB_CHECK_VERSION (2, 35, 0)
   g_type_init ();
 #endif
   magic = magic_open (MAGIC_MIME_TYPE);
   if (0 != magic_load (magic, NULL))
   {
     /* FIXME: how to deal with errors? */
   }
 }
 
 
 /**
  * Destructor for the library, cleans up.
  */
 void __attribute__ ((destructor))
 thumbnailgtk_ltdl_fini (void);
 
 void __attribute__ ((destructor))
 thumbnailgtk_ltdl_fini ()
 {
   if (NULL != magic)
   {
     magic_close (magic);
     magic = NULL;
   }
 }
 
 
 /* end of thumbnailgtk_extractor.c */