MP4 support for Common Encryption 'cbcs' scheme.

media/formats/mp4/box_definitions.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/box_definitions.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/video_types.h"
 #include "media/base/video_util.h"
 #include "media/formats/mp4/avc.h"
 #include "media/formats/mp4/es_descriptor.h"
 #include "media/formats/mp4/rcheck.h"
 #include "media/media_features.h"
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
 #include "media/formats/mp4/hevc.h"
 #endif
 
 namespace media {
 namespace mp4 {
 
+namespace {
+
+const size_t kKeyIdSize = 16;
+
+}  // namespace
+
 FileType::FileType() {}
 FileType::FileType(const FileType& other) = default;
 FileType::~FileType() {}
 FourCC FileType::BoxType() const { return FOURCC_FTYP; }
 
 bool FileType::Parse(BoxReader* reader) {
   RCHECK(reader->ReadFourCC(&major_brand) && reader->Read4(&minor_version));
   size_t num_brands = (reader->size() - reader->pos()) / sizeof(FourCC);
   return reader->SkipBytes(sizeof(FourCC) * num_brands);  // compatible_brands
 }
@@ skipping 114 matching lines @@
 
 SampleEncryptionEntry::SampleEncryptionEntry() {}
 SampleEncryptionEntry::SampleEncryptionEntry(
     const SampleEncryptionEntry& other) = default;
 SampleEncryptionEntry::~SampleEncryptionEntry() {}
 
 bool SampleEncryptionEntry::Parse(BufferReader* reader,
                                   uint8_t iv_size,
                                   bool has_subsamples) {
   // According to ISO/IEC FDIS 23001-7: CENC spec, IV should be either
-  // 64-bit (8-byte) or 128-bit (16-byte).
-  RCHECK(iv_size == 8 || iv_size == 16);
+  // 64-bit (8-byte) or 128-bit (16-byte). Subsequent editions allow |iv_size|

[ddorwin, 2016/06/17 23:32:40]

nit: It would be nice to specify which edition added this.

[dougsteed, 2016/10/10 18:18:01]

Done.

+  // to be 0, for the case of a "constant IV". In this case, the existence of
+  // the constant IV must be ensured by the caller.

[ddorwin, 2016/06/17 23:32:40]

Do you mean the caller of this function? I assume that is implemented in this
CL. Is that line 273?

[dougsteed, 2016/10/10 18:18:01]

Actually it's in track_run_iterator.cc, line 502.

+  RCHECK(iv_size == 0 || iv_size == 8 || iv_size == 16);
 
   memset(initialization_vector, 0, sizeof(initialization_vector));
   for (uint8_t i = 0; i < iv_size; i++)
     RCHECK(reader->Read1(initialization_vector + i));
 
   if (!has_subsamples) {
     subsamples.clear();
     return true;
   }
 
@@ skipping 53 matching lines @@
 FourCC SchemeType::BoxType() const { return FOURCC_SCHM; }
 
 bool SchemeType::Parse(BoxReader* reader) {
   RCHECK(reader->ReadFullBoxHeader() &&
          reader->ReadFourCC(&type) &&
          reader->Read4(&version));
   return true;
 }
 
 TrackEncryption::TrackEncryption()
-  : is_encrypted(false), default_iv_size(0) {
+    : is_encrypted(false),
+      default_iv_size(0)
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
+      ,
+      default_crypt_byte_block(0),
+      default_skip_byte_block(0),
+      default_constant_iv_size(0)
+#endif
+{
 }
 TrackEncryption::TrackEncryption(const TrackEncryption& other) = default;
 TrackEncryption::~TrackEncryption() {}
 FourCC TrackEncryption::BoxType() const { return FOURCC_TENC; }
 
 bool TrackEncryption::Parse(BoxReader* reader) {
   uint8_t flag;
-  RCHECK(reader->ReadFullBoxHeader() &&
-         reader->SkipBytes(2) &&
-         reader->Read1(&flag) &&
+  uint8_t possible_pattern_info;
+  RCHECK(reader->ReadFullBoxHeader() && reader->SkipBytes(1) &&

[ddorwin, 2016/06/17 23:32:40]

What is being skipped? Should we document this?

[dougsteed, 2016/10/10 18:18:01]

A reserved byte.

+         reader->Read1(&possible_pattern_info) && reader->Read1(&flag) &&

[ddorwin, 2016/06/17 23:32:40]

Did they use reserved bits or something? Why is this just possible?

[dougsteed, 2016/10/10 18:18:01]

Yes. There were two reserved bytes. They reassigned the second one to be the
pattern, but only if the isProtected flag is set, and only if the version is 1
or greater. I named it "possible" because the value is read before it is known
whether it is to be interpreted as pattern info or not (it may turn out to be
skipped).

          reader->Read1(&default_iv_size) &&
-         reader->ReadVec(&default_kid, 16));
+         reader->ReadVec(&default_kid, kKeyIdSize));
   is_encrypted = (flag != 0);
-  if (is_encrypted) {
+  if (default_iv_size != 0) {
     RCHECK(default_iv_size == 8 || default_iv_size == 16);
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)

[ddorwin, 2016/06/17 23:32:40]

Should this be inside the else if - with a #else that causes this to fail? I
guess line 280 covers this, but (as with the comments below) it might be easier
to understand other ways / the way it was.

[dougsteed, 2016/10/10 18:18:01]

I agree. It was unclear. Rearranged it a bit to (hopefully) improve clarity.

+  } else if (is_encrypted) {

[ddorwin, 2016/06/17 23:32:40]

What is the relationship between this block and default_iv_size? For CBCS  is it
0?

It seems it would be easier to understand if the IV size check was inside
is_encrypted even though that might be more logic.

Also, this block only applies to cbcs, but do we already know we are using cbcs?
If not, it seems we should have something like:
  if (foo) {
    // Must be 'cbcs' (or must be a skip scheme).

[dougsteed, 2016/10/10 18:18:01]

see above.

+    if (reader->version() > 0) {
+      default_crypt_byte_block = (possible_pattern_info >> 4) & 0x0f;
+      default_skip_byte_block = possible_pattern_info & 0x0f;
+    }
+    RCHECK(reader->Read1(&default_constant_iv_size) &&
+           (default_constant_iv_size == 8 || default_constant_iv_size == 16));
+    memset(default_constant_iv, 0, sizeof(default_constant_iv));
+    for (uint8_t i = 0; i < default_constant_iv_size; i++)
+      RCHECK(reader->Read1(default_constant_iv + i));
+#endif
   } else {
-    RCHECK(default_iv_size == 0);
+    RCHECK(!is_encrypted);
   }
   return true;
 }
 
 SchemeInfo::SchemeInfo() {}
 SchemeInfo::SchemeInfo(const SchemeInfo& other) = default;
 SchemeInfo::~SchemeInfo() {}
 FourCC SchemeInfo::BoxType() const { return FOURCC_SCHI; }
 
 bool SchemeInfo::Parse(BoxReader* reader) {
   return reader->ScanChildren() && reader->ReadChild(&track_encryption);
 }
 
 ProtectionSchemeInfo::ProtectionSchemeInfo() {}
 ProtectionSchemeInfo::ProtectionSchemeInfo(const ProtectionSchemeInfo& other) =
     default;
 ProtectionSchemeInfo::~ProtectionSchemeInfo() {}
 FourCC ProtectionSchemeInfo::BoxType() const { return FOURCC_SINF; }
 
 bool ProtectionSchemeInfo::Parse(BoxReader* reader) {
   RCHECK(reader->ScanChildren() &&
          reader->ReadChild(&format) &&
          reader->ReadChild(&type));
-  if (type.type == FOURCC_CENC)
+  if (HasSupportedScheme())
     RCHECK(reader->ReadChild(&info));
   // Other protection schemes are silently ignored. Since the protection scheme
   // type can't be determined until this box is opened, we return 'true' for
   // non-CENC protection scheme types. It is the parent box's responsibility to
   // ensure that this scheme type is a supported one.
   return true;
 }
 
+bool ProtectionSchemeInfo::HasSupportedScheme() const {
+  FourCC fourCC = type.type;
+  if (fourCC == FOURCC_CENC)
+    return true;
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
+  return fourCC == FOURCC_CBCS;

[ddorwin, 2016/06/17 23:32:40]

nit: If you follow the style for CENC, you don't need #else and at least the
return false; is always compiled.

[dougsteed, 2016/10/10 18:18:01]

Done.

+#else
+  return false;
+#endif
+}
+
 MovieHeader::MovieHeader()
     : creation_time(0),
       modification_time(0),
       timescale(0),
       duration(0),
       rate(-1),
       volume(-1),
       next_track_id(0) {}
 MovieHeader::MovieHeader(const MovieHeader& other) = default;
 MovieHeader::~MovieHeader() {}
@@ skipping 307 matching lines @@
          reader->Read2(&width) &&
          reader->Read2(&height) &&
          reader->SkipBytes(50));
 
   RCHECK(reader->ScanChildren() &&
          reader->MaybeReadChild(&pixel_aspect));
 
   if (format == FOURCC_ENCV) {
     // Continue scanning until a recognized protection scheme is found, or until
     // we run out of protection schemes.
-    while (sinf.type.type != FOURCC_CENC) {
+    while (!sinf.HasSupportedScheme()) {
       if (!reader->ReadChild(&sinf))
         return false;
     }
   }
 
   const FourCC actual_format =
       format == FOURCC_ENCV ? sinf.format.format : format;
   switch (actual_format) {
     case FOURCC_AVC1:
     case FOURCC_AVC3: {
@@ skipping 119 matching lines @@
          reader->Read2(&samplesize) &&
          reader->SkipBytes(4) &&
          reader->Read4(&samplerate));
   // Convert from 16.16 fixed point to integer
   samplerate >>= 16;
 
   RCHECK(reader->ScanChildren());
   if (format == FOURCC_ENCA) {
     // Continue scanning until a recognized protection scheme is found, or until
     // we run out of protection schemes.
-    while (sinf.type.type != FOURCC_CENC) {
+    while (!sinf.HasSupportedScheme()) {
       if (!reader->ReadChild(&sinf))
         return false;
     }
   }
 
   // ESDS is not valid in case of EAC3.
   RCHECK(reader->MaybeReadChild(&esds));
   return true;
 }
 
@@ skipping 319 matching lines @@
   RCHECK(reader->Read4(&count));
   entries.resize(count);
   for (uint32_t i = 0; i < count; ++i) {
     RCHECK(reader->Read4(&entries[i].sample_count) &&
            reader->Read4(&entries[i].group_description_index));
   }
   return true;
 }
 
 CencSampleEncryptionInfoEntry::CencSampleEncryptionInfoEntry()
-    : is_encrypted(false), iv_size(0) {}
+    : is_encrypted(false),
+      iv_size(0)
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
+      ,
+      crypt_byte_block(0),
+      skip_byte_block(0),
+      constant_iv_size(0)
+#endif
+{
+}
 CencSampleEncryptionInfoEntry::CencSampleEncryptionInfoEntry(
     const CencSampleEncryptionInfoEntry& other) = default;
 CencSampleEncryptionInfoEntry::~CencSampleEncryptionInfoEntry() {}
 
+bool CencSampleEncryptionInfoEntry::Parse(BoxReader* reader) {
+  uint8_t flag;
+  uint8_t possible_pattern_info;
+  RCHECK(reader->SkipBytes(1) &&  // reserved.
+         reader->Read1(&possible_pattern_info) && reader->Read1(&flag) &&
+         reader->Read1(&iv_size) && reader->ReadVec(&key_id, kKeyIdSize));
+
+  is_encrypted = (flag != 0);
+  if (iv_size != 0) {

[ddorwin, 2016/06/17 23:32:40]

ditto on structure
note to self: I skipped this.

[dougsteed, 2016/10/10 18:18:01]

Done.

+    RCHECK(iv_size == 8 || iv_size == 16);
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
+  } else if (is_encrypted) {
+    crypt_byte_block = (possible_pattern_info >> 4) & 0x0f;
+    skip_byte_block = possible_pattern_info & 0x0f;
+    RCHECK(reader->Read1(&constant_iv_size) &&
+           (constant_iv_size == 8 || constant_iv_size == 16));
+    memset(constant_iv, 0, sizeof(constant_iv));
+    for (uint8_t i = 0; i < constant_iv_size; i++)
+      RCHECK(reader->Read1(constant_iv + i));
+#endif
+  } else {
+    RCHECK(!is_encrypted);
+  }
+  return true;
+}
+
 SampleGroupDescription::SampleGroupDescription() : grouping_type(0) {}
 SampleGroupDescription::SampleGroupDescription(
     const SampleGroupDescription& other) = default;
 SampleGroupDescription::~SampleGroupDescription() {}
 FourCC SampleGroupDescription::BoxType() const { return FOURCC_SGPD; }
 
 bool SampleGroupDescription::Parse(BoxReader* reader) {
   RCHECK(reader->ReadFullBoxHeader() &&
          reader->Read4(&grouping_type));
 
   if (grouping_type != FOURCC_SEIG) {
     DLOG(WARNING) << "SampleGroupDescription box with grouping_type '"
                   << grouping_type << "' is not supported.";
     return true;
   }
 
   const uint8_t version = reader->version();
 
-  const size_t kKeyIdSize = 16;
   const size_t kEntrySize = sizeof(uint32_t) + kKeyIdSize;
   uint32_t default_length = 0;
   if (version == 1) {
       RCHECK(reader->Read4(&default_length));
       RCHECK(default_length == 0 || default_length >= kEntrySize);
   }
 
   uint32_t count;
   RCHECK(reader->Read4(&count));
   entries.resize(count);
   for (uint32_t i = 0; i < count; ++i) {
     if (version == 1) {
       if (default_length == 0) {
         uint32_t description_length = 0;
         RCHECK(reader->Read4(&description_length));
         RCHECK(description_length >= kEntrySize);
       }
     }
-
-    uint8_t flag;
-    RCHECK(reader->SkipBytes(2) &&  // reserved.
-           reader->Read1(&flag) &&
-           reader->Read1(&entries[i].iv_size) &&
-           reader->ReadVec(&entries[i].key_id, kKeyIdSize));
-
-    entries[i].is_encrypted = (flag != 0);
-    if (entries[i].is_encrypted) {
-      RCHECK(entries[i].iv_size == 8 || entries[i].iv_size == 16);
-    } else {
-      RCHECK(entries[i].iv_size == 0);
-    }
+    RCHECK(entries[i].Parse(reader));
   }
   return true;
 }
 
 TrackFragment::TrackFragment() {}
 TrackFragment::TrackFragment(const TrackFragment& other) = default;
 TrackFragment::~TrackFragment() {}
 FourCC TrackFragment::BoxType() const { return FOURCC_TRAF; }
 
 bool TrackFragment::Parse(BoxReader* reader) {
-  RCHECK(reader->ScanChildren() &&
-         reader->ReadChild(&header) &&
+  RCHECK(reader->ScanChildren() && reader->ReadChild(&header) &&
          // Media Source specific: 'tfdt' required
-         reader->ReadChild(&decode_time) &&
-         reader->MaybeReadChildren(&runs) &&
+         reader->ReadChild(&decode_time) && reader->MaybeReadChildren(&runs) &&
          reader->MaybeReadChild(&auxiliary_offset) &&
          reader->MaybeReadChild(&auxiliary_size) &&
-         reader->MaybeReadChild(&sdtp));
+         reader->MaybeReadChild(&sdtp) &&
+         reader->MaybeReadChild(&sample_encryption));

[ddorwin, 2016/06/17 23:32:40]

Was this missed in a previous CL?

[dougsteed, 2016/10/10 18:18:01]

It looks like this box was added in the 2nd Edition (at least it is not
mentioned in the 1st Edition). 

 
   // There could be multiple SampleGroupDescription and SampleToGroup boxes with
   // different grouping types. For common encryption, the relevant grouping type
   // is 'seig'. Continue reading until 'seig' is found, or until running out of
   // child boxes.
   while (reader->HasChild(&sample_group_description)) {
     RCHECK(reader->ReadChild(&sample_group_description));
     if (sample_group_description.grouping_type == FOURCC_SEIG)
       break;
     sample_group_description.entries.clear();
@@ skipping 49 matching lines @@
 SampleDependsOn IndependentAndDisposableSamples::sample_depends_on(
     size_t i) const {
   if (i >= sample_depends_on_.size())
     return kSampleDependsOnUnknown;
 
   return sample_depends_on_[i];
 }
 
 }  // namespace mp4
 }  // namespace media