tests/tests/media/src/android/media/cts/MediaRandomTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2012 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package android.media.cts;


 import com.android.cts.media.R;

 import android.media.MediaRecorder;
 import android.media.MediaPlayer;
 import android.view.SurfaceHolder;
 import android.test.ActivityInstrumentationTestCase2;
 import android.os.Environment;
 import android.content.res.AssetFileDescriptor;
 import android.content.res.Resources;
 import android.util.Log;

 import java.util.Random;

 /**
  * Tests for the MediaPlayer.java and MediaRecorder.java APIs
  *
  * These testcases make randomized calls to the public APIs available, and
  * the focus is on whether the randomized calls can lead to crash in
  * mediaserver process and/or ANRs.
  *
  * The files in res/raw used by testLocalVideo* are (c) copyright 2008,
  * Blender Foundation / www.bigbuckbunny.org, and are licensed under the Creative Commons
  * Attribution 3.0 License at http://creativecommons.org/licenses/by/3.0/us/.
  */
 public class MediaRandomTest extends ActivityInstrumentationTestCase2<MediaStubActivity> {
     private static final String TAG = "MediaRandomTest";

     private static final String OUTPUT_FILE =
                 Environment.getExternalStorageDirectory().toString() + "/record.3gp";

     private static final int NUMBER_OF_RECORDER_RANDOM_ACTIONS = 100000;
     private static final int NUMBER_OF_PLAYER_RANDOM_ACTIONS   = 100000;

     private MediaRecorder mRecorder;
     private MediaPlayer mPlayer;
     private SurfaceHolder mSurfaceHolder;
     private Resources mResources;

     // Modified across multiple threads
     private volatile boolean mMediaServerDied;
     private volatile int mAction;
     private volatile int mParam;

     @Override
     protected void setUp() throws Exception {
         super.setUp();
         getInstrumentation().waitForIdleSync();
         mMediaServerDied = false;
         mSurfaceHolder = getActivity().getSurfaceHolder();
         mResources = getInstrumentation().getTargetContext().getResources();
         try {
             // Running this on UI thread make sure that
             // onError callback can be received.
             runTestOnUiThread(new Runnable() {
                 public void run() {
                     mRecorder = new MediaRecorder();
                     mPlayer = new MediaPlayer();
                 }
             });
         } catch (Throwable e) {
             e.printStackTrace();
             fail();
         }
     }

     @Override
     protected void tearDown() throws Exception {
         if (mRecorder != null) {
             mRecorder.release();
             mRecorder = null;
         }
         if (mPlayer != null) {
             mPlayer.release();
             mPlayer = null;
         }
         super.tearDown();
     }

     /**
      * This is a watchdog used to stop the process if it hasn't been pinged
      * for more than specified milli-seconds. It is used like:
      *
      * Watchdog w = new Watchdog(10000);  // 10 seconds.
      * w.start();       // start the watchdog.
      * ...
      * w.ping();
      * ...
      * w.ping();
      * ...
      * w.end();        // ask the watchdog to stop.
      * w.join();        // join the thread.
      */
     class Watchdog extends Thread {
         private final long mTimeoutMs;
         private boolean mWatchdogStop;
         private boolean mWatchdogPinged;

         public Watchdog(long timeoutMs) {
             mTimeoutMs = timeoutMs;
             mWatchdogStop = false;
             mWatchdogPinged = false;
         }

         public synchronized void run() {
             while (true) {
                 // avoid early termination by "spurious" waitup.
                 final long startTimeMs = System.currentTimeMillis();
                 long remainingWaitTimeMs = mTimeoutMs;
                 do {
                     try {
                         wait(remainingWaitTimeMs);
                     } catch (InterruptedException ex) {
                         // ignore.
                     }
                     remainingWaitTimeMs = mTimeoutMs - (System.currentTimeMillis() - startTimeMs);
                 } while (remainingWaitTimeMs > 0);

                 if (mWatchdogStop) {
                     break;
                 }

                 if (!mWatchdogPinged) {
                     fail("Action " + mAction + " Param " + mParam
                             + " waited over " + (mTimeoutMs - remainingWaitTimeMs) + " ms");
                     return;
                 }
                 mWatchdogPinged = false;
             }
         }

         public synchronized void ping() {
             mWatchdogPinged = true;
             this.notify();
         }

         public synchronized void end() {
             mWatchdogStop = true;
             this.notify();
         }
     }

     public MediaRandomTest() {
         super("com.android.cts.media", MediaStubActivity.class);
     }

     private void loadSource(int resid) throws Exception {
         AssetFileDescriptor afd = mResources.openRawResourceFd(resid);
         try {
             mPlayer.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(),
                     afd.getLength());
         } finally {
             afd.close();
         }
     }

     public void testPlayerRandomAction() throws Exception {
         Watchdog watchdog = new Watchdog(5000);
         try {
             mPlayer.setOnErrorListener(new MediaPlayer.OnErrorListener() {
                 @Override
                 public boolean onError(MediaPlayer mp, int what, int extra) {
                     if (mPlayer == mp &&
                         what == MediaPlayer.MEDIA_ERROR_SERVER_DIED) {
                         Log.e(TAG, "mediaserver process died");
                         mMediaServerDied = true;
                     }
                     return true;
                 }
             });
             loadSource(R.raw.video_480x360_mp4_h264_500kbps_30fps_aac_stereo_128kbps_44100hz);
             mPlayer.setDisplay(mSurfaceHolder);
             mPlayer.prepare();
             mPlayer.start();

             long seed = System.currentTimeMillis();
             Log.v(TAG, "seed = " + seed);
             Random r = new Random(seed);

             watchdog.start();
             for (int i = 0; i < NUMBER_OF_PLAYER_RANDOM_ACTIONS; i++){
                 watchdog.ping();
                 assertTrue(!mMediaServerDied);

                 mAction = (int)(r.nextInt() % 12);
                 mParam = (int)(r.nextInt() % 1000000);
                 try {
                     switch (mAction) {
                     case 0:
                         mPlayer.getCurrentPosition();
                         break;
                     case 1:
                         mPlayer.getDuration();
                         break;
                     case 2:
                         mPlayer.getVideoHeight();
                         break;
                     case 3:
                         mPlayer.getVideoWidth();
                        break;
                     case 4:
                         mPlayer.isPlaying();
                         break;
                     case 5:
                         mPlayer.pause();
                         break;
                     case 6:
                         // Don't add mPlayer.prepare() call here for two reasons:
                         // 1. calling prepare() is a bad idea since it is a blocking call, and
                         // 2. when prepare() is in progress, mediaserver died message will not be sent to apps
                         mPlayer.prepareAsync();
                         break;
                     case 7:
                         mPlayer.seekTo((int)(mParam));
                         break;
                     case 8:
                         mPlayer.setLooping(mParam % 2 == 0);
                         break;
                     case 9:
                         mPlayer.setVolume((mParam % 1000) / 500.0f,
                                      (mParam / 1000) / 500.0f);
                         break;
                     case 10:
                         mPlayer.start();
                         break;
                     case 11:
                         Thread.sleep(mParam % 20);
                         break;
                     }
                 } catch (Exception e) {
                 }
             }
             mPlayer.stop();
         } catch (Exception e) {
             Log.v(TAG, e.toString());
         } finally {
             watchdog.end();
             watchdog.join();
         }
     }

     public void testRecorderRandomAction() throws Exception {
         Watchdog watchdog = new Watchdog(5000);
         try {
             long seed = System.currentTimeMillis();
             Log.v(TAG, "seed = " + seed);
             Random r = new Random(seed);

             mMediaServerDied = false;
             mRecorder.setOnErrorListener(new MediaRecorder.OnErrorListener() {
                 @Override
                 public void onError(MediaRecorder recorder, int what, int extra) {
                     if (mRecorder == recorder &&
                         what == MediaRecorder.MEDIA_ERROR_SERVER_DIED) {
                         Log.e(TAG, "mediaserver process died");
                         mMediaServerDied = true;
                     }
                 }
             });

             final int[] width  = {176, 352, 320, 640, 1280, 1920};
             final int[] height = {144, 288, 240, 480,  720, 1080};

             watchdog.start();
             for (int i = 0; i < NUMBER_OF_RECORDER_RANDOM_ACTIONS; i++) {
                 watchdog.ping();
                 assertTrue(!mMediaServerDied);

                 mAction = (int)(r.nextInt(14));
                 mParam = (int)(r.nextInt(1000000));
                 try {
                     switch (mAction) {
                     case 0:
                         mRecorder.setAudioSource(mParam % 3);
                         break;
                     case 1:
                         // XXX:
                         // Fix gralloc source and change
                         // mRecorder.setVideoSource(mParam % 3);
                         mRecorder.setVideoSource(mParam % 2);
                         break;
                     case 2:
                         mRecorder.setOutputFormat(mParam % 5);
                         break;
                     case 3:
                         mRecorder.setAudioEncoder(mParam % 3);
                         break;
                     case 4:
                         mRecorder.setVideoEncoder(mParam % 5);
                         break;
                     case 5:
                         mRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
                         break;
                     case 6:
                         int index = mParam % width.length;
                         mRecorder.setVideoSize(width[index], height[index]);
                         break;
                     case 7:
                         mRecorder.setVideoFrameRate(mParam % 40 - 5);
                         break;
                     case 8:
                         mRecorder.setOutputFile(OUTPUT_FILE);
                         break;
                     case 9:
                         mRecorder.prepare();
                         break;
                     case 10:
                         mRecorder.start();
                         break;
                     case 11:
                         Thread.sleep(mParam % 20);
                         break;
                     case 12:
                         mRecorder.stop();
                         break;
                     case 13:
                         mRecorder.reset();
                         break;
                     default:
                         break;
                     }
                 } catch (Exception e) {
                 }
             }
         } catch (Exception e) {
             Log.v(TAG, e.toString());
         } finally {
             watchdog.end();
             watchdog.join();
         }
     }
 }
	/*
	* Copyright (C) 2012 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package android.media.cts;


	import com.android.cts.media.R;

	import android.media.MediaRecorder;
	import android.media.MediaPlayer;
	import android.view.SurfaceHolder;
	import android.test.ActivityInstrumentationTestCase2;
	import android.os.Environment;
	import android.content.res.AssetFileDescriptor;
	import android.content.res.Resources;
	import android.util.Log;

	import java.util.Random;

	/**
	* Tests for the MediaPlayer.java and MediaRecorder.java APIs
	*
	* These testcases make randomized calls to the public APIs available, and
	* the focus is on whether the randomized calls can lead to crash in
	* mediaserver process and/or ANRs.
	*
	* The files in res/raw used by testLocalVideo* are (c) copyright 2008,
	* Blender Foundation / www.bigbuckbunny.org, and are licensed under the Creative Commons
	* Attribution 3.0 License at http://creativecommons.org/licenses/by/3.0/us/.
	*/
	public class MediaRandomTest extends ActivityInstrumentationTestCase2<MediaStubActivity> {
	private static final String TAG = "MediaRandomTest";

	private static final String OUTPUT_FILE =
	Environment.getExternalStorageDirectory().toString() + "/record.3gp";

	private static final int NUMBER_OF_RECORDER_RANDOM_ACTIONS = 100000;
	private static final int NUMBER_OF_PLAYER_RANDOM_ACTIONS = 100000;

	private MediaRecorder mRecorder;
	private MediaPlayer mPlayer;
	private SurfaceHolder mSurfaceHolder;
	private Resources mResources;

	// Modified across multiple threads
	private volatile boolean mMediaServerDied;
	private volatile int mAction;
	private volatile int mParam;

	@Override
	protected void setUp() throws Exception {
	super.setUp();
	getInstrumentation().waitForIdleSync();
	mMediaServerDied = false;
	mSurfaceHolder = getActivity().getSurfaceHolder();
	mResources = getInstrumentation().getTargetContext().getResources();
	try {
	// Running this on UI thread make sure that
	// onError callback can be received.
	runTestOnUiThread(new Runnable() {
	public void run() {
	mRecorder = new MediaRecorder();
	mPlayer = new MediaPlayer();
	}
	});
	} catch (Throwable e) {
	e.printStackTrace();
	fail();
	}
	}

	@Override
	protected void tearDown() throws Exception {
	if (mRecorder != null) {
	mRecorder.release();
	mRecorder = null;
	}
	if (mPlayer != null) {
	mPlayer.release();
	mPlayer = null;
	}
	super.tearDown();
	}

	/**
	* This is a watchdog used to stop the process if it hasn't been pinged
	* for more than specified milli-seconds. It is used like:
	*
	* Watchdog w = new Watchdog(10000); // 10 seconds.
	* w.start(); // start the watchdog.
	* ...
	* w.ping();
	* ...
	* w.ping();
	* ...
	* w.end(); // ask the watchdog to stop.
	* w.join(); // join the thread.
	*/
	class Watchdog extends Thread {
	private final long mTimeoutMs;
	private boolean mWatchdogStop;
	private boolean mWatchdogPinged;

	public Watchdog(long timeoutMs) {
	mTimeoutMs = timeoutMs;
	mWatchdogStop = false;
	mWatchdogPinged = false;
	}

	public synchronized void run() {
	while (true) {
	// avoid early termination by "spurious" waitup.
	final long startTimeMs = System.currentTimeMillis();
	long remainingWaitTimeMs = mTimeoutMs;
	do {
	try {
	wait(remainingWaitTimeMs);
	} catch (InterruptedException ex) {
	// ignore.
	}
	remainingWaitTimeMs = mTimeoutMs - (System.currentTimeMillis() - startTimeMs);
	} while (remainingWaitTimeMs > 0);

	if (mWatchdogStop) {
	break;
	}

	if (!mWatchdogPinged) {
	fail("Action " + mAction + " Param " + mParam
	+ " waited over " + (mTimeoutMs - remainingWaitTimeMs) + " ms");
	return;
	}
	mWatchdogPinged = false;
	}
	}

	public synchronized void ping() {
	mWatchdogPinged = true;
	this.notify();
	}

	public synchronized void end() {
	mWatchdogStop = true;
	this.notify();
	}
	}

	public MediaRandomTest() {
	super("com.android.cts.media", MediaStubActivity.class);
	}

	private void loadSource(int resid) throws Exception {
	AssetFileDescriptor afd = mResources.openRawResourceFd(resid);
	try {
	mPlayer.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(),
	afd.getLength());
	} finally {
	afd.close();
	}
	}

	public void testPlayerRandomAction() throws Exception {
	Watchdog watchdog = new Watchdog(5000);
	try {
	mPlayer.setOnErrorListener(new MediaPlayer.OnErrorListener() {
	@Override
	public boolean onError(MediaPlayer mp, int what, int extra) {
	if (mPlayer == mp &&
	what == MediaPlayer.MEDIA_ERROR_SERVER_DIED) {
	Log.e(TAG, "mediaserver process died");
	mMediaServerDied = true;
	}
	return true;
	}
	});
	loadSource(R.raw.video_480x360_mp4_h264_500kbps_30fps_aac_stereo_128kbps_44100hz);
	mPlayer.setDisplay(mSurfaceHolder);
	mPlayer.prepare();
	mPlayer.start();

	long seed = System.currentTimeMillis();
	Log.v(TAG, "seed = " + seed);
	Random r = new Random(seed);

	watchdog.start();
	for (int i = 0; i < NUMBER_OF_PLAYER_RANDOM_ACTIONS; i++){
	watchdog.ping();
	assertTrue(!mMediaServerDied);

	mAction = (int)(r.nextInt() % 12);
	mParam = (int)(r.nextInt() % 1000000);
	try {
	switch (mAction) {
	case 0:
	mPlayer.getCurrentPosition();
	break;
	case 1:
	mPlayer.getDuration();
	break;
	case 2:
	mPlayer.getVideoHeight();
	break;
	case 3:
	mPlayer.getVideoWidth();
	break;
	case 4:
	mPlayer.isPlaying();
	break;
	case 5:
	mPlayer.pause();
	break;
	case 6:
	// Don't add mPlayer.prepare() call here for two reasons:
	// 1. calling prepare() is a bad idea since it is a blocking call, and
	// 2. when prepare() is in progress, mediaserver died message will not be sent to apps
	mPlayer.prepareAsync();
	break;
	case 7:
	mPlayer.seekTo((int)(mParam));
	break;
	case 8:
	mPlayer.setLooping(mParam % 2 == 0);
	break;
	case 9:
	mPlayer.setVolume((mParam % 1000) / 500.0f,
	(mParam / 1000) / 500.0f);
	break;
	case 10:
	mPlayer.start();
	break;
	case 11:
	Thread.sleep(mParam % 20);
	break;
	}
	} catch (Exception e) {
	}
	}
	mPlayer.stop();
	} catch (Exception e) {
	Log.v(TAG, e.toString());
	} finally {
	watchdog.end();
	watchdog.join();
	}
	}

	public void testRecorderRandomAction() throws Exception {
	Watchdog watchdog = new Watchdog(5000);
	try {
	long seed = System.currentTimeMillis();
	Log.v(TAG, "seed = " + seed);
	Random r = new Random(seed);

	mMediaServerDied = false;
	mRecorder.setOnErrorListener(new MediaRecorder.OnErrorListener() {
	@Override
	public void onError(MediaRecorder recorder, int what, int extra) {
	if (mRecorder == recorder &&
	what == MediaRecorder.MEDIA_ERROR_SERVER_DIED) {
	Log.e(TAG, "mediaserver process died");
	mMediaServerDied = true;
	}
	}
	});

	final int[] width = {176, 352, 320, 640, 1280, 1920};
	final int[] height = {144, 288, 240, 480, 720, 1080};

	watchdog.start();
	for (int i = 0; i < NUMBER_OF_RECORDER_RANDOM_ACTIONS; i++) {
	watchdog.ping();
	assertTrue(!mMediaServerDied);

	mAction = (int)(r.nextInt(14));
	mParam = (int)(r.nextInt(1000000));
	try {
	switch (mAction) {
	case 0:
	mRecorder.setAudioSource(mParam % 3);
	break;
	case 1:
	// XXX:
	// Fix gralloc source and change
	// mRecorder.setVideoSource(mParam % 3);
	mRecorder.setVideoSource(mParam % 2);
	break;
	case 2:
	mRecorder.setOutputFormat(mParam % 5);
	break;
	case 3:
	mRecorder.setAudioEncoder(mParam % 3);
	break;
	case 4:
	mRecorder.setVideoEncoder(mParam % 5);
	break;
	case 5:
	mRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
	break;
	case 6:
	int index = mParam % width.length;
	mRecorder.setVideoSize(width[index], height[index]);
	break;
	case 7:
	mRecorder.setVideoFrameRate(mParam % 40 - 5);
	break;
	case 8:
	mRecorder.setOutputFile(OUTPUT_FILE);
	break;
	case 9:
	mRecorder.prepare();
	break;
	case 10:
	mRecorder.start();
	break;
	case 11:
	Thread.sleep(mParam % 20);
	break;
	case 12:
	mRecorder.stop();
	break;
	case 13:
	mRecorder.reset();
	break;
	default:
	break;
	}
	} catch (Exception e) {
	}
	}
	} catch (Exception e) {
	Log.v(TAG, e.toString());
	} finally {
	watchdog.end();
	watchdog.join();
	}
	}
	}