1 /*

     2 * Copyright (c) 2010 Ixonos Plc.

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the "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 * Ixonos Plc

    14 *

    15 * Description:  

    16 *

    17 */

    18 

    19 

    20 

    21 #include "VedAudioClipInfoImp.h"

    22 #include "AudClip.h"

    23 #include "AudClipInfo.h"

    24 

    25 #include "movieprocessor.h"

    26 

    27 // Print macro

    28 #ifdef _DEBUG

    29 #include <e32svr.h>

    30 #define PRINT(x) RDebug::Print x

    31 #else

    32 #define PRINT(x)

    33 #endif

    34 

    35 

    36 // -----------------------------------------------------------------------------

    37 // CVedAudioClipInfo::NewL

    38 // Constructs a new CVedAudioClipInfo object

    39 // (other items were commented in a header).

    40 // -----------------------------------------------------------------------------

    41 //

    42 EXPORT_C CVedAudioClipInfo* CVedAudioClipInfo::NewL(const TDesC& aFileName,

    43                                                     MVedAudioClipInfoObserver& aObserver)

    44     {

    45     CVedAudioClipInfoImp* self = (CVedAudioClipInfoImp*)NewLC(aFileName, aObserver);

    46     CleanupStack::Pop(self);

    47     return self;

    48     }

    49     

    50 EXPORT_C CVedAudioClipInfo* CVedAudioClipInfo::NewL(RFile* aFileHandle,

    51                                                     MVedAudioClipInfoObserver& aObserver)

    52     {

    53     CVedAudioClipInfoImp* self = (CVedAudioClipInfoImp*)NewLC(aFileHandle, aObserver);

    54     CleanupStack::Pop(self);

    55     return self;

    56     }

    57 

    58 // -----------------------------------------------------------------------------

    59 // CVedAudioClipInfo::NewLC

    60 // Constructs a new CVedAudioClipInfo object, leaves it to cleanupstack

    61 // (other items were commented in a header).

    62 // -----------------------------------------------------------------------------

    63 //

    64 EXPORT_C CVedAudioClipInfo* CVedAudioClipInfo::NewLC(const TDesC& aFileName,

    65                                                      MVedAudioClipInfoObserver& aObserver)

    66     {

    67     CVedAudioClipInfoImp* self = new (ELeave) CVedAudioClipInfoImp();

    68     CleanupStack::PushL(self);

    69     self->ConstructL(aFileName, aObserver);

    70     return self;

    71     }

    72 

    73 EXPORT_C CVedAudioClipInfo* CVedAudioClipInfo::NewLC(RFile* aFileHandle,

    74                                                      MVedAudioClipInfoObserver& aObserver)

    75     {

    76     CVedAudioClipInfoImp* self = new (ELeave) CVedAudioClipInfoImp();

    77     CleanupStack::PushL(self);

    78     self->ConstructL(aFileHandle, aObserver);

    79     return self;

    80     }

    81 

    82 

    83 CVedAudioClipInfoImp* CVedAudioClipInfoImp::NewL(CAudClip* aAudClip,

    84                                                  MVedAudioClipInfoObserver& aObserver)

    85     {

    86     CVedAudioClipInfoImp* self = (CVedAudioClipInfoImp*)NewLC(aAudClip, aObserver);

    87     CleanupStack::Pop(self);

    88     return self;

    89     }

    90 

    91 

    92 CVedAudioClipInfoImp* CVedAudioClipInfoImp::NewLC(CAudClip* aAudClip,

    93                                             MVedAudioClipInfoObserver& aObserver)

    94     {

    95     CVedAudioClipInfoImp* self = new (ELeave) CVedAudioClipInfoImp();

    96     CleanupStack::PushL(self);

    97     self->ConstructL(aAudClip, aObserver);

    98     return self;

    99     }

   100 

   101 

   102 // -----------------------------------------------------------------------------

   103 

   104 

   105 // -----------------------------------------------------------------------------

   106 // CVedAudioClipInfo::CVedAudioClipInfoImp

   107 // Constuctor 

   108 // (other items were commented in a header).

   109 // -----------------------------------------------------------------------------

   110 //

   111 CVedAudioClipInfoImp::CVedAudioClipInfoImp()

   112         : iReady(EFalse)

   113     {

   114     }

   115 

   116 // -----------------------------------------------------------------------------

   117 // CVedAudioClipInfoImp::ConstructL

   118 // Symbian two phased constructor.

   119 // (other items were commented in a header).

   120 // -----------------------------------------------------------------------------

   121 //

   122     

   123 void CVedAudioClipInfoImp::ConstructL(CAudClip* aAudClip, 

   124                                       MVedAudioClipInfoObserver& aObserver)

   125     {

   126     PRINT(_L("CVedAudioClipInfoImp::ConstructL in"));

   127     iAudClip = aAudClip;

   128     iAudClipInfo = iAudClip->Info();

   129     iAudioProperties = iAudClipInfo->Properties();

   130     iReady = ETrue;

   131     iObserver = &aObserver;

   132     iOperation = CVedAudioClipInfoOperation::NewL(this, aObserver);

   133     PRINT(_L("CVedAudioClipInfoImp::ConstructL out"));

   134     }

   135     

   136 void CVedAudioClipInfoImp::ConstructL(const TDesC& aFileName, 

   137                                      MVedAudioClipInfoObserver& aObserver)

   138     {

   139     

   140     PRINT(_L("CVedAudioClipInfoImp::ConstructL in"));

   141     iReady = EFalse;

   142     iAudClipInfo = CAudClipInfo::NewL(aFileName, *this);

   143     

   144     iObserver = &aObserver;

   145     PRINT(_L("CVedAudioClipInfoImp::ConstructL out"));

   146     }

   147     

   148 void CVedAudioClipInfoImp::ConstructL(RFile* aFileHandle, 

   149                                      MVedAudioClipInfoObserver& aObserver)

   150     {

   151     

   152     PRINT(_L("CVedAudioClipInfoImp::ConstructL in"));

   153     iReady = EFalse;

   154     iAudClipInfo = CAudClipInfo::NewL(aFileHandle, *this);

   155     

   156     iObserver = &aObserver;

   157     PRINT(_L("CVedAudioClipInfoImp::ConstructL out"));

   158     }

   159 

   160 

   161 // -----------------------------------------------------------------------------

   162 // CVedAudioClipInfoImp::~CVedAudioClipInfoImp

   163 // Destroys the object and releases all resources.

   164 // (other items were commented in a header).

   165 // -----------------------------------------------------------------------------

   166 //

   167 CVedAudioClipInfoImp::~CVedAudioClipInfoImp()

   168     {

   169     

   170     if (iAudClipInfo != 0 && !iAudClip) 

   171     {

   172     delete iAudClipInfo;

   173     }

   174     

   175     delete iOperation;    

   176     REComSession::FinalClose();

   177     }

   178 

   179 

   180 void CVedAudioClipInfoImp::NotifyClipInfoReady(CAudClipInfo& aInfo, TInt aError)

   181     {

   182     if (aError == KErrNone)

   183         {

   184         iAudioProperties = aInfo.Properties();    

   185         iReady = ETrue;

   186         }

   187 

   188     iObserver->NotifyAudioClipInfoReady(*this, aError);

   189     }

   190     

   191 

   192 // -----------------------------------------------------------------------------

   193 // CVedAudioClipInfoImp::ChannelMode

   194 // Returns the channel mode of the audio if applicable.

   195 // (other items were commented in a header).

   196 // -----------------------------------------------------------------------------

   197 //

   198 TVedAudioChannelMode CVedAudioClipInfoImp::ChannelMode() const

   199     {

   200     

   201     __ASSERT_ALWAYS(iReady, TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

   202     

   203     TVedAudioChannelMode vedChannelMode = EVedAudioChannelModeUnrecognized;

   204     if (iAudioProperties.iChannelMode == EAudStereo)

   205         {

   206         vedChannelMode = EVedAudioChannelModeStereo;

   207         }

   208     else if (iAudioProperties.iChannelMode == EAudSingleChannel)

   209         {

   210         vedChannelMode = EVedAudioChannelModeSingleChannel;

   211         }

   212     else if (iAudioProperties.iChannelMode == EAudDualChannel)

   213         {

   214         vedChannelMode = EVedAudioChannelModeDualChannel;

   215         }

   216 

   217     return vedChannelMode;   

   218     }

   219 

   220 // -----------------------------------------------------------------------------

   221 // CVedAudioClipInfoImp::SamplingRate

   222 // Returns the sampling rate in hertz.

   223 // (other items were commented in a header).

   224 // -----------------------------------------------------------------------------

   225 //

   226 TInt CVedAudioClipInfoImp::SamplingRate() const

   227     {

   228     

   229     __ASSERT_ALWAYS(iReady, TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

   230     

   231     return iAudioProperties.iSamplingRate;

   232 

   233     }

   234   

   235 // -----------------------------------------------------------------------------

   236 // CVedAudioClipInfoImp::Format

   237 // Returns the audio format

   238 // (other items were commented in a header).

   239 // -----------------------------------------------------------------------------

   240 //  

   241 TVedAudioFormat CVedAudioClipInfoImp::Format() const 

   242     {

   243     __ASSERT_ALWAYS(iReady, 

   244                     TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

   245 

   246     TVedAudioFormat vedAudioFormat = EVedAudioFormatUnrecognized;

   247 

   248     switch(iAudioProperties.iFileFormat) 

   249         {

   250     case EAudFormat3GPP:

   251         vedAudioFormat = EVedAudioFormat3GPP;

   252         break;

   253     case EAudFormatMP4:

   254         vedAudioFormat = EVedAudioFormatMP4;

   255         break;

   256     case EAudFormatAMR:

   257         vedAudioFormat = EVedAudioFormatAMR;

   258         break;

   259     case EAudFormatAMRWB:

   260         vedAudioFormat = EVedAudioFormatAMRWB;

   261         break;

   262     case EAudFormatMP3:

   263         vedAudioFormat = EVedAudioFormatMP3;

   264         break;

   265     case EAudFormatAAC_ADIF:

   266         vedAudioFormat = EVedAudioFormatAAC_ADIF;

   267         break;

   268     case EAudFormatAAC_ADTS:

   269         vedAudioFormat = EVedAudioFormatAAC_ADTS;

   270         break;

   271     case EAudFormatWAV:

   272         vedAudioFormat = EVedAudioFormatWAV;

   273         break;

   274     default:

   275         TVedPanic::Panic(TVedPanic::EInternal);

   276         }

   277     

   278     return vedAudioFormat;

   279     }

   280 

   281 // -----------------------------------------------------------------------------

   282 // CVedAudioClipInfoImp::BitrateMode

   283 // Returns the bitrate mode

   284 // (other items were commented in a header).

   285 // -----------------------------------------------------------------------------

   286 //  

   287 TVedBitrateMode CVedAudioClipInfoImp::BitrateMode() const

   288     {

   289     __ASSERT_ALWAYS(iReady, 

   290                     TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

   291     

   292     TVedBitrateMode vedBitrateMode = EVedBitrateModeUnrecognized;

   293     switch(iAudioProperties.iBitrateMode) 

   294         {

   295     case EAudConstant:

   296         vedBitrateMode = EVedBitrateModeConstant;

   297         break;

   298     case EAudVariable:

   299         vedBitrateMode = EVedBitrateModeVariable;

   300         break;

   301     default:

   302         TVedPanic::Panic(TVedPanic::EInternal);

   303         }

   304     return vedBitrateMode;

   305     }

   306 

   307 // -----------------------------------------------------------------------------

   308 // CVedAudioClipInfoImp::Bitrate

   309 // Returns the bitrate

   310 // (other items were commented in a header).

   311 // -----------------------------------------------------------------------------

   312 //  

   313 TInt CVedAudioClipInfoImp::Bitrate() const

   314     {

   315     __ASSERT_ALWAYS(iReady, 

   316                     TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

   317     return iAudioProperties.iBitrate;

   318     }

   319 

   320 // -----------------------------------------------------------------------------

   321 // CVedAudioClipInfoImp::GetVisualizationL

   322 // Generates a visualization of the audio clip

   323 // (other items were commented in a header).

   324 // -----------------------------------------------------------------------------

   325 //  

   326 void CVedAudioClipInfoImp::GetVisualizationL(MVedAudioClipVisualizationObserver& aObserver, TInt aResolution, TInt aPriority)

   327     {

   328     __ASSERT_ALWAYS(iReady, 

   329                     TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

   330 

   331     iVisualizationObserver = &aObserver;

   332     iAudClipInfo->GetVisualizationL(*this, aResolution, aPriority);

   333     }

   334 

   335 // -----------------------------------------------------------------------------

   336 // CVedAudioClipInfoImp::CancelVisualizationL

   337 // Cancels visualization generation

   338 // (other items were commented in a header).

   339 // -----------------------------------------------------------------------------

   340 //  

   341 void CVedAudioClipInfoImp::CancelVisualizationL()

   342     {

   343     __ASSERT_ALWAYS(iReady, 

   344                     TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

   345     

   346     iAudClipInfo->CancelVisualization();

   347     }

   348     

   349 // -----------------------------------------------------------------------------

   350 // CVedAudioClipInfoImp::NotifyClipInfoVisualizationCompleted

   351 // Callback for visualization complete

   352 // (other items were commented in a header).

   353 // -----------------------------------------------------------------------------

   354 //  

   355 void CVedAudioClipInfoImp::NotifyClipInfoVisualizationCompleted(const CAudClipInfo& /*aClipInfo*/, TInt aError, TInt8* aVisualization, TInt aSize)

   356     {

   357     iVisualizationObserver->NotifyAudioClipVisualizationCompleted(*this, aError, aVisualization, aSize);

   358     iVisualizationObserver = 0;

   359     }

   360     

   361 // -----------------------------------------------------------------------------

   362 // CVedAudioClipInfoImp::NotifyClipInfoVisualizationStarted

   363 // Callback for visualization started 

   364 // (other items were commented in a header).

   365 // -----------------------------------------------------------------------------

   366 //  

   367 void CVedAudioClipInfoImp::NotifyClipInfoVisualizationStarted(const CAudClipInfo& /*aClipInfo*/, TInt aError)

   368     {

   369     if (aError != KErrNone) 

   370         {

   371         iVisualizationObserver->NotifyAudioClipVisualizationCompleted(*this, aError, NULL, 0);

   372         iVisualizationObserver = 0;

   373         }

   374     else

   375         {

   376         iVisualizationObserver->NotifyAudioClipVisualizationStarted(*this);

   377         }

   378     }

   379 

   380 // -----------------------------------------------------------------------------

   381 // CVedAudioClipInfoImp::NotifyClipInfoVisualizationProgressed

   382 // Callback for visualization progress

   383 // (other items were commented in a header).

   384 // -----------------------------------------------------------------------------

   385 //  

   386 void CVedAudioClipInfoImp::NotifyClipInfoVisualizationProgressed(const CAudClipInfo& /*aClipInfo*/, TInt aPercentage)

   387     {

   388     iVisualizationObserver->NotifyAudioClipVisualizationProgressed(*this, aPercentage);

   389     }

   390 

   391 // -----------------------------------------------------------------------------

   392 // CVedAudioClipInfoImp::

   393 // Returns the audio clip filename

   394 // (other items were commented in a header).

   395 // -----------------------------------------------------------------------------

   396 //  

   397 TPtrC CVedAudioClipInfoImp::FileName() const

   398     {

   399     __ASSERT_ALWAYS(iReady, 

   400                     TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

   401 

   402     return iAudClipInfo->FileName();

   403 

   404     }

   405     

   406 RFile* CVedAudioClipInfoImp::FileHandle() const

   407     {

   408     __ASSERT_ALWAYS(iReady, 

   409                     TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

   410 

   411     return iAudClipInfo->FileHandle();

   412 

   413     }

   414 

   415 // -----------------------------------------------------------------------------

   416 // CVedAudioClipInfoImp::Type

   417 // Returns the audio type

   418 // (other items were commented in a header).

   419 // -----------------------------------------------------------------------------

   420 //  

   421 TVedAudioType CVedAudioClipInfoImp::Type() const

   422     {

   423     __ASSERT_ALWAYS(iReady, 

   424                     TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

   425 

   426     TVedAudioType vedAudioType = EVedAudioTypeUnrecognized;

   427 

   428     if (iAudioProperties.iAudioType == EAudAMR)

   429         {

   430         vedAudioType = EVedAudioTypeAMR;

   431         }

   432     else if (iAudioProperties.iAudioType == EAudAMRWB)

   433         {

   434         vedAudioType = EVedAudioTypeAMRWB;

   435         }

   436     else if (iAudioProperties.iAudioType == EAudMP3)

   437         {

   438         vedAudioType = EVedAudioTypeMP3;

   439         }

   440     else if (iAudioProperties.iAudioType == EAudAAC_MPEG2 || iAudioProperties.iAudioType == EAudAAC_MPEG4 )

   441         {

   442         vedAudioType = EVedAudioTypeAAC_LC;

   443         }

   444     else if (iAudioProperties.iAudioType == EAudWAV)

   445         {

   446         vedAudioType = EVedAudioTypeWAV;

   447         }

   448 

   449     return vedAudioType;

   450     }

   451 

   452 // -----------------------------------------------------------------------------

   453 // CVedAudioClipInfoImp::Duration

   454 // Returns the audio clip duration

   455 // (other items were commented in a header).

   456 // -----------------------------------------------------------------------------

   457 //  

   458 TTimeIntervalMicroSeconds CVedAudioClipInfoImp::Duration() const

   459     {

   460     __ASSERT_ALWAYS(iReady, 

   461                     TVedPanic::Panic(TVedPanic::EAudioClipInfoNotReady));

   462 

   463     return iAudioProperties.iDuration;

   464     }

   465 

   466 

   467 // -----------------------------------------------------------------------------

   468 // CVedAudioClipInfoImp::Compare

   469 // Compares two audio clip info classes

   470 // (other items were commented in a header).

   471 // -----------------------------------------------------------------------------

   472 //  

   473 TInt CVedAudioClipInfoImp::Compare(const CVedAudioClipInfoImp& c1, 

   474                                    const CVedAudioClipInfoImp& c2) 

   475     {

   476 

   477 

   478     if (c1.iAudClip == 0 || c2.iAudClip == 0)

   479         {

   480         return 0;

   481         }

   482     if (c1.iAudClip->StartTime() > c2.iAudClip->StartTime()) 

   483         {

   484         return 1;

   485         }

   486     else if (c1.iAudClip->StartTime() < c2.iAudClip->StartTime()) 

   487         {

   488         return -1;

   489         }

   490     else 

   491         {

   492         return 0;

   493         }

   494     }

   495 

   496 //////////////////////////////////////////////////////////////////////////

   497 

   498 

   499 // CVedAudioClipInfoOperation

   500 // 

   501 

   502 // -----------------------------------------------------------------------------

   503 // CVedAudioClipInfoOperation::NewL

   504 // Constructs a new CVedAudioClipInfoOperation object.

   505 // (other items were commented in a header).

   506 // -----------------------------------------------------------------------------

   507 //

   508 CVedAudioClipInfoOperation* CVedAudioClipInfoOperation::NewL(CVedAudioClipInfoImp* aInfo,

   509                                                              MVedAudioClipInfoObserver& aObserver)

   510     {

   511     CVedAudioClipInfoOperation* self = 

   512         new (ELeave) CVedAudioClipInfoOperation(aInfo, aObserver);

   513     CleanupStack::PushL(self);

   514     self->ConstructL();

   515     CleanupStack::Pop(self);

   516     return self;

   517     }

   518 

   519 // -----------------------------------------------------------------------------

   520 // CVedAudioClipInfoOperation::CVedAudioClipInfoOperation

   521 // Constructor.

   522 // (other items were commented in a header).

   523 // -----------------------------------------------------------------------------

   524 //

   525 CVedAudioClipInfoOperation::CVedAudioClipInfoOperation(CVedAudioClipInfoImp* aInfo,

   526                                                        MVedAudioClipInfoObserver& aObserver)

   527         : CActive(EPriorityStandard), iObserver(aObserver), iInfo(aInfo)

   528           

   529     {

   530     CActiveScheduler::Add(this);

   531     }

   532 

   533 // -----------------------------------------------------------------------------

   534 // CVedAudioClipInfoOperation::ConstructL

   535 // Symbian two phased constructor

   536 // (other items were commented in a header).

   537 // -----------------------------------------------------------------------------

   538 //

   539 void CVedAudioClipInfoOperation::ConstructL()

   540     {

   541     PRINT(_L("CVedAudioClipInfoOperation::ConstructL in"));

   542     

   543     SetActive();

   544     TRequestStatus* status = &iStatus;

   545     User::RequestComplete(status, KErrNone);

   546 

   547     PRINT(_L("CVedAudioClipInfoOperation::ConstructL out"));

   548     }

   549 

   550 // -----------------------------------------------------------------------------

   551 // CVedAudioClipInfoOperation::~CVedAudioClipInfoOperation

   552 // Destructor

   553 // (other items were commented in a header).

   554 // -----------------------------------------------------------------------------

   555 //

   556 CVedAudioClipInfoOperation::~CVedAudioClipInfoOperation()

   557     {

   558     Cancel();

   559     }

   560 

   561 // -----------------------------------------------------------------------------

   562 // CVedAudioClipInfoOperation::RunError

   563 // Handle errors from RunL()

   564 // (other items were commented in a header).

   565 // -----------------------------------------------------------------------------

   566 //

   567 TInt CVedAudioClipInfoOperation::RunError( TInt aError )

   568     {

   569     iObserver.NotifyAudioClipInfoReady(*iInfo, aError);

   570     return KErrNone;

   571     }

   572 

   573 // -----------------------------------------------------------------------------

   574 // CVedAudioClipInfoOperation::RunL

   575 // Active objects RunL function ran when request completes.

   576 // (other items were commented in a header).

   577 // -----------------------------------------------------------------------------

   578 //

   579 void CVedAudioClipInfoOperation::RunL()

   580     {

   581     PRINT(_L("CVedAudioClipInfoOperation::RunL in"));

   582     

   583     iObserver.NotifyAudioClipInfoReady(*iInfo, KErrNone);

   584 

   585     PRINT(_L("CVedAudioClipInfoOperation::RunL out"));

   586     }

   587 

   588 // -----------------------------------------------------------------------------

   589 // CVedAudioClipInfoOperation::DoCancel

   590 // Cancel ongoing request.

   591 // (other items were commented in a header).

   592 // -----------------------------------------------------------------------------

   593 //

   594 void CVedAudioClipInfoOperation::DoCancel()

   595     {

   596     iObserver.NotifyAudioClipInfoReady(*iInfo, KErrCancel);

   597     }

   598