Return buffers from StreamParsers in a single unified map

media/formats/webm/webm_cluster_parser_unittest.cc

 // Copyright 2014 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 "media/formats/webm/webm_cluster_parser.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 161 matching lines @@
 std::unique_ptr<Cluster> CreateEncryptedCluster(int bytes_to_write) {
   CHECK_GT(bytes_to_write, 0);
   CHECK_LE(bytes_to_write, static_cast<int>(sizeof(kEncryptedFrame)));
 
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
   cb.AddSimpleBlock(kVideoTrackNum, 0, 0, kEncryptedFrame, bytes_to_write);
   return cb.Finish();
 }
 
-bool VerifyBuffers(const WebMClusterParser::BufferQueue& audio_buffers,
-                   const WebMClusterParser::BufferQueue& video_buffers,
-                   const WebMClusterParser::BufferQueue& text_buffers,
+bool VerifyBuffers(const StreamParser::BufferQueueMap& buffer_queue_map,
                    const BlockInfo* block_info,
                    int block_count) {
-  int buffer_count = audio_buffers.size() + video_buffers.size() +
-      text_buffers.size();
+  int buffer_count = 0;
+  for (const auto& it : buffer_queue_map)
+    buffer_count += it.second.size();
   if (block_count != buffer_count) {
     DVLOG(1) << __FUNCTION__ << " : block_count (" << block_count
              << ") mismatches buffer_count (" << buffer_count << ")";
     return false;
   }
 
   size_t audio_offset = 0;
   size_t video_offset = 0;
   size_t text_offset = 0;
   for (int i = 0; i < block_count; i++) {
-    const WebMClusterParser::BufferQueue* buffers = NULL;
+    const StreamParser::BufferQueue* buffers = NULL;
     size_t* offset;
     StreamParserBuffer::Type expected_type = DemuxerStream::UNKNOWN;
 
+    const auto& it = buffer_queue_map.find(block_info[i].track_num);
+    EXPECT_NE(buffer_queue_map.end(), it);
+    buffers = &it->second;
     if (block_info[i].track_num == kAudioTrackNum) {
-      buffers = &audio_buffers;
       offset = &audio_offset;
       expected_type = DemuxerStream::AUDIO;
     } else if (block_info[i].track_num == kVideoTrackNum) {
-      buffers = &video_buffers;
       offset = &video_offset;
       expected_type = DemuxerStream::VIDEO;
     } else if (block_info[i].track_num == kTextTrackNum) {
-      buffers = &text_buffers;
       offset = &text_offset;
       expected_type = DemuxerStream::TEXT;
     } else {
       LOG(ERROR) << "Unexpected track number " << block_info[i].track_num;
       return false;
     }
 
     if (*offset >= buffers->size()) {
       DVLOG(1) << __FUNCTION__ << " : Too few buffers (" << buffers->size()
                << ") for track_num (" << block_info[i].track_num
@@ skipping 10 matching lines @@
     EXPECT_EQ(block_info[i].track_num, buffer->track_id());
     EXPECT_EQ(block_info[i].is_key_frame, buffer->is_key_frame());
   }
 
   return true;
 }
 
 bool VerifyBuffers(const std::unique_ptr<WebMClusterParser>& parser,
                    const BlockInfo* block_info,
                    int block_count) {
-  const WebMClusterParser::TextBufferQueueMap& text_map =
-      parser->GetTextBuffers();
-  const WebMClusterParser::BufferQueue* text_buffers;
-  const WebMClusterParser::BufferQueue no_text_buffers;
-  if (!text_map.empty())
-    text_buffers = &(text_map.rbegin()->second);
-  else
-    text_buffers = &no_text_buffers;
-
-  return VerifyBuffers(parser->GetAudioBuffers(),
-                       parser->GetVideoBuffers(),
-                       *text_buffers,
-                       block_info,
-                       block_count);
+  StreamParser::BufferQueueMap buffers;
+  parser->GetBuffers(&buffers);
+  return VerifyBuffers(buffers, block_info, block_count);
 }
 
 bool VerifyTextBuffers(const std::unique_ptr<WebMClusterParser>& parser,
                        const BlockInfo* block_info_ptr,
                        int block_count,
                        int text_track_num,
                        const WebMClusterParser::BufferQueue& text_buffers) {
   const BlockInfo* const block_info_end = block_info_ptr + block_count;
 
   typedef WebMClusterParser::BufferQueue::const_iterator TextBufferIter;
@@ skipping 20 matching lines @@
   EXPECT_TRUE(buffer_iter == buffer_end);
   return true;
 }
 
 void VerifyEncryptedBuffer(scoped_refptr<StreamParserBuffer> buffer) {
   EXPECT_TRUE(buffer->decrypt_config());
   EXPECT_EQ(static_cast<unsigned long>(DecryptConfig::kDecryptionKeySize),
             buffer->decrypt_config()->iv().length());
 }
 
-void AppendToEnd(const WebMClusterParser::BufferQueue& src,
-                 WebMClusterParser::BufferQueue* dest) {
-  for (WebMClusterParser::BufferQueue::const_iterator itr = src.begin();
-       itr != src.end(); ++itr) {
-    dest->push_back(*itr);
-  }
-}
-
 }  // namespace
 
 class WebMClusterParserTest : public testing::Test {
  public:
   WebMClusterParserTest()
       : media_log_(new StrictMock<MockMediaLog>()),
         parser_(CreateDefaultParser()) {}
 
  protected:
   void ResetParserToHaveDefaultDurations() {
@@ skipping 193 matching lines @@
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kDefaultBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, ParseClusterWithMultipleCalls) {
   int block_count = arraysize(kDefaultBlockInfo);
   std::unique_ptr<Cluster> cluster(
       CreateCluster(0, kDefaultBlockInfo, block_count));
 
-  WebMClusterParser::BufferQueue audio_buffers;
-  WebMClusterParser::BufferQueue video_buffers;
-  const WebMClusterParser::BufferQueue no_text_buffers;
-
   const uint8_t* data = cluster->data();
   int size = cluster->size();
   int default_parse_size = 3;
   int parse_size = std::min(default_parse_size, size);
 
   while (size > 0) {
     int result = parser_->Parse(data, parse_size);
     ASSERT_GE(result, 0);
     ASSERT_LE(result, parse_size);
 
     if (result == 0) {
       // The parser needs more data so increase the parse_size a little.
       parse_size += default_parse_size;
       parse_size = std::min(parse_size, size);
       continue;
     }
 

[wolenetz, 2016/08/23 21:31:21]

The point of this unit test is to verify the behavior of incremental parses,
which involve incremental GetBuffers(). Please restore that to this test.

[servolk, 2016/08/23 23:56:32]

Wait, perhaps I'm missing something. This test still does multiple calls to
parser_->Parse. As far as I can see AppendToEnd haven't done any additional
verification of those intermediate results, and simply appended the buffers that
were ready so far to audio/video_buffers. The final verification was done
outside the loop. So I thought I've preserved the intended behavior here, no?

[wolenetz, 2016/08/24 21:57:51]

Hmm. I can see how this was confusing. WebMStreamParser executes incremental
parses, with getbuffers between each. This test was intended to mimic that
behavior. Especially on a muxed cluster, the "ready buffers" calculations are
important to not emit any frames with timestamp greater than any
parsed-but-with-duration-not-known-yet frames in the cluster. At cluster
boundary, all such frames are known. Incremental getBuffers tests the common
case where a full cluster might not be appended to the stream parser yet;
conforming to the reality where each Parse is interleaved with a GetBuffers.
Other tests in this file overlap this a little, but with specific cases around
where durations might be estimated or unknown until cluster end. Please restore
incremental getbuffers.

[servolk, 2016/08/24 23:17:44]

Ah, ok, restored calling GetBuffers after each Parse.

-    AppendToEnd(parser_->GetAudioBuffers(), &audio_buffers);
-    AppendToEnd(parser_->GetVideoBuffers(), &video_buffers);
-
     parse_size = default_parse_size;
 
     data += result;
     size -= result;
   }
-  ASSERT_TRUE(VerifyBuffers(audio_buffers, video_buffers,
-                            no_text_buffers, kDefaultBlockInfo,
-                            block_count));
+  StreamParser::BufferQueueMap buffers;
+  parser_->GetBuffers(&buffers);
+  ASSERT_TRUE(VerifyBuffers(buffers, kDefaultBlockInfo, block_count));
 }
 
 // Verify that both BlockGroups with the BlockDuration before the Block
 // and BlockGroups with the BlockDuration after the Block are supported
 // correctly.
 // Note: Raw bytes are use here because ClusterBuilder only generates
 // one of these scenarios.
 TEST_F(WebMClusterParserTest, ParseBlockGroup) {
   const BlockInfo kBlockInfo[] = {
       {kAudioTrackNum, 0, 23, false, NULL, 0, true},
@@ skipping 181 matching lines @@
 
   parser_.reset(CreateParserWithKeyIdsAndAudioCodec(
       std::string(), "video_key_id", kUnknownAudioCodec));
 
   // The encrypted cluster contains just one block, video.
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(
       WebMClusterParser::kDefaultVideoBufferDurationInMs));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
-  ASSERT_EQ(1UL, parser_->GetVideoBuffers().size());
-  scoped_refptr<StreamParserBuffer> buffer = parser_->GetVideoBuffers()[0];
+  StreamParser::BufferQueueMap buffers;
+  parser_->GetBuffers(&buffers);
+  EXPECT_EQ(1UL, buffers[kVideoTrackNum].size());
+  scoped_refptr<StreamParserBuffer> buffer = buffers[kVideoTrackNum][0];
   VerifyEncryptedBuffer(buffer);
 }
 
 TEST_F(WebMClusterParserTest, ParseBadEncryptedBlock) {
   std::unique_ptr<Cluster> cluster(
       CreateEncryptedCluster(sizeof(kEncryptedFrame) - 1));
 
   parser_.reset(CreateParserWithKeyIdsAndAudioCodec(
       std::string(), "video_key_id", kUnknownAudioCodec));
   int result = parser_->Parse(cluster->data(), cluster->size());
@@ skipping 109 matching lines @@
 
   // Send slightly less than the first full cluster so all but the last video
   // block is parsed. Verify the last fully parsed audio and video buffer are
   // both missing from the result (parser should hold them aside for duration
   // estimation prior to end of cluster detection in the absence of
   // DefaultDurations.)
   int result = parser_->Parse(cluster1->data(), cluster1->size() - 1);
   EXPECT_GT(result, 0);
   EXPECT_LT(result, cluster1->size());
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo1, block_count1 - 3));
-  EXPECT_EQ(3UL, parser_->GetAudioBuffers().size());
-  EXPECT_EQ(1UL, parser_->GetVideoBuffers().size());
+  StreamParser::BufferQueueMap buffers;
+  parser_->GetBuffers(&buffers);
+  EXPECT_EQ(3UL, buffers[kAudioTrackNum].size());
+  EXPECT_EQ(1UL, buffers[kVideoTrackNum].size());
 
   parser_->Reset();
 
   // Now parse the full first cluster and verify all the blocks are parsed.
   EXPECT_MEDIA_LOG(
       WebMSimpleBlockDurationEstimated(kExpectedAudioEstimationInMs));
   EXPECT_MEDIA_LOG(
       WebMSimpleBlockDurationEstimated(kExpectedVideoEstimationInMs));
   result = parser_->Parse(cluster1->data(), cluster1->size());
   EXPECT_EQ(cluster1->size(), result);
@@ skipping 50 matching lines @@
 
   // Send slightly less than the first full cluster so all but the last video
   // block is parsed. Verify the last fully parsed audio and video buffer are
   // both missing from the result (parser should hold them aside for duration
   // estimation prior to end of cluster detection in the absence of
   // DefaultDurations.)
   int result = parser_->Parse(cluster1->data(), cluster1->size() - 1);
   EXPECT_GT(result, 0);
   EXPECT_LT(result, cluster1->size());
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo1, block_count1 - 3));
-  EXPECT_EQ(3UL, parser_->GetAudioBuffers().size());
-  EXPECT_EQ(1UL, parser_->GetVideoBuffers().size());
+  StreamParser::BufferQueueMap buffers;
+  parser_->GetBuffers(&buffers);
+  EXPECT_EQ(3UL, buffers[kAudioTrackNum].size());
+  EXPECT_EQ(1UL, buffers[kVideoTrackNum].size());
 
   parser_->Reset();
 
   // Now parse the full first cluster and verify all the blocks are parsed.
   EXPECT_MEDIA_LOG(
       WebMSimpleBlockDurationEstimated(kExpectedAudioEstimationInMs));
   EXPECT_MEDIA_LOG(
       WebMSimpleBlockDurationEstimated(kExpectedVideoEstimationInMs));
   result = parser_->Parse(cluster1->data(), cluster1->size());
   EXPECT_EQ(cluster1->size(), result);
@@ skipping 214 matching lines @@
   int block_count = arraysize(kBlockInfo);
   std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
 
   // Will verify that duration of buffer matches that of BlockDuration.
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 }  // namespace media