Parsing of encoded duration for unencrypted opus streams.

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 <cstdlib>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "media/base/audio_decoder_config.h"
 #include "media/base/decrypt_config.h"
 #include "media/formats/webm/cluster_builder.h"
+#include "media/formats/webm/opus_packet_builder.h"
 #include "media/formats/webm/webm_cluster_parser.h"
 #include "media/formats/webm/webm_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::_;
 
 namespace media {
 
 typedef WebMTracksParser::TextTracks TextTracks;
 
 enum {
   kTimecodeScale = 1000000,  // Timecode scale for millisecond timestamps.
   kAudioTrackNum = 1,
   kVideoTrackNum = 2,
   kTextTrackNum = 3,
   kTestAudioFrameDefaultDurationInMs = 13,
   kTestVideoFrameDefaultDurationInMs = 17
 };
 
+// Test duration defaults must differ from parser estimation defaults to know
+// which durations parser used when emitting buffers.
 static_assert(
     static_cast<int>(kTestAudioFrameDefaultDurationInMs) !=
         static_cast<int>(WebMClusterParser::kDefaultAudioBufferDurationInMs),
     "test default is the same as estimation fallback audio duration");
 static_assert(
     static_cast<int>(kTestVideoFrameDefaultDurationInMs) !=
         static_cast<int>(WebMClusterParser::kDefaultVideoBufferDurationInMs),
     "test default is the same as estimation fallback video duration");
 
 struct BlockInfo {
   int track_num;
   int timestamp;
 
   // Negative value is allowed only for block groups (not simple blocks) and
   // directs CreateCluster() to exclude BlockDuration entry from the cluster for
   // this BlockGroup. The absolute value is used for parser verification.
   // For simple blocks, this value must be non-negative, and is used only for
   // parser verification.
-  int duration;
+  float duration;

[wolenetz, 2015/02/05 23:05:00]

In[Milli]SecondsF returns a double. why float elsewhere in this CL?

[chcunningham, 2015/02/06 03:20:10]

Done.

+
   bool use_simple_block;
+
+  // Default data will be used if no data given.
+  const uint8_t* data;
+  int data_length;
 };
 
 static const BlockInfo kDefaultBlockInfo[] = {
-  { kAudioTrackNum, 0, 23, true },
-  { kAudioTrackNum, 23, 23, true },
-  { kVideoTrackNum, 33, 34, true },  // Assumes not using DefaultDuration
-  { kAudioTrackNum, 46, 23, true },
-  { kVideoTrackNum, 67, 33, false },
-  { kAudioTrackNum, 69, 23, false },
-  { kVideoTrackNum, 100, 33, false },
+    {kAudioTrackNum, 0, 23, true, NULL, 0},
+    {kAudioTrackNum, 23, 23, true, NULL, 0},
+    // Assumes not using DefaultDuration
+    {kVideoTrackNum, 33, 34, true, NULL, 0},
+    {kAudioTrackNum, 46, 23, true, NULL, 0},
+    {kVideoTrackNum, 67, 33, false, NULL, 0},
+    {kAudioTrackNum, 69, 23, false, NULL, 0},
+    {kVideoTrackNum, 100, 33, false, NULL, 0},
 };
 
-static const uint8 kEncryptedFrame[] = {
+static const uint8_t kEncryptedFrame[] = {
   0x01,  // Block is encrypted
   0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08  // IV
 };
 
 static scoped_ptr<Cluster> CreateCluster(int timecode,
                                          const BlockInfo* block_info,
                                          int block_count) {
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
 
+  uint8_t kDefaultBlockData[] = { 0x00 };
+
   for (int i = 0; i < block_count; i++) {
-    uint8 data[] = { 0x00 };
+    const uint8_t* data;
+    int data_length;
+    if (block_info[i].data != NULL) {
+      data = block_info[i].data;
+      data_length = block_info[i].data_length;
+    } else {
+      data = kDefaultBlockData;
+      data_length = sizeof(kDefaultBlockData);
+    }
+
     if (block_info[i].use_simple_block) {
       CHECK_GE(block_info[i].duration, 0);
-      cb.AddSimpleBlock(block_info[i].track_num,
-                        block_info[i].timestamp,
-                        0, data, sizeof(data));
+      cb.AddSimpleBlock(block_info[i].track_num, block_info[i].timestamp, 0,
+                        data, data_length);
       continue;
     }
 
     if (block_info[i].duration < 0) {
       cb.AddBlockGroupWithoutBlockDuration(block_info[i].track_num,
-                                           block_info[i].timestamp,
-                                           0, data, sizeof(data));
+                                           block_info[i].timestamp, 0, data,
+                                           data_length);
       continue;
     }
 
-    cb.AddBlockGroup(block_info[i].track_num,
-                     block_info[i].timestamp,
-                     block_info[i].duration,
-                     0, data, sizeof(data));
+    cb.AddBlockGroup(block_info[i].track_num, block_info[i].timestamp,
+                     block_info[i].duration, 0, data, data_length);
   }
 
   return cb.Finish();
 }
 
 // Creates a Cluster with one encrypted Block. |bytes_to_write| is number of
 // bytes of the encrypted frame to write.
 static scoped_ptr<Cluster> CreateEncryptedCluster(int bytes_to_write) {
   CHECK_GT(bytes_to_write, 0);
   CHECK_LE(bytes_to_write, static_cast<int>(sizeof(kEncryptedFrame)));
@@ skipping 46 matching lines @@
       DVLOG(1) << __FUNCTION__ << " : Too few buffers (" << buffers->size()
                << ") for track_num (" << block_info[i].track_num
                << "), expected at least " << *offset + 1 << " buffers";
       return false;
     }
 
     scoped_refptr<StreamParserBuffer> buffer = (*buffers)[(*offset)++];
 
     EXPECT_EQ(block_info[i].timestamp, buffer->timestamp().InMilliseconds());
     EXPECT_EQ(std::abs(block_info[i].duration),
-              buffer->duration().InMilliseconds());
+              buffer->duration().InMillisecondsF());
     EXPECT_EQ(expected_type, buffer->type());
     EXPECT_EQ(block_info[i].track_num, buffer->track_id());
   }
 
   return true;
 }
 
 static bool VerifyBuffers(const scoped_ptr<WebMClusterParser>& parser,
                           const BlockInfo* block_info,
                           int block_count) {
@@ skipping 30 matching lines @@
 
     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(block_info.timestamp, buffer->timestamp().InMilliseconds());
     EXPECT_EQ(std::abs(block_info.duration),
-              buffer->duration().InMilliseconds());
+              buffer->duration().InMillisecondsF());
     EXPECT_EQ(DemuxerStream::TEXT, buffer->type());
     EXPECT_EQ(text_track_num, buffer->track_id());
   }
 
   EXPECT_TRUE(buffer_iter == buffer_end);
   return true;
 }
 
 static void VerifyEncryptedBuffer(
     scoped_refptr<StreamParserBuffer> buffer) {
@@ skipping 15 matching lines @@
   WebMClusterParserTest()
       : parser_(new WebMClusterParser(kTimecodeScale,
                                       kAudioTrackNum,
                                       kNoTimestamp(),
                                       kVideoTrackNum,
                                       kNoTimestamp(),
                                       TextTracks(),
                                       std::set<int64>(),
                                       std::string(),
                                       std::string(),
+                                      kUnknownAudioCodec,
                                       LogCB())) {}
 
  protected:
   void ResetParserToHaveDefaultDurations() {
     base::TimeDelta default_audio_duration = base::TimeDelta::FromMilliseconds(
         kTestAudioFrameDefaultDurationInMs);
     base::TimeDelta default_video_duration = base::TimeDelta::FromMilliseconds(
         kTestVideoFrameDefaultDurationInMs);
     ASSERT_GE(default_audio_duration, base::TimeDelta());
     ASSERT_GE(default_video_duration, base::TimeDelta());
     ASSERT_NE(kNoTimestamp(), default_audio_duration);
     ASSERT_NE(kNoTimestamp(), default_video_duration);
 
     parser_.reset(new WebMClusterParser(kTimecodeScale,
                                         kAudioTrackNum,
                                         default_audio_duration,
                                         kVideoTrackNum,
                                         default_video_duration,
                                         TextTracks(),
                                         std::set<int64>(),
                                         std::string(),
                                         std::string(),
+                                        kUnknownAudioCodec,
                                         LogCB()));
   }
 
   scoped_ptr<WebMClusterParser> parser_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebMClusterParserTest);
 };
 
 TEST_F(WebMClusterParserTest, HeldBackBufferHoldsBackAllTracks) {
@@ skipping 15 matching lines @@
   ASSERT_NE(kNoTimestamp(), default_audio_duration);
   parser_.reset(new WebMClusterParser(kTimecodeScale,
                                       kAudioTrackNum,
                                       default_audio_duration,
                                       kVideoTrackNum,
                                       kNoTimestamp(),
                                       text_tracks,
                                       std::set<int64>(),
                                       std::string(),
                                       std::string(),
+                                      kUnknownAudioCodec,
                                       LogCB()));
 
   const BlockInfo kBlockInfo[] = {
-    { kVideoTrackNum, 0, 33, true },
-    { kAudioTrackNum, 0, 23, false },
-    { kTextTrackNum, 10, 42, false },
-    { kAudioTrackNum, 23, kTestAudioFrameDefaultDurationInMs, true },
-    { kVideoTrackNum, 33, 33, true },
-    { kAudioTrackNum, 36, kTestAudioFrameDefaultDurationInMs, true },
-    { kVideoTrackNum, 66, 33, true },
-    { kAudioTrackNum, 70, kTestAudioFrameDefaultDurationInMs, true },
-    { kAudioTrackNum, 83, kTestAudioFrameDefaultDurationInMs, true },
+      {kVideoTrackNum, 0, 33, true, NULL, 0},
+      {kAudioTrackNum, 0, 23, false, NULL, 0},
+      {kTextTrackNum, 10, 42, false, NULL, 0},
+      {kAudioTrackNum, 23, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
+      {kVideoTrackNum, 33, 33, true, NULL, 0},
+      {kAudioTrackNum, 36, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
+      {kVideoTrackNum, 66, 33, true, NULL, 0},
+      {kAudioTrackNum, 70, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
+      {kAudioTrackNum, 83, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
   };
 
   const int kExpectedBuffersOnPartialCluster[] = {
     0,  // Video simple block without DefaultDuration should be held back
     0,  // Audio buffer ready, but not emitted because its TS >= held back video
     0,  // Text buffer ready, but not emitted because its TS >= held back video
     0,  // 2nd audio buffer ready, also not emitted for same reason as first
     4,  // All previous buffers emitted, 2nd video held back with no duration
     4,  // 2nd video still has no duration, 3rd audio ready but not emitted
     6,  // All previous buffers emitted, 3rd video held back with no duration
@@ skipping 70 matching lines @@
 }
 
 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;
 
-  const uint8* data = cluster->data();
+  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) {
@@ skipping 16 matching lines @@
                             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 },
-    { kVideoTrackNum, 33, 34, false },
+      {kAudioTrackNum, 0, 23, false, NULL, 0},
+      {kVideoTrackNum, 33, 34, false, NULL, 0},
   };
   int block_count = arraysize(kBlockInfo);
 
-  const uint8 kClusterData[] = {
+  const uint8_t kClusterData[] = {
     0x1F, 0x43, 0xB6, 0x75, 0x9B,  // Cluster(size=27)
     0xE7, 0x81, 0x00,  // Timecode(size=1, value=0)
     // BlockGroup with BlockDuration before Block.
     0xA0, 0x8A,  // BlockGroup(size=10)
     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(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 },
+      {kAudioTrackNum, 0, 23, true, NULL, 0},
+      {kAudioTrackNum, 23, 23, false, NULL, 0},
+      {kVideoTrackNum, 33, 34, true, NULL, 0},
+      {kAudioTrackNum, 46, 23, false, NULL, 0},
+      {kVideoTrackNum, 67, 33, false, NULL, 0},
   };
   int block_count = arraysize(kBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, IgnoredTracks) {
   std::set<int64> ignored_tracks;
   ignored_tracks.insert(kTextTrackNum);
 
   parser_.reset(new WebMClusterParser(kTimecodeScale,
                                       kAudioTrackNum,
                                       kNoTimestamp(),
                                       kVideoTrackNum,
                                       kNoTimestamp(),
                                       TextTracks(),
                                       ignored_tracks,
                                       std::string(),
                                       std::string(),
+                                      kUnknownAudioCodec,
                                       LogCB()));
 
   const BlockInfo kInputBlockInfo[] = {
-    { kAudioTrackNum, 0,  23, true },
-    { kAudioTrackNum, 23, 23, true },
-    { kVideoTrackNum, 33, 34, true },
-    { kTextTrackNum,  33, 99, true },
-    { kAudioTrackNum, 46, 23, true },
-    { kVideoTrackNum, 67, 34, true },
+      {kAudioTrackNum, 0, 23, true, NULL, 0},
+      {kAudioTrackNum, 23, 23, true, NULL, 0},
+      {kVideoTrackNum, 33, 34, true, NULL, 0},
+      {kTextTrackNum, 33, 99, true, NULL, 0},
+      {kAudioTrackNum, 46, 23, true, NULL, 0},
+      {kVideoTrackNum, 67, 34, true, NULL, 0},
   };
   int input_block_count = arraysize(kInputBlockInfo);
 
   const BlockInfo kOutputBlockInfo[] = {
-    { kAudioTrackNum, 0,  23, true },
-    { kAudioTrackNum, 23, 23, true },
-    { kVideoTrackNum, 33, 34, true },
-    { kAudioTrackNum, 46, 23, true },
-    { kVideoTrackNum, 67, 34, true },
+      {kAudioTrackNum, 0, 23, true, NULL, 0},
+      {kAudioTrackNum, 23, 23, true, NULL, 0},
+      {kVideoTrackNum, 33, 34, true, NULL, 0},
+      {kAudioTrackNum, 46, 23, true, NULL, 0},
+      {kVideoTrackNum, 67, 34, true, NULL, 0},
   };
   int output_block_count = arraysize(kOutputBlockInfo);
 
   scoped_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kOutputBlockInfo, output_block_count));
 }
 
 TEST_F(WebMClusterParserTest, ParseTextTracks) {
   TextTracks text_tracks;
 
   text_tracks.insert(std::make_pair(TextTracks::key_type(kTextTrackNum),
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
 
   parser_.reset(new WebMClusterParser(kTimecodeScale,
                                       kAudioTrackNum,
                                       kNoTimestamp(),
                                       kVideoTrackNum,
                                       kNoTimestamp(),
                                       text_tracks,
                                       std::set<int64>(),
                                       std::string(),
                                       std::string(),
+                                      kUnknownAudioCodec,
                                       LogCB()));
 
   const BlockInfo kInputBlockInfo[] = {
-    { kAudioTrackNum, 0,  23, true },
-    { kAudioTrackNum, 23, 23, true },
-    { kVideoTrackNum, 33, 34, true },
-    { kTextTrackNum,  33, 42, false },
-    { kAudioTrackNum, 46, 23, true },
-    { kTextTrackNum, 55, 44, false },
-    { kVideoTrackNum, 67, 34, true },
+      {kAudioTrackNum, 0, 23, true, NULL, 0},
+      {kAudioTrackNum, 23, 23, true, NULL, 0},
+      {kVideoTrackNum, 33, 34, true, NULL, 0},
+      {kTextTrackNum, 33, 42, false, NULL, 0},
+      {kAudioTrackNum, 46, 23, true, NULL, 0},
+      {kTextTrackNum, 55, 44, false, NULL, 0},
+      {kVideoTrackNum, 67, 34, true, NULL, 0},
   };
   int input_block_count = arraysize(kInputBlockInfo);
 
   scoped_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kInputBlockInfo, input_block_count));
 }
 
 TEST_F(WebMClusterParserTest, TextTracksSimpleBlock) {
   TextTracks text_tracks;
 
   text_tracks.insert(std::make_pair(TextTracks::key_type(kTextTrackNum),
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
 
   parser_.reset(new WebMClusterParser(kTimecodeScale,
                                       kAudioTrackNum,
                                       kNoTimestamp(),
                                       kVideoTrackNum,
                                       kNoTimestamp(),
                                       text_tracks,
                                       std::set<int64>(),
                                       std::string(),
                                       std::string(),
+                                      kUnknownAudioCodec,
                                       LogCB()));
 
   const BlockInfo kInputBlockInfo[] = {
     { kTextTrackNum,  33, 42, true },
   };
   int input_block_count = arraysize(kInputBlockInfo);
 
   scoped_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
 
@@ skipping 17 matching lines @@
 
   parser_.reset(new WebMClusterParser(kTimecodeScale,
                                       kAudioTrackNum,
                                       kNoTimestamp(),
                                       kVideoTrackNum,
                                       kNoTimestamp(),
                                       text_tracks,
                                       std::set<int64>(),
                                       std::string(),
                                       std::string(),
+                                      kUnknownAudioCodec,
                                       LogCB()));
 
   const BlockInfo kInputBlockInfo[] = {
-    { kAudioTrackNum, 0,  23, true },
-    { kAudioTrackNum, 23, 23, true },
-    { kVideoTrackNum, 33, 34, true },
-    { kSubtitleTextTrackNum,  33, 42, false },
-    { kAudioTrackNum, 46, 23, true },
-    { kCaptionTextTrackNum, 55, 44, false },
-    { kVideoTrackNum, 67, 34, true },
-    { kSubtitleTextTrackNum,  67, 33, false },
+      {kAudioTrackNum, 0, 23, true, NULL, 0},
+      {kAudioTrackNum, 23, 23, true, NULL, 0},
+      {kVideoTrackNum, 33, 34, true, NULL, 0},
+      {kSubtitleTextTrackNum, 33, 42, false, NULL, 0},
+      {kAudioTrackNum, 46, 23, true, NULL, 0},
+      {kCaptionTextTrackNum, 55, 44, false, NULL, 0},
+      {kVideoTrackNum, 67, 34, true, NULL, 0},
+      {kSubtitleTextTrackNum, 67, 33, false, NULL, 0},
   };
   int input_block_count = arraysize(kInputBlockInfo);
 
   scoped_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
 
   const WebMClusterParser::TextBufferQueueMap& text_map =
@@ skipping 15 matching lines @@
 
   parser_.reset(new WebMClusterParser(kTimecodeScale,
                                       kAudioTrackNum,
                                       kNoTimestamp(),
                                       kVideoTrackNum,
                                       kNoTimestamp(),
                                       TextTracks(),
                                       std::set<int64>(),
                                       std::string(),
                                       "video_key_id",
+                                      kUnknownAudioCodec,
                                       LogCB()));
   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];
   VerifyEncryptedBuffer(buffer);
 }
 
 TEST_F(WebMClusterParserTest, ParseBadEncryptedBlock) {
   scoped_ptr<Cluster> cluster(
       CreateEncryptedCluster(sizeof(kEncryptedFrame) - 1));
 
   parser_.reset(new WebMClusterParser(kTimecodeScale,
                                       kAudioTrackNum,
                                       kNoTimestamp(),
                                       kVideoTrackNum,
                                       kNoTimestamp(),
                                       TextTracks(),
                                       std::set<int64>(),
                                       std::string(),
                                       "video_key_id",
+                                      kUnknownAudioCodec,
                                       LogCB()));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(-1, result);
 }
 
 TEST_F(WebMClusterParserTest, ParseInvalidZeroSizedCluster) {
-  const uint8 kBuffer[] = {
+  const uint8_t kBuffer[] = {
     0x1F, 0x43, 0xB6, 0x75, 0x80,  // CLUSTER (size = 0)
   };
 
   EXPECT_EQ(-1, parser_->Parse(kBuffer, sizeof(kBuffer)));
 }
 
 TEST_F(WebMClusterParserTest, ParseInvalidUnknownButActuallyZeroSizedCluster) {
-  const uint8 kBuffer[] = {
+  const uint8_t kBuffer[] = {
     0x1F, 0x43, 0xB6, 0x75, 0xFF,  // CLUSTER (size = "unknown")
     0x1F, 0x43, 0xB6, 0x75, 0x85,  // CLUSTER (size = 5)
   };
 
   EXPECT_EQ(-1, parser_->Parse(kBuffer, sizeof(kBuffer)));
 }
 
 TEST_F(WebMClusterParserTest, ParseInvalidTextBlockGroupWithoutDuration) {
   // Text track frames must have explicitly specified BlockGroup BlockDurations.
   TextTracks text_tracks;
 
   text_tracks.insert(std::make_pair(TextTracks::key_type(kTextTrackNum),
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
 
   parser_.reset(new WebMClusterParser(kTimecodeScale,
                                       kAudioTrackNum,
                                       kNoTimestamp(),
                                       kVideoTrackNum,
                                       kNoTimestamp(),
                                       text_tracks,
                                       std::set<int64>(),
                                       std::string(),
                                       std::string(),
+                                      kUnknownAudioCodec,
                                       LogCB()));
 
   const BlockInfo kBlockInfo[] = {
     { kTextTrackNum,  33, -42, false },
   };
   int block_count = arraysize(kBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_LT(result, 0);
 }
 
 TEST_F(WebMClusterParserTest, ParseWithDefaultDurationsSimpleBlocks) {
   InSequence s;
   ResetParserToHaveDefaultDurations();
 
   EXPECT_LT(kTestAudioFrameDefaultDurationInMs, 23);
   EXPECT_LT(kTestVideoFrameDefaultDurationInMs, 33);
 
   const BlockInfo kBlockInfo[] = {
-    { kAudioTrackNum, 0, kTestAudioFrameDefaultDurationInMs, true },
-    { kAudioTrackNum, 23, kTestAudioFrameDefaultDurationInMs, true },
-    { kVideoTrackNum, 33, kTestVideoFrameDefaultDurationInMs, true },
-    { kAudioTrackNum, 46, kTestAudioFrameDefaultDurationInMs, true },
-    { kVideoTrackNum, 67, kTestVideoFrameDefaultDurationInMs, true },
-    { kAudioTrackNum, 69, kTestAudioFrameDefaultDurationInMs, true },
-    { kVideoTrackNum, 100, kTestVideoFrameDefaultDurationInMs, true },
+      {kAudioTrackNum, 0, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
+      {kAudioTrackNum, 23, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
+      {kVideoTrackNum, 33, kTestVideoFrameDefaultDurationInMs, true, NULL, 0},
+      {kAudioTrackNum, 46, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
+      {kVideoTrackNum, 67, kTestVideoFrameDefaultDurationInMs, true, NULL, 0},
+      {kAudioTrackNum, 69, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
+      {kVideoTrackNum, 100, kTestVideoFrameDefaultDurationInMs, true, NULL, 0},
   };
 
   int block_count = arraysize(kBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
 
   // Send slightly less than the full cluster so all but the last block is
   // parsed. Though all the blocks are simple blocks, none should be held aside
   // for duration estimation prior to end of cluster detection because all the
   // tracks have DefaultDurations.
   int result = parser_->Parse(cluster->data(), cluster->size() - 1);
@@ skipping 10 matching lines @@
 }
 
 TEST_F(WebMClusterParserTest, ParseWithoutAnyDurationsSimpleBlocks) {
   InSequence s;
 
   // Absent DefaultDuration information, SimpleBlock durations are derived from
   // inter-buffer track timestamp delta if within the cluster, and are estimated
   // as the lowest non-zero duration seen so far if the last buffer in the track
   // in the cluster (independently for each track in the cluster).
   const BlockInfo kBlockInfo1[] = {
-    { kAudioTrackNum, 0, 23, true },
-    { kAudioTrackNum, 23, 22, true },
-    { kVideoTrackNum, 33, 33, true },
-    { kAudioTrackNum, 45, 23, true },
-    { kVideoTrackNum, 66, 34, true },
-    { kAudioTrackNum, 68, 22, true },  // Estimated from minimum audio dur
-    { kVideoTrackNum, 100, 33, true },  // Estimated from minimum video dur
+      {kAudioTrackNum, 0, 23, true, NULL, 0},
+      {kAudioTrackNum, 23, 22, true, NULL, 0},
+      {kVideoTrackNum, 33, 33, true, NULL, 0},
+      {kAudioTrackNum, 45, 23, true, NULL, 0},
+      {kVideoTrackNum, 66, 34, true, NULL, 0},
+      // Estimated from minimum audio dur
+      {kAudioTrackNum, 68, 22, true, NULL, 0},
+      // Estimated from minimum video dur
+      {kVideoTrackNum, 100, 33, true, NULL, 0},
   };
 
   int block_count1 = arraysize(kBlockInfo1);
   scoped_ptr<Cluster> cluster1(CreateCluster(0, kBlockInfo1, block_count1));
 
   // 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());
 
   parser_->Reset();
 
   // Now parse the full first cluster and verify all the blocks are parsed.
   result = parser_->Parse(cluster1->data(), cluster1->size());
   EXPECT_EQ(cluster1->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo1, block_count1));
 
   // Verify that the estimated frame duration is tracked across clusters for
   // each track.
   const BlockInfo kBlockInfo2[] = {
-    { kAudioTrackNum, 200, 22, true },  // Estimate carries over across clusters
-    { kVideoTrackNum, 201, 33, true },  // Estimate carries over across clusters
+      // Estimate carries over across clusters
+      {kAudioTrackNum, 200, 22, true, NULL, 0},
+      // Estimate carries over across clusters
+      {kVideoTrackNum, 201, 33, true, NULL, 0},
   };
 
   int block_count2 = arraysize(kBlockInfo2);
   scoped_ptr<Cluster> cluster2(CreateCluster(0, kBlockInfo2, block_count2));
   result = parser_->Parse(cluster2->data(), cluster2->size());
   EXPECT_EQ(cluster2->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo2, block_count2));
 }
 
 TEST_F(WebMClusterParserTest, ParseWithoutAnyDurationsBlockGroups) {
   InSequence s;
 
   // Absent DefaultDuration and BlockDuration information, BlockGroup block
   // durations are derived from inter-buffer track timestamp delta if within the
   // cluster, and are estimated as the lowest non-zero duration seen so far if
   // the last buffer in the track in the cluster (independently for each track
   // in the cluster).
-    const BlockInfo kBlockInfo1[] = {
-    { kAudioTrackNum, 0, -23, false },
-    { kAudioTrackNum, 23, -22, false },
-    { kVideoTrackNum, 33, -33, false },
-    { kAudioTrackNum, 45, -23, false },
-    { kVideoTrackNum, 66, -34, false },
-    { kAudioTrackNum, 68, -22, false },  // Estimated from minimum audio dur
-    { kVideoTrackNum, 100, -33, false },  // Estimated from minimum video dur
+  const BlockInfo kBlockInfo1[] = {
+      {kAudioTrackNum, 0, -23, false, NULL, 0},
+      {kAudioTrackNum, 23, -22, false, NULL, 0},
+      {kVideoTrackNum, 33, -33, false, NULL, 0},
+      {kAudioTrackNum, 45, -23, false, NULL, 0},
+      {kVideoTrackNum, 66, -34, false, NULL, 0},
+      // Estimated from minimum audio dur
+      {kAudioTrackNum, 68, -22, false, NULL, 0},
+      // Estimated from minimum video dur
+      {kVideoTrackNum, 100, -33, false, NULL, 0},
   };
 
   int block_count1 = arraysize(kBlockInfo1);
   scoped_ptr<Cluster> cluster1(CreateCluster(0, kBlockInfo1, block_count1));
 
   // 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());
 
   parser_->Reset();
 
   // Now parse the full first cluster and verify all the blocks are parsed.
   result = parser_->Parse(cluster1->data(), cluster1->size());
   EXPECT_EQ(cluster1->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo1, block_count1));
 
   // Verify that the estimated frame duration is tracked across clusters for
   // each track.
   const BlockInfo kBlockInfo2[] = {
-    { kAudioTrackNum, 200, -22, false },
-    { kVideoTrackNum, 201, -33, false },
+      {kAudioTrackNum, 200, -22, false, NULL, 0},
+      {kVideoTrackNum, 201, -33, false, NULL, 0},
   };
 
   int block_count2 = arraysize(kBlockInfo2);
   scoped_ptr<Cluster> cluster2(CreateCluster(0, kBlockInfo2, block_count2));
   result = parser_->Parse(cluster2->data(), cluster2->size());
   EXPECT_EQ(cluster2->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo2, block_count2));
 }
 
 // TODO(wolenetz): Is parser behavior correct? See http://crbug.com/363433.
 TEST_F(WebMClusterParserTest,
        ParseWithDefaultDurationsBlockGroupsWithoutDurations) {
   InSequence s;
   ResetParserToHaveDefaultDurations();
 
   EXPECT_LT(kTestAudioFrameDefaultDurationInMs, 23);
   EXPECT_LT(kTestVideoFrameDefaultDurationInMs, 33);
 
   const BlockInfo kBlockInfo[] = {
-    { kAudioTrackNum, 0, -kTestAudioFrameDefaultDurationInMs, false },
-    { kAudioTrackNum, 23, -kTestAudioFrameDefaultDurationInMs, false },
-    { kVideoTrackNum, 33, -kTestVideoFrameDefaultDurationInMs, false },
-    { kAudioTrackNum, 46, -kTestAudioFrameDefaultDurationInMs, false },
-    { kVideoTrackNum, 67, -kTestVideoFrameDefaultDurationInMs, false },
-    { kAudioTrackNum, 69, -kTestAudioFrameDefaultDurationInMs, false },
-    { kVideoTrackNum, 100, -kTestVideoFrameDefaultDurationInMs, false },
+      {kAudioTrackNum, 0, -kTestAudioFrameDefaultDurationInMs, false, NULL, 0},
+      {kAudioTrackNum, 23, -kTestAudioFrameDefaultDurationInMs, false, NULL, 0},
+      {kVideoTrackNum, 33, -kTestVideoFrameDefaultDurationInMs, false, NULL, 0},
+      {kAudioTrackNum, 46, -kTestAudioFrameDefaultDurationInMs, false, NULL, 0},
+      {kVideoTrackNum, 67, -kTestVideoFrameDefaultDurationInMs, false, NULL, 0},
+      {kAudioTrackNum, 69, -kTestAudioFrameDefaultDurationInMs, false, NULL, 0},
+      {kVideoTrackNum,
+       100,
+       -kTestVideoFrameDefaultDurationInMs,
+       false,
+       NULL,
+       0},
   };
 
   int block_count = arraysize(kBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
 
   // Send slightly less than the full cluster so all but the last block is
   // parsed. None should be held aside for duration estimation prior to end of
   // cluster detection because all the tracks have DefaultDurations.
   int result = parser_->Parse(cluster->data(), cluster->size() - 1);
   EXPECT_GT(result, 0);
@@ skipping 40 matching lines @@
     { kVideoTrackNum, 0, kTestVideoFrameDefaultDurationInMs, true },
   };
 
   int block_count = arraysize(kBlockInfo);
   scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
+TEST_F(WebMClusterParserTest, ReadOpusDurationsSimpleBlockAtEndOfCluster) {
+  // Reset parser to expect Opus codec audio.
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
+      kNoTimestamp(), TextTracks(), std::set<int64>(), std::string(),
+      std::string(), kCodecOpus, LogCB()));
+
+  for (const auto& packet_ptr : BuildAllOpusPackets()) {
+    const BlockInfo kBlockInfo[] = {{kAudioTrackNum,
+                                     0,
+                                     packet_ptr->duration_ms(),
+                                     true,  // Make it a SimpleBlock.
+                                     packet_ptr->data(),
+                                     packet_ptr->size()}};
+
+    int block_count = arraysize(kBlockInfo);
+    scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
+    int result = parser_->Parse(cluster->data(), cluster->size());
+    EXPECT_EQ(cluster->size(), result);
+    ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
+  }
+}
+
+TEST_F(WebMClusterParserTest, PreferOpusDurationsOverBlockDurations) {
+  // Reset parser to expect Opus codec audio.
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
+      kNoTimestamp(), TextTracks(), std::set<int64>(), std::string(),
+      std::string(), kCodecOpus, LogCB()));
+
+  for (const auto& packet_ptr : BuildAllOpusPackets()) {

[wolenetz, 2015/02/05 23:05:00]

s/const auto& packet_ptr/const auto* packet/ per Range-Based For Loops at
https://chromium-cpp.appspot.com/

[chcunningham, 2015/02/06 03:20:10]

Done.

+    // Setting BlockDuration != Opus duration to see which one the parser uses.
+    int block_duration_ms = packet_ptr->duration_ms() + 10;
+
+    BlockInfo block_infos[] = {{kAudioTrackNum,
+                                0,
+                                block_duration_ms,
+                                false,  // Not a SimpleBlock.
+                                packet_ptr->data(),
+                                packet_ptr->size()}};
+
+    int block_count = arraysize(block_infos);
+    scoped_ptr<Cluster> cluster(CreateCluster(0, block_infos, block_count));
+    int result = parser_->Parse(cluster->data(), cluster->size());
+    EXPECT_EQ(cluster->size(), result);
+
+    // BlockInfo duration will be used to verify buffer duration, so changing
+    // duration to be that of the Opus packet to verify it was preferred.
+    block_infos[0].duration = packet_ptr->duration_ms();
+
+    ASSERT_TRUE(VerifyBuffers(parser_, block_infos, block_count));
+  }
+}
+
+// Tests that BlockDuration is used to set duration on buffer rather than
+// encoded duration in Opus packet (or hard coded duration estimates). Encoded
+// opus duration is usually preferred but cannot be known when encrypted.

[wolenetz, 2015/02/05 23:05:00]

nit: s/opus/Opus/

[chcunningham, 2015/02/06 03:20:10]

Done.

+TEST_F(WebMClusterParserTest, DontReadEncodedDurationWhenEncrypted) {
+  // Non-empty dummy value for signals encryption is active for audio.

[wolenetz, 2015/02/05 23:05:00]

nit: clean up wording. "for" what?

[chcunningham, 2015/02/06 03:20:10]

Done.

+  std::string audio_encryption_id("audio_key_id");
+
+  // Reset parser to expect Opus codec audio and use audio encryption key id.
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
+      kNoTimestamp(), TextTracks(), std::set<int64>(), audio_encryption_id,
+      std::string(), kCodecOpus, LogCB()));
+
+  // Single Block with BlockDuration and encrypted data.
+  const BlockInfo kBlockInfo[] = {{kAudioTrackNum,
+                                   0,
+                                   kTestAudioFrameDefaultDurationInMs,
+                                   false,            // Not a SimpleBlock
+                                   kEncryptedFrame,  // Encrypted frame data

[wolenetz, 2015/02/05 23:05:00]

How about we try feeding it a "clear" OpusPacket so that we can observe more
explicitly that the parser is using the blockgroup->blockduration and not the
"clear frame"'s encoded duration. Just make sure that the OpusPacket's
duration_ms() is significantly different from the BlockGroup->BlockDuration
before parsing and verifying.

[chcunningham, 2015/02/06 03:20:10]

We chatted and ultimately decided to just use something that isnt the default
duration... but I can't recall why that sounded good. It seems silly now. The
duration we're using isn't known to the parser outside of us providing via block
duration in this way. This default duration differs from the hard-coded
estimation defaults used by the parser.

I looked into the encryption spec, and indeed you can have un-encrypted blocks
among encrypted blocks. Relevant quote:

"Encrypted bit. If set the Block MUST contain an IV immediately followed by an
encrypted frame. If not set the Block MUST NOT include an IV and the frame MUST
be unencrypted. The unencrypted frame MUST immediately follow the Signal Byte."

So we can consider digging into unencrypted frames among the encrypted onces to
get a precise duration. Worth it? Eh... parser complexity increase is moderate.
Expected gain is pretty slight. I doubt we often see unecrypted frames among
encrypted. WDYT?

[wolenetz, 2015/02/06 19:48:01]

Extracting encoded duration from an encrypted track containing unencrypted
blocks can be saved for a later CL. I suggest you comment on this edge case in
the bug; and maybe file a separate dependent bug (cc'ing fgalligan@, and
reference it here?

[chcunningham, 2015/02/06 22:45:59]

Done. 

+                                   arraysize(kEncryptedFrame)}};
+
+  int block_count = arraysize(kBlockInfo);
+  scoped_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