MP4 support for Common Encryption 'cbcs' scheme.

media/formats/mp4/track_run_iterator.cc

 // Copyright 2014 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/formats/mp4/track_run_iterator.h"
 
 #include <algorithm>
 #include <iomanip>
 #include <limits>
 #include <memory>
 
 #include "base/macros.h"
 #include "media/formats/mp4/rcheck.h"
 #include "media/formats/mp4/sample_to_group_iterator.h"
+#include "media/media_features.h"
 
 namespace media {
 namespace mp4 {
 
 struct SampleInfo {
   int size;
   int duration;
   int cts_offset;
   bool is_keyframe;
   uint32_t cenc_group_description_index;
@@ skipping 182 matching lines @@
       SampleToGroupEntry::kFragmentGroupDescriptionIndexBase) {
     group_description_index -=
         SampleToGroupEntry::kFragmentGroupDescriptionIndexBase;
     entries = &run_info.fragment_sample_encryption_info;
   } else {
     entries = &run_info.track_sample_encryption_group->entries;
   }
 
   // |group_description_index| is 1-based.
   DCHECK_LE(group_description_index, entries->size());
   return (group_description_index > entries->size())

[ddorwin, 2016/11/06 00:57:51]

This duplicated logic is not immediately clear. Can we change this to an if
statement that NOTREACHED() and returns nullptr followed by returning the happy
path value?
Maybe do this in a ceparate CL.

[dougsteed, 2016/12/01 19:45:32]

Separate CL sounds good. However I don't think this should be a DCHECK, since I
don't see where the range of a value parsed from the stream is checked, and we
shouldn't be DCHECKing based on untrusted input. Probably should just remove the
DCHECK or replace with RCHECK.

              ? nullptr
              : &(*entries)[group_description_index - 1];
 }
 
 // In well-structured encrypted media, each track run will be immediately
 // preceded by its auxiliary information; this is the only optimal storage
 // pattern in terms of minimum number of bytes from a serial stream needed to
 // begin playback. It also allows us to optimize caching on memory-constrained
 // architectures, because we can cache the relatively small auxiliary
 // information for an entire run and then discard data from the input stream,
@@ skipping 88 matching lines @@
       TrackRunInfo tri;
       tri.track_id = traf.header.track_id;
       tri.timescale = trak->media.header.timescale;
       tri.start_dts = run_start_dts;
       tri.sample_start_offset = trun.data_offset;
       tri.track_sample_encryption_group =
           &trak->media.information.sample_table.sample_group_description;
       tri.fragment_sample_encryption_info =
           traf.sample_group_description.entries;
 
-      uint8_t default_iv_size = 0;
+      const TrackEncryption* track_encryption;
       tri.is_audio = (stsd.type == kAudio);
       if (tri.is_audio) {
         RCHECK(!stsd.audio_entries.empty());
         if (desc_idx > stsd.audio_entries.size())
           desc_idx = 0;
         tri.audio_description = &stsd.audio_entries[desc_idx];
-        default_iv_size =
-            tri.audio_description->sinf.info.track_encryption.default_iv_size;
+        track_encryption = &tri.audio_description->sinf.info.track_encryption;
       } else {
         RCHECK(!stsd.video_entries.empty());
         if (desc_idx > stsd.video_entries.size())
           desc_idx = 0;
         tri.video_description = &stsd.video_entries[desc_idx];
-        default_iv_size =
-            tri.video_description->sinf.info.track_encryption.default_iv_size;
+        track_encryption = &tri.video_description->sinf.info.track_encryption;
       }
-
       // Initialize aux_info variables only if no sample encryption entries.
       if (sample_encryption_entries_count == 0 &&
           traf.auxiliary_offset.offsets.size() > j) {
         // Collect information from the auxiliary_offset entry with the same
         // index in the 'saiz' container as the current run's index in the
         // 'trun' container, if it is present.
         // There should be an auxiliary info entry corresponding to each sample
         // in the auxiliary offset entry's corresponding track run.
         RCHECK(traf.auxiliary_size.sample_count >=
                sample_count_sum + trun.sample_count);
@@ skipping 47 matching lines @@
         if (index != 0)
           RCHECK(GetSampleEncryptionInfoEntry(tri, index));
         is_sample_to_group_valid = sample_to_group_itr.Advance();
       }
       if (sample_encryption_entries_count > 0) {
         RCHECK(sample_encryption_entries_count >=
                sample_count_sum + trun.sample_count);
         tri.sample_encryption_entries.resize(trun.sample_count);
         for (size_t k = 0; k < trun.sample_count; k++) {
           uint32_t index = tri.samples[k].cenc_group_description_index;
-          const uint8_t iv_size =
-              index == 0 ? default_iv_size
-                         : GetSampleEncryptionInfoEntry(tri, index)->iv_size;
-          RCHECK(tri.sample_encryption_entries[k].Parse(
-              sample_encryption_reader.get(), iv_size,
-              traf.sample_encryption.use_subsample_encryption));
+          const CencSampleEncryptionInfoEntry* info_entry =
+              index == 0 ? nullptr : GetSampleEncryptionInfoEntry(tri, index);
+          const uint8_t iv_size = index == 0 ? track_encryption->default_iv_size
+                                             : info_entry->iv_size;
+          SampleEncryptionEntry& entry = tri.sample_encryption_entries[k];
+          RCHECK(entry.Parse(sample_encryption_reader.get(), iv_size,
+                             traf.sample_encryption.use_subsample_encryption));
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
+          // If we don't have a per-sample IV, get the constant IV.
+          bool is_encrypted = index == 0 ? track_encryption->is_encrypted
+                                         : info_entry->is_encrypted;
+          // We only support setting the pattern values in the 'tenc' box for
+          // the track (not varying on per sample group basis).
+          // Thus we need to verify that the settings in the sample group match
+          // those in the 'tenc'.
+          if (is_encrypted && index != 0) {
+            RCHECK(info_entry->crypt_byte_block ==
+                   track_encryption->default_crypt_byte_block);
+            RCHECK(info_entry->skip_byte_block ==
+                   track_encryption->default_skip_byte_block);
+          }
+          if (is_encrypted && !iv_size) {
+            const uint8_t constant_iv_size =
+                index == 0 ? track_encryption->default_constant_iv_size
+                           : info_entry->constant_iv_size;
+            RCHECK(constant_iv_size != 0);
+            const uint8_t* constant_iv =
+                index == 0 ? track_encryption->default_constant_iv
+                           : info_entry->constant_iv;
+            memcpy(entry.initialization_vector, constant_iv, constant_iv_size);
+          }
+#endif
         }
       }
       runs_.push_back(tri);
       sample_count_sum += trun.sample_count;
     }
 
     // We should have iterated through all samples in SampleToGroup Box.
     RCHECK(!sample_to_group_itr.IsValid());
   }
 
