MP4 support for Common Encryption 'cbcs' scheme.

media/formats/mp4/box_definitions.h

 // 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.
 
 #ifndef MEDIA_FORMATS_MP4_BOX_DEFINITIONS_H_
 #define MEDIA_FORMATS_MP4_BOX_DEFINITIONS_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/media_export.h"
 #include "media/base/media_log.h"
 #include "media/base/video_codecs.h"
 #include "media/formats/mp4/aac.h"
 #include "media/formats/mp4/avc.h"
 #include "media/formats/mp4/box_reader.h"
 #include "media/formats/mp4/fourccs.h"
+#include "media/media_features.h"
 
 namespace media {
 namespace mp4 {
 
+// Size in bytes needed to store largest IV.
+const int kInitializationVectorSize = 16;
+
 enum TrackType { kInvalid = 0, kVideo, kAudio, kText, kHint };
 
 enum SampleFlags {
   kSampleIsNonSyncSample = 0x10000
 };
 
 #define DECLARE_BOX_METHODS(T)            \
   T();                                    \
   T(const T& other);                      \
   ~T() override;                          \
@@ skipping 47 matching lines @@
   // Parse SampleEncryptionEntry from |reader|.
   // |iv_size| specifies the size of initialization vector. |has_subsamples|
   // indicates whether this sample encryption entry constains subsamples.
   // Returns false if parsing fails.
   bool Parse(BufferReader* reader, uint8_t iv_size, bool has_subsamples);
 
   // Get accumulated size of subsamples. Returns false if there is an overflow
   // anywhere.
   bool GetTotalSizeOfSubsamples(size_t* total_size) const;
 
-  uint8_t initialization_vector[16];
+  uint8_t initialization_vector[kInitializationVectorSize];
   std::vector<SubsampleEntry> subsamples;
 };
 
 // ISO/IEC 23001-7:2015 8.1.1.
 struct MEDIA_EXPORT SampleEncryption : Box {
   enum SampleEncryptionFlags {
     kUseSubsampleEncryption = 2,
   };
 
   DECLARE_BOX_METHODS(SampleEncryption);
@@ skipping 17 matching lines @@
   uint32_t version;
 };
 
 struct MEDIA_EXPORT TrackEncryption : Box {
   DECLARE_BOX_METHODS(TrackEncryption);
 
   // Note: this definition is specific to the CENC protection type.
   bool is_encrypted;
   uint8_t default_iv_size;
   std::vector<uint8_t> default_kid;
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
+  uint8_t default_crypt_byte_block;
+  uint8_t default_skip_byte_block;
+  uint8_t default_constant_iv_size;
+  uint8_t default_constant_iv[kInitializationVectorSize];
+#endif
 };
 
 struct MEDIA_EXPORT SchemeInfo : Box {
   DECLARE_BOX_METHODS(SchemeInfo);
 
   TrackEncryption track_encryption;
 };
 
 struct MEDIA_EXPORT ProtectionSchemeInfo : Box {
   DECLARE_BOX_METHODS(ProtectionSchemeInfo);
 
   OriginalFormat format;
   SchemeType type;
   SchemeInfo info;
+
+  bool HasSupportedScheme() const;
 };
 
 struct MEDIA_EXPORT MovieHeader : Box {
   DECLARE_BOX_METHODS(MovieHeader);
 
   uint8_t version;
   uint64_t creation_time;
   uint64_t modification_time;
   uint32_t timescale;
   uint64_t duration;
@@ skipping 126 matching lines @@
 
   TrackType type;
   std::vector<VideoSampleEntry> video_entries;
   std::vector<AudioSampleEntry> audio_entries;
 };
 
 struct MEDIA_EXPORT CencSampleEncryptionInfoEntry {
   CencSampleEncryptionInfoEntry();
   CencSampleEncryptionInfoEntry(const CencSampleEncryptionInfoEntry& other);
   ~CencSampleEncryptionInfoEntry();
+  bool Parse(BoxReader* reader);
 
   bool is_encrypted;
   uint8_t iv_size;
   std::vector<uint8_t> key_id;
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
+  uint8_t crypt_byte_block;
+  uint8_t skip_byte_block;
+  uint8_t constant_iv_size;
+  uint8_t constant_iv[kInitializationVectorSize];
+#endif
 };
 
 struct MEDIA_EXPORT SampleGroupDescription : Box {  // 'sgpd'.
   DECLARE_BOX_METHODS(SampleGroupDescription);
 
   uint32_t grouping_type;
   std::vector<CencSampleEncryptionInfoEntry> entries;
 };
 
 struct MEDIA_EXPORT SampleTable : Box {
@@ skipping 172 matching lines @@
   std::vector<TrackFragment> tracks;
   std::vector<ProtectionSystemSpecificHeader> pssh;
 };
 
 #undef DECLARE_BOX
 
 }  // namespace mp4
 }  // namespace media
 
 #endif  // MEDIA_FORMATS_MP4_BOX_DEFINITIONS_H_