Stop audio FFmpegDemuxerStreams if we get notified that audio rendering is disabled.

media/filters/ffmpeg_demuxer_unittest.cc

 // Copyright (c) 2011 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 <deque>
 
 #include "base/file_path.h"
 #include "base/path_service.h"
 #include "base/threading/thread.h"
 #include "media/base/filters.h"
@@ skipping 108 matching lines @@
   // when streaming video). Uses this data source to initialize a demuxer, then
   // returns true if the bitrate is valid, false otherwise.
   bool VideoHasValidBitrate(
       const std::string& file_name, bool disable_file_size) {
     scoped_refptr<FileDataSource> data_source =
         CreateDataSource(file_name, disable_file_size);
     InitializeDemuxer(data_source);
     return demuxer_->GetBitrate() > 0;
   }
 
+  bool IsStreamStopped(DemuxerStream::Type type) {
+    DemuxerStream* stream = demuxer_->GetStream(type);
+    CHECK(stream);
+    return static_cast<FFmpegDemuxerStream*>(stream)->stopped_;
+  }
+
   // Fixture members.
   scoped_refptr<FFmpegDemuxer> demuxer_;
   StrictMock<MockFilterHost> host_;
   MessageLoop message_loop_;
 
   int64 current_read_position_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxerTest);
 };
@@ skipping 11 matching lines @@
 // av_open_input_file(), but has av_find_stream_info() fail.
 //
 //TEST_F(FFmpegDemuxerTest, Initialize_ParseFails) {
 //  demuxer_->Initialize(
 //      CreateDataSource("find_stream_info_fail.webm"),
 //      NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_PARSE));
 //  message_loop_.RunAllPending();
 //}
 
 TEST_F(FFmpegDemuxerTest, Initialize_NoStreams) {
-  // Open a file with no parseable streams.
+  // Open a file with no streams whatsoever.
   EXPECT_CALL(host_, SetCurrentReadPosition(_));
   demuxer_->Initialize(
       CreateDataSource("no_streams.webm"),
       NewExpectedStatusCB(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
   message_loop_.RunAllPending();
 }
 
-// TODO(acolwell): Find a subtitle only file so we can uncomment this test.
-//
-//TEST_F(FFmpegDemuxerTest, Initialize_DataStreamOnly) {
-//  demuxer_->Initialize(
-//      CreateDataSource("subtitles_only.mp4"),,
-//      NewExpectedStatusCB(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
-//  message_loop_.RunAllPending();
-//}
+TEST_F(FFmpegDemuxerTest, Initialize_NoAudioVideo) {
+  // Open a file containing streams but none of which are audio/video streams.
+  demuxer_->Initialize(
+      CreateDataSource("no_audio_video.webm"),
+      NewExpectedStatusCB(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
+  message_loop_.RunAllPending();
+}
 
 TEST_F(FFmpegDemuxerTest, Initialize_Successful) {
   InitializeDemuxer(CreateDataSource("bear-320x240.webm"));
 
   // Video stream should be present.
   scoped_refptr<DemuxerStream> stream =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
 
@@ skipping 18 matching lines @@
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
 
   const AudioDecoderConfig& audio_config = stream->audio_decoder_config();
   EXPECT_EQ(kCodecVorbis, audio_config.codec());
   EXPECT_EQ(16, audio_config.bits_per_channel());
   EXPECT_EQ(CHANNEL_LAYOUT_STEREO, audio_config.channel_layout());
   EXPECT_EQ(44100, audio_config.samples_per_second());
   EXPECT_TRUE(audio_config.extra_data());
   EXPECT_GT(audio_config.extra_data_size(), 0u);
+
+  // Unknown stream should never be present.
+  EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
+}
+
+TEST_F(FFmpegDemuxerTest, Initialize_Multitrack) {
+  // Open a file containing the following streams:
+  //   Stream #0: Video (VP8)
+  //   Stream #1: Audio (Vorbis)
+  //   Stream #2: Subtitles (SRT)
+  //   Stream #3: Video (Theora)
+  //   Stream #4: Audio (16-bit signed little endian PCM)
+  //
+  // We should only pick the first audio/video streams we come across.
+  InitializeDemuxer(CreateDataSource("bear-320x240-multitrack.webm"));
+
+  // Video stream should be VP8.
+  scoped_refptr<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, Read_Audio) {
   // We test that on a successful audio packet read.
   InitializeDemuxer(CreateDataSource("bear-320x240.webm"));
 
   // Attempt a read from the audio stream and run the message loop until done.
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
@@ skipping 260 matching lines @@
   message_loop_.RunAllPending();
 
   // Get our streams.
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(video);
   ASSERT_TRUE(audio);
 
-  // Attempt a read from the video stream and run the message loop until done.
+  // The audio stream should have been prematurely stopped.
+  EXPECT_FALSE(IsStreamStopped(DemuxerStream::VIDEO));
+  EXPECT_TRUE(IsStreamStopped(DemuxerStream::AUDIO));
+
+  // Attempt a read from the video stream: it should return valid data.
   scoped_refptr<DemuxerStreamReader> reader(new DemuxerStreamReader());
   reader->Read(video);
   message_loop_.RunAllPending();
-  EXPECT_TRUE(reader->called());
+  ASSERT_TRUE(reader->called());
   ValidateBuffer(FROM_HERE, reader->buffer(), 22084, 0);
 
+  // Attempt a read from the audio stream: it should immediately return end of
+  // stream without requiring the message loop to read data.
   reader->Reset();
   reader->Read(audio);
-  message_loop_.RunAllPending();
-  EXPECT_TRUE(reader->called());
+  ASSERT_TRUE(reader->called());
   EXPECT_TRUE(reader->buffer()->IsEndOfStream());
 }
 
 class MockFFmpegDemuxer : public FFmpegDemuxer {
  public:
   explicit MockFFmpegDemuxer(MessageLoop* message_loop)
       : FFmpegDemuxer(message_loop, true) {
   }
   virtual ~MockFFmpegDemuxer() {}
 
@@ skipping 181 matching lines @@
   message_loop_.RunAllPending();
   EXPECT_TRUE(reader->called());
   ValidateBuffer(FROM_HERE, reader->buffer(), 1740, 2436000);
 
   // Manually release the last reference to the buffer and verify it was freed.
   reader->Reset();
   message_loop_.RunAllPending();
 }
 
 }  // namespace media