libbase/GnashImage.h

   1 // GnashImage.h: Base class for reading image data in 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 // The GnashImage class and subclasses are partly based on the public domain
  22 // work of Thatcher Ulrich <tu@tulrich.com> 2002
  23
  24 #ifndef GNASH_GNASHIMAGE_H
  25 #define GNASH_GNASHIMAGE_H
  26
  27 #include <boost/shared_ptr.hpp>
  28 #include <boost/noncopyable.hpp>
  29 #include <boost/cstdint.hpp>
  30 #include <boost/scoped_array.hpp>
  31 #include <memory>
  32
  33 #include "GnashEnums.h"
  34 #include "log.h"
  35 #include "dsodefs.h"
  36
  37 // Forward declarations
  38 namespace gnash {
  39     class IOChannel;
  40 }
  41
  42 namespace gnash {
  43
  44 /// Image handling functions and classes.
  45 namespace image {
  46
  47 /// The types of images handled in Gnash.
  48 enum ImageType
  49 {
  50     GNASH_IMAGE_INVALID,
  51     TYPE_RGB,
  52     TYPE_RGBA
  53 };
  54
  55 /// The locations of images handled in Gnash.
  56 enum ImageLocation
  57 {
  58     GNASH_IMAGE_CPU = 1,
  59     GNASH_IMAGE_GPU
  60 };
  61
  62 inline size_t
  63 numChannels(ImageType t)
  64 {
  65     switch (t) {
  66         case TYPE_RGBA:
  67             return 4;
  68         case TYPE_RGB:
  69             return 3;
  70         default:
  71             std::abort();
  72     }
  73 }
  74
  75 /// Base class for different types of bitmaps
  76 //
  77 /// 1. Bytes are packed in RGB(A) order.
  78 /// 2. Rowstride is equal to channels * width
  79 class DSOEXPORT GnashImage : boost::noncopyable
  80 {
  81 public:
  82
  83     typedef boost::uint8_t value_type;
  84     typedef boost::scoped_array<value_type> container_type;
  85     typedef value_type* iterator;
  86     typedef const value_type* const_iterator;
  87
  88     virtual ~GnashImage() {}
  89
  90     /// Return the ImageType of the image.
  91     //
  92     /// This saves guessing when dynamic_cast is used.
  93     ImageType type() const {
  94         return _type;
  95     }
  96
  97     /// Return the ImageLocation of the image.
  98     //
  99     /// This saves guessing when dynamic_cast is used.
 100     ImageLocation location() const {
 101         return _location;
 102     }
 103
 104     /// Get the size of the image buffer
 105     //
 106     /// @return     The size of the buffer in bytes
 107     size_t size() const {
 108         return stride() * _height;
 109     }
 110
 111     /// Get the pitch of the image buffer
 112     //
 113     /// @return     The rowstride of the buffer in bytes
 114     virtual size_t stride() const {
 115         return _width * channels();
 116     }
 117
 118     /// Get the number of channels
 119     //
 120     /// @return     The number of channels
 121     size_t channels() const {
 122         return numChannels(_type);
 123     }
 124
 125     /// Get the image's width
 126     //
 127     /// @return     The image's width in pixels.
 128     size_t width() const {
 129         return _width;
 130     }
 131
 132     /// Get the image's width
 133     //
 134     /// @return     The image's height in pixels.
 135     size_t height() const {
 136         return _height;
 137     }
 138
 139     /// Copy image data from a buffer.
 140     //
 141     /// Note that this buffer MUST have the same rowstride and type, or
 142     /// unexpected things will happen. In general, it is only safe to copy
 143     /// from another GnashImage or unexpected things will happen.
 144     ///
 145     /// @param data     buffer to copy data from.
 146     void update(const_iterator data);
 147
 148     /// Copy image data from another image data
 149     //
 150     /// Note that this buffer must have the same rowstride and type
 151     ///
 152     /// @param from     image to copy data from.
 153     void update(const GnashImage& from);
 154
 155     /// Access the raw data.
 156     virtual iterator begin() {
 157         return _data.get();
 158     }
 159
 160     /// Access the raw data
 161     virtual const_iterator begin() const {
 162         return _data.get();
 163     }
 164
 165     /// An iterator to the end of the data.
 166     iterator end() {
 167         return begin() + size();
 168     }
 169
 170     /// An iterator to the end of the data.
 171     const_iterator end() const {
 172         return begin() + size();
 173     }
 174
 175 protected:
 176
 177     /// Construct a GnashImage from a data buffer, taking ownership of the data.
 178     //
 179     /// @param data     The raw image data. This class takes ownership.
 180     /// @param width    The width of the image in pixels.
 181     /// @param height   The height of the image in pixels.
 182     /// @param pitch    The pitch (rowstride) of the image in bytes.
 183     /// @param type     The ImageType of the image.
 184     GnashImage(iterator data, size_t width, size_t height, ImageType type,
 185             ImageLocation location = GNASH_IMAGE_CPU);
 186
 187     /// Construct an empty GnashImage
 188     //
 189     /// Note: there is an arbitrary limit of boost::int32_t::max bytes for the
 190     /// total size of the bitmap constructed with this constructor.
 191     //
 192     /// @param width    The width of the image in pixels.
 193     /// @param height   The height of the image in pixels.
 194     /// @param type     The ImageType of the image.
 195     GnashImage(size_t width, size_t height, ImageType type,
 196                ImageLocation location = GNASH_IMAGE_CPU);
 197
 198     /// The type of the image: RGBA or RGB.
 199     const ImageType _type;
 200
 201     /// Image data location (CPU or GPU)
 202     const ImageLocation _location;
 203
 204     /// Width of image, in pixels
 205     const size_t _width;
 206
 207     /// Height of image, in pixels
 208     const size_t _height;
 209
 210     /// Data if held in this class
 211     container_type _data;
 212
 213 };
 214
 215 /// 24-bit RGB bitmap
 216 //
 217 /// Channels are in RGB order.
 218 class DSOEXPORT ImageRGB : public GnashImage
 219 {
 220 public:
 221
 222     /// Create an empty RGB image with uninitialized data.
 223     ImageRGB(size_t width, size_t height);
 224
 225     /// Create an ImageRGB taking ownership of the data.
 226     ImageRGB(iterator data, size_t width, size_t height)
 227         :
 228         GnashImage(data, width, height, TYPE_RGB)
 229     {}
 230
 231     virtual ~ImageRGB();
 232 };
 233
 234 /// 32-bit RGBA bitmap
 235 //
 236 /// Channels are in RGBA order.
 237 class DSOEXPORT ImageRGBA : public GnashImage
 238 {
 239
 240 public:
 241
 242     /// Create an empty RGB image with uninitialized data.
 243     ImageRGBA(size_t width, size_t height);
 244
 245     ImageRGBA(iterator data, size_t width, size_t height)
 246         :
 247         GnashImage(data, width, height, TYPE_RGBA)
 248     {}
 249
 250     ~ImageRGBA();
 251
 252     /// Set pixel value
 253     //
 254     /// TODO: move in base class ?
 255     ///
 256     void setPixel(size_t x, size_t y, value_type r, value_type g, value_type b,
 257             value_type a);
 258 };
 259
 260 /// The base class for reading image data.
 261 class Input : boost::noncopyable
 262 {
 263 public:
 264
 265     /// Construct an Input object to read from an IOChannel.
 266     //
 267     /// @param in   The stream to read data from. Ownership is shared
 268     ///             between caller and Input, so it is freed
 269     ///             automatically when the last owner is destroyed.
 270     Input(boost::shared_ptr<IOChannel> in)
 271         :
 272         _inStream(in),
 273         _type(GNASH_IMAGE_INVALID)
 274     {}
 275
 276     virtual ~Input() {}
 277
 278     /// Begin processing the image data.
 279     virtual void read() = 0;
 280
 281     /// Get the image's height in pixels.
 282     //
 283     /// @return     The height of the image in pixels.
 284     virtual size_t getHeight() const = 0;
 285
 286     /// Get the image's width in pixels.
 287     //
 288     /// @return     The width of the image in pixels.
 289     virtual size_t getWidth() const = 0;
 290
 291     /// Get number of components (channels)
 292     //
 293     /// @return     The number of components, e.g. 3 for RGB
 294     virtual size_t getComponents() const = 0;
 295
 296     /// Read a scanline's worth of image data into the given buffer.
 297     //
 298     /// @param rgbData  The buffer for writing raw RGB data to.
 299     virtual void readScanline(unsigned char* rgbData) = 0;
 300
 301     /// Get the ImageType of the image.
 302     //
 303     /// @return The type of the image. This is GNASH_IMAGE_INVALID
 304     ///         at least until read() has been called and reads some
 305     ///         valid data.
 306     ImageType imageType() { return _type; }
 307
 308     /// \brief
 309     /// For reading SWF JPEG3-style image data, like ordinary JPEG,
 310     /// but stores the data in ImageRGBA format.
 311     DSOEXPORT static std::auto_ptr<ImageRGBA> readSWFJpeg3(
 312             boost::shared_ptr<gnash::IOChannel> in);
 313
 314     /// Read image data from an IOChannel into an GnashImage.
 315     //
 316     /// @param in   The IOChannel to read the image from.
 317     /// @param type The type of image to read.
 318     /// @return     An GnashImage with the read image data. If type
 319     ///             is an unsupported FileType or image reading fails,
 320     ///             a NULL auto_ptr is returned.
 321     DSOEXPORT static std::auto_ptr<GnashImage> readImageData(
 322             boost::shared_ptr<gnash::IOChannel> in, FileType type);
 323
 324 protected:
 325
 326     boost::shared_ptr<IOChannel> _inStream;
 327
 328     ImageType _type;
 329
 330 };
 331
 332 // Base class for writing image data.
 333 class Output : boost::noncopyable
 334 {
 335
 336 public:
 337
 338     /// Construct an Output for writing to an IOChannel
 339     //
 340     /// @param out      The gnash::IOChannel to write the image to. Ownership
 341     ///                 is shared.
 342     /// @param width    The width of the resulting image
 343     /// @param height   The height of the resulting image.
 344     Output(boost::shared_ptr<IOChannel> out, size_t width, size_t height)
 345         :
 346         _width(width),
 347         _height(height),
 348         _outStream(out)
 349     {}
 350
 351     virtual ~Output() {}
 352
 353     /// Write RGB image data using the parameters supplied at construction.
 354     //
 355     /// @param rgbData  The raw RGB image data to write as an image.
 356     virtual void writeImageRGB(const unsigned char* rgbData) = 0;
 357
 358     /// Write RGBA image data using the parameters supplied at construction.
 359     //
 360     /// @param rgbaData  The raw RGBA image data to write as an image.
 361     virtual void writeImageRGBA(const unsigned char* /*rgbaData*/)
 362     {
 363         log_error(_("This image format does not support writing RGBA images"));
 364     }
 365
 366     /// Write the given image to the given IOChannel in a specified format.
 367     //
 368     /// @param type     The image format to write in (see GnashEnums.h)
 369     /// @param out      The IOChannel to write to.
 370     /// @param image    The image to write.
 371     /// @param quality  The quality of the image output, from 0..100. Values
 372     ///                 outside this range will be clamped to the minimum or
 373     ///                 maxium value. The quality is not used for all
 374     ///                 formats.
 375     DSOEXPORT static void writeImageData(FileType type,
 376             boost::shared_ptr<gnash::IOChannel> out, const GnashImage& image,
 377             int quality);
 378
 379 protected:
 380
 381     const size_t _width;
 382
 383     const size_t _height;
 384
 385     boost::shared_ptr<IOChannel> _outStream;
 386
 387 };
 388
 389 /// Get a pointer to a given row of any image.
 390 //
 391 /// @param row    The index of the required row.
 392 /// @return     A pointer to the first byte of the specified row.
 393 inline GnashImage::iterator
 394 scanline(GnashImage& im, size_t row)
 395 {
 396     assert(row < im.height());
 397     return im.begin() + im.stride() * row;
 398 }
 399
 400 /// Get a read-only pointer to a given row of any image.
 401 //
 402 /// @param y    The index of the required row.
 403 /// @return     A read-only pointer to the first byte of the specified row.
 404 inline GnashImage::const_iterator
 405 scanline(const GnashImage& im, size_t row)
 406 {
 407     assert(row < im.height());
 408     return im.begin() + im.stride() * row;
 409 }
 410
 411 DSOEXPORT void mergeAlpha(ImageRGBA& im, GnashImage::const_iterator alphaData,
 412         const size_t bufferLength);
 413
 414 } // namespace image
 415 } // namespace gnash
 416
 417 #endif