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 65 matching lines @@
     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));
+
     demuxer_.reset(new FFmpegDemuxer(message_loop_.message_loop_proxy(),
                                      data_source_.get(),
                                      need_key_cb,
                                      new MediaLog()));
   }
 
   MOCK_METHOD1(CheckPoint, void(int v));
 
-  void InitializeDemuxer() {
+  void InitializeDemuxerText(bool enable_text) {
     EXPECT_CALL(host_, SetDuration(_));
     WaitableMessageLoopEvent event;
-    demuxer_->Initialize(&host_, event.GetPipelineStatusCB());
+    demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), enable_text);
     event.RunAndWaitForStatus(PIPELINE_OK);
   }
 
+  void InitializeDemuxer() {
+    InitializeDemuxerText(false);
+  }
+
   MOCK_METHOD2(OnReadDoneCalled, void(int, int64));
 
   // Verifies that |buffer| has a specific |size| and |timestamp|.
   // |location| simply indicates where the call to this function was made.
   // This makes it easier to track down where test failures occur.
   void OnReadDone(const tracked_objects::Location& location,
                   int size, int64 timestampInMicroseconds,
                   DemuxerStream::Status status,
                   const scoped_refptr<DecoderBuffer>& buffer) {
     std::string location_str;
@@ skipping 81 matching lines @@
     EXPECT_TRUE(data_source_->Initialize(file_path));
   }
 
   DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxerTest);
 };
 
 TEST_F(FFmpegDemuxerTest, Initialize_OpenFails) {
   // Simulate avformat_open_input() failing.
   CreateDemuxer("ten_byte_file");
   WaitableMessageLoopEvent event;
-  demuxer_->Initialize(&host_, event.GetPipelineStatusCB());
+  demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), true);
   event.RunAndWaitForStatus(DEMUXER_ERROR_COULD_NOT_OPEN);
 }
 
 // TODO(acolwell): Uncomment this test when we discover a file that passes
 // avformat_open_input(), but has avformat_find_stream_info() fail.
 //
 //TEST_F(FFmpegDemuxerTest, Initialize_ParseFails) {
 //  ("find_stream_info_fail.webm");
 //  demuxer_->Initialize(
 //      &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_PARSE));
 //  message_loop_.RunUntilIdle();
 //}
 
 TEST_F(FFmpegDemuxerTest, Initialize_NoStreams) {
   // Open a file with no streams whatsoever.
   CreateDemuxer("no_streams.webm");
   WaitableMessageLoopEvent event;
-  demuxer_->Initialize(&host_, event.GetPipelineStatusCB());
+  demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), true);
   event.RunAndWaitForStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_NoAudioVideo) {
   // Open a file containing streams but none of which are audio/video streams.
   CreateDemuxer("no_audio_video.webm");
   WaitableMessageLoopEvent event;
-  demuxer_->Initialize(&host_, event.GetPipelineStatusCB());
+  demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), true);
   event.RunAndWaitForStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_Successful) {
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
 
   // Video stream should be present.
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(stream);
@@ skipping 52 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)
+
+  CreateDemuxer("bear-vp8-webvtt.webm");
+  DemuxerStream* text_stream = NULL;
+  EXPECT_CALL(host_, AddTextStream(_, _))
+      .WillOnce(SaveArg<0>(&text_stream));
+  InitializeDemuxerText(true);
+  ASSERT_TRUE(text_stream);
+  EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
+
+  // 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());
+
+  // 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 19 matching lines @@
   // Attempt a read from the video stream and run the message loop until done.
   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   video->Read(NewReadCB(FROM_HERE, 22084, 0));
   message_loop_.Run();
 
   video->Read(NewReadCB(FROM_HERE, 1057, 33000));
   message_loop_.Run();
 }
 
