MediaRecorderStressTest.java revision 55a6ac8c542ae831b0d041360cab4bbc7212ade5
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 17package com.android.mediaframeworktest.stress; 18 19 20import com.android.mediaframeworktest.MediaFrameworkTest; 21 22import java.io.BufferedWriter; 23import java.io.File; 24import java.io.FileWriter; 25import java.io.Writer; 26 27import android.hardware.Camera; 28import android.media.MediaPlayer; 29import android.media.MediaRecorder; 30import android.os.Looper; 31import android.test.ActivityInstrumentationTestCase2; 32import android.test.suitebuilder.annotation.LargeTest; 33import android.util.Log; 34import android.view.SurfaceHolder; 35 36/** 37 * Junit / Instrumentation test case for the media player api 38 39 */ 40public 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} 372