/*

* Copyright (c) 2006-2009 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:  Harvests meta data from video file.*

*/

#include <e32base.h>

#include <e32std.h>

#include <3gplibrary/mp4lib.h>

#include <hxmetadatautil.h>

#include <hxmetadatakeys.h>

#include <caf/caf.h>

#include <pathinfo.h>

#include "mdsutils.h"

#include "harvestervideoplugin.h"

#include "harvesterlog.h"

#include "harvesterblacklist.h"

#include "mdeobjectwrapper.h"

#include "mdscommoninternal.h"

#include <mdenamespacedef.h>

#include <mdeobjectdef.h>

#include <mdepropertydef.h>

#include <mdeobject.h>

#include <harvesterdata.h>

#include <mdeconstants.h>

using namespace MdeConstants;

_LIT( KMimeTypeVideoMp4,  "video/mp4" );

_LIT( KMimeTypeAudioMp4,  "audio/mp4" );

_LIT( KMimeTypeVideo3gpp, "video/3gpp" );

_LIT( KMimeTypeAudio3gpp, "audio/3gpp" );

_LIT( KMimeTypeRm,        "application/vnd.rn-realmedia" ); // can be audio or video

_LIT( KMimeTypeRmvb,      "application/vnd.rn-realmedia-vbr" ); // can be audio or video

_LIT( KMimeTypeRv,        "video/vnd.rn-realvideo" );

_LIT( KMimeTypeRa,        "audio/vnd.rn-realaudio" );

_LIT( KMimeTypeAvi,        "video/avi");

_LIT( KMimeTypeVideoMatroska, "video/x-matroska");

_LIT( KMimeTypeAudioMatroska, "audio/x-matroska");

_LIT( KMimeTypeWmv, "video/x-ms-wmv");

_LIT( KMimeTypeDivx, "video/x-hx-divx");

_LIT( KMimeTypeAsf, "video/x-ms-asf");

_LIT( KExtensionMp4,   "mp4" );

_LIT( KExtensionMpg4,  "mpg4" );

_LIT( KExtensionMpeg4, "mpeg4" );

_LIT( KExtensionM4v,   "m4v" );

_LIT( KExtensionM4a,   "m4a" );

_LIT( KExtension3gp,   "3gp" );

_LIT( KExtension3gpp,  "3gpp" );

_LIT( KExtension3g2,   "3g2" );

_LIT( KExtensionRm,    "rm" );

_LIT( KExtensionRmvb,  "rmvb" );

_LIT( KExtensionRv,    "rv" );

_LIT( KExtensionAvi,    "avi" );

_LIT( KExtensionMkv,    "mkv" );

_LIT( KExtensionRa,     "ra" );

_LIT( KExtensionWmv,     "wmv" );

_LIT( KExtensionDivx,     "divx" );

_LIT( KExtensionAsf,     "asf" );

_LIT(KVideo, "Video");

_LIT(KAudio, "Audio");

_LIT(KAudioAC3, "audio/AC3");

_LIT(KAudioEAC3, "audio/EAC3");

const TUint32 KMDSFourCCCodeAC3 = 0x33434120;       //{' ', 'A', 'C', '3'}

const TUint32 KMDSFourCCCodeEAC3 = 0x33434145;      //{'E', 'A', 'C', '3'}

_LIT(KInUse, "InUse");

const TInt KKiloBytes = 1024;

const TReal32 KThousandReal = 1000.0;

	{

	}

void CHarvesterVideoPluginPropertyDefs::ConstructL(CMdEObjectDef& aObjectDef)

	{

	}

/**

* Default constructor

*/

CHarvesterVideoPlugin::CHarvesterVideoPlugin() : CHarvesterPlugin(), iPropDefs( NULL )

	{

	}

/**

* Construction

* @return Harvester image plugin

*/

