GIFImageDecoder.cpp [plain text]
#include "config.h"
#include "GIFImageDecoder.h"
#include "GIFImageReader.h"
namespace WebCore {
GIFImageDecoder::GIFImageDecoder()
: m_alreadyScannedThisDataForFrameCount(true)
, m_repetitionCount(cAnimationLoopOnce)
, m_readOffset(0)
{
}
GIFImageDecoder::~GIFImageDecoder()
{
}
void GIFImageDecoder::setData(SharedBuffer* data, bool allDataReceived)
{
if (failed())
return;
ImageDecoder::setData(data, allDataReceived);
m_alreadyScannedThisDataForFrameCount = false;
}
bool GIFImageDecoder::isSizeAvailable()
{
if (!ImageDecoder::isSizeAvailable())
decode(0, GIFSizeQuery);
return ImageDecoder::isSizeAvailable();
}
bool GIFImageDecoder::setSize(unsigned width, unsigned height)
{
if (!ImageDecoder::setSize(width, height))
return false;
prepareScaleDataIfNecessary();
return true;
}
size_t GIFImageDecoder::frameCount()
{
if (!m_alreadyScannedThisDataForFrameCount) {
GIFImageReader reader(0);
reader.read((const unsigned char*)m_data->data(), m_data->size(), GIFFrameCountQuery, static_cast<unsigned>(-1));
m_alreadyScannedThisDataForFrameCount = true;
m_frameBufferCache.resize(reader.images_count);
}
return m_frameBufferCache.size();
}
int GIFImageDecoder::repetitionCount() const
{
if (m_reader) {
const int repetitionCount = m_reader->loop_count;
if (repetitionCount != cLoopCountNotSeen)
m_repetitionCount = repetitionCount;
}
return m_repetitionCount;
}
RGBA32Buffer* GIFImageDecoder::frameBufferAtIndex(size_t index)
{
if (index >= frameCount())
return 0;
RGBA32Buffer& frame = m_frameBufferCache[index];
if (frame.status() != RGBA32Buffer::FrameComplete)
decode(index + 1, GIFFullQuery);
return &frame;
}
void GIFImageDecoder::clearFrameBufferCache(size_t clearBeforeFrame)
{
if (m_frameBufferCache.isEmpty())
return;
clearBeforeFrame = std::min(clearBeforeFrame, m_frameBufferCache.size() - 1);
const Vector<RGBA32Buffer>::iterator end(m_frameBufferCache.begin() + clearBeforeFrame);
Vector<RGBA32Buffer>::iterator i(end);
for (; (i != m_frameBufferCache.begin()) && ((i->status() == RGBA32Buffer::FrameEmpty) || (i->disposalMethod() == RGBA32Buffer::DisposeOverwritePrevious)); --i) {
if ((i->status() == RGBA32Buffer::FrameComplete) && (i != end))
i->clear();
}
for (Vector<RGBA32Buffer>::iterator j(m_frameBufferCache.begin()); j != i; ++j) {
ASSERT(j->status() != RGBA32Buffer::FramePartial);
if (j->status() != RGBA32Buffer::FrameEmpty)
j->clear();
}
}
void GIFImageDecoder::decodingHalted(unsigned bytesLeft)
{
m_readOffset = m_data->size() - bytesLeft;
}
bool GIFImageDecoder::haveDecodedRow(unsigned frameIndex, unsigned char* rowBuffer, unsigned char* rowEnd, unsigned rowNumber, unsigned repeatCount, bool writeTransparentPixels)
{
const GIFFrameReader* frameReader = m_reader->frame_reader;
int xBegin = upperBoundScaledX(frameReader->x_offset);
int yBegin = upperBoundScaledY(frameReader->y_offset + rowNumber);
int xEnd = lowerBoundScaledX(std::min(xBegin + static_cast<int>(rowEnd - rowBuffer), size().width()) - 1, xBegin + 1) + 1;
int yEnd = lowerBoundScaledY(std::min(yBegin + static_cast<int>(repeatCount), size().height()) - 1, yBegin + 1) + 1;
if (!rowBuffer || (xBegin < 0) || (yBegin < 0) || (xEnd <= xBegin) || (yEnd <= yBegin))
return true;
const unsigned char* colorMap;
unsigned colorMapSize;
if (frameReader->is_local_colormap_defined) {
colorMap = frameReader->local_colormap;
colorMapSize = (unsigned)frameReader->local_colormap_size;
} else {
colorMap = m_reader->global_colormap;
colorMapSize = m_reader->global_colormap_size;
}
if (!colorMap)
return true;
RGBA32Buffer& buffer = m_frameBufferCache[frameIndex];
if ((buffer.status() == RGBA32Buffer::FrameEmpty) && !initFrameBuffer(frameIndex))
return false;
for (int x = xBegin; x < xEnd; ++x) {
const unsigned char sourceValue = *(rowBuffer + (m_scaled ? m_scaledColumns[x] : x) - frameReader->x_offset);
if ((!frameReader->is_transparent || (sourceValue != frameReader->tpixel)) && (sourceValue < colorMapSize)) {
const size_t colorIndex = static_cast<size_t>(sourceValue) * 3;
buffer.setRGBA(x, yBegin, colorMap[colorIndex], colorMap[colorIndex + 1], colorMap[colorIndex + 2], 255);
} else {
m_currentBufferSawAlpha = true;
if (writeTransparentPixels)
buffer.setRGBA(x, yBegin, 0, 0, 0, 0);
}
}
if (repeatCount > 1)
buffer.copyRowNTimes(xBegin, xEnd, yBegin, yEnd);
return true;
}
bool GIFImageDecoder::frameComplete(unsigned frameIndex, unsigned frameDuration, RGBA32Buffer::FrameDisposalMethod disposalMethod)
{
RGBA32Buffer& buffer = m_frameBufferCache[frameIndex];
if ((buffer.status() == RGBA32Buffer::FrameEmpty) && !initFrameBuffer(frameIndex))
return false;
buffer.setStatus(RGBA32Buffer::FrameComplete);
buffer.setDuration(frameDuration);
buffer.setDisposalMethod(disposalMethod);
if (!m_currentBufferSawAlpha) {
if (buffer.rect().contains(IntRect(IntPoint(), scaledSize())))
buffer.setHasAlpha(false);
else if (frameIndex) {
const RGBA32Buffer* prevBuffer = &m_frameBufferCache[--frameIndex];
while (frameIndex && (prevBuffer->disposalMethod() == RGBA32Buffer::DisposeOverwritePrevious))
prevBuffer = &m_frameBufferCache[--frameIndex];
if ((prevBuffer->disposalMethod() == RGBA32Buffer::DisposeOverwriteBgcolor) && !prevBuffer->hasAlpha() && buffer.rect().contains(prevBuffer->rect()))
buffer.setHasAlpha(false);
}
}
return true;
}
void GIFImageDecoder::gifComplete()
{
if (m_reader)
m_repetitionCount = m_reader->loop_count;
m_reader.clear();
}
void GIFImageDecoder::decode(unsigned haltAtFrame, GIFQuery query)
{
if (failed())
return;
if (!m_reader)
m_reader.set(new GIFImageReader(this));
if (!m_reader->read((const unsigned char*)m_data->data() + m_readOffset, m_data->size() - m_readOffset, query, haltAtFrame) && isAllDataReceived())
setFailed();
if (failed())
m_reader.clear();
}
bool GIFImageDecoder::initFrameBuffer(unsigned frameIndex)
{
const GIFFrameReader* frameReader = m_reader->frame_reader;
IntRect frameRect(frameReader->x_offset, frameReader->y_offset, frameReader->width, frameReader->height);
if (frameRect.right() > size().width())
frameRect.setWidth(size().width() - frameReader->x_offset);
if (frameRect.bottom() > size().height())
frameRect.setHeight(size().height() - frameReader->y_offset);
RGBA32Buffer* const buffer = &m_frameBufferCache[frameIndex];
int left = upperBoundScaledX(frameRect.x());
int right = lowerBoundScaledX(frameRect.right(), left);
int top = upperBoundScaledY(frameRect.y());
int bottom = lowerBoundScaledY(frameRect.bottom(), top);
buffer->setRect(IntRect(left, top, right - left, bottom - top));
if (!frameIndex) {
if (!buffer->setSize(scaledSize().width(), scaledSize().height()))
return setFailed();
} else {
const RGBA32Buffer* prevBuffer = &m_frameBufferCache[--frameIndex];
RGBA32Buffer::FrameDisposalMethod prevMethod = prevBuffer->disposalMethod();
while (frameIndex && (prevMethod == RGBA32Buffer::DisposeOverwritePrevious)) {
prevBuffer = &m_frameBufferCache[--frameIndex];
prevMethod = prevBuffer->disposalMethod();
}
ASSERT(prevBuffer->status() == RGBA32Buffer::FrameComplete);
if ((prevMethod == RGBA32Buffer::DisposeNotSpecified) || (prevMethod == RGBA32Buffer::DisposeKeep)) {
buffer->copyBitmapData(*prevBuffer);
} else {
const IntRect& prevRect = prevBuffer->rect();
const IntSize& bufferSize = scaledSize();
if (!frameIndex || prevRect.contains(IntRect(IntPoint(), scaledSize()))) {
if (!buffer->setSize(bufferSize.width(), bufferSize.height()))
return setFailed();
} else {
buffer->copyBitmapData(*prevBuffer);
for (int y = prevRect.y(); y < prevRect.bottom(); ++y) {
for (int x = prevRect.x(); x < prevRect.right(); ++x)
buffer->setRGBA(x, y, 0, 0, 0, 0);
}
if ((prevRect.width() > 0) && (prevRect.height() > 0))
buffer->setHasAlpha(true);
}
}
}
buffer->setStatus(RGBA32Buffer::FramePartial);
m_currentBufferSawAlpha = false;
return true;
}
}