| /* |
| * The contents of this file are subject to the Mozilla Public |
| * License Version 1.1 (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.mozilla.org/MPL/ |
| * |
| * Software distributed under the License is distributed on an "AS |
| * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * rights and limitations under the License. |
| * |
| * The Original Code is MPEG4IP. |
| * |
| * The Initial Developer of the Original Code is Cisco Systems Inc. |
| * Portions created by Cisco Systems Inc. are |
| * Copyright (C) Cisco Systems Inc. 2001. All Rights Reserved. |
| * |
| * Contributor(s): |
| * Dave Mackie dmackie@cisco.com |
| */ |
| |
| #include "src/impl.h" |
| |
| namespace mp4v2 { |
| namespace impl { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /* rtp hint track operations */ |
| |
| MP4RtpHintTrack::MP4RtpHintTrack(MP4File& file, MP4Atom& trakAtom) |
| : MP4Track(file, trakAtom) |
| { |
| m_pRefTrack = NULL; |
| |
| m_pRtpMapProperty = NULL; |
| m_pPayloadNumberProperty = NULL; |
| m_pMaxPacketSizeProperty = NULL; |
| m_pSnroProperty = NULL; |
| m_pTsroProperty = NULL; |
| |
| m_pReadHint = NULL; |
| m_pReadHintSample = NULL; |
| m_readHintSampleSize = 0; |
| |
| m_pWriteHint = NULL; |
| m_writeHintId = MP4_INVALID_SAMPLE_ID; |
| m_writePacketId = 0; |
| |
| m_pTrpy = NULL; |
| m_pNump = NULL; |
| m_pTpyl = NULL; |
| m_pMaxr = NULL; |
| m_pDmed = NULL; |
| m_pDimm = NULL; |
| m_pPmax = NULL; |
| m_pDmax = NULL; |
| |
| m_pMaxPdu = NULL; |
| m_pAvgPdu = NULL; |
| m_pMaxBitRate = NULL; |
| m_pAvgBitRate = NULL; |
| |
| m_thisSec = 0; |
| m_bytesThisSec = 0; |
| m_bytesThisHint = 0; |
| m_bytesThisPacket = 0; |
| } |
| |
| MP4RtpHintTrack::~MP4RtpHintTrack() |
| { |
| delete m_pReadHint; m_pReadHint = NULL; |
| MP4Free( m_pReadHintSample ); m_pReadHintSample = NULL; |
| delete m_pWriteHint; m_pWriteHint = NULL; |
| } |
| |
| void MP4RtpHintTrack::InitRefTrack() |
| { |
| if (m_pRefTrack == NULL) { |
| MP4Integer32Property* pRefTrackIdProperty = NULL; |
| (void)m_trakAtom.FindProperty( |
| "trak.tref.hint.entries[0].trackId", |
| (MP4Property**)&pRefTrackIdProperty); |
| ASSERT(pRefTrackIdProperty); |
| |
| m_pRefTrack = m_File.GetTrack(pRefTrackIdProperty->GetValue()); |
| } |
| } |
| |
| void MP4RtpHintTrack::InitRtpStart() |
| { |
| number::srandom( time::getLocalTimeMilliseconds() ); |
| |
| (void)m_trakAtom.FindProperty( |
| "trak.udta.hnti.rtp .snro.offset", |
| (MP4Property**)&m_pSnroProperty); |
| |
| if (m_pSnroProperty) { |
| m_rtpSequenceStart = m_pSnroProperty->GetValue(); |
| } else { |
| m_rtpSequenceStart = number::random32(); |
| } |
| |
| (void)m_trakAtom.FindProperty( |
| "trak.udta.hnti.rtp .tsro.offset", |
| (MP4Property**)&m_pTsroProperty); |
| |
| if (m_pTsroProperty) { |
| m_rtpTimestampStart = m_pTsroProperty->GetValue(); |
| } else { |
| m_rtpTimestampStart = number::random32(); |
| } |
| } |
| |
| void MP4RtpHintTrack::ReadHint( |
| MP4SampleId hintSampleId, |
| uint16_t* pNumPackets) |
| { |
| if (m_pRefTrack == NULL) { |
| InitRefTrack(); |
| InitRtpStart(); |
| } |
| |
| // dispose of any old hint |
| delete m_pReadHint; m_pReadHint = NULL; |
| MP4Free( m_pReadHintSample ); m_pReadHintSample = NULL; |
| m_readHintSampleSize = 0; |
| |
| // read the desired hint sample into memory |
| ReadSample( |
| hintSampleId, |
| &m_pReadHintSample, |
| &m_readHintSampleSize, |
| &m_readHintTimestamp); |
| |
| m_File.EnableMemoryBuffer(m_pReadHintSample, m_readHintSampleSize); |
| |
| m_pReadHint = new MP4RtpHint(*this); |
| m_pReadHint->Read(m_File); |
| |
| m_File.DisableMemoryBuffer(); |
| |
| if (pNumPackets) { |
| *pNumPackets = GetHintNumberOfPackets(); |
| } |
| } |
| |
| uint16_t MP4RtpHintTrack::GetHintNumberOfPackets() |
| { |
| if (m_pReadHint == NULL) { |
| throw new Exception("no hint has been read", |
| __FILE__, __LINE__, __FUNCTION__); |
| } |
| return m_pReadHint->GetNumberOfPackets(); |
| } |
| |
| bool MP4RtpHintTrack::GetPacketBFrame(uint16_t packetIndex) |
| { |
| if (m_pReadHint == NULL) { |
| throw new Exception("no hint has been read", |
| __FILE__, __LINE__, __FUNCTION__); |
| } |
| MP4RtpPacket* pPacket = |
| m_pReadHint->GetPacket(packetIndex); |
| |
| return pPacket->IsBFrame(); |
| } |
| |
| uint16_t MP4RtpHintTrack::GetPacketTransmitOffset(uint16_t packetIndex) |
| { |
| if (m_pReadHint == NULL) { |
| throw new Exception("no hint has been read", |
| __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| MP4RtpPacket* pPacket = |
| m_pReadHint->GetPacket(packetIndex); |
| |
| return pPacket->GetTransmitOffset(); |
| } |
| |
| void MP4RtpHintTrack::ReadPacket( |
| uint16_t packetIndex, |
| uint8_t** ppBytes, |
| uint32_t* pNumBytes, |
| uint32_t ssrc, |
| bool addHeader, |
| bool addPayload) |
| { |
| if (m_pReadHint == NULL) { |
| throw new Exception("no hint has been read", |
| __FILE__, __LINE__, __FUNCTION__); |
| } |
| if (!addHeader && !addPayload) { |
| throw new Exception("no data requested", |
| __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| MP4RtpPacket* pPacket = |
| m_pReadHint->GetPacket(packetIndex); |
| |
| *pNumBytes = 0; |
| if (addHeader) { |
| *pNumBytes += 12; |
| } |
| if (addPayload) { |
| *pNumBytes += pPacket->GetDataSize(); |
| } |
| |
| // if needed, allocate the packet memory |
| bool buffer_malloc = false; |
| |
| if (*ppBytes == NULL) { |
| *ppBytes = (uint8_t*)MP4Malloc(*pNumBytes); |
| buffer_malloc = true; |
| } |
| |
| try { |
| uint8_t* pDest = *ppBytes; |
| |
| if (addHeader) { |
| *pDest++ = |
| 0x80 | (pPacket->GetPBit() << 5) | (pPacket->GetXBit() << 4); |
| |
| *pDest++ = |
| (pPacket->GetMBit() << 7) | pPacket->GetPayload(); |
| |
| *((uint16_t*)pDest) = |
| MP4V2_HTONS(m_rtpSequenceStart + pPacket->GetSequenceNumber()); |
| pDest += 2; |
| |
| *((uint32_t*)pDest) = |
| MP4V2_HTONL(m_rtpTimestampStart + (uint32_t)m_readHintTimestamp); |
| pDest += 4; |
| |
| *((uint32_t*)pDest) = |
| MP4V2_HTONL(ssrc); |
| pDest += 4; |
| } |
| |
| if (addPayload) { |
| pPacket->GetData(pDest); |
| } |
| } |
| catch (Exception* x) { |
| if (buffer_malloc) { |
| MP4Free(*ppBytes); |
| *ppBytes = NULL; |
| } |
| throw x; |
| } |
| |
| log.hexDump(0, MP4_LOG_VERBOSE1, *ppBytes, *pNumBytes, |
| "\"%s\": %u ", GetFile().GetFilename().c_str(), |
| packetIndex); |
| } |
| |
| MP4Timestamp MP4RtpHintTrack::GetRtpTimestampStart() |
| { |
| if (m_pRefTrack == NULL) { |
| InitRefTrack(); |
| InitRtpStart(); |
| } |
| |
| return m_rtpTimestampStart; |
| } |
| |
| void MP4RtpHintTrack::SetRtpTimestampStart(MP4Timestamp start) |
| { |
| if (!m_pTsroProperty) { |
| MP4Atom* pTsroAtom = |
| m_File.AddDescendantAtoms(&m_trakAtom, "udta.hnti.rtp .tsro"); |
| |
| ASSERT(pTsroAtom); |
| |
| (void)pTsroAtom->FindProperty("offset", |
| (MP4Property**)&m_pTsroProperty); |
| |
| ASSERT(m_pTsroProperty); |
| } |
| |
| m_pTsroProperty->SetValue(start); |
| m_rtpTimestampStart = start; |
| } |
| |
| void MP4RtpHintTrack::InitPayload() |
| { |
| if (m_pRtpMapProperty == NULL) { |
| (void)m_trakAtom.FindProperty( |
| "trak.udta.hinf.payt.rtpMap", |
| (MP4Property**)&m_pRtpMapProperty); |
| } |
| |
| if (m_pPayloadNumberProperty == NULL) { |
| (void)m_trakAtom.FindProperty( |
| "trak.udta.hinf.payt.payloadNumber", |
| (MP4Property**)&m_pPayloadNumberProperty); |
| } |
| |
| if (m_pMaxPacketSizeProperty == NULL) { |
| (void)m_trakAtom.FindProperty( |
| "trak.mdia.minf.stbl.stsd.rtp .maxPacketSize", |
| (MP4Property**)&m_pMaxPacketSizeProperty); |
| } |
| } |
| |
| void MP4RtpHintTrack::GetPayload( |
| char** ppPayloadName, |
| uint8_t* pPayloadNumber, |
| uint16_t* pMaxPayloadSize, |
| char **ppEncodingParams) |
| { |
| const char* pRtpMap; |
| const char* pSlash; |
| uint32_t length; |
| InitPayload(); |
| |
| if (ppPayloadName || ppEncodingParams) { |
| if (ppPayloadName) |
| *ppPayloadName = NULL; |
| if (ppEncodingParams) |
| *ppEncodingParams = NULL; |
| if (m_pRtpMapProperty) { |
| pRtpMap = m_pRtpMapProperty->GetValue(); |
| pSlash = strchr(pRtpMap, '/'); |
| |
| if (pSlash) { |
| length = pSlash - pRtpMap; |
| } else { |
| length = (uint32_t)strlen(pRtpMap); |
| } |
| |
| if (ppPayloadName) { |
| *ppPayloadName = (char*)MP4Calloc(length + 1); |
| strncpy(*ppPayloadName, pRtpMap, length); |
| } |
| if (pSlash && ppEncodingParams) { |
| pSlash++; |
| pSlash = strchr(pSlash, '/'); |
| if (pSlash != NULL) { |
| pSlash++; |
| if (*pSlash != '\0') { |
| length = (uint32_t)strlen(pRtpMap) - (pSlash - pRtpMap); |
| *ppEncodingParams = (char *)MP4Calloc(length + 1); |
| strncpy(*ppEncodingParams, pSlash, length); |
| } |
| } |
| } |
| } |
| } |
| |
| if (pPayloadNumber) { |
| if (m_pPayloadNumberProperty) { |
| *pPayloadNumber = m_pPayloadNumberProperty->GetValue(); |
| } else { |
| *pPayloadNumber = 0; |
| } |
| } |
| |
| if (pMaxPayloadSize) { |
| if (m_pMaxPacketSizeProperty) { |
| *pMaxPayloadSize = m_pMaxPacketSizeProperty->GetValue(); |
| } else { |
| *pMaxPayloadSize = 0; |
| } |
| } |
| } |
| |
| void MP4RtpHintTrack::SetPayload( |
| const char* payloadName, |
| uint8_t payloadNumber, |
| uint16_t maxPayloadSize, |
| const char *encoding_parms, |
| bool include_rtp_map, |
| bool include_mpeg4_esid) |
| { |
| InitRefTrack(); |
| InitPayload(); |
| |
| ASSERT(m_pRtpMapProperty); |
| ASSERT(m_pPayloadNumberProperty); |
| ASSERT(m_pMaxPacketSizeProperty); |
| |
| size_t len = strlen(payloadName) + 16; |
| if (encoding_parms != NULL) { |
| size_t temp = strlen(encoding_parms); |
| if (temp == 0) { |
| encoding_parms = NULL; |
| } else { |
| len += temp; |
| } |
| } |
| |
| char* rtpMapBuf = (char*)MP4Malloc(len); |
| snprintf(rtpMapBuf, len, "%s/%u%c%s", |
| payloadName, |
| GetTimeScale(), |
| encoding_parms != NULL ? '/' : '\0', |
| encoding_parms == NULL ? "" : encoding_parms); |
| m_pRtpMapProperty->SetValue(rtpMapBuf); |
| |
| m_pPayloadNumberProperty->SetValue(payloadNumber); |
| |
| if (maxPayloadSize == 0) { |
| maxPayloadSize = 1460; |
| } |
| m_pMaxPacketSizeProperty->SetValue(maxPayloadSize); |
| |
| // set sdp media type |
| const char* sdpMediaType; |
| if (!strcmp(m_pRefTrack->GetType(), MP4_AUDIO_TRACK_TYPE)) { |
| sdpMediaType = "audio"; |
| } else if (!strcmp(m_pRefTrack->GetType(), MP4_VIDEO_TRACK_TYPE)) { |
| sdpMediaType = "video"; |
| } else if (!strcmp(m_pRefTrack->GetType(), MP4_CNTL_TRACK_TYPE)) { |
| sdpMediaType = "control"; |
| } else { |
| sdpMediaType = "application"; |
| } |
| |
| uint32_t maxlen = |
| (uint32_t)strlen(sdpMediaType) + (uint32_t)strlen(rtpMapBuf) + 256; |
| char* sdpBuf = (char*)MP4Malloc(maxlen); |
| uint32_t buflen; |
| buflen = snprintf(sdpBuf, maxlen, |
| "m=%s 0 RTP/AVP %u\015\012" |
| "a=control:trackID=%u\015\012", |
| sdpMediaType, payloadNumber, |
| m_trackId); |
| if (include_rtp_map) { |
| buflen += snprintf(sdpBuf + buflen, maxlen - buflen, |
| "a=rtpmap:%u %s\015\012", |
| payloadNumber, rtpMapBuf); |
| } |
| if (include_mpeg4_esid) { |
| snprintf(sdpBuf + buflen, maxlen - buflen, |
| "a=mpeg4-esid:%u\015\012", |
| m_pRefTrack->GetId()); |
| } |
| |
| MP4StringProperty* pSdpProperty = NULL; |
| (void)m_trakAtom.FindProperty("trak.udta.hnti.sdp .sdpText", |
| (MP4Property**)&pSdpProperty); |
| ASSERT(pSdpProperty); |
| pSdpProperty->SetValue(sdpBuf); |
| |
| // cleanup |
| MP4Free(rtpMapBuf); |
| MP4Free(sdpBuf); |
| } |
| |
| void MP4RtpHintTrack::AddHint(bool isBFrame, uint32_t timestampOffset) |
| { |
| // on first hint, need to lookup the reference track |
| if (m_writeHintId == MP4_INVALID_SAMPLE_ID) { |
| InitRefTrack(); |
| InitStats(); |
| } |
| |
| if (m_pWriteHint) { |
| throw new Exception("unwritten hint is still pending", __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| m_pWriteHint = new MP4RtpHint(*this); |
| m_pWriteHint->SetBFrame(isBFrame); |
| m_pWriteHint->SetTimestampOffset(timestampOffset); |
| |
| m_bytesThisHint = 0; |
| m_writeHintId++; |
| } |
| |
| void MP4RtpHintTrack::AddPacket(bool setMbit, int32_t transmitOffset) |
| { |
| if (m_pWriteHint == NULL) { |
| throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| MP4RtpPacket* pPacket = m_pWriteHint->AddPacket(); |
| |
| ASSERT(m_pPayloadNumberProperty); |
| |
| pPacket->Set( |
| m_pPayloadNumberProperty->GetValue(), |
| m_writePacketId++, |
| setMbit); |
| pPacket->SetTransmitOffset(transmitOffset); |
| |
| m_bytesThisHint += 12; |
| if (m_bytesThisPacket > m_pPmax->GetValue()) { |
| m_pPmax->SetValue(m_bytesThisPacket); |
| } |
| m_bytesThisPacket = 12; |
| m_pNump->IncrementValue(); |
| m_pTrpy->IncrementValue(12); // RTP packet header size |
| } |
| |
| void MP4RtpHintTrack::AddImmediateData( |
| const uint8_t* pBytes, |
| uint32_t numBytes) |
| { |
| if (m_pWriteHint == NULL) { |
| throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| |
| MP4RtpPacket* pPacket = m_pWriteHint->GetCurrentPacket(); |
| if (pPacket == NULL) { |
| throw new Exception("no packet pending", __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| if (pBytes == NULL || numBytes == 0) { |
| throw new Exception("no data", |
| __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| if (numBytes > 14) { |
| throw new Exception("data size is larger than 14 bytes", |
| __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| |
| MP4RtpImmediateData* pData = new MP4RtpImmediateData(*pPacket); |
| pData->Set(pBytes, numBytes); |
| |
| pPacket->AddData(pData); |
| |
| m_bytesThisHint += numBytes; |
| m_bytesThisPacket += numBytes; |
| m_pDimm->IncrementValue(numBytes); |
| m_pTpyl->IncrementValue(numBytes); |
| m_pTrpy->IncrementValue(numBytes); |
| } |
| |
| void MP4RtpHintTrack::AddSampleData( |
| MP4SampleId sampleId, |
| uint32_t dataOffset, |
| uint32_t dataLength) |
| { |
| if (m_pWriteHint == NULL) { |
| throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| |
| MP4RtpPacket* pPacket = m_pWriteHint->GetCurrentPacket(); |
| if (pPacket == NULL) { |
| throw new Exception("no packet pending", __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| |
| MP4RtpSampleData* pData = new MP4RtpSampleData(*pPacket); |
| |
| pData->SetReferenceSample(sampleId, dataOffset, dataLength); |
| |
| pPacket->AddData(pData); |
| |
| m_bytesThisHint += dataLength; |
| m_bytesThisPacket += dataLength; |
| m_pDmed->IncrementValue(dataLength); |
| m_pTpyl->IncrementValue(dataLength); |
| m_pTrpy->IncrementValue(dataLength); |
| } |
| |
| void MP4RtpHintTrack::AddESConfigurationPacket() |
| { |
| if (m_pWriteHint == NULL) { |
| throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| |
| uint8_t* pConfig = NULL; |
| uint32_t configSize = 0; |
| |
| m_File.GetTrackESConfiguration(m_pRefTrack->GetId(), |
| &pConfig, &configSize); |
| |
| if (pConfig == NULL) { |
| return; |
| } |
| |
| ASSERT(m_pMaxPacketSizeProperty); |
| |
| if (configSize > m_pMaxPacketSizeProperty->GetValue()) { |
| throw new Exception("ES configuration is too large for RTP payload", __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| |
| AddPacket(false); |
| |
| MP4RtpPacket* pPacket = m_pWriteHint->GetCurrentPacket(); |
| ASSERT(pPacket); |
| |
| // This is ugly! |
| // To get the ES configuration data somewhere known |
| // we create a sample data reference that points to |
| // this hint track (not the media track) |
| // and this sample of the hint track |
| // the offset into this sample is filled in during the write process |
| MP4RtpSampleData* pData = new MP4RtpSampleData(*pPacket); |
| |
| pData->SetEmbeddedImmediate(m_writeSampleId, pConfig, configSize); |
| |
| pPacket->AddData(pData); |
| |
| m_bytesThisHint += configSize; |
| m_bytesThisPacket += configSize; |
| m_pTpyl->IncrementValue(configSize); |
| m_pTrpy->IncrementValue(configSize); |
| } |
| |
| void MP4RtpHintTrack::WriteHint(MP4Duration duration, bool isSyncSample) |
| { |
| if (m_pWriteHint == NULL) { |
| throw new Exception("no hint pending", __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| |
| uint8_t* pBytes; |
| uint64_t numBytes; |
| |
| m_File.EnableMemoryBuffer(); |
| |
| m_pWriteHint->Write(m_File); |
| |
| m_File.DisableMemoryBuffer(&pBytes, &numBytes); |
| |
| WriteSample(pBytes, numBytes, duration, 0, isSyncSample); |
| |
| MP4Free(pBytes); |
| |
| // update statistics |
| if (m_bytesThisPacket > m_pPmax->GetValue()) { |
| m_pPmax->SetValue(m_bytesThisPacket); |
| } |
| |
| if (duration > m_pDmax->GetValue()) { |
| m_pDmax->SetValue(duration); |
| } |
| |
| MP4Timestamp startTime; |
| |
| GetSampleTimes(m_writeHintId, &startTime, NULL); |
| |
| if (startTime < m_thisSec + GetTimeScale()) { |
| m_bytesThisSec += m_bytesThisHint; |
| } else { |
| if (m_bytesThisSec > m_pMaxr->GetValue()) { |
| m_pMaxr->SetValue(m_bytesThisSec); |
| } |
| m_thisSec = startTime - (startTime % GetTimeScale()); |
| m_bytesThisSec = m_bytesThisHint; |
| } |
| |
| // cleanup |
| delete m_pWriteHint; |
| m_pWriteHint = NULL; |
| } |
| |
| void MP4RtpHintTrack::FinishWrite(uint32_t option) |
| { |
| if (m_writeHintId != MP4_INVALID_SAMPLE_ID) { |
| m_pMaxPdu->SetValue(m_pPmax->GetValue()); |
| if (m_pNump->GetValue()) { |
| m_pAvgPdu->SetValue(m_pTrpy->GetValue() / m_pNump->GetValue()); |
| } |
| |
| m_pMaxBitRate->SetValue(m_pMaxr->GetValue() * 8); |
| if (GetDuration()) { |
| m_pAvgBitRate->SetValue( |
| m_pTrpy->GetValue() * 8 * GetTimeScale() / GetDuration()); |
| } |
| } |
| |
| MP4Track::FinishWrite(); |
| } |
| |
| void MP4RtpHintTrack::InitStats() |
| { |
| MP4Atom* pHinfAtom = m_trakAtom.FindAtom("trak.udta.hinf"); |
| |
| ASSERT(pHinfAtom); |
| |
| (void)pHinfAtom->FindProperty("hinf.trpy.bytes", (MP4Property**)&m_pTrpy); |
| (void)pHinfAtom->FindProperty("hinf.nump.packets", (MP4Property**)&m_pNump); |
| (void)pHinfAtom->FindProperty("hinf.tpyl.bytes", (MP4Property**)&m_pTpyl); |
| (void)pHinfAtom->FindProperty("hinf.maxr.bytes", (MP4Property**)&m_pMaxr); |
| (void)pHinfAtom->FindProperty("hinf.dmed.bytes", (MP4Property**)&m_pDmed); |
| (void)pHinfAtom->FindProperty("hinf.dimm.bytes", (MP4Property**)&m_pDimm); |
| (void)pHinfAtom->FindProperty("hinf.pmax.bytes", (MP4Property**)&m_pPmax); |
| (void)pHinfAtom->FindProperty("hinf.dmax.milliSecs", (MP4Property**)&m_pDmax); |
| |
| MP4Atom* pHmhdAtom = m_trakAtom.FindAtom("trak.mdia.minf.hmhd"); |
| |
| ASSERT(pHmhdAtom); |
| |
| (void)pHmhdAtom->FindProperty("hmhd.maxPduSize", (MP4Property**)&m_pMaxPdu); |
| (void)pHmhdAtom->FindProperty("hmhd.avgPduSize", (MP4Property**)&m_pAvgPdu); |
| (void)pHmhdAtom->FindProperty("hmhd.maxBitRate", (MP4Property**)&m_pMaxBitRate); |
| (void)pHmhdAtom->FindProperty("hmhd.avgBitRate", (MP4Property**)&m_pAvgBitRate); |
| |
| MP4Integer32Property* pMaxrPeriod = NULL; |
| (void)pHinfAtom->FindProperty("hinf.maxr.granularity", |
| (MP4Property**)&pMaxrPeriod); |
| if (pMaxrPeriod) { |
| pMaxrPeriod->SetValue(1000); // 1 second |
| } |
| } |
| |
| |
| MP4RtpHint::MP4RtpHint(MP4RtpHintTrack& track) |
| : m_track(track) |
| { |
| AddProperty( /* 0 */ |
| new MP4Integer16Property(this->GetTrack().GetTrakAtom(), "packetCount")); |
| AddProperty( /* 1 */ |
| new MP4Integer16Property(this->GetTrack().GetTrakAtom(), "reserved")); |
| } |
| |
| MP4RtpHint::~MP4RtpHint() |
| { |
| for (uint32_t i = 0; i < m_rtpPackets.Size(); i++) { |
| delete m_rtpPackets[i]; |
| } |
| } |
| |
| MP4RtpPacket* MP4RtpHint::AddPacket() |
| { |
| MP4RtpPacket* pPacket = new MP4RtpPacket(*this); |
| m_rtpPackets.Add(pPacket); |
| |
| // packetCount property |
| ((MP4Integer16Property*)m_pProperties[0])->IncrementValue(); |
| |
| pPacket->SetBFrame(m_isBFrame); |
| pPacket->SetTimestampOffset(m_timestampOffset); |
| |
| return pPacket; |
| } |
| |
| void MP4RtpHint::Read(MP4File& file) |
| { |
| // call base class Read for required properties |
| MP4Container::Read(file); |
| |
| uint16_t numPackets = |
| ((MP4Integer16Property*)m_pProperties[0])->GetValue(); |
| |
| for (uint16_t i = 0; i < numPackets; i++) { |
| MP4RtpPacket* pPacket = new MP4RtpPacket(*this); |
| |
| m_rtpPackets.Add(pPacket); |
| |
| pPacket->Read(file); |
| } |
| |
| if (log.verbosity >= MP4_LOG_VERBOSE1) { |
| log.verbose1f("\"%s\": ReadHint:", GetTrack().GetFile().GetFilename().c_str()); |
| Dump(10, false); |
| } |
| } |
| |
| void MP4RtpHint::Write(MP4File& file) |
| { |
| uint64_t hintStartPos = file.GetPosition(); |
| |
| MP4Container::Write(file); |
| |
| uint64_t packetStartPos = file.GetPosition(); |
| |
| uint32_t i; |
| |
| // first write out packet (and data) entries |
| for (i = 0; i < m_rtpPackets.Size(); i++) { |
| m_rtpPackets[i]->Write(file); |
| } |
| |
| // now let packets write their extra data into the hint sample |
| for (i = 0; i < m_rtpPackets.Size(); i++) { |
| m_rtpPackets[i]->WriteEmbeddedData(file, hintStartPos); |
| } |
| |
| uint64_t endPos = file.GetPosition(); |
| |
| file.SetPosition(packetStartPos); |
| |
| // finally rewrite the packet and data entries |
| // which now contain the correct offsets for the embedded data |
| for (i = 0; i < m_rtpPackets.Size(); i++) { |
| m_rtpPackets[i]->Write(file); |
| } |
| |
| file.SetPosition(endPos); |
| |
| if (log.verbosity >= MP4_LOG_VERBOSE1) { |
| log.verbose1f("\"%s\": WriteRtpHint:", GetTrack().GetFile().GetFilename().c_str()); |
| Dump(14, false); |
| } |
| } |
| |
| void MP4RtpHint::Dump(uint8_t indent, bool dumpImplicits) |
| { |
| MP4Container::Dump(indent, dumpImplicits); |
| |
| for (uint32_t i = 0; i < m_rtpPackets.Size(); i++) { |
| log.dump(indent, MP4_LOG_VERBOSE1,"\"%s\": RtpPacket: %u", |
| GetTrack().GetFile().GetFilename().c_str(), i); |
| m_rtpPackets[i]->Dump(indent + 1, dumpImplicits); |
| } |
| } |
| |
| MP4RtpPacket::MP4RtpPacket(MP4RtpHint& hint) |
| : m_hint(hint) |
| { |
| AddProperty( /* 0 */ |
| new MP4Integer32Property(this->GetHint().GetTrack().GetTrakAtom(), "relativeXmitTime")); |
| AddProperty( /* 1 */ |
| new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "reserved1", 2)); |
| AddProperty( /* 2 */ |
| new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "Pbit", 1)); |
| AddProperty( /* 3 */ |
| new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "Xbit", 1)); |
| AddProperty( /* 4 */ |
| new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "reserved2", 4)); |
| AddProperty( /* 5 */ |
| new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "Mbit", 1)); |
| AddProperty( /* 6 */ |
| new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "payloadType", 7)); |
| AddProperty( /* 7 */ |
| new MP4Integer16Property(this->GetHint().GetTrack().GetTrakAtom(), "sequenceNumber")); |
| AddProperty( /* 8 */ |
| new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "reserved3", 13)); |
| AddProperty( /* 9 */ |
| new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "extraFlag", 1)); |
| AddProperty( /* 10 */ |
| new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "bFrameFlag", 1)); |
| AddProperty( /* 11 */ |
| new MP4BitfieldProperty(this->GetHint().GetTrack().GetTrakAtom(), "repeatFlag", 1)); |
| AddProperty( /* 12 */ |
| new MP4Integer16Property(this->GetHint().GetTrack().GetTrakAtom(), "entryCount")); |
| } |
| |
| MP4RtpPacket::~MP4RtpPacket() |
| { |
| for (uint32_t i = 0; i < m_rtpData.Size(); i++) { |
| delete m_rtpData[i]; |
| } |
| } |
| |
| void MP4RtpPacket::AddExtraProperties() |
| { |
| AddProperty( /* 13 */ |
| new MP4Integer32Property(this->GetHint().GetTrack().GetTrakAtom(), "extraInformationLength")); |
| |
| // This is a bit of a hack, since the tlv entries are really defined |
| // as atoms but there is only one type defined now, rtpo, and getting |
| // our atom code hooked up here would be a major pain with little gain |
| |
| AddProperty( /* 14 */ |
| new MP4Integer32Property(this->GetHint().GetTrack().GetTrakAtom(), "tlvLength")); |
| AddProperty( /* 15 */ |
| new MP4StringProperty(this->GetHint().GetTrack().GetTrakAtom(), "tlvType")); |
| AddProperty( /* 16 */ |
| new MP4Integer32Property(this->GetHint().GetTrack().GetTrakAtom(), "timestampOffset")); |
| |
| ((MP4Integer32Property*)m_pProperties[13])->SetValue(16); |
| ((MP4Integer32Property*)m_pProperties[14])->SetValue(12); |
| ((MP4StringProperty*)m_pProperties[15])->SetFixedLength(4); |
| ((MP4StringProperty*)m_pProperties[15])->SetValue("rtpo"); |
| } |
| |
| void MP4RtpPacket::Read(MP4File& file) |
| { |
| // call base class Read for required properties |
| MP4Container::Read(file); |
| |
| // read extra info if present |
| // we only support the rtpo field! |
| if (((MP4BitfieldProperty*)m_pProperties[9])->GetValue() == 1) { |
| ReadExtra(file); |
| } |
| |
| uint16_t numDataEntries = |
| ((MP4Integer16Property*)m_pProperties[12])->GetValue(); |
| |
| // read data entries |
| for (uint16_t i = 0; i < numDataEntries; i++) { |
| uint8_t dataType; |
| file.PeekBytes(&dataType, 1); |
| |
| MP4RtpData* pData; |
| |
| switch (dataType) { |
| case 0: |
| pData = new MP4RtpNullData(*this); |
| break; |
| case 1: |
| pData = new MP4RtpImmediateData(*this); |
| break; |
| case 2: |
| pData = new MP4RtpSampleData(*this); |
| break; |
| case 3: |
| pData = new MP4RtpSampleDescriptionData(*this); |
| break; |
| default: |
| throw new Exception("unknown packet data entry type", __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| |
| m_rtpData.Add(pData); |
| |
| // read data entry's properties |
| pData->Read(file); |
| } |
| } |
| |
| void MP4RtpPacket::ReadExtra(MP4File& file) |
| { |
| AddExtraProperties(); |
| |
| int32_t extraLength = (int32_t)file.ReadUInt32(); |
| |
| if (extraLength < 4) { |
| throw new Exception("bad packet extra info length", __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| extraLength -= 4; |
| |
| while (extraLength > 0) { |
| uint32_t entryLength = file.ReadUInt32(); |
| uint32_t entryTag = file.ReadUInt32(); |
| |
| if (entryLength < 8) { |
| throw new Exception("bad packet extra info entry length", __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| |
| if (entryTag == STRTOINT32("rtpo") && entryLength == 12) { |
| // read the rtp timestamp offset |
| m_pProperties[16]->Read(file); |
| } else { |
| // ignore it, LATER carry it along |
| file.SetPosition(file.GetPosition() + entryLength - 8); |
| } |
| |
| extraLength -= entryLength; |
| } |
| |
| if (extraLength < 0) { |
| throw new Exception("invalid packet extra info length", __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| } |
| |
| void MP4RtpPacket::Set(uint8_t payloadNumber, |
| uint32_t packetId, bool setMbit) |
| { |
| ((MP4BitfieldProperty*)m_pProperties[5])->SetValue(setMbit); |
| ((MP4BitfieldProperty*)m_pProperties[6])->SetValue(payloadNumber); |
| ((MP4Integer16Property*)m_pProperties[7])->SetValue(packetId); |
| } |
| |
| int32_t MP4RtpPacket::GetTransmitOffset() |
| { |
| return ((MP4Integer32Property*)m_pProperties[0])->GetValue(); |
| } |
| |
| void MP4RtpPacket::SetTransmitOffset(int32_t transmitOffset) |
| { |
| ((MP4Integer32Property*)m_pProperties[0])->SetValue(transmitOffset); |
| } |
| |
| bool MP4RtpPacket::GetPBit() |
| { |
| return ((MP4BitfieldProperty*)m_pProperties[2])->GetValue(); |
| } |
| |
| bool MP4RtpPacket::GetXBit() |
| { |
| return ((MP4BitfieldProperty*)m_pProperties[3])->GetValue(); |
| } |
| |
| bool MP4RtpPacket::GetMBit() |
| { |
| return ((MP4BitfieldProperty*)m_pProperties[5])->GetValue(); |
| } |
| |
| uint8_t MP4RtpPacket::GetPayload() |
| { |
| return ((MP4BitfieldProperty*)m_pProperties[6])->GetValue(); |
| } |
| |
| uint16_t MP4RtpPacket::GetSequenceNumber() |
| { |
| return ((MP4Integer16Property*)m_pProperties[7])->GetValue(); |
| } |
| |
| bool MP4RtpPacket::IsBFrame() |
| { |
| return ((MP4BitfieldProperty*)m_pProperties[10])->GetValue(); |
| } |
| |
| void MP4RtpPacket::SetBFrame(bool isBFrame) |
| { |
| ((MP4BitfieldProperty*)m_pProperties[10])->SetValue(isBFrame); |
| } |
| |
| void MP4RtpPacket::SetTimestampOffset(uint32_t timestampOffset) |
| { |
| if (timestampOffset == 0) { |
| return; |
| } |
| |
| ASSERT(((MP4BitfieldProperty*)m_pProperties[9])->GetValue() == 0); |
| |
| // set X bit |
| ((MP4BitfieldProperty*)m_pProperties[9])->SetValue(1); |
| |
| AddExtraProperties(); |
| |
| ((MP4Integer32Property*)m_pProperties[16])->SetValue(timestampOffset); |
| } |
| |
| void MP4RtpPacket::AddData(MP4RtpData* pData) |
| { |
| m_rtpData.Add(pData); |
| |
| // increment entry count property |
| ((MP4Integer16Property*)m_pProperties[12])->IncrementValue(); |
| } |
| |
| uint32_t MP4RtpPacket::GetDataSize() |
| { |
| uint32_t totalDataSize = 0; |
| |
| for (uint32_t i = 0; i < m_rtpData.Size(); i++) { |
| totalDataSize += m_rtpData[i]->GetDataSize(); |
| } |
| |
| return totalDataSize; |
| } |
| |
| void MP4RtpPacket::GetData(uint8_t* pDest) |
| { |
| for (uint32_t i = 0; i < m_rtpData.Size(); i++) { |
| m_rtpData[i]->GetData(pDest); |
| pDest += m_rtpData[i]->GetDataSize(); |
| } |
| } |
| |
| void MP4RtpPacket::Write(MP4File& file) |
| { |
| MP4Container::Write(file); |
| |
| for (uint32_t i = 0; i < m_rtpData.Size(); i++) { |
| m_rtpData[i]->Write(file); |
| } |
| } |
| |
| void MP4RtpPacket::WriteEmbeddedData(MP4File& file, uint64_t startPos) |
| { |
| for (uint32_t i = 0; i < m_rtpData.Size(); i++) { |
| m_rtpData[i]->WriteEmbeddedData(file, startPos); |
| } |
| } |
| |
| void MP4RtpPacket::Dump(uint8_t indent, bool dumpImplicits) |
| { |
| MP4Container::Dump(indent, dumpImplicits); |
| |
| for (uint32_t i = 0; i < m_rtpData.Size(); i++) { |
| log.dump(indent, MP4_LOG_VERBOSE1, "\"%s\": RtpData: %u", |
| GetHint().GetTrack().GetFile().GetFilename().c_str(), i); |
| m_rtpData[i]->Dump(indent + 1, dumpImplicits); |
| } |
| } |
| |
| MP4RtpData::MP4RtpData(MP4RtpPacket& packet) |
| : m_packet(packet) |
| { |
| AddProperty( /* 0 */ |
| new MP4Integer8Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "type")); |
| } |
| |
| MP4Track* MP4RtpData::FindTrackFromRefIndex(uint8_t refIndex) |
| { |
| MP4Track* pTrack; |
| |
| if (refIndex == (uint8_t)-1) { |
| // ourselves |
| pTrack = &GetPacket().GetHint().GetTrack(); |
| } else if (refIndex == 0) { |
| // our reference track |
| pTrack = GetPacket().GetHint().GetTrack().GetRefTrack(); |
| } else { |
| // some other track |
| MP4RtpHintTrack* pHintTrack = |
| &GetPacket().GetHint().GetTrack(); |
| |
| MP4Atom& trakAtom = pHintTrack->GetTrakAtom(); |
| |
| MP4Integer32Property* pTrackIdProperty = NULL; |
| (void)trakAtom.FindProperty( |
| "trak.tref.hint.entries", |
| (MP4Property**)&pTrackIdProperty); |
| ASSERT(pTrackIdProperty); |
| |
| uint32_t refTrackId = |
| pTrackIdProperty->GetValue(refIndex - 1); |
| |
| pTrack = pHintTrack->GetFile().GetTrack(refTrackId); |
| } |
| |
| return pTrack; |
| } |
| |
| MP4RtpNullData::MP4RtpNullData(MP4RtpPacket& packet) |
| : MP4RtpData(packet) |
| { |
| ((MP4Integer8Property*)m_pProperties[0])->SetValue(0); |
| |
| AddProperty( /* 1 */ |
| new MP4BytesProperty(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "pad", 15)); |
| |
| ((MP4BytesProperty*)m_pProperties[1])->SetFixedSize(15); |
| } |
| |
| MP4RtpImmediateData::MP4RtpImmediateData(MP4RtpPacket& packet) |
| : MP4RtpData(packet) |
| { |
| ((MP4Integer8Property*)m_pProperties[0])->SetValue(1); |
| |
| AddProperty( /* 1 */ |
| new MP4Integer8Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "count")); |
| AddProperty( /* 2 */ |
| new MP4BytesProperty(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "data", 14)); |
| |
| ((MP4BytesProperty*)m_pProperties[2])->SetFixedSize(14); |
| } |
| |
| void MP4RtpImmediateData::Set(const uint8_t* pBytes, uint8_t numBytes) |
| { |
| ((MP4Integer8Property*)m_pProperties[1])->SetValue(numBytes); |
| ((MP4BytesProperty*)m_pProperties[2])->SetValue(pBytes, numBytes); |
| } |
| |
| uint16_t MP4RtpImmediateData::GetDataSize() |
| { |
| return ((MP4Integer8Property*)m_pProperties[1])->GetValue(); |
| } |
| |
| void MP4RtpImmediateData::GetData(uint8_t* pDest) |
| { |
| uint8_t* pValue; |
| uint32_t valueSize; |
| ((MP4BytesProperty*)m_pProperties[2])->GetValue(&pValue, &valueSize); |
| |
| memcpy(pDest, pValue, GetDataSize()); |
| MP4Free(pValue); |
| } |
| |
| MP4RtpSampleData::MP4RtpSampleData(MP4RtpPacket& packet) |
| : MP4RtpData(packet) |
| { |
| ((MP4Integer8Property*)m_pProperties[0])->SetValue(2); |
| |
| AddProperty( /* 1 */ |
| new MP4Integer8Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "trackRefIndex")); |
| AddProperty( /* 2 */ |
| new MP4Integer16Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "length")); |
| AddProperty( /* 3 */ |
| new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "sampleNumber")); |
| AddProperty( /* 4 */ |
| new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "sampleOffset")); |
| AddProperty( /* 5 */ |
| new MP4Integer16Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "bytesPerBlock")); |
| AddProperty( /* 6 */ |
| new MP4Integer16Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "samplesPerBlock")); |
| |
| ((MP4Integer16Property*)m_pProperties[5])->SetValue(1); |
| ((MP4Integer16Property*)m_pProperties[6])->SetValue(1); |
| |
| m_pRefData = NULL; |
| m_pRefTrack = NULL; |
| m_refSampleId = MP4_INVALID_SAMPLE_ID; |
| m_refSampleOffset = 0; |
| } |
| |
| void MP4RtpSampleData::SetEmbeddedImmediate(MP4SampleId sampleId, |
| uint8_t* pData, uint16_t dataLength) |
| { |
| ((MP4Integer8Property*)m_pProperties[1])->SetValue((uint8_t)-1); |
| ((MP4Integer16Property*)m_pProperties[2])->SetValue(dataLength); |
| ((MP4Integer32Property*)m_pProperties[3])->SetValue(sampleId); |
| ((MP4Integer32Property*)m_pProperties[4])->SetValue(0); |
| CHECK_AND_FREE(m_pRefData); |
| m_pRefData = pData; |
| } |
| |
| void MP4RtpSampleData::SetReferenceSample( |
| MP4SampleId refSampleId, uint32_t refSampleOffset, |
| uint16_t sampleLength) |
| { |
| ((MP4Integer8Property*)m_pProperties[1])->SetValue(0); |
| ((MP4Integer16Property*)m_pProperties[2])->SetValue(sampleLength); |
| ((MP4Integer32Property*)m_pProperties[3])->SetValue(refSampleId); |
| ((MP4Integer32Property*)m_pProperties[4])->SetValue(refSampleOffset); |
| } |
| |
| void MP4RtpSampleData::SetEmbeddedSample( |
| MP4SampleId sampleId, MP4Track* pRefTrack, |
| MP4SampleId refSampleId, uint32_t refSampleOffset, |
| uint16_t sampleLength) |
| { |
| ((MP4Integer8Property*)m_pProperties[1])->SetValue((uint8_t)-1); |
| ((MP4Integer16Property*)m_pProperties[2])->SetValue(sampleLength); |
| ((MP4Integer32Property*)m_pProperties[3])->SetValue(sampleId); |
| ((MP4Integer32Property*)m_pProperties[4])->SetValue(0); |
| m_pRefTrack = pRefTrack; |
| m_refSampleId = refSampleId; |
| m_refSampleOffset = refSampleOffset; |
| } |
| |
| uint16_t MP4RtpSampleData::GetDataSize() |
| { |
| return ((MP4Integer16Property*)m_pProperties[2])->GetValue(); |
| } |
| |
| void MP4RtpSampleData::GetData(uint8_t* pDest) |
| { |
| uint8_t trackRefIndex = |
| ((MP4Integer8Property*)m_pProperties[1])->GetValue(); |
| |
| MP4Track* pSampleTrack = |
| FindTrackFromRefIndex(trackRefIndex); |
| |
| pSampleTrack->ReadSampleFragment( |
| ((MP4Integer32Property*)m_pProperties[3])->GetValue(), // sampleId |
| ((MP4Integer32Property*)m_pProperties[4])->GetValue(), // sampleOffset |
| ((MP4Integer16Property*)m_pProperties[2])->GetValue(), // sampleLength |
| pDest); |
| } |
| |
| void MP4RtpSampleData::WriteEmbeddedData(MP4File& file, uint64_t startPos) |
| { |
| // if not using embedded data, nothing to do |
| if (((MP4Integer8Property*)m_pProperties[1])->GetValue() != (uint8_t)-1) { |
| return; |
| } |
| |
| // figure out the offset within this hint sample for this embedded data |
| uint64_t offset = file.GetPosition() - startPos; |
| ASSERT(offset <= 0xFFFFFFFF); |
| ((MP4Integer32Property*)m_pProperties[4])->SetValue((uint32_t)offset); |
| |
| uint16_t length = ((MP4Integer16Property*)m_pProperties[2])->GetValue(); |
| |
| if (m_pRefData) { |
| file.WriteBytes(m_pRefData, length); |
| return; |
| } |
| |
| if (m_refSampleId != MP4_INVALID_SAMPLE_ID) { |
| uint8_t* pSample = NULL; |
| uint32_t sampleSize = 0; |
| |
| ASSERT(m_pRefTrack); |
| m_pRefTrack->ReadSample(m_refSampleId, &pSample, &sampleSize); |
| |
| ASSERT(m_refSampleOffset + length <= sampleSize); |
| |
| file.WriteBytes(&pSample[m_refSampleOffset], length); |
| |
| MP4Free(pSample); |
| return; |
| } |
| } |
| |
| MP4RtpSampleDescriptionData::MP4RtpSampleDescriptionData(MP4RtpPacket& packet) |
| : MP4RtpData(packet) |
| { |
| ((MP4Integer8Property*)m_pProperties[0])->SetValue(3); |
| |
| AddProperty( /* 1 */ |
| new MP4Integer8Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "trackRefIndex")); |
| AddProperty( /* 2 */ |
| new MP4Integer16Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "length")); |
| AddProperty( /* 3 */ |
| new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "sampleDescriptionIndex")); |
| AddProperty( /* 4 */ |
| new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "sampleDescriptionOffset")); |
| AddProperty( /* 5 */ |
| new MP4Integer32Property(this->GetPacket().GetHint().GetTrack().GetTrakAtom(), "reserved")); |
| } |
| |
| void MP4RtpSampleDescriptionData::Set(uint32_t sampleDescrIndex, |
| uint32_t offset, uint16_t length) |
| { |
| ((MP4Integer16Property*)m_pProperties[2])->SetValue(length); |
| ((MP4Integer32Property*)m_pProperties[3])->SetValue(sampleDescrIndex); |
| ((MP4Integer32Property*)m_pProperties[4])->SetValue(offset); |
| } |
| |
| uint16_t MP4RtpSampleDescriptionData::GetDataSize() |
| { |
| return ((MP4Integer16Property*)m_pProperties[2])->GetValue(); |
| } |
| |
| void MP4RtpSampleDescriptionData::GetData(uint8_t* pDest) |
| { |
| // we start with the index into our track references |
| uint8_t trackRefIndex = |
| ((MP4Integer8Property*)m_pProperties[1])->GetValue(); |
| |
| // from which we can find the track structure |
| MP4Track* pSampleTrack = |
| FindTrackFromRefIndex(trackRefIndex); |
| |
| // next find the desired atom in the track's sample description table |
| uint32_t sampleDescrIndex = |
| ((MP4Integer32Property*)m_pProperties[3])->GetValue(); |
| |
| MP4Atom& trakAtom = |
| pSampleTrack->GetTrakAtom(); |
| |
| char sdName[64]; |
| snprintf(sdName, 64, "trak.mdia.minf.stbl.stsd.*[%u]", sampleDescrIndex); |
| |
| MP4Atom* pSdAtom = |
| trakAtom.FindAtom(sdName); |
| |
| // bad reference |
| if (pSdAtom == NULL) { |
| throw new Exception("invalid sample description index", __FILE__, __LINE__, __FUNCTION__ ); |
| } |
| |
| // check validity of the upcoming copy |
| uint16_t length = |
| ((MP4Integer16Property*)m_pProperties[2])->GetValue(); |
| uint32_t offset = |
| ((MP4Integer32Property*)m_pProperties[4])->GetValue(); |
| |
| if (offset + length > pSdAtom->GetSize()) { |
| throw new Exception("offset and/or length are too large", |
| __FILE__, __LINE__, __FUNCTION__); |
| } |
| |
| // now we use the raw file to get the desired bytes |
| |
| MP4File& file = GetPacket().GetHint().GetTrack().GetFile(); |
| |
| uint64_t orgPos = file.GetPosition(); |
| |
| // It's not entirely clear from the spec whether the offset is from |
| // the start of the sample descirption atom, or the start of the atom's |
| // data. I believe it is the former, but the commented out code will |
| // realize the latter interpretation if I turn out to be wrong. |
| uint64_t dataPos = pSdAtom->GetStart(); |
| //uint64_t dataPos = pSdAtom->GetEnd() - pSdAtom->GetSize(); |
| |
| file.SetPosition(dataPos + offset); |
| |
| file.ReadBytes(pDest, length); |
| |
| file.SetPosition(orgPos); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| } |
| } // namespace mp4v2::impl |
