Support HLS MPEG2 TS with SAMPLE-AES encryption.

media/formats/mp2t/es_parser_h264.cc

Index: media/formats/mp2t/es_parser_h264.cc
diff --git a/media/formats/mp2t/es_parser_h264.cc b/media/formats/mp2t/es_parser_h264.cc
index 94b25b4f5157847d06f3a8acc87136bd3d5a3f4a..a9f4a4489d538e99c37080e3232146ad2deed3b0 100644
--- a/media/formats/mp2t/es_parser_h264.cc
+++ b/media/formats/mp2t/es_parser_h264.cc
@@ -6,6 +6,7 @@
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
+#include "media/base/decrypt_config.h"
 #include "media/base/encryption_scheme.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/timestamp_constants.h"
@@ -19,19 +20,171 @@
 namespace media {
 namespace mp2t {
 
+namespace {
+
+#ifdef ENABLE_HLS_SAMPLE_AES
+
+const int kSampleAESMaxUnprotectedNALULength = 48;
+const int kSampleAESClearLeaderSize = 32;
+const int kSampleAESEncryptBlocks = 1;
+const int kSampleAESSkipBlocks = 9;
+
+// Attempts to find the first or only EP3B (emulation prevention 3 byte) in
+// the part of the |buffer| between |start_pos| and |end_pos|. Returns the
+// position of the EP3B, or 0 if there are none.
+// Note: the EP3B always follows two zero bytes, so the value 0 can never be a
+// valid position.
+int FindEP3B(const uint8* buffer, int start_pos, int end_pos) {
+  const uint8* data = buffer + start_pos;
+  int data_size = end_pos - start_pos;
+  DCHECK_GE(data_size, 0);
+  int bytes_left = data_size;
+
+  while (bytes_left >= 4) {
+    if (data[0] == 0x00 && data[1] == 0x00 && data[2] == 0x03 &&
+        data[3] <= 0x03) {
+      return (data - buffer) + 2;
+    }
+    ++data;
+    --bytes_left;
+  }
+  return 0;
+}
+
+// Remove the byte at |pos| in the |buffer| and close up the gap, moving all the
+// bytes from [pos + 1, end_pos) to [pos, end_pos - 1).
+void RemoveByte(uint8* buffer, int pos, int end_pos) {
+  memmove(&buffer[pos], &buffer[pos + 1], end_pos - pos - 1);
+}
+
+// Given an Access Unit pointed to by |au| of size |au_size|, removes emulation
+// prevention 3 bytes (EP3B) from within the |protected_blocks|. Also computes
+// the |subsamples| vector describing the resulting AU.
+// Returns the allocated buffer holding the adjusted copy, or NULL if no size
+// adjustment was necessary.
+scoped_ptr<uint8[]> AdjustAUForSampleAES(
+    const uint8* au,
+    int* au_size,
+    const Ranges<int>& protected_blocks,
+    std::vector<SubsampleEntry>* subsamples) {
+  DCHECK(subsamples);
+  DCHECK(au_size);
+  scoped_ptr<uint8[]> result;
+  int& au_end_pos = *au_size;
+
+  // 1. Considering each protected block in turn, find any emulation prevention
+  // 3 bytes (EP3B) within it, keeping track of their positions. While doing so,
+  // produce a revised Ranges<int> reflecting the new protected block positions
+  // that will apply after we have removed the EP3Bs.
+  Ranges<int> adjusted_protected_blocks;
+  std::vector<int> epbs;
+  int adjustment = 0;
+  for (size_t i = 0; i < protected_blocks.size(); i++) {
+    int start_pos = protected_blocks.start(i) - adjustment;
+    int end_pos = protected_blocks.end(i) - adjustment;
+    int search_pos = start_pos;
+    int epb_pos;
+    int block_adjustment = 0;
+    while ((epb_pos = FindEP3B(au, search_pos, end_pos))) {
+      epbs.push_back(epb_pos);
+      block_adjustment++;
+      search_pos = epb_pos + 2;
+    }
+    end_pos -= block_adjustment;
+    adjustment += block_adjustment;
+    adjusted_protected_blocks.Add(start_pos, end_pos);
+  }
+
+  // 2. If we actually found any EP3Bs, make a copy of the AU and then remove
+  // the EP3Bs in the copy (we can't modify the original).
+  if (adjustment) {
+    result.reset(new uint8[au_end_pos]);
+    uint8* temp = result.get();
+    memcpy(temp, au, au_end_pos);
+    for (auto epb_pos = epbs.rbegin(); epb_pos != epbs.rend(); ++epb_pos) {
+      RemoveByte(temp, *epb_pos, au_end_pos);
+      au_end_pos--;
+    }
+    au = temp;
+  }
+
+  // We now have either the original AU, or a copy with the EP3Bs removed.
+  // We also have an updated Ranges<int> indicating the protected blocks.
+  // Also au_end_pos has been adjusted to indicate the new au_size.
+
+  // 3. Use a new Ranges<int> to collect all the clear ranges. They will
+  // automatically be coalesced to minimize the number of (disjoint) ranges.
+  Ranges<int> clear_ranges;
+  int previous_pos = 0;
+  for (size_t i = 0; i < adjusted_protected_blocks.size(); i++) {
+    int start_pos = adjusted_protected_blocks.start(i);
+    int end_pos = adjusted_protected_blocks.end(i);
+    // Add the clear range prior to this protected block.
+    clear_ranges.Add(previous_pos, start_pos);
+    int block_size = end_pos - start_pos;
+    DCHECK_GT(block_size, kSampleAESMaxUnprotectedNALULength);
+    // Add the clear leader.
+    clear_ranges.Add(start_pos, start_pos + kSampleAESClearLeaderSize);
+    block_size -= kSampleAESClearLeaderSize;
+    // Add the bytes beyond an integral multiple of AES blocks (16 bytes).
+    int residual_bytes = block_size % 16;
+    clear_ranges.Add(end_pos - residual_bytes, end_pos);
+    previous_pos = end_pos;
+  }
+  // Add the trailing bytes beyond the last protected block.
+  clear_ranges.Add(previous_pos, au_end_pos);
+
+  // 4. Convert the disjoint set of clear ranges into subsample entries. Each
+  // subsample entry is a count of clear bytes followed by a count of protected
+  // bytes.
+  subsamples->clear();
+  for (size_t i = 0; i < clear_ranges.size(); i++) {
+    int start_pos = clear_ranges.start(i);
+    int end_pos = clear_ranges.end(i);
+    int clear_size = end_pos - start_pos;
+    int encrypt_start_pos = end_pos;
+    if (i + 1 < clear_ranges.size())
+      encrypt_start_pos = clear_ranges.start(i + 1);
+    SubsampleEntry subsample(clear_size, encrypt_start_pos - end_pos);
+    subsamples->push_back(subsample);
+  }
+  return result.Pass();
+}
+
+#endif
+}
+
 // An AUD NALU is at least 4 bytes:
 // 3 bytes for the start code + 1 byte for the NALU type.
 const int kMinAUDSize = 4;
 
-EsParserH264::EsParserH264(
-    const NewVideoConfigCB& new_video_config_cb,
-    const EmitBufferCB& emit_buffer_cb)
+EsParserH264::EsParserH264(const NewVideoConfigCB& new_video_config_cb,
+                           const EmitBufferCB& emit_buffer_cb)
     : es_adapter_(new_video_config_cb, emit_buffer_cb),
       h264_parser_(new H264Parser()),
       current_access_unit_pos_(0),
-      next_access_unit_pos_(0) {
+      next_access_unit_pos_(0)
+#ifdef ENABLE_HLS_SAMPLE_AES
+      ,
+      get_decrypt_config_cb_(GetDecryptConfigCB()),

[yucliu1, 2015/12/11 19:55:31]

ditto.

[dougsteed, 2015/12/14 22:51:46]

Done.

+      use_hls_sample_aes_(false)
+#endif
+{
 }
 
+#ifdef ENABLE_HLS_SAMPLE_AES
+EsParserH264::EsParserH264(const NewVideoConfigCB& new_video_config_cb,
+                           const EmitBufferCB& emit_buffer_cb,
+                           const GetDecryptConfigCB& get_decrypt_config_cb,
+                           bool use_hls_sample_aes)
+    : es_adapter_(new_video_config_cb, emit_buffer_cb),
+      h264_parser_(new H264Parser()),
+      current_access_unit_pos_(0),
+      next_access_unit_pos_(0),
+      get_decrypt_config_cb_(get_decrypt_config_cb),
+      use_hls_sample_aes_(use_hls_sample_aes) {}
+#endif
+
 EsParserH264::~EsParserH264() {
 }
 
@@ -179,6 +332,15 @@ bool EsParserH264::ParseFromEsQueue() {
         } else {
           pps_id_for_access_unit = shdr.pic_parameter_set_id;
         }
+#ifdef ENABLE_HLS_SAMPLE_AES
+        // With HLS SampleAES, protected blocks in H.264 consist of IDR and non-
+        // IDR slices that are more than 48 bytes in length.
+        if (use_hls_sample_aes_ &&
+            nalu.size > kSampleAESMaxUnprotectedNALULength) {
+          int64 nal_begin = nalu.data - es;
+          protected_blocks_.Add(nal_begin, nal_begin + nalu.size);
+        }
+#endif
         break;
       }
       default: {
@@ -231,6 +393,14 @@ bool EsParserH264::EmitFrame(int64 access_unit_pos, int access_unit_size,
     if (!sps)
       return false;
     EncryptionScheme scheme(false);
+#ifdef ENABLE_HLS_SAMPLE_AES
+    if (use_hls_sample_aes_) {
+      scheme =
+          EncryptionScheme(kCipherModeAesCbc,
+                           EncryptionScheme::PatternSpec(
+                               kSampleAESEncryptBlocks, kSampleAESSkipBlocks));

[yucliu1, 2015/12/11 19:55:31]

Add a TODO to support arbitrary enrypt:skip pattern.

[dougsteed, 2015/12/14 22:51:46]

Not needed for HLS SampleAES. But may be needed when/if we generalize this to
cover other uses of CENCv3. At that time there will presumably be extended
signalling to convey the (encrypt,skip) values.

+    }
+#endif
     RCHECK(UpdateVideoDecoderConfig(sps, scheme));
   }
 
@@ -242,6 +412,18 @@ bool EsParserH264::EmitFrame(int64 access_unit_pos, int access_unit_size,
   es_queue_->PeekAt(current_access_unit_pos_, &es, &es_size);
   CHECK_GE(es_size, access_unit_size);
 
+#ifdef ENABLE_HLS_SAMPLE_AES
+  scoped_ptr<uint8[]> adjusted_au;
+  std::vector<SubsampleEntry> subsamples;
+  if (use_hls_sample_aes_) {
+    adjusted_au = AdjustAUForSampleAES(es, &access_unit_size, protected_blocks_,
+                                       &subsamples);
+    protected_blocks_.clear();
+    if (adjusted_au)
+      es = adjusted_au.get();
+  }
+#endif
+
   // TODO(wolenetz/acolwell): Validate and use a common cross-parser TrackId
   // type and allow multiple video tracks. See https://crbug.com/341581.
   scoped_refptr<StreamParserBuffer> stream_parser_buffer =
@@ -255,11 +437,10 @@ bool EsParserH264::EmitFrame(int64 access_unit_pos, int access_unit_size,
   stream_parser_buffer->set_timestamp(current_timing_desc.pts);
 #ifdef ENABLE_HLS_SAMPLE_AES
   if (use_hls_sample_aes_) {
-    // TODO(dougsteed): temporary place-holders.
-    const std::string key_id = "XXXXXXXXXXXXXXXX";
-    const std::string iv = "IVIVIVIVIVIVIVIV";
-    scoped_ptr<DecryptConfig> decrypt_config(
-        new DecryptConfig(key_id, iv, subsamples));
+    DCHECK(!get_decrypt_config_cb_.is_null());
+    const DecryptConfig& base_decrypt_config = get_decrypt_config_cb_.Run();
+    scoped_ptr<DecryptConfig> decrypt_config(new DecryptConfig(
+        base_decrypt_config.key_id(), base_decrypt_config.iv(), subsamples));
     stream_parser_buffer->set_decrypt_config(decrypt_config.Pass());
   }
 #endif