expo-juce 0.3.1 → 0.3.2

package/ios/juce_modules/juce_graphics/image_formats/jpglib/transupp.h

@@ -0,0 +1,135 @@
+/*
+ * transupp.h
+ *
+ * Copyright (C) 1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains declarations for image transformation routines and
+ * other utility code used by the jpegtran sample application.  These are
+ * NOT part of the core JPEG library.  But we keep these routines separate
+ * from jpegtran.c to ease the task of maintaining jpegtran-like programs
+ * that have other user interfaces.
+ *
+ * NOTE: all the routines declared here have very specific requirements
+ * about when they are to be executed during the reading and writing of the
+ * source and destination files.  See the comments in transupp.c, or see
+ * jpegtran.c for an example of correct usage.
+ */
+
+/* If you happen not to want the image transform support, disable it here */
+#ifndef TRANSFORMS_SUPPORTED
+#define TRANSFORMS_SUPPORTED 1		/* 0 disables transform code */
+#endif
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jtransform_request_workspace		jTrRequest
+#define jtransform_adjust_parameters		jTrAdjust
+#define jtransform_execute_transformation	jTrExec
+#define jcopy_markers_setup			jCMrkSetup
+#define jcopy_markers_execute			jCMrkExec
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/*
+ * Codes for supported types of image transformations.
+ */
+
+typedef enum {
+	JXFORM_NONE,		/* no transformation */
+	JXFORM_FLIP_H,		/* horizontal flip */
+	JXFORM_FLIP_V,		/* vertical flip */
+	JXFORM_TRANSPOSE,	/* transpose across UL-to-LR axis */
+	JXFORM_TRANSVERSE,	/* transpose across UR-to-LL axis */
+	JXFORM_ROT_90,		/* 90-degree clockwise rotation */
+	JXFORM_ROT_180,		/* 180-degree rotation */
+	JXFORM_ROT_270		/* 270-degree clockwise (or 90 ccw) */
+} JXFORM_CODE;
+
+/*
+ * Although rotating and flipping data expressed as DCT coefficients is not
+ * hard, there is an asymmetry in the JPEG format specification for images
+ * whose dimensions aren't multiples of the iMCU size.  The right and bottom
+ * image edges are padded out to the next iMCU boundary with junk data; but
+ * no padding is possible at the top and left edges.  If we were to flip
+ * the whole image including the pad data, then pad garbage would become
+ * visible at the top and/or left, and real pixels would disappear into the
+ * pad margins --- perhaps permanently, since encoders & decoders may not
+ * bother to preserve DCT blocks that appear to be completely outside the
+ * nominal image area.  So, we have to exclude any partial iMCUs from the
+ * basic transformation.
+ *
+ * Transpose is the only transformation that can handle partial iMCUs at the
+ * right and bottom edges completely cleanly.  flip_h can flip partial iMCUs
+ * at the bottom, but leaves any partial iMCUs at the right edge untouched.
+ * Similarly flip_v leaves any partial iMCUs at the bottom edge untouched.
+ * The other transforms are defined as combinations of these basic transforms
+ * and process edge blocks in a way that preserves the equivalence.
+ *
+ * The "trim" option causes untransformable partial iMCUs to be dropped;
+ * this is not strictly lossless, but it usually gives the best-looking
+ * result for odd-size images.  Note that when this option is active,
+ * the expected mathematical equivalences between the transforms may not hold.
+ * (For example, -rot 270 -trim trims only the bottom edge, but -rot 90 -trim
+ * followed by -rot 180 -trim trims both edges.)
+ *
+ * We also offer a "force to grayscale" option, which simply discards the
+ * chrominance channels of a YCbCr image.  This is lossless in the sense that
+ * the luminance channel is preserved exactly.  It's not the same kind of
+ * thing as the rotate/flip transformations, but it's convenient to handle it
+ * as part of this package, mainly because the transformation routines have to
+ * be aware of the option to know how many components to work on.
+ */
+
+typedef struct {
+  /* Options: set by caller */
+  JXFORM_CODE transform;	/* image transform operator */
+  boolean trim;			/* if TRUE, trim partial MCUs as needed */
+  boolean force_grayscale;	/* if TRUE, convert color image to grayscale */
+
+  /* Internal workspace: caller should not touch these */
+  int num_components;		/* # of components in workspace */
+  jvirt_barray_ptr * workspace_coef_arrays; /* workspace for transformations */
+} jpeg_transform_info;
+
+
+#if TRANSFORMS_SUPPORTED
+
+/* Request any required workspace */
+EXTERN(void) jtransform_request_workspace
+	JPP((j_decompress_ptr srcinfo, jpeg_transform_info *info));
+/* Adjust output image parameters */
+EXTERN(jvirt_barray_ptr *) jtransform_adjust_parameters
+	JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+	     jvirt_barray_ptr *src_coef_arrays,
+	     jpeg_transform_info *info));
+/* Execute the actual transformation, if any */
+EXTERN(void) jtransform_execute_transformation
+	JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+	     jvirt_barray_ptr *src_coef_arrays,
+	     jpeg_transform_info *info));
+
+#endif /* TRANSFORMS_SUPPORTED */
+
+
+/*
+ * Support for copying optional markers from source to destination file.
+ */
+
+typedef enum {
+	JCOPYOPT_NONE,		/* copy no optional markers */
+	JCOPYOPT_COMMENTS,	/* copy only comment (COM) markers */
+	JCOPYOPT_ALL		/* copy all optional markers */
+} JCOPY_OPTION;
+
+#define JCOPYOPT_DEFAULT  JCOPYOPT_COMMENTS	/* recommended default */
+
+/* Setup decompression object to save desired markers in memory */
+EXTERN(void) jcopy_markers_setup
+	JPP((j_decompress_ptr srcinfo, JCOPY_OPTION option));
+/* Copy markers saved in the given source object to the destination object */
+EXTERN(void) jcopy_markers_execute
+	JPP((j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
+	     JCOPY_OPTION option));

