GIFImageDecoder.cpp [plain text]
#include "config.h"
#include "GIFImageDecoder.h"
#include "GIFImageReader.h"
#include <limits>
namespace WebCore {
GIFImageDecoder::GIFImageDecoder(ImageSource::AlphaOption alphaOption,
ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
: ImageDecoder(alphaOption, gammaAndColorProfileOption)
, m_repetitionCount(cAnimationLoopOnce)
{
}
GIFImageDecoder::~GIFImageDecoder()
{
}
void GIFImageDecoder::setData(SharedBuffer& data, bool allDataReceived)
{
if (failed())
return;
ImageDecoder::setData(data, allDataReceived);
if (m_reader)
m_reader->setData(&data);
}
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()
{
decode(std::numeric_limits<unsigned>::max(), GIFFrameCountQuery);
return m_frameBufferCache.size();
}
int GIFImageDecoder::repetitionCount() const
{
if (failed() || (m_reader && (!m_reader->imagesCount())))
m_repetitionCount = cAnimationLoopOnce;
else if (m_reader && m_reader->loopCount() != cLoopCountNotSeen)
m_repetitionCount = m_reader->loopCount();
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 = nullptr;
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();
}
m_reader = nullptr;
}
bool GIFImageDecoder::haveDecodedRow(unsigned frameIndex, const Vector<unsigned char>& rowBuffer, size_t width, size_t rowNumber, unsigned repeatCount, bool writeTransparentPixels)
{
const GIFFrameContext* frameContext = m_reader->frameContext();
int xBegin = upperBoundScaledX(frameContext->xOffset);
int yBegin = upperBoundScaledY(frameContext->yOffset + rowNumber);
int xEnd = lowerBoundScaledX(std::min(static_cast<int>(frameContext->xOffset + width), size().width()) - 1, xBegin + 1) + 1;
int yEnd = lowerBoundScaledY(std::min(static_cast<int>(frameContext->yOffset + rowNumber + repeatCount), size().height()) - 1, yBegin + 1) + 1;
if (rowBuffer.isEmpty() || (xBegin < 0) || (yBegin < 0) || (xEnd <= xBegin) || (yEnd <= yBegin))
return true;
const unsigned char* colorMap;
unsigned colorMapSize;
if (frameContext->isLocalColormapDefined) {
colorMap = m_reader->localColormap(frameContext);
colorMapSize = m_reader->localColormapSize(frameContext);
} else {
colorMap = m_reader->globalColormap();
colorMapSize = m_reader->globalColormapSize();
}
if (!colorMap)
return true;
ImageFrame& buffer = m_frameBufferCache[frameIndex];
if (((buffer.status() == ImageFrame::FrameEmpty) && !initFrameBuffer(frameIndex)) || !buffer.hasPixelData())
return false;
ImageFrame::PixelData* currentAddress = buffer.getAddr(xBegin, yBegin);
for (int x = xBegin; x < xEnd; ++x) {
const unsigned char sourceValue = rowBuffer[(m_scaled ? m_scaledColumns[x] : x) - frameContext->xOffset];
if ((!frameContext->isTransparent || (sourceValue != frameContext->tpixel)) && (sourceValue < colorMapSize)) {
const size_t colorIndex = static_cast<size_t>(sourceValue) * 3;
buffer.setRGBA(currentAddress, colorMap[colorIndex], colorMap[colorIndex + 1], colorMap[colorIndex + 2], 255);
} else {
m_currentBufferSawAlpha = true;
if (writeTransparentPixels)
buffer.setRGBA(currentAddress, 0, 0, 0, 0);
}
++currentAddress;
}
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 = nullptr;
}
void GIFImageDecoder::decode(unsigned haltAtFrame, GIFQuery query)
{
if (failed())
return;
if (!m_reader) {
m_reader = std::make_unique<GIFImageReader>(this);
m_reader->setData(m_data.get());
}
if (query == GIFSizeQuery) {
if (!m_reader->decode(GIFSizeQuery, haltAtFrame))
setFailed();
return;
}
if (!m_reader->decode(GIFFrameCountQuery, haltAtFrame)) {
setFailed();
return;
}
const size_t oldSize = m_frameBufferCache.size();
m_frameBufferCache.resize(m_reader->imagesCount());
for (size_t i = oldSize; i < m_reader->imagesCount(); ++i)
m_frameBufferCache[i].setPremultiplyAlpha(m_premultiplyAlpha);
if (query == GIFFrameCountQuery)
return;
if (!m_reader->decode(GIFFullQuery, haltAtFrame)) {
setFailed();
return;
}
if (isAllDataReceived() && haltAtFrame >= m_frameBufferCache.size() && m_reader)
setFailed();
}
bool GIFImageDecoder::initFrameBuffer(unsigned frameIndex)
{
const GIFFrameContext* frameContext = m_reader->frameContext();
IntRect frameRect(frameContext->xOffset, frameContext->yOffset, frameContext->width, frameContext->height);
if (frameRect.maxX() > size().width())
frameRect.setWidth(size().width() - frameContext->xOffset);
if (frameRect.maxY() > size().height())
frameRect.setHeight(size().height() - frameContext->yOffset);
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();
buffer->zeroFillFrameRect(prevRect);
}
}
}
buffer->setStatus(ImageFrame::FramePartial);
m_currentBufferSawAlpha = false;
return true;
}
}