Update ChunkDemuxer unit tests to use real muxed clusters.

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 379 matching lines @@
         block_duration = kTextBlockDuration;
         break;
     }
     ASSERT_NE(block_duration, 0);
     int end_timecode = timecode + block_count * block_duration;
     AppendCluster(source_id,
                   GenerateSingleStreamCluster(
                       timecode, end_timecode, track_number, block_duration));
   }
 
-  // |cluster_description| - A space delimited string of buffer info that
-  //  is used to construct a cluster. Each buffer info is a timestamp in
-  //  milliseconds and optionally followed by a 'K' to indicate that a buffer
-  //  should be marked as a keyframe. For example "0K 30 60" should constuct
-  //  a cluster with 3 blocks: a keyframe with timestamp 0 and 2 non-keyframes
-  //  at 30ms and 60ms.
-  void AppendSingleStreamCluster(const std::string& source_id, int track_number,
-                                 const std::string& cluster_description) {
+  struct BlockInfo {
+    BlockInfo()
+        : track_number(0),
+          timestamp_in_ms(0),
+          flags(0),
+          duration(0) {
+    }
+
+    BlockInfo(int tn, int ts, int f, int d)
+        : track_number(tn),
+          timestamp_in_ms(ts),
+          flags(f),
+          duration(d) {
+    }
+
+    int track_number;
+    int timestamp_in_ms;
+    int flags;
+    int duration;
+
+    bool operator< (const BlockInfo& rhs) const {
+      return timestamp_in_ms < rhs.timestamp_in_ms;
+    }
+  };
+
+  // |track_number| - The track number to place in
+  // |block_descriptions| - A space delimited string of block info that
+  //  is used to populate |blocks|. Each block info has a timestamp in
+  //  milliseconds and optionally followed by a 'K' to indicate that a block
+  //  should be marked as a keyframe. For example "0K 30 60" should populate
+  //  |blocks| with 3 BlockInfo objects: a keyframe with timestamp 0 and 2
+  //  non-keyframes at 30ms and 60ms.
+  void ParseBlockDescriptions(int track_number,
+                              const std::string block_descriptions,
+                              std::vector<BlockInfo>* blocks) {
     std::vector<std::string> timestamps;
-    base::SplitString(cluster_description, ' ', &timestamps);
+    base::SplitString(block_descriptions, ' ', &timestamps);
 
-    ClusterBuilder cb;
-    std::vector<uint8> data(10);
     for (size_t i = 0; i < timestamps.size(); ++i) {
       std::string timestamp_str = timestamps[i];
-      int block_flags = 0;
+      BlockInfo block_info;
+      block_info.track_number = track_number;
+      block_info.flags = 0;
+      block_info.duration = 0;
+
       if (EndsWith(timestamp_str, "K", true)) {
-        block_flags = kWebMFlagKeyframe;
+        block_info.flags = kWebMFlagKeyframe;
         // Remove the "K" off of the token.
         timestamp_str = timestamp_str.substr(0, timestamps[i].length() - 1);
       }
-      int timestamp_in_ms;
-      CHECK(base::StringToInt(timestamp_str, &timestamp_in_ms));
-
-      if (i == 0)
-        cb.SetClusterTimecode(timestamp_in_ms);
+      CHECK(base::StringToInt(timestamp_str, &block_info.timestamp_in_ms));
 
       if (track_number == kTextTrackNum ||
           track_number == kAlternateTextTrackNum) {
-        cb.AddBlockGroup(track_number, timestamp_in_ms, kTextBlockDuration,
-                         block_flags, &data[0], data.size());
+        block_info.duration = kTextBlockDuration;
+        ASSERT_EQ(kWebMFlagKeyframe, block_info.flags)
+            << "Text block with timestamp " << block_info.timestamp_in_ms
+            << " was not marked as a keyframe."
+            << " All text blocks must be keyframes";
+      }
+
+      blocks->push_back(block_info);
+    }
+  }
+
+  scoped_ptr<Cluster> GenerateCluster(const std::vector<BlockInfo>& blocks,
+                                      bool unknown_size) {
+    DCHECK_GT(blocks.size(), 0u);
+    ClusterBuilder cb;
+
+    std::vector<uint8> data(10);
+    for (size_t i = 0; i < blocks.size(); ++i) {
+      if (i == 0)
+        cb.SetClusterTimecode(blocks[i].timestamp_in_ms);
+
+      if (blocks[i].duration) {
+        if (blocks[i].track_number == kVideoTrackNum) {
+          AddVideoBlockGroup(&cb,
+                             blocks[i].track_number, blocks[i].timestamp_in_ms,
+                             blocks[i].duration, blocks[i].flags);
+        } else {
+          cb.AddBlockGroup(blocks[i].track_number, blocks[i].timestamp_in_ms,
+                           blocks[i].duration, blocks[i].flags,
+                           &data[0], data.size());
+        }
       } else {
-        cb.AddSimpleBlock(track_number, timestamp_in_ms, block_flags,
+        cb.AddSimpleBlock(blocks[i].track_number, blocks[i].timestamp_in_ms,
+                          blocks[i].flags,
                           &data[0], data.size());
       }
     }
-    AppendCluster(source_id, cb.Finish());
+
+    return unknown_size ? cb.FinishWithUnknownSize() : cb.Finish();
+  }
+
+  scoped_ptr<Cluster> GenerateCluster(
+      std::priority_queue<BlockInfo> block_queue,
+      bool unknown_size) {
+    std::vector<BlockInfo> blocks(block_queue.size());
+    for (size_t i = block_queue.size() - 1; !block_queue.empty(); --i) {
+      blocks[i] = block_queue.top();
+      block_queue.pop();
+    }
+
+    return GenerateCluster(blocks, unknown_size);
+  }
+
+  // |block_descriptions| - The block descriptions used to construct the
+  // cluster. See the documentation for ParseBlockDescriptions() for details on
+  // the string format.
+  void AppendSingleStreamCluster(const std::string& source_id, int track_number,
+                                 const std::string& block_descriptions) {
+    std::vector<BlockInfo> blocks;
+    ParseBlockDescriptions(track_number, block_descriptions, &blocks);
+    AppendCluster(source_id, GenerateCluster(blocks, false));
   }
 
   struct MuxedStreamInfo {
     MuxedStreamInfo()
         : track_number(0),
-          cluster_description("")
+          block_descriptions("")
     {}
 
-    MuxedStreamInfo(int track_num, const char* cluster_desc)
+    MuxedStreamInfo(int track_num, const char* block_desc)
         : track_number(track_num),
-          cluster_description(cluster_desc) {
+          block_descriptions(block_desc) {
     }
 
     int track_number;
-    // The cluster description passed to AppendSingleStreamCluster().
+    // The block description passed to ParseBlockDescriptions().
     // See the documentation for that method for details on the string format.
-    const char* cluster_description;
+    const char* block_descriptions;
   };
 
   void AppendMuxedCluster(const MuxedStreamInfo& msi_1,
                           const MuxedStreamInfo& msi_2) {
     std::vector<MuxedStreamInfo> msi(2);
     msi[0] = msi_1;
     msi[1] = msi_2;
     AppendMuxedCluster(msi);
   }
 
   void AppendMuxedCluster(const MuxedStreamInfo& msi_1,
                           const MuxedStreamInfo& msi_2,
                           const MuxedStreamInfo& msi_3) {
     std::vector<MuxedStreamInfo> msi(3);
     msi[0] = msi_1;
     msi[1] = msi_2;
     msi[2] = msi_3;
     AppendMuxedCluster(msi);
   }
 
   void AppendMuxedCluster(const std::vector<MuxedStreamInfo> msi) {
+    std::priority_queue<BlockInfo> block_queue;
     for (size_t i = 0; i < msi.size(); ++i) {
-      AppendSingleStreamCluster(kSourceId,
-                                msi[i].track_number,
-                                msi[i].cluster_description);
+      std::vector<BlockInfo> track_blocks;
+      ParseBlockDescriptions(msi[i].track_number, msi[i].block_descriptions,
+                             &track_blocks);
+
+      for (size_t j = 0; j < track_blocks.size(); ++j)
+        block_queue.push(track_blocks[j]);
     }
+
+    AppendCluster(kSourceId, GenerateCluster(block_queue, false));
   }
 
   void AppendData(const std::string& source_id,
                   const uint8* data, size_t length) {
     EXPECT_CALL(host_, AddBufferedTimeRange(_, _)).Times(AnyNumber());
 
     demuxer_->AppendData(source_id, data, length,
                          append_window_start_for_next_append_,
                          append_window_end_for_next_append_,
                          &timestamp_offset_map_[source_id]);
@@ skipping 224 matching lines @@
                                       int block_count) {
     return GenerateCluster(first_audio_timecode, first_video_timecode,
                            block_count, false);
   }
   scoped_ptr<Cluster> GenerateCluster(int first_audio_timecode,
                                       int first_video_timecode,
                                       int block_count,
                                       bool unknown_size) {
     CHECK_GT(block_count, 0);
 
-    int size = 10;
-    scoped_ptr<uint8[]> data(new uint8[size]);
-
-    ClusterBuilder cb;
-    cb.SetClusterTimecode(std::min(first_audio_timecode, first_video_timecode));
+    std::priority_queue<BlockInfo> block_queue;
 
     if (block_count == 1) {
-      cb.AddBlockGroup(kAudioTrackNum, first_audio_timecode,
-                       kAudioBlockDuration, kWebMFlagKeyframe,
-                       data.get(), size);
-      return cb.Finish();
+      block_queue.push(BlockInfo(kAudioTrackNum,
+                                 first_audio_timecode,
+                                 kWebMFlagKeyframe,
+                                 kAudioBlockDuration));
+      return GenerateCluster(block_queue, unknown_size);
     }
 
     int audio_timecode = first_audio_timecode;
     int video_timecode = first_video_timecode;
 
     // Create simple blocks for everything except the last 2 blocks.
     // The first video frame must be a keyframe.
     uint8 video_flag = kWebMFlagKeyframe;
     for (int i = 0; i < block_count - 2; i++) {
       if (audio_timecode <= video_timecode) {
-        cb.AddSimpleBlock(kAudioTrackNum, audio_timecode, kWebMFlagKeyframe,
-                          data.get(), size);
+        block_queue.push(BlockInfo(kAudioTrackNum,
+                                   audio_timecode,
+                                   kWebMFlagKeyframe,
+                                   0));
         audio_timecode += kAudioBlockDuration;
         continue;
       }
 
-      cb.AddSimpleBlock(kVideoTrackNum, video_timecode, video_flag, data.get(),
-                        size);
+      block_queue.push(BlockInfo(kVideoTrackNum,
+                                 video_timecode,
+                                 video_flag,
+                                 0));
       video_timecode += kVideoBlockDuration;
       video_flag = 0;
     }
 
     // Make the last 2 blocks BlockGroups so that they don't get delayed by the
     // block duration calculation logic.
-    if (audio_timecode <= video_timecode) {
-      cb.AddBlockGroup(kAudioTrackNum, audio_timecode, kAudioBlockDuration,
-                       kWebMFlagKeyframe, data.get(), size);
-      AddVideoBlockGroup(&cb, kVideoTrackNum, video_timecode,
-                         kVideoBlockDuration, video_flag);
-    } else {
-      AddVideoBlockGroup(&cb, kVideoTrackNum, video_timecode,
-                         kVideoBlockDuration, video_flag);
-      cb.AddBlockGroup(kAudioTrackNum, audio_timecode, kAudioBlockDuration,
-                       kWebMFlagKeyframe, data.get(), size);
-    }
+    block_queue.push(BlockInfo(kAudioTrackNum,
+                               audio_timecode,
+                               kWebMFlagKeyframe,
+                               kAudioBlockDuration));
+    block_queue.push(BlockInfo(kVideoTrackNum,
+                               video_timecode,
+                               video_flag,
+                               kVideoBlockDuration));
 
-    return unknown_size ? cb.FinishWithUnknownSize() : cb.Finish();
+    return GenerateCluster(block_queue, unknown_size);
   }
 
   scoped_ptr<Cluster> GenerateSingleStreamCluster(int timecode,
                                                   int end_timecode,
                                                   int track_number,
                                                   int block_duration) {
     CHECK_GT(end_timecode, timecode);
 
     std::vector<uint8> data(kBlockSize);
 
@@ skipping 501 matching lines @@
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
       HAS_TEXT | HAS_AUDIO | HAS_VIDEO, false, false));
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(audio_stream && video_stream && text_stream);
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "0 23K"),
       MuxedStreamInfo(kVideoTrackNum, "0 30K"),
-      MuxedStreamInfo(kTextTrackNum, "0 40K"));
-  CheckExpectedRanges(kSourceId, "{ [30,46) }");
+      MuxedStreamInfo(kTextTrackNum, "25K 40K"));
+  CheckExpectedRanges(kSourceId, "{ [23,46) }");
 
   AppendInitSegment(HAS_TEXT | HAS_AUDIO | HAS_VIDEO);
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "46 69K"),
       MuxedStreamInfo(kVideoTrackNum, "60 90K"),
