Gitiles
Code Review Sign In
gerrit.omnirom.org / android_frameworks_av / 2177d443f2d57b9d3045d535d8f2b186e5b76f25 / . / libvideoeditor / lvpp / VideoEditorPreviewController.cpp
blob: 52aa87e3339a8a4232418448d0d2dcf14f46d831 [file] [log] [blame]
Dharmaray Kundargi643290d2011-01-16 16:02:42 -0800[diff] [blame]1/*
2 * Copyright (C) 2011 NXP Software
3 * Copyright (C) 2011 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18#define LOG_NDEBUG 1
19#define LOG_TAG "VideoEditorPreviewController"
20#include "VideoEditorPreviewController.h"
21
22namespace android {
23
24#define PREVIEW_THREAD_STACK_SIZE (65536)
25
26VideoEditorPreviewController::VideoEditorPreviewController()
27 : mCurrentPlayer(0),
28 mThreadContext(NULL),
29 mPlayerState(VePlayerIdle),
30 mClipList(NULL),
31 mNumberClipsInStoryBoard(0),
32 mNumberClipsToPreview(0),
33 mStartingClipIndex(0),
34 mPreviewLooping(M4OSA_FALSE),
35 mCallBackAfterFrameCnt(0),
36 mEffectsSettings(NULL),
37 mNumberEffects(0),
38 mCurrentClipNumber(-1),
39 mClipTotalDuration(0),
40 mCurrentVideoEffect(VIDEO_EFFECT_NONE),
41 mTarget(NULL),
42 mJniCookie(NULL),
43 mJniCallback(NULL),
44 mBackgroundAudioSetting(NULL),
45 mAudioMixPCMFileHandle(NULL),
46 mVideoStoryBoardTimeMsUptoFirstPreviewClip(0),
47 mCurrentPlayedDuration(0),
48 mCurrentClipDuration(0),
49 mOutputVideoWidth(0),
50 mOutputVideoHeight(0),
51 bStopThreadInProgress(false),
52 mSemThreadWait(NULL) {
53 LOGV("VideoEditorPreviewController");
54 mRenderingMode = M4xVSS_kBlackBorders;
55 mIsFiftiesEffectStarted = false;
56
57 for (int i=0; i<NBPLAYER_INSTANCES; i++) {
58 mVePlayer[i] = NULL;
59 }
60}
61
62VideoEditorPreviewController::~VideoEditorPreviewController() {
63 M4OSA_UInt32 i = 0;
64 M4OSA_ERR err = M4NO_ERROR;
65 LOGV("~VideoEditorPreviewController");
66
67 // Stop the thread if its still running
68 if(mThreadContext != NULL) {
69 err = M4OSA_threadSyncStop(mThreadContext);
70 if(err != M4NO_ERROR) {
71 LOGV("~VideoEditorPreviewController: error 0x%x \
72 in trying to stop thread", err);
73 // Continue even if error
74 }
75
76 err = M4OSA_threadSyncClose(mThreadContext);
77 if(err != M4NO_ERROR) {
78 LOGE("~VideoEditorPreviewController: error 0x%x \
79 in trying to close thread", err);
80 // Continue even if error
81 }
82
83 mThreadContext = NULL;
84 }
85
86 for (int playerInst=0; playerInst<NBPLAYER_INSTANCES;
87 playerInst++) {
88 if(mVePlayer[playerInst] != NULL) {
89 LOGV("clearing mVePlayer %d", playerInst);
90 mVePlayer[playerInst].clear();
91 }
92 }
93
94 if(mClipList != NULL) {
95 // Clean up
96 for(i=0;i<mNumberClipsInStoryBoard;i++)
97 {
98 if(mClipList[i]->pFile != NULL) {
99 M4OSA_free((M4OSA_MemAddr32)mClipList[i]->pFile);
100 mClipList[i]->pFile = NULL;
101 }
102
103 M4OSA_free((M4OSA_MemAddr32)mClipList[i]);
104 }
105 M4OSA_free((M4OSA_MemAddr32)mClipList);
106 mClipList = NULL;
107 }
108
109 if(mEffectsSettings) {
110 for(i=0;i<mNumberEffects;i++) {
111 if(mEffectsSettings[i].xVSS.pFramingBuffer != NULL) {
112 M4OSA_free(
113 (M4OSA_MemAddr32)mEffectsSettings[i].xVSS.pFramingBuffer->pac_data);
114
115 M4OSA_free(
116 (M4OSA_MemAddr32)mEffectsSettings[i].xVSS.pFramingBuffer);
117
118 mEffectsSettings[i].xVSS.pFramingBuffer = NULL;
119 }
120 }
121 M4OSA_free((M4OSA_MemAddr32)mEffectsSettings);
122 mEffectsSettings = NULL;
123 }
124
125 if(mTarget != NULL) {
126 delete mTarget;
127 mTarget = NULL;
128 }
129
130 LOGV("~VideoEditorPreviewController returns");
131}
132
133M4OSA_ERR VideoEditorPreviewController::loadEditSettings(
134 M4VSS3GPP_EditSettings* pSettings,M4xVSS_AudioMixingSettings* bgmSettings) {
135
136 M4OSA_UInt32 i = 0, iClipDuration = 0, rgbSize = 0;
137 M4VIFI_UInt8 *tmp = NULL;
138 M4OSA_ERR err = M4NO_ERROR;
139
140 LOGV("loadEditSettings");
141 LOGV("loadEditSettings Channels = %d, sampling Freq %d",
142 bgmSettings->uiNbChannels, bgmSettings->uiSamplingFrequency );
143 bgmSettings->uiSamplingFrequency = 32000;
144
145 LOGV("loadEditSettings Channels = %d, sampling Freq %d",
146 bgmSettings->uiNbChannels, bgmSettings->uiSamplingFrequency );
147 Mutex::Autolock autoLock(mLock);
148
149 // Clean up any previous Edit settings before loading new ones
150 mCurrentVideoEffect = VIDEO_EFFECT_NONE;
151
152 if(mAudioMixPCMFileHandle) {
153 err = M4OSA_fileReadClose (mAudioMixPCMFileHandle);
154 mAudioMixPCMFileHandle = M4OSA_NULL;
155 }
156
157 if(mBackgroundAudioSetting != NULL) {
158 M4OSA_free((M4OSA_MemAddr32)mBackgroundAudioSetting);
159 mBackgroundAudioSetting = NULL;
160 }
161
162 if(mClipList != NULL) {
163 // Clean up
164 for(i=0;i<mNumberClipsInStoryBoard;i++)
165 {
166 if(mClipList[i]->pFile != NULL) {
167 M4OSA_free((M4OSA_MemAddr32)mClipList[i]->pFile);
168 mClipList[i]->pFile = NULL;
169 }
170
171 M4OSA_free((M4OSA_MemAddr32)mClipList[i]);
172 }
173 M4OSA_free((M4OSA_MemAddr32)mClipList);
174 mClipList = NULL;
175 }
176
177 if(mEffectsSettings) {
178 for(i=0;i<mNumberEffects;i++) {
179 if(mEffectsSettings[i].xVSS.pFramingBuffer != NULL) {
180 M4OSA_free(
181 (M4OSA_MemAddr32)mEffectsSettings[i].xVSS.pFramingBuffer->pac_data);
182
183 M4OSA_free(
184 (M4OSA_MemAddr32)mEffectsSettings[i].xVSS.pFramingBuffer);
185
186 mEffectsSettings[i].xVSS.pFramingBuffer = NULL;
187 }
188 }
189 M4OSA_free((M4OSA_MemAddr32)mEffectsSettings);
190 mEffectsSettings = NULL;
191 }
192
193 if(mClipList == NULL) {
194 mNumberClipsInStoryBoard = pSettings->uiClipNumber;
195 LOGV("loadEditSettings: # of Clips = %d", mNumberClipsInStoryBoard);
196
197 mClipList = (M4VSS3GPP_ClipSettings**)M4OSA_malloc(
198 sizeof(M4VSS3GPP_ClipSettings*)*pSettings->uiClipNumber, M4VS,
199 (M4OSA_Char*)"LvPP, copy of pClipList");
200
201 if(NULL == mClipList) {
202 LOGE("loadEditSettings: Malloc error");
203 return M4ERR_ALLOC;
204 }
205 M4OSA_memset((M4OSA_MemAddr8)mClipList,
206 sizeof(M4VSS3GPP_ClipSettings*)*pSettings->uiClipNumber, 0);
207
208 for(i=0;i<pSettings->uiClipNumber;i++) {
209
210 // Allocate current clip
211 mClipList[i] =
212 (M4VSS3GPP_ClipSettings*)M4OSA_malloc(
213 sizeof(M4VSS3GPP_ClipSettings),M4VS,(M4OSA_Char*)"clip settings");
214
215 if(mClipList[i] == NULL) {
216
217 LOGE("loadEditSettings: Allocation error for mClipList[%d]", i);
218 return M4ERR_ALLOC;
219 }
220 // Copy plain structure
221 M4OSA_memcpy((M4OSA_MemAddr8)mClipList[i],
222 (M4OSA_MemAddr8)pSettings->pClipList[i],
223 sizeof(M4VSS3GPP_ClipSettings));
224
225 if(NULL != pSettings->pClipList[i]->pFile) {
226 mClipList[i]->pFile = (M4OSA_Char*)M4OSA_malloc(
227 pSettings->pClipList[i]->filePathSize, M4VS,
228 (M4OSA_Char*)"pClipSettingsDest->pFile");
229
230 if(NULL == mClipList[i]->pFile)
231 {
232 LOGE("loadEditSettings : ERROR allocating filename");
233 return M4ERR_ALLOC;
234 }
235
236 M4OSA_memcpy((M4OSA_MemAddr8)mClipList[i]->pFile,
237 (M4OSA_MemAddr8)pSettings->pClipList[i]->pFile,
238 pSettings->pClipList[i]->filePathSize);
239 }
240 else {
241 LOGE("NULL file path");
242 return M4ERR_PARAMETER;
243 }
244
245 // Calculate total duration of all clips
246 iClipDuration = pSettings->pClipList[i]->uiEndCutTime -
247 pSettings->pClipList[i]->uiBeginCutTime;
248
249 mClipTotalDuration = mClipTotalDuration+iClipDuration;
250 }
251 }
252
253 if(mEffectsSettings == NULL) {
254 mNumberEffects = pSettings->nbEffects;
255 LOGV("loadEditSettings: mNumberEffects = %d", mNumberEffects);
256
257 if(mNumberEffects != 0) {
258 mEffectsSettings = (M4VSS3GPP_EffectSettings*)M4OSA_malloc(
259 mNumberEffects*sizeof(M4VSS3GPP_EffectSettings),
260 M4VS, (M4OSA_Char*)"effects settings");
261
262 if(mEffectsSettings == NULL) {
263 LOGE("loadEffectsSettings: Allocation error");
264 return M4ERR_ALLOC;
265 }
266
267 M4OSA_memset((M4OSA_MemAddr8)mEffectsSettings,
268 mNumberEffects*sizeof(M4VSS3GPP_EffectSettings), 0);
269
270 for(i=0;i<mNumberEffects;i++) {
271
272 mEffectsSettings[i].xVSS.pFramingFilePath = NULL;
273 mEffectsSettings[i].xVSS.pFramingBuffer = NULL;
274 mEffectsSettings[i].xVSS.pTextBuffer = NULL;
275
276 M4OSA_memcpy((M4OSA_MemAddr8)&(mEffectsSettings[i]),
277 (M4OSA_MemAddr8)&(pSettings->Effects[i]),
278 sizeof(M4VSS3GPP_EffectSettings));
279
280 if(pSettings->Effects[i].VideoEffectType ==
281 M4xVSS_kVideoEffectType_Framing) {
282 // Allocate the pFraming RGB buffer
283 mEffectsSettings[i].xVSS.pFramingBuffer =
284 (M4VIFI_ImagePlane *)M4OSA_malloc(sizeof(M4VIFI_ImagePlane),
285 M4VS, (M4OSA_Char*)"lvpp framing buffer");
286
287 if(mEffectsSettings[i].xVSS.pFramingBuffer == NULL) {
288 LOGE("loadEffectsSettings:Alloc error for pFramingBuf");
289 M4OSA_free((M4OSA_MemAddr32)mEffectsSettings);
290 mEffectsSettings = NULL;
291 return M4ERR_ALLOC;
292 }
293
294 // Allocate the pac_data (RGB)
295 if(pSettings->Effects[i].xVSS.rgbType == M4VSS3GPP_kRGB565){
296 rgbSize =
297 pSettings->Effects[i].xVSS.pFramingBuffer->u_width *
298 pSettings->Effects[i].xVSS.pFramingBuffer->u_height*2;
299 }
300 else if(
301 pSettings->Effects[i].xVSS.rgbType == M4VSS3GPP_kRGB888) {
302 rgbSize =
303 pSettings->Effects[i].xVSS.pFramingBuffer->u_width *
304 pSettings->Effects[i].xVSS.pFramingBuffer->u_height*3;
305 }
306 else {
307 LOGE("loadEffectsSettings: wrong RGB type");
308 M4OSA_free((M4OSA_MemAddr32)mEffectsSettings);
309 mEffectsSettings = NULL;
310 return M4ERR_PARAMETER;
311 }
312
313 tmp = (M4VIFI_UInt8 *)M4OSA_malloc(rgbSize, M4VS,
314 (M4OSA_Char*)"framing buffer pac_data");
315
316 if(tmp == NULL) {
317 LOGE("loadEffectsSettings:Alloc error pFramingBuf pac");
318 M4OSA_free((M4OSA_MemAddr32)mEffectsSettings);
319 mEffectsSettings = NULL;
320 M4OSA_free(
321 (M4OSA_MemAddr32)mEffectsSettings[i].xVSS.pFramingBuffer);
322
323 mEffectsSettings[i].xVSS.pFramingBuffer = NULL;
324 return M4ERR_ALLOC;
325 }
326 /* Initialize the pFramingBuffer*/
327 mEffectsSettings[i].xVSS.pFramingBuffer->pac_data = tmp;
328 mEffectsSettings[i].xVSS.pFramingBuffer->u_height =
329 pSettings->Effects[i].xVSS.pFramingBuffer->u_height;
330
331 mEffectsSettings[i].xVSS.pFramingBuffer->u_width =
332 pSettings->Effects[i].xVSS.pFramingBuffer->u_width;
333
334 mEffectsSettings[i].xVSS.pFramingBuffer->u_stride =
335 pSettings->Effects[i].xVSS.pFramingBuffer->u_stride;
336
337 mEffectsSettings[i].xVSS.pFramingBuffer->u_topleft =
338 pSettings->Effects[i].xVSS.pFramingBuffer->u_topleft;
339
340 mEffectsSettings[i].xVSS.uialphaBlendingStart =
341 pSettings->Effects[i].xVSS.uialphaBlendingStart;
342
343 mEffectsSettings[i].xVSS.uialphaBlendingMiddle =
344 pSettings->Effects[i].xVSS.uialphaBlendingMiddle;
345
346 mEffectsSettings[i].xVSS.uialphaBlendingEnd =
347 pSettings->Effects[i].xVSS.uialphaBlendingEnd;
348
349 mEffectsSettings[i].xVSS.uialphaBlendingFadeInTime =
350 pSettings->Effects[i].xVSS.uialphaBlendingFadeInTime;
351 mEffectsSettings[i].xVSS.uialphaBlendingFadeOutTime =
352 pSettings->Effects[i].xVSS.uialphaBlendingFadeOutTime;
353
354 // Copy the pFraming data
355 M4OSA_memcpy((M4OSA_MemAddr8)
356 mEffectsSettings[i].xVSS.pFramingBuffer->pac_data,
357 (M4OSA_MemAddr8)pSettings->Effects[i].xVSS.pFramingBuffer->pac_data,
358 rgbSize);
359
360 mEffectsSettings[i].xVSS.rgbType =
361 pSettings->Effects[i].xVSS.rgbType;
362 }
363 }
364 }
365 }
366
367 if (mBackgroundAudioSetting == NULL) {
368
369 mBackgroundAudioSetting = (M4xVSS_AudioMixingSettings*)M4OSA_malloc(
370 sizeof(M4xVSS_AudioMixingSettings), M4VS,
371 (M4OSA_Char*)"LvPP, copy of bgmSettings");
372
373 if(NULL == mBackgroundAudioSetting) {
374 LOGE("loadEditSettings: mBackgroundAudioSetting Malloc failed");
375 return M4ERR_ALLOC;
376 }
377
378 M4OSA_memset((M4OSA_MemAddr8)mBackgroundAudioSetting, sizeof(M4xVSS_AudioMixingSettings*), 0);
379 M4OSA_memcpy((M4OSA_MemAddr8)mBackgroundAudioSetting, (M4OSA_MemAddr8)bgmSettings, sizeof(M4xVSS_AudioMixingSettings));
380
381 if ( mBackgroundAudioSetting->pFile != M4OSA_NULL ) {
382
383 mBackgroundAudioSetting->pFile = (M4OSA_Void*) bgmSettings->pPCMFilePath;
384 mBackgroundAudioSetting->uiNbChannels = 2;
385 mBackgroundAudioSetting->uiSamplingFrequency = 32000;
386 }
387
388 // Open the BG file
389 if ( mBackgroundAudioSetting->pFile != M4OSA_NULL ) {
390 err = M4OSA_fileReadOpen(&mAudioMixPCMFileHandle,
391 mBackgroundAudioSetting->pFile, M4OSA_kFileRead);
392
393 if (err != M4NO_ERROR) {
394 LOGE("loadEditSettings: mBackgroundAudio PCM File open failed");
395 return M4ERR_PARAMETER;
396 }
397 }
398 }
399
400 mOutputVideoSize = pSettings->xVSS.outputVideoSize;
401 mFrameStr.pBuffer = M4OSA_NULL;
402 return M4NO_ERROR;
403}
404
405M4OSA_ERR VideoEditorPreviewController::setSurface(const sp<Surface> &surface) {
406 LOGV("setSurface");
407 Mutex::Autolock autoLock(mLock);
408
409 mSurface = surface;
410 mISurface = surface->getISurface();
411 LOGV("setSurface: mISurface = %p", mISurface.get());
412 return M4NO_ERROR;
413}
414
415M4OSA_ERR VideoEditorPreviewController::startPreview(
416 M4OSA_UInt32 fromMS, M4OSA_Int32 toMs, M4OSA_UInt16 callBackAfterFrameCount,
417 M4OSA_Bool loop) {
418
419 M4OSA_ERR err = M4NO_ERROR;
420 M4OSA_UInt32 i = 0, iIncrementedDuration = 0;
421 LOGV("startPreview");
422
423 if(fromMS > toMs) {
424 LOGE("startPreview: fromMS > toMs");
425 return M4ERR_PARAMETER;
426 }
427
428 if(toMs == 0) {
429 LOGE("startPreview: toMs is 0");
430 return M4ERR_PARAMETER;
431 }
432
433 // If already started, then stop preview first
434 for(int playerInst=0; playerInst<NBPLAYER_INSTANCES; playerInst++) {
435 if(mVePlayer[playerInst] != NULL) {
436 LOGV("startPreview: stopping previously started preview playback");
437 stopPreview();
438 break;
439 }
440 }
441
442 // If renderPreview was called previously, then delete Renderer object first
443 if(mTarget != NULL) {
444 LOGV("startPreview: delete previous PreviewRenderer");
445 delete mTarget;
446 mTarget = NULL;
447 }
448
449 LOGV("startPreview: loop = %d", loop);
450 mPreviewLooping = loop;
451
452 LOGV("startPreview: callBackAfterFrameCount = %d", callBackAfterFrameCount);
453 mCallBackAfterFrameCnt = callBackAfterFrameCount;
454
455 for (int playerInst=0; playerInst<NBPLAYER_INSTANCES; playerInst++) {
456 mVePlayer[playerInst] = new VideoEditorPlayer();
457 if(mVePlayer[playerInst] == NULL) {
458 LOGE("startPreview:Error creating VideoEditorPlayer %d",playerInst);
459 return M4ERR_ALLOC;
460 }
461 LOGV("startPreview: object created");
462
463 mVePlayer[playerInst]->setNotifyCallback(this,(notify_callback_f)notify);
464 LOGV("startPreview: notify callback set");
465
466 mVePlayer[playerInst]->loadEffectsSettings(mEffectsSettings,
467 mNumberEffects);
468 LOGV("startPreview: effects settings loaded");
469
470 mVePlayer[playerInst]->loadAudioMixSettings(mBackgroundAudioSetting);
471 LOGV("startPreview: AudioMixSettings settings loaded");
472
473 mVePlayer[playerInst]->setAudioMixPCMFileHandle(mAudioMixPCMFileHandle);
474 LOGV("startPreview: AudioMixPCMFileHandle set");
475
476 mVePlayer[playerInst]->setProgressCallbackInterval(
477 mCallBackAfterFrameCnt);
478 LOGV("startPreview: setProgressCallBackInterval");
479 }
480
481 mPlayerState = VePlayerIdle;
482
483 if(fromMS == 0) {
484 mCurrentClipNumber = -1;
485 // Save original value
486 mFirstPreviewClipBeginTime = mClipList[0]->uiBeginCutTime;
487 mVideoStoryBoardTimeMsUptoFirstPreviewClip = 0;
488 }
489 else {
490 LOGV("startPreview: fromMS=%d", fromMS);
491 if(fromMS >= mClipTotalDuration) {
492 LOGE("startPreview: fromMS >= mClipTotalDuration");
493 return M4ERR_PARAMETER;
494 }
495 for(i=0;i<mNumberClipsInStoryBoard;i++) {
496 if(fromMS < (iIncrementedDuration + (mClipList[i]->uiEndCutTime -
497 mClipList[i]->uiBeginCutTime))) {
498 // Set to 1 index below,
499 // as threadProcess first increments the clip index
500 // and then processes clip in thread loop
501 mCurrentClipNumber = i-1;
502 LOGV("startPreview:mCurrentClipNumber = %d fromMS=%d",i,fromMS);
503
504 // Save original value
505 mFirstPreviewClipBeginTime = mClipList[i]->uiBeginCutTime;
506
507 // Set correct begin time to start playback
508 if((fromMS+mClipList[i]->uiBeginCutTime) >
509 (iIncrementedDuration+mClipList[i]->uiBeginCutTime)) {
510
511 mClipList[i]->uiBeginCutTime =
512 mClipList[i]->uiBeginCutTime +
513 (fromMS - iIncrementedDuration);
514 }
515 break;
516 }
517 else {
518 iIncrementedDuration = iIncrementedDuration +
519 (mClipList[i]->uiEndCutTime - mClipList[i]->uiBeginCutTime);
520 }
521 }
522 mVideoStoryBoardTimeMsUptoFirstPreviewClip = iIncrementedDuration;
523 }
524
525 for (int playerInst=0; playerInst<NBPLAYER_INSTANCES; playerInst++) {
526 mVePlayer[playerInst]->setAudioMixStoryBoardParam(fromMS,
527 mFirstPreviewClipBeginTime,
528 mClipList[i]->ClipProperties.uiClipAudioVolumePercentage);
529
530 LOGV("startPreview:setAudioMixStoryBoardSkimTimeStamp set %d cuttime \
531 %d", fromMS, mFirstPreviewClipBeginTime);
532 }
533
534 mStartingClipIndex = mCurrentClipNumber+1;
535
536 // Start playing with player instance 0
537 mCurrentPlayer = 0;
538
539 if(toMs == -1) {
540 LOGV("startPreview: Preview till end of storyboard");
541 mNumberClipsToPreview = mNumberClipsInStoryBoard;
542 // Save original value
543 mLastPreviewClipEndTime =
544 mClipList[mNumberClipsToPreview-1]->uiEndCutTime;
545 }
546 else {
547 LOGV("startPreview: toMs=%d", toMs);
548 if(toMs > mClipTotalDuration) {
549 LOGE("startPreview: toMs > mClipTotalDuration");
550 return M4ERR_PARAMETER;
551 }
552
553 iIncrementedDuration = 0;
554
555 for(i=0;i<mNumberClipsInStoryBoard;i++) {
556 if(toMs <= (iIncrementedDuration +
557 (mClipList[i]->uiEndCutTime - mClipList[i]->uiBeginCutTime))) {
558 // Save original value
559 mLastPreviewClipEndTime = mClipList[i]->uiEndCutTime;
560 // Set the end cut time of clip index i to toMs
561 mClipList[i]->uiEndCutTime = toMs;
562
563 // Number of clips to be previewed is from index 0 to i
564 // increment by 1 as i starts from 0
565 mNumberClipsToPreview = i+1;
566 break;
567 }
568 else {
569 iIncrementedDuration = iIncrementedDuration +
570 (mClipList[i]->uiEndCutTime - mClipList[i]->uiBeginCutTime);
571 }
572 }
573 }
574
575 // Open the thread semaphore
576 M4OSA_semaphoreOpen(&mSemThreadWait, 1);
577
578 // Open the preview process thread
579 err = M4OSA_threadSyncOpen(&mThreadContext, (M4OSA_ThreadDoIt)threadProc);
580 if (M4NO_ERROR != err) {
581 LOGE("VideoEditorPreviewController:M4OSA_threadSyncOpen error %d", err);
582 return err;
583 }
584
585 // Set the stacksize
586 err = M4OSA_threadSyncSetOption(mThreadContext, M4OSA_ThreadStackSize,
587 (M4OSA_DataOption)PREVIEW_THREAD_STACK_SIZE);
588
589 if (M4NO_ERROR != err) {
590 LOGE("VideoEditorPreviewController: threadSyncSetOption error %d", err);
591 M4OSA_threadSyncClose(mThreadContext);
592 mThreadContext = NULL;
593 return err;
594 }
595
596 // Start the thread
597 err = M4OSA_threadSyncStart(mThreadContext, (M4OSA_Void*)this);
598 if (M4NO_ERROR != err) {
599 LOGE("VideoEditorPreviewController: threadSyncStart error %d", err);
600 M4OSA_threadSyncClose(mThreadContext);
601 mThreadContext = NULL;
602 return err;
603 }
604 bStopThreadInProgress = false;
605
606 LOGV("startPreview: process thread started");
607 return M4NO_ERROR;
608}
609
610M4OSA_ERR VideoEditorPreviewController::stopPreview() {
611 M4OSA_ERR err = M4NO_ERROR;
612 LOGV("stopPreview");
613
614 // Stop the thread
615 if(mThreadContext != NULL) {
616 bStopThreadInProgress = true;
617 err = M4OSA_semaphorePost(mSemThreadWait);
618
619 err = M4OSA_threadSyncStop(mThreadContext);
620 if(err != M4NO_ERROR) {
621 LOGV("stopPreview: error 0x%x in trying to stop thread", err);
622 // Continue even if error
623 }
624
625 err = M4OSA_threadSyncClose(mThreadContext);
626 if(err != M4NO_ERROR) {
627 LOGE("stopPreview: error 0x%x in trying to close thread", err);
628 // Continue even if error
629 }
630
631 mThreadContext = NULL;
632 }
633
634 // Close the semaphore first
635 if(mSemThreadWait != NULL) {
636 err = M4OSA_semaphoreClose(mSemThreadWait);
637 LOGV("stopPreview: close semaphore returns 0x%x", err);
638 }
639
640 for (int playerInst=0; playerInst<NBPLAYER_INSTANCES; playerInst++) {
641 if(mVePlayer[playerInst] != NULL) {
642 if(mVePlayer[playerInst]->isPlaying()) {
643 LOGV("stop the player first");
644 mVePlayer[playerInst]->stop();
645 }
646
647 LOGV("stopPreview: clearing mVePlayer");
648 mVePlayer[playerInst].clear();
649 mVePlayer[playerInst] = NULL;
650 }
651 }
652
653 // If image file playing, then free the buffer pointer
654 if(mFrameStr.pBuffer != M4OSA_NULL) {
655 M4OSA_free((M4OSA_MemAddr32)mFrameStr.pBuffer);
656 mFrameStr.pBuffer = M4OSA_NULL;
657 }
658
659 // Reset original begin cuttime of first previewed clip*/
660 mClipList[mStartingClipIndex]->uiBeginCutTime = mFirstPreviewClipBeginTime;
661 // Reset original end cuttime of last previewed clip*/
662 mClipList[mNumberClipsToPreview-1]->uiEndCutTime = mLastPreviewClipEndTime;
663
664 mPlayerState = VePlayerIdle;
665
666 mCurrentPlayedDuration = 0;
667 mCurrentClipDuration = 0;
668 mRenderingMode = M4xVSS_kBlackBorders;
669 mOutputVideoWidth = 0;
670 mOutputVideoHeight = 0;
671
672 return M4NO_ERROR;
673}
674
Dheeraj Sharma9ec356a2011-01-24 15:02:18 -0800[diff] [blame]675M4OSA_ERR VideoEditorPreviewController::clearSurface(
676 const sp<Surface> &surface, VideoEditor_renderPreviewFrameStr* pFrameInfo) {
677
678 M4OSA_ERR err = M4NO_ERROR;
679 VideoEditor_renderPreviewFrameStr* pFrameStr = pFrameInfo;
680 M4OSA_UInt32 outputBufferWidth =0, outputBufferHeight=0;
681 M4VIFI_ImagePlane planeOut[3];
682 LOGV("Inside preview clear frame");
683
684 Mutex::Autolock autoLock(mLock);
685
686 // Get the Isurface to be passed to renderer
687 mISurface = surface->getISurface();
688
689 // Delete previous renderer instance
690 if(mTarget != NULL) {
691 delete mTarget;
692 mTarget = NULL;
693 }
694
695 if(mOutputVideoWidth == 0) {
696 mOutputVideoWidth = pFrameStr->uiFrameWidth;
697 }
698 if(mOutputVideoHeight == 0) {
699 mOutputVideoHeight = pFrameStr->uiFrameHeight;
700 }
701
702 // Initialize the renderer
703 if(mTarget == NULL) {
704 mTarget = new PreviewRenderer(
705 OMX_COLOR_FormatYUV420Planar, surface, mOutputVideoWidth, mOutputVideoHeight,
706 mOutputVideoWidth, mOutputVideoHeight, 0);
707 if(mTarget == NULL) {
708 LOGE("renderPreviewFrame: cannot create PreviewRenderer");
709 return M4ERR_ALLOC;
710 }
711 }
712
713 // Out plane
714 uint8_t* outBuffer;
715 size_t outBufferStride = 0;
716
717 LOGV("doMediaRendering CALL getBuffer()");
718 mTarget->getBufferYV12(&outBuffer, &outBufferStride);
719
720 // Set the output YUV420 plane to be compatible with YV12 format
721 //In YV12 format, sizes must be even
722 M4OSA_UInt32 yv12PlaneWidth = ((mOutputVideoWidth +1)>>1)<<1;
723 M4OSA_UInt32 yv12PlaneHeight = ((mOutputVideoHeight+1)>>1)<<1;
724
725 prepareYV12ImagePlane(planeOut, yv12PlaneWidth, yv12PlaneHeight,
726 (M4OSA_UInt32)outBufferStride, (M4VIFI_UInt8 *)outBuffer);
727
728 /* Fill the surface with black frame */
729 M4OSA_memset((M4OSA_MemAddr8)planeOut[0].pac_data,planeOut[0].u_width *
730 planeOut[0].u_height * 1.5,0x00);
731 M4OSA_memset((M4OSA_MemAddr8)planeOut[1].pac_data,planeOut[1].u_width *
732 planeOut[1].u_height,128);
733 M4OSA_memset((M4OSA_MemAddr8)planeOut[2].pac_data,planeOut[2].u_width *
734 planeOut[2].u_height,128);
735
736 mTarget->renderYV12();
737 return err;
738}
739
Dharmaray Kundargi643290d2011-01-16 16:02:42 -0800[diff] [blame]740M4OSA_ERR VideoEditorPreviewController::renderPreviewFrame(
741 const sp<Surface> &surface, VideoEditor_renderPreviewFrameStr* pFrameInfo) {
742
743 M4OSA_ERR err = M4NO_ERROR;
744 M4OSA_UInt32 i = 0, iIncrementedDuration = 0, tnTimeMs=0, framesize =0;
745 VideoEditor_renderPreviewFrameStr* pFrameStr = pFrameInfo;
746 M4VIFI_UInt8 *pixelArray = NULL;
747
748 Mutex::Autolock autoLock(mLock);
749
750 // Get the Isurface to be passed to renderer
751 mISurface = surface->getISurface();
752
753 // Delete previous renderer instance
754 if(mTarget != NULL) {
755 delete mTarget;
756 mTarget = NULL;
757 }
758
759 if(mOutputVideoWidth == 0) {
760 mOutputVideoWidth = pFrameStr->uiFrameWidth;
761 }
762 if(mOutputVideoHeight == 0) {
763 mOutputVideoHeight = pFrameStr->uiFrameHeight;
764 }
765
766 // Initialize the renderer
767 if(mTarget == NULL) {
768 mTarget = new PreviewRenderer(
769 OMX_COLOR_FormatYUV420Planar, surface, mOutputVideoWidth, mOutputVideoHeight,
770 mOutputVideoWidth, mOutputVideoHeight, 0);
771 if(mTarget == NULL) {
772 LOGE("renderPreviewFrame: cannot create PreviewRenderer");
773 return M4ERR_ALLOC;
774 }
775 }
776
777 pixelArray = NULL;
778
779 // Postprocessing (apply video effect)
780 if(pFrameStr->bApplyEffect == M4OSA_TRUE) {
781
782 for(i=0;i<mNumberEffects;i++) {
783 // First check if effect starttime matches the clip being previewed
784 if((mEffectsSettings[i].uiStartTime < pFrameStr->clipBeginCutTime)
785 ||(mEffectsSettings[i].uiStartTime >= pFrameStr->clipEndCutTime)) {
786 // This effect doesn't belong to this clip, check next one
787 continue;
788 }
789 if((mEffectsSettings[i].uiStartTime <= pFrameStr->timeMs) &&
790 ((mEffectsSettings[i].uiStartTime+mEffectsSettings[i].uiDuration) >=
791 pFrameStr->timeMs) && (mEffectsSettings[i].uiDuration != 0)) {
792 setVideoEffectType(mEffectsSettings[i].VideoEffectType, TRUE);
793 }
794 else {
795 setVideoEffectType(mEffectsSettings[i].VideoEffectType, FALSE);
796 }
797 }
798
799 if(mCurrentVideoEffect != VIDEO_EFFECT_NONE) {
800 err = applyVideoEffect((M4OSA_Void *)pFrameStr->pBuffer,
801 OMX_COLOR_FormatYUV420Planar, pFrameStr->uiFrameWidth,
802 pFrameStr->uiFrameHeight, pFrameStr->timeMs,
803 (M4OSA_Void *)pixelArray);
804
805 if(err != M4NO_ERROR) {
806 LOGE("renderPreviewFrame: applyVideoEffect error 0x%x", err);
807 delete mTarget;
808 mTarget = NULL;
809 M4OSA_free((M4OSA_MemAddr32)pixelArray);
810 pixelArray = NULL;
811 return err;
812 }
813 mCurrentVideoEffect = VIDEO_EFFECT_NONE;
814 }
815 else {
816 // Apply the rendering mode
817 err = doImageRenderingMode((M4OSA_Void *)pFrameStr->pBuffer,
818 OMX_COLOR_FormatYUV420Planar, pFrameStr->uiFrameWidth,
819 pFrameStr->uiFrameHeight, (M4OSA_Void *)pixelArray);
820
821 if(err != M4NO_ERROR) {
822 LOGE("renderPreviewFrame:doImageRenderingMode error 0x%x", err);
823 delete mTarget;
824 mTarget = NULL;
825 M4OSA_free((M4OSA_MemAddr32)pixelArray);
826 pixelArray = NULL;
827 return err;
828 }
829 }
830 }
831 else {
832 // Apply the rendering mode
833 err = doImageRenderingMode((M4OSA_Void *)pFrameStr->pBuffer,
834 OMX_COLOR_FormatYUV420Planar, pFrameStr->uiFrameWidth,
835 pFrameStr->uiFrameHeight, (M4OSA_Void *)pixelArray);
836
837 if(err != M4NO_ERROR) {
838 LOGE("renderPreviewFrame: doImageRenderingMode error 0x%x", err);
839 delete mTarget;
840 mTarget = NULL;
841 M4OSA_free((M4OSA_MemAddr32)pixelArray);
842 pixelArray = NULL;
843 return err;
844 }
845 }
846
847 mTarget->renderYV12();
848 return err;
849}
850
851M4OSA_Void VideoEditorPreviewController::setJniCallback(void* cookie,
852 jni_progress_callback_fct callbackFct) {
853 //LOGV("setJniCallback");
854 mJniCookie = cookie;
855 mJniCallback = callbackFct;
856}
857
858M4OSA_ERR VideoEditorPreviewController::preparePlayer(
859 void* param, int playerInstance, int index) {
860
861 M4OSA_ERR err = M4NO_ERROR;
862 VideoEditorPreviewController *pController =
863 (VideoEditorPreviewController *)param;
864
865 LOGV("preparePlayer: instance %d file %d", playerInstance, index);
866
867 pController->mVePlayer[playerInstance]->setDataSource(
868 (const char *)pController->mClipList[index]->pFile, NULL);
869 LOGV("preparePlayer: setDataSource instance %s",
870 (const char *)pController->mClipList[index]->pFile);
871
872 pController->mVePlayer[playerInstance]->setVideoISurface(
873 pController->mISurface);
874 LOGV("preparePlayer: setVideoISurface");
875
876 pController->mVePlayer[playerInstance]->setVideoSurface(
877 pController->mSurface);
878 LOGV("preparePlayer: setVideoSurface");
879
880 pController->mVePlayer[playerInstance]->setMediaRenderingMode(
881 pController->mClipList[index]->xVSS.MediaRendering,
882 pController->mOutputVideoSize);
883 LOGV("preparePlayer: setMediaRenderingMode");
884
885 if(index == pController->mStartingClipIndex) {
886 pController->mVePlayer[playerInstance]->setPlaybackBeginTime(
887 pController->mFirstPreviewClipBeginTime);
888 }
889 else {
890 pController->mVePlayer[playerInstance]->setPlaybackBeginTime(
891 pController->mClipList[index]->uiBeginCutTime);
892 }
893 LOGV("preparePlayer: setPlaybackBeginTime(%d)",
894 pController->mClipList[index]->uiBeginCutTime);
895
896 pController->mVePlayer[playerInstance]->setPlaybackEndTime(
897 pController->mClipList[index]->uiEndCutTime);
898 LOGV("preparePlayer: setPlaybackEndTime(%d)",
899 pController->mClipList[index]->uiEndCutTime);
900
901 if(pController->mClipList[index]->FileType == M4VIDEOEDITING_kFileType_ARGB8888) {
902 pController->mVePlayer[playerInstance]->setImageClipProperties(
903 pController->mClipList[index]->ClipProperties.uiVideoWidth,
904 pController->mClipList[index]->ClipProperties.uiVideoHeight);
905 LOGV("preparePlayer: setImageClipProperties");
906 }
907
908 pController->mVePlayer[playerInstance]->prepare();
909 LOGV("preparePlayer: prepared");
910
911 if(pController->mClipList[index]->uiBeginCutTime > 0) {
912 pController->mVePlayer[playerInstance]->seekTo(
913 pController->mClipList[index]->uiBeginCutTime);
914
915 LOGV("preparePlayer: seekTo(%d)",
916 pController->mClipList[index]->uiBeginCutTime);
917 }
918
919 pController->mVePlayer[playerInstance]->readFirstVideoFrame();
920 LOGV("preparePlayer: readFirstVideoFrame of clip");
921
922 return err;
923}
924
925M4OSA_ERR VideoEditorPreviewController::threadProc(M4OSA_Void* param) {
926 M4OSA_ERR err = M4NO_ERROR;
927 M4OSA_Int32 index = 0;
928 VideoEditorPreviewController *pController =
929 (VideoEditorPreviewController *)param;
930
931 LOGV("inside threadProc");
932 if(pController->mPlayerState == VePlayerIdle) {
933 (pController->mCurrentClipNumber)++;
934
935 LOGV("threadProc: playing file index %d total clips %d",
936 pController->mCurrentClipNumber, pController->mNumberClipsToPreview);
937
938 if(pController->mCurrentClipNumber >=
939 pController->mNumberClipsToPreview) {
940
941 LOGV("All clips previewed");
942
943 pController->mCurrentPlayedDuration = 0;
944 pController->mCurrentClipDuration = 0;
945 pController->mCurrentPlayer = 0;
946
947 if(pController->mPreviewLooping == M4OSA_TRUE) {
948 pController->mCurrentClipNumber =
949 pController->mStartingClipIndex;
950
951 LOGV("Preview looping TRUE, restarting from clip index %d",
952 pController->mCurrentClipNumber);
953
954 // Reset the story board timestamp inside the player
955 for (int playerInst=0; playerInst<NBPLAYER_INSTANCES;
956 playerInst++) {
957 pController->mVePlayer[playerInst]->resetJniCallbackTimeStamp();
958 }
959 }
960 else {
961 if(pController->mJniCallback != NULL) {
962 pController->mJniCallback(
963 pController->mJniCookie, MSG_TYPE_PREVIEW_END, 0);
964 }
965 pController->mPlayerState = VePlayerAutoStop;
966
967 // Reset original begin cuttime of first previewed clip
968 pController->mClipList[pController->mStartingClipIndex]->uiBeginCutTime =
969 pController->mFirstPreviewClipBeginTime;
970 // Reset original end cuttime of last previewed clip
971 pController->mClipList[pController->mNumberClipsToPreview-1]->uiEndCutTime =
972 pController->mLastPreviewClipEndTime;
973
974 // Return a warning to M4OSA thread handler
975 // so that thread is moved from executing state to open state
976 return M4WAR_NO_MORE_STREAM;
977 }
978 }
979
980 index=pController->mCurrentClipNumber;
981 if(pController->mCurrentClipNumber == pController->mStartingClipIndex) {
982 pController->mCurrentPlayedDuration +=
983 pController->mVideoStoryBoardTimeMsUptoFirstPreviewClip;
984
985 pController->mCurrentClipDuration =
986 pController->mClipList[pController->mCurrentClipNumber]->uiEndCutTime
987 - pController->mFirstPreviewClipBeginTime;
988
989 preparePlayer((void*)pController, pController->mCurrentPlayer, index);
990 }
991 else {
992 pController->mCurrentPlayedDuration +=
993 pController->mCurrentClipDuration;
994
995 pController->mCurrentClipDuration =
996 pController->mClipList[pController->mCurrentClipNumber]->uiEndCutTime -
997 pController->mClipList[pController->mCurrentClipNumber]->uiBeginCutTime;
998 }
999
1000 pController->mVePlayer[pController->mCurrentPlayer]->setStoryboardStartTime(
1001 pController->mCurrentPlayedDuration);
1002 LOGV("threadProc: setStoryboardStartTime");
1003
1004 // Set the next clip duration for Audio mix here
1005 if(pController->mCurrentClipNumber != pController->mStartingClipIndex) {
1006
1007 pController->mVePlayer[pController->mCurrentPlayer]->setAudioMixStoryBoardParam(
1008 pController->mCurrentPlayedDuration,
1009 pController->mClipList[index]->uiBeginCutTime,
1010 pController->mClipList[index]->ClipProperties.uiClipAudioVolumePercentage);
1011
1012 LOGV("threadProc: setAudioMixStoryBoardParam fromMS %d \
1013 ClipBeginTime %d", pController->mCurrentPlayedDuration +
1014 pController->mClipList[index]->uiBeginCutTime,
1015 pController->mClipList[index]->uiBeginCutTime,
1016 pController->mClipList[index]->ClipProperties.uiClipAudioVolumePercentage);
1017 }
1018
1019 pController->mVePlayer[pController->mCurrentPlayer]->start();
1020 LOGV("threadProc: started");
1021
1022 pController->mPlayerState = VePlayerBusy;
1023
1024 }
1025 else if(pController->mPlayerState == VePlayerAutoStop) {
1026 LOGV("Preview completed..auto stop the player");
1027 }
1028 else {
1029 if(!pController->bStopThreadInProgress) {
1030 LOGV("threadProc: state busy...wait for sem");
1031 err = M4OSA_semaphoreWait(pController->mSemThreadWait,
1032 M4OSA_WAIT_FOREVER);
1033 }
1034 LOGV("threadProc: sem wait returned err = 0x%x", err);
1035 }
1036
1037 //Always return M4NO_ERROR to ensure the thread keeps running
1038 return M4NO_ERROR;
1039}
1040
1041void VideoEditorPreviewController::notify(
1042 void* cookie, int msg, int ext1, int ext2)
1043{
1044 VideoEditorPreviewController *pController =
1045 (VideoEditorPreviewController *)cookie;
1046
1047 M4OSA_ERR err = M4NO_ERROR;
1048 uint32_t clipDuration = 0;
1049 switch (msg) {
1050 case MEDIA_NOP: // interface test message
1051 LOGV("MEDIA_NOP");
1052 break;
1053 case MEDIA_PREPARED:
1054 LOGV("MEDIA_PREPARED");
1055 break;
1056 case MEDIA_PLAYBACK_COMPLETE:
1057 LOGV("notify:MEDIA_PLAYBACK_COMPLETE");
1058 pController->mPlayerState = VePlayerIdle;
1059
1060 //send progress callback with last frame timestamp
1061 if(pController->mCurrentClipNumber ==
1062 pController->mStartingClipIndex) {
1063 clipDuration =
1064 pController->mClipList[pController->mCurrentClipNumber]->uiEndCutTime
1065 - pController->mFirstPreviewClipBeginTime;
1066 }
1067 else {
1068 clipDuration =
1069 pController->mClipList[pController->mCurrentClipNumber]->uiEndCutTime
1070 - pController->mClipList[pController->mCurrentClipNumber]->uiBeginCutTime;
1071 }
1072 pController->mJniCallback(
1073 pController->mJniCookie, MSG_TYPE_PROGRESS_INDICATION,
1074 (clipDuration+pController->mCurrentPlayedDuration));
1075
1076 M4OSA_semaphorePost(pController->mSemThreadWait);
1077 break;
1078 case MEDIA_ERROR:
1079 // Always log errors.
1080 // ext1: Media framework error code.
1081 // ext2: Implementation dependant error code.
1082 LOGE("MEDIA_ERROR; error (%d, %d)", ext1, ext2);
1083 if(pController->mJniCallback != NULL) {
1084 pController->mJniCallback(pController->mJniCookie,
1085 MSG_TYPE_PLAYER_ERROR, ext1);
1086 }
1087 break;
1088 case MEDIA_INFO:
1089 // ext1: Media framework error code.
1090 // ext2: Implementation dependant error code.
1091 //LOGW("MEDIA_INFO; info/warning (%d, %d)", ext1, ext2);
1092 if(pController->mJniCallback != NULL) {
1093 pController->mJniCallback(pController->mJniCookie,
1094 MSG_TYPE_PROGRESS_INDICATION, ext2);
1095 }
1096 break;
1097 case MEDIA_SEEK_COMPLETE:
1098 LOGV("MEDIA_SEEK_COMPLETE; Received seek complete");
1099 break;
1100 case MEDIA_BUFFERING_UPDATE:
1101 LOGV("MEDIA_BUFFERING_UPDATE; buffering %d", ext1);
1102 break;
1103 case MEDIA_SET_VIDEO_SIZE:
1104 LOGV("MEDIA_SET_VIDEO_SIZE; New video size %d x %d", ext1, ext2);
1105 break;
1106 case 0xAAAAAAAA:
1107 LOGV("VIDEO PLAYBACK ALMOST over, prepare next player");
1108
1109 // Select next player and prepare it
1110 // If there is a clip after this one
1111 if ((pController->mCurrentClipNumber+1) <
1112 pController->mNumberClipsToPreview) {
1113
1114 pController->mCurrentPlayer++;
1115 if (pController->mCurrentPlayer >= NBPLAYER_INSTANCES) {
1116 pController->mCurrentPlayer = 0;
1117 }
1118 // Prepare the first clip to be played
1119 preparePlayer((void*)pController, pController->mCurrentPlayer,
1120 pController->mCurrentClipNumber+1);
1121 }
1122 break;
1123 default:
1124 LOGV("unrecognized message: (%d, %d, %d)", msg, ext1, ext2);
1125 break;
1126 }
1127}
1128
1129void VideoEditorPreviewController::setVideoEffectType(
1130 M4VSS3GPP_VideoEffectType type, M4OSA_Bool enable) {
1131
1132 M4OSA_UInt32 effect = VIDEO_EFFECT_NONE;
1133
1134 // map M4VSS3GPP_VideoEffectType to local enum
1135 switch(type) {
1136 case M4VSS3GPP_kVideoEffectType_FadeFromBlack:
1137 effect = VIDEO_EFFECT_FADEFROMBLACK;
1138 break;
1139
1140 case M4VSS3GPP_kVideoEffectType_FadeToBlack:
1141 effect = VIDEO_EFFECT_FADETOBLACK;
1142 break;
1143
1144 case M4VSS3GPP_kVideoEffectType_CurtainOpening:
1145 effect = VIDEO_EFFECT_CURTAINOPEN;
1146 break;
1147
1148 case M4VSS3GPP_kVideoEffectType_CurtainClosing:
1149 effect = VIDEO_EFFECT_CURTAINCLOSE;
1150 break;
1151
1152 case M4xVSS_kVideoEffectType_BlackAndWhite:
1153 effect = VIDEO_EFFECT_BLACKANDWHITE;
1154 break;
1155
1156 case M4xVSS_kVideoEffectType_Pink:
1157 effect = VIDEO_EFFECT_PINK;
1158 break;
1159
1160 case M4xVSS_kVideoEffectType_Green:
1161 effect = VIDEO_EFFECT_GREEN;
1162 break;
1163
1164 case M4xVSS_kVideoEffectType_Sepia:
1165 effect = VIDEO_EFFECT_SEPIA;
1166 break;
1167
1168 case M4xVSS_kVideoEffectType_Negative:
1169 effect = VIDEO_EFFECT_NEGATIVE;
1170 break;
1171
1172 case M4xVSS_kVideoEffectType_Framing:
1173 effect = VIDEO_EFFECT_FRAMING;
1174 break;
1175
1176 case M4xVSS_kVideoEffectType_Fifties:
1177 effect = VIDEO_EFFECT_FIFTIES;
1178 break;
1179
1180 case M4xVSS_kVideoEffectType_ColorRGB16:
1181 effect = VIDEO_EFFECT_COLOR_RGB16;
1182 break;
1183
1184 case M4xVSS_kVideoEffectType_Gradient:
1185 effect = VIDEO_EFFECT_GRADIENT;
1186 break;
1187
1188 default:
1189 effect = VIDEO_EFFECT_NONE;
1190 break;
1191 }
1192
1193 if(enable == M4OSA_TRUE) {
1194 // If already set, then no need to set again
1195 if(!(mCurrentVideoEffect & effect))
1196 mCurrentVideoEffect |= effect;
1197 if(effect == VIDEO_EFFECT_FIFTIES) {
1198 mIsFiftiesEffectStarted = true;
1199 }
1200 }
1201 else {
1202 // Reset only if already set
1203 if(mCurrentVideoEffect & effect)
1204 mCurrentVideoEffect &= ~effect;
1205 }
1206
1207 return;
1208}
1209
1210
1211M4OSA_ERR VideoEditorPreviewController::applyVideoEffect(
1212 M4OSA_Void * dataPtr, M4OSA_UInt32 colorFormat, M4OSA_UInt32 videoWidth,
1213 M4OSA_UInt32 videoHeight, M4OSA_UInt32 timeMs, M4OSA_Void* outPtr) {
1214
1215 M4OSA_ERR err = M4NO_ERROR;
1216 vePostProcessParams postProcessParams;
1217
1218 postProcessParams.vidBuffer = (M4VIFI_UInt8*)dataPtr;
1219 postProcessParams.videoWidth = videoWidth;
1220 postProcessParams.videoHeight = videoHeight;
1221 postProcessParams.timeMs = timeMs;
1222 postProcessParams.timeOffset = 0; //Since timeMS already takes care of offset in this case
1223 postProcessParams.effectsSettings = mEffectsSettings;
1224 postProcessParams.numberEffects = mNumberEffects;
1225 postProcessParams.outVideoWidth = mOutputVideoWidth;
1226 postProcessParams.outVideoHeight = mOutputVideoHeight;
1227 postProcessParams.currentVideoEffect = mCurrentVideoEffect;
1228 postProcessParams.renderingMode = mRenderingMode;
1229 if(mIsFiftiesEffectStarted == M4OSA_TRUE) {
1230 postProcessParams.isFiftiesEffectStarted = M4OSA_TRUE;
1231 mIsFiftiesEffectStarted = M4OSA_FALSE;
1232 }
1233 else {
1234 postProcessParams.isFiftiesEffectStarted = M4OSA_FALSE;
1235 }
1236 //postProcessParams.renderer = mTarget;
1237 postProcessParams.overlayFrameRGBBuffer = NULL;
1238 postProcessParams.overlayFrameYUVBuffer = NULL;
1239
1240 mTarget->getBufferYV12(&(postProcessParams.pOutBuffer), &(postProcessParams.outBufferStride));
1241
Dharmaray Kundargi35cb2de2011-01-19 19:09:27 -0800[diff] [blame]1242 err = applyEffectsAndRenderingMode(&postProcessParams, mOutputVideoWidth, mOutputVideoHeight);
Dharmaray Kundargi643290d2011-01-16 16:02:42 -0800[diff] [blame]1243 return err;
1244}
1245
1246M4OSA_ERR VideoEditorPreviewController::setPreviewFrameRenderingMode(
1247 M4xVSS_MediaRendering mode, M4VIDEOEDITING_VideoFrameSize outputVideoSize) {
1248
1249 //LOGV("setMediaRenderingMode: outputVideoSize = %d", outputVideoSize);
1250 mRenderingMode = mode;
1251
1252 switch(outputVideoSize) {
1253 case M4VIDEOEDITING_kSQCIF:
1254 mOutputVideoWidth = 128;
1255 mOutputVideoHeight = 96;
1256 break;
1257
1258 case M4VIDEOEDITING_kQQVGA:
1259 mOutputVideoWidth = 160;
1260 mOutputVideoHeight = 120;
1261 break;
1262
1263 case M4VIDEOEDITING_kQCIF:
1264 mOutputVideoWidth = 176;
1265 mOutputVideoHeight = 144;
1266 break;
1267
1268 case M4VIDEOEDITING_kQVGA:
1269 mOutputVideoWidth = 320;
1270 mOutputVideoHeight = 240;
1271 break;
1272
1273 case M4VIDEOEDITING_kCIF:
1274 mOutputVideoWidth = 352;
1275 mOutputVideoHeight = 288;
1276 break;
1277
1278 case M4VIDEOEDITING_kVGA:
1279 mOutputVideoWidth = 640;
1280 mOutputVideoHeight = 480;
1281 break;
1282
1283 case M4VIDEOEDITING_kWVGA:
1284 mOutputVideoWidth = 800;
1285 mOutputVideoHeight = 480;
1286 break;
1287
1288 case M4VIDEOEDITING_kNTSC:
1289 mOutputVideoWidth = 720;
1290 mOutputVideoHeight = 480;
1291 break;
1292
1293 case M4VIDEOEDITING_k640_360:
1294 mOutputVideoWidth = 640;
1295 mOutputVideoHeight = 360;
1296 break;
1297
1298 case M4VIDEOEDITING_k854_480:
1299 mOutputVideoWidth = 854;
1300 mOutputVideoHeight = 480;
1301 break;
1302
1303 case M4VIDEOEDITING_kHD1280:
1304 mOutputVideoWidth = 1280;
1305 mOutputVideoHeight = 720;
1306 break;
1307
1308 case M4VIDEOEDITING_kHD1080:
1309 mOutputVideoWidth = 1080;
1310 mOutputVideoHeight = 720;
1311 break;
1312
1313 case M4VIDEOEDITING_kHD960:
1314 mOutputVideoWidth = 960;
1315 mOutputVideoHeight = 720;
1316 break;
1317
1318 default:
1319 mOutputVideoWidth = 0;
1320 mOutputVideoHeight = 0;
1321 break;
1322 }
1323
1324 return OK;
1325}
1326
1327M4OSA_ERR VideoEditorPreviewController::doImageRenderingMode(
1328 M4OSA_Void * dataPtr, M4OSA_UInt32 colorFormat, M4OSA_UInt32 videoWidth,
1329 M4OSA_UInt32 videoHeight, M4OSA_Void* outPtr) {
1330
1331 M4OSA_ERR err = M4NO_ERROR;
1332 M4VIFI_ImagePlane planeIn[3], planeOut[3];
1333 M4VIFI_UInt8 *inBuffer = M4OSA_NULL;
1334 M4OSA_UInt32 outputBufferWidth =0, outputBufferHeight=0;
1335
1336 //frameSize = (videoWidth*videoHeight*3) >> 1;
1337 inBuffer = (M4OSA_UInt8 *)dataPtr;
1338
1339 // In plane
1340 prepareYUV420ImagePlane(planeIn, videoWidth,
Dharmaray Kundargi35cb2de2011-01-19 19:09:27 -0800[diff] [blame]1341 videoHeight, (M4VIFI_UInt8 *)inBuffer, videoWidth, videoHeight);
Dharmaray Kundargi643290d2011-01-16 16:02:42 -0800[diff] [blame]1342
1343 outputBufferWidth = mOutputVideoWidth;
1344 outputBufferHeight = mOutputVideoHeight;
1345
1346 // Out plane
1347 uint8_t* outBuffer;
1348 size_t outBufferStride = 0;
1349
1350 LOGV("doMediaRendering CALL getBuffer()");
1351 mTarget->getBufferYV12(&outBuffer, &outBufferStride);
1352
1353 // Set the output YUV420 plane to be compatible with YV12 format
1354 //In YV12 format, sizes must be even
1355 M4OSA_UInt32 yv12PlaneWidth = ((mOutputVideoWidth +1)>>1)<<1;
1356 M4OSA_UInt32 yv12PlaneHeight = ((mOutputVideoHeight+1)>>1)<<1;
1357
1358 prepareYV12ImagePlane(planeOut, yv12PlaneWidth, yv12PlaneHeight,
1359 (M4OSA_UInt32)outBufferStride, (M4VIFI_UInt8 *)outBuffer);
1360
1361 err = applyRenderingMode(planeIn, planeOut, mRenderingMode);
1362 if(err != M4NO_ERROR) {
1363 LOGE("doImageRenderingMode: applyRenderingMode returned err=0x%x", err);
1364 }
1365 return err;
1366}
1367
1368} //namespace android