Implement support for 2 source ids (1 for audio and 1 for video).

media/filters/chunk_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 "base/bind.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_demuxer_host.h"
 #include "media/base/test_data_util.h"
@@ skipping 58 matching lines @@
       arg->GetTimestamp().InMilliseconds() == timestamp_in_ms;
 }
 
 static void OnReadDone(const base::TimeDelta& expected_time,
                        bool* called,
                        const scoped_refptr<DecoderBuffer>& buffer) {
   EXPECT_EQ(expected_time, buffer->GetTimestamp());
   *called = true;
 }
 
+static void OnReadDone_EOSExpected(bool* called,
+                                   const scoped_refptr<DecoderBuffer>& buffer) {
+  EXPECT_TRUE(buffer->IsEndOfStream());
+  *called = true;
+}
+
 class MockChunkDemuxerClient : public ChunkDemuxerClient {
  public:
   MockChunkDemuxerClient() {}
   virtual ~MockChunkDemuxerClient() {}
 
   MOCK_METHOD1(DemuxerOpened, void(ChunkDemuxer* demuxer));
   MOCK_METHOD0(DemuxerClosed, void());
   // TODO(xhwang): This is a workaround of the issue that move-only parameters
   // are not supported in mocked methods. Remove this when the issue is fixed.
   // See http://code.google.com/p/googletest/issues/detail?id=395
@@ skipping 101 matching lines @@
                    video_track_entry->GetDataSize() +
                    video_content_encodings->GetDataSize() -
                    kVideoTrackEntryHeaderSize);
         buf += video_content_encodings->GetDataSize();
       }
       buf += video_track_entry->GetDataSize();
     }
   }
 
   ChunkDemuxer::Status AddId() {
-    std::vector<std::string> codecs(2);
-    codecs[0] = "vp8";
-    codecs[1] = "vorbis";
-    return demuxer_->AddId(kSourceId, "video/webm", codecs);
+    return AddId(kSourceId, true, true);
+  }
+
+  ChunkDemuxer::Status AddId(const std::string& source_id,
+                             bool has_audio, bool has_video) {
+    std::vector<std::string> codecs;
+    std::string type;
+
+    if (has_audio) {
+      codecs.push_back("vorbis");
+      type = "audio/webm";
+    }
+
+    if (has_video) {
+      codecs.push_back("vp8");
+      type = "video/webm";
+    }
+
+    if (!has_audio && !has_video) {
+      return AddId(kSourceId, true, true);
+    }
+
+    return demuxer_->AddId(source_id, type, codecs);
   }
 
   bool AppendData(const uint8* data, size_t length) {
+    return AppendData(kSourceId, data, length);
+  }
+
+  bool AppendData(const std::string& source_id,
+                  const uint8* data, size_t length) {
     CHECK(length);
     EXPECT_CALL(host_, AddBufferedByteRange(_, _)).Times(AnyNumber())
         .WillRepeatedly(SaveArg<1>(&buffered_bytes_));
-    return demuxer_->AppendData(kSourceId, data, length);
+    return demuxer_->AppendData(source_id, data, length);
   }
 
   bool AppendDataInPieces(const uint8* data, size_t length) {
     return AppendDataInPieces(data, length, 7);
   }
 
   bool AppendDataInPieces(const uint8* data, size_t length, size_t piece_size) {
     const uint8* start = data;
     const uint8* end = data + length;
     while (start < end) {
       int64 old_buffered_bytes = buffered_bytes_;
       size_t append_size = std::min(piece_size,
                                     static_cast<size_t>(end - start));
       if (!AppendData(start, append_size))
         return false;
       start += append_size;
 
       EXPECT_GT(buffered_bytes_, old_buffered_bytes);
     }
     return true;
   }
 
   bool AppendInitSegment(bool has_audio, bool has_video,
                          bool video_content_encoded) {
+    return AppendInitSegment(kSourceId, has_audio, has_video,
+                             video_content_encoded);
+  }
+
+  bool AppendInitSegment(const std::string& source_id,
+                         bool has_audio, bool has_video,
+                         bool video_content_encoded) {
     scoped_array<uint8> info_tracks;
     int info_tracks_size = 0;
     CreateInitSegment(has_audio, has_video, video_content_encoded,
                       &info_tracks, &info_tracks_size);
-    return AppendData(info_tracks.get(), info_tracks_size);
+    return AppendData(source_id, info_tracks.get(), info_tracks_size);
   }
 
   void InitDoneCalled(PipelineStatus expected_status,
                       PipelineStatus status) {
     EXPECT_EQ(status, expected_status);
   }
 
   PipelineStatusCB CreateInitDoneCB(const base::TimeDelta& expected_duration,
                                     PipelineStatus expected_status) {
     if (expected_status == PIPELINE_OK)
       EXPECT_CALL(host_, SetDuration(expected_duration));
 
     return base::Bind(&ChunkDemuxerTest::InitDoneCalled,
                       base::Unretained(this),
                       expected_status);
   }
 
   bool InitDemuxer(bool has_audio, bool has_video,
                    bool video_content_encoded) {
     PipelineStatus expected_status =
         (has_audio || has_video) ? PIPELINE_OK : DEMUXER_ERROR_COULD_NOT_OPEN;
 
     EXPECT_CALL(*client_, DemuxerOpened(_));
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(kDefaultDuration(), expected_status));
 
