Support HEVC through EME

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 88 matching lines @@
 const char kAudioOnlyWebM[] = "video/webm; codecs=\"vorbis\"";
 const char kOpusAudioOnlyWebM[] = "video/webm; codecs=\"opus\"";
 const char kVideoOnlyWebM[] = "video/webm; codecs=\"vp8\"";
 #if defined(USE_PROPRIETARY_CODECS)
 const char kADTS[] = "audio/aac";
 const char kMP4[] = "video/mp4; codecs=\"avc1.4D4041,mp4a.40.2\"";
 const char kMP4VideoAVC3[] = "video/mp4; codecs=\"avc3.64001f\"";
 #if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
 const char kMP4VideoVP9[] = "video/mp4; codecs=\"vp09.00.00.08.01.01.00.00\"";
 #endif
+#if BUILDFLAG(ENABLE_HEVC_DEMUXING)
+const char kMP4VideoHEVC1[] = "video/mp4; codecs=\"hvc1.1.6.L93.B0\"";
+const char kMP4VideoHEVC2[] = "video/mp4; codecs=\"hev1.1.6.L93.B0\"";
+#endif
 const char kMP4Video[] = "video/mp4; codecs=\"avc1.4D4041\"";
 const char kMP4Audio[] = "audio/mp4; codecs=\"mp4a.40.2\"";
 const char kMP3[] = "audio/mpeg";
 #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.
@@ skipping 599 matching lines @@
         .Times(AnyNumber());
 
     // Encrypted content not used, so this is never called.
     EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
 
     demuxer_ = source->GetDemuxer();
     pipeline_->Start(demuxer_.get(), CreateRenderer(), this,
                      base::Bind(&PipelineIntegrationTest::OnStatusCallback,
                                 base::Unretained(this)));
     message_loop_.Run();
-    EXPECT_EQ(PIPELINE_OK, pipeline_status_);
+    EXPECT_EQ(pipeline_status_, expected_pipeline_status_);

[ddorwin, 2016/05/18 19:51:13]

Expected comes first in GTest.

[servolk, 2016/05/19 00:43:43]

Done.

     return pipeline_status_;
   }
 
   void StartPipelineWithEncryptedMedia(MockMediaSource* source,
                                        FakeEncryptedMedia* encrypted_media) {
     EXPECT_CALL(*source, InitSegmentReceived(_)).Times(AtLeast(1));
     EXPECT_CALL(*this, OnMetadata(_))
         .Times(AtMost(1))
         .WillRepeatedly(SaveArg<0>(&metadata_));
     EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
@@ skipping 14 matching lines @@
 
     pipeline_->Start(demuxer_.get(), CreateRenderer(), this,
                      base::Bind(&PipelineIntegrationTest::OnStatusCallback,
                                 base::Unretained(this)));
 
     source->set_encrypted_media_init_data_cb(
         base::Bind(&FakeEncryptedMedia::OnEncryptedMediaInitData,
                    base::Unretained(encrypted_media)));
 
     message_loop_.Run();
-    EXPECT_EQ(PIPELINE_OK, pipeline_status_);
+    EXPECT_EQ(pipeline_status_, expected_pipeline_status_);

[ddorwin, 2016/05/18 19:51:14]

ditto

[servolk, 2016/05/19 00:43:43]

Done.

   }
 
   // Verifies that seeking works properly for ChunkDemuxer when the
   // seek happens while there is a pending read on the ChunkDemuxer
   // and no data is available.
   bool TestSeekDuringRead(const std::string& filename,
                           const std::string& mimetype,
                           int initial_append_size,
                           base::TimeDelta start_seek_time,
                           base::TimeDelta seek_time,
@@ skipping 1128 matching lines @@
   ASSERT_EQ(PIPELINE_OK, pipeline_status_);
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
 }
 #endif  // #if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
 
+#if BUILDFLAG(ENABLE_HEVC_DEMUXING)
+TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VideoOnly_MP4_HEVC1) {
+  // Chromium supports HEVC demuxing, but not decoding, so we expect the decoder
+  // error to be reported here. It indicates that we did pass media mime type
+  // checks and attempted to actually demux and decode the stream.
+  expected_pipeline_status_ = DECODER_ERROR_NOT_SUPPORTED;

[ddorwin, 2016/05/18 19:51:14]

Adding a member variable to the base class is overly intrusive for these two
tests, and it is not consistently used base the base or its children.

It would be much simpler to add a new
StartPipelineWithMediaSourceAndExpectStatus() or something similar. The main
StartPipelineWithMediaSource will need to be updated to handle an additional
parameter.

[servolk, 2016/05/19 00:43:43]

I've decided to go a little further and introduce a new overload for
StartPipelineWithMediaSource function that consolidates the code that is
currently duplicated between StartPipelineWithMediaSource and
StartPipelineWithEncryptedMedia. The new function will simply return the
PipelineStatus without checking what it is, and then the old
StartPipelineWithMediaSource and StartPipelineWithEncryptedMedia can call it and
do the same checks as before.
All of that was done in a separate CL

+  MockMediaSource source("bear-320x240-v_frag-hevc.mp4", kMP4VideoHEVC1,
+                         kAppendWholeFile);
+  StartPipelineWithMediaSource(&source);
+}

[halliwell, 2016/05/13 01:53:20]

Where will these tests get run in practice?  Is it worth setting the buildflag
for public cast_shell bot and adding media tests to it?

[servolk, 2016/05/13 18:33:02]

Yes, these tests will run on cast_shell* trybots, HEVC demuxing is already
enabled there (and only there for now).
You can check out the logs for media_unittests on cast_shell_linux trybot in
this CL to confirm that these test cases got run there (the log link is
https://build.chromium.org/p/tryserver.chromium.linux/builders/cast_shell_lin...):
[2905/2936]
PipelineIntegrationTest.BasicPlayback_MediaSource_VideoOnly_MP4_HEVC1 (1 ms)
[2906/2936]
PipelineIntegrationTest.BasicPlayback_MediaSource_VideoOnly_MP4_HEVC2 (0 ms)

[servolk, 2016/05/13 18:42:51]

Btw, note that these tests actually use a regular playback code path. Perhaps we
should also add some new tests to
content/browser/media/encrypted_media_browsertest.cc for end-to-end testing of
this. But I have noticed that so far there's no proprietary codecs tests in
content/browser/media/encrypted_media_browsertest.cc at all.

+
+TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VideoOnly_MP4_HEVC2) {
+  // Chromium supports HEVC demuxing, but not decoding, so we expect the decoder
+  // error to be reported here. It indicates that we did pass media mime type
+  // checks and attempted to actually demux and decode the stream.
+  expected_pipeline_status_ = DECODER_ERROR_NOT_SUPPORTED;
+  MockMediaSource source("bear-320x240-v_frag-hevc.mp4", kMP4VideoHEVC2,
+                         kAppendWholeFile);
+  StartPipelineWithMediaSource(&source);
+}
+#endif  // #if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
+
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
 TEST_F(PipelineIntegrationTest, SeekWhilePaused) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
 
   base::TimeDelta duration(pipeline_->GetMediaDuration());
   base::TimeDelta start_seek_time(duration / 4);
   base::TimeDelta seek_time(duration * 3 / 4);
 
   Play();
@@ skipping 251 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