auto import from //depot/cupcake/@137055

4 files changed, 1094 insertions, 153 deletions

diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkTestRunner.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkTestRunner.java
index 453a165..73688cc 100755
--- a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkTestRunner.java
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkTestRunner.java
@@ -47,9 +47,9 @@ public class MediaFrameworkTestRunner extends InstrumentationTestRunner {
         suite.addTestSuite(MediaPlayerApiTest.class);
         suite.addTestSuite(SimTonesTest.class);
         suite.addTestSuite(MediaMetadataTest.class);
-        // suite.addTestSuite(CameraTest.class);
+        suite.addTestSuite(CameraTest.class);
         suite.addTestSuite(MediaRecorderTest.class);
-        suite.addTestSuite(MediaAudioTrackTest.class);
+        //suite.addTestSuite(MediaAudioTrackTest.class);
         return suite;
     }
 
@@ -59,3 +59,4 @@ public class MediaFrameworkTestRunner extends InstrumentationTestRunner {
     }
 }
 
+
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/CameraTest.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/CameraTest.java
index 5981a13..59803f7 100644
--- a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/CameraTest.java
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/CameraTest.java
@@ -136,11 +136,13 @@ public class CameraTest extends ActivityInstrumentationTestCase<MediaFrameworkTe
     //Implement the RawPictureCallback
     private final class RawPictureCallback implements PictureCallback { 
         public void onPictureTaken(byte [] rawData, Camera camera) {
-           if (rawData != null) {
-               rawPictureCallbackResult = true;
-           } else {
-               rawPictureCallbackResult = false;
-           }
+           // no support for raw data - success if we get the callback
+           rawPictureCallbackResult = true;
+           //if (rawData != null) {
+           //    rawPictureCallbackResult = true;
+           //} else {
+           //    rawPictureCallbackResult = false;
+           //}
             Log.v(TAG, "RawPictureCallback callback");
         }
     };
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/MediaAudioTrackTest.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/MediaAudioTrackTest.java
index b6a0848..24edb65 100644
--- a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/MediaAudioTrackTest.java
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/MediaAudioTrackTest.java
@@ -34,7 +34,7 @@ import android.test.suitebuilder.annotation.Suppress;
  
  */  
 public class MediaAudioTrackTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> {    
-    private String TAG = "MediaAudioTrack";
+    private String TAG = "MediaAudioTrackTest";
    
     public MediaAudioTrackTest() {
         super("com.android.mediaframeworktest", MediaFrameworkTest.class);
@@ -50,6 +50,18 @@ public class MediaAudioTrackTest extends ActivityInstrumentationTestCase2<MediaF
         super.tearDown();              
     }
     
+    private static void assumeTrue(String message, boolean cond) {
+        assertTrue("(assume)"+message, cond);
+    }
+    
+    private void log(String testName, String message) {
+        Log.v(TAG, "["+testName+"] "+message);
+    }
+    
+    private void loge(String testName, String message) {
+        Log.e(TAG, "["+testName+"] "+message);
+    }
+    
     //-----------------------------------------------------------------
     // private class to hold test reslts
     public class TestResults {
@@ -62,7 +74,8 @@ public class MediaAudioTrackTest extends ActivityInstrumentationTestCase2<MediaF
     // generic test methods
     public TestResults constructorTestMultiSampleRate(
                         // parameters tested by this method
-                        int _inTest_streamType, int _inTest_mode, int _inTest_config,
+                        int _inTest_streamType, int _inTest_mode, 
+                        int _inTest_config, int _inTest_format,
                         // parameter-dependent expected results
                         int _expected_stateForMode) {
         
@@ -70,7 +83,7 @@ public class MediaAudioTrackTest extends ActivityInstrumentationTestCase2<MediaF
         String failedRates = "Failure for rate(s): ";
         boolean localRes, finalRes = true;
         
-        for(int i = 0 ; i < testSampleRates.length ; i++) {
+        for (int i = 0 ; i < testSampleRates.length ; i++) {
             //Log.v("MediaAudioTrackTest", "[ constructorTestMultiSampleRate ] testing "+ testSampleRates[i]);
             AudioTrack track = null;
             try {
@@ -78,15 +91,16 @@ public class MediaAudioTrackTest extends ActivityInstrumentationTestCase2<MediaF
                         _inTest_streamType, 
                         testSampleRates[i], 
                         _inTest_config, 
-                        AudioFormat.ENCODING_PCM_16BIT,
+                        _inTest_format,
                         AudioTrack.getMinBufferSize(testSampleRates[i], 
-                                _inTest_config, AudioFormat.ENCODING_PCM_16BIT),//testSampleRates[i]*4 
+                                _inTest_config, _inTest_format), 
                         _inTest_mode);
             } catch(IllegalArgumentException iae) {
                 Log.e("MediaAudioTrackTest", "[ constructorTestMultiSampleRate ] exception at SR "
                         + testSampleRates[i]+": \n" + iae);
+                localRes = false;
             }
-            if(track != null) {
+            if (track != null) {
                 localRes = (track.getState() == _expected_stateForMode);
                 track.release();
             }
@@ -98,11 +112,11 @@ public class MediaAudioTrackTest extends ActivityInstrumentationTestCase2<MediaF
                 //log the error for the test runner
                 failedRates += Integer.toString(testSampleRates[i]) + "Hz ";
                 //log the error for logcat
-                Log.e("MediaAudioTrackTest", "[ constructorTestMultiSampleRate ] failed to construct "
+                log("constructorTestMultiSampleRate", "failed to construct "
                         +"AudioTrack(streamType="+_inTest_streamType 
                         +", sampleRateInHz=" + testSampleRates[i]
                         +", channelConfig=" + _inTest_config
-                        +", audioFormat=AudioFormat.ENCODING_PCM_16BIT"  
+                        +", audioFormat=" + _inTest_format  
                         +", bufferSizeInBytes=" + AudioTrack.getMinBufferSize(testSampleRates[i], 
                                 _inTest_config, AudioFormat.ENCODING_PCM_16BIT)
                         +", mode="+ _inTest_mode );
@@ -118,16 +132,16 @@ public class MediaAudioTrackTest extends ActivityInstrumentationTestCase2<MediaF
     //----------------------------------
     
     //-----------------------------------------------------------------
-    //      AudioTrack constructor and AudioTrack.getMinBufferSize(...)
+    //      AudioTrack constructor and AudioTrack.getMinBufferSize(...) for 16bit PCM
     //----------------------------------
        
     //Test case 1: constructor for streaming AudioTrack, mono, 16bit at misc valid sample rates
-    @MediumTest
+    @LargeTest
     public void testConstructorMono16MusicStream() throws Exception {
         
         TestResults res = constructorTestMultiSampleRate(
                 AudioManager.STREAM_MUSIC, AudioTrack.MODE_STREAM, 
-                    AudioFormat.CHANNEL_CONFIGURATION_MONO,
+                    AudioFormat.CHANNEL_CONFIGURATION_MONO, AudioFormat.ENCODING_PCM_16BIT,
                 AudioTrack.STATE_INITIALIZED);
 
         assertTrue("testConstructorMono16MusicStream: " + res.mResultLog, res.mResult);
@@ -135,12 +149,12 @@ public class MediaAudioTrackTest extends ActivityInstrumentationTestCase2<MediaF
     
     
     //Test case 2: constructor for streaming AudioTrack, stereo, 16bit at misc valid sample rates
-    @MediumTest
+    @LargeTest
     public void testConstructorStereo16MusicStream() throws Exception {
         
         TestResults res = constructorTestMultiSampleRate(
                 AudioManager.STREAM_MUSIC, AudioTrack.MODE_STREAM, 
-                    AudioFormat.CHANNEL_CONFIGURATION_STEREO,
+                    AudioFormat.CHANNEL_CONFIGURATION_STEREO, AudioFormat.ENCODING_PCM_16BIT,
                 AudioTrack.STATE_INITIALIZED);
 
         assertTrue("testConstructorStereo16MusicStream: " + res.mResultLog, res.mResult);
@@ -148,12 +162,12 @@ public class MediaAudioTrackTest extends ActivityInstrumentationTestCase2<MediaF
     
     
     //Test case 3: constructor for static AudioTrack, mono, 16bit at misc valid sample rates
-    @MediumTest
+    @LargeTest
     public void testConstructorMono16MusicStatic() throws Exception {
         
         TestResults res = constructorTestMultiSampleRate(
                 AudioManager.STREAM_MUSIC, AudioTrack.MODE_STATIC, 
-                    AudioFormat.CHANNEL_CONFIGURATION_MONO,
+                    AudioFormat.CHANNEL_CONFIGURATION_MONO, AudioFormat.ENCODING_PCM_16BIT,
                 AudioTrack.STATE_NO_STATIC_DATA);
 
         assertTrue("testConstructorMono16MusicStatic: " + res.mResultLog, res.mResult);
@@ -161,16 +175,723 @@ public class MediaAudioTrackTest extends ActivityInstrumentationTestCase2<MediaF
     
     
     //Test case 4: constructor for static AudioTrack, stereo, 16bit at misc valid sample rates
-    @MediumTest
+    @LargeTest
     public void testConstructorStereo16MusicStatic() throws Exception {
         
         TestResults res = constructorTestMultiSampleRate(
                 AudioManager.STREAM_MUSIC, AudioTrack.MODE_STATIC, 
-                    AudioFormat.CHANNEL_CONFIGURATION_STEREO,
+                    AudioFormat.CHANNEL_CONFIGURATION_STEREO, AudioFormat.ENCODING_PCM_16BIT,
                 AudioTrack.STATE_NO_STATIC_DATA);
 
         assertTrue("testConstructorStereo16MusicStatic: " + res.mResultLog, res.mResult);
     }
+    
+    
+    //-----------------------------------------------------------------
+    //      AudioTrack constructor and AudioTrack.getMinBufferSize(...) for 8bit PCM
+    //----------------------------------
+       
+    //Test case 1: constructor for streaming AudioTrack, mono, 8bit at misc valid sample rates
+    @LargeTest
+    public void testConstructorMono8MusicStream() throws Exception {
+        
+        TestResults res = constructorTestMultiSampleRate(
+                AudioManager.STREAM_MUSIC, AudioTrack.MODE_STREAM, 
+                    AudioFormat.CHANNEL_CONFIGURATION_MONO, AudioFormat.ENCODING_PCM_8BIT,
+                AudioTrack.STATE_INITIALIZED);
+
+        assertTrue("testConstructorMono8MusicStream: " + res.mResultLog, res.mResult);
+    }
+    
+    //Test case 2: constructor for streaming AudioTrack, stereo, 8bit at misc valid sample rates
+    @LargeTest
+    public void testConstructorStereo8MusicStream() throws Exception {
+        
+        TestResults res = constructorTestMultiSampleRate(
+                AudioManager.STREAM_MUSIC, AudioTrack.MODE_STREAM, 
+                    AudioFormat.CHANNEL_CONFIGURATION_STEREO, AudioFormat.ENCODING_PCM_8BIT,
+                AudioTrack.STATE_INITIALIZED);
+
+        assertTrue("testConstructorStereo8MusicStream: " + res.mResultLog, res.mResult);
+    }
+    
+    //Test case 3: constructor for static AudioTrack, mono, 8bit at misc valid sample rates
+    @LargeTest
+    public void testConstructorMono8MusicStatic() throws Exception {
+        
+        TestResults res = constructorTestMultiSampleRate(
+                AudioManager.STREAM_MUSIC, AudioTrack.MODE_STATIC, 
+                    AudioFormat.CHANNEL_CONFIGURATION_MONO, AudioFormat.ENCODING_PCM_8BIT,
+                AudioTrack.STATE_NO_STATIC_DATA);
+
+        assertTrue("testConstructorMono8MusicStatic: " + res.mResultLog, res.mResult);
+    }
+    
+    //Test case 4: constructor for static AudioTrack, stereo, 8bit at misc valid sample rates
+    @LargeTest
+    public void testConstructorStereo8MusicStatic() throws Exception {
+        
+        TestResults res = constructorTestMultiSampleRate(
+                AudioManager.STREAM_MUSIC, AudioTrack.MODE_STATIC, 
+                    AudioFormat.CHANNEL_CONFIGURATION_STEREO, AudioFormat.ENCODING_PCM_8BIT,
+                AudioTrack.STATE_NO_STATIC_DATA);
+
+        assertTrue("testConstructorStereo8MusicStatic: " + res.mResultLog, res.mResult);
+    }
+    
+    
+    //-----------------------------------------------------------------
+    //      AudioTrack constructor for all stream types
+    //----------------------------------
+        
+    //Test case 1: constructor for all stream types
+    @LargeTest
+    public void testConstructorStreamType() throws Exception {
+        // constants for test
+        final int TYPE_TEST_SR = 22050;
+        final int TYPE_TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TYPE_TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TYPE_TEST_MODE = AudioTrack.MODE_STREAM;
+        final int[] STREAM_TYPES = { AudioManager.STREAM_ALARM, AudioManager.STREAM_BLUETOOTH_SCO, 
+                AudioManager.STREAM_MUSIC, AudioManager.STREAM_NOTIFICATION,
+                AudioManager.STREAM_RING, AudioManager.STREAM_SYSTEM, 
+                AudioManager.STREAM_VOICE_CALL };
+        final String[] STREAM_NAMES = { "STREAM_ALARM", "STREAM_BLUETOOTH_SCO", "STREAM_MUSIC",
+                "STREAM_NOTIFICATION", "STREAM_RING", "STREAM_SYSTEM", "STREAM_VOICE_CALL" };
+        
+        boolean localTestRes = true;
+        AudioTrack track = null;
+        // test: loop constructor on all stream types
+        for (int i = 0 ; i < STREAM_TYPES.length ; i++)
+        {
+            try {
+            //-------- initialization --------------
+                track = new AudioTrack(STREAM_TYPES[i], 
+                        TYPE_TEST_SR, TYPE_TEST_CONF, TYPE_TEST_FORMAT,
+                        AudioTrack.getMinBufferSize(TYPE_TEST_SR, TYPE_TEST_CONF, TYPE_TEST_FORMAT), 
+                        TYPE_TEST_MODE);
+            } catch (IllegalArgumentException iae) {
+                loge("testConstructorStreamType", "exception for stream type "
+                        + STREAM_NAMES[i] + ": "+ iae);
+                localTestRes = false;
+            }
+            //--------  test   --------------
+            if (track != null) {
+                if (track.getState() != AudioTrack.STATE_INITIALIZED) {
+                    localTestRes = false;
+                    Log.e("MediaAudioTrackTest", 
+                            "[ testConstructorStreamType ] failed for stream type "+STREAM_NAMES[i]);
+                }
+            //--------  tear down  --------------
+                track.release();
+            }
+            else {
+                localTestRes = false;
+            }
+        }
 
+        assertTrue("testConstructorStreamType", localTestRes);
+    }
+    
+    
+    //-----------------------------------------------------------------
+    //      Playback head position
+    //----------------------------------
+  
+    //Test case 1: getPlaybackHeadPosition() at 0 after initialization
+    @LargeTest
+    public void testPlaybackHeadPositionAfterInit() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testPlaybackHeadPositionAfterInit";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT), TEST_MODE);
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        assertTrue(TEST_NAME, track.getPlaybackHeadPosition() == 0);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 2: getPlaybackHeadPosition() increases after play()
+    @LargeTest
+    public void testPlaybackHeadPositionIncrease() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testPlaybackHeadPositionIncrease";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize/2];
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        track.play();
+        Thread.sleep(100);
+        log(TEST_NAME, "position ="+ track.getPlaybackHeadPosition());
+        assertTrue(TEST_NAME, track.getPlaybackHeadPosition() > 0);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 3: getPlaybackHeadPosition() is 0 after flush();
+    @LargeTest
+    public void testPlaybackHeadPositionAfterFlush() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testPlaybackHeadPositionAfterFlush";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize/2];
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        track.play();
+        Thread.sleep(100);
+        track.stop();
+        track.flush();
+        log(TEST_NAME, "position ="+ track.getPlaybackHeadPosition());
+        assertTrue(TEST_NAME, track.getPlaybackHeadPosition() == 0);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 3: getPlaybackHeadPosition() is 0 after stop();
+    @LargeTest
+    public void testPlaybackHeadPositionAfterStop() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testPlaybackHeadPositionAfterStop";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize/2];
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        track.play();
+        Thread.sleep(100);
+        track.stop();
+        Thread.sleep(100); // TODO: what is a sensible value?
+        int pos = track.getPlaybackHeadPosition();
+        log(TEST_NAME, "position ="+ pos);
+        assertTrue(TEST_NAME, pos == 0);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 4: getPlaybackHeadPosition() is > 0 after play(); pause();
+    @LargeTest
+    public void testPlaybackHeadPositionAfterPause() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testPlaybackHeadPositionAfterPause";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize/2];
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        track.play();
+        Thread.sleep(100);
+        track.pause();
+        int pos = track.getPlaybackHeadPosition();
+        log(TEST_NAME, "position ="+ pos);
+        assertTrue(TEST_NAME, pos > 0);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    
+    //-----------------------------------------------------------------
+    //      Playback properties
+    //----------------------------------
+    
+    //Test case 1: setStereoVolume() with max volume returns SUCCESS
+    @LargeTest
+    public void testSetStereoVolumeMax() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetStereoVolumeMax";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize/2];
+        //--------    test        --------------
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        track.play();
+        float maxVol = AudioTrack.getMaxVolume();
+        assertTrue(TEST_NAME, track.setStereoVolume(maxVol, maxVol) == AudioTrack.SUCCESS);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 2: setStereoVolume() with min volume returns SUCCESS
+    @LargeTest
+    public void testSetStereoVolumeMin() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetStereoVolumeMin";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize/2];
+        //--------    test        --------------
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        track.play();
+        float minVol = AudioTrack.getMinVolume();
+        assertTrue(TEST_NAME, track.setStereoVolume(minVol, minVol) == AudioTrack.SUCCESS);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 3: setStereoVolume() with mid volume returns SUCCESS
+    @LargeTest
+    public void testSetStereoVolumeMid() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetStereoVolumeMid";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize/2];
+        //--------    test        --------------
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        track.play();
+        float midVol = (AudioTrack.getMaxVolume() - AudioTrack.getMinVolume()) / 2;
+        assertTrue(TEST_NAME, track.setStereoVolume(midVol, midVol) == AudioTrack.SUCCESS);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 4: setPlaybackRate() with half the content rate returns SUCCESS
+    @LargeTest
+    public void testSetPlaybackRate() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetPlaybackRate";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize/2];
+        //--------    test        --------------
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        track.play();
+        assertTrue(TEST_NAME, track.setPlaybackRate((int)(TEST_SR/2)) == AudioTrack.SUCCESS);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 5: setPlaybackRate(0) returns bad value error
+    @LargeTest
+    public void testSetPlaybackRateZero() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetPlaybackRateZero";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        assertTrue(TEST_NAME, track.setPlaybackRate(0) == AudioTrack.ERROR_BAD_VALUE);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 6: setPlaybackRate() accepts values twice the output sample rate
+    @LargeTest
+    public void testSetPlaybackRateTwiceOutputSR() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetPlaybackRateTwiceOutputSR";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize/2];
+        int outputSR = AudioTrack.getNativeOutputSampleRate(TEST_STREAM_TYPE);
+        //--------    test        --------------
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        track.play();
+        assertTrue(TEST_NAME, track.setPlaybackRate(2*outputSR) == AudioTrack.SUCCESS);
+        //-------- tear down      --------------
+        track.release();
+    }
+/*    
+    //Test case 7: setPlaybackRate() clips values over twice the output sample rate
+    @LargeTest
+    public void testSetPlaybackRateClip() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetPlaybackRateClip";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_STEREO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize/2];
+        int outputSR = AudioTrack.getNativeOutputSampleRate(TEST_STREAM_TYPE);
+        //--------    test        --------------
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        track.play();
+        track.setPlaybackRate(3*outputSR);
+        assertTrue(TEST_NAME, track.getSampleRate() == 2*outputSR);
+        //-------- tear down      --------------
+        track.release();
+    }
+*/    
+    //Test case 8: setPlaybackRate() invalid operation if track not initialized
+    @LargeTest
+    public void testSetPlaybackRateUninit() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetPlaybackRateUninit";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_MONO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STATIC;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_NO_STATIC_DATA);
+        assertTrue(TEST_NAME, track.setPlaybackRate(TEST_SR/2) == AudioTrack.ERROR_INVALID_OPERATION);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //-----------------------------------------------------------------
+    //      Playback progress
+    //----------------------------------
+    
+    //Test case 1: setPlaybackHeadPosition() on playing track
+    @LargeTest
+    public void testSetPlaybackHeadPositionPlaying() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetPlaybackHeadPositionPlaying";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_MONO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                2*minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize];
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        track.play();
+        assertTrue(TEST_NAME,
+                track.setPlaybackHeadPosition(10) == AudioTrack.ERROR_INVALID_OPERATION);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 2: setPlaybackHeadPosition() on stopped track
+    @LargeTest
+    public void testSetPlaybackHeadPositionStopped() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetPlaybackHeadPositionStopped";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_MONO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                2*minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize];
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        track.play();
+        track.stop();
+        assumeTrue(TEST_NAME, track.getPlayState() == AudioTrack.PLAYSTATE_STOPPED);
+        assertTrue(TEST_NAME, track.setPlaybackHeadPosition(10) == AudioTrack.SUCCESS);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 3: setPlaybackHeadPosition() on paused track
+    @LargeTest
+    public void testSetPlaybackHeadPositionPaused() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetPlaybackHeadPositionPaused";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_MONO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                2*minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize];
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        track.play();
+        track.pause();
+        assumeTrue(TEST_NAME, track.getPlayState() == AudioTrack.PLAYSTATE_PAUSED);
+        assertTrue(TEST_NAME, track.setPlaybackHeadPosition(10) == AudioTrack.SUCCESS);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 4: setPlaybackHeadPosition() beyond what has been written
+    @LargeTest
+    public void testSetPlaybackHeadPositionTooFar() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetPlaybackHeadPositionTooFar";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_MONO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                2*minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize];
+        // make up a frame index that's beyond what has been written: go from buffer size to frame
+        //   count (given the audio track properties), and add 77.
+        int frameIndexTooFar = (2*minBuffSize/2) + 77;
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        track.write(data, 0, data.length);
+        track.write(data, 0, data.length);
+        track.play();
+        track.stop();
+        assumeTrue(TEST_NAME, track.getPlayState() == AudioTrack.PLAYSTATE_STOPPED);
+        assertTrue(TEST_NAME, track.setPlaybackHeadPosition(frameIndexTooFar) == AudioTrack.ERROR_BAD_VALUE);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    
+    //Test case 5: setLoopPoints() fails for MODE_STREAM
+    @LargeTest
+    public void testSetLoopPointsStream() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetLoopPointsStream";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_MONO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STREAM;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                2*minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize];
+        //--------    test        --------------
+        track.write(data, 0, data.length);
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        assertTrue(TEST_NAME, track.setLoopPoints(2, 50, 2) == AudioTrack.ERROR_INVALID_OPERATION);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 6: setLoopPoints() fails start > end
+    @LargeTest
+    public void testSetLoopPointsStartAfterEnd() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetLoopPointsStartAfterEnd";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_MONO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STATIC;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize];
+        //--------    test        --------------
+        track.write(data, 0, data.length);
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        assertTrue(TEST_NAME, track.setLoopPoints(50, 0, 2) == AudioTrack.ERROR_BAD_VALUE);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 6: setLoopPoints() success
+    @LargeTest
+    public void testSetLoopPointsSuccess() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetLoopPointsSuccess";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_MONO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STATIC;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize];
+        //--------    test        --------------
+        track.write(data, 0, data.length);
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        assertTrue(TEST_NAME, track.setLoopPoints(0, 50, 2) == AudioTrack.SUCCESS);
+        //-------- tear down      --------------
+        track.release();
+    }
+    
+    //Test case 7: setLoopPoints() fails with loop length bigger than content
+    @LargeTest
+    public void testSetLoopPointsLoopTooLong() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetLoopPointsLoopTooLong";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_MONO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STATIC;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize];
+        int dataSizeInFrames = minBuffSize/2;
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_NO_STATIC_DATA);
+        track.write(data, 0, data.length);
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        assertTrue(TEST_NAME, 
+                track.setLoopPoints(10, dataSizeInFrames+20, 2) == AudioTrack.ERROR_BAD_VALUE);
+        //-------- tear down      --------------
+        track.release();
+    }
+/*    
+    //Test case 7: setLoopPoints() fails with start beyond what can be written for the track
+    @LargeTest
+    public void testSetLoopPointsStartTooFar() throws Exception {
+        // constants for test
+        final String TEST_NAME = "testSetLoopPointsStartTooFar";
+        final int TEST_SR = 22050;
+        final int TEST_CONF = AudioFormat.CHANNEL_CONFIGURATION_MONO;
+        final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT;
+        final int TEST_MODE = AudioTrack.MODE_STATIC;
+        final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC;
+        
+        //-------- initialization --------------
+        int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT);
+        AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 
+                minBuffSize, TEST_MODE);
+        byte data[] = new byte[minBuffSize];
+        int dataSizeInFrames = minBuffSize/2;//16bit data
+        //--------    test        --------------
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_NO_STATIC_DATA);
+        track.write(data, 0, data.length);
+        assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED);
+        assertTrue(TEST_NAME, 
+                track.setLoopPoints(dataSizeInFrames+20, dataSizeInFrames+50, 2) 
+                    == AudioTrack.ERROR_BAD_VALUE);
+        //-------- tear down      --------------
+        track.release();
+    }
+*/    
+    
 }
 
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/performance/MediaPlayerPerformance.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/performance/MediaPlayerPerformance.java
index b606f25..2f0173d 100644
--- a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/performance/MediaPlayerPerformance.java
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/performance/MediaPlayerPerformance.java
@@ -1,17 +1,17 @@
 /*
  * Copyright (C) 2008 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
- *
+ * 
+ * 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.
+ * 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 com.android.mediaframeworktest.performance;
@@ -19,141 +19,358 @@ package com.android.mediaframeworktest.performance;
 import com.android.mediaframeworktest.MediaFrameworkTest;
 import com.android.mediaframeworktest.MediaNames;
 
-import android.content.Context;
 import android.database.sqlite.SQLiteDatabase;
 import android.media.MediaPlayer;
+import android.media.MediaRecorder;
 import android.os.SystemClock;
 import android.test.ActivityInstrumentationTestCase;
 import android.test.suitebuilder.annotation.LargeTest;
 import android.test.suitebuilder.annotation.Suppress;
 import android.util.Log;
+import android.view.SurfaceHolder;
 
 import java.io.FileDescriptor;
 import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Writer;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.BufferedWriter;
+
 import android.media.MediaMetadataRetriever;
 
 /**
- * Junit / Instrumentation test case for the media player api
- 
- */  
-public class MediaPlayerPerformance extends ActivityInstrumentationTestCase<MediaFrameworkTest> {    
-  
-   
-   private boolean mIsPlaying = true;
-   private String TAG = "MediaPlayerApiTest";
-   Context mContext;
-   private SQLiteDatabase mDB;
-   
-   
-   public MediaPlayerPerformance() {
-     super("com.android.mediaframeworktest", MediaFrameworkTest.class);
-   }
+ * Junit / Instrumentation - performance measurement for media player and 
+ * recorder
+ */
+public class MediaPlayerPerformance extends ActivityInstrumentationTestCase<MediaFrameworkTest> {
+
+    private String TAG = "MediaFrameworkPerformance";
+
+    private SQLiteDatabase mDB;
+    private SurfaceHolder mSurfaceHolder = null;
+    private static final int NUM_STRESS_LOOP = 10;
+    private static final int NUM_PLAYBACk_IN_EACH_LOOP = 20;
+    private static final long MEDIA_STRESS_WAIT_TIME = 5000; //5 seconds
+    private static final String H263_VIDEO_PLAYBACK_MEMOUT =
+        "/sdcard/h263VideoPlaybackMemOut.txt";
+    private static final String H264_VIDEO_PLAYBACK_MEMOUT =
+        "/sdcard/h264VideoPlaybackMemOut.txt";
+    private static final String WMV_VIDEO_PLAYBACK_MEMOUT =
+        "/sdcard/WmvVideoPlaybackMemOut.txt";
+    private static final String H263_VIDEO_ONLY_RECORD_MEMOUT =
+        "/sdcard/recordH263VideoOnlyMemOut.txt";
+    private static final String MP4_VIDEO_ONLY_RECORD_MEMOUT =
+        "/sdcard/recordMPEG4VideoOnlyMemOut.txt";
+    private static final String H263_VIDEO_AUDIO_RECORD_MEMOUT =
+        "/sdcard/recordVideoH263AudioMemOut.txt";
+    private static final String AUDIO_ONLY_RECORD_MEMOUT =
+        "/sdcard/recordAudioOnlyMemOut.txt";
+
+
+    public MediaPlayerPerformance() {
+        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
+    }
 
     protected void setUp() throws Exception {
-      
-      super.setUp();
-    }
-       
-    public void createDB(){
-      mDB = SQLiteDatabase.openOrCreateDatabase("/sdcard/perf.db",null);
-      mDB.execSQL("CREATE TABLE perfdata (_id INTEGER PRIMARY KEY,"
-          + "file TEXT," + "setdatatime LONG," +"preparetime LONG," +"playtime LONG" + ");");
-    }
-    
-    public void audioPlaybackStartupTime(String[] testFile){
-      long t1 = 0;
-      long t2 = 0;
-      long t3 = 0;
-      long t4 =0;
-      
-      long setDataSourceDuration = 0;
-      long prepareDuration = 0;
-      long startDuration=0;
-      
-      long totalSetDataTime=0;
-      long totalPrepareTime=0;
-      long totalStartDuration=0;
-      
-      int numberOfFiles = testFile.length;
-      Log.v(TAG, "File lenght " + numberOfFiles);
-      for (int k=0; k<numberOfFiles; k++){
-        MediaPlayer mp = new MediaPlayer();
-        try{
-          t1 = SystemClock.uptimeMillis();
-          FileInputStream  fis = new FileInputStream(testFile[k]);
-          FileDescriptor fd = fis.getFD();
-          mp.setDataSource(fd);
-          fis.close();
-          t2 = SystemClock.uptimeMillis();
-          mp.prepare();
-          t3 = SystemClock.uptimeMillis();
-          mp.start();
-          t4 = SystemClock.uptimeMillis();
-          Thread.sleep(10000);
-          mp.pause();
-        }catch (Exception e){}
-        setDataSourceDuration = t2 -t1;
-        prepareDuration = t3 - t2;
-        startDuration = t4 - t3;
-        totalSetDataTime = totalSetDataTime + setDataSourceDuration;
-        totalPrepareTime = totalPrepareTime + prepareDuration;
-        totalStartDuration = totalStartDuration + startDuration;
-        mDB.execSQL("INSERT INTO perfdata (file, setdatatime, preparetime, playtime) VALUES (" + '"' + testFile[k] + '"' +','
-          +setDataSourceDuration+ ',' + prepareDuration + ',' + startDuration +");");
-        Log.v(TAG,"File name " + testFile[k]);
-        mp.stop();
-        mp.release();   
-      }
-      Log.v (TAG, "setDataSource average " + totalSetDataTime/numberOfFiles);
-      Log.v (TAG, "prepare average " + totalPrepareTime/numberOfFiles);
-      Log.v (TAG, "start average " + totalStartDuration/numberOfFiles);
-      
-    }
-    
-    //Test cases for GetCurrentPosition
-    @LargeTest
+        super.setUp();
+    }
+
+    public void createDB() {
+        mDB = SQLiteDatabase.openOrCreateDatabase("/sdcard/perf.db", null);
+        mDB.execSQL("CREATE TABLE perfdata (_id INTEGER PRIMARY KEY," + 
+                "file TEXT," + "setdatatime LONG," + "preparetime LONG," +
+                "playtime LONG" + ");");
+    }
+
+    public void audioPlaybackStartupTime(String[] testFile) {
+        long t1 = 0;
+        long t2 = 0;
+        long t3 = 0;
+        long t4 = 0;
+        long setDataSourceDuration = 0;
+        long prepareDuration = 0;
+        long startDuration = 0;
+        long totalSetDataTime = 0;
+        long totalPrepareTime = 0;
+        long totalStartDuration = 0;
+
+        int numberOfFiles = testFile.length;
+        Log.v(TAG, "File length " + numberOfFiles);
+        for (int k = 0; k < numberOfFiles; k++) {
+            MediaPlayer mp = new MediaPlayer();
+            try {
+                t1 = SystemClock.uptimeMillis();
+                FileInputStream fis = new FileInputStream(testFile[k]);
+                FileDescriptor fd = fis.getFD();
+                mp.setDataSource(fd);
+                fis.close();
+                t2 = SystemClock.uptimeMillis();
+                mp.prepare();
+                t3 = SystemClock.uptimeMillis();
+                mp.start();
+                t4 = SystemClock.uptimeMillis();
+            } catch (Exception e) {
+                Log.v(TAG, e.toString());
+            }
+            setDataSourceDuration = t2 - t1;
+            prepareDuration = t3 - t2;
+            startDuration = t4 - t3;
+            totalSetDataTime = totalSetDataTime + setDataSourceDuration;
+            totalPrepareTime = totalPrepareTime + prepareDuration;
+            totalStartDuration = totalStartDuration + startDuration;
+            mDB.execSQL("INSERT INTO perfdata (file, setdatatime, preparetime," +
+                    " playtime) VALUES (" + '"' + testFile[k] + '"' + ',' +
+                    setDataSourceDuration + ',' + prepareDuration +
+            		',' + startDuration + ");");
+            Log.v(TAG, "File name " + testFile[k]);
+            mp.stop();
+            mp.release();
+        }
+        Log.v(TAG, "setDataSource average " + totalSetDataTime / numberOfFiles);
+        Log.v(TAG, "prepare average " + totalPrepareTime / numberOfFiles);
+        Log.v(TAG, "start average " + totalStartDuration / numberOfFiles);
+
+    }
+
+    @Suppress
     public void testStartUpTime() throws Exception {
-      createDB();
-      audioPlaybackStartupTime(MediaNames.MP3FILES);    
-      audioPlaybackStartupTime(MediaNames.AACFILES);   
-      
-    }
-   
-    public void wmametadatautility(String[] testFile){
-      long t1 = 0;
-      long t2 = 0;
-      long sum = 0;
-      long duration = 0;
-      MediaMetadataRetriever retriever = new MediaMetadataRetriever();
-      String value;
-      for(int i = 0, n = testFile.length; i < n; ++i) {
-          try {
-              t1 = SystemClock.uptimeMillis();
-              retriever.setDataSource(testFile[i]);
-              value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUM);
-              value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST);
-              value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COMPOSER);
-              value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_GENRE);
-              value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE);
-              value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_YEAR);
-              value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_CD_TRACK_NUMBER);
-              t2 = SystemClock.uptimeMillis();
-              duration = t2 - t1;
-              Log.v(TAG, "Time taken = " + duration);
-              sum=sum+duration;           
-          }
-          catch (Exception e){Log.v(TAG, e.getMessage());}
-          
-      }      
-      Log.v(TAG, "Average duration = " + sum/testFile.length); 
-    }
-    
+        createDB();
+        audioPlaybackStartupTime(MediaNames.MP3FILES);
+        audioPlaybackStartupTime(MediaNames.AACFILES);
+
+    }
+
+    public void wmametadatautility(String[] testFile) {
+        long t1 = 0;
+        long t2 = 0;
+        long sum = 0;
+        long duration = 0;
+        MediaMetadataRetriever retriever = new MediaMetadataRetriever();
+        String value;
+        for (int i = 0, n = testFile.length; i < n; ++i) {
+            try {
+                t1 = SystemClock.uptimeMillis();
+                retriever.setDataSource(testFile[i]);
+                value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUM);
+                value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST);
+                value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COMPOSER);
+                value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_GENRE);
+                value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE);
+                value = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_YEAR);
+                value =
+                    retriever
+                    .extractMetadata(MediaMetadataRetriever.METADATA_KEY_CD_TRACK_NUMBER);
+                t2 = SystemClock.uptimeMillis();
+                duration = t2 - t1;
+                Log.v(TAG, "Time taken = " + duration);
+                sum = sum + duration;
+            } catch (Exception e) {
+                Log.v(TAG, e.getMessage());
+            }
+
+        }
+        Log.v(TAG, "Average duration = " + sum / testFile.length);
+    }
+
+
+    // Note: This test is to assume the mediaserver's pid is 34
+    public void mediaStressPlayback(String testFilePath) {
+        for (int i = 0; i < NUM_PLAYBACk_IN_EACH_LOOP; i++) {
+            MediaPlayer mp = new MediaPlayer();
+            try {
+                mp.setDataSource(testFilePath);
+                mp.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder());
+                mp.prepare();
+                mp.start();
+                Thread.sleep(MEDIA_STRESS_WAIT_TIME);
+                mp.release();
+            } catch (Exception e) {
+                mp.release();
+                Log.v(TAG, e.toString());
+            }
+        }
+    }
+
+    // Note: This test is to assume the mediaserver's pid is 34
+    private void stressVideoRecord(int frameRate, int width, int height, int videoFormat,
+            int outFormat, String outFile, boolean videoOnly) {
+        // Video recording
+        for (int i = 0; i < NUM_PLAYBACk_IN_EACH_LOOP; i++) {
+            MediaRecorder mRecorder = new MediaRecorder();
+            try {
+                if (!videoOnly) {
+                    Log.v(TAG, "setAudioSource");
+                    mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
+                }
+                mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
+                mRecorder.setOutputFormat(outFormat);
+                Log.v(TAG, "output format " + outFormat);
+                mRecorder.setOutputFile(outFile);
+                mRecorder.setVideoFrameRate(frameRate);
+                mRecorder.setVideoSize(width, height);
+                Log.v(TAG, "setEncoder");
+                mRecorder.setVideoEncoder(videoFormat);
+                if (!videoOnly) {
+                    mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
+                }
+                mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
+                mRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
+                mRecorder.prepare();
+                mRecorder.start();
+                Thread.sleep(MEDIA_STRESS_WAIT_TIME);
+                mRecorder.stop();
+                mRecorder.release();
+            } catch (Exception e) {
+                Log.v("record video failed ", e.toString());
+                mRecorder.release();
+            }
+        }
+    }
+
+    public void stressAudioRecord(String filePath) {
+        // This test is only for the short media file
+        for (int i = 0; i < NUM_PLAYBACk_IN_EACH_LOOP; i++) {
+            MediaRecorder mRecorder = new MediaRecorder();
+            try {
+                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(MEDIA_STRESS_WAIT_TIME);
+                mRecorder.stop();
+                mRecorder.release();
+            } catch (Exception e) {
+                Log.v(TAG, e.toString());
+                mRecorder.release();
+            }
+        }
+    }
+
+    //Write the ps output to the file
+    public void getMemoryWriteToLog(Writer output) {
+        String cm = "ps mediaserver";
+        String memoryUsage = 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);
+            }
+            memoryUsage = sb.toString();
+        } catch (IOException e) {
+            Log.v(TAG, e.toString());
+        }
+
+        String[] poList = memoryUsage.split("\r|\n|\r\n");
+        String memusage = poList[1].concat("\n");
+        Log.v(TAG, memusage);
+        try {
+            //Write to file output
+            output.write(memusage);
+        } catch (Exception e) {
+            e.toString();
+        }
+    }
+
+
     @Suppress
     public void testWmaParseTime() throws Exception {
-     // createDB();
-      wmametadatautility(MediaNames.WMASUPPORTED);
+        // createDB();
+        wmametadatautility(MediaNames.WMASUPPORTED);
+    }
+
+
+    // Test case 1: Capture the memory usage after every 20 h263 playback
+    @LargeTest
+    public void testH263VideoPlaybackMemoryUsage() throws Exception {
+        File h263MemoryOut = new File(H263_VIDEO_PLAYBACK_MEMOUT);
+        Writer output = new BufferedWriter(new FileWriter(h263MemoryOut));
+        for (int i = 0; i < NUM_STRESS_LOOP; i++) {
+            mediaStressPlayback(MediaNames.VIDEO_HIGHRES_H263);
+            getMemoryWriteToLog(output);
+        }
+        output.close();
+    }
+
+    // Test case 2: Capture the memory usage after every 20 h264 playback
+    @LargeTest
+    public void testH264VideoPlaybackMemoryUsage() throws Exception {
+        File h264MemoryOut = new File(H264_VIDEO_PLAYBACK_MEMOUT);
+        Writer output = new BufferedWriter(new FileWriter(h264MemoryOut));
+        for (int i = 0; i < NUM_STRESS_LOOP; i++) {
+            mediaStressPlayback(MediaNames.VIDEO_H264_AMR);
+            getMemoryWriteToLog(output);
+        }
+        output.close();
+    }
+
+    // Test case 3: Capture the memory usage after each 20 WMV playback
+    @LargeTest
+    public void testWMVVideoPlaybackMemoryUsage() throws Exception {
+        File wmvMemoryOut = new File(WMV_VIDEO_PLAYBACK_MEMOUT);
+        Writer output = new BufferedWriter(new FileWriter(wmvMemoryOut));
+        for (int i = 0; i < NUM_STRESS_LOOP; i++) {
+            mediaStressPlayback(MediaNames.VIDEO_WMV);
+            getMemoryWriteToLog(output);
+        }
+        output.close();
+    }
+
+    // Test case 4: Capture the memory usage after every 20 video only recorded
+    @LargeTest
+    public void testH263RecordVideoOnlyMemoryUsage() throws Exception {
+        File videoH263RecordOnlyMemoryOut = new File(H263_VIDEO_ONLY_RECORD_MEMOUT);
+        Writer output = new BufferedWriter(new FileWriter(videoH263RecordOnlyMemoryOut));
+        for (int i = 0; i < NUM_STRESS_LOOP; i++) {
+            stressVideoRecord(20, 352, 288, MediaRecorder.VideoEncoder.H263,
+                    MediaRecorder.OutputFormat.MPEG_4, MediaNames.RECORDED_VIDEO_3GP, true);
+            getMemoryWriteToLog(output);
+        }
+        output.close();
+    }
+
+    // Test case 5: Capture the memory usage after every 20 video only recorded
+    @LargeTest
+    public void testMpeg4RecordVideoOnlyMemoryUsage() throws Exception {
+        File videoMp4RecordOnlyMemoryOut = new File(MP4_VIDEO_ONLY_RECORD_MEMOUT);
+        Writer output = new BufferedWriter(new FileWriter(videoMp4RecordOnlyMemoryOut));
+        for (int i = 0; i < NUM_STRESS_LOOP; i++) {
+            stressVideoRecord(20, 352, 288, MediaRecorder.VideoEncoder.MPEG_4_SP,
+                    MediaRecorder.OutputFormat.MPEG_4, MediaNames.RECORDED_VIDEO_3GP, true);
+            getMemoryWriteToLog(output);
+        }
+        output.close();
+    }
+
+    // Test case 6: Capture the memory usage after every 20 video and audio recorded
+    @LargeTest
+    public void testRecordVidedAudioMemoryUsage() throws Exception {
+        File videoRecordAudioMemoryOut = new File(H263_VIDEO_AUDIO_RECORD_MEMOUT);
+        Writer output = new BufferedWriter(new FileWriter(videoRecordAudioMemoryOut));
+        for (int i = 0; i < NUM_STRESS_LOOP; i++) {
+            stressVideoRecord(20, 352, 288, MediaRecorder.VideoEncoder.H263,
+                    MediaRecorder.OutputFormat.MPEG_4, MediaNames.RECORDED_VIDEO_3GP, false);
+            getMemoryWriteToLog(output);
+        }
+        output.close();
     }
-   
-    
-}
 
+    // Test case 7: Capture the memory usage after every 20 audio only recorded
+    @LargeTest
+    public void testRecordAudioOnlyMemoryUsage() throws Exception {
+        File audioOnlyMemoryOut = new File(AUDIO_ONLY_RECORD_MEMOUT);
+        Writer output = new BufferedWriter(new FileWriter(audioOnlyMemoryOut));
+        for (int i = 0; i < NUM_STRESS_LOOP; i++) {
+            stressAudioRecord(MediaNames.RECORDER_OUTPUT);
+            getMemoryWriteToLog(output);
+        }
+        output.close();
+    }
+}