Implement ISO BMFF support in Media Source.

media/mp4/track_run_iterator.cc

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "media/mp4/track_run_iterator.h"
+
+#include <algorithm>
+
+#include "media/mp4/rcheck.h"
+
+namespace media {
+namespace mp4 {
+
+base::TimeDelta TimeDeltaFromFrac(int64 numer, uint64 denom) {
+  DCHECK_LT(std::abs(numer), kint64max / base::Time::kMicrosecondsPerSecond);
+  return base::TimeDelta::FromMicroseconds(
+        base::Time::kMicrosecondsPerSecond * numer / denom);
+}
+
+const static uint32 kSampleIsDifferenceSampleFlagMask = 0x10000;

[acolwell GONE FROM CHROMIUM, 2012/06/08 16:10:38]

lint nit: static comes first.

[strobe_, 2012/06/11 18:44:21]

Done.

+
+TrackRunInfo::TrackRunInfo() {}
+TrackRunInfo::~TrackRunInfo() {}
+
+TrackRunIterator::TrackRunIterator() {}
+TrackRunIterator::~TrackRunIterator() {}
+
+static void PopulateSampleInfo(const Track& trak,
+                               const TrackExtends& trex,
+                               const TrackFragmentHeader& tfhd,
+                               const TrackFragmentRun& trun,
+                               const uint32 i,
+                               SampleInfo* sample_info) {
+  if (i < trun.sample_sizes.size()) {
+    sample_info->size = trun.sample_sizes[i];
+  } else if (tfhd.default_sample_size > 0) {
+    sample_info->size = tfhd.default_sample_size;
+  } else {
+    sample_info->size = trex.default_sample_size;
+  }
+
+  const uint64 timescale = trak.media.header.timescale;
+  uint64 duration;
+  if (i < trun.sample_durations.size()) {
+    duration = trun.sample_durations[i];
+  } else if (tfhd.default_sample_duration > 0) {
+    duration = tfhd.default_sample_duration;
+  } else {
+    duration = trex.default_sample_duration;
+  }
+  sample_info->duration = TimeDeltaFromFrac(duration, timescale);
+
+  if (i < trun.sample_composition_time_offsets.size()) {
+    sample_info->cts_offset =
+        TimeDeltaFromFrac(trun.sample_composition_time_offsets[i], timescale);
+  } else {
+    sample_info->cts_offset = TimeDelta::FromMicroseconds(0);
+  }
+
+  uint32 flags;
+  if (i < trun.sample_flags.size()) {
+    flags = trun.sample_flags[i];
+  } else if (tfhd.has_default_sample_flags) {
+    flags = tfhd.default_sample_flags;
+  } else {
+    flags = trex.default_sample_flags;
+  }
+  sample_info->is_keyframe = !(flags & kSampleIsDifferenceSampleFlagMask);
+}
+
+class CompareOffset {
+ public:
+  bool operator()(TrackRunInfo a, TrackRunInfo b) {
+    int64 a_min = a.sample_start_offset;
+    if (a.is_encrypted && a.cenc_start_offset < a_min)
+      a_min = a.cenc_start_offset;
+    int64 b_min = b.sample_start_offset;
+    if (b.is_encrypted && b.cenc_start_offset < b_min)
+      b_min = b.cenc_start_offset;
+    return a_min < b_min;
+  }
+};
+
+bool TrackRunIterator::Init(const Movie& moov, const MovieFragment& moof) {
+  runs_.clear();
+
+  for (size_t i = 0; i < moof.tracks.size(); i++) {
+    const TrackFragment& traf = moof.tracks[i];
+
+    const Track* trak = NULL;
+    for (size_t t = 0; t < moov.tracks.size(); t++) {
+      if (moov.tracks[t].header.track_id == traf.header.track_id)
+        trak = &moov.tracks[t];
+    }
+
+    const TrackExtends* trex = NULL;
+    for (size_t t = 0; t < moov.extends.tracks.size(); t++) {
+      if (moov.extends.tracks[t].track_id == traf.header.track_id)
+        trex = &moov.extends.tracks[t];
+    }
+    RCHECK(trak && trex);
+
+    const ProtectionSchemeInfo* sinf = NULL;
+    const SampleDescription& stsd =
+        trak->media.information.sample_table.description;
+    if (stsd.type == kAudio) {
+      sinf = &stsd.audio_entries[0].sinf;
+    } else if (stsd.type == kVideo) {
+      sinf = &stsd.video_entries[0].sinf;
+    } else {
+      DVLOG(1) << "Skipping unhandled track type";
+      continue;
+    }
+
+    for (size_t j = 0; j < traf.runs.size(); j++) {
+      const TrackFragmentRun& trun = traf.runs[j];
+      TrackRunInfo tri;
+      tri.track_id = traf.header.track_id;
+      tri.start_dts = TimeDeltaFromFrac(traf.decode_time.decode_time,
+                                        trak->media.header.timescale);
+      tri.sample_start_offset = trun.data_offset;
+      tri.is_encrypted = sinf->info.track_encryption.is_encrypted;
+      // TODO(strobe): CENC recovery and testing
+
+      tri.samples.resize(trun.sample_count);
+
+      for (size_t k = 0; k < trun.sample_count; k++) {
+        PopulateSampleInfo(*trak, *trex, traf.header, trun, k, &tri.samples[k]);
+      }
+      runs_.push_back(tri);
+    }
+  }
+
+  std::sort(runs_.begin(), runs_.end(), CompareOffset());
+  run_itr_ = runs_.begin();
+  min_clear_offset_itr_ = min_clear_offsets_.begin();
+  ResetRun();
+  return true;
+}
+
+void TrackRunIterator::AdvanceRun() {
+  ++run_itr_;
+  if (min_clear_offset_itr_ != min_clear_offsets_.end())
+    ++min_clear_offset_itr_;
+  ResetRun();
+}
+
+void TrackRunIterator::ResetRun() {
+  if (!RunValid()) return;
+  sample_dts_ = run_itr_->start_dts;
+  sample_offset_ = run_itr_->sample_start_offset;
+  sample_itr_ = run_itr_->samples.begin();
+}
+
+void TrackRunIterator::AdvanceSample() {
+  DCHECK(SampleValid());
+  sample_dts_ += sample_itr_->duration;
+  sample_offset_ += sample_itr_->size;
+  // TODO(strobe): frame_cenc_info_
+  ++sample_itr_;
+}
+
+bool TrackRunIterator::NeedsCENC() {
+  CHECK(!is_encrypted()) << "TODO(strobe): Implement CENC.";
+  return is_encrypted();
+}
+
+bool TrackRunIterator::CacheCENC(const uint8* buf, int size) {
+  LOG(FATAL) << "Not implemented";
+  return false;
+}
+
+bool TrackRunIterator::RunValid() const {
+  return run_itr_ != runs_.end();
+}
+
+bool TrackRunIterator::SampleValid() const {
+  return RunValid() && (sample_itr_ != run_itr_->samples.end());
+}
+
+int64 TrackRunIterator::GetMaxClearOffset() {
+  int64 offset = kint64max;
+
+  if (SampleValid()) {
+    offset = std::min(offset, sample_offset_);
+    if (NeedsCENC()) {
+      offset = std::min(offset, cenc_offset());
+    }
+  }
+  if (min_clear_offset_itr_ != min_clear_offsets_.end()) {
+    offset = std::min(offset, *min_clear_offset_itr_);
+  }
+  if (offset == kint64max) return 0;
+  return offset;
+}
+
+uint32 TrackRunIterator::track_id() const {
+  DCHECK(RunValid());
+  return run_itr_->track_id;
+}
+
+bool TrackRunIterator::is_encrypted() const {
+  DCHECK(RunValid());
+  return run_itr_->is_encrypted;
+}
+
+int64 TrackRunIterator::cenc_offset() const {
+  DCHECK(is_encrypted());
+  return run_itr_->cenc_start_offset;
+}
+
+int TrackRunIterator::cenc_size() const {
+  DCHECK(is_encrypted());
+  return run_itr_->cenc_total_size;
+}
+
+int64 TrackRunIterator::offset() const {
+  DCHECK(SampleValid());
+  return sample_offset_;
+}
+
+int TrackRunIterator::size() const {
+  DCHECK(SampleValid());
+  return sample_itr_->size;
+}
+
+TimeDelta TrackRunIterator::dts() const {
+  DCHECK(SampleValid());
+  return sample_dts_;
+}
+
+TimeDelta TrackRunIterator::cts() const {
+  DCHECK(SampleValid());
+  return sample_dts_ + sample_itr_->cts_offset;
+}
+
+TimeDelta TrackRunIterator::duration() const {
+  DCHECK(SampleValid());
+  return sample_itr_->duration;
+}
+
+bool TrackRunIterator::is_keyframe() const {
+  DCHECK(SampleValid());
+  return sample_itr_->is_keyframe;
+}
+
+const FrameCENCInfo& TrackRunIterator::frame_cenc_info() {
+  DCHECK(is_encrypted());
+  return frame_cenc_info_;
+}
+
+}  // namespace mp4
+}  // namespace media