Revert 142268 - Implement ISO BMFF support in Media Source.

BUG=129072
TEST=MP4StreamParserTest


Review URL: https://chromiumcodereview.appspot.com/10536014

TBR=strobe@google.com
Review URL: https://chromiumcodereview.appspot.com/10533164

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@142283 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 0 insertions, 262 deletions

diff --git a/media/mp4/track_run_iterator.cc b/media/mp4/track_run_iterator.cc
deleted file mode 100644
index 440ea06..0000000
--- a/media/mp4/track_run_iterator.cc
+++ /dev/null
@@ -1,262 +0,0 @@
-// 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/base/stream_parser_buffer.h"
-#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);
-}
-
-static const uint32 kSampleIsDifferenceSampleFlagMask = 0x10000;
-
-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 (http://crbug.com/132351)
-
-      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;
-  ++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;
-}
-
-TimeDelta TrackRunIterator::GetMinDecodeTimestamp() {
-  TimeDelta dts = kInfiniteDuration();
-  for (size_t i = 0; i < runs_.size(); i++) {
-    if (runs_[i].start_dts < dts)
-      dts = runs_[i].start_dts;
-  }
-  return dts;
-}
-
-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