| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // #define LOG_NDEBUG 0 |
| #define LOG_TAG "PreviewController" |
| #include <utils/Log.h> |
| |
| #include <gui/Surface.h> |
| |
| #include "VideoEditorAudioPlayer.h" |
| #include "PreviewRenderer.h" |
| #include "M4OSA_Semaphore.h" |
| #include "M4OSA_Thread.h" |
| #include "VideoEditorPreviewController.h" |
| |
| namespace android { |
| |
| |
| VideoEditorPreviewController::VideoEditorPreviewController() |
| : mCurrentPlayer(0), |
| mThreadContext(NULL), |
| mPlayerState(VePlayerIdle), |
| mPrepareReqest(M4OSA_FALSE), |
| mClipList(NULL), |
| mNumberClipsInStoryBoard(0), |
| mNumberClipsToPreview(0), |
| mStartingClipIndex(0), |
| mPreviewLooping(M4OSA_FALSE), |
| mCallBackAfterFrameCnt(0), |
| mEffectsSettings(NULL), |
| mNumberEffects(0), |
| mCurrentClipNumber(-1), |
| mClipTotalDuration(0), |
| mCurrentVideoEffect(VIDEO_EFFECT_NONE), |
| mBackgroundAudioSetting(NULL), |
| mAudioMixPCMFileHandle(NULL), |
| mTarget(NULL), |
| mJniCookie(NULL), |
| mJniCallback(NULL), |
| mCurrentPlayedDuration(0), |
| mCurrentClipDuration(0), |
| mVideoStoryBoardTimeMsUptoFirstPreviewClip(0), |
| mOverlayState(OVERLAY_CLEAR), |
| mActivePlayerIndex(0), |
| mOutputVideoWidth(0), |
| mOutputVideoHeight(0), |
| bStopThreadInProgress(false), |
| mSemThreadWait(NULL) { |
| ALOGV("VideoEditorPreviewController"); |
| mRenderingMode = M4xVSS_kBlackBorders; |
| mIsFiftiesEffectStarted = false; |
| |
| for (int i = 0; i < kTotalNumPlayerInstances; ++i) { |
| mVePlayer[i] = NULL; |
| } |
| } |
| |
| VideoEditorPreviewController::~VideoEditorPreviewController() { |
| ALOGV("~VideoEditorPreviewController"); |
| M4OSA_UInt32 i = 0; |
| M4OSA_ERR err = M4NO_ERROR; |
| |
| // Stop the thread if its still running |
| if(mThreadContext != NULL) { |
| err = M4OSA_threadSyncStop(mThreadContext); |
| if(err != M4NO_ERROR) { |
| ALOGV("~VideoEditorPreviewController: error 0x%x \ |
| in trying to stop thread", err); |
| // Continue even if error |
| } |
| |
| err = M4OSA_threadSyncClose(mThreadContext); |
| if(err != M4NO_ERROR) { |
| ALOGE("~VideoEditorPreviewController: error 0x%x \ |
| in trying to close thread", (unsigned int) err); |
| // Continue even if error |
| } |
| |
| mThreadContext = NULL; |
| } |
| |
| for (int playerInst=0; playerInst<kTotalNumPlayerInstances; |
| playerInst++) { |
| if(mVePlayer[playerInst] != NULL) { |
| ALOGV("clearing mVePlayer %d", playerInst); |
| mVePlayer[playerInst].clear(); |
| } |
| } |
| |
| if(mClipList != NULL) { |
| // Clean up |
| for(i=0;i<mNumberClipsInStoryBoard;i++) |
| { |
| if(mClipList[i]->pFile != NULL) { |
| free(mClipList[i]->pFile); |
| mClipList[i]->pFile = NULL; |
| } |
| |
| free(mClipList[i]); |
| } |
| free(mClipList); |
| mClipList = NULL; |
| } |
| |
| if(mEffectsSettings) { |
| for(i=0;i<mNumberEffects;i++) { |
| if(mEffectsSettings[i].xVSS.pFramingBuffer != NULL) { |
| free(mEffectsSettings[i].xVSS.pFramingBuffer->pac_data); |
| |
| free(mEffectsSettings[i].xVSS.pFramingBuffer); |
| |
| mEffectsSettings[i].xVSS.pFramingBuffer = NULL; |
| } |
| } |
| free(mEffectsSettings); |
| mEffectsSettings = NULL; |
| } |
| |
| if (mAudioMixPCMFileHandle) { |
| err = M4OSA_fileReadClose (mAudioMixPCMFileHandle); |
| mAudioMixPCMFileHandle = M4OSA_NULL; |
| } |
| |
| if (mBackgroundAudioSetting != NULL) { |
| free(mBackgroundAudioSetting); |
| mBackgroundAudioSetting = NULL; |
| } |
| |
| if(mTarget != NULL) { |
| delete mTarget; |
| mTarget = NULL; |
| } |
| |
| mOverlayState = OVERLAY_CLEAR; |
| |
| ALOGV("~VideoEditorPreviewController returns"); |
| } |
| |
| M4OSA_ERR VideoEditorPreviewController::loadEditSettings( |
| M4VSS3GPP_EditSettings* pSettings,M4xVSS_AudioMixingSettings* bgmSettings) { |
| |
| M4OSA_UInt32 i = 0, iClipDuration = 0, rgbSize = 0; |
| M4VIFI_UInt8 *tmp = NULL; |
| M4OSA_ERR err = M4NO_ERROR; |
| |
| ALOGV("loadEditSettings"); |
| ALOGV("loadEditSettings Channels = %d, sampling Freq %d", |
| bgmSettings->uiNbChannels, bgmSettings->uiSamplingFrequency ); |
| bgmSettings->uiSamplingFrequency = 32000; |
| |
| ALOGV("loadEditSettings Channels = %d, sampling Freq %d", |
| bgmSettings->uiNbChannels, bgmSettings->uiSamplingFrequency ); |
| Mutex::Autolock autoLock(mLock); |
| |
| // Clean up any previous Edit settings before loading new ones |
| mCurrentVideoEffect = VIDEO_EFFECT_NONE; |
| |
| if(mAudioMixPCMFileHandle) { |
| err = M4OSA_fileReadClose (mAudioMixPCMFileHandle); |
| mAudioMixPCMFileHandle = M4OSA_NULL; |
| } |
| |
| if(mBackgroundAudioSetting != NULL) { |
| free(mBackgroundAudioSetting); |
| mBackgroundAudioSetting = NULL; |
| } |
| |
| if(mClipList != NULL) { |
| // Clean up |
| for(i=0;i<mNumberClipsInStoryBoard;i++) |
| { |
| if(mClipList[i]->pFile != NULL) { |
| free(mClipList[i]->pFile); |
| mClipList[i]->pFile = NULL; |
| } |
| |
| free(mClipList[i]); |
| } |
| free(mClipList); |
| mClipList = NULL; |
| } |
| |
| if(mEffectsSettings) { |
| for(i=0;i<mNumberEffects;i++) { |
| if(mEffectsSettings[i].xVSS.pFramingBuffer != NULL) { |
| free(mEffectsSettings[i].xVSS.pFramingBuffer->pac_data); |
| |
| free(mEffectsSettings[i].xVSS.pFramingBuffer); |
| |
| mEffectsSettings[i].xVSS.pFramingBuffer = NULL; |
| } |
| } |
| free(mEffectsSettings); |
| mEffectsSettings = NULL; |
| } |
| |
| if(mClipList == NULL) { |
| mNumberClipsInStoryBoard = pSettings->uiClipNumber; |
| ALOGV("loadEditSettings: # of Clips = %d", mNumberClipsInStoryBoard); |
| |
| mClipList = (M4VSS3GPP_ClipSettings**)M4OSA_32bitAlignedMalloc( |
| sizeof(M4VSS3GPP_ClipSettings*)*pSettings->uiClipNumber, M4VS, |
| (M4OSA_Char*)"LvPP, copy of pClipList"); |
| |
| if(NULL == mClipList) { |
| ALOGE("loadEditSettings: Malloc error"); |
| return M4ERR_ALLOC; |
| } |
| memset((void *)mClipList,0, |
| sizeof(M4VSS3GPP_ClipSettings*)*pSettings->uiClipNumber); |
| |
| for(i=0;i<pSettings->uiClipNumber;i++) { |
| |
| // Allocate current clip |
| mClipList[i] = |
| (M4VSS3GPP_ClipSettings*)M4OSA_32bitAlignedMalloc( |
| sizeof(M4VSS3GPP_ClipSettings),M4VS,(M4OSA_Char*)"clip settings"); |
| |
| if(mClipList[i] == NULL) { |
| |
| ALOGE("loadEditSettings: Allocation error for mClipList[%d]", (int)i); |
| return M4ERR_ALLOC; |
| } |
| // Copy plain structure |
| memcpy((void *)mClipList[i], |
| (void *)pSettings->pClipList[i], |
| sizeof(M4VSS3GPP_ClipSettings)); |
| |
| if(NULL != pSettings->pClipList[i]->pFile) { |
| mClipList[i]->pFile = (M4OSA_Char*)M4OSA_32bitAlignedMalloc( |
| pSettings->pClipList[i]->filePathSize, M4VS, |
| (M4OSA_Char*)"pClipSettingsDest->pFile"); |
| |
| if(NULL == mClipList[i]->pFile) |
| { |
| ALOGE("loadEditSettings : ERROR allocating filename"); |
| return M4ERR_ALLOC; |
| } |
| |
| memcpy((void *)mClipList[i]->pFile, |
| (void *)pSettings->pClipList[i]->pFile, |
| pSettings->pClipList[i]->filePathSize); |
| } |
| else { |
| ALOGE("NULL file path"); |
| return M4ERR_PARAMETER; |
| } |
| |
| // Calculate total duration of all clips |
| iClipDuration = pSettings->pClipList[i]->uiEndCutTime - |
| pSettings->pClipList[i]->uiBeginCutTime; |
| |
| mClipTotalDuration = mClipTotalDuration+iClipDuration; |
| } |
| } |
| |
| if(mEffectsSettings == NULL) { |
| mNumberEffects = pSettings->nbEffects; |
| ALOGV("loadEditSettings: mNumberEffects = %d", mNumberEffects); |
| |
| if(mNumberEffects != 0) { |
| mEffectsSettings = (M4VSS3GPP_EffectSettings*)M4OSA_32bitAlignedMalloc( |
| mNumberEffects*sizeof(M4VSS3GPP_EffectSettings), |
| M4VS, (M4OSA_Char*)"effects settings"); |
| |
| if(mEffectsSettings == NULL) { |
| ALOGE("loadEffectsSettings: Allocation error"); |
| return M4ERR_ALLOC; |
| } |
| |
| memset((void *)mEffectsSettings,0, |
| mNumberEffects*sizeof(M4VSS3GPP_EffectSettings)); |
| |
| for(i=0;i<mNumberEffects;i++) { |
| |
| mEffectsSettings[i].xVSS.pFramingFilePath = NULL; |
| mEffectsSettings[i].xVSS.pFramingBuffer = NULL; |
| mEffectsSettings[i].xVSS.pTextBuffer = NULL; |
| |
| memcpy((void *)&(mEffectsSettings[i]), |
| (void *)&(pSettings->Effects[i]), |
| sizeof(M4VSS3GPP_EffectSettings)); |
| |
| if(pSettings->Effects[i].VideoEffectType == |
| (M4VSS3GPP_VideoEffectType)M4xVSS_kVideoEffectType_Framing) { |
| // Allocate the pFraming RGB buffer |
| mEffectsSettings[i].xVSS.pFramingBuffer = |
| (M4VIFI_ImagePlane *)M4OSA_32bitAlignedMalloc(sizeof(M4VIFI_ImagePlane), |
| M4VS, (M4OSA_Char*)"lvpp framing buffer"); |
| |
| if(mEffectsSettings[i].xVSS.pFramingBuffer == NULL) { |
| ALOGE("loadEffectsSettings:Alloc error for pFramingBuf"); |
| free(mEffectsSettings); |
| mEffectsSettings = NULL; |
| return M4ERR_ALLOC; |
| } |
| |
| // Allocate the pac_data (RGB) |
| if(pSettings->Effects[i].xVSS.rgbType == M4VSS3GPP_kRGB565){ |
| rgbSize = |
| pSettings->Effects[i].xVSS.pFramingBuffer->u_width * |
| pSettings->Effects[i].xVSS.pFramingBuffer->u_height*2; |
| } |
| else if( |
| pSettings->Effects[i].xVSS.rgbType == M4VSS3GPP_kRGB888) { |
| rgbSize = |
| pSettings->Effects[i].xVSS.pFramingBuffer->u_width * |
| pSettings->Effects[i].xVSS.pFramingBuffer->u_height*3; |
| } |
| else { |
| ALOGE("loadEffectsSettings: wrong RGB type"); |
| free(mEffectsSettings); |
| mEffectsSettings = NULL; |
| return M4ERR_PARAMETER; |
| } |
| |
| tmp = (M4VIFI_UInt8 *)M4OSA_32bitAlignedMalloc(rgbSize, M4VS, |
| (M4OSA_Char*)"framing buffer pac_data"); |
| |
| if(tmp == NULL) { |
| ALOGE("loadEffectsSettings:Alloc error pFramingBuf pac"); |
| free(mEffectsSettings); |
| mEffectsSettings = NULL; |
| free(mEffectsSettings[i].xVSS.pFramingBuffer); |
| |
| mEffectsSettings[i].xVSS.pFramingBuffer = NULL; |
| return M4ERR_ALLOC; |
| } |
| /* Initialize the pFramingBuffer*/ |
| mEffectsSettings[i].xVSS.pFramingBuffer->pac_data = tmp; |
| mEffectsSettings[i].xVSS.pFramingBuffer->u_height = |
| pSettings->Effects[i].xVSS.pFramingBuffer->u_height; |
| |
| mEffectsSettings[i].xVSS.pFramingBuffer->u_width = |
| pSettings->Effects[i].xVSS.pFramingBuffer->u_width; |
| |
| mEffectsSettings[i].xVSS.pFramingBuffer->u_stride = |
| pSettings->Effects[i].xVSS.pFramingBuffer->u_stride; |
| |
| mEffectsSettings[i].xVSS.pFramingBuffer->u_topleft = |
| pSettings->Effects[i].xVSS.pFramingBuffer->u_topleft; |
| |
| mEffectsSettings[i].xVSS.uialphaBlendingStart = |
| pSettings->Effects[i].xVSS.uialphaBlendingStart; |
| |
| mEffectsSettings[i].xVSS.uialphaBlendingMiddle = |
| pSettings->Effects[i].xVSS.uialphaBlendingMiddle; |
| |
| mEffectsSettings[i].xVSS.uialphaBlendingEnd = |
| pSettings->Effects[i].xVSS.uialphaBlendingEnd; |
| |
| mEffectsSettings[i].xVSS.uialphaBlendingFadeInTime = |
| pSettings->Effects[i].xVSS.uialphaBlendingFadeInTime; |
| mEffectsSettings[i].xVSS.uialphaBlendingFadeOutTime = |
| pSettings->Effects[i].xVSS.uialphaBlendingFadeOutTime; |
| |
| // Copy the pFraming data |
| memcpy((void *) |
| mEffectsSettings[i].xVSS.pFramingBuffer->pac_data, |
| (void *)pSettings->Effects[i].xVSS.pFramingBuffer->pac_data, |
| rgbSize); |
| |
| mEffectsSettings[i].xVSS.rgbType = |
| pSettings->Effects[i].xVSS.rgbType; |
| } |
| } |
| } |
| } |
| |
| if (mBackgroundAudioSetting == NULL) { |
| |
| mBackgroundAudioSetting = (M4xVSS_AudioMixingSettings*)M4OSA_32bitAlignedMalloc( |
| sizeof(M4xVSS_AudioMixingSettings), M4VS, |
| (M4OSA_Char*)"LvPP, copy of bgmSettings"); |
| |
| if(NULL == mBackgroundAudioSetting) { |
| ALOGE("loadEditSettings: mBackgroundAudioSetting Malloc failed"); |
| return M4ERR_ALLOC; |
| } |
| |
| memset((void *)mBackgroundAudioSetting, 0,sizeof(M4xVSS_AudioMixingSettings*)); |
| memcpy((void *)mBackgroundAudioSetting, (void *)bgmSettings, sizeof(M4xVSS_AudioMixingSettings)); |
| |
| if ( mBackgroundAudioSetting->pFile != M4OSA_NULL ) { |
| |
| mBackgroundAudioSetting->pFile = (M4OSA_Void*) bgmSettings->pPCMFilePath; |
| mBackgroundAudioSetting->uiNbChannels = 2; |
| mBackgroundAudioSetting->uiSamplingFrequency = 32000; |
| } |
| |
| // Open the BG file |
| if ( mBackgroundAudioSetting->pFile != M4OSA_NULL ) { |
| err = M4OSA_fileReadOpen(&mAudioMixPCMFileHandle, |
| mBackgroundAudioSetting->pFile, M4OSA_kFileRead); |
| |
| if (err != M4NO_ERROR) { |
| ALOGE("loadEditSettings: mBackgroundAudio PCM File open failed"); |
| return M4ERR_PARAMETER; |
| } |
| } |
| } |
| |
| mOutputVideoSize = pSettings->xVSS.outputVideoSize; |
| mFrameStr.pBuffer = M4OSA_NULL; |
| return M4NO_ERROR; |
| } |
| |
| M4OSA_ERR VideoEditorPreviewController::setSurface(const sp<Surface> &surface) { |
| ALOGV("setSurface"); |
| Mutex::Autolock autoLock(mLock); |
| |
| mSurface = surface; |
| return M4NO_ERROR; |
| } |
| |
| M4OSA_ERR VideoEditorPreviewController::startPreview( |
| M4OSA_UInt32 fromMS, M4OSA_Int32 toMs, M4OSA_UInt16 callBackAfterFrameCount, |
| M4OSA_Bool loop) { |
| |
| M4OSA_ERR err = M4NO_ERROR; |
| M4OSA_UInt32 i = 0, iIncrementedDuration = 0; |
| ALOGV("startPreview"); |
| |
| if(fromMS > (M4OSA_UInt32)toMs) { |
| ALOGE("startPreview: fromMS > toMs"); |
| return M4ERR_PARAMETER; |
| } |
| |
| if(toMs == 0) { |
| ALOGE("startPreview: toMs is 0"); |
| return M4ERR_PARAMETER; |
| } |
| |
| // If already started, then stop preview first |
| for(int playerInst=0; playerInst<kTotalNumPlayerInstances; playerInst++) { |
| if(mVePlayer[playerInst] != NULL) { |
| ALOGV("startPreview: stopping previously started preview playback"); |
| stopPreview(); |
| break; |
| } |
| } |
| |
| // If renderPreview was called previously, then delete Renderer object first |
| if(mTarget != NULL) { |
| ALOGV("startPreview: delete previous PreviewRenderer"); |
| delete mTarget; |
| mTarget = NULL; |
| } |
| |
| // Create Audio player to be used for entire |
| // storyboard duration |
| mVEAudioSink = new VideoEditorPlayer::VeAudioOutput(); |
| mVEAudioPlayer = new VideoEditorAudioPlayer(mVEAudioSink); |
| mVEAudioPlayer->setAudioMixSettings(mBackgroundAudioSetting); |
| mVEAudioPlayer->setAudioMixPCMFileHandle(mAudioMixPCMFileHandle); |
| |
| // Create Video Renderer to be used for the entire storyboard duration. |
| uint32_t width, height; |
| getVideoSizeByResolution(mOutputVideoSize, &width, &height); |
| mNativeWindowRenderer = new NativeWindowRenderer(mSurface, width, height); |
| |
| ALOGV("startPreview: loop = %d", loop); |
| mPreviewLooping = loop; |
| |
| ALOGV("startPreview: callBackAfterFrameCount = %d", callBackAfterFrameCount); |
| mCallBackAfterFrameCnt = callBackAfterFrameCount; |
| |
| for (int playerInst=0; playerInst<kTotalNumPlayerInstances; playerInst++) { |
| mVePlayer[playerInst] = new VideoEditorPlayer(mNativeWindowRenderer); |
| if(mVePlayer[playerInst] == NULL) { |
| ALOGE("startPreview:Error creating VideoEditorPlayer %d",playerInst); |
| return M4ERR_ALLOC; |
| } |
| ALOGV("startPreview: object created"); |
| |
| mVePlayer[playerInst]->setNotifyCallback(this,(notify_callback_f)notify); |
| ALOGV("startPreview: notify callback set"); |
| |
| mVePlayer[playerInst]->loadEffectsSettings(mEffectsSettings, |
| mNumberEffects); |
| ALOGV("startPreview: effects settings loaded"); |
| |
| mVePlayer[playerInst]->loadAudioMixSettings(mBackgroundAudioSetting); |
| ALOGV("startPreview: AudioMixSettings settings loaded"); |
| |
| mVePlayer[playerInst]->setAudioMixPCMFileHandle(mAudioMixPCMFileHandle); |
| ALOGV("startPreview: AudioMixPCMFileHandle set"); |
| |
| mVePlayer[playerInst]->setProgressCallbackInterval( |
| mCallBackAfterFrameCnt); |
| ALOGV("startPreview: setProgressCallBackInterval"); |
| } |
| |
| mPlayerState = VePlayerIdle; |
| mPrepareReqest = M4OSA_FALSE; |
| |
| if(fromMS == 0) { |
| mCurrentClipNumber = -1; |
| // Save original value |
| mFirstPreviewClipBeginTime = mClipList[0]->uiBeginCutTime; |
| mVideoStoryBoardTimeMsUptoFirstPreviewClip = 0; |
| } |
| else { |
| ALOGV("startPreview: fromMS=%d", fromMS); |
| if(fromMS >= mClipTotalDuration) { |
| ALOGE("startPreview: fromMS >= mClipTotalDuration"); |
| return M4ERR_PARAMETER; |
| } |
| for(i=0;i<mNumberClipsInStoryBoard;i++) { |
| if(fromMS < (iIncrementedDuration + (mClipList[i]->uiEndCutTime - |
| mClipList[i]->uiBeginCutTime))) { |
| // Set to 1 index below, |
| // as threadProcess first increments the clip index |
| // and then processes clip in thread loop |
| mCurrentClipNumber = i-1; |
| ALOGD("startPreview:mCurrentClipNumber = %d fromMS=%d",i,fromMS); |
| |
| // Save original value |
| mFirstPreviewClipBeginTime = mClipList[i]->uiBeginCutTime; |
| |
| // Set correct begin time to start playback |
| if((fromMS+mClipList[i]->uiBeginCutTime) > |
| (iIncrementedDuration+mClipList[i]->uiBeginCutTime)) { |
| |
| mClipList[i]->uiBeginCutTime = |
| mClipList[i]->uiBeginCutTime + |
| (fromMS - iIncrementedDuration); |
| } |
| break; |
| } |
| else { |
| iIncrementedDuration = iIncrementedDuration + |
| (mClipList[i]->uiEndCutTime - mClipList[i]->uiBeginCutTime); |
| } |
| } |
| mVideoStoryBoardTimeMsUptoFirstPreviewClip = iIncrementedDuration; |
| } |
| |
| for (int playerInst=0; playerInst<kTotalNumPlayerInstances; playerInst++) { |
| mVePlayer[playerInst]->setAudioMixStoryBoardParam(fromMS, |
| mFirstPreviewClipBeginTime, |
| mClipList[i]->ClipProperties.uiClipAudioVolumePercentage); |
| |
| ALOGV("startPreview:setAudioMixStoryBoardSkimTimeStamp set %d cuttime \ |
| %d", fromMS, mFirstPreviewClipBeginTime); |
| } |
| |
| mStartingClipIndex = mCurrentClipNumber+1; |
| |
| // Start playing with player instance 0 |
| mCurrentPlayer = 0; |
| mActivePlayerIndex = 0; |
| |
| if(toMs == -1) { |
| ALOGV("startPreview: Preview till end of storyboard"); |
| mNumberClipsToPreview = mNumberClipsInStoryBoard; |
| // Save original value |
| mLastPreviewClipEndTime = |
| mClipList[mNumberClipsToPreview-1]->uiEndCutTime; |
| } |
| else { |
| ALOGV("startPreview: toMs=%d", toMs); |
| if((M4OSA_UInt32)toMs > mClipTotalDuration) { |
| ALOGE("startPreview: toMs > mClipTotalDuration"); |
| return M4ERR_PARAMETER; |
| } |
| |
| iIncrementedDuration = 0; |
| |
| for(i=0;i<mNumberClipsInStoryBoard;i++) { |
| if((M4OSA_UInt32)toMs <= (iIncrementedDuration + |
| (mClipList[i]->uiEndCutTime - mClipList[i]->uiBeginCutTime))) { |
| // Save original value |
| mLastPreviewClipEndTime = mClipList[i]->uiEndCutTime; |
| // Set the end cut time of clip index i to toMs |
| mClipList[i]->uiEndCutTime = toMs; |
| |
| // Number of clips to be previewed is from index 0 to i |
| // increment by 1 as i starts from 0 |
| mNumberClipsToPreview = i+1; |
| break; |
| } |
| else { |
| iIncrementedDuration = iIncrementedDuration + |
| (mClipList[i]->uiEndCutTime - mClipList[i]->uiBeginCutTime); |
| } |
| } |
| } |
| |
| // Open the thread semaphore |
| M4OSA_semaphoreOpen(&mSemThreadWait, 1); |
| |
| // Open the preview process thread |
| err = M4OSA_threadSyncOpen(&mThreadContext, (M4OSA_ThreadDoIt)threadProc); |
| if (M4NO_ERROR != err) { |
| ALOGE("VideoEditorPreviewController:M4OSA_threadSyncOpen error %d", (int) err); |
| return err; |
| } |
| |
| // Set the stacksize |
| err = M4OSA_threadSyncSetOption(mThreadContext, M4OSA_ThreadStackSize, |
| (M4OSA_DataOption) kPreviewThreadStackSize); |
| |
| if (M4NO_ERROR != err) { |
| ALOGE("VideoEditorPreviewController: threadSyncSetOption error %d", (int) err); |
| M4OSA_threadSyncClose(mThreadContext); |
| mThreadContext = NULL; |
| return err; |
| } |
| |
| // Start the thread |
| err = M4OSA_threadSyncStart(mThreadContext, (M4OSA_Void*)this); |
| if (M4NO_ERROR != err) { |
| ALOGE("VideoEditorPreviewController: threadSyncStart error %d", (int) err); |
| M4OSA_threadSyncClose(mThreadContext); |
| mThreadContext = NULL; |
| return err; |
| } |
| bStopThreadInProgress = false; |
| |
| ALOGV("startPreview: process thread started"); |
| return M4NO_ERROR; |
| } |
| |
| M4OSA_UInt32 VideoEditorPreviewController::stopPreview() { |
| M4OSA_ERR err = M4NO_ERROR; |
| uint32_t lastRenderedFrameTimeMs = 0; |
| ALOGV("stopPreview"); |
| |
| // Stop the thread |
| if(mThreadContext != NULL) { |
| bStopThreadInProgress = true; |
| { |
| Mutex::Autolock autoLock(mLockSem); |
| if (mSemThreadWait != NULL) { |
| err = M4OSA_semaphorePost(mSemThreadWait); |
| } |
| } |
| |
| err = M4OSA_threadSyncStop(mThreadContext); |
| if(err != M4NO_ERROR) { |
| ALOGV("stopPreview: error 0x%x in trying to stop thread", err); |
| // Continue even if error |
| } |
| |
| err = M4OSA_threadSyncClose(mThreadContext); |
| if(err != M4NO_ERROR) { |
| ALOGE("stopPreview: error 0x%x in trying to close thread", (unsigned int)err); |
| // Continue even if error |
| } |
| |
| mThreadContext = NULL; |
| } |
| |
| // Close the semaphore first |
| { |
| Mutex::Autolock autoLock(mLockSem); |
| if(mSemThreadWait != NULL) { |
| err = M4OSA_semaphoreClose(mSemThreadWait); |
| ALOGV("stopPreview: close semaphore returns 0x%x", err); |
| mSemThreadWait = NULL; |
| } |
| } |
| |
| for (int playerInst=0; playerInst<kTotalNumPlayerInstances; playerInst++) { |
| if(mVePlayer[playerInst] != NULL) { |
| if(mVePlayer[playerInst]->isPlaying()) { |
| ALOGV("stop the player first"); |
| mVePlayer[playerInst]->stop(); |
| } |
| if (playerInst == mActivePlayerIndex) { |
| // Return the last rendered frame time stamp |
| mVePlayer[mActivePlayerIndex]->getLastRenderedTimeMs(&lastRenderedFrameTimeMs); |
| } |
| |
| //This is used to syncronize onStreamDone() in PreviewPlayer and |
| //stopPreview() in PreviewController |
| sp<VideoEditorPlayer> temp = mVePlayer[playerInst]; |
| temp->acquireLock(); |
| ALOGV("stopPreview: clearing mVePlayer"); |
| mVePlayer[playerInst].clear(); |
| mVePlayer[playerInst] = NULL; |
| temp->releaseLock(); |
| } |
| } |
| ALOGV("stopPreview: clear audioSink and audioPlayer"); |
| mVEAudioSink.clear(); |
| if (mVEAudioPlayer) { |
| delete mVEAudioPlayer; |
| mVEAudioPlayer = NULL; |
| } |
| |
| delete mNativeWindowRenderer; |
| mNativeWindowRenderer = NULL; |
| |
| // If image file playing, then free the buffer pointer |
| if(mFrameStr.pBuffer != M4OSA_NULL) { |
| free(mFrameStr.pBuffer); |
| mFrameStr.pBuffer = M4OSA_NULL; |
| } |
| |
| // Reset original begin cuttime of first previewed clip*/ |
| mClipList[mStartingClipIndex]->uiBeginCutTime = mFirstPreviewClipBeginTime; |
| // Reset original end cuttime of last previewed clip*/ |
| mClipList[mNumberClipsToPreview-1]->uiEndCutTime = mLastPreviewClipEndTime; |
| |
| mPlayerState = VePlayerIdle; |
| mPrepareReqest = M4OSA_FALSE; |
| |
| mCurrentPlayedDuration = 0; |
| mCurrentClipDuration = 0; |
| mRenderingMode = M4xVSS_kBlackBorders; |
| mOutputVideoWidth = 0; |
| mOutputVideoHeight = 0; |
| |
| ALOGV("stopPreview() lastRenderedFrameTimeMs %ld", lastRenderedFrameTimeMs); |
| return lastRenderedFrameTimeMs; |
| } |
| |
| M4OSA_ERR VideoEditorPreviewController::clearSurface( |
| const sp<Surface> &surface, VideoEditor_renderPreviewFrameStr* pFrameInfo) { |
| |
| M4OSA_ERR err = M4NO_ERROR; |
| VideoEditor_renderPreviewFrameStr* pFrameStr = pFrameInfo; |
| M4OSA_UInt32 outputBufferWidth =0, outputBufferHeight=0; |
| M4VIFI_ImagePlane planeOut[3]; |
| ALOGV("Inside preview clear frame"); |
| |
| Mutex::Autolock autoLock(mLock); |
| |
| // Delete previous renderer instance |
| if(mTarget != NULL) { |
| delete mTarget; |
| mTarget = NULL; |
| } |
| |
| outputBufferWidth = pFrameStr->uiFrameWidth; |
| outputBufferHeight = pFrameStr->uiFrameHeight; |
| |
| // Initialize the renderer |
| if(mTarget == NULL) { |
| |
| mTarget = PreviewRenderer::CreatePreviewRenderer( |
| surface, |
| outputBufferWidth, outputBufferHeight); |
| |
| if(mTarget == NULL) { |
| ALOGE("renderPreviewFrame: cannot create PreviewRenderer"); |
| return M4ERR_ALLOC; |
| } |
| } |
| |
| // Out plane |
| uint8_t* outBuffer; |
| size_t outBufferStride = 0; |
| |
| ALOGV("doMediaRendering CALL getBuffer()"); |
| mTarget->getBufferYV12(&outBuffer, &outBufferStride); |
| |
| // Set the output YUV420 plane to be compatible with YV12 format |
| //In YV12 format, sizes must be even |
| M4OSA_UInt32 yv12PlaneWidth = ((outputBufferWidth +1)>>1)<<1; |
| M4OSA_UInt32 yv12PlaneHeight = ((outputBufferHeight+1)>>1)<<1; |
| |
| prepareYV12ImagePlane(planeOut, yv12PlaneWidth, yv12PlaneHeight, |
| (M4OSA_UInt32)outBufferStride, (M4VIFI_UInt8 *)outBuffer); |
| |
| /* Fill the surface with black frame */ |
| memset((void *)planeOut[0].pac_data,0x00,planeOut[0].u_width * |
| planeOut[0].u_height * 1.5); |
| memset((void *)planeOut[1].pac_data,128,planeOut[1].u_width * |
| planeOut[1].u_height); |
| memset((void *)planeOut[2].pac_data,128,planeOut[2].u_width * |
| planeOut[2].u_height); |
| |
| mTarget->renderYV12(); |
| return err; |
| } |
| |
| M4OSA_ERR VideoEditorPreviewController::renderPreviewFrame( |
| const sp<Surface> &surface, |
| VideoEditor_renderPreviewFrameStr* pFrameInfo, |
| VideoEditorCurretEditInfo *pCurrEditInfo) { |
| |
| M4OSA_ERR err = M4NO_ERROR; |
| M4OSA_UInt32 i = 0, iIncrementedDuration = 0, tnTimeMs=0, framesize =0; |
| VideoEditor_renderPreviewFrameStr* pFrameStr = pFrameInfo; |
| M4VIFI_UInt8 *pixelArray = NULL; |
| Mutex::Autolock autoLock(mLock); |
| |
| if (pCurrEditInfo != NULL) { |
| pCurrEditInfo->overlaySettingsIndex = -1; |
| } |
| // Delete previous renderer instance |
| if(mTarget != NULL) { |
| delete mTarget; |
| mTarget = NULL; |
| } |
| |
| if(mOutputVideoWidth == 0) { |
| mOutputVideoWidth = pFrameStr->uiFrameWidth; |
| } |
| |
| if(mOutputVideoHeight == 0) { |
| mOutputVideoHeight = pFrameStr->uiFrameHeight; |
| } |
| |
| // Initialize the renderer |
| if(mTarget == NULL) { |
| mTarget = PreviewRenderer::CreatePreviewRenderer( |
| surface, |
| mOutputVideoWidth, mOutputVideoHeight); |
| |
| if(mTarget == NULL) { |
| ALOGE("renderPreviewFrame: cannot create PreviewRenderer"); |
| return M4ERR_ALLOC; |
| } |
| } |
| |
| pixelArray = NULL; |
| |
| // Apply rotation if required |
| if (pFrameStr->videoRotationDegree != 0) { |
| err = applyVideoRotation((M4OSA_Void *)pFrameStr->pBuffer, |
| pFrameStr->uiFrameWidth, pFrameStr->uiFrameHeight, |
| pFrameStr->videoRotationDegree); |
| if (M4NO_ERROR != err) { |
| ALOGE("renderPreviewFrame: cannot rotate video, err 0x%x", (unsigned int)err); |
| delete mTarget; |
| mTarget = NULL; |
| return err; |
| } else { |
| // Video rotation done. |
| // Swap width and height if 90 or 270 degrees |
| if (pFrameStr->videoRotationDegree != 180) { |
| int32_t temp = pFrameStr->uiFrameWidth; |
| pFrameStr->uiFrameWidth = pFrameStr->uiFrameHeight; |
| pFrameStr->uiFrameHeight = temp; |
| } |
| } |
| } |
| // Postprocessing (apply video effect) |
| if(pFrameStr->bApplyEffect == M4OSA_TRUE) { |
| |
| for(i=0;i<mNumberEffects;i++) { |
| // First check if effect starttime matches the clip being previewed |
| if((mEffectsSettings[i].uiStartTime < pFrameStr->clipBeginCutTime) |
| ||(mEffectsSettings[i].uiStartTime >= pFrameStr->clipEndCutTime)) { |
| // This effect doesn't belong to this clip, check next one |
| continue; |
| } |
| if((mEffectsSettings[i].uiStartTime <= pFrameStr->timeMs) && |
| ((mEffectsSettings[i].uiStartTime+mEffectsSettings[i].uiDuration) >= |
| pFrameStr->timeMs) && (mEffectsSettings[i].uiDuration != 0)) { |
| setVideoEffectType(mEffectsSettings[i].VideoEffectType, TRUE); |
| } |
| else { |
| setVideoEffectType(mEffectsSettings[i].VideoEffectType, FALSE); |
| } |
| } |
| |
| //Provide the overlay Update indication when there is an overlay effect |
| if (mCurrentVideoEffect & VIDEO_EFFECT_FRAMING) { |
| M4OSA_UInt32 index; |
| mCurrentVideoEffect &= ~VIDEO_EFFECT_FRAMING; //never apply framing here. |
| |
| // Find the effect in effectSettings array |
| for (index = 0; index < mNumberEffects; index++) { |
| if(mEffectsSettings[index].VideoEffectType == |
| (M4VSS3GPP_VideoEffectType)M4xVSS_kVideoEffectType_Framing) { |
| |
| if((mEffectsSettings[index].uiStartTime <= pFrameInfo->timeMs) && |
| ((mEffectsSettings[index].uiStartTime+ |
| mEffectsSettings[index].uiDuration) >= pFrameInfo->timeMs)) |
| { |
| break; |
| } |
| } |
| } |
| if ((index < mNumberEffects) && (pCurrEditInfo != NULL)) { |
| pCurrEditInfo->overlaySettingsIndex = index; |
| ALOGV("Framing index = %d", index); |
| } else { |
| ALOGV("No framing effects found"); |
| } |
| } |
| |
| if(mCurrentVideoEffect != VIDEO_EFFECT_NONE) { |
| err = applyVideoEffect((M4OSA_Void *)pFrameStr->pBuffer, |
| OMX_COLOR_FormatYUV420Planar, pFrameStr->uiFrameWidth, |
| pFrameStr->uiFrameHeight, pFrameStr->timeMs, |
| (M4OSA_Void *)pixelArray); |
| |
| if(err != M4NO_ERROR) { |
| ALOGE("renderPreviewFrame: applyVideoEffect error 0x%x", (unsigned int)err); |
| delete mTarget; |
| mTarget = NULL; |
| free(pixelArray); |
| pixelArray = NULL; |
| return err; |
| } |
| mCurrentVideoEffect = VIDEO_EFFECT_NONE; |
| } |
| else { |
| // Apply the rendering mode |
| err = doImageRenderingMode((M4OSA_Void *)pFrameStr->pBuffer, |
| OMX_COLOR_FormatYUV420Planar, pFrameStr->uiFrameWidth, |
| pFrameStr->uiFrameHeight, (M4OSA_Void *)pixelArray); |
| |
| if(err != M4NO_ERROR) { |
| ALOGE("renderPreviewFrame:doImageRenderingMode error 0x%x", (unsigned int)err); |
| delete mTarget; |
| mTarget = NULL; |
| free(pixelArray); |
| pixelArray = NULL; |
| return err; |
| } |
| } |
| } |
| else { |
| // Apply the rendering mode |
| err = doImageRenderingMode((M4OSA_Void *)pFrameStr->pBuffer, |
| OMX_COLOR_FormatYUV420Planar, pFrameStr->uiFrameWidth, |
| pFrameStr->uiFrameHeight, (M4OSA_Void *)pixelArray); |
| |
| if(err != M4NO_ERROR) { |
| ALOGE("renderPreviewFrame: doImageRenderingMode error 0x%x", (unsigned int)err); |
| delete mTarget; |
| mTarget = NULL; |
| free(pixelArray); |
| pixelArray = NULL; |
| return err; |
| } |
| } |
| |
| mTarget->renderYV12(); |
| return err; |
| } |
| |
| M4OSA_Void VideoEditorPreviewController::setJniCallback(void* cookie, |
| jni_progress_callback_fct callbackFct) { |
| //ALOGV("setJniCallback"); |
| mJniCookie = cookie; |
| mJniCallback = callbackFct; |
| } |
| |
| M4OSA_ERR VideoEditorPreviewController::preparePlayer( |
| void* param, int playerInstance, int index) { |
| |
| M4OSA_ERR err = M4NO_ERROR; |
| VideoEditorPreviewController *pController = |
| (VideoEditorPreviewController *)param; |
| |
| ALOGV("preparePlayer: instance %d file %d", playerInstance, index); |
| |
| const char* fileName = (const char*) pController->mClipList[index]->pFile; |
| pController->mVePlayer[playerInstance]->setDataSource(fileName, NULL); |
| |
| ALOGV("preparePlayer: setDataSource instance %s", |
| (const char *)pController->mClipList[index]->pFile); |
| |
| pController->mVePlayer[playerInstance]->setVideoSurface( |
| pController->mSurface); |
| ALOGV("preparePlayer: setVideoSurface"); |
| |
| pController->mVePlayer[playerInstance]->setMediaRenderingMode( |
| pController->mClipList[index]->xVSS.MediaRendering, |
| pController->mOutputVideoSize); |
| ALOGV("preparePlayer: setMediaRenderingMode"); |
| |
| if((M4OSA_UInt32)index == pController->mStartingClipIndex) { |
| pController->mVePlayer[playerInstance]->setPlaybackBeginTime( |
| pController->mFirstPreviewClipBeginTime); |
| } |
| else { |
| pController->mVePlayer[playerInstance]->setPlaybackBeginTime( |
| pController->mClipList[index]->uiBeginCutTime); |
| } |
| ALOGV("preparePlayer: setPlaybackBeginTime(%d)", |
| pController->mClipList[index]->uiBeginCutTime); |
| |
| pController->mVePlayer[playerInstance]->setPlaybackEndTime( |
| pController->mClipList[index]->uiEndCutTime); |
| ALOGV("preparePlayer: setPlaybackEndTime(%d)", |
| pController->mClipList[index]->uiEndCutTime); |
| |
| if(pController->mClipList[index]->FileType == M4VIDEOEDITING_kFileType_ARGB8888) { |
| pController->mVePlayer[playerInstance]->setImageClipProperties( |
| pController->mClipList[index]->ClipProperties.uiVideoWidth, |
| pController->mClipList[index]->ClipProperties.uiVideoHeight); |
| ALOGV("preparePlayer: setImageClipProperties"); |
| } |
| |
| pController->mVePlayer[playerInstance]->prepare(); |
| ALOGV("preparePlayer: prepared"); |
| |
| if(pController->mClipList[index]->uiBeginCutTime > 0) { |
| pController->mVePlayer[playerInstance]->seekTo( |
| pController->mClipList[index]->uiBeginCutTime); |
| |
| ALOGV("preparePlayer: seekTo(%d)", |
| pController->mClipList[index]->uiBeginCutTime); |
| } |
| pController->mVePlayer[pController->mCurrentPlayer]->setAudioPlayer(pController->mVEAudioPlayer); |
| |
| pController->mVePlayer[playerInstance]->readFirstVideoFrame(); |
| ALOGV("preparePlayer: readFirstVideoFrame of clip"); |
| |
| return err; |
| } |
| |
| M4OSA_ERR VideoEditorPreviewController::threadProc(M4OSA_Void* param) { |
| M4OSA_ERR err = M4NO_ERROR; |
| M4OSA_Int32 index = 0; |
| VideoEditorPreviewController *pController = |
| (VideoEditorPreviewController *)param; |
| |
| ALOGV("inside threadProc"); |
| if(pController->mPlayerState == VePlayerIdle) { |
| (pController->mCurrentClipNumber)++; |
| |
| ALOGD("threadProc: playing file index %d total clips %d", |
| pController->mCurrentClipNumber, pController->mNumberClipsToPreview); |
| |
| if((M4OSA_UInt32)pController->mCurrentClipNumber >= |
| pController->mNumberClipsToPreview) { |
| |
| ALOGD("All clips previewed"); |
| |
| pController->mCurrentPlayedDuration = 0; |
| pController->mCurrentClipDuration = 0; |
| pController->mCurrentPlayer = 0; |
| |
| if(pController->mPreviewLooping == M4OSA_TRUE) { |
| pController->mCurrentClipNumber = |
| pController->mStartingClipIndex; |
| |
| ALOGD("Preview looping TRUE, restarting from clip index %d", |
| pController->mCurrentClipNumber); |
| |
| // Reset the story board timestamp inside the player |
| for (int playerInst=0; playerInst<kTotalNumPlayerInstances; |
| playerInst++) { |
| pController->mVePlayer[playerInst]->resetJniCallbackTimeStamp(); |
| } |
| } |
| else { |
| M4OSA_UInt32 endArgs = 0; |
| if(pController->mJniCallback != NULL) { |
| pController->mJniCallback( |
| pController->mJniCookie, MSG_TYPE_PREVIEW_END, &endArgs); |
| } |
| pController->mPlayerState = VePlayerAutoStop; |
| |
| // Reset original begin cuttime of first previewed clip |
| pController->mClipList[pController->mStartingClipIndex]->uiBeginCutTime = |
| pController->mFirstPreviewClipBeginTime; |
| // Reset original end cuttime of last previewed clip |
| pController->mClipList[pController->mNumberClipsToPreview-1]->uiEndCutTime = |
| pController->mLastPreviewClipEndTime; |
| |
| // Return a warning to M4OSA thread handler |
| // so that thread is moved from executing state to open state |
| return M4WAR_NO_MORE_STREAM; |
| } |
| } |
| |
| index=pController->mCurrentClipNumber; |
| if((M4OSA_UInt32)pController->mCurrentClipNumber == pController->mStartingClipIndex) { |
| pController->mCurrentPlayedDuration += |
| pController->mVideoStoryBoardTimeMsUptoFirstPreviewClip; |
| |
| pController->mCurrentClipDuration = |
| pController->mClipList[pController->mCurrentClipNumber]->uiEndCutTime |
| - pController->mFirstPreviewClipBeginTime; |
| |
| preparePlayer((void*)pController, pController->mCurrentPlayer, index); |
| } |
| else { |
| pController->mCurrentPlayedDuration += |
| pController->mCurrentClipDuration; |
| |
| pController->mCurrentClipDuration = |
| pController->mClipList[pController->mCurrentClipNumber]->uiEndCutTime - |
| pController->mClipList[pController->mCurrentClipNumber]->uiBeginCutTime; |
| } |
| |
| pController->mVePlayer[pController->mCurrentPlayer]->setStoryboardStartTime( |
| pController->mCurrentPlayedDuration); |
| ALOGV("threadProc: setStoryboardStartTime"); |
| |
| // Set the next clip duration for Audio mix here |
| if((M4OSA_UInt32)pController->mCurrentClipNumber != pController->mStartingClipIndex) { |
| |
| pController->mVePlayer[pController->mCurrentPlayer]->setAudioMixStoryBoardParam( |
| pController->mCurrentPlayedDuration, |
| pController->mClipList[index]->uiBeginCutTime, |
| pController->mClipList[index]->ClipProperties.uiClipAudioVolumePercentage); |
| |
| ALOGV("threadProc: setAudioMixStoryBoardParam fromMS %d \ |
| ClipBeginTime %d", pController->mCurrentPlayedDuration + |
| pController->mClipList[index]->uiBeginCutTime, |
| pController->mClipList[index]->uiBeginCutTime, |
| pController->mClipList[index]->ClipProperties.uiClipAudioVolumePercentage); |
| } |
| // Capture the active player being used |
| pController->mActivePlayerIndex = pController->mCurrentPlayer; |
| |
| pController->mVePlayer[pController->mCurrentPlayer]->start(); |
| ALOGV("threadProc: started"); |
| |
| pController->mPlayerState = VePlayerBusy; |
| |
| } else if(pController->mPlayerState == VePlayerAutoStop) { |
| ALOGV("Preview completed..auto stop the player"); |
| } else if ((pController->mPlayerState == VePlayerBusy) && (pController->mPrepareReqest)) { |
| // Prepare the player here |
| pController->mPrepareReqest = M4OSA_FALSE; |
| preparePlayer((void*)pController, pController->mCurrentPlayer, |
| pController->mCurrentClipNumber+1); |
| if (pController->mSemThreadWait != NULL) { |
| err = M4OSA_semaphoreWait(pController->mSemThreadWait, |
| M4OSA_WAIT_FOREVER); |
| } |
| } else { |
| if (!pController->bStopThreadInProgress) { |
| ALOGV("threadProc: state busy...wait for sem"); |
| if (pController->mSemThreadWait != NULL) { |
| err = M4OSA_semaphoreWait(pController->mSemThreadWait, |
| M4OSA_WAIT_FOREVER); |
| } |
| } |
| ALOGV("threadProc: sem wait returned err = 0x%x", err); |
| } |
| |
| //Always return M4NO_ERROR to ensure the thread keeps running |
| return M4NO_ERROR; |
| } |
| |
| void VideoEditorPreviewController::notify( |
| void* cookie, int msg, int ext1, int ext2) |
| { |
| VideoEditorPreviewController *pController = |
| (VideoEditorPreviewController *)cookie; |
| |
| M4OSA_ERR err = M4NO_ERROR; |
| uint32_t clipDuration = 0; |
| switch (msg) { |
| case MEDIA_NOP: // interface test message |
| ALOGV("MEDIA_NOP"); |
| break; |
| case MEDIA_PREPARED: |
| ALOGV("MEDIA_PREPARED"); |
| break; |
| case MEDIA_PLAYBACK_COMPLETE: |
| { |
| ALOGD("notify:MEDIA_PLAYBACK_COMPLETE, mCurrentClipNumber = %d", |
| pController->mCurrentClipNumber); |
| pController->mPlayerState = VePlayerIdle; |
| |
| //send progress callback with last frame timestamp |
| if((M4OSA_UInt32)pController->mCurrentClipNumber == |
| pController->mStartingClipIndex) { |
| clipDuration = |
| pController->mClipList[pController->mCurrentClipNumber]->uiEndCutTime |
| - pController->mFirstPreviewClipBeginTime; |
| } |
| else { |
| clipDuration = |
| pController->mClipList[pController->mCurrentClipNumber]->uiEndCutTime |
| - pController->mClipList[pController->mCurrentClipNumber]->uiBeginCutTime; |
| } |
| |
| M4OSA_UInt32 playedDuration = clipDuration+pController->mCurrentPlayedDuration; |
| pController->mJniCallback( |
| pController->mJniCookie, MSG_TYPE_PROGRESS_INDICATION, |
| &playedDuration); |
| |
| if ((pController->mOverlayState == OVERLAY_UPDATE) && |
| ((M4OSA_UInt32)pController->mCurrentClipNumber != |
| (pController->mNumberClipsToPreview-1))) { |
| VideoEditorCurretEditInfo *pEditInfo = |
| (VideoEditorCurretEditInfo*)M4OSA_32bitAlignedMalloc(sizeof(VideoEditorCurretEditInfo), |
| M4VS, (M4OSA_Char*)"Current Edit info"); |
| pEditInfo->overlaySettingsIndex = ext2; |
| pEditInfo->clipIndex = pController->mCurrentClipNumber; |
| pController->mOverlayState == OVERLAY_CLEAR; |
| if (pController->mJniCallback != NULL) { |
| pController->mJniCallback(pController->mJniCookie, |
| MSG_TYPE_OVERLAY_CLEAR, pEditInfo); |
| } |
| free(pEditInfo); |
| } |
| { |
| Mutex::Autolock autoLock(pController->mLockSem); |
| if (pController->mSemThreadWait != NULL) { |
| M4OSA_semaphorePost(pController->mSemThreadWait); |
| return; |
| } |
| } |
| |
| break; |
| } |
| case MEDIA_ERROR: |
| { |
| int err_val = ext1; |
| // Always log errors. |
| // ext1: Media framework error code. |
| // ext2: Implementation dependant error code. |
| ALOGE("MEDIA_ERROR; error (%d, %d)", ext1, ext2); |
| if(pController->mJniCallback != NULL) { |
| pController->mJniCallback(pController->mJniCookie, |
| MSG_TYPE_PLAYER_ERROR, &err_val); |
| } |
| break; |
| } |
| case MEDIA_INFO: |
| { |
| int info_val = ext2; |
| // ext1: Media framework error code. |
| // ext2: Implementation dependant error code. |
| //ALOGW("MEDIA_INFO; info/warning (%d, %d)", ext1, ext2); |
| if(pController->mJniCallback != NULL) { |
| pController->mJniCallback(pController->mJniCookie, |
| MSG_TYPE_PROGRESS_INDICATION, &info_val); |
| } |
| break; |
| } |
| case MEDIA_SEEK_COMPLETE: |
| ALOGV("MEDIA_SEEK_COMPLETE; Received seek complete"); |
| break; |
| case MEDIA_BUFFERING_UPDATE: |
| ALOGV("MEDIA_BUFFERING_UPDATE; buffering %d", ext1); |
| break; |
| case MEDIA_SET_VIDEO_SIZE: |
| ALOGV("MEDIA_SET_VIDEO_SIZE; New video size %d x %d", ext1, ext2); |
| break; |
| case 0xAAAAAAAA: |
| ALOGV("VIDEO PLAYBACK ALMOST over, prepare next player"); |
| // Select next player and prepare it |
| // If there is a clip after this one |
| if ((M4OSA_UInt32)(pController->mCurrentClipNumber+1) < |
| pController->mNumberClipsToPreview) { |
| pController->mPrepareReqest = M4OSA_TRUE; |
| pController->mCurrentPlayer++; |
| if (pController->mCurrentPlayer >= kTotalNumPlayerInstances) { |
| pController->mCurrentPlayer = 0; |
| } |
| // Prepare the first clip to be played |
| { |
| Mutex::Autolock autoLock(pController->mLockSem); |
| if (pController->mSemThreadWait != NULL) { |
| M4OSA_semaphorePost(pController->mSemThreadWait); |
| } |
| } |
| } |
| break; |
| case 0xBBBBBBBB: |
| { |
| ALOGV("VIDEO PLAYBACK, Update Overlay"); |
| int overlayIndex = ext2; |
| VideoEditorCurretEditInfo *pEditInfo = |
| (VideoEditorCurretEditInfo*)M4OSA_32bitAlignedMalloc(sizeof(VideoEditorCurretEditInfo), |
| M4VS, (M4OSA_Char*)"Current Edit info"); |
| //ext1 = 1; start the overlay display |
| // = 2; Clear the overlay. |
| pEditInfo->overlaySettingsIndex = ext2; |
| pEditInfo->clipIndex = pController->mCurrentClipNumber; |
| ALOGV("pController->mCurrentClipNumber = %d",pController->mCurrentClipNumber); |
| if (pController->mJniCallback != NULL) { |
| if (ext1 == 1) { |
| pController->mOverlayState = OVERLAY_UPDATE; |
| pController->mJniCallback(pController->mJniCookie, |
| MSG_TYPE_OVERLAY_UPDATE, pEditInfo); |
| } else { |
| pController->mOverlayState = OVERLAY_CLEAR; |
| pController->mJniCallback(pController->mJniCookie, |
| MSG_TYPE_OVERLAY_CLEAR, pEditInfo); |
| } |
| } |
| free(pEditInfo); |
| break; |
| } |
| default: |
| ALOGV("unrecognized message: (%d, %d, %d)", msg, ext1, ext2); |
| break; |
| } |
| } |
| |
| void VideoEditorPreviewController::setVideoEffectType( |
| M4VSS3GPP_VideoEffectType type, M4OSA_Bool enable) { |
| |
| M4OSA_UInt32 effect = VIDEO_EFFECT_NONE; |
| |
| // map M4VSS3GPP_VideoEffectType to local enum |
| switch(type) { |
| case M4VSS3GPP_kVideoEffectType_FadeFromBlack: |
| effect = VIDEO_EFFECT_FADEFROMBLACK; |
| break; |
| |
| case M4VSS3GPP_kVideoEffectType_FadeToBlack: |
| effect = VIDEO_EFFECT_FADETOBLACK; |
| break; |
| |
| case M4xVSS_kVideoEffectType_BlackAndWhite: |
| effect = VIDEO_EFFECT_BLACKANDWHITE; |
| break; |
| |
| case M4xVSS_kVideoEffectType_Pink: |
| effect = VIDEO_EFFECT_PINK; |
| break; |
| |
| case M4xVSS_kVideoEffectType_Green: |
| effect = VIDEO_EFFECT_GREEN; |
| break; |
| |
| case M4xVSS_kVideoEffectType_Sepia: |
| effect = VIDEO_EFFECT_SEPIA; |
| break; |
| |
| case M4xVSS_kVideoEffectType_Negative: |
| effect = VIDEO_EFFECT_NEGATIVE; |
| break; |
| |
| case M4xVSS_kVideoEffectType_Framing: |
| effect = VIDEO_EFFECT_FRAMING; |
| break; |
| |
| case M4xVSS_kVideoEffectType_Fifties: |
| effect = VIDEO_EFFECT_FIFTIES; |
| break; |
| |
| case M4xVSS_kVideoEffectType_ColorRGB16: |
| effect = VIDEO_EFFECT_COLOR_RGB16; |
| break; |
| |
| case M4xVSS_kVideoEffectType_Gradient: |
| effect = VIDEO_EFFECT_GRADIENT; |
| break; |
| |
| default: |
| effect = VIDEO_EFFECT_NONE; |
| break; |
| } |
| |
| if(enable == M4OSA_TRUE) { |
| // If already set, then no need to set again |
| if(!(mCurrentVideoEffect & effect)) |
| mCurrentVideoEffect |= effect; |
| if(effect == VIDEO_EFFECT_FIFTIES) { |
| mIsFiftiesEffectStarted = true; |
| } |
| } |
| else { |
| // Reset only if already set |
| if(mCurrentVideoEffect & effect) |
| mCurrentVideoEffect &= ~effect; |
| } |
| |
| return; |
| } |
| |
| |
| M4OSA_ERR VideoEditorPreviewController::applyVideoEffect( |
| M4OSA_Void * dataPtr, M4OSA_UInt32 colorFormat, M4OSA_UInt32 videoWidth, |
| M4OSA_UInt32 videoHeight, M4OSA_UInt32 timeMs, M4OSA_Void* outPtr) { |
| |
| M4OSA_ERR err = M4NO_ERROR; |
| vePostProcessParams postProcessParams; |
| |
| postProcessParams.vidBuffer = (M4VIFI_UInt8*)dataPtr; |
| postProcessParams.videoWidth = videoWidth; |
| postProcessParams.videoHeight = videoHeight; |
| postProcessParams.timeMs = timeMs; |
| postProcessParams.timeOffset = 0; //Since timeMS already takes care of offset in this case |
| postProcessParams.effectsSettings = mEffectsSettings; |
| postProcessParams.numberEffects = mNumberEffects; |
| postProcessParams.outVideoWidth = mOutputVideoWidth; |
| postProcessParams.outVideoHeight = mOutputVideoHeight; |
| postProcessParams.currentVideoEffect = mCurrentVideoEffect; |
| postProcessParams.renderingMode = mRenderingMode; |
| if(mIsFiftiesEffectStarted == M4OSA_TRUE) { |
| postProcessParams.isFiftiesEffectStarted = M4OSA_TRUE; |
| mIsFiftiesEffectStarted = M4OSA_FALSE; |
| } |
| else { |
| postProcessParams.isFiftiesEffectStarted = M4OSA_FALSE; |
| } |
| //postProcessParams.renderer = mTarget; |
| postProcessParams.overlayFrameRGBBuffer = NULL; |
| postProcessParams.overlayFrameYUVBuffer = NULL; |
| |
| mTarget->getBufferYV12(&(postProcessParams.pOutBuffer), &(postProcessParams.outBufferStride)); |
| |
| err = applyEffectsAndRenderingMode(&postProcessParams, videoWidth, videoHeight); |
| return err; |
| } |
| |
| status_t VideoEditorPreviewController::setPreviewFrameRenderingMode( |
| M4xVSS_MediaRendering mode, M4VIDEOEDITING_VideoFrameSize outputVideoSize) { |
| |
| ALOGV("setMediaRenderingMode: outputVideoSize = %d", outputVideoSize); |
| mRenderingMode = mode; |
| |
| status_t err = OK; |
| /* get the video width and height by resolution */ |
| err = getVideoSizeByResolution(outputVideoSize, |
| &mOutputVideoWidth, &mOutputVideoHeight); |
| |
| return err; |
| } |
| |
| M4OSA_ERR VideoEditorPreviewController::doImageRenderingMode( |
| M4OSA_Void * dataPtr, M4OSA_UInt32 colorFormat, M4OSA_UInt32 videoWidth, |
| M4OSA_UInt32 videoHeight, M4OSA_Void* outPtr) { |
| |
| M4OSA_ERR err = M4NO_ERROR; |
| M4VIFI_ImagePlane planeIn[3], planeOut[3]; |
| M4VIFI_UInt8 *inBuffer = M4OSA_NULL; |
| M4OSA_UInt32 outputBufferWidth =0, outputBufferHeight=0; |
| |
| //frameSize = (videoWidth*videoHeight*3) >> 1; |
| inBuffer = (M4OSA_UInt8 *)dataPtr; |
| |
| // In plane |
| prepareYUV420ImagePlane(planeIn, videoWidth, |
| videoHeight, (M4VIFI_UInt8 *)inBuffer, videoWidth, videoHeight); |
| |
| outputBufferWidth = mOutputVideoWidth; |
| outputBufferHeight = mOutputVideoHeight; |
| |
| // Out plane |
| uint8_t* outBuffer; |
| size_t outBufferStride = 0; |
| |
| ALOGV("doMediaRendering CALL getBuffer()"); |
| mTarget->getBufferYV12(&outBuffer, &outBufferStride); |
| |
| // Set the output YUV420 plane to be compatible with YV12 format |
| //In YV12 format, sizes must be even |
| M4OSA_UInt32 yv12PlaneWidth = ((mOutputVideoWidth +1)>>1)<<1; |
| M4OSA_UInt32 yv12PlaneHeight = ((mOutputVideoHeight+1)>>1)<<1; |
| |
| prepareYV12ImagePlane(planeOut, yv12PlaneWidth, yv12PlaneHeight, |
| (M4OSA_UInt32)outBufferStride, (M4VIFI_UInt8 *)outBuffer); |
| |
| err = applyRenderingMode(planeIn, planeOut, mRenderingMode); |
| if(err != M4NO_ERROR) { |
| ALOGE("doImageRenderingMode: applyRenderingMode returned err=0x%x", (unsigned int)err); |
| } |
| return err; |
| } |
| |
| } //namespace android |