@@ skipping 40 matching lines @@
   int64_t 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];
 
     if (IsSampleEncrypted(i)) {
       BufferReader reader(buf + pos, info_size);
       const uint8_t iv_size = GetIvSize(i);
       const bool has_subsamples = info_size > iv_size;
-      RCHECK(
-          sample_encryption_entries[i].Parse(&reader, iv_size, has_subsamples));
+      SampleEncryptionEntry& entry = sample_encryption_entries[i];
+      RCHECK(entry.Parse(&reader, iv_size, has_subsamples));
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
+      // if we don't have a per-sample IV, get the constant IV.
+      if (!iv_size) {
+        RCHECK(ApplyConstantIv(i, &entry));
+      }
+#endif
     }
     pos += info_size;
   }
 
   return true;
 }
 
 bool TrackRunIterator::IsRunValid() const {
   return run_itr_ != runs_.end();
 }
@@ skipping 96 matching lines @@
 }
 
 const TrackEncryption& TrackRunIterator::track_encryption() const {
   if (is_audio())
     return audio_description().sinf.info.track_encryption;
   return video_description().sinf.info.track_encryption;
 }
 
 std::unique_ptr<DecryptConfig> TrackRunIterator::GetDecryptConfig() {
   DCHECK(is_encrypted());
+  size_t sample_idx = sample_itr_ - run_itr_->samples.begin();
+  const std::vector<uint8_t>& kid = GetKeyId(sample_idx);
 
   if (run_itr_->sample_encryption_entries.empty()) {
     DCHECK_EQ(0, aux_info_size());
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
+    // The 'cbcs' scheme allows empty aux info when a constant IV is in use
+    // with full sample encryption. That case will fall through to here.
+    SampleEncryptionEntry sample_encryption_entry;
+    if (ApplyConstantIv(sample_idx, &sample_encryption_entry)) {
+      return std::unique_ptr<DecryptConfig>(new DecryptConfig(
+          std::string(reinterpret_cast<const char*>(&kid[0]), kid.size()),
+          std::string(reinterpret_cast<const char*>(
+                          sample_encryption_entry.initialization_vector),
+                      arraysize(sample_encryption_entry.initialization_vector)),
+          sample_encryption_entry.subsamples));
+    }
+#endif
     MEDIA_LOG(ERROR, media_log_) << "Sample encryption info is not available.";
     return std::unique_ptr<DecryptConfig>();
   }
 
-  size_t sample_idx = sample_itr_ - run_itr_->samples.begin();
   DCHECK_LT(sample_idx, run_itr_->sample_encryption_entries.size());
   const SampleEncryptionEntry& sample_encryption_entry =
       run_itr_->sample_encryption_entries[sample_idx];
 
   size_t total_size = 0;
   if (!sample_encryption_entry.subsamples.empty() &&
       (!sample_encryption_entry.GetTotalSizeOfSubsamples(&total_size) ||
        total_size != static_cast<size_t>(sample_size()))) {
     MEDIA_LOG(ERROR, media_log_) << "Incorrect CENC subsample size.";
     return std::unique_ptr<DecryptConfig>();
   }
 
-  const std::vector<uint8_t>& kid = GetKeyId(sample_idx);
   return std::unique_ptr<DecryptConfig>(new DecryptConfig(
       std::string(reinterpret_cast<const char*>(&kid[0]), kid.size()),
       std::string(reinterpret_cast<const char*>(
                       sample_encryption_entry.initialization_vector),
                   arraysize(sample_encryption_entry.initialization_vector)),
       sample_encryption_entry.subsamples));
 }
 
 uint32_t TrackRunIterator::GetGroupDescriptionIndex(
     uint32_t sample_index) const {
@@ skipping 15 matching lines @@
   return (index == 0) ? track_encryption().default_kid
                       : GetSampleEncryptionInfoEntry(*run_itr_, index)->key_id;
 }
 
 uint8_t TrackRunIterator::GetIvSize(size_t sample_index) const {
   uint32_t index = GetGroupDescriptionIndex(sample_index);
   return (index == 0) ? track_encryption().default_iv_size
                       : GetSampleEncryptionInfoEntry(*run_itr_, index)->iv_size;
 }
 
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
+bool TrackRunIterator::ApplyConstantIv(size_t sample_index,
+                                       SampleEncryptionEntry* entry) const {
+  if (!IsSampleEncrypted(sample_index))
+    return true;

[ddorwin, 2016/11/06 00:57:51]

Explain why? Or should we never get here, in which case this should be a DCHECK.

[dougsteed, 2016/12/01 19:45:32]

Done.

+  uint32_t index = GetGroupDescriptionIndex(sample_index);
+  const uint8_t constant_iv_size =
+      index == 0
+          ? track_encryption().default_constant_iv_size
+          : GetSampleEncryptionInfoEntry(*run_itr_, index)->constant_iv_size;
+  RCHECK(constant_iv_size != 0);
+  const uint8_t* constant_iv =
+      index == 0 ? track_encryption().default_constant_iv
+                 : GetSampleEncryptionInfoEntry(*run_itr_, index)->constant_iv;
+  RCHECK(constant_iv != nullptr);
+  memcpy(entry->initialization_vector, constant_iv, kInitializationVectorSize);
+  return true;
+}
+#endif
+
 }  // namespace mp4
 }  // namespace media