MSE: Add StreamParser buffer remuxing utility and tests

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "media/base/decrypt_config.h"
 #include "media/formats/webm/cluster_builder.h"
@@ skipping 78 matching lines @@
                           const WebMClusterParser::BufferQueue& video_buffers,
                           const WebMClusterParser::BufferQueue& text_buffers,
                           const BlockInfo* block_info,
                           int block_count) {
   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;
     size_t* offset;
+    StreamParserBuffer::Type expected_type = DemuxerStream::UNKNOWN;
 
     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())
       return false;
 
     scoped_refptr<StreamParserBuffer> buffer = (*buffers)[(*offset)++];
 
-
-    EXPECT_EQ(buffer->timestamp().InMilliseconds(), block_info[i].timestamp);
+    EXPECT_EQ(block_info[i].timestamp, buffer->timestamp().InMilliseconds());
 
     if (!block_info[i].use_simple_block)
-      EXPECT_NE(buffer->duration(), kNoTimestamp());
+      EXPECT_NE(kNoTimestamp(), buffer->duration());
 
     if (buffer->duration() != kNoTimestamp())
-      EXPECT_EQ(buffer->duration().InMilliseconds(), block_info[i].duration);
+      EXPECT_EQ(block_info[i].duration, buffer->duration().InMilliseconds());
+
+    EXPECT_EQ(expected_type, buffer->type());
+    if (expected_type == DemuxerStream::TEXT)
+      EXPECT_EQ(kTextTrackNum, buffer->text_track_number());
   }
 
   return true;
 }
 
 static bool VerifyBuffers(const scoped_ptr<WebMClusterParser>& parser,
                           const BlockInfo* block_info,
                           int block_count) {
   const WebMClusterParser::TextBufferQueueMap& text_map =
       parser->GetTextBuffers();
@@ skipping 26 matching lines @@
   while (block_info_ptr != block_info_end) {
     const BlockInfo& block_info = *block_info_ptr++;
 
     if (block_info.track_num != text_track_num)
       continue;
 
     EXPECT_FALSE(block_info.use_simple_block);
     EXPECT_FALSE(buffer_iter == buffer_end);
 
     const scoped_refptr<StreamParserBuffer> buffer = *buffer_iter++;
-    EXPECT_EQ(buffer->timestamp().InMilliseconds(), block_info.timestamp);
-    EXPECT_EQ(buffer->duration().InMilliseconds(), block_info.duration);
+    EXPECT_EQ(block_info.timestamp, buffer->timestamp().InMilliseconds());
+    EXPECT_EQ(block_info.duration, buffer->duration().InMilliseconds());
+    EXPECT_EQ(DemuxerStream::TEXT, buffer->type());
+    EXPECT_EQ(text_track_num, buffer->text_track_number());
   }
 
   EXPECT_TRUE(buffer_iter == buffer_end);
   return true;
 }
 
 static void VerifyEncryptedBuffer(
     scoped_refptr<StreamParserBuffer> buffer) {
   EXPECT_TRUE(buffer->decrypt_config());
   EXPECT_EQ(static_cast<unsigned long>(DecryptConfig::kDecryptionKeySize),
@@ skipping 34 matching lines @@
   // parsed.
   int result = parser_->Parse(cluster->data(), cluster->size() - 1);
   EXPECT_GT(result, 0);
   EXPECT_LT(result, cluster->size());
 
   ASSERT_TRUE(VerifyBuffers(parser_, kDefaultBlockInfo, block_count - 1));
   parser_->Reset();
 
   // Now parse a whole cluster to verify that all the blocks will get parsed.
   result = parser_->Parse(cluster->data(), cluster->size());
-  EXPECT_EQ(result, cluster->size());
+  EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kDefaultBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, ParseClusterWithSingleCall) {
   int block_count = arraysize(kDefaultBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kDefaultBlockInfo, block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
-  EXPECT_EQ(cluster->size(), result);
+  EXPECT_EQ(result, cluster->size());

[xhwang, 2014/02/06 00:36:32]

why reverse this order?

[wolenetz, 2014/02/06 23:56:03]

My mistake. Fixed.

   ASSERT_TRUE(VerifyBuffers(parser_, kDefaultBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, ParseClusterWithMultipleCalls) {
   int block_count = arraysize(kDefaultBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kDefaultBlockInfo, block_count));
 
   WebMClusterParser::BufferQueue audio_buffers;
   WebMClusterParser::BufferQueue video_buffers;
   const WebMClusterParser::BufferQueue no_text_buffers;
@@ skipping 48 matching lines @@
     0x9B, 0x81, 0x17,  // BlockDuration(size=1, value=23)
     0xA1, 0x85, 0x81, 0x00, 0x00, 0x00, 0xaa,  // Block(size=5, track=1, ts=0)
     // BlockGroup with BlockDuration after Block.
     0xA0, 0x8A,  // BlockGroup(size=10)
     0xA1, 0x85, 0x82, 0x00, 0x21, 0x00, 0x55,  // Block(size=5, track=2, ts=33)
     0x9B, 0x81, 0x22,  // BlockDuration(size=1, value=34)
   };
   const int kClusterSize = sizeof(kClusterData);
 
   int result = parser_->Parse(kClusterData, kClusterSize);
-  EXPECT_EQ(result, kClusterSize);
+  EXPECT_EQ(kClusterSize, result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, ParseSimpleBlockAndBlockGroupMixture) {
   const BlockInfo kBlockInfo[] = {
     { kAudioTrackNum, 0, 23, true },
     { kAudioTrackNum, 23, 23, false },
     { kVideoTrackNum, 33, 34, true },
     { kAudioTrackNum, 46, 23, false },
     { kVideoTrackNum, 67, 33, false },
@@ skipping 199 matching lines @@
                                       LogCB()));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(-1, result);
 }
 
 TEST_F(WebMClusterParserTest, ParseInvalidZeroSizedCluster) {
   const uint8 kBuffer[] = {
     0x1F, 0x43, 0xB6, 0x75, 0x80,  // CLUSTER (size = 0)
   };
 
-  EXPECT_EQ(parser_->Parse(kBuffer, sizeof(kBuffer)), -1);
+  EXPECT_EQ(-1, parser_->Parse(kBuffer, sizeof(kBuffer)));
 }
 
 TEST_F(WebMClusterParserTest, ParseInvalidUnknownButActuallyZeroSizedCluster) {
   const uint8 kBuffer[] = {
     0x1F, 0x43, 0xB6, 0x75, 0xFF,  // CLUSTER (size = "unknown")
     0x1F, 0x43, 0xB6, 0x75, 0x85,  // CLUSTER (size = 5)
   };
 
-  EXPECT_EQ(parser_->Parse(kBuffer, sizeof(kBuffer)), -1);
+  EXPECT_EQ(-1, parser_->Parse(kBuffer, sizeof(kBuffer)));
 }
 
 }  // namespace media