| /* |
| * Copyright (C) 2011 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.videoeditor; |
| |
| import java.io.File; |
| import java.io.IOException; |
| |
| import android.media.videoeditor.AudioTrack; |
| import android.media.videoeditor.MediaImageItem; |
| import android.media.videoeditor.MediaItem; |
| import android.media.videoeditor.MediaProperties; |
| import android.media.videoeditor.MediaVideoItem; |
| import android.media.videoeditor.VideoEditor; |
| import android.os.Environment; |
| import android.test.ActivityInstrumentationTestCase; |
| import android.test.suitebuilder.annotation.LargeTest; |
| import com.android.mediaframeworktest.MediaFrameworkTest; |
| import com.android.mediaframeworktest.VideoEditorHelper; |
| import com.android.mediaframeworktest.MediaProfileReader; |
| |
| public class MediaPropertiesTest extends |
| ActivityInstrumentationTestCase<MediaFrameworkTest> { |
| private final String TAG = "MediaPropertiesTest"; |
| |
| private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON; |
| |
| private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON; |
| |
| private VideoEditor mVideoEditor; |
| |
| private VideoEditorHelper mVideoEditorHelper; |
| |
| public MediaPropertiesTest() { |
| super("com.android.mediaframeworktest", MediaFrameworkTest.class); |
| } |
| |
| @Override |
| protected void setUp() throws Exception { |
| // setup for each test case. |
| super.setUp(); |
| mVideoEditorHelper = new VideoEditorHelper(); |
| // Create a random String which will be used as project path, |
| // where all project related files will be stored. |
| final String projectPath = mVideoEditorHelper. |
| createRandomFile(PROJECT_LOCATION); |
| mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| mVideoEditorHelper.destroyVideoEditor(mVideoEditor); |
| // Clean the directory created as project path |
| mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath())); |
| System.gc(); |
| super.tearDown(); |
| } |
| |
| protected void validateVideoProperties(int aspectRatio, int fileType, |
| int videoCodecType, int duration, int videoBitrate, int fps, |
| int videoProfile, int videoLevel, int width, int height, int audioCodecType, |
| int audioSamplingFrequency, int audioChannel, int audioBitrate, |
| MediaVideoItem mvi) throws Exception { |
| assertEquals("Aspect Ratio Mismatch", aspectRatio, mvi.getAspectRatio()); |
| assertEquals("File Type Mismatch", fileType, mvi.getFileType()); |
| assertEquals("VideoCodec Mismatch", videoCodecType, mvi.getVideoType()); |
| |
| assertTrue("Video duration Mismatch", mVideoEditorHelper.checkRange ( |
| duration, mvi.getDuration(), 10)); |
| assertEquals("Video Profile " + mvi.getVideoProfile(), videoProfile, |
| mvi.getVideoProfile()); |
| assertEquals("Video Level " + mvi.getVideoLevel(), videoLevel, |
| mvi.getVideoLevel()); |
| assertEquals("Video height " + mvi.getHeight(), height, mvi.getHeight()); |
| assertEquals("Video width " + mvi.getWidth(), width, mvi.getWidth()); |
| /** Check FPS with 10% range */ |
| assertTrue("fps Mismatch" + mvi.getFps(), |
| mVideoEditorHelper.checkRange(fps, mvi.getFps(), 10)); |
| |
| assertEquals("AudioType Mismatch ", audioCodecType, mvi.getAudioType()); |
| assertEquals("Audio Sampling " + mvi.getAudioSamplingFrequency(), |
| audioSamplingFrequency, mvi.getAudioSamplingFrequency()); |
| // PV SW AAC codec always returns number of channels as Stereo. |
| // So we do not assert for number of audio channels for AAC_LC |
| if ( audioCodecType != MediaProperties.ACODEC_AAC_LC ) { |
| assertEquals("Audio Channels " + mvi.getAudioChannels(), audioChannel, |
| mvi.getAudioChannels()); |
| } |
| } |
| |
| protected void validateAudioProperties(int audioCodecType, int duration, |
| int audioSamplingFrequency, int audioChannel, int audioBitrate, |
| AudioTrack aT) throws Exception { |
| assertEquals("AudioType Mismatch ", audioCodecType, aT.getAudioType()); |
| assertTrue("Video duration Mismatch", mVideoEditorHelper.checkRange ( |
| duration, aT.getDuration(), 10)); |
| assertEquals("Audio Sampling " + aT.getAudioSamplingFrequency(), |
| audioSamplingFrequency, aT.getAudioSamplingFrequency()); |
| // PV SW AAC codec always returns number of channels as Stereo. |
| // So we do not assert for number of audio channels for AAC_LC |
| if ( audioCodecType != MediaProperties.ACODEC_AAC_LC ) { |
| assertEquals("Audio Channels " + aT.getAudioChannels(), audioChannel, |
| aT.getAudioChannels()); |
| } |
| } |
| |
| protected void validateImageProperties(int aspectRatio, int fileType, |
| int width, int height, MediaImageItem mii) |
| throws Exception { |
| assertEquals("Aspect Ratio Mismatch", aspectRatio, mii.getAspectRatio()); |
| assertEquals("File Type Mismatch", fileType, mii.getFileType()); |
| assertEquals("Image height " + mii.getHeight(), height, mii.getHeight()); |
| assertEquals("Image width " + mii.getWidth(), width, mii.getWidth()); |
| } |
| |
| |
| /** |
| *To test Media Properties for file MPEG4 854 x 480 |
| */ |
| @LargeTest |
| public void testPropertiesMPEG4854_480() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH |
| + "MPEG4_SP_854x480_15fps_256kbps_AACLC_16khz_48kbps_s_0_26.mp4"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_16_9; |
| final int fileType = MediaProperties.FILE_MP4; |
| final int videoCodecType = MediaProperties.VCODEC_MPEG4; |
| final int duration = 26933; |
| final int videoBitrate = 319000; |
| final int audioBitrate = 48000; |
| final int fps = 15; |
| final int audioCodecType = MediaProperties.ACODEC_AAC_LC; |
| final int audioSamplingFrequency = 16000; |
| final int audioChannel = 2; |
| final int videoProfile = MediaProperties.MPEG4Profile.MPEG4ProfileSimple; |
| final int videoLevel = MediaProperties.MPEG4Level.MPEG4Level1; |
| final int width = 854; |
| final int height = MediaProperties.HEIGHT_480; |
| |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, |
| MediaItem.RENDERING_MODE_BLACK_BORDER); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| } |
| |
| |
| /** |
| *To test Media Properties for file MPEG4 WVGA |
| */ |
| @LargeTest |
| public void testPropertiesMPEGWVGA() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH |
| + "MPEG4_SP_800x480_515kbps_15fps_AMR_NB_8KHz_12.2kbps_m_0_26.mp4"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_5_3; |
| final int fileType = MediaProperties.FILE_MP4; |
| final int videoCodecType = MediaProperties.VCODEC_MPEG4; |
| final int duration = 26933; |
| final int videoBitrate = 384000; |
| final int audioBitrate = 12800; |
| final int fps = 15; |
| final int audioCodecType = MediaProperties.ACODEC_AMRNB; |
| final int audioSamplingFrequency = 8000; |
| final int audioChannel = 1; |
| final int videoProfile = MediaProperties.MPEG4Profile.MPEG4ProfileSimple; |
| final int videoLevel = MediaProperties.MPEG4Level.MPEG4Level1; |
| final int width = 800; |
| final int height = MediaProperties.HEIGHT_480; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, renderingMode); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| } |
| |
| /** |
| *To test media properties for MPEG4 720x480 (NTSC) + AAC file. |
| */ |
| @LargeTest |
| public void testPropertiesMPEGNTSC() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH |
| + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_161kbps_s_0_26.mp4"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2; |
| final int fileType = MediaProperties.FILE_MP4; |
| final int videoCodecType = MediaProperties.VCODEC_MPEG4; |
| final int duration = 26866; |
| final int videoBitrate = 403000; |
| final int audioBitrate = 160000; |
| final int fps = 30; |
| final int audioCodecType = MediaProperties.ACODEC_AAC_LC; |
| final int audioSamplingFrequency = 48000; |
| final int audioChannel = 2; |
| final int videoProfile = MediaProperties.MPEG4Profile.MPEG4ProfileSimple; |
| final int videoLevel = MediaProperties.MPEG4Level.MPEG4Level1; |
| final int width = 720; |
| final int height = MediaProperties.HEIGHT_480; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, renderingMode); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| } |
| |
| /** |
| *To test Media Properties for file MPEG4 VGA |
| */ |
| @LargeTest |
| public void testPropertiesMPEGVGA() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH |
| + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3; |
| final int fileType = MediaProperties.FILE_MP4; |
| final int videoCodecType = MediaProperties.VCODEC_MPEG4; |
| final int duration = 26933; |
| final int videoBitrate = 533000; |
| final int audioBitrate = 128000; |
| final int fps = 15; |
| final int audioCodecType = MediaProperties.ACODEC_AAC_LC; |
| final int audioSamplingFrequency = 48000; |
| final int audioChannel = 2; |
| final int videoProfile = MediaProperties.MPEG4Profile.MPEG4ProfileSimple; |
| final int videoLevel = MediaProperties.MPEG4Level.MPEG4Level1; |
| final int width = 640; |
| final int height = MediaProperties.HEIGHT_480; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, renderingMode); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| } |
| |
| /** |
| *To test Media Properties for file MPEG4 QCIF |
| */ |
| @LargeTest |
| public void testPropertiesMPEGQCIF() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH |
| + "MPEG4_SP_176x144_12fps_92kbps_AMRNB_8KHz_12.2kbps_m_0_27.3gp"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_11_9; |
| final int fileType = MediaProperties.FILE_3GP; |
| final int videoCodecType = MediaProperties.VCODEC_MPEG4; |
| final int duration = 27000; |
| final int videoBitrate = 384000; |
| final int audioBitrate = 12200; |
| final int fps = 12; |
| final int audioCodecType = MediaProperties.ACODEC_AMRNB; |
| final int audioSamplingFrequency = 8000; |
| final int audioChannel = 1; |
| final int videoProfile = MediaProperties.MPEG4Profile.MPEG4ProfileSimple; |
| final int videoLevel = MediaProperties.MPEG4Level.MPEG4Level1; |
| final int width = 176; |
| final int height = MediaProperties.HEIGHT_144; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, renderingMode); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| } |
| |
| /** |
| *To To test media properties for H263 176x144 (QCIF) + AAC (mono) file. |
| */ |
| @LargeTest |
| public void testPropertiesH263QCIF() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH |
| + "H263_profile0_176x144_15fps_256kbps_AACLC_16kHz_32kbps_m_0_26.3gp"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_11_9; |
| final int fileType = MediaProperties.FILE_3GP; |
| final int videoCodecType = MediaProperties.VCODEC_H263; |
| final int duration = 26933; |
| final int videoBitrate = 384000; |
| final int audioBitrate = 64000; |
| final int fps = 15; |
| final int audioCodecType = MediaProperties.ACODEC_AAC_LC; |
| final int audioSamplingFrequency = 16000; |
| final int audioChannel = 1; |
| final int videoProfile = MediaProperties.H263Profile.H263ProfileBaseline; |
| final int videoLevel = MediaProperties.H263Level.H263Level10; |
| final int width = 176; |
| final int height = MediaProperties.HEIGHT_144; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, renderingMode); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| } |
| |
| /** |
| *To test Media Properties for file H264 VGA |
| */ |
| @LargeTest |
| public void testPropertiesH264VGA() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH |
| + "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_64kps_m_0_27.3gp"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3; |
| final int fileType = MediaProperties.FILE_3GP; |
| final int videoCodecType = MediaProperties.VCODEC_H264; |
| final int duration = 77600; |
| final int videoBitrate = 745000; |
| final int audioBitrate = 64000; |
| final int fps = 15; |
| final int audioCodecType = MediaProperties.ACODEC_AAC_LC; |
| final int audioSamplingFrequency = 48000; |
| final int audioChannel = 2; |
| final int videoProfile = MediaProperties.H264Profile.H264ProfileBaseline; |
| final int videoLevel = MediaProperties.H264Level.H264Level13; |
| final int width = 640; |
| final int height = MediaProperties.HEIGHT_480; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, renderingMode); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| } |
| |
| /** |
| *To test Media Properties for file H264 NTSC |
| */ |
| @LargeTest |
| public void testPropertiesH264NTSC() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH |
| + "H264_BP_720x480_25fps_256kbps_AMRNB_8khz_12.2kbps_m_0_26.mp4"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2; |
| final int fileType = MediaProperties.FILE_MP4; |
| final int videoCodecType = MediaProperties.VCODEC_H264; |
| final int duration = 26880; |
| final int videoBitrate = 244000; |
| final int audioBitrate = 12200; |
| final int fps = 25; |
| final int audioCodecType = MediaProperties.ACODEC_AMRNB; |
| final int audioSamplingFrequency = 8000; |
| final int audioChannel = 1; |
| final int videoProfile = MediaProperties.H264Profile.H264ProfileBaseline; |
| final int videoLevel = MediaProperties.H264Level.H264Level13; |
| final int width = 720; |
| final int height = MediaProperties.HEIGHT_480; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, renderingMode); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| } |
| |
| /** |
| *To test media properties for H264 800x480 (WVGA) + AAC file. |
| */ |
| @LargeTest |
| public void testPropertiesH264WVGA() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH + |
| "H264_BP_800x480_15fps_512kbps_AACLC_24KHz_38Kbps_s_1_17.mp4"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_5_3; |
| final int fileType = MediaProperties.FILE_MP4; |
| final int videoCodecType = MediaProperties.VCODEC_H264; |
| final int duration = 77466; |
| final int videoBitrate = 528000; |
| final int audioBitrate = 38000; |
| final int fps = 15; |
| final int audioCodecType = MediaProperties.ACODEC_AAC_LC; |
| final int audioSamplingFrequency = 24000; |
| final int audioChannel = 2; |
| final int videoProfile = MediaProperties.H264Profile.H264ProfileBaseline; |
| final int videoLevel = MediaProperties.H264Level.H264Level13; |
| final int width = 800; |
| final int height = MediaProperties.HEIGHT_480; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, renderingMode); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| } |
| |
| /** |
| *To test Media Properties for file H264 HD1280 |
| */ |
| @LargeTest |
| public void testPropertiesH264HD1280() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH |
| + "H264_BP_1280x720_15fps_512kbps_AACLC_16khz_48kbps_s_1_17.mp4"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_16_9; |
| final int fileType = MediaProperties.FILE_MP4; |
| final int videoCodecType = MediaProperties.VCODEC_H264; |
| final int duration = 77600; |
| final int videoBitrate = 606000; |
| final int audioBitrate = 48000; |
| final int fps = 15; |
| final int audioCodecType = MediaProperties.ACODEC_AAC_LC; |
| final int audioSamplingFrequency = 16000; |
| final int audioChannel = 2; |
| final int videoProfile = MediaProperties.H264Profile.H264ProfileBaseline; |
| final int videoLevel = MediaProperties.H264Level.H264Level13; |
| final int width = 1280; |
| final int height = MediaProperties.HEIGHT_720; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, renderingMode); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| } |
| |
| /** |
| *To test media properties for H264 1080x720 + AAC file |
| */ |
| @LargeTest |
| public void testPropertiesH264HD1080WithAudio() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH |
| + "H264_BP_1080x720_30fps_12Mbps_AACLC_44.1khz_64kbps_s_1_17.mp4"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2; |
| final int fileType = MediaProperties.FILE_MP4; |
| final int videoCodecType = MediaProperties.VCODEC_H264; |
| final int duration = 77500; |
| final int videoBitrate = 1190000; |
| final int audioBitrate = 64000; |
| final int fps = 10; |
| final int audioCodecType = MediaProperties.ACODEC_AAC_LC; |
| final int audioSamplingFrequency = 44100; |
| final int audioChannel = 2; |
| final int videoProfile = MediaProperties.H264Profile.H264ProfileBaseline; |
| final int videoLevel = MediaProperties.H264Level.H264Level13; |
| final int width = 1080; |
| final int height = MediaProperties.HEIGHT_720; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, renderingMode); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| } |
| |
| /** |
| *To test Media Properties for file WMV - Unsupported type |
| */ |
| @LargeTest |
| public void testPropertiesWMVFile() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH + |
| "WMV_V7_640x480_15fps_512Kbps_wma_V9_44khz_48Kbps_s_1_30.wmv"; |
| boolean flagForException = false; |
| if (MediaProfileReader.getWMVEnable() == false) { |
| flagForException = true; |
| } else { |
| try { |
| new MediaVideoItem(mVideoEditor, "m1", videoItemFilename, |
| MediaItem.RENDERING_MODE_BLACK_BORDER); |
| } catch (IllegalArgumentException e) { |
| flagForException = true; |
| } catch (IOException e) { |
| flagForException = true; |
| } |
| } |
| assertTrue("Media Properties for a WMV File -- Unsupported file type", |
| flagForException); |
| } |
| |
| /** |
| *To test media properties for H.264 Main/Advanced profile. |
| */ |
| @LargeTest |
| public void testPropertiesH264MainLineProfile() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH |
| + "H264_MP_960x720_25fps_800kbps_AACLC_48Khz_192Kbps_s_1_17.mp4"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3; |
| final int videoCodecType = MediaProperties.VCODEC_H264; |
| final int fileType = MediaProperties.FILE_MP4; |
| final int duration = 77500; |
| final int videoBitrate = 800000; |
| final int audioBitrate = 192000; |
| final int fps = 25; |
| final int audioCodecType = MediaProperties.ACODEC_AAC_LC; |
| final int audioSamplingFrequency = 48000; |
| final int audioChannel = 2; |
| final int videoProfile = MediaProperties.H264Profile.H264ProfileMain; |
| final int videoLevel = MediaProperties.H264Level.H264Level31; |
| final int width = 960; |
| final int height = MediaProperties.HEIGHT_720; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, renderingMode); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| |
| } |
| |
| /** |
| *To test Media Properties for non existing file. |
| */ |
| @LargeTest |
| public void testPropertiesForNonExsitingFile() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH + "abc.3gp"; |
| boolean flagForException = false; |
| |
| try { |
| new MediaVideoItem(mVideoEditor, "m1", videoItemFilename, |
| MediaItem.RENDERING_MODE_BLACK_BORDER); |
| } catch (IllegalArgumentException e) { |
| flagForException = true; |
| } catch (IOException e) { |
| flagForException = true; |
| } |
| assertTrue("Media Properties for non exsisting file", flagForException); |
| } |
| |
| /** |
| *To test Media Properties for file H264 HD1080 |
| */ |
| @LargeTest |
| public void testPropertiesH264HD1080WithoutAudio() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH + |
| "H264_BP_1080x720_30fps_800kbps_1_17.mp4"; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2; |
| final int fileType = MediaProperties.FILE_MP4; |
| final int videoCodecType = MediaProperties.VCODEC_H264; |
| final int duration = 77366; |
| final int videoBitrate = 859000; |
| final int audioBitrate = 0; |
| final int fps = 30; |
| final int audioCodecType = -1; |
| final int audioSamplingFrequency = 0; |
| final int audioChannel = 0; |
| final int videoProfile = MediaProperties.H264Profile.H264ProfileBaseline; |
| final int videoLevel = MediaProperties.H264Level.H264Level13; |
| final int width = 1080; |
| final int height = MediaProperties.HEIGHT_720; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| |
| final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", videoItemFilename, renderingMode); |
| |
| validateVideoProperties(aspectRatio, fileType, videoCodecType, duration, |
| videoBitrate, fps, videoProfile, videoLevel, width, height, audioCodecType, |
| audioSamplingFrequency, audioChannel, audioBitrate, mvi); |
| } |
| |
| /** |
| *To test Media Properties for Image file of JPEG Type |
| */ |
| @LargeTest |
| public void testPropertiesVGAImage() throws Exception { |
| final String imageItemFilename = INPUT_FILE_PATH + "IMG_640x480.jpg"; |
| final int imageItemDuration = 10000; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3; |
| final int fileType = MediaProperties.FILE_JPEG; |
| final int width = 640; |
| final int height = MediaProperties.HEIGHT_480; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| |
| final MediaImageItem mii = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", imageItemFilename, imageItemDuration, |
| renderingMode); |
| validateImageProperties(aspectRatio, fileType, width, height, mii); |
| } |
| |
| /** |
| *To test Media Properties for Image file of PNG Type |
| */ |
| @LargeTest |
| public void testPropertiesPNG() throws Exception { |
| final String imageItemFilename = INPUT_FILE_PATH + "IMG_640x480.png"; |
| final int imageItemDuration = 10000; |
| final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3; |
| final int fileType = MediaProperties.FILE_PNG; |
| final int width = 640; |
| final int height = 480; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| final MediaImageItem mii = mVideoEditorHelper.createMediaItem |
| (mVideoEditor, "m1", imageItemFilename, imageItemDuration, |
| renderingMode); |
| validateImageProperties(aspectRatio, fileType, width, height, mii); |
| } |
| |
| /** |
| *To test Media Properties for file GIF - Unsupported type |
| */ |
| @LargeTest |
| public void testPropertiesGIFFile() throws Exception { |
| |
| final String imageItemFilename = INPUT_FILE_PATH + "IMG_640x480.gif"; |
| final int imageItemDuration = 10000; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| boolean flagForException = false; |
| try { |
| new MediaImageItem(mVideoEditor, "m1", imageItemFilename, |
| imageItemDuration, renderingMode); |
| } catch (IllegalArgumentException e) { |
| flagForException = true; |
| } |
| assertTrue("Media Properties for a GIF File -- Unsupported file type", |
| flagForException); |
| } |
| |
| /** |
| *To test Media Properties for file Text file named as 3GP |
| */ |
| @LargeTest |
| public void testPropertiesofDirtyFile() throws Exception { |
| |
| final String videoItemFilename = INPUT_FILE_PATH + |
| "Text_FileRenamedTo3gp.3gp"; |
| boolean flagForException = false; |
| |
| try { |
| new MediaVideoItem(mVideoEditor, "m1", videoItemFilename, |
| MediaItem.RENDERING_MODE_BLACK_BORDER); |
| } catch (IllegalArgumentException e) { |
| flagForException = true; |
| } |
| assertTrue("Media Properties for a Dirty File ", |
| flagForException); |
| } |
| |
| /** |
| *To test Media Properties for file name as NULL |
| */ |
| @LargeTest |
| public void testPropertieNULLFile() throws Exception { |
| final String videoItemFilename = null; |
| boolean flagForException = false; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| try { |
| new MediaVideoItem(mVideoEditor, "m1", videoItemFilename, |
| renderingMode); |
| } catch (IllegalArgumentException e) { |
| flagForException = true; |
| } |
| assertTrue("Media Properties for NULL File ", |
| flagForException); |
| } |
| |
| /** |
| *To test Media Properties for file which is of type MPEG2 |
| */ |
| @LargeTest |
| public void testPropertiesMPEG2File() throws Exception { |
| final String videoItemFilename = INPUT_FILE_PATH + |
| "MPEG2_640x480_30fps_192kbps_1_5.mp4"; |
| boolean flagForException = false; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| try { |
| new MediaVideoItem(mVideoEditor, "m1", videoItemFilename, |
| renderingMode); |
| } catch (IllegalArgumentException e) { |
| flagForException = true; |
| } |
| assertTrue("Media Properties for a MPEG2 File --Unsupported file type", |
| flagForException); |
| } |
| |
| /** |
| *To test Media Properties for file without Video only Audio |
| */ |
| @LargeTest |
| public void testProperties3GPWithoutVideoMediaItem() throws Exception { |
| final String audioFilename = INPUT_FILE_PATH + |
| "AACLC_48KHz_256Kbps_s_1_17.3gp"; |
| boolean flagForException = false; |
| final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; |
| try { |
| new MediaVideoItem(mVideoEditor, "m1", audioFilename, |
| renderingMode); |
| } catch (IllegalArgumentException e) { |
| flagForException = true; |
| } |
| assertTrue("Exception in Creaing Media Video item object without video", |
| flagForException); |
| } |
| |
| /** |
| *To test media properties for Audio Track file. (No Video, AAC Audio) |
| */ |
| @LargeTest |
| public void testProperties3GPWithoutVideoAudioTrack() throws Exception { |
| |
| final String audioFilename = INPUT_FILE_PATH + |
| "AACLC_44.1kHz_256kbps_s_1_17.mp4"; |
| final int duration = 77554; |
| final int audioBitrate = 384000; |
| final int audioCodecType = MediaProperties.ACODEC_AAC_LC; |
| final int audioSamplingFrequency = 44100; |
| final int audioChannel = 2; |
| |
| final AudioTrack audioTrack = mVideoEditorHelper.createAudio |
| (mVideoEditor, "a1", audioFilename); |
| |
| validateAudioProperties(audioCodecType, duration, audioSamplingFrequency, |
| audioChannel, audioBitrate, audioTrack); |
| } |
| |
| /** |
| *To test media properties for Audio Track file. MP3 file |
| */ |
| @LargeTest |
| public void testPropertiesMP3AudioTrack() throws Exception { |
| |
| final String audioFilename = INPUT_FILE_PATH + |
| "MP3_48KHz_128kbps_s_1_17.mp3"; |
| final int duration = 77640; |
| final int audioBitrate = 128000; |
| final int audioCodecType = MediaProperties.ACODEC_MP3; |
| final int audioSamplingFrequency = 48000; |
| final int audioChannel = 2; |
| |
| final AudioTrack audioTrack = mVideoEditorHelper.createAudio |
| (mVideoEditor, "a1", audioFilename); |
| |
| validateAudioProperties(audioCodecType, duration, audioSamplingFrequency, |
| audioChannel, audioBitrate, audioTrack); |
| } |
| } |