image_libgif.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <iostream>
#include <string>

extern "C"
{
#include <gif_lib.h>
}

#include <archon/util/mutex.H>
#include <archon/util/text.H>
#include <archon/util/random.H>
#include <archon/util/image.H>

using namespace std;

namespace Archon
{
  namespace Utilities
  {

OUCH OUCH OUCH It seems libungif is not thread-safe after all due to its global error code storage.

    struct FormatLibgif: Image::Format
    {
      string getSpecifier() const
      {
        return "gif";
      }

      bool checkSignature(Ref<Stream::Reader> r) const
      {
        LoadContext c(r, 0, 0); // No logging since we are only probing.
        LoadWrapper w;
        w.g = DGifOpen(&c, readCallback);
        return w.g;
      }

      bool checkSuffix(string s) const
      {
        return s == "gif";
      }

      Image load(Ref<Stream::Reader> reader, Image::ProgressTracker *tracker,
                 Logger *logger) const
        throw(Image::InvalidFormatException,
              IOException, UnexpectedException)
      {
        LoadContext c(r, tracker, logger);
        LoadWrapper w;
        w.g = DGifOpen(&c, readCallback);
        if(!w.g) error(&context);

      if(DGifSlurp(w.g) != GIF_OK) loadError(&context);
      if(w.g->ImageCount<1)
      {
        if(logger) logger->log("No images in GIF file");
        ARCHON_THROW1(Image::FormatException, "");
      }

      SavedImage *image = w.g->SavedImages;

      if(image->ImageDesc.Left + image->ImageDesc.Width > w.g->SWidth ||
         image->ImageDesc.Top + image->ImageDesc.Height > w.g->SHeight)
      {
        if(logger) logger->log("Image does not fit on canvas");
        ARCHON_THROW1(Image::FormatException, "");
      }

      ColorMapObject *palette = image->ImageDesc.ColorMap;
      if(!palette) palette = w.g->SColorMap;
      if(!palette)
      {
        if(logger) logger->log("No palette in GIF file");
        ARCHON_THROW1(Image::FormatException, "");
      }
      if(w.g->SBackGroundColor >= palette->ColorCount)
      {
        if(logger) logger->log("Background color is not in palette");
        ARCHON_THROW1(Image::FormatException, "");
      }

      /*
       * Graphic Control Extension
       *
       * Byte index 0:
       *  Bit 1:   Enable transparency
       *  Bit 2:   User Input Flag (What is this?)
       *  Bit 3-5: Disposal Method (What to do about this frame when
       *           the next frame is to be displayed)
       *   0 -> no disposal specified
       *   1 -> do not dispose (background for next frame)
       *   2 -> restore to background color
       *   3 -> restore to previous (with Disposal Method 0/1)
       * Byte index 1-2:
       *  Animation delay
       * Byte index 3:
       *  Index of transparent color
       *
       * \sa http://www.webreference.com/content/studio/disposal.html
       * \sa The GIFtrans source code
       */
      // Check for transparency and comment
      int transparentIndex = -1;
      for(int i=0; i<image->ExtensionBlockCount; ++i)
      {
        ExtensionBlock *ext = image->ExtensionBlocks + i;
        int n = ext->ByteCount;
        switch(ext->Function)
        {
        case COMMENT_EXT_FUNC_CODE:
          {
            int m=0;
            while(m<n && ext->Bytes[m]) ++m;
            if(m && !comment.empty()) comment += "\n";
            comment += string(ext->Bytes, m);
          }
          break;
        case GRAPHICS_EXT_FUNC_CODE:
          {
            if(n>=4 && ext->Bytes[0]&1)
              transparentIndex = static_cast<unsigned char>(ext->Bytes[3]);
          }
          break;
        }
      }
      bool transparent = transparentIndex >= 0;
      //cerr << "Transparency: " << (!transparent ? string("none") : Text::toString(transparentIndex)) << "\n";

      width            = w.g->SWidth;
      height           = w.g->SHeight;
      bitsPerComponent = 8;
      components       = transparent ? components_rgba : components_rgb;
      charsPerPixel    = (bitsPerComponent*components+7)/8;
      charsPerRow      = charsPerPixel*width;

      DataHolder dataHolder(new unsigned char[charsPerRow*height]);

      // Fill canvas with background color
      {
        GifColorType *color = palette->Colors + w.g->SBackGroundColor;
        unsigned char alpha = static_cast<unsigned char>
          (w.g->SBackGroundColor == transparentIndex ? 0 : 255);

        unsigned char *p = dataHolder.ptr;
        for(unsigned x=0; x<width; ++x)
        {
          *p++ = static_cast<unsigned char>(color->Red);
          *p++ = static_cast<unsigned char>(color->Green);
          *p++ = static_cast<unsigned char>(color->Blue);
          if(transparent) *p++ = alpha;
        }
        for(unsigned y=1; y<height; ++y) memcpy(dataHolder.ptr+y*charsPerRow, dataHolder.ptr, charsPerRow);
      }

      // Paste first image onto canvas
      char *src = image->RasterBits;
      unsigned char *dst = dataHolder.ptr + ((height-1-image->ImageDesc.Top)*width + image->ImageDesc.Left)*charsPerPixel;
      if(image->ImageDesc.Interlace)
      {
        int offset[] = { 0, 4, 2, 1 };
        int step[]   = { 8, 8, 4, 2 };
        for(unsigned i=0; i<4; ++i) for(int y=offset[i]; y<image->ImageDesc.Height; y+=step[i])
        {
          unsigned char *d = dst - charsPerRow*y;
          for(int x=0; x<image->ImageDesc.Width; ++x)
          {
            if(static_cast<unsigned char>(*src) >= palette->ColorCount)
            {
              if(logger) logger->log("Pixel color is not in palette");
              ARCHON_THROW1(Image::FormatException, "");
            }
            int s = static_cast<unsigned char>(*src);
            GifColorType *color = palette->Colors + s;
            *d++ = static_cast<unsigned char>(color->Red);
            *d++ = static_cast<unsigned char>(color->Green);
            *d++ = static_cast<unsigned char>(color->Blue);
            if(transparent) *d++ = static_cast<unsigned char>
                              (s == transparentIndex ? 0 : 255);
            ++src;
          }
        }
      }
      else
      {
        for(int y=0; y<image->ImageDesc.Height; ++y)
        {
          unsigned char *d = dst;
          for(int x=0; x<image->ImageDesc.Width; ++x)
          {
            if(static_cast<unsigned char>(*src) >= palette->ColorCount)
            {
              if(logger) logger->log("Pixel color is not in palette");
              ARCHON_THROW1(Image::FormatException, "");
            }
            int s = static_cast<unsigned char>(*src);
            GifColorType *color = palette->Colors + s;
            *d++ = static_cast<unsigned char>(color->Red);
            *d++ = static_cast<unsigned char>(color->Green);
            *d++ = static_cast<unsigned char>(color->Blue);
            if(transparent) *d++ = static_cast<unsigned char>
                              (s == transparentIndex ? 0 : 255);
            ++src;
          }
          dst -= charsPerRow;
        }
      }

      data = dataHolder.ptr;
      dataHolder.ptr = 0;
      }