CHarvesterVideoPlugin* CHarvesterVideoPlugin::NewL()

	{

	WRITELOG("CHarvesterVideoPlugin::NewL()");

	CHarvesterVideoPlugin* self = new(ELeave) CHarvesterVideoPlugin();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

* Destruction

*/

CHarvesterVideoPlugin::~CHarvesterVideoPlugin()

	{

	delete iPropDefs;

	iMimeTypeMappings.Close();

    RMediaIdUtil::ReleaseInstance();

    delete iPhoneVideosPath;

    delete iMmcVideosPath;

	WRITELOG("CHarvesterVideoPlugin::CHarvesterVideoPlugin()");

	}

/**

* 2nd phase constructor

*/

void CHarvesterVideoPlugin::ConstructL()

	{

	WRITELOG( "CHarvesterVideoPlugin::ConstructL() - begin" );

	TLinearOrder< THarvestingHandling > cmp( THarvestingHandling::CompareFunction );

	// MPEG4

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtensionMp4(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KNullDesC(),

    				KMimeTypeVideoMp4(), KMimeTypeAudioMp4() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtensionMpg4(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KNullDesC(),

    				KMimeTypeVideoMp4(), KMimeTypeAudioMp4() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtensionMpeg4(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KNullDesC(),

    				KMimeTypeVideoMp4(), KMimeTypeAudioMp4() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtensionM4v(), KMimeTypeVideoMp4(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KVideo(),

    				KMimeTypeVideoMp4(), KMimeTypeAudioMp4() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtensionM4a(), KMimeTypeAudioMp4(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KAudio(),

    				KMimeTypeVideoMp4(), KMimeTypeAudioMp4() ) ), 

    		cmp ) );

	// 3GP

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtension3gp(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KNullDesC(),

    				KMimeTypeVideo3gpp(), KMimeTypeAudio3gpp() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtension3gpp(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KNullDesC(),

    				KMimeTypeVideo3gpp(), KMimeTypeAudio3gpp() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtension3g2(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KNullDesC(),

    				KMimeTypeVideo3gpp(), KMimeTypeAudio3gpp() ) ), 

    		cmp ) );

	// RealMedia

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtensionRm(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KNullDesC(),

    				KMimeTypeRm(), KMimeTypeRm() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtensionRmvb(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KNullDesC(),

    				KMimeTypeRmvb(), KMimeTypeRmvb() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtensionRv(), KMimeTypeRv(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KVideo(),

    				KMimeTypeRv(), KMimeTypeRa() ) ), 

    		cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

            KExtensionRa(), KMimeTypeRa(), 

            TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KAudio(),

                    KMimeTypeRv(), KMimeTypeRa() ) ), 

            cmp ) );

    // Avi

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

            KExtensionAvi(), KMimeTypeAvi(), 

            TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KVideo(),

                    KMimeTypeAvi(), KMimeTypeAvi() ) ), 

            cmp ) );

    // Divx

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

            KExtensionDivx(), KMimeTypeDivx(), 

            TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KVideo(),

                    KMimeTypeDivx(), KMimeTypeDivx() ) ), 

            cmp ) );

    // Matroska

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

            KExtensionMkv(), KNullDesC(), 

            TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KNullDesC(),

                    KMimeTypeVideoMatroska(), KMimeTypeAudioMatroska() ) ), 

            cmp ) );

    // Wmv

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

            KExtensionWmv(), KMimeTypeWmv(), 

            TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KVideo(),

                    KMimeTypeWmv(), KMimeTypeWmv() ) ), 

            cmp ) );

    // Asf

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

            KExtensionAsf(), KMimeTypeAsf(), 

            TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KVideo(),

                    KMimeTypeAsf(), KMimeTypeAsf() ) ), 

            cmp ) );

    TFileName videos = PathInfo::VideosPath();

    TFileName phonePath = PathInfo::PhoneMemoryRootPath();

    phonePath.Append( videos );

    iPhoneVideosPath = phonePath.AllocL();

    TFileName mmcPath = PathInfo::MemoryCardRootPath();

    mmcPath.Append( videos );

    iMmcVideosPath = mmcPath.Right( mmcPath.Length() - 1 ).AllocL();

    iMediaIdUtil = &RMediaIdUtil::GetInstanceL();

    }

// ---------------------------------------------------------------------------

// GetObjectType

// ---------------------------------------------------------------------------

//

void CHarvesterVideoPlugin::GetObjectType( const TDesC& aUri, TDes& aObjectType )

	{

	aObjectType.Zero();

	const THarvestingHandling* mapping = FindHandler( aUri );

	// no matching extension found

	if( !mapping )

		{

		return;

		}

	const TVideoMetadataHandling& handler = mapping->iHandler;

    // object def is defined by extension

    if( handler.iObjectDef.Length() > 0 )

    	{

    	aObjectType.Copy( handler.iObjectDef );

    	return;

    	}

    RFile64 file;

    // File must not be allowed to be written to here. If file passes through 

    // here while it is still open for writing, it will fail in actual harvesting

    // and will not be processed again until the file is modified

    const TInt error = file.Open( iFs, aUri, EFileRead | EFileShareReadersOnly  );

    if ( error != KErrNone )

        {

        WRITELOG1( "CHarvesterVideoPlugin::GetObjectType - File open error: %d", error );

            {

#ifdef _DEBUG

            TPtrC fileName( aUri.Mid(2) );

            WRITELOG1( "CHarvesterVideoPlugin :: Checking open file handles to %S", &fileName );

            CFileList* fileList = 0;

            TOpenFileScan fileScan( iFs );

            TRAP_IGNORE( fileScan.NextL( fileList ) );   

            while ( fileList )   

                {

                const TInt count( fileList->Count() ); 

                for (TInt i = 0; i < count; i++ )   

                    {   

                    if ( (*fileList)[i].iName == aUri.Mid(2) )

                        {

                        TFullName processName;

                        TFindThread find(_L("*"));

                        while( find.Next( processName ) == KErrNone )

                            {

                            RThread thread;

                            TInt err = thread.Open( processName );

                            if ( err == KErrNone )

                                {

                                if ( thread.Id().Id() ==  fileScan.ThreadId() )

                                    {

                                    processName = thread.Name();

                                    thread.Close();

                                    WRITELOG1( "CHarvesterVideoPlugin:: %S has a file handle open", &processName );

                                    break;

                                    }

                                thread.Close();

                                }

                            }

                        }

                    }

                fileList = NULL;

                TRAP_IGNORE( fileScan.NextL( fileList ) );   

                } 

#endif

            aObjectType.Copy( KInUse() );

            }

        return;

        }

    if( handler.iLibrary == TVideoMetadataHandling::EMp4LibHandling )

    	{

    	GetMp4Type( file, aObjectType );

    	}

    else if( handler.iLibrary == TVideoMetadataHandling::EHexilMetadataHandling )

    	{

    	TRAP_IGNORE( GetRmTypeL( file, aObjectType ) );

    	}

    else

    	{

    	WRITELOG1( "CHarvesterVideoPlugin::GetObjectType - ERROR: %S. No handling library found", &aUri );

    	}

    file.Close();

	}