package/ios/juce_modules/juce_graphics/image_formats/juce_GIFLoader.cpp

@@ -0,0 +1,464 @@
+/*
+  ==============================================================================
+
+   This file is part of the JUCE framework.
+   Copyright (c) Raw Material Software Limited
+
+   JUCE is an open source framework subject to commercial or open source
+   licensing.
+
+   By downloading, installing, or using the JUCE framework, or combining the
+   JUCE framework with any other source code, object code, content or any other
+   copyrightable work, you agree to the terms of the JUCE End User Licence
+   Agreement, and all incorporated terms including the JUCE Privacy Policy and
+   the JUCE Website Terms of Service, as applicable, which will bind you. If you
+   do not agree to the terms of these agreements, we will not license the JUCE
+   framework to you, and you must discontinue the installation or download
+   process and cease use of the JUCE framework.
+
+   JUCE End User Licence Agreement: https://juce.com/legal/juce-8-licence/
+   JUCE Privacy Policy: https://juce.com/juce-privacy-policy
+   JUCE Website Terms of Service: https://juce.com/juce-website-terms-of-service/
+
+   Or:
+
+   You may also use this code under the terms of the AGPLv3:
+   https://www.gnu.org/licenses/agpl-3.0.en.html
+
+   THE JUCE FRAMEWORK IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL
+   WARRANTIES, WHETHER EXPRESSED OR IMPLIED, INCLUDING WARRANTY OF
+   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, ARE DISCLAIMED.
+
+  ==============================================================================
+*/
+
+namespace juce
+{
+
+#if (JUCE_MAC || JUCE_IOS) && USE_COREGRAPHICS_RENDERING && JUCE_USE_COREIMAGE_LOADER
+ Image juce_loadWithCoreImage (InputStream& input);
+#else
+
+JUCE_BEGIN_IGNORE_WARNINGS_MSVC (6385)
+
+//==============================================================================
+class GIFLoader
+{
+public:
+    GIFLoader (InputStream& in)
+        : input (in),
+          dataBlockIsZero (false), fresh (false), finished (false),
+          currentBit (0), lastBit (0), lastByteIndex (0),
+          codeSize (0), setCodeSize (0), maxCode (0), maxCodeSize (0),
+          firstcode (0), oldcode (0), clearCode (0), endCode (0)
+    {
+        int imageWidth, imageHeight;
+        if (! getSizeFromHeader (imageWidth, imageHeight))
+            return;
+
+        uint8 buf [16];
+        if (in.read (buf, 3) != 3)
+            return;
+
+        int numColours = 2 << (buf[0] & 7);
+        int transparent = -1;
+
+        if ((buf[0] & 0x80) != 0)
+            readPalette (numColours);
+
+        for (;;)
+        {
+            if (input.read (buf, 1) != 1 || buf[0] == ';')
+                break;
+
+            if (buf[0] == '!')
+            {
+                if (readExtension (transparent))
+                    continue;
+
+                break;
+            }
+
+            if (buf[0] != ',')
+                continue;
+
+            if (input.read (buf, 9) == 9)
+            {
+                imageWidth  = (int) ByteOrder::littleEndianShort (buf + 4);
+                imageHeight = (int) ByteOrder::littleEndianShort (buf + 6);
+
+                numColours = 2 << (buf[8] & 7);
+
+                if ((buf[8] & 0x80) != 0)
+                    if (! readPalette (numColours))
+                        break;
+
+                image = Image (transparent >= 0 ? Image::ARGB : Image::RGB,
+                               imageWidth, imageHeight, transparent >= 0);
+
+                image.getProperties()->set ("originalImageHadAlpha", transparent >= 0);
+
+                readImage ((buf[8] & 0x40) != 0, transparent);
+            }
+
+            break;
+        }
+    }
+
+    Image image;
+
+private:
+    InputStream& input;
+    uint8 buffer [260];
+    PixelARGB palette [256];
+    bool dataBlockIsZero, fresh, finished;
+    int currentBit, lastBit, lastByteIndex;
+    int codeSize, setCodeSize;
+    int maxCode, maxCodeSize;
+    int firstcode, oldcode;
+    int clearCode, endCode;
+    enum { maxGifCode = 1 << 12 };
+    int table [2] [maxGifCode];
+    int stack [2 * maxGifCode];
+    int* sp;
+
+    bool getSizeFromHeader (int& w, int& h)
+    {
+        // Add an extra byte for the zero terminator
+        char b[7]{};
+
+        if (input.read (b, 6) == 6
+             && (strncmp ("GIF87a", b, 6) == 0
+                  || strncmp ("GIF89a", b, 6) == 0))
+        {
+            if (input.read (b, 4) == 4)
+            {
+                w = (int) ByteOrder::littleEndianShort (b);
+                h = (int) ByteOrder::littleEndianShort (b + 2);
+                return w > 0 && h > 0;
+            }
+        }
+
+        return false;
+    }
+
+    bool readPalette (const int numCols)
+    {
+        for (int i = 0; i < numCols; ++i)
+        {
+            uint8 rgb[4];
+            input.read (rgb, 3);
+
+            palette[i].setARGB (0xff, rgb[0], rgb[1], rgb[2]);
+            palette[i].premultiply();
+        }
+
+        return true;
+    }
+
+    int readDataBlock (uint8* const dest)
+    {
+        uint8 n;
+        if (input.read (&n, 1) == 1)
+        {
+            dataBlockIsZero = (n == 0);
+
+            if (dataBlockIsZero || (input.read (dest, n) == n))
+                return n;
+        }
+
+        return -1;
+    }
+
+    int readExtension (int& transparent)
+    {
+        uint8 type;
+        if (input.read (&type, 1) != 1)
+            return false;
+
+        uint8 b [260];
+        int n = 0;
+
+        if (type == 0xf9)
+        {
+            n = readDataBlock (b);
+            if (n < 0)
+                return 1;
+
+            if ((b[0] & 1) != 0)
+                transparent = b[3];
+        }
+
+        do
+        {
+            n = readDataBlock (b);
+        }
+        while (n > 0);
+
+        return n >= 0;
+    }
+
+    void clearTable()
+    {
+        int i;
+        for (i = 0; i < clearCode; ++i)
+        {
+            table[0][i] = 0;
+            table[1][i] = i;
+        }
+
+        for (; i < maxGifCode; ++i)
+        {
+            table[0][i] = 0;
+            table[1][i] = 0;
+        }
+    }
+
+    void initialise (const int inputCodeSize)
+    {
+        setCodeSize = inputCodeSize;
+        codeSize = setCodeSize + 1;
+        clearCode = 1 << setCodeSize;
+        endCode = clearCode + 1;
+        maxCodeSize = 2 * clearCode;
+        maxCode = clearCode + 2;
+
+        getCode (0, true);
+
+        fresh = true;
+        clearTable();
+        sp = stack;
+    }
+
+    int readLZWByte()
+    {
+        if (fresh)
+        {
+            fresh = false;
+
+            for (;;)
+            {
+                firstcode = oldcode = getCode (codeSize, false);
+
+                if (firstcode != clearCode)
+                    return firstcode;
+            }
+        }
+
+        if (sp > stack)
+            return *--sp;
+
+        int code;
+
+        while ((code = getCode (codeSize, false)) >= 0)
+        {
+            if (code == clearCode)
+            {
+                clearTable();
+                codeSize = setCodeSize + 1;
+                maxCodeSize = 2 * clearCode;
+                maxCode = clearCode + 2;
+                sp = stack;
+                firstcode = oldcode = getCode (codeSize, false);
+                return firstcode;
+            }
+            else if (code == endCode)
+            {
+                if (dataBlockIsZero)
+                    return -2;
+
+                uint8 buf [260];
+                int n;
+
+                while ((n = readDataBlock (buf)) > 0)
+                {}
+
+                if (n != 0)
+                    return -2;
+            }
+
+            const int incode = code;
+
+            if (code >= maxCode)
+            {
+                *sp++ = firstcode;
+                code = oldcode;
+            }
+
+            while (code >= clearCode)
+            {
+                *sp++ = table[1][code];
+                if (code == table[0][code])
+                    return -2;
+
+                code = table[0][code];
+            }
+
+            *sp++ = firstcode = table[1][code];
+
+            if ((code = maxCode) < maxGifCode)
+            {
+                table[0][code] = oldcode;
+                table[1][code] = firstcode;
+                ++maxCode;
+
+                if (maxCode >= maxCodeSize && maxCodeSize < maxGifCode)
+                {
+                    maxCodeSize <<= 1;
+                    ++codeSize;
+                }
+            }
+
+            oldcode = incode;
+
+            if (sp > stack)
+                return *--sp;
+        }
+
+        return code;
+    }
+
+    int getCode (const int codeSize_, const bool shouldInitialise)
+    {
+        if (shouldInitialise)
+        {
+            currentBit = 0;
+            lastBit = 0;
+            finished = false;
+            return 0;
+        }
+
+        if ((currentBit + codeSize_) >= lastBit)
+        {
+            if (finished)
+                return -1;
+
+            buffer[0] = buffer [jmax (0, lastByteIndex - 2)];
+            buffer[1] = buffer [jmax (0, lastByteIndex - 1)];
+
+            const int n = readDataBlock (buffer + 2);
+
+            if (n == 0)
+                finished = true;
+
+            lastByteIndex = 2 + n;
+            currentBit = (currentBit - lastBit) + 16;
+            lastBit = (2 + n) * 8 ;
+        }
+
+        int result = 0;
+        int i = currentBit;
+
+        for (int j = 0; j < codeSize_; ++j)
+        {
+            result |= ((buffer[i >> 3] & (1 << (i & 7))) != 0) << j;
+            ++i;
+        }
+
+        currentBit += codeSize_;
+        return result;
+    }
+
+    bool readImage (const int interlace, const int transparent)
+    {
+        uint8 c;
+        if (input.read (&c, 1) != 1)
+            return false;
+
+        initialise (c);
+
+        if (transparent >= 0)
+            palette [transparent].setARGB (0, 0, 0, 0);
+
+        int xpos = 0, ypos = 0, yStep = 8, pass = 0;
+
+        const Image::BitmapData destData (image, Image::BitmapData::writeOnly);
+        uint8* p = destData.getPixelPointer (0, 0);
+        const bool hasAlpha = image.hasAlphaChannel();
+
+        for (;;)
+        {
+            const int index = readLZWByte();
+            if (index < 0)
+                break;
+
+            if (hasAlpha)
+                ((PixelARGB*) p)->set (palette [index]);
+            else
+                ((PixelRGB*)  p)->set (palette [index]);
+
+            p += destData.pixelStride;
+
+            if (++xpos == destData.width)
+            {
+                xpos = 0;
+
+                if (interlace)
+                {
+                    ypos += yStep;
+
+                    while (ypos >= destData.height)
+                    {
+                        switch (++pass)
+                        {
+                            case 1:     ypos = 4; yStep = 8; break;
+                            case 2:     ypos = 2; yStep = 4; break;
+                            case 3:     ypos = 1; yStep = 2; break;
+                            default:    return true;
+                        }
+                    }
+                }
+                else
+                {
+                    if (++ypos >= destData.height)
+                        break;
+                }
+
+                p = destData.getPixelPointer (xpos, ypos);
+            }
+        }
+
+        return true;
+    }
+
+    JUCE_DECLARE_NON_COPYABLE (GIFLoader)
+};
+
+JUCE_END_IGNORE_WARNINGS_MSVC
+
+#endif
+
+//==============================================================================
+GIFImageFormat::GIFImageFormat() {}
+GIFImageFormat::~GIFImageFormat() {}
+
+String GIFImageFormat::getFormatName()                  { return "GIF"; }
+bool GIFImageFormat::usesFileExtension (const File& f)  { return f.hasFileExtension ("gif"); }
+
+bool GIFImageFormat::canUnderstand (InputStream& in)
+{
+    char header [4];
+
+    return (in.read (header, sizeof (header)) == (int) sizeof (header))
+             && header[0] == 'G'
+             && header[1] == 'I'
+             && header[2] == 'F';
+}
+
+Image GIFImageFormat::decodeImage (InputStream& in)
+{
+   #if (JUCE_MAC || JUCE_IOS) && USE_COREGRAPHICS_RENDERING && JUCE_USE_COREIMAGE_LOADER
+    return juce_loadWithCoreImage (in);
+   #else
+    const std::unique_ptr<GIFLoader> loader (new GIFLoader (in));
+    return loader->image;
+   #endif
+}
+
+bool GIFImageFormat::writeImageToStream (const Image& /*sourceImage*/, OutputStream& /*destStream*/)
+{
+    jassertfalse; // writing isn't implemented for GIFs!
+    return false;
+}
+
+} // namespace juce