-      MuxedStreamInfo(kTextTrackNum, "80 90K"));
-  CheckExpectedRanges(kSourceId, "{ [30,92) }");
+      MuxedStreamInfo(kTextTrackNum, "80K 90K"));
+  CheckExpectedRanges(kSourceId, "{ [23,92) }");
 
   CheckExpectedBuffers(audio_stream, "23 69");
   CheckExpectedBuffers(video_stream, "30 90");
-
-  // WebM parser marks all text buffers as keyframes.
-  CheckExpectedBuffers(text_stream, "0 40 80 90");
+  CheckExpectedBuffers(text_stream, "25 40 80 90");
 }
 
 // Make sure that the demuxer reports an error if Shutdown()
 // is called before all the initialization segments are appended.
 TEST_F(ChunkDemuxerTest, Shutdown_BeforeAllInitSegmentsAppended) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
           kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
@@ skipping 1143 matching lines @@
   // Verify that the range extends to the end of the video data.
   CheckExpectedRanges("{ [0,66) }");
 
   // Verify that the range reverts to the intersection when end of stream
   // has been cancelled.
   demuxer_->UnmarkEndOfStream();
   CheckExpectedRanges("{ [0,46) }");
 
   // Append and remove data so that the 2 streams' end ranges do not overlap.
 
