| /* |
| * 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.Looper; |
| import android.os.SystemClock; |
| import android.util.Log; |
| |
| import java.io.File; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.Writer; |
| import java.io.FileOutputStream; |
| import java.util.Random; |
| /** |
| * Junit / Instrumentation test case for the media player api |
| |
| */ |
| public class CodecTest { |
| private static String TAG = "CodecTest"; |
| private static MediaPlayer mMediaPlayer; |
| private MediaPlayer.OnPreparedListener mOnPreparedListener; |
| |
| private static int WAIT_FOR_COMMAND_TO_COMPLETE = 60000; //1 min max. |
| private static boolean mInitialized = false; |
| private static boolean mPrepareReset = false; |
| private static Looper mLooper = null; |
| private static final Object lock = new Object(); |
| private static final Object prepareDone = new Object(); |
| private static final Object videoSizeChanged = new Object(); |
| private static final Object onCompletion = new Object(); |
| private static boolean onPrepareSuccess = false; |
| public static boolean onCompleteSuccess = false; |
| public static boolean mPlaybackError = false; |
| public static int mMediaInfoUnknownCount = 0; |
| public static int mMediaInfoVideoTrackLaggingCount = 0; |
| public static int mMediaInfoBadInterleavingCount = 0; |
| public static int mMediaInfoNotSeekableCount = 0; |
| public static int mMediaInfoMetdataUpdateCount = 0; |
| |
| 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){ |
| Log.v(TAG, e.toString()); |
| } |
| 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(); |
| } |
| |
| static MediaPlayer.OnVideoSizeChangedListener mOnVideoSizeChangedListener = |
| new MediaPlayer.OnVideoSizeChangedListener() { |
| public void onVideoSizeChanged(MediaPlayer mp, int width, int height) { |
| synchronized (videoSizeChanged) { |
| Log.v(TAG, "sizechanged notification received ..."); |
| videoSizeChanged.notify(); |
| } |
| } |
| }; |
| |
| //Register the videoSizeChanged listener |
| public static int videoHeight(String filePath) throws Exception { |
| Log.v(TAG, "videoHeight - " + filePath); |
| int videoHeight = 0; |
| synchronized (lock) { |
| initializeMessageLooper(); |
| try { |
| lock.wait(WAIT_FOR_COMMAND_TO_COMPLETE); |
| } catch(Exception e) { |
| Log.v(TAG, "looper was interrupted."); |
| return 0; |
| } |
| } |
| try { |
| mMediaPlayer.setDataSource(filePath); |
| mMediaPlayer.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder()); |
| mMediaPlayer.setOnVideoSizeChangedListener(mOnVideoSizeChangedListener); |
| synchronized (videoSizeChanged) { |
| try { |
| mMediaPlayer.prepare(); |
| mMediaPlayer.start(); |
| videoSizeChanged.wait(WAIT_FOR_COMMAND_TO_COMPLETE); |
| } catch (Exception e) { |
| Log.v(TAG, "wait was interrupted"); |
| } |
| } |
| videoHeight = mMediaPlayer.getVideoHeight(); |
| terminateMessageLooper(); |
| } catch (Exception e) { |
| Log.e(TAG, e.getMessage()); |
| } |
| |
| return videoHeight; |
| } |
| |
| //Register the videoSizeChanged listener |
| public static int videoWidth(String filePath) throws Exception { |
| Log.v(TAG, "videoWidth - " + filePath); |
| int videoWidth = 0; |
| |
| synchronized (lock) { |
| initializeMessageLooper(); |
| try { |
| lock.wait(WAIT_FOR_COMMAND_TO_COMPLETE); |
| } catch(Exception e) { |
| Log.v(TAG, "looper was interrupted."); |
| return 0; |
| } |
| } |
| try { |
| mMediaPlayer.setDataSource(filePath); |
| mMediaPlayer.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder()); |
| mMediaPlayer.setOnVideoSizeChangedListener(mOnVideoSizeChangedListener); |
| synchronized (videoSizeChanged) { |
| try { |
| mMediaPlayer.prepare(); |
| mMediaPlayer.start(); |
| videoSizeChanged.wait(WAIT_FOR_COMMAND_TO_COMPLETE); |
| } catch (Exception e) { |
| Log.v(TAG, "wait was interrupted"); |
| } |
| } |
| videoWidth = mMediaPlayer.getVideoWidth(); |
| terminateMessageLooper(); |
| } catch (Exception e) { |
| Log.e(TAG, e.getMessage()); |
| } |
| 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.getFrameAtTime(-1); |
| |
| //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 half line of pixel |
| int x = goldenHeight / 2; |
| for (int j = 1; j < goldenWidth / 2; j++) { |
| if (goldenBitmap.getPixel(x, j) != outThumbnail.getPixel(x, j)) { |
| Log.v(TAG, "pixel = " + goldenBitmap.getPixel(x, j)); |
| return false; |
| } |
| } |
| }catch (Exception e){ |
| Log.v(TAG, e.toString()); |
| return false; |
| } |
| 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; |
| } |
| |
| /* |
| * Initializes the message looper so that the mediaPlayer object can |
| * receive the callback messages. |
| */ |
| private static void initializeMessageLooper() { |
| Log.v(TAG, "start looper"); |
| new Thread() { |
| @Override |
| public void run() { |
| // Set up a looper to be used by camera. |
| Looper.prepare(); |
| Log.v(TAG, "start loopRun"); |
| // Save the looper so that we can terminate this thread |
| // after we are done with it. |
| mLooper = Looper.myLooper(); |
| mMediaPlayer = new MediaPlayer(); |
| synchronized (lock) { |
| mInitialized = true; |
| lock.notify(); |
| } |
| Looper.loop(); // Blocks forever until Looper.quit() is called. |
| Log.v(TAG, "initializeMessageLooper: quit."); |
| } |
| }.start(); |
| } |
| |
| /* |
| * Terminates the message looper thread. |
| */ |
| private static void terminateMessageLooper() { |
| mLooper.quit(); |
| mMediaPlayer.release(); |
| } |
| |
| static MediaPlayer.OnPreparedListener mPreparedListener = new MediaPlayer.OnPreparedListener() { |
| public void onPrepared(MediaPlayer mp) { |
| synchronized (prepareDone) { |
| if(mPrepareReset){ |
| Log.v(TAG, "call Reset"); |
| mMediaPlayer.reset(); |
| } |
| Log.v(TAG, "notify the prepare callback"); |
| prepareDone.notify(); |
| onPrepareSuccess = true; |
| } |
| } |
| }; |
| |
| public static boolean prepareAsyncCallback(String filePath, boolean reset) throws Exception { |
| //Added the PrepareReset flag which allow us to switch to different |
| //test case. |
| if (reset){ |
| mPrepareReset = true; |
| } |
| |
| synchronized (lock) { |
| initializeMessageLooper(); |
| try { |
| lock.wait(WAIT_FOR_COMMAND_TO_COMPLETE); |
| } catch(Exception e) { |
| Log.v(TAG, "looper was interrupted."); |
| return false; |
| } |
| } |
| try{ |
| mMediaPlayer.setOnPreparedListener(mPreparedListener); |
| mMediaPlayer.setDataSource(filePath); |
| mMediaPlayer.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder()); |
| mMediaPlayer.prepareAsync(); |
| synchronized (prepareDone) { |
| try { |
| prepareDone.wait(WAIT_FOR_COMMAND_TO_COMPLETE); |
| } catch (Exception e) { |
| Log.v(TAG, "wait was interrupted."); |
| } |
| } |
| terminateMessageLooper(); |
| }catch (Exception e){ |
| Log.v(TAG,e.getMessage()); |
| } |
| return onPrepareSuccess; |
| } |
| |
| static MediaPlayer.OnCompletionListener mCompletionListener = new MediaPlayer.OnCompletionListener() { |
| public void onCompletion(MediaPlayer mp) { |
| synchronized (onCompletion) { |
| Log.v(TAG, "notify the completion callback"); |
| onCompletion.notify(); |
| onCompleteSuccess = true; |
| } |
| } |
| }; |
| |
| static MediaPlayer.OnErrorListener mOnErrorListener = new MediaPlayer.OnErrorListener() { |
| public boolean onError(MediaPlayer mp, int framework_err, int impl_err) { |
| mPlaybackError = true; |
| mp.reset(); |
| return true; |
| } |
| }; |
| |
| static MediaPlayer.OnInfoListener mInfoListener = new MediaPlayer.OnInfoListener() { |
| public boolean onInfo(MediaPlayer mp, int what, int extra) { |
| switch (what){ |
| case MediaPlayer.MEDIA_INFO_UNKNOWN: |
| mMediaInfoUnknownCount++; |
| break; |
| case MediaPlayer.MEDIA_INFO_VIDEO_TRACK_LAGGING: |
| mMediaInfoVideoTrackLaggingCount++; |
| break; |
| case MediaPlayer.MEDIA_INFO_BAD_INTERLEAVING: |
| mMediaInfoBadInterleavingCount++; |
| break; |
| case MediaPlayer.MEDIA_INFO_NOT_SEEKABLE: |
| mMediaInfoNotSeekableCount++; |
| break; |
| case MediaPlayer.MEDIA_INFO_METADATA_UPDATE: |
| mMediaInfoMetdataUpdateCount++; |
| break; |
| } |
| return true; |
| } |
| }; |
| |
| public static boolean playMediaSamples(String filePath) throws Exception { |
| return playMediaSamples(filePath, 2000); |
| } |
| |
| // For each media file, forward twice and backward once, then play to the end |
| public static boolean playMediaSamples(String filePath, int buffertime) throws Exception { |
| int duration = 0; |
| int curPosition = 0; |
| int nextPosition = 0; |
| int waittime = 0; |
| onCompleteSuccess = false; |
| mMediaInfoUnknownCount = 0; |
| mMediaInfoVideoTrackLaggingCount = 0; |
| mMediaInfoBadInterleavingCount = 0; |
| mMediaInfoNotSeekableCount = 0; |
| mMediaInfoMetdataUpdateCount = 0; |
| mPlaybackError = false; |
| String testResult; |
| |
| initializeMessageLooper(); |
| synchronized (lock) { |
| try { |
| lock.wait(WAIT_FOR_COMMAND_TO_COMPLETE); |
| } catch(Exception e) { |
| Log.v(TAG, "looper was interrupted."); |
| return false; |
| } |
| } |
| try { |
| mMediaPlayer.setOnCompletionListener(mCompletionListener); |
| mMediaPlayer.setOnErrorListener(mOnErrorListener); |
| mMediaPlayer.setOnInfoListener(mInfoListener); |
| Log.v(TAG, "playMediaSamples: sample file name " + filePath); |
| mMediaPlayer.setDataSource(filePath); |
| mMediaPlayer.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder()); |
| mMediaPlayer.prepare(); |
| duration = mMediaPlayer.getDuration(); |
| // start to play |
| mMediaPlayer.start(); |
| waittime = duration - mMediaPlayer.getCurrentPosition(); |
| synchronized(onCompletion){ |
| try { |
| onCompletion.wait(waittime + buffertime); |
| }catch (Exception e) { |
| Log.v(TAG, "playMediaSamples are interrupted"); |
| return false; |
| } |
| } |
| terminateMessageLooper(); |
| } catch (Exception e) { |
| Log.v(TAG, "playMediaSamples:" + e.getMessage()); |
| } |
| return onCompleteSuccess; |
| } |
| } |
