libbase/GnashImageGif.cpp

   1 // GnashImageGif.cpp: gif_lib wrapper for Gnash.
   2 //
   3 //   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010,
   4 //   2011 Free Software Foundation, Inc
   5 //
   6 // This program is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 3 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19 //
  20
  21 #include "GnashImageGif.h"
  22
  23 #include <sstream>
  24 #include <algorithm>
  25 #include <boost/scoped_array.hpp>
  26
  27 extern "C" {
  28 #include <gif_lib.h>
  29 }
  30
  31 #include "GnashImage.h"
  32 #include "utility.h"
  33 #include "log.h"
  34 #include "GnashException.h"
  35 #include "IOChannel.h"
  36
  37 namespace gnash {
  38 namespace image {
  39
  40 namespace {
  41
  42 int
  43 readData(GifFileType* ft, GifByteType* data, int length)
  44 {
  45     // Do not read until opened.
  46     assert(ft);
  47     IOChannel* in = reinterpret_cast<IOChannel*>(ft->UserData);
  48     return in->read(reinterpret_cast<char*>(data), length);
  49 }
  50
  51 class GifInput : public Input
  52 {
  53
  54 public:
  55
  56     /// Construct a GifInput object to read from an IOChannel.
  57     //
  58     /// @param in   The stream to read GIF data from. Ownership is shared
  59     ///             between caller and GifInput, so it is freed
  60     ///             automatically when the last owner is destroyed.
  61     GifInput(boost::shared_ptr<IOChannel> in);
  62
  63     ~GifInput();
  64
  65     /// Begin processing the image data.
  66     void read();
  67
  68     /// Get the image's height in pixels.
  69     //
  70     /// @return     The height of the image in pixels.
  71     size_t getHeight() const;
  72
  73     /// Get the image's width in pixels.
  74     //
  75     /// @return     The width of the image in pixels.
  76     size_t getWidth() const;
  77
  78     /// Get number of components (channels)
  79     //
  80     /// @return     The number of components, e.g. 3 for RGB
  81     size_t getComponents() const { return 3; }
  82
  83     /// Read a scanline's worth of image data into the given buffer.
  84     //
  85     /// The amount of data read is getWidth() * getComponents().
  86     ///
  87     /// @param rgbData  The buffer for writing raw RGB data to.
  88     void readScanline(unsigned char* rgb_data);
  89
  90 private:
  91
  92     /// Initialize gif_lib
  93     void init();
  94
  95     /// Process a single image record
  96     //
  97     /// @return     false if no image was parsed, true if we have an image.
  98     bool processRecord(GifRecordType record);
  99
 100     // State needed for input.
 101     GifFileType* _gif;
 102
 103     // A counter for keeping track of the last row copied.
 104     size_t _currentRow;
 105
 106     typedef boost::scoped_array<GifPixelType> PixelRow;
 107
 108     // A 2-dimensional scoped array holding the unpacked pixel data.
 109     boost::scoped_array<PixelRow> _gifData;
 110 };
 111
 112
 113 GifInput::GifInput(boost::shared_ptr<IOChannel> in)
 114     :
 115     Input(in),
 116     _gif(0),
 117     _currentRow(0)
 118 {
 119 }
 120
 121 GifInput::~GifInput()
 122 {
 123     // Clean up allocated data.
 124     DGifCloseFile(_gif);
 125 }
 126
 127 size_t
 128 GifInput::getHeight() const
 129 {
 130     assert (_gif);
 131     return _gif->SHeight;
 132 }
 133
 134 size_t
 135 GifInput::getWidth() const
 136 {
 137     assert (_gif);
 138     return _gif->SWidth;
 139 }
 140
 141 void
 142 GifInput::readScanline(unsigned char* rgbData)
 143 {
 144
 145     const ColorMapObject* const colormap = (_gif->Image.ColorMap) ?
 146                             _gif->Image.ColorMap : _gif->SColorMap;
 147
 148     assert(colormap);
 149
 150     unsigned char* ptr = rgbData;
 151
 152     for (size_t i = 0, e = getWidth(); i < e; ++i) {
 153
 154         const GifColorType* const mapentry =
 155             &colormap->Colors[_gifData[_currentRow][i]];
 156
 157         *ptr++ = mapentry->Red;
 158         *ptr++ = mapentry->Green;
 159         *ptr++ = mapentry->Blue;
 160     }
 161
 162     _currentRow++;
 163
 164 }
 165
 166 bool
 167 GifInput::processRecord(GifRecordType record)
 168 {
 169     switch (record) {
 170
 171         case IMAGE_DESC_RECORD_TYPE:
 172         {
 173             // Fill the _gif->Image fields
 174             if (DGifGetImageDesc(_gif) != GIF_OK) {
 175                 throw ParserException(_("GIF: Error retrieving image "
 176                             "description"));
 177             }
 178             const int backgroundColor = _gif->SBackGroundColor;
 179
 180             // Set the height dimension of the array
 181             _gifData.reset(new PixelRow[getHeight()]);
 182
 183             // The GIF 'screen' width and height
 184             const size_t screenWidth = getWidth();
 185             const size_t screenHeight = getHeight();
 186
 187             // Set all the pixels to the background colour.
 188             for (size_t i = 0; i < screenHeight; ++i) {
 189                 // Set the width dimension of the array
 190                 _gifData[i].reset(new GifPixelType[screenWidth]);
 191                 // Fill all the pixels with the background color.
 192                 std::fill_n(_gifData[i].get(), screenWidth,
 193                         backgroundColor);
 194             }
 195
 196             // The position of the image on the GIF 'screen'
 197             const size_t imageHeight = _gif->Image.Height;
 198             const size_t imageWidth = _gif->Image.Width;
 199             const size_t imageTop = _gif->Image.Top;
 200             const size_t imageLeft = _gif->Image.Left;
 201
 202             if (imageHeight + imageTop > screenHeight ||
 203                 imageWidth + imageLeft > screenWidth) {
 204                 throw ParserException(_("GIF: invalid image data "
 205                             "(bounds outside GIF screen)"));
 206             }
 207
 208             // Handle interlaced data in four passes.
 209             if (_gif->Image.Interlace) {
 210                 log_debug(_("Found interlaced GIF (%d x %d)"),
 211                         screenWidth, screenHeight);
 212
 213                 // The order of interlaced GIFs.
 214                 const int interlacedOffsets[] = { 0, 4, 2, 1 };
 215                 const int interlacedJumps[] = { 8, 8, 4, 2 };
 216
 217                 for (size_t i = 0; i < 4; ++i) {
 218
 219                     for (size_t j = imageTop + interlacedOffsets[i];
 220                                 j < imageTop + imageHeight;
 221                                 j += interlacedJumps[i]) {
 222
 223                         if (DGifGetLine(_gif, &_gifData[j][imageLeft],
 224                                     imageWidth) != GIF_OK) {
 225
 226                             throw ParserException(_("GIF: failed reading "
 227                                         "pixel data"));
 228
 229                         }
 230                     }
 231                 }
 232                 // One record is enough.
 233                 return true;
 234             }
 235
 236             // Non-interlaced data.
 237             log_debug(_("Found non-interlaced GIF (%d x %d)"),
 238                     screenWidth, screenHeight);
 239
 240             for (size_t i = imageTop; i < imageHeight; ++i) {
 241                 // Read the gif data into the gif array.
 242                 if (DGifGetLine(_gif, &_gifData[i][imageLeft], imageWidth)
 243                         != GIF_OK) {
 244                     throw ParserException(_("GIF: failed reading "
 245                                 "pixel data"));
 246                 }
 247             }
 248             // One record is enough.
 249             return true;
 250         }
 251
 252         case EXTENSION_RECORD_TYPE:
 253             // Skip all extension records.
 254             GifByteType* extension;
 255             int extCode;
 256             DGifGetExtension(_gif, &extCode, &extension);
 257             while (extension) {
 258                 if (DGifGetExtensionNext(_gif, &extension) == GIF_ERROR) {
 259                     break;
 260                 }
 261             }
 262             break;
 263         default:
 264             break;
 265     }
 266     return false;
 267 }
 268
 269 void
 270 GifInput::read()
 271 {
 272     _gif = DGifOpen(_inStream.get(), &readData);
 273
 274     GifRecordType record;
 275
 276     // Parse the (first?) image into memory.
 277     // Is there a multi-dimensional smart array? It's silly to
 278     // have to allocate each row separately and can mean a lot
 279     // of reallocation.
 280     do {
 281
 282         if (DGifGetRecordType(_gif, &record) != GIF_OK) {
 283             throw ParserException(_("GIF: Error retrieving record type"));
 284         }
 285         if (processRecord(record)) break;
 286
 287     } while (record != TERMINATE_RECORD_TYPE);
 288
 289     // Set the type to RGB
 290     // TODO: implement RGBA!
 291     _type = TYPE_RGB;
 292
 293 }
 294
 295 } // unnamed namespace
 296
 297 std::auto_ptr<Input>
 298 createGifInput(boost::shared_ptr<IOChannel> in)
 299 {
 300     std::auto_ptr<Input> ret(new GifInput(in));
 301     ret->read();
 302     return ret;
 303 }
 304
 305 } // namespace image
 306 } // namespace gnash
 307
 308 // Local Variables:
 309 // mode: C++
 310 // c-basic-offset: 8
 311 // tab-width: 8
 312 // indent-tabs-mode: t
 313 // End: