GIFImageDecoder.cpp [plain text]
#include "config.h"
#include "GIFImageDecoder.h"
#include "GIFImageReader.h"
#include <limits>
namespace WebCore {
GIFImageDecoder::GIFImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
: ScalableImageDecoder(alphaOption, gammaAndColorProfileOption)
{
}
GIFImageDecoder::~GIFImageDecoder() = default;
void GIFImageDecoder::setData(SharedBuffer& data, bool allDataReceived)
{
if (failed())
return;
ScalableImageDecoder::setData(data, allDataReceived);
if (m_reader)
m_reader->setData(&data);
}
bool GIFImageDecoder::setSize(const IntSize& size)
{
if (ScalableImageDecoder::encodedDataStatus() >= EncodedDataStatus::SizeAvailable && this->size() == size)
return true;
if (!ScalableImageDecoder::setSize(size))
return false;
prepareScaleDataIfNecessary();
return true;
}
size_t GIFImageDecoder::frameCount() const
{
const_cast<GIFImageDecoder*>(this)->decode(std::numeric_limits<unsigned>::max(), GIFFrameCountQuery, isAllDataReceived());
return m_frameBufferCache.size();
}
RepetitionCount GIFImageDecoder::repetitionCount() const
{
if (failed() || (m_reader && (!m_reader->imagesCount())))
m_repetitionCount = RepetitionCountOnce;
else if (m_reader && m_reader->loopCount() != cLoopCountNotSeen)
m_repetitionCount = m_reader->loopCount();
return m_repetitionCount;
}
size_t GIFImageDecoder::findFirstRequiredFrameToDecode(size_t frameIndex)
{
if (!frameIndex)
return 0;
for (size_t i = frameIndex; i > 0; --i) {
ImageFrame& frame = m_frameBufferCache[i - 1];
if (frame.disposalMethod() == ImageFrame::DisposalMethod::RestoreToPrevious)
continue;
if (frame.isComplete())
return i;
if (frame.disposalMethod() == ImageFrame::DisposalMethod::RestoreToBackground) {
const auto* frameContext = m_reader->frameContext(i - 1);
ASSERT(frameContext);
IntRect frameRect(frameContext->xOffset, frameContext->yOffset, frameContext->width, frameContext->height);
if (frameRect.contains({ { }, size() }))
return i;
}
}
return 0;
}
ImageFrame* GIFImageDecoder::frameBufferAtIndex(size_t index)
{
if (index >= frameCount())
return 0;
ImageFrame& frame = m_frameBufferCache[index];
if (!frame.isComplete()) {
for (auto i = findFirstRequiredFrameToDecode(index); i <= index; i++)
decode(i + 1, GIFFullQuery, isAllDataReceived());
}
return &frame;
}
bool GIFImageDecoder::setFailed()
{
m_reader = nullptr;
return ScalableImageDecoder::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->isInvalid() || (i->disposalMethod() == ImageFrame::DisposalMethod::RestoreToPrevious)); --i) {
if (i->isComplete() && (i != end))
i->clear();
}
for (Vector<ImageFrame>::iterator j(m_frameBufferCache.begin()); j != i; ++j) {
ASSERT(!j->isPartial());
if (!j->isInvalid())
j->clear();
}
}
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.isInvalid() && !initFrameBuffer(frameIndex)) || !buffer.hasBackingStore())
return false;
RGBA32* currentAddress = buffer.backingStore()->pixelAt(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.backingStore()->setPixel(currentAddress, colorMap[colorIndex], colorMap[colorIndex + 1], colorMap[colorIndex + 2], 255);
} else {
m_currentBufferSawAlpha = true;
if (writeTransparentPixels)
buffer.backingStore()->setPixel(currentAddress, 0, 0, 0, 0);
}
++currentAddress;
}
if (repeatCount > 1)
buffer.backingStore()->repeatFirstRow(IntRect(xBegin, yBegin, xEnd - xBegin , yEnd - yBegin));
return true;
}
bool GIFImageDecoder::frameComplete(unsigned frameIndex, unsigned frameDuration, ImageFrame::DisposalMethod disposalMethod)
{
ImageFrame& buffer = m_frameBufferCache[frameIndex];
if (buffer.isInvalid() && !initFrameBuffer(frameIndex))
return false;
buffer.setDecodingStatus(DecodingStatus::Complete);
buffer.setDuration(Seconds::fromMilliseconds(frameDuration));
buffer.setDisposalMethod(disposalMethod);
if (!m_currentBufferSawAlpha) {
IntRect rect = buffer.backingStore()->frameRect();
if (rect.contains(IntRect(IntPoint(), scaledSize())))
buffer.setHasAlpha(false);
else if (frameIndex) {
const ImageFrame* prevBuffer = &m_frameBufferCache[--frameIndex];
while (frameIndex && (prevBuffer->disposalMethod() == ImageFrame::DisposalMethod::RestoreToPrevious))
prevBuffer = &m_frameBufferCache[--frameIndex];
IntRect prevRect = prevBuffer->backingStore()->frameRect();
if ((prevBuffer->disposalMethod() == ImageFrame::DisposalMethod::RestoreToBackground) && !prevBuffer->hasAlpha() && rect.contains(prevRect))
buffer.setHasAlpha(false);
}
}
return true;
}
void GIFImageDecoder::gifComplete()
{
repetitionCount();
m_reader = nullptr;
}
void GIFImageDecoder::decode(unsigned haltAtFrame, GIFQuery query, bool allDataReceived)
{
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;
}
m_frameBufferCache.resize(m_reader->imagesCount());
if (query == GIFFrameCountQuery)
return;
if (!m_reader->decode(GIFFullQuery, haltAtFrame)) {
setFailed();
return;
}
if (allDataReceived && 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);
ImageFrame* const buffer = &m_frameBufferCache[frameIndex];
if (!frameIndex) {
if (!buffer->initialize(scaledSize(), m_premultiplyAlpha))
return setFailed();
} else {
const ImageFrame* prevBuffer = &m_frameBufferCache[--frameIndex];
ImageFrame::DisposalMethod prevMethod = prevBuffer->disposalMethod();
while (frameIndex && (prevMethod == ImageFrame::DisposalMethod::RestoreToPrevious)) {
prevBuffer = &m_frameBufferCache[--frameIndex];
prevMethod = prevBuffer->disposalMethod();
}
ASSERT(prevBuffer->isComplete());
if ((prevMethod == ImageFrame::DisposalMethod::Unspecified) || (prevMethod == ImageFrame::DisposalMethod::DoNotDispose)) {
if (!prevBuffer->backingStore() || !buffer->initialize(*prevBuffer->backingStore()))
return setFailed();
} else {
IntRect prevRect = prevBuffer->backingStore()->frameRect();
const IntSize& bufferSize = scaledSize();
if (!frameIndex || prevRect.contains(IntRect(IntPoint(), scaledSize()))) {
if (!buffer->initialize(bufferSize, m_premultiplyAlpha))
return setFailed();
} else {
if (!prevBuffer->backingStore() || !buffer->initialize(*prevBuffer->backingStore()))
return setFailed();
buffer->backingStore()->clearRect(prevRect);
buffer->setHasAlpha(true);
}
}
}
if (frameRect.maxX() > size().width())
frameRect.setWidth(size().width() - frameContext->xOffset);
if (frameRect.maxY() > size().height())
frameRect.setHeight(size().height() - frameContext->yOffset);
int left = upperBoundScaledX(frameRect.x());
int right = lowerBoundScaledX(frameRect.maxX(), left);
int top = upperBoundScaledY(frameRect.y());
int bottom = lowerBoundScaledY(frameRect.maxY(), top);
buffer->backingStore()->setFrameRect(IntRect(left, top, right - left, bottom - top));
buffer->setDecodingStatus(DecodingStatus::Partial);
m_currentBufferSawAlpha = false;
return true;
}
}