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