libbase/GnashImageGif.cpp

   1 // GnashImageGif.cpp: gif_lib wrapper for Gnash.
   2 //
   3 //   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Free Software
   4 //   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 "utility.h"
  32 #include "log.h"
  33 #include "GnashException.h"
  34 #include "IOChannel.h"
  35
  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 }
  52
  53 GifInput::GifInput(boost::shared_ptr<IOChannel> in)
  54     :
  55     Input(in),
  56     _gif(0),
  57     _currentRow(0)
  58 {
  59 }
  60
  61 GifInput::~GifInput()
  62 {
  63     // Clean up allocated data.
  64     DGifCloseFile(_gif);
  65 }
  66
  67 size_t
  68 GifInput::getHeight() const
  69 {
  70     assert (_gif);
  71     return _gif->SHeight;
  72 }
  73
  74 size_t
  75 GifInput::getWidth() const
  76 {
  77     assert (_gif);
  78     return _gif->SWidth;
  79 }
  80
  81 void
  82 GifInput::readScanline(unsigned char* rgbData)
  83 {
  84
  85     const ColorMapObject* const colormap = (_gif->Image.ColorMap) ?
  86                             _gif->Image.ColorMap : _gif->SColorMap;
  87
  88     assert(colormap);
  89
  90     unsigned char* ptr = rgbData;
  91
  92     for (size_t i = 0, e = getWidth(); i < e; ++i) {
  93
  94         const GifColorType* const mapentry =
  95             &colormap->Colors[_gifData[_currentRow][i]];
  96
  97         *ptr++ = mapentry->Red;
  98         *ptr++ = mapentry->Green;
  99         *ptr++ = mapentry->Blue;
 100     }
 101
 102     _currentRow++;
 103
 104 }
 105
 106 bool
 107 GifInput::processRecord(GifRecordType record)
 108 {
 109     switch (record) {
 110
 111         case IMAGE_DESC_RECORD_TYPE:
 112         {
 113             // Fill the _gif->Image fields
 114             if (DGifGetImageDesc(_gif) != GIF_OK) {
 115                 throw ParserException(_("GIF: Error retrieving image "
 116                             "description"));
 117             }
 118             const int backgroundColor = _gif->SBackGroundColor;
 119
 120             // Set the height dimension of the array
 121             _gifData.reset(new PixelRow[getHeight()]);
 122
 123             // The GIF 'screen' width and height
 124             const size_t screenWidth = getWidth();
 125             const size_t screenHeight = getHeight();
 126
 127             // Set all the pixels to the background colour.
 128             for (size_t i = 0; i < screenHeight; ++i) {
 129                 // Set the width dimension of the array
 130                 _gifData[i].reset(new GifPixelType[screenWidth]);
 131                 // Fill all the pixels with the background color.
 132                 std::fill_n(_gifData[i].get(), screenWidth,
 133                         backgroundColor);
 134             }
 135
 136             // The position of the image on the GIF 'screen'
 137             const size_t imageHeight = _gif->Image.Height;
 138             const size_t imageWidth = _gif->Image.Width;
 139             const size_t imageTop = _gif->Image.Top;
 140             const size_t imageLeft = _gif->Image.Left;
 141
 142             if (imageHeight + imageTop > screenHeight ||
 143                 imageWidth + imageLeft > screenWidth) {
 144                 throw ParserException(_("GIF: invalid image data "
 145                             "(bounds outside GIF screen)"));
 146             }
 147
 148             // Handle interlaced data in four passes.
 149             if (_gif->Image.Interlace) {
 150                 log_debug(_("Found interlaced GIF (%d x %d)"),
 151                         screenWidth, screenHeight);
 152
 153                 // The order of interlaced GIFs.
 154                 const int interlacedOffsets[] = { 0, 4, 2, 1 };
 155                 const int interlacedJumps[] = { 8, 8, 4, 2 };
 156
 157                 for (size_t i = 0; i < 4; ++i) {
 158
 159                     for (size_t j = imageTop + interlacedOffsets[i];
 160                                 j < imageTop + imageHeight;
 161                                 j += interlacedJumps[i]) {
 162
 163                         if (DGifGetLine(_gif, &_gifData[j][imageLeft],
 164                                     imageWidth) != GIF_OK) {
 165
 166                             throw ParserException(_("GIF: failed reading "
 167                                         "pixel data"));
 168
 169                         }
 170                     }
 171                 }
 172                 // One record is enough.
 173                 return true;
 174             }
 175
 176             // Non-interlaced data.
 177             log_debug(_("Found non-interlaced GIF (%d x %d)"),
 178                     screenWidth, screenHeight);
 179
 180             for (size_t i = imageTop; i < imageHeight; ++i) {
 181                 // Read the gif data into the gif array.
 182                 if (DGifGetLine(_gif, &_gifData[i][imageLeft], imageWidth)
 183                         != GIF_OK) {
 184                     throw ParserException(_("GIF: failed reading "
 185                                 "pixel data"));
 186                 }
 187             }
 188             // One record is enough.
 189             return true;
 190         }
 191
 192         case EXTENSION_RECORD_TYPE:
 193             // Skip all extension records.
 194             GifByteType* extension;
 195             int extCode;
 196             DGifGetExtension(_gif, &extCode, &extension);
 197             while (extension) {
 198                 if (DGifGetExtensionNext(_gif, &extension) == GIF_ERROR) {
 199                     break;
 200                 }
 201             }
 202             break;
 203         default:
 204             break;
 205     }
 206     return false;
 207 }
 208
 209 void
 210 GifInput::read()
 211 {
 212     _gif = DGifOpen(_inStream.get(), &readData);
 213
 214     GifRecordType record;
 215
 216     // Parse the (first?) image into memory.
 217     // Is there a multi-dimensional smart array? It's silly to
 218     // have to allocate each row separately and can mean a lot
 219     // of reallocation.
 220     do {
 221
 222         if (DGifGetRecordType(_gif, &record) != GIF_OK) {
 223             throw ParserException(_("GIF: Error retrieving record type"));
 224         }
 225         if (processRecord(record)) break;
 226
 227     } while (record != TERMINATE_RECORD_TYPE);
 228
 229     // Set the type to RGB
 230     // TODO: implement RGBA!
 231     _type = TYPE_RGB;
 232
 233 }
 234
 235 } // namespace image
 236 } // namespace gnash
 237
 238 // Local Variables:
 239 // mode: C++
 240 // c-basic-offset: 8
 241 // tab-width: 8
 242 // indent-tabs-mode: t
 243 // End: