/*

* 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 );