Support HLS MPEG2 TS with SAMPLE-AES encryption.

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 <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/stl_util.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/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"
 
+#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
+#include "media/formats/mp2t/ts_section_cat.h"
+#include "media/formats/mp2t/ts_section_cets_ecm.h"
+#include "media/formats/mp2t/ts_section_cets_pssh.h"
+#endif
+
 namespace media {
 namespace mp2t {
 
+namespace {
+
+#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
+const int64_t kSampleAESPrivateDataIndicatorAVC = 0x7a617663;
+const int64_t kSampleAESPrivateDataIndicatorAAC = 0x61616364;
+// TODO(dougsteed). Consider adding support for the following:
+// const int64_t kSampleAESPrivateDataIndicatorAC3 = 0x61633364;
+// const int64_t kSampleAESPrivateDataIndicatorEAC3 = 0x65633364;
+#endif
+
+}  // namespace
+
 enum StreamType {
   // ISO-13818.1 / ITU H.222 Table 2.34 "Stream type assignments"
   kStreamTypeMpeg1Audio = 0x3,
   kStreamTypeAAC = 0xf,
   kStreamTypeAVC = 0x1b,
+#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
+  kStreamTypeAACWithSampleAES = 0xcf,
+  kStreamTypeAVCWithSampleAES = 0xdb,
+// TODO(dougsteed). Consider adding support for the following:
+//  kStreamTypeAC3WithSampleAES = 0xc1,
+//  kStreamTypeEAC3WithSampleAES = 0xc2,
+#endif
 };
 
 class PidState {
  public:
   enum PidType {
     kPidPat,
     kPidPmt,
     kPidAudioPes,
     kPidVideoPes,
+#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
+    kPidCat,
+    kPidCetsEcm,
+    kPidCetsPssh,
+#endif
   };
 
   PidState(int pid, PidType pid_tyoe,
            scoped_ptr<TsSection> section_parser);
 
   // Extract the content of the TS packet and parse it.
   // Return true if successful.
   bool PushTsPacket(const TsPacket& ts_packet);
 
   // Flush the PID state (possibly emitting some pending frames)
@@ skipping 136 matching lines @@
   encrypted_media_init_data_cb_ = encrypted_media_init_data_cb;
   new_segment_cb_ = new_segment_cb;
   end_of_segment_cb_ = end_of_segment_cb;
   media_log_ = media_log;
 }
 
 void Mp2tStreamParser::Flush() {
   DVLOG(1) << "Mp2tStreamParser::Flush";
 
   // Flush the buffers and reset the pids.
-  for (std::map<int, PidState*>::iterator it = pids_.begin();
-       it != pids_.end(); ++it) {
-    DVLOG(1) << "Flushing PID: " << it->first;
-    PidState* pid_state = it->second;
+  for (const auto& pid : pids_) {
+    DVLOG(1) << "Flushing PID: " << pid.first;
+    PidState* pid_state = pid.second;
     pid_state->Flush();
     delete pid_state;
   }
   pids_.clear();
 
   // Flush is invoked from SourceBuffer.abort/SourceState::ResetParserState, and
   // MSE spec prohibits emitting new configs in ResetParserState algorithm (see
   // https://w3c.github.io/media-source/#sourcebuffer-reset-parser-state,
   // 3.5.2 Reset Parser State states that new frames might be processed only in
   // PARSING_MEDIA_SEGMENT and therefore doesn't allow emitting new configs,
@@ skipping 57 matching lines @@
     if (!ts_packet) {
       DVLOG(1) << "Error: invalid TS packet";
       ts_byte_queue_.Pop(1);
       continue;
     }
     DVLOG(LOG_LEVEL_TS)
         << "Processing PID=" << ts_packet->pid()
         << " start_unit=" << ts_packet->payload_unit_start_indicator();
 
     // Parse the section.
-    std::map<int, PidState*>::iterator it = pids_.find(ts_packet->pid());
+    auto it = pids_.find(ts_packet->pid());
     if (it == pids_.end() &&
         ts_packet->pid() == TsSection::kPidPat) {
       // Create the PAT state here if needed.
       scoped_ptr<TsSection> pat_section_parser(
           new TsSectionPat(
               base::Bind(&Mp2tStreamParser::RegisterPmt,
                          base::Unretained(this))));
       scoped_ptr<PidState> pat_pid_state(new PidState(
           ts_packet->pid(), PidState::kPidPat, std::move(pat_section_parser)));
       pat_pid_state->Enable();
-      it = pids_.insert(
-          std::pair<int, PidState*>(ts_packet->pid(),
-                                    pat_pid_state.release())).first;
+      it =
+          pids_.insert(PidMapElement(ts_packet->pid(), pat_pid_state.release()))
+              .first;
     }
+#if BUILDFLAG(ENABLE_HLS_SAMPLE_AES)
+    // We allow a CAT to appear as the first packet in the TS. This allows us to
+    // specify encryption metadata for HLS by injecting it as an extra TS packet
+    // at the front of the stream.
+    else if (it == pids_.end() && ts_packet->pid() == TsSection::kPidCat) {
+      it = RegisterCat();
+    }
+#endif
 
     if (it != pids_.end()) {
       if (!it->second->PushTsPacket(*ts_packet))
         return false;
     } else {
       DVLOG(LOG_LEVEL_TS) << "Ignoring TS packet for pid: " << ts_packet->pid();
     }
 
     // Go to the next packet.
     ts_byte_queue_.Pop(TsPacket::kPacketSize);
   }
 
   RCHECK(FinishInitializationIfNeeded());
 
   // Emit the A/V buffers that kept accumulating during TS parsing.
   return EmitRemainingBuffers();
 }
 
 void Mp2tStreamParser::RegisterPmt(int program_number, int pmt_pid) {
   DVLOG(1) << "RegisterPmt:"
            << " program_number=" << program_number
            << " pmt_pid=" << pmt_pid;
 
   // Only one TS program is allowed. Ignore the incoming program map table,
   // if there is already one registered.
-  for (std::map<int, PidState*>::iterator it = pids_.begin();
-       it != pids_.end(); ++it) {
-    PidState* pid_state = it->second;
+  for (const auto& pid : pids_) {
+    PidState* pid_state = pid.second;
     if (pid_state->pid_type() == PidState::kPidPmt) {
-      DVLOG_IF(1, pmt_pid != it->first) << "More than one program is defined";
+      DVLOG_IF(1, pmt_pid != pid.first) << "More than one program is defined";
       return;
     }
   }
 
   // Create the PMT state here if needed.
   DVLOG(1) << "Create a new PMT parser";
   scoped_ptr<TsSection> pmt_section_parser(
       new TsSectionPmt(
           base::Bind(&Mp2tStreamParser::RegisterPes,
                      base::Unretained(this), pmt_pid)));
   scoped_ptr<PidState> pmt_pid_state(
       new PidState(pmt_pid, PidState::kPidPmt, std::move(pmt_section_parser)));
   pmt_pid_state->Enable();
   pids_.insert(std::pair<int, PidState*>(pmt_pid, pmt_pid_state.release()));
+
+#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,
-                                   int stream_type) {
+                                   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;
   std::map<int, PidState*>::iterator it = pids_.find(pes_pid);
   if (it != pids_.end())
     return;
 
   // Create a stream parser corresponding to the stream type.
   bool is_audio = false;
@@ skipping 19 matching lines @@
             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),
+        base::Bind(&Mp2tStreamParser::GetDecryptConfig, base::Unretained(this)),
+        true));
+  } 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 {
     return;
   }
 
   // Create the PES state here.
   DVLOG(1) << "Create a new PES state";
   scoped_ptr<TsSection> pes_section_parser(
       new TsSectionPes(std::move(es_parser), &timestamp_unroller_));
   PidState::PidType pid_type =
       is_audio ? PidState::kPidAudioPes : PidState::kPidVideoPes;
