Declare intent to use sample-aes later in the stream.

media/formats/mp2t/descriptors.cc

 // Copyright 2015 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/mp2t/descriptors.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "media/base/bit_reader.h"
+#include "media/base/encryption_scheme.h"
 #include "media/formats/mp2t/mp2t_common.h"
 
 namespace media {
 namespace mp2t {
 
 namespace {
 
 // Tag values for various kinds of descriptors for which there is specific
 // parsing support herein.
 enum DescriptorTag {
   DESCRIPTOR_TAG_REGISTRATION = 5,
   DESCRIPTOR_TAG_CA = 9,
   DESCRIPTOR_TAG_PRIVATE_DATA_INDICATOR = 15,
 };
 
 const int kCASystemIdCenc = 0x6365;  // 'ce'
+const uint32_t kFourccCbcs = 0x63626373;  // 'cbcs'
 
 class StringBitReader : public BitReader {
  public:
   StringBitReader(const std::string& input);
   ~StringBitReader() override;
 };
 
 StringBitReader::StringBitReader(const std::string& input)
     : BitReader(reinterpret_cast<const uint8_t*>(input.data()), input.size()) {}
 
@@ skipping 66 matching lines @@
   StringBitReader reader(data);
   RCHECK(reader.ReadBits(16, system_id));
   RCHECK(reader.SkipBits(3));
   RCHECK(reader.ReadBits(13, pid));
   size_t extra_bits = reader.bits_available();
   RCHECK(extra_bits % 8 == 0);
   RCHECK(reader.ReadString(extra_bits, private_data));
   return true;
 }
 
-bool Descriptors::HasCADescriptorCenc(int* ca_pid, int* pssh_pid) const {
+bool Descriptors::HasCADescriptorCenc(int* ca_pid,
+                                      int* pssh_pid,
+                                      EncryptionScheme* scheme) const {
   DCHECK(ca_pid);
   DCHECK(pssh_pid);
   int system_id;
   std::string private_data;
   if (!HasCADescriptor(&system_id, ca_pid, &private_data))
     return false;
   if (system_id != kCASystemIdCenc)
     return false;
   StringBitReader reader(private_data);
   uint32_t scheme_type;
   uint32_t scheme_version;
   int num_systems;
   int encryption_algorithm;
   char pssh_system_id[16];
-  // TODO(dougsteed). Currently we don't check many of the following values.
+  // TODO(dougsteed). Currently we don't check many of the following values,
+  // and we only support the 'cbcs' scheme (which involves AES-CBC encryption).
   // When we flesh out this implementation to cover all of ISO/IEC 23001-9 we
-  // will need to use and check these values.
+  // will need to use and check these values more comprehensively.
   RCHECK(reader.ReadBits(32, &scheme_type));
+  RCHECK(scheme_type == kFourccCbcs);
   RCHECK(reader.ReadBits(32, &scheme_version));
   RCHECK(reader.ReadBits(8, &num_systems));
   RCHECK(num_systems == 1);
   RCHECK(reader.ReadBits(24, &encryption_algorithm));
   for (size_t i = 0; i < 16; i++) {
     RCHECK(reader.ReadBits(8, &pssh_system_id[i]));
   }
   RCHECK(reader.ReadBits(13, pssh_pid));
+  // The pattern is actually set differently for audio and video, so OK not to
+  // set it here. Important thing is to set the cipher mode.
+  *scheme = EncryptionScheme(EncryptionScheme::CIPHER_MODE_AES_CBC,
+                             EncryptionScheme::Pattern());
   return true;
 }
 
 bool Descriptors::HasPrivateDataIndicator(int64_t value) const {
   int64_t private_data_indicator;
   auto search = descriptors_.find(DESCRIPTOR_TAG_PRIVATE_DATA_INDICATOR);
   if (search == descriptors_.end())
     return false;
   const std::string& data = search->second;
   StringBitReader reader(data);
   RCHECK(reader.ReadBits(32, &private_data_indicator));
   RCHECK(reader.bits_available() == 0);
   return private_data_indicator == value;
 }
 
 }  // namespace mp2t
 }  // namespace media