-    if (AddId() != ChunkDemuxer::kOk)
+    if (AddId(kSourceId, has_audio, has_video) != ChunkDemuxer::kOk)
       return false;
 
     return AppendInitSegment(has_audio, has_video, video_content_encoded);
   }
 
+  bool InitDemuxerAudioAndVideoSources(const std::string& audio_id,
+                                       const std::string& video_id) {
+    EXPECT_CALL(*client_, DemuxerOpened(_));
+    demuxer_->Initialize(
+        &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
+
+    if (AddId(audio_id, true, false) != ChunkDemuxer::kOk)
+      return false;
+    if (AddId(video_id, false, true) != ChunkDemuxer::kOk)
+      return false;
+
+    bool success = AppendInitSegment(audio_id, true, false, false);
+    success &= AppendInitSegment(video_id, false, true, false);
+    return success;
+  }
+
   void ShutdownDemuxer() {
     if (demuxer_) {
       EXPECT_CALL(*client_, DemuxerClosed());
       demuxer_->Shutdown();
     }
   }
 
   void AddSimpleBlock(ClusterBuilder* cb, int track_num, int64 timecode) {
     uint8 data[] = { 0x00 };
     cb->AddSimpleBlock(track_num, timecode, 0, data, sizeof(data));
@@ skipping 46 matching lines @@
     } else {
       cb.AddBlockGroup(kVideoTrackNum, video_timecode, kVideoBlockDuration,
                        video_flag, data.get(), size);
       cb.AddBlockGroup(kAudioTrackNum, audio_timecode, kAudioBlockDuration,
                        kWebMFlagKeyframe, data.get(), size);
     }
 
     return cb.Finish();
   }
 
