+2006-02-07 Dave Hyatt <hyatt@apple.com>
+
+ Rename ImageDecoderPlugin to ImageDecoder. Rename
+ GIFReader to GIFImageReder. Rename GIFDecoderPlugin to
+ GIFImageDecoder.
+
+ Reviewed by mjs
+
+ * WebCore.vcproj/WebCore/WebCore.vcproj:
+ * platform/cairo/ImageSourceCairo.cpp:
+ (WebCore::createDecoder):
+ (WebCore::ImageSource::setData):
+ * platform/image-decoders/ImageDecoder.h: Added.
+ (WebCore::ImageDecoder::~ImageDecoder):
+ * platform/image-decoders/ImageDecoderPlugin.h: Removed.
+ * platform/image-decoders/gif/GIFDecoderPlugin.cpp: Removed.
+ * platform/image-decoders/gif/GIFDecoderPlugin.h: Removed.
+ * platform/image-decoders/gif/GIFImageDecoder.cpp: Added.
+ (WebCore::GIFImageDecoderPrivate::GIFImageDecoderPrivate):
+ (WebCore::GIFImageDecoderPrivate::~GIFImageDecoderPrivate):
+ (WebCore::GIFImageDecoderPrivate::decode):
+ (WebCore::GIFImageDecoder::GIFImageDecoder):
+ (WebCore::GIFImageDecoder::~GIFImageDecoder):
+ (WebCore::GIFImageDecoder::setData):
+ (WebCore::GIFImageDecoder::isSizeAvailable):
+ (WebCore::GIFImageDecoder::size):
+ (WebCore::GIFImageDecoder::frameCount):
+ (WebCore::GIFImageDecoder::repetitionCount):
+ (WebCore::GIFImageDecoder::frameBufferAtIndex):
+ (WebCore::GIFImageDecoder::decode):
+ (WebCore::GIFImageDecoder::sizeNowAvailable):
+ (WebCore::GIFImageDecoder::decodingHalted):
+ (WebCore::GIFImageDecoder::haveDecodedRow):
+ (WebCore::GIFImageDecoder::frameComplete):
+ (WebCore::GIFImageDecoder::gifComplete):
+ * platform/image-decoders/gif/GIFImageDecoder.h: Added.
+ * platform/image-decoders/gif/GIFImageReader.cpp: Added.
+ (GIFImageReader::output_row):
+ (GIFImageReader::do_lzw):
+ (GIFImageReader::read):
+ * platform/image-decoders/gif/GIFImageReader.h: Added.
+ (GIFImageReader::GIFImageReader):
+ (GIFImageReader::~GIFImageReader):
+ * platform/image-decoders/gif/GIFReader.cpp: Removed.
+ * platform/image-decoders/gif/GIFReader.h: Removed.
+
2006-02-07 David Hyatt <hyatt@apple.com>
Rename ImageDecoder to ImageSource.
>\r
</File>\r
<File\r
- RelativePath="..\..\platform\ImageData.cpp"\r
- >\r
- </File>\r
- <File\r
- RelativePath="..\..\platform\ImageData.h"\r
- >\r
- </File>\r
- <File\r
- RelativePath="..\..\platform\ImageDecoder.h"\r
+ RelativePath="..\..\platform\ImageSource.h"\r
>\r
</File>\r
<File\r
>\r
</File>\r
<File\r
- RelativePath="..\..\platform\cairo\ImageDecoderCairo.cpp"\r
+ RelativePath="..\..\platform\cairo\ImageSourceCairo.cpp"\r
>\r
</File>\r
<Filter\r
Name="image-decoders"\r
>\r
<File\r
- RelativePath="..\..\platform\image-decoders\ImageDecoderPlugin.h"\r
+ RelativePath="..\..\platform\image-decoders\ImageDecoder.h"\r
>\r
</File>\r
<Filter\r
Name="gif"\r
>\r
<File\r
- RelativePath="..\..\platform\image-decoders\gif\GIFDecoderPlugin.cpp"\r
+ RelativePath="..\..\platform\image-decoders\gif\GIFImageDecoder.cpp"\r
>\r
</File>\r
<File\r
- RelativePath="..\..\platform\image-decoders\gif\GIFDecoderPlugin.h"\r
+ RelativePath="..\..\platform\image-decoders\gif\GIFImageDecoder.h"\r
>\r
</File>\r
<File\r
- RelativePath="..\..\platform\image-decoders\gif\GIFReader.cpp"\r
+ RelativePath="..\..\platform\image-decoders\gif\GIFImageReader.cpp"\r
>\r
</File>\r
<File\r
- RelativePath="..\..\platform\image-decoders\gif\GIFReader.h"\r
+ RelativePath="..\..\platform\image-decoders\gif\GIFImageReader.h"\r
>\r
</File>\r
</Filter>\r
#include "config.h"
#include <cairo.h>
-#include "GIFDecoderPlugin.h"
+#include "GIFImageDecoder.h"
#include "ImageSource.h"
#include "IntSize.h"
namespace WebCore {
-ImageDecoder* createDecoderPlugin(const ByteArray& data)
+ImageDecoder* createDecoder(const ByteArray& data)
{
// We need at least 4 bytes to figure out what kind of image we're dealing with.
int length = data.size();
// GIFs begin with GIF8(7 or 9).
if (strncmp(contents, "GIF8", 4) == 0)
- return new GIFDecoderPlugin();
+ return new GIFImageDecoder();
// Test for PNG.
if (uContents[0]==0x89 &&
// This method will examine the data and instantiate an instance of the appropriate decoder plugin.
// If insufficient bytes are available to determine the image type, no decoder plugin will be
// made.
- m_decoder = createDecoderPlugin(*data);
+ m_decoder = createDecoder(*data);
if (!m_decoder)
return;
m_decoder->setData(*data, allDataReceived);
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef IMAGE_DECODER_PLUGIN_H_
-#define IMAGE_DECODER_PLUGIN_H_
+#ifndef IMAGE_DECODER_H_
+#define IMAGE_DECODER_H_
#include "config.h"
#include "IntSize.h"
-#include "ImageDecoder.h"
+#include "ImageSource.h"
#include <kxmlcore/Vector.h>
#include "Array.h"
bool m_includeInNextFrame; // Whether or not the next buffer should be initially populated with our data.
};
-// The ImageDecoderPlugin class represents a base class for specific image format decoders
+// The ImageDecoder class represents a base class for specific image format decoders
// (e.g., GIF, JPG, PNG, ICO) to derive from. All decoders decode into RGBA32 format
// and the base class manages the RGBA32 frame cache.
-class ImageDecoderPlugin
+class ImageDecoder
{
public:
- virtual ~ImageDecoderPlugin() {}
+ virtual ~ImageDecoder() {}
// All specific decoder plugins must do something with the data they are given.
virtual void setData(const ByteArray& data, bool allDataReceived) { m_data = data; }
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "GIFDecoderPlugin.h"
-#include "GIFReader.h"
+#include "GIFImageDecoder.h"
+#include "GIFImageReader.h"
namespace WebCore {
-class GIFDecoderPluginPrivate
+class GIFImageDecoderPrivate
{
public:
- GIFDecoderPluginPrivate(GIFDecoderPlugin* plugin = 0)
- : m_reader(plugin)
+ GIFImageDecoderPrivate(GIFImageDecoder* decoder = 0)
+ : m_reader(decoder)
{
m_readOffset = 0;
}
- ~GIFDecoderPluginPrivate()
+ ~GIFImageDecoderPrivate()
{
m_reader.close();
}
bool decode(const ByteArray& data,
- GIFDecoderPlugin::GIFQuery query = GIFDecoderPlugin::GIFFullQuery,
+ GIFImageDecoder::GIFQuery query = GIFImageDecoder::GIFFullQuery,
unsigned int haltFrame = -1)
{
return m_reader.read((const unsigned char*)data.data() + m_readOffset, data.size() - m_readOffset,
unsigned duration() const { return m_reader.frame_reader->delay_time; }
private:
- GIFReader m_reader;
+ GIFImageReader m_reader;
unsigned m_readOffset;
};
-GIFDecoderPlugin::GIFDecoderPlugin()
+GIFImageDecoder::GIFImageDecoder()
: m_frameCountValid(true), m_sizeAvailable(false), m_failed(false), m_impl(0)
{}
-GIFDecoderPlugin::~GIFDecoderPlugin()
+GIFImageDecoder::~GIFImageDecoder()
{
delete m_impl;
}
// Take the data and store it.
-void GIFDecoderPlugin::setData(const ByteArray& data, bool allDataReceived)
+void GIFImageDecoder::setData(const ByteArray& data, bool allDataReceived)
{
if (m_failed)
return;
// Cache our new data.
- ImageDecoderPlugin::setData(data, allDataReceived);
+ ImageDecoder::setData(data, allDataReceived);
// Our frame count is now unknown.
m_frameCountValid = false;
// Create the GIF reader.
if (!m_impl && !m_failed)
- m_impl = new GIFDecoderPluginPrivate(this);
+ m_impl = new GIFImageDecoderPrivate(this);
}
// Whether or not the size information has been decoded yet.
-bool GIFDecoderPlugin::isSizeAvailable() const
+bool GIFImageDecoder::isSizeAvailable() const
{
// If we have pending data to decode, send it to the GIF reader now.
if (!m_sizeAvailable && m_impl) {
}
// Requests the size.
-IntSize GIFDecoderPlugin::size() const
+IntSize GIFImageDecoder::size() const
{
return m_size;
}
// The total number of frames for the image. Will scan the image data for the answer
// (without necessarily decoding all of the individual frames).
-int GIFDecoderPlugin::frameCount()
+int GIFImageDecoder::frameCount()
{
// If the decoder had an earlier error, we will just return what we had decoded
// so far.
// slowly. Might be interesting to try to clone our existing read session to preserve
// state, but for now we just crawl all the data. Note that this is no worse than what
// ImageIO does on Mac right now (it also crawls all the data again).
- GIFDecoderPluginPrivate reader;
+ GIFImageDecoderPrivate reader;
reader.decode(m_data, GIFFrameCountQuery);
m_frameCountValid = true;
m_frameBufferCache.resize(reader.frameCount());
}
// The number of repetitions to perform for an animation loop.
-int GIFDecoderPlugin::repetitionCount() const
+int GIFImageDecoder::repetitionCount() const
{
// We don't have to do any decoding to determine this, since the loop count was determined after
// the initial query for size.
return cAnimationNone;
}
-RGBA32Buffer GIFDecoderPlugin::frameBufferAtIndex(size_t index)
+RGBA32Buffer GIFImageDecoder::frameBufferAtIndex(size_t index)
{
if (index >= m_frameBufferCache.size())
return RGBA32Buffer();
}
// Feed data to the GIF reader.
-void GIFDecoderPlugin::decode(GIFQuery query, unsigned haltAtFrame) const
+void GIFImageDecoder::decode(GIFQuery query, unsigned haltAtFrame) const
{
if (m_failed)
return;
}
// Callbacks from the GIF reader.
-void GIFDecoderPlugin::sizeNowAvailable(unsigned width, unsigned height)
+void GIFImageDecoder::sizeNowAvailable(unsigned width, unsigned height)
{
m_size = IntSize(width, height);
m_sizeAvailable = true;
}
-void GIFDecoderPlugin::decodingHalted(unsigned bytesLeft)
+void GIFImageDecoder::decodingHalted(unsigned bytesLeft)
{
m_impl->setReadOffset(m_data.size() - bytesLeft);
}
-void GIFDecoderPlugin::haveDecodedRow(unsigned frameIndex,
+void GIFImageDecoder::haveDecodedRow(unsigned frameIndex,
unsigned char* rowBuffer, // Pointer to single scanline temporary buffer
unsigned char* rowEnd,
unsigned rowNumber, // The row index
}
}
-void GIFDecoderPlugin::frameComplete(unsigned frameIndex, unsigned frameDuration, bool includeInNextFrame)
+void GIFImageDecoder::frameComplete(unsigned frameIndex, unsigned frameDuration, bool includeInNextFrame)
{
RGBA32Buffer& buffer = m_frameBufferCache[frameIndex];
buffer.setIncludeInNextFrame(includeInNextFrame);
}
-void GIFDecoderPlugin::gifComplete()
+void GIFImageDecoder::gifComplete()
{
delete m_impl;
m_impl = 0;
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef GIF_DECODER_PLUGIN_H_
-#define GIF_DECODER_PLUGIN_H_
+#ifndef GIF_DECODER_H_
+#define GIF_DECODER_H_
-#include "ImageDecoderPlugin.h"
+#include "ImageDecoder.h"
namespace WebCore {
-class GIFDecoderPluginPrivate;
+class GIFImageDecoderPrivate;
// This class decodes the GIF image format.
-class GIFDecoderPlugin : public ImageDecoderPlugin
+class GIFImageDecoder : public ImageDecoder
{
public:
- GIFDecoderPlugin();
- ~GIFDecoderPlugin();
+ GIFImageDecoder();
+ ~GIFImageDecoder();
// Take the data and store it.
virtual void setData(const ByteArray& data, bool allDataReceived);
bool m_sizeAvailable : 1;
mutable bool m_failed : 1;
IntSize m_size;
- mutable GIFDecoderPluginPrivate* m_impl;
+ mutable GIFImageDecoderPrivate* m_impl;
};
}
#include <stddef.h>
#include <string.h>
#include "config.h"
-#include "GIFDecoderPlugin.h"
-#include "GIFReader.h"
+#include "GIFImageDecoder.h"
+#include "GIFImageReader.h"
-using WebCore::GIFDecoderPlugin;
+using WebCore::GIFImageDecoder;
// Define the Mozilla macro setup so that we can leave the macros alone.
#define PR_BEGIN_MACRO do {\r
* Note, the hold will never need to be bigger than 256 bytes to gather up in the hold,
* as each GIF block (except colormaps) can never be bigger than 256 bytes.
* Colormaps are directly copied in the resp. global_colormap or dynamically allocated local_colormap.
- * So a fixed buffer in GIFReader is good enough.
+ * So a fixed buffer in GIFImageReader is good enough.
* This buffer is only needed to copy left-over data from one GifWrite call to the next
*/
#define GETN(n,s) \
//******************************************************************************
// Send the data to the display front-end.
-void GIFReader::output_row()
+void GIFImageReader::output_row()
{
GIFFrameReader* gs = frame_reader;
//******************************************************************************
/* Perform Lempel-Ziv-Welch decoding */
-int GIFReader::do_lzw(const unsigned char *q)
+int GIFImageReader::do_lzw(const unsigned char *q)
{
GIFFrameReader* gs = frame_reader;
if (!gs)
* process data arriving from the stream for the gif decoder
*/
-bool GIFReader::read(const unsigned char *buf, unsigned len,
- GIFDecoderPlugin::GIFQuery query, unsigned haltAtFrame)
+bool GIFImageReader::read(const unsigned char *buf, unsigned len,
+ GIFImageDecoder::GIFQuery query, unsigned haltAtFrame)
{
if (!len)
return false;
const unsigned size = 3*global_colormap_size;
// Malloc the color map, but only if we're not just counting frames.
- if (query != GIFDecoderPlugin::GIFFrameCountQuery)
+ if (query != GIFImageDecoder::GIFFrameCountQuery)
global_colormap = new unsigned char[size];
if (len < size) {
case gif_control_extension:
{
- if (query != GIFDecoderPlugin::GIFFrameCountQuery) {
+ if (query != GIFImageDecoder::GIFFrameCountQuery) {
if (!frame_reader)
frame_reader = new GIFFrameReader();
}
}
}
- if (query == GIFDecoderPlugin::GIFSizeQuery || haltAtFrame == images_decoded) {
+ if (query == GIFImageDecoder::GIFSizeQuery || haltAtFrame == images_decoded) {
// The decoder needs to stop. Hand back the number of bytes we consumed from
// buffer minus 9 (the amount we consumed to read the header).
clientptr->decodingHalted(len + 9);
images_count = images_decoded + 1;
- if (query == GIFDecoderPlugin::GIFFullQuery && !frame_reader)
+ if (query == GIFImageDecoder::GIFFullQuery && !frame_reader)
frame_reader = new GIFFrameReader();
if (frame_reader) {
// Define ourselves as the clientPtr. Mozilla just hacked their C++ callback class into this old C decoder,
// so we will too.
namespace WebCore {
- class GIFDecoderPlugin;
+ class GIFImageDecoder;
}
/* gif2.h
}
};
-struct GIFReader {
- WebCore::GIFDecoderPlugin* clientptr;
+struct GIFImageReader {
+ WebCore::GIFImageDecoder* clientptr;
/* Parsing state machine */
gstate state; /* Current decoder master state */
unsigned bytes_to_consume; /* Number of bytes to accumulate */
GIFFrameReader* frame_reader;
- GIFReader(WebCore::GIFDecoderPlugin* client = 0) {
+ GIFImageReader(WebCore::GIFImageDecoder* client = 0) {
clientptr = client;
state = gif_type;
bytes_to_consume = 6;
count = 0;
}
- ~GIFReader() {
+ ~GIFImageReader() {
close();
}
}
bool read(const unsigned char * buf, unsigned int numbytes,
- WebCore::GIFDecoderPlugin::GIFQuery query = WebCore::GIFDecoderPlugin::GIFFullQuery, unsigned haltAtFrame = -1);
+ WebCore::GIFImageDecoder::GIFQuery query = WebCore::GIFImageDecoder::GIFFullQuery, unsigned haltAtFrame = -1);
private:
void output_row();
git://git.webkit.org / WebKit-https.git / commitdiff