--- /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 <utf.h>
+#include <eikenv.h>
+#include <bautils.h>
+#include <mmf/server/mmfdatasourcesink.hrh>
+#include <mediarecognizer.h>
+
+#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<KMaxDataTypeLength> 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<KMaxFileName> fileExtension;
+ fileExtension.Copy( parser.Ext() );
+
+ TBuf8<KMaxFileName> dmExtension( KDmFileExtension );
+ TBuf8<KMaxFileName> dcfExtension( KDcfFileExtension );
+ TBuf8<KMaxFileName> 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<KMaxFileName> 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<KMaxDataTypeLength> 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<TUid> 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<TUid> 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<KMaxDataTypeLength> 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