Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c23844c6 authored by James Dong's avatar James Dong Committed by Android (Google) Code Review
Browse files

Merge "Use Java API from xml configuration in the test application"

parents 5386b3f9 1b7babd2

media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaProfileReader.java

+60 −75
Original line number Diff line number Diff line 
package com.android.mediaframeworktest;



import android.media.MediaRecorder;

import android.media.EncoderCapabilities;

import android.media.EncoderCapabilities.VideoEncoderCap;

import android.media.EncoderCapabilities.AudioEncoderCap;

import android.media.DecoderCapabilities;

import android.media.DecoderCapabilities.VideoDecoder;

import android.media.DecoderCapabilities.AudioDecoder;



import android.os.SystemProperties;

import java.util.List;

import java.util.HashMap;



public class MediaProfileReader {

public class MediaProfileReader

{

    private static final List<VideoDecoder> videoDecoders = DecoderCapabilities.getVideoDecoders();

    private static final List<AudioDecoder> audioDecoders = DecoderCapabilities.getAudioDecoders();

    private static final List<VideoEncoderCap> videoEncoders = EncoderCapabilities.getVideoEncoders();

    private static final List<AudioEncoderCap> audioEncoders = EncoderCapabilities.getAudioEncoders();

    private static final HashMap<Integer, String> encoderMap = new HashMap<Integer, String>();



    public static final HashMap<String, Integer>

    OUTPUT_FORMAT_TABLE = new HashMap<String, Integer>();

    public static String MEDIA_ENC_VID = "ro.media.enc.vid.";

    public static String MEDIA_AUD_VID = "ro.media.enc.aud.";

    public static String[] VIDEO_ENCODER_PROPERTY = {".width", ".height", ".bps", ".fps",};

    public static String[] AUDIO_ENCODER_PROPERTY = {".bps", ".hz", ".ch",};

    static {

        initEncoderMap();

    };



