Home | History | Annotate | Download | only in videoeditor 
      1 /*
      2  * Copyright (C) 2011 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 
     17 package com.android.mediaframeworktest.functional.videoeditor;
     18 
     19 import java.io.File;
     20 import java.util.List;
     21 
     22 import android.graphics.Bitmap;
     23 import android.graphics.Rect;
     24 import android.media.videoeditor.AudioTrack;
     25 import android.media.videoeditor.EffectColor;
     26 import android.media.videoeditor.EffectKenBurns;
     27 import android.media.videoeditor.ExtractAudioWaveformProgressListener;
     28 import android.media.videoeditor.MediaImageItem;
     29 import android.media.videoeditor.MediaItem;
     30 import android.media.videoeditor.MediaProperties;
     31 import android.media.videoeditor.MediaVideoItem;
     32 import android.media.videoeditor.OverlayFrame;
     33 import android.media.videoeditor.Transition;
     34 import android.media.videoeditor.TransitionAlpha;
     35 import android.media.videoeditor.TransitionCrossfade;
     36 import android.media.videoeditor.TransitionFadeBlack;
     37 import android.media.videoeditor.TransitionSliding;
     38 import android.media.videoeditor.VideoEditor;
     39 import android.os.Environment;
     40 import android.test.ActivityInstrumentationTestCase;
     41 import android.media.videoeditor.VideoEditor.MediaProcessingProgressListener;
     42 
     43 import android.util.Log;
     44 import java.lang.annotation.Annotation;
     45 
     46 import com.android.mediaframeworktest.MediaFrameworkTest;
     47 import android.test.suitebuilder.annotation.LargeTest;
     48 import com.android.mediaframeworktest.VideoEditorHelper;
     49 
     50 public class VideoEditorAPITest extends
     51         ActivityInstrumentationTestCase<MediaFrameworkTest> {
     52     private final String TAG = "VideoEditorTest";
     53 
     54     private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;
     55 
     56     private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;
     57 
     58     private final String PROJECT_CLASS_NAME =
     59         "android.media.videoeditor.VideoEditorImpl";
     60     private VideoEditor mVideoEditor;
     61     private VideoEditorHelper mVideoEditorHelper;
     62 
     63     public VideoEditorAPITest() {
     64         super("com.android.mediaframeworktest", MediaFrameworkTest.class);
     65     }
     66 
     67     @Override
     68     protected void setUp() throws Exception {
     69         // setup for each test case.
     70         super.setUp();
     71         mVideoEditorHelper = new VideoEditorHelper();
     72         // Create a random String which will be used as project path, where all
     73         // project related files will be stored.
     74         final String projectPath = mVideoEditorHelper.
     75             createRandomFile(PROJECT_LOCATION);
     76         mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath);
     77     }
     78 
     79     @Override
     80     protected void tearDown() throws Exception {
     81         mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
     82         // Clean the directory created as project path
     83         mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
     84         System.gc();
     85         super.tearDown();
     86     }
     87 
     88     /**
     89      * To Test Creation of Media Video Item.
     90      */
     91     @LargeTest
     92     public void testMediaVideoItem() throws Exception {
     93         final String videoItemFileName = INPUT_FILE_PATH
     94             + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
     95         final int videoItemRenderingMode =
     96             MediaItem.RENDERING_MODE_BLACK_BORDER;
     97 
     98         final MediaVideoItem mediaVideoItem1 =
     99             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
    100             videoItemFileName, videoItemRenderingMode);
    101 
    102         assertTrue("Media Video ID",
    103             mediaVideoItem1.getId().equals("mediaVideoItem1"));
    104         assertTrue("Media Video Filename",
    105             mediaVideoItem1.getFilename().equals(videoItemFileName));
    106         assertEquals("Media Video Rendering Mode",
    107             videoItemRenderingMode, mediaVideoItem1.getRenderingMode());
    108         assertEquals("Media Video Item Duration", mediaVideoItem1.getDuration(),
    109             mediaVideoItem1.getTimelineDuration());
    110         assertEquals("Media Video Overlay", 0,
    111             mediaVideoItem1.getAllOverlays().size());
    112         assertEquals("Media Video Effect", 0,
    113             mediaVideoItem1.getAllEffects().size());
    114         assertNull("Media Video Begin transition",
    115             mediaVideoItem1.getBeginTransition());
    116         assertNull("Media Video End transition",
    117             mediaVideoItem1.getEndTransition());
    118         mediaVideoItem1.setExtractBoundaries(1000,11000);
    119         boolean flagForException = false;
    120         if (mediaVideoItem1.getDuration() !=
    121             mediaVideoItem1.getTimelineDuration()) {
    122             flagForException = true;
    123         }
    124         assertTrue("Media Video Item Duration & Timeline are same",
    125             flagForException );
    126     }
    127 
    128     /**
    129      * To test creation of Media Video Item with Set Extract Boundaries With Get
    130      * the Begin and End Time.
    131      */
    132     @LargeTest
    133     public void testMediaVideoItemExtractBoundaries() throws Exception {
    134         final String videoItemFileName = INPUT_FILE_PATH
    135             + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
    136         final int videoItemRenderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
    137         boolean flagForException = false;
    138         final MediaVideoItem mediaVideoItem1 =
    139             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
    140             videoItemFileName, videoItemRenderingMode);
    141         mVideoEditor.addMediaItem(mediaVideoItem1);
    142 
    143         mediaVideoItem1.setExtractBoundaries(1000, 11000);
    144         assertEquals("Media Item Duration = StoryBoard Duration",
    145             mediaVideoItem1.getTimelineDuration(), mVideoEditor.getDuration());
    146         try {
    147             mediaVideoItem1.setExtractBoundaries(0, 100000000);
    148         } catch (IllegalArgumentException e) {
    149             flagForException = true;
    150         }
    151         assertTrue("Set Extract with Invalid Values endTime > FileDuration",
    152             flagForException);
    153 
    154         flagForException = false;
    155         try {
    156             mediaVideoItem1.setExtractBoundaries(100000000, 11000);
    157         } catch (IllegalArgumentException e) {
    158             flagForException = true;
    159         }
    160         assertTrue("Set Extract with Invalid Values startTime > endTime",
    161             flagForException);
    162 
    163         flagForException = false;
    164         try {
    165             mediaVideoItem1.setExtractBoundaries(0, 0);
    166         } catch (IllegalArgumentException e) {
    167             flagForException = true;
    168         }
    169         assertTrue("Set Extract with Invalid Values startTime = endTime",
    170             flagForException);
    171 
    172         mediaVideoItem1.setExtractBoundaries(1000, 10000);
    173         assertTrue("Media Item Duration is still the same",
    174             (mediaVideoItem1.getTimelineDuration() ==
    175             (mediaVideoItem1.getBoundaryEndTime()-
    176             mediaVideoItem1.getBoundaryBeginTime())) ? true : false);
    177 
    178         mediaVideoItem1.setExtractBoundaries(1,mediaVideoItem1.getDuration()-1);
    179         assertEquals("Media Item Start Time", 1,
    180             mediaVideoItem1.getBoundaryBeginTime());
    181         assertEquals("Media Item End Time", (mediaVideoItem1.getDuration() - 1),
    182             mediaVideoItem1.getBoundaryEndTime());
    183 
    184         mediaVideoItem1.setExtractBoundaries(1, mediaVideoItem1.getDuration());
    185         assertEquals("Media Item Duration = StoryBoard Duration",
    186             mediaVideoItem1.getTimelineDuration(), mVideoEditor.getDuration());
    187 
    188         mediaVideoItem1.setExtractBoundaries(0,mediaVideoItem1.getDuration()/2);
    189         assertEquals("Media Item Duration = StoryBoard Duration",
    190             mediaVideoItem1.getTimelineDuration(), mVideoEditor.getDuration());
    191 
    192         mediaVideoItem1.setExtractBoundaries(0, -1);
    193         assertEquals("Media Item Duration = StoryBoard Duration",
    194             mediaVideoItem1.getTimelineDuration(), mVideoEditor.getDuration());
    195     }
    196 
    197     /**
    198      * To test creation of Media Video Item with Set and Get rendering Mode
    199      */
    200     @LargeTest
    201     public void testMediaVideoItemRenderingModes() throws Exception {
    202         final String videoItemFileName = INPUT_FILE_PATH
    203             + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
    204         final int videoItemRenderingMode= MediaItem.RENDERING_MODE_BLACK_BORDER;
    205         boolean flagForException = false;
    206         final MediaVideoItem mediaVideoItem1 =
    207             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
    208             videoItemFileName, videoItemRenderingMode);
    209         mVideoEditor.addMediaItem(mediaVideoItem1);
    210         mediaVideoItem1.setRenderingMode(MediaItem.RENDERING_MODE_CROPPING);
    211         assertEquals("MediaVideo Item rendering Mode",
    212             MediaItem.RENDERING_MODE_CROPPING,
    213             mediaVideoItem1.getRenderingMode());
    214         try {
    215             mediaVideoItem1.setRenderingMode(
    216                 MediaItem.RENDERING_MODE_CROPPING + 911);
    217         } catch (IllegalArgumentException e) {
    218             flagForException = true;
    219         }
    220         assertTrue("Media Item Invalid rendering Mode", flagForException);
    221         flagForException = false;
    222         try {
    223             mediaVideoItem1.setRenderingMode(
    224                 MediaItem.RENDERING_MODE_BLACK_BORDER - 11);
    225         } catch (IllegalArgumentException e) {
    226             flagForException = true;
    227         }
    228         assertTrue("Media Item Invalid rendering Mode", flagForException);
    229         assertEquals("MediaVideo Item rendering Mode",
    230             MediaItem.RENDERING_MODE_CROPPING,
    231             mediaVideoItem1.getRenderingMode());
    232         mediaVideoItem1.setRenderingMode(MediaItem.RENDERING_MODE_STRETCH);
    233         assertEquals("MediaVideo Item rendering Mode",
    234             MediaItem.RENDERING_MODE_STRETCH,
    235             mediaVideoItem1.getRenderingMode());
    236     }
    237 
    238 
    239     /**
    240      * To Test the Media Video API : Set Audio Volume, Get Audio Volume and Mute
    241      */
    242     @LargeTest
    243     public void testMediaVideoItemAudioFeatures() throws Exception {
    244         final String videoItemFileName = INPUT_FILE_PATH
    245             + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
    246         final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
    247         boolean flagForException = false;
    248         final MediaVideoItem mediaVideoItem1 =
    249             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
    250             videoItemFileName, videoItemRenderingMode);
    251         mVideoEditor.addMediaItem(mediaVideoItem1);
    252         mediaVideoItem1.setVolume(77);
    253         assertEquals("Updated Volume is 77", 77, mediaVideoItem1.getVolume());
    254 
    255         mediaVideoItem1.setMute(true);
    256         assertTrue("Audio must be Muted", mediaVideoItem1.isMuted());
    257 
    258         mediaVideoItem1.setVolume(78);
    259         assertEquals("Updated Volume is 78", 78, mediaVideoItem1.getVolume());
    260         assertTrue("Audio must be Muted", mediaVideoItem1.isMuted());
    261 
    262         try {
    263             mediaVideoItem1.setVolume(1000);
    264         } catch (IllegalArgumentException e) {
    265             flagForException = true;
    266         }
    267         assertTrue("Invalid Set Volume", flagForException);
    268 
    269         mediaVideoItem1.setMute(false);
    270         assertFalse("Audio must be Un-Muted", mediaVideoItem1.isMuted());
    271 
    272         mediaVideoItem1.setVolume(0);
    273         assertFalse("Audio must be Un-Muted", mediaVideoItem1.isMuted());
    274 
    275         flagForException = false;
    276         try {
    277             mediaVideoItem1.setVolume(-1);
    278         } catch (IllegalArgumentException e) {
    279             flagForException = true;
    280         }
    281         assertTrue("Invalid Set Volume", flagForException);
    282 
    283         mediaVideoItem1.setVolume(100);
    284         assertEquals("MediaItem Volume", 100, mediaVideoItem1.getVolume());
    285         try {
    286             mediaVideoItem1.setVolume(101);
    287         } catch (IllegalArgumentException e) {
    288             flagForException = true;
    289         }
    290         assertTrue("Invalid Set Volume", flagForException);
    291         assertEquals("MediaItem Volume", 100, mediaVideoItem1.getVolume());
    292     }
    293 
    294     /**
    295      * To Test the Media Video API : GetWaveFormData and
    296      * extractAudioWaveFormData
    297      */
    298 
    299     @LargeTest
    300     public void testMediaVideoItemGetWaveformData() throws Exception {
    301 
    302         final String videoItemFileName = INPUT_FILE_PATH
    303             + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
    304         final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
    305         final MediaVideoItem mediaVideoItem1 =
    306             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
    307             videoItemFileName, videoItemRenderingMode);
    308         mVideoEditor.addMediaItem(mediaVideoItem1);
    309 
    310         assertNull("WaveForm data", mediaVideoItem1.getWaveformData());
    311         final int[] progressWaveform = new int[105];
    312 
    313         mediaVideoItem1.extractAudioWaveform(new
    314             ExtractAudioWaveformProgressListener() {
    315                 int i = 0;
    316                 public void onProgress(int progress) {
    317                     Log.i("WaveformData","progress=" +progress);
    318                     progressWaveform[i++] = progress;
    319                 }
    320             });
    321         assertTrue("Progress of WaveForm data", mVideoEditorHelper
    322             .checkProgressCBValues(progressWaveform));
    323         assertNotNull("WaveForm data", mediaVideoItem1.getWaveformData());
    324         assertTrue("WaveForm Frame Duration",
    325             (mediaVideoItem1.getWaveformData().getFrameDuration() > 0?
    326             true : false));
    327         assertTrue("WaveForm Frame Count",
    328             (mediaVideoItem1.getWaveformData().getFramesCount() > 0 ?
    329             true : false));
    330         assertTrue("WaveForm Gain",
    331             (mediaVideoItem1.getWaveformData().getFrameGains().length > 0 ?
    332             true : false));
    333 
    334     }
    335 
    336     /**
    337      * To Test the Media Video API : Get Effect, GetAllEffects, remove Effect
    338      */
    339 
    340     @LargeTest
    341     public void testMediaVideoItemEffect() throws Exception {
    342         final String videoItemFileName = INPUT_FILE_PATH
    343             + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
    344         final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
    345         final MediaVideoItem mediaVideoItem1 = mVideoEditorHelper.
    346             createMediaItem(mVideoEditor, "mediaVideoItem1", videoItemFileName,
    347             videoItemRenderingMode);
    348         mVideoEditor.addMediaItem(mediaVideoItem1);
    349 
    350         assertTrue("Effect List Size",
    351             (mediaVideoItem1.getAllEffects().size() == 0) ? true : false);
    352         assertNull("Effect Item by ID", mediaVideoItem1.getEffect("xyx"));
    353 
    354         final EffectColor effectColor = mVideoEditorHelper.createEffectItem(
    355             mediaVideoItem1, "Effecton MVi1", 0, 4000, EffectColor.TYPE_GRADIENT,
    356             EffectColor.GRAY);
    357         mediaVideoItem1.addEffect(effectColor);
    358 
    359         assertTrue("Effect List Size", (mediaVideoItem1.
    360             getAllEffects().size() == 1) ? true : false);
    361         assertEquals("Effect Item by Valid ID", effectColor,
    362             mediaVideoItem1.getEffect(effectColor.getId()));
    363         assertNull("Effect Item by Invalid ID",
    364             mediaVideoItem1.getEffect("xyz"));
    365         assertNull("Effect Item by Invalid ID",
    366             mediaVideoItem1.removeEffect("effectId"));
    367         assertTrue("Effect List Size",
    368             (mediaVideoItem1.getAllEffects().size() == 1) ? true : false);
    369         assertEquals("Effect Removed", effectColor,
    370             mediaVideoItem1.removeEffect(effectColor.getId()));
    371         assertTrue("Effect List Size",
    372             (mediaVideoItem1.getAllEffects().size() == 0) ? true : false);
    373         assertNull("Effect Item by ID", mediaVideoItem1.getEffect("effectId"));
    374     }
    375 
    376     /**
    377      * To Test the Media Video API : Get Before and after transition
    378      */
    379 
    380     @LargeTest
    381     public void testMediaVideoItemTransitions() throws Exception {
    382         final String videoItemFileName = INPUT_FILE_PATH
    383             + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
    384         final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
    385         final MediaVideoItem mediaVideoItem1 =
    386             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
    387             videoItemFileName, videoItemRenderingMode);
    388         mVideoEditor.addMediaItem(mediaVideoItem1);
    389         assertNull("Begin Transition", mediaVideoItem1.getBeginTransition());
    390         assertNull("End Transition", mediaVideoItem1.getEndTransition());
    391 
    392         TransitionFadeBlack transition1 =
    393             mVideoEditorHelper.createTFadeBlack("transition1", mediaVideoItem1,
    394             null, 0, Transition.BEHAVIOR_SPEED_UP);
    395         mVideoEditor.addTransition(transition1);
    396         assertEquals("Begin transition", transition1,
    397             mediaVideoItem1.getEndTransition());
    398 
    399         assertNotNull("End Transition", mediaVideoItem1.getEndTransition());
    400         assertTrue(mediaVideoItem1.
    401             getEndTransition().getId().equals(transition1.getId()));
    402         assertTrue(mediaVideoItem1.getEndTransition().getDuration() ==
    403             transition1.getDuration() ? true : false);
    404         assertTrue(mediaVideoItem1.getEndTransition().getBehavior() ==
    405             transition1.getBehavior() ? true : false);
    406 
    407         TransitionFadeBlack transition2 = mVideoEditorHelper.createTFadeBlack(
    408             "transition2", null,mediaVideoItem1, 0, Transition.BEHAVIOR_LINEAR);
    409         mVideoEditor.addTransition(transition2);
    410         assertNotNull("Begin transition", mediaVideoItem1.getBeginTransition());
    411         assertEquals("End Transition", transition2,
    412             mediaVideoItem1.getBeginTransition());
    413         assertTrue(mediaVideoItem1.
    414             getBeginTransition().getId().equals(transition2.getId()));
    415         assertTrue(mediaVideoItem1. getBeginTransition().getDuration() ==
    416             transition2.getDuration() ? true : false);
    417         assertTrue(mediaVideoItem1.getBeginTransition().getBehavior() ==
    418             transition2.getBehavior() ? true : false);
    419     }
    420 
    421     /**
    422      * To Test the Media Video API : Get All Overlay, Get Overlay and remove Overlay
    423      *
    424      */
    425 
    426     @LargeTest
    427     public void testMediaVideoItemOverlays() throws Exception {
    428         final String videoItemFileName = INPUT_FILE_PATH
    429             + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
    430         final String overlayItemFileName = INPUT_FILE_PATH +
    431             "IMG_176x144_Overlay1.png";
    432         final int videoItemRenderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
    433         final MediaVideoItem mediaVideoItem1 =
    434             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
    435             videoItemFileName, videoItemRenderingMode);
    436         mVideoEditor.addMediaItem(mediaVideoItem1);
    437 
    438         assertTrue("Overlay List Size",
    439             (mediaVideoItem1.getAllOverlays().size() == 0) ? true : false);
    440         assertNull("Overlay Item by ID", mediaVideoItem1.getOverlay("xyz"));
    441 
    442         final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayItemFileName,
    443             176, 144);
    444         final OverlayFrame overlayFrame = mVideoEditorHelper.createOverlay(
    445             mediaVideoItem1, "overlayId", mBitmap, 5000, 5000);
    446         mediaVideoItem1.addOverlay(overlayFrame);
    447 
    448         assertTrue("Overlay List Size",
    449             (mediaVideoItem1.getAllOverlays().size() == 1) ? true : false);
    450         assertEquals("Overlay Item by Valid ID", overlayFrame, mediaVideoItem1
    451             .getOverlay(overlayFrame.getId()));
    452         assertNull("Overlay Item by Invalid ID",
    453             mediaVideoItem1.getOverlay("xyz"));
    454         assertNull("Overlay Item by Invalid ID",
    455             mediaVideoItem1.removeOverlay("xyz"));
    456         assertTrue("Overlay List Size",
    457             (mediaVideoItem1.getAllOverlays().size() == 1) ? true : false);
    458         assertEquals("Overlay Removed", overlayFrame,
    459             mediaVideoItem1.removeOverlay(overlayFrame.getId()));
    460         assertTrue("Overlay List Size",
    461             (mediaVideoItem1.getAllOverlays().size() == 0) ? true : false);
    462         assertNull("Overlay Item by ID",mediaVideoItem1.getOverlay("effectId"));
    463     }
    464 
    465     /**
    466      * To Test Creation of Media Image Item.
    467      */
    468     @LargeTest
    469     public void testMediaImageItem() throws Exception {
    470         final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
    471         final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
    472         final MediaImageItem mediaImageItem1 =
    473             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
    474                 imageItemFileName, 5000, imageItemRenderingMode);
    475         assertTrue("Media Image ID",
    476             mediaImageItem1.getId().equals("mediaImageItem1"));
    477         assertTrue("Media IMage Filename",
    478             mediaImageItem1.getFilename().equals(imageItemFileName));
    479         assertEquals("Media Image Rendering Mode",
    480             imageItemRenderingMode, mediaImageItem1.getRenderingMode());
    481         assertEquals("Media Image Item Duration", mediaImageItem1.getDuration(),
    482             mediaImageItem1.getTimelineDuration());
    483         assertEquals("Media Image Overlay", 0,
    484             mediaImageItem1.getAllOverlays().size());
    485         assertEquals("Media Image Effect", 0,
    486             mediaImageItem1.getAllEffects().size());
    487         assertNull("Media Image Begin transition",
    488             mediaImageItem1.getBeginTransition());
    489         assertNull("Media Image End transition",
    490             mediaImageItem1.getEndTransition());
    491         assertEquals("Media Image Scaled Height", MediaProperties.HEIGHT_720,
    492             mediaImageItem1.getScaledHeight());
    493         assertEquals("Media Image Scaled Width", 960,
    494             mediaImageItem1.getScaledWidth());
    495         assertEquals("Media Image Aspect Ratio", MediaProperties.ASPECT_RATIO_4_3,
    496             mediaImageItem1.getAspectRatio());
    497         assertNotNull("Media Image Thumbnail",
    498             mediaImageItem1.getThumbnail(960, MediaProperties.HEIGHT_720, 2000));
    499     }
    500 
    501     /**
    502      * To Test the Media Image API : Get and Set rendering Mode
    503      */
    504     @LargeTest
    505     public void testMediaImageItemRenderingModes() throws Exception {
    506         final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
    507         final int imageItemRenderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
    508         boolean flagForException = false;
    509         final MediaImageItem mediaImageItem1 =
    510             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
    511             imageItemFileName, imageItemRenderingMode, 5000);
    512         mVideoEditor.addMediaItem(mediaImageItem1);
    513 
    514         mediaImageItem1.setRenderingMode(MediaItem.RENDERING_MODE_CROPPING);
    515         assertEquals("MediaVideo Item rendering Mode",
    516             MediaItem.RENDERING_MODE_CROPPING, mediaImageItem1.getRenderingMode());
    517         try {
    518             mediaImageItem1.setRenderingMode(
    519                 MediaItem.RENDERING_MODE_CROPPING + 911);
    520         } catch (IllegalArgumentException e) {
    521             flagForException = true;
    522         }
    523         assertTrue("Media Item Invalid rendering Mode", flagForException);
    524 
    525         flagForException = false;
    526         try {
    527             mediaImageItem1.setRenderingMode(
    528                 MediaItem.RENDERING_MODE_BLACK_BORDER - 11);
    529         } catch (IllegalArgumentException e) {
    530             flagForException = true;
    531         }
    532         assertTrue("Media Item Invalid rendering Mode", flagForException);
    533 
    534         assertEquals("MediaVideo Item rendering Mode",
    535             MediaItem.RENDERING_MODE_CROPPING,
    536             mediaImageItem1.getRenderingMode());
    537         mediaImageItem1.setRenderingMode(MediaItem.RENDERING_MODE_STRETCH);
    538         assertEquals("MediaVideo Item rendering Mode",
    539             MediaItem.RENDERING_MODE_STRETCH,
    540             mediaImageItem1.getRenderingMode());
    541     }
    542 
    543     /**
    544      * To Test the Media Image API : GetHeight and GetWidth
    545      */
    546     @LargeTest
    547     public void testMediaImageItemHeightWidth() throws Exception {
    548         final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
    549         final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
    550         final MediaImageItem mediaImageItem1 =
    551             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
    552             imageItemFileName, imageItemRenderingMode, 5000);
    553         mVideoEditor.addMediaItem(mediaImageItem1);
    554 
    555         assertEquals("Image Height = Image Scaled Height",
    556             mediaImageItem1.getScaledHeight(), mediaImageItem1.getHeight());
    557         assertEquals("Image Width = Image Scaled Width",
    558             mediaImageItem1.getScaledWidth(), mediaImageItem1.getWidth());
    559     }
    560 
    561 
    562 
    563 /**    This Test Case can be removed as this is already checked in TC 010 */
    564     /**
    565      * To Test the Media Image API : Scaled Height and Scaled GetWidth
    566      */
    567     @LargeTest
    568     public void testMediaImageItemScaledHeightWidth() throws Exception {
    569         final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
    570         final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
    571 
    572         final MediaImageItem mediaImageItem1 =
    573             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
    574             imageItemFileName, imageItemRenderingMode, 5000);
    575         mVideoEditor.addMediaItem(mediaImageItem1);
    576 
    577         assertNotSame("Image Height = Image Scaled Height",
    578             mediaImageItem1.getScaledHeight(), mediaImageItem1.getHeight());
    579         assertNotSame("Image Width = Image Scaled Width",
    580             mediaImageItem1.getScaledWidth(), mediaImageItem1.getWidth());
    581     }
    582 
    583     /**
    584      * To Test the Media Image API : Get Effect, GetAllEffects, remove Effect
    585      */
    586 
    587     @LargeTest
    588     public void testMediaImageItemEffect() throws Exception {
    589         final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
    590         final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
    591         final MediaImageItem mediaImageItem1 =
    592             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
    593             imageItemFileName, 5000, imageItemRenderingMode);
    594         mVideoEditor.addMediaItem(mediaImageItem1);
    595 
    596         assertTrue("Effect List Size",
    597             (mediaImageItem1.getAllEffects().size() == 0) ? true : false);
    598         assertNull("Effect Item by ID", mediaImageItem1.getEffect("xyx"));
    599 
    600         final EffectColor effectColor =
    601             mVideoEditorHelper.createEffectItem(mediaImageItem1,
    602             "Effecton MVi1", 0, 4000, EffectColor.TYPE_GRADIENT, EffectColor.GRAY);
    603         mediaImageItem1.addEffect(effectColor);
    604 
    605         assertTrue("Effect List Size",
    606             (mediaImageItem1.getAllEffects().size() == 1) ? true : false);
    607         assertEquals("Effect Item by Valid ID",
    608             effectColor, mediaImageItem1.getEffect(effectColor.getId()));
    609         assertNull("Effect Item by Invalid ID",
    610             mediaImageItem1.getEffect("xyz"));
    611         assertNull("Effect Item by Invalid ID",
    612             mediaImageItem1.removeEffect("effectId"));
    613         assertTrue("Effect List Size",
    614             (mediaImageItem1.getAllEffects().size() == 1) ? true : false);
    615         assertEquals("Effect Removed", effectColor,
    616             mediaImageItem1.removeEffect(effectColor.getId()));
    617         assertTrue("Effect List Size",
    618             (mediaImageItem1.getAllEffects().size() == 0) ? true : false);
    619         assertNull("Effect Item by ID", mediaImageItem1.getEffect("effectId"));
    620     }
    621 
    622     /**
    623      * To Test the Media Image API : Get Before and after transition
    624      */
    625 
    626     @LargeTest
    627     public void testMediaImageItemTransitions() throws Exception {
    628         final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
    629         final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
    630         final MediaImageItem mediaImageItem1 =
    631             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
    632             imageItemFileName, 5000, imageItemRenderingMode);
    633         mVideoEditor.addMediaItem(mediaImageItem1);
    634 
    635         assertNull("Begin Transition", mediaImageItem1.getBeginTransition());
    636         assertNull("End Transition", mediaImageItem1.getEndTransition());
    637 
    638         TransitionFadeBlack transition1 =
    639             mVideoEditorHelper.createTFadeBlack("transition1", mediaImageItem1,
    640             null, 0, Transition.BEHAVIOR_SPEED_UP);
    641         mVideoEditor.addTransition(transition1);
    642 
    643         assertEquals("Begin transition", transition1,
    644             mediaImageItem1.getEndTransition());
    645         assertNotNull("End Transition", mediaImageItem1.getEndTransition());
    646         assertTrue(mediaImageItem1.getEndTransition().getId().equals
    647             (transition1.getId()));
    648         assertTrue(mediaImageItem1.getEndTransition().getDuration() ==
    649             transition1.getDuration() ? true : false);
    650         assertTrue(mediaImageItem1.getEndTransition().getBehavior() ==
    651             transition1.getBehavior() ? true : false);
    652 
    653         TransitionFadeBlack transition2 = mVideoEditorHelper.createTFadeBlack(
    654             "transition2",null, mediaImageItem1, 0, Transition.BEHAVIOR_SPEED_UP);
    655         mVideoEditor.addTransition(transition2);
    656 
    657         assertNotNull("Begin transition", mediaImageItem1.getBeginTransition());
    658         assertEquals("End Transition", transition2,
    659             mediaImageItem1.getBeginTransition());
    660         assertTrue(mediaImageItem1.getBeginTransition().getId().equals(
    661             transition2.getId()));
    662         assertTrue(mediaImageItem1.getBeginTransition().getDuration() ==
    663             transition2.getDuration() ? true : false);
    664         assertTrue(mediaImageItem1.getBeginTransition().getBehavior() ==
    665             transition2.getBehavior() ? true : false);
    666     }
    667 
    668     /**
    669      * To Test the Media Image API : Get All Overlay, Get Overlay and remove
    670      * Overlay
    671      */
    672 
    673     @LargeTest
    674     public void testMediaImageItemOverlays() throws Exception {
    675         final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
    676         final String overlayItemFileName = INPUT_FILE_PATH +
    677             "IMG_640x480_Overlay1.png";
    678         final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
    679         final MediaImageItem mediaImageItem1 =
    680             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
    681             imageItemFileName, 12000, imageItemRenderingMode);
    682         mVideoEditor.addMediaItem(mediaImageItem1);
    683 
    684         assertTrue("Overlay List Size",
    685             (mediaImageItem1.getAllOverlays().size() == 0) ? true : false);
    686         assertNull("Overlay Item by ID", mediaImageItem1.getOverlay("xyz"));
    687         final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayItemFileName,
    688             640, 480);
    689         final OverlayFrame overlayFrame =
    690             mVideoEditorHelper.createOverlay(mediaImageItem1, "overlayId",
    691             mBitmap, 5000, 5000);
    692         mediaImageItem1.addOverlay(overlayFrame);
    693 
    694         assertTrue("Overlay List Size",
    695             (mediaImageItem1.getAllOverlays().size() == 1) ? true : false);
    696         assertEquals("Overlay Item by Valid ID", overlayFrame, mediaImageItem1
    697             .getOverlay(overlayFrame.getId()));
    698         assertNull("Overlay Item by Invalid ID",
    699             mediaImageItem1.getOverlay("xyz"));
    700         assertNull("Remove Overlay Item by Invalid ID",
    701             mediaImageItem1.removeOverlay("xyz"));
    702         assertTrue("Overlay List Size",
    703             (mediaImageItem1.getAllOverlays().size() == 1) ? true : false);
    704         assertEquals("Overlay Removed",
    705             overlayFrame, mediaImageItem1.removeOverlay(overlayFrame.getId()));
    706         assertTrue("Overlay List Size",
    707             (mediaImageItem1.getAllOverlays().size() == 0) ? true : false);
    708         assertNull("Overlay Item by ID",
    709             mediaImageItem1.getOverlay("effectId"));
    710     }
    711 
    712     /**
    713      * To test creation of Audio Track
    714      */
    715 
    716     @LargeTest
    717     public void testAudioTrack() throws Exception {
    718         final String audioFileName = INPUT_FILE_PATH +
    719             "AACLC_48KHz_256Kbps_s_1_17.3gp";
    720         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
    721             mVideoEditor, "audioTrack", audioFileName);
    722         mVideoEditor.addAudioTrack(audioTrack);
    723 
    724         assertEquals("Audio Track Item Duration", audioTrack.getDuration(),
    725             audioTrack.getTimelineDuration());
    726         assertEquals("Audio Track Start Time", 0, audioTrack.getStartTime());
    727         assertFalse("Audio Track is Looping", audioTrack.isLooping());
    728         audioTrack.getVolume();
    729         assertFalse("Audio Track Ducking is Disabled",
    730             audioTrack.isDuckingEnabled());
    731         assertTrue("Audio Track Filename",
    732             audioTrack.getFilename().equals(audioFileName));
    733          assertEquals("Audio Ducking Threshold", 0,
    734             audioTrack.getDuckingThreshhold());
    735          assertFalse("Audio Track Mute", audioTrack.isMuted());
    736          audioTrack.getDuckedTrackVolume();
    737     }
    738 
    739     /**
    740      * To test creation of Audio Track with set extract boundaries
    741      */
    742     @LargeTest
    743     public void testAudioTrackExtractBoundaries() throws Exception {
    744         final String audioFileName = INPUT_FILE_PATH +
    745             "AACLC_48KHz_256Kbps_s_1_17.3gp";
    746         boolean flagForException = false;
    747         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
    748             mVideoEditor, "audioTrack", audioFileName);
    749         mVideoEditor.addAudioTrack(audioTrack);
    750 
    751         audioTrack.setExtractBoundaries(1000, 5000);
    752         assertEquals("Audio Track Start time", 1000,
    753             audioTrack.getBoundaryBeginTime());
    754         assertEquals("Audio Track End time", 5000,
    755             audioTrack.getBoundaryEndTime());
    756         try {
    757             audioTrack.setExtractBoundaries(0, 100000000);
    758         } catch (IllegalArgumentException e) {
    759             flagForException = true;
    760         }
    761         assertTrue("Audio Track With endTime > FileDuration", flagForException);
    762         flagForException = false;
    763         try {
    764             audioTrack.setExtractBoundaries(100000000, 5000);
    765         } catch (IllegalArgumentException e) {
    766             flagForException = true;
    767         }
    768         assertTrue("Audio Track With startTime > FileDuration",
    769             flagForException);
    770         flagForException = false;
    771         try {
    772             audioTrack.setExtractBoundaries(0, 0);
    773         } catch (IllegalArgumentException e) {
    774             flagForException = true;
    775         }
    776         /* This is under discussion.  Hence, checked for False */
    777         assertFalse("Audio Track With startTime = endTime", flagForException);
    778         assertEquals("Audio Track Start time", 0,
    779             audioTrack.getBoundaryBeginTime());
    780         assertEquals("Audio Track End time", 0,
    781             audioTrack.getBoundaryEndTime());
    782         assertEquals("Audio Track Start time",0,
    783             audioTrack.getBoundaryBeginTime());
    784         assertEquals("Audio Track End time", (audioTrack.getTimelineDuration()),
    785             audioTrack.getBoundaryEndTime());
    786         audioTrack.setExtractBoundaries(0, audioTrack.getDuration() / 2);
    787         assertEquals("Audio Track Start time",0,
    788             audioTrack.getBoundaryBeginTime());
    789         assertEquals("Audio Track End time", (audioTrack.getDuration() / 2),
    790             audioTrack.getBoundaryEndTime());
    791         audioTrack.setExtractBoundaries(1, audioTrack.getDuration() - 1);
    792         assertEquals("Audio Track Start time", 1,
    793             audioTrack.getBoundaryBeginTime());
    794         assertEquals("Audio Track End time", (audioTrack.getDuration() - 1),
    795             audioTrack.getBoundaryEndTime());
    796 
    797         flagForException = false;
    798         try {
    799                 audioTrack.setExtractBoundaries(0, -1);
    800         } catch (IllegalArgumentException e) {
    801             flagForException = true;
    802         }
    803         assertTrue ("Audio Track end time < 0",flagForException);
    804     }
    805 
    806     /**
    807      * To test creation of Audio Track with set Start Time and Get Time
    808      */
    809     @LargeTest
    810     public void testAudioTrackSetGetTime() throws Exception {
    811         final String audioFileName = INPUT_FILE_PATH +
    812             "AACLC_48KHz_256Kbps_s_1_17.3gp";
    813         boolean flagForException = false;
    814         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
    815             mVideoEditor, "audioTrack", audioFileName);
    816         mVideoEditor.addAudioTrack(audioTrack);
    817         /** set StartTime API is removed and start time is always 0 */
    818         assertEquals("Audio Track Start Time", 0, audioTrack.getStartTime());
    819     }
    820 
    821     /**
    822      * To Test the Audio Track API: Enable Ducking
    823      */
    824     @LargeTest
    825     public void testAudioTrackEnableDucking() throws Exception {
    826         final String audioFileName = INPUT_FILE_PATH +
    827             "AACLC_48KHz_256Kbps_s_1_17.3gp";
    828         boolean flagForException = false;
    829         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
    830             mVideoEditor, "audioTrack", audioFileName);
    831         mVideoEditor.addAudioTrack(audioTrack);
    832 
    833         assertFalse("Audio Ducking Disabled by default",
    834             audioTrack.isDuckingEnabled());
    835         audioTrack.enableDucking(45, 70);
    836         assertTrue("Audio Ducking Enabled", audioTrack.isDuckingEnabled());
    837         assertEquals("Audio Ducking Threshold", 45,
    838             audioTrack.getDuckingThreshhold());
    839         assertEquals("Audio Ducking Volume", 70,
    840             audioTrack.getDuckedTrackVolume());
    841         audioTrack.enableDucking(85, 70);
    842         assertEquals("Audio Ducking Threshold", 85,
    843             audioTrack.getDuckingThreshhold());
    844         assertEquals("Audio Ducking Volume", 70,
    845             audioTrack.getDuckedTrackVolume());
    846         try {
    847             audioTrack.enableDucking(91, 70);
    848         } catch (IllegalArgumentException e) {
    849             flagForException = true;
    850         }
    851         assertTrue("Enable ducking threshold > 90", flagForException);
    852         flagForException = false;
    853         try {
    854             audioTrack.enableDucking(90, 101);
    855         } catch (IllegalArgumentException e) {
    856             flagForException = true;
    857         }
    858         assertTrue("Enable ducking volume > 100", flagForException);
    859         flagForException = false;
    860         try {
    861             audioTrack.enableDucking(91, 101);
    862         } catch (IllegalArgumentException e) {
    863             flagForException = true;
    864         }
    865         assertTrue("Enable ducking volume > 100 and threshold > 91",
    866             flagForException);
    867         flagForException = false;
    868         try {
    869             audioTrack.enableDucking(-1, 100);
    870         } catch (IllegalArgumentException e) {
    871             flagForException = true;
    872         }
    873         assertTrue("Enable ducking threshold < 0", flagForException);
    874         flagForException = false;
    875         try {
    876             audioTrack.enableDucking(1, -1);
    877         } catch (IllegalArgumentException e) {
    878             flagForException = true;
    879         }
    880         assertTrue("Enable ducking lowVolume < 0", flagForException);
    881         flagForException = false;
    882         try {
    883             audioTrack.enableDucking(0, 50);
    884         } catch (IllegalArgumentException e) {
    885             flagForException = true;
    886         }
    887         assertFalse("Enable ducking threshold = 0", flagForException);
    888     }
    889 
    890     /**
    891      * To Test the Audio Track API: Looping
    892      */
    893     @LargeTest
    894     public void testAudioTrackLooping() throws Exception {
    895         final String audioFileName = INPUT_FILE_PATH +
    896             "AACLC_48KHz_256Kbps_s_1_17.3gp";
    897         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
    898             mVideoEditor, "audioTrack", audioFileName);
    899         mVideoEditor.addAudioTrack(audioTrack);
    900         assertFalse("Audio Looping", audioTrack.isLooping());
    901         audioTrack.enableLoop();
    902         assertTrue("Audio Looping", audioTrack.isLooping());
    903         audioTrack.disableLoop();
    904         assertFalse("Audio Looping", audioTrack.isLooping());
    905     }
    906 
    907     /**
    908      * To Test the Audio Track API:Extract waveform data
    909      */
    910 
    911     @LargeTest
    912     public void testAudioTrackWaveFormData() throws Exception {
    913         /** Image item is added as dummy as Audio track cannot be added without
    914          * a media item in the story board
    915          */
    916         final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
    917         final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
    918         final MediaImageItem mediaImageItem =
    919             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
    920             imageItemFileName, 5000, imageItemRenderingMode);
    921         mVideoEditor.addMediaItem(mediaImageItem);
    922 
    923         final String audioFileName = INPUT_FILE_PATH +
    924             "AACLC_48KHz_256Kbps_s_1_17.3gp";
    925         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
    926             mVideoEditor, "audioTrack", audioFileName);
    927 
    928         mVideoEditor.addAudioTrack(audioTrack);
    929         assertNull("WaveForm data", audioTrack.getWaveformData());
    930 
    931         final int[] progressUpdate = new int[105];
    932         mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
    933             int i = 0;
    934             public void onProgress(Object item, int action, int progress) {
    935                 progressUpdate[i++] = progress;
    936             }
    937         });
    938 
    939         final int[] progressWaveform = new int[105];
    940 
    941         audioTrack.extractAudioWaveform(
    942             new ExtractAudioWaveformProgressListener() {
    943                 int i = 0;
    944                 public void onProgress(int progress) {
    945                     Log.i("AudioWaveformData","progress=" +progress);
    946                     progressWaveform[i++] = progress;
    947             }
    948         });
    949         assertTrue("Progress of WaveForm data", mVideoEditorHelper
    950             .checkProgressCBValues(progressWaveform));
    951         assertNotNull("WaveForm data", audioTrack.getWaveformData());
    952         assertTrue("WaveForm Frame Duration",
    953             (audioTrack.getWaveformData().getFrameDuration() > 0 ?
    954             true : false));
    955         assertTrue("WaveForm Frame Count",
    956             (audioTrack.getWaveformData().getFramesCount() > 0 ? true : false));
    957         assertTrue("WaveForm Gain",
    958             (audioTrack.getWaveformData().getFrameGains().length > 0 ?
    959             true : false));
    960     }
    961 
    962     /**
    963      * To Test the Audio Track API: Mute
    964      */
    965     @LargeTest
    966     public void testAudioTrackMute() throws Exception {
    967         final String audioFileName = INPUT_FILE_PATH +
    968             "AACLC_48KHz_256Kbps_s_1_17.3gp";
    969         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
    970             mVideoEditor, "audioTrack", audioFileName);
    971         assertFalse("Audio Track UnMute", audioTrack.isMuted());
    972         audioTrack.setMute(true);
    973         assertTrue("Audio Track Mute", audioTrack.isMuted());
    974         audioTrack.setMute(false);
    975         assertFalse("Audio Track UnMute", audioTrack.isMuted());
    976     }
    977 
    978     /**
    979      * To Test the Audio Track API: Get Volume and Set Volume
    980      */
    981     @LargeTest
    982     public void testAudioTrackGetSetVolume() throws Exception {
    983         final String audioFileName = INPUT_FILE_PATH +
    984             "AACLC_48KHz_256Kbps_s_1_17.3gp";
    985         boolean flagForException = false;
    986         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
    987             mVideoEditor, "audioTrack", audioFileName);
    988         audioTrack.setVolume(0);
    989         assertEquals("Audio Volume", 0, audioTrack.getVolume());
    990         assertFalse("Audio Track UnMute", audioTrack.isMuted());
    991         audioTrack.setVolume(45);
    992         assertEquals("Audio Volume", 45, audioTrack.getVolume());
    993         assertFalse("Audio Track UnMute", audioTrack.isMuted());
    994         try {
    995             audioTrack.setVolume(-1);
    996         } catch (IllegalArgumentException e) {
    997             flagForException = true;
    998         }
    999         assertTrue("Volume = -1", flagForException);
   1000         assertEquals("Audio Volume", 45, audioTrack.getVolume());
   1001         flagForException = false;
   1002         try {
   1003             audioTrack.setVolume(101);
   1004         } catch (IllegalArgumentException e) {
   1005             flagForException = true;
   1006         }
   1007         assertTrue("Volume = 101", flagForException);
   1008         flagForException = false;
   1009         try {
   1010             audioTrack.setVolume(1000);
   1011         } catch (IllegalArgumentException e) {
   1012             flagForException = true;
   1013         }
   1014         assertTrue("Volume = 10000", flagForException);
   1015         assertEquals("Audio Volume", 45, audioTrack.getVolume());
   1016     }
   1017 
   1018     /**
   1019      * To test Effect Color.
   1020      */
   1021     @LargeTest
   1022     public void testAllEffects() throws Exception {
   1023         final String videoItemFileName = INPUT_FILE_PATH +
   1024             "MPEG4_SP_640x480_30fps_512Kbps_0_27.mp4";
   1025         boolean flagForException = false;
   1026         final MediaVideoItem mediaVideoItem1 =
   1027             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
   1028             videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1029         mVideoEditor.addMediaItem(mediaVideoItem1);
   1030 
   1031         final EffectColor effectColor1 = mVideoEditorHelper.createEffectItem(
   1032             mediaVideoItem1, "effect1", 1000, 1000, EffectColor.TYPE_COLOR,
   1033             EffectColor.PINK);
   1034         mediaVideoItem1.addEffect(effectColor1);
   1035 
   1036         assertEquals("Associated Media Item", mediaVideoItem1,
   1037             effectColor1.getMediaItem());
   1038         assertTrue("Effect Id", effectColor1.getId().equals("effect1"));
   1039         assertEquals("Effect StartTime", 1000, effectColor1.getStartTime());
   1040         assertEquals("Effect EndTime", 1000, effectColor1.getDuration());
   1041         assertEquals("Effect Type", EffectColor.TYPE_COLOR,
   1042             effectColor1.getType());
   1043         assertEquals("Effect Color", EffectColor.PINK, effectColor1.getColor());
   1044 
   1045         final EffectColor effectColor2 = mVideoEditorHelper.createEffectItem(
   1046             mediaVideoItem1, "effect2", 2000, 1000, EffectColor.TYPE_COLOR,
   1047             EffectColor.GRAY);
   1048         mediaVideoItem1.addEffect(effectColor2);
   1049 
   1050         assertEquals("Associated Media Item", mediaVideoItem1,
   1051             effectColor2.getMediaItem());
   1052         assertTrue("Effect Id", effectColor2.getId().equals("effect2"));
   1053         assertEquals("Effect StartTime", 2000, effectColor2.getStartTime());
   1054         assertEquals("Effect EndTime", 1000, effectColor2.getDuration());
   1055         assertEquals("Effect Type", EffectColor.TYPE_COLOR,
   1056             effectColor2.getType());
   1057         assertEquals("Effect Color", EffectColor.GRAY, effectColor2.getColor());
   1058 
   1059         final EffectColor effectColor3 = mVideoEditorHelper.createEffectItem(
   1060             mediaVideoItem1, "effect3", 3000, 1000, EffectColor.TYPE_COLOR,
   1061             EffectColor.GREEN);
   1062         mediaVideoItem1.addEffect(effectColor3);
   1063 
   1064         assertEquals("Associated Media Item", mediaVideoItem1,
   1065             effectColor3.getMediaItem());
   1066         assertTrue("Effect Id", effectColor3.getId().equals("effect3"));
   1067         assertEquals("Effect StartTime", 3000, effectColor3.getStartTime());
   1068         assertEquals("Effect EndTime", 1000, effectColor3.getDuration());
   1069         assertEquals("Effect Type", EffectColor.TYPE_COLOR,
   1070             effectColor3.getType());
   1071         assertEquals("Effect Color", EffectColor.GREEN, effectColor3.getColor());
   1072 
   1073         final EffectColor effectColor4 = mVideoEditorHelper.createEffectItem(
   1074             mediaVideoItem1, "effect4", 4000, 1000, EffectColor.TYPE_GRADIENT,
   1075             EffectColor.PINK);
   1076         mediaVideoItem1.addEffect(effectColor4);
   1077 
   1078         assertEquals("Associated Media Item", mediaVideoItem1,
   1079             effectColor4.getMediaItem());
   1080         assertTrue("Effect Id", effectColor4.getId().equals("effect4"));
   1081         assertEquals("Effect StartTime", 4000, effectColor4.getStartTime());
   1082         assertEquals("Effect EndTime", 1000, effectColor4.getDuration());
   1083         assertEquals("Effect Type", EffectColor.TYPE_GRADIENT,
   1084             effectColor4.getType());
   1085         assertEquals("Effect Color", EffectColor.PINK, effectColor4.getColor());
   1086 
   1087         final EffectColor effectColor5 = mVideoEditorHelper.createEffectItem(
   1088             mediaVideoItem1, "effect5", 5000, 1000,
   1089             EffectColor.TYPE_GRADIENT, EffectColor.GRAY);
   1090         mediaVideoItem1.addEffect(effectColor5);
   1091 
   1092         assertEquals("Associated Media Item", mediaVideoItem1,
   1093             effectColor5.getMediaItem());
   1094         assertTrue("Effect Id", effectColor5.getId().equals("effect5"));
   1095         assertEquals("Effect StartTime", 5000, effectColor5.getStartTime());
   1096         assertEquals("Effect EndTime", 1000, effectColor5.getDuration());
   1097         assertEquals("Effect Type", EffectColor.TYPE_GRADIENT,
   1098             effectColor5.getType());
   1099         assertEquals("Effect Color", EffectColor.GRAY, effectColor5.getColor());
   1100 
   1101         final EffectColor effectColor6 = mVideoEditorHelper.createEffectItem(
   1102             mediaVideoItem1, "effect6", 6000, 1000,
   1103             EffectColor.TYPE_GRADIENT, EffectColor.GREEN);
   1104         mediaVideoItem1.addEffect(effectColor6);
   1105 
   1106         assertEquals("Associated Media Item", mediaVideoItem1,
   1107             effectColor6.getMediaItem());
   1108         assertTrue("Effect Id", effectColor6.getId().equals("effect6"));
   1109         assertEquals("Effect StartTime", 6000, effectColor6.getStartTime());
   1110         assertEquals("Effect EndTime", 1000, effectColor6.getDuration());
   1111         assertEquals("Effect Type",
   1112             EffectColor.TYPE_GRADIENT, effectColor6.getType());
   1113         assertEquals("Effect Color",
   1114             EffectColor.GREEN, effectColor6.getColor());
   1115 
   1116         final EffectColor effectColor7 = mVideoEditorHelper.createEffectItem(
   1117             mediaVideoItem1, "effect7", 7000, 1000,
   1118             EffectColor.TYPE_FIFTIES, 0);
   1119         mediaVideoItem1.addEffect(effectColor7);
   1120 
   1121         assertEquals("Associated Media Item", mediaVideoItem1,
   1122             effectColor7.getMediaItem());
   1123         assertTrue("Effect Id", effectColor7.getId().equals("effect7"));
   1124         assertEquals("Effect StartTime", 7000, effectColor7.getStartTime());
   1125         assertEquals("Effect EndTime", 1000, effectColor7.getDuration());
   1126         assertEquals("Effect Type", EffectColor.TYPE_FIFTIES,
   1127             effectColor7.getType());
   1128         assertEquals("Effect Color", -1, effectColor7.getColor());
   1129 
   1130         final EffectColor effectColor8 = mVideoEditorHelper.createEffectItem(
   1131             mediaVideoItem1, "effect8", 8000, 1000, EffectColor.TYPE_SEPIA, 0);
   1132         mediaVideoItem1.addEffect(effectColor8);
   1133 
   1134         assertEquals("Associated Media Item", mediaVideoItem1,
   1135             effectColor8.getMediaItem());
   1136         assertTrue("Effect Id", effectColor8.getId().equals("effect8"));
   1137         assertEquals("Effect StartTime", 8000, effectColor8.getStartTime());
   1138         assertEquals("Effect EndTime", 1000, effectColor8.getDuration());
   1139         assertEquals("Effect Type", EffectColor.TYPE_SEPIA,
   1140             effectColor8.getType());
   1141         assertEquals("Effect Color", -1, effectColor8.getColor());
   1142 
   1143         final EffectColor effectColor9 = mVideoEditorHelper.createEffectItem(
   1144             mediaVideoItem1, "effect9", 9000, 1000,
   1145             EffectColor.TYPE_NEGATIVE, 0);
   1146         mediaVideoItem1.addEffect(effectColor9);
   1147 
   1148         assertEquals("Associated Media Item", mediaVideoItem1,
   1149             effectColor9.getMediaItem());
   1150         assertTrue("Effect Id", effectColor9.getId().equals("effect9"));
   1151         assertEquals("Effect StartTime", 9000, effectColor9.getStartTime());
   1152         assertEquals("Effect EndTime", 1000, effectColor9.getDuration());
   1153         assertEquals("Effect Type", EffectColor.TYPE_NEGATIVE,
   1154             effectColor9.getType());
   1155         assertEquals("Effect Color", -1, effectColor9.getColor());
   1156         try {
   1157             mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect9",
   1158                 9000, 1000, EffectColor.TYPE_COLOR - 1, 0);
   1159         } catch (IllegalArgumentException e) {
   1160             flagForException = true;
   1161         }
   1162         assertTrue("Effect type Invalid", flagForException);
   1163         flagForException = false;
   1164         try {
   1165             mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect9",
   1166                 9000, 1000, EffectColor.TYPE_FIFTIES + 1, 0);
   1167         } catch (IllegalArgumentException e) {
   1168             flagForException = true;
   1169         }
   1170         assertTrue("Effect type Invalid", flagForException);
   1171         try {
   1172             mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect10",
   1173                 10000, 1000, EffectColor.TYPE_FIFTIES +
   1174                 EffectColor.TYPE_GRADIENT, 0);
   1175         } catch (IllegalArgumentException e) {
   1176             flagForException = true;
   1177         }
   1178         assertTrue("Effect type Invalid", flagForException);
   1179     }
   1180 
   1181     /**
   1182      * To test Effect Color : Set duration and Get Duration
   1183      */
   1184     @LargeTest
   1185     public void testEffectSetgetDuration() throws Exception {
   1186         final String videoItemFileName = INPUT_FILE_PATH +
   1187             "MPEG4_SP_640x480_30fps_512Kbps_0_27.mp4";
   1188         final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
   1189         boolean flagForException = false;
   1190         final MediaVideoItem mediaVideoItem1 =
   1191             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
   1192             videoItemFileName, videoItemRenderingMode);
   1193         mVideoEditor.addMediaItem(mediaVideoItem1);
   1194 
   1195         final EffectColor effectColor1 = mVideoEditorHelper.createEffectItem(
   1196             mediaVideoItem1, "effect1", 1000, 2000,
   1197             EffectColor.TYPE_COLOR, EffectColor.PINK);
   1198         mediaVideoItem1.addEffect(effectColor1);
   1199 
   1200         effectColor1.setDuration(5000);
   1201         assertEquals("Updated Effect Duration", 5000,
   1202             effectColor1.getDuration());
   1203         try {
   1204             effectColor1.setDuration(mediaVideoItem1.getDuration() + 1000);
   1205         } catch (IllegalArgumentException e) {
   1206             flagForException = true;
   1207         }
   1208         assertTrue("Effect Color duration > mediaVideoItemDuration",
   1209             flagForException);
   1210         assertEquals("Effect Duration", 5000, effectColor1.getDuration());
   1211         flagForException = false;
   1212         try {
   1213             effectColor1.setDuration(-1);
   1214         } catch (IllegalArgumentException e) {
   1215             flagForException = true;
   1216         }
   1217         assertTrue("Effect Color duration = -1", flagForException);
   1218     }
   1219 
   1220     /**
   1221      * To test Effect Color : UNDEFINED color param value
   1222      */
   1223     @LargeTest
   1224     public void testEffectUndefinedColorParam() throws Exception {
   1225         final String videoItemFileName = INPUT_FILE_PATH +
   1226             "MPEG4_SP_640x480_30fps_512Kbps_0_27.mp4";
   1227         final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
   1228         boolean flagForException = false;
   1229         final MediaVideoItem mediaVideoItem1 =
   1230             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
   1231             videoItemFileName, videoItemRenderingMode);
   1232         mVideoEditor.addMediaItem(mediaVideoItem1);
   1233         try{
   1234         mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect1", 1000,
   1235             2000, EffectColor.TYPE_COLOR, 0xabcdabcd);
   1236         }catch (IllegalArgumentException e){
   1237             flagForException = true;
   1238         }
   1239         assertTrue("Invalid Effect added",flagForException);
   1240     }
   1241 
   1242     /**
   1243      * To test Effect Color : with Invalid StartTime and Duration
   1244      */
   1245     @LargeTest
   1246     public void testEffectInvalidStartTimeAndDuration() throws Exception {
   1247         final String videoItemFileName = INPUT_FILE_PATH +
   1248             "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_32kbps_m_1_17.3gp";
   1249         final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
   1250         boolean flagForException = false;
   1251         final MediaVideoItem mediaVideoItem1 =
   1252             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
   1253             videoItemFileName, videoItemRenderingMode);
   1254         mVideoEditor.addMediaItem(mediaVideoItem1);
   1255 
   1256         try {
   1257             mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect1",
   1258                 400000000, 2000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
   1259         } catch (IllegalArgumentException e) {
   1260             flagForException = true;
   1261         }
   1262         assertTrue("Effect with invalid StartTime", flagForException);
   1263 
   1264         flagForException = false;
   1265         try {
   1266             mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect1", -1,
   1267                 2000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
   1268         } catch (IllegalArgumentException e) {
   1269             flagForException = true;
   1270         }
   1271         assertTrue("Effect with invalid StartTime", flagForException);
   1272 
   1273         flagForException = false;
   1274         try {
   1275             mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect1",
   1276                 2000, -1, EffectColor.TYPE_COLOR, EffectColor.GREEN);
   1277         } catch (IllegalArgumentException e) {
   1278             flagForException = true;
   1279         }
   1280         assertTrue("Effect with invalid Duration", flagForException);
   1281     }
   1282 
   1283 
   1284     /** Test cases 29, 30, 31, 32 and 33 are removed */
   1285 
   1286 
   1287     /**
   1288      * To test Effect : with NULL Media Item
   1289      */
   1290     @LargeTest
   1291     public void testEffectNullMediaItem() throws Exception {
   1292         boolean flagForException = false;
   1293         try {
   1294             mVideoEditorHelper.createEffectItem(null, "effect1", 1000, 4000,
   1295                 EffectColor.TYPE_COLOR, EffectColor.GREEN);
   1296         } catch (IllegalArgumentException e) {
   1297             flagForException = true;
   1298         }
   1299         assertTrue("Effect with null MediaItem", flagForException);
   1300     }
   1301 
   1302     /**
   1303      * To test Effect : KenBurn Effect
   1304      */
   1305     @LargeTest
   1306     public void testEffectKenBurn() throws Exception {
   1307         // Test ken burn effect using a JPEG file.
   1308         testEffectKenBurn(INPUT_FILE_PATH + "IMG_640x480.jpg",
   1309          "mediaImageItem1");
   1310 
   1311         // Test ken burn effect using a PNG file
   1312         testEffectKenBurn(INPUT_FILE_PATH + "IMG_640x480.png",
   1313          "mediaImageItem2");
   1314     }
   1315 
   1316     private void testEffectKenBurn(final String imageItemFileName,
   1317      final String MediaId) throws Exception {
   1318         final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
   1319         final MediaImageItem mediaImageItem =
   1320             mVideoEditorHelper.createMediaItem(mVideoEditor, MediaId,
   1321             imageItemFileName, 5000, imageItemRenderingMode);
   1322         mVideoEditor.addMediaItem(mediaImageItem);
   1323 
   1324         final Rect startRect = new Rect((mediaImageItem.getHeight() / 3),
   1325             (mediaImageItem.getWidth() / 3), (mediaImageItem.getHeight() / 2),
   1326             (mediaImageItem.getWidth() / 2));
   1327         final Rect endRect = new Rect(0, 0, mediaImageItem.getWidth(),
   1328             mediaImageItem.getHeight());
   1329 
   1330         final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
   1331             mediaImageItem, "KBOnM2", startRect, endRect, 500, 3000);
   1332 
   1333         assertNotNull("EffectKenBurns: " + imageItemFileName,
   1334             kbEffectOnMediaItem);
   1335 
   1336         mediaImageItem.addEffect(kbEffectOnMediaItem);
   1337         assertEquals("KenBurn Start Rect: " + imageItemFileName, startRect,
   1338             kbEffectOnMediaItem.getStartRect());
   1339 
   1340         assertEquals("KenBurn End Rect: " + imageItemFileName, endRect,
   1341             kbEffectOnMediaItem.getEndRect());
   1342     }
   1343 
   1344     /**
   1345      * To test KenBurnEffect : Set StartRect and EndRect
   1346      */
   1347 
   1348     @LargeTest
   1349     public void testEffectKenBurnSet() throws Exception {
   1350         final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
   1351         final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
   1352         boolean flagForException = false;
   1353         final MediaImageItem mediaImageItem =
   1354             mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
   1355             imageItemFileName, 5000, imageItemRenderingMode);
   1356         mVideoEditor.addMediaItem(mediaImageItem);
   1357 
   1358         final Rect startRect = new Rect((mediaImageItem.getHeight() / 3),
   1359             (mediaImageItem.getWidth() / 3), (mediaImageItem.getHeight() / 2),
   1360             (mediaImageItem.getWidth() / 2));
   1361         final Rect endRect = new Rect(0, 0, mediaImageItem.getWidth(),
   1362             mediaImageItem.getHeight());
   1363 
   1364         EffectKenBurns kbEffectOnMediaItem=null;
   1365         kbEffectOnMediaItem = new EffectKenBurns(mediaImageItem, "KBOnM2",
   1366             startRect, endRect, 500, 3000);
   1367 
   1368         assertNotNull("EffectKenBurns", kbEffectOnMediaItem);
   1369         mediaImageItem.addEffect(kbEffectOnMediaItem);
   1370         assertEquals("KenBurn Start Rect", startRect,
   1371             kbEffectOnMediaItem.getStartRect());
   1372         assertEquals("KenBurn End Rect", endRect,
   1373             kbEffectOnMediaItem.getEndRect());
   1374 
   1375         final Rect startRect1 = new Rect((mediaImageItem.getHeight() / 5),
   1376             (mediaImageItem.getWidth() / 5), (mediaImageItem.getHeight() / 4),
   1377             (mediaImageItem.getWidth() / 4));
   1378         final Rect endRect1 = new Rect(10, 10, mediaImageItem.getWidth() / 4,
   1379             mediaImageItem.getHeight() / 4);
   1380 
   1381         /* Added newly to take care of removal set APIs */
   1382         kbEffectOnMediaItem = new EffectKenBurns(mediaImageItem, "KBOnM2_changed",
   1383             startRect1, endRect1, 500, 3000);
   1384 
   1385         assertEquals("KenBurn Start Rect", startRect1,
   1386             kbEffectOnMediaItem.getStartRect());
   1387         assertEquals("KenBurn End Rect", endRect1,
   1388             kbEffectOnMediaItem.getEndRect());
   1389 
   1390         final Rect zeroRect = new Rect(0, 0, 0, 0);
   1391         try {
   1392             kbEffectOnMediaItem = new EffectKenBurns(mediaImageItem, "KBOnM2_zeroStart",
   1393                 zeroRect, endRect, 500, 3000);
   1394 
   1395         } catch (IllegalArgumentException e) {
   1396             flagForException = true;
   1397         }
   1398         assertTrue("Invalid Start Rect", flagForException);
   1399 
   1400         flagForException = false;
   1401         try {
   1402             kbEffectOnMediaItem = new EffectKenBurns(mediaImageItem, "KBOnM2_zeroEnd",
   1403                 startRect, zeroRect, 500, 3000);
   1404         } catch (IllegalArgumentException e) {
   1405             flagForException = true;
   1406         }
   1407         assertTrue("Invalid End Rect", flagForException);
   1408     }
   1409 
   1410     /**
   1411      * To test Transition : Fade To Black with all behavior
   1412      * SPEED_UP/SPEED_DOWN/LINEAR/MIDDLE_SLOW/MIDDLE_FAST
   1413      */
   1414 
   1415     @LargeTest
   1416     public void testTransitionFadeBlack() throws Exception {
   1417 
   1418         final String videoItemFilename1 = INPUT_FILE_PATH +
   1419             "H264_BP_640x480_30fps_256kbps_1_17.mp4";
   1420         final String videoItemFilename2 = INPUT_FILE_PATH +
   1421             "H263_profile0_176x144_15fps_128kbps_1_35.3gp";
   1422         final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
   1423         final String videoItemFilename3 = INPUT_FILE_PATH +
   1424             "H264_BP_640x480_30fps_192kbps_1_5.mp4";
   1425         final String videoItemFilename4 = INPUT_FILE_PATH +
   1426             "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
   1427         final String videoItemFilename5 = INPUT_FILE_PATH +
   1428             "H263_profile0_176x144_10fps_96kbps_0_25.3gp";
   1429         boolean flagForException = false;
   1430 
   1431         final MediaVideoItem mediaVideoItem1 =
   1432             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   1433             videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1434         mediaVideoItem1.setExtractBoundaries(0, 15000);
   1435         mVideoEditor.addMediaItem(mediaVideoItem1);
   1436 
   1437         final MediaVideoItem mediaVideoItem2 =
   1438             mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
   1439             videoItemFilename2, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1440         mediaVideoItem2.setExtractBoundaries(0, 15000);
   1441         mVideoEditor.addMediaItem(mediaVideoItem2);
   1442 
   1443         final TransitionFadeBlack transition1And2 = mVideoEditorHelper
   1444             .createTFadeBlack("transition1And2", mediaVideoItem1,
   1445             mediaVideoItem2, 3000, Transition.BEHAVIOR_SPEED_UP);
   1446         mVideoEditor.addTransition(transition1And2);
   1447 
   1448         assertTrue("Transition ID",
   1449             transition1And2.getId().equals("transition1And2"));
   1450         assertEquals("Transtion After Media item",
   1451             mediaVideoItem1, transition1And2.getAfterMediaItem());
   1452         assertEquals("Transtion Before Media item", mediaVideoItem2,
   1453             transition1And2.getBeforeMediaItem());
   1454         assertEquals("Transtion Duration", 3000, transition1And2.getDuration());
   1455         assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_UP,
   1456             transition1And2.getBehavior());
   1457 
   1458         final MediaImageItem mediaImageItem3 =
   1459             mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
   1460                 imageItemFilename1, 15000, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1461         mVideoEditor.addMediaItem(mediaImageItem3);
   1462 
   1463         final TransitionFadeBlack transition2And3 =
   1464             mVideoEditorHelper.createTFadeBlack("transition2And3", mediaVideoItem2,
   1465                 mediaImageItem3, 1000, Transition.BEHAVIOR_SPEED_DOWN);
   1466         mVideoEditor.addTransition(transition2And3);
   1467 
   1468         assertTrue("Transition ID",
   1469             transition2And3.getId().equals("transition2And3"));
   1470         assertEquals("Transtion After Media item", mediaVideoItem2,
   1471             transition2And3.getAfterMediaItem());
   1472         assertEquals("Transtion Before Media item", mediaImageItem3,
   1473             transition2And3.getBeforeMediaItem());
   1474         assertEquals("Transtion Duration", 1000, transition2And3.getDuration());
   1475         assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_DOWN,
   1476             transition2And3.getBehavior());
   1477 
   1478         final MediaVideoItem mediaVideoItem4 =
   1479             mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
   1480                 videoItemFilename3, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1481         mediaVideoItem4.setExtractBoundaries(0, 20000);
   1482         mVideoEditor.addMediaItem(mediaVideoItem4);
   1483 
   1484         final TransitionFadeBlack transition3And4 =
   1485             mVideoEditorHelper.createTFadeBlack("transition3And4", mediaImageItem3,
   1486                 mediaVideoItem4, 5000, Transition.BEHAVIOR_LINEAR);
   1487         mVideoEditor.addTransition(transition3And4);
   1488 
   1489         assertTrue("Transition ID",
   1490             transition3And4.getId().equals("transition3And4"));
   1491         assertEquals("Transtion After Media item", mediaImageItem3,
   1492             transition3And4.getAfterMediaItem());
   1493         assertEquals("Transtion Before Media item", mediaVideoItem4,
   1494             transition3And4.getBeforeMediaItem());
   1495         assertEquals("Transtion Duration", 5000, transition3And4.getDuration());
   1496         assertEquals("Transtion Behavior", Transition.BEHAVIOR_LINEAR,
   1497             transition3And4.getBehavior());
   1498 
   1499         final MediaVideoItem mediaVideoItem5 =
   1500             mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
   1501                 videoItemFilename4, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1502         mVideoEditor.addMediaItem(mediaVideoItem5);
   1503 
   1504         final TransitionFadeBlack transition4And5 =
   1505             mVideoEditorHelper.createTFadeBlack("transition4And5", mediaVideoItem4,
   1506                 mediaVideoItem5, 8000, Transition.BEHAVIOR_MIDDLE_FAST);
   1507         mVideoEditor.addTransition(transition4And5);
   1508 
   1509         assertTrue("Transition ID",
   1510             transition4And5.getId().equals("transition4And5"));
   1511         assertEquals("Transtion After Media item", mediaVideoItem4,
   1512             transition4And5.getAfterMediaItem());
   1513         assertEquals("Transtion Before Media item", mediaVideoItem5,
   1514             transition4And5.getBeforeMediaItem());
   1515         assertEquals("Transtion Duration", 8000, transition4And5.getDuration());
   1516         assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_FAST,
   1517             transition4And5.getBehavior());
   1518 
   1519         final MediaVideoItem mediaVideoItem6 =
   1520             mVideoEditorHelper.createMediaItem(mVideoEditor, "m6",
   1521                 videoItemFilename5, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1522         mediaVideoItem6.setExtractBoundaries(0, 20000);
   1523         mVideoEditor.addMediaItem(mediaVideoItem6);
   1524 
   1525         final TransitionFadeBlack transition5And6 =
   1526             mVideoEditorHelper.createTFadeBlack("transition5And6", mediaVideoItem5,
   1527                 mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_SLOW);
   1528         mVideoEditor.addTransition(transition5And6);
   1529 
   1530         assertTrue("Transition ID",
   1531             transition5And6.getId().equals("transition5And6"));
   1532         assertEquals("Transtion After Media item", mediaVideoItem5,
   1533             transition5And6.getAfterMediaItem());
   1534         assertEquals("Transtion Before Media item", mediaVideoItem6,
   1535             transition5And6.getBeforeMediaItem());
   1536         assertEquals("Transtion Duration", 2000, transition5And6.getDuration());
   1537         assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_SLOW,
   1538             transition5And6.getBehavior());
   1539         flagForException = false;
   1540         try {
   1541             mVideoEditorHelper.createTFadeBlack("transitiond6", mediaVideoItem5,
   1542                 mediaVideoItem6, 2000, Transition.BEHAVIOR_SPEED_UP - 1);
   1543         } catch (IllegalArgumentException e) {
   1544             flagForException = true;
   1545         }
   1546         assertTrue("Transition FadeBlack with Invalid behavior", flagForException);
   1547         flagForException = false;
   1548         try {
   1549             mVideoEditorHelper.createTFadeBlack("transitiond6", mediaVideoItem5,
   1550                 mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_FAST + 1);
   1551         } catch (IllegalArgumentException e) {
   1552             flagForException = true;
   1553         }
   1554         assertTrue("Transition FadeBlack with Invalid behavior", flagForException);
   1555     }
   1556 
   1557     /**
   1558      * To test Transition : CrossFade with all behavior
   1559      * SPEED_UP/SPEED_DOWN/LINEAR/MIDDLE_SLOW/MIDDLE_FAST
   1560      */
   1561 
   1562     @LargeTest
   1563     public void testTransitionCrossFade() throws Exception {
   1564 
   1565         final String videoItemFilename1 = INPUT_FILE_PATH +
   1566             "H264_BP_640x480_30fps_256kbps_1_17.mp4";
   1567         final String videoItemFilename2 = INPUT_FILE_PATH +
   1568             "H263_profile0_176x144_15fps_128kbps_1_35.3gp";
   1569         final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
   1570         final String videoItemFilename3 = INPUT_FILE_PATH +
   1571             "H264_BP_640x480_30fps_192kbps_1_5.mp4";
   1572         final String videoItemFilename4 = INPUT_FILE_PATH +
   1573             "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
   1574         final String videoItemFilename5 = INPUT_FILE_PATH +
   1575             "H263_profile0_176x144_10fps_96kbps_0_25.3gp";
   1576         boolean flagForException = false;
   1577         final MediaVideoItem mediaVideoItem1 =
   1578             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   1579                 videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1580         mediaVideoItem1.setExtractBoundaries(0, 15000);
   1581         mVideoEditor.addMediaItem(mediaVideoItem1);
   1582 
   1583         final MediaVideoItem mediaVideoItem2 =
   1584             mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
   1585                 videoItemFilename2, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1586         mediaVideoItem2.setExtractBoundaries(0, 15000);
   1587         mVideoEditor.addMediaItem(mediaVideoItem2);
   1588 
   1589         final TransitionCrossfade transition1And2 =
   1590             mVideoEditorHelper.createTCrossFade("transition1And2", mediaVideoItem1,
   1591                 mediaVideoItem2, 3000, Transition.BEHAVIOR_SPEED_UP);
   1592         mVideoEditor.addTransition(transition1And2);
   1593 
   1594         assertTrue("Transition ID",
   1595             transition1And2.getId().equals("transition1And2"));
   1596         assertEquals("Transtion After Media item", mediaVideoItem1,
   1597             transition1And2.getAfterMediaItem());
   1598         assertEquals("Transtion Before Media item", mediaVideoItem2,
   1599             transition1And2.getBeforeMediaItem());
   1600         assertEquals("Transtion Duration", 3000, transition1And2.getDuration());
   1601         assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_UP,
   1602             transition1And2.getBehavior());
   1603 
   1604         final MediaImageItem mediaImageItem3 =
   1605             mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
   1606                 imageItemFilename1, 15000, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1607         mVideoEditor.addMediaItem(mediaImageItem3);
   1608 
   1609         final TransitionCrossfade transition2And3 =
   1610             mVideoEditorHelper.createTCrossFade("transition2And3", mediaVideoItem2,
   1611                 mediaImageItem3, 1000, Transition.BEHAVIOR_SPEED_DOWN);
   1612         mVideoEditor.addTransition(transition2And3);
   1613 
   1614         assertTrue("Transition ID",
   1615             transition2And3.getId().equals("transition2And3"));
   1616         assertEquals("Transtion After Media item", mediaVideoItem2,
   1617             transition2And3.getAfterMediaItem());
   1618         assertEquals("Transtion Before Media item", mediaImageItem3,
   1619             transition2And3.getBeforeMediaItem());
   1620         assertEquals("Transtion Duration", 1000, transition2And3.getDuration());
   1621         assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_DOWN,
   1622             transition2And3.getBehavior());
   1623 
   1624         final MediaVideoItem mediaVideoItem4 =
   1625             mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
   1626                 videoItemFilename3, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1627         mediaVideoItem4.setExtractBoundaries(0, 18000);
   1628         mVideoEditor.addMediaItem(mediaVideoItem4);
   1629 
   1630         final TransitionCrossfade transition3And4 =
   1631             mVideoEditorHelper.createTCrossFade("transition3And4", mediaImageItem3,
   1632                 mediaVideoItem4, 5000, Transition.BEHAVIOR_LINEAR);
   1633         mVideoEditor.addTransition(transition3And4);
   1634 
   1635         assertTrue("Transition ID",
   1636             transition3And4.getId().equals("transition3And4"));
   1637         assertEquals("Transtion After Media item", mediaImageItem3,
   1638             transition3And4.getAfterMediaItem());
   1639         assertEquals("Transtion Before Media item", mediaVideoItem4,
   1640             transition3And4.getBeforeMediaItem());
   1641         assertEquals("Transtion Duration", 5000, transition3And4.getDuration());
   1642         assertEquals("Transtion Behavior", Transition.BEHAVIOR_LINEAR,
   1643             transition3And4.getBehavior());
   1644 
   1645         final MediaVideoItem mediaVideoItem5 =
   1646             mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
   1647                 videoItemFilename4, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1648         mVideoEditor.addMediaItem(mediaVideoItem5);
   1649 
   1650         final TransitionCrossfade transition4And5 =
   1651             mVideoEditorHelper.createTCrossFade("transition4And5", mediaVideoItem4,
   1652                 mediaVideoItem5, 8000, Transition.BEHAVIOR_MIDDLE_FAST);
   1653         mVideoEditor.addTransition(transition4And5);
   1654 
   1655         assertTrue("Transition ID",
   1656             transition4And5.getId().equals("transition4And5"));
   1657         assertEquals("Transtion After Media item", mediaVideoItem4,
   1658             transition4And5.getAfterMediaItem());
   1659         assertEquals("Transtion Before Media item", mediaVideoItem5,
   1660             transition4And5.getBeforeMediaItem());
   1661         assertEquals("Transtion Duration", 8000, transition4And5.getDuration());
   1662         assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_FAST,
   1663             transition4And5.getBehavior());
   1664 
   1665         final MediaVideoItem mediaVideoItem6 =
   1666             mVideoEditorHelper.createMediaItem(mVideoEditor, "m6",
   1667                 videoItemFilename5, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1668         mediaVideoItem6.setExtractBoundaries(0, 20000);
   1669         mVideoEditor.addMediaItem(mediaVideoItem6);
   1670 
   1671         final TransitionCrossfade transition5And6 =
   1672             mVideoEditorHelper.createTCrossFade("transition5And6", mediaVideoItem5,
   1673                 mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_SLOW);
   1674         mVideoEditor.addTransition(transition5And6);
   1675 
   1676         assertTrue("Transition ID",
   1677             transition5And6.getId().equals("transition5And6"));
   1678         assertEquals("Transtion After Media item", mediaVideoItem5,
   1679             transition5And6.getAfterMediaItem());
   1680         assertEquals("Transtion Before Media item", mediaVideoItem6,
   1681             transition5And6.getBeforeMediaItem());
   1682         assertEquals("Transtion Duration", 2000, transition5And6.getDuration());
   1683         assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_SLOW,
   1684             transition5And6.getBehavior());
   1685 
   1686         flagForException = false;
   1687         try {
   1688             mVideoEditorHelper.createTCrossFade("transitiond6", mediaVideoItem5,
   1689                 mediaVideoItem6, 2000, Transition.BEHAVIOR_SPEED_UP - 1);
   1690         } catch (IllegalArgumentException e) {
   1691             flagForException = true;
   1692         }
   1693         assertTrue("Transition FadeBlack with Invalid behavior", flagForException);
   1694         flagForException = false;
   1695         try {
   1696             mVideoEditorHelper.createTCrossFade("transitiond6", mediaVideoItem5,
   1697                 mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_FAST + 1);
   1698         } catch (IllegalArgumentException e) {
   1699             flagForException = true;
   1700         }
   1701         assertTrue("Transition FadeBlack with Invalid behavior", flagForException);
   1702     }
   1703 
   1704     /**
   1705      * To test Transition : Sliding with all behavior
   1706      * SPEED_UP/SPEED_DOWN/LINEAR/MIDDLE_SLOW/MIDDLE_FAST and Direction =
   1707      * DIRECTION_RIGHT_OUT_LEFT_IN
   1708      * ,DIRECTION_LEFT_OUT_RIGHT_IN,DIRECTION_TOP_OUT_BOTTOM_IN
   1709      * ,DIRECTION_BOTTOM_OUT_TOP_IN
   1710      */
   1711 
   1712     @LargeTest
   1713     public void testTransitionSliding() throws Exception {
   1714         final String videoItemFilename1 = INPUT_FILE_PATH +
   1715             "H264_BP_640x480_30fps_256kbps_1_17.mp4";
   1716         final String videoItemFilename2 = INPUT_FILE_PATH +
   1717             "H263_profile0_176x144_15fps_128kbps_1_35.3gp";
   1718         final String imageItemFilename1 = INPUT_FILE_PATH +
   1719             "IMG_1600x1200.jpg";
   1720         final String videoItemFilename3 = INPUT_FILE_PATH +
   1721             "H264_BP_640x480_30fps_192kbps_1_5.mp4";
   1722         final String videoItemFilename4 = INPUT_FILE_PATH +
   1723             "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
   1724         final String videoItemFilename5 = INPUT_FILE_PATH +
   1725             "H263_profile0_176x144_10fps_96kbps_0_25.3gp";
   1726         boolean flagForException = false;
   1727 
   1728         final MediaVideoItem mediaVideoItem1 =
   1729             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   1730                 videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1731         mediaVideoItem1.setExtractBoundaries(0, 15000);
   1732         mVideoEditor.addMediaItem(mediaVideoItem1);
   1733 
   1734         final MediaVideoItem mediaVideoItem2 =
   1735             mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
   1736                 videoItemFilename2, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1737         mediaVideoItem2.setExtractBoundaries(0, 15000);
   1738         mVideoEditor.addMediaItem(mediaVideoItem2);
   1739 
   1740         final TransitionSliding transition1And2 =
   1741             mVideoEditorHelper.createTSliding("transition1And2", mediaVideoItem1,
   1742                 mediaVideoItem2, 3000, Transition.BEHAVIOR_SPEED_UP,
   1743                 TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
   1744         mVideoEditor.addTransition(transition1And2);
   1745 
   1746         assertTrue("Transition ID",
   1747             transition1And2.getId().equals("transition1And2"));
   1748         assertEquals("Transtion After Media item", mediaVideoItem1,
   1749             transition1And2.getAfterMediaItem());
   1750         assertEquals("Transtion Before Media item", mediaVideoItem2,
   1751             transition1And2.getBeforeMediaItem());
   1752         assertEquals("Transtion Duration", 3000, transition1And2.getDuration());
   1753         assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_UP,
   1754             transition1And2.getBehavior());
   1755         assertEquals("Transition Sliding",
   1756             TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN,
   1757             transition1And2.getDirection());
   1758 
   1759         final MediaImageItem mediaImageItem3 =
   1760             mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
   1761                 imageItemFilename1, 15000, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1762         mVideoEditor.addMediaItem(mediaImageItem3);
   1763 
   1764         final TransitionSliding transition2And3 =
   1765             mVideoEditorHelper.createTSliding("transition2And3",
   1766                 mediaVideoItem2, mediaImageItem3, 1000,
   1767                 Transition.BEHAVIOR_SPEED_DOWN,
   1768                 TransitionSliding.DIRECTION_LEFT_OUT_RIGHT_IN);
   1769         mVideoEditor.addTransition(transition2And3);
   1770 
   1771         assertTrue("Transition ID",
   1772             transition2And3.getId().equals("transition2And3"));
   1773         assertEquals("Transtion After Media item", mediaVideoItem2,
   1774             transition2And3.getAfterMediaItem());
   1775         assertEquals("Transtion Before Media item", mediaImageItem3,
   1776             transition2And3.getBeforeMediaItem());
   1777         assertEquals("Transtion Duration", 1000, transition2And3.getDuration());
   1778         assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_DOWN,
   1779             transition2And3.getBehavior());
   1780         assertEquals("Transition Sliding",
   1781             TransitionSliding.DIRECTION_LEFT_OUT_RIGHT_IN,
   1782             transition2And3.getDirection());
   1783 
   1784         final MediaVideoItem mediaVideoItem4 =
   1785             mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
   1786                 videoItemFilename3, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1787         mediaVideoItem4.setExtractBoundaries(0, 18000);
   1788         mVideoEditor.addMediaItem(mediaVideoItem4);
   1789 
   1790         final TransitionSliding transition3And4 =
   1791             mVideoEditorHelper.createTSliding("transition3And4", mediaImageItem3,
   1792                 mediaVideoItem4, 5000, Transition.BEHAVIOR_LINEAR,
   1793                 TransitionSliding.DIRECTION_TOP_OUT_BOTTOM_IN);
   1794         mVideoEditor.addTransition(transition3And4);
   1795 
   1796         assertTrue("Transition ID",
   1797             transition3And4.getId().equals("transition3And4"));
   1798         assertEquals("Transtion After Media item", mediaImageItem3,
   1799             transition3And4.getAfterMediaItem());
   1800         assertEquals("Transtion Before Media item", mediaVideoItem4,
   1801             transition3And4.getBeforeMediaItem());
   1802         assertEquals("Transtion Duration", 5000, transition3And4.getDuration());
   1803         assertEquals("Transtion Behavior", Transition.BEHAVIOR_LINEAR,
   1804             transition3And4.getBehavior());
   1805         assertEquals("Transition Sliding",
   1806             TransitionSliding.DIRECTION_TOP_OUT_BOTTOM_IN,
   1807             transition3And4.getDirection());
   1808 
   1809         final MediaVideoItem mediaVideoItem5 =
   1810             mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
   1811                 videoItemFilename4, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1812         mVideoEditor.addMediaItem(mediaVideoItem5);
   1813 
   1814         final TransitionSliding transition4And5 =
   1815             mVideoEditorHelper.createTSliding("transition4And5", mediaVideoItem4,
   1816                 mediaVideoItem5, 8000, Transition.BEHAVIOR_MIDDLE_FAST,
   1817                 TransitionSliding.DIRECTION_BOTTOM_OUT_TOP_IN);
   1818         mVideoEditor.addTransition(transition4And5);
   1819 
   1820         assertTrue("Transition ID",
   1821             transition4And5.getId().equals("transition4And5"));
   1822         assertEquals("Transtion After Media item", mediaVideoItem4,
   1823             transition4And5.getAfterMediaItem());
   1824         assertEquals("Transtion Before Media item", mediaVideoItem5,
   1825             transition4And5.getBeforeMediaItem());
   1826         assertEquals("Transtion Duration", 8000, transition4And5.getDuration());
   1827         assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_FAST,
   1828             transition4And5.getBehavior());
   1829         assertEquals("Transition Sliding",
   1830             TransitionSliding.DIRECTION_BOTTOM_OUT_TOP_IN,
   1831             transition4And5.getDirection());
   1832 
   1833         final MediaVideoItem mediaVideoItem6 =
   1834             mVideoEditorHelper.createMediaItem(mVideoEditor, "m6",
   1835                 videoItemFilename5, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1836         mediaVideoItem6.setExtractBoundaries(0, 20000);
   1837         mVideoEditor.addMediaItem(mediaVideoItem6);
   1838 
   1839         final TransitionSliding transition5And6 =
   1840             mVideoEditorHelper.createTSliding("transition5And6", mediaVideoItem5,
   1841                 mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_SLOW,
   1842                 TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
   1843         mVideoEditor.addTransition(transition5And6);
   1844 
   1845         assertTrue("Transition ID",
   1846             transition5And6.getId().equals("transition5And6"));
   1847         assertEquals("Transtion After Media item", mediaVideoItem5,
   1848             transition5And6.getAfterMediaItem());
   1849         assertEquals("Transtion Before Media item", mediaVideoItem6,
   1850             transition5And6.getBeforeMediaItem());
   1851         assertEquals("Transtion Duration", 2000, transition5And6.getDuration());
   1852         assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_SLOW,
   1853             transition5And6.getBehavior());
   1854         assertEquals("Transition Sliding",
   1855             TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN,
   1856             transition5And6.getDirection());
   1857 
   1858         flagForException = false;
   1859         try {
   1860             mVideoEditorHelper.createTSliding("transitiond6", mediaVideoItem5,
   1861                 mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_SLOW,
   1862                 TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN - 1);
   1863         } catch (IllegalArgumentException e) {
   1864             flagForException = true;
   1865         }
   1866         assertTrue("Transition Sliding with Invalid Direction", flagForException);
   1867         flagForException = false;
   1868         try {
   1869             mVideoEditorHelper.createTSliding("transitiond6", mediaVideoItem5,
   1870                 mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_FAST + 1,
   1871                 TransitionSliding.DIRECTION_BOTTOM_OUT_TOP_IN + 1);
   1872         } catch (IllegalArgumentException e) {
   1873             flagForException = true;
   1874         }
   1875         assertTrue("Transition Sliding with Invalid behavior", flagForException);
   1876         flagForException = false;
   1877         try {
   1878             mVideoEditorHelper.createTSliding("transitiond6", mediaVideoItem5,
   1879                 mediaVideoItem6, 2000, Transition.BEHAVIOR_SPEED_UP - 1,
   1880                 TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
   1881         } catch (IllegalArgumentException e) {
   1882             flagForException = true;
   1883         }
   1884         assertTrue("Transition Sliding with Invalid behavior", flagForException);
   1885         flagForException = false;
   1886         try {
   1887             mVideoEditorHelper.createTSliding("transitiond6", mediaVideoItem5,
   1888                 mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_FAST + 1,
   1889                 TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
   1890         } catch (IllegalArgumentException e) {
   1891             flagForException = true;
   1892         }
   1893         assertTrue("Transition Sliding with Invalid behavior", flagForException);
   1894     }
   1895 
   1896     /**
   1897      * To test Transition : Alpha with all behavior
   1898      * SPEED_UP/SPEED_DOWN/LINEAR/MIDDLE_SLOW/MIDDLE_FAST
   1899      */
   1900 
   1901     @LargeTest
   1902     public void testTransitionAlpha() throws Exception {
   1903 
   1904         final String videoItemFilename1 = INPUT_FILE_PATH +
   1905             "H264_BP_640x480_30fps_256kbps_1_17.mp4";
   1906         final String videoItemFilename2 = INPUT_FILE_PATH +
   1907             "H263_profile0_176x144_15fps_128kbps_1_35.3gp";
   1908         final String imageItemFilename1 = INPUT_FILE_PATH +
   1909             "IMG_640x480.jpg";
   1910         final String videoItemFilename3 = INPUT_FILE_PATH +
   1911             "H264_BP_640x480_30fps_192kbps_1_5.mp4";
   1912         final String videoItemFilename4 = INPUT_FILE_PATH +
   1913             "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
   1914         final String videoItemFilename5 = INPUT_FILE_PATH +
   1915             "H263_profile0_176x144_10fps_96kbps_0_25.3gp";
   1916         final String maskFilename = INPUT_FILE_PATH +
   1917             "TransitionSpiral_QVGA.jpg";
   1918         boolean flagForException = false;
   1919         final MediaVideoItem mediaVideoItem1 =
   1920             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   1921                 videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1922         mediaVideoItem1.setExtractBoundaries(0, 15000);
   1923         mVideoEditor.addMediaItem(mediaVideoItem1);
   1924 
   1925         final MediaVideoItem mediaVideoItem2 =
   1926             mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
   1927                 videoItemFilename2, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1928         mediaVideoItem2.setExtractBoundaries(0, 15000);
   1929         mVideoEditor.addMediaItem(mediaVideoItem2);
   1930 
   1931         final TransitionAlpha transition1And2 =
   1932             mVideoEditorHelper.createTAlpha("transition1And2", mediaVideoItem1,
   1933             mediaVideoItem2, 3000, Transition.BEHAVIOR_SPEED_UP, maskFilename,
   1934             10, false);
   1935         mVideoEditor.addTransition(transition1And2);
   1936 
   1937         assertTrue("Transition ID",
   1938             transition1And2.getId().equals("transition1And2"));
   1939         assertEquals("Transtion After Media item", mediaVideoItem1,
   1940             transition1And2.getAfterMediaItem());
   1941         assertEquals("Transtion Before Media item", mediaVideoItem2,
   1942             transition1And2.getBeforeMediaItem());
   1943         assertEquals("Transtion Duration", 3000, transition1And2.getDuration());
   1944         assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_UP,
   1945             transition1And2.getBehavior());
   1946         assertTrue("Transition maskFile",
   1947             transition1And2.getMaskFilename().equals(maskFilename));
   1948         assertEquals("Transition BlendingPercent", 10,
   1949             transition1And2.getBlendingPercent());
   1950         assertFalse("Transition Invert", transition1And2.isInvert());
   1951 
   1952         final MediaImageItem mediaImageItem3 =
   1953             mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
   1954                 imageItemFilename1, 15000, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1955         mVideoEditor.addMediaItem(mediaImageItem3);
   1956 
   1957         final TransitionAlpha transition2And3 =
   1958             mVideoEditorHelper.createTAlpha("transition2And3", mediaVideoItem2,
   1959                 mediaImageItem3, 1000, Transition.BEHAVIOR_SPEED_DOWN,
   1960                 maskFilename, 30, false);
   1961         mVideoEditor.addTransition(transition2And3);
   1962 
   1963         assertTrue("Transition ID",
   1964             transition2And3.getId().equals("transition2And3"));
   1965         assertEquals("Transtion After Media item", mediaVideoItem2,
   1966             transition2And3.getAfterMediaItem());
   1967         assertEquals("Transtion Before Media item", mediaImageItem3,
   1968             transition2And3.getBeforeMediaItem());
   1969         assertEquals("Transtion Duration", 1000, transition2And3.getDuration());
   1970         assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_DOWN,
   1971             transition2And3.getBehavior());
   1972         assertTrue("Transition maskFile",
   1973             transition2And3.getMaskFilename().equals(maskFilename));
   1974         assertEquals("Transition BlendingPercent", 30,
   1975             transition2And3.getBlendingPercent());
   1976         assertFalse("Transition Invert", transition2And3.isInvert());
   1977 
   1978         final MediaVideoItem mediaVideoItem4 =
   1979             mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
   1980                 videoItemFilename3, MediaItem.RENDERING_MODE_BLACK_BORDER);
   1981         mediaVideoItem4.setExtractBoundaries(0, 18000);
   1982         mVideoEditor.addMediaItem(mediaVideoItem4);
   1983 
   1984         final TransitionAlpha transition3And4 =
   1985             mVideoEditorHelper.createTAlpha("transition3And4", mediaImageItem3,
   1986             mediaVideoItem4, 5000, Transition.BEHAVIOR_LINEAR, maskFilename,
   1987             50, false);
   1988         mVideoEditor.addTransition(transition3And4);
   1989 
   1990         assertTrue("Transition ID",
   1991             transition3And4.getId().equals("transition3And4"));
   1992         assertEquals("Transtion After Media item", mediaImageItem3,
   1993             transition3And4.getAfterMediaItem());
   1994         assertEquals("Transtion Before Media item", mediaVideoItem4,
   1995             transition3And4.getBeforeMediaItem());
   1996         assertEquals("Transtion Duration", 5000, transition3And4.getDuration());
   1997         assertEquals("Transtion Behavior", Transition.BEHAVIOR_LINEAR,
   1998             transition3And4.getBehavior());
   1999         assertTrue("Transition maskFile",
   2000             transition3And4.getMaskFilename().equals(maskFilename));
   2001         assertEquals("Transition BlendingPercent", 50,
   2002             transition3And4.getBlendingPercent());
   2003         assertFalse("Transition Invert", transition3And4.isInvert());
   2004 
   2005         final MediaVideoItem mediaVideoItem5 =
   2006             mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
   2007                 videoItemFilename4, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2008         mVideoEditor.addMediaItem(mediaVideoItem5);
   2009 
   2010         final TransitionAlpha transition4And5 =
   2011             mVideoEditorHelper.createTAlpha("transition4And5", mediaVideoItem4,
   2012             mediaVideoItem5, 8000, Transition.BEHAVIOR_MIDDLE_FAST,
   2013             maskFilename, 70, true);
   2014         mVideoEditor.addTransition(transition4And5);
   2015 
   2016         assertTrue("Transition ID",
   2017             transition4And5.getId().equals("transition4And5"));
   2018         assertEquals("Transtion After Media item", mediaVideoItem4,
   2019             transition4And5.getAfterMediaItem());
   2020         assertEquals("Transtion Before Media item", mediaVideoItem5,
   2021             transition4And5.getBeforeMediaItem());
   2022         assertEquals("Transtion Duration", 8000, transition4And5.getDuration());
   2023         assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_FAST,
   2024             transition4And5.getBehavior());
   2025         assertTrue("Transition maskFile",
   2026             transition4And5.getMaskFilename().equals(maskFilename));
   2027         assertEquals("Transition BlendingPercent", 70,
   2028             transition4And5.getBlendingPercent());
   2029         assertTrue("Transition Invert", transition4And5.isInvert());
   2030 
   2031         final MediaVideoItem mediaVideoItem6 =
   2032             mVideoEditorHelper.createMediaItem(mVideoEditor, "m6",
   2033                 videoItemFilename5, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2034         mediaVideoItem6.setExtractBoundaries(0, 20000);
   2035         mVideoEditor.addMediaItem(mediaVideoItem6);
   2036 
   2037         try {
   2038             mVideoEditorHelper.createTAlpha("transition5And6", mediaVideoItem5,
   2039                 mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_SLOW,
   2040                 INPUT_FILE_PATH + "imDummyFile.jpg", 70,
   2041                 true);
   2042         } catch (IllegalArgumentException e) {
   2043             flagForException = true;
   2044         }
   2045         assertTrue("MaskFile is not exsisting", flagForException);
   2046         flagForException = false;
   2047         try {
   2048             mVideoEditorHelper.createTAlpha("transition5And6", null, null, 2000,
   2049                 Transition.BEHAVIOR_MIDDLE_SLOW, maskFilename, 101, true);
   2050         } catch (IllegalArgumentException e) {
   2051             flagForException = true;
   2052         }
   2053         assertTrue("Invalid Blending Percent", flagForException);
   2054 
   2055         flagForException = false;
   2056         try {
   2057             mVideoEditorHelper.createTAlpha("transitiond6", mediaVideoItem4,
   2058                 mediaVideoItem5, 2000, Transition.BEHAVIOR_SPEED_UP - 1,
   2059                 maskFilename, 30, false);
   2060         } catch (IllegalArgumentException e) {
   2061             flagForException = true;
   2062         }
   2063         assertTrue("Transition FadeBlack with Invalid behavior", flagForException);
   2064         flagForException = false;
   2065         try {
   2066             mVideoEditorHelper.createTAlpha("transitiond6", mediaVideoItem4,
   2067                 mediaVideoItem5, 2000, Transition.BEHAVIOR_MIDDLE_FAST + 1,
   2068                 maskFilename, 30, false);
   2069         } catch (IllegalArgumentException e) {
   2070             flagForException = true;
   2071         }
   2072         assertTrue("Transition FadeBlack with Invalid behavior", flagForException);
   2073     }
   2074 
   2075     /**
   2076      * To test Frame Overlay for Media Video Item
   2077      */
   2078 
   2079     @LargeTest
   2080     public void testFrameOverlayVideoItem() throws Exception {
   2081         final String videoItemFilename1 = INPUT_FILE_PATH +
   2082             "H263_profile0_176x144_10fps_256kbps_0_25.3gp";
   2083         final String overlayFile1 = INPUT_FILE_PATH +  "IMG_176x144_Overlay1.png";
   2084         final String overlayFile2 = INPUT_FILE_PATH +  "IMG_176x144_Overlay2.png";
   2085         final MediaVideoItem mediaVideoItem1 =
   2086             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   2087                 videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2088         mVideoEditor.addMediaItem(mediaVideoItem1);
   2089 
   2090         final Bitmap mBitmap1 =  mVideoEditorHelper.getBitmap(overlayFile1,
   2091             176, 144);
   2092         final OverlayFrame overlayFrame1 = mVideoEditorHelper.createOverlay(
   2093             mediaVideoItem1, "overlayId1", mBitmap1, 5000, 5000);
   2094         mediaVideoItem1.addOverlay(overlayFrame1);
   2095 
   2096         assertEquals("Overlay : Media Item", mediaVideoItem1,
   2097             overlayFrame1.getMediaItem());
   2098         assertTrue("Overlay Id", overlayFrame1.getId().equals("overlayId1"));
   2099         assertEquals("Overlay Bitmap", mBitmap1, overlayFrame1.getBitmap());
   2100         assertEquals("Overlay Start Time", 5000, overlayFrame1.getStartTime());
   2101         assertEquals("Overlay Duration", 5000, overlayFrame1.getDuration());
   2102 
   2103         Bitmap upddateBmp = mVideoEditorHelper.getBitmap(overlayFile2, 176, 144);
   2104         overlayFrame1.setBitmap(upddateBmp);
   2105         assertEquals("Overlay Update Bitmap", upddateBmp, overlayFrame1.getBitmap());
   2106         upddateBmp.recycle();
   2107     }
   2108 
   2109     /**
   2110      * To test Frame Overlay for Media Video Item : Set duration and Get
   2111      * Duration
   2112      */
   2113 
   2114     @LargeTest
   2115     public void testFrameOverlaySetAndGet() throws Exception {
   2116         final String videoItemFilename1 = INPUT_FILE_PATH +
   2117             "MPEG4_SP_640x480_30fps_512Kbps_0_27.mp4";
   2118         final String overlayFile1 = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
   2119         boolean flagForException = false;
   2120 
   2121         final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
   2122             640, 480);
   2123 
   2124         final MediaVideoItem mediaVideoItem1 =
   2125             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   2126             videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2127         mVideoEditor.addMediaItem(mediaVideoItem1);
   2128 
   2129         final OverlayFrame overlayFrame1 = mVideoEditorHelper.createOverlay(
   2130             mediaVideoItem1, "overlayId1", mBitmap, 5000, 5000);
   2131         mediaVideoItem1.addOverlay(overlayFrame1);
   2132         overlayFrame1.setDuration(5000);
   2133 
   2134         assertEquals("Overlay Duration", 5000, overlayFrame1.getDuration());
   2135         try {
   2136             overlayFrame1.setDuration(mediaVideoItem1.getDuration() + 10000);
   2137         } catch (IllegalArgumentException e) {
   2138             flagForException = true;
   2139         }
   2140         assertTrue("Overlay Duration > MediaVideo Item Duration",
   2141             flagForException);
   2142 
   2143         assertEquals("Overlay Duration", 5000, overlayFrame1.getDuration());
   2144         flagForException = false;
   2145 
   2146         try {
   2147             overlayFrame1.setDuration(-1);
   2148         } catch (IllegalArgumentException e) {
   2149             flagForException = true;
   2150         }
   2151         assertTrue("Overlay Duration = -1", flagForException);
   2152     }
   2153 
   2154     /**
   2155      * To test Frame Overlay for Media Video Item : Set duration and Get
   2156      * Duration
   2157      */
   2158 
   2159     @LargeTest
   2160     public void testFrameOverlayInvalidTime() throws Exception {
   2161         final String videoItemFilename1 = INPUT_FILE_PATH +
   2162             "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
   2163         final String overlayFile1 = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
   2164         boolean flagForException = false;
   2165 
   2166         final MediaVideoItem mediaVideoItem1 =
   2167             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   2168                 videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2169         mVideoEditor.addMediaItem(mediaVideoItem1);
   2170 
   2171         try {
   2172             final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
   2173                 640, 480);
   2174             mVideoEditorHelper.createOverlay(mediaVideoItem1, "overlayId1",
   2175                 mBitmap, 400000000, 2000);
   2176         } catch (IllegalArgumentException e) {
   2177             flagForException = true;
   2178         }
   2179         assertTrue("Overlay With Invalid Start Time", flagForException);
   2180 
   2181         flagForException = false;
   2182         try {
   2183             final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
   2184                 640, 480);
   2185             mVideoEditorHelper.createOverlay(mediaVideoItem1, "overlayId2",
   2186                 mBitmap, -1, 2000);
   2187         } catch (IllegalArgumentException e) {
   2188             flagForException = true;
   2189         }
   2190         assertTrue("Overlay With Invalid Start Time", flagForException);
   2191 
   2192         flagForException = false;
   2193         try {
   2194             final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
   2195             640, 480);
   2196             mVideoEditorHelper.createOverlay(mediaVideoItem1, "overlayId3",
   2197                 mBitmap, 2000, -1);
   2198         } catch (IllegalArgumentException e) {
   2199             flagForException = true;
   2200         }
   2201         assertTrue("Overlay With Invalid Start Time", flagForException);
   2202     }
   2203 
   2204     /**
   2205      * To test Frame Overlay for Media Image Item
   2206      */
   2207     @LargeTest
   2208     public void testFrameOverlayImageItem() throws Exception {
   2209         final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_640x480.jpg";
   2210         final String overlayFile1 = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
   2211         final String overlayFile2 = INPUT_FILE_PATH + "IMG_640x480_Overlay2.png";
   2212 
   2213         final MediaImageItem mediaImageItem1 =
   2214             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   2215                 imageItemFilename1, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2216         mVideoEditor.addMediaItem(mediaImageItem1);
   2217 
   2218         final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1, 640,
   2219             480);
   2220         final OverlayFrame overlayFrame1 = mVideoEditorHelper.createOverlay(
   2221             mediaImageItem1, "overlayId1", mBitmap, 5000, 5000);
   2222         mediaImageItem1.addOverlay(overlayFrame1);
   2223 
   2224         assertEquals("Overlay : Media Item", mediaImageItem1,
   2225             overlayFrame1.getMediaItem());
   2226         assertTrue("Overlay Id", overlayFrame1.getId().equals("overlayId1"));
   2227         assertEquals("Overlay Bitmap",mBitmap ,overlayFrame1.getBitmap());
   2228         assertEquals("Overlay Start Time", 5000, overlayFrame1.getStartTime());
   2229         assertEquals("Overlay Duration", 5000, overlayFrame1.getDuration());
   2230         Bitmap upddateBmp = mVideoEditorHelper.getBitmap(overlayFile2, 640, 480);
   2231 
   2232         overlayFrame1.setBitmap(upddateBmp);
   2233         assertEquals("Overlay Update Bitmap", upddateBmp, overlayFrame1.getBitmap());
   2234         upddateBmp.recycle();
   2235     }
   2236 
   2237     /**
   2238      * To test Frame Overlay for Media Image Item : Set duration and Get
   2239      * Duration
   2240      */
   2241 
   2242     @LargeTest
   2243     public void testFrameOverlaySetAndGetImage() throws Exception {
   2244         final String videoItemFilename1 = INPUT_FILE_PATH + "IMG_640x480.jpg";
   2245         final String overlayFile1 = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
   2246         boolean flagForException = false;
   2247 
   2248         final MediaImageItem mediaImageItem1 =
   2249             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   2250                 videoItemFilename1, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2251         mVideoEditor.addMediaItem(mediaImageItem1);
   2252 
   2253         final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
   2254             640, 480);
   2255         final OverlayFrame overlayFrame1 = mVideoEditorHelper.createOverlay(
   2256             mediaImageItem1, "overlayId1", mBitmap, 5000, 5000);
   2257         mediaImageItem1.addOverlay(overlayFrame1);
   2258 
   2259         overlayFrame1.setDuration(5000);
   2260         assertEquals("Overlay Duration", 5000, overlayFrame1.getDuration());
   2261 
   2262         try {
   2263             overlayFrame1.setDuration(mediaImageItem1.getDuration() + 10000);
   2264         } catch (IllegalArgumentException e) {
   2265             flagForException = true;
   2266         }
   2267         assertTrue("Overlay Duration > Media Item Duration", flagForException);
   2268         assertEquals("Overlay Duration", 5000, overlayFrame1.getDuration());
   2269 
   2270         flagForException = false;
   2271         try {
   2272             overlayFrame1.setDuration(-1);
   2273         } catch (IllegalArgumentException e) {
   2274             flagForException = true;
   2275         }
   2276         assertTrue("Overlay Duration = -1", flagForException);
   2277     }
   2278 
   2279     /**
   2280      * To test  Frame Overlay for  Media Image Item :Invalid StartTime and
   2281      * Duration
   2282      */
   2283 
   2284     @LargeTest
   2285     public void testFrameOverlayInvalidTimeImage() throws Exception {
   2286         final String videoItemFilename1 = INPUT_FILE_PATH + "IMG_640x480.jpg";
   2287         final String overlayFile1 = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
   2288         boolean flagForException = false;
   2289 
   2290         final MediaImageItem mediaImageItem1 =
   2291             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   2292                 videoItemFilename1, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2293         mVideoEditor.addMediaItem(mediaImageItem1);
   2294 
   2295         try {
   2296             final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
   2297                 640, 480);
   2298             mVideoEditorHelper.createOverlay(mediaImageItem1, "overlayId1",
   2299                 mBitmap, 400000000, 2000);
   2300         } catch (IllegalArgumentException e) {
   2301             flagForException = true;
   2302         }
   2303         assertTrue("Overlay With Invalid Start Time", flagForException);
   2304 
   2305         flagForException = false;
   2306         try {
   2307             final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
   2308                 640, 480);
   2309             mVideoEditorHelper.createOverlay(mediaImageItem1, "overlayId2",
   2310                 mBitmap, -1, 2000);
   2311         } catch (IllegalArgumentException e) {
   2312             flagForException = true;
   2313         }
   2314         assertTrue("Overlay With Invalid Start Time", flagForException);
   2315 
   2316         flagForException = false;
   2317         try {
   2318             final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
   2319                 640, 480);
   2320             mVideoEditorHelper.createOverlay(mediaImageItem1, "overlayId3",
   2321                 mBitmap, 2000, -1);
   2322         } catch (IllegalArgumentException e) {
   2323             flagForException = true;
   2324         }
   2325         assertTrue("Overlay With Invalid Start Time", flagForException);
   2326     }
   2327 
   2328     /**
   2329      * To Test Frame Overlay Media Image Item :JPG File
   2330      */
   2331 
   2332     @LargeTest
   2333     public void testFrameOverlayJPGImage() throws Exception {
   2334 
   2335         final String imageItemFilename = INPUT_FILE_PATH + "IMG_640x480.jpg";
   2336         final String overlayFile1 = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
   2337         boolean flagForException = false;
   2338         final MediaImageItem mediaImageItem1 =
   2339             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   2340                 imageItemFilename, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2341         mVideoEditor.addMediaItem(mediaImageItem1);
   2342         final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1, 640,
   2343             480);
   2344         mVideoEditorHelper.createOverlay(mediaImageItem1, "overlayId1",
   2345             mBitmap, 5000, 5000);
   2346     }
   2347 
   2348     /**
   2349      * To test Video Editor API
   2350      *
   2351      * @throws Exception
   2352      */
   2353     @LargeTest
   2354     public void testVideoEditorAPI() throws Exception {
   2355 
   2356         final String videoItemFileName1 = INPUT_FILE_PATH
   2357             + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
   2358         final String videoItemFileName2 = INPUT_FILE_PATH +
   2359             "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
   2360         final String videoItemFileName3 = INPUT_FILE_PATH
   2361             + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
   2362         final String imageItemFileName1 = INPUT_FILE_PATH + "IMG_640x480.jpg";
   2363         final String imageItemFileName2 = INPUT_FILE_PATH + "IMG_176x144.jpg";
   2364         final String audioFilename1 = INPUT_FILE_PATH +
   2365             "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
   2366         final String audioFilename2 = INPUT_FILE_PATH +
   2367             "AACLC_48KHz_256Kbps_s_1_17.3gp";
   2368         final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
   2369         boolean flagForException = false;
   2370         TransitionCrossfade transition2And4;
   2371 
   2372         final MediaVideoItem mediaVideoItem1 =
   2373             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   2374                 videoItemFileName1, renderingMode);
   2375         mediaVideoItem1.setExtractBoundaries(0, 10000);
   2376         mVideoEditor.addMediaItem(mediaVideoItem1);
   2377 
   2378         final MediaVideoItem mediaVideoItem2 =
   2379             mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
   2380                 videoItemFileName2, renderingMode);
   2381         mediaVideoItem2.setExtractBoundaries(mediaVideoItem2.getDuration() / 4,
   2382             mediaVideoItem2.getDuration() / 2);
   2383         mVideoEditor.addMediaItem(mediaVideoItem2);
   2384 
   2385         final MediaVideoItem mediaVideoItem3 =
   2386             mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
   2387                 videoItemFileName3, renderingMode);
   2388         mediaVideoItem3.setExtractBoundaries(mediaVideoItem3.getDuration() / 2,
   2389             mediaVideoItem3.getDuration());
   2390         mVideoEditor.addMediaItem(mediaVideoItem3);
   2391 
   2392         final MediaImageItem mediaImageItem1 =
   2393             mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
   2394                 imageItemFileName1, 5000, renderingMode);
   2395 
   2396         final MediaImageItem mediaImageItem2 =
   2397             mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
   2398                 imageItemFileName2, 5000, renderingMode);
   2399 
   2400         List<MediaItem> mediaList = mVideoEditor.getAllMediaItems();
   2401         assertEquals("Media Item List Size", 3, mediaList.size());
   2402 
   2403         mVideoEditor.insertMediaItem(mediaImageItem1, mediaVideoItem2.getId());
   2404         mediaList = mVideoEditor.getAllMediaItems();
   2405         assertEquals("Media Item List Size", 4, mediaList.size());
   2406         assertEquals("Media item 1", mediaVideoItem1, mediaList.get(0));
   2407         assertEquals("Media item 2", mediaVideoItem2, mediaList.get(1));
   2408         assertEquals("Media item 4", mediaImageItem1, mediaList.get(2));
   2409         assertEquals("Media item 3", mediaVideoItem3, mediaList.get(3));
   2410 
   2411         mVideoEditor.insertMediaItem(mediaImageItem2, mediaImageItem1.getId());
   2412         mediaList = mVideoEditor.getAllMediaItems();
   2413         assertEquals("Media Item List Size", 5, mediaList.size());
   2414         assertEquals("Media item 1", mediaVideoItem1, mediaList.get(0));
   2415         assertEquals("Media item 2", mediaVideoItem2, mediaList.get(1));
   2416         assertEquals("Media item 4", mediaImageItem1, mediaList.get(2));
   2417         assertEquals("Media item 5", mediaImageItem2, mediaList.get(3));
   2418         assertEquals("Media item 3", mediaVideoItem3, mediaList.get(4));
   2419 
   2420         mVideoEditor.moveMediaItem(mediaVideoItem1.getId(), mediaImageItem2.getId());
   2421         mediaList = mVideoEditor.getAllMediaItems();
   2422         assertEquals("Media Item List Size", 5, mediaList.size());
   2423         assertEquals("Media item 2", mediaVideoItem2, mediaList.get(0));
   2424         assertEquals("Media item 4", mediaImageItem1, mediaList.get(1));
   2425         assertEquals("Media item 5", mediaImageItem2, mediaList.get(2));
   2426         assertEquals("Media item 1", mediaVideoItem1, mediaList.get(3));
   2427         assertEquals("Media item 3", mediaVideoItem3, mediaList.get(4));
   2428 
   2429         assertEquals("Media Item 1", mediaVideoItem1,
   2430             mVideoEditor.getMediaItem(mediaVideoItem1.getId()));
   2431 
   2432         flagForException = false;
   2433         transition2And4 = null;
   2434         try{
   2435             transition2And4 = mVideoEditorHelper.createTCrossFade(
   2436                 "transition2And4", mediaVideoItem2, mediaImageItem1, 2000,
   2437                 Transition.BEHAVIOR_MIDDLE_FAST);
   2438             mVideoEditor.addTransition(transition2And4);
   2439         }
   2440         catch (IllegalArgumentException e) {
   2441             flagForException = true;
   2442         }
   2443         assertFalse("Transition2and4 cannot be created", flagForException);
   2444 
   2445 
   2446         TransitionCrossfade transition1And3 = null;
   2447         flagForException = false;
   2448         try{
   2449             transition1And3 = mVideoEditorHelper.createTCrossFade(
   2450                 "transition1And3", mediaVideoItem1, mediaVideoItem2, 5000,
   2451                 Transition.BEHAVIOR_MIDDLE_FAST);
   2452                 mVideoEditor.addTransition(transition1And3);
   2453             }catch (IllegalArgumentException e) {
   2454                 flagForException = true;
   2455             }
   2456         assertTrue("Transition1and3 cannot be created", flagForException);
   2457 
   2458         List<Transition> transitionList = mVideoEditor.getAllTransitions();
   2459         assertEquals("Transition List", 1, transitionList.size());
   2460 
   2461         assertEquals("Transition 2", transition2And4,
   2462             mVideoEditor.getTransition(transition2And4.getId()));
   2463 
   2464         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
   2465             mVideoEditor, "audioTrack", audioFilename1);
   2466         mVideoEditor.addAudioTrack(audioTrack);
   2467 
   2468         List<AudioTrack> audioList = mVideoEditor.getAllAudioTracks();
   2469         assertEquals("Audio List", 1, audioList.size());
   2470 
   2471         final AudioTrack audioTrack1 = mVideoEditorHelper.createAudio(
   2472             mVideoEditor, "audioTrack1", audioFilename2);
   2473         flagForException = false;
   2474         try {
   2475             mVideoEditor.addAudioTrack(audioTrack1);
   2476         } catch (IllegalArgumentException e) {
   2477             flagForException = true;
   2478         }
   2479         assertTrue("Audio Track support is 1 ", flagForException);
   2480 
   2481         flagForException = false;
   2482         try {
   2483             mVideoEditor.insertAudioTrack(audioTrack1,"audioTrack");
   2484         } catch (IllegalArgumentException e) {
   2485             flagForException = true;
   2486         }
   2487         assertTrue("Audio Track supports is 1 ", flagForException);
   2488 
   2489         assertEquals("Removing AudioTrack", audioTrack,
   2490             mVideoEditor.removeAudioTrack(audioTrack.getId()));
   2491 
   2492         assertEquals("Removing transition", transition2And4,
   2493             mVideoEditor.removeTransition(transition2And4.getId()));
   2494 
   2495         assertEquals("Removing Media Item", mediaVideoItem2,
   2496             mVideoEditor.removeMediaItem(mediaVideoItem2.getId()));
   2497 
   2498         mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_16_9);
   2499         assertEquals("Check Aspect Ratio", MediaProperties.ASPECT_RATIO_16_9,
   2500             mVideoEditor.getAspectRatio());
   2501 
   2502         long storyBoardDuration = mediaVideoItem1.getTimelineDuration()
   2503             + mediaVideoItem3.getTimelineDuration()
   2504             + mediaImageItem1.getDuration()
   2505             + mediaImageItem2.getDuration();
   2506         assertEquals("Story Board Duration", storyBoardDuration,
   2507             mVideoEditor.getDuration());
   2508     }
   2509 
   2510     /**
   2511      * To add Audio Track Greater than MediaItem Duration
   2512      *
   2513      * @throws Exception
   2514      */
   2515     @LargeTest
   2516     public void testVideoLessThanAudio() throws Exception {
   2517         final String videoItemFileName1 = INPUT_FILE_PATH
   2518             + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
   2519         final String audioTrackFilename = INPUT_FILE_PATH +
   2520             "AACLC_48KHz_256Kbps_s_1_17.3gp";
   2521         final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
   2522 
   2523         final MediaVideoItem mediaVideoItem1 =
   2524             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   2525                 videoItemFileName1, renderingMode);
   2526         mVideoEditor.addMediaItem(mediaVideoItem1);
   2527         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
   2528             mVideoEditor, "audioTrackId", audioTrackFilename);
   2529         mVideoEditor.addAudioTrack(audioTrack);
   2530         assertEquals("Storyboard = mediaItem Duration",
   2531             mediaVideoItem1.getDuration(), mVideoEditor.getDuration());
   2532         assertTrue("Audio Duration > mediaItem Duration",
   2533             (audioTrack.getDuration() > mediaVideoItem1.getDuration() ?
   2534             true : false));
   2535     }
   2536 
   2537     /**
   2538      * To test Video Editor API with 1080 P
   2539      *
   2540      * @throws Exception
   2541      */
   2542     @LargeTest
   2543     public void testVideoContentHD() throws Exception {
   2544         final String videoItemFileName1 = INPUT_FILE_PATH
   2545             + "H264_BP_1920x1080_30fps_1200Kbps_1_10.mp4";
   2546         final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
   2547         final MediaVideoItem mediaVideoItem1;
   2548         // 1080p resolution is supported on some devices
   2549         // but not on other devices.
   2550         // So this test case is not generic and
   2551         // hence we always assert true
   2552         boolean flagForException = true;
   2553         try {
   2554             mediaVideoItem1 = mVideoEditorHelper.createMediaItem(mVideoEditor,
   2555                 "m1", videoItemFileName1, renderingMode);
   2556         } catch (IllegalArgumentException e) {
   2557         }
   2558         assertTrue("VideoContent 1920x1080", flagForException);
   2559     }
   2560 
   2561 
   2562     /**
   2563      * To test: Remove audio track
   2564      *
   2565      * @throws Exception
   2566      */
   2567     @LargeTest
   2568     public void testRemoveAudioTrack() throws Exception {
   2569         final String audioFileName = INPUT_FILE_PATH +
   2570             "AACLC_48KHz_256Kbps_s_1_17.3gp";
   2571         boolean flagForException = false;
   2572 
   2573         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
   2574             mVideoEditor, "audioTrack1", audioFileName);
   2575         mVideoEditor.addAudioTrack(audioTrack);
   2576 
   2577         assertEquals("Audio Track Item Duration", audioTrack.getDuration(),
   2578             audioTrack.getTimelineDuration());
   2579         assertTrue("Audio Track ID", audioTrack.getId().equals("audioTrack1"));
   2580         assertNotNull("Remove Audio Track",
   2581             mVideoEditor.removeAudioTrack("audioTrack1"));
   2582         try{
   2583             mVideoEditor.removeAudioTrack("audioTrack1");
   2584         }catch (IllegalArgumentException e){
   2585             flagForException = true;
   2586         }
   2587         assertTrue("Remove Audio Track not possible", flagForException);
   2588     }
   2589 
   2590       /**
   2591      * To test: Disable ducking
   2592      *
   2593      * @throws Exception
   2594      */
   2595     @LargeTest
   2596     public void testAudioDuckingDisable() throws Exception {
   2597         final String audioFileName = INPUT_FILE_PATH +
   2598             "AACLC_48KHz_256Kbps_s_1_17.3gp";
   2599         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
   2600             mVideoEditor, "audioTrack", audioFileName);
   2601         mVideoEditor.addAudioTrack(audioTrack);
   2602 
   2603         audioTrack.disableDucking();
   2604         assertFalse("Audio Track Ducking is Disabled",
   2605             audioTrack.isDuckingEnabled());
   2606     }
   2607 
   2608 
   2609 
   2610       /**
   2611      * To test: Need a basic test case for the get value for TransitionAlpha
   2612      *  ( ie. getBlendingPercent, getMaskFilename, isInvert)
   2613      *
   2614      * @throws Exception
   2615      */
   2616     @LargeTest
   2617     public void testTransitionAlphaBasic() throws Exception {
   2618 
   2619         final String videoItemFilename1 = INPUT_FILE_PATH +
   2620             "H264_BP_640x480_30fps_256kbps_1_17.mp4";
   2621         final String maskFilename = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
   2622         boolean flagForException = false;
   2623 
   2624         final MediaVideoItem mediaVideoItem1 =
   2625             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   2626                 videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2627         mediaVideoItem1.setExtractBoundaries(0, 15000);
   2628 
   2629         final MediaImageItem mediaImageItem =
   2630             mVideoEditorHelper.createMediaItem(mVideoEditor, "m2", maskFilename,
   2631                 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2632         mediaImageItem.setDuration(15000);
   2633 
   2634         mVideoEditor.addMediaItem(mediaVideoItem1);
   2635         mVideoEditor.addMediaItem(mediaImageItem);
   2636         final TransitionAlpha transition1And2 =
   2637             mVideoEditorHelper.createTAlpha("transition1And2", mediaVideoItem1,
   2638                 mediaImageItem, 3000, Transition.BEHAVIOR_SPEED_UP,
   2639                 maskFilename, 10, false);
   2640         mVideoEditor.addTransition(transition1And2);
   2641         assertTrue("Transition maskFile",
   2642             transition1And2.getMaskFilename().equals(maskFilename));
   2643         assertEquals("Transition BlendingPercent", 10,
   2644             transition1And2.getBlendingPercent());
   2645         assertFalse("Transition Invert", transition1And2.isInvert());
   2646     }
   2647 
   2648     /**
   2649      * To test: NULL arguments to the Video Editor APIs
   2650      *
   2651      * @throws Exception
   2652      */
   2653     @LargeTest
   2654     public void testNullAPIs() throws Exception {
   2655 
   2656         final String videoItemFilename1 = INPUT_FILE_PATH +
   2657             "H264_BP_640x480_30fps_256kbps_1_17.mp4";
   2658         final String maskFilename = INPUT_FILE_PATH +
   2659             "IMG_640x480_Overlay1.png";
   2660         final String audioFileName = INPUT_FILE_PATH +
   2661             "AACLC_48KHz_256Kbps_s_1_17.3gp";
   2662         boolean flagForException = false;
   2663 
   2664         try {
   2665             mVideoEditor.addAudioTrack(null);
   2666         } catch(IllegalArgumentException e) {
   2667             flagForException = true;
   2668         }
   2669         assertTrue("Video Editor with null Audio Track", flagForException);
   2670         flagForException = false;
   2671         try {
   2672             mVideoEditor.addMediaItem(null);
   2673         } catch(IllegalArgumentException e) {
   2674             flagForException = true;
   2675         }
   2676         assertTrue("Video Editor with NULL Image Item ", flagForException);
   2677         flagForException = false;
   2678         try {
   2679             mVideoEditor.addMediaItem(null);
   2680         } catch(IllegalArgumentException e) {
   2681             flagForException = true;
   2682         }
   2683         assertTrue("Video Editor with NULL Video Item ", flagForException);
   2684 
   2685         MediaVideoItem mediaVideoItem1 = null;
   2686         try {
   2687             mediaVideoItem1 =
   2688             mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
   2689                 videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2690         } catch (IllegalArgumentException e) {
   2691             assertTrue("Cannot Create Video Item", false);
   2692         }
   2693         mediaVideoItem1.setExtractBoundaries(0, 15000);
   2694         mVideoEditor.addMediaItem(mediaVideoItem1);
   2695         flagForException = false;
   2696         try {
   2697             mediaVideoItem1.addEffect(null);
   2698         } catch(IllegalArgumentException e) {
   2699             flagForException = true;
   2700         }
   2701         assertTrue("Video with null effect ", flagForException);
   2702         flagForException = false;
   2703         try {
   2704             mediaVideoItem1.addOverlay(null);
   2705         } catch(IllegalArgumentException e) {
   2706             flagForException = true;
   2707         }
   2708         assertTrue("Video with null overlay ", flagForException);
   2709 
   2710         final MediaImageItem mediaImageItem =
   2711             mVideoEditorHelper.createMediaItem(mVideoEditor, "m2", maskFilename,
   2712                 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
   2713         mediaImageItem.setDuration(15000);
   2714         mVideoEditor.addMediaItem(mediaImageItem);
   2715         flagForException = false;
   2716         try {
   2717             mediaImageItem.addEffect(null);
   2718         } catch(IllegalArgumentException e) {
   2719             flagForException = true;
   2720         }
   2721         assertTrue("Image with null effect ", flagForException);
   2722         flagForException = false;
   2723         try {
   2724             mediaImageItem.addOverlay(null);
   2725         } catch(IllegalArgumentException e) {
   2726             flagForException = true;
   2727         }
   2728         assertTrue("Image with null overlay ", flagForException);
   2729 
   2730         final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
   2731             mVideoEditor, "audioTrack", audioFileName);
   2732         mVideoEditor.addAudioTrack(audioTrack);
   2733 
   2734         flagForException = false;
   2735         try {
   2736             mVideoEditor.addTransition(null);
   2737         } catch(IllegalArgumentException e) {
   2738             flagForException = true;
   2739         }
   2740         assertTrue("Added null transition ", flagForException);
   2741 
   2742         flagForException = false;
   2743         try {
   2744             mVideoEditor.addTransition(null);
   2745         } catch(IllegalArgumentException e) {
   2746             flagForException = true;
   2747         }
   2748         assertTrue("Added null transition ", flagForException);
   2749 
   2750     }
   2751 }
   2752