FCL/sf/mw/mmappfw: comparison mmappcomponents/harvester/metadataextractor/src/mpxmetadataextractor.cpp

equal deleted inserted replaced

-:09978a29cfde
+:b7b49303d0c0
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:  Extracts metadata from a file
-*  Version     : %version: da1mmcf#38.1.4.2.6.1.5.3.5 % << Don't touch! Updated by Synergy at check-out.
+*  Version     : %version: da1mmcf#38.1.4.2.6.1.5.3.6 % << Don't touch! Updated by Synergy at check-out.
 *
 */
 #include <e32base.h>
 #include <badesca.h>
 _LIT( KWmaCafMimeType, "x-caf-audio/x-ms-wma" );
 #ifdef RD_MPX_TNM_INTEGRATION
 _LIT( KImageFileType, "image/jpeg" );
 const TInt KMPXTimeoutTimer = 3000000; // 3 seconds
 const TInt KMPXMaxThumbnailRequest = 2;
 #endif //RD_MPX_TNM_INTEGRATION
 #ifdef ABSTRACTAUDIOALBUM_INCLUDED
 _LIT( KNonEmbeddedArtExt, ".alb" );
 #endif
 iFileOpenError = KErrNone;
 iObs = NULL;
 aNewProperty = NULL;
 iFileName = aFile;
 iMetadataOnly = aMetadataOnly;
 // populate the task array
 AddTasksL();
 // execute all tasks in the array
 while ( iArrayTasks.Count() )
 {
 // execute task at index 0
 MPX_TRAPD( error, ExecuteTaskL() );
 CleanUp();
 User::LeaveIfError( error );
 }
 break;
 }
 iArrayTasks.Remove( 0 );
 }
 aNewProperty = iMedia;
 iMedia = NULL;  // ownership transferred.
 CleanUp();
 }
 aMediaProp.SetTextValueL( KMPXMediaMusicArtist,
 KNullDesC );
 // Album
 aMediaProp.SetTextValueL( KMPXMediaMusicAlbum,
 KNullDesC );
