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 197 matching lines @@
 
 TrackEncryption::TrackEncryption()
   : is_encrypted(false), default_iv_size(0) {
 }
 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) &&
-         reader->Read1(&default_iv_size) &&
-         reader->ReadVec(&default_kid, 16));
+  uint8_t possible_pattern_info;
+  RCHECK(reader->ReadFullBoxHeader() && reader->SkipBytes(1) &&
+         reader->Read1(&possible_pattern_info) && reader->Read1(&flag) &&
+         reader->Read1(&default_iv_size) && reader->ReadVec(&default_kid, 16));

[kqyang, 2016/05/23 20:57:34]

s/16/kKeyIdSize/

[dougsteed, 2016/05/25 17:23:21]

Done.

   is_encrypted = (flag != 0);
-  if (is_encrypted) {
+  if (default_iv_size != 0) {
     RCHECK(default_iv_size == 8 || default_iv_size == 16);
+#if BUILDFLAG(ENABLE_CENC_NEW_EDITIONS)

[kqyang, 2016/05/23 20:57:34]

I'd prefer as less preprocessor primitive in the code as possible. I think we
can rename the flag to ENABLE_CENC_PATTERN_ENCRYPTION and have it in
HasSupportedScheme() alone should be sufficient.

+ddorwin, do you have a preference / guideline or preprocessor conditions?

[ddorwin, 2016/05/24 23:25:03]

I'm worried about all the ifdef'd code being added, but I'm also wary of
including code in all builds that is not used by nearly all Chrome platforms.

Most importantly, though, I think this flag name is inaccurate. See my comments
in the .gni file.

[dougsteed, 2016/05/25 17:23:21]

Changed the name as suggested.

+  } else if (is_encrypted) {
+    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_CENC_NEW_EDITIONS)
+  return fourCC == FOURCC_CBC1 || fourCC == FOURCC_CBCS ||

[ddorwin, 2016/05/24 23:25:03]

Are there actual use cases for the other two? If not, I think we should avoid
advertising them unless there is a proven need.

[dougsteed, 2016/05/25 17:23:21]

Done.

+         fourCC == FOURCC_CENS;
+#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 324 matching lines @@
   }
   return true;
 }
 
 CencSampleEncryptionInfoEntry::CencSampleEncryptionInfoEntry()
     : is_encrypted(false), iv_size(0) {}
 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) {
+    RCHECK(iv_size == 8 || iv_size == 16);
+#if BUILDFLAG(ENABLE_CENC_NEW_EDITIONS)
+  } 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) {
@@ skipping 67 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