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

media/formats/mp2t/mp2t_stream_parser.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/mp2t/mp2t_stream_parser.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "media/base/media_tracks.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/timestamp_constants.h"
+#include "media/formats/mp2t/descriptors.h"
 #include "media/formats/mp2t/es_parser.h"
 #include "media/formats/mp2t/es_parser_adts.h"
 #include "media/formats/mp2t/es_parser_h264.h"
 #include "media/formats/mp2t/es_parser_mpeg1audio.h"
 #include "media/formats/mp2t/mp2t_common.h"
 #include "media/formats/mp2t/ts_packet.h"
 #include "media/formats/mp2t/ts_section.h"
 #include "media/formats/mp2t/ts_section_pat.h"
 #include "media/formats/mp2t/ts_section_pes.h"
 #include "media/formats/mp2t/ts_section_pmt.h"
@@ skipping 335 matching lines @@
     PidState* pid_state = pid_pair.second.get();
     if (pid_state->pid_type() == PidState::kPidPmt) {
       DVLOG_IF(1, pmt_pid != pid_pair.first)
           << "More than one program is defined";
       return;
     }
   }
 
   // Create the PMT state here if needed.
   DVLOG(1) << "Create a new PMT parser";
-  std::unique_ptr<TsSection> pmt_section_parser(new TsSectionPmt(base::Bind(
-      &Mp2tStreamParser::RegisterPes, base::Unretained(this), pmt_pid)));
+  std::unique_ptr<TsSection> pmt_section_parser(new TsSectionPmt(
+      base::Bind(&Mp2tStreamParser::RegisterPes, base::Unretained(this))));
   std::unique_ptr<PidState> pmt_pid_state(
       new PidState(pmt_pid, PidState::kPidPmt, std::move(pmt_section_parser)));
   pmt_pid_state->Enable();
   pids_.insert(std::make_pair(pmt_pid, std::move(pmt_pid_state)));
 
 #if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
   // Take the opportunity to clean up any PIDs that were involved in importing
   // encryption metadata for HLS with SampleAES. This prevents the possibility
   // of interference with actual PIDs that might be declared in the PMT.
   // TODO(dougsteed): if in the future the appropriate PIDs are embedded in the
   // source stream, this will not be necessary.
   UnregisterCat();
   UnregisterCencPids();
 #endif
 }
 
