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