| /* ------------------------------------------------------------------ |
| * Copyright (C) 1998-2009 PacketVideo |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either |
| * express or implied. |
| * See the License for the specific language governing permissions |
| * and limitations under the License. |
| * ------------------------------------------------------------------- |
| */ |
| #include "tscsrpbuffer.h" |
| #define MAX_TSCSRP_BUFFER_SZ 768 |
| #define NUM_TSCSRP_FRAGS 24 |
| #define PV_TSC_SRP_BUFFER_TIMER_ID 1 |
| #define TSC_SRP_BUFFER_TIMEOUT 50 |
| |
| |
| TscSrpBufferLLPortIn *TscSrpBufferLLPortIn::NewL(TscSrpBuffer *aTscSrpBuffer) |
| { |
| TscSrpBufferLLPortIn *self = OSCL_NEW(TscSrpBufferLLPortIn, (aTscSrpBuffer)); |
| if (self) |
| { |
| ConstructSelf(self); |
| } |
| else |
| { |
| OSCL_LEAVE(PVMFErrNoMemory); |
| } |
| return self; |
| } |
| |
| void TscSrpBufferLLPortIn::ConstructSelf(TscSrpBufferLLPortIn* self) |
| { |
| int error; |
| OSCL_TRY(error, self->ConstructL();); |
| if (error) |
| { |
| OSCL_DELETE(self); |
| OSCL_LEAVE(error); |
| } |
| } |
| |
| |
| TscSrpBufferLLPortIn::~TscSrpBufferLLPortIn() |
| { |
| if (iFrag) |
| { |
| iMediaFragAlloc->deallocate_fragment(iFrag); |
| iFrag = NULL; |
| } |
| |
| if (iPkt) |
| { |
| iPkt->Clear(); |
| iMediaPktAlloc.deallocate_packet(iPkt); |
| iPkt = NULL; |
| } |
| |
| if (iMediaFragAlloc) |
| { |
| OSCL_DELETE(iMediaFragAlloc); |
| iMediaFragAlloc = NULL; |
| } |
| } |
| |
| PVMFStatus TscSrpBufferLLPortIn::Receive(PVMFSharedMediaMsgPtr aMsg) |
| { |
| OsclRefCounterMemFrag frag; |
| PVMFSharedMediaDataPtr mediaData; |
| convertToPVMFMediaData(mediaData, aMsg); |
| uint32 fullH245Msg = mediaData->getMarkerInfo(); |
| |
| if (iFrag == NULL) |
| { |
| iFrag = iMediaFragAlloc->allocate_fragment(MAX_TSCSRP_BUFFER_SZ); |
| if (iFrag == NULL) return PVMFFailure; |
| } |
| |
| for (uint32 i = 0; i < mediaData->getNumFragments(); i++) |
| { |
| if (mediaData->getMediaFragment(i, frag)) |
| { |
| if ((frag.getMemFragSize() + iCurSize) > MAX_TSCSRP_BUFFER_SZ) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iTscSrpBuffer->iLogger, PVLOGMSG_STACK_TRACE, |
| (0, "TscSrpBufferLLPortIn::PutData MAX_TSCSRP_BUFFER_SZ size exceeded")); |
| fullH245Msg = true; |
| break; |
| } |
| else |
| { |
| oscl_memcpy(iFrag->GetPtr() + iCurSize, frag.getMemFragPtr(), |
| frag.getMemFragSize()); |
| iCurSize += frag.getMemFragSize(); |
| } |
| } |
| } |
| |
| if (fullH245Msg) |
| { |
| iFrag->GetFragment()->len = iCurSize; |
| iPkt->AddMediaFragment(iFrag); |
| iMediaFragAlloc->deallocate_fragment(iFrag); |
| iFrag = NULL; |
| iCurSize = 0; |
| |
| iTscSrpBuffer->ProcessIncomingSrpPacket(iPkt); |
| iPkt->Clear(); |
| } |
| |
| return PVMFSuccess; |
| } |
| |
| void TscSrpBufferLLPortIn::ConstructL() |
| { |
| iMediaFragAlloc = OSCL_NEW(PoolFragmentAllocator, (NUM_TSCSRP_FRAGS, |
| MAX_TSCSRP_BUFFER_SZ)); |
| OsclError::LeaveIfNull(iMediaFragAlloc); |
| iPkt = iMediaPktAlloc.allocate_packet(); |
| } |
| |
| TscSrpBuffer *TscSrpBuffer::NewL() |
| { |
| TscSrpBuffer *self = OSCL_NEW(TscSrpBuffer, ()); |
| if (self) |
| { |
| ConstructSelf(self); |
| } |
| else |
| { |
| OSCL_LEAVE(PVMFErrNoMemory); |
| } |
| |
| return self; |
| } |
| |
| void TscSrpBuffer::ConstructSelf(TscSrpBuffer* self) |
| { |
| int error; |
| OSCL_TRY(error, self->ConstructL();); |
| if (error) |
| { |
| OSCL_DELETE(self); |
| OSCL_LEAVE(error); |
| } |
| } |
| |
| |
| TscSrpBuffer::~TscSrpBuffer() |
| { |
| iTxData.Unbind(); |
| |
| if (iLLPortIn) |
| { |
| OSCL_DELETE(iLLPortIn); |
| iLLPortIn = NULL; |
| } |
| |
| if (iLLPortOut) |
| { |
| OSCL_DELETE(iLLPortOut); |
| iLLPortOut = NULL; |
| } |
| |
| if (iTimer) |
| { |
| iTimer->Clear(); |
| OSCL_DELETE(iTimer); |
| iTimer = NULL; |
| } |
| |
| if (iTxPacketAlloc) |
| { |
| OSCL_DELETE(iTxPacketAlloc); |
| iTxPacketAlloc = NULL; |
| } |
| |
| if (iTxMediaDataImplMemAlloc) |
| { |
| OSCL_DELETE(iTxMediaDataImplMemAlloc); |
| iTxMediaDataImplMemAlloc = NULL; |
| } |
| |
| if (iTxMediaMsgPoolAlloc) |
| { |
| OSCL_DELETE(iTxMediaMsgPoolAlloc); |
| iTxMediaMsgPoolAlloc = NULL; |
| } |
| } |
| |
| void TscSrpBuffer::ProcessIncomingSrpPacket(MediaPacket* pPkt) |
| { |
| iH245Interface.Dispatch(pPkt); |
| } |
| |
| void TscSrpBuffer::ProcessOutgoingH245Packet(MediaPacket* pPkt) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, |
| (0, "TscSrpBuffer::ProcessOutgoingH245Packet instance=%x, pPkt=%x", |
| this, pPkt)); |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, |
| (0, "TscSrpBuffer::ProcessOutgoingH245Packet pPkt length=%d", |
| pPkt->GetLength())); |
| |
| if (iState != TscSrpBufferStarted) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, |
| (0, "TscSrpBuffer::ProcessOutgoingH245Packet - Error: Message received in stopped state")); |
| return; |
| } |
| |
| //Allocate message and data |
| if (iTxData.GetRep() == NULL) |
| { |
| OsclSharedPtr<PVMFMediaDataImpl> data; |
| |
| data = iTxPacketAlloc->allocate(MAX_TSCSRP_BUFFER_SZ); |
| if (!data) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, |
| PVLOGMSG_ERR, (0, |
| "TscSrpBuffer::ProcessOutgoingH245Packet - Unable allocate tx message impl")); |
| return; |
| } |
| |
| iTxData = PVMFMediaData::createMediaData(data, iTxMediaMsgPoolAlloc); |
| if (!iTxData) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, |
| PVLOGMSG_ERR, (0, |
| "TscSrpBuffer::ProcessOutgoingH245Packet - Unable allocate tx message")); |
| return; |
| } |
| } |
| |
| iNumMsgs++; |
| |
| /* Just add the fragments to our fragment */ |
| MediaFragment frag; |
| OsclRefCounterMemFrag osclFrag; |
| uint32 curSize = iTxData->getFilledSize(); |
| iTxData->getMediaFragment(0, osclFrag); |
| |
| for (int frag_num = 0; frag_num < pPkt->GetNumFrags(); frag_num++) |
| { |
| pPkt->GetMediaFragment(frag_num, frag); |
| |
| if ((curSize + frag.GetLen()) > MAX_TSCSRP_BUFFER_SZ) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, |
| (0, "TscSrpBuffer::ProcessOutgoingH245Packet - Error: Buffer size exceeded")); |
| /* reset the buffer */ |
| Reset(); |
| return; |
| } |
| oscl_memcpy((uint8 *)osclFrag.getMemFragPtr() + curSize, frag.GetPtr(), |
| frag.GetLen()); |
| curSize += frag.GetLen(); |
| } |
| |
| iTxData->setMediaFragFilledLen(0, curSize); |
| |
| if (iEnableBuffering) |
| { |
| if (iNumMsgs == 1) |
| { |
| // start the timer |
| iTimer->Request(PV_TSC_SRP_BUFFER_TIMER_ID, |
| PV_TSC_SRP_BUFFER_TIMER_ID , 1, this); |
| } |
| } |
| else |
| { |
| // Cancel the timer |
| iTimer->Cancel(PV_TSC_SRP_BUFFER_TIMER_ID); |
| // Call the dispatch routine immediately |
| TimeoutOccurred(PV_TSC_SRP_BUFFER_TIMER_ID, 0); |
| } |
| } |
| |
| void TscSrpBuffer::TimeoutOccurred(int32 timerID, int32 timeoutInfo) |
| { |
| OSCL_UNUSED_ARG(timerID); |
| OSCL_UNUSED_ARG(timeoutInfo); |
| |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, |
| (0, "TscSrpBuffer::TimeoutOccurred- iNumMsgs(%d), size(%d)\n", |
| iNumMsgs, iTxData->getFilledSize())); |
| OSCL_ASSERT(iNumMsgs); |
| |
| /* Dispatch message to SRP */ |
| if (iNumMsgs) |
| { |
| PVMFSharedMediaMsgPtr msg; |
| |
| convertToPVMFMediaMsg(msg, iTxData); |
| |
| iNumMsgs = 0; |
| iTxData.Unbind(); |
| iLLPortOut->QueueOutgoingMsg(msg); |
| iLLPortOut->Send(); |
| } |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, |
| (0, "TscSrpBuffer::TimeoutOccurred- done")); |
| |
| } |
| |
| void TscSrpBuffer::Start() |
| { |
| iState = TscSrpBufferStarted; |
| } |
| |
| void TscSrpBuffer::Stop() |
| { |
| iState = TscSrpBufferStopped; |
| iTimer->Clear(); |
| Reset(); |
| } |
| |
| void TscSrpBuffer::Reset() |
| { |
| iTxData.Unbind(); |
| iNumMsgs = 0; |
| } |
| |
| void TscSrpBuffer::EnableBuffering(bool enable) |
| { |
| iEnableBuffering = enable; |
| } |
| |
| void TscSrpBuffer::ConstructL() |
| { |
| iLogger = PVLogger::GetLoggerObject("3g324m.srp.tscsrpbuffer"); |
| |
| iTxMediaMsgPoolAlloc = OSCL_NEW(OsclMemPoolFixedChunkAllocator, |
| (NUM_TSCSRP_FRAGS, 0, &iMemAllocator)); |
| OsclError::LeaveIfNull(iTxMediaMsgPoolAlloc); |
| iTxMediaDataImplMemAlloc = OSCL_NEW(OsclMemPoolFixedChunkAllocator, |
| (NUM_TSCSRP_FRAGS, 0, &iMemAllocator)); |
| OsclError::LeaveIfNull(iTxMediaDataImplMemAlloc); |
| iTxPacketAlloc = OSCL_NEW(PVMFSimpleMediaBufferCombinedAlloc, |
| (iTxMediaDataImplMemAlloc)); |
| OsclError::LeaveIfNull(iTxPacketAlloc); |
| |
| iTimer = new OsclTimer<OsclMemAllocator>("TSCSRPBufferTimer"); |
| OsclError::LeaveIfNull(iTimer); |
| iTimer->SetFrequency(1000 / TSC_SRP_BUFFER_TIMEOUT); // make timer work in 20ms intervals |
| iTimer->SetObserver(this); |
| |
| iLLPortOut = OSCL_NEW(TscSrpBufferLLPortOut, ()); |
| OsclError::LeaveIfNull(iLLPortOut); |
| iLLPortIn = TscSrpBufferLLPortIn::NewL(this); |
| |
| iH245Interface = this; |
| } |
| |
| |
| |