+  scoped_ptr<Cluster> GenerateSingleStreamCluster(int timecode,
+                                                  int block_count,
+                                                  int track_number,
+                                                  int block_duration) {
+    CHECK_GT(block_count, 0);
+
+    int size = 10;
+    scoped_array<uint8> data(new uint8[size]);
+
+    ClusterBuilder cb;
+    cb.SetClusterTimecode(timecode);
+
+    // Create simple blocks for everything except the last block.
+    for (int i = 0; i < block_count - 1; i++) {
+      cb.AddSimpleBlock(track_number, timecode, kWebMFlagKeyframe,
+                        data.get(), size);
+      timecode += block_duration;
+    }
+
+    // Make the last block a BlockGroup so that it doesn't get delayed by the
+    // block duration calculation logic.
+    cb.AddBlockGroup(track_number, timecode, block_duration,
+                      kWebMFlagKeyframe, data.get(), size);
+    return cb.Finish();
+  }
+
   void GenerateExpectedReads(int timecode, int block_count,
                              DemuxerStream* audio,
                              DemuxerStream* video) {
     CHECK_GT(block_count, 0);
     int audio_timecode = timecode;
     int video_timecode = timecode;
 
     if (block_count == 1) {
       ExpectRead(audio, audio_timecode);
       return;
     }
 
     for (int i = 0; i < block_count; i++) {
       if (audio_timecode <= video_timecode) {
         ExpectRead(audio, audio_timecode);
         audio_timecode += kAudioBlockDuration;
         continue;
       }
 
       ExpectRead(video, video_timecode);
       video_timecode += kVideoBlockDuration;
     }
   }
 
+  void GenerateExpectedReads(int timecode, int block_count,
+                             DemuxerStream* stream, int block_duration) {
+    CHECK_GT(block_count, 0);
+    int stream_timecode = timecode;
+
+    for (int i = 0; i < block_count; i++) {
+      ExpectRead(stream, stream_timecode);
+      stream_timecode += block_duration;
+    }
+  }
+
   MOCK_METHOD1(ReadDone, void(const scoped_refptr<DecoderBuffer>&));
 
   void ExpectRead(DemuxerStream* stream, int64 timestamp_in_ms) {
     EXPECT_CALL(*this, ReadDone(HasTimestamp(timestamp_in_ms)));
     stream->Read(base::Bind(&ChunkDemuxerTest::ReadDone,
                             base::Unretained(this)));
   }
 
   MOCK_METHOD1(Checkpoint, void(int id));
 
   struct BufferTimestamps {
     int video_time_ms;
     int audio_time_ms;
   };
   static const int kSkip = -1;
 
   // Test parsing a WebM file.
   // |filename| - The name of the file in media/test/data to parse.
   // |timestamps| - The expected timestamps on the parsed buffers.
   //    a timestamp of kSkip indicates that a Read() call for that stream
   //    shouldn't be made on that iteration of the loop. If both streams have
   //    a kSkip then the loop will terminate.
   bool ParseWebMFile(const std::string& filename,
                      const BufferTimestamps* timestamps,
                      const base::TimeDelta& duration) {
+    return ParseWebMFile(filename, timestamps, duration, true, true);
+  }
+
+  bool ParseWebMFile(const std::string& filename,
+                     const BufferTimestamps* timestamps,
+                     const base::TimeDelta& duration,
+                     bool has_audio, bool has_video) {
     EXPECT_CALL(*client_, DemuxerOpened(_));
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(duration, PIPELINE_OK));
 
-    if (AddId() != ChunkDemuxer::kOk)
+    if (AddId(kSourceId, has_audio, has_video) != ChunkDemuxer::kOk)
       return false;
 
     // Read a WebM file into memory and send the data to the demuxer.
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
     if (!AppendDataInPieces(buffer->GetData(), buffer->GetDataSize(), 512))
       return false;
 
     scoped_refptr<DemuxerStream> audio =
         demuxer_->GetStream(DemuxerStream::AUDIO);
     scoped_refptr<DemuxerStream> video =
