diff --git a/jni/GifTranscoder.cpp b/jni/GifTranscoder.cpp
new file mode 100644
index 0000000..44fa30c
--- /dev/null
+++ b/jni/GifTranscoder.cpp
@@ -0,0 +1,573 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+#include <time.h>
+#include <stdio.h>
+#include <memory>
+#include <vector>
+
+#include <android/log.h>
+
+#include "GifTranscoder.h"
+
+#define SQUARE(a) (a)*(a)
+
+// GIF does not support partial transparency, so our alpha channels are always 0x0 or 0xff.
+static const ColorARGB TRANSPARENT = 0x0;
+
+#define ALPHA(color) (((color) >> 24) & 0xff)
+#define RED(color)   (((color) >> 16) & 0xff)
+#define GREEN(color) (((color) >>  8) & 0xff)
+#define BLUE(color)  (((color) >>  0) & 0xff)
+
+#define MAKE_COLOR_ARGB(a, r, g, b) \
+    ((a) << 24 | (r) << 16 | (g) << 8 | (b))
+
+#define MAX_COLOR_DISTANCE 255 * 255 * 255
+
+#define TAG "GifTranscoder.cpp"
+#define LOGD_ENABLED 0
+#if LOGD_ENABLED
+#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__))
+#else
+#define LOGD(...) ((void)0)
+#endif
+#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__))
+#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, TAG, __VA_ARGS__))
+#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__))
+
+// This macro expects the assertion to pass, but logs a FATAL if not.
+#define ASSERT(cond, ...) \
+    ( (__builtin_expect((cond) == 0, 0)) \
+    ? ((void)__android_log_assert(#cond, TAG, ## __VA_ARGS__)) \
+    : (void) 0 )
+#define ASSERT_ENABLED 1
+
+namespace {
+
+// Current time in milliseconds since Unix epoch.
+double now(void) {
+    struct timespec res;
+    clock_gettime(CLOCK_REALTIME, &res);
+    return 1000.0 * res.tv_sec + (double) res.tv_nsec / 1e6;
+}
+
+// Gets the pixel at position (x,y) from a buffer that uses row-major order to store an image with
+// the specified width.
+template <typename T>
+T* getPixel(T* buffer, int width, int x, int y) {
+    return buffer + (y * width + x);
+}
+
+} // namespace
+
+int GifTranscoder::transcode(const char* pathIn, const char* pathOut) {
+    int error;
+    double t0;
+    GifFileType* gifIn;
+    GifFileType* gifOut;
+
+    // Automatically closes the GIF files when this method returns
+    GifFilesCloser closer;
+
+    gifIn = DGifOpenFileName(pathIn, &error);
+    if (gifIn) {
+        closer.setGifIn(gifIn);
+        LOGD("Opened input GIF: %s", pathIn);
+    } else {
+        LOGE("Could not open input GIF: %s, error = %d", pathIn, error);
+        return GIF_ERROR;
+    }
+
+    gifOut = EGifOpenFileName(pathOut, false, &error);
+    if (gifOut) {
+        closer.setGifOut(gifOut);
+        LOGD("Opened output GIF: %s", pathOut);
+    } else {
+        LOGE("Could not open output GIF: %s, error = %d", pathOut, error);
+        return GIF_ERROR;
+    }
+
+    t0 = now();
+    if (resizeBoxFilter(gifIn, gifOut)) {
+        LOGD("Resized GIF in %.2f ms", now() - t0);
+    } else {
+        LOGE("Could not resize GIF");
+        return GIF_ERROR;
+    }
+
+    return GIF_OK;
+}
+
+bool GifTranscoder::resizeBoxFilter(GifFileType* gifIn, GifFileType* gifOut) {
+    ASSERT(gifIn != NULL, "gifIn cannot be NULL");
+    ASSERT(gifOut != NULL, "gifOut cannot be NULL");
+
+    if (gifIn->SWidth < 0 || gifIn->SHeight < 0) {
+        LOGE("Input GIF has invalid size: %d x %d", gifIn->SWidth, gifIn->SHeight);
+        return false;
+    }
+
+    // Output GIF will be 50% the size of the original.
+    if (EGifPutScreenDesc(gifOut,
+                          gifIn->SWidth / 2,
+                          gifIn->SHeight / 2,
+                          gifIn->SColorResolution,
+                          gifIn->SBackGroundColor,
+                          gifIn->SColorMap) == GIF_ERROR) {
+        LOGE("Could not write screen descriptor");
+        return false;
+    }
+    LOGD("Wrote screen descriptor");
+
+    // Index of the current image.
+    int imageIndex = 0;
+
+    // Transparent color of the current image.
+    int transparentColor = NO_TRANSPARENT_COLOR;
+
+    // Buffer for reading raw images from the input GIF.
+    std::vector<GifByteType> srcBuffer(gifIn->SWidth * gifIn->SHeight);
+
+    // Buffer for rendering images from the input GIF.
+    std::unique_ptr<ColorARGB> renderBuffer(new ColorARGB[gifIn->SWidth * gifIn->SHeight]);
+
+    // Buffer for writing new images to output GIF (one row at a time).
+    std::unique_ptr<GifByteType> dstRowBuffer(new GifByteType[gifOut->SWidth]);
+
+    // Many GIFs use DISPOSE_DO_NOT to make images draw on top of previous images. They can also
+    // use DISPOSE_BACKGROUND to clear the last image region before drawing the next one. We need
+    // to keep track of the disposal mode as we go along to properly render the GIF.
+    int disposalMode = DISPOSAL_UNSPECIFIED;
+    int prevImageDisposalMode = DISPOSAL_UNSPECIFIED;
+    GifImageDesc prevImageDimens;
+
+    // Background color (applies to entire GIF).
+    ColorARGB bgColor = TRANSPARENT;
+
+    GifRecordType recordType;
+    do {
+        if (DGifGetRecordType(gifIn, &recordType) == GIF_ERROR) {
+            LOGE("Could not get record type");
+            return false;
+        }
+        LOGD("Read record type: %d", recordType);
+        switch (recordType) {
+            case IMAGE_DESC_RECORD_TYPE: {
+                if (DGifGetImageDesc(gifIn) == GIF_ERROR) {
+                    LOGE("Could not read image descriptor (%d)", imageIndex);
+                    return false;
+                }
+
+                // Sanity-check the current image position.
+                if (gifIn->Image.Left < 0 ||
+                        gifIn->Image.Top < 0 ||
+                        gifIn->Image.Left + gifIn->Image.Width > gifIn->SWidth ||
+                        gifIn->Image.Top + gifIn->Image.Height > gifIn->SHeight) {
+                    LOGE("GIF image extends beyond logical screen");
+                    return false;
+                }
+
+                // Write the new image descriptor.
+                if (EGifPutImageDesc(gifOut,
+                                     0, // Left
+                                     0, // Top
+                                     gifOut->SWidth,
+                                     gifOut->SHeight,
+                                     false, // Interlace
+                                     gifIn->Image.ColorMap) == GIF_ERROR) {
+                    LOGE("Could not write image descriptor (%d)", imageIndex);
+                    return false;
+                }
+
+                // Read the image from the input GIF. The buffer is already initialized to the
+                // size of the GIF, which is usually equal to the size of all the images inside it.
+                // If not, the call to resize below ensures that the buffer is the right size.
+                srcBuffer.resize(gifIn->Image.Width * gifIn->Image.Height);
+                if (readImage(gifIn, srcBuffer.data()) == false) {
+                    LOGE("Could not read image data (%d)", imageIndex);
+                    return false;
+                }
+                LOGD("Read image data (%d)", imageIndex);
+                // Render the image from the input GIF.
+                if (renderImage(gifIn,
+                                srcBuffer.data(),
+                                imageIndex,
+                                transparentColor,
+                                renderBuffer.get(),
+                                bgColor,
+                                prevImageDimens,
+                                prevImageDisposalMode) == false) {
+                    LOGE("Could not render %d", imageIndex);
+                    return false;
+                }
+                LOGD("Rendered image (%d)", imageIndex);
+
+                // Generate the image in the output GIF.
+                for (int y = 0; y < gifOut->SHeight; y++) {
+                    for (int x = 0; x < gifOut->SWidth; x++) {
+                      const GifByteType dstColorIndex = computeNewColorIndex(
+                          gifIn, transparentColor, renderBuffer.get(), x, y);
+                      *(dstRowBuffer.get() + x) = dstColorIndex;
+                    }
+                    if (EGifPutLine(gifOut, dstRowBuffer.get(), gifOut->SWidth) == GIF_ERROR) {
+                        LOGE("Could not write raster data (%d)", imageIndex);
+                        return false;
+                    }
+                }
+                LOGD("Wrote raster data (%d)", imageIndex);
+
+                // Save the disposal mode for rendering the next image.
+                // We only support DISPOSE_DO_NOT and DISPOSE_BACKGROUND.
+                prevImageDisposalMode = disposalMode;
+                if (prevImageDisposalMode == DISPOSAL_UNSPECIFIED) {
+                    prevImageDisposalMode = DISPOSE_DO_NOT;
+                } else if (prevImageDisposalMode == DISPOSE_PREVIOUS) {
+                    prevImageDisposalMode = DISPOSE_BACKGROUND;
+                }
+                if (prevImageDisposalMode == DISPOSE_BACKGROUND) {
+                    prevImageDimens.Left = gifIn->Image.Left;
+                    prevImageDimens.Top = gifIn->Image.Top;
+                    prevImageDimens.Width = gifIn->Image.Width;
+                    prevImageDimens.Height = gifIn->Image.Height;
+                }
+
+                if (gifOut->Image.ColorMap) {
+                    GifFreeMapObject(gifOut->Image.ColorMap);
+                    gifOut->Image.ColorMap = NULL;
+                }
+
+                imageIndex++;
+            } break;
+            case EXTENSION_RECORD_TYPE: {
+                int extCode;
+                GifByteType* ext;
+                if (DGifGetExtension(gifIn, &extCode, &ext) == GIF_ERROR) {
+                    LOGE("Could not read extension block");
+                    return false;
+                }
+                LOGD("Read extension block, code: %d", extCode);
+                if (extCode == GRAPHICS_EXT_FUNC_CODE) {
+                    GraphicsControlBlock gcb;
+                    if (DGifExtensionToGCB(ext[0], ext + 1, &gcb) == GIF_ERROR) {
+                        LOGE("Could not interpret GCB extension");
+                        return false;
+                    }
+                    transparentColor = gcb.TransparentColor;
+
+                    // This logic for setting the background color based on the first GCB
+                    // doesn't quite match the GIF spec, but empirically it seems to work and it
+                    // matches what libframesequence (Rastermill) does.
+                    if (imageIndex == 0 && gifIn->SColorMap) {
+                        if (gcb.TransparentColor == NO_TRANSPARENT_COLOR) {
+                            GifColorType bgColorIndex =
+                                    gifIn->SColorMap->Colors[gifIn->SBackGroundColor];
+                            bgColor = gifColorToColorARGB(bgColorIndex);
+                            LOGD("Set background color based on first GCB");
+                        }
+                    }
+
+                    // Record the original disposal mode and then update it.
+                    disposalMode = gcb.DisposalMode;
+                    gcb.DisposalMode = DISPOSE_BACKGROUND;
+                    EGifGCBToExtension(&gcb, ext + 1);
+                }
+                if (EGifPutExtensionLeader(gifOut, extCode) == GIF_ERROR) {
+                    LOGE("Could not write extension leader");
+                    return false;
+                }
+                if (EGifPutExtensionBlock(gifOut, ext[0], ext + 1) == GIF_ERROR) {
+                    LOGE("Could not write extension block");
+                    return false;
+                }
+                LOGD("Wrote extension block");
+                while (ext != NULL) {
+                    if (DGifGetExtensionNext(gifIn, &ext) == GIF_ERROR) {
+                        LOGE("Could not read extension continuation");
+                        return false;
+                    }
+                    if (ext != NULL) {
+                        LOGD("Read extension continuation");
+                        if (EGifPutExtensionBlock(gifOut, ext[0], ext + 1) == GIF_ERROR) {
+                            LOGE("Could not write extension continuation");
+                            return false;
+                        }
+                        LOGD("Wrote extension continuation");
+                    }
+                }
+                if (EGifPutExtensionTrailer(gifOut) == GIF_ERROR) {
+                    LOGE("Could not write extension trailer");
+                    return false;
+                }
+            } break;
+        }
+
+    } while (recordType != TERMINATE_RECORD_TYPE);
+    LOGD("No more records");
+
+    return true;
+}
+
+bool GifTranscoder::readImage(GifFileType* gifIn, GifByteType* rasterBits) {
+    if (gifIn->Image.Interlace) {
+        int interlacedOffset[] = { 0, 4, 2, 1 };
+        int interlacedJumps[] = { 8, 8, 4, 2 };
+
+        // Need to perform 4 passes on the image
+        for (int i = 0; i < 4; i++) {
+            for (int j = interlacedOffset[i]; j < gifIn->Image.Height; j += interlacedJumps[i]) {
+                if (DGifGetLine(gifIn,
+                                rasterBits + j * gifIn->Image.Width,
+                                gifIn->Image.Width) == GIF_ERROR) {
+                    LOGE("Could not read interlaced raster data");
+                    return false;
+                }
+            }
+        }
+    } else {
+        if (DGifGetLine(gifIn, rasterBits, gifIn->Image.Width * gifIn->Image.Height) == GIF_ERROR) {
+            LOGE("Could not read raster data");
+            return false;
+        }
+    }
+    return true;
+}
+
+bool GifTranscoder::renderImage(GifFileType* gifIn,
+                                GifByteType* rasterBits,
+                                int imageIndex,
+                                int transparentColorIndex,
+                                ColorARGB* renderBuffer,
+                                ColorARGB bgColor,
+                                GifImageDesc prevImageDimens,
+                                int prevImageDisposalMode) {
+    ASSERT(imageIndex < gifIn->ImageCount,
+           "Image index %d is out of bounds (count=%d)", imageIndex, gifIn->ImageCount);
+
+    ColorMapObject* colorMap = getColorMap(gifIn);
+    if (colorMap == NULL) {
+        LOGE("No GIF color map found");
+        return false;
+    }
+
+    // Clear all or part of the background, before drawing the first image and maybe before drawing
+    // subsequent images (depending on the DisposalMode).
+    if (imageIndex == 0) {
+        fillRect(renderBuffer, gifIn->SWidth, gifIn->SHeight,
+                 0, 0, gifIn->SWidth, gifIn->SHeight, bgColor);
+    } else if (prevImageDisposalMode == DISPOSE_BACKGROUND) {
+        fillRect(renderBuffer, gifIn->SWidth, gifIn->SHeight,
+                 prevImageDimens.Left, prevImageDimens.Top,
+                 prevImageDimens.Width, prevImageDimens.Height, TRANSPARENT);
+    }
+
+    // Paint this image onto the canvas
+    for (int y = 0; y < gifIn->Image.Height; y++) {
+        for (int x = 0; x < gifIn->Image.Width; x++) {
+            GifByteType colorIndex = *getPixel(rasterBits, gifIn->Image.Width, x, y);
+
+            // This image may be smaller than the GIF's "logical screen"
+            int renderX = x + gifIn->Image.Left;
+            int renderY = y + gifIn->Image.Top;
+
+            // Skip drawing transparent pixels if this image renders on top of the last one
+            if (imageIndex > 0 && prevImageDisposalMode == DISPOSE_DO_NOT &&
+                colorIndex == transparentColorIndex) {
+                continue;
+            }
+
+            ColorARGB* renderPixel = getPixel(renderBuffer, gifIn->SWidth, renderX, renderY);
+            *renderPixel = getColorARGB(colorMap, transparentColorIndex, colorIndex);
+        }
+    }
+    return true;
+}
+
+void GifTranscoder::fillRect(ColorARGB* renderBuffer,
+                             int imageWidth,
+                             int imageHeight,
+                             int left,
+                             int top,
+                             int width,
+                             int height,
+                             ColorARGB color) {
+    ASSERT(left + width <= imageWidth, "Rectangle is outside image bounds");
+    ASSERT(top + height <= imageHeight, "Rectangle is outside image bounds");
+
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            ColorARGB* renderPixel = getPixel(renderBuffer, imageWidth, x + left, y + top);
+            *renderPixel = color;
+        }
+    }
+}
+
+GifByteType GifTranscoder::computeNewColorIndex(GifFileType* gifIn,
+                                                int transparentColorIndex,
+                                                ColorARGB* renderBuffer,
+                                                int x,
+                                                int y) {
+    ColorMapObject* colorMap = getColorMap(gifIn);
+
+    // Compute the average color of 4 adjacent pixels from the input image.
+    ColorARGB c1 = *getPixel(renderBuffer, gifIn->SWidth, x * 2, y * 2);
+    ColorARGB c2 = *getPixel(renderBuffer, gifIn->SWidth, x * 2 + 1, y * 2);
+    ColorARGB c3 = *getPixel(renderBuffer, gifIn->SWidth, x * 2, y * 2 + 1);
+    ColorARGB c4 = *getPixel(renderBuffer, gifIn->SWidth, x * 2 + 1, y * 2 + 1);
+    ColorARGB avgColor = computeAverage(c1, c2, c3, c4);
+
+    // Search the color map for the best match.
+    return findBestColor(colorMap, transparentColorIndex, avgColor);
+}
+
+ColorARGB GifTranscoder::computeAverage(ColorARGB c1, ColorARGB c2, ColorARGB c3, ColorARGB c4) {
+    char avgAlpha = (char)(((int) ALPHA(c1) + (int) ALPHA(c2) +
+                            (int) ALPHA(c3) + (int) ALPHA(c4)) / 4);
+    char avgRed =   (char)(((int) RED(c1) + (int) RED(c2) +
+                            (int) RED(c3) + (int) RED(c4)) / 4);
+    char avgGreen = (char)(((int) GREEN(c1) + (int) GREEN(c2) +
+                            (int) GREEN(c3) + (int) GREEN(c4)) / 4);
+    char avgBlue =  (char)(((int) BLUE(c1) + (int) BLUE(c2) +
+                            (int) BLUE(c3) + (int) BLUE(c4)) / 4);
+    return MAKE_COLOR_ARGB(avgAlpha, avgRed, avgGreen, avgBlue);
+}
+
+GifByteType GifTranscoder::findBestColor(ColorMapObject* colorMap, int transparentColorIndex,
+                                         ColorARGB targetColor) {
+    // Return the transparent color if the average alpha is zero.
+    char alpha = ALPHA(targetColor);
+    if (alpha == 0 && transparentColorIndex != NO_TRANSPARENT_COLOR) {
+        return transparentColorIndex;
+    }
+
+    GifByteType closestColorIndex = 0;
+    int closestColorDistance = MAX_COLOR_DISTANCE;
+    for (int i = 0; i < colorMap->ColorCount; i++) {
+        // Skip the transparent color (we've already eliminated that option).
+        if (i == transparentColorIndex) {
+            continue;
+        }
+        ColorARGB indexedColor = gifColorToColorARGB(colorMap->Colors[i]);
+        int distance = computeDistance(targetColor, indexedColor);
+        if (distance < closestColorDistance) {
+            closestColorIndex = i;
+            closestColorDistance = distance;
+        }
+    }
+    return closestColorIndex;
+}
+
+int GifTranscoder::computeDistance(ColorARGB c1, ColorARGB c2) {
+    return SQUARE(RED(c1) - RED(c2)) +
+           SQUARE(GREEN(c1) - GREEN(c2)) +
+           SQUARE(BLUE(c1) - BLUE(c2));
+}
+
+ColorMapObject* GifTranscoder::getColorMap(GifFileType* gifIn) {
+    if (gifIn->Image.ColorMap) {
+        return gifIn->Image.ColorMap;
+    }
+    return gifIn->SColorMap;
+}
+
+ColorARGB GifTranscoder::getColorARGB(ColorMapObject* colorMap, int transparentColorIndex,
+                                      GifByteType colorIndex) {
+    if (colorIndex == transparentColorIndex) {
+        return TRANSPARENT;
+    }
+    return gifColorToColorARGB(colorMap->Colors[colorIndex]);
+}
+
+ColorARGB GifTranscoder::gifColorToColorARGB(const GifColorType& color) {
+    return MAKE_COLOR_ARGB(0xff, color.Red, color.Green, color.Blue);
+}
+
+GifFilesCloser::~GifFilesCloser() {
+    if (mGifIn) {
+        DGifCloseFile(mGifIn);
+        mGifIn = NULL;
+    }
+    if (mGifOut) {
+        EGifCloseFile(mGifOut);
+        mGifOut = NULL;
+    }
+}
+
+void GifFilesCloser::setGifIn(GifFileType* gifIn) {
+    ASSERT(mGifIn == NULL, "mGifIn is already set");
+    mGifIn = gifIn;
+}
+
+void GifFilesCloser::releaseGifIn() {
+    ASSERT(mGifIn != NULL, "mGifIn is already NULL");
+    mGifIn = NULL;
+}
+
+void GifFilesCloser::setGifOut(GifFileType* gifOut) {
+    ASSERT(mGifOut == NULL, "mGifOut is already set");
+    mGifOut = gifOut;
+}
+
+void GifFilesCloser::releaseGifOut() {
+    ASSERT(mGifOut != NULL, "mGifOut is already NULL");
+    mGifOut = NULL;
+}
+
+// JNI stuff
+
+jboolean transcode(JNIEnv* env, jobject clazz, jstring filePath, jstring outFilePath) {
+    const char* pathIn = env->GetStringUTFChars(filePath, JNI_FALSE);
+    const char* pathOut = env->GetStringUTFChars(outFilePath, JNI_FALSE);
+
+    GifTranscoder transcoder;
+    int gifCode = transcoder.transcode(pathIn, pathOut);
+
+    env->ReleaseStringUTFChars(filePath, pathIn);
+    env->ReleaseStringUTFChars(outFilePath, pathOut);
+
+    return (gifCode == GIF_OK);
+}
+
+const char *kClassPathName = "com/android/messaging/util/GifTranscoder";
+
+JNINativeMethod kMethods[] = {
+        { "transcodeInternal", "(Ljava/lang/String;Ljava/lang/String;)Z", (void*)transcode },
+};
+
+int registerNativeMethods(JNIEnv* env, const char* className,
+                          JNINativeMethod* gMethods, int numMethods) {
+    jclass clazz = env->FindClass(className);
+    if (clazz == NULL) {
+        return JNI_FALSE;
+    }
+    if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
+        return JNI_FALSE;
+    }
+    return JNI_TRUE;
+}
+
+jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    JNIEnv* env;
+    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+        return -1;
+    }
+    if (!registerNativeMethods(env, kClassPathName,
+                               kMethods, sizeof(kMethods) / sizeof(kMethods[0]))) {
+      return -1;
+    }
+    return JNI_VERSION_1_6;
+}