-  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(246)));
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(398)));
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "200K 223K"),
       MuxedStreamInfo(kVideoTrackNum, "200K 233 266 299 332K 365"));
 
   // At this point, the per-stream ranges are as follows:
   // Audio: [0,46) [200,246)
   // Video: [0,66) [200,398)
   CheckExpectedRanges("{ [0,46) [200,246) }");
 
@@ skipping 864 matching lines @@
   // Append a cluster that starts before and ends after the append
   // window.
   AppendMuxedCluster(
       MuxedStreamInfo(kVideoTrackNum,
                       "0K 30 60 90 120K 150 180 210 240K 270 300 330K"),
       MuxedStreamInfo(kTextTrackNum, "0K 100K 200K 300K" ));
 
   // Verify that text cues that start outside the window are not included
   // in the buffer. Also verify that cues that extend beyond the
   // window are not included.
-  CheckExpectedRanges(kSourceId, "{ [120,270) }");
+  CheckExpectedRanges(kSourceId, "{ [100,270) }");
   CheckExpectedBuffers(video_stream, "120 150 180 210 240");
   CheckExpectedBuffers(text_stream, "100");
 
   // Extend the append window to [20,650).
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(650);
 
   // Append more data and verify that a new range is created.
   AppendMuxedCluster(
       MuxedStreamInfo(kVideoTrackNum,
                       "360 390 420K 450 480 510 540K 570 600 630K"),
       MuxedStreamInfo(kTextTrackNum, "400K 500K 600K 700K" ));
