MediaRecorderTest.java revision 99b4523b753f35122e23e90c95f57399c3f8bb10 
1/*
2 * Copyright (C) 2008 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.functional.mediarecorder;
18
19import com.android.mediaframeworktest.MediaFrameworkTest;
20import com.android.mediaframeworktest.MediaNames;
21
22import java.io.*;
23
24import android.content.Context;
25import android.hardware.Camera;
26import android.media.MediaPlayer;
27import android.media.MediaRecorder;
28import android.media.EncoderCapabilities;
29import android.media.EncoderCapabilities.VideoEncoderCap;
30import android.media.EncoderCapabilities.AudioEncoderCap;
31import android.test.ActivityInstrumentationTestCase2;
32import android.util.Log;
33import android.view.SurfaceHolder;
34import android.view.SurfaceView;
35import com.android.mediaframeworktest.MediaProfileReader;
36import com.android.mediaframeworktest.MediaFrameworkTestRunner;
37
38import android.test.suitebuilder.annotation.LargeTest;
39import android.test.suitebuilder.annotation.Suppress;
40import java.util.List;
41
42
43/**
44 * Junit / Instrumentation test case for the media recorder api
45 */
46public class MediaRecorderTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> {
47    private String TAG = "MediaRecorderTest";
48    private int mOutputDuration =0;
49    private int mOutputVideoWidth = 0;
50    private int mOutputVideoHeight= 0 ;
51
52    private SurfaceHolder mSurfaceHolder = null;
53    private MediaRecorder mRecorder;
54
55    private int MIN_VIDEO_FPS = 5;
56
57    Context mContext;
58    Camera mCamera;
59
60    public MediaRecorderTest() {
61        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
62
63    }
64
65    protected void setUp() throws Exception {
66        getActivity();
67        mRecorder = new MediaRecorder();
68        super.setUp();
69    }
70
71    private void recordVideo(int frameRate, int width, int height,
72            int videoFormat, int outFormat, String outFile, boolean videoOnly) {
73        Log.v(TAG,"startPreviewAndPrepareRecording");
74        try {
75            if (!videoOnly) {
76                Log.v(TAG, "setAudioSource");
77                mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
78            }
79            mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
80            mRecorder.setOutputFormat(outFormat);
81            Log.v(TAG, "output format " + outFormat);
82            mRecorder.setOutputFile(outFile);
83            mRecorder.setVideoFrameRate(frameRate);
84            mRecorder.setVideoSize(width, height);
85            Log.v(TAG, "setEncoder");
86            mRecorder.setVideoEncoder(videoFormat);
87            if (!videoOnly) {
88                mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
89            }
90            mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
91            Log.v(TAG, "setPreview");
92            mRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
93            Log.v(TAG, "prepare");
94            mRecorder.prepare();
95            Log.v(TAG, "start");
96            mRecorder.start();
97            Thread.sleep(MediaNames.RECORDED_TIME);
98            Log.v(TAG, "stop");
99            mRecorder.stop();
100            mRecorder.release();
101        } catch (Exception e) {
102            Log.v("record video failed ", e.toString());
103            mRecorder.release();
104        }
105    }
106
107    private boolean recordVideoWithPara(VideoEncoderCap videoCap, AudioEncoderCap audioCap, boolean highQuality){
108        boolean recordSuccess = false;
109        int videoEncoder = videoCap.mCodec;
110        int audioEncoder = audioCap.mCodec;
111        int videoWidth = highQuality? videoCap.mMaxFrameWidth: videoCap.mMinFrameWidth;
112        int videoHeight = highQuality? videoCap.mMaxFrameHeight: videoCap.mMinFrameHeight;
113        int videoFps = highQuality? videoCap.mMaxFrameRate: videoCap.mMinFrameRate;
114        int videoBitrate = highQuality? videoCap.mMaxBitRate: videoCap.mMinBitRate;
115        int audioBitrate = highQuality? audioCap.mMaxBitRate: audioCap.mMinBitRate;
116        int audioChannels = highQuality? audioCap.mMaxChannels: audioCap.mMinChannels ;
117        int audioSamplingRate = highQuality? audioCap.mMaxSampleRate: audioCap.mMinSampleRate;
118
119        //Overide the fps if the min_camera_fps is set
120        if (MediaFrameworkTestRunner.mMinCameraFps != 0 &&
121            MediaFrameworkTestRunner.mMinCameraFps > videoFps){
122            videoFps = MediaFrameworkTestRunner.mMinCameraFps;
123        }
124
125        if (videoFps < MIN_VIDEO_FPS) {
126            videoFps = MIN_VIDEO_FPS;
127        }
128
129        mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
130        String filename = ("/sdcard/" + videoEncoder + "_" + audioEncoder + "_" + highQuality + ".3gp");
131        try {
132            Log.v(TAG, "video encoder : " + videoEncoder);
133            Log.v(TAG, "audio encoder : " + audioEncoder);
134            Log.v(TAG, "quality : " + (highQuality?"high": "low"));
135            Log.v(TAG, "encoder : " + MediaProfileReader.getVideoCodecName(videoEncoder));
136            Log.v(TAG, "audio : " + MediaProfileReader.getAudioCodecName(audioEncoder));
137            Log.v(TAG, "videoWidth : " + videoWidth);
138            Log.v(TAG, "videoHeight : " + videoHeight);
139            Log.v(TAG, "videoFPS : " + videoFps);
140            Log.v(TAG, "videobitrate : " + videoBitrate);
141            Log.v(TAG, "audioBitrate : " + audioBitrate);
142            Log.v(TAG, "audioChannel : " + audioChannels);
143            Log.v(TAG, "AudioSampleRate : " + audioSamplingRate);
144
145            MediaRecorder mMediaRecorder = new MediaRecorder();
146            mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
147            mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
148            mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
149            mMediaRecorder.setOutputFile(filename);
150            mMediaRecorder.setVideoFrameRate(videoFps);
151            mMediaRecorder.setVideoSize(videoWidth, videoHeight);
152            mMediaRecorder.setVideoEncodingBitRate(videoBitrate);
153            mMediaRecorder.setAudioEncodingBitRate(audioBitrate);
154            mMediaRecorder.setAudioChannels(audioChannels);
155            mMediaRecorder.setAudioSamplingRate(audioSamplingRate);
156            mMediaRecorder.setVideoEncoder(videoEncoder);
157            mMediaRecorder.setAudioEncoder(audioEncoder);
158            mMediaRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
159            mMediaRecorder.prepare();
160            mMediaRecorder.start();
161            Thread.sleep(MediaNames.RECORDED_TIME);
162            mMediaRecorder.stop();
163            mMediaRecorder.release();
164            recordSuccess = validateVideo(filename, videoWidth, videoHeight);
165        } catch (Exception e) {
166            Log.v(TAG, e.toString());
167            return false;
168        }
169        return recordSuccess;
170    }
171
172    private boolean invalidRecordSetting(int frameRate, int width, int height,
173            int videoFormat, int outFormat, String outFile, boolean videoOnly) {
174        try {
175            if (!videoOnly) {
176                Log.v(TAG, "setAudioSource");
177                mRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
178            }
179            mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
180            mRecorder.setOutputFormat(outFormat);
181            Log.v(TAG, "output format " + outFormat);
182            mRecorder.setOutputFile(outFile);
183            mRecorder.setVideoFrameRate(frameRate);
184            mRecorder.setVideoSize(width, height);
185            Log.v(TAG, "setEncoder");
186            mRecorder.setVideoEncoder(videoFormat);
187            if (!videoOnly) {
188                mRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
189            }
190            mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
191            Log.v(TAG, "setPreview");
192            mRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
193            Log.v(TAG, "prepare");
194            mRecorder.prepare();
195            Log.v(TAG, "start");
196            mRecorder.start();
197            Thread.sleep(MediaNames.RECORDED_TIME);
198            Log.v(TAG, "stop");
199            mRecorder.stop();
200            mRecorder.release();
201        } catch (Exception e) {
202            Log.v("record video failed ", e.toString());
203            mRecorder.release();
204            Log.v(TAG, "reset and release");
205            return true;
206        }
207        return false;
208    }
209
210    private void getOutputVideoProperty(String outputFilePath) {
211        MediaPlayer mediaPlayer = new MediaPlayer();
212        try {
213            mediaPlayer.setDataSource(outputFilePath);
214            Log.v(TAG, "file Path = " + outputFilePath);
215            mediaPlayer.setDisplay(MediaFrameworkTest.mSurfaceView.getHolder());
216            Log.v(TAG, "before player prepare");
217            mediaPlayer.prepare();
218            Log.v(TAG, "before getduration");
219            mOutputDuration = mediaPlayer.getDuration();
220            Log.v(TAG, "get video dimension");
221            Thread.sleep(1000);
222            mOutputVideoHeight = mediaPlayer.getVideoHeight();
223            mOutputVideoWidth = mediaPlayer.getVideoWidth();
224            mediaPlayer.release();
225        } catch (Exception e) {
226            Log.v(TAG, e.toString());
227            mediaPlayer.release();
228        }
229    }
230
231    private boolean validateVideo(String filePath, int width, int height) {
232        boolean validVideo = false;
233        getOutputVideoProperty(filePath);
234        if (mOutputVideoWidth == width && mOutputVideoHeight == height &&
235                mOutputDuration > MediaNames.VALID_VIDEO_DURATION ) {
236            validVideo = true;
237        }
238        Log.v(TAG, "width = " + mOutputVideoWidth + " height = " + mOutputVideoHeight + " Duration = " + mOutputDuration);
239        return validVideo;
240    }
241
242    @LargeTest
243    /*
244     * This test case set the camera in portrait mode.
245     * Verification: validate the video dimension and the duration.
246     */
247    public void testPortraitH263() throws Exception {
248        boolean videoRecordedResult = false;
249        try {
250            mCamera = Camera.open();
251            Camera.Parameters parameters = mCamera.getParameters();
252            parameters.setPreviewSize(352, 288);
253            parameters.set("orientation", "portrait");
254            mCamera.setParameters(parameters);
255            mCamera.unlock();
256            mRecorder.setCamera(mCamera);
257            Thread.sleep(1000);
258            int codec = MediaRecorder.VideoEncoder.H263;
259            int frameRate = MediaProfileReader.getMaxFrameRateForCodec(codec);
260            recordVideo(frameRate, 352, 288, codec,
261                    MediaRecorder.OutputFormat.THREE_GPP,
262                    MediaNames.RECORDED_PORTRAIT_H263, true);
263            mCamera.lock();
264            mCamera.release();
265            videoRecordedResult =
266                validateVideo(MediaNames.RECORDED_PORTRAIT_H263, 352, 288);
267        } catch (Exception e) {
268            Log.v(TAG, e.toString());
269        }
270        assertTrue("PortraitH263", videoRecordedResult);
271    }
272
273    @LargeTest
274    public void testInvalidVideoPath() throws Exception {
275        boolean isTestInvalidVideoPathSuccessful = false;
276        isTestInvalidVideoPathSuccessful = invalidRecordSetting(15, 176, 144, MediaRecorder.VideoEncoder.H263,
277               MediaRecorder.OutputFormat.THREE_GPP, MediaNames.INVALD_VIDEO_PATH, false);
278        assertTrue("Invalid outputFile Path", isTestInvalidVideoPathSuccessful);
279    }
280
281    @LargeTest
282    //test cases for the new codec
283    public void testDeviceSpecificCodec() throws Exception {
284        int noOfFailure = 0;
285        boolean recordSuccess = false;
286        String deviceType = MediaProfileReader.getDeviceType();
287        Log.v(TAG, "deviceType = " + deviceType);
288        List<VideoEncoderCap> videoEncoders = MediaProfileReader.getVideoEncoders();
289        List<AudioEncoderCap> audioEncoders = MediaProfileReader.getAudioEncoders();
290        for (int k = 0; k < 2; k++) {
291            for (VideoEncoderCap videoEncoder: videoEncoders) {
292                for (AudioEncoderCap audioEncoder: audioEncoders) {
293                    if (k == 0) {
294                        recordSuccess = recordVideoWithPara(videoEncoder, audioEncoder, true);
295                    } else {
296                        recordSuccess = recordVideoWithPara(videoEncoder, audioEncoder, false);
297                    }
298                    if (!recordSuccess) {
299                        Log.v(TAG, "testDeviceSpecificCodec failed");
300                        Log.v(TAG, "Encoder = " + videoEncoder.mCodec + "Audio Encoder = " + audioEncoder.mCodec);
301                        noOfFailure++;
302                    }
303                }
304            }
305        }
306        if (noOfFailure != 0) {
307            assertTrue("testDeviceSpecificCodec", false);
308        }
309    }
310}
311