spacepaste

Paste details

reply | raw

  1.  
  2. /* This Source Code Form is subject to the terms of the Mozilla Public
  3. * License, v. 2.0. If a copy of the MPL was not distributed with this
  4. * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
  6. #include "mp4_demuxer/MoofParser.h"
  7. #include "mp4_demuxer/Box.h"
  8. #include "mp4_demuxer/SinfParser.h"
  9. #include <limits>
  10. #include "Intervals.h"
  12. #include "prlog.h"
  14. #ifdef PR_LOGGING
  15. extern PRLogModuleInfo* GetDemuxerLog();
  17. /* Polyfill __func__ on MSVC to pass to the log. */
  18. #ifdef _MSC_VER
  19. #define __func__ __FUNCTION__
  20. #endif
  22. #define STRINGIFY(x) #x
  23. #define TOSTRING(x) STRINGIFY(x)
  24. #define LOG(name, arg, ...) PR_LOG(GetDemuxerLog(), PR_LOG_DEBUG, (TOSTRING(name) "(%p)::%s: " arg, this, __func__, ##__VA_ARGS__))
  25. #else
  26. #define LOG(...)
  27. #endif
  29. namespace mp4_demuxer
  30. {
  32. using namespace stagefright;
  33. using namespace mozilla;
  35. bool
  36. MoofParser::RebuildFragmentedIndex(
  37. const nsTArray<mozilla::MediaByteRange>& aByteRanges)
  38. {
  39. BoxContext context(mSource, aByteRanges);
  40. return RebuildFragmentedIndex(context);
  41. }
  43. bool
  44. MoofParser::RebuildFragmentedIndex(BoxContext& aContext)
  45. {
  46. bool foundValidMoof = false;
  47. bool foundMdat = false;
  49. for (Box box(&aContext, mOffset); box.IsAvailable(); box = box.Next()) {
  50. if (box.IsType("moov") && mInitRange.IsNull()) {
  51. mInitRange = MediaByteRange(0, box.Range().mEnd);
  52. ParseMoov(box);
  53. } else if (box.IsType("moof")) {
  54. Moof moof(box, mTrex, mMvhd, mMdhd, mEdts, mSinf, mIsAudio);
  56. if (!moof.IsValid() && !box.Next().IsAvailable()) {
  57. // Moof isn't valid abort search for now.
  58. break;
  59. }
  61. if (!mMoofs.IsEmpty()) {
  62. // Stitch time ranges together in the case of a (hopefully small) time
  63. // range gap between moofs.
  64. mMoofs.LastElement().FixRounding(moof);
  65. }
  67. mMoofs.AppendElement(moof);
  68. mMediaRanges.AppendElement(moof.mRange);
  69. foundValidMoof = true;
  70. } else if (box.IsType("mdat") && !Moofs().IsEmpty()) {
  71. // Check if we have all our data from last moof.
  72. Moof& moof = Moofs().LastElement();
  73. media::Interval<int64_t> datarange(moof.mMdatRange.mStart, moof.mMdatRange.mEnd, 0);
  74. media::Interval<int64_t> mdat(box.Range().mStart, box.Range().mEnd, 0);
  75. if (datarange.Intersects(mdat)) {
  76. mMediaRanges.LastElement() =
  77. mMediaRanges.LastElement().Extents(box.Range());
  78. }
  79. }
  80. mOffset = box.NextOffset();
  81. }
  82. return foundValidMoof;
  83. }
  85. MediaByteRange
  86. MoofParser::FirstCompleteMediaHeader()
  87. {
  88. if (Moofs().IsEmpty()) {
  89. return MediaByteRange();
  90. }
  91. return Moofs()[0].mRange;
  92. }
  94. MediaByteRange
  95. MoofParser::FirstCompleteMediaSegment()
  96. {
  97. for (uint32_t i = 0 ; i < mMediaRanges.Length(); i++) {
  98. if (mMediaRanges[i].Contains(Moofs()[i].mMdatRange)) {
  99. return mMediaRanges[i];
  100. }
  101. }
  102. return MediaByteRange();
  103. }
  105. class BlockingStream : public Stream {
  106. public:
  107. explicit BlockingStream(Stream* aStream) : mStream(aStream)
  108. {
  109. }
  111. bool ReadAt(int64_t offset, void* data, size_t size, size_t* bytes_read)
  112. override
  113. {
  114. return mStream->ReadAt(offset, data, size, bytes_read);
  115. }
  117. bool CachedReadAt(int64_t offset, void* data, size_t size, size_t* bytes_read)
  118. override
  119. {
  120. return mStream->ReadAt(offset, data, size, bytes_read);
  121. }
  123. virtual bool Length(int64_t* size) override
  124. {
  125. return mStream->Length(size);
  126. }
  128. private:
  129. nsRefPtr<Stream> mStream;
  130. };
  132. bool
  133. MoofParser::BlockingReadNextMoof()
  134. {
  135. int64_t length = std::numeric_limits<int64_t>::max();
  136. mSource->Length(&length);
  137. nsTArray<MediaByteRange> byteRanges;
  138. byteRanges.AppendElement(MediaByteRange(0, length));
  139. nsRefPtr<mp4_demuxer::BlockingStream> stream = new BlockingStream(mSource);
  141. BoxContext context(stream, byteRanges);
  142. for (Box box(&context, mOffset); box.IsAvailable(); box = box.Next()) {
  143. if (box.IsType("moof")) {
  144. byteRanges.Clear();
  145. byteRanges.AppendElement(MediaByteRange(mOffset, box.Range().mEnd));
  146. return RebuildFragmentedIndex(context);
  147. }
  148. }
  149. return false;
  150. }
  152. void
  153. MoofParser::ScanForMetadata(mozilla::MediaByteRange& aFtyp,
  154. mozilla::MediaByteRange& aMoov)
  155. {
  156. int64_t length = std::numeric_limits<int64_t>::max();
  157. mSource->Length(&length);
  158. nsTArray<MediaByteRange> byteRanges;
  159. byteRanges.AppendElement(MediaByteRange(0, length));
  160. nsRefPtr<mp4_demuxer::BlockingStream> stream = new BlockingStream(mSource);
  162. BoxContext context(stream, byteRanges);
  163. for (Box box(&context, mOffset); box.IsAvailable(); box = box.Next()) {
  164. if (box.IsType("ftyp")) {
  165. aFtyp = box.Range();
  166. continue;
  167. }
  168. if (box.IsType("moov")) {
  169. aMoov = box.Range();
  170. break;
  171. }
  172. }
  173. mInitRange = aFtyp.Extents(aMoov);
  174. }
  176. bool
  177. MoofParser::HasMetadata()
  178. {
  179. MediaByteRange ftyp;
  180. MediaByteRange moov;
  181. ScanForMetadata(ftyp, moov);
  182. return !!ftyp.Length() && !!moov.Length();
  183. }
  185. already_AddRefed<mozilla::MediaLargeByteBuffer>
  186. MoofParser::Metadata()
  187. {
  188. MediaByteRange ftyp;
  189. MediaByteRange moov;
  190. ScanForMetadata(ftyp, moov);
  191. if (!ftyp.Length() || !moov.Length()) {
  192. return nullptr;
  193. }
  194. nsRefPtr<MediaLargeByteBuffer> metadata = new MediaLargeByteBuffer();
  195. if (!metadata->SetLength(ftyp.Length() + moov.Length())) {
  196. // OOM
  197. return nullptr;
  198. }
  200. nsRefPtr<mp4_demuxer::BlockingStream> stream = new BlockingStream(mSource);
  201. size_t read;
  202. bool rv =
  203. stream->ReadAt(ftyp.mStart, metadata->Elements(), ftyp.Length(), &read);
  204. if (!rv || read != ftyp.Length()) {
  205. return nullptr;
  206. }
  207. rv =
  208. stream->ReadAt(moov.mStart, metadata->Elements() + ftyp.Length(), moov.Length(), &read);
  209. if (!rv || read != moov.Length()) {
  210. return nullptr;
  211. }
  212. return metadata.forget();
  213. }
  215. Interval<Microseconds>
  216. MoofParser::GetCompositionRange(const nsTArray<MediaByteRange>& aByteRanges)
  217. {
  218. Interval<Microseconds> compositionRange;
  219. BoxContext context(mSource, aByteRanges);
  220. for (size_t i = 0; i < mMoofs.Length(); i++) {
  221. Moof& moof = mMoofs[i];
  222. Box box(&context, moof.mRange.mStart);
  223. if (box.IsAvailable()) {
  224. compositionRange = compositionRange.Extents(moof.mTimeRange);
  225. }
  226. }
  227. return compositionRange;
  228. }
  230. bool
  231. MoofParser::ReachedEnd()
  232. {
  233. int64_t length;
  234. return mSource->Length(&length) && mOffset == length;
  235. }
  237. void
  238. MoofParser::ParseMoov(Box& aBox)
  239. {
  240. for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
  241. if (box.IsType("mvhd")) {
  242. mMvhd = Mvhd(box);
  243. } else if (box.IsType("trak")) {
  244. ParseTrak(box);
  245. } else if (box.IsType("mvex")) {
  246. ParseMvex(box);
  247. }
  248. }
  249. }
  251. void
  252. MoofParser::ParseTrak(Box& aBox)
  253. {
  254. Tkhd tkhd;
  255. for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
  256. if (box.IsType("tkhd")) {
  257. tkhd = Tkhd(box);
  258. } else if (box.IsType("mdia")) {
  259. if (!mTrex.mTrackId || tkhd.mTrackId == mTrex.mTrackId) {
  260. ParseMdia(box, tkhd);
  261. }
  262. } else if (box.IsType("edts") &&
  263. (!mTrex.mTrackId || tkhd.mTrackId == mTrex.mTrackId)) {
  264. mEdts = Edts(box);
  265. }
  266. }
  267. }
  269. void
  270. MoofParser::ParseMdia(Box& aBox, Tkhd& aTkhd)
  271. {
  272. for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
  273. if (box.IsType("mdhd")) {
  274. mMdhd = Mdhd(box);
  275. } else if (box.IsType("minf")) {
  276. ParseMinf(box);
  277. }
  278. }
  279. }
  281. void
  282. MoofParser::ParseMvex(Box& aBox)
  283. {
  284. for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
  285. if (box.IsType("trex")) {
  286. Trex trex = Trex(box);
  287. if (!mTrex.mTrackId || trex.mTrackId == mTrex.mTrackId) {
  288. auto trackId = mTrex.mTrackId;
  289. mTrex = trex;
  290. // Keep the original trackId, as should it be 0 we want to continue
  291. // parsing all tracks.
  292. mTrex.mTrackId = trackId;
  293. }
  294. }
  295. }
  296. }
  298. void
  299. MoofParser::ParseMinf(Box& aBox)
  300. {
  301. for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
  302. if (box.IsType("stbl")) {
  303. ParseStbl(box);
  304. }
  305. }
  306. }
  308. void
  309. MoofParser::ParseStbl(Box& aBox)
  310. {
  311. for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
  312. if (box.IsType("stsd")) {
  313. ParseStsd(box);
  314. }
  315. }
  316. }
  318. void
  319. MoofParser::ParseStsd(Box& aBox)
  320. {
  321. for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
  322. if (box.IsType("encv") || box.IsType("enca")) {
  323. ParseEncrypted(box);
  324. }
  325. }
  326. }
  328. void
  329. MoofParser::ParseEncrypted(Box& aBox)
  330. {
  331. for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
  332. // Some MP4 files have been found to have multiple sinf boxes in the same
  333. // enc* box. This does not match spec anyway, so just choose the first
  334. // one that parses properly.
  335. if (box.IsType("sinf")) {
  336. mSinf = Sinf(box);
  338. if (mSinf.IsValid()) {
  339. break;
  340. }
  341. }
  342. }
  343. }
  345. Moof::Moof(Box& aBox, Trex& aTrex, Mvhd& aMvhd, Mdhd& aMdhd, Edts& aEdts, Sinf& aSinf, bool aIsAudio)
  346. : mRange(aBox.Range())
  347. , mMaxRoundingError(35000)
  348. {
  349. for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
  350. if (box.IsType("traf")) {
  351. ParseTraf(box, aTrex, aMvhd, aMdhd, aEdts, aSinf, aIsAudio);
  352. }
  353. }
  354. if (IsValid()) {
  355. ProcessCenc();
  356. }
  357. }
  359. bool
  360. Moof::GetAuxInfo(AtomType aType, nsTArray<MediaByteRange>* aByteRanges)
  361. {
  362. aByteRanges->Clear();
  364. Saiz* saiz = nullptr;
  365. for (int i = 0; ; i++) {
  366. if (i == mSaizs.Length()) {
  367. return false;
  368. }
  369. if (mSaizs[i].mAuxInfoType == aType) {
  370. saiz = &mSaizs[i];
  371. break;
  372. }
  373. }
  374. Saio* saio = nullptr;
  375. for (int i = 0; ; i++) {
  376. if (i == mSaios.Length()) {
  377. return false;
  378. }
  379. if (mSaios[i].mAuxInfoType == aType) {
  380. saio = &mSaios[i];
  381. break;
  382. }
  383. }
  385. if (saio->mOffsets.Length() == 1) {
  386. aByteRanges->SetCapacity(saiz->mSampleInfoSize.Length());
  387. uint64_t offset = mRange.mStart + saio->mOffsets[0];
  388. for (size_t i = 0; i < saiz->mSampleInfoSize.Length(); i++) {
  389. aByteRanges->AppendElement(
  390. MediaByteRange(offset, offset + saiz->mSampleInfoSize[i]));
  391. offset += saiz->mSampleInfoSize[i];
  392. }
  393. return true;
  394. }
  396. if (saio->mOffsets.Length() == saiz->mSampleInfoSize.Length()) {
  397. aByteRanges->SetCapacity(saiz->mSampleInfoSize.Length());
  398. for (size_t i = 0; i < saio->mOffsets.Length(); i++) {
  399. uint64_t offset = mRange.mStart + saio->mOffsets[i];
  400. aByteRanges->AppendElement(
  401. MediaByteRange(offset, offset + saiz->mSampleInfoSize[i]));
  402. }
  403. return true;
  404. }
  406. return false;
  407. }
  409. bool
  410. Moof::ProcessCenc()
  411. {
  412. nsTArray<MediaByteRange> cencRanges;
  413. if (!GetAuxInfo(AtomType("cenc"), &cencRanges) ||
  414. cencRanges.Length() != mIndex.Length()) {
  415. return false;
  416. }
  417. for (int i = 0; i < cencRanges.Length(); i++) {
  418. mIndex[i].mCencRange = cencRanges[i];
  419. }
  420. return true;
  421. }
  423. void
  424. Moof::ParseTraf(Box& aBox, Trex& aTrex, Mvhd& aMvhd, Mdhd& aMdhd, Edts& aEdts, Sinf& aSinf, bool aIsAudio)
  425. {
  426. Tfhd tfhd(aTrex);
  427. Tfdt tfdt;
  428. for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
  429. if (box.IsType("tfhd")) {
  430. tfhd = Tfhd(box, aTrex);
  431. } else if (!aTrex.mTrackId || tfhd.mTrackId == aTrex.mTrackId) {
  432. if (box.IsType("tfdt")) {
  433. tfdt = Tfdt(box);
  434. } else if (box.IsType("saiz")) {
  435. mSaizs.AppendElement(Saiz(box, aSinf.mDefaultEncryptionType));
  436. } else if (box.IsType("saio")) {
  437. mSaios.AppendElement(Saio(box, aSinf.mDefaultEncryptionType));
  438. }
  439. }
  440. }
  441. if (aTrex.mTrackId && tfhd.mTrackId != aTrex.mTrackId) {
  442. return;
  443. }
  444. if (!tfdt.IsValid()) {
  445. return;
  446. }
  447. // Now search for TRUN boxes.
  448. uint64_t decodeTime = tfdt.mBaseMediaDecodeTime;
  449. for (Box box = aBox.FirstChild(); box.IsAvailable(); box = box.Next()) {
  450. if (box.IsType("trun")) {
  451. if (ParseTrun(box, tfhd, aMvhd, aMdhd, aEdts, &decodeTime, aIsAudio)) {
  452. mValid = true;
  453. } else {
  454. mValid = false;
  455. break;
  456. }
  457. }
  458. }
  459. }
  461. void
  462. Moof::FixRounding(const Moof& aMoof) {
  463. Microseconds gap = aMoof.mTimeRange.start - mTimeRange.end;
  464. if (gap > 0 && gap <= mMaxRoundingError) {
  465. mTimeRange.end = aMoof.mTimeRange.start;
  466. }
  467. }
  469. class CtsComparator
  470. {
  471. public:
  472. bool Equals(Sample* const aA, Sample* const aB) const
  473. {
  474. return aA->mCompositionRange.start == aB->mCompositionRange.start;
  475. }
  476. bool
  477. LessThan(Sample* const aA, Sample* const aB) const
  478. {
  479. return aA->mCompositionRange.start < aB->mCompositionRange.start;
  480. }
  481. };
  483. bool
  484. Moof::ParseTrun(Box& aBox, Tfhd& aTfhd, Mvhd& aMvhd, Mdhd& aMdhd, Edts& aEdts, uint64_t* aDecodeTime, bool aIsAudio)
  485. {
  486. if (!aTfhd.IsValid() || !aMvhd.IsValid() || !aMdhd.IsValid() ||
  487. !aEdts.IsValid()) {
  488. return false;
  489. }
  491. BoxReader reader(aBox);
  492. if (!reader->CanReadType<uint32_t>()) {
  493. return false;
  494. }
  495. uint32_t flags = reader->ReadU32();
  496. uint8_t version = flags >> 24;
  498. if (!reader->CanReadType<uint32_t>()) {
  499. return false;
  500. }
  501. uint32_t sampleCount = reader->ReadU32();
  502. if (sampleCount == 0) {
  503. return true;
  504. }
  506. size_t need =
  507. ((flags & 1) ? sizeof(uint32_t) : 0) +
  508. ((flags & 4) ? sizeof(uint32_t) : 0);
  509. uint16_t flag[] = { 0x100, 0x200, 0x400, 0x800, 0 };
  510. for (size_t i = 0; flag[i]; i++) {
  511. if (flags & flag[i]) {
  512. need += sizeof(uint32_t) * sampleCount;
  513. }
  514. }
  515. if (reader->Remaining() < need) {
  516. return false;
  517. }
  519. uint64_t offset = aTfhd.mBaseDataOffset + (flags & 1 ? reader->ReadU32() : 0);
  520. uint32_t firstSampleFlags =
  521. flags & 4 ? reader->ReadU32() : aTfhd.mDefaultSampleFlags;
  522. uint64_t decodeTime = *aDecodeTime;
  523. nsTArray<Interval<Microseconds>> timeRanges;
  525. if (!mIndex.SetCapacity(sampleCount)) {
  526. return false;
  527. }
  529. for (size_t i = 0; i < sampleCount; i++) {
  530. uint32_t sampleDuration =
  531. flags & 0x100 ? reader->ReadU32() : aTfhd.mDefaultSampleDuration;
  532. uint32_t sampleSize =
  533. flags & 0x200 ? reader->ReadU32() : aTfhd.mDefaultSampleSize;
  534. uint32_t sampleFlags =
  535. flags & 0x400 ? reader->ReadU32()
  536. : i ? aTfhd.mDefaultSampleFlags : firstSampleFlags;
  537. int32_t ctsOffset = 0;
  538. if (flags & 0x800) {
  539. ctsOffset = reader->Read32();
  540. }
  542. Sample sample;
  543. sample.mByteRange = MediaByteRange(offset, offset + sampleSize);
  544. offset += sampleSize;
  546. sample.mDecodeTime =
  547. aMdhd.ToMicroseconds((int64_t)decodeTime - aEdts.mMediaStart) + aMvhd.ToMicroseconds(aEdts.mEmptyOffset);
  548. sample.mCompositionRange = Interval<Microseconds>(
  549. aMdhd.ToMicroseconds((int64_t)decodeTime + ctsOffset - aEdts.mMediaStart) + aMvhd.ToMicroseconds(aEdts.mEmptyOffset),
  550. aMdhd.ToMicroseconds((int64_t)decodeTime + ctsOffset + sampleDuration - aEdts.mMediaStart) + aMvhd.ToMicroseconds(aEdts.mEmptyOffset));
  551. decodeTime += sampleDuration;
  553. // Sometimes audio streams don't properly mark their samples as keyframes,
  554. // because every audio sample is a keyframe.
  555. sample.mSync = !(sampleFlags & 0x1010000) || aIsAudio;
  557. MOZ_ALWAYS_TRUE(mIndex.AppendElement(sample));
  559. mMdatRange = mMdatRange.Extents(sample.mByteRange);
  560. }
  561. mMaxRoundingError += aMdhd.ToMicroseconds(sampleCount);
  563. nsTArray<Sample*> ctsOrder;
  564. for (int i = 0; i < mIndex.Length(); i++) {
  565. ctsOrder.AppendElement(&mIndex[i]);
  566. }
  567. ctsOrder.Sort(CtsComparator());
  569. for (size_t i = 0; i < ctsOrder.Length(); i++) {
  570. if (i + 1 < ctsOrder.Length()) {
  571. ctsOrder[i]->mCompositionRange.end = ctsOrder[i + 1]->mCompositionRange.start;
  572. }
  573. }
  574. mTimeRange = Interval<Microseconds>(ctsOrder[0]->mCompositionRange.start,
  575. ctsOrder.LastElement()->mCompositionRange.end);
  576. *aDecodeTime = decodeTime;
  577. return true;
  578. }
  580. Tkhd::Tkhd(Box& aBox)
  581. {
  582. BoxReader reader(aBox);
  583. if (!reader->CanReadType<uint32_t>()) {
  584. return;
  585. }
  586. uint32_t flags = reader->ReadU32();
  587. uint8_t version = flags >> 24;
  588. size_t need =
  589. 3*(version ? sizeof(int64_t) : sizeof(int32_t)) + 2*sizeof(int32_t);
  590. if (reader->Remaining() < need) {
  591. return;
  592. }
  593. if (version == 0) {
  594. mCreationTime = reader->ReadU32();
  595. mModificationTime = reader->ReadU32();
  596. mTrackId = reader->ReadU32();
  597. uint32_t reserved = reader->ReadU32();
  598. NS_ASSERTION(!reserved, "reserved should be 0");
  599. mDuration = reader->ReadU32();
  600. } else if (version == 1) {
  601. mCreationTime = reader->ReadU64();
  602. mModificationTime = reader->ReadU64();
  603. mTrackId = reader->ReadU32();
  604. uint32_t reserved = reader->ReadU32();
  605. NS_ASSERTION(!reserved, "reserved should be 0");
  606. mDuration = reader->ReadU64();
  607. }
  608. // More stuff that we don't care about
  609. reader->DiscardRemaining();
  610. mValid = true;
  611. }
  613. Mvhd::Mvhd(Box& aBox)
  614. {
  615. BoxReader reader(aBox);
  616. if (!reader->CanReadType<uint32_t>()) {
  617. return;
  618. }
  619. uint32_t flags = reader->ReadU32();
  620. uint8_t version = flags >> 24;
  621. size_t need =
  622. 3*(version ? sizeof(int64_t) : sizeof(int32_t)) + sizeof(uint32_t);
  623. if (reader->Remaining() < need) {
  624. return;
  625. }
  627. if (version == 0) {
  628. mCreationTime = reader->ReadU32();
  629. mModificationTime = reader->ReadU32();
  630. mTimescale = reader->ReadU32();
  631. mDuration = reader->ReadU32();
  632. } else if (version == 1) {
  633. mCreationTime = reader->ReadU64();
  634. mModificationTime = reader->ReadU64();
  635. mTimescale = reader->ReadU32();
  636. mDuration = reader->ReadU64();
  637. } else {
  638. reader->DiscardRemaining();
  639. return;
  640. }
  641. // More stuff that we don't care about
  642. reader->DiscardRemaining();
  643. mValid = true;
  644. }
  646. Mdhd::Mdhd(Box& aBox)
  647. : Mvhd(aBox)
  648. {
  649. }
  651. Trex::Trex(Box& aBox)
  652. {
  653. BoxReader reader(aBox);
  654. if (reader->Remaining() < 6*sizeof(uint32_t)) {
  655. return;
  656. }
  657. mFlags = reader->ReadU32();
  658. mTrackId = reader->ReadU32();
  659. mDefaultSampleDescriptionIndex = reader->ReadU32();
  660. mDefaultSampleDuration = reader->ReadU32();
  661. mDefaultSampleSize = reader->ReadU32();
  662. mDefaultSampleFlags = reader->ReadU32();
  663. mValid = true;
  664. }
  666. Tfhd::Tfhd(Box& aBox, Trex& aTrex)
  667. : Trex(aTrex)
  668. {
  669. MOZ_ASSERT(aBox.IsType("tfhd"));
  670. MOZ_ASSERT(aBox.Parent()->IsType("traf"));
  671. MOZ_ASSERT(aBox.Parent()->Parent()->IsType("moof"));
  673. BoxReader reader(aBox);
  674. if (!reader->CanReadType<uint32_t>()) {
  675. return;
  676. }
  677. mFlags = reader->ReadU32();
  678. size_t need = sizeof(uint32_t) /* trackid */;
  679. uint8_t flag[] = { 1, 2, 8, 0x10, 0x20, 0 };
  680. for (size_t i = 0; flag[i]; i++) {
  681. if (mFlags & flag[i]) {
  682. need += sizeof(uint32_t);
  683. }
  684. }
  685. if (reader->Remaining() < need) {
  686. return;
  687. }
  688. mBaseDataOffset =
  689. mFlags & 1 ? reader->ReadU32() : aBox.Parent()->Parent()->Offset();
  690. mTrackId = reader->ReadU32();
  691. if (mFlags & 2) {
  692. mDefaultSampleDescriptionIndex = reader->ReadU32();
  693. }
  694. if (mFlags & 8) {
  695. mDefaultSampleDuration = reader->ReadU32();
  696. }
  697. if (mFlags & 0x10) {
  698. mDefaultSampleSize = reader->ReadU32();
  699. }
  700. if (mFlags & 0x20) {
  701. mDefaultSampleFlags = reader->ReadU32();
  702. }
  703. mValid = true;
  704. }
  706. Tfdt::Tfdt(Box& aBox)
  707. {
  708. BoxReader reader(aBox);
  709. if (!reader->CanReadType<uint32_t>()) {
  710. return;
  711. }
  712. uint32_t flags = reader->ReadU32();
  713. uint8_t version = flags >> 24;
  714. size_t need = version ? sizeof(uint64_t) : sizeof(uint32_t) ;
  715. if (reader->Remaining() < need) {
  716. return;
  717. }
  718. if (version == 0) {
  719. mBaseMediaDecodeTime = reader->ReadU32();
  720. } else if (version == 1) {
  721. mBaseMediaDecodeTime = reader->ReadU64();
  722. }
  723. reader->DiscardRemaining();
  724. mValid = true;
  725. }
  727. Edts::Edts(Box& aBox)
  728. : mMediaStart(0)
  729. , mEmptyOffset(0)
  730. {
  731. Box child = aBox.FirstChild();
  732. if (!child.IsType("elst")) {
  733. return;
  734. }
  736. BoxReader reader(child);
  737. if (!reader->CanReadType<uint32_t>()) {
  738. return;
  739. }
  740. uint32_t flags = reader->ReadU32();
  741. uint8_t version = flags >> 24;
  742. size_t need =
  743. sizeof(uint32_t) + 2*(version ? sizeof(int64_t) : sizeof(uint32_t));
  744. if (reader->Remaining() < need) {
  745. return;
  746. }
  747. bool emptyEntry = false;
  748. uint32_t entryCount = reader->ReadU32();
  749. for (uint32_t i = 0; i < entryCount; i++) {
  750. uint64_t segment_duration;
  751. int64_t media_time;
  752. if (version == 1) {
  753. segment_duration = reader->ReadU64();
  754. media_time = reader->Read64();
  755. } else {
  756. segment_duration = reader->ReadU32();
  757. media_time = reader->Read32();
  758. }
  759. if (media_time == -1 && i) {
  760. break;
  761. } else if (media_time == -1) {
  762. mEmptyOffset = segment_duration;
  763. emptyEntry = true;
  764. } else if (i > 1 || (i > 0 && !emptyEntry)) {
  765. break;
  766. } else {
  767. mMediaStart = media_time;
  768. }
  769. reader->ReadU32(); // media_rate_integer and media_rate_fraction
  770. }
  771. }
  773. Saiz::Saiz(Box& aBox, AtomType aDefaultType)
  774. : mAuxInfoType(aDefaultType)
  775. , mAuxInfoTypeParameter(0)
  776. {
  777. BoxReader reader(aBox);
  778. if (!reader->CanReadType<uint32_t>()) {
  779. return;
  780. }
  781. uint32_t flags = reader->ReadU32();
  782. uint8_t version = flags >> 24;
  783. size_t need =
  784. ((flags & 1) ? 2*sizeof(uint32_t) : 0) + sizeof(uint8_t) + sizeof(uint32_t);
  785. if (reader->Remaining() < need) {
  786. return;
  787. }
  788. if (flags & 1) {
  789. mAuxInfoType = reader->ReadU32();
  790. mAuxInfoTypeParameter = reader->ReadU32();
  791. }
  792. uint8_t defaultSampleInfoSize = reader->ReadU8();
  793. uint32_t count = reader->ReadU32();
  794. if (defaultSampleInfoSize) {
  795. for (int i = 0; i < count; i++) {
  796. mSampleInfoSize.AppendElement(defaultSampleInfoSize);
  797. }
  798. } else {
  799. if (!reader->ReadArray(mSampleInfoSize, count)) {
  800. return;
  801. }
  802. }
  803. mValid = true;
  804. }
  806. Saio::Saio(Box& aBox, AtomType aDefaultType)
  807. : mAuxInfoType(aDefaultType)
  808. , mAuxInfoTypeParameter(0)
  809. {
  810. BoxReader reader(aBox);
  811. if (!reader->CanReadType<uint32_t>()) {
  812. return;
  813. }
  814. uint32_t flags = reader->ReadU32();
  815. uint8_t version = flags >> 24;
  816. size_t need = ((flags & 1) ? (2*sizeof(uint32_t)) : 0) + sizeof(uint32_t);
  817. if (reader->Remaining() < need) {
  818. return;
  819. }
  820. if (flags & 1) {
  821. mAuxInfoType = reader->ReadU32();
  822. mAuxInfoTypeParameter = reader->ReadU32();
  823. }
  824. size_t count = reader->ReadU32();
  825. need = (version ? sizeof(uint64_t) : sizeof(uint32_t)) * count;
  826. if (reader->Remaining() < count) {
  827. return;
  828. }
  829. mOffsets.SetCapacity(count);
  830. if (version == 0) {
  831. for (size_t i = 0; i < count; i++) {
  832. mOffsets.AppendElement(reader->ReadU32());
  833. }
  834. } else {
  835. for (size_t i = 0; i < count; i++) {
  836. mOffsets.AppendElement(reader->ReadU64());
  837. }
  838. }
  839. mValid = true;
  840. }
  842. #undef LOG
  843. }
  844.  
Powered by spacepaste. Paste removal.