Add a GifEncoder/GifResourceEncoder.

8 files changed, 859 insertions, 816 deletions

diff --git a/third_party/gif_decoder/src/main/java/com/bumptech/glide/gifdecoder/GifDecoder.java b/third_party/gif_decoder/src/main/java/com/bumptech/glide/gifdecoder/GifDecoder.java
index fc57e522..4e82f84b 100644
--- a/third_party/gif_decoder/src/main/java/com/bumptech/glide/gifdecoder/GifDecoder.java
+++ b/third_party/gif_decoder/src/main/java/com/bumptech/glide/gifdecoder/GifDecoder.java
@@ -305,6 +305,10 @@ public class GifDecoder {
         mainScratch = null;
     }
 
+    public void setData(GifHeader header, byte[] data) {
+        setData(null, header, data);
+    }
+
     public void setData(String id, GifHeader header, byte[] data) {
         this.id = id;
         this.header = header;
diff --git a/third_party/gif_encoder/README.third_party b/third_party/gif_encoder/README.third_party
index 82547e95..10fc85b2 100644
--- a/third_party/gif_encoder/README.third_party
+++ b/third_party/gif_encoder/README.third_party
@@ -10,4 +10,4 @@ See also:
 http://members.ozemail.com.au/~dekker/NEUQUANT.HTML
 
 Local Modifications:
-None.
+Converted BufferedImage to Android's Bitmap class, split apart classes into individual files.
diff --git a/third_party/gif_encoder/build.gradle b/third_party/gif_encoder/build.gradle
new file mode 100644
index 00000000..d13e5e10
--- /dev/null
+++ b/third_party/gif_encoder/build.gradle
@@ -0,0 +1,12 @@
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 19
+    buildToolsVersion '19.1.0'
+
+    defaultConfig {
+        applicationId 'com.bumptech.glide.gifencod:'
+        minSdkVersion 10
+        targetSdkVersion 19
+    }
+}
diff --git a/third_party/gif_encoder/lint.xml b/third_party/gif_encoder/lint.xml
new file mode 100644
index 00000000..d9d6c9ff
--- /dev/null
+++ b/third_party/gif_encoder/lint.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<lint>
+    <issue id="AllowBackup" severity="ignore" />
+</lint>
diff --git a/third_party/gif_encoder/src/main/AndroidManifest.xml b/third_party/gif_encoder/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..77f17b14
--- /dev/null
+++ b/third_party/gif_encoder/src/main/AndroidManifest.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.bumptech.glide.gifencoder">
+  <application />
+</manifest>
diff --git a/third_party/gif_encoder/src/main/java/com/bumptech/glide/gifencoder/AnimatedGifEncoder.java b/third_party/gif_encoder/src/main/java/com/bumptech/glide/gifencoder/AnimatedGifEncoder.java
index 771daf88..a20e87ff 100644
--- a/third_party/gif_encoder/src/main/java/com/bumptech/glide/gifencoder/AnimatedGifEncoder.java
+++ b/third_party/gif_encoder/src/main/java/com/bumptech/glide/gifencoder/AnimatedGifEncoder.java
@@ -1,5 +1,8 @@
 package com.bumptech.glide.gifencoder;
 
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
 import android.graphics.Color;
 
 import java.io.BufferedOutputStream;
