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 /* Copyright (c) 2003, Nokia. All rights reserved */

    21 

    22 #include "AudClipInfo.h"

    23 #include "AudProcessor.h"

    24 #include "AudPanic.h"

    25 

    26 

    27 

    28 #include <fbs.h>

    29 #include <e32base.h>

    30 

    31 // Debug print macro

    32 #if defined _DEBUG 

    33 #include <e32svr.h>

    34 #define PRINT(x) RDebug::Print x;

    35 #else

    36 #define PRINT(x)

    37 #endif

    38 

    39 

    40 EXPORT_C CAudClipInfo* CAudClipInfo::NewL(const TDesC& aFileName, 

    41                                           MAudClipInfoObserver& aObserver)

    42     {

    43     CAudClipInfo* self = NewLC(aFileName, aObserver);

    44     CleanupStack::Pop(self);

    45     return self;

    46     }

    47 

    48     

    49 EXPORT_C CAudClipInfo* CAudClipInfo::NewLC(const TDesC& aFileName, 

    50                                            MAudClipInfoObserver& aObserver)

    51     {

    52     CAudClipInfo* self = new (ELeave) CAudClipInfo();

    53     CleanupStack::PushL(self);

    54     self->ConstructL(aFileName, aObserver);

    55     return self;

    56     }

    57     

    58 EXPORT_C CAudClipInfo* CAudClipInfo::NewL(RFile* aFileHandle,

    59                                           MAudClipInfoObserver& aObserver)

    60     {

    61     CAudClipInfo* self = NewLC(aFileHandle, aObserver);

    62     CleanupStack::Pop(self);

    63     return self;

    64     }

    65 

    66     

    67 EXPORT_C CAudClipInfo* CAudClipInfo::NewLC(RFile* aFileHandle,

    68                                            MAudClipInfoObserver& aObserver)

    69     {

    70     CAudClipInfo* self = new (ELeave) CAudClipInfo();

    71     CleanupStack::PushL(self);

    72     self->ConstructL(aFileHandle, aObserver);

    73     return self;

    74     }

    75 

    76 EXPORT_C TAudFileProperties CAudClipInfo::Properties() const

    77     {

    78 

    79     return *iProperties;

    80     }

    81 

    82 EXPORT_C TPtrC CAudClipInfo::FileName() const 

    83     {

    84     return *iFileName;

    85     }

    86     

    87 EXPORT_C RFile* CAudClipInfo::FileHandle() const 

    88     {

    89     return iFileHandle;

    90     }

    91 

    92 EXPORT_C void CAudClipInfo::GetVisualizationL(MAudVisualizationObserver& aObserver,

    93                                               TInt aSize, TInt aPriority) const 

    94     {

    95 

    96 

    97     iOperation->StartVisualizationL(aObserver, aSize, aPriority);

    98     }

    99 

   100 EXPORT_C void CAudClipInfo::CancelVisualization()

   101     {

   102 

   103 

   104     iOperation->CancelVisualization();

   105     }

   106 

   107 CAudClipInfo::CAudClipInfo() : iInfoReady(EFalse)

   108 

   109     {

   110     }

   111 

   112 

   113 void CAudClipInfo::ConstructL(const TDesC& aFileName, MAudClipInfoObserver& aObserver)

   114     {

   115 

   116     iProperties = new (ELeave) TAudFileProperties();

   117 

   118     iFileName = HBufC::NewL(aFileName.Length());

   119     *iFileName = aFileName;

   120     iFileHandle = NULL;

   121     

   122     iOperation = CAudClipInfoOperation::NewL(this, aObserver);

   123     iOperation->StartGetPropertiesL();

   124 

   125     }

   126     

   127 void CAudClipInfo::ConstructL(RFile* aFileHandle, MAudClipInfoObserver& aObserver)

   128     {

   129 

   130     iProperties = new (ELeave) TAudFileProperties();

   131         

   132     iFileHandle = aFileHandle;

   133     

   134     iFileName = HBufC::NewL(1);

   135     

   136     iOperation = CAudClipInfoOperation::NewL(this, aObserver);

   137     iOperation->StartGetPropertiesL();

   138 

   139     }

   140 

   141 

   142 EXPORT_C CAudClipInfo::~CAudClipInfo() 

   143     {

   144     

   145 	PRINT((_L("CAudClipInfo::~CAudClipInfo() in")));

   146     if (iProperties != 0)

   147         {

   148         delete iProperties;

   149         iProperties = 0;

   150         }

   151 	PRINT((_L("CAudClipInfo::~CAudClipInfo() deleted iProperties")));

   152     if (iOperation)

   153         {

   154         delete iOperation;

   155         iOperation = 0;

   156         }

   157 

   158 	PRINT((_L("CAudClipInfo::~CAudClipInfo() deleted iOperation")));

   159     if (iFileName != 0)

   160         {

   161         delete iFileName;

   162         iFileName = 0;

   163         }

   164 	PRINT((_L("CAudClipInfo::~CAudClipInfo() out")));

   165     

   166     }

   167 

   168 

   169 

   170 

   171 CAudClipInfoOperation* CAudClipInfoOperation::NewL(CAudClipInfo* aInfo,

   172                                                              MAudClipInfoObserver& aObserver)

   173     {

   174     CAudClipInfoOperation* self = 

   175         new (ELeave) CAudClipInfoOperation(aInfo, aObserver);

   176     CleanupStack::PushL(self);

   177     self->ConstructL();

   178     CleanupStack::Pop(self);

   179     return self;

   180     }

   181 

   182 

   183 CAudClipInfoOperation::CAudClipInfoOperation(CAudClipInfo* aInfo,

   184                                              MAudClipInfoObserver& aObserver) : 

   185                                              iInfo(aInfo), iObserver(&aObserver)

   186                                     

   187     {

   188 

   189     }

   190 

   191 

   192 void CAudClipInfoOperation::ConstructL() 

   193     {

   194 

   195    

   196     }

   197 

   198 

   199 CAudClipInfoOperation::~CAudClipInfoOperation() 

   200     {

   201 

   202 	PRINT((_L("CAudClipInfoOperation::~CAudClipInfoOperation() in")));

   203     if (iProcessor != 0)

   204         {

   205         delete iProcessor;

   206         iProcessor = 0;

   207 

   208         }

   209 	PRINT((_L("CAudClipInfoOperation::~CAudClipInfoOperation() out")));

   210 

   211     }

   212 

   213 

   214 void CAudClipInfoOperation::NotifyClipInfoReady(TInt aError) 

   215     {

   216     

   217 	PRINT((_L("CAudClipInfoOperation::NotifyClipInfoReady() in")));

   218     

   219     iInfo->iInfoReady = ETrue;

   220 

   221     if (iProcessor == 0) 

   222         {

   223         TAudPanic::Panic(TAudPanic::EInternal);

   224         }

   225 

   226     if (iProcessor != 0)

   227         {

   228         delete iProcessor;

   229         iProcessor = 0;

   230         }

   231 

   232     iObserver->NotifyClipInfoReady(*iInfo, aError);

   233 

   234 	PRINT((_L("CAudClipInfoOperation::NotifyClipInfoReady() out")));

   235 

   236     }

   237 

   238 void CAudClipInfoOperation::StartGetPropertiesL() 

   239     {

   240 	PRINT((_L("CAudClipInfoOperation::StartGetPropertiesL() in")));

   241 

   242     if (iProcessor != 0) 

   243         {

   244         TAudPanic::Panic(TAudPanic::EInternal);

   245         }

   246     iProcessor = CAudProcessor::NewL();        

   247     iProcessor->GetAudFilePropertiesL(*iInfo->iFileName, iInfo->iFileHandle, 

   248                                       iInfo->iProperties, *this, CActive::EPriorityStandard);

   249 

   250 	PRINT((_L("CAudClipInfoOperation::StartGetPropertiesL() out")));

   251     }

   252 

   253 void CAudClipInfoOperation::StartVisualizationL(MAudVisualizationObserver& aObserver, TInt aSize, 

   254                                             TInt aPriority) 

   255     {

   256 

   257     if (iProcessor != 0) 

   258         {

   259         TAudPanic::Panic(TAudPanic::EClipInfoProcessAlreadyRunning);

   260         }

   261     iVisualizationObserver = &aObserver;

   262 

   263     CAudProcessor* processor = CAudProcessor::NewLC();

   264     

   265     processor->StartGetClipVisualizationL(iInfo, aSize, *this, aPriority);

   266 

   267     

   268     CleanupStack::Pop(processor);

   269     iProcessor = processor;

   270 

   271     }

   272 

   273 void CAudClipInfoOperation::CancelVisualization()

   274     {

   275     PRINT((_L("CAudClipInfoOperation::CancelVisualization() in")));

   276 

   277     if (iProcessor == 0) 

   278         {

   279         PRINT((_L("CAudClipInfoOperation::CancelVisualization() no visualization going on, ignore")));

   280         return;

   281         }

   282     else 

   283         {

   284         PRINT((_L("CAudClipInfoOperation::CancelVisualization() cancel iProcessor")));

   285         iProcessor->CancelClipVisualization();

   286         

   287         delete iProcessor;

   288         iProcessor = 0;

   289             

   290         iVisualizationObserver = 0;

   291         PRINT((_L("CAudClipInfoOperation::CancelVisualization() out")));

   292         }

   293     }

   294 

   295 void CAudClipInfoOperation::NotifySongVisualizationCompleted(const CAudSong& /*aSong*/, 

   296         TInt /*aError*/, 

   297         TInt8* /*aVisualization*/,

   298         TInt /*aSize*/) 

   299     {

   300 

   301     // should not be called

   302     TAudPanic::Panic(TAudPanic::EInternal);

   303 

   304 

   305     }

   306 

   307 void CAudClipInfoOperation::NotifySongVisualizationStarted(const CAudSong& /*aSong*/, 

   308                                                                     TInt /*aError*/) 

   309     {

   310     // should not be called

   311     TAudPanic::Panic(TAudPanic::EInternal);

   312 

   313     }

   314 

   315 

   316 void CAudClipInfoOperation::NotifySongVisualizationProgressed(const CAudSong& /*aSong*/, 

   317                                                                        TInt /*aPercentage*/) 

   318     {

   319 

   320     // should not be called

   321     TAudPanic::Panic(TAudPanic::EInternal);

   322     

   323 

   324     }

   325 

   326 void CAudClipInfoOperation::NotifyClipInfoVisualizationCompleted(const CAudClipInfo& aClipInfo, 

   327         TInt aError, 

   328         TInt8* aVisualization,

   329         TInt aSize) 

   330     {

   331     PRINT((_L("CAudClipInfoOperation::NotifyClipInfoVisualizationCompleted() in")));

   332     if (aError != KErrNone)

   333         {

   334         iVisualizationObserver->NotifyClipInfoVisualizationCompleted(aClipInfo, aError, aVisualization, aSize);

   335         PRINT((_L("CAudClipInfoOperation::NotifyClipInfoVisualizationCompleted() completed with error %d"),aError));

   336         }

   337     else

   338         {

   339         if (iProcessor != 0)

   340             {

   341             delete iProcessor;

   342             iProcessor = 0;

   343             }

   344 

   345         MAudVisualizationObserver* observer = iVisualizationObserver;

   346         iVisualizationObserver = 0;

   347         observer->NotifyClipInfoVisualizationProgressed(aClipInfo, 100);

   348         observer->NotifyClipInfoVisualizationCompleted(aClipInfo, aError, aVisualization, aSize);

   349         PRINT((_L("CAudClipInfoOperation::NotifyClipInfoVisualizationCompleted() completed")));

   350         }

   351     

   352     

   353     PRINT((_L("CAudClipInfoOperation::NotifyClipInfoVisualizationCompleted() out")));

   354     }

   355 

   356 

   357 void CAudClipInfoOperation::NotifyClipInfoVisualizationStarted(const CAudClipInfo& aClipInfo, 

   358                                         TInt aError) 

   359     {

   360 

   361     

   362     iVisualizationObserver->NotifyClipInfoVisualizationStarted(aClipInfo, aError);

   363 

   364     }

   365 

   366 void CAudClipInfoOperation::NotifyClipInfoVisualizationProgressed(const CAudClipInfo& aClipInfo, 

   367                                                                            TInt aPercentage) 

   368     {

   369 

   370     

   371     iVisualizationObserver->NotifyClipInfoVisualizationProgressed(aClipInfo, aPercentage);

   372     }