libbase/GnashImagePng.cpp

   1 // GnashImagePng.cpp: libpng wrapper for Gnash.
   2 //
   3 //   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
   4 //   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 #ifdef HAVE_CONFIG_H
  22 # include "gnashconfig.h"
  23 #endif
  24
  25 #include "GnashImagePng.h"
  26
  27 #include <sstream>
  28
  29 extern "C" {
  30 #ifdef HAVE_PNG_H
  31 # include <png.h>
  32 #endif
  33 }
  34
  35 #include "GnashImage.h"
  36 #include "utility.h"
  37 #include "log.h"
  38 #include "GnashException.h"
  39 #include "IOChannel.h"
  40
  41 namespace gnash {
  42 namespace image {
  43
  44 namespace {
  45
  46 void
  47 error(png_struct*, const char* msg)
  48 {
  49     std::ostringstream ss;
  50     ss << _("PNG error: ") << msg;
  51     throw ParserException(ss.str());
  52 }
  53
  54 void
  55 warning(png_struct*, const char* msg)
  56 {
  57     log_debug("PNG warning: %s", msg);
  58 }
  59
  60 void
  61 readData(png_structp pngptr, png_bytep data, png_size_t length)
  62 {
  63     // Do not call unless the PNG exists.
  64     assert(pngptr);
  65     IOChannel* in = reinterpret_cast<IOChannel*>(png_get_io_ptr(pngptr));
  66     in->read(reinterpret_cast<char*>(data), length);
  67 }
  68
  69 void
  70 writeData(png_structp pngptr, png_bytep data, png_size_t length)
  71 {
  72     // Do not call unless the PNG exists.
  73     assert(pngptr);
  74     IOChannel* out = reinterpret_cast<IOChannel*>(png_get_io_ptr(pngptr));
  75     out->write(reinterpret_cast<char*>(data), length);
  76 }
  77
  78 void
  79 flushData(png_structp /*pngptr*/)
  80 {
  81 }
  82
  83 class PngInput : public Input
  84 {
  85
  86 public:
  87
  88     /// Construct a PngInput object to read from an IOChannel.
  89     //
  90     /// @param in   The stream to read PNG data from. Ownership is shared
  91     ///             between caller and JpegInput, so it is freed
  92     ///             automatically when the last owner is destroyed.
  93     PngInput(std::shared_ptr<IOChannel> in)
  94         :
  95         Input(in),
  96         _pngPtr(nullptr),
  97         _infoPtr(nullptr),
  98         _currentRow(0)
  99     {
 100         init();
 101     }
 102
 103     ~PngInput();
 104
 105     /// Begin processing the image data.
 106     void read();
 107
 108     /// Get the image's height in pixels.
 109     //
 110     /// @return     The height of the image in pixels.
 111     size_t getHeight() const;
 112
 113     /// Get the image's width in pixels.
 114     //
 115     /// @return     The width of the image in pixels.
 116     size_t getWidth() const;
 117
 118     /// Read a scanline's worth of image data into the given buffer.
 119     //
 120     /// The amount of data read is getWidth() * getComponents().
 121     ///
 122     /// @param rgbData  The buffer for writing raw RGB data to.
 123     void readScanline(unsigned char* imageData);
 124
 125 private:
 126
 127     // State needed for input.
 128     png_structp _pngPtr;
 129     png_infop _infoPtr;
 130     std::unique_ptr<png_bytep[]> _rowPtrs;
 131     std::unique_ptr<png_byte[]> _pixelData;
 132
 133     // A counter for keeping track of the last row copied.
 134     size_t _currentRow;
 135
 136     void init();
 137
 138     // Return number of components (i.e. == 3 for RGB
 139     // data).
 140     size_t getComponents() const;
 141
 142 };
 143
 144 // Class object for writing PNG image data.
 145 class PngOutput : public Output
 146 {
 147
 148 public:
 149
 150     /// Create an output object bound to a gnash::IOChannel
 151     //
 152     /// @param out      The IOChannel used for output. Must be kept alive
 153     ///                 throughout
 154     /// @param quality Unused in PNG output
 155     PngOutput(std::shared_ptr<IOChannel> out, size_t width,
 156             size_t height, int quality);
 157
 158     ~PngOutput();
 159
 160     void writeImageRGB(const unsigned char* rgbData);
 161
 162     void writeImageRGBA(const unsigned char* rgbaData);
 163
 164 private:
 165
 166     /// Initialize libpng.
 167     void init();
 168
 169     /// Libpng structures for image and output state.
 170     png_structp _pngPtr;
 171     png_infop _infoPtr;
 172
 173 };
 174
 175 PngInput::~PngInput()
 176 {
 177     png_destroy_read_struct(&_pngPtr, &_infoPtr, nullptr);
 178 }
 179
 180 size_t
 181 PngInput::getHeight() const
 182 {
 183     assert(_pngPtr && _infoPtr);
 184     return png_get_image_height(_pngPtr, _infoPtr);
 185 }
 186
 187 size_t
 188 PngInput::getWidth() const
 189 {
 190     assert(_pngPtr && _infoPtr);
 191     return png_get_image_width(_pngPtr, _infoPtr);
 192 }
 193
 194 size_t
 195 PngInput::getComponents() const
 196 {
 197     return png_get_channels(_pngPtr, _infoPtr);
 198 }
 199
 200 void
 201 PngInput::readScanline(unsigned char* imageData)
 202 {
 203     assert(_currentRow < getHeight());
 204     assert(_rowPtrs);
 205
 206     // Data packed as RGB / RGBA
 207     const size_t size = getWidth() * getComponents();
 208
 209     std::copy(_rowPtrs[_currentRow], _rowPtrs[_currentRow] + size, imageData);
 210
 211     ++_currentRow;
 212 }
 213
 214
 215 void
 216 PngInput::init()
 217 {
 218     // Initialize png library.
 219     _pngPtr = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, &error,
 220             &warning);
 221
 222     if (!_pngPtr) return;
 223
 224     _infoPtr = png_create_info_struct(_pngPtr);
 225
 226     if (!_infoPtr) {
 227         png_destroy_read_struct(&_pngPtr, nullptr, nullptr);
 228         return;
 229     }
 230 }
 231
 232 void
 233 PngInput::read()
 234 {
 235     // Set our user-defined reader function
 236     png_set_read_fn(_pngPtr, _inStream.get(), &readData);
 237
 238     png_read_info(_pngPtr, _infoPtr);
 239
 240     const png_byte type = png_get_color_type(_pngPtr, _infoPtr);
 241     const png_byte bitDepth = png_get_bit_depth(_pngPtr, _infoPtr);
 242
 243     // Convert indexed images to RGB
 244     if (type == PNG_COLOR_TYPE_PALETTE) {
 245         log_debug("Converting palette PNG to RGB(A)");
 246         png_set_palette_to_rgb(_pngPtr);
 247     }
 248
 249     // Convert less-than-8-bit greyscale to 8 bit.
 250     if (type == PNG_COLOR_TYPE_GRAY && bitDepth < 8) {
 251             log_debug("Setting grey bit depth(%d) to 8", bitDepth);
 252 #if PNG_LIBPNG_VER_MINOR < 4
 253         png_set_gray_1_2_4_to_8(_pngPtr);
 254 #else
 255         png_set_expand_gray_1_2_4_to_8(_pngPtr);
 256 #endif
 257     }
 258
 259     // Apply the transparency block if it exists.
 260     if (png_get_valid(_pngPtr, _infoPtr, PNG_INFO_tRNS)) {
 261         log_debug("Applying transparency block, image is RGBA");
 262         png_set_tRNS_to_alpha(_pngPtr);
 263         _type = TYPE_RGBA;
 264     }
 265
 266     // Make 16-bit data into 8-bit data
 267     if (bitDepth == 16) png_set_strip_16(_pngPtr);
 268
 269     // Set the type of the image if it hasn't been set already.
 270     if (_type == GNASH_IMAGE_INVALID) {
 271         if (type & PNG_COLOR_MASK_ALPHA) {
 272             log_debug("Loading PNG image with alpha");
 273             _type = TYPE_RGBA;
 274         }
 275         else {
 276                 log_debug("Loading PNG image without alpha");
 277             _type = TYPE_RGB;
 278         }
 279     }
 280
 281     // Convert 1-channel grey images to 3-channel RGB.
 282     if (type == PNG_COLOR_TYPE_GRAY || type == PNG_COLOR_TYPE_GRAY_ALPHA) {
 283         log_debug("Converting greyscale PNG to RGB(A)");
 284         png_set_gray_to_rgb(_pngPtr);
 285     }
 286
 287     png_read_update_info(_pngPtr, _infoPtr);
 288
 289     const size_t height = getHeight();
 290     const size_t width = getWidth();
 291     const size_t components = getComponents();
 292
 293     // We must have 3 or 4-channel data by this point.
 294     assert((_type == TYPE_RGB && components == 3) ||
 295            (_type == TYPE_RGBA && components == 4));
 296
 297     // Allocate space for the data
 298     _pixelData.reset(new png_byte[width * height * components]);
 299
 300     // Allocate an array of pointers to the beginning of
 301     // each row.
 302     _rowPtrs.reset(new png_bytep[height]);
 303
 304     // Fill in the row pointers.
 305     for (size_t y = 0; y < height; ++y) {
 306         _rowPtrs[y] = _pixelData.get() + y * width * components;
 307     }
 308
 309     // Read in the image using the options set.
 310     png_read_image(_pngPtr, _rowPtrs.get());
 311
 312 }
 313
 314 ///
 315 /// PNG output
 316 ///
 317
 318 PngOutput::PngOutput(std::shared_ptr<IOChannel> out, size_t width,
 319         size_t height, int /*quality*/)
 320     :
 321     Output(out, width, height),
 322     _pngPtr(nullptr),
 323     _infoPtr(nullptr)
 324 {
 325     init();
 326 }
 327
 328
 329 PngOutput::~PngOutput()
 330 {
 331     png_destroy_write_struct(&_pngPtr, &_infoPtr);
 332 }
 333
 334
 335 void
 336 PngOutput::init()
 337 {
 338     // Initialize png library.
 339     _pngPtr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
 340                                         nullptr, &error, &warning);
 341     if (!_pngPtr) return;
 342
 343     _infoPtr = png_create_info_struct(_pngPtr);
 344
 345     if (!_infoPtr) {
 346         png_destroy_write_struct(&_pngPtr, static_cast<png_infopp>(nullptr));
 347         return;
 348     }
 349 }
 350
 351 void
 352 PngOutput::writeImageRGBA(const unsigned char* rgbaData)
 353 {
 354     png_set_write_fn(_pngPtr, _outStream.get(), &writeData, &flushData);
 355
 356     std::unique_ptr<const png_byte*[]> rows(new const png_byte*[_height]);
 357
 358     // RGBA
 359     const size_t components = 4;
 360
 361     for (size_t y = 0; y < _height; ++y) {
 362         rows[y] = rgbaData + _width * y * components;
 363     }
 364
 365     // libpng needs non-const. We'll hope it doesn't change our image.
 366     png_set_rows(_pngPtr, _infoPtr, const_cast<png_bytepp>(rows.get()));
 367
 368     png_set_IHDR(_pngPtr, _infoPtr, _width, _height,
 369        8, PNG_COLOR_TYPE_RGBA, PNG_INTERLACE_NONE,
 370        PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 371
 372     png_write_png(_pngPtr, _infoPtr, PNG_TRANSFORM_IDENTITY, nullptr);
 373 }
 374
 375
 376 void
 377 PngOutput::writeImageRGB(const unsigned char* rgbData)
 378 {
 379     png_set_write_fn(_pngPtr, _outStream.get(), &writeData, &flushData);
 380
 381     std::unique_ptr<const png_byte*[]> rows(new const png_byte*[_height]);
 382
 383     // RGB
 384     const size_t components = 3;
 385
 386     for (size_t y = 0; y < _height; ++y) {
 387         rows[y] = rgbData + _width * y * components;
 388     }
 389
 390     // libpng needs non-const. We'll hope it doesn't change our image.
 391     png_set_rows(_pngPtr, _infoPtr, const_cast<png_bytepp>(rows.get()));
 392
 393     png_set_IHDR(_pngPtr, _infoPtr, _width, _height,
 394        8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
 395        PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 396
 397     png_write_png(_pngPtr, _infoPtr, PNG_TRANSFORM_IDENTITY, nullptr);
 398 }
 399
 400 } // unnamed namespace
 401
 402 std::unique_ptr<Input>
 403 createPngInput(std::shared_ptr<IOChannel> in)
 404 {
 405     std::unique_ptr<Input> ret(new PngInput(in));
 406     ret->read();
 407     return ret;
 408 }
 409
 410 std::unique_ptr<Output>
 411 createPngOutput(std::shared_ptr<IOChannel> o, size_t width,
 412                        size_t height, int quality)
 413 {
 414     std::unique_ptr<Output> outChannel(new PngOutput(o, width, height, quality));
 415     return outChannel;
 416 }
 417
 418 } // namespace image
 419 } // namespace gnash
 420
 421 // Local Variables:
 422 // mode: C++
 423 // c-basic-offset: 8
 424 // tab-width: 8
 425 // indent-tabs-mode: t
 426 // End: