1 /*

     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:

    15  *

    16  */

    17 

    18 #include <string.h>

    19 #include <ctype.h>

    20 #include <uri8.h>

    21 #include <uri16.h>

    22 #include "cmmfbackendengine.h"

    23 #include "markerpositiontimer.h"

    24 #include "positionupdatetimer.h"

    25 #include "profileutilmacro.h"

    26 #include <mmf/common/mmfvideoenums.h>

    27 

    28 extern "C"

    29     {

    30 #include "xaadaptationmmf.h"

    31     }

    32 

    33 #define RET_IF_ERR(res, val) if (res != KErrNone) return val

    34 

    35 const XAuint32 XA_PLAYSTATE_PLAYERUNINITIALIZED = 0;

    36 

    37 CMMFBackendEngine* CMMFBackendEngine::NewL()

    38     {

    39     CMMFBackendEngine* self = new (ELeave) CMMFBackendEngine();

    40     CleanupStack::PushL(self);

    41     self->ConstructL();

    42     CleanupStack::Pop(self);

    43     return self;

    44     }

    45 

    46 CMMFBackendEngine::~CMMFBackendEngine()

    47     {

    48     Close();

    49     Destroy();

    50     }

    51 

    52 CMMFBackendEngine::CMMFBackendEngine() :

    53     iPositionUpdatePeriod(1000), /* default is 1000 millisec */

    54     iUriPtr(NULL, 0)

    55     {

    56     iRecordState = ERecorderNotReady;

    57     iPositionUpdateTimer = NULL;

    58     iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED;

    59     iMMFPlayerState = EPlayerClosed;

    60     }

    61 

    62 void CMMFBackendEngine::ConstructL()

    63     {

    64     iAPIBeingUsed = ENoUtility;

    65     iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait;

    66     }

    67 

    68 void CMMFBackendEngine::InitAudioRecorderUtilityL()

    69     {

    70     if (!iAudioRecorder)

    71         {

    72         iBaseAudioRecorder = CMdaAudioRecorderUtility::NewL(*this);

    73         iAudioRecorder = (CMdaAudioRecorderUtility*) iBaseAudioRecorder;

    74         }

    75     }

    76 

    77 void CMMFBackendEngine::InitAudioPlayerUtilityL()

    78     {

    79     if (!iAudioPlayer)

    80         {

    81         iBaseAudioPlayer = CMdaAudioPlayerUtility::NewL(*this);

    82         iAudioPlayer = (CMdaAudioPlayerUtility*) iBaseAudioPlayer;

    83         }

    84     InitPlayerTimersL();

    85     }

    86 

    87 void CMMFBackendEngine::InitVideoPlayerUtilityL()

    88     {

    89     if (!iVideoPlayer)

    90         {

    91         iBaseVideoPlayer = CVideoPlayerUtility2::NewL(*this,

    92                 EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);

    93         iVideoPlayer = (CVideoPlayerUtility2*) iBaseVideoPlayer;

    94         iVideoPlayer->RegisterForVideoLoadingNotification(*this);

    95         }

    96     InitPlayerTimersL();

    97     }

    98 

    99 void CMMFBackendEngine::InitPlayerTimersL()

   100     {

   101     if (!iMarkerPositionTimer)

   102         {

   103         iMarkerPositionTimer = CMarkerPositionTimer::NewL(iAudioPlayer,

   104                 iVideoPlayer);

   105         iMarkerPositionTimer->SetContext(iAdaptContext);

   106         }

   107     if (!iPlayItfPositionUpdateTimer)

   108         {

   109         iPlayItfPositionUpdateTimer = CPositionUpdateTimer::NewL(

   110                 iAudioPlayer, iVideoPlayer);

   111         iPlayItfPositionUpdateTimer->SetContext(iAdaptContext);

   112         }

   113     iMarkerPositionTimer->Stop();

   114     iPlayItfPositionUpdateTimer->Stop();

   115     }

   116 

   117 TInt CMMFBackendEngine::SetFileName(char* uri, XAuint32 format,

   118         TFuncInUse func)

   119     {

   120     TInt err(KErrNone);

   121     _LIT8(KFileSlash,"file:///");

   122     TInt fileslashlen = KFileSlash().Length();

   123     if (func == ERecord)

   124         {

   125         if (iRecordState == ERecorderNotReady)

   126             {

   127             iFileFormat = format;

   128             iAPIBeingUsed = DetermineAPIToUse(uri, ERecord);

   129             err = XA_RESULT_INTERNAL_ERROR;

   130             if (iAPIBeingUsed == EAudioRecorderUtility)

   131                 {

   132                 /* Initialize URI as needed by MMF utilities */

   133                 err = InitializeURIForMMFUtil(uri);

   134                 RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

   135                 /* Initalize Recorder related objects */

   136                 TRAP(err, InitAudioRecorderUtilityL());

   137                 RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

   138 

   139                 TRAP(err, iAudioRecorder->OpenFileL(iUriPtr));

   140                 RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

   141                 /* Wait until we receive moscostatechanged callback */

   142                 if (iActiveSchedulerWait && !iActiveSchedulerWait->IsStarted())

   143                     {

   144                     iActiveSchedulerWait->Start();

   145                     }

   146                 RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

   147                 }

   148             }

   149         }

   150     else

   151         {

   152         /* The second one is needed for dynamic source interface */

   153         if ((iMediaPlayerState == XA_PLAYSTATE_PLAYERUNINITIALIZED)

   154                 || (iMediaPlayerState == XA_PLAYSTATE_STOPPED))

   155             {

   156             iFileFormat = format;

   157             iAPIBeingUsed = DetermineAPIToUse(uri, EPlay);

   158             err = XA_RESULT_INTERNAL_ERROR;

   159             if (iAPIBeingUsed == EAudioPlayerUtility)

   160                 {

   161                 /* Initialize URI as needed by MMF utilities */

   162                 err = InitializeURIForMMFUtil(uri);

   163                 RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

   164                 /* Initalize Player related objects */

   165                 TRAP(err, InitAudioPlayerUtilityL());

   166                 RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

   167 

   168                 TAG_TIME_PROFILING_BEGIN;

   169                 TRAP(err, iAudioPlayer->OpenFileL(iUriPtr));

   170                 RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR); 

   171                 TAG_TIME_PROFILING_END; 

   172                 PRINT_TO_CONSOLE_TIME_DIFF;

   173 

   174                 /* Wait until we receive mapc init complete */

   175                 PRINT_TO_CONSOLE_HOME_TIME;

   176                 if (iActiveSchedulerWait && !iActiveSchedulerWait->IsStarted())

   177                     {

   178                     iActiveSchedulerWait->Start();

   179                     }

   180                 RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

   181                 }

   182             else if (iAPIBeingUsed == EVideoPlayerUtility)

   183                 {

   184                 /* Initialize URI as needed by MMF utilities */

   185                 err = InitializeURIForMMFUtil(uri);

   186                 RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

   187                 /* Initalize Player related objects */

   188                 TRAP(err, InitVideoPlayerUtilityL());

   189                 RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

   190 

   191                 if (iUriType == ELocal)

   192                     {

   193                     /* Open file */

   194                     TAG_TIME_PROFILING_BEGIN;

   195                     TRAP(err, iVideoPlayer->OpenFileL(iUriPtr));

   196                     RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR); 

   197                     TAG_TIME_PROFILING_END; 

   198                     PRINT_TO_CONSOLE_TIME_DIFF;

   199                     }

   200                 else

   201                     {

   202                     /* Open URL */

   203                     TAG_TIME_PROFILING_BEGIN;

   204                     TRAP(err, iVideoPlayer->OpenUrlL(iUriPtr));

   205                     RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR); 

   206                     TAG_TIME_PROFILING_END; 

   207                     PRINT_TO_CONSOLE_TIME_DIFF;

   208                     }

   209                 /* Wait until we receive  MvpuoOpenComplete */

   210                 PRINT_TO_CONSOLE_HOME_TIME;

   211                 if (iActiveSchedulerWait && !iActiveSchedulerWait->IsStarted())

   212                     {

   213                     iActiveSchedulerWait->Start();

   214                     }

   215                 RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

   216 

   217                 /* Prepare utility */

   218                 TAG_TIME_PROFILING_BEGIN_NO_VAR_DEF;

   219                 iVideoPlayer->Prepare();

   220                 TAG_TIME_PROFILING_END_NO_VAR_DEF; 

   221                 PRINT_TO_CONSOLE_TIME_DIFF;

   222 

   223                 /* Wait until we receive  MvpuoPrepareComplete */

   224                 PRINT_TO_CONSOLE_HOME_TIME_NO_VAR_DEF;

   225                 if (iActiveSchedulerWait && !iActiveSchedulerWait->IsStarted())

   226                     {

   227                     iActiveSchedulerWait->Start();

   228                     }

   229                 RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

   230                 }

   231             }

   232         }

   233     if (err != KErrNone)

   234         {

   235         err = XA_RESULT_INTERNAL_ERROR;

   236         }

   237     return err;

   238     }

   239 

   240 TInt CMMFBackendEngine::DetermineAPIToUse(char* uri, TFuncInUse aFunc)

   241     {

   242     char* dotPtr = NULL;

   243     char ext[MAX_EXTENSION_SIZE] =

   244         {

   245         0

   246         };

   247     int extLen;

   248 

   249     int colpos;

   250     char urischeme[MAX_EXTENSION_SIZE] =

   251         {

   252         0

   253         };

   254     int urischemeLen;

   255 

   256     dotPtr = strrchr(uri, (int) '.');

   257     if (!dotPtr)

   258         {

   259         return KErrNotFound;

   260         }

   261 

   262     strncpy(ext, dotPtr, strlen(dotPtr));

   263     /*Null terminate the string*/

   264     ext[strlen(dotPtr)] = '\0';

   265     extLen = sizeof(ext);

   266     for (unsigned int i = 0; i < extLen; i++)

   267         {

   268         ext[i] = tolower(ext[i]);

   269         }

   270 

   271     colpos = strcspn(uri, ":");

   272 

   273     strncpy(urischeme, uri, colpos + 1);

   274     /*Null terminate the string*/

   275     urischeme[colpos + 1] = '\0';

   276     urischemeLen = sizeof(urischeme);

   277     for (unsigned int i = 0; i < urischemeLen; i++)

   278         {

   279         urischeme[i] = tolower(urischeme[i]);

   280         }

   281 

   282     if (aFunc == ERecord)

   283         {

   284         return EAudioRecorderUtility;

   285         }

   286     else

   287         {

   288         if (!strcmp(urischeme, "file:"))

   289             {

   290             if (!strcmp(ext, ".mp3") || !strcmp(ext, ".amr")

   291                     || !strcmp(ext, ".aac") || !strcmp(ext, ".mid")

   292                     || !strcmp(ext, ".wav") || !strcmp(ext, ".awb"))

   293                 {

   294                 return EAudioPlayerUtility;

   295                 }

   296             else

   297                 {

   298                 return EVideoPlayerUtility;

   299                 }

   300             }

   301         else

   302             {

   303             return EVideoPlayerUtility;

   304             }

   305         }

   306     }

   307 

   308 //From MVidePlayerUtilityObserver

   309 void CMMFBackendEngine::MvpuoOpenComplete(TInt aError)

   310     {

   311     PRINT_TO_CONSOLE_HOME_TIME;

   312 

   313     iErrorCode = aError;

   314     if (iErrorCode == KErrNone)

   315         {

   316         iMMFPlayerState = EPlayerOpened;

   317         }

   318     if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted())

   319         {

   320         iActiveSchedulerWait->AsyncStop();

   321         }

   322     }

   323 

   324 void CMMFBackendEngine::MvpuoPrepareComplete(TInt aError)

   325     {

   326     PRINT_TO_CONSOLE_HOME_TIME;

   327 

   328     TAutoScaleType autoScale = EAutoScaleBestFit;

   329     iErrorCode = aError;

   330     iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED;

   331     iMediaDuration = 0;

   332     iMarkerPositionTimer->ResetPlayer();

   333     iPlayItfPositionUpdateTimer->ResetPlayer();

   334     if (iErrorCode == KErrNone)

   335         {

   336         iMMFPlayerState = EPlayerPrepared;

   337         TAG_TIME_PROFILING_BEGIN;

   338         TRAP(iErrorCode, iMediaDuration = iVideoPlayer->DurationL()); 

   339         TAG_TIME_PROFILING_END; 

   340         PRINT_TO_CONSOLE_TIME_DIFF;

   341         if (iErrorCode == KErrNone)

   342             {

   343             iPlaybackHead = 0;

   344             iMediaPlayerState = XA_PLAYSTATE_STOPPED;

   345             iMarkerPositionTimer->UseVideoPlayer();

   346             iPlayItfPositionUpdateTimer->UseVideoPlayer();

   347             if (m_pWs && m_pScr && m_pWindow)

   348                 {

   349                 TRect videoExtent = TRect(m_pWindow->Size());

   350                 TRect clipRect = TRect(m_pWindow->Size());

   351                 TAG_TIME_PROFILING_BEGIN;

   352                 TRAP_IGNORE(iVideoPlayer->AddDisplayWindowL(*m_pWs, *m_pScr, *m_pWindow, videoExtent, clipRect));

   353                 TRAP_IGNORE(iVideoPlayer->SetAutoScaleL(*m_pWindow, autoScale)); 

   354                 TAG_TIME_PROFILING_END; 

   355                 PRINT_TO_CONSOLE_TIME_DIFF;

   356                 }

   357             }

   358         }

   359     if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted())

   360         {

   361         iActiveSchedulerWait->AsyncStop();

   362         }

   363     }

   364 

   365 void CMMFBackendEngine::MvpuoFrameReady(CFbsBitmap& /*aFrame*/, TInt /*aError*/)

   366     {

   367 

   368     }

   369 void CMMFBackendEngine::MvpuoPlayComplete(TInt aError)

   370     {

   371     iErrorCode = aError;

   372     if (iErrorCode == KErrNone)

   373         {

   374         iPlaybackHead = iMediaDuration;

   375         /* Per OpenMAX AL Spec, when playback is completed, media player stays in

   376          * paused state with playhead at the end of the media clip */

   377         iMediaPlayerState = XA_PLAYSTATE_PAUSED;

   378         DoPostEvent(XA_PLAYEVENT_HEADATEND);

   379         }

   380     else

   381         {

   382         iPlaybackHead = 0;

   383         iMediaPlayerState = XA_PLAYSTATE_STOPPED;

   384         XAAdaptEvent event =

   385             {

   386             XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL

   387             };

   388         XAAdaptationBase_SendAdaptEvents(

   389                 (XAAdaptationBaseCtx*) iAdaptContext, &event);

   390         }

   391     iMMFPlayerState = EPlayerPrepared;

   392     iMarkerPositionTimer->Stop();

   393     iPlayItfPositionUpdateTimer->Stop();

   394     }

   395 

   396 void CMMFBackendEngine::MvpuoEvent(class TMMFEvent const & event)

   397     {

   398     //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent (0x%x %d)"), event.iEventType, event.iErrorCode);

   399 

   400     if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError

   401             && event.iErrorCode == KErrHardwareNotAvailable)

   402         {

   403         //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Hardware Not Available"));

   404         }

   405 

   406     else if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError

   407             && event.iErrorCode == KErrMMPartialPlayback)

   408         {

   409         //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Partial playback"));

   410         }

   411     if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError

   412             && event.iErrorCode == -12014)

   413         {

   414         //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Audio Device taken"));

   415         PausePlayback();

   416         XAAdaptEvent alEvent =

   417             {

   418             XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL

   419             };

   420         XAAdaptationBase_SendAdaptEvents(

   421                 (XAAdaptationBaseCtx*) iAdaptContext, &alEvent);

   422         }

   423     else if (event.iEventType == KMMFRefreshMetaData)

   424         {

   425         //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: EventType == KMMFRefreshMetaData"));

   426         }

   427     else

   428         {

   429         //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Unhandled event"));

   430         }

   431 

   432     }

   433 

   434 // From MRebufferCallback

   435 void CMMFBackendEngine::MvloLoadingStarted()

   436     {

   437     }

   438 

   439 void CMMFBackendEngine::MvloLoadingComplete()

   440     {

   441     //file playing

   442     }

   443 

   444 //MMdaAudioPlayerCallback

   445 void CMMFBackendEngine::MapcInitComplete(TInt aError,

   446         const TTimeIntervalMicroSeconds& aDuration)

   447     {

   448     PRINT_TO_CONSOLE_HOME_TIME;

   449 

   450     iErrorCode = aError;

   451     iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED;

   452     iMMFPlayerState = EPlayerClosed;

   453     iMediaDuration = 0;

   454     iMarkerPositionTimer->ResetPlayer();

   455     iPlayItfPositionUpdateTimer->ResetPlayer();

   456     if (iErrorCode == KErrNone)

   457         {

   458         iMediaDuration = aDuration;

   459         iPlaybackHead = 0;

   460         iMediaPlayerState = XA_PLAYSTATE_STOPPED;

   461         iMMFPlayerState = EPlayerOpened;

   462         iMarkerPositionTimer->UseAudioPlayer();

   463         iPlayItfPositionUpdateTimer->UseAudioPlayer();

   464         }

   465     if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted())

   466         {

   467         iActiveSchedulerWait->AsyncStop();

   468         }

   469     }

   470 

   471 void CMMFBackendEngine::MapcPlayComplete(TInt aError)

   472     {

   473     iErrorCode = aError;

   474     if (iErrorCode == KErrNone)

   475         {

   476         /* Now we should have better value. Start using that */

   477         iAudioPlayer->Duration(iMediaDuration);

   478         iPlaybackHead = iMediaDuration;

   479         /* Per OpenMAX AL Spec, when playback is completed, media player stays in

   480          * paused state with playhead at the end of the media clip */

   481         iMediaPlayerState = XA_PLAYSTATE_PAUSED;

   482         DoPostEvent(XA_PLAYEVENT_HEADATEND);

   483         iMMFPlayerState = EPlayerOpened;

   484         }

   485     else

   486         {

   487         iAudioPlayer->GetPosition(iPlaybackHead);

   488         iMediaPlayerState = XA_PLAYSTATE_PAUSED;

   489         iMMFPlayerState = EPlayerPaused;

   490         XAAdaptEvent event =

   491             {

   492             XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL

   493             };

   494         XAAdaptationBase_SendAdaptEvents(

   495                 (XAAdaptationBaseCtx*) iAdaptContext, &event);

   496         }

   497     iMarkerPositionTimer->Stop();

   498     iPlayItfPositionUpdateTimer->Stop();

   499     }

   500 

   501 // from MMdaObjectStateChangeObserver

   502 void CMMFBackendEngine::MoscoStateChangeEvent(CBase* /*aObject*/,

   503         TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)

   504     {

   505     TInt err(KErrNone);

   506     iPreviousRecordState = aPreviousState;

   507     iCurrentRecordState = aCurrentState;

   508     iErrorCode = aErrorCode;

   509     //RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 1 Error[%d]"),aErrorCode);

   510     if (iCurrentRecordState == CMdaAudioClipUtility::EOpen) //EOpen

   511         {

   512         //outputfile is open and ready for recording

   513         iRecordState = CMMFBackendEngine::ERecorderOpen;

   514         if (iErrorCode == KErrNone)

   515             {

   516             if (iPreviousRecordState == CMdaAudioClipUtility::ENotReady)

   517                 {

   518                 //RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 2"));

   519                 TRAP(err,iAudioInputRecord = CAudioInput::NewL( *iAudioRecorder ));

   520                 if (err == KErrNone)

   521                     {

   522                     RArray<CAudioInput::TAudioInputPreference> inputArray;

   523                     inputArray.Append(CAudioInput::EDefaultMic);

   524                     // Set Audio Input

   525                     TRAP(err, iAudioInputRecord->SetAudioInputL( inputArray.Array( ) ));

   526                     inputArray.Close();

   527                     }

   528                 TMMFMessageDestination destination(

   529                         KUidMetaDataWriteCustomCommand);

   530                 TMMFMessageDestinationPckg pckg = TMMFMessageDestinationPckg(

   531                         destination);

   532                 TInt ret = iAudioRecorder->RecordControllerCustomCommandSync(

   533                         pckg, 0, KNullDesC8, KNullDesC8);

   534                 //RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 3 [%d]"),ret);

   535                 if (ret != KErrNone && iFileFormat == XA_CONTAINERTYPE_MP4)

   536                     {

   537                     iPauseSupportMP4 = FALSE;

   538                     }

   539                 if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted())

   540                     {

   541                     iActiveSchedulerWait->AsyncStop();

   542                     }

   543                 }

   544             }

   545         else

   546             {

   547             XAAdaptEvent event =

   548                 {

   549                 XA_RECORDITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL

   550                 };

   551             XAAdaptationBase_SendAdaptEvents(

   552                     (XAAdaptationBaseCtx*) iAdaptContext, &event);

   553             }

   554         }

   555     else if (iCurrentRecordState == CMdaAudioClipUtility::ERecording) //ERecording

   556         {

   557         iRecordState = CMMFBackendEngine::ERecorderRecording;

   558         iPositionUpdateTimer->Start(iTimerDelay);

   559         XAAdaptEvent event =

   560             {

   561             XA_RECORDITFEVENTS, XA_RECORDEVENT_HEADMOVING, 0, NULL

   562             };

   563         XAAdaptationBase_SendAdaptEvents(

   564                 (XAAdaptationBaseCtx*) iAdaptContext, &event);

   565         }

   566     else //ENotReady

   567         {

   568         //outputfile is not open

   569         iRecordState = CMMFBackendEngine::ERecorderNotReady;

   570         }

   571     }

   572 

   573 TInt CMMFBackendEngine::SetRecorderState(TRecorderState state,

   574         XAboolean stopCalled)

   575     {

   576     TInt err(KErrNone);

   577 

   578     if (iAPIBeingUsed != EAudioRecorderUtility)

   579         {

   580         return XA_RESULT_INTERNAL_ERROR;

   581         }

   582 

   583     switch (state)

   584         {

   585         case ERecorderNotReady:

   586             iAudioRecorder->Close();

   587             iRecordState = ERecorderNotReady;

   588             break;

   589         case ERecorderOpen:

   590             if (iFileFormat == XA_CONTAINERTYPE_MP4 && !iPauseSupportMP4

   591                     && !stopCalled)

   592                 {

   593                 err = KErrNotSupported;

   594                 return err;

   595                 }

   596             iPositionUpdateTimer->Stop();

   597             iAudioRecorder->Stop();

   598             iRecordState = ERecorderOpen;

   599             break;

   600         case ERecorderRecording:

   601             TRAP(err, iAudioRecorder->RecordL())

   602             ;

   603             break;

   604         }

   605     return err;

   606     }

   607 

   608 void CMMFBackendEngine::Close()

   609     {

   610     if (iMarkerPositionTimer)

   611         {

   612         iMarkerPositionTimer->Stop();

   613         }

   614     if (iPlayItfPositionUpdateTimer)

   615         {

   616         iPlayItfPositionUpdateTimer->Stop();

   617         }

   618 

   619     if (iBaseVideoPlayer && iVideoPlayer)

   620         {

   621         switch (iMMFPlayerState)

   622             {

   623             case EPlayerPlaying:

   624             case EPlayerPaused:

   625             case EPlayerPrepared:

   626                 iVideoPlayer->Stop();

   627             case EPlayerOpened:

   628                 if (m_pWs && m_pScr && m_pWindow)

   629                     {

   630                     iVideoPlayer->RemoveDisplayWindow(*m_pWindow);

   631                     }

   632                 iVideoPlayer->Close();

   633             case EPlayerClosed:

   634             default:

   635                 break;

   636             };

   637         }

   638 

   639     // deleting the AudioInput object

   640     if (iAudioInputRecord)

   641         {

   642         delete iAudioInputRecord;

   643         iAudioInputRecord = NULL;

   644         }

   645 

   646     if (iBaseAudioPlayer && iAudioPlayer)

   647         {

   648         iAudioPlayer->Close();

   649         }

   650 

   651     if (iBaseAudioRecorder)

   652         {

   653         iAudioRecorder->Close();

   654         }

   655 

   656     if (iPositionUpdateTimer)

   657         {

   658         iPositionUpdateTimer->Stop();

   659         }

   660 

   661     if (iActiveSchedulerWait && iActiveSchedulerWait->IsStarted())

   662         {

   663         iActiveSchedulerWait->AsyncStop();

   664         }

   665     }

   666 

   667 void CMMFBackendEngine::Destroy()

   668     {

   669     delete iPositionUpdateTimer;

   670     iPositionUpdateTimer = NULL;

   671     delete iUri;

   672     iUri = NULL;

   673     delete iMarkerPositionTimer;

   674     iMarkerPositionTimer = NULL;

   675     delete iPlayItfPositionUpdateTimer;

   676     iPlayItfPositionUpdateTimer = NULL;

   677     delete iBaseVideoPlayer;

   678     iBaseVideoPlayer = NULL;

   679     iVideoPlayer = NULL;

   680     delete iBaseAudioPlayer;

   681     iBaseAudioPlayer = NULL;

   682     iAudioPlayer = NULL;

   683     delete iBaseAudioRecorder;

   684     iBaseAudioRecorder = NULL;

   685     iAudioRecorder = NULL;

   686     delete iActiveSchedulerWait;

   687     iActiveSchedulerWait = NULL;

   688     delete m_pScr;

   689     m_pScr = NULL;

   690     }

   691 

   692 TInt CMMFBackendEngine::GetRecordPosition(XAuint64* position)

   693     {

   694     TInt err(KErrNone);

   695     *position = iAudioRecorder->Position().Int64();

   696     return err;

   697     }

   698 

   699 TInt CMMFBackendEngine::SetPositionUpdatePerioed(XAmillisecond period)

   700     {

   701     TInt err(KErrNone);

   702     iTimerDelay = period;

   703     return err;

   704     }

   705 

   706 TInt CMMFBackendEngine::SetAdaptContext(void* adaptcontext)

   707     {

   708     TInt err(KErrNone);

   709     iAdaptContext = adaptcontext;

   710     TRAP(err, iPositionUpdateTimer = new (ELeave) LocalTimer(this, iAdaptContext));

   711     if (!err)

   712         {

   713         iPositionUpdateTimer->PostInit();

   714         }

   715     return err;

   716     }

   717 

   718 TInt CMMFBackendEngine::GetCodecId(XAuint32* codecid)

   719     {

   720     TInt err(KErrNone);

   721 

   722     if (iAPIBeingUsed == EAudioRecorderUtility)

   723         {

   724         if (iRecordState != CMMFBackendEngine::ERecorderNotReady)

   725             {

   726             TFourCC dest;

   727             TRAP(err, dest = iAudioRecorder->DestinationDataTypeL());

   728             if (err == KErrNone)

   729                 {

   730                 *codecid = dest.FourCC();

   731                 }

   732             }

   733         }

   734     else if (iAPIBeingUsed == EAudioPlayerUtility)

   735         {

   736         if (iMediaPlayerState != XA_PLAYSTATE_PLAYERUNINITIALIZED)

   737             {

   738             TMMFMessageDestinationPckg pckg(KUidInterfaceMMFAudioController);

   739             TPckgBuf<TMMFAudioConfig> configPackage;

   740             TInt err = iAudioPlayer->CustomCommandSync(pckg,

   741                     EMMFAudioControllerGetSourceDataType, KNullDesC8,

   742                     KNullDesC8, configPackage);

   743             if (err == KErrNone)

   744                 {

   745                 *codecid = configPackage().iSourceDataTypeCode.FourCC();

   746                 }

   747             }

   748         }

   749     return err;

   750     }

   751 

   752 TInt CMMFBackendEngine::GetBitRate(XAuint32* bitrate)

   753     {

   754     TInt err(KErrNone);

   755     TUint br(0);

   756     if (iAPIBeingUsed == EAudioRecorderUtility)

   757         {

   758         if (iRecordState != CMMFBackendEngine::ERecorderNotReady)

   759             {

   760             TRAP(err, br = iAudioRecorder->DestinationBitRateL());

   761             if (err == KErrNone)

   762                 {

   763                 *bitrate = br;

   764                 }

   765             }

   766         }

   767     else if (iAPIBeingUsed == EAudioPlayerUtility)

   768         {

   769         if (iMediaPlayerState != XA_PLAYSTATE_PLAYERUNINITIALIZED)

   770             {

   771             TInt err = iAudioPlayer->GetBitRate(br);

   772             *bitrate = br;

   773             }

   774         }

   775     return err;

   776     }

   777 

   778 TInt CMMFBackendEngine::GetSampleRate(XAmilliHertz* samplerate)

   779     {

   780     TInt err(KErrNone);

   781     TUint sr(0);

   782     if (iAPIBeingUsed == EAudioRecorderUtility)

   783         {

   784         if (iRecordState != CMMFBackendEngine::ERecorderNotReady)

   785             {

   786             TRAP(err, sr = iAudioRecorder->DestinationSampleRateL());

   787             if (err == KErrNone)

   788                 {

   789                 *samplerate = sr * 1000;

   790                 }

   791             }

   792         }

   793     else if (iAPIBeingUsed == EAudioPlayerUtility)

   794         {

   795         if (iMediaPlayerState != XA_PLAYSTATE_PLAYERUNINITIALIZED)

   796             {

   797             TMMFMessageDestinationPckg pckg(KUidInterfaceMMFAudioController);

   798             TPckgBuf<TMMFAudioConfig> configPackage;

   799             TInt err = iAudioPlayer->CustomCommandSync(pckg,

   800                     EMMFAudioControllerGetSourceSampleRate, KNullDesC8,

   801                     KNullDesC8, configPackage);

   802             if (err == KErrNone)

   803                 {

   804                 *samplerate = configPackage().iSampleRate * 1000;

   805                 }

   806             }

   807         }

   808     return err;

   809     }

   810 

   811 TInt CMMFBackendEngine::GetChannels(XAuint32* channels)

   812     {

   813     TInt err(KErrNone);

   814     TUint ch(0);

   815     if (iAPIBeingUsed == EAudioRecorderUtility)

   816         {

   817         if (iRecordState != CMMFBackendEngine::ERecorderNotReady)

   818             {

   819             TRAP(err,ch = iAudioRecorder->DestinationNumberOfChannelsL());

   820             if (err == KErrNone)

   821                 {

   822                 *channels = ch;

   823                 }

   824             }

   825         }

   826     else if (iAPIBeingUsed == EAudioPlayerUtility)

   827         {

   828         if (iMediaPlayerState != XA_PLAYSTATE_PLAYERUNINITIALIZED)

   829             {

   830             TMMFMessageDestinationPckg pckg(KUidInterfaceMMFAudioController);

   831             TPckgBuf<TMMFAudioConfig> configPackage;

   832             TInt err = iAudioPlayer->CustomCommandSync(pckg,

   833                     EMMFAudioControllerGetSourceNumChannels, KNullDesC8,

   834                     KNullDesC8, configPackage);

   835             if (err == KErrNone)

   836                 {

   837                 *channels = configPackage().iChannels;

   838                 }

   839             }

   840         }

   841     return err;

   842     }

   843 

   844 TInt CMMFBackendEngine::SetDestinationBitRate(XAuint32* bitrate)

   845     {

   846     TInt err(KErrNone);

   847     if (iRecordState == CMMFBackendEngine::ERecorderOpen)

   848         {

   849         TRAP(err, iAudioRecorder->SetDestinationBitRateL(*bitrate));

   850         if (err != KErrNone)

   851             {

   852             return XA_RESULT_PARAMETER_INVALID;

   853             }

   854         }

   855     return err;

   856     }

   857 

   858 TInt CMMFBackendEngine::SetDestinationSampleRate(XAmilliHertz* samplerate)

   859     {

   860     TInt err(KErrNone);

   861     if (iRecordState == CMMFBackendEngine::ERecorderOpen)

   862         {

   863         TRAP(err, iAudioRecorder->SetDestinationSampleRateL(*samplerate/1000));

   864         if (err != KErrNone)

   865             {

   866             return XA_RESULT_PARAMETER_INVALID;

   867             }

   868         }

   869     return err;

   870     }

   871 

   872 TInt CMMFBackendEngine::SetDestinationChannels(XAuint32* channels)

   873     {

   874     TInt err(KErrNone);

   875     if (iRecordState == CMMFBackendEngine::ERecorderOpen)

   876         {

   877         TRAP(err,iAudioRecorder->SetDestinationNumberOfChannelsL(*channels));

   878         if (err != KErrNone)

   879             {

   880             return XA_RESULT_PARAMETER_INVALID;

   881             }

   882         }

   883     return err;

   884     }

   885 

   886 /*

   887  XAresult CMMFBackendEngine::SetWindowHandle(void* display_info)

   888  {

   889  XADataLocator_NativeDisplay* nativeDisplay;

   890  XADataSink* videoSink = (XADataSink*)display_info;

   891 

   892  nativeDisplay = (XADataLocator_NativeDisplay*) (videoSink->pLocator);

   893 

   894  m_pWindow = ((RWindow*)(nativeDisplay->hWindow));

   895  m_pWs =     ((RWsSession*)(nativeDisplay->hDisplay));

   896 

   897  m_bWindowReferencePassed = TRUE;

   898  return XA_RESULT_SUCCESS;

   899  }

   900 

   901  */

   902 XAresult CMMFBackendEngine::CreateAndConfigureWindowL()

   903     {

   904 #ifdef USE_LOCAL_WINDOW_RESOURCES

   905     // create window for attaching the surface as its background

   906     //RWsSession ws;

   907     //TInt err2(KErrNone);

   908     TInt err2 = m_ws.Connect();

   909     m_pScr = new(ELeave) CWsScreenDevice(m_ws);

   910     err2 = m_pScr->Construct();

   911     CWindowGc* gc = NULL;

   912     err2 = m_pScr->CreateContext(gc);

   913     RWindowGroup grp(m_ws);

   914     err2 = grp.Construct(0xf00f00);

   915     const TSize KWinSize(320, 240);

   916     m_pWindow = new (ELeave) RWindow(m_ws);

   917     err2 = m_pWindow->Construct(grp, 0xfeefee);

   918     m_pWindow->SetExtent(TPoint(), KWinSize);

   919     m_pWindow->SetBackgroundColor(TRgb(255,0,0,128));

   920     //win.SetBackgroundColor(TRgb(0,0,0,0));

   921     m_pWindow->Activate();

   922     m_pWindow->Invalidate();

   923     m_pWindow->BeginRedraw();

   924     gc->Activate(*m_pWindow);

   925     m_pWindow->EndRedraw();

   926     m_ws.Flush();

   927 

   928     //Create MediaClientUitlity for NGA Surfaces

   929     TInt displayId = m_pScr->GetScreenNumber();

   930 

   931     // Add the display window

   932     m_cropRegion = TRect(m_pWindow->Size());

   933     m_clipRect = TRect(m_pWindow->Size());

   934     m_videoExtent = TRect(m_pWindow->Size());

   935     m_rotation = EVideoRotationNone;

   936 #endif /* USE_LOCAL_WINDOW_RESOURCES */

   937 

   938     return XA_RESULT_SUCCESS;

   939     }

   940 

   941 XAresult CMMFBackendEngine::SetNativeDisplayInformation(void* display_info)

   942     {

   943     XAresult retVal(XA_RESULT_SUCCESS);

   944     //display_info is of type XADataSink

   945     //display_info.pLocator is of type XADataLocator_NativeDisplay

   946     XADataLocator_NativeDisplay* nativeDisplay;

   947     XADataSink* videoSink = (XADataSink*) display_info;

   948 

   949     if (videoSink)

   950         {

   951         nativeDisplay = (XADataLocator_NativeDisplay*) (videoSink->pLocator);

   952         m_pWindow = ((RWindow*) (nativeDisplay->hWindow));

   953         m_pWs = ((RWsSession*) (nativeDisplay->hDisplay));

   954         /*

   955          m_cropRegion = TRect(m_pWindow->Size());

   956          m_videoExtent = TRect(m_pWindow->Size());

   957          m_cropRect = TRect(m_pWindow->Size());

   958          m_clipRect = TRect(m_pWindow->Size());

   959          m_cropRegion = TRect(m_pWindow->Size());

   960          */

   961         if (m_pWs)

   962             {

   963             delete m_pScr;

   964             m_pScr = NULL;

   965             TRAPD(err, m_pScr = new CWsScreenDevice(*m_pWs));

   966             RET_IF_ERR(err, XA_RESULT_MEMORY_FAILURE);

   967             m_pScr->Construct();

   968             }

   969         }

   970     return retVal;

   971     }

   972 

   973 XAresult CMMFBackendEngine::ResumePlayback()

   974     {

   975     XAresult retVal(XA_RESULT_SUCCESS);

   976     TBool postHeadMovingEvent(EFalse);

   977     switch (iMediaPlayerState)

   978         {

   979         case XA_PLAYSTATE_STOPPED:

   980         case XA_PLAYSTATE_PAUSED:

   981             /* If we are already at the end of clip, do nothing

   982              * check ::MapcPlayComplete for documentation */

   983             if ((iPlaybackHead < iMediaDuration) && ((iAPIBeingUsed

   984                     == EAudioPlayerUtility) || (iAPIBeingUsed

   985                     == EVideoPlayerUtility)))

   986                 {

   987                 if (iAPIBeingUsed == EAudioPlayerUtility)

   988                     {

   989                     TAG_TIME_PROFILING_BEGIN;

   990                     iAudioPlayer->Play();

   991                     TAG_TIME_PROFILING_END; PRINT_TO_CONSOLE_TIME_DIFF;

   992                     }

   993                 else if (iAPIBeingUsed == EVideoPlayerUtility)

   994                     {

   995                     TAG_TIME_PROFILING_BEGIN;

   996                     //iVideoPlayer->Play( iPlaybackHead, iMediaDuration);

   997                     iVideoPlayer->Play();

   998                     TAG_TIME_PROFILING_END; PRINT_TO_CONSOLE_TIME_DIFF;

   999                     }

  1000                 postHeadMovingEvent = ETrue;

  1001                 iMediaPlayerState = XA_PLAYSTATE_PLAYING;

  1002                 iMMFPlayerState = EPlayerPlaying;

  1003                 iMarkerPositionTimer->Start();

  1004                 iPlayItfPositionUpdateTimer->Start();

  1005                 }

  1006             break;

  1007         case XA_PLAYSTATE_PLAYING:

  1008             break;

  1009         case XA_PLAYSTATE_PLAYERUNINITIALIZED:

  1010         default:

  1011             retVal = XA_RESULT_INTERNAL_ERROR;

  1012             break;

  1013         }

  1014 

  1015     if (postHeadMovingEvent)

  1016         {

  1017         DoPostEvent(XA_PLAYEVENT_HEADMOVING);

  1018         }

  1019     return retVal;

  1020     }

  1021 

  1022 XAresult CMMFBackendEngine::PausePlayback()

  1023     {

  1024     XAresult retVal(XA_RESULT_SUCCESS);

  1025     switch (iMediaPlayerState)

  1026         {

  1027         case XA_PLAYSTATE_PLAYING:

  1028         case XA_PLAYSTATE_STOPPED:

  1029             if ((iAPIBeingUsed == EAudioPlayerUtility) || (iAPIBeingUsed

  1030                     == EVideoPlayerUtility))

  1031                 {

  1032                 TInt pauseOpRes(KErrNone);

  1033                 if (iAPIBeingUsed == EAudioPlayerUtility)

  1034                     {

  1035                     TAG_TIME_PROFILING_BEGIN;

  1036                     pauseOpRes = iAudioPlayer->Pause();

  1037                     TAG_TIME_PROFILING_END; PRINT_TO_CONSOLE_TIME_DIFF;

  1038                     }

  1039                 else if (iAPIBeingUsed == EVideoPlayerUtility)

  1040                     {

  1041                     TAG_TIME_PROFILING_BEGIN;

  1042                     TRAP(pauseOpRes, iVideoPlayer->PauseL());

  1043                     if (pauseOpRes == KErrNone)

  1044                         {

  1045                         TRAPD(err, iPlaybackHead = iVideoPlayer->PositionL());

  1046                         if (err != KErrNone)

  1047                             {

  1048                             iPlaybackHead = 0;

  1049                             }

  1050                         } TAG_TIME_PROFILING_END; PRINT_TO_CONSOLE_TIME_DIFF;

  1051                     }

  1052                 if (pauseOpRes == KErrNone)

  1053                     {

  1054                     iMediaPlayerState = XA_PLAYSTATE_PAUSED;

  1055                     iMMFPlayerState = EPlayerPaused;

  1056                     iMarkerPositionTimer->Stop();

  1057                     iPlayItfPositionUpdateTimer->Stop();

  1058                     }

  1059                 }

  1060             break;

  1061         case XA_PLAYSTATE_PAUSED:

  1062             break;

  1063         case XA_PLAYSTATE_PLAYERUNINITIALIZED:

  1064         default:

  1065             retVal = XA_RESULT_INTERNAL_ERROR;

  1066             break;

  1067         }

  1068     return retVal;

  1069     }

  1070 

  1071 XAresult CMMFBackendEngine::StopPlayback()

  1072     {

  1073     XAresult retVal(XA_RESULT_SUCCESS);

  1074     switch (iMediaPlayerState)

  1075         {

  1076         case XA_PLAYSTATE_PAUSED:

  1077         case XA_PLAYSTATE_PLAYING:

  1078             if ((iAPIBeingUsed == EAudioPlayerUtility) || (iAPIBeingUsed

  1079                     == EVideoPlayerUtility))

  1080                 {

  1081                 if (iAPIBeingUsed == EAudioPlayerUtility)

  1082                     {

  1083                     TAG_TIME_PROFILING_BEGIN;

  1084                     iAudioPlayer->Stop();

  1085                     TAG_TIME_PROFILING_END; PRINT_TO_CONSOLE_TIME_DIFF;

  1086 

  1087                     iMMFPlayerState = EPlayerOpened;

  1088                     }

  1089                 else if (iAPIBeingUsed == EVideoPlayerUtility)

  1090                     {

  1091                     TAG_TIME_PROFILING_BEGIN;

  1092                     iVideoPlayer->Stop();

  1093                     TAG_TIME_PROFILING_END; PRINT_TO_CONSOLE_TIME_DIFF;

  1094 

  1095                     iMMFPlayerState = EPlayerPrepared;

  1096                     }

  1097                 iMediaPlayerState = XA_PLAYSTATE_STOPPED;

  1098                 iPlaybackHead = 0;

  1099                 iMarkerPositionTimer->Stop();

  1100                 iPlayItfPositionUpdateTimer->Stop();

  1101                 }

  1102             break;

  1103         case XA_PLAYSTATE_STOPPED:

  1104             break;

  1105         case XA_PLAYSTATE_PLAYERUNINITIALIZED:

  1106         default:

  1107             retVal = XA_RESULT_INTERNAL_ERROR;

  1108             break;

  1109         }

  1110     return retVal;

  1111     }

  1112 XAresult CMMFBackendEngine::GetPlayState(XAuint32 *pState)

  1113     {

  1114     XAresult retVal(XA_RESULT_INTERNAL_ERROR);

  1115     switch (iMediaPlayerState)

  1116         {

  1117         case XA_PLAYSTATE_STOPPED:

  1118         case XA_PLAYSTATE_PAUSED:

  1119         case XA_PLAYSTATE_PLAYING:

  1120             *pState = iMediaPlayerState;

  1121             retVal = XA_RESULT_SUCCESS;

  1122             break;

  1123         case XA_PLAYSTATE_PLAYERUNINITIALIZED:

  1124         default:

  1125             break;

  1126         }

  1127     return retVal;

  1128     }

  1129 

  1130 XAresult CMMFBackendEngine::GetDuration(XAmillisecond *pMsec)

  1131     {

  1132     XAresult retVal(XA_RESULT_INTERNAL_ERROR);

  1133     /* to convert from microseconds to milliseconds */

  1134     TInt64 divider(1000);

  1135     switch (iMediaPlayerState)