GnashImage.h

Go to the documentation of this file.

// GnashImage.h: Base class for reading image data in Gnash.
// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

// The GnashImage class and subclasses are partly based on the public domain
// work of Thatcher Ulrich <tu@tulrich.com> 2002

#ifndef GNASH_GNASHIMAGE_H
#define GNASH_GNASHIMAGE_H

#include <boost/noncopyable.hpp>
#include <cstdint>
#include <memory> 

#include "GnashEnums.h"
#include "log.h"
#include "dsodefs.h"

// Forward declarations
namespace gnash {
    class IOChannel;
}

namespace gnash {

namespace image {

enum ImageType
{
    GNASH_IMAGE_INVALID,
    TYPE_RGB,
    TYPE_RGBA
};

enum ImageLocation
{
    GNASH_IMAGE_CPU = 1,
    GNASH_IMAGE_GPU
};

inline size_t
numChannels(ImageType t)
{
    switch (t) {
        case TYPE_RGBA:
            return 4;
        case TYPE_RGB:
            return 3;
        default:
            std::abort();
    }
}

//
class DSOEXPORT GnashImage : boost::noncopyable
{
public:

    typedef std::uint8_t value_type;
    typedef std::unique_ptr<value_type[]> container_type;
    typedef value_type* iterator;
    typedef const value_type* const_iterator;

    virtual ~GnashImage() {}

    //
    ImageType type() const {
        return _type;
    }

    //
    ImageLocation location() const {
        return _location;
    }

    //
    size_t size() const {
        return stride() * _height;
    }

    //
    virtual size_t stride() const {
        return _width * channels();
    }

    //
    size_t channels() const {
        return numChannels(_type);
    }

    //
    size_t width() const {
        return _width;
    }

    //
    size_t height() const {
        return _height;
    }

    //
    void update(const_iterator data);

    //
    void update(const GnashImage& from);
    
    virtual iterator begin() {
        return _data.get();
    }

    virtual const_iterator begin() const {
        return _data.get();
    }

    iterator end() {
        return begin() + size();
    }

    const_iterator end() const {
        return begin() + size();
    }

protected:

    //
    GnashImage(iterator data, size_t width, size_t height, ImageType type,
            ImageLocation location = GNASH_IMAGE_CPU);

    //
    //
    GnashImage(size_t width, size_t height, ImageType type,
               ImageLocation location = GNASH_IMAGE_CPU);

    const ImageType _type;

    const ImageLocation _location;

    const size_t _width;

    const size_t _height;

    container_type _data;

};

//
class DSOEXPORT ImageRGB : public GnashImage
{
public:

    ImageRGB(size_t width, size_t height);

    ImageRGB(iterator data, size_t width, size_t height)
        :
        GnashImage(data, width, height, TYPE_RGB)
    {}

    virtual ~ImageRGB();
};

//
class DSOEXPORT ImageRGBA : public GnashImage
{

public:

    ImageRGBA(size_t width, size_t height);

    ImageRGBA(iterator data, size_t width, size_t height)
        :
        GnashImage(data, width, height, TYPE_RGBA)
    {}
    
    ~ImageRGBA();

    //
    void setPixel(size_t x, size_t y, value_type r, value_type g, value_type b,
            value_type a);
};

class Input : boost::noncopyable
{
public:

    //
    Input(std::shared_ptr<IOChannel> in)
        :
        _inStream(in),
        _type(GNASH_IMAGE_INVALID)
    {}

    virtual ~Input() {}

    virtual void read() = 0;

    //
    virtual size_t getHeight() const = 0;

    //
    virtual size_t getWidth() const = 0;

    //
    virtual size_t getComponents() const = 0;

    //
    virtual void readScanline(unsigned char* rgbData) = 0;

    //
    ImageType imageType() { return _type; }

    DSOEXPORT static std::unique_ptr<ImageRGBA> readSWFJpeg3(
            std::shared_ptr<gnash::IOChannel> in);

    //
    DSOEXPORT static std::unique_ptr<GnashImage> readImageData(
            std::shared_ptr<gnash::IOChannel> in, FileType type);

protected:

    std::shared_ptr<IOChannel> _inStream;

    ImageType _type;

};

// Base class for writing image data.
class Output : boost::noncopyable
{

public:

    //
    Output(std::shared_ptr<IOChannel> out, size_t width, size_t height)
        :
        _width(width),
        _height(height),
        _outStream(out)
    {}

    virtual ~Output() {}
    
    //
    virtual void writeImageRGB(const unsigned char* rgbData) = 0;
    
    //
    virtual void writeImageRGBA(const unsigned char* /*rgbaData*/)
    {
        log_error(_("This image format does not support writing RGBA images"));
    }

    //
    DSOEXPORT static void writeImageData(FileType type,
            std::shared_ptr<gnash::IOChannel> out, const GnashImage& image,
            int quality);

protected:

    const size_t _width;

    const size_t _height;
    
    std::shared_ptr<IOChannel> _outStream;

};

//
inline GnashImage::iterator
scanline(GnashImage& im, size_t row)
{
    assert(row < im.height());
    return im.begin() + im.stride() * row;
}

//
inline GnashImage::const_iterator
scanline(const GnashImage& im, size_t row)
{
    assert(row < im.height());
    return im.begin() + im.stride() * row;
}

DSOEXPORT void mergeAlpha(ImageRGBA& im, GnashImage::const_iterator alphaData,
        const size_t bufferLength);

} // namespace image
} // namespace gnash

#endif