Home | History | Annotate | Download | only in video 
      1 /*
      2  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 #include <assert.h>
     11 
     12 #include <algorithm>
     13 #include <sstream>
     14 #include <string>
     15 
     16 #include "testing/gtest/include/gtest/gtest.h"
     17 
     18 #include "webrtc/call.h"
     19 #include "webrtc/modules/audio_coding/main/interface/audio_coding_module.h"
     20 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
     21 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
     22 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
     23 #include "webrtc/system_wrappers/interface/rtp_to_ntp.h"
     24 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
     25 #include "webrtc/system_wrappers/interface/thread_annotations.h"
     26 #include "webrtc/test/direct_transport.h"
     27 #include "webrtc/test/encoder_settings.h"
     28 #include "webrtc/test/fake_audio_device.h"
     29 #include "webrtc/test/fake_decoder.h"
     30 #include "webrtc/test/fake_encoder.h"
     31 #include "webrtc/test/frame_generator.h"
     32 #include "webrtc/test/frame_generator_capturer.h"
     33 #include "webrtc/test/rtp_rtcp_observer.h"
     34 #include "webrtc/test/testsupport/fileutils.h"
     35 #include "webrtc/test/testsupport/perf_test.h"
     36 #include "webrtc/video/transport_adapter.h"
     37 #include "webrtc/voice_engine/include/voe_base.h"
     38 #include "webrtc/voice_engine/include/voe_codec.h"
     39 #include "webrtc/voice_engine/include/voe_network.h"
     40 #include "webrtc/voice_engine/include/voe_rtp_rtcp.h"
     41 #include "webrtc/voice_engine/include/voe_video_sync.h"
     42 
     43 namespace webrtc {
     44 
     45 static unsigned int kLongTimeoutMs = 120 * 1000;
     46 static const uint32_t kSendSsrc = 0x654321;
     47 static const uint32_t kReceiverLocalSsrc = 0x123456;
     48 static const uint8_t kSendPayloadType = 125;
     49 
     50 class CallPerfTest : public ::testing::Test {
     51  public:
     52   CallPerfTest()
     53       : send_stream_(NULL), fake_encoder_(Clock::GetRealTimeClock()) {}
     54 
     55  protected:
     56   void CreateTestConfig(Call* call) {
     57     send_config_ = call->GetDefaultSendConfig();
     58     send_config_.rtp.ssrcs.push_back(kSendSsrc);
     59     send_config_.encoder_settings.encoder = &fake_encoder_;
     60     send_config_.encoder_settings.payload_type = kSendPayloadType;
     61     send_config_.encoder_settings.payload_name = "FAKE";
     62     video_streams_ = test::CreateVideoStreams(1);
     63   }
     64 
     65   void RunVideoSendTest(Call* call,
     66                         const VideoSendStream::Config& config,
     67                         test::RtpRtcpObserver* observer) {
     68     send_stream_ = call->CreateVideoSendStream(config, video_streams_, NULL);
     69     scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
     70         test::FrameGeneratorCapturer::Create(
     71             send_stream_->Input(), 320, 240, 30, Clock::GetRealTimeClock()));
     72     send_stream_->Start();
     73     frame_generator_capturer->Start();
     74 
     75     EXPECT_EQ(kEventSignaled, observer->Wait());
     76 
     77     observer->StopSending();
     78     frame_generator_capturer->Stop();
     79     send_stream_->Stop();
     80     call->DestroyVideoSendStream(send_stream_);
     81   }
     82 
     83   void TestMinTransmitBitrate(bool pad_to_min_bitrate);
     84 
     85   void TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
     86                           int threshold_ms,
     87                           int start_time_ms,
     88                           int run_time_ms);
     89 
     90   VideoSendStream::Config send_config_;
     91   std::vector<VideoStream> video_streams_;
     92   VideoSendStream* send_stream_;
     93   test::FakeEncoder fake_encoder_;
     94 };
     95 
     96 class SyncRtcpObserver : public test::RtpRtcpObserver {
     97  public:
     98   explicit SyncRtcpObserver(const FakeNetworkPipe::Config& config)
     99       : test::RtpRtcpObserver(kLongTimeoutMs, config),
    100         crit_(CriticalSectionWrapper::CreateCriticalSection()) {}
    101 
    102   virtual Action OnSendRtcp(const uint8_t* packet, size_t length) OVERRIDE {
    103     RTCPUtility::RTCPParserV2 parser(packet, length, true);
    104     EXPECT_TRUE(parser.IsValid());
    105 
    106     for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
    107          packet_type != RTCPUtility::kRtcpNotValidCode;
    108          packet_type = parser.Iterate()) {
    109       if (packet_type == RTCPUtility::kRtcpSrCode) {
    110         const RTCPUtility::RTCPPacket& packet = parser.Packet();
    111         RtcpMeasurement ntp_rtp_pair(
    112             packet.SR.NTPMostSignificant,
    113             packet.SR.NTPLeastSignificant,
    114             packet.SR.RTPTimestamp);
    115         StoreNtpRtpPair(ntp_rtp_pair);
    116       }
    117     }
    118     return SEND_PACKET;
    119   }
    120 
    121   int64_t RtpTimestampToNtp(uint32_t timestamp) const {
    122     CriticalSectionScoped lock(crit_.get());
    123     int64_t timestamp_in_ms = -1;
    124     if (ntp_rtp_pairs_.size() == 2) {
    125       // TODO(stefan): We can't EXPECT_TRUE on this call due to a bug in the
    126       // RTCP sender where it sends RTCP SR before any RTP packets, which leads
    127       // to a bogus NTP/RTP mapping.
    128       RtpToNtpMs(timestamp, ntp_rtp_pairs_, &timestamp_in_ms);
    129       return timestamp_in_ms;
    130     }
    131     return -1;
    132   }
    133 
    134  private:
    135   void StoreNtpRtpPair(RtcpMeasurement ntp_rtp_pair) {
    136     CriticalSectionScoped lock(crit_.get());
    137     for (RtcpList::iterator it = ntp_rtp_pairs_.begin();
    138          it != ntp_rtp_pairs_.end();
    139          ++it) {
    140       if (ntp_rtp_pair.ntp_secs == it->ntp_secs &&
    141           ntp_rtp_pair.ntp_frac == it->ntp_frac) {
    142         // This RTCP has already been added to the list.
    143         return;
    144       }
    145     }
    146     // We need two RTCP SR reports to map between RTP and NTP. More than two
    147     // will not improve the mapping.
    148     if (ntp_rtp_pairs_.size() == 2) {
    149       ntp_rtp_pairs_.pop_back();
    150     }
    151     ntp_rtp_pairs_.push_front(ntp_rtp_pair);
    152   }
    153 
    154   const scoped_ptr<CriticalSectionWrapper> crit_;
    155   RtcpList ntp_rtp_pairs_ GUARDED_BY(crit_);
    156 };
    157 
    158 class VideoRtcpAndSyncObserver : public SyncRtcpObserver, public VideoRenderer {
    159   static const int kInSyncThresholdMs = 50;
    160   static const int kStartupTimeMs = 2000;
    161   static const int kMinRunTimeMs = 30000;
    162 
    163  public:
    164   VideoRtcpAndSyncObserver(Clock* clock,
    165                            int voe_channel,
    166                            VoEVideoSync* voe_sync,
    167                            SyncRtcpObserver* audio_observer)
    168       : SyncRtcpObserver(FakeNetworkPipe::Config()),
    169         clock_(clock),
    170         voe_channel_(voe_channel),
    171         voe_sync_(voe_sync),
    172         audio_observer_(audio_observer),
    173         creation_time_ms_(clock_->TimeInMilliseconds()),
    174         first_time_in_sync_(-1) {}
    175 
    176   virtual void RenderFrame(const I420VideoFrame& video_frame,
    177                            int time_to_render_ms) OVERRIDE {
    178     int64_t now_ms = clock_->TimeInMilliseconds();
    179     uint32_t playout_timestamp = 0;
    180     if (voe_sync_->GetPlayoutTimestamp(voe_channel_, playout_timestamp) != 0)
    181       return;
    182     int64_t latest_audio_ntp =
    183         audio_observer_->RtpTimestampToNtp(playout_timestamp);
    184     int64_t latest_video_ntp = RtpTimestampToNtp(video_frame.timestamp());
    185     if (latest_audio_ntp < 0 || latest_video_ntp < 0)
    186       return;
    187     int time_until_render_ms =
    188         std::max(0, static_cast<int>(video_frame.render_time_ms() - now_ms));
    189     latest_video_ntp += time_until_render_ms;
    190     int64_t stream_offset = latest_audio_ntp - latest_video_ntp;
    191     std::stringstream ss;
    192     ss << stream_offset;
    193     webrtc::test::PrintResult("stream_offset",
    194                               "",
    195                               "synchronization",
    196                               ss.str(),
    197                               "ms",
    198                               false);
    199     int64_t time_since_creation = now_ms - creation_time_ms_;
    200     // During the first couple of seconds audio and video can falsely be
    201     // estimated as being synchronized. We don't want to trigger on those.
    202     if (time_since_creation < kStartupTimeMs)
    203       return;
    204     if (std::abs(latest_audio_ntp - latest_video_ntp) < kInSyncThresholdMs) {
    205       if (first_time_in_sync_ == -1) {
    206         first_time_in_sync_ = now_ms;
    207         webrtc::test::PrintResult("sync_convergence_time",
    208                                   "",
    209                                   "synchronization",
    210                                   time_since_creation,
    211                                   "ms",
    212                                   false);
    213       }
    214       if (time_since_creation > kMinRunTimeMs)
    215         observation_complete_->Set();
    216     }
    217   }
    218 
    219  private:
    220   Clock* const clock_;
    221   int voe_channel_;
    222   VoEVideoSync* voe_sync_;
    223   SyncRtcpObserver* audio_observer_;
    224   int64_t creation_time_ms_;
    225   int64_t first_time_in_sync_;
    226 };
    227 
    228 TEST_F(CallPerfTest, PlaysOutAudioAndVideoInSync) {
    229   VoiceEngine* voice_engine = VoiceEngine::Create();
    230   VoEBase* voe_base = VoEBase::GetInterface(voice_engine);
    231   VoECodec* voe_codec = VoECodec::GetInterface(voice_engine);
    232   VoENetwork* voe_network = VoENetwork::GetInterface(voice_engine);
    233   VoEVideoSync* voe_sync = VoEVideoSync::GetInterface(voice_engine);
    234   const std::string audio_filename =
    235       test::ResourcePath("voice_engine/audio_long16", "pcm");
    236   ASSERT_STRNE("", audio_filename.c_str());
    237   test::FakeAudioDevice fake_audio_device(Clock::GetRealTimeClock(),
    238                                           audio_filename);
    239   EXPECT_EQ(0, voe_base->Init(&fake_audio_device, NULL));
    240   int channel = voe_base->CreateChannel();
    241 
    242   FakeNetworkPipe::Config net_config;
    243   net_config.queue_delay_ms = 500;
    244   SyncRtcpObserver audio_observer(net_config);
    245   VideoRtcpAndSyncObserver observer(Clock::GetRealTimeClock(),
    246                                     channel,
    247                                     voe_sync,
    248                                     &audio_observer);
    249 
    250   Call::Config receiver_config(observer.ReceiveTransport());
    251   receiver_config.voice_engine = voice_engine;
    252   scoped_ptr<Call> sender_call(
    253       Call::Create(Call::Config(observer.SendTransport())));
    254   scoped_ptr<Call> receiver_call(Call::Create(receiver_config));
    255   CodecInst isac = {103, "ISAC", 16000, 480, 1, 32000};
    256   EXPECT_EQ(0, voe_codec->SetSendCodec(channel, isac));
    257 
    258   class VoicePacketReceiver : public PacketReceiver {
    259    public:
    260     VoicePacketReceiver(int channel, VoENetwork* voe_network)
    261         : channel_(channel),
    262           voe_network_(voe_network),
    263           parser_(RtpHeaderParser::Create()) {}
    264     virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
    265                                          size_t length) OVERRIDE {
    266       int ret;
    267       if (parser_->IsRtcp(packet, static_cast<int>(length))) {
    268         ret = voe_network_->ReceivedRTCPPacket(
    269             channel_, packet, static_cast<unsigned int>(length));
    270       } else {
    271         ret = voe_network_->ReceivedRTPPacket(
    272             channel_, packet, static_cast<unsigned int>(length), PacketTime());
    273       }
    274       return ret == 0 ? DELIVERY_OK : DELIVERY_PACKET_ERROR;
    275     }
    276 
    277    private:
    278     int channel_;
    279     VoENetwork* voe_network_;
    280     scoped_ptr<RtpHeaderParser> parser_;
    281   } voe_packet_receiver(channel, voe_network);
    282 
    283   audio_observer.SetReceivers(&voe_packet_receiver, &voe_packet_receiver);
    284 
    285   internal::TransportAdapter transport_adapter(audio_observer.SendTransport());
    286   transport_adapter.Enable();
    287   EXPECT_EQ(0,
    288             voe_network->RegisterExternalTransport(channel, transport_adapter));
    289 
    290   observer.SetReceivers(receiver_call->Receiver(), sender_call->Receiver());
    291 
    292   test::FakeDecoder fake_decoder;
    293 
    294   CreateTestConfig(sender_call.get());
    295 
    296   VideoReceiveStream::Config receive_config =
    297       receiver_call->GetDefaultReceiveConfig();
    298   assert(receive_config.codecs.empty());
    299   VideoCodec codec =
    300       test::CreateDecoderVideoCodec(send_config_.encoder_settings);
    301   receive_config.codecs.push_back(codec);
    302   assert(receive_config.external_decoders.empty());
    303   ExternalVideoDecoder decoder;
    304   decoder.decoder = &fake_decoder;
    305   decoder.payload_type = send_config_.encoder_settings.payload_type;
    306   receive_config.external_decoders.push_back(decoder);
    307   receive_config.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
    308   receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
    309   receive_config.renderer = &observer;
    310   receive_config.audio_channel_id = channel;
    311 
    312   VideoSendStream* send_stream =
    313       sender_call->CreateVideoSendStream(send_config_, video_streams_, NULL);
    314   VideoReceiveStream* receive_stream =
    315       receiver_call->CreateVideoReceiveStream(receive_config);
    316   scoped_ptr<test::FrameGeneratorCapturer> capturer(
    317       test::FrameGeneratorCapturer::Create(send_stream->Input(),
    318                                            video_streams_[0].width,
    319                                            video_streams_[0].height,
    320                                            30,
    321                                            Clock::GetRealTimeClock()));
    322   receive_stream->Start();
    323   send_stream->Start();
    324   capturer->Start();
    325 
    326   fake_audio_device.Start();
    327   EXPECT_EQ(0, voe_base->StartPlayout(channel));
    328   EXPECT_EQ(0, voe_base->StartReceive(channel));
    329   EXPECT_EQ(0, voe_base->StartSend(channel));
    330 
    331   EXPECT_EQ(kEventSignaled, observer.Wait())
    332       << "Timed out while waiting for audio and video to be synchronized.";
    333 
    334   EXPECT_EQ(0, voe_base->StopSend(channel));
    335   EXPECT_EQ(0, voe_base->StopReceive(channel));
    336   EXPECT_EQ(0, voe_base->StopPlayout(channel));
    337   fake_audio_device.Stop();
    338 
    339   capturer->Stop();
    340   send_stream->Stop();
    341   receive_stream->Stop();
    342   observer.StopSending();
    343   audio_observer.StopSending();
    344 
    345   voe_base->DeleteChannel(channel);
    346   voe_base->Release();
    347   voe_codec->Release();
    348   voe_network->Release();
    349   voe_sync->Release();
    350   sender_call->DestroyVideoSendStream(send_stream);
    351   receiver_call->DestroyVideoReceiveStream(receive_stream);
    352   VoiceEngine::Delete(voice_engine);
    353 }
    354 
    355 class CaptureNtpTimeObserver : public test::RtpRtcpObserver,
    356                                public VideoRenderer {
    357  public:
    358   CaptureNtpTimeObserver(Clock* clock,
    359                          const FakeNetworkPipe::Config& config,
    360                          int threshold_ms,
    361                          int start_time_ms,
    362                          int run_time_ms)
    363       : RtpRtcpObserver(kLongTimeoutMs, config),
    364         clock_(clock),
    365         threshold_ms_(threshold_ms),
    366         start_time_ms_(start_time_ms),
    367         run_time_ms_(run_time_ms),
    368         creation_time_ms_(clock_->TimeInMilliseconds()),
    369         capturer_(NULL),
    370         rtp_start_timestamp_set_(false),
    371         rtp_start_timestamp_(0) {}
    372 
    373   virtual void RenderFrame(const I420VideoFrame& video_frame,
    374                            int time_to_render_ms) OVERRIDE {
    375     if (video_frame.ntp_time_ms() <= 0) {
    376       // Haven't got enough RTCP SR in order to calculate the capture ntp time.
    377       return;
    378     }
    379 
    380     int64_t now_ms = clock_->TimeInMilliseconds();
    381     int64_t time_since_creation = now_ms - creation_time_ms_;
    382     if (time_since_creation < start_time_ms_) {
    383       // Wait for |start_time_ms_| before start measuring.
    384       return;
    385     }
    386 
    387     if (time_since_creation > run_time_ms_) {
    388       observation_complete_->Set();
    389     }
    390 
    391     FrameCaptureTimeList::iterator iter =
    392         capture_time_list_.find(video_frame.timestamp());
    393     EXPECT_TRUE(iter != capture_time_list_.end());
    394 
    395     // The real capture time has been wrapped to uint32_t before converted
    396     // to rtp timestamp in the sender side. So here we convert the estimated
    397     // capture time to a uint32_t 90k timestamp also for comparing.
    398     uint32_t estimated_capture_timestamp =
    399         90 * static_cast<uint32_t>(video_frame.ntp_time_ms());
    400     uint32_t real_capture_timestamp = iter->second;
    401     int time_offset_ms = real_capture_timestamp - estimated_capture_timestamp;
    402     time_offset_ms = time_offset_ms / 90;
    403     std::stringstream ss;
    404     ss << time_offset_ms;
    405 
    406     webrtc::test::PrintResult("capture_ntp_time",
    407                               "",
    408                               "real - estimated",
    409                               ss.str(),
    410                               "ms",
    411                               true);
    412     EXPECT_TRUE(std::abs(time_offset_ms) < threshold_ms_);
    413   }
    414 
    415   virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
    416     RTPHeader header;
    417     EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
    418 
    419     if (!rtp_start_timestamp_set_) {
    420       // Calculate the rtp timestamp offset in order to calculate the real
    421       // capture time.
    422       uint32_t first_capture_timestamp =
    423           90 * static_cast<uint32_t>(capturer_->first_frame_capture_time());
    424       rtp_start_timestamp_ = header.timestamp - first_capture_timestamp;
    425       rtp_start_timestamp_set_ = true;
    426     }
    427 
    428     uint32_t capture_timestamp = header.timestamp - rtp_start_timestamp_;
    429     capture_time_list_.insert(capture_time_list_.end(),
    430                               std::make_pair(header.timestamp,
    431                                              capture_timestamp));
    432     return SEND_PACKET;
    433   }
    434 
    435   void SetCapturer(test::FrameGeneratorCapturer* capturer) {
    436     capturer_ = capturer;
    437   }
    438 
    439  private:
    440   Clock* clock_;
    441   int threshold_ms_;
    442   int start_time_ms_;
    443   int run_time_ms_;
    444   int64_t creation_time_ms_;
    445   test::FrameGeneratorCapturer* capturer_;
    446   bool rtp_start_timestamp_set_;
    447   uint32_t rtp_start_timestamp_;
    448   typedef std::map<uint32_t, uint32_t> FrameCaptureTimeList;
    449   FrameCaptureTimeList capture_time_list_;
    450 };
    451 
    452 void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
    453                                       int threshold_ms,
    454                                       int start_time_ms,
    455                                       int run_time_ms) {
    456   CaptureNtpTimeObserver observer(Clock::GetRealTimeClock(),
    457                                   net_config,
    458                                   threshold_ms,
    459                                   start_time_ms,
    460                                   run_time_ms);
    461 
    462   // Sender/receiver call.
    463   Call::Config receiver_config(observer.ReceiveTransport());
    464   scoped_ptr<Call> receiver_call(Call::Create(receiver_config));
    465   scoped_ptr<Call> sender_call(
    466       Call::Create(Call::Config(observer.SendTransport())));
    467   observer.SetReceivers(receiver_call->Receiver(), sender_call->Receiver());
    468 
    469   // Configure send stream.
    470   CreateTestConfig(sender_call.get());
    471   VideoSendStream* send_stream =
    472       sender_call->CreateVideoSendStream(send_config_, video_streams_, NULL);
    473   scoped_ptr<test::FrameGeneratorCapturer> capturer(
    474       test::FrameGeneratorCapturer::Create(send_stream->Input(),
    475                                            video_streams_[0].width,
    476                                            video_streams_[0].height,
    477                                            30,
    478                                            Clock::GetRealTimeClock()));
    479   observer.SetCapturer(capturer.get());
    480 
    481   // Configure receive stream.
    482   VideoReceiveStream::Config receive_config =
    483       receiver_call->GetDefaultReceiveConfig();
    484   assert(receive_config.codecs.empty());
    485   VideoCodec codec =
    486       test::CreateDecoderVideoCodec(send_config_.encoder_settings);
    487   receive_config.codecs.push_back(codec);
    488   assert(receive_config.external_decoders.empty());
    489   ExternalVideoDecoder decoder;
    490   test::FakeDecoder fake_decoder;
    491   decoder.decoder = &fake_decoder;
    492   decoder.payload_type = send_config_.encoder_settings.payload_type;
    493   receive_config.external_decoders.push_back(decoder);
    494   receive_config.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
    495   receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
    496   receive_config.renderer = &observer;
    497   // Enable the receiver side rtt calculation.
    498   receive_config.rtp.rtcp_xr.receiver_reference_time_report = true;
    499   VideoReceiveStream* receive_stream =
    500       receiver_call->CreateVideoReceiveStream(receive_config);
    501 
    502   // Start the test
    503   receive_stream->Start();
    504   send_stream->Start();
    505   capturer->Start();
    506 
    507   EXPECT_EQ(kEventSignaled, observer.Wait())
    508       << "Timed out while waiting for estimated capture ntp time to be "
    509       << "within bounds.";
    510 
    511   capturer->Stop();
    512   send_stream->Stop();
    513   receive_stream->Stop();
    514   observer.StopSending();
    515 
    516   sender_call->DestroyVideoSendStream(send_stream);
    517   receiver_call->DestroyVideoReceiveStream(receive_stream);
    518 }
    519 
    520 TEST_F(CallPerfTest, CaptureNtpTimeWithNetworkDelay) {
    521   FakeNetworkPipe::Config net_config;
    522   net_config.queue_delay_ms = 100;
    523   // TODO(wu): lower the threshold as the calculation/estimatation becomes more
    524   // accurate.
    525   const int kThresholdMs = 100;
    526   const int kStartTimeMs = 10000;
    527   const int kRunTimeMs = 20000;
    528   TestCaptureNtpTime(net_config, kThresholdMs, kStartTimeMs, kRunTimeMs);
    529 }
    530 
    531 TEST_F(CallPerfTest, CaptureNtpTimeWithNetworkJitter) {
    532   FakeNetworkPipe::Config net_config;
    533   net_config.queue_delay_ms = 100;
    534   net_config.delay_standard_deviation_ms = 10;
    535   // TODO(wu): lower the threshold as the calculation/estimatation becomes more
    536   // accurate.
    537   const int kThresholdMs = 100;
    538   const int kStartTimeMs = 10000;
    539   const int kRunTimeMs = 20000;
    540   TestCaptureNtpTime(net_config, kThresholdMs, kStartTimeMs, kRunTimeMs);
    541 }
    542 
    543 TEST_F(CallPerfTest, RegisterCpuOveruseObserver) {
    544   // Verifies that either a normal or overuse callback is triggered.
    545   class OveruseCallbackObserver : public test::RtpRtcpObserver,
    546                                   public webrtc::OveruseCallback {
    547    public:
    548     OveruseCallbackObserver() : RtpRtcpObserver(kLongTimeoutMs) {}
    549 
    550     virtual void OnOveruse() OVERRIDE {
    551       observation_complete_->Set();
    552     }
    553     virtual void OnNormalUse() OVERRIDE {
    554       observation_complete_->Set();
    555     }
    556   };
    557 
    558   OveruseCallbackObserver observer;
    559   Call::Config call_config(observer.SendTransport());
    560   call_config.overuse_callback = &observer;
    561   scoped_ptr<Call> call(Call::Create(call_config));
    562 
    563   CreateTestConfig(call.get());
    564   RunVideoSendTest(call.get(), send_config_, &observer);
    565 }
    566 
    567 void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
    568   static const int kMaxEncodeBitrateKbps = 30;
    569   static const int kMinTransmitBitrateBps = 150000;
    570   static const int kMinAcceptableTransmitBitrate = 130;
    571   static const int kMaxAcceptableTransmitBitrate = 170;
    572   static const int kNumBitrateObservationsInRange = 100;
    573   class BitrateObserver : public test::RtpRtcpObserver, public PacketReceiver {
    574    public:
    575     explicit BitrateObserver(bool using_min_transmit_bitrate)
    576         : test::RtpRtcpObserver(kLongTimeoutMs),
    577           send_stream_(NULL),
    578           send_transport_receiver_(NULL),
    579           using_min_transmit_bitrate_(using_min_transmit_bitrate),
    580           num_bitrate_observations_in_range_(0) {}
    581 
    582     virtual void SetReceivers(PacketReceiver* send_transport_receiver,
    583                               PacketReceiver* receive_transport_receiver)
    584         OVERRIDE {
    585       send_transport_receiver_ = send_transport_receiver;
    586       test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver);
    587     }
    588 
    589     void SetSendStream(VideoSendStream* send_stream) {
    590       send_stream_ = send_stream;
    591     }
    592 
    593    private:
    594     virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
    595                                          size_t length) OVERRIDE {
    596       VideoSendStream::Stats stats = send_stream_->GetStats();
    597       if (stats.substreams.size() > 0) {
    598         assert(stats.substreams.size() == 1);
    599         int bitrate_kbps = stats.substreams.begin()->second.bitrate_bps / 1000;
    600         if (bitrate_kbps > 0) {
    601           test::PrintResult(
    602               "bitrate_stats_",
    603               (using_min_transmit_bitrate_ ? "min_transmit_bitrate"
    604                                            : "without_min_transmit_bitrate"),
    605               "bitrate_kbps",
    606               static_cast<size_t>(bitrate_kbps),
    607               "kbps",
    608               false);
    609           if (using_min_transmit_bitrate_) {
    610             if (bitrate_kbps > kMinAcceptableTransmitBitrate &&
    611                 bitrate_kbps < kMaxAcceptableTransmitBitrate) {
    612               ++num_bitrate_observations_in_range_;
    613             }
    614           } else {
    615             // Expect bitrate stats to roughly match the max encode bitrate.
    616             if (bitrate_kbps > kMaxEncodeBitrateKbps - 5 &&
    617                 bitrate_kbps < kMaxEncodeBitrateKbps + 5) {
    618               ++num_bitrate_observations_in_range_;
    619             }
    620           }
    621           if (num_bitrate_observations_in_range_ ==
    622               kNumBitrateObservationsInRange)
    623             observation_complete_->Set();
    624         }
    625       }
    626       return send_transport_receiver_->DeliverPacket(packet, length);
    627     }
    628 
    629     VideoSendStream* send_stream_;
    630     PacketReceiver* send_transport_receiver_;
    631     const bool using_min_transmit_bitrate_;
    632     int num_bitrate_observations_in_range_;
    633   } observer(pad_to_min_bitrate);
    634 
    635   scoped_ptr<Call> sender_call(
    636       Call::Create(Call::Config(observer.SendTransport())));
    637   scoped_ptr<Call> receiver_call(
    638       Call::Create(Call::Config(observer.ReceiveTransport())));
    639 
    640   CreateTestConfig(sender_call.get());
    641   fake_encoder_.SetMaxBitrate(kMaxEncodeBitrateKbps);
    642 
    643   observer.SetReceivers(receiver_call->Receiver(), sender_call->Receiver());
    644 
    645   if (pad_to_min_bitrate) {
    646     send_config_.rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
    647   } else {
    648     assert(send_config_.rtp.min_transmit_bitrate_bps == 0);
    649   }
    650 
    651   VideoReceiveStream::Config receive_config =
    652       receiver_call->GetDefaultReceiveConfig();
    653   receive_config.codecs.clear();
    654   VideoCodec codec =
    655       test::CreateDecoderVideoCodec(send_config_.encoder_settings);
    656   receive_config.codecs.push_back(codec);
    657   test::FakeDecoder fake_decoder;
    658   ExternalVideoDecoder decoder;
    659   decoder.decoder = &fake_decoder;
    660   decoder.payload_type = send_config_.encoder_settings.payload_type;
    661   receive_config.external_decoders.push_back(decoder);
    662   receive_config.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
    663   receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
    664 
    665   VideoSendStream* send_stream =
    666       sender_call->CreateVideoSendStream(send_config_, video_streams_, NULL);
    667   VideoReceiveStream* receive_stream =
    668       receiver_call->CreateVideoReceiveStream(receive_config);
    669   scoped_ptr<test::FrameGeneratorCapturer> capturer(
    670       test::FrameGeneratorCapturer::Create(send_stream->Input(),
    671                                            video_streams_[0].width,
    672                                            video_streams_[0].height,
    673                                            30,
    674                                            Clock::GetRealTimeClock()));
    675   observer.SetSendStream(send_stream);
    676   receive_stream->Start();
    677   send_stream->Start();
    678   capturer->Start();
    679 
    680   EXPECT_EQ(kEventSignaled, observer.Wait())
    681       << "Timeout while waiting for send-bitrate stats.";
    682 
    683   send_stream->Stop();
    684   receive_stream->Stop();
    685   observer.StopSending();
    686   capturer->Stop();
    687   sender_call->DestroyVideoSendStream(send_stream);
    688   receiver_call->DestroyVideoReceiveStream(receive_stream);
    689 }
    690 
    691 TEST_F(CallPerfTest, PadsToMinTransmitBitrate) { TestMinTransmitBitrate(true); }
    692 
    693 TEST_F(CallPerfTest, NoPadWithoutMinTransmitBitrate) {
    694   TestMinTransmitBitrate(false);
    695 }
    696 
    697 }  // namespace webrtc
    698