GIFImageDecoder.cpp [plain text]
#include "config.h"
#include "GIFImageDecoder.h"
#include "GIFImageReader.h"
#include <wtf/PassOwnPtr.h>
#if PLATFORM(CHROMIUM)
#include "TraceEvent.h"
#endif
namespace WebCore {
GIFImageDecoder::GIFImageDecoder(ImageSource::AlphaOption alphaOption,
ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
: ImageDecoder(alphaOption, gammaAndColorProfileOption)
, 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::isSizeAvailable() && size() == IntSize(width, height))
return true;
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);
for (int i = 0; i < reader.images_count; ++i)
m_frameBufferCache[i].setPremultiplyAlpha(m_premultiplyAlpha);
}
return m_frameBufferCache.size();
}
int GIFImageDecoder::repetitionCount() const
{
if (m_reader && (m_reader->loop_count != cLoopCountNotSeen))
m_repetitionCount = m_reader->loop_count;
return m_repetitionCount;
}
ImageFrame* GIFImageDecoder::frameBufferAtIndex(size_t index)
{
if (index >= frameCount())
return 0;
ImageFrame& frame = m_frameBufferCache[index];
if (frame.status() != ImageFrame::FrameComplete)
decode(index + 1, GIFFullQuery);
return &frame;
}
bool GIFImageDecoder::setFailed()
{
m_reader.clear();
return ImageDecoder::setFailed();
}
void GIFImageDecoder::clearFrameBufferCache(size_t clearBeforeFrame)
{
if (m_frameBufferCache.isEmpty())
return;
clearBeforeFrame = std::min(clearBeforeFrame, m_frameBufferCache.size() - 1);
const Vector<ImageFrame>::iterator end(m_frameBufferCache.begin() + clearBeforeFrame);
Vector<ImageFrame>::iterator i(end);
for (; (i != m_frameBufferCache.begin()) && ((i->status() == ImageFrame::FrameEmpty) || (i->disposalMethod() == ImageFrame::DisposeOverwritePrevious)); --i) {
if ((i->status() == ImageFrame::FrameComplete) && (i != end))
i->clearPixelData();
}
for (Vector<ImageFrame>::iterator j(m_frameBufferCache.begin()); j != i; ++j) {
ASSERT(j->status() != ImageFrame::FramePartial);
if (j->status() != ImageFrame::FrameEmpty)
j->clearPixelData();
}
}
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(static_cast<int>(frameReader->x_offset + (rowEnd - rowBuffer)), size().width()) - 1, xBegin + 1) + 1;
int yEnd = lowerBoundScaledY(std::min(static_cast<int>(frameReader->y_offset + rowNumber + 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;
ImageFrame& buffer = m_frameBufferCache[frameIndex];
if ((buffer.status() == ImageFrame::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, ImageFrame::FrameDisposalMethod disposalMethod)
{
ImageFrame& buffer = m_frameBufferCache[frameIndex];
if ((buffer.status() == ImageFrame::FrameEmpty) && !initFrameBuffer(frameIndex))
return false;
buffer.setStatus(ImageFrame::FrameComplete);
buffer.setDuration(frameDuration);
buffer.setDisposalMethod(disposalMethod);
if (!m_currentBufferSawAlpha) {
if (buffer.originalFrameRect().contains(IntRect(IntPoint(), scaledSize())))
buffer.setHasAlpha(false);
else if (frameIndex) {
const ImageFrame* prevBuffer = &m_frameBufferCache[--frameIndex];
while (frameIndex && (prevBuffer->disposalMethod() == ImageFrame::DisposeOverwritePrevious))
prevBuffer = &m_frameBufferCache[--frameIndex];
if ((prevBuffer->disposalMethod() == ImageFrame::DisposeOverwriteBgcolor) && !prevBuffer->hasAlpha() && buffer.originalFrameRect().contains(prevBuffer->originalFrameRect()))
buffer.setHasAlpha(false);
}
}
return true;
}
void GIFImageDecoder::gifComplete()
{
repetitionCount();
m_reader.clear();
}
void GIFImageDecoder::decode(unsigned haltAtFrame, GIFQuery query)
{
#if PLATFORM(CHROMIUM)
TRACE_EVENT("GIFImageDecoder::decode", this, 0);
#endif
if (failed())
return;
if (!m_reader)
m_reader = adoptPtr(new GIFImageReader(this));
if (!m_reader->read((const unsigned char*)m_data->data() + m_readOffset, m_data->size() - m_readOffset, query, haltAtFrame) && isAllDataReceived())
setFailed();
}
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.maxX() > size().width())
frameRect.setWidth(size().width() - frameReader->x_offset);
if (frameRect.maxY() > size().height())
frameRect.setHeight(size().height() - frameReader->y_offset);
ImageFrame* const buffer = &m_frameBufferCache[frameIndex];
int left = upperBoundScaledX(frameRect.x());
int right = lowerBoundScaledX(frameRect.maxX(), left);
int top = upperBoundScaledY(frameRect.y());
int bottom = lowerBoundScaledY(frameRect.maxY(), top);
buffer->setOriginalFrameRect(IntRect(left, top, right - left, bottom - top));
if (!frameIndex) {
if (!buffer->setSize(scaledSize().width(), scaledSize().height()))
return setFailed();
} else {
const ImageFrame* prevBuffer = &m_frameBufferCache[--frameIndex];
ImageFrame::FrameDisposalMethod prevMethod = prevBuffer->disposalMethod();
while (frameIndex && (prevMethod == ImageFrame::DisposeOverwritePrevious)) {
prevBuffer = &m_frameBufferCache[--frameIndex];
prevMethod = prevBuffer->disposalMethod();
}
ASSERT(prevBuffer->status() == ImageFrame::FrameComplete);
if ((prevMethod == ImageFrame::DisposeNotSpecified) || (prevMethod == ImageFrame::DisposeKeep)) {
if (!buffer->copyBitmapData(*prevBuffer))
return setFailed();
} else {
const IntRect& prevRect = prevBuffer->originalFrameRect();
const IntSize& bufferSize = scaledSize();
if (!frameIndex || prevRect.contains(IntRect(IntPoint(), scaledSize()))) {
if (!buffer->setSize(bufferSize.width(), bufferSize.height()))
return setFailed();
} else {
if (!buffer->copyBitmapData(*prevBuffer))
return setFailed();
for (int y = prevRect.y(); y < prevRect.maxY(); ++y) {
for (int x = prevRect.x(); x < prevRect.maxX(); ++x)
buffer->setRGBA(x, y, 0, 0, 0, 0);
}
if ((prevRect.width() > 0) && (prevRect.height() > 0))
buffer->setHasAlpha(true);
}
}
}
buffer->setStatus(ImageFrame::FramePartial);
m_currentBufferSawAlpha = false;
return true;
}
}