Remove image decoder down sampling

Source/core/platform/image-decoders/gif/GIFImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 49 matching lines @@
          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;
+    return ImageDecoder::setSize(width, height);

[Peter Kasting, 2013/05/20 23:04:24]

It seems like we no longer need to override setSize() at all in this class,
since the return at top here doesn't really change the outcome of anything.

[Noel Gordon, 2013/05/21 04:24:03]

Yes I had wondered about that, and I wanted confirmation that I could remove it
in the GIF case ...

 }
 
 size_t GIFImageDecoder::frameCount()
 {
     decode(std::numeric_limits<unsigned>::max(), GIFFrameCountQuery);
     return m_frameBufferCache.size();
 }
 
 int GIFImageDecoder::repetitionCount() const
 {
@@ skipping 112 matching lines @@
 
 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(frameIndex);
     // The pixel data and coordinates supplied to us are relative to the frame's
     // origin within the entire image size, i.e.
     // (frameContext->xOffset, frameContext->yOffset). There is no guarantee
     // that width == (size().width() - frameContext->xOffset), so
     // we must ensure we don't run off the end of either the source data or the
     // row's X-coordinates.
-    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;
+    int xBegin = frameContext->xOffset;
+    int yBegin = frameContext->yOffset + rowNumber;
+    int xEnd = std::min(static_cast<int>(frameContext->xOffset + width), size().width());
+    int yEnd = std::min(static_cast<int>(frameContext->yOffset + rowNumber + repeatCount), size().height());
     if (rowBuffer.isEmpty() || (xBegin < 0) || (yBegin < 0) || (xEnd <= xBegin) || (yEnd <= yBegin))
         return true;
 
     // Get the colormap.
     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;
 
     // Initialize the frame if necessary.
     ImageFrame& buffer = m_frameBufferCache[frameIndex];
     if ((buffer.status() == ImageFrame::FrameEmpty) && !initFrameBuffer(frameIndex))
         return false;
 
     ImageFrame::PixelData* currentAddress = buffer.getAddr(xBegin, yBegin);
     // Write one row's worth of data into the frame.  
     for (int x = xBegin; x < xEnd; ++x) {
-        const unsigned char sourceValue = rowBuffer[(m_scaled ? m_scaledColumns[x] : x) - frameContext->xOffset];
+        const unsigned char sourceValue = rowBuffer[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;
             // We may or may not need to write transparent pixels to the buffer.
             // If we're compositing against a previous image, it's wrong, and if
             // we're writing atop a cleared, fully transparent buffer, it's
             // unnecessary; but if we're decoding an interlaced gif and
             // displaying it "Haeberli"-style, we must write these for passes
@@ skipping 20 matching lines @@
     if ((buffer.status() == ImageFrame::FrameEmpty) && !initFrameBuffer(frameIndex))
         return false; // initFrameBuffer() has already called setFailed().
 
     buffer.setStatus(ImageFrame::FrameComplete);
     buffer.setDuration(frameDuration);
     buffer.setDisposalMethod(disposalMethod);
 
     if (!m_currentBufferSawAlpha) {
         // The whole frame was non-transparent, so it's possible that the entire
         // resulting buffer was non-transparent, and we can setHasAlpha(false).
-        if (buffer.originalFrameRect().contains(IntRect(IntPoint(), scaledSize())))
+        if (buffer.originalFrameRect().contains(IntRect(IntPoint(), size())))
             buffer.setHasAlpha(false);
         else if (frameIndex) {
             // Tricky case.  This frame does not have alpha only if everywhere
             // outside its rect doesn't have alpha.  To know whether this is
             // true, we check the start state of the frame -- if it doesn't have
             // alpha, we're safe.
             //
             // First skip over prior DisposeOverwritePrevious frames (since they
             // don't affect the start state of this frame) the same way we do in
             // initFrameBuffer().
@@ skipping 70 matching lines @@
     const GIFFrameContext* frameContext = m_reader->frameContext(frameIndex);
     IntRect frameRect(frameContext->xOffset, frameContext->yOffset, frameContext->width, frameContext->height);
 
     // Make sure the frameRect doesn't extend outside the buffer.
     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));
+    buffer->setOriginalFrameRect(frameRect);
     
     if (!frameIndex) {
         // This is the first frame, so we're not relying on any previous data.
-        if (!buffer->setSize(scaledSize().width(), scaledSize().height()))
+        if (!buffer->setSize(size().width(), size().height()))
             return setFailed();
     } else {
         // The starting state for this frame depends on the previous frame's
         // disposal method.
         //
         // Frames that use the DisposeOverwritePrevious method are effectively
         // no-ops in terms of changing the starting state of a frame compared to
         // the starting state of the previous frame, so skip over them.  (If the
         // first frame specifies this method, it will get treated like
         // DisposeOverwriteBgcolor below and reset to a completely empty image.)
         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)) {
             // Preserve the last frame as the starting state for this frame.
             if (!buffer->copyBitmapData(*prevBuffer))
                 return setFailed();
         } else {
             // We want to clear the previous frame to transparent, without
             // affecting pixels in the image outside of the frame.
             const IntRect& prevRect = prevBuffer->originalFrameRect();
-            const IntSize& bufferSize = scaledSize();
-            if (!frameIndex || prevRect.contains(IntRect(IntPoint(), scaledSize()))) {
+            const IntSize& bufferSize = size();
+            if (!frameIndex || prevRect.contains(IntRect(IntPoint(), size()))) {
                 // Clearing the first frame, or a frame the size of the whole
                 // image, results in a completely empty image.
                 if (!buffer->setSize(bufferSize.width(), bufferSize.height()))
                     return setFailed();
             } else {
               // Copy the whole previous buffer, then clear just its frame.
               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);
             }
         }
     }
 
     // Update our status to be partially complete.
     buffer->setStatus(ImageFrame::FramePartial);
 
     // Reset the alpha pixel tracker for this frame.
     m_currentBufferSawAlpha = false;
     return true;
 }
 
 } // namespace WebCore