--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/mmf_adaptation/cmmfbackendengine.cpp Tue Aug 31 15:43:02 2010 +0300
@@ -0,0 +1,1930 @@
+/*
+ * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * All rights reserved.
+ * This component and the accompanying materials are made available
+ * under the terms of "Eclipse Public License v1.0"
+ * which accompanies this distribution, and is available
+ * at the URL "http://www.eclipse.org/legal/epl-v10.html".
+ *
+ * Initial Contributors:
+ * Nokia Corporation - initial contribution.
+ *
+ * Contributors:
+ *
+ * Description:
+ *
+ */
+
+#include <string.h>
+#include <ctype.h>
+#include <uri8.h>
+#include <uri16.h>
+#include "cmmfbackendengine.h"
+#include "markerpositiontimer.h"
+#include "positionupdatetimer.h"
+#include "profileutilmacro.h"
+#include <mmf/common/mmfvideoenums.h>
+
+extern "C"
+ {
+#include "xaadaptationmmf.h"
+ }
+
+#define RET_IF_ERR(res, val) if (res != KErrNone) return val
+
+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()
+ {
+ Close();
+ Destroy();
+ }
+
+CMMFBackendEngine::CMMFBackendEngine() :
+ iPositionUpdatePeriod(1000), /* default is 1000 millisec */
+ iUriPtr(NULL, 0)
+ {
+ iRecordState = ERecorderNotReady;
+ iPositionUpdateTimer = NULL;
+ iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED;
+ iMMFPlayerState = EPlayerClosed;
+ }
+
+void CMMFBackendEngine::ConstructL()
+ {
+ iAPIBeingUsed = ENoUtility;
+ iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait;
+ }
+
+void CMMFBackendEngine::InitAudioRecorderUtilityL()
+ {
+ if (!iAudioRecorder)
+ {
+ iBaseAudioRecorder = CMdaAudioRecorderUtility::NewL(*this);
+ iAudioRecorder = (CMdaAudioRecorderUtility*) iBaseAudioRecorder;
+ }
+ }
+
+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 (iRecordState == ERecorderNotReady)
+ {
+ iFileFormat = format;
+ iAPIBeingUsed = DetermineAPIToUse(uri, ERecord);
+ err = XA_RESULT_INTERNAL_ERROR;
+ if (iAPIBeingUsed == EAudioRecorderUtility)
+ {
+ /* Initialize URI as needed by MMF utilities */
+ err = InitializeURIForMMFUtil(uri);
+ RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);
+ /* Initalize Recorder related objects */
+ TRAP(err, InitAudioRecorderUtilityL());
+ RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);
+
+ TRAP(err, iAudioRecorder->OpenFileL(iUriPtr));
+ RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);
+ /* Wait until we receive moscostatechanged callback */
+ if (iActiveSchedulerWait && !iActiveSchedulerWait->IsStarted())
+ {
+ iActiveSchedulerWait->Start();
+ }
+ RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);
+ }
+ }
+ }
+ else
+ {
+ /* The second one is needed for dynamic source interface */
+ if ((iMediaPlayerState == XA_PLAYSTATE_PLAYERUNINITIALIZED)
+ || (iMediaPlayerState == XA_PLAYSTATE_STOPPED))
+ {
+ iFileFormat = format;
+ 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 && !iActiveSchedulerWait->IsStarted())
+ {
+ iActiveSchedulerWait->Start();
+ }
+ RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);
+ }
+ else if (iAPIBeingUsed == EVideoPlayerUtility)
+ {
+ /* 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);
+
+ if (iUriType == ELocal)
+ {
+ /* 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;
+ }
+ else
+ {
+ /* Open URL */
+ TAG_TIME_PROFILING_BEGIN;
+ TRAP(err, iVideoPlayer->OpenUrlL(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 && !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 && !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* dotPtr = NULL;
+ char ext[MAX_EXTENSION_SIZE] =
+ {
+ 0
+ };
+ int extLen;
+
+ int colpos;
+ char urischeme[MAX_EXTENSION_SIZE] =
+ {
+ 0
+ };
+ int urischemeLen;
+
+ dotPtr = strrchr(uri, (int) '.');
+ if (!dotPtr)
+ {
+ return KErrNotFound;
+ }
+
+ strncpy(ext, dotPtr, strlen(dotPtr));
+ /*Null terminate the string*/
+ ext[strlen(dotPtr)] = '\0';
+ extLen = sizeof(ext);
+ for (unsigned int i = 0; i < extLen; i++)
+ {
+ ext[i] = tolower(ext[i]);
+ }
+
+ colpos = strcspn(uri, ":");
+
+ strncpy(urischeme, uri, colpos + 1);
+ /*Null terminate the string*/
+ urischeme[colpos + 1] = '\0';
+ urischemeLen = sizeof(urischeme);
+ for (unsigned int i = 0; i < urischemeLen; i++)
+ {
+ urischeme[i] = tolower(urischeme[i]);
+ }
+
+ if (aFunc == ERecord)
+ {
+ return EAudioRecorderUtility;
+ }
+ else
+ {
+ if (!strcmp(urischeme, "file:"))
+ {
+ if (!strcmp(ext, ".mp3") || !strcmp(ext, ".amr")
+ || !strcmp(ext, ".aac") || !strcmp(ext, ".mid")
+ || !strcmp(ext, ".wav") || !strcmp(ext, ".awb"))
+ {
+ return EAudioPlayerUtility;
+ }
+ else
+ {
+ return EVideoPlayerUtility;
+ }
+ }
+ else
+ {
+ return EVideoPlayerUtility;
+ }
+ }
+ }
+
+//From MVidePlayerUtilityObserver
+void CMMFBackendEngine::MvpuoOpenComplete(TInt aError)
+ {
+ PRINT_TO_CONSOLE_HOME_TIME;
+
+ iErrorCode = aError;
+ if (iErrorCode == KErrNone)
+ {
+ iMMFPlayerState = EPlayerOpened;
+ }
+ if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted())
+ {
+ 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)
+ {
+ 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;
+ }
+ }
+ }
+ if (iActiveSchedulerWait && 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
+ {
+ iPlaybackHead = 0;
+ iMediaPlayerState = XA_PLAYSTATE_STOPPED;
+ XAAdaptEvent event =
+ {
+ XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL
+ };
+ XAAdaptationBase_SendAdaptEvents(
+ (XAAdaptationBaseCtx*) iAdaptContext, &event);
+ }
+ iMMFPlayerState = EPlayerPrepared;
+ iMarkerPositionTimer->Stop();
+ iPlayItfPositionUpdateTimer->Stop();
+ }
+
+void CMMFBackendEngine::MvpuoEvent(class TMMFEvent const & event)
+ {
+ //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent (0x%x %d)"), event.iEventType, event.iErrorCode);
+
+ if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError
+ && event.iErrorCode == KErrHardwareNotAvailable)
+ {
+ //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Hardware Not Available"));
+ }
+
+ else if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError
+ && event.iErrorCode == KErrMMPartialPlayback)
+ {
+ //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Partial playback"));
+ }
+ if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError
+ && event.iErrorCode == -12014)
+ {
+ //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Audio Device taken"));
+ PausePlayback();
+ XAAdaptEvent alEvent =
+ {
+ XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL
+ };
+ XAAdaptationBase_SendAdaptEvents(
+ (XAAdaptationBaseCtx*) iAdaptContext, &alEvent);
+ }
+ else if (event.iEventType == KMMFRefreshMetaData)
+ {
+ //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: EventType == KMMFRefreshMetaData"));
+ }
+ else
+ {
+ //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Unhandled event"));
+ }
+
+ }
+
+// From MRebufferCallback
+void CMMFBackendEngine::MvloLoadingStarted()
+ {
+ }
+
+void CMMFBackendEngine::MvloLoadingComplete()
+ {
+ //file playing
+ }
+
+//MMdaAudioPlayerCallback
+void CMMFBackendEngine::MapcInitComplete(TInt aError,
+ const TTimeIntervalMicroSeconds& aDuration)
+ {
+ PRINT_TO_CONSOLE_HOME_TIME;
+
+ iErrorCode = aError;
+ iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED;
+ iMMFPlayerState = EPlayerClosed;
+ iMediaDuration = 0;
+ iMarkerPositionTimer->ResetPlayer();
+ iPlayItfPositionUpdateTimer->ResetPlayer();
+ if (iErrorCode == KErrNone)
+ {
+ iMediaDuration = aDuration;
+ iPlaybackHead = 0;
+ iMediaPlayerState = XA_PLAYSTATE_STOPPED;
+ iMMFPlayerState = EPlayerOpened;
+ iMarkerPositionTimer->UseAudioPlayer();
+ iPlayItfPositionUpdateTimer->UseAudioPlayer();
+ }
+ if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted())
+ {
+ iActiveSchedulerWait->AsyncStop();
+ }
+ }
+
+void CMMFBackendEngine::MapcPlayComplete(TInt aError)
+ {
+ 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
+ {
+ //outputfile is open and ready for recording
+ iRecordState = CMMFBackendEngine::ERecorderOpen;
+ if (iErrorCode == KErrNone)
+ {
+ if (iPreviousRecordState == CMdaAudioClipUtility::ENotReady)
+ {
+ //RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 2"));
+ TRAP(err,iAudioInputRecord = CAudioInput::NewL( *iAudioRecorder ));
+ if (err == KErrNone)
+ {
+ RArray<CAudioInput::TAudioInputPreference> inputArray;
+ inputArray.Append(CAudioInput::EDefaultMic);
+ // Set Audio Input
+ TRAP(err, 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)
+ {
+ iPauseSupportMP4 = FALSE;
+ }
+ if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted())
+ {
+ iActiveSchedulerWait->AsyncStop();
+ }
+ }
+ }
+ else
+ {
+ XAAdaptEvent event =
+ {
+ XA_RECORDITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL
+ };
+ XAAdaptationBase_SendAdaptEvents(
+ (XAAdaptationBaseCtx*) iAdaptContext, &event);
+ }
+ }
+ else if (iCurrentRecordState == CMdaAudioClipUtility::ERecording) //ERecording
+ {
+ iRecordState = CMMFBackendEngine::ERecorderRecording;
+ iPositionUpdateTimer->Start(iTimerDelay);
+ XAAdaptEvent event =
+ {
+ XA_RECORDITFEVENTS, XA_RECORDEVENT_HEADMOVING, 0, NULL
+ };
+ XAAdaptationBase_SendAdaptEvents(
+ (XAAdaptationBaseCtx*) iAdaptContext, &event);
+ }
+ else //ENotReady
+ {
+ //outputfile is not open
+ iRecordState = CMMFBackendEngine::ERecorderNotReady;
+ }
+ }
+
+TInt CMMFBackendEngine::SetRecorderState(TRecorderState state,
+ XAboolean stopCalled)
+ {
+ TInt err(KErrNone);
+
+ if (iAPIBeingUsed != EAudioRecorderUtility)
+ {
+ return XA_RESULT_INTERNAL_ERROR;
+ }
+
+ switch (state)
+ {
+ case ERecorderNotReady:
+ iAudioRecorder->Close();
+ iRecordState = ERecorderNotReady;
+ break;
+ case ERecorderOpen:
+ if (iFileFormat == XA_CONTAINERTYPE_MP4 && !iPauseSupportMP4
+ && !stopCalled)
+ {
+ err = KErrNotSupported;
+ return err;
+ }
+ iPositionUpdateTimer->Stop();
+ iAudioRecorder->Stop();
+ iRecordState = ERecorderOpen;
+ break;
+ case ERecorderRecording:
+ TRAP(err, iAudioRecorder->RecordL())
+ ;
+ break;
+ }
+ return err;
+ }
+
+void CMMFBackendEngine::Close()
+ {
+ if (iMarkerPositionTimer)
+ {
+ iMarkerPositionTimer->Stop();
+ }
+ if (iPlayItfPositionUpdateTimer)
+ {
+ iPlayItfPositionUpdateTimer->Stop();
+ }
+
+ if (iBaseVideoPlayer && iVideoPlayer)
+ {
+ 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;
+ };
+ }
+
+ // deleting the AudioInput object
+ if (iAudioInputRecord)
+ {
+ delete iAudioInputRecord;
+ iAudioInputRecord = NULL;
+ }
+
+ if (iBaseAudioPlayer && iAudioPlayer)
+ {
+ iAudioPlayer->Close();
+ }
+
+ if (iBaseAudioRecorder)
+ {
+ iAudioRecorder->Close();
+ }
+
+ if (iPositionUpdateTimer)
+ {
+ iPositionUpdateTimer->Stop();
+ }
+
+ if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted())
+ {
+ iActiveSchedulerWait->AsyncStop();
+ }
+ }
+
+void CMMFBackendEngine::Destroy()
+ {
+ delete iPositionUpdateTimer;
+ iPositionUpdateTimer = NULL;
+ delete iUri;
+ iUri = NULL;
+ delete iMarkerPositionTimer;
+ iMarkerPositionTimer = NULL;
+ delete iPlayItfPositionUpdateTimer;
+ iPlayItfPositionUpdateTimer = NULL;
+ delete iBaseVideoPlayer;
+ iBaseVideoPlayer = NULL;
+ iVideoPlayer = 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)
+ {
+ TInt err(KErrNone);
+ *position = iAudioRecorder->Position().Int64();
+ return err;
+ }
+
+TInt CMMFBackendEngine::SetPositionUpdatePerioed(XAmillisecond period)
+ {
+ TInt err(KErrNone);
+ iTimerDelay = period;
+ return err;
+ }
+
+TInt CMMFBackendEngine::SetAdaptContext(void* adaptcontext)
+ {
+ TInt err(KErrNone);
+ iAdaptContext = adaptcontext;
+ TRAP(err, iPositionUpdateTimer = new (ELeave) LocalTimer(this, iAdaptContext));
+ if (!err)
+ {
+ iPositionUpdateTimer->PostInit();
+ }
+ return err;
+ }
+
+TInt CMMFBackendEngine::GetCodecId(XAuint32* codecid)
+ {
+ TInt err(KErrNone);
+
+ if (iAPIBeingUsed == EAudioRecorderUtility)
+ {
+ if (iRecordState != CMMFBackendEngine::ERecorderNotReady)
+ {
+ 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<TMMFAudioConfig> configPackage;
+ TInt err = iAudioPlayer->CustomCommandSync(pckg,
+ EMMFAudioControllerGetSourceDataType, KNullDesC8,
+ KNullDesC8, configPackage);
+ if (err == KErrNone)
+ {
+ *codecid = configPackage().iSourceDataTypeCode.FourCC();
+ }
+ }
+ }
+ return err;
+ }
+
+TInt CMMFBackendEngine::GetBitRate(XAuint32* bitrate)
+ {
+ TInt err(KErrNone);
+ TUint br(0);
+ if (iAPIBeingUsed == EAudioRecorderUtility)
+ {
+ 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::GetSampleRate(XAmilliHertz* samplerate)
+ {
+ TInt err(KErrNone);
+ TUint sr(0);
+ if (iAPIBeingUsed == EAudioRecorderUtility)
+ {
+ if (iRecordState != CMMFBackendEngine::ERecorderNotReady)
+ {
+ TRAP(err, sr = iAudioRecorder->DestinationSampleRateL());
+ if (err == KErrNone)
+ {
+ *samplerate = sr * 1000;
+ }
+ }
+ }
+ else if (iAPIBeingUsed == EAudioPlayerUtility)
+ {
+ if (iMediaPlayerState != XA_PLAYSTATE_PLAYERUNINITIALIZED)
+ {
+ TMMFMessageDestinationPckg pckg(KUidInterfaceMMFAudioController);
+ TPckgBuf<TMMFAudioConfig> configPackage;
+ TInt err = iAudioPlayer->CustomCommandSync(pckg,
+ EMMFAudioControllerGetSourceSampleRate, KNullDesC8,
+ KNullDesC8, configPackage);
+ if (err == KErrNone)
+ {
+ *samplerate = configPackage().iSampleRate * 1000;
+ }
+ }
+ }
+ return err;
+ }
+
+TInt CMMFBackendEngine::GetChannels(XAuint32* channels)
+ {
+ TInt err(KErrNone);
+ TUint ch(0);
+ if (iAPIBeingUsed == EAudioRecorderUtility)
+ {
+ if (iRecordState != CMMFBackendEngine::ERecorderNotReady)
+ {
+ TRAP(err,ch = iAudioRecorder->DestinationNumberOfChannelsL());
+ if (err == KErrNone)
+ {
+ *channels = ch;
+ }
+ }
+ }
+ else if (iAPIBeingUsed == EAudioPlayerUtility)
+ {
+ if (iMediaPlayerState != XA_PLAYSTATE_PLAYERUNINITIALIZED)
+ {
+ TMMFMessageDestinationPckg pckg(KUidInterfaceMMFAudioController);
+ TPckgBuf<TMMFAudioConfig> configPackage;
+ TInt err = iAudioPlayer->CustomCommandSync(pckg,
+ EMMFAudioControllerGetSourceNumChannels, KNullDesC8,
+ KNullDesC8, configPackage);
+ if (err == KErrNone)
+ {
+ *channels = configPackage().iChannels;
+ }
+ }
+ }
+ return err;
+ }
+
+TInt CMMFBackendEngine::SetDestinationBitRate(XAuint32* bitrate)
+ {
+ TInt err(KErrNone);
+ if (iRecordState == CMMFBackendEngine::ERecorderOpen)
+ {
+ TRAP(err, iAudioRecorder->SetDestinationBitRateL(*bitrate));
+ if (err != KErrNone)
+ {
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+ }
+ return err;
+ }
+
+TInt CMMFBackendEngine::SetDestinationSampleRate(XAmilliHertz* samplerate)
+ {
+ TInt err(KErrNone);
+ if (iRecordState == CMMFBackendEngine::ERecorderOpen)
+ {
+ TRAP(err, iAudioRecorder->SetDestinationSampleRateL(*samplerate/1000));
+ if (err != KErrNone)
+ {
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+ }
+ return err;
+ }
+
+TInt CMMFBackendEngine::SetDestinationChannels(XAuint32* channels)
+ {
+ TInt err(KErrNone);
+ if (iRecordState == CMMFBackendEngine::ERecorderOpen)
+ {
+ TRAP(err,iAudioRecorder->SetDestinationNumberOfChannelsL(*channels));
+ if (err != KErrNone)
+ {
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+ }
+ 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)
+ {
+ iUriType = ELocal;
+ TPtr tmp(const_cast<TUint16 *> (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;
+
+ }
+ else
+ {
+ iUriType = EStreaming;
+ }
+ 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;
+ }
+
+XAresult CMMFBackendEngine::SetPlaybackRate(XAint16 rate)
+ {
+ XAresult retVal(XA_RESULT_INTERNAL_ERROR);
+
+ switch (iMediaPlayerState)
+ {
+ case XA_PLAYSTATE_STOPPED:
+ case XA_PLAYSTATE_PAUSED:
+ case XA_PLAYSTATE_PLAYING:
+ if (iAPIBeingUsed == EAudioPlayerUtility)
+ {
+ retVal = XA_RESULT_FEATURE_UNSUPPORTED;
+ }
+ else
+ {
+ TRAPD(err, iVideoPlayer->SetPlayVelocityL(rate));
+ if(!err)
+ {
+ retVal = XA_RESULT_SUCCESS;
+ }
+ }
+ break;
+ case XA_PLAYSTATE_PLAYERUNINITIALIZED:
+ default:
+ break;
+ }
+ return retVal;
+ }
+
+XAresult CMMFBackendEngine::GetPlaybackRateCapabilities(XAboolean* forward,
+ XAboolean* backward)
+ {
+ XAresult retVal(XA_RESULT_PARAMETER_INVALID);
+
+ switch (iMediaPlayerState)
+ {
+ case XA_PLAYSTATE_STOPPED:
+ case XA_PLAYSTATE_PAUSED:
+ case XA_PLAYSTATE_PLAYING:
+ if (iAPIBeingUsed == EAudioPlayerUtility)
+ {
+ retVal = XA_RESULT_FEATURE_UNSUPPORTED;
+ }
+ else
+ {
+ TVideoPlayRateCapabilities capability;
+ TRAPD(err, iVideoPlayer->GetPlayRateCapabilitiesL(capability));
+ if(!err)
+ {
+ *forward = capability.iPlayForward;
+ *backward = capability.iPlayBackward;
+ retVal = XA_RESULT_SUCCESS;
+ }
+ }
+ break;
+ case XA_PLAYSTATE_PLAYERUNINITIALIZED:
+ default:
+ break;
+ }
+ return retVal;
+ }
+
+extern "C"
+ {
+
+ int mmf_backend_engine_init(void** engine)
+ {
+ TRAPD(err, *engine = CMMFBackendEngine::NewL());
+ 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);
+ }
+
+ int mmf_set_adapt_context(void* context, void* adaptcontext)
+ {
+ return ((CMMFBackendEngine*) (context))->SetAdaptContext(adaptcontext);
+ }
+
+ void mmf_close(void* context)
+ {
+ ((CMMFBackendEngine*) context)->Close();
+ }
+
+ int mmf_start_recording(void* context)
+ {
+ return ((CMMFBackendEngine*) (context))->SetRecorderState(
+ CMMFBackendEngine::ERecorderRecording, FALSE);
+ }
+
+ int mmf_stop_recording(void* context, XAboolean 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_codec_id(void* context, XAuint32* encoderId)
+ {
+ return ((CMMFBackendEngine*) (context))->GetCodecId(encoderId);
+ }
+
+ int mmf_get_channels(void* context, XAuint32* channelsIn)
+ {
+ return ((CMMFBackendEngine*) (context))->GetChannels(channelsIn);
+ }
+
+ int mmf_get_samplerate(void* context, XAmilliHertz* sampleRate)
+ {
+ 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);
+ }
+
+ int mmf_set_destination_bitrate(void* context, XAuint32* bitRate)
+ {
+ 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);
+ }
+
+ XAresult mmf_playbackrateitf_set_playbackrate(void * context, XAint16 rate)
+ {
+ return ((CMMFBackendEngine *) (context))->SetPlaybackRate(rate);
+ }
+
+ XAresult mmf_playbackrateitf_get_playbackratecaps(void * context, XAboolean* forward, XAboolean* backward)
+ {
+ return ((CMMFBackendEngine *) (context))->GetPlaybackRateCapabilities(forward,backward);
+ }
+ }