khronosfws/openmax_al/src/mmf_adaptation/cmetadatautilityitf.cpp
author hgs
Fri, 28 May 2010 19:26:28 -0500
changeset 21 2ed61feeead6
parent 20 b67dd1fc57c5
child 25 6f7ceef7b1d1
permissions -rw-r--r--
201021
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
19
hgs
parents:
diff changeset
     1
#include "cmetadatautilityitf.h"
hgs
parents:
diff changeset
     2
#include <OpenMAXAL.h>
hgs
parents:
diff changeset
     3
#include <string.h>
hgs
parents:
diff changeset
     4
#include <ctype.h>
hgs
parents:
diff changeset
     5
#include <uri8.h>
hgs
parents:
diff changeset
     6
#include "profileutilmacro.h"
hgs
parents:
diff changeset
     7
hgs
parents:
diff changeset
     8
CMetadataUtilityItf::CMetadataUtilityItf():m_pS60Util(NULL), m_pHXUtil(NULL)
hgs
parents:
diff changeset
     9
{
hgs
parents:
diff changeset
    10
}
hgs
parents:
diff changeset
    11
hgs
parents:
diff changeset
    12
CMetadataUtilityItf::~CMetadataUtilityItf()
hgs
parents:
diff changeset
    13
{
hgs
parents:
diff changeset
    14
	if(m_pS60Util)
hgs
parents:
diff changeset
    15
	{
hgs
parents:
diff changeset
    16
		delete m_pS60Util;
hgs
parents:
diff changeset
    17
	}
hgs
parents:
diff changeset
    18
hgs
parents:
diff changeset
    19
	if(m_pHXUtil)
hgs
parents:
diff changeset
    20
	{
hgs
parents:
diff changeset
    21
		delete m_pHXUtil;
hgs
parents:
diff changeset
    22
	}
hgs
parents:
diff changeset
    23
}
hgs
parents:
diff changeset
    24
hgs
parents:
diff changeset
    25
hgs
parents:
diff changeset
    26
CMetadataUtilityItf* CMetadataUtilityItf::New(char* uri)
hgs
parents:
diff changeset
    27
{
hgs
parents:
diff changeset
    28
	CMetadataUtilityItf* p_mdutilitf = new CMetadataUtilityItf;
hgs
parents:
diff changeset
    29
	
21
hgs
parents: 20
diff changeset
    30
	p_mdutilitf->ParseSource(uri); //ignore error
19
hgs
parents:
diff changeset
    31
21
hgs
parents: 20
diff changeset
    32
	return p_mdutilitf;
19
hgs
parents:
diff changeset
    33
}
hgs
parents:
diff changeset
    34
hgs
parents:
diff changeset
    35
TInt CMetadataUtilityItf::OpenSource(char* pOrigUri)
hgs
parents:
diff changeset
    36
{
hgs
parents:
diff changeset
    37
    //Make a local copy for uri
hgs
parents:
diff changeset
    38
    if ( !pOrigUri )
hgs
parents:
diff changeset
    39
        return XA_RESULT_PARAMETER_INVALID;
hgs
parents:
diff changeset
    40
    
hgs
parents:
diff changeset
    41
    int uriLen = strlen(pOrigUri);
hgs
parents:
diff changeset
    42
    char* uri = new char[uriLen+1];
hgs
parents:
diff changeset
    43
    if (! uri )
hgs
parents:
diff changeset
    44
        {
hgs
parents:
diff changeset
    45
        return XA_RESULT_MEMORY_FAILURE;
hgs
parents:
diff changeset
    46
        }
hgs
parents:
diff changeset
    47
    strncpy(uri, pOrigUri, uriLen);
hgs
parents:
diff changeset
    48
    uri[uriLen] = '\0';
hgs
parents:
diff changeset
    49
    ////////////////////////////////////////////
hgs
parents:
diff changeset
    50
hgs
parents:
diff changeset
    51
    _LIT8(KFileSlash,"file:///");
hgs
parents:
diff changeset
    52
    TInt fileslashlen = KFileSlash().Length();
hgs
parents:
diff changeset
    53
hgs
parents:
diff changeset
    54
    TPtr8 fileuri((TUint8*)uri, strlen(uri),strlen(uri));
hgs
parents:
diff changeset
    55
    TPtr8 filepath = fileuri.RightTPtr(strlen(uri)-fileslashlen);
hgs
parents:
diff changeset
    56
 
hgs
parents:
diff changeset
    57
    TInt pos = filepath.LocateReverse(':');
hgs
parents:
diff changeset
    58
    if(pos != KErrNotFound)
hgs
parents:
diff changeset
    59
    {
hgs
parents:
diff changeset
    60
        fileuri.Delete(fileslashlen+pos,1);
hgs
parents:
diff changeset
    61
    }
hgs
parents:
diff changeset
    62
hgs
parents:
diff changeset
    63
    TUriParser8 localfileUri;
hgs
parents:
diff changeset
    64
    TInt ret = localfileUri.Parse(fileuri);
hgs
parents:
diff changeset
    65
    if(ret == KErrNone)
hgs
parents:
diff changeset
    66
    {    
hgs
parents:
diff changeset
    67
        HBufC* file = NULL;
hgs
parents:
diff changeset
    68
        TRAP(ret,file = localfileUri.GetFileNameL());  
hgs
parents:
diff changeset
    69
        if(ret == KErrNone)
hgs
parents:
diff changeset
    70
        {
hgs
parents:
diff changeset
    71
        	if(m_pS60Util)
hgs
parents:
diff changeset
    72
        	{
hgs
parents:
diff changeset
    73
            	ret = m_pS60Util->ParseSource(*file);
hgs
parents:
diff changeset
    74
        	}
hgs
parents:
diff changeset
    75
			else if(m_pHXUtil)
hgs
parents:
diff changeset
    76
			{
hgs
parents:
diff changeset
    77
				ret = m_pHXUtil->ParseSource(*file);
hgs
parents:
diff changeset
    78
			}
hgs
parents:
diff changeset
    79
			else
hgs
parents:
diff changeset
    80
			{
hgs
parents:
diff changeset
    81
				ret = KErrNotFound;
hgs
parents:
diff changeset
    82
			}
hgs
parents:
diff changeset
    83
        }
hgs
parents:
diff changeset
    84
        
hgs
parents:
diff changeset
    85
        delete file;
hgs
parents:
diff changeset
    86
    }
hgs
parents:
diff changeset
    87
    
hgs
parents:
diff changeset
    88
    if(uri)
hgs
parents:
diff changeset
    89
    {
hgs
parents:
diff changeset
    90
        delete []uri;
hgs
parents:
diff changeset
    91
    }
21
hgs
parents: 20
diff changeset
    92
hgs
parents: 20
diff changeset
    93
	if(ret != KErrNone)
hgs
parents: 20
diff changeset
    94
	{
hgs
parents: 20
diff changeset
    95
		//delete the utilities
hgs
parents: 20
diff changeset
    96
		if(m_pS60Util)
hgs
parents: 20
diff changeset
    97
		{
hgs
parents: 20
diff changeset
    98
			delete m_pS60Util;
hgs
parents: 20
diff changeset
    99
			m_pS60Util = NULL;
hgs
parents: 20
diff changeset
   100
		}
hgs
parents: 20
diff changeset
   101
hgs
parents: 20
diff changeset
   102
		if(m_pHXUtil)
hgs
parents: 20
diff changeset
   103
		{
hgs
parents: 20
diff changeset
   104
			delete m_pHXUtil;
hgs
parents: 20
diff changeset
   105
			m_pHXUtil = NULL;
hgs
parents: 20
diff changeset
   106
		}
hgs
parents: 20
diff changeset
   107
hgs
parents: 20
diff changeset
   108
		
hgs
parents: 20
diff changeset
   109
	}
19
hgs
parents:
diff changeset
   110
	return ret;
hgs
parents:
diff changeset
   111
}
hgs
parents:
diff changeset
   112
hgs
parents:
diff changeset
   113
TInt CMetadataUtilityItf::ExtractUCS2(TDesC& inDes, char* outPtr,TInt maxLen)
hgs
parents:
diff changeset
   114
{
hgs
parents:
diff changeset
   115
	TPtrC tempPtr = inDes.Left((maxLen/2)-1); //save last one for null terminator
hgs
parents:
diff changeset
   116
	TInt outLen = tempPtr.Length() + 1;
hgs
parents:
diff changeset
   117
	
hgs
parents:
diff changeset
   118
	TPtr16 outDes((unsigned short*)outPtr, outLen);
hgs
parents:
diff changeset
   119
	outDes.Copy(tempPtr);
hgs
parents:
diff changeset
   120
	outDes.ZeroTerminate();
hgs
parents:
diff changeset
   121
hgs
parents:
diff changeset
   122
	return outLen * 2; //return size
hgs
parents:
diff changeset
   123
}
hgs
parents:
diff changeset
   124
