uint32 OsclNativeFile::Read(OsclAny *buffer, uint32 size, uint32 numelements)
{
#ifdef ENABLE_SHAREDFD_PLAYBACK
if (iSharedFd >= 0) {
// restore position, no locking is needed because all access to the
// shared filedescriptor is done by the same thread.
lseek64(iSharedFd, iSharedFilePosition + iSharedFileOffset, SEEK_SET);
uint32 count = size * numelements;
if (iSharedFilePosition + count > iSharedFileSize) {
count = iSharedFileSize - iSharedFilePosition;
}
ssize_t numread = read(iSharedFd, buffer, count);
// unlock
long long curpos = lseek64(iSharedFd, 0, SEEK_CUR);
if (curpos >= 0) {
iSharedFilePosition = curpos - iSharedFileOffset;
}
if (numread < 0) {
return numread;
}
return numread / size;
}
#endif
if (iFile)
{
return fread(buffer, OSCL_STATIC_CAST(int32, size), OSCL_STATIC_CAST(int32, numelements), iFile);
}
return 0;
}
uint32 OsclNativeFile::Write(const OsclAny *buffer, uint32 size, uint32 numelements)
{
#ifdef ENABLE_SHAREDFD_PLAYBACK
if (iSharedFd >= 0)
return 0;
#endif
if (iFile)
{
return fwrite(buffer, OSCL_STATIC_CAST(int32, size), OSCL_STATIC_CAST(int32, numelements), iFile);
}
return 0;
}
OSCL_EXPORT_REF OsclAny* OsclTLSRegistry::getInstance(uint32 ID, int32 &aError)
{
OSCL_ASSERT(ID < OSCL_TLS_MAX_SLOTS);
aError = 0;
TOsclTlsKey* pkey = NULL;
sLock.Lock();
#if (OSCL_TLS_IS_KEYED)
if (!iTlsKey)
{
aError = EPVErrorBaseNotInstalled;//No table!
sLock.Unlock();
return NULL;
}
pkey = iTlsKey->iOsclTlsKey;
#endif
registry_pointer_type registry = OSCL_STATIC_CAST(registry_pointer_type , TLSStorageOps::get_registry(pkey));
if (!OSCL_TLS_REGISTRY_VALID(registry))
{
aError = EPVErrorBaseNotInstalled;//No registry!
sLock.Unlock();
return NULL;
}
registry_type id = registry[ID];
sLock.Unlock();
return id;
}
OSCL_EXPORT_REF void OsclTLSRegistry::registerInstance(OsclAny* ptr, uint32 ID, int32 &aError)
{
OSCL_ASSERT(ID < OSCL_TLS_MAX_SLOTS);
aError = 0;
TOsclTlsKey *pkey = NULL;
#if (OSCL_TLS_IS_KEYED)
if (!iTlsKey)
{
aError = EPVErrorBaseNotInstalled;//No table!
return ;
}
pkey = iTlsKey->iOsclTlsKey;
#endif
registry_pointer_type registry = OSCL_STATIC_CAST(registry_pointer_type , TLSStorageOps::get_registry(pkey));
if (!OSCL_TLS_REGISTRY_VALID(registry))
{
aError = EPVErrorBaseNotInstalled;//no registry!
return;
}
registry[ID] = ptr;
}
OSCL_EXPORT_REF oscl_wchar oscl_tolower(const oscl_wchar car)
{
if (car >= 65 && car <= 90)
return (OSCL_STATIC_CAST(oscl_wchar, (car + OSCL_ASCII_CASE_MAGIC_BIT)));
else
return car;
}
OSCL_EXPORT_REF void OsclTLSRegistry::cleanup(Oscl_DefAlloc &alloc, int32 &aError)
{
TOsclTlsKey* pkey = NULL;
aError = 0;
sLock.Lock();
#if (OSCL_TLS_IS_KEYED)
if (!iTlsKey)
{
aError = EPVErrorBaseNotInstalled;//No key!
sLock.Unlock();
return;
}
pkey = iTlsKey->iOsclTlsKey;
#endif
//Cleanup this thread's registry
registry_pointer_type registry = OSCL_STATIC_CAST(registry_pointer_type , TLSStorageOps::get_registry(pkey));
if (!OSCL_TLS_REGISTRY_VALID(registry))
{
aError = EPVErrorBaseNotInstalled;//No registry!
sLock.Unlock();
return;
}
alloc.deallocate(registry);
TLSStorageOps::save_registry(pkey, NULL, aError);
if (aError)
{
sLock.Unlock();
return;
}
#if (OSCL_TLS_IS_KEYED)
//Remove Tls key
iTlsKey->iRefCnt--;
if (iTlsKey->iRefCnt == 0)
{
//Deallocate key.
OSCL_TLS_KEY_DELETE_FUNC(*pkey);
alloc.deallocate(pkey);
iTlsKey->~TlsKey();
alloc.deallocate(iTlsKey);
iTlsKey = NULL;
}
#endif
sLock.Unlock();
}
void ML::MsgLoopRjtSend(PS_MlRejectCause pCause)
{
S_MaintenanceLoopReject maintenanceLoopReject ;
S_H245Msg h245Msg ;
PS_MlRejectType temp = &(maintenanceLoopReject.mlRejectType);
LoopTypeRead(OSCL_STATIC_CAST(PS_MlRequestType, temp));
oscl_memcpy((int8*)&maintenanceLoopReject.mlRejectCause , (int8*)pCause , sizeof(S_MlRejectCause)) ;
h245Msg.Type1 = H245_MSG_RPS ;
h245Msg.Type2 = MSGTYP_ML_RJT ;
h245Msg.pData = (uint8*) & maintenanceLoopReject ;
MessageSend(&h245Msg) ;
}
void ML::MsgLoopAckSend(void)
{
S_MaintenanceLoopAck maintenanceLoopAck ;
S_H245Msg h245Msg ;
PS_MlAckType temp = &(maintenanceLoopAck.mlAckType);
LoopTypeRead(OSCL_STATIC_CAST(PS_MlRequestType, temp));
h245Msg.Type1 = H245_MSG_RPS ;
h245Msg.Type2 = MSGTYP_ML_ACK ;
h245Msg.pData = (uint8*) & maintenanceLoopAck ;
MessageSend(&h245Msg) ;
}
OSCL_EXPORT_REF void OsclTLSRegistry::initialize(Oscl_DefAlloc &alloc, int32 &aError)
{
TOsclTlsKey* pkey = NULL;
aError = 0;
#if ( OSCL_TLS_IS_KEYED)
//Allocate the table on the first init call.
//Note there's some risk of thread contention here, since
//the thread lock is not available until after this step.
if (!iTlsKey)
{
OsclAny* table = alloc.allocate(sizeof(TlsKey));
if (!table)
{
aError = EPVErrorBaseOutOfMemory;
return;
}
//allocate space for key
pkey = (TOsclTlsKey*)alloc.allocate(sizeof(TOsclTlsKey));
if (!pkey)
{
aError = EPVErrorBaseOutOfMemory;
alloc.deallocate(table);
return;
}
//create key for this thread.
if (!OSCL_TLS_KEY_CREATE_FUNC(*pkey))
{
aError = EPVErrorBaseSystemCallFailed;
alloc.deallocate(pkey);
alloc.deallocate(table);
return;
}
iTlsKey = new(table) TlsKey();
iTlsKey->iLock.Lock();
iTlsKey->iRefCnt++;
iTlsKey->iOsclTlsKey = pkey;
iTlsKey->iLock.Unlock();
}
else
{
iTlsKey->iLock.Lock();
iTlsKey->iRefCnt++;
pkey = iTlsKey->iOsclTlsKey;
iTlsKey->iLock.Unlock();
}
#endif
// allocate the space and save the pointer
registry_pointer_type registry = OSCL_STATIC_CAST(registry_pointer_type,
alloc.allocate(sizeof(registry_type) * OSCL_TLS_MAX_SLOTS));
if (registry == 0)
{
aError = EPVErrorBaseOutOfMemory;
return;
}
// initialize all TLSs to 0
for (uint32 ii = 0; ii < OSCL_TLS_MAX_SLOTS; ii++)
registry[ii] = 0;
// initialize the magic number
registry[OSCL_TLS_ID_MAGICNUM] = (OsclAny*)OSCL_TLS_MAGIC_NUMBER;
// save it away
TLSStorageOps::save_registry(pkey, registry, aError);
}
TrackFragmentRandomAccessAtom ::TrackFragmentRandomAccessAtom(MP4_FF_FILE *fp, uint32 size, uint32 type)
: FullAtom(fp, size, type)
{
OSCL_UNUSED_ARG(type);
_entry_count = 0;
_trackId = 0;
_length_size_of_traf_num = 0;
_length_size_of_trun_num = 0;
_length_size_of_sample_num = 0;
_pTFRAEntriesVec = NULL;
const uint32 version = getVersion();
iLogger = PVLogger::GetLoggerObject("mp4ffparser");
iStateVarLogger = PVLogger::GetLoggerObject("mp4ffparser_mediasamplestats");
iParsedDataLogger = PVLogger::GetLoggerObject("mp4ffparser_parseddata");
if (_success)
{
PV_MP4_FF_NEW(fp->auditCB, TFRAEntriesVecType, (), _pTFRAEntriesVec);
if (!AtomUtils::read32(fp, _trackId))
{
_success = false;
_mp4ErrorCode = READ_TRACK_FRAGMENT_RANDOM_ACCESS_ATOM_FAILED;
return;
}
if (!AtomUtils::read32(fp, _reserved))
{
_success = false;
_mp4ErrorCode = READ_TRACK_FRAGMENT_RANDOM_ACCESS_ATOM_FAILED;
return;
}
_length_size_of_traf_num = OSCL_STATIC_CAST(uint8, (_reserved & 0x00000003));
_length_size_of_trun_num = OSCL_STATIC_CAST(uint8, ((_reserved >> 2) & 0x00000003));
_length_size_of_sample_num = OSCL_STATIC_CAST(uint8, (((_reserved >> 4) & 0x00000003)));
if (!AtomUtils::read32(fp, _entry_count))
{
_success = false;
_mp4ErrorCode = READ_TRACK_FRAGMENT_RANDOM_ACCESS_ATOM_FAILED;
return;
}
for (uint32 idx = 0; idx < _entry_count ; idx++)
{
TFRAEntries *pTFRAEntries = NULL;
PV_MP4_FF_NEW(fp->auditCB, TFRAEntries, (fp, version, _length_size_of_traf_num,
_length_size_of_trun_num,
_length_size_of_sample_num),
pTFRAEntries);
if (pTFRAEntries)
{
_pTFRAEntriesVec->push_back(pTFRAEntries);
PVMF_MP4FFPARSER_LOGMEDIASAMPELSTATEVARIABLES((0, "TrackFragmentRandom Access Point _sample_number[%u] =%u", idx, pTFRAEntries->GetSampleNumber()));
PVMF_MP4FFPARSER_LOGMEDIASAMPELSTATEVARIABLES((0, "TrackFragmentRandom Access Point TimeStamp [%u] =%u", idx, pTFRAEntries->getTimeStamp()));
PVMF_MP4FFPARSER_LOGMEDIASAMPELSTATEVARIABLES((0, "TrackFragmentRandom Access Point MoofOffset [%u] =%u", idx, pTFRAEntries->getTimeMoofOffset()));
PVMF_MP4FFPARSER_LOGMEDIASAMPELSTATEVARIABLES((0, "TrackFragmentRandom Access Point _traf_number [%u] =%u", idx, pTFRAEntries->GetTrafNumber()));
PVMF_MP4FFPARSER_LOGMEDIASAMPELSTATEVARIABLES((0, "TrackFragmentRandom Access Point _trun_number [%u] =%u", idx, pTFRAEntries->GetTrunNumber()));
}
else
{
_success = false;
_mp4ErrorCode = READ_TRACK_FRAGMENT_RANDOM_ACCESS_ATOM_FAILED;
return;
}
}
}
}