+TEST_F(FFmpegDemuxerTest, Read_Text) {
+  // We test that on a successful text packet read.
+  CreateDemuxer("bear-vp8-webvtt.webm");
+  DemuxerStream* text_stream = NULL;
+  EXPECT_CALL(host_, AddTextStream(_, _))
+      .WillOnce(SaveArg<0>(&text_stream));
+  InitializeDemuxerText(true);
+  ASSERT_TRUE(text_stream);
+  EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
+
+  text_stream->Read(NewReadCB(FROM_HERE, 31, 0));
+  message_loop_.Run();
+
+  text_stream->Read(NewReadCB(FROM_HERE, 19, 500000));
+  message_loop_.Run();
+}
+
 TEST_F(FFmpegDemuxerTest, Read_VideoNonZeroStart) {
   // Test the start time is the first timestamp of the video and audio stream.
   CreateDemuxer("nonzero-start-time.webm");
   InitializeDemuxer();
 
   // Attempt a read from the video stream and run the message loop until done.
   DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
   DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   // Check first buffer in video stream.
   video->Read(NewReadCB(FROM_HERE, 5636, 400000));
   message_loop_.Run();
 
   // Check first buffer in audio stream.
   audio->Read(NewReadCB(FROM_HERE, 165, 396000));
   message_loop_.Run();
 
   // Verify that the start time is equal to the lowest timestamp (ie the audio).
   EXPECT_EQ(demuxer_->GetStartTime().InMicroseconds(), 396000);
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream) {
   // Verify that end of stream buffers are created.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
   ReadUntilEndOfStream();
 }
 
+TEST_F(FFmpegDemuxerTest, Read_EndOfStreamText) {
+  // Verify that end of stream buffers are created.
+  CreateDemuxer("bear-vp8-webvtt.webm");
+  DemuxerStream* text_stream = NULL;
+  EXPECT_CALL(host_, AddTextStream(_, _))
+      .WillOnce(SaveArg<0>(&text_stream));
+  InitializeDemuxerText(true);
+  ASSERT_TRUE(text_stream);
+  EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
+
+  bool got_eos_buffer = false;
+  const int kMaxBuffers = 10;
+  for (int i = 0; !got_eos_buffer && i < kMaxBuffers; i++) {
+    text_stream->Read(base::Bind(&EosOnReadDone, &got_eos_buffer));
+    message_loop_.Run();
+  }
+
+  EXPECT_TRUE(got_eos_buffer);
+}
+
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration) {
   // Verify that end of stream buffers are created.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
   set_duration_known(false);
   EXPECT_CALL(host_, SetDuration(_));
   ReadUntilEndOfStream();
 }
 
 TEST_F(FFmpegDemuxerTest, Seek) {
@@ skipping 28 matching lines @@
 
   // Video read #1.
   video->Read(NewReadCB(FROM_HERE, 5425, 801000));
   message_loop_.Run();
 
   // Video read #2.
   video->Read(NewReadCB(FROM_HERE, 1906, 834000));
   message_loop_.Run();
 }
 
+TEST_F(FFmpegDemuxerTest, SeekText) {
+  // We're testing that the demuxer frees all queued packets when it receives
+  // a Seek().
+  CreateDemuxer("bear-vp8-webvtt.webm");
+  DemuxerStream* text_stream = NULL;
+  EXPECT_CALL(host_, AddTextStream(_, _))
+      .WillOnce(SaveArg<0>(&text_stream));
+  InitializeDemuxerText(true);
+  ASSERT_TRUE(text_stream);
+  EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
+
+  // Get our streams.
+  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  ASSERT_TRUE(video);
+  ASSERT_TRUE(audio);
+
+  // Read a text packet and release it.
+  text_stream->Read(NewReadCB(FROM_HERE, 31, 0));
+  message_loop_.Run();
+
+  // Issue a simple forward seek, which should discard queued packets.
+  WaitableMessageLoopEvent event;
+  demuxer_->Seek(base::TimeDelta::FromMicroseconds(1000000),
+                 event.GetPipelineStatusCB());
+  event.RunAndWaitForStatus(PIPELINE_OK);
+
+  // Audio read #1.
+  audio->Read(NewReadCB(FROM_HERE, 145, 803000));
+  message_loop_.Run();
+
+  // Audio read #2.
+  audio->Read(NewReadCB(FROM_HERE, 148, 826000));
+  message_loop_.Run();
+
+  // Video read #1.
+  video->Read(NewReadCB(FROM_HERE, 5425, 801000));
+  message_loop_.Run();
+
+  // Video read #2.
+  video->Read(NewReadCB(FROM_HERE, 1906, 834000));
+  message_loop_.Run();
+
+  // Text read #1.
+  text_stream->Read(NewReadCB(FROM_HERE, 19, 500000));
+  message_loop_.Run();
+
+  // Text read #2.
+  text_stream->Read(NewReadCB(FROM_HERE, 19, 1000000));
+  message_loop_.Run();
+}
+
 class MockReadCB {
  public:
   MockReadCB() {}
   ~MockReadCB() {}
 
   MOCK_METHOD2(Run, void(DemuxerStream::Status status,
                          const scoped_refptr<DecoderBuffer>& buffer));
  private:
   DISALLOW_COPY_AND_ASSIGN(MockReadCB);
 };
@@ skipping 150 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