hgs
parents:
diff changeset
   125
TInt CMetadataUtilityItf::CalculateNumMetadataItems(TUint*numItems)
hgs
parents:
diff changeset
   126
{
21
hgs
parents: 20
diff changeset
   127
	*numItems = 0;
hgs
parents: 20
diff changeset
   128
	
19
hgs
parents:
diff changeset
   129
	if(m_pS60Util)
hgs
parents:
diff changeset
   130
	{
hgs
parents:
diff changeset
   131
		return m_pS60Util->CalculateNumMetadataItems(numItems);
hgs
parents:
diff changeset
   132
	}
21
hgs
parents: 20
diff changeset
   133
	else if(m_pHXUtil)
19
hgs
parents:
diff changeset
   134
	{
hgs
parents:
diff changeset
   135
		return m_pHXUtil->CalculateNumMetadataItems(numItems);
hgs
parents:
diff changeset
   136
	}
21
hgs
parents: 20
diff changeset
   137
hgs
parents: 20
diff changeset
   138
	return KErrNone;
19
hgs
parents:
diff changeset
   139
}
hgs
parents:
diff changeset
   140
hgs
parents:
diff changeset
   141
char* CMetadataUtilityItf::GetKey(TInt index)
hgs
parents:
diff changeset
   142
{
hgs
parents:
diff changeset
   143
	if(m_pS60Util)
hgs
parents:
diff changeset
   144
	{
hgs
parents:
diff changeset
   145
		return m_pS60Util->GetKey(index);
hgs
parents:
diff changeset
   146
	}
21
hgs
parents: 20
diff changeset
   147
	else if(m_pHXUtil)
19
hgs
parents:
diff changeset
   148
	{
hgs
parents:
diff changeset
   149
		return m_pHXUtil->GetKey(index);
hgs
parents:
diff changeset
   150
	}
21
hgs
parents: 20
diff changeset
   151
hgs
parents: 20
diff changeset
   152
	return NULL;
19
hgs
parents:
diff changeset
   153
}
hgs
parents:
diff changeset
   154
hgs
parents:
diff changeset
   155
TInt CMetadataUtilityItf::GetValueSize(TInt index)
hgs
parents:
diff changeset
   156
{
hgs
parents:
diff changeset
   157
	if(m_pS60Util)
hgs
parents:
diff changeset
   158
	{
hgs
parents:
diff changeset
   159
		return m_pS60Util->GetValueSize(index);
hgs
parents:
diff changeset
   160
	}
21
hgs
parents: 20
diff changeset
   161
	else if(m_pHXUtil)
19
hgs
parents:
diff changeset
   162
	{
hgs
parents:
diff changeset
   163
		return m_pHXUtil->GetValueSize(index);
hgs
parents:
diff changeset
   164
	}
21
hgs
parents: 20
diff changeset
   165
hgs
parents: 20
diff changeset
   166
	return 0;
19
hgs
parents:
diff changeset
   167
}
hgs
parents:
diff changeset
   168
hgs
parents:
diff changeset
   169
TInt CMetadataUtilityItf::GetValue(TInt index, char* data, TInt maxLength, TInt* outSize, TInt* encodingType)
hgs
parents:
diff changeset
   170
{
hgs
parents:
diff changeset
   171
	if(m_pS60Util)
hgs
parents:
diff changeset
   172
	{
hgs
parents:
diff changeset
   173
		return m_pS60Util->GetValue(index, data, maxLength, outSize, encodingType);
hgs
parents:
diff changeset
   174
	}
21
hgs
parents: 20
diff changeset
   175
	else if(m_pHXUtil)
19
hgs
parents:
diff changeset
   176
	{
hgs
parents:
diff changeset
   177
		return m_pHXUtil->GetValue(index, data, maxLength, outSize, encodingType);
hgs
parents:
diff changeset
   178
	}
21
hgs
parents: 20
diff changeset
   179
hgs
parents: 20
diff changeset
   180
	return 0;
19
hgs
parents:
diff changeset
   181
}
hgs
parents:
diff changeset
   182
hgs
parents:
diff changeset
   183
TInt CMetadataUtilityItf::ParseSource(char* uri)
hgs
parents:
diff changeset
   184
{
hgs
parents:
diff changeset
   185
	char* tempPtr = NULL;
hgs
parents:
diff changeset
   186
 	char extension[MAX_EXTENSION_SIZE] = { 0 };
hgs
parents:
diff changeset
   187
  
hgs
parents:
diff changeset
   188
	tempPtr = strchr(uri, (int)'.');
hgs
parents:
diff changeset
   189
	strncpy(extension,tempPtr,sizeof(tempPtr));
hgs
parents:
diff changeset
   190
	
hgs
parents:
diff changeset
   191
  	for(unsigned int i=0;i<sizeof(extension);i++)
hgs
parents:
diff changeset
   192
  	{
hgs
parents:
diff changeset
   193
      	extension[i] = tolower(extension[i]);
hgs
parents:
diff changeset
   194
  	}
hgs
parents:
diff changeset
   195
hgs
parents:
diff changeset
   196
	//if s60 util in use
hgs
parents:
diff changeset
   197
	if(m_pS60Util)
hgs
parents:
diff changeset
   198
	{
hgs
parents:
diff changeset
   199
		//reset existing instace
hgs
parents:
diff changeset
   200
		TInt ret = m_pS60Util->Reset();
hgs
parents:
diff changeset
   201
		if(!CS60MetadataUtilityItf::IsSupportedExtension(extension))
hgs
parents:
diff changeset
   202
		{
hgs
parents:
diff changeset
   203
			delete m_pS60Util;
hgs
parents:
diff changeset
   204
			m_pS60Util = NULL;
hgs
parents:
diff changeset
   205
		}
hgs
parents:
diff changeset
   206
	}
hgs
parents:
diff changeset
   207
hgs
parents:
diff changeset
   208
	if(m_pHXUtil)
hgs
parents:
diff changeset
   209
	{
hgs
parents:
diff changeset
   210
		//reset existing instace
hgs
parents:
diff changeset
   211
		TInt ret = m_pHXUtil->Reset();
hgs
parents:
diff changeset
   212
		if(CS60MetadataUtilityItf::IsSupportedExtension(extension))
hgs
parents:
diff changeset
   213
		{
hgs
parents:
diff changeset
   214
			delete m_pHXUtil;
hgs
parents:
diff changeset
   215
			m_pHXUtil = NULL;
hgs
parents:
diff changeset
   216
		}
hgs
parents:
diff changeset
   217
	}
hgs
parents:
diff changeset
   218
hgs
parents:
diff changeset
   219
	if(!m_pS60Util && !m_pHXUtil)
hgs
parents:
diff changeset
   220
	{
hgs
parents:
diff changeset
   221
		
hgs
parents:
diff changeset
   222
		if(CS60MetadataUtilityItf::IsSupportedExtension(extension))
hgs
parents:
diff changeset
   223
		{
hgs
parents:
diff changeset
   224
			m_pS60Util = CS60MetadataUtilityItf::New(); 
hgs
parents:
diff changeset
   225
		}
hgs
parents:
diff changeset
   226
		else
hgs
parents:
diff changeset
   227
		{
hgs
parents:
diff changeset
   228
			m_pHXUtil = CHXMetadataUtilityItf::New();
hgs
parents:
diff changeset
   229
		}
hgs
parents:
diff changeset
   230
	}
hgs
parents:
diff changeset
   231
hgs
parents:
diff changeset
   232
	return OpenSource(uri);
hgs
parents:
diff changeset
   233
}
hgs
parents:
diff changeset
   234
hgs
parents:
diff changeset
   235
hgs
parents:
diff changeset
   236
bool CS60MetadataUtilityItf::IsSupportedExtension(char *extn)
hgs
parents:
diff changeset
   237
{
hgs
parents:
diff changeset
   238
	if(	(!strcasecmp(extn, ".mp3"))	|| 
hgs
parents:
diff changeset
   239
		(!strcasecmp(extn, ".wma"))	|| 
hgs
parents:
diff changeset
   240
		(!strcasecmp(extn, ".aac")) ||
hgs
parents:
diff changeset
   241
		(!strcasecmp(extn, ".wav")) ||
hgs
parents:
diff changeset
   242
		(!strcasecmp(extn, ".m4a")))
hgs
parents:
diff changeset
   243
	{
hgs
parents:
diff changeset
   244
		return true;
hgs
parents:
diff changeset
   245
	}
hgs
parents:
diff changeset
   246
hgs
parents:
diff changeset
   247
	return false;
hgs
parents:
diff changeset
   248
}
hgs
parents:
diff changeset
   249
hgs
parents:
diff changeset
   250
CS60MetadataUtilityItf* CS60MetadataUtilityItf::New()
hgs
parents:
diff changeset
   251
{
hgs
parents:
diff changeset
   252
	CS60MetadataUtilityItf* self = new CS60MetadataUtilityItf();
hgs
parents:
diff changeset
   253
	
hgs
parents:
diff changeset
   254
	TInt err = KErrGeneral;
hgs
parents:
diff changeset
   255
	TRAP(err, self->ConstructL());
hgs
parents:
diff changeset
   256
hgs
parents:
diff changeset
   257
	if(err == KErrNone)
hgs
parents:
diff changeset
   258
	{
hgs
parents:
diff changeset
   259
		return self;
hgs
parents:
diff changeset
   260
	}
hgs
parents:
diff changeset
   261
hgs
parents:
diff changeset
   262
	delete self;
hgs
parents:
diff changeset
   263
	return NULL;
hgs
parents:
diff changeset
   264
}
hgs
parents:
diff changeset
   265
hgs
parents:
diff changeset
   266
CS60MetadataUtilityItf::CS60MetadataUtilityItf():pMetaDataUtility(NULL)
hgs
parents:
diff changeset
   267
{
hgs
parents:
diff changeset
   268
}
hgs
parents:
diff changeset
   269
hgs
parents:
diff changeset
   270
void CS60MetadataUtilityItf::ConstructL()
hgs
parents:
diff changeset
   271
{
hgs
parents:
diff changeset
   272
	TAG_TIME_PROFILING_BEGIN;
hgs
parents:
diff changeset
   273
	pMetaDataUtility = CMetaDataUtility::NewL();
hgs
parents:
diff changeset
   274
	TAG_TIME_PROFILING_END;
hgs
parents:
diff changeset
   275
	PRINT_TO_CONSOLE_TIME_DIFF;
hgs
parents:
diff changeset
   276
}
hgs
parents:
diff changeset
   277
    
hgs
parents:
diff changeset
   278
CS60MetadataUtilityItf::~CS60MetadataUtilityItf()
hgs
parents:
diff changeset
   279
{
hgs
parents:
diff changeset
   280
	if(pMetaDataUtility)
hgs
parents:
diff changeset
   281
	{		
hgs
parents:
diff changeset
   282
		TInt err = KErrGeneral;
hgs
parents:
diff changeset
   283
		
hgs
parents:
diff changeset
   284
		TAG_TIME_PROFILING_BEGIN;
hgs
parents:
diff changeset
   285
		TRAP(err, pMetaDataUtility->ResetL());
hgs
parents:
diff changeset
   286
		delete pMetaDataUtility;
hgs
parents:
diff changeset
   287
		TAG_TIME_PROFILING_END;
hgs
parents:
diff changeset
   288
		PRINT_TO_CONSOLE_TIME_DIFF;
hgs
parents:
diff changeset
   289
	}
hgs
parents:
diff changeset
   290
hgs
parents:
diff changeset
   291
	pMetaDataUtility = NULL;
hgs
parents:
diff changeset
   292
}
hgs
parents:
diff changeset
   293
hgs
parents:
diff changeset
   294
TInt CS60MetadataUtilityItf::ParseSource(TDesC& fileName)
hgs
parents:
diff changeset
   295
{
hgs
parents:
diff changeset
   296
	TInt err = KErrGeneral;
hgs
parents:
diff changeset
   297
hgs
parents:
diff changeset
   298
	if(pMetaDataUtility)
hgs
parents:
diff changeset
   299
	{
hgs
parents:
diff changeset
   300
	
hgs
parents:
diff changeset
   301
		TAG_TIME_PROFILING_BEGIN;
hgs
parents:
diff changeset
   302
		//open with the file handle
hgs
parents:
diff changeset
   303
		TRAP(err, pMetaDataUtility->OpenFileL(fileName));
hgs
parents:
diff changeset
   304
		TAG_TIME_PROFILING_END;
hgs
parents:
diff changeset
   305
		PRINT_TO_CONSOLE_TIME_DIFF;
hgs
parents:
diff changeset
   306
hgs
parents:
diff changeset
   307
		if(err == KErrNone)
hgs
parents:
diff changeset
   308
		{
hgs
parents:
diff changeset
   309
			uNumMetadataItems = pMetaDataUtility->MetaDataCount();
hgs
parents:
diff changeset
   310
		}
hgs
parents:
diff changeset
   311
	}
hgs
parents:
diff changeset
   312
hgs
parents:
diff changeset
   313
	return err;
hgs
parents:
diff changeset
   314
}
hgs
parents:
diff changeset
   315
hgs
parents:
diff changeset
   316
TInt CS60MetadataUtilityItf::CalculateNumMetadataItems(TUint* numItems)
hgs
parents:
diff changeset
   317
{
hgs
parents:
diff changeset
   318
	TInt err = KErrGeneral;
hgs
parents:
diff changeset
   319
hgs
parents:
diff changeset
   320
	if(pMetaDataUtility && numItems)
hgs
parents:
diff changeset
   321
	{
hgs
parents:
diff changeset
   322
		*numItems = uNumMetadataItems;
hgs
parents:
diff changeset
   323
		err = KErrNone;
hgs
parents:
diff changeset
   324
	}
hgs
parents:
diff changeset
   325
hgs
parents:
diff changeset
   326
	return err;
hgs
parents:
diff changeset
   327
}
hgs
parents:
diff changeset
   328
hgs
parents:
diff changeset
   329
char* CS60MetadataUtilityItf::KeyMapping(TMetaDataFieldId fldID)
hgs
parents:
diff changeset
   330
{
hgs
parents:
diff changeset
   331
	switch(fldID)
hgs
parents:
diff changeset
   332
	{
hgs
parents:
diff changeset
   333
	
hgs
parents:
diff changeset
   334
		case EMetaDataSongTitle:
hgs
parents:
diff changeset
   335
		{
hgs
parents:
diff changeset
   336
			return "KhronosTitle";
hgs
parents:
diff changeset
   337
		}
hgs
parents:
diff changeset
   338
		case EMetaDataArtist:
hgs
parents:
diff changeset
   339
		{
hgs
parents:
diff changeset
   340
			return "KhronosArtist";
hgs
parents:
diff changeset
   341
		}
hgs
parents:
diff changeset
   342
		case EMetaDataAlbum:
hgs
parents:
diff changeset
   343
		{
hgs
parents:
diff changeset
   344
			return "KhronosAlbum";
hgs
parents:
diff changeset
   345
		}
hgs
parents:
diff changeset
   346
		case EMetaDataYear:
hgs
parents:
diff changeset
   347
		{
hgs
parents:
diff changeset
   348
			return "KhronosYear";
hgs
parents:
diff changeset
   349
		}
hgs
parents:
diff changeset
   350
		case EMetaDataComment:
hgs
parents:
diff changeset
   351
		{
hgs
parents:
diff changeset
   352
			return "KhronosComment";
hgs
parents:
diff changeset
   353
		}
hgs
parents:
diff changeset
   354
		case EMetaDataAlbumTrack:
hgs
parents:
diff changeset
   355
		{
hgs
parents:
diff changeset
   356
			return "KhronosTrackNumber";
hgs
parents:
diff changeset
   357
		}
hgs
parents:
diff changeset
   358
		case EMetaDataGenre:
hgs
parents:
diff changeset
   359
		{
hgs
parents:
diff changeset
   360
			return "KhronosGenre";
hgs
parents:
diff changeset
   361
		}
hgs
parents:
diff changeset
   362
		case EMetaDataComposer:
hgs
parents:
diff changeset
   363
		{
hgs
parents:
diff changeset
   364
			return "Composer"; //Non Standard
hgs
parents:
diff changeset
   365
		}
hgs
parents:
diff changeset
   366
		case EMetaDataCopyright:
hgs
parents:
diff changeset
   367
		{
hgs
parents:
diff changeset
   368
			return "KhronosCopyright";
hgs
parents:
diff changeset
   369
		}
hgs
parents:
diff changeset
   370
		case EMetaDataOriginalArtist:
hgs
parents:
diff changeset
   371
		{
hgs
parents:
diff changeset
   372
			return "Original Artist"; //Non Standard
hgs
parents:
diff changeset
   373
		}
hgs
parents:
diff changeset
   374
		case EMetaDataUserUrl:
hgs
parents:
diff changeset
   375
		case EMetaDataUrl:	   
hgs
parents:
diff changeset
   376
		{
hgs
parents:
diff changeset
   377
			return "KhronosContentURL";
hgs
parents:
diff changeset
   378
		}
hgs
parents:
diff changeset
   379
		case EMetaDataJpeg:
hgs
parents:
diff changeset
   380
		{
hgs
parents:
diff changeset
   381
			return "attachedpicture";//"KhronosAlbumArtJPEG";
hgs
parents:
diff changeset
   382
		}
hgs
parents:
diff changeset
   383
		case EMetaDataVendor:
hgs
parents:
diff changeset
   384
		{
hgs
parents:
diff changeset
   385
			return "Vendor"; //Non Standard
hgs
parents:
diff changeset
   386
		}
hgs
parents:
diff changeset
   387
		case EMetaDataRating:
hgs
parents:
diff changeset
   388
		{
hgs
parents:
diff changeset
   389
			return "KhronosRating";			
hgs
parents:
diff changeset
   390
		}
hgs
parents:
diff changeset
   391
		case EMetaDataDuration:
hgs
parents:
diff changeset
   392
		{
hgs
parents:
diff changeset
   393
			return "Duration"; //Non Standard
hgs
parents:
diff changeset
   394
		}
hgs
parents:
diff changeset
   395
		default:
hgs
parents:
diff changeset
   396
		{
hgs
parents:
diff changeset
   397
		}
hgs
parents:
diff changeset
   398
	} 
hgs
parents:
diff changeset
   399
20
hgs
parents: 19
diff changeset
   400
	return "UnSupported";
19
hgs
parents:
diff changeset
   401
}
hgs
parents:
diff changeset
   402
hgs
parents:
diff changeset
   403
TInt CS60MetadataUtilityItf::ValueEncoding(TMetaDataFieldId fldID)
hgs
parents:
diff changeset
   404
{
hgs
parents:
diff changeset
   405
	switch(fldID)
hgs
parents:
diff changeset
   406
	{
hgs
parents:
diff changeset
   407
		case EMetaDataJpeg:
hgs
parents:
diff changeset
   408
		{
hgs
parents:
diff changeset
   409
			return CMetadataUtilityItf::EBinaryEncoding;
hgs
parents:
diff changeset
   410
		}
hgs
parents:
diff changeset
   411
		
hgs
parents:
diff changeset
   412
		case EMetaDataSongTitle:
hgs
parents:
diff changeset
   413
		case EMetaDataArtist:
hgs
parents:
diff changeset
   414
		case EMetaDataAlbum:
hgs
parents:
diff changeset
   415
		case EMetaDataYear:
hgs
parents:
diff changeset
   416
		case EMetaDataComment:
hgs
parents:
diff changeset
   417
		case EMetaDataAlbumTrack:
hgs
parents:
diff changeset
   418
		case EMetaDataGenre:
hgs
parents:
diff changeset
   419
		case EMetaDataComposer:
hgs
parents:
diff changeset
   420
		case EMetaDataCopyright:
hgs
parents:
diff changeset
   421
		case EMetaDataOriginalArtist:
hgs
parents:
diff changeset
   422
		case EMetaDataUserUrl:
hgs
parents:
diff changeset
   423
		case EMetaDataUrl:
hgs
parents:
diff changeset
   424
		case EMetaDataVendor:
hgs
parents:
diff changeset
   425
		case EMetaDataRating:
hgs
parents:
diff changeset
   426
		case EMetaDataDuration:
hgs
parents:
diff changeset
   427
		default:
hgs
parents:
diff changeset
   428
		{
hgs
parents:
diff changeset
   429
			return CMetadataUtilityItf::EUnicodeEncoding;
hgs
parents:
diff changeset
   430
		}
hgs
parents:
diff changeset
   431
	}
hgs
parents:
diff changeset
   432
	
hgs
parents:
diff changeset
   433
}
hgs
parents:
diff changeset
   434
char* CS60MetadataUtilityItf::GetKey(TInt index)
hgs
parents:
diff changeset
   435
{
hgs
parents:
diff changeset
   436
hgs
parents:
diff changeset
   437
	if(pMetaDataUtility && index < uNumMetadataItems)
hgs
parents:
diff changeset
   438
	{
hgs
parents:
diff changeset
   439
		
hgs
parents:
diff changeset
   440
        TMetaDataFieldId fieldId; 
hgs
parents:
diff changeset
   441
		
hgs
parents:
diff changeset
   442
		TAG_TIME_PROFILING_BEGIN;
hgs
parents:
diff changeset
   443
		TInt err = KErrGeneral;
hgs
parents:
diff changeset
   444
		TRAP(err, pMetaDataUtility->MetaDataFieldsL().FieldIdAt( index, fieldId ));
hgs
parents:
diff changeset
   445
		TAG_TIME_PROFILING_END;
hgs
parents:
diff changeset
   446
		PRINT_TO_CONSOLE_TIME_DIFF;
hgs
parents:
diff changeset
   447
		
hgs
parents:
diff changeset
   448
		if((err == KErrNone) && (fieldId != EUnknownMetaDataField))
hgs
parents:
diff changeset
   449
		{
hgs
parents:
diff changeset
   450
			return KeyMapping(fieldId);
hgs
parents:
diff changeset
   451
		}
hgs
parents:
diff changeset
   452
	}
hgs
parents:
diff changeset
   453
	return NULL;
hgs
parents:
diff changeset
   454
}
hgs
parents:
diff changeset
   455
hgs
parents:
diff changeset
   456
TInt CS60MetadataUtilityItf::GetValueSize(TInt index)
hgs
parents:
diff changeset
   457
{
hgs
parents:
diff changeset
   458
	if(pMetaDataUtility && index < uNumMetadataItems)
hgs
parents:
diff changeset
   459
	{
hgs
parents:
diff changeset
   460
		
hgs
parents:
diff changeset
   461
        TMetaDataFieldId fieldId; 
hgs
parents:
diff changeset
   462
		TInt err = KErrGeneral;
hgs
parents:
diff changeset
   463
		TRAP(err, pMetaDataUtility->MetaDataFieldsL().FieldIdAt( index, fieldId ));
hgs
parents:
diff changeset
   464
hgs
parents:
diff changeset
   465
		if((err == KErrNone) && (fieldId != EUnknownMetaDataField))
hgs
parents:
diff changeset
   466
		{
hgs
parents:
diff changeset
   467
			const CMetaDataFieldContainer* iContainer = NULL;
hgs
parents:
diff changeset
   468
			TRAP(err, iContainer  = &pMetaDataUtility->MetaDataFieldsL());
hgs
parents:
diff changeset
   469
			if(err == KErrNone)
hgs
parents:
diff changeset
   470
			{
hgs
parents:
diff changeset
   471
				if(ValueEncoding(fieldId) == CMetadataUtilityItf::EUnicodeEncoding)
hgs
parents:
diff changeset
   472
				{
hgs
parents:
diff changeset
   473
					TPtrC field = iContainer->Field( fieldId ); 
hgs
parents:
diff changeset
   474
					if(field != KNullDesC)
hgs
parents:
diff changeset
   475
					{
hgs
parents:
diff changeset
   476
						return field.Size() + 2; //additional character (two bytes) for null terminator
hgs
parents:
diff changeset
   477
					}
hgs
parents:
diff changeset
   478
				}	
hgs
parents:
diff changeset
   479
				else //Binary
hgs
parents:
diff changeset
   480
				{
hgs
parents:
diff changeset
   481
					TPtrC8 field8 = iContainer->Field8( fieldId );
hgs
parents:
diff changeset
   482
					if(field8 != KNullDesC8)
hgs
parents:
diff changeset
   483
					{
hgs
parents:
diff changeset
   484
						return field8.Size();
hgs
parents:
diff changeset
   485
					}
hgs
parents:
diff changeset
   486
		        }
hgs
parents:
diff changeset
   487
			}
hgs
parents:
diff changeset
   488
		}
hgs
parents:
diff changeset
   489
	}
hgs
parents:
diff changeset
   490
hgs
parents:
diff changeset
   491
	return 0;
hgs
parents:
diff changeset
   492
}
hgs
parents:
diff changeset
   493
	
hgs
parents:
diff changeset
   494
TInt CS60MetadataUtilityItf::GetValue(TInt index, char* data, TInt maxLength,  //in params
hgs
parents:
diff changeset
   495
										TInt* outSize, TInt* encodingType) //out params
hgs
parents:
diff changeset
   496
{
hgs
parents:
diff changeset
   497
hgs
parents:
diff changeset
   498
	TInt retValueSize = 0;
hgs
parents:
diff changeset
   499
	*encodingType= CMetadataUtilityItf::EUnknownEncoding;
hgs
parents:
diff changeset
   500
hgs
parents:
diff changeset
   501
	if(pMetaDataUtility && index < uNumMetadataItems)
hgs
parents:
diff changeset
   502
	{
hgs
parents:
diff changeset
   503
		
hgs
parents:
diff changeset
   504
        TMetaDataFieldId fieldId; 
hgs
parents:
diff changeset
   505
		TInt err = KErrGeneral;
hgs
parents:
diff changeset
   506
		TRAP(err, pMetaDataUtility->MetaDataFieldsL().FieldIdAt( index, fieldId )); 
hgs
parents:
diff changeset
   507
		
hgs
parents:
diff changeset
   508
		
hgs
parents:
diff changeset
   509
		if((err==KErrNone) && (fieldId != EUnknownMetaDataField))
hgs
parents:
diff changeset
   510
		{
hgs
parents:
diff changeset
   511
		
hgs
parents:
diff changeset
   512
			const CMetaDataFieldContainer* iContainer = NULL;
hgs
parents:
diff changeset
   513
			TRAP(err, iContainer  = &pMetaDataUtility->MetaDataFieldsL());
hgs
parents:
diff changeset
   514
			if(err == KErrNone)
hgs
parents:
diff changeset
   515
			{
hgs
parents:
diff changeset
   516
				*encodingType = ValueEncoding(fieldId);
hgs
parents:
diff changeset
   517
				if(*encodingType == CMetadataUtilityItf::EUnicodeEncoding)
hgs
parents:
diff changeset
   518
				{
hgs
parents:
diff changeset
   519
				
hgs
parents:
diff changeset
   520
					
hgs
parents:
diff changeset
   521
					TAG_TIME_PROFILING_BEGIN;
hgs
parents:
diff changeset
   522
					TPtrC field = iContainer->Field( fieldId ); 
hgs
parents:
diff changeset
   523
					TAG_TIME_PROFILING_END;
hgs
parents:
diff changeset
   524
					PRINT_TO_CONSOLE_TIME_DIFF;
hgs
parents:
diff changeset
   525
					if(field != KNullDesC)
hgs
parents:
diff changeset
   526
					{
hgs
parents:
diff changeset
   527
						*outSize = CMetadataUtilityItf::ExtractUCS2(field, data, maxLength);
hgs
parents:
diff changeset
   528
						retValueSize = field.Size() + 2; //actual size
hgs
parents:
diff changeset
   529
					}
hgs
parents:
diff changeset
   530
				}	
hgs
parents:
diff changeset
   531
				else //Binary
hgs
parents:
diff changeset
   532
				{
hgs
parents:
diff changeset
   533
					
hgs
parents:
diff changeset
   534
					TAG_TIME_PROFILING_BEGIN;
hgs
parents:
diff changeset
   535
					TPtrC8 field8 = iContainer->Field8( fieldId ); 
hgs
parents:
diff changeset
   536
					TAG_TIME_PROFILING_END;
hgs
parents:
diff changeset
   537
					PRINT_TO_CONSOLE_TIME_DIFF;
hgs
parents:
diff changeset
   538
					if(field8 != KNullDesC8)
hgs
parents:
diff changeset
   539
					{
hgs
parents:
diff changeset
   540
						*outSize = (maxLength > field8.Size())?field8.Size():maxLength;					
hgs
parents:
diff changeset
   541
						memcpy(data, field8.Ptr(), *outSize);
hgs
parents:
diff changeset
   542
						retValueSize = field8.Size();					
hgs
parents:
diff changeset
   543
					}
hgs
parents:
diff changeset
   544
				}
hgs
parents:
diff changeset
   545
			}
hgs
parents:
diff changeset
   546
		}
hgs
parents:
diff changeset
   547
	}
hgs
parents:
diff changeset
   548
hgs
parents:
diff changeset
   549
	return	 retValueSize;
hgs
parents:
diff changeset
   550
}
hgs
parents:
diff changeset
   551
hgs
parents:
diff changeset
   552
TInt CS60MetadataUtilityItf::Reset()
hgs
parents:
diff changeset
   553
{
hgs
parents:
diff changeset
   554
	TInt err = KErrNone;	
hgs
parents:
diff changeset
   555
	if(pMetaDataUtility)
hgs
parents:
diff changeset
   556
	{		
hgs
parents:
diff changeset
   557
		TRAP(err, pMetaDataUtility->ResetL());
hgs
parents:
diff changeset
   558
	}
hgs
parents:
diff changeset
   559
hgs
parents:
diff changeset
   560
	return err;
hgs
parents:
diff changeset
   561
}
hgs
parents:
diff changeset
   562
hgs
parents:
diff changeset
   563
hgs
parents:
diff changeset
   564
CHXMetadataUtilityItf::CHXMetadataUtilityItf():pHXMetaDataUtility(NULL)
hgs
parents:
diff changeset
   565
{
hgs
parents:
diff changeset
   566
}
hgs
parents:
diff changeset
   567
hgs
parents:
diff changeset
   568
void CHXMetadataUtilityItf::ConstructL()
hgs
parents:
diff changeset
   569
{
hgs
parents:
diff changeset
   570
	TAG_TIME_PROFILING_BEGIN;
hgs
parents:
diff changeset
   571
	pHXMetaDataUtility = CHXMetaDataUtility::NewL();
hgs
parents:
diff changeset
   572
	TAG_TIME_PROFILING_END;
hgs
parents:
diff changeset
   573
	PRINT_TO_CONSOLE_TIME_DIFF;
hgs
parents:
diff changeset
   574
}
hgs
parents:
diff changeset
   575
hgs
parents:
diff changeset
   576
   
hgs
parents:
diff changeset
   577
CHXMetadataUtilityItf* CHXMetadataUtilityItf::New()
hgs
parents:
diff changeset
   578
{
hgs
parents:
diff changeset
   579
	CHXMetadataUtilityItf* self = new CHXMetadataUtilityItf();
hgs
parents:
diff changeset
   580
hgs
parents:
diff changeset
   581
	if(self)
hgs
parents:
diff changeset
   582
	{
hgs
parents:
diff changeset
   583
		TInt err = KErrGeneral;
hgs
parents:
diff changeset
   584
		TRAP(err, self->ConstructL());
hgs
parents:
diff changeset
   585
   
hgs
parents:
diff changeset
   586
		if(err != KErrNone)
hgs
parents:
diff changeset
   587
		{
hgs
parents:
diff changeset
   588
			delete self;
hgs
parents:
diff changeset
   589
			self = NULL;
hgs
parents:
diff changeset
   590
		}
hgs
parents:
diff changeset
   591
	}
hgs
parents:
diff changeset
   592
   
hgs
parents:
diff changeset
   593
	return self;
hgs
parents:
diff changeset
   594
}
hgs
parents:
diff changeset
   595
   
hgs
parents:
diff changeset
   596
CHXMetadataUtilityItf::~CHXMetadataUtilityItf()
hgs
parents:
diff changeset
   597
{
hgs
parents:
diff changeset
   598
	if(pHXMetaDataUtility)
hgs
parents:
diff changeset
   599
	{		
hgs
parents:
diff changeset
   600
		TInt err = KErrGeneral;
hgs
parents:
diff changeset
   601
		
hgs
parents:
diff changeset
   602
		TAG_TIME_PROFILING_BEGIN;
hgs
parents:
diff changeset
   603
		TRAP(err, pHXMetaDataUtility->ResetL());
hgs
parents:
diff changeset
   604
		delete pHXMetaDataUtility;
hgs
parents:
diff changeset
   605
		TAG_TIME_PROFILING_END;
hgs
parents:
diff changeset
   606
		PRINT_TO_CONSOLE_TIME_DIFF;
hgs
parents:
diff changeset
   607
	}
hgs
parents:
diff changeset
   608
hgs
parents:
diff changeset
   609
	pHXMetaDataUtility = NULL;
hgs
parents:
diff changeset
   610
}
hgs
parents:
diff changeset
   611
hgs
parents:
diff changeset
   612
TInt CHXMetadataUtilityItf::Reset()
hgs
parents:
diff changeset
   613
{
hgs
parents:
diff changeset
   614
	TInt err = KErrNone;	
hgs
parents:
diff changeset
   615
	if(pHXMetaDataUtility)
hgs
parents:
diff changeset
   616
	{		
hgs
parents:
diff changeset
   617
		TRAP(err, pHXMetaDataUtility->ResetL());
hgs
parents:
diff changeset
   618
	}
hgs
parents:
diff changeset
   619
hgs
parents:
diff changeset
   620
	return err;
hgs
parents:
diff changeset
   621
}
hgs
parents:
diff changeset
   622
hgs
parents:
diff changeset
   623
hgs
parents:
diff changeset
   624
hgs
parents:
diff changeset
   625
TInt CHXMetadataUtilityItf::ParseSource(TDesC& fileName)
hgs
parents:
diff changeset
   626
{
hgs
parents:
diff changeset
   627
	TInt err = KErrGeneral;
hgs
parents:
diff changeset
   628
hgs
parents:
diff changeset
   629
	if(pHXMetaDataUtility)
hgs
parents:
diff changeset
   630
	{
hgs
parents:
diff changeset
   631
		//open with the file handle
hgs
parents:
diff changeset
   632
		TAG_TIME_PROFILING_BEGIN;
hgs
parents:
diff changeset
   633
		TRAP(err, pHXMetaDataUtility->OpenFileL(fileName));
hgs
parents:
diff changeset
   634
		TAG_TIME_PROFILING_END;
hgs
parents:
diff changeset
   635
		PRINT_TO_CONSOLE_TIME_DIFF;
hgs
parents:
diff changeset
   636
hgs
parents:
diff changeset
   637
		if(err == KErrNone)
hgs
parents:
diff changeset
   638
		{
hgs
parents:
diff changeset
   639
			 return pHXMetaDataUtility->GetMetaDataCount(uNumMetadataItems);
hgs
parents:
diff changeset
   640
		}
hgs
parents:
diff changeset
   641
	}
hgs
parents:
diff changeset
   642
hgs
parents:
diff changeset
   643
	return err;
hgs
parents:
diff changeset
   644
}
hgs
parents:
diff changeset
   645
hgs
parents:
diff changeset
   646
TInt CHXMetadataUtilityItf::CalculateNumMetadataItems(TUint* numItems)
hgs
parents:
diff changeset
   647
{
hgs
parents:
diff changeset
   648
	TInt err = KErrGeneral;
hgs
parents:
diff changeset
   649
hgs
parents:
diff changeset
   650
	if(pHXMetaDataUtility && numItems)
hgs
parents:
diff changeset
   651
	{
hgs
parents:
diff changeset
   652
		*numItems = uNumMetadataItems;
hgs
parents:
diff changeset
   653
		err = KErrNone;
hgs
parents:
diff changeset
   654
	}
hgs
parents:
diff changeset
   655
hgs
parents:
diff changeset
   656
	return err;
hgs
parents:
diff changeset
   657
}
hgs
parents:
diff changeset
   658
hgs
parents:
diff changeset
   659
char* CHXMetadataUtilityItf::KeyMapping(HXMetaDataKeys::EHXMetaDataId fldID)
hgs
parents:
diff changeset
   660
{
hgs
parents:
diff changeset
   661
        
hgs
parents:
diff changeset
   662
	switch(fldID)
hgs
parents:
diff changeset
   663
	{
hgs
parents:
diff changeset
   664
	
hgs
parents:
diff changeset
   665
		case HXMetaDataKeys::EHXTitle:
hgs
parents:
diff changeset
   666
		{
hgs
parents:
diff changeset
   667
			return "KhronosTitle";
hgs
parents:
diff changeset
   668
		}
hgs
parents:
diff changeset
   669
		case HXMetaDataKeys::EHXPerformer:
hgs
parents:
diff changeset
   670
		{
hgs
parents:
diff changeset
   671
			return "KhronosArtist";
hgs
parents:
diff changeset
   672
		}
hgs
parents:
diff changeset
   673
		case HXMetaDataKeys::EHXDescription:
hgs
parents:
diff changeset
   674
		{
hgs
parents:
diff changeset
   675
			return "KhronosComment";
hgs
parents:
diff changeset
   676
		}
hgs
parents:
diff changeset
   677
		case HXMetaDataKeys::EHXGenre:
hgs
parents:
diff changeset
   678
		{
hgs
parents:
diff changeset
   679
			return "KhronosGenre";
hgs
parents:
diff changeset
   680
		}
hgs
parents:
diff changeset
   681
		case HXMetaDataKeys::EHXAuthor:
hgs
parents:
diff changeset
   682
		{
hgs
parents:
diff changeset
   683
			return "Composer"; //Non Standard
hgs
parents:
diff changeset
   684
		}
hgs
parents:
diff changeset
   685
		case HXMetaDataKeys::EHXCopyright:
hgs
parents:
diff changeset
   686
		{
hgs
parents:
diff changeset
   687
			return "KhronosCopyright";
hgs
parents:
diff changeset
   688
		}
hgs
parents:
diff changeset
   689
		case HXMetaDataKeys::EHXContentURI:	   
hgs
parents:
diff changeset
   690
		{
hgs
parents:
diff changeset
   691
			return "KhronosContentURL";
hgs
parents:
diff changeset
   692
		}
hgs
parents:
diff changeset
   693
		case HXMetaDataKeys::EHXDuration:
hgs
parents:
diff changeset
   694
		{
hgs
parents:
diff changeset
   695
			return "Duration"; //Non Standard
hgs
parents:
diff changeset
   696
		}
hgs
parents:
diff changeset
   697
		case HXMetaDataKeys::EHXClipBitRate:
hgs
parents:
diff changeset
   698
		{
hgs
parents:
diff changeset
   699
			return "ClipBitRate"; //non-standard
hgs
parents:
diff changeset
   700
		}
hgs
parents:
diff changeset
   701
		case HXMetaDataKeys::EHXVideoBitRate:
hgs
parents:
diff changeset
   702
		{
hgs
parents:
diff changeset
   703
			return "VideoBitRate"; // non-standard
hgs
parents:
diff changeset
   704
		}
hgs
parents:
diff changeset
   705
		case HXMetaDataKeys::EHXAudioBitRate:
hgs
parents:
diff changeset
   706
		{
hgs
parents:
diff changeset
   707
			return "AudioBitRate";
hgs
parents:
diff changeset
   708
		}
hgs
parents:
diff changeset
   709
		case HXMetaDataKeys::EHXCodec:
hgs
parents:
diff changeset
   710
		{
hgs
parents:
diff changeset
   711
			return "Codec";
hgs
parents:
diff changeset
   712
		}
hgs
parents:
diff changeset
   713
		case HXMetaDataKeys::EHXFrameSize:
hgs
parents:
diff changeset
   714
		{
hgs
parents:
diff changeset
   715
			return "Resolution";
hgs
parents:
diff changeset
   716
		}
hgs
parents:
diff changeset
   717
		case HXMetaDataKeys::EHXFramesPerSecond:
hgs
parents:
diff changeset
   718
		{
hgs
parents:
diff changeset
   719
			return "FrameRate";
hgs
parents:
diff changeset
   720
		}
hgs
parents:
diff changeset
   721
		case HXMetaDataKeys::EHXStreamCount:
hgs
parents:
diff changeset
   722
		{
hgs
parents:
diff changeset
   723
			return "Stream Count";
hgs
parents:
diff changeset
   724
		}
hgs
parents:
diff changeset
   725
		case HXMetaDataKeys::EHXLiveStream:
hgs
parents:
diff changeset
   726
		{
hgs
parents:
diff changeset
   727
			return "Live Stream";
hgs
parents:
diff changeset
   728
		}
hgs
parents:
diff changeset
   729
        case HXMetaDataKeys::EHXSeekable:
hgs
parents:
diff changeset
   730
		{
hgs
parents:
diff changeset
   731
			return "Seekable";
hgs
parents:
diff changeset
   732
		}
hgs
parents:
diff changeset
   733
        case HXMetaDataKeys::EHXContentType:
hgs
parents:
diff changeset
   734
  		{
hgs
parents:
diff changeset
   735
			return "Content Type";
hgs
parents:
diff changeset
   736
		}
hgs
parents:
diff changeset
   737
		case HXMetaDataKeys::EHXFormat:
hgs
parents:
diff changeset
   738
		{
hgs
parents:
diff changeset
   739
			return "Format";
hgs
parents:
diff changeset
   740
		}
hgs
parents:
diff changeset
   741
        case HXMetaDataKeys::EHXQuality:
hgs
parents:
diff changeset
   742
		{
hgs
parents:
diff changeset
   743
			return "Quality";
hgs
parents:
diff changeset
   744
		}
hgs
parents:
diff changeset
   745
        case HXMetaDataKeys::EHXAbstract:
hgs
parents:
diff changeset
   746
		{
hgs
parents:
diff changeset
   747
			return "Abstract";
hgs
parents:
diff changeset
   748
		}
hgs
parents:
diff changeset
   749
		case HXMetaDataKeys::EHXMimeType:
hgs
parents:
diff changeset
   750
		{
hgs
parents:
diff changeset
   751
			return "MimeType";
hgs
parents:
diff changeset
   752
		}
hgs
parents:
diff changeset
   753
		case HXMetaDataKeys::EHXIconURI:
hgs
parents:
diff changeset
   754
		{
hgs
parents:
diff changeset
   755
			return "Icon URI";
hgs
parents:
diff changeset
   756
		}
hgs
parents:
diff changeset
   757
        case HXMetaDataKeys::EHXEPreviewURI:
hgs
parents:
diff changeset
   758
		{
hgs
parents:
diff changeset
   759
			return "Preview URI";
hgs
parents:
diff changeset
   760
		}
hgs
parents:
diff changeset
   761
        case HXMetaDataKeys::EHXContentID:
hgs
parents:
diff changeset
   762
		{
hgs
parents:
diff changeset
   763
			return "Content ID";
hgs
parents:
diff changeset
   764
		}
hgs
parents:
diff changeset
   765
        case HXMetaDataKeys::EHXInfoURL:
hgs
parents:
diff changeset
   766
		{
hgs
parents:
diff changeset
   767
			return "Info URL";
hgs
parents:
diff changeset
   768
		}
hgs
parents:
diff changeset
   769
		default:
hgs
parents:
diff changeset
   770
		{
hgs
parents:
diff changeset
   771
		}
hgs
parents:
diff changeset
   772
	} 
hgs
parents:
diff changeset
   773
20
hgs
parents: 19
diff changeset
   774
	return "UnSupported";
19
hgs
parents:
diff changeset
   775
}
hgs
parents:
diff changeset
   776
hgs
parents:
diff changeset
   777
TInt CHXMetadataUtilityItf::ValueEncoding(HXMetaDataKeys::EHXMetaDataId fldID)
hgs
parents:
diff changeset
   778
{
hgs
parents:
diff changeset
   779
	switch(fldID)
hgs
parents:
diff changeset
   780
	{
hgs
parents:
diff changeset
   781
		default:
hgs
parents:
diff changeset
   782
		{
hgs
parents:
diff changeset
   783
			return CMetadataUtilityItf::EUnicodeEncoding;
hgs
parents:
diff changeset
   784
		}
hgs
parents:
diff changeset
   785
	}
hgs
parents:
diff changeset
   786
	
hgs
parents:
diff changeset
   787
}
hgs
parents:
diff changeset
   788
char* CHXMetadataUtilityItf::GetKey(TInt index)
hgs
parents:
diff changeset
   789
{
hgs
parents:
diff changeset
   790
hgs
parents:
diff changeset
   791
	if(pHXMetaDataUtility && index < uNumMetadataItems)
hgs
parents:
diff changeset
   792
	{
hgs
parents:
diff changeset
   793
		HXMetaDataKeys::EHXMetaDataId id;
hgs
parents:
diff changeset
   794
		HBufC* pDes;
hgs
parents:
diff changeset
   795
		
hgs
parents:
diff changeset
   796
		TAG_TIME_PROFILING_BEGIN;
hgs
parents:
diff changeset
   797
        TInt err = pHXMetaDataUtility->GetMetaDataAt(index, id, pDes); 
hgs
parents:
diff changeset
   798
		TAG_TIME_PROFILING_END;
hgs
parents:
diff changeset
   799
		PRINT_TO_CONSOLE_TIME_DIFF;
hgs
parents:
diff changeset
   800
		
hgs
parents:
diff changeset
   801
		if(err == KErrNone)
hgs
parents:
diff changeset
   802
		{
hgs
parents:
diff changeset
   803
			return KeyMapping(id);
hgs
parents:
diff changeset
   804
		}
hgs
parents:
diff changeset
   805
	}
hgs
parents:
diff changeset
   806
	return NULL;
hgs
parents:
diff changeset
   807
}
hgs
parents:
diff changeset
   808
hgs
parents:
diff changeset
   809
TInt CHXMetadataUtilityItf::GetValueSize(TInt index)
hgs
parents:
diff changeset
   810
{
hgs
parents:
diff changeset
   811
	if(pHXMetaDataUtility && index < uNumMetadataItems)
hgs
parents:
diff changeset
   812
	{
hgs
parents:
diff changeset
   813
		HXMetaDataKeys::EHXMetaDataId id;
hgs
parents:
diff changeset
   814
		HBufC* pDes;
hgs
parents:
diff changeset
   815
		
hgs
parents:
diff changeset
   816
        TInt err =  pHXMetaDataUtility->GetMetaDataAt(index, id, pDes); 
hgs
parents:
diff changeset
   817
		
hgs
parents:
diff changeset
   818
		if(err == KErrNone)
hgs
parents:
diff changeset
   819
		{
hgs
parents:
diff changeset
   820
			if(ValueEncoding(id) == CMetadataUtilityItf::EUnicodeEncoding)
hgs
parents:
diff changeset
   821
			{
hgs
parents:
diff changeset
   822
				return pDes->Size() + 2; //additional character (two bytes) for null terminator
hgs
parents:
diff changeset
   823
			}	
hgs
parents:
diff changeset
   824
			else //Binary
hgs
parents:
diff changeset
   825
			{
hgs
parents:
diff changeset
   826
				//no support
hgs
parents:
diff changeset
   827
	        }
hgs
parents:
diff changeset
   828
		}
hgs
parents:
diff changeset
   829
	}
hgs
parents:
diff changeset
   830
hgs
parents:
diff changeset
   831
	return 0;
hgs
parents:
diff changeset
   832
}
hgs
parents:
diff changeset
   833
	
hgs
parents:
diff changeset
   834
TInt CHXMetadataUtilityItf::GetValue(TInt index, char* data, TInt maxLength,  //in params
hgs
parents:
diff changeset
   835
										TInt* outSize, TInt* encodingType) //out params
hgs
parents:
diff changeset
   836
{
hgs
parents:
diff changeset
   837
hgs
parents:
diff changeset
   838
	TInt retValueSize = 0;
hgs
parents:
diff changeset
   839
	*encodingType= CMetadataUtilityItf::EUnknownEncoding;
hgs
parents:
diff changeset
   840
hgs
parents:
diff changeset
   841
	if(pHXMetaDataUtility && index < uNumMetadataItems)
hgs
parents:
diff changeset
   842
	{
hgs
parents:
diff changeset
   843
		HXMetaDataKeys::EHXMetaDataId id;
hgs
parents:
diff changeset
   844
		HBufC* pDes;
hgs
parents:
diff changeset
   845
hgs
parents:
diff changeset
   846
		
hgs
parents:
diff changeset
   847
		TAG_TIME_PROFILING_BEGIN;
hgs
parents:
diff changeset
   848
        TInt err =  pHXMetaDataUtility->GetMetaDataAt(index, id, pDes); 
hgs
parents:
diff changeset
   849
		TAG_TIME_PROFILING_END;
hgs
parents:
diff changeset
   850
		PRINT_TO_CONSOLE_TIME_DIFF;
hgs
parents:
diff changeset
   851
		
hgs
parents:
diff changeset
   852
		*encodingType = ValueEncoding(id);
hgs
parents:
diff changeset
   853
		
hgs
parents:
diff changeset
   854
		if(err == KErrNone)
hgs
parents:
diff changeset
   855
		{
hgs
parents:
diff changeset
   856
			if(*encodingType == CMetadataUtilityItf::EUnicodeEncoding)
hgs
parents:
diff changeset
   857
			{
hgs
parents:
diff changeset
   858
				*outSize = CMetadataUtilityItf::ExtractUCS2(*pDes, data, maxLength);
hgs
parents:
diff changeset
   859
				retValueSize = pDes->Size() + 2; //actual Size	
hgs
parents:
diff changeset
   860
			}	
hgs
parents:
diff changeset
   861
			else //Binary
hgs
parents:
diff changeset
   862
			{
hgs
parents:
diff changeset
   863
				//no support
hgs
parents:
diff changeset
   864
			}
hgs
parents:
diff changeset
   865
		}
hgs
parents:
diff changeset
   866
	}
hgs
parents:
diff changeset
   867
hgs
parents:
diff changeset
   868
	return	 retValueSize;
hgs
parents:
diff changeset
   869
}
hgs
parents:
diff changeset
   870
hgs
parents:
diff changeset
   871
hgs
parents:
diff changeset
   872
extern "C" {
hgs
parents:
diff changeset
   873
hgs
parents:
diff changeset
   874
    void* mmf_metadata_utility_init(char* uri)
hgs
parents:
diff changeset
   875
	{
hgs
parents:
diff changeset
   876
		return CMetadataUtilityItf::New(uri);
hgs
parents:
diff changeset
   877
	}
hgs
parents:
diff changeset
   878
hgs
parents:
diff changeset
   879
    void mmf_metadata_utility_destroy(void* context)
hgs
parents:
diff changeset
   880
	{
hgs
parents:
diff changeset
   881
		delete ((CMetadataUtilityItf*)context);
hgs
parents:
diff changeset
   882
	}
hgs
parents:
diff changeset
   883
hgs
parents:
diff changeset
   884
	XAresult mmf_metadata_utility_parse_source(void* context, char* uri)
hgs
parents:
diff changeset
   885
	{
hgs
parents:
diff changeset
   886
		TInt err = ((CMetadataUtilityItf*)context)->ParseSource(uri);
hgs
parents:
diff changeset
   887
		
hgs
parents:
diff changeset
   888
		if(err == KErrNone)
hgs
parents:
diff changeset
   889
		{
hgs
parents:
diff changeset
   890
			return XA_RESULT_SUCCESS;
hgs
parents:
diff changeset
   891
		}
hgs
parents:
diff changeset
   892
		
hgs
parents:
diff changeset
   893
		return XA_RESULT_PARAMETER_INVALID;
hgs
parents:
diff changeset
   894
	}
hgs
parents:
diff changeset
   895
hgs
parents:
diff changeset
   896
hgs
parents:
diff changeset
   897
	XAresult  mmf_get_item_count(void* context, XAuint32* itemCount)
hgs
parents:
diff changeset
   898
	{
hgs
parents:
diff changeset
   899
		if(itemCount)
hgs
parents:
diff changeset
   900
		{
hgs
parents:
diff changeset
   901
			TInt err = ((CMetadataUtilityItf*)(context))->CalculateNumMetadataItems((TUint *)itemCount);
hgs
parents:
diff changeset
   902
			if(err == KErrNone)
hgs
parents:
diff changeset
   903
			{
hgs
parents:
diff changeset
   904
				return XA_RESULT_SUCCESS;
hgs
parents:
diff changeset
   905
			}
hgs
parents:
diff changeset
   906
		}
hgs
parents:
diff changeset
   907
hgs
parents:
diff changeset
   908
		return XA_RESULT_PARAMETER_INVALID;
hgs
parents:
diff changeset
   909
	}
hgs
parents:
diff changeset
   910
	
hgs
parents:
diff changeset
   911
	XAresult  mmf_get_key_size(void* context, XAuint32 keyIndex, XAuint32* keySize)
hgs
parents:
diff changeset
   912
	{
hgs
parents:
diff changeset
   913
		char* key = ((CMetadataUtilityItf*)(context))->GetKey(keyIndex);
hgs
parents:
diff changeset
   914
		if(key && keySize)
hgs
parents:
diff changeset
   915
		{
hgs
parents:
diff changeset
   916
			*keySize = (strlen(key) + sizeof(XAMetadataInfo));
hgs
parents:
diff changeset
   917
			
hgs
parents:
diff changeset
   918
			return XA_RESULT_SUCCESS;
hgs
parents:
diff changeset
   919
		}
hgs
parents:
diff changeset
   920
		
hgs
parents:
diff changeset
   921
		return XA_RESULT_PARAMETER_INVALID;		
hgs
parents:
diff changeset
   922
	}
hgs
parents:
diff changeset
   923
	
hgs
parents:
diff changeset
   924
hgs
parents:
diff changeset
   925
	XAresult  mmf_get_key(void* context, XAuint32 index,XAuint32 keySize, XAMetadataInfo *pKey)
hgs
parents:
diff changeset
   926
	{
hgs
parents:
diff changeset
   927
		XAresult ret = XA_RESULT_PARAMETER_INVALID;
hgs
parents:
diff changeset
   928
		
hgs
parents:
diff changeset
   929
		TInt keyDataSize = keySize - sizeof(XAMetadataInfo) + 1;
hgs
parents:
diff changeset
   930
		char* ascKey = ((CMetadataUtilityItf*)(context))->GetKey(index);
hgs
parents:
diff changeset
   931
hgs
parents:
diff changeset
   932
		if(ascKey && keyDataSize)
hgs
parents:
diff changeset
   933
		{
hgs
parents:
diff changeset
   934
			TInt ascKeySize = strlen(ascKey);
hgs
parents:
diff changeset
   935
			TInt outSize = (ascKeySize >= keyDataSize) ? (keyDataSize - 1) : ascKeySize;
hgs
parents:
diff changeset
   936
			
hgs
parents:
diff changeset
   937
			pKey->size = outSize + 1;
hgs
parents:
diff changeset
   938
			pKey->encoding = XA_CHARACTERENCODING_ASCII;
hgs
parents:
diff changeset
   939
			strcpy((char *)(pKey->langCountry), "en-us");
hgs
parents:
diff changeset
   940
			strncpy((char *)(pKey->data), ascKey, outSize);
hgs
parents:
diff changeset
   941
			pKey->data[outSize] = '\0';
hgs
parents:
diff changeset
   942
hgs
parents:
diff changeset
   943
			if(ascKeySize >= keyDataSize)
hgs
parents:
diff changeset
   944
			{
hgs
parents:
diff changeset
   945
				ret = XA_RESULT_BUFFER_INSUFFICIENT;
hgs
parents:
diff changeset
   946
			}
hgs
parents:
diff changeset
   947
			else
hgs
parents:
diff changeset
   948
			{
hgs
parents:
diff changeset
   949
				ret = XA_RESULT_SUCCESS;
hgs
parents:
diff changeset
   950
			}
hgs
parents:
diff changeset
   951
		}
hgs
parents:
diff changeset
   952
hgs
parents:
diff changeset
   953
		ret = XA_RESULT_SUCCESS;
hgs
parents:
diff changeset
   954
		return ret;		
hgs
parents:
diff changeset
   955
	}
hgs
parents:
diff changeset
   956
hgs
parents:
diff changeset
   957
	XAresult  mmf_get_value_size(void* context, XAuint32 index, XAuint32 *pValueSize)
hgs
parents:
diff changeset
   958
	{
hgs
parents:
diff changeset
   959
		if(pValueSize)
hgs
parents:
diff changeset
   960
		{
hgs
parents:
diff changeset
   961
			*pValueSize = ((CMetadataUtilityItf*)(context))->GetValueSize(index) + sizeof(XAMetadataInfo) - 1; //XAMetadataInfo already includes one byte for Data
hgs
parents:
diff changeset
   962
			
hgs
parents:
diff changeset
   963
			return XA_RESULT_SUCCESS;
hgs
parents:
diff changeset
   964
		}
hgs
parents:
diff changeset
   965
hgs
parents:
diff changeset
   966
		return XA_RESULT_PARAMETER_INVALID;		
hgs
parents:
diff changeset
   967
	}
hgs
parents:
diff changeset
   968
hgs
parents:
diff changeset
   969
	XAresult  mmf_get_value(void* context, XAuint32 index, XAuint32 valueSize, XAMetadataInfo *pValue)
hgs
parents:
diff changeset
   970
	{
hgs
parents:
diff changeset
   971
		XAresult ret = XA_RESULT_PARAMETER_INVALID;
hgs
parents:
diff changeset
   972
		TInt dataSize = valueSize - sizeof(XAMetadataInfo) + 1;
hgs
parents:
diff changeset
   973
		TInt outLen = 0, encodingType = CMetadataUtilityItf::EUnknownEncoding;
hgs
parents:
diff changeset
   974
hgs
parents:
diff changeset
   975
		if(dataSize > 0)
hgs
parents:
diff changeset
   976
		{
hgs
parents:
diff changeset
   977
		
hgs
parents:
diff changeset
   978
			TInt actualDataSize = ((CMetadataUtilityItf*)(context))->GetValue(index, (char*)pValue->data, dataSize, &outLen, &encodingType);
hgs
parents:
diff changeset
   979
hgs
parents:
diff changeset
   980
			pValue->size = outLen;
hgs
parents:
diff changeset
   981
			pValue->encoding = (encodingType == CMetadataUtilityItf::EUnicodeEncoding) ? XA_CHARACTERENCODING_UTF16LE : XA_CHARACTERENCODING_BINARY;
hgs
parents:
diff changeset
   982
			strcpy((char *)(pValue->langCountry), "en-us");
hgs
parents:
diff changeset
   983
hgs
parents:
diff changeset
   984
			if(!actualDataSize)
hgs
parents:
diff changeset
   985
			{
hgs
parents:
diff changeset
   986
				return XA_RESULT_INTERNAL_ERROR;
hgs
parents:
diff changeset
   987
			}
hgs
parents:
diff changeset
   988
			if(actualDataSize > dataSize)
hgs
parents:
diff changeset
   989
			{
hgs
parents:
diff changeset
   990
				ret = XA_RESULT_BUFFER_INSUFFICIENT;
hgs
parents:
diff changeset
   991
			}
hgs
parents:
diff changeset
   992
			else
hgs
parents:
diff changeset
   993
			{
hgs
parents:
diff changeset
   994
				ret = XA_RESULT_SUCCESS;
hgs
parents:
diff changeset
   995
			}
hgs
parents:
diff changeset
   996
		}
hgs
parents:
diff changeset
   997
			
hgs
parents:
diff changeset
   998
		return ret; 
hgs
parents:
diff changeset
   999
	}
hgs
parents:
diff changeset
  1000
}
hgs
parents:
diff changeset
  1001