integrate media stress test : MediaPlay and MediaRecord only
- media files are copied manually before test
- one test class per each resolution and format
- support of format is checked for each test case, and not-supported format
  will be just passed.

Change-Id: I7828a27fdd7e9396cfbdf0c8cfe9c8e950d95316
diff --git a/CtsTestCaseList.mk b/CtsTestCaseList.mk
index c31fbcb..fe3d540 100644
--- a/CtsTestCaseList.mk
+++ b/CtsTestCaseList.mk
@@ -45,6 +45,7 @@
 	CtsHardwareTestCases \
 	CtsJniTestCases \
 	CtsLocationTestCases \
+	CtsMediaStressTestCases \
 	CtsMediaTestCases \
 	CtsNdefTestCases \
 	CtsNetTestCases \
diff --git a/tests/tests/mediastress/Android.mk b/tests/tests/mediastress/Android.mk
new file mode 100644
index 0000000..4fa7fdb
--- /dev/null
+++ b/tests/tests/mediastress/Android.mk
@@ -0,0 +1,31 @@
+# Copyright (C) 2012 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.
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+# don't include this package in any target
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_DATA_APPS)
+
+LOCAL_JAVA_LIBRARIES := android.test.runner
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_PACKAGE_NAME := CtsMediaStressTestCases
+
+LOCAL_SDK_VERSION := current
+
+include $(BUILD_PACKAGE)
diff --git a/tests/tests/mediastress/AndroidManifest.xml b/tests/tests/mediastress/AndroidManifest.xml
new file mode 100644
index 0000000..5a4569c
--- /dev/null
+++ b/tests/tests/mediastress/AndroidManifest.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2012 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.
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+        package="com.android.cts.mediastress">
+
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+
+    <application>
+        <uses-library android:name="android.test.runner" />
+        <activity android:label="@string/app_name"
+                android:name="android.mediastress.cts.MediaFrameworkTest"
+                android:screenOrientation="landscape">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+        </activity>
+    </application>
+    <instrumentation android:name="android.test.InstrumentationTestRunner"
+            android:targetPackage="com.android.cts.mediastress"
+            android:label="Media stress tests InstrumentationRunner" />
+
+</manifest>
diff --git a/tests/tests/mediastress/res/layout/surface_view.xml b/tests/tests/mediastress/res/layout/surface_view.xml
new file mode 100644
index 0000000..97f1dd4
--- /dev/null
+++ b/tests/tests/mediastress/res/layout/surface_view.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2012 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.
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:orientation="vertical">
+
+    <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent">
+
+        <SurfaceView
+                android:id="@+id/surface_view"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:layout_centerInParent="true" />
+
+        <ImageView android:id="@+id/overlay_layer"
+                android:layout_width="0dip"
+                android:layout_height="392dip"/>
+
+        <VideoView
+                android:id="@+id/video_view"
+                android:layout_width="320px"
+                android:layout_height="240px"  />
+
+    </FrameLayout>
+
+</LinearLayout>
diff --git a/tests/tests/mediastress/res/values/strings.xml b/tests/tests/mediastress/res/values/strings.xml
new file mode 100644
index 0000000..32c58e0
--- /dev/null
+++ b/tests/tests/mediastress/res/values/strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2012 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.
+-->
+
+<resources>
+    <string name="app_name">MediaStressTest</string>
+    <string name="open_url">Open</string>
+</resources>
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/CodecTest.java b/tests/tests/mediastress/src/android/mediastress/cts/CodecTest.java
new file mode 100644
index 0000000..c349ac0
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/CodecTest.java
@@ -0,0 +1,817 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+import android.content.res.AssetFileDescriptor;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.media.MediaMetadataRetriever;
+import android.media.MediaPlayer;
+import android.media.MediaRecorder;
+import android.os.Looper;
+import android.os.SystemClock;
+import android.util.Log;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Junit / Instrumentation test case for the media player api
+ */
+public class CodecTest {
+    private static String TAG = "CodecTest";
+    private static MediaPlayer mMediaPlayer;
+    private MediaPlayer.OnPreparedListener mOnPreparedListener;
+
+    private static int WAIT_FOR_COMMAND_TO_COMPLETE = 60000;  //1 min max.
+    private static boolean mInitialized = false;
+    private static boolean mPrepareReset = false;
+    private static Looper mLooper = null;
+    private static final Object mLock = new Object();
+    private static final Object mPrepareDone = new Object();
+    private static final Object mVideoSizeChanged = new Object();
+    private static final Object mOnCompletion = new Object();
+    private static boolean mOnPrepareSuccess = false;
+    private static final long PAUSE_WAIT_TIME = 3000;
+    private static final long WAIT_TIME = 2000;
+    private static final int SEEK_TIME = 10000;
+
+    public static boolean mOnCompleteSuccess = false;
+    public static boolean mPlaybackError = false;
+    public static int mMediaInfoUnknownCount = 0;
+    public static int mMediaInfoVideoTrackLaggingCount = 0;
+    public static int mMediaInfoBadInterleavingCount = 0;
+    public static int mMediaInfoNotSeekableCount = 0;
+    public static int mMediaInfoMetdataUpdateCount = 0;
+
+    public static String printCpuInfo() {
+        String cm = "dumpsys cpuinfo";
+        String cpuinfo = null;
+        int ch;
+        try {
+            Process  p = Runtime.getRuntime().exec(cm);
+            InputStream in = p.getInputStream();
+            StringBuffer sb = new StringBuffer(512);
+            while ( ( ch = in.read() ) != -1 ) {
+                sb.append((char) ch);
+            }
+            cpuinfo = sb.toString();
+        } catch (IOException e) {
+            Log.v(TAG, e.toString());
+        }
+        return cpuinfo;
+    }
+
+
+    public static int getDuration(String filePath) {
+        Log.v(TAG, "getDuration - " + filePath);
+        MediaPlayer mp = new MediaPlayer();
+        try {
+            mp.setDataSource(filePath);
+            mp.prepare();
+        } catch (Exception e) {
+            Log.v(TAG, e.toString());
+        }
+        int duration = mp.getDuration();
+        Log.v(TAG, "Duration " + duration);
+        mp.release();
+        Log.v(TAG, "release");
+        return duration;
+    }
+
+    public static boolean getCurrentPosition(String filePath) {
+        Log.v(TAG, "GetCurrentPosition - " + filePath);
+        int currentPosition = 0;
+        long t1=0;
+        long t2 =0;
+        MediaPlayer mp = new MediaPlayer();
+        try {
+            mp.setDataSource(filePath);
+            Log.v(TAG, "start playback");
+            mp.prepare();
+            mp.start();
+            t1=SystemClock.uptimeMillis();
+            Thread.sleep(10000);
+            mp.pause();
+            Thread.sleep(PAUSE_WAIT_TIME);
+            t2=SystemClock.uptimeMillis();
+        } catch (Exception e) {
+            Log.v(TAG, e.toString());
+        }
+        currentPosition = mp.getCurrentPosition();
+        mp.stop();
+        mp.release();
+        Log.v(TAG, "mp currentPositon = " + currentPosition + " play duration = " + (t2-t1));
+
+        if ((currentPosition < ((t2-t1) *1.2)) && (currentPosition > 0))
+            return true;
+        else
+            return false;
+    }
+
+    public static boolean seekTo(String filePath) {
+        Log.v(TAG, "seekTo " + filePath);
+        int currentPosition = 0;
+        MediaPlayer mp = new MediaPlayer();
+        try {
+            mp.setDataSource(filePath);
+            mp.prepare();
+            mp.start();
+            mp.seekTo(SEEK_TIME);
+            Thread.sleep(WAIT_TIME);
+            currentPosition = mp.getCurrentPosition();
+        } catch (Exception e) {
+            Log.v(TAG, e.getMessage());
+        }
+        mp.stop();
+        mp.release();
+        Log.v(TAG, "CurrentPosition = " + currentPosition);
+        //The currentposition should be at least greater than the 80% of seek time
+        if ((currentPosition > SEEK_TIME *0.8))
+            return true;
+        else
+            return false;
+    }
+
+    public static boolean setLooping(String filePath) {
+        int currentPosition = 0;
+        int duration = 0;
+        long t1 =0;
+        long t2 =0;
+        Log.v (TAG, "SetLooping - " + filePath);
+        MediaPlayer mp = new MediaPlayer();
+        try {
+            mp.setDataSource(filePath);
+            mp.prepare();
+            duration = mp.getDuration();
+            Log.v(TAG, "setLooping duration " + duration);
+            mp.setLooping(true);
+            mp.start();
+            Thread.sleep(5000);
+            mp.seekTo(duration - 5000);
+            t1=SystemClock.uptimeMillis();
+            Thread.sleep(20000);
+            t2=SystemClock.uptimeMillis();
+            Log.v(TAG, "pause");
+            //Bug# 1106852 - IllegalStateException will be thrown if pause is called
+            //in here
+            //mp.pause();
+            currentPosition = mp.getCurrentPosition();
+            Log.v(TAG, "looping position " + currentPosition + "duration = " + (t2-t1));
+        } catch (Exception e) {
+            Log.v(TAG, "Exception : " + e.toString());
+        }
+        mp.stop();
+        mp.release();
+        //The current position should be within 20% of the sleep time
+        //and should be greater than zero.
+        if ((currentPosition < ((t2-t1-5000)*1.2)) && currentPosition > 0)
+            return true;
+        else
+            return false;
+    }
+
+    public static boolean pause(String filePath) throws Exception {
+        Log.v(TAG, "pause - " + filePath);
+        boolean misPlaying = true;
+        boolean pauseResult = false;
+        long t1=0;
+        long t2=0;
+        MediaPlayer mp = new MediaPlayer();
+        mp.setDataSource(filePath);
+        mp.prepare();
+        int duration = mp.getDuration();
+        mp.start();
+        t1=SystemClock.uptimeMillis();
+        Thread.sleep(5000);
+        mp.pause();
+        Thread.sleep(PAUSE_WAIT_TIME);
+        t2=SystemClock.uptimeMillis();
+        misPlaying = mp.isPlaying();
+        int curPosition = mp.getCurrentPosition();
+        Log.v(TAG, filePath + " pause currentPositon " + curPosition);
+        Log.v(TAG, "isPlaying "+ misPlaying + " wait time " + (t2 - t1) );
+        String cpuinfo = printCpuInfo();
+        Log.v(TAG, cpuinfo);
+        if ((curPosition>0) && (curPosition < ((t2-t1) * 1.3)) && (misPlaying == false))
+            pauseResult = true;
+        mp.stop();
+        mp.release();
+        return pauseResult;
+    }
+
+    public static void prepareStopRelease(String filePath) throws Exception {
+        Log.v(TAG, "prepareStopRelease" + filePath);
+        MediaPlayer mp = new MediaPlayer();
+        mp.setDataSource(filePath);
+        mp.prepare();
+        mp.stop();
+        mp.release();
+    }
+
+    public static void preparePauseRelease(String filePath) throws Exception {
+        Log.v(TAG, "preparePauseRelease" + filePath);
+        MediaPlayer mp = new MediaPlayer();
+        mp.setDataSource(filePath);
+        mp.prepare();
+        mp.pause();
+        mp.release();
+    }
+
+    static MediaPlayer.OnVideoSizeChangedListener mOnVideoSizeChangedListener =
+        new MediaPlayer.OnVideoSizeChangedListener() {
+            public void onVideoSizeChanged(MediaPlayer mp, int width, int height) {
+                synchronized (mVideoSizeChanged) {
+                    Log.v(TAG, "sizechanged notification received ...");
+                    mVideoSizeChanged.notify();
+                }
+            }
+    };
+
+    //Register the videoSizeChanged listener
+    public static int videoHeight(String filePath) throws Exception {
+        Log.v(TAG, "videoHeight - " + filePath);
+        int videoHeight = 0;
+        synchronized (mLock) {
+            initializeMessageLooper();
+            try {
+                mLock.wait(WAIT_FOR_COMMAND_TO_COMPLETE);
+            } catch(Exception e) {
+                Log.v(TAG, "looper was interrupted.");
+                return 0;
+            }
+        }
+        try {
+            mMediaPlayer.setDataSource(filePath);
+            mMediaPlayer.setDisplay(MediaFrameworkTest.getSurfaceView().getHolder());
+            mMediaPlayer.setOnVideoSizeChangedListener(mOnVideoSizeChangedListener);
+            synchronized (mVideoSizeChanged) {
+                try {
+                    mMediaPlayer.prepare();
+                    mMediaPlayer.start();
+                    mVideoSizeChanged.wait(WAIT_FOR_COMMAND_TO_COMPLETE);
+                } catch (Exception e) {
+                    Log.v(TAG, "wait was interrupted");
+                }
+            }
+            videoHeight = mMediaPlayer.getVideoHeight();
+            terminateMessageLooper();
+        } catch (Exception e) {
+            Log.e(TAG, e.getMessage());
+        }
+
+        return videoHeight;
+    }
+
+    //Register the videoSizeChanged listener
+    public static int videoWidth(String filePath) throws Exception {
+        Log.v(TAG, "videoWidth - " + filePath);
+        int videoWidth = 0;
+
+        synchronized (mLock) {
+            initializeMessageLooper();
+            try {
+                mLock.wait(WAIT_FOR_COMMAND_TO_COMPLETE);
+            } catch(Exception e) {
+                Log.v(TAG, "looper was interrupted.");
+                return 0;
+            }
+        }
+        try {
+            mMediaPlayer.setDataSource(filePath);
+            mMediaPlayer.setDisplay(MediaFrameworkTest.getSurfaceView().getHolder());
+            mMediaPlayer.setOnVideoSizeChangedListener(mOnVideoSizeChangedListener);
+            synchronized (mVideoSizeChanged) {
+                try {
+                    mMediaPlayer.prepare();
+                    mMediaPlayer.start();
+                    mVideoSizeChanged.wait(WAIT_FOR_COMMAND_TO_COMPLETE);
+                } catch (Exception e) {
+                    Log.v(TAG, "wait was interrupted");
+                }
+            }
+            videoWidth = mMediaPlayer.getVideoWidth();
+            terminateMessageLooper();
+        } catch (Exception e) {
+            Log.e(TAG, e.getMessage());
+        }
+        return videoWidth;
+    }
+
+    //This also test the streaming video which may take a long
+    //time to start the playback.
+    public static boolean videoSeekTo(String filePath) throws Exception {
+        Log.v(TAG, "videoSeekTo - " + filePath);
+        int currentPosition = 0;
+        int duration = 0;
+        boolean videoResult = false;
+        MediaPlayer mp = new MediaPlayer();
+        mp.setDataSource(filePath);
+        mp.setDisplay(MediaFrameworkTest.getSurfaceView().getHolder());
+        mp.prepare();
+        mp.start();
+
+        Thread.sleep(5000);
+        duration = mp.getDuration();
+        Log.v(TAG, "video duration " + duration);
+        mp.pause();
+        Thread.sleep(PAUSE_WAIT_TIME);
+        mp.seekTo(duration - 20000 );
+        mp.start();
+        Thread.sleep(1000);
+        mp.pause();
+        Thread.sleep(PAUSE_WAIT_TIME);
+        mp.seekTo(duration/2);
+        mp.start();
+        Thread.sleep(10000);
+        currentPosition = mp.getCurrentPosition();
+        Log.v(TAG, "video currentPosition " + currentPosition);
+        mp.release();
+        if (currentPosition > (duration /2 )*0.9)
+            return true;
+        else
+            return false;
+
+    }
+
+    public static boolean seekToEnd(String filePath) {
+        Log.v(TAG, "seekToEnd - " + filePath);
+        int duration = 0;
+        int currentPosition = 0;
+        boolean isPlaying = false;
+        MediaPlayer mp = new MediaPlayer();
+        try {
+            mp.setDataSource(filePath);
+            Log.v(TAG, "start playback");
+            mp.prepare();
+            duration = mp.getDuration();
+            mp.seekTo(duration - 3000);
+            mp.start();
+            Thread.sleep(6000);
+        } catch (Exception e) {}
+        isPlaying = mp.isPlaying();
+        currentPosition = mp.getCurrentPosition();
+        Log.v(TAG, "seekToEnd currentPosition= " + currentPosition + " isPlaying = " + isPlaying);
+        mp.stop();
+        mp.release();
+        Log.v(TAG, "duration = " + duration);
+        if (currentPosition < 0.9 * duration || isPlaying)
+            return false;
+        else
+            return true;
+    }
+
+    public static boolean shortMediaStop(String filePath) {
+        Log.v(TAG, "shortMediaStop - " + filePath);
+        //This test is only for the short media file
+        int duration = 0;
+        int currentPosition = 0;
+        boolean isPlaying = false;
+        MediaPlayer mp = new MediaPlayer();
+        try {
+            mp.setDataSource(filePath);
+            Log.v(TAG, "start playback");
+            mp.prepare();
+            duration = mp.getDuration();
+            mp.start();
+            Thread.sleep(10000);
+        } catch (Exception e) {}
+        isPlaying = mp.isPlaying();
+        currentPosition = mp.getCurrentPosition();
+        Log.v(TAG, "seekToEnd currentPosition= " + currentPosition + " isPlaying = " + isPlaying);
+        mp.stop();
+        mp.release();
+        Log.v(TAG, "duration = " + duration);
+        if (currentPosition > duration || isPlaying)
+            return false;
+        else
+            return true;
+    }
+
+    public static boolean playToEnd(String filePath) {
+        Log.v(TAG, "shortMediaStop - " + filePath);
+        //This test is only for the short media file
+        int duration = 200000;
+        int updateDuration = 0;
+        int currentPosition = 0;
+        boolean isPlaying = false;
+        MediaPlayer mp = new MediaPlayer();
+        try {
+            Thread.sleep(5000);
+            mp.setDataSource(filePath);
+            Log.v(TAG, "start playback");
+            mp.prepare();
+            //duration = mp.getDuration();
+            mp.start();
+            Thread.sleep(50000);
+        } catch (Exception e){}
+        isPlaying = mp.isPlaying();
+        currentPosition = mp.getCurrentPosition();
+        //updateDuration = mp.getDuration();
+        Log.v(TAG, "seekToEnd currentPosition= " + currentPosition + " isPlaying = " + isPlaying);
+        mp.stop();
+        mp.release();
+        //Log.v(TAG, "duration = " + duration);
+        //Log.v(TAG, "Update duration = " + updateDuration);
+        if (currentPosition > duration || isPlaying)
+            return false;
+        else
+            return true;
+    }
+
+    public static boolean seektoBeforeStart(String filePath){
+        Log.v(TAG, "seektoBeforeStart - " + filePath);
+        //This test is only for the short media file
+        int duration = 0;
+        int currentPosition = 0;
+
+        MediaPlayer mp = new MediaPlayer();
+        try {
+            mp.setDataSource(filePath);
+            mp.prepare();
+            duration = mp.getDuration();
+            mp.seekTo(duration - 10000);
+            mp.start();
+            currentPosition=mp.getCurrentPosition();
+            mp.stop();
+            mp.release();
+        } catch (Exception e) {}
+        if (currentPosition < duration/2)
+            return false;
+        else
+            return true;
+    }
+
+    public static boolean mediaRecorderRecord(String filePath){
+        Log.v(TAG, "SoundRecording - " + filePath);
+        //This test is only for the short media file
+        int duration = 0;
+        try {
+            MediaRecorder mRecorder = new MediaRecorder();
+            mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
+            mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
+            mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
+            mRecorder.setOutputFile(filePath);
+            mRecorder.prepare();
+            mRecorder.start();
+            Thread.sleep(500);
+            mRecorder.stop();
+            Log.v(TAG, "sound recorded");
+            mRecorder.release();
+        } catch (Exception e) {
+            Log.v(TAG, e.toString());
+        }
+
+        //Verify the recorded file
+        MediaPlayer mp = new MediaPlayer();
+        try {
+            mp.setDataSource(filePath);
+            mp.prepare();
+            duration = mp.getDuration();
+            Log.v(TAG,"Duration " + duration);
+            mp.release();
+        } catch (Exception e) {}
+        //Check the record media file length is greate than zero
+        if (duration > 0)
+            return true;
+        else
+            return false;
+
+    }
+
+    //Test for mediaMeta Data Thumbnail
+    public static boolean getThumbnail(String filePath, String goldenPath) {
+        Log.v(TAG, "getThumbnail - " + filePath);
+
+        int goldenHeight = 0;
+        int goldenWidth = 0;
+        int outputWidth = 0;
+        int outputHeight = 0;
+
+        //This test is only for the short media file
+        try {
+            BitmapFactory mBitmapFactory = new BitmapFactory();
+
+            MediaMetadataRetriever mMediaMetadataRetriever = new MediaMetadataRetriever();
+            try {
+                mMediaMetadataRetriever.setDataSource(filePath);
+            } catch(Exception e) {
+                e.printStackTrace();
+                return false;
+            }
+            Bitmap outThumbnail = mMediaMetadataRetriever.getFrameAtTime(-1);
+
+            //Verify the thumbnail
+            Bitmap goldenBitmap = mBitmapFactory.decodeFile(goldenPath);
+            outputWidth = outThumbnail.getWidth();
+            outputHeight = outThumbnail.getHeight();
+            goldenHeight = goldenBitmap.getHeight();
+            goldenWidth = goldenBitmap.getWidth();
+
+            //check the image dimension
+            if ((outputWidth != goldenWidth) || (outputHeight != goldenHeight))
+                return false;
+
+            // Check half line of pixel
+            int x = goldenHeight / 2;
+            for (int j = 1; j < goldenWidth / 2; j++) {
+                if (goldenBitmap.getPixel(x, j) != outThumbnail.getPixel(x, j)) {
+                    Log.v(TAG, "pixel = " + goldenBitmap.getPixel(x, j));
+                    return false;
+                }
+           }
+        } catch (Exception e) {
+            Log.v(TAG, e.toString());
+            return false;
+        }
+        return true;
+    }
+
+    //Load midi file from resources
+    public static boolean resourcesPlayback(AssetFileDescriptor afd, int expectedDuration) {
+        int duration = 0;
+        try {
+            MediaPlayer mp = new MediaPlayer();
+            mp.setDataSource(afd.getFileDescriptor(),afd.getStartOffset(), afd.getLength());
+            mp.prepare();
+            mp.start();
+            duration = mp.getDuration();
+            Thread.sleep(5000);
+            mp.release();
+        } catch (Exception e) {
+            Log.v(TAG,e.getMessage());
+        }
+        if (duration > expectedDuration)
+            return true;
+        else
+            return false;
+    }
+
+    public static boolean prepareAsyncReset(String filePath) {
+        //preparesAsync
+        try {
+            MediaPlayer mp = new MediaPlayer();
+            mp.setDataSource(filePath);
+            mp.prepareAsync();
+            mp.reset();
+            mp.release();
+        } catch (Exception e) {
+            Log.v(TAG,e.getMessage());
+            return false;
+        }
+        return true;
+    }
+
+
+    public static boolean isLooping(String filePath) {
+        MediaPlayer mp = null;
+
+        try {
+            mp = new MediaPlayer();
+            if (mp.isLooping()) {
+                Log.v(TAG, "MediaPlayer.isLooping() returned true after ctor");
+                return false;
+            }
+            mp.setDataSource(filePath);
+            mp.prepare();
+
+            mp.setLooping(true);
+            if (!mp.isLooping()) {
+                Log.v(TAG, "MediaPlayer.isLooping() returned false after setLooping(true)");
+                return false;
+            }
+
+            mp.setLooping(false);
+            if (mp.isLooping()) {
+                Log.v(TAG, "MediaPlayer.isLooping() returned true after setLooping(false)");
+                return false;
+            }
+        } catch (Exception e) {
+            Log.v(TAG, "Exception : " + e.toString());
+            return false;
+        } finally {
+            if (mp != null)
+                mp.release();
+        }
+
+        return true;
+    }
+
+    public static boolean isLoopingAfterReset(String filePath) {
+        MediaPlayer mp = null;
+        try {
+            mp = new MediaPlayer();
+            mp.setDataSource(filePath);
+            mp.prepare();
+
+            mp.setLooping(true);
+            mp.reset();
+            if (mp.isLooping()) {
+                Log.v(TAG, "MediaPlayer.isLooping() returned true after reset()");
+                return false;
+            }
+        } catch (Exception e){
+            Log.v(TAG, "Exception : " + e.toString());
+            return false;
+        } finally {
+            if (mp != null)
+                mp.release();
+        }
+
+        return true;
+    }
+
+    /*
+     * Initializes the message looper so that the mediaPlayer object can
+     * receive the callback messages.
+     */
+    private static void initializeMessageLooper() {
+        Log.v(TAG, "start looper");
+        new Thread() {
+            @Override
+            public void run() {
+                // Set up a looper to be used by camera.
+                Looper.prepare();
+                Log.v(TAG, "start loopRun");
+                // Save the looper so that we can terminate this thread
+                // after we are done with it.
+                mLooper = Looper.myLooper();
+                mMediaPlayer = new MediaPlayer();
+                synchronized (mLock) {
+                    mInitialized = true;
+                    mLock.notify();
+                }
+                Looper.loop();  // Blocks forever until Looper.quit() is called.
+                Log.v(TAG, "initializeMessageLooper: quit.");
+            }
+        }.start();
+    }
+
+    /*
+     * Terminates the message looper thread.
+     */
+    private static void terminateMessageLooper() {
+        mLooper.quit();
+        mMediaPlayer.release();
+    }
+
+    static MediaPlayer.OnPreparedListener mPreparedListener = new MediaPlayer.OnPreparedListener() {
+        public void onPrepared(MediaPlayer mp) {
+            synchronized (mPrepareDone) {
+                if(mPrepareReset) {
+                    Log.v(TAG, "call Reset");
+                    mMediaPlayer.reset();
+                }
+                Log.v(TAG, "notify the prepare callback");
+                mPrepareDone.notify();
+                mOnPrepareSuccess = true;
+            }
+        }
+    };
+
+    public static boolean prepareAsyncCallback(String filePath, boolean reset) throws Exception {
+        //Added the PrepareReset flag which allow us to switch to different
+        //test case.
+        if (reset) {
+            mPrepareReset = true;
+        }
+
+        synchronized (mLock) {
+            initializeMessageLooper();
+            try {
+                mLock.wait(WAIT_FOR_COMMAND_TO_COMPLETE);
+            } catch(Exception e) {
+                Log.v(TAG, "looper was interrupted.");
+                return false;
+            }
+        }
+        try{
+            mMediaPlayer.setOnPreparedListener(mPreparedListener);
+            mMediaPlayer.setDataSource(filePath);
+            mMediaPlayer.setDisplay(MediaFrameworkTest.getSurfaceView().getHolder());
+            mMediaPlayer.prepareAsync();
+            synchronized (mPrepareDone) {
+                try {
+                    mPrepareDone.wait(WAIT_FOR_COMMAND_TO_COMPLETE);
+                } catch (Exception e) {
+                    Log.v(TAG, "wait was interrupted.");
+                }
+            }
+            terminateMessageLooper();
+        }catch (Exception e) {
+            Log.v(TAG,e.getMessage());
+        }
+       return mOnPrepareSuccess;
+    }
+
+    static MediaPlayer.OnCompletionListener mCompletionListener = new MediaPlayer.OnCompletionListener() {
+        public void onCompletion(MediaPlayer mp) {
+            synchronized (mOnCompletion) {
+                Log.v(TAG, "notify the completion callback");
+                mOnCompletion.notify();
+                mOnCompleteSuccess = true;
+            }
+        }
+    };
+
+    static MediaPlayer.OnErrorListener mOnErrorListener = new MediaPlayer.OnErrorListener() {
+        public boolean onError(MediaPlayer mp, int framework_err, int impl_err) {
+            Log.v(TAG, "playback error");
+            mPlaybackError = true;
+            mp.reset();
+            synchronized (mOnCompletion) {
+                Log.v(TAG, "notify the completion callback");
+                mOnCompletion.notify();
+                mOnCompleteSuccess = false;
+            }
+            return true;
+        }
+    };
+
+    static MediaPlayer.OnInfoListener mInfoListener = new MediaPlayer.OnInfoListener() {
+        public boolean onInfo(MediaPlayer mp, int what, int extra) {
+            switch (what) {
+                case MediaPlayer.MEDIA_INFO_UNKNOWN:
+                    mMediaInfoUnknownCount++;
+                    break;
+                case MediaPlayer.MEDIA_INFO_VIDEO_TRACK_LAGGING:
+                    mMediaInfoVideoTrackLaggingCount++;
+                    break;
+                case MediaPlayer.MEDIA_INFO_BAD_INTERLEAVING:
+                    mMediaInfoBadInterleavingCount++;
+                    break;
+                case MediaPlayer.MEDIA_INFO_NOT_SEEKABLE:
+                    mMediaInfoNotSeekableCount++;
+                    break;
+                case MediaPlayer.MEDIA_INFO_METADATA_UPDATE:
+                    mMediaInfoMetdataUpdateCount++;
+                    break;
+            }
+            return true;
+        }
+    };
+
+    public static boolean playMediaSample(String fileName) throws Exception {
+        int duration = 0;
+        int curPosition = 0;
+        int nextPosition = 0;
+        int waittime = 0;
+        mOnCompleteSuccess = false;
+        mMediaInfoUnknownCount = 0;
+        mMediaInfoVideoTrackLaggingCount = 0;
+        mMediaInfoBadInterleavingCount = 0;
+        mMediaInfoNotSeekableCount = 0;
+        mMediaInfoMetdataUpdateCount = 0;
+        mPlaybackError = false;
+
+        initializeMessageLooper();
+        synchronized (mLock) {
+            try {
+                mLock.wait(WAIT_FOR_COMMAND_TO_COMPLETE);
+            } catch(Exception e) {
+                Log.v(TAG, "looper was interrupted.");
+                return false;
+            }
+        }
+        try {
+            mMediaPlayer.setOnCompletionListener(mCompletionListener);
+            mMediaPlayer.setOnErrorListener(mOnErrorListener);
+            mMediaPlayer.setOnInfoListener(mInfoListener);
+            Log.v(TAG, "playMediaSample: sample file name " + fileName);
+            mMediaPlayer.setDataSource(fileName);
+            mMediaPlayer.setDisplay(MediaFrameworkTest.getSurfaceView().getHolder());
+            mMediaPlayer.prepare();
+            duration = mMediaPlayer.getDuration();
+            Log.v(TAG, "duration of media " + duration);
+            // start to play
+            mMediaPlayer.start();
+            waittime = duration - mMediaPlayer.getCurrentPosition();
+            synchronized(mOnCompletion) {
+                try {
+                    mOnCompletion.wait(waittime + 2000);
+                } catch (Exception e) {
+                    Log.v(TAG, "playMediaSamples are interrupted");
+                    return false;
+                }
+            }
+            terminateMessageLooper();
+        } catch (Exception e) {
+            Log.v(TAG, "playMediaSample Exception:" + e.getMessage());
+        }
+        return mOnCompleteSuccess;
+    }
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/H263QcifLongPlayerTest.java b/tests/tests/mediastress/src/android/mediastress/cts/H263QcifLongPlayerTest.java
new file mode 100644
index 0000000..6e47fe1
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/H263QcifLongPlayerTest.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+public class H263QcifLongPlayerTest extends MediaPlayerStressTest {
+    private final static String VIDEO_PATH_MIDDLE = "bbb_full/176x144/3gp_h263_libfaac/";
+    private final String[] mMedias = { // indentation shortened due to long file name
+        "bbb_full.ffmpeg.176x144.3gp.h263_56kbps_12fps.libfaac_mono_24kbps_11025Hz.3gp"
+    };
+
+    public void testPlay00() throws Exception {
+        doTestVideoPlaybackLong(0);
+    }
+
+    @Override
+    protected String getFullVideoClipName(int mediaNumber) {
+        return VIDEO_TOP_DIR + VIDEO_PATH_MIDDLE + mMedias[mediaNumber];
+    }
+
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/H263QcifShortPlayerTest.java b/tests/tests/mediastress/src/android/mediastress/cts/H263QcifShortPlayerTest.java
new file mode 100644
index 0000000..2035869
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/H263QcifShortPlayerTest.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+public class H263QcifShortPlayerTest extends MediaPlayerStressTest {
+    private final static String VIDEO_PATH_MIDDLE = "bbb_short/176x144/3gp_h263_libfaac/";
+    private final String[] mMedias = {
+        "bbb_short.ffmpeg.176x144.3gp.h263_300kbps_12fps.libfaac_mono_24kbps_11025Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_300kbps_12fps.libfaac_mono_24kbps_22050Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_300kbps_12fps.libfaac_stereo_128kbps_11025Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_300kbps_12fps.libfaac_stereo_128kbps_22050Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_300kbps_12fps.libfaac_stereo_24kbps_11025Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_300kbps_12fps.libfaac_stereo_24kbps_22050Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_300kbps_25fps.libfaac_mono_24kbps_11025Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_300kbps_25fps.libfaac_mono_24kbps_22050Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_300kbps_25fps.libfaac_stereo_128kbps_11025Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_300kbps_25fps.libfaac_stereo_128kbps_22050Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_300kbps_25fps.libfaac_stereo_24kbps_11025Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_300kbps_25fps.libfaac_stereo_24kbps_22050Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_56kbps_12fps.libfaac_mono_24kbps_11025Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_56kbps_12fps.libfaac_mono_24kbps_22050Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_56kbps_12fps.libfaac_stereo_128kbps_11025Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_56kbps_12fps.libfaac_stereo_128kbps_22050Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_56kbps_12fps.libfaac_stereo_24kbps_11025Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_56kbps_12fps.libfaac_stereo_24kbps_22050Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_56kbps_25fps.libfaac_mono_24kbps_11025Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_56kbps_25fps.libfaac_mono_24kbps_22050Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_56kbps_25fps.libfaac_stereo_128kbps_11025Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_56kbps_25fps.libfaac_stereo_128kbps_22050Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_56kbps_25fps.libfaac_stereo_24kbps_11025Hz.3gp",
+        "bbb_short.ffmpeg.176x144.3gp.h263_56kbps_25fps.libfaac_stereo_24kbps_22050Hz.3gp"
+    };
+
+    public void testPlay00() throws Exception {
+        doTestVideoPlaybackShort(0);
+    }
+
+    public void testPlay01() throws Exception {
+        doTestVideoPlaybackShort(1);
+    }
+
+    public void testPlay02() throws Exception {
+        doTestVideoPlaybackShort(2);
+    }
+
+    public void testPlay03() throws Exception {
+        doTestVideoPlaybackShort(3);
+    }
+
+    public void testPlay04() throws Exception {
+        doTestVideoPlaybackShort(4);
+    }
+
+    public void testPlay05() throws Exception {
+        doTestVideoPlaybackShort(5);
+    }
+
+    public void testPlay06() throws Exception {
+        doTestVideoPlaybackShort(6);
+    }
+
+    public void testPlay07() throws Exception {
+        doTestVideoPlaybackShort(7);
+    }
+
+    public void testPlay08() throws Exception {
+        doTestVideoPlaybackShort(8);
+    }
+
+    public void testPlay09() throws Exception {
+        doTestVideoPlaybackShort(9);
+    }
+
+    public void testPlay10() throws Exception {
+        doTestVideoPlaybackShort(10);
+    }
+
+    public void testPlay11() throws Exception {
+        doTestVideoPlaybackShort(11);
+    }
+
+    public void testPlay12() throws Exception {
+        doTestVideoPlaybackShort(12);
+    }
+
+    public void testPlay13() throws Exception {
+        doTestVideoPlaybackShort(13);
+    }
+
+    public void testPlay14() throws Exception {
+        doTestVideoPlaybackShort(14);
+    }
+
+    public void testPlay15() throws Exception {
+        doTestVideoPlaybackShort(15);
+    }
+
+    public void testPlay16() throws Exception {
+        doTestVideoPlaybackShort(16);
+    }
+
+    public void testPlay17() throws Exception {
+        doTestVideoPlaybackShort(17);
+    }
+
+    public void testPlay18() throws Exception {
+        doTestVideoPlaybackShort(18);
+    }
+
+    public void testPlay19() throws Exception {
+        doTestVideoPlaybackShort(19);
+    }
+
+    public void testPlay20() throws Exception {
+        doTestVideoPlaybackShort(20);
+    }
+
+    public void testPlay21() throws Exception {
+        doTestVideoPlaybackShort(21);
+    }
+
+    public void testPlay22() throws Exception {
+        doTestVideoPlaybackShort(22);
+    }
+
+    public void testPlay23() throws Exception {
+        doTestVideoPlaybackShort(23);
+    }
+
+    @Override
+    protected String getFullVideoClipName(int mediaNumber) {
+        return VIDEO_TOP_DIR + VIDEO_PATH_MIDDLE + mMedias[mediaNumber];
+    }
+
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/H264R1080pAacLongPlayerTest.java b/tests/tests/mediastress/src/android/mediastress/cts/H264R1080pAacLongPlayerTest.java
new file mode 100644
index 0000000..b7f7564
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/H264R1080pAacLongPlayerTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+import android.media.CamcorderProfile;
+import android.media.MediaRecorder.AudioEncoder;
+import android.media.MediaRecorder.VideoEncoder;
+
+public class H264R1080pAacLongPlayerTest extends MediaPlayerStressTest {
+    private static final String VIDEO_PATH_MIDDLE = "bbb_full/1920x1080/mp4_libx264_libfaac/";
+    private final String[] mMedias = {
+        "bbb_full.ffmpeg.1920x1080.mp4.libx264_10000kbps_30fps.libfaac_stereo_192kbps_48000Hz.mp4"
+    };
+
+    public H264R1080pAacLongPlayerTest() {
+        super(CamcorderProfile.QUALITY_1080P, VideoEncoder.H264, AudioEncoder.AAC);
+    }
+
+    public void testPlay00() throws Exception {
+        doTestVideoPlaybackLong(0);
+    }
+
+    @Override
+    protected String getFullVideoClipName(int mediaNumber) {
+        return VIDEO_TOP_DIR + VIDEO_PATH_MIDDLE + mMedias[mediaNumber];
+    }
+
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/H264R1080pAacShortPlayerTest.java b/tests/tests/mediastress/src/android/mediastress/cts/H264R1080pAacShortPlayerTest.java
new file mode 100644
index 0000000..3b7da57
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/H264R1080pAacShortPlayerTest.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+import android.media.CamcorderProfile;
+import android.media.MediaRecorder.AudioEncoder;
+import android.media.MediaRecorder.VideoEncoder;
+
+public class H264R1080pAacShortPlayerTest extends MediaPlayerStressTest {
+    private static final String VIDEO_PATH_MIDDLE = "bbb_short/1920x1080/mp4_libx264_libfaac/";
+    private final String[] mMedias = {
+        "bbb_short.ffmpeg.1920x1080.mp4.libx264_10000kbps_30fps.libfaac_stereo_192kbps_48000Hz.mp4",
+        "bbb_short.ffmpeg.1920x1080.mp4.libx264_1750kbps_30fps.libfaac_stereo_192kbps_48000Hz.mp4",
+        "bbb_short.ffmpeg.1920x1080.mp4.libx264_5000kbps_30fps.libfaac_stereo_192kbps_48000Hz.mp4"
+    };
+
+    public H264R1080pAacShortPlayerTest() {
+        super(CamcorderProfile.QUALITY_1080P, VideoEncoder.H264, AudioEncoder.AAC);
+    }
+
+    public void testPlay00() throws Exception {
+        doTestVideoPlaybackShort(0);
+    }
+
+    public void testPlay01() throws Exception {
+        doTestVideoPlaybackShort(1);
+    }
+
+    public void testPlay02() throws Exception {
+        doTestVideoPlaybackShort(2);
+    }
+
+    @Override
+    protected String getFullVideoClipName(int mediaNumber) {
+        return VIDEO_TOP_DIR + VIDEO_PATH_MIDDLE + mMedias[mediaNumber];
+    }
+
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/H264R480pAacLongPlayerTest.java b/tests/tests/mediastress/src/android/mediastress/cts/H264R480pAacLongPlayerTest.java
new file mode 100644
index 0000000..f01aa75
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/H264R480pAacLongPlayerTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+import android.media.CamcorderProfile;
+import android.media.MediaRecorder.AudioEncoder;
+import android.media.MediaRecorder.VideoEncoder;
+
+public class H264R480pAacLongPlayerTest extends MediaPlayerStressTest {
+    private static final String VIDEO_PATH_MIDDLE = "bbb_full/720x480/mp4_libx264_libfaac/";
+    private final String[] mMedias = {
+        "bbb_full.ffmpeg.720x480.mp4.libx264_500kbps_25fps.libfaac_stereo_128kbps_44100Hz.mp4"
+    };
+
+    public H264R480pAacLongPlayerTest() {
+        super(CamcorderProfile.QUALITY_480P, VideoEncoder.H264, AudioEncoder.AAC);
+    }
+
+    public void testPlay00() throws Exception {
+        doTestVideoPlaybackLong(0);
+    }
+
+    @Override
+    protected String getFullVideoClipName(int mediaNumber) {
+        return VIDEO_TOP_DIR + VIDEO_PATH_MIDDLE + mMedias[mediaNumber];
+    }
+
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/H264R480pAacShortPlayerTest.java b/tests/tests/mediastress/src/android/mediastress/cts/H264R480pAacShortPlayerTest.java
new file mode 100644
index 0000000..81b80e5
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/H264R480pAacShortPlayerTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+import android.media.CamcorderProfile;
+import android.media.MediaRecorder.AudioEncoder;
+import android.media.MediaRecorder.VideoEncoder;
+
+public class H264R480pAacShortPlayerTest extends MediaPlayerStressTest {
+    private static final String VIDEO_PATH_MIDDLE = "bbb_short/720x480/mp4_libx264_libfaac/";
+    private final String[] mMedias = {
+        "bbb_short.ffmpeg.720x480.mp4.libx264_1000kbps_25fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.720x480.mp4.libx264_1000kbps_25fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.720x480.mp4.libx264_1000kbps_30fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.720x480.mp4.libx264_1000kbps_30fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.720x480.mp4.libx264_1350kbps_25fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.720x480.mp4.libx264_1350kbps_25fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.720x480.mp4.libx264_1350kbps_30fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.720x480.mp4.libx264_1350kbps_30fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.720x480.mp4.libx264_500kbps_25fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.720x480.mp4.libx264_500kbps_25fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.720x480.mp4.libx264_500kbps_30fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.720x480.mp4.libx264_500kbps_30fps.libfaac_stereo_192kbps_44100Hz.mp4"
+    };
+
+    public H264R480pAacShortPlayerTest() {
+        super(CamcorderProfile.QUALITY_480P, VideoEncoder.H264, AudioEncoder.AAC);
+    }
+
+    public void testPlay00() throws Exception {
+        doTestVideoPlaybackShort(0);
+    }
+
+    public void testPlay01() throws Exception {
+        doTestVideoPlaybackShort(1);
+    }
+
+    public void testPlay02() throws Exception {
+        doTestVideoPlaybackShort(2);
+    }
+
+    public void testPlay03() throws Exception {
+        doTestVideoPlaybackShort(3);
+    }
+
+    public void testPlay04() throws Exception {
+        doTestVideoPlaybackShort(4);
+    }
+
+    public void testPlay05() throws Exception {
+        doTestVideoPlaybackShort(5);
+    }
+
+    public void testPlay06() throws Exception {
+        doTestVideoPlaybackShort(6);
+    }
+
+    public void testPlay07() throws Exception {
+        doTestVideoPlaybackShort(7);
+    }
+
+    public void testPlay08() throws Exception {
+        doTestVideoPlaybackShort(8);
+    }
+
+    public void testPlay09() throws Exception {
+        doTestVideoPlaybackShort(9);
+    }
+
+    public void testPlay10() throws Exception {
+        doTestVideoPlaybackShort(10);
+    }
+
+    public void testPlay11() throws Exception {
+        doTestVideoPlaybackShort(11);
+    }
+
+    @Override
+    protected String getFullVideoClipName(int mediaNumber) {
+        return VIDEO_TOP_DIR + VIDEO_PATH_MIDDLE + mMedias[mediaNumber];
+    }
+
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/H264R480x360AacShortPlayerTest.java b/tests/tests/mediastress/src/android/mediastress/cts/H264R480x360AacShortPlayerTest.java
new file mode 100644
index 0000000..12e8f6d
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/H264R480x360AacShortPlayerTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+public class H264R480x360AacShortPlayerTest extends MediaPlayerStressTest {
+    private static final String VIDEO_PATH_MIDDLE = "bbb_short/480x360/mp4_libx264_libfaac/";
+    private final String[] mMedias = {
+        "bbb_short.ffmpeg.480x360.mp4.libx264_1000kbps_25fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.480x360.mp4.libx264_1000kbps_25fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.480x360.mp4.libx264_1000kbps_30fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.480x360.mp4.libx264_1000kbps_30fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.480x360.mp4.libx264_1350kbps_25fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.480x360.mp4.libx264_1350kbps_25fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.480x360.mp4.libx264_1350kbps_30fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.480x360.mp4.libx264_1350kbps_30fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.480x360.mp4.libx264_500kbps_25fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.480x360.mp4.libx264_500kbps_25fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.480x360.mp4.libx264_500kbps_30fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.480x360.mp4.libx264_500kbps_30fps.libfaac_stereo_192kbps_44100Hz.mp4"
+    };
+
+    public void testPlay00() throws Exception {
+        doTestVideoPlaybackShort(0);
+    }
+
+    public void testPlay01() throws Exception {
+        doTestVideoPlaybackShort(1);
+    }
+
+    public void testPlay02() throws Exception {
+        doTestVideoPlaybackShort(2);
+    }
+
+    public void testPlay03() throws Exception {
+        doTestVideoPlaybackShort(3);
+    }
+
+    public void testPlay04() throws Exception {
+        doTestVideoPlaybackShort(4);
+    }
+
+    public void testPlay05() throws Exception {
+        doTestVideoPlaybackShort(5);
+    }
+
+    public void testPlay06() throws Exception {
+        doTestVideoPlaybackShort(6);
+    }
+
+    public void testPlay07() throws Exception {
+        doTestVideoPlaybackShort(7);
+    }
+
+    public void testPlay08() throws Exception {
+        doTestVideoPlaybackShort(8);
+    }
+
+    public void testPlay09() throws Exception {
+        doTestVideoPlaybackShort(9);
+    }
+
+    public void testPlay10() throws Exception {
+        doTestVideoPlaybackShort(10);
+    }
+
+    public void testPlay11() throws Exception {
+        doTestVideoPlaybackShort(11);
+    }
+
+    @Override
+    protected String getFullVideoClipName(int mediaNumber) {
+        return VIDEO_TOP_DIR + VIDEO_PATH_MIDDLE + mMedias[mediaNumber];
+    }
+
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/H264R720pAacLongPlayerTest.java b/tests/tests/mediastress/src/android/mediastress/cts/H264R720pAacLongPlayerTest.java
new file mode 100644
index 0000000..3efec62
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/H264R720pAacLongPlayerTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+import android.media.CamcorderProfile;
+import android.media.MediaRecorder.AudioEncoder;
+import android.media.MediaRecorder.VideoEncoder;
+
+public class H264R720pAacLongPlayerTest extends MediaPlayerStressTest {
+    private static final String VIDEO_PATH_MIDDLE = "bbb_full/1280x720/mp4_libx264_libfaac/";
+    private final String[] mMedias = {
+        "bbb_full.ffmpeg.1280x720.mp4.libx264_1350kbps_25fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_full.ffmpeg.1280x720.mp4.libx264_1750kbps_30fps.libfaac_stereo_192kbps_48000Hz.mp4"
+    };
+
+    public H264R720pAacLongPlayerTest() {
+        super(CamcorderProfile.QUALITY_720P, VideoEncoder.H264, AudioEncoder.AAC);
+    }
+
+    public void testPlay00() throws Exception {
+        doTestVideoPlaybackLong(0);
+    }
+
+    public void testPlay01() throws Exception {
+        doTestVideoPlaybackLong(1);
+    }
+
+    @Override
+    protected String getFullVideoClipName(int mediaNumber) {
+        return VIDEO_TOP_DIR + VIDEO_PATH_MIDDLE + mMedias[mediaNumber];
+    }
+
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/H264R720pAacShortPlayerTest.java b/tests/tests/mediastress/src/android/mediastress/cts/H264R720pAacShortPlayerTest.java
new file mode 100644
index 0000000..e919a35
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/H264R720pAacShortPlayerTest.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+import android.media.CamcorderProfile;
+import android.media.MediaRecorder.AudioEncoder;
+import android.media.MediaRecorder.VideoEncoder;
+
+public class H264R720pAacShortPlayerTest extends MediaPlayerStressTest {
+    private static final String VIDEO_PATH_MIDDLE = "bbb_short/1280x720/mp4_libx264_libfaac/";
+    private final String[] mMedias = {
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_10000kbps_30fps.libfaac_stereo_192kbps_48000Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_1000kbps_25fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_1000kbps_25fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_1000kbps_30fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_1000kbps_30fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_1350kbps_25fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_1350kbps_25fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_1350kbps_30fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_1350kbps_30fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_1750kbps_30fps.libfaac_stereo_192kbps_48000Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_5000kbps_30fps.libfaac_stereo_192kbps_48000Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_500kbps_25fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_500kbps_25fps.libfaac_stereo_192kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_500kbps_30fps.libfaac_stereo_128kbps_44100Hz.mp4",
+        "bbb_short.ffmpeg.1280x720.mp4.libx264_500kbps_30fps.libfaac_stereo_192kbps_44100Hz.mp4"
+    };
+
+    public H264R720pAacShortPlayerTest() {
+        super(CamcorderProfile.QUALITY_720P, VideoEncoder.H264, AudioEncoder.AAC);
+    }
+
+    public void testPlay00() throws Exception {
+        doTestVideoPlaybackShort(0);
+    }
+
+    public void testPlay01() throws Exception {
+        doTestVideoPlaybackShort(1);
+    }
+
+    public void testPlay02() throws Exception {
+        doTestVideoPlaybackShort(2);
+    }
+
+    public void testPlay03() throws Exception {
+        doTestVideoPlaybackShort(3);
+    }
+
+    public void testPlay04() throws Exception {
+        doTestVideoPlaybackShort(4);
+    }
+
+    public void testPlay05() throws Exception {
+        doTestVideoPlaybackShort(5);
+    }
+
+    public void testPlay06() throws Exception {
+        doTestVideoPlaybackShort(6);
+    }
+
+    public void testPlay07() throws Exception {
+        doTestVideoPlaybackShort(7);
+    }
+
+    public void testPlay08() throws Exception {
+        doTestVideoPlaybackShort(8);
+    }
+
+    public void testPlay09() throws Exception {
+        doTestVideoPlaybackShort(9);
+    }
+
+    public void testPlay10() throws Exception {
+        doTestVideoPlaybackShort(10);
+    }
+
+    public void testPlay11() throws Exception {
+        doTestVideoPlaybackShort(11);
+    }
+
+    public void testPlay12() throws Exception {
+        doTestVideoPlaybackShort(12);
+    }
+
+    public void testPlay13() throws Exception {
+        doTestVideoPlaybackShort(13);
+    }
+
+    public void testPlay14() throws Exception {
+        doTestVideoPlaybackShort(14);
+    }
+
+    @Override
+    protected String getFullVideoClipName(int mediaNumber) {
+        return VIDEO_TOP_DIR + VIDEO_PATH_MIDDLE + mMedias[mediaNumber];
+    }
+
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/MediaFrameworkTest.java b/tests/tests/mediastress/src/android/mediastress/cts/MediaFrameworkTest.java
new file mode 100644
index 0000000..034eeeb
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/MediaFrameworkTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.PowerManager;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+
+import com.android.cts.mediastress.R;
+
+public class MediaFrameworkTest extends Activity implements SurfaceHolder.Callback {
+    private static String TAG = "MediaFrameworkTest";
+    private static SurfaceView mSurfaceView;
+
+    private Bitmap mDestBitmap;
+    private ImageView mOverlayView;
+
+    private PowerManager.WakeLock mWakeLock = null;
+
+    public static SurfaceView getSurfaceView() {
+        return mSurfaceView;
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        setContentView(R.layout.surface_view);
+        mSurfaceView = (SurfaceView)findViewById(R.id.surface_view);
+        mOverlayView = (ImageView)findViewById(R.id.overlay_layer);
+        ViewGroup.LayoutParams lp = mSurfaceView.getLayoutParams();
+        mSurfaceView.getHolder().addCallback(this);
+
+        mOverlayView.setLayoutParams(lp);
+        mDestBitmap = Bitmap.createBitmap((int)640, (int)480, Bitmap.Config.ARGB_8888);
+        mOverlayView.setImageBitmap(mDestBitmap);
+
+        //Acquire the full wake lock to keep the device up
+        PowerManager pm = (PowerManager) this.getSystemService(Context.POWER_SERVICE);
+        mWakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK, "MediaFrameworkTest");
+        mWakeLock.acquire();
+    }
+
+    public void onStop(Bundle icicle) {
+        mWakeLock.release();
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        //Can do nothing in here. The test case will fail if the surface destroyed.
+        Log.v(TAG, "Test application surface destroyed");
+    }
+
+    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
+        //Do nothing in here. Just print out the log
+        Log.v(TAG, "Test application surface changed");
+    }
+
+    public void surfaceCreated(SurfaceHolder holder) {
+        holder.addCallback(this);
+        Log.v(TAG, "Test application surface created");
+    }
+
+    public void startPlayback(String filename){
+      String mimetype = "audio/mpeg";
+      Uri path = Uri.parse(filename);
+      Intent intent = new Intent(Intent.ACTION_VIEW);
+      intent.setDataAndType(path, mimetype);
+      startActivity(intent);
+    }
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/MediaPlayerStressTest.java b/tests/tests/mediastress/src/android/mediastress/cts/MediaPlayerStressTest.java
new file mode 100644
index 0000000..3678811
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/MediaPlayerStressTest.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2011 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.mediastress.cts;
+
+import android.app.Activity;
+import android.app.Instrumentation;
+import android.content.Intent;
+import android.media.CamcorderProfile;
+import android.media.MediaRecorder.AudioEncoder;
+import android.media.MediaRecorder.VideoEncoder;
+import android.os.Environment;
+import android.test.suitebuilder.annotation.LargeTest;
+import android.util.Log;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.Writer;
+
+import android.test.InstrumentationTestCase;
+
+/**
+ * Helper for implementing video playback stress test
+ */
+abstract class MediaPlayerStressTest extends InstrumentationTestCase {
+    protected static final String VIDEO_TOP_DIR = WorkDir.getMediaDirString();
+    protected static final int REPEAT_NUMBER_FOR_SHORT_CLIPS = 2;
+    protected static final int REPEAT_NUMBER_FOR_LONG_CLIPS = 1;
+    private static final String TAG = "MediaPlayerStressTest";
+    // whether a video format is supported or not.
+    private final boolean mSupported;
+
+    /**
+     * construct a test case with check of whether the format is supported or not.
+     * @param quality
+     * @param videoCodec
+     * @param audioCodec
+     */
+    protected MediaPlayerStressTest(int quality, int videoCodec, int audioCodec) {
+        mSupported = VideoPlayerCapability.formatSupported(quality, videoCodec, audioCodec);
+    }
+
+    protected MediaPlayerStressTest() {
+        mSupported = true; // supported if nothing specified
+    }
+
+    /**
+     * provides full path name of video clip for the given media number
+     * @param mediaNumber
+     * @return video file name
+     */
+    abstract protected String getFullVideoClipName(int mediaNumber);
+
+    private int mTotalPlaybackError;
+    private int mTotalComplete;
+    private int mTotalInfoUnknown;
+    private int mTotalVideoTrackLagging;
+    private int mTotalBadInterleaving;
+    private int mTotalNotSeekable;
+    private int mTotalMetaDataUpdate;
+
+    private void writeTestOutput(String filename, Writer output) throws Exception{
+        output.write("File Name: " + filename);
+        output.write(" Complete: " + CodecTest.mOnCompleteSuccess);
+        output.write(" Error: " + CodecTest.mPlaybackError);
+        output.write(" Unknown Info: " + CodecTest.mMediaInfoUnknownCount);
+        output.write(" Track Lagging: " +  CodecTest.mMediaInfoVideoTrackLaggingCount);
+        output.write(" Bad Interleaving: " + CodecTest.mMediaInfoBadInterleavingCount);
+        output.write(" Not Seekable: " + CodecTest.mMediaInfoNotSeekableCount);
+        output.write(" Info Meta data update: " + CodecTest.mMediaInfoMetdataUpdateCount);
+        output.write("\n");
+    }
+
+    private void writeTestSummary(Writer output) throws Exception{
+        output.write("Total Result:\n");
+        output.write("Total Complete: " + mTotalComplete + "\n");
+        output.write("Total Error: " + mTotalPlaybackError + "\n");
+        output.write("Total Unknown Info: " + mTotalInfoUnknown + "\n");
+        output.write("Total Track Lagging: " + mTotalVideoTrackLagging + "\n" );
+        output.write("Total Bad Interleaving: " + mTotalBadInterleaving + "\n");
+        output.write("Total Not Seekable: " + mTotalNotSeekable + "\n");
+        output.write("Total Info Meta data update: " + mTotalMetaDataUpdate + "\n");
+        output.write("\n");
+    }
+
+    private void updateTestResult(){
+        if (CodecTest.mOnCompleteSuccess){
+            mTotalComplete++;
+        }
+        else if (CodecTest.mPlaybackError){
+            mTotalPlaybackError++;
+        }
+        mTotalInfoUnknown += CodecTest.mMediaInfoUnknownCount;
+        mTotalVideoTrackLagging += CodecTest.mMediaInfoVideoTrackLaggingCount;
+        mTotalBadInterleaving += CodecTest.mMediaInfoBadInterleavingCount;
+        mTotalNotSeekable += CodecTest.mMediaInfoNotSeekableCount;
+        mTotalMetaDataUpdate += CodecTest.mMediaInfoMetdataUpdateCount;
+    }
+
+    /**
+     * runs video playback test for the given mediaNumber
+     * @param mediaNumber number of media to be used for playback.
+     *         This number is passed to getFullVideoClipName.
+     * @param  repeatCounter repeat playback for the given number
+     * @throws Exception
+     */
+    protected void doTestVideoPlayback(int mediaNumber, int repeatCounter) throws Exception {
+        if (!mSupported) {
+            return;
+        }
+
+        File playbackOutput = new File(WorkDir.getTopDir(), "PlaybackTestResult.txt");
+        Writer output = new BufferedWriter(new FileWriter(playbackOutput, true));
+
+        boolean testResult = true;
+        boolean onCompleteSuccess = false;
+
+        Instrumentation inst = getInstrumentation();
+        Intent intent = new Intent();
+
+        intent.setClass(inst.getTargetContext(), MediaFrameworkTest.class);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+        Activity act = inst.startActivitySync(intent);
+
+        String mediaName = getFullVideoClipName(mediaNumber);
+        for (int i = 0; i < repeatCounter; i++) {
+            Log.v(TAG, "start playing " + mediaName);
+            onCompleteSuccess =
+                CodecTest.playMediaSample(mediaName);
+            if (!onCompleteSuccess) {
+                //Don't fail the test right away, print out the failure file.
+                Log.v(TAG, "Failure File : " + mediaName);
+                testResult = false;
+            }
+        }
+        Thread.sleep(1000);
+
+        act.finish();
+        //Write test result to an output file
+        writeTestOutput(mediaName, output);
+        //Get the summary
+        updateTestResult();
+
+        writeTestSummary(output);
+        output.close();
+        assertTrue("playback " + mediaName, testResult);
+    }
+
+    protected void doTestVideoPlaybackShort(int mediaNumber) throws Exception {
+        doTestVideoPlayback(mediaNumber, REPEAT_NUMBER_FOR_SHORT_CLIPS);
+    }
+
+    protected void doTestVideoPlaybackLong(int mediaNumber) throws Exception {
+        doTestVideoPlayback(mediaNumber, REPEAT_NUMBER_FOR_LONG_CLIPS);
+    }
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/MediaRecorderStressTest.java b/tests/tests/mediastress/src/android/mediastress/cts/MediaRecorderStressTest.java
new file mode 100644
index 0000000..0ca8f99
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/MediaRecorderStressTest.java
@@ -0,0 +1,382 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+import android.hardware.Camera;
+import android.media.CamcorderProfile;
+import android.media.MediaPlayer;
+import android.media.MediaRecorder;
+import android.os.Handler;
+import android.os.Looper;
+import android.test.ActivityInstrumentationTestCase2;
+import android.test.suitebuilder.annotation.LargeTest;
+import android.util.Log;
+import android.view.SurfaceHolder;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.Writer;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+
+public class MediaRecorderStressTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> {
+
+    private static String TAG = "MediaRecorderStressTest";
+    private static final int NUMBER_OF_CAMERA_STRESS_LOOPS = 50;
+    private static final int NUMBER_OF_RECORDER_STRESS_LOOPS = 50;
+    private static final int NUMBER_OF_RECORDERANDPLAY_STRESS_LOOPS = 50;
+    private static final int NUMBER_OF_SWTICHING_LOOPS_BW_CAMERA_AND_RECORDER = 50;
+    private static final long WAIT_TIME_CAMERA_TEST = 3000;  // in ms
+    private static final long WAIT_TIME_RECORDER_TEST = 5000;  // in ms
+    private static final String OUTPUT_FILE = WorkDir.getTopDirString() + "temp";
+    private static final String OUTPUT_FILE_EXT = ".3gp";
+    private static final String MEDIA_STRESS_OUTPUT ="mediaStressOutput.txt";
+    private final CameraErrorCallback mCameraErrorCallback = new CameraErrorCallback();
+    private final RecorderErrorCallback mRecorderErrorCallback = new RecorderErrorCallback();
+    private final static int WAIT_TIMEOUT = 10000;
+
+    private MediaRecorder mRecorder;
+    private Camera mCamera;
+    private Thread mLooperThread;
+    private Handler mHandler;
+
+    private static int mCameraId;
+    private static int mProfileQuality = CamcorderProfile.QUALITY_HIGH;
+    private static CamcorderProfile profile =
+                        CamcorderProfile.get(mCameraId, mProfileQuality);
+
+    private int mIterations = 50;
+    private int mVideoEncoder;
+    private int mAudioEncoder;
+    private int mFrameRate;
+    private int mVideoWidth;
+    private int mVideoHeight;
+    private int mBitRate;
+    private boolean mRemoveVideo = true;
+    private int mRecordDuration = 5000;
+
+    public MediaRecorderStressTest() {
+        super(MediaFrameworkTest.class);
+    }
+
+    protected void setUp() throws Exception {
+        int cameraId = 0;
+        CamcorderProfile profile = CamcorderProfile.get(cameraId, CamcorderProfile.QUALITY_HIGH);
+        mVideoEncoder = profile.videoCodec;
+        mAudioEncoder = profile.audioCodec;
+        mFrameRate = profile.videoFrameRate;
+        mVideoWidth = profile.videoFrameWidth;
+        mVideoHeight = profile.videoFrameHeight;
+        mBitRate = profile.videoBitRate;
+
+        final Semaphore sem = new Semaphore(0);
+        mLooperThread = new Thread() {
+            @Override
+            public void run() {
+                Log.v(TAG, "starting looper");
+                Looper.prepare();
+                mHandler = new Handler();
+                sem.release();
+                Looper.loop();
+                Log.v(TAG, "quit looper");
+            }
+        };
+        mLooperThread.start();
+        if (!sem.tryAcquire(WAIT_TIMEOUT, TimeUnit.MILLISECONDS)) {
+            fail("Failed to start the looper.");
+        }
+
+        getActivity();
+        super.setUp();
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        if (mHandler != null) {
+            mHandler.getLooper().quit();
+            mHandler = null;
+        }
+        if (mLooperThread != null) {
+            mLooperThread.join(WAIT_TIMEOUT);
+            if (mLooperThread.isAlive()) {
+                fail("Failed to stop the looper.");
+            }
+            mLooperThread = null;
+        }
+
+        super.tearDown();
+    }
+
+    private void runOnLooper(final Runnable command) throws InterruptedException {
+        final Semaphore sem = new Semaphore(0);
+        mHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    command.run();
+                } finally {
+                    sem.release();
+                }
+            }
+        });
+        if (! sem.tryAcquire(WAIT_TIMEOUT, TimeUnit.MILLISECONDS)) {
+            fail("Failed to run the command on the looper.");
+        }
+    }
+
+    private final class CameraErrorCallback implements android.hardware.Camera.ErrorCallback {
+        public void onError(int error, android.hardware.Camera camera) {
+            assertTrue("Camera test mediaserver died", error !=
+                    android.hardware.Camera.CAMERA_ERROR_SERVER_DIED);
+        }
+    }
+
+    private final class RecorderErrorCallback implements MediaRecorder.OnErrorListener {
+        public void onError(MediaRecorder mr, int what, int extra) {
+            // fail the test case no matter what error come up
+            fail("mediaRecorder error");
+        }
+    }
+
+    //Test case for stressing the camera preview.
+    @LargeTest
+    public void testStressCamera() throws Exception {
+        SurfaceHolder mSurfaceHolder;
+        mSurfaceHolder = MediaFrameworkTest.getSurfaceView().getHolder();
+        File stressOutFile = new File(WorkDir.getTopDir(), MEDIA_STRESS_OUTPUT);
+        Writer output = new BufferedWriter(new FileWriter(stressOutFile, true));
+        output.write("Camera start preview stress:\n");
+        output.write("Total number of loops:" +
+                NUMBER_OF_CAMERA_STRESS_LOOPS + "\n");
+
+        Log.v(TAG, "Start preview");
+        output.write("No of loop: ");
+
+        for (int i = 0; i< NUMBER_OF_CAMERA_STRESS_LOOPS; i++) {
+            runOnLooper(new Runnable() {
+                @Override
+                public void run() {
+                    mCamera = Camera.open();
+                }
+            });
+            mCamera.setErrorCallback(mCameraErrorCallback);
+            mCamera.setPreviewDisplay(mSurfaceHolder);
+            mCamera.startPreview();
+            Thread.sleep(WAIT_TIME_CAMERA_TEST);
+            mCamera.stopPreview();
+            mCamera.release();
+            output.write(" ," + i);
+        }
+
+        output.write("\n\n");
+        output.close();
+    }
+
+    //Test case for stressing the camera preview.
+    @LargeTest
+    public void testStressRecorder() throws Exception {
+        String filename;
+        SurfaceHolder mSurfaceHolder;
+        mSurfaceHolder = MediaFrameworkTest.getSurfaceView().getHolder();
+        File stressOutFile = new File(WorkDir.getTopDir(), MEDIA_STRESS_OUTPUT);
+        Writer output = new BufferedWriter(new FileWriter(stressOutFile, true));
+        output.write("H263 video record- reset after prepare Stress test\n");
+        output.write("Total number of loops:" +
+                NUMBER_OF_RECORDER_STRESS_LOOPS + "\n");
+
+        output.write("No of loop: ");
+        Log.v(TAG, "Start preview");
+        for (int i = 0; i < NUMBER_OF_RECORDER_STRESS_LOOPS; i++) {
+            runOnLooper(new Runnable() {
+                @Override
+                public void run() {
+                    mRecorder = new MediaRecorder();
+                }
+            });
+            Log.v(TAG, "counter = " + i);
+            filename = OUTPUT_FILE + i + OUTPUT_FILE_EXT;
+            Log.v(TAG, filename);
+            mRecorder.setOnErrorListener(mRecorderErrorCallback);
+            mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
+            mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
+            mRecorder.setOutputFile(filename);
+            mRecorder.setVideoFrameRate(mFrameRate);
+            mRecorder.setVideoSize(176,144);
+            Log.v(TAG, "setEncoder");
+            mRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H263);
+            mSurfaceHolder = MediaFrameworkTest.getSurfaceView().getHolder();
+            Log.v(TAG, "setPreview");
+            mRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
+            Log.v(TAG, "prepare");
+            mRecorder.prepare();
+            Log.v(TAG, "before release");
+            Thread.sleep(WAIT_TIME_RECORDER_TEST);
+            mRecorder.reset();
+            mRecorder.release();
+            output.write(", " + i);
+        }
+
+        output.write("\n\n");
+        output.close();
+    }
+
+    //Stress test case for switching camera and video recorder preview.
+    @LargeTest
+    public void testStressCameraSwitchRecorder() throws Exception {
+        String filename;
+        SurfaceHolder mSurfaceHolder;
+        mSurfaceHolder = MediaFrameworkTest.getSurfaceView().getHolder();
+        File stressOutFile = new File(WorkDir.getTopDir(), MEDIA_STRESS_OUTPUT);
+        Writer output = new BufferedWriter(new FileWriter(stressOutFile, true));
+        output.write("Camera and video recorder preview switching\n");
+        output.write("Total number of loops:"
+                + NUMBER_OF_SWTICHING_LOOPS_BW_CAMERA_AND_RECORDER + "\n");
+
+        Log.v(TAG, "Start preview");
+        output.write("No of loop: ");
+        for (int i = 0; i < NUMBER_OF_SWTICHING_LOOPS_BW_CAMERA_AND_RECORDER; i++) {
+            runOnLooper(new Runnable() {
+                @Override
+                public void run() {
+                    mCamera = Camera.open();
+                }
+            });
+            mCamera.setErrorCallback(mCameraErrorCallback);
+            mCamera.setPreviewDisplay(mSurfaceHolder);
+            mCamera.startPreview();
+            Thread.sleep(WAIT_TIME_CAMERA_TEST);
+            mCamera.stopPreview();
+            mCamera.release();
+            mCamera = null;
+            Log.v(TAG, "release camera");
+            filename = OUTPUT_FILE + i + OUTPUT_FILE_EXT;
+            Log.v(TAG, filename);
+            runOnLooper(new Runnable() {
+                @Override
+                public void run() {
+                    mRecorder = new MediaRecorder();
+                }
+            });
+            mRecorder.setOnErrorListener(mRecorderErrorCallback);
+            mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
+            mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
+            mRecorder.setOutputFile(filename);
+            mRecorder.setVideoFrameRate(mFrameRate);
+            mRecorder.setVideoSize(176,144);
+            Log.v(TAG, "Media recorder setEncoder");
+            mRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H263);
+            Log.v(TAG, "mediaRecorder setPreview");
+            mRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
+            Log.v(TAG, "prepare");
+            mRecorder.prepare();
+            Log.v(TAG, "before release");
+            Thread.sleep(WAIT_TIME_CAMERA_TEST);
+            mRecorder.release();
+            Log.v(TAG, "release video recorder");
+            output.write(", " + i);
+        }
+
+        output.write("\n\n");
+        output.close();
+    }
+
+    public void validateRecordedVideo(String recordedFile) throws Exception {
+        MediaPlayer mp = new MediaPlayer();
+        mp.setDataSource(recordedFile);
+        mp.prepare();
+        int duration = mp.getDuration();
+        if (duration <= 0){
+            assertTrue("stressRecordAndPlayback", false);
+        }
+        mp.release();
+    }
+
+    public void removeRecodedVideo(String filename){
+        File video = new File(filename);
+        Log.v(TAG, "remove recorded video " + filename);
+        video.delete();
+    }
+
+    //Stress test case for record a video and play right away.
+    @LargeTest
+    public void testStressRecordVideoAndPlayback() throws Exception {
+        String filename;
+        SurfaceHolder mSurfaceHolder;
+        mSurfaceHolder = MediaFrameworkTest.getSurfaceView().getHolder();
+        File stressOutFile = new File(WorkDir.getTopDir(), MEDIA_STRESS_OUTPUT);
+        Writer output = new BufferedWriter(
+                new FileWriter(stressOutFile, true));
+        output.write("Video record and play back stress test:\n");
+        output.write("Total number of loops:"
+                + NUMBER_OF_RECORDERANDPLAY_STRESS_LOOPS + "\n");
+
+        output.write("No of loop: ");
+        for (int i = 0; i < mIterations; i++){
+            filename = OUTPUT_FILE + i + OUTPUT_FILE_EXT;
+            Log.v(TAG, filename);
+            runOnLooper(new Runnable() {
+                @Override
+                public void run() {
+                    mRecorder = new MediaRecorder();
+                }
+            });
+            Log.v(TAG, "iterations : " + mIterations);
+            Log.v(TAG, "videoEncoder : " + mVideoEncoder);
+            Log.v(TAG, "audioEncoder : " + mAudioEncoder);
+            Log.v(TAG, "frameRate : " + mFrameRate);
+            Log.v(TAG, "videoWidth : " + mVideoWidth);
+            Log.v(TAG, "videoHeight : " + mVideoHeight);
+            Log.v(TAG, "bitRate : " + mBitRate);
+            Log.v(TAG, "recordDuration : " + mRecordDuration);
+
+            mRecorder.setOnErrorListener(mRecorderErrorCallback);
+            mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
+            mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
+            mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
+            mRecorder.setOutputFile(filename);
+            mRecorder.setVideoFrameRate(mFrameRate);
+            mRecorder.setVideoSize(mVideoWidth, mVideoHeight);
+            mRecorder.setVideoEncoder(mVideoEncoder);
+            mRecorder.setAudioEncoder(mAudioEncoder);
+            Log.v(TAG, "mediaRecorder setPreview");
+            mRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
+            mRecorder.prepare();
+            mRecorder.start();
+            Thread.sleep(mRecordDuration);
+            Log.v(TAG, "Before stop");
+            mRecorder.stop();
+            mRecorder.release();
+            //start the playback
+            MediaPlayer mp = new MediaPlayer();
+            mp.setDataSource(filename);
+            mp.setDisplay(MediaFrameworkTest.getSurfaceView().getHolder());
+            mp.prepare();
+            mp.start();
+            Thread.sleep(mRecordDuration);
+            mp.release();
+            validateRecordedVideo(filename);
+            if (mRemoveVideo) {
+                removeRecodedVideo(filename);
+            }
+            output.write(", " + i);
+        }
+
+        output.write("\n\n");
+        output.close();
+    }
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/VideoPlayerCapability.java b/tests/tests/mediastress/src/android/mediastress/cts/VideoPlayerCapability.java
new file mode 100644
index 0000000..f8dd2aa
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/VideoPlayerCapability.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+import android.media.CamcorderProfile;
+import android.util.Log;
+
+import junit.framework.Assert;
+
+public class VideoPlayerCapability {
+    private static final String TAG = "VideoPlayCapability";
+
+    static boolean formatSupported(int quality, int videoCodec, int audioCodec) {
+        if (!CamcorderProfile.hasProfile(quality)) {
+            Log.i(TAG, "quality " + quality + " not supported");
+            return false;
+        }
+        CamcorderProfile profile = CamcorderProfile.get(quality);
+        Assert.assertNotNull(profile);
+        if ((profile.videoCodec == videoCodec) && (profile.audioCodec == audioCodec)) {
+            Log.i(TAG, "quality " + quality + " video codec " + videoCodec + " audio codec " +
+                    audioCodec + " supproted");
+            return true;
+        }
+        return false;
+    }
+
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/Vp8R480x360LongPlayerTest.java b/tests/tests/mediastress/src/android/mediastress/cts/Vp8R480x360LongPlayerTest.java
new file mode 100644
index 0000000..372f034
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/Vp8R480x360LongPlayerTest.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+public class Vp8R480x360LongPlayerTest extends MediaPlayerStressTest {
+    private static final String VIDEO_PATH_MIDDLE = "bbb_full/480x360/webm_libvpx_libvorbis/";
+    private final String[] mMedias = {
+        "bbb_full.ffmpeg.480x360.webm.libvpx_500kbps_25fps.libvorbis_stereo_128kbps_44100Hz.webm"
+    };
+
+    public void testPlay00() throws Exception {
+        doTestVideoPlaybackLong(0);
+    }
+
+    @Override
+    protected String getFullVideoClipName(int mediaNumber) {
+        return VIDEO_TOP_DIR + VIDEO_PATH_MIDDLE + mMedias[mediaNumber];
+    }
+
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/Vp8R480x360ShortPlayerTest.java b/tests/tests/mediastress/src/android/mediastress/cts/Vp8R480x360ShortPlayerTest.java
new file mode 100644
index 0000000..30b4d2e
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/Vp8R480x360ShortPlayerTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+public class Vp8R480x360ShortPlayerTest extends MediaPlayerStressTest {
+    private static final String VIDEO_PATH_MIDDLE = "bbb_short/480x360/webm_libvpx_libvorbis/";
+    private final String[] mMedias = {
+        "bbb_short.ffmpeg.480x360.webm.libvpx_1000kbps_25fps.libvorbis_stereo_128kbps_44100Hz.webm",
+        "bbb_short.ffmpeg.480x360.webm.libvpx_1000kbps_25fps.libvorbis_stereo_192kbps_44100Hz.webm",
+        "bbb_short.ffmpeg.480x360.webm.libvpx_1000kbps_30fps.libvorbis_stereo_128kbps_44100Hz.webm",
+        "bbb_short.ffmpeg.480x360.webm.libvpx_1000kbps_30fps.libvorbis_stereo_192kbps_44100Hz.webm",
+        "bbb_short.ffmpeg.480x360.webm.libvpx_1350kbps_25fps.libvorbis_stereo_128kbps_44100Hz.webm",
+        "bbb_short.ffmpeg.480x360.webm.libvpx_1350kbps_25fps.libvorbis_stereo_192kbps_44100Hz.webm",
+        "bbb_short.ffmpeg.480x360.webm.libvpx_1350kbps_30fps.libvorbis_stereo_128kbps_44100Hz.webm",
+        "bbb_short.ffmpeg.480x360.webm.libvpx_1350kbps_30fps.libvorbis_stereo_192kbps_44100Hz.webm",
+        "bbb_short.ffmpeg.480x360.webm.libvpx_500kbps_25fps.libvorbis_stereo_128kbps_44100Hz.webm",
+        "bbb_short.ffmpeg.480x360.webm.libvpx_500kbps_25fps.libvorbis_stereo_192kbps_44100Hz.webm",
+        "bbb_short.ffmpeg.480x360.webm.libvpx_500kbps_30fps.libvorbis_stereo_128kbps_44100Hz.webm",
+        "bbb_short.ffmpeg.480x360.webm.libvpx_500kbps_30fps.libvorbis_stereo_192kbps_44100Hz.webm"
+    };
+
+    public void testPlay00() throws Exception {
+        doTestVideoPlaybackShort(0);
+    }
+
+    public void testPlay01() throws Exception {
+        doTestVideoPlaybackShort(1);
+    }
+
+    public void testPlay02() throws Exception {
+        doTestVideoPlaybackShort(2);
+    }
+
+    public void testPlay03() throws Exception {
+        doTestVideoPlaybackShort(3);
+    }
+
+    public void testPlay04() throws Exception {
+        doTestVideoPlaybackShort(4);
+    }
+
+    public void testPlay05() throws Exception {
+        doTestVideoPlaybackShort(5);
+    }
+
+    public void testPlay06() throws Exception {
+        doTestVideoPlaybackShort(6);
+    }
+
+    public void testPlay07() throws Exception {
+        doTestVideoPlaybackShort(7);
+    }
+
+    public void testPlay08() throws Exception {
+        doTestVideoPlaybackShort(8);
+    }
+
+    public void testPlay09() throws Exception {
+        doTestVideoPlaybackShort(9);
+    }
+
+    public void testPlay10() throws Exception {
+        doTestVideoPlaybackShort(10);
+    }
+
+    public void testPlay11() throws Exception {
+        doTestVideoPlaybackShort(11);
+    }
+
+    @Override
+    protected String getFullVideoClipName(int mediaNumber) {
+        return VIDEO_TOP_DIR + VIDEO_PATH_MIDDLE + mMedias[mediaNumber];
+    }
+
+}
diff --git a/tests/tests/mediastress/src/android/mediastress/cts/WorkDir.java b/tests/tests/mediastress/src/android/mediastress/cts/WorkDir.java
new file mode 100644
index 0000000..4a40fad
--- /dev/null
+++ b/tests/tests/mediastress/src/android/mediastress/cts/WorkDir.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2012 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.mediastress.cts;
+
+import android.os.Environment;
+
+import java.io.File;
+
+import junit.framework.Assert;
+
+public class WorkDir {
+    static final File getTopDir() {
+        Assert.assertEquals(Environment.getExternalStorageState(), Environment.MEDIA_MOUNTED);
+        return Environment.getExternalStorageDirectory();
+    }
+
+    static final String getTopDirString() {
+        return (getTopDir().getAbsolutePath() + File.separator);
+    }
+
+    static final String getMediaDirString() {
+        return (getTopDirString() + "test/");
+    }
+}