JPEGImageDecoder RGB565 and downsample support and related Skia imagegenerator changes

third_party/WebKit/Source/platform/image-decoders/ImageFrame.h

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) Research In Motion Limited 2009-2010. 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
@@ skipping 48 matching lines @@
     enum AlphaBlendSource {
         // Blend non-opaque pixels atop the corresponding pixels in the
         // initial buffer state (i.e. any previous frame buffer after having
         // been properly disposed).
         BlendAtopPreviousFrame,
 
         // Blend non-opaque pixels against fully transparent (i.e. simply
         // overwrite the corresponding pixels).
         BlendAtopBgcolor,
     };
+
+    enum ColorType {
+        RGBA8888 = kRGBA_8888_SkColorType,
+        RGB565 = kRGB_565_SkColorType
+    };
+
     typedef uint32_t PixelData;
+    typedef uint16_t PixelData16;
 
     ImageFrame();
 
     // The assignment operator reads m_hasAlpha (inside setStatus()) before it
     // sets it (in setHasAlpha()).  This doesn't cause any problems, since the
     // setHasAlpha() call ensures all state is set correctly, but it means we
     // need to initialize m_hasAlpha to some value before calling the operator
     // lest any tools complain about using an uninitialized value.
     ImageFrame(const ImageFrame& other) : m_hasAlpha(false) { operator=(other); }
 
@@ skipping 22 matching lines @@
         ASSERT(endY <= height());
         const int rowBytes = (endX - startX) * sizeof(PixelData);
         const PixelData* const startAddr = getAddr(startX, startY);
         for (int destY = startY + 1; destY < endY; ++destY)
             memcpy(getAddr(startX, destY), startAddr, rowBytes);
     }
 
     // Allocates space for the pixel data.  Must be called before any pixels
     // are written.  Must only be called once.  Returns whether allocation
     // succeeded.
-    bool setSize(int newWidth, int newHeight);
+    // called from decoder before start writing pixel data

[scroggo_chromium, 2015/10/19 20:41:36]

I don't see how this says anything different from "Must be called before any
pixels are written", above.

[aleksandar.stojiljkovic, 2015/10/20 09:51:12]

Updating it, "Must only be called once" is not needed.
My intention was to document usage in current code - that it is called from
decoder.

+    bool setSize(int newWidth, int newHeight, ColorType bitmapType = RGBA8888);
 
     // Returns a caller-owned pointer to the underlying native image data.
     // (Actual use: This pointer will be owned by BitmapImage and freed in
     // FrameData::clear()).
     const SkBitmap& bitmap() const;
 
     bool hasAlpha() const;
     const IntRect& originalFrameRect() const { return m_originalFrameRect; }
     Status status() const { return m_status; }
     unsigned duration() const { return m_duration; }
@@ skipping 16 matching lines @@
     // The pixelsChanged flag needs to be set when the raw pixel data was directly modified
     // (e.g. through a pointer or setRGBA). The flag is usually set after a batch of changes was made.
     void setPixelsChanged(bool pixelsChanged) { m_pixelsChanged = pixelsChanged; }
     void setRequiredPreviousFrameIndex(size_t previousFrameIndex) { m_requiredPreviousFrameIndex = previousFrameIndex; }
 
     inline PixelData* getAddr(int x, int y)
     {
         return m_bitmap.getAddr32(x, y);
     }
 
+    template<class T>
+    inline T* getAddrT(int x, int y)
+    {
+        ASSERT_NOT_REACHED();
+    }
+
     inline void setRGBA(int x, int y, unsigned r, unsigned g, unsigned b, unsigned a)
     {
         setRGBA(getAddr(x, y), r, g, b, a);
     }
 
     inline void setRGBA(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a)
     {
         if (m_premultiplyAlpha)
             setRGBAPremultiply(dest, r, g, b, a);
         else
@@ skipping 12 matching lines @@
         }
 
         *dest = SkPackARGB32NoCheck(a, r, g, b);
     }
 
     static inline void setRGBARaw(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a)
     {
         *dest = SkPackARGB32NoCheck(a, r, g, b);
     }
 
+    static inline void setRGB565(PixelData16* dest, unsigned r, unsigned g, unsigned b)
+    {
+        *dest = SkDitherPack888ToRGB16(r, g, b);

[aleksandar.stojiljkovic, 2015/10/19 18:17:09]

Dither: Don't know if it makes sense to use ordered dithering here.
Floyd-Steinberg was set for all decoding (so this too).
For clarification, this path is executed when there is color profile (e.g. when
QCMS is in use and then output is set to rgb), so when output is RGB or CMYK.

This path is not executed when jpeg output is JCS_RGB565 - scanlines are
directly outputted to SkBitmap's rows.

+    }
+
     // Notifies the SkBitmap if any pixels changed and resets the flag.
     inline void notifyBitmapIfPixelsChanged()
     {
         if (m_pixelsChanged)
             m_bitmap.notifyPixelsChanged();
         m_pixelsChanged = false;
     }
 
 private:
     int width() const
@@ skipping 20 matching lines @@
     // True if the pixels changed, but the bitmap has not yet been notified.
     bool m_pixelsChanged;
 
     // The frame that must be decoded before this frame can be decoded.
     // WTF::kNotFound if this frame doesn't require any previous frame.
     // This is used by ImageDecoder::clearCacheExceptFrame(), and will never
     // be read for image formats that do not have multiple frames.
     size_t m_requiredPreviousFrameIndex;
 };
 
+template<>
+inline ImageFrame::PixelData* ImageFrame::getAddrT<ImageFrame::PixelData>(int x, int y)
+{
+    return m_bitmap.getAddr32(x, y);
+}
+
+template<>
+inline ImageFrame::PixelData16* ImageFrame::getAddrT<ImageFrame::PixelData16>(int x, int y)
+{
+    return m_bitmap.getAddr16(x, y);
+}
+
 } // namespace blink
 
 #endif