diff --git a/tests/tests/media/libmediandkjni/Android.mk b/tests/tests/media/libmediandkjni/Android.mk
index 2d2033f..59ff7bb 100644
--- a/tests/tests/media/libmediandkjni/Android.mk
+++ b/tests/tests/media/libmediandkjni/Android.mk
@@ -20,7 +20,9 @@
 
 LOCAL_MODULE_TAGS := optional
 
-LOCAL_SRC_FILES := native-media-jni.cpp
+LOCAL_SRC_FILES := \
+	native-media-jni.cpp \
+	codec-utils-jni.cpp
 
 LOCAL_C_INCLUDES := $(JNI_H_INCLUDE)
 
diff --git a/tests/tests/media/libmediandkjni/codec-utils-jni.cpp b/tests/tests/media/libmediandkjni/codec-utils-jni.cpp
new file mode 100644
index 0000000..f99f1c8
--- /dev/null
+++ b/tests/tests/media/libmediandkjni/codec-utils-jni.cpp
@@ -0,0 +1,307 @@
+/*
+ * Copyright 2014 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.
+ */
+
+/* Original code copied from NDK Native-media sample code */
+
+#undef NDEBUG
+//#define LOG_NDEBUG 0
+#include <stdint.h>
+#include <sys/types.h>
+#include <jni.h>
+
+#include <ScopedLocalRef.h>
+#include <JNIHelp.h>
+
+typedef ssize_t offs_t;
+
+// for __android_log_print(ANDROID_LOG_INFO, "YourApp", "formatted message");
+#include <android/log.h>
+#define TAG "CodecUtilsJNI"
+#define __ALOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, TAG, __VA_ARGS__)
+#if LOG_NDEBUG
+#define ALOGV(...) do { if (0) { __ALOGV(__VA_ARGS__); } } while (0)
+#else
+#define ALOGV(...) __ALOGV(__VA_ARGS__)
+#endif
+#define ALOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)
+#define ALOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
+#define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, TAG, __VA_ARGS__)
+#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
+
+struct NativeImage {
+    struct crop {
+        int left;
+        int top;
+        int right;
+        int bottom;
+    } crop;
+    struct plane {
+        const uint8_t *buffer;
+        size_t size;
+        ssize_t colInc;
+        ssize_t rowInc;
+        offs_t cropOffs;
+        size_t cropWidth;
+        size_t cropHeight;
+    } plane[3];
+    int width;
+    int height;
+    int format;
+    long timestamp;
+    size_t numPlanes;
+};
+
+struct ChecksumAlg {
+    virtual void init() = 0;
+    virtual void update(uint8_t c) = 0;
+    virtual uint32_t checksum() = 0;
+    virtual size_t length() = 0;
+protected:
+    virtual ~ChecksumAlg() {}
+};
+
+struct Adler32 : ChecksumAlg {
+    Adler32() {
+        init();
+    }
+    void init() {
+        a = 1;
+        len = b = 0;
+    }
+    void update(uint8_t c) {
+        a += c;
+        b += a;
+        ++len;
+    }
+    uint32_t checksum() {
+        return (a % 65521) + ((b % 65521) << 16);
+    }
+    size_t length() {
+        return len;
+    }
+private:
+    uint32_t a, b;
+    size_t len;
+};
+
+static struct ImageFieldsAndMethods {
+    // android.graphics.ImageFormat
+    int YUV_420_888;
+    // android.media.Image
+    jmethodID methodWidth;
+    jmethodID methodHeight;
+    jmethodID methodFormat;
+    jmethodID methodTimestamp;
+    jmethodID methodPlanes;
+    jmethodID methodCrop;
+    // android.media.Image.Plane
+    jmethodID methodBuffer;
+    jmethodID methodPixelStride;
+    jmethodID methodRowStride;
+    // android.graphics.Rect
+    jfieldID fieldLeft;
+    jfieldID fieldTop;
+    jfieldID fieldRight;
+    jfieldID fieldBottom;
+} gFields;
+static bool gFieldsInitialized = false;
+
+void initializeGlobalFields(JNIEnv *env) {
+    if (gFieldsInitialized) {
+        return;
+    }
+    {   // ImageFormat
+        jclass imageFormatClazz = env->FindClass("android/graphics/ImageFormat");
+        const jfieldID fieldYUV420888 = env->GetStaticFieldID(imageFormatClazz, "YUV_420_888", "I");
+        gFields.YUV_420_888 = env->GetStaticIntField(imageFormatClazz, fieldYUV420888);
+        env->DeleteLocalRef(imageFormatClazz);
+        imageFormatClazz = NULL;
+    }
+
+    {   // Image
+        jclass imageClazz = env->FindClass("android/media/Image");
+        gFields.methodWidth  = env->GetMethodID(imageClazz, "getWidth", "()I");
+        gFields.methodHeight = env->GetMethodID(imageClazz, "getHeight", "()I");
+        gFields.methodFormat = env->GetMethodID(imageClazz, "getFormat", "()I");
+        gFields.methodTimestamp = env->GetMethodID(imageClazz, "getTimestamp", "()J");
+        gFields.methodPlanes = env->GetMethodID(
+                imageClazz, "getPlanes", "()[Landroid/media/Image$Plane;");
+        gFields.methodCrop   = env->GetMethodID(
+                imageClazz, "getCropRect", "()Landroid/graphics/Rect;");
+        env->DeleteLocalRef(imageClazz);
+        imageClazz = NULL;
+    }
+
+    {   // Image.Plane
+        jclass planeClazz = env->FindClass("android/media/Image$Plane");
+        gFields.methodBuffer = env->GetMethodID(planeClazz, "getBuffer", "()Ljava/nio/ByteBuffer;");
+        gFields.methodPixelStride = env->GetMethodID(planeClazz, "getPixelStride", "()I");
+        gFields.methodRowStride = env->GetMethodID(planeClazz, "getRowStride", "()I");
+        env->DeleteLocalRef(planeClazz);
+        planeClazz = NULL;
+    }
+
+    {   // Rect
+        jclass rectClazz = env->FindClass("android/graphics/Rect");
+        gFields.fieldLeft   = env->GetFieldID(rectClazz, "left", "I");
+        gFields.fieldTop    = env->GetFieldID(rectClazz, "top", "I");
+        gFields.fieldRight  = env->GetFieldID(rectClazz, "right", "I");
+        gFields.fieldBottom = env->GetFieldID(rectClazz, "bottom", "I");
+        env->DeleteLocalRef(rectClazz);
+        rectClazz = NULL;
+    }
+    gFieldsInitialized = true;
+}
+
+NativeImage *getNativeImage(JNIEnv *env, jobject image) {
+    if (image == NULL) {
+        jniThrowNullPointerException(env, "image is null");
+        return NULL;
+    }
+
+    initializeGlobalFields(env);
+
+    NativeImage *img = new NativeImage;
+    img->format = env->CallIntMethod(image, gFields.methodFormat);
+    img->width  = env->CallIntMethod(image, gFields.methodWidth);
+    img->height = env->CallIntMethod(image, gFields.methodHeight);
+    img->timestamp = env->CallLongMethod(image, gFields.methodTimestamp);
+
+    jobject cropRect = env->CallObjectMethod(image, gFields.methodCrop);
+    img->crop.left   = env->GetIntField(cropRect, gFields.fieldLeft);
+    img->crop.top    = env->GetIntField(cropRect, gFields.fieldTop);
+    img->crop.right  = env->GetIntField(cropRect, gFields.fieldRight);
+    img->crop.bottom = env->GetIntField(cropRect, gFields.fieldBottom);
+    if (img->crop.right == 0 && img->crop.bottom == 0) {
+        img->crop.right  = img->width;
+        img->crop.bottom = img->height;
+    }
+    env->DeleteLocalRef(cropRect);
+    cropRect = NULL;
+
+    if (img->format != gFields.YUV_420_888) {
+        jniThrowException(
+                env, "java/lang/UnsupportedOperationException",
+                "only support YUV_420_888 images");
+        delete img;
+        img = NULL;
+        return NULL;
+    }
+    img->numPlanes = 3;
+
+    ScopedLocalRef<jobjectArray> planesArray(
+            env, (jobjectArray)env->CallObjectMethod(image, gFields.methodPlanes));
+    int xDecim = 0;
+    int yDecim = 0;
+    for (size_t ix = 0; ix < img->numPlanes; ++ix) {
+        ScopedLocalRef<jobject> plane(
+                env, env->GetObjectArrayElement(planesArray.get(), (jsize)ix));
+        img->plane[ix].colInc = env->CallIntMethod(plane.get(), gFields.methodPixelStride);
+        img->plane[ix].rowInc = env->CallIntMethod(plane.get(), gFields.methodRowStride);
+        ScopedLocalRef<jobject> buffer(
+                env, env->CallObjectMethod(plane.get(), gFields.methodBuffer));
+
+        img->plane[ix].buffer = (const uint8_t *)env->GetDirectBufferAddress(buffer.get());
+        img->plane[ix].size = env->GetDirectBufferCapacity(buffer.get());
+
+        img->plane[ix].cropOffs =
+            (img->crop.left >> xDecim) * img->plane[ix].colInc
+                    + (img->crop.top >> yDecim) * img->plane[ix].rowInc;
+        img->plane[ix].cropHeight =
+            ((img->crop.bottom + (1 << yDecim) - 1) >> yDecim) - (img->crop.top >> yDecim);
+        img->plane[ix].cropWidth =
+            ((img->crop.right + (1 << xDecim) - 1) >> xDecim) - (img->crop.left >> xDecim);
+
+        // sanity check on increments
+        ssize_t widthOffs =
+            (((img->width + (1 << xDecim) - 1) >> xDecim) - 1) * img->plane[ix].colInc;
+        ssize_t heightOffs =
+            (((img->height + (1 << yDecim) - 1) >> yDecim) - 1) * img->plane[ix].rowInc;
+        if (widthOffs < 0 || heightOffs < 0
+                || widthOffs + heightOffs >= (ssize_t)img->plane[ix].size) {
+            jniThrowException(
+                    env, "java/lang/IndexOutOfBoundsException", "plane exceeds bytearray");
+            delete img;
+            img = NULL;
+            return NULL;
+        }
+        xDecim = yDecim = 1;
+    }
+    return img;
+}
+
+extern "C" jint Java_android_media_cts_CodecUtils_getImageChecksum(JNIEnv *env,
+        jclass /*clazz*/, jobject image)
+{
+    NativeImage *img = getNativeImage(env, image);
+    if (img == NULL) {
+        return 0;
+    }
+
+    Adler32 adler;
+    for (size_t ix = 0; ix < img->numPlanes; ++ix) {
+        const uint8_t *row = img->plane[ix].buffer + img->plane[ix].cropOffs;
+        for (size_t y = img->plane[ix].cropHeight; y > 0; --y) {
+            const uint8_t *col = row;
+            ssize_t colInc = img->plane[ix].colInc;
+            for (size_t x = img->plane[ix].cropWidth; x > 0; --x) {
+                adler.update(*col);
+                col += colInc;
+            }
+            row += img->plane[ix].rowInc;
+        }
+    }
+    ALOGV("adler %zu/%u", adler.length(), adler.checksum());
+    return adler.checksum();
+}
+
+/* tiled copy that loops around source image boundary */
+extern "C" void Java_android_media_cts_CodecUtils_copyFlexYUVImage(JNIEnv *env,
+        jclass /*clazz*/, jobject target, jobject source)
+{
+    NativeImage *tgt = getNativeImage(env, target);
+    NativeImage *src = getNativeImage(env, source);
+    if (tgt != NULL && src != NULL) {
+        ALOGV("copyFlexYUVImage %dx%d (%d,%d..%d,%d) (%zux%zu) %+zd%+zd %+zd%+zd %+zd%+zd <= "
+                "%dx%d (%d, %d..%d, %d) (%zux%zu) %+zd%+zd %+zd%+zd %+zd%+zd",
+                tgt->width, tgt->height,
+                tgt->crop.left, tgt->crop.top, tgt->crop.right, tgt->crop.bottom,
+                tgt->plane[0].cropWidth, tgt->plane[0].cropHeight,
+                tgt->plane[0].rowInc, tgt->plane[0].colInc,
+                tgt->plane[1].rowInc, tgt->plane[1].colInc,
+                tgt->plane[2].rowInc, tgt->plane[2].colInc,
+                src->width, src->height,
+                src->crop.left, src->crop.top, src->crop.right, src->crop.bottom,
+                src->plane[0].cropWidth, src->plane[0].cropHeight,
+                src->plane[0].rowInc, src->plane[0].colInc,
+                src->plane[1].rowInc, src->plane[1].colInc,
+                src->plane[2].rowInc, src->plane[2].colInc);
+        for (size_t ix = 0; ix < tgt->numPlanes; ++ix) {
+            uint8_t *row = const_cast<uint8_t *>(tgt->plane[ix].buffer) + tgt->plane[ix].cropOffs;
+            for (size_t y = 0; y < tgt->plane[ix].cropHeight; ++y) {
+                uint8_t *col = row;
+                ssize_t colInc = tgt->plane[ix].colInc;
+                const uint8_t *srcRow = (src->plane[ix].buffer + src->plane[ix].cropOffs
+                        + src->plane[ix].rowInc * (y % src->plane[ix].cropHeight));
+                for (size_t x = 0; x < tgt->plane[ix].cropWidth; ++x) {
+                    *col = srcRow[src->plane[ix].colInc * (x % src->plane[ix].cropWidth)];
+                    col += colInc;
+                }
+                row += tgt->plane[ix].rowInc;
+            }
+        }
+    }
+}
diff --git a/tests/tests/media/res/raw/video_480x360_mp4_h264_871kbps_30fps.mp4 b/tests/tests/media/res/raw/video_480x360_mp4_h264_871kbps_30fps.mp4
new file mode 100644
index 0000000..55a83e7
--- /dev/null
+++ b/tests/tests/media/res/raw/video_480x360_mp4_h264_871kbps_30fps.mp4
Binary files differ
diff --git a/tests/tests/media/src/android/media/cts/CodecUtils.java b/tests/tests/media/src/android/media/cts/CodecUtils.java
new file mode 100644
index 0000000..3c3576f
--- /dev/null
+++ b/tests/tests/media/src/android/media/cts/CodecUtils.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2014 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.
+ */
+
+package android.media.cts;
+
+import android.media.Image;
+import android.util.Log;
+
+public class CodecUtils  {
+    private static final String TAG = "CodecUtils";
+
+    /** Load jni on initialization */
+    static {
+        Log.i(TAG, "before loadlibrary");
+        System.loadLibrary("ctsmediacodec_jni");
+        Log.i(TAG, "after loadlibrary");
+    }
+
+    public native static int getImageChecksum(Image image);
+    public native static void copyFlexYUVImage(Image target, Image source);
+}
+
diff --git a/tests/tests/media/src/android/media/cts/OutputSurface.java b/tests/tests/media/src/android/media/cts/OutputSurface.java
index fc8ad9c..c87326d 100644
--- a/tests/tests/media/src/android/media/cts/OutputSurface.java
+++ b/tests/tests/media/src/android/media/cts/OutputSurface.java
@@ -70,7 +70,7 @@
         eglSetup(width, height);
         makeCurrent();
 
