libextractor

tiff_extractor.c (5958B)

---

 /*
      This file is part of libextractor.
      Copyright (C) 2012 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/tiff_extractor.c
  * @brief plugin to support TIFF files
  * @author Christian Grothoff
  */
 #include "platform.h"
 #include "extractor.h"
 #include <tiffio.h>
 
 
 /**
  * Error handler for libtiff.  Does nothing.
  *
  * @param module where did the error arise?
  * @param fmt format string
  * @param ap arguments for fmt
  */
 static void
 error_cb (const char *module,
           const char *fmt,
           va_list ap)
 {
   /* do nothing */
 }
 
 
 /**
  * Callback invoked by TIFF lib for reading.
  *
  * @param ctx the 'struct EXTRACTOR_ExtractContext'
  * @param data where to write data
  * @param size number of bytes to read
  * @return number of bytes read
  */
 static tsize_t
 read_cb (thandle_t ctx,
          tdata_t data,
          tsize_t size)
 {
   struct EXTRACTOR_ExtractContext *ec = ctx;
   void *ptr;
   ssize_t ret;
 
   ret = ec->read (ec->cls, &ptr, size);
   if (ret > 0)
     memcpy (data, ptr, ret);
   return ret;
 }
 
 
 /**
  * Callback invoked by TIFF lib for writing.  Always fails.
  *
  * @param ctx the 'struct EXTRACTOR_ExtractContext'
  * @param data where to write data
  * @param size number of bytes to read
  * @return -1 (error)
  */
 static tsize_t
 write_cb (thandle_t ctx,
           tdata_t data,
           tsize_t size)
 {
   return -1;
 }
 
 
 /**
  * Callback invoked by TIFF lib for seeking.
  *
  * @param ctx the 'struct EXTRACTOR_ExtractContext'
  * @param offset target offset
  * @param whence target is relative to where
  * @return new offset
  */
 static toff_t
 seek_cb (thandle_t ctx,
          toff_t offset,
          int whence)
 {
   struct EXTRACTOR_ExtractContext *ec = ctx;
 
   return ec->seek (ec->cls, offset, whence);
 }
 
 
 /**
  * Callback invoked by TIFF lib for getting the file size.
  *
  * @param ctx the 'struct EXTRACTOR_ExtractContext'
  * @return file size
  */
 static toff_t
 size_cb (thandle_t ctx)
 {
   struct EXTRACTOR_ExtractContext *ec = ctx;
 
   return ec->get_size (ec->cls);
 }
 
 
 /**
  * Callback invoked by TIFF lib for closing the file. Does nothing.
  *
  * @param ctx the 'struct EXTRACTOR_ExtractContext'
  */
 static int
 close_cb (thandle_t ctx)
 {
   return 0; /* success */
 }
 
 
 /**
  * A mapping from TIFF Tag to extractor types.
  */
 struct Matches
 {
   /**
    * TIFF Tag.
    */
   ttag_t tag;
 
   /**
    * Corresponding LE type.
    */
   enum EXTRACTOR_MetaType type;
 };
 
 
 /**
  * Mapping of TIFF tags to LE types.
  * NULL-terminated.
  */
 static struct Matches tmap[] = {
   { TIFFTAG_ARTIST, EXTRACTOR_METATYPE_ARTIST },
   { TIFFTAG_COPYRIGHT, EXTRACTOR_METATYPE_COPYRIGHT },
   { TIFFTAG_DATETIME, EXTRACTOR_METATYPE_CREATION_DATE },
   { TIFFTAG_DOCUMENTNAME, EXTRACTOR_METATYPE_TITLE },
   { TIFFTAG_HOSTCOMPUTER, EXTRACTOR_METATYPE_BUILDHOST },
   { TIFFTAG_IMAGEDESCRIPTION, EXTRACTOR_METATYPE_DESCRIPTION },
   { TIFFTAG_MAKE, EXTRACTOR_METATYPE_CAMERA_MAKE },
   { TIFFTAG_MODEL, EXTRACTOR_METATYPE_CAMERA_MODEL },
   { TIFFTAG_PAGENAME, EXTRACTOR_METATYPE_PAGE_RANGE },
   { TIFFTAG_SOFTWARE, EXTRACTOR_METATYPE_CREATED_BY_SOFTWARE },
   { TIFFTAG_TARGETPRINTER, EXTRACTOR_METATYPE_TARGET_ARCHITECTURE },
   { 0, 0 }
 };
 
 
 /**
  * Main entry method for the 'image/tiff' extraction plugin.
  *
  * @param ec extraction context provided to the plugin
  */
 void
 EXTRACTOR_tiff_extract_method (struct EXTRACTOR_ExtractContext *ec)
 {
   TIFF *tiff;
   unsigned int i;
   char *meta;
   char format[128];
   uint32_t width;
   uint32_t height;
 
   TIFFSetErrorHandler (&error_cb);
   TIFFSetWarningHandler (&error_cb);
   tiff = TIFFClientOpen ("<no filename>",
                          "rm", /* read-only, no mmap */
                          ec,
                          &read_cb,
                          &write_cb,
                          &seek_cb,
                          &close_cb,
                          &size_cb,
                          NULL, NULL);
   if (NULL == tiff)
     return;
   for (i = 0; 0 != tmap[i].tag; i++)
     if ( (1 ==
           TIFFGetField (tiff, tmap[i].tag, &meta)) &&
          (0 !=
           ec->proc (ec->cls,
                     "tiff",
                     tmap[i].type,
                     EXTRACTOR_METAFORMAT_UTF8,
                     "text/plain",
                     meta,
                     strlen (meta) + 1)) )
       goto CLEANUP;
   if ( (1 ==
         TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width)) &&
        (1 ==
         TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height)) )
   {
     snprintf (format,
               sizeof (format),
               "%ux%u",
               (unsigned int) width,
               (unsigned int) height);
     if (0 !=
         ec->proc (ec->cls,
                   "tiff",
                   EXTRACTOR_METATYPE_IMAGE_DIMENSIONS,
                   EXTRACTOR_METAFORMAT_UTF8,
                   "text/plain",
                   format,
                   strlen (format) + 1))
       goto CLEANUP;
     if (0 !=
         ec->proc (ec->cls,
                   "tiff",
                   EXTRACTOR_METATYPE_MIMETYPE,
                   EXTRACTOR_METAFORMAT_UTF8,
                   "text/plain",
                   "image/tiff",
                   strlen ("image/tiff") + 1))
       goto CLEANUP;
   }
 
 CLEANUP:
   TIFFClose (tiff);
 }
 
 
 /* end of tiff_extractor.c */