-  CheckExpectedRanges(kSourceId, "{ [120,270) [420,630) }");
+  CheckExpectedRanges(kSourceId, "{ [100,270) [400,630) }");
 
   // Seek to the new range and verify that the expected buffers are returned.
   Seek(base::TimeDelta::FromMilliseconds(420));
   CheckExpectedBuffers(video_stream, "420 450 480 510 540 570 600");
   CheckExpectedBuffers(text_stream, "400 500");
 }
 
 TEST_F(ChunkDemuxerTest, StartWaitingForSeekAfterParseError) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
@@ skipping 112 matching lines @@
   // Append text cues that start after the seek point and verify that
   // they are returned by Read() calls.
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "220K 240K 260K 280K"),
       MuxedStreamInfo(kVideoTrackNum, "240K 270 300 330"),
       MuxedStreamInfo(kTextTrackNum, "225K 275K 325K"));
 
   message_loop_.RunUntilIdle();
   EXPECT_TRUE(text_read_done);
 
-  // NOTE: we start at 175 here because the buffer at 125 was returned
+  // NOTE: we start at 275 here because the buffer at 225 was returned
   // to the pending read initiated above.
   CheckExpectedBuffers(text_stream, "275 325");
 
   // Verify that audio & video streams continue to return expected values.
   CheckExpectedBuffers(audio_stream, "160 180");
   CheckExpectedBuffers(video_stream, "180 210");
 }
 
 TEST_F(ChunkDemuxerTest, ClusterWithUnknownSize) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
@@ skipping 23 matching lines @@
 TEST_F(ChunkDemuxerTest, CuesBetweenClusters) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendCluster(GenerateCluster(0, 0, 4));
   AppendData(kCuesHeader, sizeof(kCuesHeader));
   AppendCluster(GenerateCluster(46, 66, 5));
   CheckExpectedRanges(kSourceId, "{ [0,115) }");
 }
 
 }  // namespace media