media/cast/logging/logging_impl_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <stdint.h>
   6
   7 #include <vector>
   8
   9 #include "base/rand_util.h"
  10 #include "base/test/simple_test_tick_clock.h"
  11 #include "base/time/tick_clock.h"
  12 #include "base/time/time.h"
  13 #include "media/cast/logging/logging_defines.h"
  14 #include "media/cast/logging/logging_impl.h"
  15 #include "media/cast/logging/simple_event_subscriber.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace media {
  19 namespace cast {
  20
  21 // Insert frame duration- one second.
  22 const int64 kIntervalTime1S = 1;
  23 // Test frame rate goal - 30fps.
  24 const int kFrameIntervalMs = 33;
  25
  26 static const int64 kStartMillisecond = INT64_C(12345678900000);
  27
  28 class LoggingImplTest : public ::testing::Test {
  29  protected:
  30   LoggingImplTest() {
  31     testing_clock_.Advance(
  32         base::TimeDelta::FromMilliseconds(kStartMillisecond));
  33     logging_.AddRawEventSubscriber(&event_subscriber_);
  34   }
  35
  36   virtual ~LoggingImplTest() {
  37     logging_.RemoveRawEventSubscriber(&event_subscriber_);
  38   }
  39
  40   LoggingImpl logging_;
  41   base::SimpleTestTickClock testing_clock_;
  42   SimpleEventSubscriber event_subscriber_;
  43
  44   DISALLOW_COPY_AND_ASSIGN(LoggingImplTest);
  45 };
  46
  47 TEST_F(LoggingImplTest, BasicFrameLogging) {
  48   base::TimeTicks start_time = testing_clock_.NowTicks();
  49   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
  50   uint32 rtp_timestamp = 0;
  51   uint32 frame_id = 0;
  52   base::TimeTicks now;
  53   do {
  54     now = testing_clock_.NowTicks();
  55     logging_.InsertFrameEvent(
  56         now, FRAME_CAPTURE_BEGIN, VIDEO_EVENT, rtp_timestamp, frame_id);
  57     testing_clock_.Advance(
  58         base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
  59     rtp_timestamp += kFrameIntervalMs * 90;
  60     ++frame_id;
  61     time_interval = now - start_time;
  62   }  while (time_interval.InSeconds() < kIntervalTime1S);
  63
  64   // Get logging data.
  65   std::vector<FrameEvent> frame_events;
  66   event_subscriber_.GetFrameEventsAndReset(&frame_events);
  67   // Size of vector should be equal to the number of events logged,
  68   // which equals to number of frames in this case.
  69   EXPECT_EQ(frame_id, frame_events.size());
  70 }
  71
  72 TEST_F(LoggingImplTest, FrameLoggingWithSize) {
  73   // Average packet size.
  74   const int kBaseFrameSizeBytes = 25000;
  75   const int kRandomSizeInterval = 100;
  76   base::TimeTicks start_time = testing_clock_.NowTicks();
  77   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
  78   uint32 rtp_timestamp = 0;
  79   uint32 frame_id = 0;
  80   size_t sum_size = 0;
  81   int target_bitrate = 1234;
  82   do {
  83     int size = kBaseFrameSizeBytes +
  84         base::RandInt(-kRandomSizeInterval, kRandomSizeInterval);
  85     sum_size += static_cast<size_t>(size);
  86     logging_.InsertEncodedFrameEvent(testing_clock_.NowTicks(),
  87                                      FRAME_ENCODED, VIDEO_EVENT, rtp_timestamp,
  88                                      frame_id, size, true, target_bitrate);
  89     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
  90     rtp_timestamp += kFrameIntervalMs * 90;
  91     ++frame_id;
  92     time_interval = testing_clock_.NowTicks() - start_time;
  93   } while (time_interval.InSeconds() < kIntervalTime1S);
  94   // Get logging data.
  95   std::vector<FrameEvent> frame_events;
  96   event_subscriber_.GetFrameEventsAndReset(&frame_events);
  97   // Size of vector should be equal to the number of events logged, which
  98   // equals to number of frames in this case.
  99   EXPECT_EQ(frame_id, frame_events.size());
 100 }
 101
 102 TEST_F(LoggingImplTest, FrameLoggingWithDelay) {
 103   // Average packet size.
 104   const int kPlayoutDelayMs = 50;
 105   const int kRandomSizeInterval = 20;
 106   base::TimeTicks start_time = testing_clock_.NowTicks();
 107   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
 108   uint32 rtp_timestamp = 0;
 109   uint32 frame_id = 0;
 110   do {
 111     int delay = kPlayoutDelayMs +
 112                 base::RandInt(-kRandomSizeInterval, kRandomSizeInterval);
 113     logging_.InsertFrameEventWithDelay(
 114         testing_clock_.NowTicks(),
 115         FRAME_CAPTURE_BEGIN,
 116         VIDEO_EVENT,
 117         rtp_timestamp,
 118         frame_id,
 119         base::TimeDelta::FromMilliseconds(delay));
 120     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
 121     rtp_timestamp += kFrameIntervalMs * 90;
 122     ++frame_id;
 123     time_interval = testing_clock_.NowTicks() - start_time;
 124   } while (time_interval.InSeconds() < kIntervalTime1S);
 125   // Get logging data.
 126   std::vector<FrameEvent> frame_events;
 127   event_subscriber_.GetFrameEventsAndReset(&frame_events);
 128   // Size of vector should be equal to the number of frames logged.
 129   EXPECT_EQ(frame_id, frame_events.size());
 130 }
 131
 132 TEST_F(LoggingImplTest, MultipleEventFrameLogging) {
 133   base::TimeTicks start_time = testing_clock_.NowTicks();
 134   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
 135   uint32 rtp_timestamp = 0u;
 136   uint32 frame_id = 0u;
 137   uint32 num_events = 0u;
 138   do {
 139     logging_.InsertFrameEvent(testing_clock_.NowTicks(),
 140                               FRAME_CAPTURE_END,
 141                               VIDEO_EVENT,
 142                               rtp_timestamp,
 143                               frame_id);
 144     ++num_events;
 145     if (frame_id % 2) {
 146       logging_.InsertEncodedFrameEvent(testing_clock_.NowTicks(),
 147                                        FRAME_ENCODED, AUDIO_EVENT,
 148                                        rtp_timestamp,
 149                                        frame_id, 1500, true, 0);
 150     } else if (frame_id % 3) {
 151       logging_.InsertFrameEvent(testing_clock_.NowTicks(), FRAME_DECODED,
 152                                 VIDEO_EVENT, rtp_timestamp, frame_id);
 153     } else {
 154       logging_.InsertFrameEventWithDelay(
 155           testing_clock_.NowTicks(), FRAME_PLAYOUT, VIDEO_EVENT,
 156           rtp_timestamp, frame_id, base::TimeDelta::FromMilliseconds(20));
 157     }
 158     ++num_events;
 159
 160     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
 161     rtp_timestamp += kFrameIntervalMs * 90;
 162     ++frame_id;
 163     time_interval = testing_clock_.NowTicks() - start_time;
 164   } while (time_interval.InSeconds() < kIntervalTime1S);
 165   // Get logging data.
 166   std::vector<FrameEvent> frame_events;
 167   event_subscriber_.GetFrameEventsAndReset(&frame_events);
 168   // Size of vector should be equal to the number of frames logged.
 169   EXPECT_EQ(num_events, frame_events.size());
 170   // Multiple events captured per frame.
 171 }
 172
 173 TEST_F(LoggingImplTest, PacketLogging) {
 174   const int kNumPacketsPerFrame = 10;
 175   const int kBaseSize = 2500;
 176   const int kSizeInterval = 100;
 177   base::TimeTicks start_time = testing_clock_.NowTicks();
 178   base::TimeTicks latest_time;
 179   base::TimeDelta time_interval = testing_clock_.NowTicks() - start_time;
 180   RtpTimestamp rtp_timestamp = 0;
 181   int frame_id = 0;
 182   int num_packets = 0;
 183   int sum_size = 0u;
 184   do {
 185     for (int i = 0; i < kNumPacketsPerFrame; ++i) {
 186       int size = kBaseSize + base::RandInt(-kSizeInterval, kSizeInterval);
 187       sum_size += size;
 188       latest_time = testing_clock_.NowTicks();
 189       ++num_packets;
 190       logging_.InsertPacketEvent(latest_time,
 191                                  PACKET_RECEIVED,
 192                                  VIDEO_EVENT,
 193                                  rtp_timestamp,
 194                                  frame_id,
 195                                  i,
 196                                  kNumPacketsPerFrame,
 197                                  size);
 198     }
 199     testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kFrameIntervalMs));
 200     rtp_timestamp += kFrameIntervalMs * 90;
 201     ++frame_id;
 202     time_interval = testing_clock_.NowTicks() - start_time;
 203   } while (time_interval.InSeconds() < kIntervalTime1S);
 204   // Get logging data.
 205   std::vector<PacketEvent> packet_events;
 206   event_subscriber_.GetPacketEventsAndReset(&packet_events);
 207   // Size of vector should be equal to the number of packets logged.
 208   EXPECT_EQ(num_packets, static_cast<int>(packet_events.size()));
 209 }
 210
 211 TEST_F(LoggingImplTest, MultipleRawEventSubscribers) {
 212   SimpleEventSubscriber event_subscriber_2;
 213
 214   // Now logging_ has two subscribers.
 215   logging_.AddRawEventSubscriber(&event_subscriber_2);
 216
 217   logging_.InsertFrameEvent(testing_clock_.NowTicks(),
 218                             FRAME_CAPTURE_BEGIN,
 219                             VIDEO_EVENT,
 220                             /*rtp_timestamp*/ 0u,
 221                             /*frame_id*/ 0u);
 222
 223   std::vector<FrameEvent> frame_events;
 224   event_subscriber_.GetFrameEventsAndReset(&frame_events);
 225   EXPECT_EQ(1u, frame_events.size());
 226   frame_events.clear();
 227   event_subscriber_2.GetFrameEventsAndReset(&frame_events);
 228   EXPECT_EQ(1u, frame_events.size());
 229
 230   logging_.RemoveRawEventSubscriber(&event_subscriber_2);
 231 }
 232
 233 }  // namespace cast
 234 }  // namespace media