-void Mp2tStreamParser::RegisterPes(int pmt_pid,
-                                   int pes_pid,
+std::unique_ptr<EsParser> Mp2tStreamParser::MaybeCreateH264Parser(
+    int pes_pid,
+    int stream_type,
+    const Descriptors& descriptors) {
+  bool is_h264 = stream_type == kStreamTypeAVC;
+  bool enable_hls = false;
+  std::unique_ptr<EsParser> es_parser;
+
+#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
+  if (is_h264 && !is_initialized_ && initial_scheme_.is_encrypted()) {
+    enable_hls = true;
+  } else if (stream_type == kStreamTypeAVCWithSampleAES &&
+             descriptors.HasPrivateDataIndicator(
+                 kSampleAESPrivateDataIndicatorAVC)) {
+    is_h264 = true;
+    enable_hls = true;
+  }
+#endif
+
+  if (!is_h264)
+    return nullptr;
+
+  auto on_video_config_changed = base::Bind(
+      &Mp2tStreamParser::OnVideoConfigChanged, base::Unretained(this), pes_pid);
+  auto on_emit_video_buffer = base::Bind(&Mp2tStreamParser::OnEmitVideoBuffer,
+                                         base::Unretained(this), pes_pid);
+  if (!enable_hls) {
+    es_parser.reset(
+        new EsParserH264(on_video_config_changed, on_emit_video_buffer));
+  }
+#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
+  else {
+    auto get_decrypt_config =
+        base::Bind(&Mp2tStreamParser::GetDecryptConfig, base::Unretained(this));
+    es_parser.reset(new EsParserH264(on_video_config_changed,
+                                     on_emit_video_buffer, true,
+                                     get_decrypt_config));
+  }
+#endif
+  return es_parser;
+}
+
+std::unique_ptr<EsParser> Mp2tStreamParser::MaybeCreateAACParser(
+    int pes_pid,
+    int stream_type,
+    const Descriptors& descriptors) {
+  bool is_AAC = stream_type == kStreamTypeAAC;
+  bool enable_hls = false;
+  std::unique_ptr<EsParser> es_parser;
+#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
+  if (is_AAC && !is_initialized_ && initial_scheme_.is_encrypted()) {

[kqyang, 2017/04/07 23:33:43]

I understand that Marvel does not support switching encryption schemes, but I
don't understand why the encryption scheme needs to be signaled before starting
playing the clear "commercial". Why cannot it be signaled before playing the
actual encrypted stream? Can you explain? 

[dougsteed, 2017/04/26 20:34:14]

On this platform, we always need to initialize a decryptor (and get the scheme
correct) at the beginning of the stream, regardless of whether any part (or all)
of the stream is clear.

[kqyang, 2017/05/06 00:06:12]

Is this a limitation of Chromium media pipeline or Chromecast media pipeline?
Also, aren't the commercial and real content two different steams?

+    enable_hls = true;
+  } else if (stream_type == kStreamTypeAACWithSampleAES &&
+             descriptors.HasPrivateDataIndicator(
+                 kSampleAESPrivateDataIndicatorAAC)) {
+    is_AAC = true;
+    enable_hls = true;
+  }
+#endif
+
+  if (!is_AAC)
+    return nullptr;
+
+  auto on_audio_config_changed = base::Bind(
+      &Mp2tStreamParser::OnAudioConfigChanged, base::Unretained(this), pes_pid);
+  auto on_emit_audio_buffer = base::Bind(&Mp2tStreamParser::OnEmitAudioBuffer,
+                                         base::Unretained(this), pes_pid);
+  if (!enable_hls) {
+    es_parser.reset(new EsParserAdts(on_audio_config_changed,
+                                     on_emit_audio_buffer, sbr_in_mimetype_));
+  }
+#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
+  else {
+    auto get_decrypt_config =
+        base::Bind(&Mp2tStreamParser::GetDecryptConfig, base::Unretained(this));
+    es_parser.reset(new EsParserAdts(on_audio_config_changed,
+                                     on_emit_audio_buffer, get_decrypt_config,
+                                     true, sbr_in_mimetype_));
+  }
+#endif
+  return es_parser;
+}
+
+std::unique_ptr<EsParser> Mp2tStreamParser::MaybeCreateMpeg1AudioParser(
+    int pes_pid,
+    int stream_type) {
+  if (stream_type != kStreamTypeMpeg1Audio)

[servolk, 2017/04/04 20:08:18]

&& stream_type != kStreamTypeMpeg2Audio

[dougsteed, 2017/04/26 20:34:14]

Done.

+    return nullptr;
+  auto on_audio_config_changed = base::Bind(
+      &Mp2tStreamParser::OnAudioConfigChanged, base::Unretained(this), pes_pid);
+  auto on_emit_audio_buffer = base::Bind(&Mp2tStreamParser::OnEmitAudioBuffer,
+                                         base::Unretained(this), pes_pid);
+  std::unique_ptr<EsParser> es_parser(new EsParserMpeg1Audio(
+      on_audio_config_changed, on_emit_audio_buffer, media_log_));
+  return es_parser;
+}
+
+void Mp2tStreamParser::RegisterPes(int pes_pid,
                                    int stream_type,
                                    const Descriptors& descriptors) {
   // TODO(damienv): check there is no mismatch if the entry already exists.
   DVLOG(1) << "RegisterPes:"
            << " pes_pid=" << pes_pid
            << " stream_type=" << std::hex << stream_type << std::dec;
   auto it = pids_.find(pes_pid);
   if (it != pids_.end())
     return;
 
   // Create a stream parser corresponding to the stream type.
-  bool is_audio = false;
+  bool is_audio = true;
   std::unique_ptr<EsParser> es_parser;
-  if (stream_type == kStreamTypeAVC) {
-    es_parser.reset(
-        new EsParserH264(
-            base::Bind(&Mp2tStreamParser::OnVideoConfigChanged,
-                       base::Unretained(this),
-                       pes_pid),
-            base::Bind(&Mp2tStreamParser::OnEmitVideoBuffer,
-                       base::Unretained(this),
-                       pes_pid)));
-  } else if (stream_type == kStreamTypeAAC) {
-    es_parser.reset(
-        new EsParserAdts(
-            base::Bind(&Mp2tStreamParser::OnAudioConfigChanged,
-                       base::Unretained(this),
-                       pes_pid),
-            base::Bind(&Mp2tStreamParser::OnEmitAudioBuffer,
-                       base::Unretained(this),
-                       pes_pid),
-            sbr_in_mimetype_));
-    is_audio = true;
-  } else if (stream_type == kStreamTypeMpeg1Audio) {
-    es_parser.reset(new EsParserMpeg1Audio(
-        base::Bind(&Mp2tStreamParser::OnAudioConfigChanged,
-                   base::Unretained(this), pes_pid),
-        base::Bind(&Mp2tStreamParser::OnEmitAudioBuffer, base::Unretained(this),
-                   pes_pid),
-        media_log_));
-    is_audio = true;
-#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
-  } else if (stream_type == kStreamTypeAVCWithSampleAES &&
-             descriptors.HasPrivateDataIndicator(
-                 kSampleAESPrivateDataIndicatorAVC)) {
-    es_parser.reset(
-        new EsParserH264(base::Bind(&Mp2tStreamParser::OnVideoConfigChanged,
-                                    base::Unretained(this), pes_pid),
-                         base::Bind(&Mp2tStreamParser::OnEmitVideoBuffer,
-                                    base::Unretained(this), pes_pid),
-                         true, base::Bind(&Mp2tStreamParser::GetDecryptConfig,
-                                          base::Unretained(this))));
-  } else if (stream_type == kStreamTypeAACWithSampleAES &&
-             descriptors.HasPrivateDataIndicator(
-                 kSampleAESPrivateDataIndicatorAAC)) {
-    es_parser.reset(new EsParserAdts(
-        base::Bind(&Mp2tStreamParser::OnAudioConfigChanged,
-                   base::Unretained(this), pes_pid),
-        base::Bind(&Mp2tStreamParser::OnEmitAudioBuffer, base::Unretained(this),
-                   pes_pid),
-        base::Bind(&Mp2tStreamParser::GetDecryptConfig, base::Unretained(this)),
-        true, sbr_in_mimetype_));
-    is_audio = true;
-#endif
-  } else {
+
+  es_parser = MaybeCreateH264Parser(pes_pid, stream_type, descriptors);
+  if (es_parser)
+    is_audio = false;
+  else
+    es_parser = MaybeCreateAACParser(pes_pid, stream_type, descriptors);
+
+  if (!es_parser)
+    es_parser = MaybeCreateMpeg1AudioParser(pes_pid, stream_type);
+
+  if (!es_parser)

[kqyang, 2017/04/07 23:33:43]

I think the code would be cleaner and easier to maintain with this:

switch (stream_type) {
  case kStreamTypeAVC:
#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
    // Add some comments on when and why could this happen.
    if (!is_initialized_ && initial_scheme_.is_encrypted())) {
      CreateEncryptedH264Parser(pes_pid);
      break;
    }
#endif
    CreateH264Parser(pes_pid);
    break;
#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
  case kStreamTypeAVCWithSampleAES:
    if (!descriptors.HasPrivateDataIndicator(
                 kSampleAESPrivateDataIndicatorAVC)) { FAIL ... }
    CreateEncryptedH264Parser(pes_pid);
    break;
#endif

  case kStreamTypeAAC:
#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
    // Add some comments on when and why could this happen.
    if (!is_initialized_ && initial_scheme_.is_encrypted())) {
      CreateEncryptedAacParser(pes_pid);
      break;
    }
#endif
    CreateAacParser(pes_pid);
    break;
#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
  case kStreamTypeAACWithSampleAES:
    if (!descriptors.HasPrivateDataIndicator(
                 kSampleAESPrivateDataIndicatorAAC)) { FAIL ... }
    CreateEncryptedAacParser(pes_pid);
    break;
#endif
  default:
    FAIL...
}

[dougsteed, 2017/04/26 20:34:14]

Adopted this general approach, but with some variation.

     return;
-  }
 
   // Create the PES state here.
   DVLOG(1) << "Create a new PES state";
   std::unique_ptr<TsSection> pes_section_parser(
       new TsSectionPes(std::move(es_parser), &timestamp_unroller_));
   PidState::PidType pid_type =
       is_audio ? PidState::kPidAudioPes : PidState::kPidVideoPes;
   std::unique_ptr<PidState> pes_pid_state(
       new PidState(pes_pid, pid_type, std::move(pes_section_parser)));
   pids_.insert(std::make_pair(pes_pid, std::move(pes_pid_state)));
