media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/CodecTest.java - platform/frameworks/base - Gitiles

 /*
  * 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
  *
  * 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 com.android.mediaframeworktest.functional;


 //import android.content.Resources;
 import com.android.mediaframeworktest.MediaFrameworkTest;
 import com.android.mediaframeworktest.MediaNames;

 import android.content.res.AssetFileDescriptor;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.media.MediaMetadataRetriever;
 import android.media.MediaPlayer;
 import android.media.MediaRecorder;
 import android.os.SystemClock;
 import android.util.Log;

 import java.io.IOException;
 import java.io.InputStream;
 /**
  * Junit / Instrumentation test case for the media player api

  */
 public class CodecTest {
     private static String TAG = "MediaPlayerApiTest";

     public static String printCpuInfo(){
         String cm = "dumpsys cpuinfo";
         String cpuinfo =null;
         int ch;
         try{
             Process  p = Runtime.getRuntime().exec(cm);
             InputStream in = p.getInputStream();
             StringBuffer sb = new StringBuffer(512);
             while ( ( ch = in.read() ) != -1 ){
                 sb.append((char) ch);
             }
             cpuinfo = sb.toString();
         }catch (IOException e){
             Log.v(TAG, e.toString());
         }
         return cpuinfo;
     }


     public static int getDuration(String filePath) {
         Log.v(TAG, "getDuration - " + filePath);
         MediaPlayer mp = new MediaPlayer();
         try{
             mp.setDataSource(filePath);
             mp.prepare();
         }catch (Exception e){}
         int duration = mp.getDuration();
         Log.v(TAG, "Duration " + duration);
         mp.release();
         Log.v(TAG, "release");
         return duration;
     }

     public static boolean getCurrentPosition(String filePath){
         Log.v(TAG, "GetCurrentPosition - " + filePath);
         int currentPosition = 0;
         long t1=0;
         long t2 =0;
         MediaPlayer mp = new MediaPlayer();
         try{
             mp.setDataSource(filePath);
             Log.v(TAG, "start playback");
             mp.prepare();
             mp.start();
             t1=SystemClock.uptimeMillis();
             Thread.sleep(10000);
             mp.pause();
             Thread.sleep(MediaNames.PAUSE_WAIT_TIME);
             t2=SystemClock.uptimeMillis();
         }catch (Exception e){
             Log.v(TAG, e.toString());
         }
         currentPosition = mp.getCurrentPosition();
         mp.stop();
         mp.release();
         Log.v(TAG, "mp currentPositon = " + currentPosition + " play duration = " + (t2-t1));
         //The currentposition should be within 10% of the sleep time
         //For the very short mp3, it should return the length instead of 10 seconds
         if (filePath.equals(MediaNames.SHORTMP3)){
             if (currentPosition < 1000 )
                 return true;
         }
         if ((currentPosition < ((t2-t1) *1.2)) && (currentPosition > 0))
             return true;
         else
             return false;
     }

     public static boolean seekTo(String filePath){
         Log.v(TAG, "seekTo " + filePath);
         int currentPosition = 0;
         MediaPlayer mp = new MediaPlayer();
         try{
             mp.setDataSource(filePath);
             mp.prepare();
             mp.start();
             mp.seekTo(MediaNames.SEEK_TIME);
             Thread.sleep(MediaNames.WAIT_TIME);
             currentPosition = mp.getCurrentPosition();
         }catch (Exception e){
             Log.v(TAG, e.getMessage());
         }
         mp.stop();
         mp.release();
         Log.v(TAG, "CurrentPosition = " + currentPosition);
         //The currentposition should be at least greater than the 80% of seek time
         if ((currentPosition > MediaNames.SEEK_TIME *0.8))
             return true;
         else
             return false;
     }

     public static boolean setLooping(String filePath){
         int currentPosition = 0;
         int duration = 0;
         long t1 =0;
         long t2 =0;
         Log.v (TAG, "SetLooping - " + filePath);
         MediaPlayer mp = new MediaPlayer();
         try{
             mp.setDataSource(filePath);
             mp.prepare();
             duration = mp.getDuration();
             Log.v(TAG, "setLooping duration " + duration);
             mp.setLooping(true);
             mp.start();
             Thread.sleep(5000);
             mp.seekTo(duration - 5000);
             t1=SystemClock.uptimeMillis();
             Thread.sleep(20000);
             t2=SystemClock.uptimeMillis();
             Log.v(TAG, "pause");
             //Bug# 1106852 - IllegalStateException will be thrown if pause is called
             //in here
             //mp.pause();
             currentPosition = mp.getCurrentPosition();
             Log.v(TAG, "looping position " + currentPosition + "duration = " + (t2-t1));
         }catch (Exception e){
             Log.v(TAG, "Exception : " + e.toString());
         }
         mp.stop();
         mp.release();
         //The current position should be within 20% of the sleep time
         //and should be greater than zero.
         if ((currentPosition < ((t2-t1-5000)*1.2)) && currentPosition > 0)
             return true;
         else
             return false;
     }

     public static boolean pause(String filePath) throws Exception {
         Log.v(TAG, "pause - " + filePath);
         boolean misPlaying = true;
         boolean pauseResult = false;
         long t1=0;
         long t2=0;
         MediaPlayer mp = new MediaPlayer();
         mp.setDataSource(filePath);
         mp.prepare();
         int duration = mp.getDuration();
         mp.start();
         t1=SystemClock.uptimeMillis();
         Thread.sleep(5000);
         mp.pause();
         Thread.sleep(MediaNames.PAUSE_WAIT_TIME);
         t2=SystemClock.uptimeMillis();
         misPlaying = mp.isPlaying();
         int curPosition = mp.getCurrentPosition();
         Log.v(TAG, filePath + " pause currentPositon " + curPosition);
         Log.v(TAG, "isPlaying "+ misPlaying + " wait time " + (t2 - t1) );
         String cpuinfo = printCpuInfo();
         Log.v(TAG, cpuinfo);
         if ((curPosition>0) && (curPosition < ((t2-t1) * 1.3)) && (misPlaying == false))
             pauseResult = true;
         mp.stop();
         mp.release();
         return pauseResult;
     }

     public static void prepareStopRelease(String filePath) throws Exception {
         Log.v(TAG, "prepareStopRelease" + filePath);
         MediaPlayer mp = new MediaPlayer();
         mp.setDataSource(filePath);
         mp.prepare();
         mp.stop();
         mp.release();
     }

     public static void preparePauseRelease(String filePath) throws Exception {
         Log.v(TAG, "preparePauseRelease" + filePath);
         MediaPlayer mp = new MediaPlayer();
         mp.setDataSource(filePath);
         mp.prepare();
         mp.pause();
         mp.release();
     }

     public static int videoHeight(String filePath) throws Exception {
         Log.v(TAG, "videoHeight - " + filePath);
         int videoHeight = 0;
         MediaPlayer mp = new MediaPlayer();
         mp.setDataSource(filePath);
         mp.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder());
         mp.prepare();
         videoHeight = mp.getVideoHeight();
         mp.release();
         return videoHeight;
     }

     public static int videoWidth(String filePath) throws Exception {
         Log.v(TAG, "videoWidth - " + filePath);
         int videoWidth = 0;
         MediaPlayer mp = new MediaPlayer();
         mp.setDataSource(filePath);
         mp.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder());
         mp.prepare();
         videoWidth = mp.getVideoWidth();
         mp.release();
         return videoWidth;
     }

     //This also test the streaming video which may take a long
     //time to start the playback.
     public static boolean videoSeekTo(String filePath) throws Exception {
         Log.v(TAG, "videoSeekTo - " + filePath);
         int currentPosition = 0;
         int duration = 0;
         boolean videoResult = false;
         MediaPlayer mp = new MediaPlayer();
         mp.setDataSource(filePath);
         mp.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder());
         mp.prepare();
         mp.start();
         if (filePath.equals(MediaNames.VIDEO_SHORT_3GP)){
             mp.pause();
             Thread.sleep(MediaNames.PAUSE_WAIT_TIME);
             mp.seekTo(0);
             mp.start();
             Thread.sleep(1000);
             currentPosition = mp.getCurrentPosition();
             Log.v(TAG,"short position " + currentPosition);
             if (currentPosition > 100 )
                 return true;
             else
                 return false;
         }
         Thread.sleep(5000);
         duration = mp.getDuration();
         Log.v(TAG, "video duration " + duration);
         mp.pause();
         Thread.sleep(MediaNames.PAUSE_WAIT_TIME);
         mp.seekTo(duration - 20000 );
         mp.start();
         Thread.sleep(1000);
         mp.pause();
         Thread.sleep(MediaNames.PAUSE_WAIT_TIME);
         mp.seekTo(duration/2);
         mp.start();
         Thread.sleep(10000);
         currentPosition = mp.getCurrentPosition();
         Log.v(TAG, "video currentPosition " + currentPosition);
         mp.release();
         if (currentPosition > (duration /2 )*0.9)
             return true;
         else
             return false;

     }

     public static boolean seekToEnd(String filePath){
         Log.v(TAG, "seekToEnd - " + filePath);
         int duration = 0;
         int currentPosition = 0;
         boolean isPlaying = false;
         MediaPlayer mp = new MediaPlayer();
         try{
             mp.setDataSource(filePath);
             Log.v(TAG, "start playback");
             mp.prepare();
             duration = mp.getDuration();
             mp.seekTo(duration - 3000);
             mp.start();
             Thread.sleep(6000);
         }catch (Exception e){}
         isPlaying = mp.isPlaying();
         currentPosition = mp.getCurrentPosition();
         Log.v(TAG, "seekToEnd currentPosition= " + currentPosition + " isPlaying = " + isPlaying);
         mp.stop();
         mp.release();
         Log.v(TAG, "duration = " + duration);
         if (currentPosition < 0.9 * duration || isPlaying)
             return false;
         else
             return true;
     }

     public static boolean shortMediaStop(String filePath){
         Log.v(TAG, "shortMediaStop - " + filePath);
         //This test is only for the short media file
         int duration = 0;
         int currentPosition = 0;
         boolean isPlaying = false;
         MediaPlayer mp = new MediaPlayer();
         try{
             mp.setDataSource(filePath);
             Log.v(TAG, "start playback");
             mp.prepare();
             duration = mp.getDuration();
             mp.start();
             Thread.sleep(10000);
         }catch (Exception e){}
         isPlaying = mp.isPlaying();
         currentPosition = mp.getCurrentPosition();
         Log.v(TAG, "seekToEnd currentPosition= " + currentPosition + " isPlaying = " + isPlaying);
         mp.stop();
         mp.release();
         Log.v(TAG, "duration = " + duration);
         if (currentPosition > duration || isPlaying)
             return false;
         else
             return true;
     }

     public static boolean playToEnd(String filePath){
         Log.v(TAG, "shortMediaStop - " + filePath);
         //This test is only for the short media file
         int duration = 200000;
         int updateDuration = 0;
         int currentPosition = 0;
         boolean isPlaying = false;
         MediaPlayer mp = new MediaPlayer();
         try{
             Thread.sleep(5000);
             mp.setDataSource(filePath);
             Log.v(TAG, "start playback");
             mp.prepare();
             //duration = mp.getDuration();
             mp.start();
             Thread.sleep(50000);
         }catch (Exception e){}
         isPlaying = mp.isPlaying();
         currentPosition = mp.getCurrentPosition();
         //updateDuration = mp.getDuration();
         Log.v(TAG, "seekToEnd currentPosition= " + currentPosition + " isPlaying = " + isPlaying);
         mp.stop();
         mp.release();
         //Log.v(TAG, "duration = " + duration);
         //Log.v(TAG, "Update duration = " + updateDuration);
         if (currentPosition > duration || isPlaying)
             return false;
         else
             return true;
     }

     public static boolean seektoBeforeStart(String filePath){
         Log.v(TAG, "seektoBeforeStart - " + filePath);
         //This test is only for the short media file
         int duration = 0;
         int currentPosition = 0;

         MediaPlayer mp = new MediaPlayer();
         try{
             mp.setDataSource(filePath);
             mp.prepare();
             duration = mp.getDuration();
             mp.seekTo(duration - 10000);
             mp.start();
             currentPosition=mp.getCurrentPosition();
             mp.stop();
             mp.release();
         }catch (Exception e){}
         if (currentPosition < duration/2)
             return false;
         else
             return true;
     }

     public static boolean mediaRecorderRecord(String filePath){
         Log.v(TAG, "SoundRecording - " + filePath);
         //This test is only for the short media file
         int duration = 0;
         try{
             MediaRecorder mRecorder = new MediaRecorder();
             mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
             mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
             mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
             mRecorder.setOutputFile(filePath);
             mRecorder.prepare();
             mRecorder.start();
             Thread.sleep(500);
             mRecorder.stop();
             Log.v(TAG, "sound recorded");
             mRecorder.release();
         }catch (Exception e){
             Log.v(TAG, e.toString());
         }

         //Verify the recorded file
         MediaPlayer mp = new MediaPlayer();
         try{
             mp.setDataSource(filePath);
             mp.prepare();
             duration = mp.getDuration();
             Log.v(TAG,"Duration " + duration);
             mp.release();
         }catch (Exception e){}
         //Check the record media file length is greate than zero
         if (duration > 0)
             return true;
         else
             return false;

     }

     //Test for mediaMeta Data Thumbnail
     public static boolean getThumbnail(String filePath, String goldenPath){
         Log.v(TAG, "getThumbnail - " + filePath);

         int goldenHeight = 0;
         int goldenWidth = 0;
         int outputWidth = 0;
         int outputHeight = 0;

         //This test is only for the short media file
         try{
             BitmapFactory mBitmapFactory = new BitmapFactory();

             MediaMetadataRetriever mMediaMetadataRetriever = new MediaMetadataRetriever();
             try {
                 mMediaMetadataRetriever.setDataSource(filePath);
             } catch(Exception e) {
                 e.printStackTrace();
                 return false;
             }
             Bitmap outThumbnail = mMediaMetadataRetriever.captureFrame();

             //Verify the thumbnail
             Bitmap goldenBitmap = mBitmapFactory.decodeFile(goldenPath);

             outputWidth = outThumbnail.getWidth();
             outputHeight = outThumbnail.getHeight();
             goldenHeight = goldenBitmap.getHeight();
             goldenWidth = goldenBitmap.getWidth();

             //check the image dimension
             if ((outputWidth != goldenWidth) || (outputHeight != goldenHeight))
                 return false;

             //Check one line of pixel
             int x = goldenHeight/2;
             for (int j=0; j<goldenWidth; j++){
                 if (goldenBitmap.getPixel(x, j) != outThumbnail.getPixel(x, j)){
                     Log.v(TAG, "pixel = " + goldenBitmap.getPixel(x, j));
                     return false;
                 }
             }
         }catch (Exception e){}
         return true;
     }

     //Load midi file from resources
     public static boolean resourcesPlayback(AssetFileDescriptor afd, int expectedDuration){
         int duration = 0;
         try{
             MediaPlayer mp = new MediaPlayer();
             mp.setDataSource(afd.getFileDescriptor(),afd.getStartOffset(), afd.getLength());
             mp.prepare();
             mp.start();
             duration = mp.getDuration();
             Thread.sleep(5000);
             mp.release();
         }catch (Exception e){
             Log.v(TAG,e.getMessage());
         }
         if (duration > expectedDuration)
             return true;
         else
             return false;
     }

     public static boolean prepareAsyncReset(String filePath){
         //preparesAsync
         try{
             MediaPlayer mp = new MediaPlayer();
             mp.setDataSource(filePath);
             mp.prepareAsync();
             mp.reset();
             mp.release();
         }catch (Exception e){
             Log.v(TAG,e.getMessage());
             return false;
         }
         return true;
     }


     public static boolean isLooping(String filePath) {
         MediaPlayer mp = null;

         try {
             mp = new MediaPlayer();
             if (mp.isLooping()) {
                 Log.v(TAG, "MediaPlayer.isLooping() returned true after ctor");
                 return false;
             }
             mp.setDataSource(filePath);
             mp.prepare();

             mp.setLooping(true);
             if (!mp.isLooping()) {
                 Log.v(TAG, "MediaPlayer.isLooping() returned false after setLooping(true)");
                 return false;
             }

             mp.setLooping(false);
             if (mp.isLooping()) {
                 Log.v(TAG, "MediaPlayer.isLooping() returned true after setLooping(false)");
                 return false;
             }
         }catch (Exception e){
             Log.v(TAG, "Exception : " + e.toString());
             return false;
         } finally {
             if (mp != null)
                 mp.release();
         }

         return true;
     }

     public static boolean isLoopingAfterReset(String filePath) {
         MediaPlayer mp = null;
         try {
             mp = new MediaPlayer();
             mp.setDataSource(filePath);
             mp.prepare();

             mp.setLooping(true);
             mp.reset();
             if (mp.isLooping()) {
                 Log.v(TAG, "MediaPlayer.isLooping() returned true after reset()");
                 return false;
             }
         }catch (Exception e){
             Log.v(TAG, "Exception : " + e.toString());
             return false;
         } finally {
             if (mp != null)
                 mp.release();
         }

         return true;
     }
 }
	/*
	* 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
	*
	* 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 com.android.mediaframeworktest.functional;



	//import android.content.Resources;
	import com.android.mediaframeworktest.MediaFrameworkTest;
	import com.android.mediaframeworktest.MediaNames;

	import android.content.res.AssetFileDescriptor;
	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.media.MediaMetadataRetriever;
	import android.media.MediaPlayer;
	import android.media.MediaRecorder;
	import android.os.SystemClock;
	import android.util.Log;

	import java.io.IOException;
	import java.io.InputStream;
	/**
	* Junit / Instrumentation test case for the media player api

	*/
	public class CodecTest {
	private static String TAG = "MediaPlayerApiTest";

	public static String printCpuInfo(){
	String cm = "dumpsys cpuinfo";
	String cpuinfo =null;
	int ch;
	try{
	Process p = Runtime.getRuntime().exec(cm);
	InputStream in = p.getInputStream();
	StringBuffer sb = new StringBuffer(512);
	while ( ( ch = in.read() ) != -1 ){
	sb.append((char) ch);
	}
	cpuinfo = sb.toString();
	}catch (IOException e){
	Log.v(TAG, e.toString());
	}
	return cpuinfo;
	}


	public static int getDuration(String filePath) {
	Log.v(TAG, "getDuration - " + filePath);
	MediaPlayer mp = new MediaPlayer();
	try{
	mp.setDataSource(filePath);
	mp.prepare();
	}catch (Exception e){}
	int duration = mp.getDuration();
	Log.v(TAG, "Duration " + duration);
	mp.release();
	Log.v(TAG, "release");
	return duration;
	}

	public static boolean getCurrentPosition(String filePath){
	Log.v(TAG, "GetCurrentPosition - " + filePath);
	int currentPosition = 0;
	long t1=0;
	long t2 =0;
	MediaPlayer mp = new MediaPlayer();
	try{
	mp.setDataSource(filePath);
	Log.v(TAG, "start playback");
	mp.prepare();
	mp.start();
	t1=SystemClock.uptimeMillis();
	Thread.sleep(10000);
	mp.pause();
	Thread.sleep(MediaNames.PAUSE_WAIT_TIME);
	t2=SystemClock.uptimeMillis();
	}catch (Exception e){
	Log.v(TAG, e.toString());
	}
	currentPosition = mp.getCurrentPosition();
	mp.stop();
	mp.release();
	Log.v(TAG, "mp currentPositon = " + currentPosition + " play duration = " + (t2-t1));
	//The currentposition should be within 10% of the sleep time
	//For the very short mp3, it should return the length instead of 10 seconds
	if (filePath.equals(MediaNames.SHORTMP3)){
	if (currentPosition < 1000 )
	return true;
	}
	if ((currentPosition < ((t2-t1) *1.2)) && (currentPosition > 0))
	return true;
	else
	return false;
	}

	public static boolean seekTo(String filePath){
	Log.v(TAG, "seekTo " + filePath);
	int currentPosition = 0;
	MediaPlayer mp = new MediaPlayer();
	try{
	mp.setDataSource(filePath);
	mp.prepare();
	mp.start();
	mp.seekTo(MediaNames.SEEK_TIME);
	Thread.sleep(MediaNames.WAIT_TIME);
	currentPosition = mp.getCurrentPosition();
	}catch (Exception e){
	Log.v(TAG, e.getMessage());
	}
	mp.stop();
	mp.release();
	Log.v(TAG, "CurrentPosition = " + currentPosition);
	//The currentposition should be at least greater than the 80% of seek time
	if ((currentPosition > MediaNames.SEEK_TIME *0.8))
	return true;
	else
	return false;
	}

	public static boolean setLooping(String filePath){
	int currentPosition = 0;
	int duration = 0;
	long t1 =0;
	long t2 =0;
	Log.v (TAG, "SetLooping - " + filePath);
	MediaPlayer mp = new MediaPlayer();
	try{
	mp.setDataSource(filePath);
	mp.prepare();
	duration = mp.getDuration();
	Log.v(TAG, "setLooping duration " + duration);
	mp.setLooping(true);
	mp.start();
	Thread.sleep(5000);
	mp.seekTo(duration - 5000);
	t1=SystemClock.uptimeMillis();
	Thread.sleep(20000);
	t2=SystemClock.uptimeMillis();
	Log.v(TAG, "pause");
	//Bug# 1106852 - IllegalStateException will be thrown if pause is called
	//in here
	//mp.pause();
	currentPosition = mp.getCurrentPosition();
	Log.v(TAG, "looping position " + currentPosition + "duration = " + (t2-t1));
	}catch (Exception e){
	Log.v(TAG, "Exception : " + e.toString());
	}
	mp.stop();
	mp.release();
	//The current position should be within 20% of the sleep time
	//and should be greater than zero.
	if ((currentPosition < ((t2-t1-5000)*1.2)) && currentPosition > 0)
	return true;
	else
	return false;
	}

	public static boolean pause(String filePath) throws Exception {
	Log.v(TAG, "pause - " + filePath);
	boolean misPlaying = true;
	boolean pauseResult = false;
	long t1=0;
	long t2=0;
	MediaPlayer mp = new MediaPlayer();
	mp.setDataSource(filePath);
	mp.prepare();
	int duration = mp.getDuration();
	mp.start();
	t1=SystemClock.uptimeMillis();
	Thread.sleep(5000);
	mp.pause();
	Thread.sleep(MediaNames.PAUSE_WAIT_TIME);
	t2=SystemClock.uptimeMillis();
	misPlaying = mp.isPlaying();
	int curPosition = mp.getCurrentPosition();
	Log.v(TAG, filePath + " pause currentPositon " + curPosition);
	Log.v(TAG, "isPlaying "+ misPlaying + " wait time " + (t2 - t1) );
	String cpuinfo = printCpuInfo();
	Log.v(TAG, cpuinfo);
	if ((curPosition>0) && (curPosition < ((t2-t1) * 1.3)) && (misPlaying == false))
	pauseResult = true;
	mp.stop();
	mp.release();
	return pauseResult;
	}

	public static void prepareStopRelease(String filePath) throws Exception {
	Log.v(TAG, "prepareStopRelease" + filePath);
	MediaPlayer mp = new MediaPlayer();
	mp.setDataSource(filePath);
	mp.prepare();
	mp.stop();
	mp.release();
	}

	public static void preparePauseRelease(String filePath) throws Exception {
	Log.v(TAG, "preparePauseRelease" + filePath);
	MediaPlayer mp = new MediaPlayer();
	mp.setDataSource(filePath);
	mp.prepare();
	mp.pause();
	mp.release();
	}

	public static int videoHeight(String filePath) throws Exception {
	Log.v(TAG, "videoHeight - " + filePath);
	int videoHeight = 0;
	MediaPlayer mp = new MediaPlayer();
	mp.setDataSource(filePath);
	mp.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder());
	mp.prepare();
	videoHeight = mp.getVideoHeight();
	mp.release();
	return videoHeight;
	}

	public static int videoWidth(String filePath) throws Exception {
	Log.v(TAG, "videoWidth - " + filePath);
	int videoWidth = 0;
	MediaPlayer mp = new MediaPlayer();
	mp.setDataSource(filePath);
	mp.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder());
	mp.prepare();
	videoWidth = mp.getVideoWidth();
	mp.release();
	return videoWidth;
	}

	//This also test the streaming video which may take a long
	//time to start the playback.
	public static boolean videoSeekTo(String filePath) throws Exception {
	Log.v(TAG, "videoSeekTo - " + filePath);
	int currentPosition = 0;
	int duration = 0;
	boolean videoResult = false;
	MediaPlayer mp = new MediaPlayer();
	mp.setDataSource(filePath);
	mp.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder());
	mp.prepare();
	mp.start();
	if (filePath.equals(MediaNames.VIDEO_SHORT_3GP)){
	mp.pause();
	Thread.sleep(MediaNames.PAUSE_WAIT_TIME);
	mp.seekTo(0);
	mp.start();
	Thread.sleep(1000);
	currentPosition = mp.getCurrentPosition();
	Log.v(TAG,"short position " + currentPosition);
	if (currentPosition > 100 )
	return true;
	else
	return false;
	}
	Thread.sleep(5000);
	duration = mp.getDuration();
	Log.v(TAG, "video duration " + duration);
	mp.pause();
	Thread.sleep(MediaNames.PAUSE_WAIT_TIME);
	mp.seekTo(duration - 20000 );
	mp.start();
	Thread.sleep(1000);
	mp.pause();
	Thread.sleep(MediaNames.PAUSE_WAIT_TIME);
	mp.seekTo(duration/2);
	mp.start();
	Thread.sleep(10000);
	currentPosition = mp.getCurrentPosition();
	Log.v(TAG, "video currentPosition " + currentPosition);
	mp.release();
	if (currentPosition > (duration /2 )*0.9)
	return true;
	else
	return false;

	}

	public static boolean seekToEnd(String filePath){
	Log.v(TAG, "seekToEnd - " + filePath);
	int duration = 0;
	int currentPosition = 0;
	boolean isPlaying = false;
	MediaPlayer mp = new MediaPlayer();
	try{
	mp.setDataSource(filePath);
	Log.v(TAG, "start playback");
	mp.prepare();
	duration = mp.getDuration();
	mp.seekTo(duration - 3000);
	mp.start();
	Thread.sleep(6000);
	}catch (Exception e){}
	isPlaying = mp.isPlaying();
	currentPosition = mp.getCurrentPosition();
	Log.v(TAG, "seekToEnd currentPosition= " + currentPosition + " isPlaying = " + isPlaying);
	mp.stop();
	mp.release();
	Log.v(TAG, "duration = " + duration);
	if (currentPosition < 0.9 * duration \|\| isPlaying)
	return false;
	else
	return true;
	}

	public static boolean shortMediaStop(String filePath){
	Log.v(TAG, "shortMediaStop - " + filePath);
	//This test is only for the short media file
	int duration = 0;
	int currentPosition = 0;
	boolean isPlaying = false;
	MediaPlayer mp = new MediaPlayer();
	try{
	mp.setDataSource(filePath);
	Log.v(TAG, "start playback");
	mp.prepare();
	duration = mp.getDuration();
	mp.start();
	Thread.sleep(10000);
	}catch (Exception e){}
	isPlaying = mp.isPlaying();
	currentPosition = mp.getCurrentPosition();
	Log.v(TAG, "seekToEnd currentPosition= " + currentPosition + " isPlaying = " + isPlaying);
	mp.stop();
	mp.release();
	Log.v(TAG, "duration = " + duration);
	if (currentPosition > duration \|\| isPlaying)
	return false;
	else
	return true;
	}

	public static boolean playToEnd(String filePath){
	Log.v(TAG, "shortMediaStop - " + filePath);
	//This test is only for the short media file
	int duration = 200000;
	int updateDuration = 0;
	int currentPosition = 0;
	boolean isPlaying = false;
	MediaPlayer mp = new MediaPlayer();
	try{
	Thread.sleep(5000);
	mp.setDataSource(filePath);
	Log.v(TAG, "start playback");
	mp.prepare();
	//duration = mp.getDuration();
	mp.start();
	Thread.sleep(50000);
	}catch (Exception e){}
	isPlaying = mp.isPlaying();
	currentPosition = mp.getCurrentPosition();
	//updateDuration = mp.getDuration();
	Log.v(TAG, "seekToEnd currentPosition= " + currentPosition + " isPlaying = " + isPlaying);
	mp.stop();
	mp.release();
	//Log.v(TAG, "duration = " + duration);
	//Log.v(TAG, "Update duration = " + updateDuration);
	if (currentPosition > duration \|\| isPlaying)
	return false;
	else
	return true;
	}

	public static boolean seektoBeforeStart(String filePath){
	Log.v(TAG, "seektoBeforeStart - " + filePath);
	//This test is only for the short media file
	int duration = 0;
	int currentPosition = 0;

	MediaPlayer mp = new MediaPlayer();
	try{
	mp.setDataSource(filePath);
	mp.prepare();
	duration = mp.getDuration();
	mp.seekTo(duration - 10000);
	mp.start();
	currentPosition=mp.getCurrentPosition();
	mp.stop();
	mp.release();
	}catch (Exception e){}
	if (currentPosition < duration/2)
	return false;
	else
	return true;
	}

	public static boolean mediaRecorderRecord(String filePath){
	Log.v(TAG, "SoundRecording - " + filePath);
	//This test is only for the short media file
	int duration = 0;
	try{
	MediaRecorder mRecorder = new MediaRecorder();
	mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
	mRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
	mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
	mRecorder.setOutputFile(filePath);
	mRecorder.prepare();
	mRecorder.start();
	Thread.sleep(500);
	mRecorder.stop();
	Log.v(TAG, "sound recorded");
	mRecorder.release();
	}catch (Exception e){
	Log.v(TAG, e.toString());
	}

	//Verify the recorded file
	MediaPlayer mp = new MediaPlayer();
	try{
	mp.setDataSource(filePath);
	mp.prepare();
	duration = mp.getDuration();
	Log.v(TAG,"Duration " + duration);
	mp.release();
	}catch (Exception e){}
	//Check the record media file length is greate than zero
	if (duration > 0)
	return true;
	else
	return false;

	}

	//Test for mediaMeta Data Thumbnail
	public static boolean getThumbnail(String filePath, String goldenPath){
	Log.v(TAG, "getThumbnail - " + filePath);

	int goldenHeight = 0;
	int goldenWidth = 0;
	int outputWidth = 0;
	int outputHeight = 0;

	//This test is only for the short media file
	try{
	BitmapFactory mBitmapFactory = new BitmapFactory();

	MediaMetadataRetriever mMediaMetadataRetriever = new MediaMetadataRetriever();
	try {
	mMediaMetadataRetriever.setDataSource(filePath);
	} catch(Exception e) {
	e.printStackTrace();
	return false;
	}
	Bitmap outThumbnail = mMediaMetadataRetriever.captureFrame();

	//Verify the thumbnail
	Bitmap goldenBitmap = mBitmapFactory.decodeFile(goldenPath);

	outputWidth = outThumbnail.getWidth();
	outputHeight = outThumbnail.getHeight();
	goldenHeight = goldenBitmap.getHeight();
	goldenWidth = goldenBitmap.getWidth();

	//check the image dimension
	if ((outputWidth != goldenWidth) \|\| (outputHeight != goldenHeight))
	return false;

	//Check one line of pixel
	int x = goldenHeight/2;
	for (int j=0; j<goldenWidth; j++){
	if (goldenBitmap.getPixel(x, j) != outThumbnail.getPixel(x, j)){
	Log.v(TAG, "pixel = " + goldenBitmap.getPixel(x, j));
	return false;
	}
	}
	}catch (Exception e){}
	return true;
	}

	//Load midi file from resources
	public static boolean resourcesPlayback(AssetFileDescriptor afd, int expectedDuration){
	int duration = 0;
	try{
	MediaPlayer mp = new MediaPlayer();
	mp.setDataSource(afd.getFileDescriptor(),afd.getStartOffset(), afd.getLength());
	mp.prepare();
	mp.start();
	duration = mp.getDuration();
	Thread.sleep(5000);
	mp.release();
	}catch (Exception e){
	Log.v(TAG,e.getMessage());
	}
	if (duration > expectedDuration)
	return true;
	else
	return false;
	}

	public static boolean prepareAsyncReset(String filePath){
	//preparesAsync
	try{
	MediaPlayer mp = new MediaPlayer();
	mp.setDataSource(filePath);
	mp.prepareAsync();
	mp.reset();
	mp.release();
	}catch (Exception e){
	Log.v(TAG,e.getMessage());
	return false;
	}
	return true;
	}


	public static boolean isLooping(String filePath) {
	MediaPlayer mp = null;

	try {
	mp = new MediaPlayer();
	if (mp.isLooping()) {
	Log.v(TAG, "MediaPlayer.isLooping() returned true after ctor");
	return false;
	}
	mp.setDataSource(filePath);
	mp.prepare();

	mp.setLooping(true);
	if (!mp.isLooping()) {
	Log.v(TAG, "MediaPlayer.isLooping() returned false after setLooping(true)");
	return false;
	}

	mp.setLooping(false);
	if (mp.isLooping()) {
	Log.v(TAG, "MediaPlayer.isLooping() returned true after setLooping(false)");
	return false;
	}
	}catch (Exception e){
	Log.v(TAG, "Exception : " + e.toString());
	return false;
	} finally {
	if (mp != null)
	mp.release();
	}

	return true;
	}

	public static boolean isLoopingAfterReset(String filePath) {
	MediaPlayer mp = null;
	try {
	mp = new MediaPlayer();
	mp.setDataSource(filePath);
	mp.prepare();

	mp.setLooping(true);
	mp.reset();
	if (mp.isLooping()) {
	Log.v(TAG, "MediaPlayer.isLooping() returned true after reset()");
	return false;
	}
	}catch (Exception e){
	Log.v(TAG, "Exception : " + e.toString());
	return false;
	} finally {
	if (mp != null)
	mp.release();
	}

	return true;
	}
	}