void pff_pause_disconnect_test::test()
{
int error = 0;
char *filename = new char[iFilename.get_size() + 1];
if ((filename == NULL) || (oscl_UnicodeToUTF8(iFilename.get_cstr(), iFilename.get_size(), filename, iFilename.get_size() + 1) == 0))
{
OSCL_LEAVE(-1);
}
fprintf(fileoutput, "Start play from file pause disconnect test, before add source %d, file %s\n", iUsePlayFileBeforeAddSource, filename);
delete filename;
scheduler = OsclExecScheduler::Current();
this->AddToScheduler();
if (start_async_test())
{
OSCL_TRY(error, scheduler->StartScheduler());
if (error != 0)
{
OSCL_LEAVE(error);
}
}
destroy_sink_source();
this->RemoveFromScheduler();
}
OSCL_EXPORT_REF PVMFStatus
PVMFStreamingManagerExtensionInterfaceImpl::SetClientPlayBackClock(OsclClock* clientClock)
{
PVMFSMNodeContainer* iJitterBufferNodeContainer =
iContainer->getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
PVMFJitterBufferExtensionInterface* jbExtIntf =
(PVMFJitterBufferExtensionInterface*)
(iJitterBufferNodeContainer->iExtensions[0]);
jbExtIntf->setClientPlayBackClock(clientClock);
PVMFSMNodeContainer* iMediaLayerNodeContainer =
iContainer->getNodeContainer(PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE);
if (iMediaLayerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
PVMFMediaLayerNodeExtensionInterface* mlExtIntf =
(PVMFMediaLayerNodeExtensionInterface*)
(iMediaLayerNodeContainer->iExtensions[0]);
mlExtIntf->setClientPlayBackClock(clientClock);
return PVMFSuccess;
}
void pff_eos_test::test()
{
int error = 0;
char *filename = new char[iFilename.get_size() + 1];
if ((filename == NULL) || (oscl_UnicodeToUTF8(iFilename.get_cstr(), iFilename.get_size(), filename, iFilename.get_size() + 1) == 0))
{
OSCL_LEAVE(-1);
}
fprintf(fileoutput, "Start pff eos test, num runs %d, audio eos %d, vidoe eos %d, proxy %d, file %s\n", iMaxRuns, iWaitForAudioEOS, iWaitForVideoEOS, iUseProxy, filename);
delete filename;
scheduler = OsclExecScheduler::Current();
this->AddToScheduler();
if (start_async_test())
{
OSCL_TRY(error, scheduler->StartScheduler());
if (error != 0)
{
OSCL_LEAVE(error);
}
}
destroy_sink_source();
this->RemoveFromScheduler();
}
OSCL_EXPORT_REF bool OsclMemPoolResizableAllocator::trim(OsclAny* aPtr, uint32 aBytesToFree)
{
// Amount to free has to be aligned
uint32 alignedbytestofree = oscl_mem_aligned_size(aBytesToFree);
if (alignedbytestofree > aBytesToFree)
{
// Not aligned so decrease amount to free by one alignment size
alignedbytestofree -= 8;
}
OSCL_ASSERT(alignedbytestofree <= aBytesToFree);
// Check that the returned pointer is from the memory pool
if (validateblock(aPtr) == false)
{
OSCL_LEAVE(OsclErrArgument);
// OSCL_UNUSED_RETURN(false); This statement was removed to avoid compiler warning for Unreachable Code
}
// Retrieve the block info header and validate the info
uint8* byteptr = (uint8*)aPtr;
MemPoolBlockInfo* resizeblock = (MemPoolBlockInfo*)(byteptr - iBlockInfoAlignedSize);
OSCL_ASSERT(resizeblock != NULL);
OSCL_ASSERT(resizeblock->iBlockPreFence == OSCLMEMPOOLRESIZABLEALLOCATOR_PREFENCE_PATTERN);
OSCL_ASSERT(resizeblock->iBlockPostFence == OSCLMEMPOOLRESIZABLEALLOCATOR_POSTFENCE_PATTERN);
if ((resizeblock->iBlockSize - iBlockInfoAlignedSize) < alignedbytestofree)
{
// The bytes to free in the resize is bigger than the original buffer size
OSCL_LEAVE(OsclErrArgument);
// OSCL_UNUSED_RETURN(false); This statement was removed to avoid compiler warning for Unreachable Code
}
if (alignedbytestofree < (iBlockInfoAlignedSize + OSCLMEMPOOLRESIZABLEALLOCATOR_MIN_BUFFERSIZE))
{
// The resizing cannot be done since the amount to free doesn't have
// enough space to put in a block info header plus the minimum buffer for the new free block
// So don't do anything and return
return false;
}
// Create and fill in a block info header for the memory being freed back to memory pool
MemPoolBlockInfo* freeblock = (MemPoolBlockInfo*)((uint8*)resizeblock + resizeblock->iBlockSize - alignedbytestofree);
freeblock->iBlockPreFence = OSCLMEMPOOLRESIZABLEALLOCATOR_PREFENCE_PATTERN;
freeblock->iNextFreeBlock = NULL;
freeblock->iPrevFreeBlock = NULL;
freeblock->iBlockSize = alignedbytestofree;
freeblock->iBlockBuffer = (uint8*)freeblock + iBlockInfoAlignedSize;
freeblock->iParentBuffer = resizeblock->iParentBuffer;
freeblock->iBlockPostFence = OSCLMEMPOOLRESIZABLEALLOCATOR_POSTFENCE_PATTERN;
// Return the free block to the memory pool buffer
deallocateblock(*freeblock);
// Adjust the block info for the block being resized
resizeblock->iBlockSize -= alignedbytestofree;
return true;
}
OSCL_EXPORT_REF void ThreadSafeMemPoolFixedChunkAllocator::deallocate(OsclAny* p)
{
if (iMemPool == NULL)
{
// Memory pool hasn't been allocated yet so error
OSCL_LEAVE(OsclErrNotReady);
}
uint8* ptmp = (uint8*)p;
uint8* mptmp = (uint8*)iMemPool;
if ((ptmp < mptmp) || ptmp >= (mptmp + iNumChunk*iChunkSizeMemAligned))
{
// Returned memory is not part of this memory pool
OSCL_LEAVE(OsclErrArgument);
}
if (((ptmp - mptmp) % iChunkSizeMemAligned) != 0)
{
// Returned memory is not aligned to the chunk.
OSCL_LEAVE(OsclErrArgument);
}
iMemPoolMutex.Lock();
// Put the returned chunk in the free pool
iFreeMemChunkList.push_back(p);
removeRef_internal();
if (iRefCount > 0)
{
iMemPoolMutex.Unlock();
// Notify the observer about free chunk available if waiting for such callback
if (iCheckNextAvailableFreeChunk)
{
iCheckNextAvailableFreeChunk = false;
if (iObserver)
{
iObserver->freechunkavailable(iNextAvailableContextData);
}
}
}
else
{
iMemPoolMutex.Unlock();
// when the mempool is about to be destroyed, no need to
// notify the observer. By this time, the observer should not
// be expecting it
Delete();
}
}
OSCL_EXPORT_REF void OsclMemPoolFixedChunkAllocator::deallocate(OsclAny* p)
{
if (iMemPool == NULL)
{
// Memory pool hasn't been allocated yet so error
OSCL_LEAVE(OsclErrNotReady);
}
uint8* ptmp = (uint8*)p;
uint8* mptmp = (uint8*)iMemPoolAligned;
if ((ptmp < mptmp) || ptmp >= (mptmp + iNumChunk*iChunkSizeMemAligned))
{
// Returned memory is not part of this memory pool
OSCL_LEAVE(OsclErrArgument);
}
if (((ptmp - mptmp) % iChunkSizeMemAligned) != 0)
{
// Returned memory is not aligned to the chunk.
OSCL_LEAVE(OsclErrArgument);
}
#if(!OSCL_BYPASS_MEMMGT)
// check if the same chunk was deallocated multiple times in a row
uint32 ii;
for (ii = 0; ii < iFreeMemChunkList.size(); ii++)
{
if (iFreeMemChunkList[ii] == p)
{
OSCL_LEAVE(OsclErrArgument);
}
}
#endif
// Put the returned chunk in the free pool
iFreeMemChunkList.push_back(p);
// Notify the observer about free chunk available if waiting for such callback
if (iCheckNextAvailableFreeChunk)
{
iCheckNextAvailableFreeChunk = false;
if (iObserver)
{
iObserver->freechunkavailable(iNextAvailableContextData);
}
}
// Decrement the refcount since deallocating succeeded
removeRef();
}
OSCL_EXPORT_REF OsclAny* ThreadSafeMemPoolFixedChunkAllocator::allocate(const uint32 n)
{
// Create the memory pool if it hasn't been created yet.
// Use the allocation size, n, as the chunk size for memory pool
iMemPoolMutex.Lock();
if (iChunkSize == 0)
{
iChunkSize = n;
createmempool();
}
else if (n > iChunkSize)
{
OSCL_LEAVE(OsclErrArgument);
}
if (iFreeMemChunkList.empty())
{
// No free chunk is available
iMemPoolMutex.Unlock();
return NULL;
}
// Return the next available chunk from the pool
OsclAny* freechunk = iFreeMemChunkList.back();
// Remove the chunk from the free list
iFreeMemChunkList.pop_back();
addRef_internal();
iMemPoolMutex.Unlock();
return freechunk;
}
OsclMemPoolResizableAllocator::MemPoolBlockInfo* OsclMemPoolResizableAllocator::findfreeblock(uint32 aBlockAlignedSize)
{
OSCL_ASSERT(aBlockAlignedSize > 0);
OSCL_ASSERT(aBlockAlignedSize == oscl_mem_aligned_size(aBlockAlignedSize));
// Go through each mempool buffer and return the first free block that
// is bigger than the specified size
if (aBlockAlignedSize == 0)
{
// Request should be non-zero
OSCL_LEAVE(OsclErrArgument);
// OSCL_UNUSED_RETURN(NULL); This statement was removed to avoid compiler warning for Unreachable Code
}
for (uint32 i = 0; i < iMemPoolBufferList.size(); ++i)
{
MemPoolBufferInfo* bufferinfo = iMemPoolBufferList[i];
MemPoolBlockInfo* blockinfo = bufferinfo->iNextFreeBlock;
while (blockinfo != NULL)
{
if ((blockinfo->iBlockSize/* - iBlockInfoAlignedSize*/) >= aBlockAlignedSize)
{
// This free block fits the request
return blockinfo;
}
// Go to the next free block
blockinfo = blockinfo->iNextFreeBlock;
}
}
return NULL;
}
OSCL_EXPORT_REF uint32 OsclMemPoolResizableAllocator::getLargestContiguousFreeBlockSize() const
{
uint32 blockSz = 0;
if (iMemPoolBufferNumLimit > 0)
{
for (uint32 i = 0; i < iMemPoolBufferList.size(); ++i)
{
MemPoolBufferInfo* bufferinfo = iMemPoolBufferList[i];
if (bufferinfo)
{
MemPoolBlockInfo* blockinfo = bufferinfo->iNextFreeBlock;
while (blockinfo != NULL)
{
if (blockinfo->iBlockSize > blockSz) blockSz = blockinfo->iBlockSize;
blockinfo = blockinfo->iNextFreeBlock;
}
}
}
}
else
OSCL_LEAVE(OsclErrNotSupported);
if (blockSz > iBlockInfoAlignedSize) blockSz -= iBlockInfoAlignedSize;
else blockSz = 0;
return blockSz;
}
void CompositionOffsetAtom::Run()
{
// Create it for the first time
if ((MT_SampleCount == NULL) && (MT_EntryCount == NULL))
{
PVMFStatus status = CreateMarkerTable();
if (status == PVMFFailure)
{
OSCL_LEAVE(OsclErrNoMemory);
}
iMarkerTableCreation = true;
}
PopulateMarkerTable();
// check for entry count being exhausted.. table iterated completely
if ((entrycountTraversed < _entryCount) && (refSample < _iTotalNumSamplesInTrack)
&& (MT_Counter < _iTotalNumSamplesInTrack / MT_SAMPLECOUNT_INCREMENT))
{
RunIfNotReady();
}
return;
}
void PvmfMediaInputNode::createContext(PvmiMIOSession aSession,
PvmiCapabilityContext& aContext)
{
OSCL_UNUSED_ARG(aSession);
OSCL_UNUSED_ARG(aContext);
// not supported
OSCL_LEAVE(PVMFErrNotSupported);
}
void PVMp4FFComposerNode::DeleteContext(PvmiMIOSession aSession,
PvmiCapabilityContext& aContext)
{
OSCL_UNUSED_ARG(aSession);
OSCL_UNUSED_ARG(aContext);
// not supported
OSCL_LEAVE(PVMFErrNotSupported);
}
OSCL_EXPORT_REF CDecoder_AMR_NB *CDecoder_AMR_NB::NewL()
{
CDecoder_AMR_NB *dec = new CDecoder_AMR_NB;
if (dec == NULL)
OSCL_LEAVE(OsclErrNoMemory);
else
dec->ConstructL();
return dec;
}
OSCL_EXPORT_REF PVAVCDecoderInterface* PVAVCDecoderFactory::CreatePVAVCDecoder()
{
PVAVCDecoderInterface* videodec = NULL;
videodec = PVAVCDecoder::New();
if (videodec == NULL)
{
OSCL_LEAVE(OsclErrNoMemory);
}
return videodec;
}
OSCL_EXPORT_REF PVMFNodeInterface* PVMFOMXAudioDecNodeFactory::CreatePVMFOMXAudioDecNode(int32 aPriority)
{
PVMFNodeInterface* node = NULL;
node = new PVMFOMXAudioDecNode(aPriority);
if (node == NULL)
{
OSCL_LEAVE(OsclErrNoMemory);
}
return node;
}
OSCL_EXPORT_REF PVMFRecognizerPluginInterface* PVPLSFFRecognizerFactory::CreateRecognizerPlugin()
{
PVMFRecognizerPluginInterface* plugin = NULL;
plugin = OSCL_STATIC_CAST(PVMFRecognizerPluginInterface*, OSCL_NEW(PVPLSFFRecognizerPlugin, ()));
if (plugin == NULL)
{
OSCL_LEAVE(OsclErrNoMemory);
}
return plugin;
}
OSCL_EXPORT_REF PVMFNodeInterface* PVMFOMXVideoDecNodeFactory::CreatePVMFOMXVideoDecNode(int32 aPriority, bool aHwAccelerated)
{
PVMFNodeInterface* node = NULL;
node = new PVMFOMXVideoDecNode(aPriority, aHwAccelerated);
if (node == NULL)
{
OSCL_LEAVE(OsclErrNoMemory);
}
return node;
}
OSCL_EXPORT_REF PVMFNodeInterface* PVMFAACFFParserNodeFactory::CreatePVMFAACFFParserNode(int32 aPriority)
{
PVMFNodeInterface* node = NULL;
node = OSCL_NEW(PVMFAACFFParserNode, (aPriority));
if (node == NULL)
{
OSCL_LEAVE(OsclErrNoMemory);
}
return node;
}
OsclMemPoolResizableAllocator::MemPoolBufferInfo* OsclMemPoolResizableAllocator::addnewmempoolbuffer(uint32 aBufferAlignedSize)
{
OSCL_ASSERT(aBufferAlignedSize > 0);
OSCL_ASSERT(aBufferAlignedSize == oscl_mem_aligned_size(aBufferAlignedSize));
// Allocate memory for one buffer
uint8* newbuffer = NULL;
if (iMemPoolBufferAllocator)
{
// Use the outside allocator
newbuffer = (uint8*)iMemPoolBufferAllocator->ALLOCATE(aBufferAlignedSize);
}
else
{
// Allocate directly from heap
newbuffer = (uint8*)OSCL_MALLOC(aBufferAlignedSize);
}
if (newbuffer == NULL)
{
OSCL_LEAVE(OsclErrNoMemory);
// OSCL_UNUSED_RETURN(NULL); This statement was removed to avoid compiler warning for Unreachable Code
}
#if OSCL_MEM_FILL_WITH_PATTERN
oscl_memset(newbuffer, 0x55, aBufferAlignedSize);
#endif
// Fill in the buffer info header
MemPoolBufferInfo* newbufferinfo = (MemPoolBufferInfo*)newbuffer;
newbufferinfo->iBufferPreFence = OSCLMEMPOOLRESIZABLEALLOCATOR_PREFENCE_PATTERN;
newbufferinfo->iStartAddr = (OsclAny*)(newbuffer + iBufferInfoAlignedSize);
newbufferinfo->iEndAddr = (OsclAny*)(newbuffer + aBufferAlignedSize - 1);
newbufferinfo->iBufferSize = aBufferAlignedSize;
newbufferinfo->iNumOutstanding = 0;
newbufferinfo->iNextFreeBlock = (MemPoolBlockInfo*)(newbufferinfo->iStartAddr);
newbufferinfo->iAllocatedSz = 0;
newbufferinfo->iBufferPostFence = OSCLMEMPOOLRESIZABLEALLOCATOR_POSTFENCE_PATTERN;
// Put in one free block in the new buffer
MemPoolBlockInfo* freeblockinfo = (MemPoolBlockInfo*)(newbufferinfo->iStartAddr);
freeblockinfo->iBlockPreFence = OSCLMEMPOOLRESIZABLEALLOCATOR_PREFENCE_PATTERN;
freeblockinfo->iNextFreeBlock = NULL;
freeblockinfo->iPrevFreeBlock = NULL;
freeblockinfo->iBlockSize = aBufferAlignedSize - iBufferInfoAlignedSize;
freeblockinfo->iBlockBuffer = (uint8*)freeblockinfo + iBlockInfoAlignedSize;
freeblockinfo->iParentBuffer = newbufferinfo;
freeblockinfo->iBlockPostFence = OSCLMEMPOOLRESIZABLEALLOCATOR_POSTFENCE_PATTERN;
// Add the new buffer to the list
iMemPoolBufferList.push_front(newbufferinfo);
return newbufferinfo;
}
OSCL_EXPORT_REF void PVMIExternalDownloadFileMonitor::StopMonitoring(void)
{
if (iState != STATE_MONITORING)
{
//Calling StopMonitoring when not monitoring a file is an error.
OSCL_LEAVE(OsclErrGeneral);
}
iState = STATE_IDLE;
iFile.Close();
iFileServer.Close();
RemoveFromScheduler();
}
void PVMFSocketPort::setParametersSync(PvmiMIOSession aSession,
PvmiKvp* aParameters,
int num_elements,
PvmiKvp * & aRet_kvp)
{
OSCL_UNUSED_ARG(aSession);
PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_INFO, (0, "PVMFSocketPort::getParametersSync: aSession=0x%x, aParameters=0x%x, num_elements=%d, aRet_kvp=0x%x",
aSession, aParameters, num_elements, aRet_kvp));
if (!aParameters || (num_elements != 1) ||
(pv_mime_strcmp(aParameters->key, PVMF_SOCKET_PORT_SPECIFIC_ALLOCATOR_VALTYPE) != 0))
{
aRet_kvp = aParameters;
OSCL_LEAVE(OsclErrArgument);
}
if (aParameters->value.key_specific_value == NULL)
{
aRet_kvp = aParameters;
OSCL_LEAVE(OsclErrArgument);
}
}
PVMFStatus PVMFAvcEncPort::AllocateKvp(PvmiKvp*& aKvp, PvmiKeyType aKey, int32 aNumParams)
{
LOG_STACK_TRACE((0, "PVMFAvcEncPort::AllocateKvp"));
uint8* buf = NULL;
uint32 keyLen = oscl_strlen(aKey) + 1;
int32 err = 0;
OSCL_TRY(err,
buf = (uint8*)iAlloc.allocate(aNumParams * (sizeof(PvmiKvp) + keyLen));
if (!buf)
OSCL_LEAVE(OsclErrNoMemory);
);
OSCL_EXPORT_REF void PVMFBufferDataSource::QueryInterface(const PVUuid& aUuid, OsclAny*& aPtr)
{
aPtr = NULL;
if (aUuid == PVMI_CAPABILITY_AND_CONFIG_PVUUID)
{
aPtr = (PvmiCapabilityAndConfig*)this;
}
else
{
OSCL_LEAVE(OsclErrNotSupported);
}
}
void PvmfMediaInputNode::setContextParameters(PvmiMIOSession aSession,
PvmiCapabilityContext& aContext,
PvmiKvp* aParameters,
int aNumElements)
{
OSCL_UNUSED_ARG(aSession);
OSCL_UNUSED_ARG(aContext);
OSCL_UNUSED_ARG(aParameters);
OSCL_UNUSED_ARG(aNumElements);
// not supported
OSCL_LEAVE(PVMFErrNotSupported);
}
OsclAny* OsclMemPoolResizableAllocator::allocateblock(MemPoolBlockInfo& aBlockPtr, uint32 aNumAlignedBytes)
{
OSCL_ASSERT(aNumAlignedBytes > 0);
OSCL_ASSERT(aNumAlignedBytes == oscl_mem_aligned_size(aNumAlignedBytes));
if (aNumAlignedBytes == 0)
{
OSCL_LEAVE(OsclErrArgument);
// OSCL_UNUSED_RETURN(NULL); This statement was removed to avoid compiler warning for Unreachable Code
}
// Remove the free block from the double linked list
if (aBlockPtr.iPrevFreeBlock == NULL && aBlockPtr.iNextFreeBlock != NULL)
{
// Removing from the beginning of the free list
aBlockPtr.iNextFreeBlock->iPrevFreeBlock = NULL;
aBlockPtr.iParentBuffer->iNextFreeBlock = aBlockPtr.iNextFreeBlock;
}
else if (aBlockPtr.iPrevFreeBlock != NULL && aBlockPtr.iNextFreeBlock == NULL)
{
// Removing from the end of the free list
aBlockPtr.iPrevFreeBlock->iNextFreeBlock = NULL;
}
else if (aBlockPtr.iPrevFreeBlock == NULL && aBlockPtr.iNextFreeBlock == NULL)
{
// Free list becomes empty so update the parent buffer's link
aBlockPtr.iParentBuffer->iNextFreeBlock = NULL;
}
else
{
// Removing from middle of the free list
aBlockPtr.iPrevFreeBlock->iNextFreeBlock = aBlockPtr.iNextFreeBlock;
aBlockPtr.iNextFreeBlock->iPrevFreeBlock = aBlockPtr.iPrevFreeBlock;
}
aBlockPtr.iNextFreeBlock = NULL;
aBlockPtr.iPrevFreeBlock = NULL;
aBlockPtr.iParentBuffer->iAllocatedSz += aBlockPtr.iBlockSize;
// Resize the block if too large
uint32 extraspace = aBlockPtr.iBlockSize - iBlockInfoAlignedSize - aNumAlignedBytes;
if (extraspace > (iBlockInfoAlignedSize + OSCLMEMPOOLRESIZABLEALLOCATOR_MIN_BUFFERSIZE))
{
trim(aBlockPtr.iBlockBuffer, extraspace);
}
#if OSCL_MEM_FILL_WITH_PATTERN
oscl_memset(aBlockPtr.iBlockBuffer, 0x55, (aBlockPtr.iBlockSize - iBlockInfoAlignedSize));
#endif
return aBlockPtr.iBlockBuffer;
}
OSCL_EXPORT_REF void ThreadSafeMemPoolFixedChunkAllocator::createmempool()
{
if (iChunkSize == 0 || iNumChunk == 0)
{
OSCL_LEAVE(OsclErrArgument);
}
// Create one block of memory for the memory pool
iChunkSizeMemAligned = oscl_mem_aligned_size(iChunkSize);
int32 leavecode = 0;
if (iMemPoolAllocator)
{
OSCL_TRY(leavecode, iMemPool = iMemPoolAllocator->ALLOCATE(iNumChunk * iChunkSizeMemAligned));
}
else
{
OSCL_TRY(leavecode, iMemPool = OSCL_MALLOC(iNumChunk * iChunkSizeMemAligned));
}
if (leavecode || iMemPool == NULL)
{
OSCL_LEAVE(OsclErrNoMemory);
}
#if OSCL_MEM_FILL_WITH_PATTERN
oscl_memset(iMemPool, 0x55, iNumChunk*iChunkSizeMemAligned);
#endif
// Set up the free mem chunk list vector
iFreeMemChunkList.reserve(iNumChunk);
uint8* chunkptr = (uint8*)iMemPool;
for (uint32 i = 0; i < iNumChunk; ++i)
{
iFreeMemChunkList.push_back((OsclAny*)chunkptr);
chunkptr += iChunkSizeMemAligned;
}
}
TPVStatusCode H223LowerLayer::SetLevel(TPVH223Level muxLevel)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "H223LowerLayer::SetLevel muxLevel=%d", muxLevel));
if (muxLevel == H223_LEVEL_UNKNOWN || muxLevel > H223_LEVEL2_OH)
{
OSCL_LEAVE(PVMFErrNotSupported);
}
CreateParcom(muxLevel);
SetStuffingSize(muxLevel);
return EPVT_Success;
}
OSCL_EXPORT_REF uint32 OsclMemPoolResizableAllocator::getBufferSize() const
{
if (iMemPoolBufferNumLimit == 0)
OSCL_LEAVE(OsclErrNotSupported);
uint32 bufferSize = 0;
for (uint32 i = 0; i < iMemPoolBufferList.size(); ++i)
{
MemPoolBufferInfo* bufferinfo = iMemPoolBufferList[i];
bufferSize += getMemPoolBufferSize(bufferinfo);
}
return bufferSize;
}
OSCL_EXPORT_REF PVMFStatus
PVMFStreamingManagerExtensionInterfaceImpl::setPayloadParserRegistry(PayloadParserRegistry* registry)
{
PVMFSMNodeContainer* iMediaLayerNodeContainer =
iContainer->getNodeContainer(PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE);
if (iMediaLayerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
PVMFMediaLayerNodeExtensionInterface* mlExtIntf =
(PVMFMediaLayerNodeExtensionInterface*)
(iMediaLayerNodeContainer->iExtensions[0]);
return (mlExtIntf->setPayloadParserRegistry(registry));
}
OSCL_EXPORT_REF void BitStreamParser::NextBits(uint32 numberOfBits)
{
//bitpos counts down from 7 to 0, so subtract it from 7 to get the ascending position.
uint32 newbitpos = numberOfBits + (MOST_SIG_BIT - bitpos);
//Convert the ascending bit position to a descending position using only the least-significant bits.
bitpos = MOST_SIG_BIT - (newbitpos & LEAST_SIG_3_BITS_MASK);
//Calculate the number of bytes advanced.
bytepos += (newbitpos / BITS_PER_BYTE);
// Make sure bytepos won't exceed the size of the buffer while reading
if (bytepos >= (start + size))
{
OSCL_LEAVE(OsclErrOverflow);
}
}