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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mp4track.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. MP4Track::MP4Track(MP4File* pFile, MP4Atom* pTrakAtom) 
  25. {
  26. m_pFile = pFile;
  27. m_pTrakAtom = pTrakAtom;
  29. m_lastStsdIndex = 0;
  30. m_lastSampleFile = NULL;
  32. m_cachedReadSampleId = MP4_INVALID_SAMPLE_ID;
  33. m_pCachedReadSample = NULL;
  34. m_cachedReadSampleSize = 0;
  36. m_writeSampleId = 1;
  37. m_fixedSampleDuration = 0;
  38. m_pChunkBuffer = NULL;
  39. m_chunkBufferSize = 0;
  40. m_chunkSamples = 0;
  41. m_chunkDuration = 0;
  43. m_samplesPerChunk = 0;
  44. m_durationPerChunk = 0;
  46. bool success = true;
  48. MP4Integer32Property* pTrackIdProperty;
  49. success &= m_pTrakAtom->FindProperty(
  50. "trak.tkhd.trackId",
  51. (MP4Property**)&pTrackIdProperty);
  52. if (success) {
  53. m_trackId = pTrackIdProperty->GetValue();
  54. }
  56. success &= m_pTrakAtom->FindProperty(
  57. "trak.mdia.mdhd.timeScale", 
  58. (MP4Property**)&m_pTimeScaleProperty);
  59. if (success) {
  60. // default chunking is 1 second of samples
  61. m_durationPerChunk = m_pTimeScaleProperty->GetValue();
  62. }
  64. success &= m_pTrakAtom->FindProperty(
  65. "trak.tkhd.duration", 
  66. (MP4Property**)&m_pTrackDurationProperty);
  68. success &= m_pTrakAtom->FindProperty(
  69. "trak.mdia.mdhd.duration", 
  70. (MP4Property**)&m_pMediaDurationProperty);
  72. success &= m_pTrakAtom->FindProperty(
  73. "trak.tkhd.modificationTime", 
  74. (MP4Property**)&m_pTrackModificationProperty);
  76. success &= m_pTrakAtom->FindProperty(
  77. "trak.mdia.mdhd.modificationTime", 
  78. (MP4Property**)&m_pMediaModificationProperty);
  80. success &= m_pTrakAtom->FindProperty(
  81. "trak.mdia.hdlr.handlerType",
  82. (MP4Property**)&m_pTypeProperty);
  84. // get handles on sample size information
  86. success &= m_pTrakAtom->FindProperty(
  87. "trak.mdia.minf.stbl.stsz.sampleSize",
  88. (MP4Property**)&m_pStszFixedSampleSizeProperty);
  90. success &= m_pTrakAtom->FindProperty(
  91. "trak.mdia.minf.stbl.stsz.sampleCount",
  92. (MP4Property**)&m_pStszSampleCountProperty);
  94. success &= m_pTrakAtom->FindProperty(
  95. "trak.mdia.minf.stbl.stsz.entries.sampleSize",
  96. (MP4Property**)&m_pStszSampleSizeProperty);
  98. // get handles on information needed to map sample id's to file offsets
  100. success &= m_pTrakAtom->FindProperty(
  101. "trak.mdia.minf.stbl.stsc.entryCount",
  102. (MP4Property**)&m_pStscCountProperty);
  104. success &= m_pTrakAtom->FindProperty(
  105. "trak.mdia.minf.stbl.stsc.entries.firstChunk",
  106. (MP4Property**)&m_pStscFirstChunkProperty);
  108. success &= m_pTrakAtom->FindProperty(
  109. "trak.mdia.minf.stbl.stsc.entries.samplesPerChunk",
  110. (MP4Property**)&m_pStscSamplesPerChunkProperty);
  112. success &= m_pTrakAtom->FindProperty(
  113. "trak.mdia.minf.stbl.stsc.entries.sampleDescriptionIndex",
  114. (MP4Property**)&m_pStscSampleDescrIndexProperty);
  116. success &= m_pTrakAtom->FindProperty(
  117. "trak.mdia.minf.stbl.stsc.entries.firstSample",
  118. (MP4Property**)&m_pStscFirstSampleProperty);
  120. bool haveStco = m_pTrakAtom->FindProperty(
  121. "trak.mdia.minf.stbl.stco.entryCount",
  122. (MP4Property**)&m_pChunkCountProperty);
  124. if (haveStco) {
  125. success &= m_pTrakAtom->FindProperty(
  126. "trak.mdia.minf.stbl.stco.entries.chunkOffset",
  127. (MP4Property**)&m_pChunkOffsetProperty);
  128. } else {
  129. success &= m_pTrakAtom->FindProperty(
  130. "trak.mdia.minf.stbl.co64.entryCount",
  131. (MP4Property**)&m_pChunkCountProperty);
  133. success &= m_pTrakAtom->FindProperty(
  134. "trak.mdia.minf.stbl.co64.entries.chunkOffset",
  135. (MP4Property**)&m_pChunkOffsetProperty);
  136. }
  138. // get handles on sample timing info
  140. success &= m_pTrakAtom->FindProperty(
  141. "trak.mdia.minf.stbl.stts.entryCount",
  142. (MP4Property**)&m_pSttsCountProperty);
  144. success &= m_pTrakAtom->FindProperty(
  145. "trak.mdia.minf.stbl.stts.entries.sampleCount",
  146. (MP4Property**)&m_pSttsSampleCountProperty);
  148. success &= m_pTrakAtom->FindProperty(
  149. "trak.mdia.minf.stbl.stts.entries.sampleDelta",
  150. (MP4Property**)&m_pSttsSampleDeltaProperty);
  152. // get handles on rendering offset info if it exists
  154. m_pCttsCountProperty = NULL;
  155. m_pCttsSampleCountProperty = NULL;
  156. m_pCttsSampleOffsetProperty = NULL;
  158. bool haveCtts = m_pTrakAtom->FindProperty(
  159. "trak.mdia.minf.stbl.ctts.entryCount",
  160. (MP4Property**)&m_pCttsCountProperty);
  162. if (haveCtts) {
  163. success &= m_pTrakAtom->FindProperty(
  164. "trak.mdia.minf.stbl.ctts.entries.sampleCount",
  165. (MP4Property**)&m_pCttsSampleCountProperty);
  167. success &= m_pTrakAtom->FindProperty(
  168. "trak.mdia.minf.stbl.ctts.entries.sampleOffset",
  169. (MP4Property**)&m_pCttsSampleOffsetProperty);
  170. }
  172. // get handles on sync sample info if it exists
  174. m_pStssCountProperty = NULL;
  175. m_pStssSampleProperty = NULL;
  177. bool haveStss = m_pTrakAtom->FindProperty(
  178. "trak.mdia.minf.stbl.stss.entryCount",
  179. (MP4Property**)&m_pStssCountProperty);
  181. if (haveStss) {
  182. success &= m_pTrakAtom->FindProperty(
  183. "trak.mdia.minf.stbl.stss.entries.sampleNumber",
  184. (MP4Property**)&m_pStssSampleProperty);
  185. }
  187. // edit list
  188. InitEditListProperties();
  190. // was everything found?
  191. if (!success) {
  192. throw new MP4Error("invalid track", "MP4Track::MP4Track");
  193. }
  194. }
  196. MP4Track::~MP4Track()
  197. {
  198. MP4Free(m_pCachedReadSample);
  199. MP4Free(m_pChunkBuffer);
  200. }
  202. const char* MP4Track::GetType()
  203. {
  204. return m_pTypeProperty->GetValue();
  205. }
  207. void MP4Track::SetType(const char* type) 
  208. {
  209. m_pTypeProperty->SetValue(NormalizeTrackType(type));
  210. }
  212. void MP4Track::ReadSample(
  213. MP4SampleId sampleId,
  214. u_int8_t** ppBytes, 
  215. u_int32_t* pNumBytes, 
  216. MP4Timestamp* pStartTime, 
  217. MP4Duration* pDuration,
  218. MP4Duration* pRenderingOffset, 
  219. bool* pIsSyncSample)
  220. {
  221. if (sampleId == MP4_INVALID_SAMPLE_ID) {
  222. throw new MP4Error("sample id can't be zero", 
  223. "MP4Track::ReadSample");
  224. }
  226. // handle unusual case of wanting to read a sample
  227. // that is still sitting in the write chunk buffer
  228. if (m_pChunkBuffer && sampleId >= m_writeSampleId - m_chunkSamples) {
  229. WriteChunkBuffer();
  230. }
  232. FILE* pFile = GetSampleFile(sampleId);
  234. if (pFile == (FILE*)-1) {
  235. throw new MP4Error("sample is located in an inaccessible file",
  236. "MP4Track::ReadSample");
  237. }
  239. u_int64_t fileOffset = GetSampleFileOffset(sampleId);
  241. u_int32_t sampleSize = GetSampleSize(sampleId);
  242. if (*ppBytes != NULL && *pNumBytes < sampleSize) {
  243. throw new MP4Error("sample buffer is too small",
  244.  "MP4Track::ReadSample");
  245. }
  246. *pNumBytes = sampleSize;
  248. VERBOSE_READ_SAMPLE(m_pFile->GetVerbosity(),
  249. printf("ReadSample: track %u id %u offset 0x"LLX" size %u (0x%x)n",
  250. m_trackId, sampleId, fileOffset, *pNumBytes, *pNumBytes));
  252. bool bufferMalloc = false;
  253. if (*ppBytes == NULL) {
  254. *ppBytes = (u_int8_t*)MP4Malloc(*pNumBytes);
  255. bufferMalloc = true;
  256. }
  258. u_int64_t oldPos = m_pFile->GetPosition(pFile); // only used in mode == 'w'
  259. try { 
  260. m_pFile->SetPosition(fileOffset, pFile);
  261. m_pFile->ReadBytes(*ppBytes, *pNumBytes, pFile);
  263. if (pStartTime || pDuration) {
  264. GetSampleTimes(sampleId, pStartTime, pDuration);
  266. VERBOSE_READ_SAMPLE(m_pFile->GetVerbosity(),
  267. printf("ReadSample:  start "LLU" duration "LLD"n",
  268. (pStartTime ? *pStartTime : 0), 
  269. (pDuration ? *pDuration : 0)));
  270. }
  271. if (pRenderingOffset) {
  272. *pRenderingOffset = GetSampleRenderingOffset(sampleId);
  274. VERBOSE_READ_SAMPLE(m_pFile->GetVerbosity(),
  275. printf("ReadSample:  renderingOffset "LLD"n",
  276. *pRenderingOffset));
  277. }
  278. if (pIsSyncSample) {
  279. *pIsSyncSample = IsSyncSample(sampleId);
  281. VERBOSE_READ_SAMPLE(m_pFile->GetVerbosity(),
  282. printf("ReadSample:  isSyncSample %un",
  283. *pIsSyncSample));
  284. }
  285. }
  287. catch (MP4Error* e) {
  288. if (bufferMalloc) {
  289. // let's not leak memory
  290. MP4Free(*ppBytes);
  291. *ppBytes = NULL;
  292. }
  293. if (m_pFile->GetMode() == 'w') {
  294. m_pFile->SetPosition(oldPos, pFile);
  295. }
  296. throw e;
  297. }
  299. if (m_pFile->GetMode() == 'w') {
  300. m_pFile->SetPosition(oldPos, pFile);
  301. }
  302. }
  304. void MP4Track::ReadSampleFragment(
  305. MP4SampleId sampleId,
  306. u_int32_t sampleOffset,
  307. u_int16_t sampleLength,
  308. u_int8_t* pDest)
  309. {
  310. if (sampleId == MP4_INVALID_SAMPLE_ID) {
  311. throw new MP4Error("invalid sample id", 
  312. "MP4Track::ReadSampleFragment");
  313. }
  315. if (sampleId != m_cachedReadSampleId) {
  316. MP4Free(m_pCachedReadSample);
  317. m_pCachedReadSample = NULL;
  318. m_cachedReadSampleSize = 0;
  319. m_cachedReadSampleId = MP4_INVALID_SAMPLE_ID;
  321. ReadSample(
  322. sampleId,
  323. &m_pCachedReadSample,
  324. &m_cachedReadSampleSize);
  326. m_cachedReadSampleId = sampleId;
  327. }
  329. if (sampleOffset + sampleLength > m_cachedReadSampleSize) {
  330. throw new MP4Error("offset and/or length are too large", 
  331. "MP4Track::ReadSampleFragment");
  332. }
  334. memcpy(pDest, &m_pCachedReadSample[sampleOffset], sampleLength);
  335. }
  337. void MP4Track::WriteSample(
  338. u_int8_t* pBytes, 
  339. u_int32_t numBytes,
  340. MP4Duration duration, 
  341. MP4Duration renderingOffset, 
  342. bool isSyncSample)
  343. {
  344. VERBOSE_WRITE_SAMPLE(m_pFile->GetVerbosity(),
  345. printf("WriteSample: track %u id %u size %u (0x%x) ",
  346. m_trackId, m_writeSampleId, numBytes, numBytes));
  348. if (pBytes == NULL && numBytes > 0) {
  349. throw new MP4Error("no sample data", "MP4WriteSample");
  350. }
  352. if (duration == MP4_INVALID_DURATION) {
  353. duration = GetFixedSampleDuration();
  354. }
  356. VERBOSE_WRITE_SAMPLE(m_pFile->GetVerbosity(),
  357. printf("duration "LLU"n", duration));
  359. // append sample bytes to chunk buffer
  360. m_pChunkBuffer = (u_int8_t*)MP4Realloc(m_pChunkBuffer, 
  361. m_chunkBufferSize + numBytes);
  362. memcpy(&m_pChunkBuffer[m_chunkBufferSize], pBytes, numBytes);
  363. m_chunkBufferSize += numBytes;
  364. m_chunkSamples++;
  365. m_chunkDuration += duration;
  367. UpdateSampleSizes(m_writeSampleId, numBytes);
  369. UpdateSampleTimes(duration);
  371. UpdateRenderingOffsets(m_writeSampleId, renderingOffset);
  373. UpdateSyncSamples(m_writeSampleId, isSyncSample);
  375. if (IsChunkFull(m_writeSampleId)) {
  376. WriteChunkBuffer();
  377. }
  379. UpdateDurations(duration);
  381. UpdateModificationTimes();
  383. m_writeSampleId++;
  384. }
  386. void MP4Track::WriteChunkBuffer()
  387. {
  388. if (m_chunkBufferSize == 0) {
  389. return;
  390. }
  392. u_int64_t chunkOffset = m_pFile->GetPosition();
  394. // write chunk buffer
  395. m_pFile->WriteBytes(m_pChunkBuffer, m_chunkBufferSize);
  397. VERBOSE_WRITE_SAMPLE(m_pFile->GetVerbosity(),
  398. printf("WriteChunk: track %u offset 0x"LLX" size %u (0x%x) numSamples %un",
  399. m_trackId, chunkOffset, m_chunkBufferSize, 
  400. m_chunkBufferSize, m_chunkSamples));
  402. UpdateSampleToChunk(m_writeSampleId, 
  403. m_pChunkCountProperty->GetValue() + 1, 
  404. m_chunkSamples);
  406. UpdateChunkOffsets(chunkOffset);
  408. // clean up chunk buffer
  409. MP4Free(m_pChunkBuffer);
  410. m_pChunkBuffer = NULL;
  411. m_chunkBufferSize = 0;
  412. m_chunkSamples = 0;
  413. m_chunkDuration = 0;
  414. }
  416. void MP4Track::FinishWrite()
  417. {
  418. // write out any remaining samples in chunk buffer
  419. WriteChunkBuffer();
  421. // record buffer size and bitrates
  422. MP4BitfieldProperty* pBufferSizeProperty;
  424. if (m_pTrakAtom->FindProperty(
  425.   "trak.mdia.minf.stbl.stsd.*.esds.decConfigDescr.bufferSizeDB",
  426.   (MP4Property**)&pBufferSizeProperty)) {
  427. pBufferSizeProperty->SetValue(GetMaxSampleSize());
  428. }
  430. MP4Integer32Property* pBitrateProperty;
  432. if (m_pTrakAtom->FindProperty(
  433.   "trak.mdia.minf.stbl.stsd.*.esds.decConfigDescr.maxBitrate",
  434.   (MP4Property**)&pBitrateProperty)) {
  435. pBitrateProperty->SetValue(GetMaxBitrate());
  436. }
  438. if (m_pTrakAtom->FindProperty(
  439.   "trak.mdia.minf.stbl.stsd.*.esds.decConfigDescr.avgBitrate",
  440.   (MP4Property**)&pBitrateProperty)) {
  441. pBitrateProperty->SetValue(GetAvgBitrate());
  442. }
  443. }
  445. bool MP4Track::IsChunkFull(MP4SampleId sampleId)
  446. {
  447. if (m_samplesPerChunk) {
  448. return m_chunkSamples >= m_samplesPerChunk;
  449. }
  451. ASSERT(m_durationPerChunk);
  452. return m_chunkDuration >= m_durationPerChunk;
  453. }
  455. u_int32_t MP4Track::GetNumberOfSamples()
  456. {
  457. return m_pStszSampleCountProperty->GetValue();
  458. }
  460. u_int32_t MP4Track::GetSampleSize(MP4SampleId sampleId)
  461. {
  462. u_int32_t fixedSampleSize = 
  463. m_pStszFixedSampleSizeProperty->GetValue(); 
  465. if (fixedSampleSize != 0) {
  466. return fixedSampleSize;
  467. }
  468. return m_pStszSampleSizeProperty->GetValue(sampleId - 1);
  469. }
  471. u_int32_t MP4Track::GetMaxSampleSize()
  472. {
  473. u_int32_t fixedSampleSize = 
  474. m_pStszFixedSampleSizeProperty->GetValue(); 
  476. if (fixedSampleSize != 0) {
  477. return fixedSampleSize;
  478. }
  480. u_int32_t maxSampleSize = 0;
  481. u_int32_t numSamples = m_pStszSampleSizeProperty->GetCount();
  482. for (MP4SampleId sid = 1; sid <= numSamples; sid++) {
  483. u_int32_t sampleSize =
  484. m_pStszSampleSizeProperty->GetValue(sid - 1);
  485. if (sampleSize > maxSampleSize) {
  486. maxSampleSize = sampleSize;
  487. }
  488. }
  489. return maxSampleSize;
  490. }
  492. u_int64_t MP4Track::GetTotalOfSampleSizes()
  493. {
  494. u_int32_t fixedSampleSize = 
  495. m_pStszFixedSampleSizeProperty->GetValue(); 
  497. // if fixed sample size, just need to multiply by number of samples
  498. if (fixedSampleSize != 0) {
  499. return fixedSampleSize * GetNumberOfSamples();
  500. }
  502. // else non-fixed sample size, sum them
  503. u_int64_t totalSampleSizes = 0;
  504. u_int32_t numSamples = m_pStszSampleSizeProperty->GetCount();
  505. for (MP4SampleId sid = 1; sid <= numSamples; sid++) {
  506. u_int32_t sampleSize =
  507. m_pStszSampleSizeProperty->GetValue(sid - 1);
  508. totalSampleSizes += sampleSize;
  509. }
  510. return totalSampleSizes;
  511. }
  513. void MP4Track::UpdateSampleSizes(MP4SampleId sampleId, u_int32_t numBytes)
  514. {
  515. // for first sample
  516. if (sampleId == 1) {
  517. // presume sample size is fixed
  518. m_pStszFixedSampleSizeProperty->SetValue(numBytes); 
  520. } else { // sampleId > 1
  521. u_int32_t fixedSampleSize = 
  522. m_pStszFixedSampleSizeProperty->GetValue(); 
  524. if (fixedSampleSize == 0 || numBytes != fixedSampleSize) {
  525. // sample size is not fixed
  527. if (fixedSampleSize) {
  528. // need to clear fixed sample size
  529. m_pStszFixedSampleSizeProperty->SetValue(0); 
  531. // and create sizes for all previous samples
  532. for (MP4SampleId sid = 1; sid < sampleId; sid++) {
  533. m_pStszSampleSizeProperty->AddValue(fixedSampleSize);
  534. }
  535. }
  537. // add size value for this sample
  538. m_pStszSampleSizeProperty->AddValue(numBytes);
  539. }
  540. }
  542. m_pStszSampleCountProperty->IncrementValue();
  543. }
  545. u_int32_t MP4Track::GetAvgBitrate()
  546. {
  547. if (GetDuration() == 0) {
  548. return 0;
  549. }
  551. u_int64_t durationSecs =
  552. MP4ConvertTime(GetDuration(), GetTimeScale(), MP4_SECS_TIME_SCALE);
  554. if (GetDuration() % GetTimeScale() != 0) {
  555. durationSecs++;
  556. }
  558. return (GetTotalOfSampleSizes() * 8) / durationSecs;
  559. }
  561. u_int32_t MP4Track::GetMaxBitrate()
  562. {
  563. u_int32_t timeScale = GetTimeScale();
  564. MP4SampleId numSamples = GetNumberOfSamples();
  565. u_int32_t maxBytesPerSec = 0;
  566. u_int32_t bytesThisSec = 0;
  567. MP4Timestamp thisSec = 0;
  569. for (MP4SampleId sid = 1; sid <= numSamples; sid++) {
  570. u_int32_t sampleSize;
  571. MP4Timestamp sampleTime;
  573. sampleSize = GetSampleSize(sid);
  575. GetSampleTimes(sid, &sampleTime, NULL);
  577. // sample counts for current second
  578. if (sampleTime < thisSec + timeScale) {
  579. bytesThisSec += sampleSize;
  580. } else { // sample is in a future second
  581. if (bytesThisSec > maxBytesPerSec) {
  582. maxBytesPerSec = bytesThisSec;
  583. }
  585. thisSec = sampleTime - (sampleTime % timeScale);
  586. bytesThisSec = sampleSize;
  587. }
  588. }
  590. // last second (or partial second) 
  591. if (bytesThisSec > maxBytesPerSec) {
  592. maxBytesPerSec = bytesThisSec;
  593. }
  595. return maxBytesPerSec * 8;
  596. }
  598. u_int32_t MP4Track::GetSampleStscIndex(MP4SampleId sampleId)
  599. {
  600. u_int32_t stscIndex;
  601. u_int32_t numStscs = m_pStscCountProperty->GetValue();
  603. if (numStscs == 0) {
  604. throw new MP4Error("No data chunks exist", "GetSampleStscIndex");
  605. }
  607. for (stscIndex = 0; stscIndex < numStscs; stscIndex++) {
  608. if (sampleId < m_pStscFirstSampleProperty->GetValue(stscIndex)) {
  609. ASSERT(stscIndex != 0);
  610. stscIndex -= 1;
  611. break;
  612. }
  613. }
  614. if (stscIndex == numStscs) {
  615. ASSERT(stscIndex != 0);
  616. stscIndex -= 1;
  617. }
  619. return stscIndex;
  620. }
  622. FILE* MP4Track::GetSampleFile(MP4SampleId sampleId)
  623. {
  624. u_int32_t stscIndex =
  625. GetSampleStscIndex(sampleId);
  627. u_int32_t stsdIndex = 
  628. m_pStscSampleDescrIndexProperty->GetValue(stscIndex);
  630. // check if the answer will be the same as last time
  631. if (m_lastStsdIndex && stsdIndex == m_lastStsdIndex) {
  632. return m_lastSampleFile;
  633. }
  635. MP4Atom* pStsdAtom = 
  636. m_pTrakAtom->FindAtom("trak.mdia.minf.stbl.stsd");
  637. ASSERT(pStsdAtom);
  639. MP4Atom* pStsdEntryAtom = 
  640. pStsdAtom->GetChildAtom(stsdIndex - 1);
  641. ASSERT(pStsdEntryAtom);
  643. MP4Integer16Property* pDrefIndexProperty = NULL;
  644. pStsdEntryAtom->FindProperty(
  645. "*.dataReferenceIndex",
  646. (MP4Property**)&pDrefIndexProperty);
  648. if (pDrefIndexProperty == NULL) {
  649. throw new MP4Error("invalid stsd entry", "GetSampleFile");
  650. }
  652. u_int32_t drefIndex =
  653. pDrefIndexProperty->GetValue();
  655. MP4Atom* pDrefAtom =
  656. m_pTrakAtom->FindAtom("trak.mdia.minf.dinf.dref");
  657. ASSERT(pDrefAtom);
  659. MP4Atom* pUrlAtom =
  660. pDrefAtom->GetChildAtom(drefIndex - 1);
  661. ASSERT(pUrlAtom);
  663. FILE* pFile;
  665. if (pUrlAtom->GetFlags() & 1) {
  666. pFile = NULL; // self-contained
  667. } else {
  668. MP4StringProperty* pLocationProperty = NULL;
  669. pUrlAtom->FindProperty(
  670. "*.location", 
  671. (MP4Property**)&pLocationProperty);
  672. ASSERT(pLocationProperty);
  674. const char* url = pLocationProperty->GetValue();
  676. VERBOSE_READ_SAMPLE(m_pFile->GetVerbosity(),
  677. printf("dref url = %sn", url));
  679. pFile = (FILE*)-1;
  681. // attempt to open url if it's a file url 
  682. // currently this is the only thing we understand
  683. if (!strncmp(url, "file:", 5)) {
  684. const char* fileName = url + 5;
  685. if (!strncmp(fileName, "//", 2)) {
  686. fileName = strchr(fileName + 2, '/');
  687. }
  688. if (fileName) {
  689. pFile = fopen(fileName, "rb");
  690. if (!pFile) {
  691. pFile = (FILE*)-1;
  692. }
  693. }
  694. } 
  695. }
  697. if (m_lastSampleFile) {
  698. fclose(m_lastSampleFile);
  699. }
  701. // cache the answer
  702. m_lastStsdIndex = stsdIndex;
  703. m_lastSampleFile = pFile;
  705. return pFile;
  706. }
  708. u_int64_t MP4Track::GetSampleFileOffset(MP4SampleId sampleId)
  709. {
  710. u_int32_t stscIndex =
  711. GetSampleStscIndex(sampleId);
  713. u_int32_t firstChunk = 
  714. m_pStscFirstChunkProperty->GetValue(stscIndex);
  716. MP4SampleId firstSample = 
  717. m_pStscFirstSampleProperty->GetValue(stscIndex);
  719. u_int32_t samplesPerChunk = 
  720. m_pStscSamplesPerChunkProperty->GetValue(stscIndex);
  722. MP4ChunkId chunkId = firstChunk +
  723. ((sampleId - firstSample) / samplesPerChunk);
  725. u_int64_t chunkOffset = m_pChunkOffsetProperty->GetValue(chunkId - 1);
  727. MP4SampleId firstSampleInChunk = 
  728. sampleId - ((sampleId - firstSample) % samplesPerChunk);
  730. // need cumulative samples sizes from firstSample to sampleId - 1
  731. u_int32_t sampleOffset = 0;
  732. for (MP4SampleId i = firstSampleInChunk; i < sampleId; i++) {
  733. sampleOffset += GetSampleSize(i);
  734. }
  736. return chunkOffset + sampleOffset;
  737. }
  739. void MP4Track::UpdateSampleToChunk(MP4SampleId sampleId,
  740.  MP4ChunkId chunkId, u_int32_t samplesPerChunk)
  741. {
  742. u_int32_t numStsc = m_pStscCountProperty->GetValue();
  744. // if samplesPerChunk == samplesPerChunk of last entry
  745. if (numStsc && samplesPerChunk == 
  746.   m_pStscSamplesPerChunkProperty->GetValue(numStsc-1)) {
  748. // nothing to do
  750. } else {
  751. // add stsc entry
  752. m_pStscFirstChunkProperty->AddValue(chunkId);
  753. m_pStscSamplesPerChunkProperty->AddValue(samplesPerChunk);
  754. m_pStscSampleDescrIndexProperty->AddValue(1);
  755. m_pStscFirstSampleProperty->AddValue(sampleId - samplesPerChunk + 1);
  757. m_pStscCountProperty->IncrementValue();
  758. }
  759. }
  761. void MP4Track::UpdateChunkOffsets(u_int64_t chunkOffset)
  762. {
  763. if (m_pChunkOffsetProperty->GetType() == Integer32Property) {
  764. ((MP4Integer32Property*)m_pChunkOffsetProperty)->AddValue(chunkOffset);
  765. } else {
  766. ((MP4Integer64Property*)m_pChunkOffsetProperty)->AddValue(chunkOffset);
  767. }
  768. m_pChunkCountProperty->IncrementValue();
  769. }
  771. MP4Duration MP4Track::GetFixedSampleDuration()
  772. {
  773. u_int32_t numStts = m_pSttsCountProperty->GetValue();
  775. if (numStts == 0) {
  776. return m_fixedSampleDuration;
  777. }
  778. if (numStts != 1) {
  779. return MP4_INVALID_DURATION; // sample duration is not fixed
  780. }
  781. return m_pSttsSampleDeltaProperty->GetValue(0);
  782. }
  784. bool MP4Track::SetFixedSampleDuration(MP4Duration duration)
  785. {
  786. u_int32_t numStts = m_pSttsCountProperty->GetValue();
  788. // setting this is only allowed before samples have been written
  789. if (numStts != 0) {
  790. return false;
  791. }
  792. m_fixedSampleDuration = duration;
  793. return true;
  794. }
  796. void MP4Track::GetSampleTimes(MP4SampleId sampleId,
  797. MP4Timestamp* pStartTime, MP4Duration* pDuration)
  798. {
  799. u_int32_t numStts = m_pSttsCountProperty->GetValue();
  800. MP4SampleId sid = 1;
  801. MP4Duration elapsed = 0;
  803. for (u_int32_t sttsIndex = 0; sttsIndex < numStts; sttsIndex++) {
  804. u_int32_t sampleCount = 
  805. m_pSttsSampleCountProperty->GetValue(sttsIndex);
  806. u_int32_t sampleDelta = 
  807. m_pSttsSampleDeltaProperty->GetValue(sttsIndex);
  809. if (sampleId <= sid + sampleCount - 1) {
  810. if (pStartTime) {
  811. *pStartTime = elapsed + ((sampleId - sid) * sampleDelta);
  812. }
  813. if (pDuration) {
  814. *pDuration = sampleDelta;
  815. }
  816. return;
  817. }
  818. sid += sampleCount;
  819. elapsed += sampleCount * sampleDelta;
  820. }
  822. throw new MP4Error("sample id out of range", 
  823. "MP4Track::GetSampleTimes");
  824. }
  826. MP4SampleId MP4Track::GetSampleIdFromTime(
  827. MP4Timestamp when, 
  828. bool wantSyncSample) 
  829. {
  830. u_int32_t numStts = m_pSttsCountProperty->GetValue();
  831. MP4SampleId sid = 1;
  832. MP4Duration elapsed = 0;
  834. for (u_int32_t sttsIndex = 0; sttsIndex < numStts; sttsIndex++) {
  835. u_int32_t sampleCount = 
  836. m_pSttsSampleCountProperty->GetValue(sttsIndex);
  837. u_int32_t sampleDelta = 
  838. m_pSttsSampleDeltaProperty->GetValue(sttsIndex);
  840. if (sampleDelta == 0 && sttsIndex < numStts - 1) {
  841. VERBOSE_READ(m_pFile->GetVerbosity(),
  842. printf("Warning: Zero sample duration, stts entry %un",
  843. sttsIndex));
  844. }
  846. MP4Duration d = when - elapsed;
  848. if (d <= sampleCount * sampleDelta) {
  849. MP4SampleId sampleId = sid;
  850. if (sampleDelta) {
  851. sampleId += (d / sampleDelta);
  852. }
  854. if (wantSyncSample) {
  855. return GetNextSyncSample(sampleId);
  856. }
  857. return sampleId;
  858. }
  860. sid += sampleCount;
  861. elapsed += sampleCount * sampleDelta;
  862. }
  864. throw new MP4Error("time out of range", 
  865. "MP4Track::GetSampleIdFromTime");
  867. return 0; // satisfy MS compiler
  868. }
  870. void MP4Track::UpdateSampleTimes(MP4Duration duration)
  871. {
  872. u_int32_t numStts = m_pSttsCountProperty->GetValue();
  874. // if duration == duration of last entry
  875. if (numStts 
  876.   && duration == m_pSttsSampleDeltaProperty->GetValue(numStts-1)) {
  877. // increment last entry sampleCount
  878. m_pSttsSampleCountProperty->IncrementValue(1, numStts-1);
  880. } else {
  881. // add stts entry, sampleCount = 1, sampleDuration = duration
  882. m_pSttsSampleCountProperty->AddValue(1);
  883. m_pSttsSampleDeltaProperty->AddValue(duration);
  884. m_pSttsCountProperty->IncrementValue();;
  885. }
  886. }
  888. u_int32_t MP4Track::GetSampleCttsIndex(MP4SampleId sampleId, 
  889. MP4SampleId* pFirstSampleId)
  890. {
  891. u_int32_t numCtts = m_pCttsCountProperty->GetValue();
  893. MP4SampleId sid = 1;
  895. for (u_int32_t cttsIndex = 0; cttsIndex < numCtts; cttsIndex++) {
  896. u_int32_t sampleCount = 
  897. m_pCttsSampleCountProperty->GetValue(cttsIndex);
  899. if (sampleId <= sid + sampleCount - 1) {
  900. if (pFirstSampleId) {
  901. *pFirstSampleId = sid;
  902. }
  903. return cttsIndex;
  904. }
  905. sid += sampleCount;
  906. }
  908. throw new MP4Error("sample id out of range", 
  909. "MP4Track::GetSampleCttsIndex");
  910. return 0; // satisfy MS compiler
  911. }
  913. MP4Duration MP4Track::GetSampleRenderingOffset(MP4SampleId sampleId)
  914. {
  915. if (m_pCttsCountProperty == NULL) {
  916. return 0;
  917. }
  918. if (m_pCttsCountProperty->GetValue() == 0) {
  919. return 0;
  920. }
  922. u_int32_t cttsIndex = GetSampleCttsIndex(sampleId);
  924. return m_pCttsSampleOffsetProperty->GetValue(cttsIndex);
  925. }
  927. void MP4Track::UpdateRenderingOffsets(MP4SampleId sampleId, 
  928. MP4Duration renderingOffset)
  929. {
  930. // if ctts atom doesn't exist
  931. if (m_pCttsCountProperty == NULL) {
  933. // no rendering offset, so nothing to do
  934. if (renderingOffset == 0) {
  935. return;
  936. }
  938. // else create a ctts atom
  939. MP4Atom* pCttsAtom = AddAtom("trak.mdia.minf.stbl", "ctts");
  941. // and get handles on the properties
  942. pCttsAtom->FindProperty(
  943. "ctts.entryCount",
  944. (MP4Property**)&m_pCttsCountProperty);
  946. pCttsAtom->FindProperty(
  947. "ctts.entries.sampleCount",
  948. (MP4Property**)&m_pCttsSampleCountProperty);
  950. pCttsAtom->FindProperty(
  951. "ctts.entries.sampleOffset",
  952. (MP4Property**)&m_pCttsSampleOffsetProperty);
  954. // if this is not the first sample
  955. if (sampleId > 1) {
  956. // add a ctts entry for all previous samples
  957. // with rendering offset equal to zero
  958. m_pCttsSampleCountProperty->AddValue(sampleId - 1);
  959. m_pCttsSampleOffsetProperty->AddValue(0);
  960. m_pCttsCountProperty->IncrementValue();;
  961. }
  962. }
  964. // ctts atom exists (now)
  966. u_int32_t numCtts = m_pCttsCountProperty->GetValue();
  968. // if renderingOffset == renderingOffset of last entry
  969. if (numCtts && renderingOffset
  970.    == m_pCttsSampleOffsetProperty->GetValue(numCtts-1)) {
  972. // increment last entry sampleCount
  973. m_pCttsSampleCountProperty->IncrementValue(1, numCtts-1);
  975. } else {
  976. // add ctts entry, sampleCount = 1, sampleOffset = renderingOffset
  977. m_pCttsSampleCountProperty->AddValue(1);
  978. m_pCttsSampleOffsetProperty->AddValue(renderingOffset);
  979. m_pCttsCountProperty->IncrementValue();
  980. }
  981. }
  983. void MP4Track::SetSampleRenderingOffset(MP4SampleId sampleId,
  984.  MP4Duration renderingOffset)
  985. {
  986. // check if any ctts entries exist
  987. if (m_pCttsCountProperty == NULL
  988.   || m_pCttsCountProperty->GetValue() == 0) {
  989. // if not then Update routine can be used 
  990. // to create a ctts entry for samples before this one
  991. // and a ctts entry for this sample 
  992. UpdateRenderingOffsets(sampleId, renderingOffset);
  994. // but we also need a ctts entry 
  995. // for all samples after this one
  996. u_int32_t afterSamples = GetNumberOfSamples() - sampleId;
  998. if (afterSamples) {
  999. m_pCttsSampleCountProperty->AddValue(afterSamples);
  1000. m_pCttsSampleOffsetProperty->AddValue(0);
  1001. m_pCttsCountProperty->IncrementValue();;
  1002. }
  1004. return;
  1005. }
  1007. MP4SampleId firstSampleId;
  1008. u_int32_t cttsIndex = GetSampleCttsIndex(sampleId, &firstSampleId);
  1010. // do nothing in the degenerate case
  1011. if (renderingOffset == 
  1012.   m_pCttsSampleOffsetProperty->GetValue(cttsIndex)) {
  1013. return;
  1014. }
  1016. u_int32_t sampleCount =
  1017. m_pCttsSampleCountProperty->GetValue(cttsIndex);
  1019. // if this sample has it's own ctts entry
  1020. if (sampleCount == 1) {
  1021. // then just set the value, 
  1022. // note we don't attempt to collapse entries
  1023. m_pCttsSampleOffsetProperty->SetValue(renderingOffset, cttsIndex);
  1024. return;
  1025. }
  1027. MP4SampleId lastSampleId = firstSampleId + sampleCount - 1;
  1029. // else we share this entry with other samples
  1030. // we need to insert our own entry
  1031. if (sampleId == firstSampleId) {
  1032. // our sample is the first one
  1033. m_pCttsSampleCountProperty->
  1034. InsertValue(1, cttsIndex);
  1035. m_pCttsSampleOffsetProperty->
  1036. InsertValue(renderingOffset, cttsIndex);
  1038. m_pCttsSampleCountProperty->
  1039. SetValue(sampleCount - 1, cttsIndex + 1);
  1041. m_pCttsCountProperty->IncrementValue();
  1043. } else if (sampleId == lastSampleId) {
  1044. // our sample is the last one
  1045. m_pCttsSampleCountProperty->
  1046. InsertValue(1, cttsIndex + 1);
  1047. m_pCttsSampleOffsetProperty->
  1048. InsertValue(renderingOffset, cttsIndex + 1);
  1050. m_pCttsSampleCountProperty->
  1051. SetValue(sampleCount - 1, cttsIndex);
  1053. m_pCttsCountProperty->IncrementValue();
  1055. } else {
  1056. // our sample is in the middle, UGH!
  1058. // insert our new entry
  1059. m_pCttsSampleCountProperty->
  1060. InsertValue(1, cttsIndex + 1);
  1061. m_pCttsSampleOffsetProperty->
  1062. InsertValue(renderingOffset, cttsIndex + 1);
  1064. // adjust count of previous entry
  1065. m_pCttsSampleCountProperty->
  1066. SetValue(sampleId - firstSampleId, cttsIndex);
  1068. // insert new entry for those samples beyond our sample
  1069. m_pCttsSampleCountProperty->
  1070. InsertValue(lastSampleId - sampleId, cttsIndex + 2);
  1071. u_int32_t oldRenderingOffset =
  1072. m_pCttsSampleOffsetProperty->GetValue(cttsIndex);
  1073. m_pCttsSampleOffsetProperty->
  1074. InsertValue(oldRenderingOffset, cttsIndex + 2);
  1076. m_pCttsCountProperty->IncrementValue(2);
  1077. }
  1078. }
  1080. bool MP4Track::IsSyncSample(MP4SampleId sampleId)
  1081. {
  1082. if (m_pStssCountProperty == NULL) {
  1083. return true;
  1084. }
  1086. u_int32_t numStss = m_pStssCountProperty->GetValue();
  1088. for (u_int32_t stssIndex = 0; stssIndex < numStss; stssIndex++) {
  1089. MP4SampleId syncSampleId = 
  1090. m_pStssSampleProperty->GetValue(stssIndex);
  1092. if (sampleId == syncSampleId) {
  1093. return true;
  1094. } 
  1095. if (sampleId < syncSampleId) {
  1096. break;
  1097. }
  1098. }
  1100. return false;
  1101. }
  1103. // N.B. "next" is inclusive of this sample id
  1104. MP4SampleId MP4Track::GetNextSyncSample(MP4SampleId sampleId)
  1105. {
  1106. if (m_pStssCountProperty == NULL) {
  1107. return sampleId;
  1108. }
  1110. u_int32_t numStss = m_pStssCountProperty->GetValue();
  1112. for (u_int32_t stssIndex = 0; stssIndex < numStss; stssIndex++) {
  1113. MP4SampleId syncSampleId = 
  1114. m_pStssSampleProperty->GetValue(stssIndex);
  1116. if (sampleId > syncSampleId) {
  1117. continue;
  1118. }
  1119. return syncSampleId;
  1120. }
  1122. // LATER check stsh for alternate sample
  1124. return MP4_INVALID_SAMPLE_ID;
  1125. }
  1127. void MP4Track::UpdateSyncSamples(MP4SampleId sampleId, bool isSyncSample)
  1128. {
  1129. if (isSyncSample) {
  1130. // if stss atom exists, add entry
  1131. if (m_pStssCountProperty) {
  1132. m_pStssSampleProperty->AddValue(sampleId);
  1133. m_pStssCountProperty->IncrementValue();
  1134. } // else nothing to do (yet)
  1136. } else { // !isSyncSample
  1137. // if stss atom doesn't exist, create one
  1138. if (m_pStssCountProperty == NULL) {
  1140. MP4Atom* pStssAtom = AddAtom("trak.mdia.minf.stbl", "stss");
  1142. pStssAtom->FindProperty(
  1143. "stss.entryCount",
  1144. (MP4Property**)&m_pStssCountProperty);
  1146. pStssAtom->FindProperty(
  1147. "stss.entries.sampleNumber",
  1148. (MP4Property**)&m_pStssSampleProperty);
  1150. // set values for all samples that came before this one
  1151. for (MP4SampleId sid = 1; sid < sampleId; sid++) {
  1152. m_pStssSampleProperty->AddValue(sid);
  1153. m_pStssCountProperty->IncrementValue();
  1154. }
  1155. } // else nothing to do
  1156. }
  1157. }
  1159. MP4Atom* MP4Track::AddAtom(char* parentName, char* childName)
  1160. {
  1161. MP4Atom* pChildAtom = MP4Atom::CreateAtom(childName);
  1163. MP4Atom* pParentAtom = m_pTrakAtom->FindAtom(parentName);
  1164. ASSERT(pParentAtom);
  1166. pParentAtom->AddChildAtom(pChildAtom);
  1168. pChildAtom->Generate();
  1170. return pChildAtom;
  1171. }
  1173. u_int64_t MP4Track::GetDuration()
  1174. {
  1175. return m_pMediaDurationProperty->GetValue();
  1176. }
  1178. u_int32_t MP4Track::GetTimeScale()
  1179. {
  1180. return m_pTimeScaleProperty->GetValue();
  1181. }
  1183. void MP4Track::UpdateDurations(MP4Duration duration)
  1184. {
  1185. // update media, track, and movie durations
  1186. m_pMediaDurationProperty->SetValue(
  1187. m_pMediaDurationProperty->GetValue() + duration);
  1189. MP4Duration movieDuration = ToMovieDuration(duration);
  1190. m_pTrackDurationProperty->SetValue(
  1191. m_pTrackDurationProperty->GetValue() + movieDuration);
  1193. m_pFile->UpdateDuration(m_pTrackDurationProperty->GetValue());
  1194. }
  1196. MP4Duration MP4Track::ToMovieDuration(MP4Duration trackDuration)
  1197. {
  1198. return (trackDuration * m_pFile->GetTimeScale()) 
  1199. / m_pTimeScaleProperty->GetValue();
  1200. }
  1202. void MP4Track::UpdateModificationTimes()
  1203. {
  1204. // update media and track modification times
  1205. MP4Timestamp now = MP4GetAbsTimestamp();
  1206. m_pMediaModificationProperty->SetValue(now);
  1207. m_pTrackModificationProperty->SetValue(now);
  1208. }
  1210. u_int32_t MP4Track::GetNumberOfChunks()
  1211. {
  1212. return m_pChunkOffsetProperty->GetCount();
  1213. }
  1215. u_int32_t MP4Track::GetChunkStscIndex(MP4ChunkId chunkId)
  1216. {
  1217. u_int32_t stscIndex;
  1218. u_int32_t numStscs = m_pStscCountProperty->GetValue();
  1220. ASSERT(chunkId);
  1221. ASSERT(numStscs > 0);
  1223. for (stscIndex = 0; stscIndex < numStscs; stscIndex++) {
  1224. if (chunkId < m_pStscFirstChunkProperty->GetValue(stscIndex)) {
  1225. ASSERT(stscIndex != 0);
  1226. break;
  1227. }
  1228. }
  1229. return stscIndex - 1;
  1230. }
  1232. MP4Timestamp MP4Track::GetChunkTime(MP4ChunkId chunkId)
  1233. {
  1234. u_int32_t stscIndex = GetChunkStscIndex(chunkId);
  1236. MP4ChunkId firstChunkId = 
  1237. m_pStscFirstChunkProperty->GetValue(stscIndex);
  1239. MP4SampleId firstSample = 
  1240. m_pStscFirstSampleProperty->GetValue(stscIndex);
  1242. u_int32_t samplesPerChunk = 
  1243. m_pStscSamplesPerChunkProperty->GetValue(stscIndex);
  1245. MP4SampleId firstSampleInChunk = 
  1246. firstSample + ((chunkId - firstChunkId) * samplesPerChunk);
  1248. MP4Timestamp chunkTime;
  1250. GetSampleTimes(firstSampleInChunk, &chunkTime, NULL);
  1252. return chunkTime;
  1253. }
  1255. u_int32_t MP4Track::GetChunkSize(MP4ChunkId chunkId)
  1256. {
  1257. u_int32_t stscIndex = GetChunkStscIndex(chunkId);
  1259. MP4ChunkId firstChunkId = 
  1260. m_pStscFirstChunkProperty->GetValue(stscIndex);
  1262. MP4SampleId firstSample = 
  1263. m_pStscFirstSampleProperty->GetValue(stscIndex);
  1265. u_int32_t samplesPerChunk = 
  1266. m_pStscSamplesPerChunkProperty->GetValue(stscIndex);
  1268. MP4SampleId firstSampleInChunk = 
  1269. firstSample + ((chunkId - firstChunkId) * samplesPerChunk);
  1271. // need cumulative sizes of samples in chunk 
  1272. u_int32_t chunkSize = 0;
  1273. for (u_int32_t i = 0; i < samplesPerChunk; i++) {
  1274. chunkSize += GetSampleSize(firstSampleInChunk + i);
  1275. }
  1277. return chunkSize;
  1278. }
  1280. void MP4Track::ReadChunk(MP4ChunkId chunkId, 
  1281. u_int8_t** ppChunk, u_int32_t* pChunkSize)
  1282. {
  1283. ASSERT(chunkId);
  1284. ASSERT(ppChunk);
  1285. ASSERT(pChunkSize);
  1287. u_int64_t chunkOffset = 
  1288. m_pChunkOffsetProperty->GetValue(chunkId - 1);
  1290. *pChunkSize = GetChunkSize(chunkId);
  1291. *ppChunk = (u_int8_t*)MP4Malloc(*pChunkSize);
  1293. VERBOSE_READ_SAMPLE(m_pFile->GetVerbosity(),
  1294. printf("ReadChunk: track %u id %u offset 0x"LLX" size %u (0x%x)n",
  1295. m_trackId, chunkId, chunkOffset, *pChunkSize, *pChunkSize));
  1297. u_int64_t oldPos = m_pFile->GetPosition(); // only used in mode == 'w'
  1298. try {
  1299. m_pFile->SetPosition(chunkOffset);
  1300. m_pFile->ReadBytes(*ppChunk, *pChunkSize);
  1301. }
  1302. catch (MP4Error* e) {
  1303. // let's not leak memory
  1304. MP4Free(*ppChunk);
  1305. *ppChunk = NULL;
  1307. if (m_pFile->GetMode() == 'w') {
  1308. m_pFile->SetPosition(oldPos);
  1309. }
  1310. throw e;
  1311. }
  1313. if (m_pFile->GetMode() == 'w') {
  1314. m_pFile->SetPosition(oldPos);
  1315. }
  1316. }
  1318. void MP4Track::RewriteChunk(MP4ChunkId chunkId, 
  1319. u_int8_t* pChunk, u_int32_t chunkSize)
  1320. {
  1321. u_int64_t chunkOffset = m_pFile->GetPosition();
  1323. m_pFile->WriteBytes(pChunk, chunkSize);
  1325. m_pChunkOffsetProperty->SetValue(chunkOffset, chunkId - 1);
  1327. VERBOSE_WRITE_SAMPLE(m_pFile->GetVerbosity(),
  1328. printf("RewriteChunk: track %u id %u offset 0x"LLX" size %u (0x%x)n",
  1329. m_trackId, chunkId, chunkOffset, chunkSize, chunkSize)); 
  1330. }
  1332. // map track type name aliases to official names
  1334. const char* MP4Track::NormalizeTrackType(const char* type)
  1335. {
  1336. if (!strcasecmp(type, "vide")
  1337.   || !strcasecmp(type, "video")
  1338.   || !strcasecmp(type, "mp4v")) {
  1339. return MP4_VIDEO_TRACK_TYPE;
  1340. }
  1342. if (!strcasecmp(type, "soun")
  1343.   || !strcasecmp(type, "sound")
  1344.   || !strcasecmp(type, "audio")
  1345.   || !strcasecmp(type, "mp4a")) {
  1346. return MP4_AUDIO_TRACK_TYPE;
  1347. }
  1349. if (!strcasecmp(type, "sdsm")
  1350.   || !strcasecmp(type, "scene")
  1351.   || !strcasecmp(type, "bifs")) {
  1352. return MP4_SCENE_TRACK_TYPE;
  1353. }
  1355. if (!strcasecmp(type, "odsm")
  1356.   || !strcasecmp(type, "od")) {
  1357. return MP4_OD_TRACK_TYPE;
  1358. }
  1360. return type;
  1361. }
  1363. bool MP4Track::InitEditListProperties()
  1364. {
  1365. m_pElstCountProperty = NULL;
  1366. m_pElstMediaTimeProperty = NULL;
  1367. m_pElstDurationProperty = NULL;
  1368. m_pElstRateProperty = NULL;
  1369. m_pElstReservedProperty = NULL;
  1371. MP4Atom* pElstAtom =
  1372. m_pTrakAtom->FindAtom("trak.edts.elst");
  1374. if (!pElstAtom) {
  1375. return false;
  1376. }
  1378. pElstAtom->FindProperty(
  1379. "elst.entryCount",
  1380. (MP4Property**)&m_pElstCountProperty);
  1382. pElstAtom->FindProperty(
  1383. "elst.entries.mediaTime",
  1384. (MP4Property**)&m_pElstMediaTimeProperty);
  1386. pElstAtom->FindProperty(
  1387. "elst.entries.segmentDuration",
  1388. (MP4Property**)&m_pElstDurationProperty);
  1390. pElstAtom->FindProperty(
  1391. "elst.entries.mediaRate",
  1392. (MP4Property**)&m_pElstRateProperty);
  1394. pElstAtom->FindProperty(
  1395. "elst.entries.reserved",
  1396. (MP4Property**)&m_pElstReservedProperty);
  1398. return m_pElstCountProperty
  1399. && m_pElstMediaTimeProperty
  1400. && m_pElstDurationProperty
  1401. && m_pElstRateProperty
  1402. && m_pElstReservedProperty;
  1403. }
  1405. MP4EditId MP4Track::AddEdit(MP4EditId editId)
  1406. {
  1407. if (!m_pElstCountProperty) {
  1408. m_pFile->AddDescendantAtoms(m_pTrakAtom, "edts.elst");
  1409. InitEditListProperties();
  1410. }
  1412. if (editId == MP4_INVALID_EDIT_ID) {
  1413. editId = m_pElstCountProperty->GetValue() + 1;
  1414. }
  1416. m_pElstMediaTimeProperty->InsertValue(0, editId - 1);
  1417. m_pElstDurationProperty->InsertValue(0, editId - 1);
  1418. m_pElstRateProperty->InsertValue(1, editId - 1);
  1419. m_pElstReservedProperty->InsertValue(0, editId - 1);
  1421. m_pElstCountProperty->IncrementValue();
  1423. return editId;
  1424. }
  1426. void MP4Track::DeleteEdit(MP4EditId editId)
  1427. {
  1428. if (editId == MP4_INVALID_EDIT_ID) {
  1429. throw new MP4Error("edit id can't be zero", 
  1430. "MP4Track::DeleteEdit");
  1431. }
  1433. if (!m_pElstCountProperty
  1434.   || m_pElstCountProperty->GetValue() == 0) {
  1435. throw new MP4Error("no edits exist", 
  1436. "MP4Track::DeleteEdit");
  1437. }
  1439. m_pElstMediaTimeProperty->DeleteValue(editId - 1);
  1440. m_pElstDurationProperty->DeleteValue(editId - 1);
  1441. m_pElstRateProperty->DeleteValue(editId - 1);
  1442. m_pElstReservedProperty->DeleteValue(editId - 1);
  1444. m_pElstCountProperty->IncrementValue(-1);
  1446. // clean up if last edit is deleted
  1447. if (m_pElstCountProperty->GetValue() == 0) {
  1448. m_pElstCountProperty = NULL;
  1449. m_pElstMediaTimeProperty = NULL;
  1450. m_pElstDurationProperty = NULL;
  1451. m_pElstRateProperty = NULL;
  1452. m_pElstReservedProperty = NULL;
  1454. m_pTrakAtom->DeleteChildAtom(
  1455. m_pTrakAtom->FindAtom("trak.edts"));
  1456. }
  1457. }
  1459. MP4Timestamp MP4Track::GetEditStart(
  1460. MP4EditId editId) 
  1461. {
  1462. if (editId == MP4_INVALID_EDIT_ID) {
  1463. return MP4_INVALID_TIMESTAMP;
  1464. } else if (editId == 1) {
  1465. return 0;
  1466. }
  1467. return (MP4Timestamp)GetEditTotalDuration(editId - 1);
  1468. }
  1470. MP4Duration MP4Track::GetEditTotalDuration(
  1471. MP4EditId editId)
  1472. {
  1473. u_int32_t numEdits = 0;
  1475. if (m_pElstCountProperty) {
  1476. numEdits = m_pElstCountProperty->GetValue();
  1477. }
  1479. if (editId == MP4_INVALID_EDIT_ID) {
  1480. editId = numEdits;
  1481. }
  1483. if (numEdits == 0 || editId > numEdits) {
  1484. return MP4_INVALID_DURATION;
  1485. }
  1487. MP4Duration totalDuration = 0;
  1489. for (MP4EditId eid = 1; eid <= editId; eid++) {
  1490. totalDuration += 
  1491. m_pElstDurationProperty->GetValue(eid - 1);
  1492. }
  1494. return totalDuration;
  1495. }
  1497. MP4SampleId MP4Track::GetSampleIdFromEditTime(
  1498. MP4Timestamp editWhen, 
  1499. MP4Timestamp* pStartTime, 
  1500. MP4Duration* pDuration)
  1501. {
  1502. MP4SampleId sampleId = MP4_INVALID_SAMPLE_ID;
  1503. u_int32_t numEdits = 0;
  1505. if (m_pElstCountProperty) {
  1506. numEdits = m_pElstCountProperty->GetValue();
  1507. }
  1509. if (numEdits) {
  1510. MP4Duration editElapsedDuration = 0;
  1512. for (MP4EditId editId = 1; editId <= numEdits; editId++) {
  1513. // remember edit segment's start time (in edit timeline)
  1514. MP4Timestamp editStartTime = 
  1515. (MP4Timestamp)editElapsedDuration;
  1517. // accumulate edit segment's duration
  1518. editElapsedDuration += 
  1519. m_pElstDurationProperty->GetValue(editId - 1);
  1521. // calculate difference between the specified edit time
  1522. // and the end of this edit segment
  1523. if (editElapsedDuration - editWhen <= 0) {
  1524. // the specified time has not yet been reached
  1525. continue;
  1526. }
  1528. // 'editWhen' is within this edit segment
  1530. // calculate the specified edit time
  1531. // relative to just this edit segment
  1532. MP4Duration editOffset =
  1533. editWhen - editStartTime;
  1535. // calculate the media (track) time that corresponds
  1536. // to the specified edit time based on the edit list
  1537. MP4Timestamp mediaWhen = 
  1538. m_pElstMediaTimeProperty->GetValue(editId - 1)
  1539. + editOffset;
  1541. // lookup the sample id for the media time
  1542. sampleId = GetSampleIdFromTime(mediaWhen, false);
  1544. // lookup the sample's media start time and duration
  1545. MP4Timestamp sampleStartTime;
  1546. MP4Duration sampleDuration;
  1548. GetSampleTimes(sampleId, &sampleStartTime, &sampleDuration);
  1550. // calculate the difference if any between when the sample
  1551. // would naturally start and when it starts in the edit timeline 
  1552. MP4Duration sampleStartOffset =
  1553. mediaWhen - sampleStartTime;
  1555. // calculate the start time for the sample in the edit time line
  1556. MP4Timestamp editSampleStartTime =
  1557. editWhen - MIN(editOffset, sampleStartOffset);
  1559. MP4Duration editSampleDuration = 0;
  1561. // calculate how long this sample lasts in the edit list timeline
  1562. if (m_pElstRateProperty->GetValue(editId - 1) == 0) {
  1563. // edit segment is a "dwell"
  1564. // so sample duration is that of the edit segment
  1565. editSampleDuration =
  1566. m_pElstDurationProperty->GetValue(editId - 1);
  1568. } else {
  1569. // begin with the natural sample duration
  1570. editSampleDuration = sampleDuration;
  1572. // now shorten that if the edit segment starts
  1573. // after the sample would naturally start 
  1574. if (editOffset < sampleStartOffset) {
  1575. editSampleDuration -= sampleStartOffset - editOffset;
  1576. }
  1578. // now shorten that if the edit segment ends
  1579. // before the sample would naturally end
  1580. if (editElapsedDuration 
  1581.   < editSampleStartTime + sampleDuration) {
  1582. editSampleDuration -= (editSampleStartTime + sampleDuration) 
  1583. - editElapsedDuration;
  1584. }
  1585. }
  1587. if (pStartTime) {
  1588. *pStartTime = editSampleStartTime;
  1589. }
  1591. if (pDuration) {
  1592. *pDuration = editSampleDuration;
  1593. }
  1595. VERBOSE_EDIT(m_pFile->GetVerbosity(),
  1596. printf("GetSampleIdFromEditTime: when %llu "
  1597. "sampleId %u start %llu duration %lldn", 
  1598. editWhen, sampleId, 
  1599. editSampleStartTime, editSampleDuration));
  1601. return sampleId;
  1602. }
  1604. throw new MP4Error("time out of range", 
  1605. "MP4Track::GetSampleIdFromEditTime");
  1607. } else { // no edit list
  1608. sampleId = GetSampleIdFromTime(editWhen, false);
  1610. if (pStartTime || pDuration) {
  1611. GetSampleTimes(sampleId, pStartTime, pDuration);
  1612. }
  1613. }
  1615. return sampleId;
  1616. }