@@ skipping 277 matching lines @@
   BufferQueueWithConfig queue_with_config(
       true, last_audio_config, last_video_config);
   buffer_queue_chain_.push_back(queue_with_config);
 
   return true;
 }
 
 #if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
 std::unique_ptr<PidState> Mp2tStreamParser::MakeCatPidState() {
   std::unique_ptr<TsSection> cat_section_parser(new TsSectionCat(
-      base::Bind(&Mp2tStreamParser::RegisterCencPids, base::Unretained(this))));
+      base::Bind(&Mp2tStreamParser::RegisterCencPids, base::Unretained(this)),
+      base::Bind(&Mp2tStreamParser::RegisterEncryptionScheme,
+                 base::Unretained(this))));
   std::unique_ptr<PidState> cat_pid_state(new PidState(
       TsSection::kPidCat, PidState::kPidCat, std::move(cat_section_parser)));
   cat_pid_state->Enable();
   return cat_pid_state;
 }
 
 void Mp2tStreamParser::UnregisterCat() {
   for (auto& pid : pids_) {
     if (pid.second->pid_type() == PidState::kPidCat) {
       pids_.erase(pid.first);
@@ skipping 27 matching lines @@
     }
   }
   for (auto& pid : pids_) {
     if (pid.second->pid_type() == PidState::kPidCetsPssh) {
       pids_.erase(pid.first);
       break;
     }
   }
 }
 
+void Mp2tStreamParser::RegisterEncryptionScheme(
+    const EncryptionScheme& scheme) {
+  // We only need to record this for the initial decoder config.
+  if (!is_initialized_) {
+    initial_scheme_ = scheme;
+  }
+  // Reset the DecryptConfig, so that unless and until a CENC-ECM (containing
+  // key id and IV) is seen, media data will be considered unencrypted. This is
+  // similar to the way clear leaders can occur in MP4 containers.
+  decrypt_config_.reset(nullptr);
+}
+
 void Mp2tStreamParser::RegisterDecryptConfig(const DecryptConfig& config) {
   decrypt_config_.reset(
       new DecryptConfig(config.key_id(), config.iv(), config.subsamples()));
 }
 
 void Mp2tStreamParser::RegisterPsshBoxes(
     const std::vector<uint8_t>& init_data) {
   encrypted_media_init_data_cb_.Run(EmeInitDataType::CENC, init_data);
 }
 
 #endif
 
 }  // namespace mp2t
 }  // namespace media