diff -r 80975da52420 -r 43d09473c595 khronosfws/openmax_al/src/mmf_adaptation/cmmfbackendengine.cpp --- a/khronosfws/openmax_al/src/mmf_adaptation/cmmfbackendengine.cpp Mon May 03 12:59:52 2010 +0300 +++ b/khronosfws/openmax_al/src/mmf_adaptation/cmmfbackendengine.cpp Fri May 14 16:22:35 2010 +0300 @@ -11,328 +11,374 @@ * * Contributors: * -* Description: +* Description: * */ -/* -Media Helper Class for handling surface events - -Shy Ward -*/ #include "cmmfbackendengine.h" #include #include #include +#include +#include "markerpositiontimer.h" +#include "positionupdatetimer.h" +#include "profileutilmacro.h" extern "C" { #include "xaadaptationmmf.h" } +#define RET_IF_ERR(res, val) if (res != KErrNone) return val -#define ENABLE_GRAPHICS_SURFACE_INTEGRATION_NOT_NOW +const XAuint32 XA_PLAYSTATE_PLAYERUNINITIALIZED = 0; CMMFBackendEngine* CMMFBackendEngine::NewL() { CMMFBackendEngine* self = new (ELeave) CMMFBackendEngine(); + CleanupStack::PushL(self); self->ConstructL(); + CleanupStack::Pop(self); return self; } CMMFBackendEngine::~CMMFBackendEngine() { - CloseAndDestroy(); - } - -CMMFBackendEngine::CMMFBackendEngine() - { - iVideoPlayer = NULL; - m_bWindowReferencePassed = FALSE; - iRecordState = ERecorderNotReady; - iPositionUpdateTimer = NULL; - } - - -void CMMFBackendEngine::InitVideoPlayerUtilityL() - { - iBaseVideoPlayer = CVideoPlayerUtility2::NewL(*this,EMdaPriorityNormal,EMdaPriorityPreferenceTimeAndQuality); - iVideoPlayer = (CVideoPlayerUtility2*)iBaseVideoPlayer; - iVideoPlayer->RegisterForVideoLoadingNotification(*this); + Close(); + Destroy(); } -void CMMFBackendEngine::CreateAndConfigureWindowL() +CMMFBackendEngine::CMMFBackendEngine() +:iPositionUpdatePeriod(1000), /* default is 1000 millisec */ + iUriPtr(NULL,0) { -#ifdef ENABLE_GRAPHICS_SURFACE_INTEGRATION_NOT_NOW - // create window for attaching the surface as its background - //RWsSession ws; - //TInt err2(KErrNone); - TInt err2 = m_ws.Connect(); - m_pScr = new(ELeave) CWsScreenDevice(m_ws); - err2 = m_pScr->Construct(); - CWindowGc* gc = NULL; - err2 = m_pScr->CreateContext(gc); - RWindowGroup grp(m_ws); - err2 = grp.Construct(0xf00f00); - const TSize KWinSize(320, 240); - m_pWindow = new (ELeave) RWindow(m_ws); - err2 = m_pWindow->Construct(grp, 0xfeefee); - m_pWindow->SetExtent(TPoint(), KWinSize); - m_pWindow->SetBackgroundColor(TRgb(255,0,0,128)); - //win.SetBackgroundColor(TRgb(0,0,0,0)); - m_pWindow->Activate(); - m_pWindow->Invalidate(); - m_pWindow->BeginRedraw(); - gc->Activate(*m_pWindow); - m_pWindow->EndRedraw(); - m_ws.Flush(); - - //Create MediaClientUitlity for NGA Surfaces - TInt displayId = m_pScr->GetScreenNumber(); - - // Add the display window - m_cropRegion = TRect(m_pWindow->Size()); - m_clipRect = TRect(m_pWindow->Size()); - m_videoExtent = TRect(m_pWindow->Size()); - m_rotation = EVideoRotationNone; - -#endif // ENABLE_GRAPHICS_SURFACE_INTEGRATION_NOT_NOW - +/* m_bWindowReferencePassed = FALSE;*/ + iRecordState = ERecorderNotReady; + iPositionUpdateTimer = NULL; + iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED; + iMMFPlayerState = EPlayerClosed; } void CMMFBackendEngine::ConstructL() { - //iBaseAudioPlayer = CMdaAudioPlayerUtility::NewL(*this); - //iAudioPlayer = (CMdaAudioPlayerUtility*)iBaseAudioPlayer; - iAPIBeingUsed = EAudioPlayerUtility; - //InitVideoPlayerUtilityL(); - iPlayerState = EPlayerClosed; - iBaseAudioRecorder = CMdaAudioRecorderUtility::NewL(*this); - iAudioRecorder = (CMdaAudioRecorderUtility*)iBaseAudioRecorder; - iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait; - } + iAPIBeingUsed = ENoUtility; + iBaseAudioRecorder = CMdaAudioRecorderUtility::NewL(*this); + iAudioRecorder = (CMdaAudioRecorderUtility*)iBaseAudioRecorder; + iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait; + } + +void CMMFBackendEngine::InitAudioPlayerUtilityL() + { + if (!iAudioPlayer) + { + iBaseAudioPlayer = CMdaAudioPlayerUtility::NewL(*this); + iAudioPlayer = (CMdaAudioPlayerUtility*)iBaseAudioPlayer; + } + InitPlayerTimersL(); + } + +void CMMFBackendEngine::InitVideoPlayerUtilityL() + { + if (!iVideoPlayer) + { + iBaseVideoPlayer = CVideoPlayerUtility2::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality); + iVideoPlayer = (CVideoPlayerUtility2*)iBaseVideoPlayer; + iVideoPlayer->RegisterForVideoLoadingNotification(*this); + } + InitPlayerTimersL(); + } + +void CMMFBackendEngine::InitPlayerTimersL() + { + if (!iMarkerPositionTimer) + { + iMarkerPositionTimer = CMarkerPositionTimer::NewL(iAudioPlayer, iVideoPlayer); + iMarkerPositionTimer->SetContext(iAdaptContext); + } + if (!iPlayItfPositionUpdateTimer) + { + iPlayItfPositionUpdateTimer = CPositionUpdateTimer::NewL(iAudioPlayer, iVideoPlayer); + iPlayItfPositionUpdateTimer->SetContext(iAdaptContext); + } + iMarkerPositionTimer->Stop(); + iPlayItfPositionUpdateTimer->Stop(); + } TInt CMMFBackendEngine::SetFileName(char* uri, XAuint32 format, TFuncInUse func) { TInt err(KErrNone); _LIT8(KFileSlash,"file:///"); TInt fileslashlen = KFileSlash().Length(); - if(func == ERecord) + if (func == ERecord) { - if(iRecordState == ERecorderNotReady) + if (iRecordState == ERecorderNotReady) { iFileFormat = format; - iAPIBeingUsed = DetermineAPIToUse(uri, ERecord); + iAPIBeingUsed = EAudioRecorderUtility; TPtr8 fileuri(((TUint8*)uri), strlen(uri) ,strlen(uri)); TPtr8 filepath = fileuri.RightTPtr(strlen(uri)-fileslashlen); - if(iAPIBeingUsed == EAudioPlayerUtility) + TInt pos = filepath.LocateReverse(':'); + if(pos != KErrNotFound) { - TInt pos = filepath.LocateReverse(':'); - if(pos != KErrNotFound) - { - fileuri.Delete(fileslashlen+pos,1); - } - - TUriParser8 localfileUri; - TInt ret = localfileUri.Parse(fileuri); - HBufC* file = NULL; - TRAP(err,file = localfileUri.GetFileNameL()); - TPtr des = file->Des(); - iFileName = des; - delete file; - file = NULL; - TRAP(err, iAudioRecorder->OpenFileL(iFileName)); + fileuri.Delete(fileslashlen+pos,1); + } + + TUriParser8 localfileUri; + TInt ret = localfileUri.Parse(fileuri); + HBufC* file = NULL; + TRAP(err,file = localfileUri.GetFileNameL()); + TPtr des = file->Des(); + iFileName = des; + delete file; + file = NULL; + TRAP(err, iAudioRecorder->OpenFileL(iFileName)); + if (!err) + { /* Wait until we receive moscostatechanged callback */ if(!iActiveSchedulerWait->IsStarted()) { iActiveSchedulerWait->Start(); } + err = iErrorCode; } } } else { - if(iPlayerState == EPlayerClosed) + /* The second one is needed for dynamic source interface */ + if ((iMediaPlayerState == XA_PLAYSTATE_PLAYERUNINITIALIZED) || + (iMediaPlayerState == XA_PLAYSTATE_STOPPED)) { iFileFormat = format; - iAPIBeingUsed = DetermineAPIToUse(uri,EPlay); - TPtr8 fileuri((TUint8*)uri, strlen(uri),strlen(uri)); - - if(iAPIBeingUsed == EAudioPlayerUtility) + iAPIBeingUsed = DetermineAPIToUse(uri, EPlay); + err = XA_RESULT_INTERNAL_ERROR; + if (iAPIBeingUsed == EAudioPlayerUtility) + { + /* Initialize URI as needed by MMF utilities */ + err = InitializeURIForMMFUtil(uri); + RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR); + /* Initalize Player related objects */ + TRAP(err, InitAudioPlayerUtilityL()); + RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR); + + TAG_TIME_PROFILING_BEGIN; + TRAP(err, iAudioPlayer->OpenFileL(iUriPtr)); + RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR); + TAG_TIME_PROFILING_END; + PRINT_TO_CONSOLE_TIME_DIFF; + + /* Wait until we receive mapc init complete */ + PRINT_TO_CONSOLE_HOME_TIME; + if (!iActiveSchedulerWait->IsStarted()) + { + iActiveSchedulerWait->Start(); + } + RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR); + } + else if (iAPIBeingUsed == EVideoPlayerUtility) { - TInt pos = fileuri.LocateReverse(':'); - fileuri.Delete(pos,1); - - TUriParser8 localfileUri; - TInt ret = localfileUri.Parse(fileuri); - HBufC* file = NULL; - TRAP(err,file = localfileUri.GetFileNameL()); - TPtr des = file->Des(); - iFileName = des; - delete file; - file = NULL; - } - else - { - HBufC* f(NULL); - TRAP(err, f = HBufC::NewL(strlen(uri))); - TPtr des = f->Des(); - des.Copy(fileuri); - iFileName = des; - delete f; - f = NULL; + /* Initialize URI as needed by MMF utilities */ + err = InitializeURIForMMFUtil(uri); + RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR); + /* Initalize Player related objects */ + TRAP(err, InitVideoPlayerUtilityL()); + RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR); + + /* Open file */ + TAG_TIME_PROFILING_BEGIN; + TRAP(err, iVideoPlayer->OpenFileL(iUriPtr)); + RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR); + TAG_TIME_PROFILING_END; + PRINT_TO_CONSOLE_TIME_DIFF; + + /* Wait until we receive MvpuoOpenComplete */ + PRINT_TO_CONSOLE_HOME_TIME; + if (!iActiveSchedulerWait->IsStarted()) + { + iActiveSchedulerWait->Start(); + } + RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR); + + /* Prepare utility */ + TAG_TIME_PROFILING_BEGIN_NO_VAR_DEF; + iVideoPlayer->Prepare(); + TAG_TIME_PROFILING_END_NO_VAR_DEF; + PRINT_TO_CONSOLE_TIME_DIFF; + + /* Wait until we receive MvpuoPrepareComplete */ + PRINT_TO_CONSOLE_HOME_TIME_NO_VAR_DEF; + if (!iActiveSchedulerWait->IsStarted()) + { + iActiveSchedulerWait->Start(); + } + RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR); } } } + if (err != KErrNone) + { + err = XA_RESULT_INTERNAL_ERROR; + } return err; } TInt CMMFBackendEngine::DetermineAPIToUse(char* uri, TFuncInUse aFunc) { - char* tempExtensionPtr = NULL; - char extension[MAX_EXTENSION_SIZE] = { 0 }; - - tempExtensionPtr = strchr(uri, (int)'.'); - strcpy(extension, tempExtensionPtr); - - for(unsigned int i=0;ipLocator); - - m_pWindow = ((RWindow*)(nativeDisplay->hWindow)); - m_pWs = ((RWsSession*)(nativeDisplay->hDisplay)); - - m_bWindowReferencePassed = TRUE; - - } - //From MVidePlayerUtilityObserver void CMMFBackendEngine::MvpuoOpenComplete(TInt aError) { - if(aError == KErrNone) + PRINT_TO_CONSOLE_HOME_TIME; + + iErrorCode = aError; + if (iErrorCode == KErrNone) + { + iMMFPlayerState = EPlayerOpened; + } + if (iActiveSchedulerWait->IsStarted()) { - //Issue the command to Play the file - TRAPD (error, iVideoPlayer->Prepare()); - if (error == KErrNone) + iActiveSchedulerWait->AsyncStop(); + } + } + +void CMMFBackendEngine::MvpuoPrepareComplete(TInt aError) + { + PRINT_TO_CONSOLE_HOME_TIME; + + TAutoScaleType autoScale = EAutoScaleBestFit; + iErrorCode = aError; + iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED; + iMediaDuration = 0; + iMarkerPositionTimer->ResetPlayer(); + iPlayItfPositionUpdateTimer->ResetPlayer(); + if (iErrorCode == KErrNone) + { + iMMFPlayerState = EPlayerPrepared; + TAG_TIME_PROFILING_BEGIN; + TRAP(iErrorCode, iMediaDuration = iVideoPlayer->DurationL()); + TAG_TIME_PROFILING_END; + PRINT_TO_CONSOLE_TIME_DIFF; + if (iErrorCode == KErrNone) { - //prepare success + iPlaybackHead = 0; + iMediaPlayerState = XA_PLAYSTATE_STOPPED; + iMarkerPositionTimer->UseVideoPlayer(); + iPlayItfPositionUpdateTimer->UseVideoPlayer(); + if (m_pWs && m_pScr && m_pWindow) + { + TRect videoExtent = TRect(m_pWindow->Size()); + TRect clipRect = TRect(m_pWindow->Size()); + TAG_TIME_PROFILING_BEGIN; + TRAP_IGNORE(iVideoPlayer->AddDisplayWindowL(*m_pWs, *m_pScr, *m_pWindow, videoExtent, clipRect)); + TRAP_IGNORE(iVideoPlayer->SetAutoScaleL(*m_pWindow, autoScale)); + TAG_TIME_PROFILING_END; + PRINT_TO_CONSOLE_TIME_DIFF; + } } - else - { - //prepare failed - } + } + if (iActiveSchedulerWait->IsStarted()) + { + iActiveSchedulerWait->AsyncStop(); + } + } + +void CMMFBackendEngine::MvpuoFrameReady(CFbsBitmap& /*aFrame*/,TInt /*aError*/) + { + + } +void CMMFBackendEngine::MvpuoPlayComplete(TInt aError) + { + iErrorCode = aError; + if (iErrorCode == KErrNone) + { + iPlaybackHead = iMediaDuration; + /* Per OpenMAX AL Spec, when playback is completed, media player stays in + * paused state with playhead at the end of the media clip */ + iMediaPlayerState = XA_PLAYSTATE_PAUSED; + DoPostEvent(XA_PLAYEVENT_HEADATEND); } else { - //could not open file + iPlaybackHead = 0; + iMediaPlayerState = XA_PLAYSTATE_STOPPED; + XAAdaptEvent event = {XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL}; + XAAdaptationBase_SendAdaptEvents((XAAdaptationBaseCtx*)iAdaptContext, &event ); } - } - - - -void CMMFBackendEngine::MvpuoFrameReady(CFbsBitmap& /*aFrame*/,TInt /*aError*/) - { - + iMMFPlayerState = EPlayerPrepared; + iMarkerPositionTimer->Stop(); + iPlayItfPositionUpdateTimer->Stop(); } - - -void CMMFBackendEngine::MvpuoPlayComplete(TInt aError) - { - - - if(aError == KErrNone) - { - //playback complete - } - else - { - //playback complete with error - } - } - - - void CMMFBackendEngine::MvpuoEvent(class TMMFEvent const & event) { - RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent (0x%x %d)\n"), - event.iEventType, event.iErrorCode); + //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent (0x%x %d)"), event.iEventType, event.iErrorCode); if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError && event.iErrorCode == KErrHardwareNotAvailable) { - //audio device taken - //handle this case + //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Hardware Not Available")); } - else if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError && - event.iErrorCode == KErrMMPartialPlayback) + else if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError && + event.iErrorCode == KErrMMPartialPlayback) { - //Partial Playback - } - + //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Partial playback")); + } + if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError && + event.iErrorCode == -12014) + { + //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Audio Device taken")); + PausePlayback(); + XAAdaptEvent event = {XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL}; + XAAdaptationBase_SendAdaptEvents((XAAdaptationBaseCtx*)iAdaptContext, &event ); + } else if (event.iEventType == KMMFRefreshMetaData) { - //entry = iVideoPlayer->MetaDataEntryL( event.iErrorCode ); + //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: EventType == KMMFRefreshMetaData")); } else { - + //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Unhandled event")); } - -} - - -void CMMFBackendEngine::MvpuoPrepareComplete(TInt aError) - { - TInt err(KErrNone); - TAutoScaleType autoScale = EAutoScaleBestFit; - if(aError == KErrNone) - { - if(m_pWindow == NULL) - { - //no RWindow was given to use so I'll create one and handle it - //CreateAndConfigureWindowL(); - } - else - { - TRAP(err, iVideoPlayer->AddDisplayWindowL(*m_pWs, *m_pScr, *m_pWindow)); - TRAP(err, iVideoPlayer->SetAutoScaleL(*m_pWindow, autoScale)); - } - - TReal beginSecs = 1; - TReal intervalSecs = 5; - TTimeIntervalMicroSeconds interval(1000000*intervalSecs); - TTimeIntervalMicroSeconds beginning(1000000*beginSecs); - - iVideoPlayer->Play(); - iPlayerState = EPlayerPlaying; - } } // From MRebufferCallback @@ -340,9 +386,6 @@ { } - - - void CMMFBackendEngine::MvloLoadingComplete() { //file playing @@ -350,50 +393,90 @@ //MMdaAudioPlayerCallback void CMMFBackendEngine::MapcInitComplete(TInt aError, - const TTimeIntervalMicroSeconds& /* aDuration */) + const TTimeIntervalMicroSeconds& aDuration) { - if (aError == KErrNone) + PRINT_TO_CONSOLE_HOME_TIME; + + iErrorCode = aError; + iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED; + iMMFPlayerState = EPlayerClosed; + iMediaDuration = 0; + iMarkerPositionTimer->ResetPlayer(); + iPlayItfPositionUpdateTimer->ResetPlayer(); + if (iErrorCode == KErrNone) { - iAudioPlayer->Play(); - iPlayerState = EPlayerPlaying; + iMediaDuration = aDuration; + iPlaybackHead = 0; + iMediaPlayerState = XA_PLAYSTATE_STOPPED; + iMMFPlayerState = EPlayerOpened; + iMarkerPositionTimer->UseAudioPlayer(); + iPlayItfPositionUpdateTimer->UseAudioPlayer(); } - else + if (iActiveSchedulerWait->IsStarted()) { - //init failed + iActiveSchedulerWait->AsyncStop(); } } -void CMMFBackendEngine::MapcPlayComplete(TInt /* aError */) +void CMMFBackendEngine::MapcPlayComplete(TInt aError) { - //audio playback complete + iErrorCode = aError; + if (iErrorCode == KErrNone) + { + /* Now we should have better value. Start using that */ + iAudioPlayer->Duration(iMediaDuration); + iPlaybackHead = iMediaDuration; + /* Per OpenMAX AL Spec, when playback is completed, media player stays in + * paused state with playhead at the end of the media clip */ + iMediaPlayerState = XA_PLAYSTATE_PAUSED; + DoPostEvent(XA_PLAYEVENT_HEADATEND); + iMMFPlayerState = EPlayerOpened; + } + else + { + iAudioPlayer->GetPosition(iPlaybackHead); + iMediaPlayerState = XA_PLAYSTATE_PAUSED; + iMMFPlayerState = EPlayerPaused; + XAAdaptEvent event = {XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL}; + XAAdaptationBase_SendAdaptEvents((XAAdaptationBaseCtx*)iAdaptContext, &event ); + } + iMarkerPositionTimer->Stop(); + iPlayItfPositionUpdateTimer->Stop(); } // from MMdaObjectStateChangeObserver void CMMFBackendEngine::MoscoStateChangeEvent(CBase* /*aObject*/, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode) { + TInt err(KErrNone); iPreviousRecordState = aPreviousState; iCurrentRecordState = aCurrentState; iErrorCode = aErrorCode; - RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 1 Error[%d]"),aErrorCode); - if(iCurrentRecordState == CMdaAudioClipUtility::EOpen) //EOpen + //RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 1 Error[%d]"),aErrorCode); + if (iCurrentRecordState == CMdaAudioClipUtility::EOpen) //EOpen { //outputfile is open and ready for recording iRecordState = CMMFBackendEngine::ERecorderOpen; - if(iErrorCode == KErrNone) + if (iErrorCode == KErrNone) { if (iPreviousRecordState == CMdaAudioClipUtility::ENotReady) { - RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 2")); + //RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 2")); + TRAP(err,iaudioInputRecord = CAudioInput::NewL( *iAudioRecorder )); + RArray inputArray; + inputArray.Append( CAudioInput::EDefaultMic ); + // Set Audio Input + iaudioInputRecord->SetAudioInputL( inputArray.Array( ) ); + inputArray.Close(); TMMFMessageDestination destination(KUidMetaDataWriteCustomCommand); TMMFMessageDestinationPckg pckg = TMMFMessageDestinationPckg(destination); TInt ret = iAudioRecorder->RecordControllerCustomCommandSync(pckg, 0, KNullDesC8, KNullDesC8); - RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 3 [%d]"),ret); - if(ret != KErrNone && iFileFormat == XA_CONTAINERTYPE_MP4) + //RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 3 [%d]"),ret); + if (ret != KErrNone && iFileFormat == XA_CONTAINERTYPE_MP4) { iPauseSupportMP4 = FALSE; } - if(iActiveSchedulerWait->IsStarted()) + if (iActiveSchedulerWait->IsStarted()) { iActiveSchedulerWait->AsyncStop(); } @@ -401,21 +484,21 @@ } else { - XAAdaptEventMMF event = {XA_RECORDITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL}; - XAAdaptationBaseMMF_SendAdaptEvents((XAAdaptationBaseMMFCtx*)iAdaptContext, &event ); + XAAdaptEvent event = {XA_RECORDITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL}; + XAAdaptationBase_SendAdaptEvents((XAAdaptationBaseCtx*)iAdaptContext, &event ); } } - else if(iCurrentRecordState == CMdaAudioClipUtility::ERecording) //ERecording + else if (iCurrentRecordState == CMdaAudioClipUtility::ERecording) //ERecording { iRecordState = CMMFBackendEngine::ERecorderRecording; iPositionUpdateTimer->Start(iTimerDelay); - XAAdaptEventMMF event = {XA_RECORDITFEVENTS, XA_RECORDEVENT_HEADMOVING, 0, NULL}; - XAAdaptationBaseMMF_SendAdaptEvents((XAAdaptationBaseMMFCtx*)iAdaptContext, &event ); + XAAdaptEvent event = {XA_RECORDITFEVENTS, XA_RECORDEVENT_HEADMOVING, 0, NULL}; + XAAdaptationBase_SendAdaptEvents((XAAdaptationBaseCtx*)iAdaptContext, &event ); } else //ENotReady { //outputfile is not open - iRecordState = CMMFBackendEngine::ERecorderNotReady; + iRecordState = CMMFBackendEngine::ERecorderNotReady; } } @@ -429,13 +512,13 @@ iRecordState = ERecorderNotReady; break; case ERecorderOpen: - if(iFileFormat == XA_CONTAINERTYPE_MP4 && !iPauseSupportMP4 && !stopCalled) + if (iFileFormat == XA_CONTAINERTYPE_MP4 && !iPauseSupportMP4 && !stopCalled) { err = KErrNotSupported; return err; - } + } iPositionUpdateTimer->Stop(); - iAudioRecorder->Stop(); + iAudioRecorder->Stop(); iRecordState = ERecorderOpen; break; case ERecorderRecording: @@ -445,123 +528,50 @@ return err; } -void CMMFBackendEngine::AudioOpenFile() - { - TRAPD(err, iAudioPlayer->OpenFileL(iFileName)); - if(err) - { - - } - } - -void CMMFBackendEngine::AudioStop() - { - iAudioPlayer->Stop(); - } - -void CMMFBackendEngine::AudioPause() - { - iAudioPlayer->Pause(); - } - -void CMMFBackendEngine::AudioClose() +void CMMFBackendEngine::Close() { - iAudioPlayer->Close(); - } - -void CMMFBackendEngine::ResumePlayback() - { - if(iPlayerState == EPlayerClosed) - { - //prepare playback - if(iAPIBeingUsed == EAudioPlayerUtility) - { - AudioOpenFile(); - } - else - { - TRAPD (error, iVideoPlayer->OpenFileL(iFileName)); - if(error != KErrNone) - { - - } - } - iPlayerState = EPlayerPaused; - } - else if (iPlayerState == EPlayerPaused) + if (iMarkerPositionTimer) { - if(iAPIBeingUsed == EAudioPlayerUtility) - { - iAudioPlayer->Play(); - } - else - { - iVideoPlayer->Play(); - } - iPlayerState = EPlayerPlaying; + iMarkerPositionTimer->Stop(); } - } - -void CMMFBackendEngine::PausePlayback() - { - if(iAPIBeingUsed == EAudioPlayerUtility) - { - AudioPause(); - } - else + if (iPlayItfPositionUpdateTimer) { - TRAPD(err, iVideoPlayer->PauseL()); - if(err != KErrNone) - { - - } - } - iPlayerState = EPlayerPaused; - } + iPlayItfPositionUpdateTimer->Stop(); + } -void CMMFBackendEngine::StopPlayback() - { - if(iAPIBeingUsed == EAudioPlayerUtility) - { - AudioStop(); - } - if(iAPIBeingUsed == EVideoPlayerUtility) - { - iVideoPlayer->Stop(); - } - iPlayerState = EPlayerClosed; - } - -void CMMFBackendEngine::CloseAndDestroy() - { if (iBaseVideoPlayer && iVideoPlayer) { - iVideoPlayer->Close(); - delete iBaseVideoPlayer; - iVideoPlayer = NULL; - iBaseVideoPlayer = NULL; + switch(iMMFPlayerState) + { + case EPlayerPlaying: + case EPlayerPaused: + case EPlayerPrepared: + iVideoPlayer->Stop(); + case EPlayerOpened: + if (m_pWs && m_pScr && m_pWindow) + { + iVideoPlayer->RemoveDisplayWindow(*m_pWindow); + } + iVideoPlayer->Close(); + case EPlayerClosed: + default: + break; + }; } - + if (iBaseAudioPlayer && iAudioPlayer) { iAudioPlayer->Close(); - delete iBaseAudioPlayer; - iAudioPlayer = NULL; - iBaseAudioPlayer = NULL; } - + if (iBaseAudioRecorder) { iAudioRecorder->Close(); - delete iBaseAudioRecorder; - iAudioRecorder = NULL; - iBaseAudioRecorder = NULL; } - + if(iPositionUpdateTimer) { - delete iPositionUpdateTimer; - iPositionUpdateTimer = NULL; + iPositionUpdateTimer->Stop(); } if(iActiveSchedulerWait) @@ -570,35 +580,49 @@ { iActiveSchedulerWait->AsyncStop(); } - delete iActiveSchedulerWait; - iActiveSchedulerWait = NULL; - } + } } -void CMMFBackendEngine::SetNativeDisplayInformation(void* display_info) +void CMMFBackendEngine::Destroy() { - //display_info is of type XADataSink - //display_info.pLocator is of type XADataLocator_NativeDisplay - m_bWindowReferencePassed = TRUE; - XADataLocator_NativeDisplay* nativeDisplay; - XADataSink* videoSink = (XADataSink*)display_info; - - nativeDisplay = (XADataLocator_NativeDisplay*) (videoSink->pLocator); - //TODO: scrDevice is not been passed Properly - // Add the display window - m_cropRegion = TRect(((RWindow*)(nativeDisplay->hWindow))->Size()); - m_videoExtent = TRect(((RWindow*)(nativeDisplay->hWindow))->Size()); - m_cropRect = TRect(((RWindow*)(nativeDisplay->hWindow))->Size()); - m_clipRect = TRect(((RWindow*)(nativeDisplay->hWindow))->Size()); - m_cropRegion = TRect(((RWindow*)(nativeDisplay->hWindow))->Size()); - m_pWindow = ((RWindow*)(nativeDisplay->hWindow)); - m_pWs = ((RWsSession*)(nativeDisplay->hDisplay)); - - TRAPD(err, m_pScr = new(ELeave) CWsScreenDevice(*m_pWs)); - if(err == KErrNone) + + if (iBaseAudioRecorder) + { + iAudioRecorder->Close(); + } + + if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted()) { - m_pScr->Construct(); + iActiveSchedulerWait->AsyncStop(); } + + delete iPositionUpdateTimer; + iPositionUpdateTimer = NULL; + delete iUri; + iUri = NULL; + delete iMarkerPositionTimer; + iMarkerPositionTimer = NULL; + delete iPlayItfPositionUpdateTimer; + iPlayItfPositionUpdateTimer = NULL; + delete iBaseVideoPlayer; + iBaseVideoPlayer = NULL; + iVideoPlayer = NULL; + if (iaudioInputRecord) + { + delete iaudioInputRecord; + iaudioInputRecord = NULL; + } + + delete iBaseAudioPlayer; + iBaseAudioPlayer = NULL; + iAudioPlayer = NULL; + delete iBaseAudioRecorder; + iBaseAudioRecorder = NULL; + iAudioRecorder = NULL; + delete iActiveSchedulerWait; + iActiveSchedulerWait = NULL; + delete m_pScr; + m_pScr = NULL; } TInt CMMFBackendEngine::GetRecordPosition(XAuint64* position) @@ -620,68 +644,140 @@ TInt err(KErrNone); iAdaptContext = adaptcontext; TRAP(err, iPositionUpdateTimer = new (ELeave) LocalTimer(this, iAdaptContext)); - if(!err) + if (!err) { iPositionUpdateTimer->PostInit(); } return err; } -TInt CMMFBackendEngine::GetEncoderId(XAuint32* encoderId) +TInt CMMFBackendEngine::GetCodecId(XAuint32* codecid) { TInt err(KErrNone); - if(iRecordState == CMMFBackendEngine::ERecorderOpen) + + if(iAPIBeingUsed == EAudioRecorderUtility) { - TFourCC dest; - TRAP(err, dest = iAudioRecorder->DestinationDataTypeL()); - if(err == KErrNone) + if(iRecordState != CMMFBackendEngine::ERecorderNotReady) { - *encoderId = dest.FourCC(); + TFourCC dest; + TRAP(err, dest = iAudioRecorder->DestinationDataTypeL()); + if(err == KErrNone) + { + *codecid = dest.FourCC(); + } + } + } + else if(iAPIBeingUsed == EAudioPlayerUtility) + { + if(iMediaPlayerState != XA_PLAYSTATE_PLAYERUNINITIALIZED) + { + TMMFMessageDestinationPckg pckg(KUidInterfaceMMFAudioController); + TPckgBuf configPackage; + TInt err = iAudioPlayer->CustomCommandSync(pckg, + EMMFAudioControllerGetSourceDataType, + KNullDesC8, + KNullDesC8, + configPackage); + if(err == KErrNone) + { + *codecid = configPackage().iSourceDataTypeCode.FourCC(); + } } } return err; } -TInt CMMFBackendEngine::GetDestinationBitRate(XAuint32* bitrate) +TInt CMMFBackendEngine::GetBitRate(XAuint32* bitrate) { TInt err(KErrNone); TUint br(0); - if(iRecordState == CMMFBackendEngine::ERecorderOpen) + if(iAPIBeingUsed == EAudioRecorderUtility) { - TRAP(err, br = iAudioRecorder->DestinationBitRateL()); - if(err == KErrNone) + if(iRecordState != CMMFBackendEngine::ERecorderNotReady) { + TRAP(err, br = iAudioRecorder->DestinationBitRateL()); + if(err == KErrNone) + { + *bitrate = br; + } + } + } + else if(iAPIBeingUsed == EAudioPlayerUtility) + { + if(iMediaPlayerState != XA_PLAYSTATE_PLAYERUNINITIALIZED) + { + TInt err = iAudioPlayer->GetBitRate(br); *bitrate = br; } } return err; } -TInt CMMFBackendEngine::GetDestinationSampleRate(XAmilliHertz* samplerate) +TInt CMMFBackendEngine::GetSampleRate(XAmilliHertz* samplerate) { TInt err(KErrNone); TUint sr(0); - if(iRecordState == CMMFBackendEngine::ERecorderOpen) + if(iAPIBeingUsed == EAudioRecorderUtility) + { + if(iRecordState != CMMFBackendEngine::ERecorderNotReady) + { + TRAP(err, sr = iAudioRecorder->DestinationSampleRateL()); + if(err == KErrNone) + { + *samplerate = sr; + } + } + } + else if(iAPIBeingUsed == EAudioPlayerUtility) { - TRAP(err, sr = iAudioRecorder->DestinationSampleRateL()); - if(err == KErrNone) + if(iMediaPlayerState != XA_PLAYSTATE_PLAYERUNINITIALIZED) { - *samplerate = sr; + TMMFMessageDestinationPckg pckg(KUidInterfaceMMFAudioController); + TPckgBuf configPackage; + TInt err = iAudioPlayer->CustomCommandSync(pckg, + EMMFAudioControllerGetSourceSampleRate, + KNullDesC8, + KNullDesC8, + configPackage); + if(err == KErrNone) + { + *samplerate = configPackage().iSampleRate; + } } } return err; } -TInt CMMFBackendEngine::GetDestinationChannels(XAuint32* channels) +TInt CMMFBackendEngine::GetChannels(XAuint32* channels) { TInt err(KErrNone); TUint ch(0); - if(iRecordState == CMMFBackendEngine::ERecorderOpen) + if(iAPIBeingUsed == EAudioRecorderUtility) + { + if(iRecordState != CMMFBackendEngine::ERecorderNotReady) + { + TRAP(err,ch = iAudioRecorder->DestinationNumberOfChannelsL()); + if(err == KErrNone) + { + *channels = ch; + } + } + } + else if(iAPIBeingUsed == EAudioPlayerUtility) { - TRAP(err,ch = iAudioRecorder->DestinationNumberOfChannelsL()); - if(err == KErrNone) + if(iMediaPlayerState != XA_PLAYSTATE_PLAYERUNINITIALIZED) { - *channels = ch; + TMMFMessageDestinationPckg pckg(KUidInterfaceMMFAudioController); + TPckgBuf configPackage; + TInt err = iAudioPlayer->CustomCommandSync( pckg, + EMMFAudioControllerGetSourceNumChannels, + KNullDesC8, + KNullDesC8, + configPackage ); + if(err == KErrNone) + { + *channels = configPackage().iChannels; + } } } return err; @@ -718,10 +814,10 @@ TInt CMMFBackendEngine::SetDestinationChannels(XAuint32* channels) { TInt err(KErrNone); - if(iRecordState == CMMFBackendEngine::ERecorderOpen) + if (iRecordState == CMMFBackendEngine::ERecorderOpen) { TRAP(err,iAudioRecorder->SetDestinationNumberOfChannelsL(*channels)); - if(err != KErrNone) + if (err != KErrNone) { return XA_RESULT_PARAMETER_INVALID; } @@ -729,103 +825,811 @@ return err; } +/* +XAresult CMMFBackendEngine::SetWindowHandle(void* display_info) + { + XADataLocator_NativeDisplay* nativeDisplay; + XADataSink* videoSink = (XADataSink*)display_info; + + nativeDisplay = (XADataLocator_NativeDisplay*) (videoSink->pLocator); + + m_pWindow = ((RWindow*)(nativeDisplay->hWindow)); + m_pWs = ((RWsSession*)(nativeDisplay->hDisplay)); + + m_bWindowReferencePassed = TRUE; + return XA_RESULT_SUCCESS; + } + +*/ +XAresult CMMFBackendEngine::CreateAndConfigureWindowL() + { +#ifdef USE_LOCAL_WINDOW_RESOURCES + // create window for attaching the surface as its background + //RWsSession ws; + //TInt err2(KErrNone); + TInt err2 = m_ws.Connect(); + m_pScr = new(ELeave) CWsScreenDevice(m_ws); + err2 = m_pScr->Construct(); + CWindowGc* gc = NULL; + err2 = m_pScr->CreateContext(gc); + RWindowGroup grp(m_ws); + err2 = grp.Construct(0xf00f00); + const TSize KWinSize(320, 240); + m_pWindow = new (ELeave) RWindow(m_ws); + err2 = m_pWindow->Construct(grp, 0xfeefee); + m_pWindow->SetExtent(TPoint(), KWinSize); + m_pWindow->SetBackgroundColor(TRgb(255,0,0,128)); + //win.SetBackgroundColor(TRgb(0,0,0,0)); + m_pWindow->Activate(); + m_pWindow->Invalidate(); + m_pWindow->BeginRedraw(); + gc->Activate(*m_pWindow); + m_pWindow->EndRedraw(); + m_ws.Flush(); + + //Create MediaClientUitlity for NGA Surfaces + TInt displayId = m_pScr->GetScreenNumber(); + + // Add the display window + m_cropRegion = TRect(m_pWindow->Size()); + m_clipRect = TRect(m_pWindow->Size()); + m_videoExtent = TRect(m_pWindow->Size()); + m_rotation = EVideoRotationNone; +#endif /* USE_LOCAL_WINDOW_RESOURCES */ + + return XA_RESULT_SUCCESS; + } + +XAresult CMMFBackendEngine::SetNativeDisplayInformation(void* display_info) + { + XAresult retVal(XA_RESULT_SUCCESS); + //display_info is of type XADataSink + //display_info.pLocator is of type XADataLocator_NativeDisplay + XADataLocator_NativeDisplay* nativeDisplay; + XADataSink* videoSink = (XADataSink*)display_info; + + if (videoSink) + { + nativeDisplay = (XADataLocator_NativeDisplay*) (videoSink->pLocator); + m_pWindow = ((RWindow*)(nativeDisplay->hWindow)); + m_pWs = ((RWsSession*)(nativeDisplay->hDisplay)); + /* + m_cropRegion = TRect(m_pWindow->Size()); + m_videoExtent = TRect(m_pWindow->Size()); + m_cropRect = TRect(m_pWindow->Size()); + m_clipRect = TRect(m_pWindow->Size()); + m_cropRegion = TRect(m_pWindow->Size()); + */ + if (m_pWs) + { + delete m_pScr; + m_pScr = NULL; + TRAPD(err, m_pScr = new CWsScreenDevice(*m_pWs)); + RET_IF_ERR(err, XA_RESULT_MEMORY_FAILURE); + m_pScr->Construct(); + } + } + return retVal; + } + +XAresult CMMFBackendEngine::ResumePlayback() + { + XAresult retVal(XA_RESULT_SUCCESS); + TBool postHeadMovingEvent(EFalse); + switch (iMediaPlayerState) + { + case XA_PLAYSTATE_STOPPED: + case XA_PLAYSTATE_PAUSED: + /* If we are already at the end of clip, do nothing + * check ::MapcPlayComplete for documentation */ + if ((iPlaybackHead < iMediaDuration) && + ((iAPIBeingUsed == EAudioPlayerUtility) || + (iAPIBeingUsed == EVideoPlayerUtility)) ) + { + if (iAPIBeingUsed == EAudioPlayerUtility) + { + TAG_TIME_PROFILING_BEGIN; + iAudioPlayer->Play(); + TAG_TIME_PROFILING_END; + PRINT_TO_CONSOLE_TIME_DIFF; + } + else if (iAPIBeingUsed == EVideoPlayerUtility) + { + TAG_TIME_PROFILING_BEGIN; + //iVideoPlayer->Play( iPlaybackHead, iMediaDuration); + iVideoPlayer->Play(); + TAG_TIME_PROFILING_END; + PRINT_TO_CONSOLE_TIME_DIFF; + } + postHeadMovingEvent = ETrue; + iMediaPlayerState = XA_PLAYSTATE_PLAYING; + iMMFPlayerState = EPlayerPlaying; + iMarkerPositionTimer->Start(); + iPlayItfPositionUpdateTimer->Start(); + } + break; + case XA_PLAYSTATE_PLAYING: + break; + case XA_PLAYSTATE_PLAYERUNINITIALIZED: + default: + retVal = XA_RESULT_INTERNAL_ERROR; + break; + } + + if (postHeadMovingEvent) + { + DoPostEvent(XA_PLAYEVENT_HEADMOVING); + } + return retVal; + } + +XAresult CMMFBackendEngine::PausePlayback() + { + XAresult retVal(XA_RESULT_SUCCESS); + switch (iMediaPlayerState) + { + case XA_PLAYSTATE_PLAYING: + case XA_PLAYSTATE_STOPPED: + if ((iAPIBeingUsed == EAudioPlayerUtility) || + (iAPIBeingUsed == EVideoPlayerUtility) ) + { + TInt pauseOpRes(KErrNone); + if (iAPIBeingUsed == EAudioPlayerUtility) + { + TAG_TIME_PROFILING_BEGIN; + pauseOpRes = iAudioPlayer->Pause(); + TAG_TIME_PROFILING_END; + PRINT_TO_CONSOLE_TIME_DIFF; + } + else if (iAPIBeingUsed == EVideoPlayerUtility) + { + TAG_TIME_PROFILING_BEGIN; + TRAP(pauseOpRes, iVideoPlayer->PauseL()); + if (pauseOpRes == KErrNone) + { + TRAPD(err, iPlaybackHead = iVideoPlayer->PositionL()); + if (err != KErrNone) + { + iPlaybackHead = 0; + } + } + TAG_TIME_PROFILING_END; + PRINT_TO_CONSOLE_TIME_DIFF; + } + if ( pauseOpRes == KErrNone) + { + iMediaPlayerState = XA_PLAYSTATE_PAUSED; + iMMFPlayerState = EPlayerPaused; + iMarkerPositionTimer->Stop(); + iPlayItfPositionUpdateTimer->Stop(); + } + } + break; + case XA_PLAYSTATE_PAUSED: + break; + case XA_PLAYSTATE_PLAYERUNINITIALIZED: + default: + retVal = XA_RESULT_INTERNAL_ERROR; + break; + } + return retVal; + } + +XAresult CMMFBackendEngine::StopPlayback() + { + XAresult retVal(XA_RESULT_SUCCESS); + switch (iMediaPlayerState) + { + case XA_PLAYSTATE_PAUSED: + case XA_PLAYSTATE_PLAYING: + if ((iAPIBeingUsed == EAudioPlayerUtility) || + (iAPIBeingUsed == EVideoPlayerUtility) ) + { + if (iAPIBeingUsed == EAudioPlayerUtility) + { + TAG_TIME_PROFILING_BEGIN; + iAudioPlayer->Stop(); + TAG_TIME_PROFILING_END; + PRINT_TO_CONSOLE_TIME_DIFF; + + iMMFPlayerState = EPlayerOpened; + } + else if (iAPIBeingUsed == EVideoPlayerUtility) + { + TAG_TIME_PROFILING_BEGIN; + iVideoPlayer->Stop(); + TAG_TIME_PROFILING_END; + PRINT_TO_CONSOLE_TIME_DIFF; + + iMMFPlayerState = EPlayerPrepared; + } + iMediaPlayerState = XA_PLAYSTATE_STOPPED; + iPlaybackHead = 0; + iMarkerPositionTimer->Stop(); + iPlayItfPositionUpdateTimer->Stop(); + } + break; + case XA_PLAYSTATE_STOPPED: + break; + case XA_PLAYSTATE_PLAYERUNINITIALIZED: + default: + retVal = XA_RESULT_INTERNAL_ERROR; + break; + } + return retVal; + } +XAresult CMMFBackendEngine::GetPlayState(XAuint32 *pState) + { + XAresult retVal(XA_RESULT_INTERNAL_ERROR); + switch (iMediaPlayerState) + { + case XA_PLAYSTATE_STOPPED: + case XA_PLAYSTATE_PAUSED: + case XA_PLAYSTATE_PLAYING: + *pState = iMediaPlayerState; + retVal = XA_RESULT_SUCCESS; + break; + case XA_PLAYSTATE_PLAYERUNINITIALIZED: + default: + break; + } + return retVal; + } + +XAresult CMMFBackendEngine::GetDuration(XAmillisecond *pMsec) + { + XAresult retVal(XA_RESULT_INTERNAL_ERROR); + /* to convert from microseconds to milliseconds */ + TInt64 divider(1000); + switch (iMediaPlayerState) + { + case XA_PLAYSTATE_STOPPED: + case XA_PLAYSTATE_PAUSED: + case XA_PLAYSTATE_PLAYING: + /* TODO Check if we query from MMF*/ + *pMsec = iMediaDuration.Int64() / divider; + retVal = XA_RESULT_SUCCESS; + break; + case XA_PLAYSTATE_PLAYERUNINITIALIZED: + default: + break; + } + return retVal; + } + +XAresult CMMFBackendEngine::GetPosition(XAmillisecond *pMsec) + { + XAresult retVal(XA_RESULT_INTERNAL_ERROR); + TInt64 divider(1000); + TTimeIntervalMicroSeconds pos; + switch (iMediaPlayerState) + { + case XA_PLAYSTATE_STOPPED: + case XA_PLAYSTATE_PAUSED: + case XA_PLAYSTATE_PLAYING: + if (iAPIBeingUsed == EAudioPlayerUtility) + { + if (iAudioPlayer->GetPosition(pos) == KErrNone) + { + *pMsec = pos.Int64() / divider; + retVal = XA_RESULT_SUCCESS; + } + } + else if (iAPIBeingUsed == EVideoPlayerUtility) + { + TInt err(KErrNone); + TRAP(err, pos = iVideoPlayer->PositionL()); + if (err == KErrNone) + { + *pMsec = pos.Int64() / divider; + retVal = XA_RESULT_SUCCESS; + } + } + break; + case XA_PLAYSTATE_PLAYERUNINITIALIZED: + default: + break; + } + return retVal; + } + +XAresult CMMFBackendEngine::SetPosition(XAmillisecond pMsec) + { + XAresult retVal(XA_RESULT_INTERNAL_ERROR); + TInt64 multiplier(1000); + TTimeIntervalMicroSeconds pos; + switch (iMediaPlayerState) + { + case XA_PLAYSTATE_STOPPED: + case XA_PLAYSTATE_PAUSED: + case XA_PLAYSTATE_PLAYING: + if(iAPIBeingUsed == EAudioPlayerUtility) + { + pos = pMsec * multiplier; + TAG_TIME_PROFILING_BEGIN; + iAudioPlayer->SetPosition(pos); + TAG_TIME_PROFILING_END; + PRINT_TO_CONSOLE_TIME_DIFF; + + retVal = XA_RESULT_SUCCESS; + } + else if (iAPIBeingUsed == EVideoPlayerUtility) + { + pos = pMsec * multiplier; + TAG_TIME_PROFILING_BEGIN; + TRAPD(err, iVideoPlayer->SetPositionL(pos)); + TAG_TIME_PROFILING_END; + PRINT_TO_CONSOLE_TIME_DIFF; + if (err == KErrNone) + { + retVal = XA_RESULT_SUCCESS; + } + } + break; + case XA_PLAYSTATE_PLAYERUNINITIALIZED: + default: + break; + } + return retVal; + } + +XAresult CMMFBackendEngine::SetRepeats(XAboolean repeat) + { + XAresult retVal(XA_RESULT_INTERNAL_ERROR); + TInt numRepeats(0); + switch (iMediaPlayerState) + { + case XA_PLAYSTATE_STOPPED: + case XA_PLAYSTATE_PAUSED: + case XA_PLAYSTATE_PLAYING: + if(iAPIBeingUsed == EAudioPlayerUtility) + { + numRepeats = repeat ? -2 : 0; + iAudioPlayer->SetRepeats(numRepeats, 0); + retVal = XA_RESULT_SUCCESS; + } + else + { + } + break; + case XA_PLAYSTATE_PLAYERUNINITIALIZED: + default: + break; + } + return retVal; + } + +XAresult CMMFBackendEngine::SetPlayWindow(XAmillisecond start, XAmillisecond end) + { + XAresult retVal(XA_RESULT_INTERNAL_ERROR); + TInt64 multiplier(1000); + TTimeIntervalMicroSeconds startpos(0); + TTimeIntervalMicroSeconds endpos(0); + + switch (iMediaPlayerState) + { + case XA_PLAYSTATE_STOPPED: + case XA_PLAYSTATE_PAUSED: + case XA_PLAYSTATE_PLAYING: + if(iAPIBeingUsed == EAudioPlayerUtility) + { + startpos = start * multiplier; + endpos = end * multiplier; + retVal = iAudioPlayer->SetPlayWindow(startpos,endpos); + } + else + { + } + break; + case XA_PLAYSTATE_PLAYERUNINITIALIZED: + default: + break; + } + return retVal; + } + +XAresult CMMFBackendEngine::SetPlayAdaptContext(void * adaptcontext) + { + XAresult retVal(XA_RESULT_SUCCESS); + + iAdaptContext = adaptcontext; + + return retVal; + } + +XAresult CMMFBackendEngine::RegisterCallback(xaPlayCallback cbFunction) + { + iPlayItfCBFunction = cbFunction; + return DoHandlePlayItfAttributesChanged(); + } + +XAresult CMMFBackendEngine::SetCallbackEventsMask(XAuint32 eventflags) + { + iPlayItfEventFlags = eventflags; + return DoHandlePlayItfAttributesChanged(); + } + +XAresult CMMFBackendEngine::SetMarkerPosition(XAmillisecond mSec) + { + iMarkerPosition = mSec; + return DoHandlePlayItfAttributesChanged(); + } + +XAresult CMMFBackendEngine::ClearMarkerPosition() + { + iMarkerPosition = XA_TIME_UNKNOWN; + DoHandlePlayItfAttributesChanged(); + return XA_RESULT_SUCCESS; + } + +XAresult CMMFBackendEngine::SetPositionUpdatePeriod(XAmillisecond mSec) + { + iPositionUpdatePeriod = mSec; + DoHandlePlayItfAttributesChanged(); + return XA_RESULT_SUCCESS; + } + +XAresult CMMFBackendEngine::DoHandlePlayItfAttributesChanged() + { + XAresult retVal(XA_RESULT_SUCCESS); + + iMarkerPositionTimer->SetCallbackEventMask(iPlayItfEventFlags); + iMarkerPositionTimer->RegisterCallback(iPlayItfCBFunction); + iMarkerPositionTimer->SetMarkerPosition(iMarkerPosition); + + iPlayItfPositionUpdateTimer->SetCallbackEventMask(iPlayItfEventFlags); + iPlayItfPositionUpdateTimer->RegisterCallback(iPlayItfCBFunction); + iPlayItfPositionUpdateTimer->SetPositionUpdatePeriod(iPositionUpdatePeriod); + + switch (iMediaPlayerState) + { + case XA_PLAYSTATE_STOPPED: + case XA_PLAYSTATE_PAUSED: + break; + case XA_PLAYSTATE_PLAYING: + iMarkerPositionTimer->Start(); + iPlayItfPositionUpdateTimer->Start(); + break; + case XA_PLAYSTATE_PLAYERUNINITIALIZED: + default: + break; + } + return retVal; + } + +void CMMFBackendEngine::DoPostEvent(XAuint32 event) + { + if ((iPlayItfEventFlags & event) && + (iPlayItfCBFunction != NULL)) + { + XAAdaptEvent xaevent = {XA_PLAYITFEVENTS, event, 0, 0 }; + XAAdaptationBase_SendAdaptEvents((XAAdaptationBaseCtx*)iAdaptContext, &xaevent ); + } + } + +XAresult CMMFBackendEngine::GetNumStreams(XAuint32* numstreams) + { + XAresult retVal(XA_RESULT_SUCCESS); + TInt bitRate(0); + TInt numS(0); + if(iAPIBeingUsed == EAudioPlayerUtility) + { + numS = 1; + *numstreams = numS; + } + else if (iAPIBeingUsed == EVideoPlayerUtility) + { + TRAPD(err, bitRate = iVideoPlayer->VideoBitRateL()); + if(!err && bitRate) + { + numS++; + *numstreams = numS; + } + + bitRate = 0; + TRAP(err, bitRate = iVideoPlayer->AudioBitRateL()); + if(!err && bitRate) + { + numS++; + *numstreams = numS; + } + } + return retVal; + } + +XAresult CMMFBackendEngine::GetStreamInfo(XAuint32 streamindex, XAuint32* streamtype) + { + XAresult retVal(XA_RESULT_SUCCESS); + if(iAPIBeingUsed == EAudioPlayerUtility) + { + *streamtype = XA_DOMAINTYPE_AUDIO; + } + else if (iAPIBeingUsed == EVideoPlayerUtility) + { + switch(streamindex) + { + case 1: + *streamtype = XA_DOMAINTYPE_VIDEO; + break; + case 2: + *streamtype = XA_DOMAINTYPE_AUDIO; + break; + default: + retVal = XA_RESULT_PARAMETER_INVALID; + break; + } + } + return retVal; + } + + +XAresult CMMFBackendEngine::GetVideoFrameSize(XAuint32* height, XAuint32* width, XAuint32* frameRate) + { + XAresult retVal(XA_RESULT_SUCCESS); + if(iAPIBeingUsed == EVideoPlayerUtility) + { + if(iMediaPlayerState != XA_PLAYSTATE_PLAYERUNINITIALIZED) + { + TSize size; + TReal32 framerate(0); + TRAPD(err, iVideoPlayer->VideoFrameSizeL(size)); + if(!err) + { + *height = size.iHeight; + *width = size.iWidth; + } + else + { + retVal = err; + } + + TRAP(err, framerate = iVideoPlayer->VideoFrameRateL()); + if(!err) + { + *frameRate = framerate; + } + } + else + { + retVal = XA_RESULT_PRECONDITIONS_VIOLATED; + } + } + else + { + retVal = XA_RESULT_FEATURE_UNSUPPORTED; + } + return retVal; + } + +XAresult CMMFBackendEngine::SetActiveState(XAuint32 streamindex, XAboolean active) + { + XAresult retVal(XA_RESULT_SUCCESS); + TInt err(KErrNone); + if(iAPIBeingUsed == EAudioPlayerUtility) + { + retVal = XA_RESULT_FEATURE_UNSUPPORTED; + } + else if (iAPIBeingUsed == EVideoPlayerUtility) + { + switch(streamindex) + { + case 1: + TRAP(err, iVideoPlayer->SetVideoEnabledL(active)); + retVal = err; + break; + case 2: + TRAP(err, iVideoPlayer->SetAudioEnabledL(active)); + retVal = err; + break; + default: + retVal = XA_RESULT_PARAMETER_INVALID; + break; + } + } + return retVal; + } + +TInt CMMFBackendEngine::InitializeURIForMMFUtil(char *uri) + { + /* Initializes and save uri param into iUri structure */ + TInt err(KErrNone); + TInt uriLen; + + if (!uri) + return KErrArgument; + + if (iUri) + { + delete iUri; + iUri = NULL; + } + + uriLen = strlen(uri); + TPtr8 uriParam((TUint8*)uri, uriLen, uriLen); + + TRAP(err, iUri = HBufC::NewL(uriLen)); + if (err != KErrNone) + return err; + + iUriPtr.Set(iUri->Des()); + iUriPtr.Copy(uriParam); /* Copy data*/ + iUriPtr.LowerCase(); + + /* For file scheme convert from file:///c:/folder/file.ext + * format to c:\\folder\\file.ext using TUriParser. */ + _LIT(KFileScheme,"file:///"); + if (iUriPtr.Find(KFileScheme) >= 0) + { + TPtr tmp(const_cast(iUriPtr.Ptr()) + KFileScheme().Length(), + iUriPtr.Length(), + iUriPtr.Length()); + /* Convert from c:/folder/file.ext format to + * c:\\folder\\file.ext using TUriParser. + * TUriParser8 accepts uri in format file:///c/folder/file.ext, + * so get rid of ':' after drive letter (if any) */ + TInt pos = tmp.Find(_L(":")); + if (pos != KErrNotFound) + { + iUriPtr.Delete(KFileScheme().Length() + pos, 1); + } + + TUriParser16 uriParser; + err = uriParser.Parse(iUriPtr); + if (err != KErrNone) + return err; + + HBufC* file = NULL; + TRAP(err, file = uriParser.GetFileNameL()); + if (err != KErrNone) + return err; + + iUriPtr.Copy(file->Des()); + delete file; + file = NULL; + + } + return err; + } + + +XAresult CMMFBackendEngine::SetVolume(XAuint32 volume) + { + XAresult retVal(XA_RESULT_SUCCESS); + TInt err(KErrNone); + if(iAPIBeingUsed == EAudioPlayerUtility) + { + retVal = iAudioPlayer->SetVolume(volume); + } + else if (iAPIBeingUsed == EVideoPlayerUtility) + { + TRAP(err, iVideoPlayer->SetVolumeL(volume)); + retVal = err; + } + else if(iAPIBeingUsed == EAudioRecorderUtility) + { + retVal = iAudioRecorder->SetVolume(volume); + } + return retVal; + } + +XAresult CMMFBackendEngine::GetMaxVolume(XAuint32* maxvolume) + { + XAresult retVal(XA_RESULT_SUCCESS); + if(iAPIBeingUsed == EAudioPlayerUtility) + { + *maxvolume = iAudioPlayer->MaxVolume(); + } + else if (iAPIBeingUsed == EVideoPlayerUtility) + { + *maxvolume = iVideoPlayer->MaxVolume(); + } + else if(iAPIBeingUsed == EAudioRecorderUtility) + { + *maxvolume = iAudioRecorder->MaxVolume(); + } + return retVal; + } + +XAresult CMMFBackendEngine::GetVolume(XAuint32* volume) + { + XAresult retVal(XA_RESULT_SUCCESS); + TInt mmfvolume(0); + if(iAPIBeingUsed == EAudioPlayerUtility) + { + retVal = iAudioPlayer->GetVolume(mmfvolume); + if(retVal == XA_RESULT_SUCCESS) + { + *volume = mmfvolume; + } + } + else if (iAPIBeingUsed == EVideoPlayerUtility) + { + *volume = iVideoPlayer->Volume(); + } + else if(iAPIBeingUsed == EAudioRecorderUtility) + { + retVal = iAudioRecorder->GetVolume(mmfvolume); + if(retVal == XA_RESULT_SUCCESS) + { + *volume = mmfvolume; + } + } + return retVal; + } + extern "C" { int mmf_backend_engine_init(void** engine) - { + { TRAPD(err, *engine = CMMFBackendEngine::NewL()); return err; - /*int err = CreateEngine(engine); - return err;*/ } - + + void mmf_backend_engine_deinit(void* engine) + { + delete ((CMMFBackendEngine*)engine); + } + int mmf_set_recorder_uri(void* context, char* uri, XAuint32 format) { return ((CMMFBackendEngine*)(context))->SetFileName(uri,format,CMMFBackendEngine::ERecord); } - void mmf_set_player_uri(void* context, char* uri, XAuint32 format) - { - ((CMMFBackendEngine*)(context))->SetFileName(uri,format,CMMFBackendEngine::EPlay); - } - int mmf_set_adapt_context(void* context, void* adaptcontext) { return ((CMMFBackendEngine*)(context))->SetAdaptContext(adaptcontext); } - void mmf_pause_playback(void* context) + void mmf_close(void* context) { - ((CMMFBackendEngine*)(context))->PausePlayback(); + ((CMMFBackendEngine*)context)->Close(); } - void mmf_resume_playback(void* context) - { - ((CMMFBackendEngine*)(context))->ResumePlayback(); - } - void mmf_set_window_handle(void* context, void* display_info) - { - ((CMMFBackendEngine*)(context))->SetWindowHandle(display_info); - } - - void mmf_stop_playback(void* context) - { - ((CMMFBackendEngine*)(context))->StopPlayback(); - } - void mmf_close(void* context) - { - delete ((CMMFBackendEngine*)context); - } - void mmf_setup_native_display(void* context, void* display_info) - { - ((CMMFBackendEngine*)(context))->SetNativeDisplayInformation(display_info); - } - int mmf_start_recording(void* context) { - return ((CMMFBackendEngine*)(context))->SetRecorderState(CMMFBackendEngine::ERecorderRecording,FALSE); + return ((CMMFBackendEngine*)(context))->SetRecorderState(CMMFBackendEngine::ERecorderRecording,FALSE); } - + int mmf_stop_recording(void* context, XAboolean stopCalled ) { - return ((CMMFBackendEngine*)(context))->SetRecorderState(CMMFBackendEngine::ERecorderOpen, stopCalled); + return ((CMMFBackendEngine*)(context))->SetRecorderState(CMMFBackendEngine::ERecorderOpen, stopCalled); } - + int mmf_get_record_position(void* context, XAuint64* position) { return ((CMMFBackendEngine*)(context))->GetRecordPosition(position); } - + int mmf_set_record_position_update_period(void* context, XAmillisecond msec) { return ((CMMFBackendEngine*)(context))->SetPositionUpdatePerioed(msec); - } - - int mmf_get_encoder_id(void* context, XAuint32* encoderId) + } + + int mmf_get_codec_id(void* context, XAuint32* encoderId) { - return ((CMMFBackendEngine*)(context))->GetEncoderId(encoderId); - } - - int mmf_get_destination_channels(void* context, XAuint32* channelsIn) - { - return ((CMMFBackendEngine*)(context))->GetDestinationChannels(channelsIn); - } - - int mmf_get_destination_samplerate(void* context, XAmilliHertz* sampleRate) - { - return ((CMMFBackendEngine*)(context))->GetDestinationSampleRate(sampleRate); + return ((CMMFBackendEngine*)(context))->GetCodecId(encoderId); } - int mmf_get_destination_bitrate(void* context, XAuint32* bitRate) + int mmf_get_channels(void* context, XAuint32* channelsIn) + { + return ((CMMFBackendEngine*)(context))->GetChannels(channelsIn); + } + + int mmf_get_samplerate(void* context, XAmilliHertz* sampleRate) { - return ((CMMFBackendEngine*)(context))->GetDestinationBitRate(bitRate); + return ((CMMFBackendEngine*)(context))->GetSampleRate(sampleRate); + } + + int mmf_get_bitrate(void* context, XAuint32* bitRate) + { + return ((CMMFBackendEngine*)(context))->GetBitRate(bitRate); } int mmf_set_destination_channels(void* context, XAuint32* channelsIn) { return ((CMMFBackendEngine*)(context))->SetDestinationChannels(channelsIn); } - + int mmf_set_destination_samplerate(void* context, XAmilliHertz* sampleRate) { return ((CMMFBackendEngine*)(context))->SetDestinationSampleRate(sampleRate); @@ -835,5 +1639,135 @@ { return ((CMMFBackendEngine*)(context))->SetDestinationBitRate(bitRate); } + + XAresult mmf_set_play_adapt_context(void * context, void * adaptcontext) + { + return ((CMMFBackendEngine *)(context))->SetPlayAdaptContext(adaptcontext); + } + + XAresult mmf_set_player_uri(void * context, char * uri, XAuint32 format) + { + return ((CMMFBackendEngine *)(context))->SetFileName(uri,format,CMMFBackendEngine::EPlay); + } + +/* + XAresult mmf_set_window_handle(void * context, void * display_info) + { + return ((CMMFBackendEngine *)(context))->SetWindowHandle(display_info); + } + +*/ + XAresult mmf_setup_native_display(void * context, void * display_info) + { + return ((CMMFBackendEngine *)(context))->SetNativeDisplayInformation(display_info); + } + + XAresult mmf_playitf_resume_playback(void * context) + { + return ((CMMFBackendEngine *)(context))->ResumePlayback(); + } + + XAresult mmf_playitf_pause_playback(void * context) + { + return ((CMMFBackendEngine *)(context))->PausePlayback(); + } + + XAresult mmf_playitf_stop_playback(void * context) + { + return ((CMMFBackendEngine *)(context))->StopPlayback(); + } + + XAresult mmf_playitf_get_play_state(void * context, XAuint32 * pState) + { + return ((CMMFBackendEngine *)(context))->GetPlayState(pState); + } + + XAresult mmf_playitf_get_duration(void * context, XAmillisecond * pMsec) + { + return ((CMMFBackendEngine *)(context))->GetDuration(pMsec); + } + + XAresult mmf_playitf_get_position(void * context, XAmillisecond * pMsec) + { + return ((CMMFBackendEngine *)(context))->GetPosition(pMsec); + } + + XAresult mmf_playitf_register_callback(void * context, xaPlayCallback callback) + { + return ((CMMFBackendEngine *)(context))->RegisterCallback(callback); + } + + XAresult mmf_playitf_set_callback_events_mask(void * context, XAuint32 eventflags) + { + return ((CMMFBackendEngine *)(context))->SetCallbackEventsMask(eventflags); + } + + XAresult mmf_playitf_set_marker_position(void * context, XAmillisecond mSec) + { + return ((CMMFBackendEngine *)(context))->SetMarkerPosition(mSec); + } + + XAresult mmf_playitf_clear_marker_position(void * context) + { + return ((CMMFBackendEngine *)(context))->ClearMarkerPosition(); + + } + + XAresult mmf_playitf_set_position_update_period(void * context, XAmillisecond mSec) + { + return ((CMMFBackendEngine *)(context))->SetPositionUpdatePeriod(mSec); + } + + XAresult mmf_seekitf_set_position(void * context, XAmillisecond pMsec) + { + return ((CMMFBackendEngine *)(context))->SetPosition(pMsec); + } + + XAresult mmf_seekitf_set_playwindow(void * context, XAmillisecond start, XAmillisecond end) + { + return ((CMMFBackendEngine *)(context))->SetPlayWindow(start,end); + } + + XAresult mmf_seekitf_set_repeats(void * context, XAboolean repeat) + { + return ((CMMFBackendEngine *)(context))->SetRepeats(repeat); + } + + XAresult mmf_streaminformationitf_get_streaminfo(void * context, XAuint32 streamindex, + XAuint32* streamtype) + { + return ((CMMFBackendEngine *)(context))->GetStreamInfo(streamindex, streamtype); + } + + XAresult mmf_streaminformationitf_get_numstreams(void * context, XAuint32* numstreams) + { + return ((CMMFBackendEngine *)(context))->GetNumStreams(numstreams); + } + + XAresult mmf_streaminformationitf_get_videoframesize(void * context, XAuint32* height, + XAuint32* width, XAuint32* frameRate) + { + return ((CMMFBackendEngine *)(context))->GetVideoFrameSize(height,width,frameRate); + } + + XAresult mmf_streaminformationitf_set_activestream(void * context, XAuint32 streamindex, + XAboolean active) + { + return ((CMMFBackendEngine *)(context))->SetActiveState(streamindex, active); + } + XAresult mmf_volumeitf_set_volume(void * context, XAuint32 volume) + { + return ((CMMFBackendEngine *)(context))->SetVolume(volume); + } + + XAresult mmf_volumeitf_get_maxvolume(void * context, XAuint32* volume) + { + return ((CMMFBackendEngine *)(context))->GetMaxVolume(volume); + } + + XAresult mmf_volumeitf_get_volume(void * context, XAuint32* volume) + { + return ((CMMFBackendEngine *)(context))->GetVolume(volume); + } }