--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/mmf_adaptation/cmetadatautilityitf.cpp Fri May 14 16:22:35 2010 +0300
@@ -0,0 +1,996 @@
+/*
+* 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 NULL;
+}
+
+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 NULL;
+}
+
+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;
+ }
+}
+