    private:

      struct Context
      {
        Image::ProgressTracker *tracker;
        Logger *logger;       // For warnings
        int errorType;        // 0 for none, 1 for ThreadTerminatedException,
                              // 2 for IOException, 3 for UnexpectedException
                              // from the stream, 4 for libpng initiated
                              // error or invalid format detected.
        string errorMessage;  // For fatal errors
        string errorLocation; // Source file location from exception
        Context(Image::ProgressTracker *tracker, Logger *logger):
          tracker(tracker), logger(logger), errorType(0)  {}
      };

      struct LoadContext: Context
      {
        Ref<Stream::Reader> reader;
        LoadContext(Ref<Stream::Reader> reader, Image::ProgressTracker *tracker,
                    Logger *logger): Context(tracker, logger), reader(reader) {}
      };

      struct SaveContext: Context
      {
        Ref<Stream::Writer> writer;
        SaveContext(Ref<Stream::Writer> writer, Image::ProgressTracker *tracker,
                    Logger *logger): Context(tracker, logger), writer(writer) {}
      };

      struct LoadWrapper
      {
        GifFileType *g;
        LoadWrapper(): g(0) {}
        ~LoadWrapper()
        {
          if(!g) return;
          LoadContext *context = static_cast<LoadContext *>(g->UserData);
          if(DGifCloseFile(g) != GIF_OK) loadError(context);
        }
      };

