开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
rtphint.cpp
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：33k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

rtphint.cpp：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is MPEG4IP.
  13.  * 
  14.  * The Initial Developer of the Original Code is Cisco Systems Inc.
  15.  * Portions created by Cisco Systems Inc. are
  16.  * Copyright (C) Cisco Systems Inc. 2001.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  * Dave Mackie dmackie@cisco.com
  20.  */
  22. #include "mp4common.h"
  24. /* rtp hint track operations */
  26. MP4RtpHintTrack::MP4RtpHintTrack(MP4File* pFile, MP4Atom* pTrakAtom)
  27. : MP4Track(pFile, pTrakAtom)
  28. {
  29. m_pRefTrack = NULL;
  31. m_pRtpMapProperty = NULL;
  32. m_pPayloadNumberProperty = NULL;
  33. m_pMaxPacketSizeProperty = NULL;
  34. m_pSnroProperty = NULL;
  35. m_pTsroProperty = NULL;
  37. m_pReadHint = NULL;
  38. m_pReadHintSample = NULL;
  39. m_readHintSampleSize = 0;
  41. m_pWriteHint = NULL;
  42. m_writeHintId = MP4_INVALID_SAMPLE_ID;
  43. m_writePacketId = 0;
  45. m_pTrpy = NULL;
  46. m_pNump = NULL;
  47. m_pTpyl = NULL;
  48. m_pMaxr = NULL;
  49. m_pDmed = NULL;
  50. m_pDimm = NULL;
  51. m_pPmax = NULL;
  52. m_pDmax = NULL;
  54. m_pMaxPdu = NULL;
  55. m_pAvgPdu = NULL;
  56. m_pMaxBitRate = NULL;
  57. m_pAvgBitRate = NULL;
  59. m_thisSec = 0;
  60. m_bytesThisSec = 0;
  61. m_bytesThisHint = 0;
  62. m_bytesThisPacket = 0;
  63. }
  65. MP4RtpHintTrack::~MP4RtpHintTrack()
  66. {
  67. delete m_pReadHint;
  68. delete m_pReadHintSample;
  69. delete m_pWriteHint;
  70. }
  72. void MP4RtpHintTrack::InitRefTrack()
  73. {
  74. if (m_pRefTrack == NULL) {
  75. MP4Integer32Property* pRefTrackIdProperty = NULL;
  76. m_pTrakAtom->FindProperty(
  77. "trak.tref.hint.entries[0].trackId",
  78. (MP4Property**)&pRefTrackIdProperty);
  79. ASSERT(pRefTrackIdProperty);
  81. m_pRefTrack = m_pFile->GetTrack(pRefTrackIdProperty->GetValue());
  82. }
  83. }
  85. void MP4RtpHintTrack::InitRtpStart() 
  86. {
  87. struct timeval tv;
  88. gettimeofday(&tv, NULL);
  89. srandom((tv.tv_usec << 12) | (tv.tv_sec & 0xFFF));
  91. ASSERT(m_pTrakAtom);
  93. m_pTrakAtom->FindProperty(
  94. "trak.udta.hnti.rtp .snro.offset",
  95. (MP4Property**)&m_pSnroProperty);
  97. if (m_pSnroProperty) {
  98. m_rtpSequenceStart = m_pSnroProperty->GetValue();
  99. } else {
  100. m_rtpSequenceStart = random();
  101. }
  103. m_pTrakAtom->FindProperty(
  104. "trak.udta.hnti.rtp .tsro.offset",
  105. (MP4Property**)&m_pTsroProperty);
  107. if (m_pTsroProperty) {
  108. m_rtpTimestampStart = m_pTsroProperty->GetValue();
  109. } else {
  110. m_rtpTimestampStart = random();
  111. }
  112. }
  114. void MP4RtpHintTrack::ReadHint(
  115. MP4SampleId hintSampleId,
  116. u_int16_t* pNumPackets)
  117. {
  118. if (m_pRefTrack == NULL) {
  119. InitRefTrack();
  120. InitRtpStart();
  121. }
  123. // dispose of any old hint
  124. delete m_pReadHint;
  125. m_pReadHint = NULL;
  126. delete m_pReadHintSample;
  127. m_pReadHintSample = NULL;
  128. m_readHintSampleSize = 0;
  130. // read the desired hint sample into memory
  131. ReadSample(
  132. hintSampleId, 
  133. &m_pReadHintSample, 
  134. &m_readHintSampleSize,
  135. &m_readHintTimestamp);
  137. m_pFile->EnableMemoryBuffer(m_pReadHintSample, m_readHintSampleSize);
  139. m_pReadHint = new MP4RtpHint(this);
  140. m_pReadHint->Read(m_pFile);
  142. m_pFile->DisableMemoryBuffer();
  144. if (pNumPackets) {
  145. *pNumPackets = GetHintNumberOfPackets();
  146. }
  147. }
  149. u_int16_t MP4RtpHintTrack::GetHintNumberOfPackets()
  150. {
  151. if (m_pReadHint == NULL) {
  152. throw new MP4Error("no hint has been read",
  153. "MP4GetRtpHintNumberOfPackets");
  154. }
  155. return m_pReadHint->GetNumberOfPackets();
  156. }
  158. bool MP4RtpHintTrack::GetPacketBFrame(u_int16_t packetIndex)
  159. {
  160. if (m_pReadHint == NULL) {
  161. throw new MP4Error("no hint has been read",
  162. "MP4GetRtpPacketBFrame");
  163. }
  164. MP4RtpPacket* pPacket =
  165. m_pReadHint->GetPacket(packetIndex);
  167. return pPacket->IsBFrame();
  168. }
  170. u_int16_t MP4RtpHintTrack::GetPacketTransmitOffset(u_int16_t packetIndex)
  171. {
  172. if (m_pReadHint == NULL) {
  173. throw new MP4Error("no hint has been read",
  174. "MP4GetRtpPacketTransmitOffset");
  175. }
  177. MP4RtpPacket* pPacket =
  178. m_pReadHint->GetPacket(packetIndex);
  180. return pPacket->GetTransmitOffset();
  181. }
  183. void MP4RtpHintTrack::ReadPacket(
  184. u_int16_t packetIndex,
  185. u_int8_t** ppBytes, 
  186. u_int32_t* pNumBytes,
  187. u_int32_t ssrc,
  188. bool addHeader,
  189. bool addPayload)
  190. {
  191. if (m_pReadHint == NULL) {
  192. throw new MP4Error("no hint has been read",
  193. "MP4ReadRtpPacket");
  194. }
  195. if (!addHeader && !addPayload) {
  196. throw new MP4Error("no data requested",
  197. "MP4ReadRtpPacket");
  198. }
  200. MP4RtpPacket* pPacket =
  201. m_pReadHint->GetPacket(packetIndex);
  203. *pNumBytes = 0;
  204. if (addHeader) {
  205. *pNumBytes += 12;
  206. }
  207. if (addPayload) {
  208. *pNumBytes += pPacket->GetDataSize();
  209. }
  211. // if needed, allocate the packet memory
  212. bool buffer_malloc = false;
  214. if (*ppBytes == NULL) {
  215. *ppBytes = (u_int8_t*)MP4Malloc(*pNumBytes);
  216. buffer_malloc = true;
  217. }
  219. try {
  220. u_int8_t* pDest = *ppBytes;
  222. if (addHeader) {
  223. *pDest++ =
  224. 0x80 | (pPacket->GetPBit() << 5) | (pPacket->GetXBit() << 4);
  226. *pDest++ =
  227. (pPacket->GetMBit() << 7) | pPacket->GetPayload();
  229. *((u_int16_t*)pDest) = 
  230. htons(m_rtpSequenceStart + pPacket->GetSequenceNumber());
  231. pDest += 2; 
  233. *((u_int32_t*)pDest) = 
  234. htonl(m_rtpTimestampStart + (u_int32_t)m_readHintTimestamp);
  235. pDest += 4; 
  237. *((u_int32_t*)pDest) = 
  238. htonl(ssrc);
  239. pDest += 4;
  240. }
  242. if (addPayload) {
  243. pPacket->GetData(pDest);
  244. }
  245. }
  246. catch (MP4Error* e) {
  247. if (buffer_malloc) {
  248. MP4Free(*ppBytes);
  249. *ppBytes = NULL;
  250. }
  251. throw e;
  252. }
  254. VERBOSE_READ_HINT(m_pFile->GetVerbosity(),
  255. printf("ReadPacket: %u ", packetIndex);
  256. MP4HexDump(*ppBytes, *pNumBytes););
  257. }
  259. MP4Timestamp MP4RtpHintTrack::GetRtpTimestampStart()
  260. {
  261. if (m_pRefTrack == NULL) {
  262. InitRefTrack();
  263. InitRtpStart();
  264. }
  266. return m_rtpTimestampStart;
  267. }
  269. void MP4RtpHintTrack::SetRtpTimestampStart(MP4Timestamp start)
  270. {
  271. if (!m_pTsroProperty) {
  272. MP4Atom* pTsroAtom =
  273. m_pFile->AddDescendantAtoms(m_pTrakAtom, "udta.hnti.rtp .tsro");
  275. ASSERT(pTsroAtom);
  277. pTsroAtom->FindProperty("offset",
  278. (MP4Property**)&m_pTsroProperty);
  280. ASSERT(m_pTsroProperty);
  281. }
  283. m_pTsroProperty->SetValue(start);
  284. m_rtpTimestampStart = start;
  285. }
  287. void MP4RtpHintTrack::InitPayload()
  288. {
  289. ASSERT(m_pTrakAtom);
  291. if (m_pRtpMapProperty == NULL) {
  292. m_pTrakAtom->FindProperty(
  293. "trak.udta.hinf.payt.rtpMap",
  294. (MP4Property**)&m_pRtpMapProperty);
  295. }
  297. if (m_pPayloadNumberProperty == NULL) {
  298. m_pTrakAtom->FindProperty(
  299. "trak.udta.hinf.payt.payloadNumber",
  300. (MP4Property**)&m_pPayloadNumberProperty);
  301. }
  303. if (m_pMaxPacketSizeProperty == NULL) {
  304. m_pTrakAtom->FindProperty(
  305. "trak.mdia.minf.stbl.stsd.rtp .maxPacketSize",
  306. (MP4Property**)&m_pMaxPacketSizeProperty);
  307. }
  308. }
  310. void MP4RtpHintTrack::GetPayload(
  311. char** ppPayloadName,
  312. u_int8_t* pPayloadNumber,
  313. u_int16_t* pMaxPayloadSize)
  314. {
  315. InitPayload();
  317. if (ppPayloadName) {
  318. if (m_pRtpMapProperty) {
  319. const char* pRtpMap = m_pRtpMapProperty->GetValue();
  320. char* pSlash = strchr(pRtpMap, '/');
  322. u_int32_t length;
  323. if (pSlash) {
  324. length = pSlash - pRtpMap;
  325. } else {
  326. length = strlen(pRtpMap);
  327. }
  329. *ppPayloadName = (char*)MP4Calloc(length + 1);
  330. strncpy(*ppPayloadName, pRtpMap, length); 
  331. } else {
  332. *ppPayloadName = NULL;
  333. }
  334. }
  336. if (pPayloadNumber) {
  337. if (m_pPayloadNumberProperty) {
  338. *pPayloadNumber = m_pPayloadNumberProperty->GetValue();
  339. } else {
  340. *pPayloadNumber = 0;
  341. }
  342. }
  344. if (pMaxPayloadSize) {
  345. if (m_pMaxPacketSizeProperty) {
  346. *pMaxPayloadSize = m_pMaxPacketSizeProperty->GetValue();
  347. } else {
  348. *pMaxPayloadSize = 0;
  349. }
  350. }
  351. }
  353. void MP4RtpHintTrack::SetPayload(
  354. const char* payloadName,
  355. u_int8_t payloadNumber,
  356. u_int16_t maxPayloadSize)
  357. {
  358. InitRefTrack();
  359. InitPayload();
  361. ASSERT(m_pRtpMapProperty);
  362. ASSERT(m_pPayloadNumberProperty);
  363. ASSERT(m_pMaxPacketSizeProperty);
  365. char* rtpMapBuf = (char*)MP4Malloc(strlen(payloadName) + 16);
  366. sprintf(rtpMapBuf, "%s/%u", payloadName, GetTimeScale());
  367. m_pRtpMapProperty->SetValue(rtpMapBuf);
  369. m_pPayloadNumberProperty->SetValue(payloadNumber);
  371. if (maxPayloadSize == 0) {
  372. maxPayloadSize = 1460;
  373. } 
  374. m_pMaxPacketSizeProperty->SetValue(maxPayloadSize);
  376. // set sdp media type
  377. const char* sdpMediaType;
  378. if (!strcmp(m_pRefTrack->GetType(), MP4_AUDIO_TRACK_TYPE)) {
  379. sdpMediaType = "audio";
  380. } else if (!strcmp(m_pRefTrack->GetType(), MP4_VIDEO_TRACK_TYPE)) {
  381. sdpMediaType = "video";
  382. } else {
  383. sdpMediaType = "application";
  384. }
  386. char* sdpBuf = (char*)MP4Malloc(
  387. strlen(sdpMediaType) + strlen(rtpMapBuf) + 256);
  388. sprintf(sdpBuf, 
  389. "m=%s 0 RTP/AVP %u1512"
  390. "a=rtpmap:%u %s1512"
  391. "a=control:trackID=%u1512" 
  392. "a=mpeg4-esid:%u1512",
  393. sdpMediaType, payloadNumber,
  394. payloadNumber, rtpMapBuf,
  395. m_trackId,
  396. m_pRefTrack->GetId());
  398. MP4StringProperty* pSdpProperty = NULL;
  399. m_pTrakAtom->FindProperty("trak.udta.hnti.sdp .sdpText",
  400. (MP4Property**)&pSdpProperty);
  401. ASSERT(pSdpProperty);
  402. pSdpProperty->SetValue(sdpBuf);
  404. // cleanup
  405. MP4Free(rtpMapBuf);
  406. MP4Free(sdpBuf);
  407. }
  409. void MP4RtpHintTrack::AddHint(bool isBFrame, u_int32_t timestampOffset)
  410. {
  411. // on first hint, need to lookup the reference track
  412. if (m_writeHintId == MP4_INVALID_SAMPLE_ID) {
  413. InitRefTrack();
  414. InitStats();
  415. }
  417. if (m_pWriteHint) {
  418. throw new MP4Error("unwritten hint is still pending", "MP4AddRtpHint");
  419. }
  421. m_pWriteHint = new MP4RtpHint(this);
  422. m_pWriteHint->SetBFrame(isBFrame);
  423. m_pWriteHint->SetTimestampOffset(timestampOffset);
  425. m_bytesThisHint = 0;
  426. m_writeHintId++;
  427. }
  429. void MP4RtpHintTrack::AddPacket(bool setMbit, int32_t transmitOffset)
  430. {
  431. if (m_pWriteHint == NULL) {
  432. throw new MP4Error("no hint pending", "MP4RtpAddPacket");
  433. }
  435. MP4RtpPacket* pPacket = m_pWriteHint->AddPacket();
  437. ASSERT(m_pPayloadNumberProperty);
  439. pPacket->Set(
  440. m_pPayloadNumberProperty->GetValue(), 
  441. m_writePacketId++, 
  442. setMbit);
  443. pPacket->SetTransmitOffset(transmitOffset);
  445. m_bytesThisHint += 12;
  446. if (m_bytesThisPacket > m_pPmax->GetValue()) {
  447. m_pPmax->SetValue(m_bytesThisPacket);
  448. }
  449. m_bytesThisPacket = 12;
  450. m_pNump->IncrementValue();
  451. m_pTrpy->IncrementValue(12); // RTP packet header size
  452. }
  454. void MP4RtpHintTrack::AddImmediateData(
  455. const u_int8_t* pBytes,
  456. u_int32_t numBytes)
  457. {
  458. if (m_pWriteHint == NULL) {
  459. throw new MP4Error("no hint pending", "MP4RtpAddImmediateData");
  460. }
  462. MP4RtpPacket* pPacket = m_pWriteHint->GetCurrentPacket();
  463. if (pPacket == NULL) {
  464. throw new MP4Error("no packet pending", "MP4RtpAddImmediateData");
  465. }
  467. if (pBytes == NULL || numBytes == 0) {
  468. throw new MP4Error("no data",
  469. "AddImmediateData");
  470. }
  471. if (numBytes > 14) {
  472. throw new MP4Error("data size is larger than 14 bytes",
  473. "AddImmediateData");
  474. }
  476. MP4RtpImmediateData* pData = new MP4RtpImmediateData(pPacket);
  477. pData->Set(pBytes, numBytes);
  479. pPacket->AddData(pData);
  481. m_bytesThisHint += numBytes;
  482. m_bytesThisPacket += numBytes;
  483. m_pDimm->IncrementValue(numBytes);
  484. m_pTpyl->IncrementValue(numBytes);
  485. m_pTrpy->IncrementValue(numBytes);
  486. }
  488. void MP4RtpHintTrack::AddSampleData(
  489. MP4SampleId sampleId,
  490. u_int32_t dataOffset,
  491. u_int32_t dataLength)
  492. {
  493. if (m_pWriteHint == NULL) {
  494. throw new MP4Error("no hint pending", "MP4RtpAddSampleData");
  495. }
  497. MP4RtpPacket* pPacket = m_pWriteHint->GetCurrentPacket();
  498. if (pPacket == NULL) {
  499. throw new MP4Error("no packet pending", "MP4RtpAddSampleData");
  500. }
  502. MP4RtpSampleData* pData = new MP4RtpSampleData(pPacket);
  504. pData->SetReferenceSample(sampleId, dataOffset, dataLength);
  506. pPacket->AddData(pData);
  508. m_bytesThisHint += dataLength;
  509. m_bytesThisPacket += dataLength;
  510. m_pDmed->IncrementValue(dataLength);
  511. m_pTpyl->IncrementValue(dataLength);
  512. m_pTrpy->IncrementValue(dataLength);
  513. }
  515. void MP4RtpHintTrack::AddESConfigurationPacket()
  516. {
  517. if (m_pWriteHint == NULL) {
  518. throw new MP4Error("no hint pending", 
  519. "MP4RtpAddESConfigurationPacket");
  520. }
  522. u_int8_t* pConfig = NULL;
  523. u_int32_t configSize = 0;
  525. m_pFile->GetTrackESConfiguration(m_pRefTrack->GetId(),
  526. &pConfig, &configSize);
  528. if (pConfig == NULL) {
  529. return;
  530. }
  532. ASSERT(m_pMaxPacketSizeProperty);
  534. if (configSize > m_pMaxPacketSizeProperty->GetValue()) {
  535. throw new MP4Error("ES configuration is too large for RTP payload",
  536. "MP4RtpAddESConfigurationPacket");
  537. }
  539. AddPacket(false);
  541. MP4RtpPacket* pPacket = m_pWriteHint->GetCurrentPacket();
  542. ASSERT(pPacket);
  544. // This is ugly!
  545. // To get the ES configuration data somewhere known
  546. // we create a sample data reference that points to 
  547. // this hint track (not the media track)
  548. // and this sample of the hint track 
  549. // the offset into this sample is filled in during the write process
  550. MP4RtpSampleData* pData = new MP4RtpSampleData(pPacket);
  552. pData->SetEmbeddedImmediate(m_writeSampleId, pConfig, configSize);
  554. pPacket->AddData(pData);
  556. m_bytesThisHint += configSize;
  557. m_bytesThisPacket += configSize;
  558. m_pTpyl->IncrementValue(configSize);
  559. m_pTrpy->IncrementValue(configSize);
  560. }
  562. void MP4RtpHintTrack::WriteHint(MP4Duration duration, bool isSyncSample)
  563. {
  564. if (m_pWriteHint == NULL) {
  565. throw new MP4Error("no hint pending", "MP4WriteRtpHint");
  566. }
  568. u_int8_t* pBytes;
  569. u_int64_t numBytes;
  571. m_pFile->EnableMemoryBuffer();
  573. m_pWriteHint->Write(m_pFile);
  575. m_pFile->DisableMemoryBuffer(&pBytes, &numBytes);
  577. WriteSample(pBytes, numBytes, duration, 0, isSyncSample);
  579. MP4Free(pBytes);
  581. // update statistics
  582. if (m_bytesThisPacket > m_pPmax->GetValue()) {
  583. m_pPmax->SetValue(m_bytesThisPacket);
  584. }
  586. if (duration > m_pDmax->GetValue()) {
  587. m_pDmax->SetValue(duration);
  588. }
  590. MP4Timestamp startTime;
  592. GetSampleTimes(m_writeHintId, &startTime, NULL);
  594. if (startTime < m_thisSec + GetTimeScale()) {
  595. m_bytesThisSec += m_bytesThisHint;
  596. } else {
  597. if (m_bytesThisSec > m_pMaxr->GetValue()) {
  598. m_pMaxr->SetValue(m_bytesThisSec);
  599. }
  600. m_thisSec = startTime - (startTime % GetTimeScale());
  601. m_bytesThisSec = m_bytesThisHint;
  602. }
  604. // cleanup
  605. delete m_pWriteHint;
  606. m_pWriteHint = NULL;
  607. }
  609. void MP4RtpHintTrack::FinishWrite()
  610. {
  611. if (m_writeHintId != MP4_INVALID_SAMPLE_ID) {
  612. m_pMaxPdu->SetValue(m_pPmax->GetValue());
  613. if (m_pNump->GetValue()) {
  614. m_pAvgPdu->SetValue(m_pTrpy->GetValue() / m_pNump->GetValue());
  615. }
  617. m_pMaxBitRate->SetValue(m_pMaxr->GetValue() * 8);
  618. if (GetDuration()) {
  619. m_pAvgBitRate->SetValue(
  620. m_pTrpy->GetValue() * 8 * GetTimeScale() / GetDuration());
  621. }
  622. }
  624. MP4Track::FinishWrite();
  625. }
  627. void MP4RtpHintTrack::InitStats()
  628. {
  629. MP4Atom* pHinfAtom = m_pTrakAtom->FindAtom("trak.udta.hinf");
  631. ASSERT(pHinfAtom);
  633. pHinfAtom->FindProperty("hinf.trpy.bytes", (MP4Property**)&m_pTrpy); 
  634. pHinfAtom->FindProperty("hinf.nump.packets", (MP4Property**)&m_pNump); 
  635. pHinfAtom->FindProperty("hinf.tpyl.bytes", (MP4Property**)&m_pTpyl); 
  636. pHinfAtom->FindProperty("hinf.maxr.bytes", (MP4Property**)&m_pMaxr); 
  637. pHinfAtom->FindProperty("hinf.dmed.bytes", (MP4Property**)&m_pDmed); 
  638. pHinfAtom->FindProperty("hinf.dimm.bytes", (MP4Property**)&m_pDimm); 
  639. pHinfAtom->FindProperty("hinf.pmax.bytes", (MP4Property**)&m_pPmax); 
  640. pHinfAtom->FindProperty("hinf.dmax.milliSecs", (MP4Property**)&m_pDmax); 
  642. MP4Atom* pHmhdAtom = m_pTrakAtom->FindAtom("trak.mdia.minf.hmhd");
  644. ASSERT(pHmhdAtom);
  646. pHmhdAtom->FindProperty("hmhd.maxPduSize", (MP4Property**)&m_pMaxPdu); 
  647. pHmhdAtom->FindProperty("hmhd.avgPduSize", (MP4Property**)&m_pAvgPdu); 
  648. pHmhdAtom->FindProperty("hmhd.maxBitRate", (MP4Property**)&m_pMaxBitRate); 
  649. pHmhdAtom->FindProperty("hmhd.avgBitRate", (MP4Property**)&m_pAvgBitRate); 
  651. MP4Integer32Property* pMaxrPeriod = NULL;
  652. pHinfAtom->FindProperty("hinf.maxr.granularity",
  653.  (MP4Property**)&pMaxrPeriod); 
  654. if (pMaxrPeriod) {
  655. pMaxrPeriod->SetValue(1000); // 1 second
  656. }
  657. }
  660. MP4RtpHint::MP4RtpHint(MP4RtpHintTrack* pTrack)
  661. {
  662. m_pTrack = pTrack;
  664. AddProperty( /* 0 */
  665. new MP4Integer16Property("packetCount"));
  666. AddProperty( /* 1 */
  667. new MP4Integer16Property("reserved"));
  668. }
  670. MP4RtpHint::~MP4RtpHint()
  671. {
  672. for (u_int32_t i = 0; i < m_rtpPackets.Size(); i++) {
  673. delete m_rtpPackets[i];
  674. }
  675. }
  677. MP4RtpPacket* MP4RtpHint::AddPacket() 
  678. {
  679. MP4RtpPacket* pPacket = new MP4RtpPacket(this);
  680. m_rtpPackets.Add(pPacket);
  682. // packetCount property
  683. ((MP4Integer16Property*)m_pProperties[0])->IncrementValue();
  685. pPacket->SetBFrame(m_isBFrame);
  686. pPacket->SetTimestampOffset(m_timestampOffset);
  688. return pPacket;
  689. }
  691. void MP4RtpHint::Read(MP4File* pFile)
  692. {
  693. // call base class Read for required properties
  694. MP4Container::Read(pFile);
  696. u_int16_t numPackets =
  697. ((MP4Integer16Property*)m_pProperties[0])->GetValue();
  699. for (u_int16_t i = 0; i < numPackets; i++) {
  700. MP4RtpPacket* pPacket = new MP4RtpPacket(this);
  702. m_rtpPackets.Add(pPacket);
  704. pPacket->Read(pFile);
  705. }
  707. VERBOSE_READ_HINT(pFile->GetVerbosity(),
  708. printf("ReadHint:n"); Dump(stdout, 10, false););
  709. }
  711. void MP4RtpHint::Write(MP4File* pFile)
  712. {
  713. u_int64_t hintStartPos = pFile->GetPosition();
  715. MP4Container::Write(pFile);
  717. u_int64_t packetStartPos = pFile->GetPosition();
  719. u_int32_t i;
  721. // first write out packet (and data) entries
  722. for (i = 0; i < m_rtpPackets.Size(); i++) {
  723. m_rtpPackets[i]->Write(pFile);
  724. }
  726. // now let packets write their extra data into the hint sample
  727. for (i = 0; i < m_rtpPackets.Size(); i++) {
  728. m_rtpPackets[i]->WriteEmbeddedData(pFile, hintStartPos);
  729. }
  731. u_int64_t endPos = pFile->GetPosition();
  733. pFile->SetPosition(packetStartPos);
  735. // finally rewrite the packet and data entries
  736. // which now contain the correct offsets for the embedded data
  737. for (i = 0; i < m_rtpPackets.Size(); i++) {
  738. m_rtpPackets[i]->Write(pFile);
  739. }
  741. pFile->SetPosition(endPos);
  743. VERBOSE_WRITE_HINT(pFile->GetVerbosity(),
  744. printf("WriteRtpHint:n"); Dump(stdout, 14, false));
  745. }
  747. void MP4RtpHint::Dump(FILE* pFile, u_int8_t indent, bool dumpImplicits)
  748. {
  749. MP4Container::Dump(pFile, indent, dumpImplicits);
  751. for (u_int32_t i = 0; i < m_rtpPackets.Size(); i++) {
  752. Indent(pFile, indent);
  753. fprintf(pFile, "RtpPacket: %un", i);
  754. m_rtpPackets[i]->Dump(pFile, indent + 1, dumpImplicits);
  755. }
  756. }
  758. MP4RtpPacket::MP4RtpPacket(MP4RtpHint* pHint)
  759. {
  760. m_pHint = pHint;
  762. AddProperty( /* 0 */
  763. new MP4Integer32Property("relativeXmitTime"));
  764. AddProperty( /* 1 */
  765. new MP4BitfieldProperty("reserved1", 2));
  766. AddProperty( /* 2 */
  767. new MP4BitfieldProperty("Pbit", 1));
  768. AddProperty( /* 3 */
  769. new MP4BitfieldProperty("Xbit", 1));
  770. AddProperty( /* 4 */
  771. new MP4BitfieldProperty("reserved2", 4));
  772. AddProperty( /* 5 */
  773. new MP4BitfieldProperty("Mbit", 1));
  774. AddProperty( /* 6 */
  775. new MP4BitfieldProperty("payloadType", 7));
  776. AddProperty( /* 7  */
  777. new MP4Integer16Property("sequenceNumber"));
  778. AddProperty( /* 8 */
  779. new MP4BitfieldProperty("reserved3", 13));
  780. AddProperty( /* 9 */
  781. new MP4BitfieldProperty("extraFlag", 1));
  782. AddProperty( /* 10 */
  783. new MP4BitfieldProperty("bFrameFlag", 1));
  784. AddProperty( /* 11 */
  785. new MP4BitfieldProperty("repeatFlag", 1));
  786. AddProperty( /* 12 */
  787. new MP4Integer16Property("entryCount"));
  788. }
  789.  
  790. MP4RtpPacket::~MP4RtpPacket()
  791. {
  792. for (u_int32_t i = 0; i < m_rtpData.Size(); i++) {
  793. delete m_rtpData[i];
  794. }
  795. }
  797. void MP4RtpPacket::AddExtraProperties()
  798. {
  799. AddProperty( /* 13 */
  800. new MP4Integer32Property("extraInformationLength"));
  802. // This is a bit of a hack, since the tlv entries are really defined 
  803. // as atoms but there is only one type defined now, rtpo, and getting 
  804. // our atom code hooked up here would be a major pain with little gain
  806. AddProperty( /* 14 */
  807. new MP4Integer32Property("tlvLength"));
  808. AddProperty( /* 15 */
  809. new MP4StringProperty("tlvType"));
  810. AddProperty( /* 16 */
  811. new MP4Integer32Property("timestampOffset"));
  813. ((MP4Integer32Property*)m_pProperties[13])->SetValue(16);
  814. ((MP4Integer32Property*)m_pProperties[14])->SetValue(12);
  815. ((MP4StringProperty*)m_pProperties[15])->SetFixedLength(4);
  816. ((MP4StringProperty*)m_pProperties[15])->SetValue("rtpo");
  817. }
  819. void MP4RtpPacket::Read(MP4File* pFile)
  820. {
  821. // call base class Read for required properties
  822. MP4Container::Read(pFile);
  824. // read extra info if present
  825. // we only support the rtpo field!
  826. if (((MP4BitfieldProperty*)m_pProperties[9])->GetValue() == 1) {
  827. ReadExtra(pFile);
  828. }
  830. u_int16_t numDataEntries =
  831. ((MP4Integer16Property*)m_pProperties[12])->GetValue();
  833. // read data entries
  834. for (u_int16_t i = 0; i < numDataEntries; i++) {
  835. u_int8_t dataType;
  836. pFile->PeekBytes(&dataType, 1);
  838. MP4RtpData* pData;
  840. switch (dataType) {
  841. case 0:
  842. pData = new MP4RtpNullData(this);
  843. break;
  844. case 1:
  845. pData = new MP4RtpImmediateData(this);
  846. break;
  847. case 2:
  848. pData = new MP4RtpSampleData(this);
  849. break;
  850. case 3:
  851. pData = new MP4RtpSampleDescriptionData(this);
  852. break;
  853. default:
  854. throw new MP4Error("unknown packet data entry type",
  855. "MP4ReadHint");
  856. }
  858. m_rtpData.Add(pData);
  860. // read data entry's properties
  861. pData->Read(pFile);
  862. }
  863. }
  865. void MP4RtpPacket::ReadExtra(MP4File* pFile)
  866. {
  867. AddExtraProperties();
  869. int32_t extraLength = (int32_t)pFile->ReadUInt32();
  871. if (extraLength < 4) {
  872. throw new MP4Error("bad packet extra info length",
  873. "MP4RtpPacket::ReadExtra");
  874. }
  875. extraLength -= 4;
  877. while (extraLength > 0) {
  878. u_int32_t entryLength = pFile->ReadUInt32();
  879. u_int32_t entryTag = pFile->ReadUInt32();
  881. if (entryLength < 8) {
  882. throw new MP4Error("bad packet extra info entry length",
  883. "MP4RtpPacket::ReadExtra");
  884. }
  886. if (entryTag == STRTOINT32("rtpo") && entryLength == 12) {
  887. // read the rtp timestamp offset
  888. m_pProperties[16]->Read(pFile);
  889. } else {
  890. // ignore it, LATER carry it along
  891. pFile->SetPosition(pFile->GetPosition() + entryLength - 8);
  892. }
  894. extraLength -= entryLength;
  895. }
  897. if (extraLength < 0) {
  898. throw new MP4Error("invalid packet extra info length",
  899. "MP4RtpPacket::ReadExtra");
  900. }
  901. }
  903. void MP4RtpPacket::Set(u_int8_t payloadNumber, 
  904. u_int32_t packetId, bool setMbit)
  905. {
  906. ((MP4BitfieldProperty*)m_pProperties[5])->SetValue(setMbit);
  907. ((MP4BitfieldProperty*)m_pProperties[6])->SetValue(payloadNumber);
  908. ((MP4Integer16Property*)m_pProperties[7])->SetValue(packetId);
  909. }
  911. int32_t MP4RtpPacket::GetTransmitOffset()
  912. {
  913. return ((MP4Integer32Property*)m_pProperties[0])->GetValue();
  914. }
  916. void MP4RtpPacket::SetTransmitOffset(int32_t transmitOffset)
  917. {
  918. ((MP4Integer32Property*)m_pProperties[0])->SetValue(transmitOffset);
  919. }
  921. bool MP4RtpPacket::GetPBit()
  922. {
  923. return ((MP4BitfieldProperty*)m_pProperties[2])->GetValue();
  924. }
  926. bool MP4RtpPacket::GetXBit()
  927. {
  928. return ((MP4BitfieldProperty*)m_pProperties[3])->GetValue();
  929. }
  931. bool MP4RtpPacket::GetMBit()
  932. {
  933. return ((MP4BitfieldProperty*)m_pProperties[5])->GetValue();
  934. }
  936. u_int8_t MP4RtpPacket::GetPayload()
  937. {
  938. return ((MP4BitfieldProperty*)m_pProperties[6])->GetValue();
  939. }
  941. u_int16_t MP4RtpPacket::GetSequenceNumber()
  942. {
  943. return ((MP4Integer16Property*)m_pProperties[7])->GetValue();
  944. }
  946. bool MP4RtpPacket::IsBFrame()
  947. {
  948. return ((MP4BitfieldProperty*)m_pProperties[10])->GetValue();
  949. }
  951. void MP4RtpPacket::SetBFrame(bool isBFrame)
  952. {
  953. ((MP4BitfieldProperty*)m_pProperties[10])->SetValue(isBFrame);
  954. }
  956. void MP4RtpPacket::SetTimestampOffset(u_int32_t timestampOffset)
  957. {
  958. if (timestampOffset == 0) {
  959. return;
  960. }
  962. ASSERT(((MP4BitfieldProperty*)m_pProperties[9])->GetValue() == 0);
  964. // set X bit
  965. ((MP4BitfieldProperty*)m_pProperties[9])->SetValue(1);
  967. AddExtraProperties();
  969. ((MP4Integer32Property*)m_pProperties[16])->SetValue(timestampOffset);
  970. }
  972. void MP4RtpPacket::AddData(MP4RtpData* pData)
  973. {
  974. m_rtpData.Add(pData);
  976. // increment entry count property
  977. ((MP4Integer16Property*)m_pProperties[12])->IncrementValue();
  978. }
  980. u_int32_t MP4RtpPacket::GetDataSize()
  981. {
  982. u_int32_t totalDataSize = 0;
  984. for (u_int32_t i = 0; i < m_rtpData.Size(); i++) {
  985. totalDataSize += m_rtpData[i]->GetDataSize();
  986. }
  988. return totalDataSize;
  989. }
  991. void MP4RtpPacket::GetData(u_int8_t* pDest)
  992. {
  993. for (u_int32_t i = 0; i < m_rtpData.Size(); i++) {
  994. m_rtpData[i]->GetData(pDest);
  995. pDest += m_rtpData[i]->GetDataSize();
  996. }
  997. }
  999. void MP4RtpPacket::Write(MP4File* pFile)
  1000. {
  1001. MP4Container::Write(pFile);
  1003. for (u_int32_t i = 0; i < m_rtpData.Size(); i++) {
  1004. m_rtpData[i]->Write(pFile);
  1005. }
  1006. }
  1008. void MP4RtpPacket::WriteEmbeddedData(MP4File* pFile, u_int64_t startPos)
  1009. {
  1010. for (u_int32_t i = 0; i < m_rtpData.Size(); i++) {
  1011. m_rtpData[i]->WriteEmbeddedData(pFile, startPos);
  1012. }
  1013. }
  1015. void MP4RtpPacket::Dump(FILE* pFile, u_int8_t indent, bool dumpImplicits)
  1016. {
  1017. MP4Container::Dump(pFile, indent, dumpImplicits);
  1019. for (u_int32_t i = 0; i < m_rtpData.Size(); i++) {
  1020. Indent(pFile, indent);
  1021. fprintf(pFile, "RtpData: %un", i);
  1022. m_rtpData[i]->Dump(pFile, indent + 1, dumpImplicits);
  1023. }
  1024. }
  1026. MP4RtpData::MP4RtpData(MP4RtpPacket* pPacket)
  1027. {
  1028. m_pPacket = pPacket;
  1030. AddProperty( /* 0 */
  1031. new MP4Integer8Property("type"));
  1032. }
  1034. MP4Track* MP4RtpData::FindTrackFromRefIndex(u_int8_t refIndex)
  1035. {
  1036. MP4Track* pTrack;
  1038. if (refIndex == (u_int8_t)-1) {
  1039. // ourselves
  1040. pTrack = GetPacket()->GetHint()->GetTrack();
  1041. } else if (refIndex == 0) {
  1042. // our reference track
  1043. pTrack = GetPacket()->GetHint()->GetTrack()->GetRefTrack();
  1044. } else {
  1045. // some other track
  1046. MP4RtpHintTrack* pHintTrack =
  1047. GetPacket()->GetHint()->GetTrack();
  1049. MP4Atom* pTrakAtom = pHintTrack->GetTrakAtom();
  1050. ASSERT(pTrakAtom);
  1052. MP4Integer32Property* pTrackIdProperty = NULL;
  1053. pTrakAtom->FindProperty(
  1054. "trak.tref.hint.entries",
  1055. (MP4Property**)&pTrackIdProperty);
  1056. ASSERT(pTrackIdProperty);
  1058. u_int32_t refTrackId = 
  1059. pTrackIdProperty->GetValue(refIndex - 1);
  1061. pTrack = pHintTrack->GetFile()->GetTrack(refTrackId); 
  1062. }
  1064. return pTrack;
  1065. }
  1067. MP4RtpNullData::MP4RtpNullData(MP4RtpPacket* pPacket)
  1068. : MP4RtpData(pPacket)
  1069. {
  1070. ((MP4Integer8Property*)m_pProperties[0])->SetValue(0);
  1072. AddProperty( /* 1 */
  1073. new MP4BytesProperty("pad", 15));
  1075. ((MP4BytesProperty*)m_pProperties[1])->SetFixedSize(15);
  1076. }
  1078. MP4RtpImmediateData::MP4RtpImmediateData(MP4RtpPacket* pPacket)
  1079. : MP4RtpData(pPacket)
  1080. {
  1081. ((MP4Integer8Property*)m_pProperties[0])->SetValue(1);
  1083. AddProperty( /* 1 */
  1084. new MP4Integer8Property("count"));
  1085. AddProperty( /* 2 */
  1086. new MP4BytesProperty("data", 14));
  1088. ((MP4BytesProperty*)m_pProperties[2])->SetFixedSize(14);
  1089. }
  1091. void MP4RtpImmediateData::Set(const u_int8_t* pBytes, u_int8_t numBytes)
  1092. {
  1093. ((MP4Integer8Property*)m_pProperties[1])->SetValue(numBytes);
  1094. ((MP4BytesProperty*)m_pProperties[2])->SetValue(pBytes, numBytes);
  1095. }
  1097. u_int16_t MP4RtpImmediateData::GetDataSize()
  1098. {
  1099. return ((MP4Integer8Property*)m_pProperties[1])->GetValue();
  1100. }
  1102. void MP4RtpImmediateData::GetData(u_int8_t* pDest)
  1103. {
  1104. u_int8_t* pValue;
  1105. u_int32_t valueSize;
  1106. ((MP4BytesProperty*)m_pProperties[2])->GetValue(&pValue, &valueSize);
  1108. memcpy(pDest, pValue, GetDataSize());
  1109. MP4Free(pValue);
  1110. }
  1112. MP4RtpSampleData::MP4RtpSampleData(MP4RtpPacket* pPacket)
  1113. : MP4RtpData(pPacket)
  1114. {
  1115. ((MP4Integer8Property*)m_pProperties[0])->SetValue(2);
  1117. AddProperty( /* 1 */
  1118. new MP4Integer8Property("trackRefIndex"));
  1119. AddProperty( /* 2 */
  1120. new MP4Integer16Property("length"));
  1121. AddProperty( /* 3 */
  1122. new MP4Integer32Property("sampleNumber"));
  1123. AddProperty( /* 4 */
  1124. new MP4Integer32Property("sampleOffset"));
  1125. AddProperty( /* 5 */
  1126. new MP4Integer16Property("bytesPerBlock"));
  1127. AddProperty( /* 6 */
  1128. new MP4Integer16Property("samplesPerBlock"));
  1130. ((MP4Integer16Property*)m_pProperties[5])->SetValue(1);
  1131. ((MP4Integer16Property*)m_pProperties[6])->SetValue(1);
  1133. m_pRefData = NULL;
  1134. m_pRefTrack = NULL;
  1135. m_refSampleId = MP4_INVALID_SAMPLE_ID;
  1136. m_refSampleOffset = 0;
  1137. }
  1139. void MP4RtpSampleData::SetEmbeddedImmediate(MP4SampleId sampleId, 
  1140. u_int8_t* pData, u_int16_t dataLength)
  1141. {
  1142. ((MP4Integer8Property*)m_pProperties[1])->SetValue((u_int8_t)-1);
  1143. ((MP4Integer16Property*)m_pProperties[2])->SetValue(dataLength);
  1144. ((MP4Integer32Property*)m_pProperties[3])->SetValue(sampleId);
  1145. ((MP4Integer32Property*)m_pProperties[4])->SetValue(0); 
  1146. m_pRefData = pData;
  1147. }
  1149. void MP4RtpSampleData::SetReferenceSample(
  1150. MP4SampleId refSampleId, u_int32_t refSampleOffset, 
  1151. u_int16_t sampleLength)
  1152. {
  1153. ((MP4Integer8Property*)m_pProperties[1])->SetValue(0);
  1154. ((MP4Integer16Property*)m_pProperties[2])->SetValue(sampleLength);
  1155. ((MP4Integer32Property*)m_pProperties[3])->SetValue(refSampleId);
  1156. ((MP4Integer32Property*)m_pProperties[4])->SetValue(refSampleOffset);
  1157. }
  1159. void MP4RtpSampleData::SetEmbeddedSample(
  1160. MP4SampleId sampleId, MP4Track* pRefTrack,
  1161. MP4SampleId refSampleId, u_int32_t refSampleOffset, 
  1162. u_int16_t sampleLength)
  1163. {
  1164. ((MP4Integer8Property*)m_pProperties[1])->SetValue((u_int8_t)-1);
  1165. ((MP4Integer16Property*)m_pProperties[2])->SetValue(sampleLength);
  1166. ((MP4Integer32Property*)m_pProperties[3])->SetValue(sampleId);
  1167. ((MP4Integer32Property*)m_pProperties[4])->SetValue(0);
  1168. m_pRefTrack = pRefTrack;
  1169. m_refSampleId = refSampleId;
  1170. m_refSampleOffset = refSampleOffset;
  1171. }
  1173. u_int16_t MP4RtpSampleData::GetDataSize()
  1174. {
  1175. return ((MP4Integer16Property*)m_pProperties[2])->GetValue();
  1176. }
  1178. void MP4RtpSampleData::GetData(u_int8_t* pDest)
  1179. {
  1180. u_int8_t trackRefIndex = 
  1181. ((MP4Integer8Property*)m_pProperties[1])->GetValue();
  1183. MP4Track* pSampleTrack =
  1184. FindTrackFromRefIndex(trackRefIndex);
  1186. pSampleTrack->ReadSampleFragment(
  1187. ((MP4Integer32Property*)m_pProperties[3])->GetValue(), // sampleId 
  1188. ((MP4Integer32Property*)m_pProperties[4])->GetValue(), // sampleOffset
  1189. ((MP4Integer16Property*)m_pProperties[2])->GetValue(), // sampleLength
  1190. pDest);
  1191. }
  1193. void MP4RtpSampleData::WriteEmbeddedData(MP4File* pFile, u_int64_t startPos)
  1194. {
  1195. // if not using embedded data, nothing to do
  1196. if (((MP4Integer8Property*)m_pProperties[1])->GetValue() != (u_int8_t)-1) {
  1197. return;
  1198. }
  1200. // figure out the offset within this hint sample for this embedded data
  1201. u_int64_t offset = pFile->GetPosition() - startPos;
  1202. ASSERT(offset <= 0xFFFFFFFF);
  1203. ((MP4Integer32Property*)m_pProperties[4])->SetValue((u_int32_t)offset);
  1205. u_int16_t length = ((MP4Integer16Property*)m_pProperties[2])->GetValue();
  1207. if (m_pRefData) {
  1208. pFile->WriteBytes(m_pRefData, length);
  1209. return;
  1210. } 
  1212. if (m_refSampleId != MP4_INVALID_SAMPLE_ID) {
  1213. u_int8_t* pSample = NULL;
  1214. u_int32_t sampleSize = 0;
  1216. ASSERT(m_pRefTrack);
  1217. m_pRefTrack->ReadSample(m_refSampleId, &pSample, &sampleSize);
  1219. ASSERT(m_refSampleOffset + length <= sampleSize);
  1221. pFile->WriteBytes(&pSample[m_refSampleOffset], length);
  1223. MP4Free(pSample);
  1224. return;
  1225. }
  1226. }
  1228. MP4RtpSampleDescriptionData::MP4RtpSampleDescriptionData(MP4RtpPacket* pPacket)
  1229. : MP4RtpData(pPacket)
  1230. {
  1231. ((MP4Integer8Property*)m_pProperties[0])->SetValue(3);
  1233. AddProperty( /* 1 */
  1234. new MP4Integer8Property("trackRefIndex"));
  1235. AddProperty( /* 2 */
  1236. new MP4Integer16Property("length"));
  1237. AddProperty( /* 3 */
  1238. new MP4Integer32Property("sampleDescriptionIndex"));
  1239. AddProperty( /* 4 */
  1240. new MP4Integer32Property("sampleDescriptionOffset"));
  1241. AddProperty( /* 5 */
  1242. new MP4Integer32Property("reserved"));
  1243. }
  1245. void MP4RtpSampleDescriptionData::Set(u_int32_t sampleDescrIndex,
  1246. u_int32_t offset, u_int16_t length)
  1247. {
  1248. ((MP4Integer16Property*)m_pProperties[2])->SetValue(length);
  1249. ((MP4Integer32Property*)m_pProperties[3])->SetValue(sampleDescrIndex);
  1250. ((MP4Integer32Property*)m_pProperties[4])->SetValue(offset);
  1251. }
  1253. u_int16_t MP4RtpSampleDescriptionData::GetDataSize()
  1254. {
  1255. return ((MP4Integer16Property*)m_pProperties[2])->GetValue();
  1256. }
  1258. void MP4RtpSampleDescriptionData::GetData(u_int8_t* pDest)
  1259. {
  1260. // we start with the index into our track references
  1261. u_int8_t trackRefIndex = 
  1262. ((MP4Integer8Property*)m_pProperties[1])->GetValue();
  1264. // from which we can find the track structure
  1265. MP4Track* pSampleTrack =
  1266. FindTrackFromRefIndex(trackRefIndex);
  1268. // next find the desired atom in the track's sample description table
  1269. u_int32_t sampleDescrIndex =
  1270. ((MP4Integer32Property*)m_pProperties[3])->GetValue();
  1272. MP4Atom* pTrakAtom =
  1273. pSampleTrack->GetTrakAtom();
  1275. char sdName[64];
  1276. sprintf(sdName, "trak.mdia.minf.stbl.stsd.*[%u]", sampleDescrIndex);
  1278. MP4Atom* pSdAtom =
  1279. pTrakAtom->FindAtom(sdName);
  1281. // bad reference
  1282. if (pSdAtom == NULL) {
  1283. throw new MP4Error("invalid sample description index",
  1284. "MP4RtpSampleDescriptionData::GetData");
  1285. }
  1287. // check validity of the upcoming copy
  1288. u_int16_t length = 
  1289. ((MP4Integer16Property*)m_pProperties[2])->GetValue();
  1290. u_int32_t offset =
  1291. ((MP4Integer32Property*)m_pProperties[4])->GetValue();
  1293. if (offset + length > pSdAtom->GetSize()) {
  1294. throw new MP4Error("offset and/or length are too large", 
  1295. "MP4RtpSampleDescriptionData::GetData");
  1296. }
  1298. // now we use the raw file to get the desired bytes
  1300. MP4File* pFile = GetPacket()->GetHint()->GetTrack()->GetFile();
  1302. u_int64_t orgPos = pFile->GetPosition();
  1304. // It's not entirely clear from the spec whether the offset is from 
  1305. // the start of the sample descirption atom, or the start of the atom's
  1306. // data. I believe it is the former, but the commented out code will 
  1307. // realize the latter interpretation if I turn out to be wrong.
  1308. u_int64_t dataPos = pSdAtom->GetStart();
  1309. //u_int64_t dataPos = pSdAtom->GetEnd() - pSdAtom->GetSize();
  1311. pFile->SetPosition(dataPos + offset);
  1313. pFile->ReadBytes(pDest, length);
  1315. pFile->SetPosition(orgPos);
  1316. }