@@ skipping 567 matching lines @@
   struct BufferTimestamps buffer_timestamps[] = {
     {kSkip, 0},
     {kSkip, 3},
     {kSkip, 6},
     {kSkip, 9},
     {kSkip, 12},
     {kSkip, kSkip},
   };
 
   ASSERT_TRUE(ParseWebMFile("bear-320x240-audio-only.webm", buffer_timestamps,
-                            base::TimeDelta::FromMilliseconds(2744)));
+                            base::TimeDelta::FromMilliseconds(2744),
+                            true, false));
 }
 
 TEST_F(ChunkDemuxerTest, TestWebMFile_VideoOnly) {
   struct BufferTimestamps buffer_timestamps[] = {
     {0, kSkip},
     {33, kSkip},
     {67, kSkip},
     {100, kSkip},
     {133, kSkip},
     {kSkip, kSkip},
   };
 
   ASSERT_TRUE(ParseWebMFile("bear-320x240-video-only.webm", buffer_timestamps,
-                            base::TimeDelta::FromMilliseconds(2703)));
+                            base::TimeDelta::FromMilliseconds(2703),
+                            false, true));
 }
 
 TEST_F(ChunkDemuxerTest, TestWebMFile_AltRefFrames) {
   struct BufferTimestamps buffer_timestamps[] = {
     {0, 0},
     {33, 3},
     {33, 6},
     {67, 9},
     {100, 12},
     {kSkip, kSkip},
@@ skipping 125 matching lines @@
 
   // Append another identical initialization segment.
   ASSERT_TRUE(AppendInitSegment(true, true, false));
 
   scoped_ptr<Cluster> cluster_b(kDefaultSecondCluster());
   ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size()));
 
   GenerateExpectedReads(0, 9, audio, video);
 }
 