      static int readCallback(GifFileType *g, GifByteType *buffer, int size) throw()
      {
        LoadContext *c = static_cast<LoadContext *>(g->UserData);
        try
        {
          return c->reader->readAll(reinterpret_cast<char *>(buffer), size);
        }
        catch(ThreadTerminatedException &e)
        {
          c->errorType     = 1;
          c->errorLocation = e.getLocation();
        }
        catch(IOException &e)
        {
          c->errorType     = 2;
          c->errorLocation = e.getLocation();
          c->errorMessage  = e.getMessage();
        }
        catch(UnexpectedException &e)
        {
          c->errorType     = 3;
          c->errorLocation = e.getLocation();
          c->errorMessage  = e.getMessage();
        }

        return -1;
      }







      const char *gifErrorMessage(int i)
      {
        switch(i)
        {
        case E_GIF_ERR_OPEN_FAILED:
          return "Failed to open given file";
        case E_GIF_ERR_WRITE_FAILED:
          return "Failed to Write to given file";
        case E_GIF_ERR_HAS_SCRN_DSCR:
          return "Screen Descriptor already been set";
        case E_GIF_ERR_HAS_IMAG_DSCR:
          return "Image Descriptor is still active";
        case E_GIF_ERR_NO_COLOR_MAP:
          return "Neither Global Nor Local color map";
        case E_GIF_ERR_DATA_TOO_BIG:
          return "#Pixels bigger than Width * Height";
        case E_GIF_ERR_NOT_ENOUGH_MEM:
          return "Fail to allocate required memory";
        case E_GIF_ERR_DISK_IS_FULL:
          return "Write failed (disk full?)";
        case E_GIF_ERR_CLOSE_FAILED:
          return "Failed to close given file";
        case E_GIF_ERR_NOT_WRITEABLE:
          return "Given file was not opened for write";
        case D_GIF_ERR_OPEN_FAILED:
          return "Failed to open given file";
        case D_GIF_ERR_READ_FAILED:
          return "Failed to Read from given file";
        case D_GIF_ERR_NOT_GIF_FILE:
          return "Given file is NOT GIF file";
        case D_GIF_ERR_NO_SCRN_DSCR:
          return "No Screen Descriptor detected";
        case D_GIF_ERR_NO_IMAG_DSCR:
          return "No Image Descriptor detected";
        case D_GIF_ERR_NO_COLOR_MAP:
          return "Neither Global Nor Local color map";
        case D_GIF_ERR_WRONG_RECORD:
          return "Wrong record type detected";
        case D_GIF_ERR_DATA_TOO_BIG:
          return "#Pixels bigger than Width * Height";
        case D_GIF_ERR_NOT_ENOUGH_MEM:
          return "Fail to allocate required memory";
        case D_GIF_ERR_CLOSE_FAILED:
          return "Failed to close given file";
        case D_GIF_ERR_NOT_READABLE:
          return "Given file was not opened for read";
        case D_GIF_ERR_IMAGE_DEFECT:
          return "Image is defective, decoding aborted";
        case D_GIF_ERR_EOF_TOO_SOON:
          return "Image EOF detected, before image complete";
        default:
          ARCHON_THROW1(Image::InternalException, "Unexpected GIF error");
        }
      }

      void loadError(LoadContext *context)
      {
        if(context->terminated) ARCHON_THROW(ThreadTerminatedException);
        if(context->logger) context->logger->log(gifErrorMessage(GifLastError()));
        ARCHON_THROW1(Image::FormatException, "");
      }


    }

    void Image::loadGif(Ref<Stream::Reader> reader, Logger *logger,
                        LoadTracker *loadTracker)
    {
    }

    void Image::saveGif(Ref<Stream::Writer> writer, Logger *logger) const
    {
      ARCHON_THROW1(InternalException, "Save GIF is not yet supported");
    }
  }
}

---