Render inband text tracks in the media pipeline

media/filters/ffmpeg_demuxer_unittest.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 <algorithm>
 #include <deque>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 54 matching lines @@
   FFmpegDemuxerTest() {}
 
   virtual ~FFmpegDemuxerTest() {
     if (demuxer_) {
       WaitableMessageLoopEvent event;
       demuxer_->Stop(event.GetClosure());
       event.RunAndWait();
     }
   }
 
-  void CreateDemuxer(const std::string& name) {
+  void CreateDemuxerText(const std::string& name, bool enable_text) {
     CHECK(!demuxer_);
 
     EXPECT_CALL(host_, SetTotalBytes(_)).Times(AnyNumber());
     EXPECT_CALL(host_, AddBufferedByteRange(_, _)).Times(AnyNumber());
     EXPECT_CALL(host_, AddBufferedTimeRange(_, _)).Times(AnyNumber());
 
     CreateDataSource(name);
 
     Demuxer::NeedKeyCB need_key_cb =
         base::Bind(&FFmpegDemuxerTest::NeedKeyCB, base::Unretained(this));
+
+    media::FFmpegAddTextTrackCB add_text_track_cb;
+    if (enable_text) {
+      add_text_track_cb =
+          base::Bind(&FFmpegDemuxerTest::AddTextTrackCB,
+                     base::Unretained(this));
+    }
+
     demuxer_.reset(new FFmpegDemuxer(message_loop_.message_loop_proxy(),
                                      data_source_.get(),
                                      need_key_cb,
+                                     add_text_track_cb,
                                      new MediaLog()));
   }
 
+  void CreateDemuxer(const std::string& name) {
+    CreateDemuxerText(name, false);
+  }
+
   MOCK_METHOD1(CheckPoint, void(int v));
 
   void InitializeDemuxer() {
     EXPECT_CALL(host_, SetDuration(_));
     WaitableMessageLoopEvent event;
     demuxer_->Initialize(&host_, event.GetPipelineStatusCB());
     event.RunAndWaitForStatus(PIPELINE_OK);
   }
 
   MOCK_METHOD2(OnReadDoneCalled, void(int, int64));
@@ skipping 32 matching lines @@
   // (http://code.google.com/p/googletest/issues/detail?id=395) or when we use
   // std::string instead of scoped_ptr<uint8[]> (http://crbug.com/130689).
   MOCK_METHOD3(NeedKeyCBMock, void(const std::string& type,
                                    const uint8* init_data, int init_data_size));
   void NeedKeyCB(const std::string& type,
                  const std::vector<uint8>& init_data) {
     const uint8* init_data_ptr = init_data.empty() ? NULL : &init_data[0];
     NeedKeyCBMock(type, init_data_ptr, init_data.size());
   }
 
+  void AddTextTrackCB(media::TextKind kind,
+                      const std::string& label,
+                      const std::string& language,
+                      int index) {
+  }
+
   // Accessor to demuxer internals.
   void set_duration_known(bool duration_known) {
     demuxer_->duration_known_ = duration_known;
   }
 
   bool IsStreamStopped(DemuxerStream::Type type) {
     DemuxerStream* stream = demuxer_->GetStream(type);
     CHECK(stream);
     return !static_cast<FFmpegDemuxerStream*>(stream)->demuxer_;
   }
@@ skipping 137 matching lines @@
   // Audio stream should be Vorbis.
   stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
   EXPECT_EQ(kCodecVorbis, stream->audio_decoder_config().codec());
 
   // Unknown stream should never be present.
   EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
 }
 
+TEST_F(FFmpegDemuxerTest, Initialize_MultitrackText) {
+  // Open a file containing the following streams:
+  //   Stream #0: Video (VP8)
+  //   Stream #1: Audio (Vorbis)
+  //   Stream #2: Text (WebVTT)
+
+  CreateDemuxerText("bear-vp8-webvtt.webm", true);
+  InitializeDemuxer();
+
+  // Video stream should be VP8.
+  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  ASSERT_TRUE(stream);
+  EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
+  EXPECT_EQ(kCodecVP8, stream->video_decoder_config().codec());
+
+  // Audio stream should be Vorbis.
+  stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  ASSERT_TRUE(stream);
+  EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
+  EXPECT_EQ(kCodecVorbis, stream->audio_decoder_config().codec());
+
+  // Text stream should also be present.
+  stream = demuxer_->GetStream(DemuxerStream::TEXT);
+  ASSERT_TRUE(stream);
+  EXPECT_EQ(DemuxerStream::TEXT, stream->type());
+
+  // Unknown stream should never be present.
+  EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
+}
+
+// TODO(matthewjheaney): Enable this test when the binary file lands.
+TEST_F(FFmpegDemuxerTest, DISABLED_Initialize_MultitrackTwoTextStreams) {
+  // Open a file containing the following streams:
+  //   Stream #0: Video (VP8)
+  //   Stream #1: Audio (Vorbis)
+  //   Stream #2: Text (WebVTT)
+  //   Stream #3: Text (WebVTT)
+
+  CreateDemuxerText("bear-vp8-webvtt2.webm", true);
+  InitializeDemuxer();
+
+  int stream_count = demuxer_->GetStreamCount();
+  EXPECT_EQ(4, stream_count);

[acolwell GONE FROM CHROMIUM, 2013/09/12 00:15:15]

nit: inline here since the count isn't used anywhere else.

[Matthew Heaney (Chromium), 2013/09/13 19:51:54]

Done.

[Matthew Heaney (Chromium), 2013/09/20 23:53:54]

This is OBE anyway, since GetStreamCount and friends is now gone.

+
+  // Video stream should be VP8.
+  DemuxerStream* stream = demuxer_->GetStreamByIndex(0);
+  ASSERT_TRUE(stream);
+  EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
+  EXPECT_EQ(kCodecVP8, stream->video_decoder_config().codec());
+
+  // Audio stream should be Vorbis.
+  stream = demuxer_->GetStreamByIndex(1);
+  ASSERT_TRUE(stream);
+  EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
+  EXPECT_EQ(kCodecVorbis, stream->audio_decoder_config().codec());
+
+  // First text stream should be present.
+  stream = demuxer_->GetStreamByIndex(2);
+  ASSERT_TRUE(stream);
+  EXPECT_EQ(DemuxerStream::TEXT, stream->type());
+
+  // Second text stream should be present.
+  stream = demuxer_->GetStreamByIndex(3);
+  ASSERT_TRUE(stream);
+  EXPECT_EQ(DemuxerStream::TEXT, stream->type());
+
+  // Unknown stream should never be present.
+  EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
+}
+
 TEST_F(FFmpegDemuxerTest, Initialize_Encrypted) {
   EXPECT_CALL(*this, NeedKeyCBMock(kWebMEncryptInitDataType, NotNull(),
                                    DecryptConfig::kDecryptionKeySize))
       .Times(Exactly(2));
 
   CreateDemuxer("bear-320x240-av_enc-av.webm");
   InitializeDemuxer();
 }
 
 TEST_F(FFmpegDemuxerTest, Read_Audio) {
@@ skipping 265 matching lines @@
 TEST_F(FFmpegDemuxerTest, MP4_ZeroStszEntry) {
 #if !defined(USE_PROPRIETARY_CODECS)
   return;
 #endif
   CreateDemuxer("bear-1280x720-zero-stsz-entry.mp4");
   InitializeDemuxer();
   ReadUntilEndOfStream();
 }
 
 }  // namespace media