Improving WebM video duration estimation.

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"
@@ skipping 785 matching lines @@
   // Now parse a whole cluster to verify that all the blocks will get parsed.
   result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 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).
+  // inter-buffer track timestamp delta if within the cluster. Duration for the
+  // last block in a cluster is estimated independently for each track in the
+  // cluster. For video tracks we use the maximum seen so far. For audio we use
+  // the the minimum.
+  // TODO(chcunningham): Move audio over to use the maximum.
   const BlockInfo kBlockInfo1[] = {
       {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},
+      // Estimated from maximum video dur
+      {kVideoTrackNum, 100, 34, 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.)
@@ skipping 10 matching lines @@
   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[] = {
       // Estimate carries over across clusters
       {kAudioTrackNum, 200, 22, true, NULL, 0},
       // Estimate carries over across clusters
-      {kVideoTrackNum, 201, 33, true, NULL, 0},
+      {kVideoTrackNum, 201, 34, 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).
+  // cluster. Duration for the last block in a cluster is estimated
+  // independently for each track in the cluster. For video tracks we use the
+  // maximum seen so far. For audio we use the the minimum.
+  // TODO(chcunningham): Move audio over to use the maximum.
   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},
+      // Estimated from maximum video dur
+      {kVideoTrackNum, 100, -34, 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, NULL, 0},
-      {kVideoTrackNum, 201, -33, false, NULL, 0},
+      {kVideoTrackNum, 201, -34, 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.
@@ skipping 166 matching lines @@
   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