    public static String getVideoCodecProperty() {

        String s;

        s = SystemProperties.get("ro.media.enc.vid.codec");

        return s;

    public static List<VideoEncoderCap> getVideoEncoders() {

        return videoEncoders;

    }



    public static String getAudioCodecProperty() {

        String s;

        s = SystemProperties.get("ro.media.enc.aud.codec");

        return s;

    public static List<AudioEncoderCap> getAudioEncoders() {

        return audioEncoders;

    }



    public static String getDeviceType() {
@@ -33,78 +40,56 @@ public class MediaProfileReader { 
    }



    public static boolean getWMAEnable() {

        // push all the property into one big table

        int wmaEnable = 1;

        wmaEnable = SystemProperties.getInt("ro.media.dec.aud.wma.enabled",

                wmaEnable);

        if (wmaEnable == 1) {

        for (AudioDecoder decoder: audioDecoders) {

            if (decoder == AudioDecoder.AUDIO_DECODER_WMA) {

                return true;

        } else {

            return false;

            }

        }

        return false;

    }



    public static boolean getWMVEnable(){

        int wmvEnable = 1;

        wmvEnable = SystemProperties.getInt("ro.media.dec.vid.wmv.enabled",

                wmvEnable);

        if (wmvEnable == 1) {

        for (VideoDecoder decoder: videoDecoders) {

            if (decoder == VideoDecoder.VIDEO_DECODER_WMV) {

                return true;

        } else {

            return false;

            }

        }



    public static void createVideoProfileTable() {

        // push all the property into one big table

        String encoderType = getVideoCodecProperty();

        if (encoderType.length() != 0) {

            String encoder[] = encoderType.split(",");

            for (int i = 0; i < encoder.length; i++) {

                for (int j = 0; j < VIDEO_ENCODER_PROPERTY.length; j++) {

                    String propertyName = MEDIA_ENC_VID + encoder[i] + VIDEO_ENCODER_PROPERTY[j];

                    String prop = SystemProperties.get(propertyName);

                    // push to the table

                    String propRange[] = prop.split(",");

                    OUTPUT_FORMAT_TABLE.put((encoder[i] + VIDEO_ENCODER_PROPERTY[j] + "_low"),

                            Integer.parseInt(propRange[0]));

                    OUTPUT_FORMAT_TABLE.put((encoder[i] + VIDEO_ENCODER_PROPERTY[j] + "_high"),

                            Integer.parseInt(propRange[1]));

        return false;

    }



    public static String getVideoCodecName(int videoEncoder) {

        if (videoEncoder != MediaRecorder.VideoEncoder.H263 &&

            videoEncoder != MediaRecorder.VideoEncoder.H264 &&

            videoEncoder != MediaRecorder.VideoEncoder.MPEG_4_SP) {

            throw new IllegalArgumentException("Unsupported video encoder " + videoEncoder);

        }

        }

        return encoderMap.get(videoEncoder);

    }



    public static void createAudioProfileTable() {

        // push all the property into one big table

        String audioType = getAudioCodecProperty();

        String encoder[] = audioType.split(",");

        if (audioType.length() != 0) {

            for (int i = 0; i < encoder.length; i++) {

                for (int j = 0; j < AUDIO_ENCODER_PROPERTY.length; j++) {

                    String propertyName = MEDIA_AUD_VID + encoder[i] + AUDIO_ENCODER_PROPERTY[j];

                    String prop = SystemProperties.get(propertyName);

                    // push to the table

                    String propRange[] = prop.split(",");

                    OUTPUT_FORMAT_TABLE.put((encoder[i] + AUDIO_ENCODER_PROPERTY[j] + "_low"),

                            Integer.parseInt(propRange[0]));

                    OUTPUT_FORMAT_TABLE.put((encoder[i] + AUDIO_ENCODER_PROPERTY[j] + "_high"),

                            Integer.parseInt(propRange[1]));

                }

            }

    public static String getAudioCodecName(int audioEncoder) {

        if (audioEncoder != MediaRecorder.AudioEncoder.AMR_NB &&

            audioEncoder != MediaRecorder.AudioEncoder.AMR_WB &&

            audioEncoder != MediaRecorder.AudioEncoder.AAC &&

            audioEncoder != MediaRecorder.AudioEncoder.AAC_PLUS &&

            audioEncoder != MediaRecorder.AudioEncoder.EAAC_PLUS) {

            throw new IllegalArgumentException("Unsupported audio encodeer " + audioEncoder);

        }

        return encoderMap.get(audioEncoder);

    }



    public static void createEncoderTable(){

        OUTPUT_FORMAT_TABLE.put("h263", MediaRecorder.VideoEncoder.H263);

        OUTPUT_FORMAT_TABLE.put("h264", MediaRecorder.VideoEncoder.H264);

        OUTPUT_FORMAT_TABLE.put("m4v", MediaRecorder.VideoEncoder.MPEG_4_SP);

        OUTPUT_FORMAT_TABLE.put("amrnb", MediaRecorder.AudioEncoder.AMR_NB);

        OUTPUT_FORMAT_TABLE.put("amrwb", MediaRecorder.AudioEncoder.AMR_WB);

        OUTPUT_FORMAT_TABLE.put("aac", MediaRecorder.AudioEncoder.AAC);

        OUTPUT_FORMAT_TABLE.put("aacplus", MediaRecorder.AudioEncoder.AAC_PLUS);

        OUTPUT_FORMAT_TABLE.put("eaacplus",

                MediaRecorder.AudioEncoder.EAAC_PLUS);

    private MediaProfileReader() {} // Don't call me



    private static void initEncoderMap() {

        // video encoders

        encoderMap.put(MediaRecorder.VideoEncoder.H263, "h263");

        encoderMap.put(MediaRecorder.VideoEncoder.H264, "h264");

        encoderMap.put(MediaRecorder.VideoEncoder.MPEG_4_SP, "m4v");



        // audio encoders

        encoderMap.put(MediaRecorder.AudioEncoder.AMR_NB, "amrnb");

        encoderMap.put(MediaRecorder.AudioEncoder.AMR_WB, "amrwb");

        encoderMap.put(MediaRecorder.AudioEncoder.AAC, "aac");

        encoderMap.put(MediaRecorder.AudioEncoder.AAC_PLUS, "aacplus");

        encoderMap.put(MediaRecorder.AudioEncoder.EAAC_PLUS, "eaacplus");

    }

}

media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/MediaRecorderTest.java

+35 −42
Original line number Diff line number Diff line
@@ -25,6 +25,9 @@ import android.content.Context; 
import android.hardware.Camera;

import android.media.MediaPlayer;

import android.media.MediaRecorder;

import android.media.EncoderCapabilities;

import android.media.EncoderCapabilities.VideoEncoderCap;

import android.media.EncoderCapabilities.AudioEncoderCap;

import android.test.ActivityInstrumentationTestCase;

import android.util.Log;

import android.view.SurfaceHolder;
@@ -33,6 +36,7 @@ import com.android.mediaframeworktest.MediaProfileReader; 


import android.test.suitebuilder.annotation.LargeTest;

import android.test.suitebuilder.annotation.Suppress;

import java.util.List;





/**
@@ -99,31 +103,29 @@ public class MediaRecorderTest extends ActivityInstrumentationTestCase<MediaFram 
        }

    }

    

    private boolean recordVideoWithPara(String encoder, String audio, String quality){

    private boolean recordVideoWithPara(VideoEncoderCap videoCap, AudioEncoderCap audioCap, boolean highQuality){

        boolean recordSuccess = false;

        int videoEncoder = MediaProfileReader.OUTPUT_FORMAT_TABLE.get(encoder);

        int audioEncoder = MediaProfileReader.OUTPUT_FORMAT_TABLE.get(audio);

        int videoWidth = MediaProfileReader.OUTPUT_FORMAT_TABLE.get(encoder + ".width_" + quality);

        int videoHeight =

                MediaProfileReader.OUTPUT_FORMAT_TABLE.get(encoder + ".height_" + quality);

        int videoFps = MediaProfileReader.OUTPUT_FORMAT_TABLE.get(encoder + ".fps_" + quality);

        int videoBitrate = MediaProfileReader.OUTPUT_FORMAT_TABLE.get(encoder + ".bps_" + quality);

        int audioBitrate = MediaProfileReader.OUTPUT_FORMAT_TABLE.get(audio + ".bps_" + quality);

        int audioChannels = MediaProfileReader.OUTPUT_FORMAT_TABLE.get(audio + ".ch_" + quality);

        int audioSamplingRate =

                MediaProfileReader.OUTPUT_FORMAT_TABLE.get(audio + ".hz_" + quality);

        int videoEncoder = videoCap.mCodec;

        int audioEncoder = audioCap.mCodec;

        int videoWidth = highQuality? videoCap.mMaxFrameWidth: videoCap.mMinFrameWidth;

        int videoHeight = highQuality? videoCap.mMaxFrameHeight: videoCap.mMinFrameHeight;

        int videoFps = highQuality? videoCap.mMaxFrameRate: videoCap.mMinFrameRate;

        int videoBitrate = highQuality? videoCap.mMaxBitRate: videoCap.mMinBitRate;

        int audioBitrate = highQuality? audioCap.mMaxBitRate: audioCap.mMinBitRate;

        int audioChannels = highQuality? audioCap.mMaxChannels: audioCap.mMinChannels ;

        int audioSamplingRate = highQuality? audioCap.mMaxSampleRate: audioCap.mMinSampleRate;



        if (videoFps < MIN_VIDEO_FPS) {

            videoFps = MIN_VIDEO_FPS;

        }

        mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();

        String filename = ("/sdcard/" + encoder + "_" + audio + "_" + quality + ".3gp");

        String filename = ("/sdcard/" + videoEncoder + "_" + audioEncoder + "_" + highQuality + ".3gp");

        try {

            Log.v(TAG, "video encoder :" + videoEncoder);

            Log.v(TAG, "audio encoder :" + audioEncoder);

            Log.v(TAG, "quality : " + quality);

            Log.v(TAG, "encoder : " + encoder);

            Log.v(TAG, "audio : " + audio);

            Log.v(TAG, "quality : " + (highQuality?"high": "low"));

            Log.v(TAG, "encoder : " + MediaProfileReader.getVideoCodecName(videoEncoder));

            Log.v(TAG, "audio : " + MediaProfileReader.getAudioCodecName(audioEncoder));

            Log.v(TAG, "videoWidth : " + videoWidth);

            Log.v(TAG, "videoHeight : " + videoHeight);

            Log.v(TAG, "videoFPS : " + videoFps);
@@ -434,29 +436,21 @@ public class MediaRecorderTest extends ActivityInstrumentationTestCase<MediaFram 
        boolean recordSuccess = false;

        String deviceType = MediaProfileReader.getDeviceType();

        Log.v(TAG, "deviceType = " + deviceType);

        // Test cases are device specified

        MediaProfileReader.createVideoProfileTable();

        MediaProfileReader.createAudioProfileTable();

        MediaProfileReader.createEncoderTable();

        String encoderType = MediaProfileReader.getVideoCodecProperty();

        String audioType = MediaProfileReader.getAudioCodecProperty();

        if ((encoderType.length() != 0) || (audioType.length() != 0)) {

            String audio[] = audioType.split(",");

            String encoder[] = encoderType.split(",");

        List<VideoEncoderCap> videoEncoders = MediaProfileReader.getVideoEncoders();

        List<AudioEncoderCap> audioEncoders = MediaProfileReader.getAudioEncoders();

        for (int k = 0; k < 2; k++) {

                for (int i = 0; i < encoder.length; i++) {

                    for (int j = 0; j < audio.length; j++) {

            for (VideoEncoderCap videoEncoder: videoEncoders) {

                for (AudioEncoderCap audioEncoder: audioEncoders) {

                    if (k == 0) {

                            recordSuccess = recordVideoWithPara(encoder[i], audio[j], "high");

                        recordSuccess = recordVideoWithPara(videoEncoder, audioEncoder, true);

                    } else {

                            recordSuccess = recordVideoWithPara(encoder[i], audio[j], "low");

                        recordSuccess = recordVideoWithPara(videoEncoder, audioEncoder, false);

                    }

                    if (!recordSuccess) {

                        Log.v(TAG, "testDeviceSpecificCodec failed");

                            Log.v(TAG, "Encoder = " + encoder[i] + "Audio Encoder = " + audio[j]);

                        Log.v(TAG, "Encoder = " + videoEncoder.mCodec + "Audio Encoder = " + audioEncoder.mCodec);

                        noOfFailure++;

                    }

                        // assertTrue((encoder[i] + audio[j]), recordSuccess);

                }

            }

        }
@@ -465,4 +459,3 @@ public class MediaRecorderTest extends ActivityInstrumentationTestCase<MediaFram 
        }

    }

}
 
}

media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/unit/MediaMetadataRetrieverTest.java

+6 −9
Original line number Diff line number Diff line
@@ -39,9 +39,8 @@ public class MediaMetadataRetrieverTest extends AndroidTestCase { 
    public static void testAlbumArt() throws Exception {

        Log.v(TAG, "testAlbumArt starts.");

        MediaMetadataRetriever retriever = new MediaMetadataRetriever();

        MediaProfileReader reader = new MediaProfileReader();

        boolean supportWMA = reader.getWMAEnable();

        boolean supportWMV = reader.getWMVEnable();

        boolean supportWMA = MediaProfileReader.getWMAEnable();

        boolean supportWMV = MediaProfileReader.getWMVEnable();

        retriever.setMode(MediaMetadataRetriever.MODE_GET_METADATA_ONLY);

        for (int i = 0, n = MediaNames.ALBUMART_TEST_FILES.length; i < n; ++i) {

            try {
@@ -74,9 +73,8 @@ public class MediaMetadataRetrieverTest extends AndroidTestCase { 
    @LargeTest

    public static void testThumbnailCapture() throws Exception {

        MediaMetadataRetriever retriever = new MediaMetadataRetriever();

        MediaProfileReader reader = new MediaProfileReader();

        boolean supportWMA = reader.getWMAEnable();

        boolean supportWMV = reader.getWMVEnable();

        boolean supportWMA = MediaProfileReader.getWMAEnable();

        boolean supportWMV = MediaProfileReader.getWMVEnable();

        Log.v(TAG, "Thumbnail processing starts");

        long startedAt = System.currentTimeMillis();

        for(int i = 0, n = MediaNames.THUMBNAIL_CAPTURE_TEST_FILES.length; i < n; ++i) {
@@ -110,9 +108,8 @@ public class MediaMetadataRetrieverTest extends AndroidTestCase { 
    

    @LargeTest

    public static void testMetadataRetrieval() throws Exception {

        MediaProfileReader reader = new MediaProfileReader();

        boolean supportWMA = reader.getWMAEnable();

        boolean supportWMV = reader.getWMVEnable();

        boolean supportWMA = MediaProfileReader.getWMAEnable();

        boolean supportWMV = MediaProfileReader.getWMVEnable();

        MediaMetadataRetriever retriever = new MediaMetadataRetriever();

        retriever.setMode(MediaMetadataRetriever.MODE_GET_METADATA_ONLY);

        for(int i = 0, n = MediaNames.METADATA_RETRIEVAL_TEST_FILES.length; i < n; ++i) {