src/media/cast/rtp_sender/rtp_packetizer/rtp_packetizer_unittest.cc

   1 // Copyright 2013 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 "media/cast/rtp_sender/rtp_packetizer/rtp_packetizer.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/test/simple_test_tick_clock.h"
   9 #include "media/cast/cast_config.h"
  10 #include "media/cast/pacing/paced_sender.h"
  11 #include "media/cast/rtp_common/rtp_defines.h"
  12 #include "media/cast/rtp_sender/packet_storage/packet_storage.h"
  13 #include "media/cast/rtp_sender/rtp_packetizer/test/rtp_header_parser.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15
  16 namespace media {
  17 namespace cast {
  18
  19 static const int kPayload = 127;
  20 static const uint32 kTimestampMs = 10;
  21 static const uint16 kSeqNum = 33;
  22 static const int kMaxPacketLength = 1500;
  23 static const int kSsrc = 0x12345;
  24 static const unsigned int kFrameSize = 5000;
  25 static const int kMaxPacketStorageTimeMs = 300;
  26
  27 class TestRtpPacketTransport : public PacedPacketSender {
  28  public:
  29   explicit TestRtpPacketTransport(RtpPacketizerConfig config)
  30        : config_(config),
  31          sequence_number_(kSeqNum),
  32          packets_sent_(0),
  33          expected_number_of_packets_(0),
  34          expected_packet_id_(0),
  35          expected_frame_id_(0) {}
  36
  37   void VerifyRtpHeader(const RtpCastHeader& rtp_header) {
  38     VerifyCommonRtpHeader(rtp_header);
  39     VerifyCastRtpHeader(rtp_header);
  40   }
  41
  42   void VerifyCommonRtpHeader(const RtpCastHeader& rtp_header) {
  43     EXPECT_EQ(expected_number_of_packets_ == packets_sent_,
  44         rtp_header.webrtc.header.markerBit);
  45     EXPECT_EQ(kPayload, rtp_header.webrtc.header.payloadType);
  46     EXPECT_EQ(sequence_number_, rtp_header.webrtc.header.sequenceNumber);
  47     EXPECT_EQ(kTimestampMs * 90, rtp_header.webrtc.header.timestamp);
  48     EXPECT_EQ(config_.ssrc, rtp_header.webrtc.header.ssrc);
  49     EXPECT_EQ(0, rtp_header.webrtc.header.numCSRCs);
  50   }
  51
  52   void VerifyCastRtpHeader(const RtpCastHeader& rtp_header) {
  53     EXPECT_FALSE(rtp_header.is_key_frame);
  54     EXPECT_EQ(expected_frame_id_, rtp_header.frame_id);
  55     EXPECT_EQ(expected_packet_id_, rtp_header.packet_id);
  56     EXPECT_EQ(expected_number_of_packets_ - 1, rtp_header.max_packet_id);
  57     EXPECT_TRUE(rtp_header.is_reference);
  58     EXPECT_EQ(static_cast<uint8>(expected_frame_id_ - 1),
  59         rtp_header.reference_frame_id);
  60   }
  61
  62   virtual bool SendPackets(const PacketList& packets) OVERRIDE {
  63     EXPECT_EQ(expected_number_of_packets_, static_cast<int>(packets.size()));
  64     PacketList::const_iterator it = packets.begin();
  65     for (; it != packets.end(); ++it) {
  66       ++packets_sent_;
  67       RtpHeaderParser parser(it->data(), it->size());
  68       RtpCastHeader rtp_header;
  69       parser.Parse(&rtp_header);
  70       VerifyRtpHeader(rtp_header);
  71       ++sequence_number_;
  72       ++expected_packet_id_;
  73     }
  74     return true;
  75   }
  76
  77   virtual bool ResendPackets(const PacketList& packets) OVERRIDE {
  78     EXPECT_TRUE(false);
  79     return false;
  80   }
  81
  82   virtual bool SendRtcpPacket(const std::vector<uint8>& packet) OVERRIDE {
  83     EXPECT_TRUE(false);
  84     return false;
  85   }
  86
  87   void SetExpectedNumberOfPackets(int num) {
  88     expected_number_of_packets_ = num;
  89   }
  90
  91   RtpPacketizerConfig config_;
  92   uint32 sequence_number_;
  93   int packets_sent_;
  94   int expected_number_of_packets_;
  95   // Assuming packets arrive in sequence.
  96   int expected_packet_id_;
  97   int expected_frame_id_;
  98 };
  99
 100 class RtpPacketizerTest : public ::testing::Test {
 101  protected:
 102   RtpPacketizerTest()
 103       :video_frame_(),
 104        packet_storage_(&testing_clock_, kMaxPacketStorageTimeMs) {
 105     config_.sequence_number = kSeqNum;
 106     config_.ssrc = kSsrc;
 107     config_.payload_type = kPayload;
 108     config_.max_payload_length = kMaxPacketLength;
 109     transport_.reset(new TestRtpPacketTransport(config_));
 110     rtp_packetizer_.reset(
 111         new RtpPacketizer(transport_.get(), &packet_storage_, config_));
 112   }
 113
 114   virtual ~RtpPacketizerTest() {}
 115
 116   virtual void SetUp() {
 117     video_frame_.key_frame = false;
 118     video_frame_.last_referenced_frame_id = 255;
 119     video_frame_.data.assign(kFrameSize, 123);
 120   }
 121
 122   base::SimpleTestTickClock testing_clock_;
 123   scoped_ptr<RtpPacketizer> rtp_packetizer_;
 124   RtpPacketizerConfig config_;
 125   scoped_ptr<TestRtpPacketTransport> transport_;
 126   EncodedVideoFrame video_frame_;
 127   PacketStorage packet_storage_;
 128 };
 129
 130 TEST_F(RtpPacketizerTest, SendStandardPackets) {
 131   int expected_num_of_packets = kFrameSize / kMaxPacketLength + 1;
 132   transport_->SetExpectedNumberOfPackets(expected_num_of_packets);
 133
 134   base::TimeTicks time;
 135   time += base::TimeDelta::FromMilliseconds(kTimestampMs);
 136   rtp_packetizer_->IncomingEncodedVideoFrame(&video_frame_, time);
 137 }
 138
 139 TEST_F(RtpPacketizerTest, Stats) {
 140   EXPECT_FALSE(rtp_packetizer_->send_packets_count());
 141   EXPECT_FALSE(rtp_packetizer_->send_octet_count());
 142   // Insert packets at varying lengths.
 143   int expected_num_of_packets = kFrameSize / kMaxPacketLength + 1;
 144   transport_->SetExpectedNumberOfPackets(expected_num_of_packets);
 145
 146   testing_clock_.Advance(base::TimeDelta::FromMilliseconds(kTimestampMs));
 147   rtp_packetizer_->IncomingEncodedVideoFrame(&video_frame_,
 148                                              testing_clock_.NowTicks());
 149   EXPECT_EQ(expected_num_of_packets, rtp_packetizer_->send_packets_count());
 150   EXPECT_EQ(kFrameSize, rtp_packetizer_->send_octet_count());
 151 }
 152
 153 }  // namespace cast
 154 }  // namespace media