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