@@ -37,7 +40,7 @@ public class AnimatedGifEncoder {
 
     protected int height;
 
-    protected Color transparent = null; // transparent color if given
+    protected Integer transparent = null; // transparent color if given
 
     protected int transIndex; // transparent index in color table
 
@@ -49,7 +52,7 @@ public class AnimatedGifEncoder {
 
     protected OutputStream out;
 
-    protected BufferedImage image; // current frame
+    protected Bitmap image; // current frame
 
     protected byte[] pixels; // BGR byte array from frame
 
@@ -105,7 +108,6 @@ public class AnimatedGifEncoder {
      *
      * @param iter
      *          int number of iterations.
-     * @return
      */
     public void setRepeat(int iter) {
         if (iter >= 0) {
@@ -120,11 +122,11 @@ public class AnimatedGifEncoder {
      * color becomes the transparent color for that frame. May be set to null to
      * indicate no transparent color.
      *
-     * @param c
+     * @param color
      *          Color to be treated as transparent on display.
      */
-    public void setTransparent(Color c) {
-        transparent = c;
+    public void setTransparent(int color) {
+        transparent = color;
     }
 
     /**
@@ -138,7 +140,7 @@ public class AnimatedGifEncoder {
      *          BufferedImage containing frame to write.
      * @return true if successful.
      */
-    public boolean addFrame(BufferedImage im) {
+    public boolean addFrame(Bitmap im) {
         if ((im == null) || !started) {
             return false;
         }
@@ -334,12 +336,12 @@ public class AnimatedGifEncoder {
      * Returns index of palette color closest to c
      *
      */
-    protected int findClosest(Color c) {
+    protected int findClosest(int color) {
         if (colorTab == null)
             return -1;
-        int r = c.getRed();
-        int g = c.getGreen();
-        int b = c.getBlue();
+        int r = Color.red(color);
+        int g = Color.green(color);
+        int b = Color.blue(color);
         int minpos = 0;
         int dmin = 256 * 256 * 256;
         int len = colorTab.length;
@@ -364,15 +366,26 @@ public class AnimatedGifEncoder {
     protected void getImagePixels() {
         int w = image.getWidth();
         int h = image.getHeight();
-        int type = image.getType();
-        if ((w != width) || (h != height) || (type != BufferedImage.TYPE_3BYTE_BGR)) {
+
+        if ((w != width) || (h != height)) {
             // create new image with right size/format
-            BufferedImage temp = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
-            Graphics2D g = temp.createGraphics();
-            g.drawImage(image, 0, 0, null);
+            Bitmap temp = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+            Canvas canvas = new Canvas(temp);
+            canvas.drawBitmap(temp, 0, 0, null);
             image = temp;
         }
-        pixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
+        int[] pixelsInt = new int[w * h];
+        image.getPixels(pixelsInt, 0, w, 0, 0, w, h);
+
+        // The algorithm requires 3 bytes per pixel as RGB.
+        pixels = new byte[pixelsInt.length * 3];
+
+        int pixelsIndex = 0;
+        for (final int pixel : pixelsInt) {
+            pixels[pixelsIndex++] = (byte) (pixel & 0xFF);
+            pixels[pixelsIndex++] = (byte) ((pixel >> 8) & 0xFF);
+            pixels[pixelsIndex++] = (byte) ((pixel >> 16) & 0xFF);
+        }
     }
 
     /**
@@ -496,801 +509,3 @@ public class AnimatedGifEncoder {
         }
     }
 }
-
-/*
- * NeuQuant Neural-Net Quantization Algorithm
- * ------------------------------------------
- *
- * Copyright (c) 1994 Anthony Dekker
- *
- * NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994. See
- * "Kohonen neural networks for optimal colour quantization" in "Network:
- * Computation in Neural Systems" Vol. 5 (1994) pp 351-367. for a discussion of
- * the algorithm.
- *
- * Any party obtaining a copy of these files from the author, directly or
- * indirectly, is granted, free of charge, a full and unrestricted irrevocable,
- * world-wide, paid up, royalty-free, nonexclusive right and license to deal in
- * this software and documentation files (the "Software"), including without
- * limitation the rights to use, copy, modify, merge, publish, distribute,
- * sublicense, and/or sell copies of the Software, and to permit persons who
- * receive copies from any such party to do so, with the only requirement being
- * that this copyright notice remain intact.
- */
-
-// Ported to Java 12/00 K Weiner
-class NeuQuant {
-
-    protected static final int netsize = 256; /* number of colours used */
-
-    /* four primes near 500 - assume no image has a length so large */
-  /* that it is divisible by all four primes */
-    protected static final int prime1 = 499;
-
-    protected static final int prime2 = 491;
-
-    protected static final int prime3 = 487;
-
-    protected static final int prime4 = 503;
-
-    protected static final int minpicturebytes = (3 * prime4);
-
-  /* minimum size for input image */
-
-  /*
-   * Program Skeleton ---------------- [select samplefac in range 1..30] [read
-   * image from input file] pic = (unsigned char*) malloc(3*width*height);
-   * initnet(pic,3*width*height,samplefac); learn(); unbiasnet(); [write output
-   * image header, using writecolourmap(f)] inxbuild(); write output image using
-   * inxsearch(b,g,r)
-   */
-
-  /*
-   * Network Definitions -------------------
-   */
-
-    protected static final int maxnetpos = (netsize - 1);
-
-    protected static final int netbiasshift = 4; /* bias for colour values */
-
-    protected static final int ncycles = 100; /* no. of learning cycles */
-
-    /* defs for freq and bias */
-    protected static final int intbiasshift = 16; /* bias for fractions */
-
-    protected static final int intbias = (((int) 1) << intbiasshift);
-
-    protected static final int gammashift = 10; /* gamma = 1024 */
-
-    protected static final int gamma = (((int) 1) << gammashift);
-
-    protected static final int betashift = 10;
-
-    protected static final int beta = (intbias >> betashift); /* beta = 1/1024 */
-
-    protected static final int betagamma = (intbias << (gammashift - betashift));
-
-    /* defs for decreasing radius factor */
-    protected static final int initrad = (netsize >> 3); /*
-                                                         * for 256 cols, radius
-                                                         * starts
-                                                         */
-
-    protected static final int radiusbiasshift = 6; /* at 32.0 biased by 6 bits */
-
-    protected static final int radiusbias = (((int) 1) << radiusbiasshift);
-
-    protected static final int initradius = (initrad * radiusbias); /*
-                                                                   * and
-                                                                   * decreases
-                                                                   * by a
-                                                                   */
-
-    protected static final int radiusdec = 30; /* factor of 1/30 each cycle */
-
-    /* defs for decreasing alpha factor */
-    protected static final int alphabiasshift = 10; /* alpha starts at 1.0 */
-
-    protected static final int initalpha = (((int) 1) << alphabiasshift);
-
-    protected int alphadec; /* biased by 10 bits */
-
-    /* radbias and alpharadbias used for radpower calculation */
-    protected static final int radbiasshift = 8;
-
-    protected static final int radbias = (((int) 1) << radbiasshift);
-
-    protected static final int alpharadbshift = (alphabiasshift + radbiasshift);
-
-    protected static final int alpharadbias = (((int) 1) << alpharadbshift);
-
-  /*
-   * Types and Global Variables --------------------------
-   */
-
-    protected byte[] thepicture; /* the input image itself */
-
-    protected int lengthcount; /* lengthcount = H*W*3 */
-
-    protected int samplefac; /* sampling factor 1..30 */
-
-    // typedef int pixel[4]; /* BGRc */
-    protected int[][] network; /* the network itself - [netsize][4] */
-
-    protected int[] netindex = new int[256];
-
-  /* for network lookup - really 256 */
-
-    protected int[] bias = new int[netsize];
-
-    /* bias and freq arrays for learning */
-    protected int[] freq = new int[netsize];
-
-    protected int[] radpower = new int[initrad];
-
-  /* radpower for precomputation */
-
-    /*
-     * Initialise network in range (0,0,0) to (255,255,255) and set parameters
-     * -----------------------------------------------------------------------
-     */
-    public NeuQuant(byte[] thepic, int len, int sample) {
-
-        int i;
-        int[] p;
-
-        thepicture = thepic;
-        lengthcount = len;
-        samplefac = sample;
-
-        network = new int[netsize][];
-        for (i = 0; i < netsize; i++) {
-            network[i] = new int[4];
-            p = network[i];
-            p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
-            freq[i] = intbias / netsize; /* 1/netsize */
-            bias[i] = 0;
-        }
-    }
-
-    public byte[] colorMap() {
-        byte[] map = new byte[3 * netsize];
-        int[] index = new int[netsize];
-        for (int i = 0; i < netsize; i++)
-            index[network[i][3]] = i;
-        int k = 0;
-        for (int i = 0; i < netsize; i++) {
-            int j = index[i];
-            map[k++] = (byte) (network[j][0]);
-            map[k++] = (byte) (network[j][1]);
-            map[k++] = (byte) (network[j][2]);
-        }
-        return map;
-    }
-
-    /*
-     * Insertion sort of network and building of netindex[0..255] (to do after
-     * unbias)
-     * -------------------------------------------------------------------------------
-     */
-    public void inxbuild() {
-
-        int i, j, smallpos, smallval;
-        int[] p;
-        int[] q;
-        int previouscol, startpos;
-
-        previouscol = 0;
-        startpos = 0;
-        for (i = 0; i < netsize; i++) {
-            p = network[i];
-            smallpos = i;
-            smallval = p[1]; /* index on g */
-      /* find smallest in i..netsize-1 */
-            for (j = i + 1; j < netsize; j++) {
-                q = network[j];
-                if (q[1] < smallval) { /* index on g */
-                    smallpos = j;
-                    smallval = q[1]; /* index on g */
-                }
-            }
-            q = network[smallpos];
-      /* swap p (i) and q (smallpos) entries */
-            if (i != smallpos) {
-                j = q[0];
-                q[0] = p[0];
-                p[0] = j;
-                j = q[1];
-                q[1] = p[1];
-                p[1] = j;
-                j = q[2];
-                q[2] = p[2];
-                p[2] = j;
-                j = q[3];
-                q[3] = p[3];
-                p[3] = j;
-            }
-      /* smallval entry is now in position i */
-            if (smallval != previouscol) {
-                netindex[previouscol] = (startpos + i) >> 1;
-                for (j = previouscol + 1; j < smallval; j++)
-                    netindex[j] = i;
-                previouscol = smallval;
-                startpos = i;
-            }
-        }
-        netindex[previouscol] = (startpos + maxnetpos) >> 1;
-        for (j = previouscol + 1; j < 256; j++)
-            netindex[j] = maxnetpos; /* really 256 */
-    }
-
-    /*
-     * Main Learning Loop ------------------
-     */
-    public void learn() {
-
-        int i, j, b, g, r;
-        int radius, rad, alpha, step, delta, samplepixels;
-        byte[] p;
-        int pix, lim;
-
-        if (lengthcount < minpicturebytes)
-            samplefac = 1;
-        alphadec = 30 + ((samplefac - 1) / 3);
-        p = thepicture;
-        pix = 0;
-        lim = lengthcount;
-        samplepixels = lengthcount / (3 * samplefac);
-        delta = samplepixels / ncycles;
-        alpha = initalpha;
-        radius = initradius;
-
-        rad = radius >> radiusbiasshift;
-        if (rad <= 1)
-            rad = 0;
-        for (i = 0; i < rad; i++)
-            radpower[i] = alpha * (((rad * rad - i * i) * radbias) / (rad * rad));
-
-        // fprintf(stderr,"beginning 1D learning: initial radius=%d\n", rad);
-
-        if (lengthcount < minpicturebytes)
-            step = 3;
-        else if ((lengthcount % prime1) != 0)
-            step = 3 * prime1;
-        else {
-            if ((lengthcount % prime2) != 0)
-                step = 3 * prime2;
-            else {
-                if ((lengthcount % prime3) != 0)
-                    step = 3 * prime3;
-                else
-                    step = 3 * prime4;
-            }
-        }
-
-        i = 0;
-        while (i < samplepixels) {
-            b = (p[pix + 0] & 0xff) << netbiasshift;
-            g = (p[pix + 1] & 0xff) << netbiasshift;
-            r = (p[pix + 2] & 0xff) << netbiasshift;
-            j = contest(b, g, r);
-
-            altersingle(alpha, j, b, g, r);
-            if (rad != 0)
-                alterneigh(rad, j, b, g, r); /* alter neighbours */
-
-            pix += step;
-            if (pix >= lim)
-                pix -= lengthcount;
-
-            i++;
-            if (delta == 0)
-                delta = 1;
-            if (i % delta == 0) {
-                alpha -= alpha / alphadec;
-                radius -= radius / radiusdec;
-                rad = radius >> radiusbiasshift;
-                if (rad <= 1)
-                    rad = 0;
-                for (j = 0; j < rad; j++)
-                    radpower[j] = alpha * (((rad * rad - j * j) * radbias) / (rad * rad));
-            }
-        }
-        // fprintf(stderr,"finished 1D learning: final alpha=%f
-        // !\n",((float)alpha)/initalpha);
-    }
-
-    /*
-     * Search for BGR values 0..255 (after net is unbiased) and return colour
-     * index
-     * ----------------------------------------------------------------------------
-     */
-    public int map(int b, int g, int r) {
-
-        int i, j, dist, a, bestd;
-        int[] p;
-        int best;
-
-        bestd = 1000; /* biggest possible dist is 256*3 */
-        best = -1;
-        i = netindex[g]; /* index on g */
-        j = i - 1; /* start at netindex[g] and work outwards */
-
-        while ((i < netsize) || (j >= 0)) {
-            if (i < netsize) {
-                p = network[i];
-                dist = p[1] - g; /* inx key */
-                if (dist >= bestd)
-                    i = netsize; /* stop iter */
-                else {
-                    i++;
-                    if (dist < 0)
-                        dist = -dist;
-                    a = p[0] - b;
-                    if (a < 0)
-                        a = -a;
-                    dist += a;
-                    if (dist < bestd) {
-                        a = p[2] - r;
-                        if (a < 0)
-                            a = -a;
-                        dist += a;
-                        if (dist < bestd) {
-                            bestd = dist;
-                            best = p[3];
-                        }
-                    }
-                }
-            }
-            if (j >= 0) {
-                p = network[j];
-                dist = g - p[1]; /* inx key - reverse dif */
-                if (dist >= bestd)
-                    j = -1; /* stop iter */
-                else {
-                    j--;
-                    if (dist < 0)
-                        dist = -dist;
-                    a = p[0] - b;
-                    if (a < 0)
-                        a = -a;
-                    dist += a;
-                    if (dist < bestd) {
-                        a = p[2] - r;
-                        if (a < 0)
-                            a = -a;
-                        dist += a;
-                        if (dist < bestd) {
-                            bestd = dist;
-                            best = p[3];
-                        }
-                    }
-                }
-            }
-        }
-        return (best);
-    }
-
-    public byte[] process() {
-        learn();
-        unbiasnet();
-        inxbuild();
-        return colorMap();
-    }
-
-    /*
-     * Unbias network to give byte values 0..255 and record position i to prepare
-     * for sort
-     * -----------------------------------------------------------------------------------
-     */
-    public void unbiasnet() {
-
-        int i, j;
-
-        for (i = 0; i < netsize; i++) {
-            network[i][0] >>= netbiasshift;
-            network[i][1] >>= netbiasshift;
-            network[i][2] >>= netbiasshift;
-            network[i][3] = i; /* record colour no */
-        }
-    }
-
-    /*
-     * Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in
-     * radpower[|i-j|]
-     * ---------------------------------------------------------------------------------
-     */
-    protected void alterneigh(int rad, int i, int b, int g, int r) {
-
-        int j, k, lo, hi, a, m;
-        int[] p;
-
-        lo = i - rad;
-        if (lo < -1)
-            lo = -1;
-        hi = i + rad;
-        if (hi > netsize)
-            hi = netsize;
-
-        j = i + 1;
-        k = i - 1;
-        m = 1;
-        while ((j < hi) || (k > lo)) {
-            a = radpower[m++];
-            if (j < hi) {
-                p = network[j++];
-                try {
-                    p[0] -= (a * (p[0] - b)) / alpharadbias;
-                    p[1] -= (a * (p[1] - g)) / alpharadbias;
-                    p[2] -= (a * (p[2] - r)) / alpharadbias;
-                } catch (Exception e) {
-                } // prevents 1.3 miscompilation
-            }
-            if (k > lo) {
-                p = network[k--];
-                try {
-                    p[0] -= (a * (p[0] - b)) / alpharadbias;
-                    p[1] -= (a * (p[1] - g)) / alpharadbias;
-                    p[2] -= (a * (p[2] - r)) / alpharadbias;
-                } catch (Exception e) {
-                }
-            }
-        }
-    }
-
-    /*
-     * Move neuron i towards biased (b,g,r) by factor alpha
-     * ----------------------------------------------------
-     */
-    protected void altersingle(int alpha, int i, int b, int g, int r) {
-
-    /* alter hit neuron */
-        int[] n = network[i];
-        n[0] -= (alpha * (n[0] - b)) / initalpha;
-        n[1] -= (alpha * (n[1] - g)) / initalpha;
-        n[2] -= (alpha * (n[2] - r)) / initalpha;
-    }
-
-    /*
-     * Search for biased BGR values ----------------------------
-     */
-    protected int contest(int b, int g, int r) {
-
-    /* finds closest neuron (min dist) and updates freq */
-    /* finds best neuron (min dist-bias) and returns position */
-    /* for frequently chosen neurons, freq[i] is high and bias[i] is negative */
-    /* bias[i] = gamma*((1/netsize)-freq[i]) */
-
-        int i, dist, a, biasdist, betafreq;
-        int bestpos, bestbiaspos, bestd, bestbiasd;
-        int[] n;
-
-        bestd = ~(((int) 1) << 31);
-        bestbiasd = bestd;
-        bestpos = -1;
-        bestbiaspos = bestpos;
-
-        for (i = 0; i < netsize; i++) {
-            n = network[i];
-            dist = n[0] - b;
-            if (dist < 0)
-                dist = -dist;
-            a = n[1] - g;
-            if (a < 0)
-                a = -a;
-            dist += a;
-            a = n[2] - r;
-            if (a < 0)
-                a = -a;
-            dist += a;
-            if (dist < bestd) {
-                bestd = dist;
-                bestpos = i;
-            }
-            biasdist = dist - ((bias[i]) >> (intbiasshift - netbiasshift));
-            if (biasdist < bestbiasd) {
-                bestbiasd = biasdist;
-                bestbiaspos = i;
-            }
-            betafreq = (freq[i] >> betashift);
-            freq[i] -= betafreq;
-            bias[i] += (betafreq << gammashift);
-        }
-        freq[bestpos] += beta;
-        bias[bestpos] -= betagamma;
-        return (bestbiaspos);
-    }
-}
-
-// ==============================================================================
-// Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott.
-// K Weiner 12/00
-
-class LZWEncoder {
-
-    private static final int EOF = -1;
-
-    private int imgW, imgH;
-
-    private byte[] pixAry;
-
-    private int initCodeSize;
-
-    private int remaining;
-
-    private int curPixel;
-
-    // GIFCOMPR.C - GIF Image compression routines
-    //
-    // Lempel-Ziv compression based on 'compress'. GIF modifications by
-    // David Rowley (mgardi@watdcsu.waterloo.edu)
-
-    // General DEFINEs
-
-    static final int BITS = 12;
-
-    static final int HSIZE = 5003; // 80% occupancy
-
-    // GIF Image compression - modified 'compress'
-    //
-    // Based on: compress.c - File compression ala IEEE Computer, June 1984.
-    //
-    // By Authors: Spencer W. Thomas (decvax!harpo!utah-cs!utah-gr!thomas)
-    // Jim McKie (decvax!mcvax!jim)
-    // Steve Davies (decvax!vax135!petsd!peora!srd)
-    // Ken Turkowski (decvax!decwrl!turtlevax!ken)
-    // James A. Woods (decvax!ihnp4!ames!jaw)
-    // Joe Orost (decvax!vax135!petsd!joe)
-
-    int n_bits; // number of bits/code
-
-    int maxbits = BITS; // user settable max # bits/code
-
-    int maxcode; // maximum code, given n_bits
-
-    int maxmaxcode = 1 << BITS; // should NEVER generate this code
-
-    int[] htab = new int[HSIZE];
-
-    int[] codetab = new int[HSIZE];
-
-    int hsize = HSIZE; // for dynamic table sizing
-
-    int free_ent = 0; // first unused entry
-
-    // block compression parameters -- after all codes are used up,
-    // and compression rate changes, start over.
-    boolean clear_flg = false;
-
-    // Algorithm: use open addressing double hashing (no chaining) on the
-    // prefix code / next character combination. We do a variant of Knuth's
-    // algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
-    // secondary probe. Here, the modular division first probe is gives way
-    // to a faster exclusive-or manipulation. Also do block compression with
-    // an adaptive reset, whereby the code table is cleared when the compression
-    // ratio decreases, but after the table fills. The variable-length output
-    // codes are re-sized at this point, and a special CLEAR code is generated
-    // for the decompressor. Late addition: construct the table according to
-    // file size for noticeable speed improvement on small files. Please direct
-    // questions about this implementation to ames!jaw.
-
-    int g_init_bits;
-
-    int ClearCode;
-
-    int EOFCode;
-
-    // output
-    //
-    // Output the given code.
-    // Inputs:
-    // code: A n_bits-bit integer. If == -1, then EOF. This assumes
-    // that n_bits =< wordsize - 1.
-    // Outputs:
-    // Outputs code to the file.
-    // Assumptions:
-    // Chars are 8 bits long.
-    // Algorithm:
-    // Maintain a BITS character long buffer (so that 8 codes will
-    // fit in it exactly). Use the VAX insv instruction to insert each
-    // code in turn. When the buffer fills up empty it and start over.
-
-    int cur_accum = 0;
-
-    int cur_bits = 0;
-
-    int masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF,
-            0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
-
-    // Number of characters so far in this 'packet'
-    int a_count;
-
-    // Define the storage for the packet accumulator
-    byte[] accum = new byte[256];
-
-    // ----------------------------------------------------------------------------
-    LZWEncoder(int width, int height, byte[] pixels, int color_depth) {
-        imgW = width;
-        imgH = height;
-        pixAry = pixels;
-        initCodeSize = Math.max(2, color_depth);
-    }
-
-    // Add a character to the end of the current packet, and if it is 254
-    // characters, flush the packet to disk.
-    void char_out(byte c, OutputStream outs) throws IOException {
-        accum[a_count++] = c;
-        if (a_count >= 254)
-            flush_char(outs);
-    }
-
-    // Clear out the hash table
-
-    // table clear for block compress
-    void cl_block(OutputStream outs) throws IOException {
-        cl_hash(hsize);
-        free_ent = ClearCode + 2;
-        clear_flg = true;
-
-        output(ClearCode, outs);
-    }
-
-    // reset code table
-    void cl_hash(int hsize) {
-        for (int i = 0; i < hsize; ++i)
-            htab[i] = -1;
-    }
-
-    void compress(int init_bits, OutputStream outs) throws IOException {
-        int fcode;
-        int i /* = 0 */;
-        int c;
-        int ent;
-        int disp;
-        int hsize_reg;
-        int hshift;
-
-        // Set up the globals: g_init_bits - initial number of bits
-        g_init_bits = init_bits;
-
-        // Set up the necessary values
-        clear_flg = false;
-        n_bits = g_init_bits;
-        maxcode = MAXCODE(n_bits);
-
-        ClearCode = 1 << (init_bits - 1);
-        EOFCode = ClearCode + 1;
-        free_ent = ClearCode + 2;
-
-        a_count = 0; // clear packet
-
-        ent = nextPixel();
-
-        hshift = 0;
-        for (fcode = hsize; fcode < 65536; fcode *= 2)
-            ++hshift;
-        hshift = 8 - hshift; // set hash code range bound
-
-        hsize_reg = hsize;
-        cl_hash(hsize_reg); // clear hash table
-
-        output(ClearCode, outs);
-
-        outer_loop: while ((c = nextPixel()) != EOF) {
-            fcode = (c << maxbits) + ent;
-            i = (c << hshift) ^ ent; // xor hashing
-
-            if (htab[i] == fcode) {
-                ent = codetab[i];
-                continue;
-            } else if (htab[i] >= 0) // non-empty slot
-            {
-                disp = hsize_reg - i; // secondary hash (after G. Knott)
-                if (i == 0)
-                    disp = 1;
-                do {
-                    if ((i -= disp) < 0)
-                        i += hsize_reg;
-
-                    if (htab[i] == fcode) {
-                        ent = codetab[i];
-                        continue outer_loop;
-                    }
-                } while (htab[i] >= 0);
-            }
-            output(ent, outs);
-            ent = c;
-            if (free_ent < maxmaxcode) {
-                codetab[i] = free_ent++; // code -> hashtable
-                htab[i] = fcode;
-            } else
-                cl_block(outs);
-        }
-        // Put out the final code.
-        output(ent, outs);
-        output(EOFCode, outs);
-    }
-
-    // ----------------------------------------------------------------------------
-    void encode(OutputStream os) throws IOException {
-        os.write(initCodeSize); // write "initial code size" byte
-
-        remaining = imgW * imgH; // reset navigation variables
-        curPixel = 0;
-
-        compress(initCodeSize + 1, os); // compress and write the pixel data
-
-        os.write(0); // write block terminator
-    }
-
-    // Flush the packet to disk, and reset the accumulator
-    void flush_char(OutputStream outs) throws IOException {
-        if (a_count > 0) {
-            outs.write(a_count);
-            outs.write(accum, 0, a_count);
-            a_count = 0;
-        }
-    }
-
-    final int MAXCODE(int n_bits) {
-        return (1 << n_bits) - 1;
-    }
-
-    // ----------------------------------------------------------------------------
-    // Return the next pixel from the image
-    // ----------------------------------------------------------------------------
-    private int nextPixel() {
-        if (remaining == 0)
-            return EOF;
-
-        --remaining;
-
-        byte pix = pixAry[curPixel++];
-
-        return pix & 0xff;
-    }
-
-    void output(int code, OutputStream outs) throws IOException {
-        cur_accum &= masks[cur_bits];
-
-        if (cur_bits > 0)
-            cur_accum |= (code << cur_bits);
-        else
-            cur_accum = code;
-
-        cur_bits += n_bits;
-
-        while (cur_bits >= 8) {
-            char_out((byte) (cur_accum & 0xff), outs);
-            cur_accum >>= 8;
-            cur_bits -= 8;
-        }
-
-        // If the next entry is going to be too big for the code size,
-        // then increase it, if possible.
-        if (free_ent > maxcode || clear_flg) {
-            if (clear_flg) {
-                maxcode = MAXCODE(n_bits = g_init_bits);
-                clear_flg = false;
-            } else {
-                ++n_bits;
-                if (n_bits == maxbits)
-                    maxcode = maxmaxcode;
-                else
-                    maxcode = MAXCODE(n_bits);
-            }
-        }
-
-        if (code == EOFCode) {
-            // At EOF, write the rest of the buffer.
-            while (cur_bits > 0) {
-                char_out((byte) (cur_accum & 0xff), outs);
-                cur_accum >>= 8;
-                cur_bits -= 8;
-            }
-
-            flush_char(outs);
-        }
-    }
-}
-
diff --git a/third_party/gif_encoder/src/main/java/com/bumptech/glide/gifencoder/LZWEncoder.java b/third_party/gif_encoder/src/main/java/com/bumptech/glide/gifencoder/LZWEncoder.java
new file mode 100644
index 00000000..0d61ef48
--- /dev/null
+++ b/third_party/gif_encoder/src/main/java/com/bumptech/glide/gifencoder/LZWEncoder.java
@@ -0,0 +1,297 @@
+package com.bumptech.glide.gifencoder;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+// ==============================================================================
+// Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott.
+// K Weiner 12/00
+
+class LZWEncoder {
+
+    private static final int EOF = -1;
+
+    private int imgW, imgH;
+
+    private byte[] pixAry;
+
+    private int initCodeSize;
+
+    private int remaining;
+
+    private int curPixel;
+
+    // GIFCOMPR.C - GIF Image compression routines
+    //
+    // Lempel-Ziv compression based on 'compress'. GIF modifications by
+    // David Rowley (mgardi@watdcsu.waterloo.edu)
+
+    // General DEFINEs
+
+    static final int BITS = 12;
+
+    static final int HSIZE = 5003; // 80% occupancy
+
+    // GIF Image compression - modified 'compress'
+    //
+    // Based on: compress.c - File compression ala IEEE Computer, June 1984.
+    //
+    // By Authors: Spencer W. Thomas (decvax!harpo!utah-cs!utah-gr!thomas)
+    // Jim McKie (decvax!mcvax!jim)
+    // Steve Davies (decvax!vax135!petsd!peora!srd)
+    // Ken Turkowski (decvax!decwrl!turtlevax!ken)
+    // James A. Woods (decvax!ihnp4!ames!jaw)
+    // Joe Orost (decvax!vax135!petsd!joe)
+
+    int n_bits; // number of bits/code
+
+    int maxbits = BITS; // user settable max # bits/code
+
+    int maxcode; // maximum code, given n_bits
+
+    int maxmaxcode = 1 << BITS; // should NEVER generate this code
+
+    int[] htab = new int[HSIZE];
+
+    int[] codetab = new int[HSIZE];
+
+    int hsize = HSIZE; // for dynamic table sizing
+
+    int free_ent = 0; // first unused entry
+
+    // block compression parameters -- after all codes are used up,
+    // and compression rate changes, start over.
+    boolean clear_flg = false;
+
+    // Algorithm: use open addressing double hashing (no chaining) on the
+    // prefix code / next character combination. We do a variant of Knuth's
+    // algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
+    // secondary probe. Here, the modular division first probe is gives way
+    // to a faster exclusive-or manipulation. Also do block compression with
+    // an adaptive reset, whereby the code table is cleared when the compression
+    // ratio decreases, but after the table fills. The variable-length output
+    // codes are re-sized at this point, and a special CLEAR code is generated
+    // for the decompressor. Late addition: construct the table according to
+    // file size for noticeable speed improvement on small files. Please direct
+    // questions about this implementation to ames!jaw.
+
+    int g_init_bits;
+
+    int ClearCode;
+
+    int EOFCode;
+
+    // output
+    //
+    // Output the given code.
+    // Inputs:
+    // code: A n_bits-bit integer. If == -1, then EOF. This assumes
+    // that n_bits =< wordsize - 1.
+    // Outputs:
+    // Outputs code to the file.
+    // Assumptions:
+    // Chars are 8 bits long.
+    // Algorithm:
+    // Maintain a BITS character long buffer (so that 8 codes will
+    // fit in it exactly). Use the VAX insv instruction to insert each
+    // code in turn. When the buffer fills up empty it and start over.
+
+    int cur_accum = 0;
+
+    int cur_bits = 0;
+
+    int masks[] = {0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF,
+            0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF};
+
+    // Number of characters so far in this 'packet'
+    int a_count;
+
+    // Define the storage for the packet accumulator
+    byte[] accum = new byte[256];
+
+    // ----------------------------------------------------------------------------
+    LZWEncoder(int width, int height, byte[] pixels, int color_depth) {
+        imgW = width;
+        imgH = height;
+        pixAry = pixels;
+        initCodeSize = Math.max(2, color_depth);
+    }
+
+    // Add a character to the end of the current packet, and if it is 254
+    // characters, flush the packet to disk.
+    void char_out(byte c, OutputStream outs) throws IOException {
+        accum[a_count++] = c;
+        if (a_count >= 254)
+            flush_char(outs);
+    }
+
+    // Clear out the hash table
+
+    // table clear for block compress
+    void cl_block(OutputStream outs) throws IOException {
+        cl_hash(hsize);
+        free_ent = ClearCode + 2;
+        clear_flg = true;
+
+        output(ClearCode, outs);
+    }
+
+    // reset code table
+    void cl_hash(int hsize) {
+        for (int i = 0; i < hsize; ++i)
+            htab[i] = -1;
+    }
+
+    void compress(int init_bits, OutputStream outs) throws IOException {
+        int fcode;
+        int i /* = 0 */;
+        int c;
+        int ent;
+        int disp;
+        int hsize_reg;
+        int hshift;
+
+        // Set up the globals: g_init_bits - initial number of bits
+        g_init_bits = init_bits;
+
+        // Set up the necessary values
+        clear_flg = false;
+        n_bits = g_init_bits;
+        maxcode = MAXCODE(n_bits);
+
+        ClearCode = 1 << (init_bits - 1);
+        EOFCode = ClearCode + 1;
+        free_ent = ClearCode + 2;
+
+        a_count = 0; // clear packet
+
+        ent = nextPixel();
+
+        hshift = 0;
+        for (fcode = hsize; fcode < 65536; fcode *= 2)
+            ++hshift;
+        hshift = 8 - hshift; // set hash code range bound
+
+        hsize_reg = hsize;
+        cl_hash(hsize_reg); // clear hash table
+
+        output(ClearCode, outs);
+
+        outer_loop:
+        while ((c = nextPixel()) != EOF) {
+            fcode = (c << maxbits) + ent;
+            i = (c << hshift) ^ ent; // xor hashing
+
+            if (htab[i] == fcode) {
+                ent = codetab[i];
+                continue;
+            } else if (htab[i] >= 0) // non-empty slot
+            {
+                disp = hsize_reg - i; // secondary hash (after G. Knott)
+                if (i == 0)
+                    disp = 1;
+                do {
+                    if ((i -= disp) < 0)
+                        i += hsize_reg;
+
+                    if (htab[i] == fcode) {
+                        ent = codetab[i];
+                        continue outer_loop;
+                    }
+                } while (htab[i] >= 0);
+            }
+            output(ent, outs);
+            ent = c;
+            if (free_ent < maxmaxcode) {
+                codetab[i] = free_ent++; // code -> hashtable
+                htab[i] = fcode;
+            } else
+                cl_block(outs);
+        }
+        // Put out the final code.
+        output(ent, outs);
+        output(EOFCode, outs);
+    }
+
+    // ----------------------------------------------------------------------------
+    void encode(OutputStream os) throws IOException {
+        os.write(initCodeSize); // write "initial code size" byte
+
+        remaining = imgW * imgH; // reset navigation variables
+        curPixel = 0;
+
+        compress(initCodeSize + 1, os); // compress and write the pixel data
+
+        os.write(0); // write block terminator
+    }
+
+    // Flush the packet to disk, and reset the accumulator
+    void flush_char(OutputStream outs) throws IOException {
+        if (a_count > 0) {
+            outs.write(a_count);
+            outs.write(accum, 0, a_count);
+            a_count = 0;
+        }
+    }
+
+    final int MAXCODE(int n_bits) {
+        return (1 << n_bits) - 1;
+    }
+
+    // ----------------------------------------------------------------------------
+    // Return the next pixel from the image
+    // ----------------------------------------------------------------------------
+    private int nextPixel() {
+        if (remaining == 0)
+            return EOF;
+
+        --remaining;
+
+        byte pix = pixAry[curPixel++];
+
+        return pix & 0xff;
+    }
+
+    void output(int code, OutputStream outs) throws IOException {
+        cur_accum &= masks[cur_bits];
+
+        if (cur_bits > 0)
+            cur_accum |= (code << cur_bits);
+        else
+            cur_accum = code;
+
+        cur_bits += n_bits;
+
+        while (cur_bits >= 8) {
+            char_out((byte) (cur_accum & 0xff), outs);
+            cur_accum >>= 8;
+            cur_bits -= 8;
+        }
+
+        // If the next entry is going to be too big for the code size,
+        // then increase it, if possible.
+        if (free_ent > maxcode || clear_flg) {
+            if (clear_flg) {
+                maxcode = MAXCODE(n_bits = g_init_bits);
+                clear_flg = false;
+            } else {
+                ++n_bits;
+                if (n_bits == maxbits)
+                    maxcode = maxmaxcode;
+                else
+                    maxcode = MAXCODE(n_bits);
+            }
+        }
+
+        if (code == EOFCode) {
+            // At EOF, write the rest of the buffer.
+            while (cur_bits > 0) {
+                char_out((byte) (cur_accum & 0xff), outs);
+                cur_accum >>= 8;
+                cur_bits -= 8;
+            }
+
+            flush_char(outs);
+        }
+    }
+}
diff --git a/third_party/gif_encoder/src/main/java/com/bumptech/glide/gifencoder/NeuQuant.java b/third_party/gif_encoder/src/main/java/com/bumptech/glide/gifencoder/NeuQuant.java
new file mode 100644
index 00000000..4ae1a1c6
--- /dev/null
+++ b/third_party/gif_encoder/src/main/java/com/bumptech/glide/gifencoder/NeuQuant.java
@@ -0,0 +1,506 @@
+package com.bumptech.glide.gifencoder;
+
+/*
+ * NeuQuant Neural-Net Quantization Algorithm
+ * ------------------------------------------
+ *
+ * Copyright (c) 1994 Anthony Dekker
+ *
+ * NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994. See
+ * "Kohonen neural networks for optimal colour quantization" in "Network:
+ * Computation in Neural Systems" Vol. 5 (1994) pp 351-367. for a discussion of
+ * the algorithm.
+ *
+ * Any party obtaining a copy of these files from the author, directly or
+ * indirectly, is granted, free of charge, a full and unrestricted irrevocable,
+ * world-wide, paid up, royalty-free, nonexclusive right and license to deal in
+ * this software and documentation files (the "Software"), including without
+ * limitation the rights to use, copy, modify, merge, publish, distribute,
+ * sublicense, and/or sell copies of the Software, and to permit persons who
+ * receive copies from any such party to do so, with the only requirement being
+ * that this copyright notice remain intact.
+ */
+
+// Ported to Java 12/00 K Weiner
+class NeuQuant {
+
+    protected static final int netsize = 256; /* number of colours used */
+
+    /* four primes near 500 - assume no image has a length so large */
+  /* that it is divisible by all four primes */
+    protected static final int prime1 = 499;
+
+    protected static final int prime2 = 491;
+
+    protected static final int prime3 = 487;
+
+    protected static final int prime4 = 503;
+
+    protected static final int minpicturebytes = (3 * prime4);
+
+  /* minimum size for input image */
+
+  /*
+   * Program Skeleton ---------------- [select samplefac in range 1..30] [read
+   * image from input file] pic = (unsigned char*) malloc(3*width*height);
+   * initnet(pic,3*width*height,samplefac); learn(); unbiasnet(); [write output
+   * image header, using writecolourmap(f)] inxbuild(); write output image using
+   * inxsearch(b,g,r)
+   */
+
+  /*
+   * Network Definitions -------------------
+   */
+
+    protected static final int maxnetpos = (netsize - 1);
+
+    protected static final int netbiasshift = 4; /* bias for colour values */
+
+    protected static final int ncycles = 100; /* no. of learning cycles */
+
+    /* defs for freq and bias */
+    protected static final int intbiasshift = 16; /* bias for fractions */
+
+    protected static final int intbias = (((int) 1) << intbiasshift);
+
+    protected static final int gammashift = 10; /* gamma = 1024 */
+
+    protected static final int gamma = (((int) 1) << gammashift);
+
+    protected static final int betashift = 10;
+
+    protected static final int beta = (intbias >> betashift); /* beta = 1/1024 */
+
+    protected static final int betagamma = (intbias << (gammashift - betashift));
+
+    /* defs for decreasing radius factor */
+    protected static final int initrad = (netsize >> 3); /*
+                                                         * for 256 cols, radius
+                                                         * starts
+                                                         */
+
+    protected static final int radiusbiasshift = 6; /* at 32.0 biased by 6 bits */
+
+    protected static final int radiusbias = (((int) 1) << radiusbiasshift);
+
+    protected static final int initradius = (initrad * radiusbias); /*
+                                                                   * and
+                                                                   * decreases
+                                                                   * by a
+                                                                   */
+
+    protected static final int radiusdec = 30; /* factor of 1/30 each cycle */
+
+    /* defs for decreasing alpha factor */
+    protected static final int alphabiasshift = 10; /* alpha starts at 1.0 */
+
+    protected static final int initalpha = (((int) 1) << alphabiasshift);
+
+    protected int alphadec; /* biased by 10 bits */
+
+    /* radbias and alpharadbias used for radpower calculation */
+    protected static final int radbiasshift = 8;
+
+    protected static final int radbias = (((int) 1) << radbiasshift);
+
+    protected static final int alpharadbshift = (alphabiasshift + radbiasshift);
+
+    protected static final int alpharadbias = (((int) 1) << alpharadbshift);
+
+  /*
+   * Types and Global Variables --------------------------
+   */
+
+    protected byte[] thepicture; /* the input image itself */
+
+    protected int lengthcount; /* lengthcount = H*W*3 */
+
+    protected int samplefac; /* sampling factor 1..30 */
+
+    // typedef int pixel[4]; /* BGRc */
+    protected int[][] network; /* the network itself - [netsize][4] */
+
+    protected int[] netindex = new int[256];
+
+  /* for network lookup - really 256 */
+
+    protected int[] bias = new int[netsize];
+
+    /* bias and freq arrays for learning */
+    protected int[] freq = new int[netsize];
+
+    protected int[] radpower = new int[initrad];
+
+  /* radpower for precomputation */
+
+    /*
+     * Initialise network in range (0,0,0) to (255,255,255) and set parameters
+     * -----------------------------------------------------------------------
+     */
+    public NeuQuant(byte[] thepic, int len, int sample) {
+
+        int i;
+        int[] p;
+
+        thepicture = thepic;
+        lengthcount = len;
+        samplefac = sample;
+
+        network = new int[netsize][];
+        for (i = 0; i < netsize; i++) {
+            network[i] = new int[4];
+            p = network[i];
+            p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
+            freq[i] = intbias / netsize; /* 1/netsize */
+            bias[i] = 0;
+        }
+    }
+
+    public byte[] colorMap() {
+        byte[] map = new byte[3 * netsize];
+        int[] index = new int[netsize];
+        for (int i = 0; i < netsize; i++)
+            index[network[i][3]] = i;
+        int k = 0;
+        for (int i = 0; i < netsize; i++) {
+            int j = index[i];
+            map[k++] = (byte) (network[j][0]);
+            map[k++] = (byte) (network[j][1]);
+            map[k++] = (byte) (network[j][2]);
+        }
+        return map;
+    }
+
+    /*
+     * Insertion sort of network and building of netindex[0..255] (to do after
+     * unbias)
+     * -------------------------------------------------------------------------------
+     */
+    public void inxbuild() {
+
+        int i, j, smallpos, smallval;
+        int[] p;
+        int[] q;
+        int previouscol, startpos;
+
+        previouscol = 0;
+        startpos = 0;
+        for (i = 0; i < netsize; i++) {
+            p = network[i];
+            smallpos = i;
+            smallval = p[1]; /* index on g */
+      /* find smallest in i..netsize-1 */
+            for (j = i + 1; j < netsize; j++) {
+                q = network[j];
+                if (q[1] < smallval) { /* index on g */
+                    smallpos = j;
+                    smallval = q[1]; /* index on g */
+                }
+            }
+            q = network[smallpos];
+      /* swap p (i) and q (smallpos) entries */
+            if (i != smallpos) {
+                j = q[0];
+                q[0] = p[0];
+                p[0] = j;
+                j = q[1];
+                q[1] = p[1];
+                p[1] = j;
+                j = q[2];
+                q[2] = p[2];
+                p[2] = j;
+                j = q[3];
+                q[3] = p[3];
+                p[3] = j;
+            }
+      /* smallval entry is now in position i */
+            if (smallval != previouscol) {
+                netindex[previouscol] = (startpos + i) >> 1;
+                for (j = previouscol + 1; j < smallval; j++)
+                    netindex[j] = i;
+                previouscol = smallval;
+                startpos = i;
+            }
+        }
+        netindex[previouscol] = (startpos + maxnetpos) >> 1;
+        for (j = previouscol + 1; j < 256; j++)
+            netindex[j] = maxnetpos; /* really 256 */
+    }
+
+    /*
+     * Main Learning Loop ------------------
+     */
+    public void learn() {
+
+        int i, j, b, g, r;
+        int radius, rad, alpha, step, delta, samplepixels;
+        byte[] p;
+        int pix, lim;
+
+        if (lengthcount < minpicturebytes)
+            samplefac = 1;
+        alphadec = 30 + ((samplefac - 1) / 3);
+        p = thepicture;
+        pix = 0;
+        lim = lengthcount;
+        samplepixels = lengthcount / (3 * samplefac);
+        delta = samplepixels / ncycles;
+        alpha = initalpha;
+        radius = initradius;
+
+        rad = radius >> radiusbiasshift;
+        if (rad <= 1)
+            rad = 0;
+        for (i = 0; i < rad; i++)
+            radpower[i] = alpha * (((rad * rad - i * i) * radbias) / (rad * rad));
+
+        // fprintf(stderr,"beginning 1D learning: initial radius=%d\n", rad);
+
+        if (lengthcount < minpicturebytes)
+            step = 3;
+        else if ((lengthcount % prime1) != 0)
+            step = 3 * prime1;
+        else {
+            if ((lengthcount % prime2) != 0)
+                step = 3 * prime2;
+            else {
+                if ((lengthcount % prime3) != 0)
+                    step = 3 * prime3;
+                else
+                    step = 3 * prime4;
+            }
+        }
+
+        i = 0;
+        while (i < samplepixels) {
+            b = (p[pix + 0] & 0xff) << netbiasshift;
+            g = (p[pix + 1] & 0xff) << netbiasshift;
+            r = (p[pix + 2] & 0xff) << netbiasshift;
+            j = contest(b, g, r);
+
+            altersingle(alpha, j, b, g, r);
+            if (rad != 0)
+                alterneigh(rad, j, b, g, r); /* alter neighbours */
+
+            pix += step;
+            if (pix >= lim)
+                pix -= lengthcount;
+
+            i++;
+            if (delta == 0)
+                delta = 1;
+            if (i % delta == 0) {
+                alpha -= alpha / alphadec;
+                radius -= radius / radiusdec;
+                rad = radius >> radiusbiasshift;
+                if (rad <= 1)
+                    rad = 0;
+                for (j = 0; j < rad; j++)
+                    radpower[j] = alpha * (((rad * rad - j * j) * radbias) / (rad * rad));
+            }
+        }
+        // fprintf(stderr,"finished 1D learning: final alpha=%f
+        // !\n",((float)alpha)/initalpha);
+    }
+
+    /*
+     * Search for BGR values 0..255 (after net is unbiased) and return colour
+     * index
+     * ----------------------------------------------------------------------------
+     */
+    public int map(int b, int g, int r) {
+
+        int i, j, dist, a, bestd;
+        int[] p;
+        int best;
+
+        bestd = 1000; /* biggest possible dist is 256*3 */
+        best = -1;
+        i = netindex[g]; /* index on g */
+        j = i - 1; /* start at netindex[g] and work outwards */
+
+        while ((i < netsize) || (j >= 0)) {
+            if (i < netsize) {
+                p = network[i];
+                dist = p[1] - g; /* inx key */
+                if (dist >= bestd)
+                    i = netsize; /* stop iter */
+                else {
+                    i++;
+                    if (dist < 0)
+                        dist = -dist;
+                    a = p[0] - b;
+                    if (a < 0)
+                        a = -a;
+                    dist += a;
+                    if (dist < bestd) {
+                        a = p[2] - r;
+                        if (a < 0)
+                            a = -a;
+                        dist += a;
+                        if (dist < bestd) {
+                            bestd = dist;
+                            best = p[3];
+                        }
+                    }
+                }
+            }
+            if (j >= 0) {
+                p = network[j];
+                dist = g - p[1]; /* inx key - reverse dif */
+                if (dist >= bestd)
+                    j = -1; /* stop iter */
+                else {
+                    j--;
+                    if (dist < 0)
+                        dist = -dist;
+                    a = p[0] - b;
+                    if (a < 0)
+                        a = -a;
+                    dist += a;
+                    if (dist < bestd) {
+                        a = p[2] - r;
+                        if (a < 0)
+                            a = -a;
+                        dist += a;
+                        if (dist < bestd) {
+                            bestd = dist;
+                            best = p[3];
+                        }
+                    }
+                }
+            }
+        }
+        return (best);
+    }
+
+    public byte[] process() {
+        learn();
+        unbiasnet();
+        inxbuild();
+        return colorMap();
+    }
+
+    /*
+     * Unbias network to give byte values 0..255 and record position i to prepare
+     * for sort
+     * -----------------------------------------------------------------------------------
+     */
+    public void unbiasnet() {
+
+        int i, j;
+
+        for (i = 0; i < netsize; i++) {
+            network[i][0] >>= netbiasshift;
+            network[i][1] >>= netbiasshift;
+            network[i][2] >>= netbiasshift;
+            network[i][3] = i; /* record colour no */
+        }
+    }
+
+    /*
+     * Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in
+     * radpower[|i-j|]
+     * ---------------------------------------------------------------------------------
+     */
+    protected void alterneigh(int rad, int i, int b, int g, int r) {
+
+        int j, k, lo, hi, a, m;
+        int[] p;
+
+        lo = i - rad;
+        if (lo < -1)
+            lo = -1;
+        hi = i + rad;
+        if (hi > netsize)
+            hi = netsize;
+
+        j = i + 1;
+        k = i - 1;
+        m = 1;
+        while ((j < hi) || (k > lo)) {
+            a = radpower[m++];
+            if (j < hi) {
+                p = network[j++];
+                try {
+                    p[0] -= (a * (p[0] - b)) / alpharadbias;
+                    p[1] -= (a * (p[1] - g)) / alpharadbias;
+                    p[2] -= (a * (p[2] - r)) / alpharadbias;
+                } catch (Exception e) {
+                } // prevents 1.3 miscompilation
+            }
+            if (k > lo) {
+                p = network[k--];
+                try {
+                    p[0] -= (a * (p[0] - b)) / alpharadbias;
+                    p[1] -= (a * (p[1] - g)) / alpharadbias;
+                    p[2] -= (a * (p[2] - r)) / alpharadbias;
+                } catch (Exception e) {
+                }
+            }
+        }
+    }
+
+    /*
+     * Move neuron i towards biased (b,g,r) by factor alpha
+     * ----------------------------------------------------
+     */
+    protected void altersingle(int alpha, int i, int b, int g, int r) {
+
+    /* alter hit neuron */
+        int[] n = network[i];
+        n[0] -= (alpha * (n[0] - b)) / initalpha;
+        n[1] -= (alpha * (n[1] - g)) / initalpha;
+        n[2] -= (alpha * (n[2] - r)) / initalpha;
+    }
+
+    /*
+     * Search for biased BGR values ----------------------------
+     */
+    protected int contest(int b, int g, int r) {
+
+    /* finds closest neuron (min dist) and updates freq */
+    /* finds best neuron (min dist-bias) and returns position */
+    /* for frequently chosen neurons, freq[i] is high and bias[i] is negative */
+    /* bias[i] = gamma*((1/netsize)-freq[i]) */
+
+        int i, dist, a, biasdist, betafreq;
+        int bestpos, bestbiaspos, bestd, bestbiasd;
+        int[] n;
+
+        bestd = ~(((int) 1) << 31);
+        bestbiasd = bestd;
+        bestpos = -1;
+        bestbiaspos = bestpos;
+
+        for (i = 0; i < netsize; i++) {
+            n = network[i];
+            dist = n[0] - b;
+            if (dist < 0)
+                dist = -dist;
+            a = n[1] - g;
+            if (a < 0)
+                a = -a;
+            dist += a;
+            a = n[2] - r;
+            if (a < 0)
+                a = -a;
+            dist += a;
+            if (dist < bestd) {
+                bestd = dist;
+                bestpos = i;
+            }
+            biasdist = dist - ((bias[i]) >> (intbiasshift - netbiasshift));
+            if (biasdist < bestbiasd) {
+                bestbiasd = biasdist;
+                bestbiaspos = i;
+            }
+            betafreq = (freq[i] >> betashift);
+            freq[i] -= betafreq;
+            bias[i] += (betafreq << gammashift);
+        }
+        freq[bestpos] += beta;
+        bias[bestpos] -= betagamma;
+        return (bestbiaspos);
+    }
+}