void CHarvesterVideoPlugin::HarvestL( CHarvesterData* aHD )

	{

    CMdEObject& mdeObject = aHD->MdeObject();

    CVideoHarvestData* fileData = new (ELeave) CVideoHarvestData;

    CleanupStack::PushL( fileData );

#ifdef _DEBUG    

    WRITELOG1("CHarvesterVideoPlugin::HarvestL - aHD->Uri() %S", &aHD->Uri() );

    WRITELOG1("CHarvesterVideoPlugin::HarvestL - mdeObject.Uri() %S", &mdeObject.Uri() );

#endif

    TRAPD( error, GatherDataL( mdeObject, *fileData ) );

    if ( error == KErrNone || error == KErrCompletion )

    	{

        TBool isNewObject( mdeObject.Id() == 0 );

        if ( isNewObject || mdeObject.Placeholder() )

            {

            TRAP_IGNORE( HandleObjectPropertiesL( *aHD, *fileData, ETrue ) );

            mdeObject.SetPlaceholder( EFalse );

            }

        else

            {

            TRAP_IGNORE( HandleObjectPropertiesL( *aHD, *fileData, EFalse ) );

            }

    	}

    else

        {

        WRITELOG1( "CHarvesterVideoPlugin::HarvestL() - TRAP error: %d", error );

        TInt convertedError = KErrNone;

        MdsUtils::ConvertTrapError( error, convertedError );

        aHD->SetErrorCode( convertedError );

        }

    CleanupStack::PopAndDestroy( fileData );

	}

// ---------------------------------------------------------------------------

// CHarvesterVideoPlugin::GetMimeType (from CHarvesterPlugin)

// ---------------------------------------------------------------------------

//    

void CHarvesterVideoPlugin::GetMimeType( const TDesC& aUri, TDes& aMimeType )

    {

    aMimeType.Zero();

    const THarvestingHandling* mapping = FindHandler( aUri );

    // no matching extension found

    if( !mapping )

        {

        return;

        }

    aMimeType = mapping->iMimeType;

    }

// ---------------------------------------------------------------------------

// GatherDataL

// ---------------------------------------------------------------------------

//

void CHarvesterVideoPlugin::GatherDataL( CMdEObject& aMetadataObject,

		CVideoHarvestData& aVHD )

    {

#ifdef _DEBUG

    TTime dStart, dStop;

    dStart.UniversalTime();

    dStop.UniversalTime();

    WRITELOG1( "CHarvesterVideoPlugin::GatherDataL start %d us", (TInt)dStop.MicroSecondsFrom(dStart).Int64() );

#endif

    const TDesC& uri = aMetadataObject.Uri();

    WRITELOG1( "CHarvesterVideoPlugin - Gather data from file %S", &uri );

    RFile64 file;

    TInt error = file.Open( iFs, uri, EFileRead | EFileShareReadersOnly );

    CleanupClosePushL( file );

    if ( error == KErrInUse ||

         error == KErrLocked )

        {

        WRITELOG( "CHarvesterVideoPlugin - File is open!" );

#ifdef _DEBUG

            TPtrC fileName( uri.Mid(2) );

            WRITELOG1( "CHarvesterVideoPlugin :: Checking open file handles to %S", &fileName );

            CFileList* fileList = 0;

            TOpenFileScan fileScan( iFs );

            fileScan.NextL( fileList );   

            while ( fileList )   

                {

                const TInt count( fileList->Count() ); 

                for (TInt i = 0; i < count; i++ )   

                    {   

                    if ( (*fileList)[i].iName == uri.Mid(2) )

                        {

                        TFullName processName;

                        TFindThread find(_L("*"));

                        while( find.Next( processName ) == KErrNone )

                            {

                            RThread thread;

                            TInt err = thread.Open( processName );

                            if ( err == KErrNone )

                                {

                                if ( thread.Id().Id() ==  fileScan.ThreadId() )

                                    {

                                    processName = thread.Name();

                                    thread.Close();

                                    WRITELOG1( "CHarvesterVideoPlugin:: %S has a file handle open", &processName );

                                    break;

                                    }

                                thread.Close();

                                }