MediaPlayerStressTest.java revision a76e7efde89424712ab2bddba2f8dc1472c2f203 
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
19import com.android.mediaframeworktest.MediaFrameworkTest;
20
21import android.hardware.Camera;
22import android.media.MediaPlayer;
23import android.media.MediaRecorder;
24import android.test.ActivityInstrumentationTestCase2;
25import android.test.suitebuilder.annotation.LargeTest;
26import android.util.Log;
27import android.view.SurfaceHolder;
28
29import com.android.mediaframeworktest.MediaNames;
30
31import java.util.Random;
32
33/**
34 * Junit / Instrumentation test case for the media player
35 */
36public class MediaPlayerStressTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> {
37    private String TAG = "MediaPlayerStressTest";
38    private MediaRecorder mRecorder;
39    private Camera mCamera;
40
41    private static final int NUMBER_OF_RANDOM_REPOSITION_AND_PLAY = 10;
42    private static final int NUMBER_OF_RANDOM_REPOSITION_AND_PLAY_SHORT = 5;
43    private static final int NUMBER_OF_STRESS_LOOPS = 500;
44    private static final int PLAYBACK_END_TOLERANCE = 30000;
45    private static final int WAIT_UNTIL_PLAYBACK_FINISH = 515000 ;
46
47    public MediaPlayerStressTest() {
48        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
49    }
50
51    protected void setUp() throws Exception {
52        getActivity();
53        super.setUp();
54    }
55
56    @LargeTest
57    public void testStressHWDecoderRelease() throws Exception {
58        SurfaceHolder mSurfaceHolder;
59        long randomseed = System.currentTimeMillis();
60        Random generator = new Random(randomseed);
61        Log.v(TAG, "Random seed: " + randomseed);
62        int video_duration = MediaNames.STREAM_H264_480_360_1411k_DURATION;
63        int random_play_time;
64
65        mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
66        try {
67            //assertTrue(MediaFrameworkTest.checkStreamingServer());
68            for (int i = 0; i < NUMBER_OF_STRESS_LOOPS; i++) {
69                MediaPlayer mp = new MediaPlayer();
70                mp.setDataSource(MediaNames.STREAM_H264_480_360_1411k);
71                mp.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder());
72                mp.prepare();
73                mp.start();
74                // seek and play
75                for (int j = 0; j < generator.nextInt(10); j++) {
76                    random_play_time =
77                        generator.nextInt(MediaNames.STREAM_H264_480_360_1411k_DURATION / 2);
78                    Log.v(TAG, "Play time = " + random_play_time);
79                    Thread.sleep(random_play_time);
80                    int seek_time = MediaNames.STREAM_H264_480_360_1411k_DURATION / 2;
81                    Log.v(TAG, "Seek time = " + seek_time);
82                    mp.seekTo(seek_time);
83                }
84                mp.release();
85            }
86
87        } catch (Exception e) {
88            Log.v(TAG, e.toString());
89            assertTrue("testStressHWDecoderRelease", false);
90        }
91    }
92
93    @LargeTest
94    public void testStressGetCurrentPosition() throws Exception {
95        SurfaceHolder mSurfaceHolder;
96        long randomseed = System.currentTimeMillis();
97        Random generator = new Random(randomseed);
98        Log.v(TAG, "Random seed: " + randomseed);
99        int video_duration = MediaNames.VIDEO_H263_AMR_DURATION;
100        int random_play_time = 0;
101        int random_seek_time = 0;
102        int random_no_of_seek = 0;
103
104        mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
105        try {
106            for (int i = 0; i < NUMBER_OF_STRESS_LOOPS; i++) {
107                MediaPlayer mp = new MediaPlayer();
108                mp.setDataSource(MediaNames.VIDEO_H263_AMR);
109                mp.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder());
110                mp.prepare();
111                mp.start();
112                random_no_of_seek = generator.nextInt(10);
113                // make sure the seek at least run once.
114                if (random_no_of_seek == 0) {
115                    random_no_of_seek = 1;
116                }
117                Log.v(TAG, "random_seek = " + random_no_of_seek);
118                // Play for 10 seconds then random seekTo
119                for (int j = 0; j < random_no_of_seek; j++) {
120                    random_play_time =
121                        generator.nextInt(video_duration / 100);
122                    Log.v(TAG, "Play time = " + random_play_time);
123                    Thread.sleep(random_play_time);
124                    random_seek_time =
125                        generator.nextInt(video_duration / 2);
126                    Log.v(TAG, "Seek time = " + random_seek_time);
127                    mp.seekTo(random_seek_time);
128                }
129                //Seek to 10s from the end of the video
130                mp.seekTo(video_duration - 10000);
131                //After reposition, play 30 seconds the video should be finished.
132                Thread.sleep(PLAYBACK_END_TOLERANCE);
133                Log.v(TAG, "CurrentPosition = " + mp.getCurrentPosition());
134                if ( mp.isPlaying() || mp.getCurrentPosition()
135                        > (video_duration)){
136                    assertTrue("Current PlayTime greater than duration", false);
137                }
138                mp.release();
139            }
140
141        } catch (Exception e) {
142            Log.v(TAG, e.toString());
143            assertTrue("testStressGetCurrentPosition", false);
144        }
145    }
146}
147
148