/*

* 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 "mdsutils.h"

#include "harvestervideoplugin.h"

#include "harvesterlog.h"

#include "harvesterblacklist.h"

#include "mdeobjectwrapper.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( 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(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;

CHarvesterVideoPluginPropertyDefs::CHarvesterVideoPluginPropertyDefs() : CBase()

	{

	}

void CHarvesterVideoPluginPropertyDefs::ConstructL(CMdEObjectDef& aObjectDef)

	{

	CMdENamespaceDef& nsDef = aObjectDef.NamespaceDef();

	// Common property definitions

	CMdEObjectDef& objectDef = nsDef.GetObjectDefL( Object::KBaseObject );

	iCreationDatePropertyDef = &objectDef.GetPropertyDefL( Object::KCreationDateProperty );

	iLastModifiedDatePropertyDef = &objectDef.GetPropertyDefL( Object::KLastModifiedDateProperty );

	iSizePropertyDef = &objectDef.GetPropertyDefL( Object::KSizeProperty );

	iTimeOffsetPropertyDef = &objectDef.GetPropertyDefL( Object::KTimeOffsetProperty );

	iItemTypePropertyDef = &objectDef.GetPropertyDefL( Object::KItemTypeProperty );

	CMdEObjectDef& mediaDef = nsDef.GetObjectDefL( MediaObject::KMediaObject );

	iReleaseDatePropertyDef = &mediaDef.GetPropertyDefL( MediaObject::KReleaseDateProperty );

	iCaptureDatePropertyDef = &mediaDef.GetPropertyDefL( MediaObject::KCaptureDateProperty );

	iDurationPropertyDef = &mediaDef.GetPropertyDefL( MediaObject::KDurationProperty );

	iWidthPropertyDef = &mediaDef.GetPropertyDefL( MediaObject::KWidthProperty );

	iHeightPropertyDef = &mediaDef.GetPropertyDefL( MediaObject::KHeightProperty );

	iBitratePropertyDef = &mediaDef.GetPropertyDefL( MediaObject::KBitrateProperty );

	iCopyrightPropertyDef = &mediaDef.GetPropertyDefL( MediaObject::KCopyrightProperty );

	iAuthorPropertyDef = &mediaDef.GetPropertyDefL( MediaObject::KAuthorProperty );

	iGenrePropertyDef = &mediaDef.GetPropertyDefL( MediaObject::KGenreProperty );

	iArtistPropertyDef = &mediaDef.GetPropertyDefL( MediaObject::KArtistProperty );

	iDescriptionPropertyDef = &mediaDef.GetPropertyDefL( MediaObject::KDescriptionProperty );

	iAudioFourCCDef = &mediaDef.GetPropertyDefL( MediaObject::KAudioFourCCProperty );

	// Video property definitions

	CMdEObjectDef& videoDef = nsDef.GetObjectDefL( Video::KVideoObject );

	iFrameratePropertyDef = &videoDef.GetPropertyDefL( Video::KFramerateProperty );

	// Audio property definitions

	CMdEObjectDef& audioDef = nsDef.GetObjectDefL( Audio::KAudioObject );

	iSamplingFrequencyPropertyDef = &audioDef.GetPropertyDefL( Audio::KSamplingFrequencyProperty );

	}

CHarvesterVideoPluginPropertyDefs* CHarvesterVideoPluginPropertyDefs::NewL(CMdEObjectDef& aObjectDef)

	{

	CHarvesterVideoPluginPropertyDefs* self = 

		new (ELeave) CHarvesterVideoPluginPropertyDefs();

	CleanupStack::PushL( self );

	self->ConstructL( aObjectDef );

	CleanupStack::Pop( self );

	return self;

	}

/**

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

	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::EMp4LibHandling, KNullDesC(),

    				KMimeTypeVideoMp4(), KMimeTypeAudioMp4() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtensionMpg4(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EMp4LibHandling, KNullDesC(),

    				KMimeTypeVideoMp4(), KMimeTypeAudioMp4() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtensionMpeg4(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EMp4LibHandling, KNullDesC(),

    				KMimeTypeVideoMp4(), KMimeTypeAudioMp4() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtensionM4v(), KMimeTypeVideoMp4(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EMp4LibHandling, KVideo(),

    				KMimeTypeVideoMp4(), KMimeTypeAudioMp4() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtensionM4a(), KMimeTypeAudioMp4(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EMp4LibHandling, KAudio(),

    				KMimeTypeVideoMp4(), KMimeTypeAudioMp4() ) ), 

    		cmp ) );

	// 3GP

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtension3gp(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EMp4LibHandling, KNullDesC(),

    				KMimeTypeVideo3gpp(), KMimeTypeAudio3gpp() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtension3gpp(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EMp4LibHandling, KNullDesC(),

    				KMimeTypeVideo3gpp(), KMimeTypeAudio3gpp() ) ), 

    		cmp ) );

	User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

    		KExtension3g2(), KNullDesC(), 

    		TVideoMetadataHandling( TVideoMetadataHandling::EMp4LibHandling, 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 ) );

    // Matroska

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( THarvestingHandling(

            KExtensionMkv(), KNullDesC(), 

            TVideoMetadataHandling( TVideoMetadataHandling::EHexilMetadataHandling, KNullDesC(),

                    KMimeTypeVideoMatroska(), KMimeTypeAudioMatroska() ) ), 

            cmp ) );

    }

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

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

        if( error == KErrInUse )

            {

            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::HarvestSingleFileL() - TRAP error: %d", error );

        TInt convertedError = KErrNone;

        MdsUtils::ConvertTrapError( error, convertedError );

        aHD->SetErrorCode( convertedError );

        }

    CleanupStack::PopAndDestroy( fileData );

	}

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

// GatherDataL

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

//

void CHarvesterVideoPlugin::GatherDataL( CMdEObject& aMetadataObject,

		CVideoHarvestData& aVHD )

    {

    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!" );

        CleanupStack::PopAndDestroy( &file );

        User::Leave( KErrInUse );

        }

    else if( error == KErrNotFound ||

                error == KErrPathNotFound ||

                error == KErrDisMounted ||

                error == KErrBadDescriptor )

        {

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

        CleanupStack::PopAndDestroy( &file );

        User::Leave( error );

        }

    TBool dataExtracted( aMetadataObject.Id() == 0 || aMetadataObject.Placeholder() );

    if( dataExtracted )

        {

        CMdEProperty* prop = NULL;

        CMdEObjectDef& objectDef = aMetadataObject.Def();

        CMdEPropertyDef& sizeDef = objectDef.GetPropertyDefL( MdeConstants::Object::KSizeProperty );

        aMetadataObject.Property( sizeDef, prop );

        if( prop )

            {

            aVHD.iFileSize  = prop->Uint32ValueL();

            }

        else

            {

            dataExtracted = EFalse;

            }

        CMdEPropertyDef& modifiedDef = objectDef.GetPropertyDefL( MdeConstants::Object::KLastModifiedDateProperty );

        aMetadataObject.Property( modifiedDef, prop );

        if( prop )

            {

            aVHD.iModified  = prop->TimeValueL();

            }

        else

            {

            dataExtracted = EFalse;

            }

        }

    if( !dataExtracted )

        {

        TEntry entry;

        const TInt errorcode = iFs.Entry( uri, entry );

        if ( errorcode != KErrNone )

            {

            WRITELOG1( "CHarvesterVideoPlugin - Error getting entry: %d", errorcode );

            CleanupStack::PopAndDestroy( &file );

            User::Leave( errorcode );

            }

        aVHD.iModified = entry.iModified;

        aVHD.iFileSize = (TUint)entry.iSize;

        }

    WRITELOG1( "CHarvesterVideoPlugin - File size: %d", aVHD.iFileSize );

    // now the minimum information has been harvested

    // from now on the harvested data should always be stored

    const THarvestingHandling* mapping = FindHandler( uri );

    if( !mapping )

    	{

    	CleanupStack::PopAndDestroy( &file );

    	User::Leave( KErrNotFound );

    	}

    aVHD.iVideoObject = aMetadataObject.Def().Name().Compare( KVideo ) == 0;

    if( error != KErrNone )

        {

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

        CleanupStack::PopAndDestroy( &file );

        User::Leave( KErrCompletion );

        }

    if ( mapping->iHandler.iLibrary == TVideoMetadataHandling::EHexilMetadataHandling )

    	{

    	// doesn't own pointers to MIME types

    	RPointerArray<HBufC> mimes;

    	CleanupClosePushL( mimes );

    	CHXMetaDataUtility* helixMetadata = CHXMetaDataUtility::NewL();

        CleanupStack::PushL( helixMetadata );

        TRAP( error, helixMetadata->OpenFileL( file ) );        

        if ( error == KErrNone )

        	{

        	HBufC *buf = NULL;

        	HXMetaDataKeys::EHXMetaDataId metaid;        	

        	TUint metacount = 0;

        	helixMetadata->GetMetaDataCount( metacount );

        	TLex lex;

        	for ( TUint i = 0; i < metacount; i++ )

        		{        		

        		helixMetadata->GetMetaDataAt( i, metaid, buf );

        		switch (metaid)

        			{

        			case HXMetaDataKeys::EHXVideoBitRate:

	        			{

        				WRITELOG( "CHarvesterVideoPlugin - found videobitrate" );

	        			if( aVHD.iVideoObject )

	        				{

	        				lex.Assign( *buf );

	        				if( KErrNone == lex.Val( aVHD.iVideoBitrate ) )

	        					{

	        					aVHD.iVideoBitrate /= KKiloBytes;

	        					}

	        				}

	        			break;

	        			}

        			case HXMetaDataKeys::EHXAudioBitRate: