// Read in a NULL terminated string byte by byte and take most significant byte first
// and convert to a OSCL_wString
bool
AtomUtils::readNullTerminatedString(MP4_FF_FILE *fp, OSCL_wString& data)
{
const int BUFSIZE = 1024;
uint8 buf[BUFSIZE];
int32 index = 0;
if (!AtomUtils::read8(fp, buf[index]))
return false;
bool nextChar = (buf[index] == 0) ? false : true;
while (nextChar && (index < BUFSIZE))
{
index++;
if (!AtomUtils::read8(fp, buf[index]))
return false;
nextChar = (buf[index] == 0) ? false : true;
}
// String buffer filled - now create OSCL_wString
uint8 outbuf[BUFSIZE*sizeof(OSCL_TCHAR)];
oscl_UTF8ToUnicode((const char *)buf, index, (OSCL_TCHAR *)outbuf, BUFSIZE);
OSCL_wHeapString<OsclMemAllocator> temp((const OSCL_TCHAR *)outbuf);
data = temp;
return true;
}
int32 OsclNativeFile::Open(const oscl_wchar *filename, uint32 mode
, const OsclNativeFileParams& params
, Oscl_FileServer& fileserv)
{
iMode = mode;
iOpenFileHandle = false;
OSCL_UNUSED_ARG(fileserv);
OSCL_UNUSED_ARG(params);
char openmode[4];
OpenModeToString(mode, openmode);
#ifdef _UNICODE
oscl_wchar convopenmode[4];
if (0 == oscl_UTF8ToUnicode(openmode, oscl_strlen(openmode), convopenmode, 4))
{
return -1;
}
if ((iFile = _wfopen(filename, convopenmode)) == NULL)
{
return -1;
}
#else
//Convert to UTF8
char convfilename[OSCL_IO_FILENAME_MAXLEN];
if (0 == oscl_UnicodeToUTF8(filename, oscl_strlen(filename), convfilename, OSCL_IO_FILENAME_MAXLEN))
{
return -1;
}
return OpenFileOrSharedFd(convfilename, openmode);
#endif
}
OSCL_EXPORT_REF bool
AtomUtils::readUTF8String(MP4_FF_FILE *fp, uint32 inLength, OSCL_wString& data)
{
const int MAX_BUFF_SIZE = 1024;
uint8 buf[MAX_BUFF_SIZE];
uint32 max_length = (uint32)MAX_BUFF_SIZE;
if (inLength > max_length)
{
inLength = max_length;
}
uint32 index = 0;
bool nextChar = true;
while (nextChar && (index < inLength))
{
if (!AtomUtils::read8(fp, buf[index]))
return false;
nextChar = (buf[index] == 0) ? false : true;
index++;
}
// String buffer filled - now create ZString
OSCL_TCHAR outbuf[MAX_BUFF_SIZE];
oscl_UTF8ToUnicode((const char *)buf, (int32)index, outbuf, MAX_BUFF_SIZE);
OSCL_wHeapString<OsclMemAllocator> temp(outbuf);
data = temp;
return true;
}
OSCL_EXPORT_REF OSCL_FILEMGMT_ERR_TYPE oscl_getcwd(oscl_wchar *path, uint32 size)
{
char convpathname[OSCL_IO_FILENAME_MAXLEN];
if (oscl_getcwd(convpathname, size > OSCL_IO_FILENAME_MAXLEN ? OSCL_IO_FILENAME_MAXLEN : size) == OSCL_FILEMGMT_E_OK)
{
if (0 == oscl_UTF8ToUnicode(convpathname, oscl_strlen(convpathname), path, size) && oscl_strlen(convpathname) != 0)
{
return OSCL_FILEMGMT_E_PATH_TOO_LONG;
}
return OSCL_FILEMGMT_E_OK;
}
return OSCL_FILEMGMT_E_PATH_NOT_FOUND;
}
void pv_metadata_engine_test::Run()
{
int error = 0;
switch (iState)
{
case STATE_CREATE:
{
iPVMEContainer.iCmdStatusObserver = this;
iPVMEContainer.iInfoEventObserver = this;
iPVMEContainer.iErrorEventObserver = this;
iPVMEContainer.iMode = iMode;
if (iPVMEContainer.iMode == PV_METADATA_ENGINE_THREADED_MODE)
{
//Configure the threadsafe queues that are used for engine
//thread callbacks.
iThreadSafeCommandQueue.Configure(this);
iThreadSafeErrorQueue.Configure(this);
iThreadSafeInfoQueue.Configure(this);
iPVMEContainer.iSem.Create();
iPVMEContainer.iAppenderType = iLoggerInfo.iAppenderType;
iPVMEContainer.iLogfilename = iLoggerInfo.logfilename;
iPVMEContainer.iLoggerConfigElements = iLoggerInfo.iLoggerConfigElements;
}
OSCL_TRY(error, PVMetadataEngineFactory::CreatePVMetadataEngine(iPVMEContainer));
PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO,
(0, "PVMetadataEngineTest::Create Called ClockInMS=%d", OsclTickCount::TicksToMsec(OsclTickCount::TickCount())));
if (error || iPVMEContainer.iPVMEInterface == NULL)
{
PVMEATB_TEST_IS_TRUE(false);
iObserver->TestCompleted(*iTestCase);
}
else
{
iState = STATE_INIT;
RunIfNotReady();
}
}
break;
case STATE_INIT:
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO,
(0, "PVMetadataEngineTest::Init Issued ClockInMS=%d", OsclTickCount::TicksToMsec(OsclTickCount::TickCount())));
iCurrentCmdId = iPVMEContainer.iPVMEInterface->Init((OsclAny*) & iContextObject);
}
break;
case STATE_SETMETADATAKEYS:
{
ReadMetadataFile();
ReadClipsFile();
if (iClipFilePresent == false)
{
fprintf(file, "\nClip File Not Present \n");
iState = STATE_RESET;
RunIfNotReady();
}
else if (iMetadataKeyList.size() != 0)
{
PVMFStatus status;
PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO,
(0, "PVMetadataEngineTest::SetMetadataKeys Issued ClockInMS=%d", OsclTickCount::TicksToMsec(OsclTickCount::TickCount())));
status = iPVMEContainer.iPVMEInterface->SetMetaDataKeys(iMetadataKeyList);
if (status == PVMFErrInvalidState)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO,
(0, "PVMetadataEngineTest::SetMetadataKeys called in wrong state"));
}
else
{
iState = STATE_GETMETADATA;
RunIfNotReady();
}
}
else
{
iState = STATE_GETMETADATA;
RunIfNotReady();
}
}
break;
case STATE_GETMETADATA:
{
//If GetMetadata is being called second time in MultipleGetMetadataTest, we don't want these statements to execute again
if (iDataSource == NULL)
{
// Create a player data source and add it
iDataSource = new PVPlayerDataSourceURL;
}
OSCL_wHeapString<OsclMemAllocator> inputfilename;
// Convert the source file name to UCS2 and extract the filename part
PVMFFormatType iFileType;
iFileName = *it;
it++;
GetSourceFormatType(iFileName, iFileType);
oscl_UTF8ToUnicode(iFileName, oscl_strlen(iFileName), iTempWCharBuf, 512);
wFileName.set(iTempWCharBuf, oscl_strlen(iTempWCharBuf));
RetrieveFilename(wFileName.get_str(), inputfilename);
printf("\nInput File Name is %s", iFileName);
iDataSource->SetDataSourceURL(wFileName);
iDataSource->SetDataSourceFormatType(iFileType);
start_time = OsclTickCount::TicksToMsec(OsclTickCount::TickCount());
PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO,
(0, "PVMetadataEngineTest::GetMetadata Issued ClockInMS = (%d)", start_time));
OSCL_TRY(error, iCurrentCmdId = iPVMEContainer.iPVMEInterface->GetMetadata(*iDataSource, iMetadataValueList, (OsclAny*) & iContextObject));
OSCL_FIRST_CATCH_ANY(error, PVMEATB_TEST_IS_TRUE(false); iState = STATE_RESET; RunIfNotReady());
}
break;
case STATE_RESET:
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO,
(0, "PVMetadataEngineTest::Reset Issued ClockInMS=%d", OsclTickCount::TicksToMsec(OsclTickCount::TickCount())));
iCurrentCmdId = iPVMEContainer.iPVMEInterface->Reset((OsclAny*) & iContextObject);
}
break;
case STATE_DELETE:
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO,
(0, "PVMetadataEngineTest::Delete Called ClockInMS=%d", OsclTickCount::TicksToMsec(OsclTickCount::TickCount())));
PVMFStatus status = PVMetadataEngineFactory::DeletePVMetadataEngine(iPVMEContainer);
if (status != PVMFSuccess)
{
PVMEATB_TEST_IS_TRUE(false);
}
delete iDataSource;
iDataSource = NULL;
iFS.Close();
if (iPVMEContainer.iMode == PV_METADATA_ENGINE_THREADED_MODE)
{
iPVMEContainer.iSem.Close();
}
PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO,
(0, "PVMetadataEngineTest::TotalNumClips=%d", numOfClips));
PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO,
(0, "PVMetadataEngineTest::AverageGetMetaDataTimeInMS=%d", (AverageGetMetaDataTimeInMS / numOfClips)));
PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO,
(0, "PVMetadataEngineTest::MaxGetMetaDataTime=%d", MaxGetMetaDataTime));
PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iPerfLogger, PVLOGMSG_INFO,
(0, "PVMetadataEngineTest::MinGetMetaDataTime=%d", MinGetMetaDataTime));
iObserver->TestCompleted(*iTestCase);
}
break;
default:
break;
}
}
OSCL_wHeapString<OsclMemAllocator> MovieHeaderAtom::convertTimeToDate(uint32 time)
{
OSCL_HeapString<OsclMemAllocator> date;
char buf[64];
int32 numDaysInMonth[12] =
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int32 numDaysInMonthLeap[12] =
{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int32 refYear = 1904;
// (365*4 + 1) * 24 * 3600
int32 numSecsInABlkofFourYears = 126230400;
// 365*24*3600
int32 numSecInYear = 31536000;
int32 numBlksOfFour = (time / numSecsInABlkofFourYears);
int32 leftOverSecs = (time - (numBlksOfFour * numSecsInABlkofFourYears));
int32 leftOverYears = 0;
int32 year = 0;
int32 numDays = 0;
int32 numHrs = 0;
int32 numMins = 0;
int32 month = 0;
int32 milliSecs = 0;
if (leftOverSecs > numSecInYear)
{
/*To take in to consideration at least 1 year among the number of years
as leap among leftOverYear*/
leftOverSecs -= (24 * 3600);
leftOverYears = (leftOverSecs / numSecInYear);
leftOverSecs -= (leftOverYears * numSecInYear);
numDays = (uint16)(leftOverSecs / (24 * 3600));
leftOverSecs -= (numDays * 24 * 3600);
for (uint32 i = 0; i < 12; i++)
{
if (numDays >= numDaysInMonth[i])
{
numDays = (numDays - numDaysInMonth[i]);
}
else
{
month = (i + 1);
break;
}
}
}
else
{
numDays = (leftOverSecs / (24 * 3600));
leftOverSecs -= (numDays * 24 * 3600);
for (int32 i = 0; i < 12; i++)
{
if (numDays >= numDaysInMonthLeap[i])
{
numDays = (numDays - numDaysInMonthLeap[i]);
}
else
{
month = (i + 1);
break;
}
}
}
// Considering a situation where by the date is 1st Jan of any year
// the leftOverSecs would be less than the sec available in a day resulting numDays
// as 0, however that is 1st Jan from user perspective. So a day adjustment factor
// is added into numDays.
numDays += ADJUST_DAY_COUNT_USER_PERSPECTIVE_FOR_FIRST_DAY_OF_YEAR;
numHrs = (leftOverSecs / 3600);
leftOverSecs -= (numHrs * 3600);
numMins = (leftOverSecs / 60);
leftOverSecs -= (numMins * 60);
year = (refYear + (numBlksOfFour * 4) + leftOverYears);
oscl_snprintf(buf,
256,
"%04d%02d%02dT%02d%02d%02d.%03dZ",
year, month, numDays, numHrs,
numMins, leftOverSecs, milliSecs);
date += buf;
/* convert to unicode */
uint32 wDateBufLen = 64 * sizeof(oscl_wchar);
oscl_wchar wDate[64*sizeof(oscl_wchar)];
oscl_memset((OsclAny*)wDate, 0, wDateBufLen);
oscl_UTF8ToUnicode(date.get_cstr(),
(int32)(date.get_size()),
wDate,
(int32)(wDateBufLen));
OSCL_wHeapString<OsclMemAllocator> wDateStr;
wDateStr += wDate;
return (wDateStr);
}
static PVMFStatus parseMP3(const char *filename,MediaScannerClient& client) {
PVID3ParCom pvId3Param;
PVFile fileHandle;
Oscl_FileServer iFs;
uint32 duration;
//LOGD("c---> filename 好的 = %s", filename);
if (iFs.Connect() != 0) {
LOGD("=======iFs.Connect failed========>\n");
return PVMFFailure;
}
oscl_wchar output[MAX_BUFF_SIZE];
oscl_UTF8ToUnicode((const char *) filename, oscl_strlen((const char *) filename),
(oscl_wchar *) output, MAX_BUFF_SIZE);
if (0 !=
fileHandle.Open((oscl_wchar *) output, Oscl_File::MODE_READ | Oscl_File::MODE_BINARY,
iFs)) {
//LOGE("Could not open the input file for reading(Test: parse id3).\n");
return PVMFFailure;
}
fileHandle.Seek(0, Oscl_File::SEEKSET);
pvId3Param.ParseID3Tag(&fileHandle);
fileHandle.Close();
iFs.Close();
//Get the frames information from ID3 library
PvmiKvpSharedPtrVector framevector;
pvId3Param.GetID3Frames(framevector);
uint32 num_frames = framevector.size();
for (uint32 i = 0; i < num_frames; i++) {
const char *key = framevector[i]->key;
bool isUtf8 = false;
bool isIso88591 = false;
// type should follow first semicolon
const char *type = strchr(key, ';');
if (type == NULL) continue;
type++;
char tracknumkeybuf[100];
if (strncmp(key, "track-info/track-number;", 24) == 0) {
// Java expects the track number key to be called "tracknumber", so
// construct a temporary one here.
snprintf(tracknumkeybuf, sizeof(tracknumkeybuf), "tracknumber;%s", type);
key = tracknumkeybuf;
}
const char *value = framevector[i]->value.pChar_value;
// KVP_VALTYPE_UTF8_CHAR check must be first, since KVP_VALTYPE_ISO88591_CHAR
// is a substring of KVP_VALTYPE_UTF8_CHAR.
// Similarly, KVP_VALTYPE_UTF16BE_WCHAR must be checked before KVP_VALTYPE_UTF16_WCHAR
if (oscl_strncmp(type, KVP_VALTYPE_UTF8_CHAR, KVP_VALTYPE_UTF8_CHAR_LEN) == 0) {
isUtf8 = true;
} else if (
oscl_strncmp(type, KVP_VALTYPE_ISO88591_CHAR, KVP_VALTYPE_ISO88591_CHAR_LEN) ==
0) {
isIso88591 = true;
}
if (isUtf8) {
// validate to make sure it is legal utf8
uint32 valid_chars;
if (oscl_str_is_valid_utf8((const uint8 *) value, valid_chars)) {
// utf8 can be passed through directly
//LOGD("c---> key(utf8) = %s ; value = %s", key, value);
if (!client.handleStringTag(key, value)) goto failure;
} else {
// treat as ISO-8859-1 if UTF-8 fails
isIso88591 = true;
}
}
if (isIso88591) {
size_t iInLen = strlen(value);
char sOutBuf[100];
size_t iOutLen = 100;
memset(sOutBuf, 0x00, 100);
ChangeCode("GBK", "UTF-8", value, &iInLen, sOutBuf, &iOutLen);
//LOGD("c---> key(gbk) = %s ; value = %s", key, sOutBuf);
if (!client.handleStringTag(key, sOutBuf)) goto failure;
}
// treat it as iso-8859-1 and our native encoding detection will try to
// figure out what it is
/* if (isIso88591) {
// convert ISO-8859-1 to utf8, worse case is 2x inflation
const unsigned char *src = (const unsigned char *) value;
char *temp = (char *) alloca(strlen(value) * 2 + 1);
if (temp) {
char *dest = temp;
unsigned int uch;
while ((uch = *src++) != 0) {
if (uch & 0x80) {
*dest++ = (uch >> 6) | 0xc0;
*dest++ = (uch & 0x3f) | 0x80;
} else *dest++ = uch;
}
*dest = 0;
LOGD("c---> key(iso) = %s ; value = %s", key, temp);
//if (!client.addStringTag(key, temp)) goto failure;
}
}*/
// not UTF-8 or ISO-8859-1, try wide char formats
if (!isUtf8 && !isIso88591 &&
(oscl_strncmp(type, KVP_VALTYPE_UTF16BE_WCHAR, KVP_VALTYPE_UTF16BE_WCHAR_LEN) ==
0 ||
oscl_strncmp(type, KVP_VALTYPE_UTF16_WCHAR, KVP_VALTYPE_UTF16_WCHAR_LEN) == 0)) {
// convert wchar to utf8
// the id3parcom library has already taken care of byteswapping
const oscl_wchar *src = framevector[i]->value.pWChar_value;
int srcLen = oscl_strlen(src);
// worse case is 3 bytes per character, plus zero termination
int destLen = srcLen * 3 + 1;
char *dest = (char *) alloca(destLen);
if (oscl_UnicodeToUTF8(src, oscl_strlen(src), dest, destLen) > 0) {
//LOGD("c---> key(!utf8 && !iso) = %s ; value = %s", key, dest);
if (!client.handleStringTag(key, dest)) goto failure;
}
} else if (oscl_strncmp(type, KVP_VALTYPE_UINT32, KVP_VALTYPE_UINT32_LEN) == 0) {
char temp[20];
snprintf(temp, sizeof(temp), "%d", (int) framevector[i]->value.uint32_value);
//LOGD("c---> key() = %s ; value = %s", key, temp);
if (!client.handleStringTag(key, temp)) goto failure;
} else {
//LOGE("unknown tag type %s for key %s\n", type, key);
}
}
// extract non-ID3 properties below
{
OSCL_wHeapString<OsclMemAllocator> mp3filename(output);
MP3ErrorType err;
IMpeg3File mp3File(mp3filename, err);
if (err != MP3_SUCCESS) {
//LOGE("IMpeg3File constructor returned %d for %s\n", err, filename);
return err;
}
err = mp3File.ParseMp3File();
if (err != MP3_SUCCESS) {
//LOGE("IMpeg3File::ParseMp3File returned %d for %s\n", err, filename);
return err;
}
char buffer[20];
duration = mp3File.GetDuration();
sprintf(buffer, "%d", duration);
LOGD("c---> duration = %s", "duration");
//if (!client.addStringTag("duration", buffer)) goto failure;
}
return PVMFSuccess;
failure:
return PVMFFailure;
}
static PVMFStatus parseMP3(const char *filename, MediaScannerClient& client)
{
PVID3ParCom pvId3Param;
PVFile fileHandle;
Oscl_FileServer iFs;
uint32 duration;
if (iFs.Connect() != 0)
{
LOGE("iFs.Connect failed\n");
return PVMFFailure;
}
oscl_wchar output[MAX_BUFF_SIZE];
oscl_UTF8ToUnicode((const char *)filename, oscl_strlen((const char *)filename), (oscl_wchar *)output, MAX_BUFF_SIZE);
if (0 != fileHandle.Open((oscl_wchar *)output, Oscl_File::MODE_READ | Oscl_File::MODE_BINARY, iFs) )
{
LOGE("Could not open the input file for reading(Test: parse id3).\n");
return PVMFFailure;
}
fileHandle.Seek(0, Oscl_File::SEEKSET);
pvId3Param.ParseID3Tag(&fileHandle);
fileHandle.Close();
iFs.Close();
//Get the frames information from ID3 library
PvmiKvpSharedPtrVector framevector;
pvId3Param.GetID3Frames(framevector);
uint32 num_frames = framevector.size();
for (uint32 i = 0; i < num_frames;i++)
{
const char* key = framevector[i]->key;
bool validUtf8 = true;
// type should follow first semicolon
const char* type = strchr(key, ';') + 1;
if (type == 0) continue;
const char* value = framevector[i]->value.pChar_value;
// KVP_VALTYPE_UTF8_CHAR check must be first, since KVP_VALTYPE_ISO88591_CHAR
// is a substring of KVP_VALTYPE_UTF8_CHAR.
// Similarly, KVP_VALTYPE_UTF16BE_WCHAR must be checked before KVP_VALTYPE_UTF16_WCHAR
if (oscl_strncmp(type, KVP_VALTYPE_UTF8_CHAR, KVP_VALTYPE_UTF8_CHAR_LEN) == 0) {
// utf8 can be passed through directly
// but first validate to make sure it is legal utf8
uint32 valid_chars;
validUtf8 = oscl_str_is_valid_utf8((const uint8 *)value, valid_chars);
if (validUtf8 && !client.handleStringTag(key, value)) goto failure;
}
// if the value is not valid utf8, then we will treat it as iso-8859-1
// and our native encoding detection will try to figure out what it is
if (oscl_strncmp(type, KVP_VALTYPE_ISO88591_CHAR, KVP_VALTYPE_ISO88591_CHAR_LEN) == 0
|| !validUtf8) {
// iso-8859-1
// convert to utf8
// worse case is 2x inflation
const unsigned char* src = (const unsigned char *)value;
char* temp = (char *)alloca(strlen(value) * 2 + 1);
if (temp) {
char* dest = temp;
unsigned int uch;
while ((uch = *src++) != 0) {
if (uch & 0x80) {
*dest++ = (uch >> 6) | 0xc0;
*dest++ = (uch & 0x3f) | 0x80;
} else *dest++ = uch;
}
*dest = 0;
if (!client.addStringTag(key, temp)) goto failure;
}
} else if (oscl_strncmp(type, KVP_VALTYPE_UTF16BE_WCHAR, KVP_VALTYPE_UTF16BE_WCHAR_LEN) == 0 ||