@@ skipping 265 matching lines @@
 
   // Push an empty queue with the last audio/video config
   // so that buffers with the same config can be added later on.
   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::map<int, PidState*>::iterator Mp2tStreamParser::RegisterCat() {
+  scoped_ptr<TsSection> cat_section_parser(new TsSectionCat(
+      base::Bind(&Mp2tStreamParser::RegisterCencPids, base::Unretained(this))));
+  scoped_ptr<PidState> cat_pid_state(new PidState(
+      TsSection::kPidCat, PidState::kPidCat, std::move(cat_section_parser)));
+  cat_pid_state->Enable();
+  return pids_
+      .insert(PidMapElement(TsSection::kPidCat, cat_pid_state.release()))
+      .first;
+}
+
+void Mp2tStreamParser::UnregisterCat() {
+  for (auto& pid : pids_) {
+    if (pid.second->pid_type() == PidState::kPidCat) {
+      delete pid.second;
+      pids_.erase(pid.first);
+      break;
+    }
+  }
+}
+
+void Mp2tStreamParser::RegisterCencPids(int ca_pid, int pssh_pid) {
+  scoped_ptr<TsSectionCetsEcm> ecm_parser(new TsSectionCetsEcm(base::Bind(
+      &Mp2tStreamParser::RegisterDecryptConfig, base::Unretained(this))));
+  scoped_ptr<PidState> ecm_pid_state(
+      new PidState(ca_pid, PidState::kPidCetsEcm, std::move(ecm_parser)));
+  ecm_pid_state->Enable();
+  pids_.insert(PidMapElement(ca_pid, ecm_pid_state.release()));
+
+  scoped_ptr<TsSectionCetsPssh> pssh_parser(new TsSectionCetsPssh(base::Bind(
+      &Mp2tStreamParser::RegisterPsshBoxes, base::Unretained(this))));
+  scoped_ptr<PidState> pssh_pid_state(
+      new PidState(pssh_pid, PidState::kPidCetsPssh, std::move(pssh_parser)));
+  pssh_pid_state->Enable();
+  pids_.insert(PidMapElement(pssh_pid, pssh_pid_state.release()));
+}
+
+void Mp2tStreamParser::UnregisterCencPids() {
+  for (auto& pid : pids_) {
+    if (pid.second->pid_type() == PidState::kPidCetsEcm) {
+      delete pid.second;
+      pids_.erase(pid.first);
+      break;
+    }
+  }
+  for (auto& pid : pids_) {
+    if (pid.second->pid_type() == PidState::kPidCetsPssh) {
+      delete pid.second;
+      pids_.erase(pid.first);
+      break;
+    }
+  }
+}
+
+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