-// Year
-aMediaProp.SetTObjectValueL<TInt64>( KMPXMediaMusicYear,
-(TInt64) 0 );
 // Track
 aMediaProp.SetTextValueL( KMPXMediaMusicAlbumTrack,
 KNullDesC );
 // Genre
 aMediaProp.SetTextValueL( KMPXMediaMusicGenre,
 MPX_FUNC("CMPXMetadataExtractor::SetMediaPropertiesL()");
 const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType );
 HBufC8* mimeType8 = HBufC8::NewLC( mimeType.Length() );
 mimeType8->Des().Append( mimeType );
 // Continue to extract metadata even if fail.
 MPX_TRAPD( metadataerror, iMetadataUtility->OpenFileL( iFile, *mimeType8 ) );
 CleanupStack::PopAndDestroy( mimeType8 );
 // Get MetadataUtility Container
 const CMetaDataFieldContainer& metaCont = iMetadataUtility->MetaDataFieldsL();
 // Get DRM data
 // Need the protected flag from metadataUtility Container
 MPX_TRAPD( drmerror, SetDrmMediaPropertiesL( metaCont ) );
 MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL, result=%d getting drm data",
 drmerror );
 // Get metadata fields
 TInt count( metaCont.Count() );
 for( TInt i=0; i<count; ++i )
 {
 TMetaDataFieldId fieldType;
 HBufC* value = NULL;
 metaCont.FieldIdAt( i, fieldType );  // get the field type
 // get the value, except for album art
 if ( fieldType != EMetaDataJpeg )
 {
 MPX_TRAPD( err, value = metaCont.At( i, fieldType ).AllocL() );
 if ( KErrNone != err )
 {
 MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL - error = %i", err);
 continue;
 }
 CleanupStack::PushL( value );
 }
 switch( fieldType )
 {
 case EMetaDataSongTitle:
 {
 TPtr valptr = value->Des();
 {
 iMedia->SetTextValueL( KMPXMediaGeneralCopyright,
 *value );
 break;
 }
 case EMetaDataDuration:
 {
 const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType );
 MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL, mimeType = %S", &mimeType);
 // Verify if WMA, get the duration
 if( mimeType.Compare(KWmaMimeType) == 0 || mimeType.Compare(KWmaCafMimeType) == 0 )
 {
 MPX_DEBUG1("CMPXMetadataExtractor::SetMediaPropertiesL- WMA");
 // Perform the duration conversion
 TLex lexer( *value );
 TInt32 duration ( 0 );
 lexer.Val( duration );   // [second]
 duration *= 1000;        // [msec]
 iMedia->SetTObjectValueL<TInt32>( KMPXMediaGeneralDuration,
 duration );
 MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL- duration = %i", duration);
 }
 break;
 }
 case EMetaDataSampleRate:
 {
 const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType );
 MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL, mimeType = %S", &mimeType);
 // Verify if WMA, get the sample rate
 if( mimeType.Compare(KWmaMimeType) == 0 || mimeType.Compare(KWmaCafMimeType) == 0 )
 {
 MPX_DEBUG1("CMPXMetadataExtractor::SetMediaPropertiesL- WMA");
 // Perform the sample rate conversion
 TLex lexer( *value );
 TInt32 sampleRate ( 0 );
 lexer.Val( sampleRate );
 iMedia->SetTObjectValueL<TUint>( KMPXMediaAudioSamplerate,
 sampleRate );
 MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL- sample rate = %i", sampleRate);
 }
 break;
 }
 case EMetaDataBitRate:
 {
 const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType );
 MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL, mimeType = %S", &mimeType);
 // Verify if WMA, get the duration
 if( mimeType.Compare(KWmaMimeType) == 0 || mimeType.Compare(KWmaCafMimeType) == 0 )
 {
 MPX_DEBUG1("CMPXMetadataExtractor::SetMediaPropertiesL- WMA");
 // Perform the duration conversion
 TLex lexer( *value );
 TInt32 bitRate ( 0 );
 lexer.Val( bitRate );
 iMedia->SetTObjectValueL<TUint>( KMPXMediaAudioBitrate,
 bitRate );
 MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL- duration = %i", bitRate);
 }
 break;
 }
 case EMetaDataOriginalArtist:  // fall through
 case EMetaDataVendor:          // fall through
 break;
 }
 }
 if (fieldType != EMetaDataJpeg)
 {
 CleanupStack::PopAndDestroy( value );
 }
 }
 }
 // ---------------------------------------------------------------------------
 //
 TInt size( 0 );
 if( iFileOpenError == KErrNone )
 {
 const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType );
 MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL, mimeType = %S", &mimeType);
 iFile.Size( size );
 iMedia->SetTObjectValueL<TInt>( KMPXMediaGeneralSize, size );
 // Verify if WMA, skip getting info from MMF
 if( mimeType.Compare(KWmaMimeType) == 0 || mimeType.Compare(KWmaCafMimeType) == 0 )
 {
 // No need to get MMF support
 MPX_DEBUG1("CMPXMetadataExtractor::SetExtMediaPropertiesL, skip MMF ");
 }
 else
 {
 MPX_DEBUG1("CMPXMetadataExtractor::SetExtMediaPropertiesL, get MMF controller");
 // Duration, bitrate, samplerate, etc
 //
 if( !iMetadataOnly )
 {
 MPX_TRAPD(err2, iFileInfoUtil->OpenFileL(
 iFile,
 iMedia->ValueText(KMPXMediaGeneralMimeType)));
 MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL, file info util error %i", err2);
 if( KErrNone == err2 )
 {
 iMedia->SetTObjectValueL<TUint>( KMPXMediaAudioBitrate,
 iMedia->SetTObjectValueL<TInt32>( KMPXMediaGeneralDuration,
 duration );
 MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL -- duration %i", duration);
 }
 iFileInfoUtil->Reset();
 }
 }
 }
 }
 // ---------------------------------------------------------------------------
 // CMPXMetadataExtractor::ThumbnailPreviewReady
 // Callback but not used here
 // ---------------------------------------------------------------------------
 void CMPXMetadataExtractor::ThumbnailPreviewReady(
 MThumbnailData& /*aThumbnail*/, TThumbnailRequestId /*aId*/ )
 {
 MPX_FUNC("CMPXMetadataExtractor::ThumbnailPreviewReady()");
 }
 // ---------------------------------------------------------------------------
 // CMPXMetadataExtractor::ThumbnailReady
 // Callback but not used here
 // ---------------------------------------------------------------------------
 void CMPXMetadataExtractor::ThumbnailReady( TInt /*aError*/,
 MThumbnailData& /*aThumbnail*/, TThumbnailRequestId aId )
 {
 MPX_FUNC("CMPXMetadataExtractor::ThumbnailReady()");
 // Remove thumbnail id from array.
 TInt index = iArrayTNRequestId.Find( aId );
 if ( index >= 0 )
 {
 iArrayTNRequestId.Remove( index );
 {
 MPX_FUNC("CMPXMetadataExtractor::TimeoutTimerCallback()");
 CMPXMetadataExtractor* ptr =
 static_cast<CMPXMetadataExtractor*>(aPtr);
 // Timer expired before thumbnail callback occurred. Stop wait loop to unblock.
 ptr->StopWaitLoop();
 return KErrNone;
 }
 // ----------------------------------------------------------------------------
 void CMPXMetadataExtractor::StopWaitLoop()
 {
 MPX_FUNC("CMPXMetadataExtractor::StopWaitLoop()");
 // Cancel timer
 CancelTimeoutTimer();
 // Stop wait loop to unblock.
 if ( iTNSyncWait->IsStarted() )
 {
 MPX_DEBUG1("CMPXMetadataExtractor::StopWaitLoop(): Stopping the wait loop.");
 iTNSyncWait->AsyncStop();
 }
 }
 // ----------------------------------------------------------------------------
 // Cancel timer.
 // ----------------------------------------------------------------------------
 void CMPXMetadataExtractor::CancelTimeoutTimer()
 {
 MPX_FUNC("CMPXMetadataExtractor::CancelTimeoutTimer()");
 // Cancel timer.
 if ( iTimer && iTimer->IsActive() )
 {
 MPX_DEBUG1("CMPXMetadataExtractor::CancelTimeoutTimer(): Timer active, cancelling");
 iTimer->Cancel();
 EXPORT_C TInt CMPXMetadataExtractor::ExtractAlbumArtL( CMPXMedia* aMedia )
 {
 MPX_FUNC("CMPXMetadataExtractor::ExtractAlbumArtL()");
 TInt err = KErrNone;
 iCancelled = EFalse;
 if ( !aMedia->IsSupported(KMPXMediaGeneralUri) )
 {
 return KErrArgument;
 }
 // Get full file name.
 const TDesC& path = aMedia->ValueText(KMPXMediaGeneralUri);
 MPX_DEBUG2("CMPXMetadataExtractor::ExtractAlbumArtL Filename:%S ", &path );
 #ifdef ABSTRACTAUDIOALBUM_INCLUDED
 TParsePtrC parse( path );
 TBuf<20> mimeType(KImageFileType);
 TInt sampleData = aMedia->ValueTObjectL<TInt>(KMPXMediaMTPSampleData);
 HBufC8* value8 = ((HBufC8*)sampleData)->Des().AllocLC();   // make a local copy of sampleData
 source = CThumbnailObjectSource::NewLC(
 value8, mimeType, path );    // give up ownership of value8
 MPX_DEBUG1("CMPXMetadataExtractor::ExtractAlbumArtL source created from buffer");
 TThumbnailRequestId tnId = iTNManager->CreateThumbnails( *source );
 iArrayTNRequestId.Append( tnId );
 CleanupStack::PopAndDestroy( source );
 CleanupStack::Pop( value8 );
 }
 else
 {
 source = CThumbnailObjectSource::NewLC(
 path, KImageFileType  );
 MPX_DEBUG1("CMPXMetadataExtractor::ExtractAlbumArtL source created from path");
 TThumbnailRequestId tnId = iTNManager->CreateThumbnails( *source );
 iArrayTNRequestId.Append( tnId );
 CleanupStack::PopAndDestroy( source );
 }
 #endif // ABSTRACTAUDIOALBUM_INCLUDED
 // create wanted fields array
 RArray<TMetaDataFieldId> wantedFields;
 CleanupClosePushL( wantedFields );
 wantedFields.Append(EMetaDataJpeg);
 // Open file
 if ( aMedia->IsSupported(KMPXMediaGeneralMimeType) )
 {
 const TDesC& mimeType = aMedia->ValueText( KMPXMediaGeneralMimeType );
 MPX_DEBUG2("CMPXMetadataExtractor::ExtractAlbumArtL MimeType:%S ", &mimeType );
 else
 {
 MPX_TRAP( err, iMetadataUtility->OpenFileL( path, wantedFields ) );
 }
 CleanupStack::PopAndDestroy( &wantedFields );
 if ( !err )
 {
 //check if can send TN request, If thumbnail creation is ongoing, wait til it is done
 CheckBeforeSendRequest();
 MPX_TRAP( err, AddMediaAlbumArtL( *aMedia, path ));
 }
 // ----------------------------------------------------------------------------
 // Add album art to media object.
 // ----------------------------------------------------------------------------
 void CMPXMetadataExtractor::AddMediaAlbumArtL( CMPXMedia& aMedia,
 const TDesC& aFile )
 {
 MPX_FUNC("CMPXMetadataExtractor::AddMediaAlbumArtL()");
 // get metadata container.
 const CMetaDataFieldContainer& metaCont = iMetadataUtility->MetaDataFieldsL();
 TPtrC8 data8 = metaCont.Field8( EMetaDataJpeg );
 if ( data8.Length() )
 {
 MPX_DEBUG1("CMPXMetadataExtractor::GetMediaAlbumArtL(): Album art exist.");
 #ifdef RD_MPX_TNM_INTEGRATION
 HBufC8* value8 = NULL;
 MPX_TRAPD( err, value8 = data8.AllocL() );
 if ( KErrNone != err )
 {
 MPX_DEBUG2("CMPXMetadataExtractor::GetMediaAlbumArtL - error jpeg = %i", err);
 return;
 }
 CleanupStack::PushL( value8 );
 TBuf<256> mimeType;
 mimeType.Copy( KImageFileType );
 CThumbnailObjectSource* source = CThumbnailObjectSource::NewL(
 value8, mimeType, aFile );
 TThumbnailRequestId tnId = iTNManager->CreateThumbnails( *source );
 iArrayTNRequestId.Append( tnId ); // add thumbnail id to array
 CleanupStack::Pop( value8 );
 delete source;
 aMedia.SetTextValueL( KMPXMediaMusicOriginalAlbumArtFileName, aFile );
 #endif // RD_MPX_TNM_INTEGRATION
 aMedia.SetTextValueL( KMPXMediaMusicAlbumArtFileName, aFile );
 }
 }
 // ----------------------------------------------------------------------------
 TDataType dataType;
 TUid dummyUid(KNullUid);
 iAppArc.AppForDocument(iFileName, dummyUid, dataType);
 iMedia->SetTextValueL( KMPXMediaGeneralMimeType,dataType.Des() );
 }
 // Initially set default tags.
 SetDefaultL( *iMedia );
 }
 // ----------------------------------------------------------------------------
 if ( iArrayTasks.Count() )
 {
 MPX_DEBUG1("CMPXMetadataExtractor::CreateMediaAsyncL Request ongoing. Abort!" );
 User::Leave( KErrAbort );
 }
 iCancelled = EFalse;
 iFileOpenError = KErrNone;
 iFileName = aFile;
 iObs = aObs;
 iMetadataOnly = aMetadataOnly;
 // populate the task array
 AddTasksL();
 // Start task timer to execute task
 if ( iArrayTasks.Count() )
 {
 if ( iTaskTimer->IsActive() )
 {
 iTaskTimer->Cancel();
 }
 iTaskTimer->Start( 0, 0, TCallBack(TaskTimerCallback, this ));
 }
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 TInt CMPXMetadataExtractor::OpenFile()
 {
 MPX_FUNC("CMPXMetadataExtractor::OpenFile()");
 // Open the file
 iFile.Close();
 TInt error = iFile.Open( iFs, iFileName, EFileRead | EFileShareReadersOrWriters );
 MPX_DEBUG2("CMPXMetadataExtractor::OpenFile open error = %d", error );
 return error;
 //
 void CMPXMetadataExtractor::AddTasksL()
 {
 MPX_FUNC("CMPXMetadataExtractor::AddTasks()");
 iFileOpenError = OpenFile();
 // Do not change the order of the task below.
 iArrayTasks.Reset();
 if ( iFileOpenError == KErrNone )
 {
 // to avoid resources contention (i.e. accessing sql, file system, etc)
 // Handle task timer expired
 // ----------------------------------------------------------------------------
 void CMPXMetadataExtractor::HandleTaskTimerExpired()
 {
 MPX_FUNC("CMPXMetadataExtractor::HandleTaskTimerExpired()");
 if ( iTaskTimer && iTaskTimer->IsActive() )
 {
 iTaskTimer->Cancel();
 }
 // execute task at index 0
 delete iMedia;
 iMedia = NULL;
 }
 iArrayTasks.Reset();
 }
 // Remove task at index 0.
 if ( iArrayTasks.Count() )
 {
 iArrayTasks.Remove( 0 );
 }
 // check if we have any more task to run
 if ( iArrayTasks.Count() )
 {
 // start task timer
 iTaskTimer->Start( 0, 0, TCallBack(TaskTimerCallback, this ));
 if ( iObs && !iCancelled )
 {
 iObs->HandleCreateMediaComplete( iMedia, error );
 iMedia = NULL;  // ownership transferred.
 }
 CleanUp();
 }
 }
 // ----------------------------------------------------------------------------
 // DB Flags to set
 TUint dbFlags(KMPXMediaGeneralFlagsSetOrUnsetBit);
 // Validate the objects to be used
 MPX_ASSERT(iMedia);
 MPX_ASSERT(iDrmMediaUtility);
 // File Path
 TParsePtrC parse( iFileName );
 iMedia->SetTextValueL( KMPXMediaGeneralUri, iFileName );
 iMedia->SetTextValueL( KMPXMediaGeneralDrive, parse.Drive() );
 MPX_DEBUG2("CMPXMetadataExtractor::SetDrmMediaPropertiesL - Filename=%S", &iFileName);
 // get the protected flag from MetadataUtility Container
 TPtrC ptr = aMetaCont.Field( EMetaDataProtected );
 MPX_DEBUG2("CMPXMetadataExtractor::SetDrmMediaPropertiesL -- status=%S", &ptr);
 _LIT( KNonProtected, "0" );
 if ( ptr.Compare( KNonProtected ) == 0 )
 {
 // this is non-protected file
 // prot = EFalse
 MPX_DEBUG1("CMPXMetadataExtractor::SetDrmMediaPropertiesL - non protected");
 iMedia->SetTObjectValueL<TBool>( KMPXMediaDrmProtected, prot );
 iMedia->SetTObjectValueL<TUint16>( KMPXMediaMTPDrmStatus, (TUint16)prot );
 }
 else
 {  // DRM file
 // DRM Rights
 //
 CMPXMedia* drm = NULL;
 User::LeaveIfError( drmError );
 }
 iMedia->SetTObjectValueL<TBool>( KMPXMediaDrmProtected, prot );
 iMedia->SetTObjectValueL<TUint16>( KMPXMediaMTPDrmStatus, (TUint16)prot );
 iDrmMediaUtility->Close();
 }  // DRM file
 // verify the file open status
 if( iFileOpenError == KErrNotFound || iFileOpenError == KErrPathNotFound )
 {
 dbFlags |= KMPXMediaGeneralFlagsIsInvalid;
 }
 // Finally set the db flag
 //
 iMedia->SetTObjectValueL( KMPXMediaGeneralFlags, dbFlags );
 }

changeset 48	b7b49303d0c0
parent 45	09978a29cfde
child 54	fa0adf088850