+TEST_F(ChunkDemuxerTest, TestAddSeparateSourcesForAudioAndVideo) {
+  std::string audio_id = "audio1";
+  std::string video_id = "video1";
+  ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
+
+  scoped_refptr<DemuxerStream> audio =
+      demuxer_->GetStream(DemuxerStream::AUDIO);
+  scoped_refptr<DemuxerStream> video =
+      demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  scoped_ptr<Cluster> cluster_a(
+      GenerateSingleStreamCluster(0, 4, kAudioTrackNum, kAudioBlockDuration));
+
+  scoped_ptr<Cluster> cluster_v(
+      GenerateSingleStreamCluster(0, 4, kVideoTrackNum, kVideoBlockDuration));
+
+  // Append audio and video data into separate source ids.
+  ASSERT_TRUE(AppendData(audio_id, cluster_a->data(), cluster_a->size()));
+  GenerateExpectedReads(0, 4, audio, kAudioBlockDuration);
+  ASSERT_TRUE(AppendData(video_id, cluster_v->data(), cluster_v->size()));
+  GenerateExpectedReads(0, 4, video, kVideoBlockDuration);
+}
+
+TEST_F(ChunkDemuxerTest, TestAddIdFailures) {
+  EXPECT_CALL(*client_, DemuxerOpened(_));
+  demuxer_->Initialize(
+      &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
+
+  std::string audio_id = "audio1";
+  std::string video_id = "video1";
+
+  ASSERT_EQ(AddId(audio_id, true, false), ChunkDemuxer::kOk);
+
+  // Adding an id with audio/video should fail because we already added audio.
+  ASSERT_EQ(AddId(), ChunkDemuxer::kReachedIdLimit);
+
+  ASSERT_TRUE(AppendInitSegment(audio_id, true, false, false));
+
+  // Adding an id after append should fail.
+  ASSERT_EQ(AddId(video_id, false, true), ChunkDemuxer::kReachedIdLimit);
+}
+
+// Test that Read() calls after a RemoveId() return "end of stream" buffers.
+TEST_F(ChunkDemuxerTest, TestRemoveId) {
+  std::string audio_id = "audio1";
+  std::string video_id = "video1";
+  ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
+
+  scoped_ptr<Cluster> cluster_a(
+      GenerateSingleStreamCluster(0, 4, kAudioTrackNum, kAudioBlockDuration));
+
+  scoped_ptr<Cluster> cluster_v(
+      GenerateSingleStreamCluster(0, 4, kVideoTrackNum, kVideoBlockDuration));
+
+  // Append audio and video data into separate source ids.
+  ASSERT_TRUE(AppendData(audio_id, cluster_a->data(), cluster_a->size()));
+  ASSERT_TRUE(AppendData(video_id, cluster_v->data(), cluster_v->size()));
+
+  // Read() from audio should return normal buffers.
+  scoped_refptr<DemuxerStream> audio =
+      demuxer_->GetStream(DemuxerStream::AUDIO);
+  GenerateExpectedReads(0, 4, audio, kAudioBlockDuration);
+
+  // Remove the audio id.
+  demuxer_->RemoveId(audio_id);
+
+  // Read() from audio should return "end of stream" buffers.
+  bool audio_read_done = false;
+  audio->Read(base::Bind(&OnReadDone_EOSExpected,
+                         &audio_read_done));
+  EXPECT_TRUE(audio_read_done);
+
+  // Read() from video should still return normal buffers.
+  scoped_refptr<DemuxerStream> video =
+      demuxer_->GetStream(DemuxerStream::VIDEO);
+  GenerateExpectedReads(0, 4, video, kVideoBlockDuration);
+}
+
+// Test that Seek() successfully seeks to all source IDs.
+TEST_F(ChunkDemuxerTest, TestSeekAudioAndVideoSources) {
+  std::string audio_id = "audio1";
+  std::string video_id = "video1";
+  ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
+
+  scoped_ptr<Cluster> cluster_a1(
+      GenerateSingleStreamCluster(0, 4, kAudioTrackNum, kAudioBlockDuration));
+
+  scoped_ptr<Cluster> cluster_v1(
+      GenerateSingleStreamCluster(0, 4, kVideoTrackNum, kVideoBlockDuration));
+
+  ASSERT_TRUE(AppendData(audio_id, cluster_a1->data(), cluster_a1->size()));
+  ASSERT_TRUE(AppendData(video_id, cluster_v1->data(), cluster_v1->size()));
+
+  // Read() should return buffers at 0.
+  bool audio_read_done = false;
+  bool video_read_done = false;
+  scoped_refptr<DemuxerStream> audio =
+      demuxer_->GetStream(DemuxerStream::AUDIO);
+  scoped_refptr<DemuxerStream> video =
+      demuxer_->GetStream(DemuxerStream::VIDEO);
+
+  audio->Read(base::Bind(&OnReadDone,
+                         base::TimeDelta::FromMilliseconds(0),
+                         &audio_read_done));
+  video->Read(base::Bind(&OnReadDone,
+                         base::TimeDelta::FromMilliseconds(0),
+                         &video_read_done));
+  EXPECT_TRUE(audio_read_done);
+  EXPECT_TRUE(video_read_done);
+
+  // Seek to 3 (an unbuffered region).
+  demuxer_->StartWaitingForSeek();
+  demuxer_->Seek(base::TimeDelta::FromSeconds(3),
+                 NewExpectedStatusCB(PIPELINE_OK));
+
+  audio_read_done = false;
+  video_read_done = false;
+  audio->Read(base::Bind(&OnReadDone,
+                         base::TimeDelta::FromSeconds(3),
+                         &audio_read_done));
+  video->Read(base::Bind(&OnReadDone,
+                         base::TimeDelta::FromSeconds(3),
+                         &video_read_done));
+
+  // Read()s should not return until after data is appended at the Seek point.
+  EXPECT_FALSE(audio_read_done);
+  EXPECT_FALSE(video_read_done);
+
+  scoped_ptr<Cluster> cluster_a2(
+      GenerateSingleStreamCluster(3000, 4, kAudioTrackNum,
+                                  kAudioBlockDuration));
+
+  scoped_ptr<Cluster> cluster_v2(
+      GenerateSingleStreamCluster(3000, 4, kVideoTrackNum,
+                                  kVideoBlockDuration));
+
+  ASSERT_TRUE(AppendData(audio_id, cluster_a2->data(), cluster_a2->size()));
+  ASSERT_TRUE(AppendData(video_id, cluster_v2->data(), cluster_v2->size()));
+
+  // Read() should return buffers at 3.
+  EXPECT_TRUE(audio_read_done);
+  EXPECT_TRUE(video_read_done);
+}
+
 }  // namespace media