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