--- 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 <string.h>
#include <ctype.h>
#include <uri8.h>
+#include <uri16.h>
+#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;i<sizeof(extension);i++)
+ char* dotPtr = NULL;
+ char ext[MAX_EXTENSION_SIZE] = { 0 };
+ int extLen;
+
+ dotPtr = strrchr(uri, (int)'.');
+ if (!dotPtr)
{
- extension[i] = tolower(extension[i]);
+ return KErrNotFound;
}
-
- if(aFunc == ERecord)
+
+ strncpy(ext, dotPtr,strlen(dotPtr));
+ /*Null terminate the string*/
+ ext[strlen(dotPtr)] = '\0';
+ extLen = sizeof(ext);
+ for(unsigned int i=0; i < extLen; i++)
{
- return EAudioPlayerUtility;
+ ext[i] = tolower(ext[i]);
+ }
+
+ if (aFunc == ERecord)
+ {
+ return EAudioRecorderUtility;
}
else
{
- if(!strcmp(extension, ".mp3") || (!strcmp(extension, ".amr")) || (!strcmp(extension, ".aac")) || (!strcmp(extension, ".mid")) ||
- (!strcmp(extension, ".awb")))
+ if (!strcasecmp(ext, ".mp3") ||
+ !strcasecmp(ext, ".amr") ||
+ !strcasecmp(ext, ".aac") ||
+ !strcasecmp(ext, ".mid") ||
+ !strcasecmp(ext, ".wav") ||
+ !strcasecmp(ext, ".awb"))
{
- return EAudioPlayerUtility;
+ return EAudioPlayerUtility;
}
- else
+ else
{
return EVideoPlayerUtility;
}
}
}
-void 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;
-
- }
-
//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<CAudioInput::TAudioInputPreference> 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<TMMFAudioConfig> 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<TMMFAudioConfig> 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<TMMFAudioConfig> 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<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;
+
+ }
+ 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);
+ }
}