/*
* Copyright (c) 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:
*
*/
#include "cmetadatautilityitf.h"
#include <OpenMAXAL.h>
#include <string.h>
#include <ctype.h>
#include <uri8.h>
#include "profileutilmacro.h"
CMetadataUtilityItf::CMetadataUtilityItf():m_pS60Util(NULL), m_pHXUtil(NULL)
{
}
CMetadataUtilityItf::~CMetadataUtilityItf()
{
if(m_pS60Util)
{
delete m_pS60Util;
}
if(m_pHXUtil)
{
delete m_pHXUtil;
}
}
CMetadataUtilityItf* CMetadataUtilityItf::New(char* uri)
{
CMetadataUtilityItf* p_mdutilitf = new CMetadataUtilityItf;
TInt ret = p_mdutilitf->ParseSource(uri);
if(ret == KErrNone)
{
return p_mdutilitf;
}
delete p_mdutilitf;
return NULL;
}
TInt CMetadataUtilityItf::OpenSource(char* pOrigUri)
{
//Make a local copy for uri
if ( !pOrigUri )
return XA_RESULT_PARAMETER_INVALID;
int uriLen = strlen(pOrigUri);
char* uri = new char[uriLen+1];
if (! uri )
{
return XA_RESULT_MEMORY_FAILURE;
}
strncpy(uri, pOrigUri, uriLen);
uri[uriLen] = '\0';
//
_LIT8(KFileSlash,"file://");
TInt fileslashlen = KFileSlash().Length();
TPtr8 fileuri((TUint8*)uri, strlen(uri),strlen(uri));
TPtr8 filepath = fileuri.RightTPtr(strlen(uri)-fileslashlen);
TInt pos = filepath.LocateReverse(':');
if(pos != KErrNotFound)
{
fileuri.Delete(fileslashlen+pos,1);
}
TUriParser8 localfileUri;
TInt ret = localfileUri.Parse(fileuri);
if(ret == KErrNone)
{
HBufC* file = NULL;
TRAP(ret,file = localfileUri.GetFileNameL());
if(ret == KErrNone)
{
if(m_pS60Util)
{
ret = m_pS60Util->ParseSource(*file);
}
else if(m_pHXUtil)
{
ret = m_pHXUtil->ParseSource(*file);
}
else
{
ret = KErrNotFound;
}
}
delete file;
}
if(uri)
{
delete []uri;
}
return ret;
}
TInt CMetadataUtilityItf::ExtractUCS2(TDesC& inDes, char* outPtr,TInt maxLen)
{
TPtrC tempPtr = inDes.Left((maxLen/2)-1); //save last one for null terminator
TInt outLen = tempPtr.Length() + 1;
TPtr16 outDes((unsigned short*)outPtr, outLen);
outDes.Copy(tempPtr);
outDes.ZeroTerminate();
return outLen * 2; //return size
}
TInt CMetadataUtilityItf::CalculateNumMetadataItems(TUint*numItems)
{
if(m_pS60Util)
{
return m_pS60Util->CalculateNumMetadataItems(numItems);
}
else
{
return m_pHXUtil->CalculateNumMetadataItems(numItems);
}
}
char* CMetadataUtilityItf::GetKey(TInt index)
{
if(m_pS60Util)
{
return m_pS60Util->GetKey(index);
}
else
{
return m_pHXUtil->GetKey(index);
}
}
TInt CMetadataUtilityItf::GetValueSize(TInt index)
{
if(m_pS60Util)
{
return m_pS60Util->GetValueSize(index);
}
else
{
return m_pHXUtil->GetValueSize(index);
}
}
TInt CMetadataUtilityItf::GetValue(TInt index, char* data, TInt maxLength, TInt* outSize, TInt* encodingType)
{
if(m_pS60Util)
{
return m_pS60Util->GetValue(index, data, maxLength, outSize, encodingType);
}
else
{
return m_pHXUtil->GetValue(index, data, maxLength, outSize, encodingType);
}
}
TInt CMetadataUtilityItf::ParseSource(char* uri)
{
char* tempPtr = NULL;
char extension[MAX_EXTENSION_SIZE] = { 0 };
tempPtr = strchr(uri, (int)'.');
strncpy(extension,tempPtr,sizeof(tempPtr));
for(unsigned int i=0;i<sizeof(extension);i++)
{
extension[i] = tolower(extension[i]);
}
//if s60 util in use
if(m_pS60Util)
{
//reset existing instace
TInt ret = m_pS60Util->Reset();
if(!CS60MetadataUtilityItf::IsSupportedExtension(extension))
{
delete m_pS60Util;
m_pS60Util = NULL;
}
}
if(m_pHXUtil)
{
//reset existing instace
TInt ret = m_pHXUtil->Reset();
if(CS60MetadataUtilityItf::IsSupportedExtension(extension))
{
delete m_pHXUtil;
m_pHXUtil = NULL;
}
}
if(!m_pS60Util && !m_pHXUtil)
{
if(CS60MetadataUtilityItf::IsSupportedExtension(extension))
{
m_pS60Util = CS60MetadataUtilityItf::New();
}
else
{
m_pHXUtil = CHXMetadataUtilityItf::New();
}
}
return OpenSource(uri);
}
bool CS60MetadataUtilityItf::IsSupportedExtension(char *extn)
{
if( (!strcasecmp(extn, ".mp3")) ||
(!strcasecmp(extn, ".wma")) ||
(!strcasecmp(extn, ".aac")) ||
(!strcasecmp(extn, ".wav")) ||
(!strcasecmp(extn, ".m4a")))
{
return true;
}
return false;
}
CS60MetadataUtilityItf* CS60MetadataUtilityItf::New()
{
CS60MetadataUtilityItf* self = new CS60MetadataUtilityItf();
TInt err = KErrGeneral;
TRAP(err, self->ConstructL());
if(err == KErrNone)
{
return self;
}
delete self;
return NULL;
}
CS60MetadataUtilityItf::CS60MetadataUtilityItf():pMetaDataUtility(NULL)
{
}
void CS60MetadataUtilityItf::ConstructL()
{
TAG_TIME_PROFILING_BEGIN;
pMetaDataUtility = CMetaDataUtility::NewL();
TAG_TIME_PROFILING_END;
PRINT_TO_CONSOLE_TIME_DIFF;
}
CS60MetadataUtilityItf::~CS60MetadataUtilityItf()
{
if(pMetaDataUtility)
{
TInt err = KErrGeneral;
TAG_TIME_PROFILING_BEGIN;
TRAP(err, pMetaDataUtility->ResetL());
delete pMetaDataUtility;
TAG_TIME_PROFILING_END;
PRINT_TO_CONSOLE_TIME_DIFF;
}
pMetaDataUtility = NULL;
}
TInt CS60MetadataUtilityItf::ParseSource(TDesC& fileName)
{
TInt err = KErrGeneral;
if(pMetaDataUtility)
{
TAG_TIME_PROFILING_BEGIN;
//open with the file handle
TRAP(err, pMetaDataUtility->OpenFileL(fileName));
TAG_TIME_PROFILING_END;
PRINT_TO_CONSOLE_TIME_DIFF;
if(err == KErrNone)
{
uNumMetadataItems = pMetaDataUtility->MetaDataCount();
}
}
return err;
}
TInt CS60MetadataUtilityItf::CalculateNumMetadataItems(TUint* numItems)
{
TInt err = KErrGeneral;
if(pMetaDataUtility && numItems)
{
*numItems = uNumMetadataItems;
err = KErrNone;
}
return err;
}
char* CS60MetadataUtilityItf::KeyMapping(TMetaDataFieldId fldID)
{
switch(fldID)
{
case EMetaDataSongTitle:
{
return "KhronosTitle";
}
case EMetaDataArtist:
{
return "KhronosArtist";
}
case EMetaDataAlbum:
{
return "KhronosAlbum";
}
case EMetaDataYear:
{
return "KhronosYear";
}
case EMetaDataComment:
{
return "KhronosComment";
}
case EMetaDataAlbumTrack:
{
return "KhronosTrackNumber";
}
case EMetaDataGenre:
{
return "KhronosGenre";
}
case EMetaDataComposer:
{
return "Composer"; //Non Standard
}
case EMetaDataCopyright:
{
return "KhronosCopyright";
}
case EMetaDataOriginalArtist:
{
return "Original Artist"; //Non Standard
}
case EMetaDataUserUrl:
case EMetaDataUrl:
{
return "KhronosContentURL";
}
case EMetaDataJpeg:
{
return "attachedpicture";//"KhronosAlbumArtJPEG";
}
case EMetaDataVendor:
{
return "Vendor"; //Non Standard
}
case EMetaDataRating:
{
return "KhronosRating";
}
case EMetaDataDuration:
{
return "Duration"; //Non Standard
}
default:
{
}
}
return "UnSupported";
}
TInt CS60MetadataUtilityItf::ValueEncoding(TMetaDataFieldId fldID)
{
switch(fldID)
{
case EMetaDataJpeg:
{
return CMetadataUtilityItf::EBinaryEncoding;
}
case EMetaDataSongTitle:
case EMetaDataArtist:
case EMetaDataAlbum:
case EMetaDataYear:
case EMetaDataComment:
case EMetaDataAlbumTrack:
case EMetaDataGenre:
case EMetaDataComposer:
case EMetaDataCopyright:
case EMetaDataOriginalArtist:
case EMetaDataUserUrl:
case EMetaDataUrl:
case EMetaDataVendor:
case EMetaDataRating:
case EMetaDataDuration:
default:
{
return CMetadataUtilityItf::EUnicodeEncoding;
}
}
}
char* CS60MetadataUtilityItf::GetKey(TInt index)
{
if(pMetaDataUtility && index < uNumMetadataItems)
{
TMetaDataFieldId fieldId;
TAG_TIME_PROFILING_BEGIN;
TInt err = KErrGeneral;
TRAP(err, pMetaDataUtility->MetaDataFieldsL().FieldIdAt( index, fieldId ));
TAG_TIME_PROFILING_END;
PRINT_TO_CONSOLE_TIME_DIFF;
if((err == KErrNone) && (fieldId != EUnknownMetaDataField))
{
return KeyMapping(fieldId);
}
}
return NULL;
}
TInt CS60MetadataUtilityItf::GetValueSize(TInt index)
{
if(pMetaDataUtility && index < uNumMetadataItems)
{
TMetaDataFieldId fieldId;
TInt err = KErrGeneral;
TRAP(err, pMetaDataUtility->MetaDataFieldsL().FieldIdAt( index, fieldId ));
if((err == KErrNone) && (fieldId != EUnknownMetaDataField))
{
const CMetaDataFieldContainer* iContainer = NULL;
TRAP(err, iContainer = &pMetaDataUtility->MetaDataFieldsL());
if(err == KErrNone)
{
if(ValueEncoding(fieldId) == CMetadataUtilityItf::EUnicodeEncoding)
{
TPtrC field = iContainer->Field( fieldId );
if(field != KNullDesC)
{
return field.Size() + 2; //additional character (two bytes) for null terminator
}
}
else //Binary
{
TPtrC8 field8 = iContainer->Field8( fieldId );
if(field8 != KNullDesC8)
{
return field8.Size();
}
}
}
}
}
return 0;
}
TInt CS60MetadataUtilityItf::GetValue(TInt index, char* data, TInt maxLength, //in params
TInt* outSize, TInt* encodingType) //out params
{
TInt retValueSize = 0;
*encodingType= CMetadataUtilityItf::EUnknownEncoding;
if(pMetaDataUtility && index < uNumMetadataItems)
{
TMetaDataFieldId fieldId;
TInt err = KErrGeneral;
TRAP(err, pMetaDataUtility->MetaDataFieldsL().FieldIdAt( index, fieldId ));
if((err==KErrNone) && (fieldId != EUnknownMetaDataField))
{
const CMetaDataFieldContainer* iContainer = NULL;
TRAP(err, iContainer = &pMetaDataUtility->MetaDataFieldsL());
if(err == KErrNone)
{
*encodingType = ValueEncoding(fieldId);
if(*encodingType == CMetadataUtilityItf::EUnicodeEncoding)
{
TAG_TIME_PROFILING_BEGIN;
TPtrC field = iContainer->Field( fieldId );
TAG_TIME_PROFILING_END;
PRINT_TO_CONSOLE_TIME_DIFF;
if(field != KNullDesC)
{
*outSize = CMetadataUtilityItf::ExtractUCS2(field, data, maxLength);
retValueSize = field.Size() + 2; //actual size
}
}
else //Binary
{
TAG_TIME_PROFILING_BEGIN;
TPtrC8 field8 = iContainer->Field8( fieldId );
TAG_TIME_PROFILING_END;
PRINT_TO_CONSOLE_TIME_DIFF;
if(field8 != KNullDesC8)
{
*outSize = (maxLength > field8.Size())?field8.Size():maxLength;
memcpy(data, field8.Ptr(), *outSize);
retValueSize = field8.Size();
}
}
}
}
}
return retValueSize;
}
TInt CS60MetadataUtilityItf::Reset()
{
TInt err = KErrNone;
if(pMetaDataUtility)
{
TRAP(err, pMetaDataUtility->ResetL());
}
return err;
}
CHXMetadataUtilityItf::CHXMetadataUtilityItf():pHXMetaDataUtility(NULL)
{
}
void CHXMetadataUtilityItf::ConstructL()
{
TAG_TIME_PROFILING_BEGIN;
pHXMetaDataUtility = CHXMetaDataUtility::NewL();
TAG_TIME_PROFILING_END;
PRINT_TO_CONSOLE_TIME_DIFF;
}
CHXMetadataUtilityItf* CHXMetadataUtilityItf::New()
{
CHXMetadataUtilityItf* self = new CHXMetadataUtilityItf();
if(self)
{
TInt err = KErrGeneral;
TRAP(err, self->ConstructL());
if(err != KErrNone)
{
delete self;
self = NULL;
}
}
return self;
}
CHXMetadataUtilityItf::~CHXMetadataUtilityItf()
{
if(pHXMetaDataUtility)
{
TInt err = KErrGeneral;
TAG_TIME_PROFILING_BEGIN;
TRAP(err, pHXMetaDataUtility->ResetL());
delete pHXMetaDataUtility;
TAG_TIME_PROFILING_END;
PRINT_TO_CONSOLE_TIME_DIFF;
}
pHXMetaDataUtility = NULL;
}
TInt CHXMetadataUtilityItf::Reset()
{
TInt err = KErrNone;
if(pHXMetaDataUtility)
{
TRAP(err, pHXMetaDataUtility->ResetL());
}
return err;
}
TInt CHXMetadataUtilityItf::ParseSource(TDesC& fileName)
{
TInt err = KErrGeneral;
if(pHXMetaDataUtility)
{
//open with the file handle
TAG_TIME_PROFILING_BEGIN;
TRAP(err, pHXMetaDataUtility->OpenFileL(fileName));
TAG_TIME_PROFILING_END;
PRINT_TO_CONSOLE_TIME_DIFF;
if(err == KErrNone)
{
return pHXMetaDataUtility->GetMetaDataCount(uNumMetadataItems);
}
}
return err;
}
TInt CHXMetadataUtilityItf::CalculateNumMetadataItems(TUint* numItems)
{
TInt err = KErrGeneral;
if(pHXMetaDataUtility && numItems)
{
*numItems = uNumMetadataItems;
err = KErrNone;
}
return err;
}
char* CHXMetadataUtilityItf::KeyMapping(HXMetaDataKeys::EHXMetaDataId fldID)
{
switch(fldID)
{
case HXMetaDataKeys::EHXTitle:
{
return "KhronosTitle";
}
case HXMetaDataKeys::EHXPerformer:
{
return "KhronosArtist";
}
case HXMetaDataKeys::EHXDescription:
{
return "KhronosComment";
}
case HXMetaDataKeys::EHXGenre:
{
return "KhronosGenre";
}
case HXMetaDataKeys::EHXAuthor:
{
return "Composer"; //Non Standard
}
case HXMetaDataKeys::EHXCopyright:
{
return "KhronosCopyright";
}
case HXMetaDataKeys::EHXContentURI:
{
return "KhronosContentURL";
}
case HXMetaDataKeys::EHXDuration:
{
return "Duration"; //Non Standard
}
case HXMetaDataKeys::EHXClipBitRate:
{
return "ClipBitRate"; //non-standard
}
case HXMetaDataKeys::EHXVideoBitRate:
{
return "VideoBitRate"; // non-standard
}
case HXMetaDataKeys::EHXAudioBitRate:
{
return "AudioBitRate";
}
case HXMetaDataKeys::EHXCodec:
{
return "Codec";
}
case HXMetaDataKeys::EHXFrameSize:
{
return "Resolution";
}
case HXMetaDataKeys::EHXFramesPerSecond:
{
return "FrameRate";
}
case HXMetaDataKeys::EHXStreamCount:
{
return "Stream Count";
}
case HXMetaDataKeys::EHXLiveStream:
{
return "Live Stream";
}
case HXMetaDataKeys::EHXSeekable:
{
return "Seekable";
}
case HXMetaDataKeys::EHXContentType:
{
return "Content Type";
}
case HXMetaDataKeys::EHXFormat:
{
return "Format";
}
case HXMetaDataKeys::EHXQuality:
{
return "Quality";
}
case HXMetaDataKeys::EHXAbstract:
{
return "Abstract";
}
case HXMetaDataKeys::EHXMimeType:
{
return "MimeType";
}
case HXMetaDataKeys::EHXIconURI:
{
return "Icon URI";
}
case HXMetaDataKeys::EHXEPreviewURI:
{
return "Preview URI";
}
case HXMetaDataKeys::EHXContentID:
{
return "Content ID";
}
case HXMetaDataKeys::EHXInfoURL:
{
return "Info URL";
}
default:
{
}
}
return "UnSupported";
}
TInt CHXMetadataUtilityItf::ValueEncoding(HXMetaDataKeys::EHXMetaDataId fldID)
{
switch(fldID)
{
default:
{
return CMetadataUtilityItf::EUnicodeEncoding;
}
}
}
char* CHXMetadataUtilityItf::GetKey(TInt index)
{
if(pHXMetaDataUtility && index < uNumMetadataItems)
{
HXMetaDataKeys::EHXMetaDataId id;
HBufC* pDes;
TAG_TIME_PROFILING_BEGIN;
TInt err = pHXMetaDataUtility->GetMetaDataAt(index, id, pDes);
TAG_TIME_PROFILING_END;
PRINT_TO_CONSOLE_TIME_DIFF;
if(err == KErrNone)
{
return KeyMapping(id);
}
}
return NULL;
}
TInt CHXMetadataUtilityItf::GetValueSize(TInt index)
{
if(pHXMetaDataUtility && index < uNumMetadataItems)
{
HXMetaDataKeys::EHXMetaDataId id;
HBufC* pDes;
TInt err = pHXMetaDataUtility->GetMetaDataAt(index, id, pDes);
if(err == KErrNone)
{
if(ValueEncoding(id) == CMetadataUtilityItf::EUnicodeEncoding)
{
return pDes->Size() + 2; //additional character (two bytes) for null terminator
}
else //Binary
{
//no support
}
}
}
return 0;
}
TInt CHXMetadataUtilityItf::GetValue(TInt index, char* data, TInt maxLength, //in params
TInt* outSize, TInt* encodingType) //out params
{
TInt retValueSize = 0;
*encodingType= CMetadataUtilityItf::EUnknownEncoding;
if(pHXMetaDataUtility && index < uNumMetadataItems)
{
HXMetaDataKeys::EHXMetaDataId id;
HBufC* pDes;
TAG_TIME_PROFILING_BEGIN;
TInt err = pHXMetaDataUtility->GetMetaDataAt(index, id, pDes);
TAG_TIME_PROFILING_END;
PRINT_TO_CONSOLE_TIME_DIFF;
*encodingType = ValueEncoding(id);
if(err == KErrNone)
{
if(*encodingType == CMetadataUtilityItf::EUnicodeEncoding)
{
*outSize = CMetadataUtilityItf::ExtractUCS2(*pDes, data, maxLength);
retValueSize = pDes->Size() + 2; //actual Size
}
else //Binary
{
//no support
}
}
}
return retValueSize;
}
extern "C" {
void* mmf_metadata_utility_init(char* uri)
{
return CMetadataUtilityItf::New(uri);
}
void mmf_metadata_utility_destroy(void* context)
{
delete ((CMetadataUtilityItf*)context);
}
XAresult mmf_metadata_utility_parse_source(void* context, char* uri)
{
TInt err = ((CMetadataUtilityItf*)context)->ParseSource(uri);
if(err == KErrNone)
{
return XA_RESULT_SUCCESS;
}
return XA_RESULT_PARAMETER_INVALID;
}
XAresult mmf_get_item_count(void* context, XAuint32* itemCount)
{
if(itemCount)
{
TInt err = ((CMetadataUtilityItf*)(context))->CalculateNumMetadataItems((TUint *)itemCount);
if(err == KErrNone)
{
return XA_RESULT_SUCCESS;
}
}
return XA_RESULT_PARAMETER_INVALID;
}
XAresult mmf_get_key_size(void* context, XAuint32 keyIndex, XAuint32* keySize)
{
char* key = ((CMetadataUtilityItf*)(context))->GetKey(keyIndex);
if(key && keySize)
{
*keySize = (strlen(key) + sizeof(XAMetadataInfo));
return XA_RESULT_SUCCESS;
}
return XA_RESULT_PARAMETER_INVALID;
}
XAresult mmf_get_key(void* context, XAuint32 index,XAuint32 keySize, XAMetadataInfo *pKey)
{
XAresult ret = XA_RESULT_PARAMETER_INVALID;
TInt keyDataSize = keySize - sizeof(XAMetadataInfo) + 1;
char* ascKey = ((CMetadataUtilityItf*)(context))->GetKey(index);
if(ascKey && keyDataSize)
{
TInt ascKeySize = strlen(ascKey);
TInt outSize = (ascKeySize >= keyDataSize) ? (keyDataSize - 1) : ascKeySize;
pKey->size = outSize + 1;
pKey->encoding = XA_CHARACTERENCODING_ASCII;
strcpy((char *)(pKey->langCountry), "en-us");
strncpy((char *)(pKey->data), ascKey, outSize);
pKey->data[outSize] = '\0';
if(ascKeySize >= keyDataSize)
{
ret = XA_RESULT_BUFFER_INSUFFICIENT;
}
else
{
ret = XA_RESULT_SUCCESS;
}
}
ret = XA_RESULT_SUCCESS;
return ret;
}
XAresult mmf_get_value_size(void* context, XAuint32 index, XAuint32 *pValueSize)
{
if(pValueSize)
{
*pValueSize = ((CMetadataUtilityItf*)(context))->GetValueSize(index) + sizeof(XAMetadataInfo) - 1; //XAMetadataInfo already includes one byte for Data
return XA_RESULT_SUCCESS;
}
return XA_RESULT_PARAMETER_INVALID;
}
XAresult mmf_get_value(void* context, XAuint32 index, XAuint32 valueSize, XAMetadataInfo *pValue)
{
XAresult ret = XA_RESULT_PARAMETER_INVALID;
TInt dataSize = valueSize - sizeof(XAMetadataInfo) + 1;
TInt outLen = 0, encodingType = CMetadataUtilityItf::EUnknownEncoding;
if(dataSize > 0)
{
TInt actualDataSize = ((CMetadataUtilityItf*)(context))->GetValue(index, (char*)pValue->data, dataSize, &outLen, &encodingType);
pValue->size = outLen;
pValue->encoding = (encodingType == CMetadataUtilityItf::EUnicodeEncoding) ? XA_CHARACTERENCODING_UTF16LE : XA_CHARACTERENCODING_BINARY;
strcpy((char *)(pValue->langCountry), "en-us");
if(!actualDataSize)
{
return XA_RESULT_INTERNAL_ERROR;
}
if(actualDataSize > dataSize)
{
ret = XA_RESULT_BUFFER_INSUFFICIENT;
}
else
{
ret = XA_RESULT_SUCCESS;
}
}
return ret;
}
}