Support HLS MPEG2 TS with SAMPLE-AES encryption.

media/test/pipeline_integration_test.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 96 matching lines @@
 const char kMP4VideoVP9[] = "video/mp4; codecs=\"vp09.00.00.08.01.01.00.00\"";
 #endif
 const char kMP4Video[] = "video/mp4; codecs=\"avc1.4D4041\"";
 const char kMP4Audio[] = "audio/mp4; codecs=\"mp4a.40.2\"";
 const char kMP3[] = "audio/mpeg";
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
 const char kMP2AudioSBR[] = "video/mp2t; codecs=\"avc1.4D4041,mp4a.40.5\"";
 #endif
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
-// Key used to encrypt test files.
-const uint8_t kSecretKey[] = {0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14, 0xd2, 0x7b,
-                              0x68, 0xef, 0x12, 0x2a, 0xfc, 0xe4, 0xae, 0x3c};
-
-// The key ID for all encrypted files.
-const uint8_t kKeyId[] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
-                          0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35};
-
 const size_t kAppendWholeFile = std::numeric_limits<size_t>::max();
 
 // Constants for the Media Source config change tests.
 const int kAppendTimeSec = 1;
 const int kAppendTimeMs = kAppendTimeSec * 1000;
 const int k320WebMFileDurationMs = 2736;
 const int k320EncWebMFileDurationMs = 2737;
 const int k640WebMFileDurationMs = 2749;
 const int kOpusEndTrimmingWebMFileDurationMs = 2741;
 const int kVP9WebMFileDurationMs = 2736;
@@ skipping 151 matching lines @@
     Decryptor* decryptor_;
   };
 
   scoped_refptr<AesDecryptor> decryptor_;
   TestCdmContext cdm_context_;
   std::unique_ptr<AppBase> app_;
 };
 
 enum PromiseResult { RESOLVED, REJECTED };
 
