Add Common Encryption support to BMFF, including subsample decryption.

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/base/stream_parser_buffer.h"
 #include "media/mp4/rcheck.h"
 
 namespace media {
 namespace mp4 {
 
 base::TimeDelta TimeDeltaFromFrac(int64 numer, uint64 denom) {
   DCHECK_LT((numer > 0 ? numer : -numer),
             kint64max / base::Time::kMicrosecondsPerSecond);
   return base::TimeDelta::FromMicroseconds(
         base::Time::kMicrosecondsPerSecond * numer / denom);
 }
 
 static const uint32 kSampleIsDifferenceSampleFlagMask = 0x10000;
 
 TrackRunInfo::TrackRunInfo()
     : track_id(0),
       sample_start_offset(-1),
-      is_encrypted(false),
-      cenc_start_offset(-1),
-      cenc_total_size(-1),
-      default_cenc_size(0) {}
+      aux_info_start_offset(-1),
+      aux_info_default_size(-1),
+      aux_info_total_size(-1) {
+}
 
 TrackRunInfo::~TrackRunInfo() {}
 
 TrackRunIterator::TrackRunIterator() : sample_offset_(0) {}
 TrackRunIterator::~TrackRunIterator() {}
 
 static void PopulateSampleInfo(const Track& trak,
                                const TrackExtends& trex,
                                const TrackFragmentHeader& tfhd,
                                const TrackFragmentRun& trun,
@@ skipping 29 matching lines @@
   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 {

[ddorwin, 2012/06/26 06:09:19]

This seems to compare specific types of offsets. Is there a better name?

[ddorwin, 2012/07/03 21:03:46]

Ping.

[strobe_, 2012/07/13 00:47:07]

Done.

  public:
   bool operator()(const TrackRunInfo& a, const 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;
+    if (a.aux_info_total_size > 0 && a.aux_info_start_offset < a_min)

[ddorwin, 2012/06/26 06:09:19]

The .h comment seems to say is_encrypted and aux info required are orthogonal.
Here, you have replaced the former with aux_info presence, which appears to
contradict that.

Reading below, I learn that CENC is aux info. (Continued below.)

[strobe_, 2012/06/27 02:01:21]

Hopefully addressed by renames.

+      a_min = a.aux_info_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;
+    if (b.aux_info_total_size > 0 && b.aux_info_start_offset < b_min)
+      b_min = b.aux_info_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];
 
@@ skipping 15 matching lines @@
         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;
     }
 
-    if (sinf->info.track_encryption.is_encrypted) {
-      // TODO(strobe): CENC recovery and testing (http://crbug.com/132351)
-      DVLOG(1) << "Encrypted tracks not handled";
-      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 = false;
-      tri.cenc_start_offset = 0;
-      tri.cenc_total_size = 0;
-      tri.default_cenc_size = 0;
+      if (traf.auxiliary_offset.offsets.size() > j) {

[ddorwin, 2012/06/26 06:09:19]

What? How is an iterator related to some other collection?

[strobe_, 2012/06/27 02:01:21]

Done.

+        RCHECK(traf.auxiliary_size.sample_count == trun.sample_count);

[ddorwin, 2012/06/26 06:09:19]

I have no idea what the rest of this code is doing. It's definitely worth a
comment.

[strobe_, 2012/06/27 02:01:21]

Done.

+        tri.aux_info_start_offset = traf.auxiliary_offset.offsets[j];
+        tri.aux_info_default_size =
+            traf.auxiliary_size.default_sample_info_size;
+        tri.aux_info_sizes = traf.auxiliary_size.sample_info_sizes;
+        if (tri.aux_info_default_size) {
+          tri.aux_info_total_size =
+              tri.aux_info_default_size * trun.sample_count;
+        } else {
+          tri.aux_info_total_size = 0;
+          for (size_t k = 0; k < trun.sample_count; k++) {
+            tri.aux_info_total_size += tri.aux_info_sizes[k];
+          }
+        }
+      } else {
+        tri.aux_info_start_offset = 0;
+        tri.aux_info_total_size = 0;
+      }
+      tri.track_encryption = sinf->info.track_encryption;
 
       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();
+  cenc_info_.clear();
 }
 
 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::AuxInfoRequired() {

[ddorwin, 2012/06/26 06:09:19]

What does this function really mean? "Need to read aux info"?
The comment for GetDecryptConfig() and logic below seem to imply something more
than the simple name.

[strobe_, 2012/06/27 02:01:21]

Hopefully addressed by rename.

+  DCHECK(RunValid());
+  // The only kind of aux info that we handle is CENC info, so we only cache it

[ddorwin, 2012/06/26 06:09:19]

Seems like a function-level comment.

[strobe_, 2012/06/27 02:01:21]

Done.

+  // if encryption is active
+  return is_encrypted() && aux_info_size() > 0 && cenc_info_.size() == 0;
 }
 
-bool TrackRunIterator::CacheCENC(const uint8* buf, int size) {
-  LOG(FATAL) << "Not implemented";
-  return false;
+bool TrackRunIterator::CacheAuxInfo(const uint8* buf, int size) {

[ddorwin, 2012/06/26 06:09:19]

buf_size would make this easier to read.

[ddorwin, 2012/06/26 06:09:19]

Add a function-level comment that this only caches CENC.

[strobe_, 2012/06/27 02:01:21]

Done.

[strobe_, 2012/06/27 02:01:21]

Done.

+  RCHECK(AuxInfoRequired() && size >= aux_info_size());

[ddorwin, 2012/06/26 06:09:19]

Nothing in the loop below verifies that we don't go beyond these values. There
should be some type of check or we might allow a buffer overrun.

[strobe_, 2012/06/27 02:01:21]

As noted below, the RCHECK() does this.

+
+  cenc_info_.resize(run_itr_->samples.size());
+  int64 pos = 0;
+  for (size_t i = 0; i < run_itr_->samples.size(); i++) {
+    int info_size = run_itr_->aux_info_default_size;
+    if (!info_size)
+      info_size = run_itr_->aux_info_sizes[i];
+
+    BufferReader reader(buf + pos, info_size);
+    RCHECK(cenc_info_[i].Parse(run_itr_->track_encryption.default_iv_size,

[ddorwin, 2012/06/26 06:09:19]

does something verify we don't exceed info_size (parameter to reader's
construction) in this Parse?

[strobe_, 2012/06/27 02:01:21]

Yes, if a request would read past the given size, the parse function immediately
returns false, which is caught by the RCHECK() (which immediately returns false
to the caller, etc, etc).

[ddorwin, 2012/07/03 21:03:46]

We should have tests for this.

+                               &reader));
+    pos += info_size;
+  }
+
+  return true;
 }
 
 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 (AuxInfoRequired()) {
+      offset = std::min(offset, aux_info_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;
+  return run_itr_->track_encryption.is_encrypted;
 }
 
-int64 TrackRunIterator::cenc_offset() const {
-  DCHECK(is_encrypted());
-  return run_itr_->cenc_start_offset;
+int64 TrackRunIterator::aux_info_offset() const {
+  return run_itr_->aux_info_start_offset;
 }
 
-int TrackRunIterator::cenc_size() const {
-  DCHECK(is_encrypted());
-  return run_itr_->cenc_total_size;
+int TrackRunIterator::aux_info_size() const {
+  return run_itr_->aux_info_total_size;
 }
 
 int64 TrackRunIterator::offset() const {
   DCHECK(SampleValid());
   return sample_offset_;
 }
 
 int TrackRunIterator::size() const {
   DCHECK(SampleValid());
   return sample_itr_->size;
@@ skipping 12 matching lines @@
 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_;
+scoped_ptr<DecryptConfig> TrackRunIterator::GetDecryptConfig() {

[ddorwin, 2012/06/26 06:09:19]

What tests do we have for this? :)

[strobe_, 2012/06/27 02:01:21]

Yeah, this whole class needs a big ol' test. On sky-is-falling Thursday, I was
hoping to defer that until we could get more time, but since our external
deadlines are slipped I'm content waiting until we have a moment to finish that
up before landing this patch.

+  const FrameCENCInfo& cenc_info =
+      cenc_info_[sample_itr_ - run_itr_->samples.begin()];

[ddorwin, 2012/06/26 06:09:19]

What is this math doing?

[strobe_, 2012/06/27 02:01:21]

Retrieves the index of the sample to which sample_itr_ is currently pointing.

[ddorwin, 2012/07/03 21:03:46]

Since it's already two lines, an index temp variable might be helpful in
explaining this with code.

[strobe_, 2012/07/13 00:47:07]

Done.

+  DCHECK(is_encrypted() && !AuxInfoRequired());
+
+  if (!cenc_info.subsamples.empty() &&
+      (cenc_info.GetTotalSize() != static_cast<size_t>(size()))) {

[ddorwin, 2012/06/26 06:09:19]

It's unclear how these are related.

[strobe_, 2012/06/27 02:01:21]

Hopefully renames make this clearer.

+    DVLOG(1) << "Incorrect CENC subsample size.";
+    return scoped_ptr<DecryptConfig>();
+  }
+
+  return scoped_ptr<DecryptConfig>(new DecryptConfig(
+      &run_itr_->track_encryption.default_kid[0],

[ddorwin, 2012/06/26 06:09:19]

Does this code not support sample groups?

[strobe_, 2012/06/27 02:01:21]

Correct, it does not. The restricted BMFF format used by DASH/Media Source
requires that only track runs be used.

[ddorwin, 2012/07/03 21:03:46]

We should document this somewhere.

[strobe_, 2012/07/13 00:47:07]

Expanded comment in mp4/box_definitions.h.

+      run_itr_->track_encryption.default_kid.size(),
+      cenc_info.iv, sizeof(cenc_info.iv),

[ddorwin, 2012/06/26 06:09:19]

iv is a fixed size now, so you'l always send 16 but the whole value was not
initialized.

[strobe_, 2012/06/27 02:01:21]

According to the CENC spec, an 8-byte IV shall be expanded to be 16 bytes with
the less-significant 8 bytes filled with zeros, which is performed in
FrameCENCInfo::Parse().

+      &cenc_info.subsamples[0], cenc_info.subsamples.size()));
 }
 
 }  // namespace mp4
 }  // namespace media