libbase/GnashImageJpeg.h

   1 // GnashImageJpeg.h:  Jpeg reader, for Gnash.
   2 //
   3 //   Copyright (C) 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 // Original version by Thatcher Ulrich <tu@tulrich.com> 2002
  22 //
  23
  24 #ifndef GNASH_IMAGE_JPEG_H
  25 #define GNASH_IMAGE_JPEG_H
  26
  27 #include <csetjmp>
  28
  29 #include "dsodefs.h"
  30 #include "GnashImage.h"
  31
  32 // jpeglib.h redefines HAVE_STDLIB_H. This silences
  33 // the warnings, but it's not good.
  34 #undef HAVE_STDLIB_H
  35 extern "C" {
  36 #include <jpeglib.h>
  37 }
  38 #undef HAVE_STDLIB_H
  39
  40 // Forward declarations
  41 namespace gnash { class IOChannel; }
  42
  43 namespace gnash {
  44 namespace image {
  45
  46 /// Class for reading JPEG image data.
  47 //
  48 /// This uses the IJG jpeglib to implement the Input interface.
  49 class DSOEXPORT JpegInput : public Input
  50 {
  51
  52 private:
  53
  54     const char* _errorOccurred;
  55
  56     std::jmp_buf _jmpBuf;
  57
  58     // State needed for input.
  59     jpeg_decompress_struct m_cinfo;
  60     jpeg_error_mgr m_jerr;
  61
  62     bool _compressorOpened;
  63
  64 public:
  65
  66     /// Construct a JpegInput object to read from an IOChannel.
  67     //
  68     /// @param in   The stream to read JPEG data from. Ownership is shared
  69     ///             between caller and JpegInput, so it is freed
  70     ///             automatically when the last owner is destroyed.
  71     DSOEXPORT JpegInput(std::shared_ptr<IOChannel> in);
  72
  73     /// Read the JPEG header information only.
  74     //
  75     /// @param maxHeaderBytes   The maximum number of bytes to read before
  76     ///                         Stopping. If the header is shorter, we stop
  77     ///                         early.
  78     void DSOEXPORT readHeader(unsigned int maxHeaderBytes);
  79
  80     ~JpegInput();
  81
  82     /// Begin processing the image data.
  83     void read();
  84
  85     /// Discard any data sitting in our input buffer.
  86     //
  87     /// Use this before/after reading headers or partial image
  88     /// data, to avoid screwing up future reads.
  89     DSOEXPORT void discardPartialBuffer();
  90
  91     /// Complete processing the image and clean up.
  92     //
  93     /// This should close / free all resources from libjpeg.
  94     void finishImage();
  95
  96     /// Get the image's height in pixels.
  97     //
  98     /// @return     The height of the image in pixels.
  99     size_t getHeight() const;
 100
 101     /// Get the image's width in pixels.
 102     //
 103     /// @return     The width of the image in pixels.
 104     size_t getWidth() const;
 105
 106     /// Get number of components (channels)
 107     //
 108     /// @return     The number of components, e.g. 3 for RGB
 109     size_t getComponents() const;
 110
 111     /// Read a scanline's worth of image data into the given buffer.
 112     //
 113     /// The amount of data read is getWidth() * getComponents().
 114     ///
 115     /// @param rgbData  The buffer for writing raw RGB data to.
 116     void readScanline(unsigned char* rgbData);
 117
 118     /// Create a JpegInput and transfer ownership to the caller.
 119     //
 120     /// @param in   The IOChannel to read JPEG data from.
 121     static std::unique_ptr<Input> create(std::shared_ptr<IOChannel> in)
 122     {
 123         std::unique_ptr<Input> ret(new JpegInput(in));
 124         // might throw an exception (I guess)
 125         if (ret.get()) ret->read();
 126         return ret;
 127     }
 128
 129     /// \brief
 130     /// For reading SWF JPEG2-style image data, using pre-loaded
 131     /// headers stored in the given JpegInput object.
 132     //
 133     /// @param loader   The JpegInput object to use for reading the
 134     ///                 data. This should have been constructed with
 135     ///                 createSWFJpeg2HeaderOnly().
 136     DSOEXPORT static std::unique_ptr<GnashImage> readSWFJpeg2WithTables(
 137             JpegInput& loader);
 138
 139     /// Create a JPEG 'loader' object by reading a JPEG header.
 140     //
 141     /// This is for reusing the header information for different JPEGs images.
 142     //
 143     /// @param in               The channel to read JPEG header data from.
 144     /// @param maxHeaderBytes   The maximum number of bytes to read.
 145     static std::unique_ptr<JpegInput> createSWFJpeg2HeaderOnly(
 146             std::shared_ptr<IOChannel> in, unsigned int maxHeaderBytes)
 147     {
 148         std::unique_ptr<JpegInput> ret (new JpegInput(in));
 149         // might throw an exception
 150         if (ret.get()) ret->readHeader(maxHeaderBytes);
 151         return ret;
 152     }
 153
 154     /// This function is called when libjpeg encounters an error.
 155     //
 156     /// It is needed to avoid memory corruption during stack unwinding by
 157     /// freeing libjpeg resources correctly before throwing an exception.
 158     ///
 159     /// @param msg  An error message for logging.
 160     void errorOccurred(const char* msg);
 161
 162
 163 };
 164
 165 // Class for writing JPEG image data.
 166 class JpegOutput : public Output
 167 {
 168
 169 public:
 170
 171     /// Constract a JpegOutput for writing to an IOChannel
 172     //
 173     /// @param out      The gnash::IOChannel to write the image to
 174     /// @param width    The width of the resulting image
 175     /// @param height   The height of the resulting image.
 176     /// @param quality  The quality of the created image, from 1-100.
 177     JpegOutput(std::shared_ptr<IOChannel> out, size_t width,
 178             size_t height, int quality);
 179
 180     ~JpegOutput();
 181
 182     /// Write RGB image data using the parameters supplied at construction.
 183     //
 184     /// @param rgbData  The raw RGB image data to write as a JPEG.
 185     virtual void writeImageRGB(const unsigned char* rgbData);
 186
 187     /// Write RGBA image data using the parameters supplied at construction.
 188     //
 189     /// Note: transparency is ignored because JPEG doesn't support it!
 190     //
 191     /// @param rgbaData  The raw RGBA image data to write as a JPEG.
 192     virtual void writeImageRGBA(const unsigned char* rgbaData);
 193
 194     /// Create a JpegOutput, transferring ownership to the caller.
 195     //
 196     /// @param out      The gnash::IOChannel to write the image to
 197     /// @param width    The width of the resulting image
 198     /// @param height   The height of the resulting image.
 199     /// @param quality  The quality of the created image, from 1-100.
 200     static std::unique_ptr<Output> create(std::shared_ptr<IOChannel> out,
 201             size_t width, size_t height, int quality);
 202
 203 private:
 204
 205     jpeg_compress_struct m_cinfo;
 206     jpeg_error_mgr m_jerr;
 207
 208 };
 209
 210 } // namespace image
 211 } // namespace gnash
 212
 213 #endif // JPEG_H
 214
 215 // Local Variables:
 216 // mode: C++
 217 // c-basic-offset: 8
 218 // tab-width: 8
 219 // indent-tabs-mode: t
 220 // End: