media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/stress/MediaRecorderStressTest.java

   1 /*
   2  * Copyright (C) 2009 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.mediaframeworktest.stress;
  18
  19
  20 import com.android.mediaframeworktest.MediaFrameworkTest;
  21
  22 import java.io.BufferedWriter;
  23 import java.io.File;
  24 import java.io.FileWriter;
  25 import java.io.Writer;
  26
  27 import android.hardware.Camera;
  28 import android.media.MediaPlayer;
  29 import android.media.MediaRecorder;
  30 import android.os.Looper;
  31 import android.test.ActivityInstrumentationTestCase2;
  32 import android.test.suitebuilder.annotation.LargeTest;
  33 import android.util.Log;
  34 import android.view.SurfaceHolder;
  35
  36 /**
  37  * Junit / Instrumentation test case for the media player api
  38
  39  */
  40 public class MediaRecorderStressTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> {
  41
  42
  43     private String TAG = "MediaRecorderStressTest";
  44     private MediaRecorder mRecorder;
  45     private Camera mCamera;
  46
  47     private static final int NUMBER_OF_CAMERA_STRESS_LOOPS = 100;
  48     private static final int NUMBER_OF_RECORDER_STRESS_LOOPS = 100;
  49     private static final int NUMBER_OF_RECORDERANDPLAY_STRESS_LOOPS = 50;
  50     private static final int NUMBER_OF_SWTICHING_LOOPS_BW_CAMERA_AND_RECORDER = 200;
  51     private static final long WAIT_TIME_CAMERA_TEST = 3000;  // 3 second
  52     private static final long WAIT_TIME_RECORDER_TEST = 6000;  // 6 second
  53     private static final long WAIT_TIME_RECORD = 10000;  // 10 seconds
  54     private static final long WAIT_TIME_PLAYBACK = 6000;  // 6 second
  55     private static final String OUTPUT_FILE = "/sdcard/temp";
  56     private static final String OUTPUT_FILE_EXT = ".3gp";
  57     private static final String MEDIA_STRESS_OUTPUT =
  58         "/sdcard/mediaStressOutput.txt";
  59     private Looper mCameraLooper = null;
  60     private Looper mRecorderLooper = null;
  61     private final Object lock = new Object();
  62     private final Object recorderlock = new Object();
  63     private static int WAIT_FOR_COMMAND_TO_COMPLETE = 10000;  // Milliseconds.
  64     private final CameraErrorCallback mCameraErrorCallback = new CameraErrorCallback();
  65     private final RecorderErrorCallback mRecorderErrorCallback = new RecorderErrorCallback();
  66
  67     public MediaRecorderStressTest() {
  68         super("com.android.mediaframeworktest", MediaFrameworkTest.class);
  69     }
  70
  71     protected void setUp() throws Exception {
  72         getActivity();
  73         super.setUp();
  74     }
  75
  76     private final class CameraErrorCallback implements android.hardware.Camera.ErrorCallback {
  77         public void onError(int error, android.hardware.Camera camera) {
  78             if (error == android.hardware.Camera.CAMERA_ERROR_SERVER_DIED) {
  79                 assertTrue("Camera test mediaserver died", false);
  80             }
  81         }
  82     }
  83
  84     private final class RecorderErrorCallback implements MediaRecorder.OnErrorListener {
  85         public void onError(MediaRecorder mr, int what, int extra) {
  86             // fail the test case no matter what error come up
  87             assertTrue("mediaRecorder error", false);
  88         }
  89     }
  90
  91     private void initializeCameraMessageLooper() {
  92         Log.v(TAG, "start looper");
  93         new Thread() {
  94             @Override
  95             public void run() {
  96                 // Set up a looper to be used by camera.
  97                 Looper.prepare();
  98                 Log.v(TAG, "start loopRun");
  99                 mCameraLooper = Looper.myLooper();
 100                 mCamera = Camera.open();
 101                 synchronized (lock) {
 102                     lock.notify();
 103                 }
 104                 Looper.loop();
 105                 Log.v(TAG, "initializeMessageLooper: quit.");
 106             }
 107         }.start();
 108     }
 109
 110     private void initializeRecorderMessageLooper() {
 111         Log.v(TAG, "start looper");
 112         new Thread() {
 113             @Override
 114             public void run() {
 115                 Looper.prepare();
 116                 Log.v(TAG, "start loopRun");
 117                 mRecorderLooper = Looper.myLooper();
 118                 mRecorder = new MediaRecorder();
 119                 synchronized (recorderlock) {
 120                     recorderlock.notify();
 121                 }
 122                 Looper.loop();  // Blocks forever until Looper.quit() is called.
 123                 Log.v(TAG, "initializeMessageLooper: quit.");
 124             }
 125         }.start();
 126     }
 127
 128     /*
 129      * Terminates the message looper thread.
 130      */
 131     private void terminateCameraMessageLooper() {
 132         mCameraLooper.quit();
 133         try {
 134             Thread.sleep(1000);
 135         } catch (Exception e){
 136             Log.v(TAG, e.toString());
 137         }
 138         mCamera.release();
 139     }
 140
 141     /*
 142      * Terminates the message looper thread.
 143      */
 144     private void terminateRecorderMessageLooper() {
 145         mRecorderLooper.quit();
 146         try {
 147             Thread.sleep(1000);
 148         } catch (Exception e){
 149             Log.v(TAG, e.toString());
 150         }
 151         mRecorder.release();
 152     }
 153
 154     //Test case for stressing the camera preview.
 155     @LargeTest
 156     public void testStressCamera() throws Exception {
 157         SurfaceHolder mSurfaceHolder;
 158         mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
 159         File stressOutFile = new File(MEDIA_STRESS_OUTPUT);
 160         Writer output = new BufferedWriter(new FileWriter(stressOutFile, true));
 161         output.write("Camera start preview stress:\n");
 162         output.write("Total number of loops:" +
 163                 NUMBER_OF_CAMERA_STRESS_LOOPS + "\n");
 164         try {
 165             Log.v(TAG, "Start preview");
 166             output.write("No of loop: ");
 167
 168             for (int i = 0; i< NUMBER_OF_CAMERA_STRESS_LOOPS; i++){
 169                 synchronized (lock) {
 170                     initializeCameraMessageLooper();
 171                     try {
 172                         lock.wait(WAIT_FOR_COMMAND_TO_COMPLETE);
 173                     } catch(Exception e) {
 174                         Log.v(TAG, "wait was interrupted.");
 175                     }
 176                 }
 177                 mCamera.setErrorCallback(mCameraErrorCallback);
 178                 mCamera.setPreviewDisplay(mSurfaceHolder);
 179                 mCamera.startPreview();
 180                 Thread.sleep(WAIT_TIME_CAMERA_TEST);
 181                 mCamera.stopPreview();
 182                 terminateCameraMessageLooper();
 183                 output.write(" ," + i);
 184             }
 185         } catch (Exception e) {
 186             assertTrue("CameraStressTest", false);
 187             Log.v(TAG, e.toString());
 188         }
 189         output.write("\n\n");
 190         output.close();
 191     }
 192
 193     //Test case for stressing the camera preview.
 194     @LargeTest
 195     public void testStressRecorder() throws Exception {
 196         String filename;
 197         SurfaceHolder mSurfaceHolder;
 198         mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
 199         File stressOutFile = new File(MEDIA_STRESS_OUTPUT);
 200         Writer output = new BufferedWriter(new FileWriter(stressOutFile, true));
 201         output.write("H263 video record- reset after prepare Stress test\n");
 202         output.write("Total number of loops:" +
 203                 NUMBER_OF_RECORDER_STRESS_LOOPS + "\n");
 204         try {
 205             output.write("No of loop: ");
 206             Log.v(TAG, "Start preview");
 207             for (int i = 0; i < NUMBER_OF_RECORDER_STRESS_LOOPS; i++){
 208                 synchronized (recorderlock) {
 209                     initializeRecorderMessageLooper();
 210                     try {
 211                         recorderlock.wait(WAIT_FOR_COMMAND_TO_COMPLETE);
 212                     } catch(Exception e) {
 213                         Log.v(TAG, "wait was interrupted.");
 214                     }
 215                 }
 216                 Log.v(TAG, "counter = " + i);
 217                 filename = OUTPUT_FILE + i + OUTPUT_FILE_EXT;
 218                 Log.v(TAG, filename);
 219                 mRecorder.setOnErrorListener(mRecorderErrorCallback);
 220                 mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
 221                 mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
 222                 mRecorder.setOutputFile(filename);
 223                 mRecorder.setVideoFrameRate(20);
 224                 mRecorder.setVideoSize(176,144);
 225                 Log.v(TAG, "setEncoder");
 226                 mRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H263);
 227                 mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
 228                 Log.v(TAG, "setPreview");
 229                 mRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
 230                 Log.v(TAG, "prepare");
 231                 mRecorder.prepare();
 232                 Log.v(TAG, "before release");
 233                 Thread.sleep(WAIT_TIME_RECORDER_TEST);
 234                 mRecorder.reset();
 235                 terminateRecorderMessageLooper();
 236                 output.write(", " + i);
 237             }
 238         } catch (Exception e) {
 239             assertTrue("Recorder Stress test", false);
 240             Log.v(TAG, e.toString());
 241         }
 242         output.write("\n\n");
 243         output.close();
 244     }
 245
 246     //Stress test case for switching camera and video recorder preview.
 247     @LargeTest
 248     public void testStressCameraSwitchRecorder() throws Exception {
 249         String filename;
 250         SurfaceHolder mSurfaceHolder;
 251         mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
 252         File stressOutFile = new File(MEDIA_STRESS_OUTPUT);
 253         Writer output = new BufferedWriter(new FileWriter(stressOutFile, true));
 254         output.write("Camera and video recorder preview switching\n");
 255         output.write("Total number of loops:"
 256                 + NUMBER_OF_SWTICHING_LOOPS_BW_CAMERA_AND_RECORDER + "\n");
 257         try {
 258             Log.v(TAG, "Start preview");
 259             output.write("No of loop: ");
 260             for (int i = 0; i < NUMBER_OF_SWTICHING_LOOPS_BW_CAMERA_AND_RECORDER; i++){
 261                 synchronized (lock) {
 262                     initializeCameraMessageLooper();
 263                     try {
 264                         lock.wait(WAIT_FOR_COMMAND_TO_COMPLETE);
 265                     } catch(Exception e) {
 266                         Log.v(TAG, "wait was interrupted.");
 267                     }
 268                 }
 269                 mCamera.setErrorCallback(mCameraErrorCallback);
 270                 mCamera.setPreviewDisplay(mSurfaceHolder);
 271                 mCamera.startPreview();
 272                 Thread.sleep(WAIT_TIME_CAMERA_TEST);
 273                 mCamera.stopPreview();
 274                 terminateCameraMessageLooper();
 275                 mCamera = null;
 276                 Log.v(TAG, "release camera");
 277                 filename = OUTPUT_FILE + i + OUTPUT_FILE_EXT;
 278                 Log.v(TAG, filename);
 279                 synchronized (recorderlock) {
 280                     initializeRecorderMessageLooper();
 281                     try {
 282                         recorderlock.wait(WAIT_FOR_COMMAND_TO_COMPLETE);
 283                     } catch(Exception e) {
 284                         Log.v(TAG, "wait was interrupted.");
 285                     }
 286                 }
 287                 mRecorder.setOnErrorListener(mRecorderErrorCallback);
 288                 mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
 289                 mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
 290                 mRecorder.setOutputFile(filename);
 291                 mRecorder.setVideoFrameRate(20);
 292                 mRecorder.setVideoSize(176,144);
 293                 Log.v(TAG, "Media recorder setEncoder");
 294                 mRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H263);
 295                 Log.v(TAG, "mediaRecorder setPreview");
 296                 mRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
 297                 Log.v(TAG, "prepare");
 298                 mRecorder.prepare();
 299                 Log.v(TAG, "before release");
 300                 Thread.sleep(WAIT_TIME_CAMERA_TEST);
 301                 terminateRecorderMessageLooper();
 302                 Log.v(TAG, "release video recorder");
 303                 output.write(", " + i);
 304             }
 305         } catch (Exception e) {
 306             assertTrue("Camer and recorder switch mode", false);
 307                 Log.v(TAG, e.toString());
 308         }
 309         output.write("\n\n");
 310         output.close();
 311     }
 312
 313     //Stress test case for record a video and play right away.
 314     @LargeTest
 315     public void testStressRecordVideoAndPlayback() throws Exception {
 316         String filename;
 317         SurfaceHolder mSurfaceHolder;
 318         mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
 319         File stressOutFile = new File(MEDIA_STRESS_OUTPUT);
 320         Writer output = new BufferedWriter(new FileWriter(stressOutFile, true));
 321         output.write("Video record and play back stress test:\n");
 322         output.write("Total number of loops:"
 323                 + NUMBER_OF_RECORDERANDPLAY_STRESS_LOOPS + "\n");
 324         try {
 325             output.write("No of loop: ");
 326             for (int i = 0; i < NUMBER_OF_RECORDERANDPLAY_STRESS_LOOPS; i++){
 327                 filename = OUTPUT_FILE + i + OUTPUT_FILE_EXT;
 328                 Log.v(TAG, filename);
 329                 synchronized (recorderlock) {
 330                     initializeRecorderMessageLooper();
 331                     try {
 332                         recorderlock.wait(WAIT_FOR_COMMAND_TO_COMPLETE);
 333                     } catch(Exception e) {
 334                         Log.v(TAG, "wait was interrupted.");
 335                     }
 336                 }
 337                 mRecorder.setOnErrorListener(mRecorderErrorCallback);
 338                 mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
 339                 mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
 340                 mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
 341                 mRecorder.setOutputFile(filename);
 342                 mRecorder.setVideoFrameRate(20);
 343                 mRecorder.setVideoSize(352,288);
 344                 mRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H263);
 345                 mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
 346                 Log.v(TAG, "mediaRecorder setPreview");
 347                 mRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
 348                 mRecorder.prepare();
 349                 mRecorder.start();
 350                 Thread.sleep(WAIT_TIME_RECORD);
 351                 Log.v(TAG, "Before stop");
 352                 mRecorder.stop();
 353                 terminateRecorderMessageLooper();
 354                 //start the playback
 355                 MediaPlayer mp = new MediaPlayer();
 356                 mp.setDataSource(filename);
 357                 mp.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder());
 358                 mp.prepare();
 359                 mp.start();
 360                 Thread.sleep(WAIT_TIME_PLAYBACK);
 361                 mp.release();
 362                 output.write(", " + i);
 363             }
 364         } catch (Exception e) {
 365             assertTrue("record and playback", false);
 366                 Log.v(TAG, e.toString());
 367         }
 368         output.write("\n\n");
 369         output.close();
 370     }
 371 }