Mpeg2TS - estimate duration for video frames.

media/formats/mp2t/es_adapter_video_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 <vector>
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/time/time.h"
+#include "media/base/stream_parser_buffer.h"
+#include "media/base/video_decoder_config.h"
+#include "media/formats/mp2t/es_adapter_video.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+namespace mp2t {
+
+namespace {
+
+VideoDecoderConfig CreateFakeVideoConfig() {
+  gfx::Size coded_size(320, 240);
+  gfx::Rect visible_rect(0, 0, 320, 240);
+  gfx::Size natural_size(320, 240);
+  return VideoDecoderConfig(
+      kCodecH264,
+      H264PROFILE_MAIN,
+      VideoFrame::I420,
+      coded_size,
+      visible_rect,
+      natural_size,
+      NULL, 0, false);
+}
+
+std::vector<scoped_refptr<StreamParserBuffer> >

[wolenetz, 2014/07/10 23:28:14]

nit: use StreamParserBuffer::BufferQueue (a deque) instead of custom vector?

[damienv1, 2014/07/11 00:44:41]

Done.

+GenerateFakeBuffers(const std::vector<base::TimeDelta>& frame_pts) {
+  uint8 dummy_buffer[] = {0, 0, 0, 0};
+
+  std::vector<scoped_refptr<StreamParserBuffer> > buffers(frame_pts.size());
+  for (size_t k = 0; k < frame_pts.size(); k++) {
+    buffers[k] = StreamParserBuffer::CopyFrom(
+        dummy_buffer, arraysize(dummy_buffer), true, DemuxerStream::VIDEO, 0);
+    buffers[k]->set_timestamp(frame_pts[k]);
+  }
+  return buffers;
+}
+
+std::vector<base::TimeDelta> ConvertToTimeDelta(
+    const int* timestamp_in_ms, size_t size) {

[wolenetz, 2014/07/10 23:28:13]

nit: |size| could be misinterpreted as # of bytes pointed to by the *. use
"count" or somesuch instead?

[wolenetz, 2014/07/10 23:28:14]

nit: move to previous line and wrap after 1st param?

[damienv1, 2014/07/11 00:44:42]

Done.

[damienv1, 2014/07/11 00:44:42]

Done.

+  std::vector<base::TimeDelta> timestamp(size);
+  for (size_t k = 0; k < size; k++)
+    timestamp[k] = base::TimeDelta::FromMilliseconds(timestamp_in_ms[k]);
+  return timestamp;
+}
+
+}
+
+class EsAdapterVideoTest : public testing::Test {
+ public:
+  EsAdapterVideoTest();
+  virtual ~EsAdapterVideoTest() {}
+
+ protected:
+  // Given a set of input pts |pts_ms|, make sure
+  // the ES adapter computes the expected durations |duration_ms|.
+  void RunDurationTest(const int* pts_ms,
+                       const int* duration_ms,
+                       size_t size);
+
+ private:
+  void OnNewConfig(const VideoDecoderConfig& video_config);
+  void OnNewBuffer(scoped_refptr<StreamParserBuffer> buffer);
+
+  EsAdapterVideo es_adapter_;
+
+  size_t buffer_count_;
+  std::vector<base::TimeDelta> expected_frame_duration_;
+
+  DISALLOW_COPY_AND_ASSIGN(EsAdapterVideoTest);
+};
+
+EsAdapterVideoTest::EsAdapterVideoTest()
+    : es_adapter_(base::Bind(&EsAdapterVideoTest::OnNewConfig,
+                             base::Unretained(this)),
+                  base::Bind(&EsAdapterVideoTest::OnNewBuffer,
+                             base::Unretained(this))),
+      buffer_count_(0) {
+}
+
+void EsAdapterVideoTest::OnNewConfig(const VideoDecoderConfig& video_config) {
+}
+
+void EsAdapterVideoTest::OnNewBuffer(
+    scoped_refptr<StreamParserBuffer> buffer) {
+  ASSERT_LT(buffer_count_, expected_frame_duration_.size());
+  EXPECT_EQ(expected_frame_duration_[buffer_count_], buffer->duration());

[scherkus (not reviewing), 2014/07/10 23:13:58]

suggestion for improving the maintainability of this test... if/when this fails
we're going to get an extremely uninformative failure along the lines of "5 !=
7" but without any context (e.g., which buffer? what about the other ones?)

a technique I like to use for these types of test to make them more
human/logging friendly is to convert these results into a string, then use
EXPECT_EQ() to compare strings

for example:

std::stringstream buffer_durations_;

void OnNewBuffer() {
  buffer_durations_ << buffer->duration().InMilliseconds() << " ";
}

std::string EsAdapterVideoTest::RunDurationTest(...) {
  buffer_durations_.clear();

  // ... do stuff

  std::string s = buffer_durations_.str();
  base::TrimWhitespaceASCII(s, base::TRIM_ALL, &s);
  return s;
}

TEST_F(EsAdapterVideoTest, FrameDurationSimpleGop) {
  // PTS for a GOP without B frames - strictly increasing.
  int pts_ms[] = {30, 31, 33, 36, 40, 45, 51, 58};
  EXPECT_EQ("1 2 3 4 5 6 7 7",
            RunDurationTest(pts_ms, arraysize(pts_ms));
}

[damienv1, 2014/07/11 00:44:42]

Pretty convenient indeed.
Thanks for the suggestion.

+  buffer_count_++;
+}
+

[wolenetz, 2014/07/10 23:28:13]

Thanks for adding test coverage - I would like to see some coverage of initial
non-keyframes replaced by the first keyframe.

[damienv1, 2014/07/11 00:44:42]

Done.

+void EsAdapterVideoTest::RunDurationTest(
+    const int* pts_ms,
+    const int* duration_ms,
+    size_t size) {
+  std::vector<base::TimeDelta> frame_pts(ConvertToTimeDelta(pts_ms, size));
+  expected_frame_duration_ = ConvertToTimeDelta(duration_ms, size);
+
+  // Generate fake buffers with the given PTS.
+  std::vector<scoped_refptr<StreamParserBuffer> > fake_buffers(
+      GenerateFakeBuffers(frame_pts));
+
+  es_adapter_.OnConfigChanged(CreateFakeVideoConfig());
+  for (size_t k = 0; k < fake_buffers.size(); k++)
+    es_adapter_.OnNewBuffer(fake_buffers[k]);
+  es_adapter_.Flush();
+}
+
+TEST_F(EsAdapterVideoTest, FrameDurationSimpleGop) {
+  // PTS for a GOP without B frames - strictly increasing.
+  int pts_ms[] = {30, 31, 33, 36, 40, 45, 51, 58};
+  int duration_ms[] = {1, 2, 3, 4, 5, 6, 7, 7};
+
+  RunDurationTest(pts_ms, duration_ms, arraysize(pts_ms));
+}
+
+TEST_F(EsAdapterVideoTest, FrameDurationComplexGop) {
+  // PTS for a GOP with B frames.
+  int pts_ms[] = {30, 120, 60, 90, 210, 150, 180, 300, 240, 270};
+  int duration_ms[] = {30, 30, 30, 30, 30, 30, 30, 30, 30, 30};
+
+  RunDurationTest(pts_ms, duration_ms, arraysize(pts_ms));
+}
+
+}  // namespace mp2t
+}  // namespace media