-        setup();
+        setup(this);
     }
 
     /**
@@ -78,14 +78,18 @@
      * new one).  Creates a Surface that can be passed to MediaCodec.configure().
      */
     public OutputSurface() {
-        setup();
+        setup(this);
+    }
+
+    public OutputSurface(final SurfaceTexture.OnFrameAvailableListener listener) {
+        setup(listener);
     }
 
     /**
      * Creates instances of TextureRender and SurfaceTexture, and a Surface associated
      * with the SurfaceTexture.
      */
-    private void setup() {
+    private void setup(SurfaceTexture.OnFrameAvailableListener listener) {
         mTextureRender = new TextureRender();
         mTextureRender.surfaceCreated();
 
@@ -107,7 +111,7 @@
         //
         // Java language note: passing "this" out of a constructor is generally unwise,
         // but we should be able to get away with it here.
-        mSurfaceTexture.setOnFrameAvailableListener(this);
+        mSurfaceTexture.setOnFrameAvailableListener(listener);
 
         mSurface = new Surface(mSurfaceTexture);
     }
@@ -285,6 +289,11 @@
         mTextureRender.drawFrame(mSurfaceTexture);
     }
 
+    public void latchImage() {
+        mTextureRender.checkGlError("before updateTexImage");
+        mSurfaceTexture.updateTexImage();
+    }
+
     @Override
     public void onFrameAvailable(SurfaceTexture st) {
         if (VERBOSE) Log.d(TAG, "new frame available");
diff --git a/tests/tests/media/src/android/media/cts/VideoEncoderTest.java b/tests/tests/media/src/android/media/cts/VideoEncoderTest.java
new file mode 100644
index 0000000..f78f5f8
--- /dev/null
+++ b/tests/tests/media/src/android/media/cts/VideoEncoderTest.java
@@ -0,0 +1,1247 @@
+/*
+ * Copyright 2014 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.
+ */
+
+package android.media.cts;
+
+import com.android.cts.media.R;
+
+import android.media.cts.CodecUtils;
+
+import android.cts.util.MediaUtils;
+import android.graphics.ImageFormat;
+import android.graphics.SurfaceTexture;
+import android.media.Image;
+import android.media.MediaCodec;
+import android.media.MediaCodec.BufferInfo;
+import android.media.MediaCodecInfo;
+import android.media.MediaCodecInfo.CodecCapabilities;
+import android.media.MediaCodecInfo.VideoCapabilities;
+import android.media.MediaCodecList;
+import android.media.MediaExtractor;
+import android.media.MediaFormat;
+import android.net.Uri;
+import android.util.Log;
+import android.util.Pair;
+import android.util.Range;
+import android.util.Size;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Set;
+
+public class VideoEncoderTest extends MediaPlayerTestBase {
+    private static final int MAX_SAMPLE_SIZE = 256 * 1024;
+    private static final String TAG = "VideoEncoderTest";
+    private static final long FRAME_TIMEOUT_MS = 1000;
+
+    private static final String SOURCE_URL =
+        "android.resource://com.android.cts.media/raw/video_480x360_mp4_h264_871kbps_30fps";
+
+    private final boolean DEBUG = false;
+
+    abstract class VideoProcessorBase extends MediaCodec.Callback {
+        private static final String TAG = "VideoProcessorBase";
+
+        private MediaExtractor mExtractor;
+        private ByteBuffer mBuffer = ByteBuffer.allocate(MAX_SAMPLE_SIZE);
+        private int mTrackIndex = -1;
+        private boolean mSignaledDecoderEOS;
+
+        protected boolean mCompleted;
+        protected final Object mCondition = new Object();
+
+        protected MediaFormat mDecFormat;
+        protected MediaCodec mDecoder, mEncoder;
+
+        protected void open(String path) throws IOException {
+            mExtractor = new MediaExtractor();
+            if (path.startsWith("android.resource://")) {
+                mExtractor.setDataSource(mContext, Uri.parse(path), null);
+            } else {
+                mExtractor.setDataSource(path);
+            }
+
+            for (int i = 0; i < mExtractor.getTrackCount(); i++) {
+                MediaFormat fmt = mExtractor.getTrackFormat(i);
+                String mime = fmt.getString(MediaFormat.KEY_MIME).toLowerCase();
+                if (mime.startsWith("video/")) {
+                    mTrackIndex = i;
+                    mDecFormat = fmt;
+                    mExtractor.selectTrack(i);
+                    break;
+                }
+            }
+            assertTrue("file " + path + " has no video", mTrackIndex >= 0);
+        }
+
+        // returns true if encoder supports the size
+        protected boolean initCodecsAndConfigureEncoder(
+                String videoEncName, String outMime, int width, int height, int colorFormat)
+                        throws IOException {
+            mDecFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, colorFormat);
+
+            MediaCodecList mcl = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
+            String videoDecName = mcl.findDecoderForFormat(mDecFormat);
+            Log.i(TAG, "decoder for " + mDecFormat + " is " + videoDecName);
+            mDecoder = MediaCodec.createByCodecName(videoDecName);
+            mEncoder = MediaCodec.createByCodecName(videoEncName);
+
+            mDecoder.setCallback(this);
+            mEncoder.setCallback(this);
+
+            MediaCodecInfo.VideoCapabilities encCaps =
+                mEncoder.getCodecInfo().getCapabilitiesForType(outMime).getVideoCapabilities();
+            if (!encCaps.isSizeSupported(width, height)) {
+                Log.i(TAG, videoEncName + " does not support size: " + width + "x" + height);
+                return false;
+            }
+
+            MediaFormat outFmt = MediaFormat.createVideoFormat(outMime, width, height);
+
+            {
+                int maxWidth = encCaps.getSupportedWidths().getUpper();
+                int maxHeight = encCaps.getSupportedHeightsFor(maxWidth).getUpper();
+                int maxRate =
+                    encCaps.getSupportedFrameRatesFor(maxWidth, maxHeight).getUpper().intValue();
+                outFmt.setInteger(MediaFormat.KEY_FRAME_RATE, Math.min(30, maxRate));
+                int bitRate = encCaps.getBitrateRange().clamp(
+                        (int)(encCaps.getBitrateRange().getUpper() /
+                                Math.sqrt(maxWidth * maxHeight / width / height)));
+                Log.d(TAG, "max rate = " + maxRate + ", bit rate = " + bitRate);
+                outFmt.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
+            }
+            outFmt.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);
+            outFmt.setInteger(MediaFormat.KEY_COLOR_FORMAT, colorFormat);
+            mEncoder.configure(outFmt, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
+            Log.i(TAG, "encoder input format " + mEncoder.getInputFormat() + " from " + outFmt);
+            return true;
+        }
+
+        protected void close() {
+            if (mDecoder != null) {
+                mDecoder.release();
+                mDecoder = null;
+            }
+            if (mEncoder != null) {
+                mEncoder.release();
+                mEncoder = null;
+            }
+            if (mExtractor != null) {
+                mExtractor.release();
+                mExtractor = null;
+            }
+        }
+
+        // returns true if filled buffer
+        protected boolean fillDecoderInputBuffer(int ix) {
+            if (DEBUG) Log.v(TAG, "decoder received input #" + ix);
+            while (!mSignaledDecoderEOS) {
+                int track = mExtractor.getSampleTrackIndex();
+                if (track >= 0 && track != mTrackIndex) {
+                    mExtractor.advance();
+                    continue;
+                }
+                int size = mExtractor.readSampleData(mBuffer, 0);
+                if (size < 0) {
+                    // queue decoder input EOS
+                    if (DEBUG) Log.v(TAG, "queuing decoder EOS");
+                    mDecoder.queueInputBuffer(
+                            ix, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
+                    mSignaledDecoderEOS = true;
+                } else {
+                    mBuffer.limit(size);
+                    mBuffer.position(0);
+                    BufferInfo info = new BufferInfo();
+                    info.set(
+                            0, mBuffer.limit(), mExtractor.getSampleTime(),
+                            mExtractor.getSampleFlags());
+                    mDecoder.getInputBuffer(ix).put(mBuffer);
+                    if (DEBUG) Log.v(TAG, "queing input #" + ix + " for decoder with timestamp "
+                            + info.presentationTimeUs);
+                    mDecoder.queueInputBuffer(
+                            ix, 0, mBuffer.limit(), info.presentationTimeUs, 0);
+                }
+                mExtractor.advance();
+                return true;
+            }
+            return false;
+        }
+
+        protected void emptyEncoderOutputBuffer(int ix, BufferInfo info) {
+            if (DEBUG) Log.v(TAG, "encoder received output #" + ix
+                     + " (sz=" + info.size + ", f=" + info.flags
+                     + ", ts=" + info.presentationTimeUs + ")");
+            if (!mCompleted) {
+                mEncoder.releaseOutputBuffer(ix, false);
+                if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
+                    Log.d(TAG, "encoder received output EOS");
+                    synchronized(mCondition) {
+                        mCompleted = true;
+                        mCondition.notifyAll(); // condition is always satisfied
+                    }
+                }
+            }
+        }
+
+        public abstract boolean processLoop(
+                String path, String outMime, String videoEncName,
+                int width, int height, boolean optional);
+    };
+
+    class VideoProcessor extends VideoProcessorBase {
+        private static final String TAG = "VideoProcessor";
+        private boolean mWorkInProgress;
+        private boolean mGotDecoderEOS;
+        private boolean mSignaledEncoderEOS;
+
+        private LinkedList<Pair<Integer, BufferInfo>> mBuffersToRender =
+            new LinkedList<Pair<Integer, BufferInfo>>();
+        private LinkedList<Integer> mEncInputBuffers = new LinkedList<Integer>();
+
+        private int mEncInputBufferSize = -1;
+
+        @Override
+        public boolean processLoop(
+                 String path, String outMime, String videoEncName,
+                 int width, int height, boolean optional) {
+            boolean skipped = true;
+            try {
+                open(path);
+                if (!initCodecsAndConfigureEncoder(
+                        videoEncName, outMime, width, height,
+                        CodecCapabilities.COLOR_FormatYUV420Flexible)) {
+                    assertTrue("could not configure encoder for supported size", optional);
+                    return !skipped;
+                }
+                skipped = false;
+
+                mDecoder.configure(mDecFormat, null /* surface */, null /* crypto */, 0);
+
+                mDecoder.start();
+                mEncoder.start();
+
+                // main loop - process GL ops as only main thread has GL context
+                while (!mCompleted) {
+                    Pair<Integer, BufferInfo> decBuffer = null;
+                    int encBuffer = -1;
+                    synchronized (mCondition) {
+                        try {
+                            // wait for an encoder input buffer and a decoder output buffer
+                            // Use a timeout to avoid stalling the test if it doesn't arrive.
+                            if (!haveBuffers() && !mCompleted) {
+                                mCondition.wait(FRAME_TIMEOUT_MS);
+                            }
+                        } catch (InterruptedException ie) {
+                            fail("wait interrupted");  // shouldn't happen
+                        }
+                        if (mCompleted) {
+                            break;
+                        }
+                        if (!haveBuffers()) {
+                            fail("timed out after " + mBuffersToRender.size()
+                                    + " decoder output and " + mEncInputBuffers.size()
+                                    + " encoder input buffers");
+                        }
+
+                        if (DEBUG) Log.v(TAG, "got image");
+                        decBuffer = mBuffersToRender.removeFirst();
+                        encBuffer = mEncInputBuffers.removeFirst();
+                        if (isEOSOnlyBuffer(decBuffer)) {
+                            queueEncoderEOS(decBuffer, encBuffer);
+                            continue;
+                        }
+                        mWorkInProgress = true;
+                    }
+
+                    if (mWorkInProgress) {
+                        renderDecodedBuffer(decBuffer, encBuffer);
+                        synchronized(mCondition) {
+                            mWorkInProgress = false;
+                        }
+                    }
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+                fail("received exception " + e);
+            } finally {
+                close();
+            }
+            return !skipped;
+        }
+
+        @Override
+        public void onInputBufferAvailable(MediaCodec mediaCodec, int ix) {
+            if (mediaCodec == mDecoder) {
+                // fill input buffer from extractor
+                fillDecoderInputBuffer(ix);
+            } else if (mediaCodec == mEncoder) {
+                synchronized(mCondition) {
+                    mEncInputBuffers.addLast(ix);
+                    tryToPropagateEOS();
+                    if (haveBuffers()) {
+                        mCondition.notifyAll();
+                    }
+                }
+            } else {
+                fail("received input buffer on " + mediaCodec.getName());
+            }
+        }
+
+        @Override
+        public void onOutputBufferAvailable(
+                MediaCodec mediaCodec, int ix, BufferInfo info) {
+            if (mediaCodec == mDecoder) {
+                if (DEBUG) Log.v(TAG, "decoder received output #" + ix
+                         + " (sz=" + info.size + ", f=" + info.flags
+                         + ", ts=" + info.presentationTimeUs + ")");
+                // render output buffer from decoder
+                if (!mGotDecoderEOS) {
+                    boolean eos = (info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
+                    // can release empty buffers now
+                    if (info.size == 0) {
+                        mDecoder.releaseOutputBuffer(ix, false /* render */);
+                        ix = -1; // dummy index used by render to not render
+                    }
+                    synchronized(mCondition) {
+                        if (ix < 0 && eos && mBuffersToRender.size() > 0) {
+                            // move lone EOS flag to last buffer to be rendered
+                            mBuffersToRender.peekLast().second.flags |=
+                                MediaCodec.BUFFER_FLAG_END_OF_STREAM;
+                        } else if (ix >= 0 || eos) {
+                            mBuffersToRender.addLast(Pair.create(ix, info));
+                        }
+                        if (eos) {
+                            tryToPropagateEOS();
+                            mGotDecoderEOS = true;
+                        }
+                        if (haveBuffers()) {
+                            mCondition.notifyAll();
+                        }
+                    }
+                }
+            } else if (mediaCodec == mEncoder) {
+                emptyEncoderOutputBuffer(ix, info);
+            } else {
+                fail("received output buffer on " + mediaCodec.getName());
+            }
+        }
+
+        private void renderDecodedBuffer(Pair<Integer, BufferInfo> decBuffer, int encBuffer) {
+            // process heavyweight actions under instance lock
+            Image encImage = mEncoder.getInputImage(encBuffer);
+            Image decImage = mDecoder.getOutputImage(decBuffer.first);
+            assertNotNull("could not get encoder image for " + mEncoder.getInputFormat(), encImage);
+            assertNotNull("could not get decoder image for " + mDecoder.getInputFormat(), decImage);
+            assertEquals("incorrect decoder format",decImage.getFormat(), ImageFormat.YUV_420_888);
+            assertEquals("incorrect encoder format", encImage.getFormat(), ImageFormat.YUV_420_888);
+
+            CodecUtils.copyFlexYUVImage(encImage, decImage);
+
+            // TRICKY: need this for queueBuffer
+            if (mEncInputBufferSize < 0) {
+                mEncInputBufferSize = mEncoder.getInputBuffer(encBuffer).capacity();
+            }
+            Log.d(TAG, "queuing output #" + encBuffer + " for encoder (sz="
+                    + mEncInputBufferSize + ", f=" + decBuffer.second.flags
+                    + ", ts=" + decBuffer.second.presentationTimeUs + ")");
+            mEncoder.queueInputBuffer(
+                    encBuffer, 0, mEncInputBufferSize, decBuffer.second.presentationTimeUs,
+                    decBuffer.second.flags);
+            if ((decBuffer.second.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
+                mSignaledEncoderEOS = true;
+            }
+            mDecoder.releaseOutputBuffer(decBuffer.first, false /* render */);
+        }
+
+        @Override
+        public void onError(MediaCodec mediaCodec, MediaCodec.CodecException e) {
+            fail("received error on " + mediaCodec.getName() + ": " + e);
+        }
+
+        @Override
+        public void onOutputFormatChanged(MediaCodec mediaCodec, MediaFormat mediaFormat) {
+            Log.i(TAG, mediaCodec.getName() + " got new output format " + mediaFormat);
+        }
+
+        // next methods are synchronized on mCondition
+        private boolean haveBuffers() {
+            return mEncInputBuffers.size() > 0 && mBuffersToRender.size() > 0
+                    && !mSignaledEncoderEOS;
+        }
+
+        private boolean isEOSOnlyBuffer(Pair<Integer, BufferInfo> decBuffer) {
+            return decBuffer.first < 0 || decBuffer.second.size == 0;
+        }
+
+        protected void tryToPropagateEOS() {
+            if (!mWorkInProgress && haveBuffers() && isEOSOnlyBuffer(mBuffersToRender.getFirst())) {
+                Pair<Integer, BufferInfo> decBuffer = mBuffersToRender.removeFirst();
+                int encBuffer = mEncInputBuffers.removeFirst();
+                queueEncoderEOS(decBuffer, encBuffer);
+            }
+        }
+
+        void queueEncoderEOS(Pair<Integer, BufferInfo> decBuffer, int encBuffer) {
+            Log.d(TAG, "signaling encoder EOS");
+            mEncoder.queueInputBuffer(encBuffer, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
+            mSignaledEncoderEOS = true;
+            if (decBuffer.first >= 0) {
+                mDecoder.releaseOutputBuffer(decBuffer.first, false /* render */);
+            }
+        }
+    }
+
+
+    class SurfaceVideoProcessor extends VideoProcessorBase
+            implements SurfaceTexture.OnFrameAvailableListener {
+        private static final String TAG = "SurfaceVideoProcessor";
+        private boolean mFrameAvailable;
+        private boolean mGotDecoderEOS;
+        private boolean mSignaledEncoderEOS;
+
+        private InputSurface mEncSurface;
+        private OutputSurface mDecSurface;
+        private BufferInfo mInfoOnSurface;
+
+        private LinkedList<Pair<Integer, BufferInfo>> mBuffersToRender =
+            new LinkedList<Pair<Integer, BufferInfo>>();
+
+        @Override
+        public boolean processLoop(
+                String path, String outMime, String videoEncName,
+                int width, int height, boolean optional) {
+            boolean skipped = true;
+            try {
+                open(path);
+                if (!initCodecsAndConfigureEncoder(
+                        videoEncName, outMime, width, height,
+                        CodecCapabilities.COLOR_FormatSurface)) {
+                    assertTrue("could not configure encoder for supported size", optional);
+                    return !skipped;
+                }
+                skipped = false;
+
+                mEncSurface = new InputSurface(mEncoder.createInputSurface());
+                mEncSurface.makeCurrent();
+
+                mDecSurface = new OutputSurface(this);
+                //mDecSurface.changeFragmentShader(FRAGMENT_SHADER);
+                mDecoder.configure(mDecFormat, mDecSurface.getSurface(), null /* crypto */, 0);
+
+                mDecoder.start();
+                mEncoder.start();
+
+                // main loop - process GL ops as only main thread has GL context
+                while (!mCompleted) {
+                    BufferInfo info = null;
+                    synchronized (mCondition) {
+                        try {
+                            // wait for mFrameAvailable, which is set by onFrameAvailable().
+                            // Use a timeout to avoid stalling the test if it doesn't arrive.
+                            if (!mFrameAvailable && !mCompleted) {
+                                mCondition.wait(FRAME_TIMEOUT_MS);
+                            }
+                        } catch (InterruptedException ie) {
+                            fail("wait interrupted");  // shouldn't happen
+                        }
+                        if (mCompleted) {
+                            break;
+                        }
+                        assertTrue("still waiting for image", mFrameAvailable);
+                        if (DEBUG) Log.v(TAG, "got image");
+                        info = mInfoOnSurface;
+                    }
+                    if (info == null) {
+                        continue;
+                    }
+                    if (info.size > 0) {
+                        mDecSurface.latchImage();
+                        if (DEBUG) Log.v(TAG, "latched image");
+                        mFrameAvailable = false;
+
+                        mDecSurface.drawImage();
+                        Log.d(TAG, "encoding frame at " + info.presentationTimeUs * 1000);
+
+                        mEncSurface.setPresentationTime(info.presentationTimeUs * 1000);
+                        mEncSurface.swapBuffers();
+                    }
+                    if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
+                        mSignaledEncoderEOS = true;
+                        Log.d(TAG, "signaling encoder EOS");
+                        mEncoder.signalEndOfInputStream();
+                    }
+
+                    synchronized (mCondition) {
+                        mInfoOnSurface = null;
+                        if (mBuffersToRender.size() > 0 && mInfoOnSurface == null) {
+                            if (DEBUG) Log.v(TAG, "handling postponed frame");
+                            Pair<Integer, BufferInfo> nextBuffer = mBuffersToRender.removeFirst();
+                            renderDecodedBuffer(nextBuffer.first, nextBuffer.second);
+                        }
+                    }
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+                fail("received exception " + e);
+            } finally {
+                close();
+                if (mEncSurface != null) {
+                    mEncSurface.release();
+                    mEncSurface = null;
+                }
+                if (mDecSurface != null) {
+                    mDecSurface.release();
+                    mDecSurface = null;
+                }
+            }
+            return !skipped;
+        }
+
+        @Override
+        public void onFrameAvailable(SurfaceTexture st) {
+            if (DEBUG) Log.v(TAG, "new frame available");
+            synchronized (mCondition) {
+                assertFalse("mFrameAvailable already set, frame could be dropped", mFrameAvailable);
+                mFrameAvailable = true;
+                mCondition.notifyAll();
+            }
+        }
+
+        @Override
+        public void onInputBufferAvailable(MediaCodec mediaCodec, int ix) {
+            if (mediaCodec == mDecoder) {
+                // fill input buffer from extractor
+                fillDecoderInputBuffer(ix);
+            } else {
+                fail("received input buffer on " + mediaCodec.getName());
+            }
+        }
+
+        @Override
+        public void onOutputBufferAvailable(
+                MediaCodec mediaCodec, int ix, BufferInfo info) {
+            if (mediaCodec == mDecoder) {
+                if (DEBUG) Log.v(TAG, "decoder received output #" + ix
+                         + " (sz=" + info.size + ", f=" + info.flags
+                         + ", ts=" + info.presentationTimeUs + ")");
+                // render output buffer from decoder
+                if (!mGotDecoderEOS) {
+                    boolean eos = (info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
+                    if (eos) {
+                        mGotDecoderEOS = true;
+                    }
+                    // can release empty buffers now
+                    if (info.size == 0) {
+                        mDecoder.releaseOutputBuffer(ix, false /* render */);
+                        ix = -1; // dummy index used by render to not render
+                    }
+                    if (eos || info.size > 0) {
+                        synchronized(mCondition) {
+                            if (mInfoOnSurface != null || mBuffersToRender.size() > 0) {
+                                if (DEBUG) Log.v(TAG, "postponing render, surface busy");
+                                mBuffersToRender.addLast(Pair.create(ix, info));
+                            } else {
+                                renderDecodedBuffer(ix, info);
+                            }
+                        }
+                    }
+                }
+            } else if (mediaCodec == mEncoder) {
+                emptyEncoderOutputBuffer(ix, info);
+            } else {
+                fail("received output buffer on " + mediaCodec.getName());
+            }
+        }
+
+        private void renderDecodedBuffer(int ix, BufferInfo info) {
+            boolean eos = (info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
+            mInfoOnSurface = info;
+            if (info.size > 0) {
+                Log.d(TAG, "rendering frame #" + ix + " at " + info.presentationTimeUs * 1000
+                        + (eos ? " with EOS" : ""));
+                mDecoder.releaseOutputBuffer(ix, info.presentationTimeUs * 1000);
+            }
+
+            if (eos && info.size == 0) {
+                if (DEBUG) Log.v(TAG, "decoder output EOS available");
+                mFrameAvailable = true;
+                mCondition.notifyAll();
+            }
+        }
+
+        @Override
+        public void onError(MediaCodec mediaCodec, MediaCodec.CodecException e) {
+            fail("received error on " + mediaCodec.getName() + ": " + e);
+        }
+
+        @Override
+        public void onOutputFormatChanged(MediaCodec mediaCodec, MediaFormat mediaFormat) {
+            Log.i(TAG, mediaCodec.getName() + " got new output format " + mediaFormat);
+        }
+    }
+
+    class Encoder {
+        final private String mName;
+        final private String mMime;
+        final private VideoCapabilities mCaps;
+
+        final private Map<Size, Set<Size>> mMinMax;     // extreme sizes
+        final private Map<Size, Set<Size>> mNearMinMax; // sizes near extreme
+        final private Set<Size> mArbitrary;             // arbitrary sizes in the middle
+        final private Set<Size> mSizes;                 // all non-specifically tested sizes
+
+        final private int xAlign;
+        final private int yAlign;
+
+        Encoder(String name, String mime, CodecCapabilities caps) {
+            mName = name;
+            mMime = mime;
+            mCaps = caps.getVideoCapabilities();
+
+            /* calculate min/max sizes */
+            mMinMax = new HashMap<Size, Set<Size>>();
+            mNearMinMax = new HashMap<Size, Set<Size>>();
+            mArbitrary = new HashSet<Size>();
+            mSizes = new HashSet<Size>();
+
+            xAlign = mCaps.getWidthAlignment();
+            yAlign = mCaps.getHeightAlignment();
+
+            initializeSizes();
+        }
+
+        private void initializeSizes() {
+            for (int x = 0; x < 2; ++x) {
+                for (int y = 0; y < 2; ++y) {
+                    addExtremeSizesFor(x, y);
+                }
+            }
+
+            // initialize arbitrary sizes
+            for (int i = 1; i <= 7; ++i) {
+                int j = ((7 * i) % 11) + 1;
+                int width = alignedPointInRange(i * 0.125, xAlign, mCaps.getSupportedWidths());
+                int height = alignedPointInRange(
+                        j * 0.077, yAlign, mCaps.getSupportedHeightsFor(width));
+                mArbitrary.add(new Size(width, height));
+
+                height = alignedPointInRange(i * 0.125, yAlign, mCaps.getSupportedHeights());
+                width = alignedPointInRange(j * 0.077, xAlign, mCaps.getSupportedWidthsFor(height));
+                mArbitrary.add(new Size(width, height));
+            }
+            mArbitrary.removeAll(mSizes);
+            mSizes.addAll(mArbitrary);
+            if (DEBUG) Log.i(TAG, "arbitrary=" + mArbitrary);
+        }
+
+        private void addExtremeSizesFor(int x, int y) {
+            Set<Size> minMax = new HashSet<Size>();
+            Set<Size> nearMinMax = new HashSet<Size>();
+
+            for (int dx = 0; dx <= xAlign; dx += xAlign) {
+                for (int dy = 0; dy <= yAlign; dy += yAlign) {
+                    Set<Size> bucket = (dx + dy == 0) ? minMax : nearMinMax;
+                    try {
+                        int width = getExtreme(mCaps.getSupportedWidths(), x, dx);
+                        int height = getExtreme(mCaps.getSupportedHeightsFor(width), y, dy);
+                        bucket.add(new Size(width, height));
+
+                        // try max max with more reasonable ratio if too skewed
+                        if (x + y == 2 && width >= 4 * height) {
+                            Size wideScreen = getLargestSizeForRatio(16, 9);
+                            width = getExtreme(
+                                    mCaps.getSupportedWidths()
+                                            .intersect(0, wideScreen.getWidth()), x, dx);
+                            height = getExtreme(mCaps.getSupportedHeightsFor(width), y, 0);
+                            bucket.add(new Size(width, height));
+                        }
+                    } catch (IllegalArgumentException e) {
+                    }
+
+                    try {
+                        int height = getExtreme(mCaps.getSupportedHeights(), y, dy);
+                        int width = getExtreme(mCaps.getSupportedWidthsFor(height), x, dx);
+                        bucket.add(new Size(width, height));
+
+                        // try max max with more reasonable ratio if too skewed
+                        if (x + y == 2 && height >= 4 * width) {
+                            Size wideScreen = getLargestSizeForRatio(9, 16);
+                            height = getExtreme(
+                                    mCaps.getSupportedHeights()
+                                            .intersect(0, wideScreen.getHeight()), y, dy);
+                            width = getExtreme(mCaps.getSupportedWidthsFor(height), x, dx);
+                            bucket.add(new Size(width, height));
+                        }
+                    } catch (IllegalArgumentException e) {
+                    }
+                }
+            }
+
+            // keep unique sizes
+            minMax.removeAll(mSizes);
+            mSizes.addAll(minMax);
+            nearMinMax.removeAll(mSizes);
+            mSizes.addAll(nearMinMax);
+
+            mMinMax.put(new Size(x, y), minMax);
+            mNearMinMax.put(new Size(x, y), nearMinMax);
+            if (DEBUG) Log.i(TAG, x + "x" + y + ": minMax=" + mMinMax + ", near=" + mNearMinMax);
+        }
+
+        private int alignInRange(double value, int align, Range<Integer> range) {
+            return range.clamp(align * (int)Math.round(value / align));
+        }
+
+        /* point should be between 0. and 1. */
+        private int alignedPointInRange(double point, int align, Range<Integer> range) {
+            return alignInRange(
+                    range.getLower() + point * (range.getUpper() - range.getLower()), align, range);
+        }
+
+        private int getExtreme(Range<Integer> range, int i, int delta) {
+            int dim = i == 1 ? range.getUpper() - delta : range.getLower() + delta;
+            if (delta == 0
+                    || (dim > range.getLower() && dim < range.getUpper())) {
+                return dim;
+            }
+            throw new IllegalArgumentException();
+        }
+
+        private Size getLargestSizeForRatio(int x, int y) {
+            Range<Integer> widthRange = mCaps.getSupportedWidths();
+            Range<Integer> heightRange = mCaps.getSupportedHeightsFor(widthRange.getUpper());
+            final int xAlign = mCaps.getWidthAlignment();
+            final int yAlign = mCaps.getHeightAlignment();
+
+            // scale by alignment
+            int width = alignInRange(
+                    Math.sqrt(widthRange.getUpper() * heightRange.getUpper() * (double)x / y),
+                    xAlign, widthRange);
+            int height = alignInRange(
+                    width * (double)y / x, yAlign, mCaps.getSupportedHeightsFor(width));
+            return new Size(width, height);
+        }
+
+
+        public boolean testExtreme(int x, int y, boolean flexYUV, boolean near) {
+            boolean skipped = true;
+            for (Size s : (near ? mNearMinMax : mMinMax).get(new Size(x, y))) {
+                if (test(s.getWidth(), s.getHeight(), false /* optional */, flexYUV)) {
+                    skipped = false;
+                }
+            }
+            return !skipped;
+        }
+
+        public boolean testArbitrary(boolean flexYUV) {
+            boolean skipped = true;
+            for (Size s : mArbitrary) {
+                if (test(s.getWidth(), s.getHeight(), false /* optional */, flexYUV)) {
+                    skipped = false;
+                }
+            }
+            return !skipped;
+        }
+
+        public boolean testSpecific(int width, int height, boolean flexYUV) {
+            // already tested by one of the min/max tests
+            if (mSizes.contains(new Size(width, height))) {
+                return false;
+            }
+            return test(width, height, true /* optional */, flexYUV);
+        }
+
+        private boolean test(int width, int height, boolean optional, boolean flexYUV) {
+            Log.i(TAG, "testing " + mMime + " on " + mName + " for " + width + "x" + height
+                    + (flexYUV ? " flexYUV" : " surface"));
+
+            VideoProcessorBase processor =
+                flexYUV ? new VideoProcessor() : new SurfaceVideoProcessor();
+
+            // We are using a resource URL as an example
+            return processor.processLoop(
+                    SOURCE_URL, mMime, mName, width, height, optional);
+        }
+
+    }
+
+    private Encoder[] googH265()  { return goog(MediaFormat.MIMETYPE_VIDEO_HEVC); }
+    private Encoder[] googH264()  { return goog(MediaFormat.MIMETYPE_VIDEO_AVC); }
+    private Encoder[] googH263()  { return goog(MediaFormat.MIMETYPE_VIDEO_H263); }
+    private Encoder[] googMpeg4() { return goog(MediaFormat.MIMETYPE_VIDEO_MPEG4); }
+    private Encoder[] googVP8()   { return goog(MediaFormat.MIMETYPE_VIDEO_VP8); }
+    private Encoder[] googVP9()   { return goog(MediaFormat.MIMETYPE_VIDEO_VP9); }
+
+    private Encoder[] otherH265()  { return other(MediaFormat.MIMETYPE_VIDEO_HEVC); }
+    private Encoder[] otherH264()  { return other(MediaFormat.MIMETYPE_VIDEO_AVC); }
+    private Encoder[] otherH263()  { return other(MediaFormat.MIMETYPE_VIDEO_H263); }
+    private Encoder[] otherMpeg4() { return other(MediaFormat.MIMETYPE_VIDEO_MPEG4); }
+    private Encoder[] otherVP8()   { return other(MediaFormat.MIMETYPE_VIDEO_VP8); }
+    private Encoder[] otherVP9()   { return other(MediaFormat.MIMETYPE_VIDEO_VP9); }
+
+    private Encoder[] goog(String mime) {
+        return encoders(mime, true /* goog */);
+    }
+
+    private Encoder[] other(String mime) {
+        return encoders(mime, false /* goog */);
+    }
+
+    private Encoder[] encoders(String mime, boolean goog) {
+        MediaCodecList mcl = new MediaCodecList(MediaCodecList.REGULAR_CODECS);
+        ArrayList<Encoder> result = new ArrayList<Encoder>();
+
+        for (MediaCodecInfo info : mcl.getCodecInfos()) {
+            if (!info.isEncoder()
+                    || info.getName().toLowerCase().startsWith("omx.google.") != goog) {
+                continue;
+            }
+            try {
+                CodecCapabilities caps = info.getCapabilitiesForType(mime);
+                result.add(new Encoder(info.getName(), mime, caps));
+            } catch (IllegalArgumentException e) { // mime is not supported
+            }
+        }
+        return result.toArray(new Encoder[result.size()]);
+    }
+
+    public void testGoogH265FlexMinMin()   { minmin(googH265(),   true /* flex */); }
+    public void testGoogH265SurfMinMin()   { minmin(googH265(),   false /* flex */); }
+    public void testGoogH264FlexMinMin()   { minmin(googH264(),   true /* flex */); }
+    public void testGoogH264SurfMinMin()   { minmin(googH264(),   false /* flex */); }
+    public void testGoogH263FlexMinMin()   { minmin(googH263(),   true /* flex */); }
+    public void testGoogH263SurfMinMin()   { minmin(googH263(),   false /* flex */); }
+    public void testGoogMpeg4FlexMinMin()  { minmin(googMpeg4(),  true /* flex */); }
+    public void testGoogMpeg4SurfMinMin()  { minmin(googMpeg4(),  false /* flex */); }
+    public void testGoogVP8FlexMinMin()    { minmin(googVP8(),    true /* flex */); }
+    public void testGoogVP8SurfMinMin()    { minmin(googVP8(),    false /* flex */); }
+    public void testGoogVP9FlexMinMin()    { minmin(googVP9(),    true /* flex */); }
+    public void testGoogVP9SurfMinMin()    { minmin(googVP9(),    false /* flex */); }
+
+    public void testOtherH265FlexMinMin()  { minmin(otherH265(),  true /* flex */); }
+    public void testOtherH265SurfMinMin()  { minmin(otherH265(),  false /* flex */); }
+    public void testOtherH264FlexMinMin()  { minmin(otherH264(),  true /* flex */); }
+    public void testOtherH264SurfMinMin()  { minmin(otherH264(),  false /* flex */); }
+    public void testOtherH263FlexMinMin()  { minmin(otherH263(),  true /* flex */); }
+    public void testOtherH263SurfMinMin()  { minmin(otherH263(),  false /* flex */); }
+    public void testOtherMpeg4FlexMinMin() { minmin(otherMpeg4(), true /* flex */); }
+    public void testOtherMpeg4SurfMinMin() { minmin(otherMpeg4(), false /* flex */); }
+    public void testOtherVP8FlexMinMin()   { minmin(otherVP8(),   true /* flex */); }
+    public void testOtherVP8SurfMinMin()   { minmin(otherVP8(),   false /* flex */); }
+    public void testOtherVP9FlexMinMin()   { minmin(otherVP9(),   true /* flex */); }
+    public void testOtherVP9SurfMinMin()   { minmin(otherVP9(),   false /* flex */); }
+
+    public void testGoogH265FlexMinMax()   { minmax(googH265(),   true /* flex */); }
+    public void testGoogH265SurfMinMax()   { minmax(googH265(),   false /* flex */); }
+    public void testGoogH264FlexMinMax()   { minmax(googH264(),   true /* flex */); }
+    public void testGoogH264SurfMinMax()   { minmax(googH264(),   false /* flex */); }
+    public void testGoogH263FlexMinMax()   { minmax(googH263(),   true /* flex */); }
+    public void testGoogH263SurfMinMax()   { minmax(googH263(),   false /* flex */); }
+    public void testGoogMpeg4FlexMinMax()  { minmax(googMpeg4(),  true /* flex */); }
+    public void testGoogMpeg4SurfMinMax()  { minmax(googMpeg4(),  false /* flex */); }
+    public void testGoogVP8FlexMinMax()    { minmax(googVP8(),    true /* flex */); }
+    public void testGoogVP8SurfMinMax()    { minmax(googVP8(),    false /* flex */); }
+    public void testGoogVP9FlexMinMax()    { minmax(googVP9(),    true /* flex */); }
+    public void testGoogVP9SurfMinMax()    { minmax(googVP9(),    false /* flex */); }
+
+    public void testOtherH265FlexMinMax()  { minmax(otherH265(),  true /* flex */); }
+    public void testOtherH265SurfMinMax()  { minmax(otherH265(),  false /* flex */); }
+    public void testOtherH264FlexMinMax()  { minmax(otherH264(),  true /* flex */); }
+    public void testOtherH264SurfMinMax()  { minmax(otherH264(),  false /* flex */); }
+    public void testOtherH263FlexMinMax()  { minmax(otherH263(),  true /* flex */); }
+    public void testOtherH263SurfMinMax()  { minmax(otherH263(),  false /* flex */); }
+    public void testOtherMpeg4FlexMinMax() { minmax(otherMpeg4(), true /* flex */); }
+    public void testOtherMpeg4SurfMinMax() { minmax(otherMpeg4(), false /* flex */); }
+    public void testOtherVP8FlexMinMax()   { minmax(otherVP8(),   true /* flex */); }
+    public void testOtherVP8SurfMinMax()   { minmax(otherVP8(),   false /* flex */); }
+    public void testOtherVP9FlexMinMax()   { minmax(otherVP9(),   true /* flex */); }
+    public void testOtherVP9SurfMinMax()   { minmax(otherVP9(),   false /* flex */); }
+
+    public void testGoogH265FlexMaxMin()   { maxmin(googH265(),   true /* flex */); }
+    public void testGoogH265SurfMaxMin()   { maxmin(googH265(),   false /* flex */); }
+    public void testGoogH264FlexMaxMin()   { maxmin(googH264(),   true /* flex */); }
+    public void testGoogH264SurfMaxMin()   { maxmin(googH264(),   false /* flex */); }
+    public void testGoogH263FlexMaxMin()   { maxmin(googH263(),   true /* flex */); }
+    public void testGoogH263SurfMaxMin()   { maxmin(googH263(),   false /* flex */); }
+    public void testGoogMpeg4FlexMaxMin()  { maxmin(googMpeg4(),  true /* flex */); }
+    public void testGoogMpeg4SurfMaxMin()  { maxmin(googMpeg4(),  false /* flex */); }
+    public void testGoogVP8FlexMaxMin()    { maxmin(googVP8(),    true /* flex */); }
+    public void testGoogVP8SurfMaxMin()    { maxmin(googVP8(),    false /* flex */); }
+    public void testGoogVP9FlexMaxMin()    { maxmin(googVP9(),    true /* flex */); }
+    public void testGoogVP9SurfMaxMin()    { maxmin(googVP9(),    false /* flex */); }
+
+    public void testOtherH265FlexMaxMin()  { maxmin(otherH265(),  true /* flex */); }
+    public void testOtherH265SurfMaxMin()  { maxmin(otherH265(),  false /* flex */); }
+    public void testOtherH264FlexMaxMin()  { maxmin(otherH264(),  true /* flex */); }
+    public void testOtherH264SurfMaxMin()  { maxmin(otherH264(),  false /* flex */); }
+    public void testOtherH263FlexMaxMin()  { maxmin(otherH263(),  true /* flex */); }
+    public void testOtherH263SurfMaxMin()  { maxmin(otherH263(),  false /* flex */); }
+    public void testOtherMpeg4FlexMaxMin() { maxmin(otherMpeg4(), true /* flex */); }
+    public void testOtherMpeg4SurfMaxMin() { maxmin(otherMpeg4(), false /* flex */); }
+    public void testOtherVP8FlexMaxMin()   { maxmin(otherVP8(),   true /* flex */); }
+    public void testOtherVP8SurfMaxMin()   { maxmin(otherVP8(),   false /* flex */); }
+    public void testOtherVP9FlexMaxMin()   { maxmin(otherVP9(),   true /* flex */); }
+    public void testOtherVP9SurfMaxMin()   { maxmin(otherVP9(),   false /* flex */); }
+
+    public void testGoogH265FlexMaxMax()   { maxmax(googH265(),   true /* flex */); }
+    public void testGoogH265SurfMaxMax()   { maxmax(googH265(),   false /* flex */); }
+    public void testGoogH264FlexMaxMax()   { maxmax(googH264(),   true /* flex */); }
+    public void testGoogH264SurfMaxMax()   { maxmax(googH264(),   false /* flex */); }
+    public void testGoogH263FlexMaxMax()   { maxmax(googH263(),   true /* flex */); }
+    public void testGoogH263SurfMaxMax()   { maxmax(googH263(),   false /* flex */); }
+    public void testGoogMpeg4FlexMaxMax()  { maxmax(googMpeg4(),  true /* flex */); }
+    public void testGoogMpeg4SurfMaxMax()  { maxmax(googMpeg4(),  false /* flex */); }
+    public void testGoogVP8FlexMaxMax()    { maxmax(googVP8(),    true /* flex */); }
+    public void testGoogVP8SurfMaxMax()    { maxmax(googVP8(),    false /* flex */); }
+    public void testGoogVP9FlexMaxMax()    { maxmax(googVP9(),    true /* flex */); }
+    public void testGoogVP9SurfMaxMax()    { maxmax(googVP9(),    false /* flex */); }
+
+    public void testOtherH265FlexMaxMax()  { maxmax(otherH265(),  true /* flex */); }
+    public void testOtherH265SurfMaxMax()  { maxmax(otherH265(),  false /* flex */); }
+    public void testOtherH264FlexMaxMax()  { maxmax(otherH264(),  true /* flex */); }
+    public void testOtherH264SurfMaxMax()  { maxmax(otherH264(),  false /* flex */); }
+    public void testOtherH263FlexMaxMax()  { maxmax(otherH263(),  true /* flex */); }
+    public void testOtherH263SurfMaxMax()  { maxmax(otherH263(),  false /* flex */); }
+    public void testOtherMpeg4FlexMaxMax() { maxmax(otherMpeg4(), true /* flex */); }
+    public void testOtherMpeg4SurfMaxMax() { maxmax(otherMpeg4(), false /* flex */); }
+    public void testOtherVP8FlexMaxMax()   { maxmax(otherVP8(),   true /* flex */); }
+    public void testOtherVP8SurfMaxMax()   { maxmax(otherVP8(),   false /* flex */); }
+    public void testOtherVP9FlexMaxMax()   { maxmax(otherVP9(),   true /* flex */); }
+    public void testOtherVP9SurfMaxMax()   { maxmax(otherVP9(),   false /* flex */); }
+
+    public void testGoogH265FlexNearMinMin()   { nearminmin(googH265(),   true /* flex */); }
+    public void testGoogH265SurfNearMinMin()   { nearminmin(googH265(),   false /* flex */); }
+    public void testGoogH264FlexNearMinMin()   { nearminmin(googH264(),   true /* flex */); }
+    public void testGoogH264SurfNearMinMin()   { nearminmin(googH264(),   false /* flex */); }
+    public void testGoogH263FlexNearMinMin()   { nearminmin(googH263(),   true /* flex */); }
+    public void testGoogH263SurfNearMinMin()   { nearminmin(googH263(),   false /* flex */); }
+    public void testGoogMpeg4FlexNearMinMin()  { nearminmin(googMpeg4(),  true /* flex */); }
+    public void testGoogMpeg4SurfNearMinMin()  { nearminmin(googMpeg4(),  false /* flex */); }
+    public void testGoogVP8FlexNearMinMin()    { nearminmin(googVP8(),    true /* flex */); }
+    public void testGoogVP8SurfNearMinMin()    { nearminmin(googVP8(),    false /* flex */); }
+    public void testGoogVP9FlexNearMinMin()    { nearminmin(googVP9(),    true /* flex */); }
+    public void testGoogVP9SurfNearMinMin()    { nearminmin(googVP9(),    false /* flex */); }
+
+    public void testOtherH265FlexNearMinMin()  { nearminmin(otherH265(),  true /* flex */); }
+    public void testOtherH265SurfNearMinMin()  { nearminmin(otherH265(),  false /* flex */); }
+    public void testOtherH264FlexNearMinMin()  { nearminmin(otherH264(),  true /* flex */); }
+    public void testOtherH264SurfNearMinMin()  { nearminmin(otherH264(),  false /* flex */); }
+    public void testOtherH263FlexNearMinMin()  { nearminmin(otherH263(),  true /* flex */); }
+    public void testOtherH263SurfNearMinMin()  { nearminmin(otherH263(),  false /* flex */); }
+    public void testOtherMpeg4FlexNearMinMin() { nearminmin(otherMpeg4(), true /* flex */); }
+    public void testOtherMpeg4SurfNearMinMin() { nearminmin(otherMpeg4(), false /* flex */); }
+    public void testOtherVP8FlexNearMinMin()   { nearminmin(otherVP8(),   true /* flex */); }
+    public void testOtherVP8SurfNearMinMin()   { nearminmin(otherVP8(),   false /* flex */); }
+    public void testOtherVP9FlexNearMinMin()   { nearminmin(otherVP9(),   true /* flex */); }
+    public void testOtherVP9SurfNearMinMin()   { nearminmin(otherVP9(),   false /* flex */); }
+
+    public void testGoogH265FlexNearMinMax()   { nearminmax(googH265(),   true /* flex */); }
+    public void testGoogH265SurfNearMinMax()   { nearminmax(googH265(),   false /* flex */); }
+    public void testGoogH264FlexNearMinMax()   { nearminmax(googH264(),   true /* flex */); }
+    public void testGoogH264SurfNearMinMax()   { nearminmax(googH264(),   false /* flex */); }
+    public void testGoogH263FlexNearMinMax()   { nearminmax(googH263(),   true /* flex */); }
+    public void testGoogH263SurfNearMinMax()   { nearminmax(googH263(),   false /* flex */); }
+    public void testGoogMpeg4FlexNearMinMax()  { nearminmax(googMpeg4(),  true /* flex */); }
+    public void testGoogMpeg4SurfNearMinMax()  { nearminmax(googMpeg4(),  false /* flex */); }
+    public void testGoogVP8FlexNearMinMax()    { nearminmax(googVP8(),    true /* flex */); }
+    public void testGoogVP8SurfNearMinMax()    { nearminmax(googVP8(),    false /* flex */); }
+    public void testGoogVP9FlexNearMinMax()    { nearminmax(googVP9(),    true /* flex */); }
+    public void testGoogVP9SurfNearMinMax()    { nearminmax(googVP9(),    false /* flex */); }
+
+    public void testOtherH265FlexNearMinMax()  { nearminmax(otherH265(),  true /* flex */); }
+    public void testOtherH265SurfNearMinMax()  { nearminmax(otherH265(),  false /* flex */); }
+    public void testOtherH264FlexNearMinMax()  { nearminmax(otherH264(),  true /* flex */); }
+    public void testOtherH264SurfNearMinMax()  { nearminmax(otherH264(),  false /* flex */); }
+    public void testOtherH263FlexNearMinMax()  { nearminmax(otherH263(),  true /* flex */); }
+    public void testOtherH263SurfNearMinMax()  { nearminmax(otherH263(),  false /* flex */); }
+    public void testOtherMpeg4FlexNearMinMax() { nearminmax(otherMpeg4(), true /* flex */); }
+    public void testOtherMpeg4SurfNearMinMax() { nearminmax(otherMpeg4(), false /* flex */); }
+    public void testOtherVP8FlexNearMinMax()   { nearminmax(otherVP8(),   true /* flex */); }
+    public void testOtherVP8SurfNearMinMax()   { nearminmax(otherVP8(),   false /* flex */); }
+    public void testOtherVP9FlexNearMinMax()   { nearminmax(otherVP9(),   true /* flex */); }
+    public void testOtherVP9SurfNearMinMax()   { nearminmax(otherVP9(),   false /* flex */); }
+
+    public void testGoogH265FlexNearMaxMin()   { nearmaxmin(googH265(),   true /* flex */); }
+    public void testGoogH265SurfNearMaxMin()   { nearmaxmin(googH265(),   false /* flex */); }
+    public void testGoogH264FlexNearMaxMin()   { nearmaxmin(googH264(),   true /* flex */); }
+    public void testGoogH264SurfNearMaxMin()   { nearmaxmin(googH264(),   false /* flex */); }
+    public void testGoogH263FlexNearMaxMin()   { nearmaxmin(googH263(),   true /* flex */); }
+    public void testGoogH263SurfNearMaxMin()   { nearmaxmin(googH263(),   false /* flex */); }
+    public void testGoogMpeg4FlexNearMaxMin()  { nearmaxmin(googMpeg4(),  true /* flex */); }
+    public void testGoogMpeg4SurfNearMaxMin()  { nearmaxmin(googMpeg4(),  false /* flex */); }
+    public void testGoogVP8FlexNearMaxMin()    { nearmaxmin(googVP8(),    true /* flex */); }
+    public void testGoogVP8SurfNearMaxMin()    { nearmaxmin(googVP8(),    false /* flex */); }
+    public void testGoogVP9FlexNearMaxMin()    { nearmaxmin(googVP9(),    true /* flex */); }
+    public void testGoogVP9SurfNearMaxMin()    { nearmaxmin(googVP9(),    false /* flex */); }
+
+    public void testOtherH265FlexNearMaxMin()  { nearmaxmin(otherH265(),  true /* flex */); }
+    public void testOtherH265SurfNearMaxMin()  { nearmaxmin(otherH265(),  false /* flex */); }
+    public void testOtherH264FlexNearMaxMin()  { nearmaxmin(otherH264(),  true /* flex */); }
+    public void testOtherH264SurfNearMaxMin()  { nearmaxmin(otherH264(),  false /* flex */); }
+    public void testOtherH263FlexNearMaxMin()  { nearmaxmin(otherH263(),  true /* flex */); }
+    public void testOtherH263SurfNearMaxMin()  { nearmaxmin(otherH263(),  false /* flex */); }
+    public void testOtherMpeg4FlexNearMaxMin() { nearmaxmin(otherMpeg4(), true /* flex */); }
+    public void testOtherMpeg4SurfNearMaxMin() { nearmaxmin(otherMpeg4(), false /* flex */); }
+    public void testOtherVP8FlexNearMaxMin()   { nearmaxmin(otherVP8(),   true /* flex */); }
+    public void testOtherVP8SurfNearMaxMin()   { nearmaxmin(otherVP8(),   false /* flex */); }
+    public void testOtherVP9FlexNearMaxMin()   { nearmaxmin(otherVP9(),   true /* flex */); }
+    public void testOtherVP9SurfNearMaxMin()   { nearmaxmin(otherVP9(),   false /* flex */); }
+
+    public void testGoogH265FlexNearMaxMax()   { nearmaxmax(googH265(),   true /* flex */); }
+    public void testGoogH265SurfNearMaxMax()   { nearmaxmax(googH265(),   false /* flex */); }
+    public void testGoogH264FlexNearMaxMax()   { nearmaxmax(googH264(),   true /* flex */); }
+    public void testGoogH264SurfNearMaxMax()   { nearmaxmax(googH264(),   false /* flex */); }
+    public void testGoogH263FlexNearMaxMax()   { nearmaxmax(googH263(),   true /* flex */); }
+    public void testGoogH263SurfNearMaxMax()   { nearmaxmax(googH263(),   false /* flex */); }
+    public void testGoogMpeg4FlexNearMaxMax()  { nearmaxmax(googMpeg4(),  true /* flex */); }
+    public void testGoogMpeg4SurfNearMaxMax()  { nearmaxmax(googMpeg4(),  false /* flex */); }
+    public void testGoogVP8FlexNearMaxMax()    { nearmaxmax(googVP8(),    true /* flex */); }
+    public void testGoogVP8SurfNearMaxMax()    { nearmaxmax(googVP8(),    false /* flex */); }
+    public void testGoogVP9FlexNearMaxMax()    { nearmaxmax(googVP9(),    true /* flex */); }
+    public void testGoogVP9SurfNearMaxMax()    { nearmaxmax(googVP9(),    false /* flex */); }
+
+    public void testOtherH265FlexNearMaxMax()  { nearmaxmax(otherH265(),  true /* flex */); }
+    public void testOtherH265SurfNearMaxMax()  { nearmaxmax(otherH265(),  false /* flex */); }
+    public void testOtherH264FlexNearMaxMax()  { nearmaxmax(otherH264(),  true /* flex */); }
+    public void testOtherH264SurfNearMaxMax()  { nearmaxmax(otherH264(),  false /* flex */); }
+    public void testOtherH263FlexNearMaxMax()  { nearmaxmax(otherH263(),  true /* flex */); }
+    public void testOtherH263SurfNearMaxMax()  { nearmaxmax(otherH263(),  false /* flex */); }
+    public void testOtherMpeg4FlexNearMaxMax() { nearmaxmax(otherMpeg4(), true /* flex */); }
+    public void testOtherMpeg4SurfNearMaxMax() { nearmaxmax(otherMpeg4(), false /* flex */); }
+    public void testOtherVP8FlexNearMaxMax()   { nearmaxmax(otherVP8(),   true /* flex */); }
+    public void testOtherVP8SurfNearMaxMax()   { nearmaxmax(otherVP8(),   false /* flex */); }
+    public void testOtherVP9FlexNearMaxMax()   { nearmaxmax(otherVP9(),   true /* flex */); }
+    public void testOtherVP9SurfNearMaxMax()   { nearmaxmax(otherVP9(),   false /* flex */); }
+
+    public void testGoogH265FlexArbitrary()   { arbitrary(googH265(),   true /* flex */); }
+    public void testGoogH265SurfArbitrary()   { arbitrary(googH265(),   false /* flex */); }
+    public void testGoogH264FlexArbitrary()   { arbitrary(googH264(),   true /* flex */); }
+    public void testGoogH264SurfArbitrary()   { arbitrary(googH264(),   false /* flex */); }
+    public void testGoogH263FlexArbitrary()   { arbitrary(googH263(),   true /* flex */); }
+    public void testGoogH263SurfArbitrary()   { arbitrary(googH263(),   false /* flex */); }
+    public void testGoogMpeg4FlexArbitrary()  { arbitrary(googMpeg4(),  true /* flex */); }
+    public void testGoogMpeg4SurfArbitrary()  { arbitrary(googMpeg4(),  false /* flex */); }
+    public void testGoogVP8FlexArbitrary()    { arbitrary(googVP8(),    true /* flex */); }
+    public void testGoogVP8SurfArbitrary()    { arbitrary(googVP8(),    false /* flex */); }
+    public void testGoogVP9FlexArbitrary()    { arbitrary(googVP9(),    true /* flex */); }
+    public void testGoogVP9SurfArbitrary()    { arbitrary(googVP9(),    false /* flex */); }
+
+    public void testOtherH265FlexArbitrary()  { arbitrary(otherH265(),  true /* flex */); }
+    public void testOtherH265SurfArbitrary()  { arbitrary(otherH265(),  false /* flex */); }
+    public void testOtherH264FlexArbitrary()  { arbitrary(otherH264(),  true /* flex */); }
+    public void testOtherH264SurfArbitrary()  { arbitrary(otherH264(),  false /* flex */); }
+    public void testOtherH263FlexArbitrary()  { arbitrary(otherH263(),  true /* flex */); }
+    public void testOtherH263SurfArbitrary()  { arbitrary(otherH263(),  false /* flex */); }
+    public void testOtherMpeg4FlexArbitrary() { arbitrary(otherMpeg4(), true /* flex */); }
+    public void testOtherMpeg4SurfArbitrary() { arbitrary(otherMpeg4(), false /* flex */); }
+    public void testOtherVP8FlexArbitrary()   { arbitrary(otherVP8(),   true /* flex */); }
+    public void testOtherVP8SurfArbitrary()   { arbitrary(otherVP8(),   false /* flex */); }
+    public void testOtherVP9FlexArbitrary()   { arbitrary(otherVP9(),   true /* flex */); }
+    public void testOtherVP9SurfArbitrary()   { arbitrary(otherVP9(),   false /* flex */); }
+
+    public void testGoogH265FlexQCIF()   { specific(googH265(),   176, 144, true /* flex */); }
+    public void testGoogH265SurfQCIF()   { specific(googH265(),   176, 144, false /* flex */); }
+    public void testGoogH264FlexQCIF()   { specific(googH264(),   176, 144, true /* flex */); }
+    public void testGoogH264SurfQCIF()   { specific(googH264(),   176, 144, false /* flex */); }
+    public void testGoogH263FlexQCIF()   { specific(googH263(),   176, 144, true /* flex */); }
+    public void testGoogH263SurfQCIF()   { specific(googH263(),   176, 144, false /* flex */); }
+    public void testGoogMpeg4FlexQCIF()  { specific(googMpeg4(),  176, 144, true /* flex */); }
+    public void testGoogMpeg4SurfQCIF()  { specific(googMpeg4(),  176, 144, false /* flex */); }
+    public void testGoogVP8FlexQCIF()    { specific(googVP8(),    176, 144, true /* flex */); }
+    public void testGoogVP8SurfQCIF()    { specific(googVP8(),    176, 144, false /* flex */); }
+    public void testGoogVP9FlexQCIF()    { specific(googVP9(),    176, 144, true /* flex */); }
+    public void testGoogVP9SurfQCIF()    { specific(googVP9(),    176, 144, false /* flex */); }
+
+    public void testOtherH265FlexQCIF()  { specific(otherH265(),  176, 144, true /* flex */); }
+    public void testOtherH265SurfQCIF()  { specific(otherH265(),  176, 144, false /* flex */); }
+    public void testOtherH264FlexQCIF()  { specific(otherH264(),  176, 144, true /* flex */); }
+    public void testOtherH264SurfQCIF()  { specific(otherH264(),  176, 144, false /* flex */); }
+    public void testOtherH263FlexQCIF()  { specific(otherH263(),  176, 144, true /* flex */); }
+    public void testOtherH263SurfQCIF()  { specific(otherH263(),  176, 144, false /* flex */); }
+    public void testOtherMpeg4FlexQCIF() { specific(otherMpeg4(), 176, 144, true /* flex */); }
+    public void testOtherMpeg4SurfQCIF() { specific(otherMpeg4(), 176, 144, false /* flex */); }
+    public void testOtherVP8FlexQCIF()   { specific(otherVP8(),   176, 144, true /* flex */); }
+    public void testOtherVP8SurfQCIF()   { specific(otherVP8(),   176, 144, false /* flex */); }
+    public void testOtherVP9FlexQCIF()   { specific(otherVP9(),   176, 144, true /* flex */); }
+    public void testOtherVP9SurfQCIF()   { specific(otherVP9(),   176, 144, false /* flex */); }
+
+    public void testGoogH265Flex480p()   { specific(googH265(),   720, 480, true /* flex */); }
+    public void testGoogH265Surf480p()   { specific(googH265(),   720, 480, false /* flex */); }
+    public void testGoogH264Flex480p()   { specific(googH264(),   720, 480, true /* flex */); }
+    public void testGoogH264Surf480p()   { specific(googH264(),   720, 480, false /* flex */); }
+    public void testGoogH263Flex480p()   { specific(googH263(),   720, 480, true /* flex */); }
+    public void testGoogH263Surf480p()   { specific(googH263(),   720, 480, false /* flex */); }
+    public void testGoogMpeg4Flex480p()  { specific(googMpeg4(),  720, 480, true /* flex */); }
+    public void testGoogMpeg4Surf480p()  { specific(googMpeg4(),  720, 480, false /* flex */); }
+    public void testGoogVP8Flex480p()    { specific(googVP8(),    720, 480, true /* flex */); }
+    public void testGoogVP8Surf480p()    { specific(googVP8(),    720, 480, false /* flex */); }
+    public void testGoogVP9Flex480p()    { specific(googVP9(),    720, 480, true /* flex */); }
+    public void testGoogVP9Surf480p()    { specific(googVP9(),    720, 480, false /* flex */); }
+
+    public void testOtherH265Flex480p()  { specific(otherH265(),  720, 480, true /* flex */); }
+    public void testOtherH265Surf480p()  { specific(otherH265(),  720, 480, false /* flex */); }
+    public void testOtherH264Flex480p()  { specific(otherH264(),  720, 480, true /* flex */); }
+    public void testOtherH264Surf480p()  { specific(otherH264(),  720, 480, false /* flex */); }
+    public void testOtherH263Flex480p()  { specific(otherH263(),  720, 480, true /* flex */); }
+    public void testOtherH263Surf480p()  { specific(otherH263(),  720, 480, false /* flex */); }
+    public void testOtherMpeg4Flex480p() { specific(otherMpeg4(), 720, 480, true /* flex */); }
+    public void testOtherMpeg4Surf480p() { specific(otherMpeg4(), 720, 480, false /* flex */); }
+    public void testOtherVP8Flex480p()   { specific(otherVP8(),   720, 480, true /* flex */); }
+    public void testOtherVP8Surf480p()   { specific(otherVP8(),   720, 480, false /* flex */); }
+    public void testOtherVP9Flex480p()   { specific(otherVP9(),   720, 480, true /* flex */); }
+    public void testOtherVP9Surf480p()   { specific(otherVP9(),   720, 480, false /* flex */); }
+
+    // even though H.263 and MPEG-4 are not defined for 720p or 1080p
+    // test for it, in case device claims support for it.
+
+    public void testGoogH265Flex720p()   { specific(googH265(),   1280, 720, true /* flex */); }
+    public void testGoogH265Surf720p()   { specific(googH265(),   1280, 720, false /* flex */); }
+    public void testGoogH264Flex720p()   { specific(googH264(),   1280, 720, true /* flex */); }
+    public void testGoogH264Surf720p()   { specific(googH264(),   1280, 720, false /* flex */); }
+    public void testGoogH263Flex720p()   { specific(googH263(),   1280, 720, true /* flex */); }
+    public void testGoogH263Surf720p()   { specific(googH263(),   1280, 720, false /* flex */); }
+    public void testGoogMpeg4Flex720p()  { specific(googMpeg4(),  1280, 720, true /* flex */); }
+    public void testGoogMpeg4Surf720p()  { specific(googMpeg4(),  1280, 720, false /* flex */); }
+    public void testGoogVP8Flex720p()    { specific(googVP8(),    1280, 720, true /* flex */); }
+    public void testGoogVP8Surf720p()    { specific(googVP8(),    1280, 720, false /* flex */); }
+    public void testGoogVP9Flex720p()    { specific(googVP9(),    1280, 720, true /* flex */); }
+    public void testGoogVP9Surf720p()    { specific(googVP9(),    1280, 720, false /* flex */); }
+
+    public void testOtherH265Flex720p()  { specific(otherH265(),  1280, 720, true /* flex */); }
+    public void testOtherH265Surf720p()  { specific(otherH265(),  1280, 720, false /* flex */); }
+    public void testOtherH264Flex720p()  { specific(otherH264(),  1280, 720, true /* flex */); }
+    public void testOtherH264Surf720p()  { specific(otherH264(),  1280, 720, false /* flex */); }
+    public void testOtherH263Flex720p()  { specific(otherH263(),  1280, 720, true /* flex */); }
+    public void testOtherH263Surf720p()  { specific(otherH263(),  1280, 720, false /* flex */); }
+    public void testOtherMpeg4Flex720p() { specific(otherMpeg4(), 1280, 720, true /* flex */); }
+    public void testOtherMpeg4Surf720p() { specific(otherMpeg4(), 1280, 720, false /* flex */); }
+    public void testOtherVP8Flex720p()   { specific(otherVP8(),   1280, 720, true /* flex */); }
+    public void testOtherVP8Surf720p()   { specific(otherVP8(),   1280, 720, false /* flex */); }
+    public void testOtherVP9Flex720p()   { specific(otherVP9(),   1280, 720, true /* flex */); }
+    public void testOtherVP9Surf720p()   { specific(otherVP9(),   1280, 720, false /* flex */); }
+
+    public void testGoogH265Flex1080p()   { specific(googH265(),   1920, 1080, true /* flex */); }
+    public void testGoogH265Surf1080p()   { specific(googH265(),   1920, 1080, false /* flex */); }
+    public void testGoogH264Flex1080p()   { specific(googH264(),   1920, 1080, true /* flex */); }
+    public void testGoogH264Surf1080p()   { specific(googH264(),   1920, 1080, false /* flex */); }
+    public void testGoogH263Flex1080p()   { specific(googH263(),   1920, 1080, true /* flex */); }
+    public void testGoogH263Surf1080p()   { specific(googH263(),   1920, 1080, false /* flex */); }
+    public void testGoogMpeg4Flex1080p()  { specific(googMpeg4(),  1920, 1080, true /* flex */); }
+    public void testGoogMpeg4Surf1080p()  { specific(googMpeg4(),  1920, 1080, false /* flex */); }
+    public void testGoogVP8Flex1080p()    { specific(googVP8(),    1920, 1080, true /* flex */); }
+    public void testGoogVP8Surf1080p()    { specific(googVP8(),    1920, 1080, false /* flex */); }
+    public void testGoogVP9Flex1080p()    { specific(googVP9(),    1920, 1080, true /* flex */); }
+    public void testGoogVP9Surf1080p()    { specific(googVP9(),    1920, 1080, false /* flex */); }
+
+    public void testOtherH265Flex1080p()  { specific(otherH265(),  1920, 1080, true /* flex */); }
+    public void testOtherH265Surf1080p()  { specific(otherH265(),  1920, 1080, false /* flex */); }
+    public void testOtherH264Flex1080p()  { specific(otherH264(),  1920, 1080, true /* flex */); }
+    public void testOtherH264Surf1080p()  { specific(otherH264(),  1920, 1080, false /* flex */); }
+    public void testOtherH263Flex1080p()  { specific(otherH263(),  1920, 1080, true /* flex */); }
+    public void testOtherH263Surf1080p()  { specific(otherH263(),  1920, 1080, false /* flex */); }
+    public void testOtherMpeg4Flex1080p() { specific(otherMpeg4(), 1920, 1080, true /* flex */); }
+    public void testOtherMpeg4Surf1080p() { specific(otherMpeg4(), 1920, 1080, false /* flex */); }
+    public void testOtherVP8Flex1080p()   { specific(otherVP8(),   1920, 1080, true /* flex */); }
+    public void testOtherVP8Surf1080p()   { specific(otherVP8(),   1920, 1080, false /* flex */); }
+    public void testOtherVP9Flex1080p()   { specific(otherVP9(),   1920, 1080, true /* flex */); }
+    public void testOtherVP9Surf1080p()   { specific(otherVP9(),   1920, 1080, false /* flex */); }
+
+    private void minmin(Encoder[] encoders, boolean flexYUV) {
+        extreme(encoders, 0 /* x */, 0 /* y */, flexYUV, false /* near */);
+    }
+
+    private void minmax(Encoder[] encoders, boolean flexYUV) {
+        extreme(encoders, 0 /* x */, 1 /* y */, flexYUV, false /* near */);
+    }
+
+    private void maxmin(Encoder[] encoders, boolean flexYUV) {
+        extreme(encoders, 1 /* x */, 0 /* y */, flexYUV, false /* near */);
+    }
+
+    private void maxmax(Encoder[] encoders, boolean flexYUV) {
+        extreme(encoders, 1 /* x */, 1 /* y */, flexYUV, false /* near */);
+    }
+
+    private void nearminmin(Encoder[] encoders, boolean flexYUV) {
+        extreme(encoders, 0 /* x */, 0 /* y */, flexYUV, true /* near */);
+    }
+
+    private void nearminmax(Encoder[] encoders, boolean flexYUV) {
+        extreme(encoders, 0 /* x */, 1 /* y */, flexYUV, true /* near */);
+    }
+
+    private void nearmaxmin(Encoder[] encoders, boolean flexYUV) {
+        extreme(encoders, 1 /* x */, 0 /* y */, flexYUV, true /* near */);
+    }
+
+    private void nearmaxmax(Encoder[] encoders, boolean flexYUV) {
+        extreme(encoders, 1 /* x */, 1 /* y */, flexYUV, true /* near */);
+    }
+
+    private void extreme(Encoder[] encoders, int x, int y, boolean flexYUV, boolean near) {
+        boolean skipped = true;
+        if (encoders.length == 0) {
+            MediaUtils.skipTest("no such encoder present");
+            return;
+        }
+        for (Encoder encoder: encoders) {
+            if (encoder.testExtreme(x, y, flexYUV, near)) {
+                skipped = false;
+            }
+        }
+        if (skipped) {
+            MediaUtils.skipTest("duplicate resolution extreme");
+        }
+    }
+
+    private void arbitrary(Encoder[] encoders, boolean flexYUV) {
+        boolean skipped = true;
+        if (encoders.length == 0) {
+            MediaUtils.skipTest("no such encoder present");
+            return;
+        }
+        for (Encoder encoder: encoders) {
+            if (encoder.testArbitrary(flexYUV)) {
+                skipped = false;
+            }
+        }
+        if (skipped) {
+            MediaUtils.skipTest("duplicate resolution");
+        }
+    }
+
+    /* test specific size */
+    private void specific(Encoder[] encoders, int width, int height, boolean flexYUV) {
+        boolean skipped = true;
+        if (encoders.length == 0) {
+            MediaUtils.skipTest("no such encoder present");
+            return;
+        }
+        for (Encoder encoder : encoders) {
+            if (encoder.testSpecific(width, height, flexYUV)) {
+                skipped = false;
+            }
+        }
+        if (skipped) {
+            MediaUtils.skipTest("duplicate or unsupported resolution");
+        }
+    }
+}