harvester/harvesterplugins/AudioPlugin/src/harvesteraudioplugin.cpp
changeset 0 c53acadfccc6
child 1 acef663c1218
equal deleted inserted replaced
-1:000000000000 0:c53acadfccc6
       
     1 /*
       
     2 * Copyright (c) 2006-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:  Harvester audio plugin
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #include <e32base.h>
       
    20 #include <harvesterdata.h>
       
    21 #include <mdenamespacedef.h>
       
    22 #include <mdeobjectdef.h>
       
    23 #include <mdeobject.h>
       
    24 #include <centralrepository.h>
       
    25 
       
    26 #include "harvesteraudioplugin.h"
       
    27 #include "harvesteraudiopluginutils.h"
       
    28 
       
    29 #include "harvesterlog.h"
       
    30 
       
    31 const TInt KMimeLength( 10 );
       
    32 const TUid KHarvesterRepoUid = { 0x200009FE };
       
    33 const TUint32 KEnableAlbumArtHarvest = 0x00090001;
       
    34 
       
    35 CHarvesterAudioPluginPropertyDefs::CHarvesterAudioPluginPropertyDefs() : CBase()
       
    36 	{
       
    37 	}
       
    38 
       
    39 void CHarvesterAudioPluginPropertyDefs::ConstructL(CMdEObjectDef& aObjectDef)
       
    40 	{
       
    41 	CMdENamespaceDef& nsDef = aObjectDef.NamespaceDef();
       
    42 
       
    43 	// Image property definitions
       
    44 	CMdEObjectDef& objectDef = nsDef.GetObjectDefL( MdeConstants::Object::KBaseObject );
       
    45 	iCreationDatePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KCreationDateProperty );
       
    46 	iLastModifiedDatePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KLastModifiedDateProperty );
       
    47 	iSizePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KSizeProperty );
       
    48 	iItemTypePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KItemTypeProperty );
       
    49 	iTitlePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KTitleProperty );
       
    50 
       
    51 	// Media property definitions
       
    52 	CMdEObjectDef& mediaDef = nsDef.GetObjectDefL( MdeConstants::MediaObject::KMediaObject );
       
    53 	iRatingPropertyDef = &mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KRatingProperty );
       
    54 	iGenrePropertyDef = &mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KGenreProperty );
       
    55 	iArtistPropertyDef = &mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KArtistProperty );
       
    56 	iDurationPropertyDef = &mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KDurationProperty );
       
    57 	iCopyrightPropertyDef = &mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KCopyrightProperty );
       
    58 	iTrackPropertyDef = &mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KTrackProperty );
       
    59 	iThumbnailPropertyDef = &mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KThumbnailPresentProperty );
       
    60 	iDatePropertyDef = &mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KReleaseDateProperty );
       
    61 
       
    62 	// Audio property definitions
       
    63 	CMdEObjectDef& audioDef = nsDef.GetObjectDefL( MdeConstants::Audio::KAudioObject );
       
    64 	iAlbumPropertyDef = &audioDef.GetPropertyDefL( MdeConstants::Audio::KAlbumProperty );
       
    65 	iComposerPropertyDef = &audioDef.GetPropertyDefL( MdeConstants::Audio::KComposerProperty );
       
    66 	iOriginalArtistPropertyDef = &audioDef.GetPropertyDefL( MdeConstants::Audio::KOriginalArtistProperty );
       
    67 	}
       
    68 
       
    69 CHarvesterAudioPluginPropertyDefs* CHarvesterAudioPluginPropertyDefs::NewL(CMdEObjectDef& aObjectDef)
       
    70 	{
       
    71 	CHarvesterAudioPluginPropertyDefs* self = 
       
    72 		new (ELeave) CHarvesterAudioPluginPropertyDefs();
       
    73 	CleanupStack::PushL( self );
       
    74 	self->ConstructL( aObjectDef );
       
    75 	CleanupStack::Pop( self );
       
    76 	return self;
       
    77 	}
       
    78 
       
    79 using namespace MdeConstants;
       
    80 
       
    81 // ---------------------------------------------------------------------------
       
    82 // CHarvesterAudioPlugin::CHarvesterAudioPlugin
       
    83 // ---------------------------------------------------------------------------
       
    84 //    
       
    85 CHarvesterAudioPlugin::CHarvesterAudioPlugin() : CHarvesterPlugin(),
       
    86     iAudioParser( NULL ), iPropDefs( NULL ), iTNM( NULL ), iHarvestAlbumArt( EFalse )
       
    87 	{
       
    88 	}
       
    89 
       
    90 // ---------------------------------------------------------------------------
       
    91 // CHarvesterAudioPlugin::NewL
       
    92 // ---------------------------------------------------------------------------
       
    93 //    
       
    94 CHarvesterAudioPlugin* CHarvesterAudioPlugin::NewL()
       
    95 	{
       
    96 	WRITELOG( "CHarvesterAudioPlugin::NewL()" );
       
    97 	CHarvesterAudioPlugin* self = new (ELeave) CHarvesterAudioPlugin();
       
    98 	CleanupStack::PushL( self );
       
    99 	self->ConstructL();
       
   100 	CleanupStack::Pop( self );
       
   101 	
       
   102 	return self;
       
   103 	}
       
   104 
       
   105 // ---------------------------------------------------------------------------
       
   106 // CHarvesterAudioPlugin::~CHarvesterAudioPlugin
       
   107 // ---------------------------------------------------------------------------
       
   108 //    
       
   109 CHarvesterAudioPlugin::~CHarvesterAudioPlugin()
       
   110 	{
       
   111 	WRITELOG( "CHarvesterAudioPlugin::~CHarvesterAudioPlugin()" );
       
   112 	
       
   113 	delete iAudioParser;
       
   114 	delete iPropDefs;
       
   115 	delete iTNM;
       
   116 	}
       
   117 
       
   118 // ---------------------------------------------------------------------------
       
   119 // CHarvesterAudioPlugin::ConstructL
       
   120 // ---------------------------------------------------------------------------
       
   121 //    
       
   122 void CHarvesterAudioPlugin::ConstructL()
       
   123 	{
       
   124 	WRITELOG( "CHarvesterAudioPlugin::ConstructL()" );
       
   125 	
       
   126     CRepository* rep = CRepository::NewLC( KHarvesterRepoUid );
       
   127     rep->Get( KEnableAlbumArtHarvest, iHarvestAlbumArt );
       
   128     CleanupStack::PopAndDestroy( rep );   
       
   129 	
       
   130 	iAudioParser = CAudioMDParser::NewL( iHarvestAlbumArt );
       
   131     iAudioParser->ResetL();
       
   132     
       
   133     if( iHarvestAlbumArt )
       
   134         {
       
   135         TRAP_IGNORE( iTNM = CThumbnailManager::NewL( *this ) );
       
   136         }
       
   137 	}
       
   138 
       
   139 // ---------------------------------------------------------------------------
       
   140 // CHarvesterAudioPlugin::HarvestL (from CHarvesterPlugin)
       
   141 // ---------------------------------------------------------------------------
       
   142 //    
       
   143 void CHarvesterAudioPlugin::HarvestL( CHarvesterData* aHD )
       
   144 	{
       
   145 	WRITELOG( "CHarvesterAudioPlugin::HarvestL()" );
       
   146 	
       
   147 	TInt err = KErrNone;
       
   148 	
       
   149 	TRAP( err, DoHarvestL( aHD ) );
       
   150 	
       
   151 	if ( err != KErrNone )
       
   152 	    {
       
   153 	    aHD->SetErrorCode( err );
       
   154 	    }
       
   155 	}
       
   156 
       
   157 // ---------------------------------------------------------------------------
       
   158 // CHarvesterAudioPlugin::ThumbnailPreviewReady 
       
   159 // ---------------------------------------------------------------------------
       
   160 //    
       
   161 void CHarvesterAudioPlugin::ThumbnailPreviewReady( MThumbnailData& /*aThumbnail*/,
       
   162     TThumbnailRequestId /*aId*/ )
       
   163     {
       
   164     // Pass through, nothing to do
       
   165     }
       
   166 
       
   167 // ---------------------------------------------------------------------------
       
   168 // CHarvesterAudioPlugin::HarvestL (from CHarvesterPlugin)
       
   169 // ---------------------------------------------------------------------------
       
   170 //    
       
   171 void CHarvesterAudioPlugin::ThumbnailReady( TInt /*aError*/, 
       
   172     MThumbnailData& /*aThumbnail*/,
       
   173     TThumbnailRequestId /*aId*/ )
       
   174     {
       
   175     // Pass through, nothing to do
       
   176     }
       
   177 
       
   178 // ---------------------------------------------------------------------------
       
   179 // CHarvesterAudioPlugin::DoHarvestL
       
   180 // ---------------------------------------------------------------------------
       
   181 //    
       
   182 void CHarvesterAudioPlugin::DoHarvestL( CHarvesterData* aHD )
       
   183 	{
       
   184 	WRITELOG( "CHarvesterAudioPlugin::DoHarvestL()" );
       
   185     CMdEObject& mdeObject = aHD->MdeObject();
       
   186         
       
   187     TBool isAdd = EFalse;
       
   188     if ( mdeObject.Placeholder() || mdeObject.Id() == KNoId ) // is a new object or placeholder
       
   189         {
       
   190         isAdd = ETrue;
       
   191         }
       
   192 
       
   193     GetPropertiesL( aHD, isAdd );
       
   194 	}
       
   195 
       
   196 
       
   197 // ---------------------------------------------------------------------------
       
   198 // CHarvesterAudioPlugin::GetPropertiesL
       
   199 // ---------------------------------------------------------------------------
       
   200 //    
       
   201 void CHarvesterAudioPlugin::GetPropertiesL( CHarvesterData* aHD,
       
   202                                             TBool aIsAdd )
       
   203     {
       
   204     CMdEObject& mdeObject = aHD->MdeObject();
       
   205     
       
   206     // get creation time, modified time and file size
       
   207     if( !mdeObject.Placeholder() )
       
   208         {
       
   209         GetPlaceHolderPropertiesL( aHD, aIsAdd );
       
   210         }
       
   211     
       
   212     const TMimeTypeMapping<TAudioMetadataHandling>* mapping = 
       
   213     	GetMimeTypePropertyL( aHD, aIsAdd );
       
   214 
       
   215     if( mapping )
       
   216     	{
       
   217 		// get properties for file types supported by CMetaDataUtility.
       
   218     	if( mapping->iHandler == EMetaDataUtilityHandling )
       
   219     		{
       
   220     		GetMusicPropertiesL( aHD, aIsAdd );
       
   221     		}
       
   222     	}
       
   223     }
       
   224 
       
   225 // ---------------------------------------------------------------------------
       
   226 // CHarvesterAudioPlugin::GetPlaceHolderPropertiesL
       
   227 // Get placeholder properties (creation time, modify time and file size).
       
   228 // ---------------------------------------------------------------------------
       
   229 //    
       
   230 void CHarvesterAudioPlugin::GetPlaceHolderPropertiesL( CHarvesterData* aHD,
       
   231                                TBool aIsAdd )
       
   232     {
       
   233     CMdEObject& mdeObject = aHD->MdeObject();
       
   234     
       
   235     const TDesC& uri = mdeObject.Uri();
       
   236     
       
   237     TEntry entry;
       
   238     TInt err = iFs.Entry( uri, entry );
       
   239     
       
   240     if ( err!= KErrNone )
       
   241         {
       
   242         User::Leave( err ); // metadata cannot be gathered!
       
   243         }
       
   244     
       
   245 	TTime now;
       
   246 	now.HomeTime();
       
   247     
       
   248 	if( !iPropDefs )
       
   249 		{
       
   250 		CMdEObjectDef& objectDef = mdeObject.Def();
       
   251 		iPropDefs = CHarvesterAudioPluginPropertyDefs::NewL( objectDef );
       
   252 		}
       
   253 	
       
   254 	CMdeObjectWrapper::HandleObjectPropertyL(
       
   255                  mdeObject, *iPropDefs->iCreationDatePropertyDef, &now, aIsAdd );
       
   256 
       
   257 	CMdeObjectWrapper::HandleObjectPropertyL(
       
   258              mdeObject, *iPropDefs->iLastModifiedDatePropertyDef, &entry.iModified, aIsAdd );
       
   259 
       
   260 	CMdeObjectWrapper::HandleObjectPropertyL(
       
   261               mdeObject, *iPropDefs->iSizePropertyDef, &entry.iSize, aIsAdd );
       
   262     }
       
   263 
       
   264 // ---------------------------------------------------------------------------
       
   265 // CHarvesterAudioPlugin::GetMimeTypePropertyL
       
   266 // Get mime type.
       
   267 // ---------------------------------------------------------------------------
       
   268 //    
       
   269 const TMimeTypeMapping<TAudioMetadataHandling>* CHarvesterAudioPlugin::GetMimeTypePropertyL( 
       
   270 		CHarvesterData* aHD, TBool aIsAdd )
       
   271     {
       
   272     CMdEObject& mdeObject = aHD->MdeObject();
       
   273  
       
   274     const TMimeTypeMapping<TAudioMetadataHandling>* mapping = 
       
   275     	iAudioParser->ParseMimeType( mdeObject.Uri() );
       
   276     
       
   277     if ( mapping )
       
   278         {
       
   279     	if( !iPropDefs )
       
   280     		{
       
   281     		CMdEObjectDef& objectDef = mdeObject.Def();
       
   282     		iPropDefs = CHarvesterAudioPluginPropertyDefs::NewL( objectDef );
       
   283     		}
       
   284         
       
   285     	CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   286     			*iPropDefs->iItemTypePropertyDef, (TAny*)&(mapping->iMimeType), aIsAdd );
       
   287         }
       
   288     
       
   289     return mapping;
       
   290     }
       
   291 
       
   292 // ---------------------------------------------------------------------------
       
   293 // CHarvesterAudioPlugin::GetMusicPropertiesL
       
   294 // ---------------------------------------------------------------------------
       
   295 //    
       
   296 void CHarvesterAudioPlugin::GetMusicPropertiesL( CHarvesterData* aHD,
       
   297                                       TBool aIsAdd )
       
   298     {
       
   299 #ifdef _DEBUG
       
   300     TTime dStart, dStop;
       
   301     dStart.UniversalTime();
       
   302     dStop.UniversalTime();
       
   303     WRITELOG1( "CHarvesterAudioPlugin::GetMusicPropertiesL start %d us", (TInt)dStop.MicroSecondsFrom(dStart).Int64() );
       
   304 #endif
       
   305     
       
   306     CMdEObject& mdeObject = aHD->MdeObject();
       
   307     const TDesC& uri = mdeObject.Uri();
       
   308     
       
   309     TBool parsed( EFalse );
       
   310     TRAPD( parseError, parsed = iAudioParser->ParseL( uri ) );
       
   311 
       
   312     if( !parsed || (parseError != KErrNone) )
       
   313     	{
       
   314     	iAudioParser->ResetL();
       
   315     	return;
       
   316     	}
       
   317 
       
   318     // We do not want to get all long text fields at this time
       
   319     TPtrC song      = iAudioParser->MetaDataFieldL( CAudioMDParser::EAudioMDFieldSong );
       
   320     TPtrC artist    = iAudioParser->MetaDataFieldL( CAudioMDParser::EAudioMDFieldArtist );
       
   321     TPtrC album     = iAudioParser->MetaDataFieldL( CAudioMDParser::EAudioMDFieldAlbum );
       
   322     TPtrC genre     = iAudioParser->MetaDataFieldL( CAudioMDParser::EAudioMDFieldGenre );
       
   323     TPtrC composer  = iAudioParser->MetaDataFieldL( CAudioMDParser::EAudioMDFieldComposer );
       
   324     TPtrC rating    = iAudioParser->MetaDataFieldL( CAudioMDParser::EAudioMDFieldRating );
       
   325     TPtrC orgArtist = iAudioParser->MetaDataFieldL( CAudioMDParser::EAudioMDFieldOriginalArtist );
       
   326     TPtrC track     = iAudioParser->MetaDataFieldL( CAudioMDParser::EAudioMDFieldTrack );
       
   327     TPtrC duration  = iAudioParser->MetaDataFieldL( CAudioMDParser::EAudioMDFieldDuration );
       
   328     TPtrC copyright     = iAudioParser->MetaDataFieldL( CAudioMDParser::EAudioMDFieldCopyright);
       
   329     TPtrC date     = iAudioParser->MetaDataFieldL( CAudioMDParser::EAudioMDFieldDate );
       
   330     
       
   331     TPtrC8 jpeg = iAudioParser->MetaDataField8L( CAudioMDParser::EAudioMDFieldJpeg );
       
   332     
       
   333 	if( !iPropDefs )
       
   334 		{
       
   335 	    CMdEObjectDef& audioObjectDef = mdeObject.Def();
       
   336 		iPropDefs = CHarvesterAudioPluginPropertyDefs::NewL( audioObjectDef );
       
   337 		}
       
   338     
       
   339     if ( song.Length() > 0
       
   340         && song.Length() < iPropDefs->iTitlePropertyDef->MaxTextLengthL() )
       
   341         {
       
   342         TRAPD( error, CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   343         		*iPropDefs->iTitlePropertyDef, &song, aIsAdd ) );
       
   344         if( error != KErrNone )
       
   345             {
       
   346             CMdEProperty* prop = NULL;
       
   347             const TInt index = mdeObject.Property( *iPropDefs->iTitlePropertyDef, prop );
       
   348             mdeObject.RemoveProperty( index );
       
   349             CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   350             		*iPropDefs->iTitlePropertyDef, &song, aIsAdd );
       
   351             }
       
   352         }
       
   353 
       
   354     if ( artist.Length() > 0
       
   355         && artist.Length() < iPropDefs->iArtistPropertyDef->MaxTextLengthL() )
       
   356         {
       
   357         CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   358         		*iPropDefs->iArtistPropertyDef, &artist, aIsAdd );
       
   359         }
       
   360 
       
   361     if ( album.Length() > 0
       
   362         && album.Length() < iPropDefs->iAlbumPropertyDef->MaxTextLengthL() )
       
   363         {
       
   364         CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   365         		*iPropDefs->iAlbumPropertyDef, &album, aIsAdd );
       
   366         }
       
   367  
       
   368     if ( genre.Length() > 0
       
   369         && genre.Length() < iPropDefs->iGenrePropertyDef->MaxTextLengthL() )
       
   370         {
       
   371         CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   372         		*iPropDefs->iGenrePropertyDef, &genre, aIsAdd );
       
   373         }
       
   374 
       
   375     if ( composer.Length() > 0
       
   376         && composer.Length() < iPropDefs->iComposerPropertyDef->MaxTextLengthL() )
       
   377         {
       
   378         CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   379         		*iPropDefs->iComposerPropertyDef, &composer, aIsAdd );
       
   380         }
       
   381 
       
   382     if ( rating.Length() > 0 )
       
   383         {
       
   384         TLex ratingLex( rating );
       
   385         TUint8 ratingValue( 0 );
       
   386         const TInt error( ratingLex.Val( ratingValue, EDecimal ) );
       
   387         if( error == KErrNone )
       
   388             {
       
   389             CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   390                 *iPropDefs->iRatingPropertyDef, &ratingValue, aIsAdd );        
       
   391             }
       
   392         }
       
   393     
       
   394     if ( orgArtist.Length() > 0
       
   395         && orgArtist.Length() < iPropDefs->iOriginalArtistPropertyDef->MaxTextLengthL() )
       
   396         {
       
   397         CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   398         		*iPropDefs->iOriginalArtistPropertyDef, &orgArtist, aIsAdd );
       
   399         }
       
   400     
       
   401     if ( track.Length() > 0 )
       
   402         {
       
   403         TLex trackLex( track );
       
   404         TUint16 trackValue( 0 );
       
   405         trackLex.Val( trackValue, EDecimal );
       
   406         CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   407         		*iPropDefs->iTrackPropertyDef, &trackValue, aIsAdd );
       
   408         }
       
   409     
       
   410     if ( duration.Length() > 0 )
       
   411         {
       
   412         TLex durationLex( duration );
       
   413         TReal32 durationValue( 0 );
       
   414         const TInt error( durationLex.Val( durationValue, EDecimal ) );
       
   415         if( error == KErrNone )
       
   416             {
       
   417             if ( durationValue < iPropDefs->iDurationPropertyDef->MaxRealValueL() )
       
   418                 {
       
   419                 CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   420                     *iPropDefs->iDurationPropertyDef, &durationValue, aIsAdd );
       
   421                 }
       
   422             }
       
   423         }
       
   424     
       
   425     if ( copyright.Length() > 0
       
   426         && copyright.Length() < iPropDefs->iCopyrightPropertyDef->MaxTextLengthL() )
       
   427         {
       
   428         CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   429         		*iPropDefs->iCopyrightPropertyDef, &copyright, aIsAdd );
       
   430         }
       
   431     
       
   432     if ( date.Length() > 0
       
   433         && date.Length() < iPropDefs->iDatePropertyDef->MaxTextLengthL() )
       
   434         {
       
   435         TTime releaseDate( date );
       
   436         CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   437                 *iPropDefs->iDatePropertyDef, &releaseDate, aIsAdd );
       
   438         }
       
   439     
       
   440     if( iHarvestAlbumArt && iTNM && jpeg.Length() > 0 )
       
   441         {
       
   442         HBufC8* jpegBuf = jpeg.AllocLC();
       
   443         TBuf<KMimeLength> mimeType( KNullDesC );
       
   444         CThumbnailObjectSource* tnmSource = CThumbnailObjectSource::NewL( jpegBuf, mimeType, uri );
       
   445         CleanupStack::Pop(); // jpegBuf
       
   446         // Ownership of buffer is transferred to Thumbnail Manager
       
   447         iTNM->CreateThumbnails( *tnmSource );
       
   448         delete tnmSource;
       
   449         TBool thumbnailPresent( ETrue );
       
   450         CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   451                           *iPropDefs->iThumbnailPropertyDef, &thumbnailPresent, aIsAdd );
       
   452         }
       
   453     else if( iHarvestAlbumArt )
       
   454         {
       
   455         TBool thumbnailNotPresent( EFalse );
       
   456         CMdeObjectWrapper::HandleObjectPropertyL( mdeObject, 
       
   457                           *iPropDefs->iThumbnailPropertyDef, &thumbnailNotPresent, aIsAdd );
       
   458         }
       
   459        
       
   460     
       
   461     iAudioParser->ResetL();
       
   462     
       
   463 #ifdef _DEBUG
       
   464     dStop.UniversalTime();
       
   465     WRITELOG1( "CHarvesterAudioPlugin::GetMusicPropertiesL start %d us", (TInt)dStop.MicroSecondsFrom(dStart).Int64() );
       
   466 #endif   
       
   467     }
       
   468 
       
   469 // End of file
       
   470