diff -r 000000000000 -r a2952bb97e68 mmappcomponents/playbackhelper/src/mediarecognizer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmappcomponents/playbackhelper/src/mediarecognizer.cpp Thu Dec 17 08:55:47 2009 +0200 @@ -0,0 +1,889 @@ +/* +* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Implementation of CMediaRecognizer +* +*/ + +// Version : %version: 7 % + + + +// INCLUDE FILES +#include +#include +#include +#include +#include + +#include "playbackhelper_log.h" + +// CONSTANTS +_LIT8(KDataTypeRAM,"audio/x-pn-realaudio-plugin"); +_LIT8(KDataTypeSDP,"application/sdp"); +_LIT8(KDataTypePlaylist,"audio/mpegurl"); +_LIT8(KDataTypeRNG,"application/vnd.nokia.ringing-tone"); + +_LIT8(KDataTypeMp3,"audio/mp3"); +_LIT8(KDataTypeXmp3,"audio/x-mp3"); +_LIT8(KDataTypeAudio3gp,"audio/3gpp"); +_LIT8(KDataTypeFlashVideo,"video/x-flv"); +_LIT8(KDataTypeText,"text"); + +_LIT8(KDataTypeAVI,"video/avi"); +_LIT8(KDataTypeMsAVI,"video/msvideo"); +_LIT8(KDataTypeMsAVIVideo,"video/x-msvideo"); + +_LIT8(KDataTypeMatroskaVideo ,"video/x-matroska"); + +#ifdef __WINDOWS_MEDIA +_LIT8(KDataTypeWMV_APP,"application/vnd.rn-wmv"); +_LIT8(KDataTypeWMV,"video/x-ms-wmv"); +_LIT8(KDataTypeASF,"application/vnd.ms-asf"); +_LIT8(KDataTypeASX, "video/x-ms-asf"); +_LIT(KRtspTcpPrefix,"rtspt://"); +_LIT(KRtspUdpPrefix,"rtspu://"); +_LIT(KHttpPrefix,"http://"); +_LIT(KHttpTcpPrefix,"httpt://"); +_LIT(KMmsPrefix,"mms://"); +_LIT(KMmstPrefix,"mmst://"); +#endif // __WINDOWS_MEDIA + +_LIT8(KDmFileExtension,".dm"); +_LIT8(KDcfFileExtension,".dcf"); +_LIT8(KOdfFileExtension,".odf"); +_LIT(KRtspPrefix,"rtsp://"); +_LIT(KFilePrefix,"file://"); + +const TInt KDefaultBufferSize = 1000; +const TInt KMinPrefixLength = 6; + + +// ============================ MEMBER FUNCTIONS =================================================== + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::CMediaRecognizer +// C++ default constructor can NOT contain any code, that might leave. +// ------------------------------------------------------------------------------------------------- +// +CMediaRecognizer::CMediaRecognizer() +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::CMediaRecognizer()")); +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::ConstructL +// Symbian 2nd phase constructor can leave. +// ------------------------------------------------------------------------------------------------- +// +void CMediaRecognizer::ConstructL() +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::ConstructL()")); + + User::LeaveIfError( iFs.Connect() ); +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::NewL +// Two-phased constructor. +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C CMediaRecognizer* CMediaRecognizer::NewL() +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::NewL()")); + + CMediaRecognizer* self = new( ELeave ) CMediaRecognizer; + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop(); + return self; +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::~CMediaRecognizer +// Destructor +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C CMediaRecognizer::~CMediaRecognizer() +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::~CMediaRecognizer()")); + + if ( iFileHandle.SubSessionHandle() ) + { + iFileHandle.Close(); + } + +#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + if ( iFileHandle64.SubSessionHandle() ) + { + iFileHandle64.Close(); + } +#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + + iFs.Close(); +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::IdentifyMediaTypeL +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C CMediaRecognizer::TMediaType +CMediaRecognizer::IdentifyMediaTypeL( const TDesC& aMediaName, TBool aIncludeUrls ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::IdentifyMediaTypeL( %S )"), &aMediaName); + + TMediaType ret = EUnidentified; + + if ( BaflUtils::FileExists( iFs, aMediaName ) ) + { + ret = MediaTypeL( aMediaName ); + } + else if ( aIncludeUrls && IsValidStreamingPrefix( aMediaName ) ) + { + ret = EUrl; + } + + return ret; +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::IdentifyMediaTypeL +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C CMediaRecognizer::TMediaType +CMediaRecognizer::IdentifyMediaTypeL( const TDesC& aMediaName, RFile& aFile, TBool aIncludeUrls ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::IdentifyMediaTypeL( %S, RFile )"), &aMediaName); + + if ( aFile.SubSessionHandle() ) + { + iFileHandle.Close(); + User::LeaveIfError( iFileHandle.Duplicate( aFile ) ); + } + + TMediaType ret = EUnidentified; + + if ( FileHandleExists() ) + { + ret = MediaTypeL( aMediaName ); + } + else if ( aIncludeUrls && IsValidStreamingPrefix( aMediaName ) ) + { + ret = EUrl; + } + + return ret; +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::MediaTypeL +// ------------------------------------------------------------------------------------------------- +// +CMediaRecognizer::TMediaType CMediaRecognizer::MediaTypeL( const TDesC& aMediaName ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::MediaTypeL( %S )"), &aMediaName); + + TMediaType ret = EUnidentified; + + TDataRecognitionResult fileRecognitionResult; + RecognizeFileL( aMediaName, fileRecognitionResult ); + + if ( ! fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeSDP ) ) + { + ret = ELocalSdpFile; + } + else if ( ! fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeRAM ) ) + { + ret = ELocalRamFile; + } + else + { + // + // Create a list of the controller plugins that support video + // + RMMFControllerImplInfoArray videoControllers; + CleanupResetAndDestroyPushL( videoControllers ); + + CreateVideoFormatsArrayL( videoControllers ); + + if ( FileHasVideoSupportL( aMediaName, fileRecognitionResult, videoControllers ) ) + { + ret = ELocalVideoFile; + } +#ifdef __WINDOWS_MEDIA + else if ( ! fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeWMV ) || + ! fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeWMV_APP ) || + ! fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeASF ) ) + { + ret = ELocalVideoFile; + } + else if ( ! fileRecognitionResult.iDataType.Des8().CompareF(KDataTypeASX) ) + { + ret = ELocalAsxFile; + } +#endif // __WINDOWS_MEDIA + else if ( ! fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeAVI ) || + ! fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeMsAVI) || + ! fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeMsAVIVideo) ) + { + ret = ELocalVideoFile; + } + else if ( ! fileRecognitionResult.iDataType.Des8().CompareF(KDataTypeFlashVideo) ) + { + ret = EFlashVideoFile; + } + else if ( ! fileRecognitionResult.iDataType.Des8().CompareF( KDataTypePlaylist ) ) + { + ret = ELocalAudioPlaylist; + } + else if ( ! fileRecognitionResult.iDataType.Des8().CompareF( KDataTypeMatroskaVideo ) ) + { + ret = ELocalVideoFile; + } + else + { + // + // Create a list of the controller plugins that support audio + // + RMMFControllerImplInfoArray audioControllers; + CleanupResetAndDestroyPushL( audioControllers ); + + CreateAudioFormatsArrayL( audioControllers ); + + if ( FileHasAudioSupport( aMediaName, + fileRecognitionResult, + audioControllers, + videoControllers ) ) + { + ret = ELocalAudioFile; + } + + CleanupStack::PopAndDestroy(); // audioControllers + } + + CleanupStack::PopAndDestroy(); // videoControllers + } + + return ret; +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::MimeTypeL +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C TBuf CMediaRecognizer::MimeTypeL( const TDesC& aLocalFile ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::MimeTypeL()")); + + TDataRecognitionResult fileRecognitionResult; + RecognizeFileL(aLocalFile,fileRecognitionResult); + TPtrC mimeType( KNullDesC ); + + if (fileRecognitionResult.iConfidence >= CApaDataRecognizerType::EPossible) + { + mimeType.Set( fileRecognitionResult.iDataType.Des() ); + } + + return mimeType; +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::FreeFilehandle +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C void CMediaRecognizer::FreeFilehandle() +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::FreeFilehandle()")); + + if ( iFileHandle.SubSessionHandle() ) + { + iFileHandle.Close(); + } + +#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + if ( iFileHandle64.SubSessionHandle() ) + { + iFileHandle64.Close(); + } +#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::FileHasVideoSupport +// ------------------------------------------------------------------------------------------------- +// +TBool CMediaRecognizer::FileHasVideoSupportL( const TDesC& aFileName, + TDataRecognitionResult& aFileRecognitionResult, + RMMFControllerImplInfoArray& aVideoControllers ) +{ + TBool videoSupport = EFalse; + + if ( aFileRecognitionResult.iConfidence >= CApaDataRecognizerType::EPossible ) + { + for ( TInt i = 0 ; i < aVideoControllers.Count() ; i++ ) + { + RMMFFormatImplInfoArray formats = aVideoControllers[i]->PlayFormats(); + + for ( TInt j = 0; j < formats.Count() ; j++ ) + { + if ( formats[j]->SupportsMimeType( aFileRecognitionResult.iDataType.Des8() ) ) + { + TPtrC8 iDataTypePtr = aFileRecognitionResult.iDataType.Des8(); + + if ( iDataTypePtr.Find( KDataTypeText ) == KErrNotFound ) + { + videoSupport = ETrue; + } + } + else if ( formats[j]->SupportsHeaderDataL( aFileRecognitionResult.iDataType.Des8())) + { + TParsePtrC parser( aFileName ); + TBuf8 fileExtension; + fileExtension.Copy( parser.Ext() ); + + TBuf8 dmExtension( KDmFileExtension ); + TBuf8 dcfExtension( KDcfFileExtension ); + TBuf8 odfExtension( KOdfFileExtension ); + + if ( ( fileExtension.Compare( dmExtension ) == 0 ) || + ( fileExtension.Compare( dcfExtension ) == 0 ) || + ( fileExtension.Compare( odfExtension ) == 0 ) ) + { + videoSupport = ETrue; + } + } + } + } + } + + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::FileHasVideoSupport() support video [%d]"), videoSupport); + + return videoSupport; +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::FileHasAudioSupport +// ------------------------------------------------------------------------------------------------- +// +TBool CMediaRecognizer::FileHasAudioSupport( const TDesC& aFileName, + TDataRecognitionResult& aFileRecognitionResult, + RMMFControllerImplInfoArray& aAudioControllers, + RMMFControllerImplInfoArray& aVideoControllers ) +{ + + TBool audioSupport = EFalse; + + if ( aFileRecognitionResult.iConfidence >= CApaDataRecognizerType::EPossible ) + { + for ( TInt i = 0 ; i < aAudioControllers.Count() ; i++ ) + { + RMMFFormatImplInfoArray formats = aAudioControllers[i]->PlayFormats(); + + for ( TInt j = 0; j < formats.Count() ; j++ ) + { + if ( formats[j]->SupportsMimeType( aFileRecognitionResult.iDataType.Des8() ) ) + { + TPtrC8 iDataTypePtr = aFileRecognitionResult.iDataType.Des8(); + + if ( iDataTypePtr.Find( KDataTypeText ) == KErrNotFound ) + { + audioSupport = ETrue; + } + } + } + } + } + else + { + // + // If we can't quess, try with file extension + // + TParsePtrC parser( aFileName ); + TBuf8 fileExtension; + fileExtension.Copy( parser.Ext() ); + for ( TInt i = 0 ; i < aVideoControllers.Count() ; i++ ) + { + RMMFFormatImplInfoArray formats = aAudioControllers[i]->PlayFormats(); + + for ( TInt j = 0; j < formats.Count() ; j++) + { + if ( formats[j]->SupportsFileExtension( fileExtension ) ) + { + audioSupport = ETrue; + } + } + } + } + + if ( audioSupport && + aFileRecognitionResult.iDataType.Des8().CompareF( KDataTypeRNG ) && + aFileRecognitionResult.iDataType.Des8().CompareF( KDataTypeMp3 ) && + aFileRecognitionResult.iDataType.Des8().CompareF( KDataTypeXmp3 ) && + aFileRecognitionResult.iDataType.Des8().CompareF( KDataTypeAudio3gp ) ) + { + audioSupport = EFalse; + } + + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::FileHasAudioSupport() audio support [%d]"), audioSupport); + + return audioSupport; +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::MimeTypeL +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C TBuf CMediaRecognizer::MimeTypeL( RFile& aFile ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::MimeTypeL( RFile )")); + + if ( aFile.SubSessionHandle() ) + { + iFileHandle.Close(); + // Preferred + User::LeaveIfError( iFileHandle.Duplicate( aFile ) ); + } + + // If new handle is not valid, old might still be + if ( !FileHandleExists() ) + { + User::Leave( KErrBadHandle ); + } + + TDataRecognitionResult fileRecognitionResult; + RecognizeFileL( KNullDesC(), fileRecognitionResult ); + TPtrC mimeType( KNullDesC ); + + if (fileRecognitionResult.iConfidence >= CApaDataRecognizerType::EPossible) + { + mimeType.Set( fileRecognitionResult.iDataType.Des() ); + } + + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::MimeTypeL( RFile ) ret [%S]"),&mimeType); + + return mimeType; +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::CreateVideoFormatsArrayL +// ------------------------------------------------------------------------------------------------- +// +void CMediaRecognizer::CreateVideoFormatsArrayL( RMMFControllerImplInfoArray& aVideoControllers ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::CreateVideoFormatsArrayL()")); + + CMMFControllerPluginSelectionParameters* cSelect = + CMMFControllerPluginSelectionParameters::NewLC(); + + CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC(); + + // Set the play and record format selection parameters to be blank. + // - format support is only retrieved if requested. + cSelect->SetRequiredPlayFormatSupportL( *fSelect ); + + // Set the media ids + RArray mediaIds; + CleanupClosePushL( mediaIds ); + User::LeaveIfError( mediaIds.Append( KUidMediaTypeVideo ) ); + + //get plugins that support at least video + cSelect->SetMediaIdsL( mediaIds, CMMFPluginSelectionParameters::EAllowOtherMediaIds ); + + // aVideoControllers contains now all plugins that support at least video + cSelect->ListImplementationsL( aVideoControllers ); + + // Clean up + CleanupStack::PopAndDestroy( 3 ); //fSelect, cSelect, mediaIds +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::CreateAudioFormatsArrayL +// ------------------------------------------------------------------------------------------------- +// +void CMediaRecognizer::CreateAudioFormatsArrayL( RMMFControllerImplInfoArray& aAudioControllers ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::CreateAudioFormatsArrayL()")); + + CMMFControllerPluginSelectionParameters* cSelect = + CMMFControllerPluginSelectionParameters::NewLC(); + + CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC(); + + // Set the play and record format selection parameters to be blank. + // - format support is only retrieved if requested. + cSelect->SetRequiredPlayFormatSupportL( *fSelect ); + + // Set the media ids + RArray mediaIds; + CleanupClosePushL( mediaIds ); + User::LeaveIfError( mediaIds.Append( KUidMediaTypeAudio ) ); + + // Get plugins that supports audio only + cSelect->SetMediaIdsL( mediaIds, CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds ); + + // aAudioControllers contains now all audio plugins that support at least audio. + cSelect->ListImplementationsL( aAudioControllers ); + + // Clean up + CleanupStack::PopAndDestroy( 3 ); //fSelect, cSelect, mediaIds +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::RecognizeFileL +// ------------------------------------------------------------------------------------------------- +// +void CMediaRecognizer::RecognizeFileL( const TDesC& aFileName, TDataRecognitionResult& aResult ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::RecognizeFileL()")); + + aResult.Reset(); + + TInt bufSize( 0 ); + RApaLsSession recognizer; + User::LeaveIfError( recognizer.Connect() ); + + CleanupClosePushL( recognizer ); + + if ( recognizer.GetMaxDataBufSize( bufSize ) || bufSize <= 0 ) + { + bufSize = KDefaultBufferSize; + } + + HBufC8* fBuf = HBufC8::NewLC( bufSize ); + TPtr8 fileBuf = fBuf->Des(); + + // recognize file + if ( FileHandleExists() ) + { + User::LeaveIfError( recognizer.RecognizeData( iFileHandle, aResult ) ); + } +#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + else if ( FileHandle64Exists() ) + { + User::LeaveIfError( recognizer.RecognizeData( iFileHandle64, aResult ) ); + } +#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + else + { + // read file + User::LeaveIfError( ReadFile( aFileName, fileBuf, bufSize ) ); + User::LeaveIfError( recognizer.RecognizeData( aFileName, fileBuf, aResult ) ); + } + + CleanupStack::PopAndDestroy( 2 ); // fBuf & recognizer +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::ReadFile +// ------------------------------------------------------------------------------------------------- +// +TInt CMediaRecognizer::ReadFile( const TDesC& aFileName, TDes8& aBuf, TInt aBufSize ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::ReadFile( %S )"), &aFileName); + + TInt err = KErrNone; + + // + // open using 32-bit file handle + // + err = ReadFileViaNewFileHandle( aFileName, aBuf, aBufSize ); + +#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + if ( err == KErrTooBig ) + { + // + // if 32-bit file handle fails, open using 64-bit file handle + // + err = ReadFileViaNewFileHandle64( aFileName, aBuf, aBufSize ); + } +#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + + return err; +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::FileHandleExists +// ------------------------------------------------------------------------------------------------- +// +TBool CMediaRecognizer::FileHandleExists() +{ + TInt size = 0; + TInt err = KErrNone; + TBool exist = EFalse; + + if ( iFileHandle.SubSessionHandle() ) + { + err = iFileHandle.Size( size ); + } + + if ( err == KErrNone && size > 0 ) + { + exist = ETrue; + } + + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::FileHandleExists() exist [%d]"), exist); + + return exist; +} + +//-------------------------------------------------------------------------------------------------- +// CMediaRecognizer::IsValidStreamingPrefix +// Check for a valid streaming prefix given a URL +//-------------------------------------------------------------------------------------------------- +// +EXPORT_C TBool CMediaRecognizer::IsValidStreamingPrefix( const TDesC& aUrl ) +{ + TBool retVal = EFalse; + + if ( aUrl.Length() >= KMinPrefixLength ) + { + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::IsValidStreamingPrefix(%S)"), &aUrl); + +#ifdef __WINDOWS_MEDIA + if ( ( ! aUrl.Left(KRtspPrefix().Length()).CompareF(KRtspPrefix) ) || + ( ! aUrl.Left(KHttpPrefix().Length()).CompareF(KHttpPrefix) ) || + ( ! aUrl.Left(KMmsPrefix().Length()).CompareF(KMmsPrefix) ) || + ( ! aUrl.Left(KMmstPrefix().Length()).CompareF(KMmstPrefix) ) || + ( ! aUrl.Left(KHttpTcpPrefix().Length()).CompareF(KHttpTcpPrefix) ) || + ( ! aUrl.Left(KRtspTcpPrefix().Length()).CompareF(KRtspTcpPrefix) ) || + ( ! aUrl.Left(KRtspUdpPrefix().Length()).CompareF(KRtspUdpPrefix) ) ) +#else + if ( ! aUrl.Left( KRtspPrefix().Length() ).CompareF( KRtspPrefix ) ) +#endif + { + retVal = ETrue; + } + } + + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::IsValidStreamingPrefix() ret %d"), retVal); + + return retVal; +} + +//-------------------------------------------------------------------------------------------------- +// CMediaRecognizer::IsValidUrlPrefix +// Check for a valid prefix given a URL +//-------------------------------------------------------------------------------------------------- +// +EXPORT_C TBool CMediaRecognizer::IsValidUrlPrefix( const TDesC& aUrl ) +{ + TBool retVal = EFalse; + + if ( aUrl.Length() >= KMinPrefixLength ) + { + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::IsValidUrlPrefix(%S)"), &aUrl); + + + if ( ( ! aUrl.Left(KFilePrefix().Length()).CompareF(KFilePrefix) ) || +#ifdef __WINDOWS_MEDIA + ( ! aUrl.Left(KHttpPrefix().Length()).CompareF(KHttpPrefix) ) || + ( ! aUrl.Left(KMmsPrefix().Length()).CompareF(KMmsPrefix) ) || + ( ! aUrl.Left(KMmstPrefix().Length()).CompareF(KMmstPrefix) ) || + ( ! aUrl.Left(KHttpTcpPrefix().Length()).CompareF(KHttpTcpPrefix) ) || + ( ! aUrl.Left(KRtspTcpPrefix().Length()).CompareF(KRtspTcpPrefix) ) || + ( ! aUrl.Left(KRtspUdpPrefix().Length()).CompareF(KRtspUdpPrefix) ) || +#endif + ( ! aUrl.Left(KRtspPrefix().Length()).CompareF(KRtspPrefix) ) ) + { + retVal = ETrue; + } + } + + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::IsValidUrlPrefix() ret %d"), retVal); + + return retVal; +} + +//-------------------------------------------------------------------------------------------------- +// CMediaRecognizer::IsValidUrlPrefix +// Check for a valid prefix given a URL +//-------------------------------------------------------------------------------------------------- +// +EXPORT_C TBool CMediaRecognizer::IsValidUrlPrefix( const TDesC8& aUrl ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::IsValidUrlPrefix(TDesC8)")); + + TBool retVal = EFalse; + + if ( aUrl.Length() >= KMinPrefixLength ) + { + HBufC16* buf16 = NULL; + + TRAPD( err, buf16 = CnvUtfConverter::ConvertToUnicodeFromUtf8L(aUrl); ); + + if ( ! err ) + { + retVal = IsValidUrlPrefix( buf16->Des() ); + delete buf16; + } + } + + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::IsValidUrlPrefix(TDesC8) ret %d"), retVal); + + return retVal; +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::ReadFileViaNewFileHandle +// ------------------------------------------------------------------------------------------------- +// +TInt CMediaRecognizer::ReadFileViaNewFileHandle( const TDesC& aFileName, TDes8& aBuf, TInt aBufSize ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::ReadFileViaNewFileHandle()")); + + TInt err = KErrNone; + + RFile file; + err = file.Open( iFs, aFileName, EFileRead | EFileShareReadersOnly ); + + if ( err ) + { + err = file.Open( iFs, aFileName, EFileRead | EFileShareAny ); + } + + if ( err == KErrNone ) + { + // read the beginning of the file + err = file.Read( 0, aBuf, aBufSize ); + file.Close(); + } + + return err; +} + +#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::IdentifyMediaTypeL +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C CMediaRecognizer::TMediaType +CMediaRecognizer::IdentifyMediaTypeL( const TDesC& aMediaName, RFile64& aFile, TBool aIncludeUrls ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::IdentifyMediaTypeL( %S, RFile64 )"), &aMediaName); + + if ( aFile.SubSessionHandle() ) + { + iFileHandle64.Close(); + User::LeaveIfError( iFileHandle64.Duplicate( aFile ) ); + } + + TMediaType ret = EUnidentified; + + if ( FileHandle64Exists() ) + { + ret = MediaTypeL( aMediaName ); + } + else if ( aIncludeUrls && IsValidStreamingPrefix( aMediaName ) ) + { + ret = EUrl; + } + + return ret; +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::MimeTypeL +// ------------------------------------------------------------------------------------------------- +// +EXPORT_C TBuf CMediaRecognizer::MimeTypeL( RFile64& aFile ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::MimeTypeL( RFile64 )")); + + if ( aFile.SubSessionHandle() ) + { + iFileHandle64.Close(); + // Preferred + User::LeaveIfError( iFileHandle64.Duplicate( aFile ) ); + } + + // If new handle is not valid, old might still be + if ( !FileHandle64Exists() ) + { + User::Leave( KErrBadHandle ); + } + + TDataRecognitionResult fileRecognitionResult; + RecognizeFileL( KNullDesC(), fileRecognitionResult ); + TPtrC mimeType( KNullDesC ); + + if (fileRecognitionResult.iConfidence >= CApaDataRecognizerType::EPossible) + { + mimeType.Set( fileRecognitionResult.iDataType.Des() ); + } + + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::DetermineMimeTypeL( RFile64 ) ret [%S]"), &mimeType); + + return mimeType; +} + + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::FileHandle64Exists +// ------------------------------------------------------------------------------------------------- +// +TBool CMediaRecognizer::FileHandle64Exists() +{ + TInt64 size = 0; + TInt err = KErrNone; + TBool exist = EFalse; + + if ( iFileHandle64.SubSessionHandle() ) + { + err = iFileHandle64.Size( size ); + } + + if ( err == KErrNone && size > 0 ) + { + exist = ETrue; + } + + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::FileHandle64Exists() exist [%d]"), exist); + + return exist; +} + +// ------------------------------------------------------------------------------------------------- +// CMediaRecognizer::ReadFileViaCurrentFileHandle64 +// ------------------------------------------------------------------------------------------------- +// +TInt CMediaRecognizer::ReadFileViaNewFileHandle64( const TDesC& aFileName, TDes8& aBuf, TInt aBufSize ) +{ + PLAYBACKHELPER_DEBUG(_L("CMediaRecognizer::ReadFileViaNewFileHandle64()")); + + TInt err = KErrNone; + + RFile64 file; + err = file.Open( iFs, aFileName, EFileRead | EFileShareReadersOnly ); + + if ( err ) + { + err = file.Open( iFs, aFileName, EFileRead | EFileShareAny ); + } + + if ( err == KErrNone ) + { + // read the beginning of the file + err = file.Read( 0, aBuf, aBufSize ); + file.Close(); + } + + return err; +} + +#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + + + +// End of File