-// Provides |kSecretKey| in response to the encrypted event.
+// Provides the test key in response to the encrypted event.
 class KeyProvidingApp : public FakeEncryptedMedia::AppBase {
  public:
   KeyProvidingApp() {}
 
   void OnResolveWithSession(PromiseResult expected,
                             const std::string& session_id) {
     EXPECT_EQ(expected, RESOLVED);
     EXPECT_GT(session_id.length(), 0ul);
     current_session_id_ = session_id;
   }
@@ skipping 83 matching lines @@
     if (current_session_id_.empty()) {
       decryptor->CreateSessionAndGenerateRequest(
           MediaKeys::TEMPORARY_SESSION, init_data_type, init_data,
           CreateSessionPromise(RESOLVED));
       EXPECT_FALSE(current_session_id_.empty());
     }
   }
 
   virtual bool LookupKey(const std::vector<uint8_t>& key_id,
                          std::vector<uint8_t>* key) {
-    // As there is no key rotation, the key ID provided should be |kKeyId|
-    // which uses |kSecretKey| as the key.
-    EXPECT_EQ(std::vector<uint8_t>(kKeyId, kKeyId + arraysize(kKeyId)), key_id);
-    key->assign(kSecretKey, kSecretKey + arraysize(kSecretKey));
-    return true;
+    // No key rotation.
+    return LookupTestKeyVector(key_id, false, key);
   }
 
   std::string current_session_id_;
   std::vector<uint8_t> prev_init_data_;
 };
 
 class RotatingKeyProvidingApp : public KeyProvidingApp {
  public:
   RotatingKeyProvidingApp() : num_distinct_need_key_calls_(0) {}
   ~RotatingKeyProvidingApp() override {
@@ skipping 11 matching lines @@
     prev_init_data_ = init_data;
     ++num_distinct_need_key_calls_;
 
     decryptor->CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
                                                init_data_type, init_data,
                                                CreateSessionPromise(RESOLVED));
   }
 
   bool LookupKey(const std::vector<uint8_t>& key_id,
                  std::vector<uint8_t>* key) override {
-    // The Key and KeyId for this testing key provider are created by left
-    // rotating |kSecretKey| and |kKeyId|. Note that this implementation is
-    // only intended for testing purpose. The actual key rotation algorithm
-    // can be much more complicated.
-    // Find out the rotating position from |starting_key_id| and apply on |key|.
-    std::vector<uint8_t> starting_key_id(kKeyId, kKeyId + arraysize(kKeyId));
-    for (size_t pos = 0; pos < starting_key_id.size(); ++pos) {
-      std::rotate(starting_key_id.begin(), starting_key_id.begin() + pos,
-                  starting_key_id.end());
-      if (key_id == starting_key_id) {
-        key->assign(kSecretKey, kSecretKey + arraysize(kSecretKey));
-        std::rotate(key->begin(), key->begin() + pos, key->end());
-        return true;
-      }
-    }
-    return false;
+    // With key rotation.
+    return LookupTestKeyVector(key_id, true, key);
   }
 
   uint32_t num_distinct_need_key_calls_;
 };
 
 // Ignores the encrypted event and does not perform a license request.
 class NoResponseApp : public FakeEncryptedMedia::AppBase {
  public:
   void OnSessionMessage(const std::string& session_id,
                         MediaKeys::MessageType message_type,
@@ skipping 1323 matching lines @@
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)

[ddorwin, 2016/06/23 19:42:01]

It would be better if we could always run this test but expect a failure. See,
for example, the HEVC tests in ToT.

[dougsteed, 2016/09/25 21:52:30]

As you mention below, this was an unrelated change by servolk@. I will inform
him so he can consider these three comments.

 TEST_F(PipelineIntegrationTest, Mp2ts_AAC_HE_SBR_Audio) {
   EXPECT_CALL(*this, OnDurationChange()).Times(AnyNumber());
 
   MockMediaSource source("bear-1280x720-aac_he.ts", kMP2AudioSBR,
                          kAppendWholeFile);
   StartPipelineWithMediaSource(&source);
 
   source.EndOfStream();
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   // When SBR is not taken into account correctly by mpeg2ts parser, it will

[ddorwin, 2016/06/23 19:42:01]

[I guess this was added in another CL, but I'm only seeing it now (via the
rebase).]

Does/can this happen or does this describe why you are checking this. If the
latter, please reword.

[dougsteed, 2016/09/25 21:52:30]

will inform servolk@

[servolk, 2016/09/26 23:15:20]

It's both the former and the latter. This did happen in the past, but this test
will enforce that to not happen again.
This comment explains why we are checking GetBufferedTimeRanges() here. We've
seen that when SBR is not taken into account properly, then audio parser emits
buffers with incorrect durations that are too short and that leads to buffered
time ranges having gaps. Per MSE spec gaps in buffered ranges must stall
playback, so I've tried to explain here that incorrect treatment of SBR on
mpeg2ts parser level leads to gaps and that, in turn, leads to stalled playback.
I'll try to reword to make it clearer.

   // estimate audio frame durations incorrectly and that will lead to gaps in
   // buffered ranges (so this check will fail) and stalled playback.

[ddorwin, 2016/06/23 19:42:01]

"stall"

[dougsteed, 2016/09/25 21:52:30]

ditto

[servolk, 2016/09/26 23:15:20]

I actually meant to say here that "... incorrect durations lead to ... gaps and
[cause] stalled playback".

   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
 }
 #endif
 
 TEST_F(PipelineIntegrationTest,
        MAYBE_EME(EncryptedPlayback_NoEncryptedFrames_MP4_CENC_AudioOnly)) {
   MockMediaSource source("bear-1280x720-a_frag-cenc_clear-all.mp4", kMP4Audio,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new NoResponseApp());
   StartPipelineWithEncryptedMedia(&source, &encrypted_media);
@@ skipping 375 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media