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