test_rtcp_packet_builder.cc 10.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276
  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. #include "media/cast/test/test_rtcp_packet_builder.h"
  5. #include <memory>
  6. #include "base/check_op.h"
  7. #include "media/cast/net/rtcp/rtcp_utility.h"
  8. namespace media {
  9. namespace cast {
  10. TestRtcpPacketBuilder::TestRtcpPacketBuilder()
  11. : ptr_of_length_(nullptr),
  12. big_endian_writer_(reinterpret_cast<char*>(buffer_), kMaxIpPacketSize),
  13. big_endian_reader_(nullptr, 0) {}
  14. void TestRtcpPacketBuilder::AddSr(uint32_t remote_ssrc,
  15. int number_of_report_blocks) {
  16. AddRtcpHeader(200, number_of_report_blocks);
  17. big_endian_writer_.WriteU32(remote_ssrc);
  18. big_endian_writer_.WriteU32(kNtpHigh); // NTP timestamp.
  19. big_endian_writer_.WriteU32(kNtpLow);
  20. big_endian_writer_.WriteU32(kRtpTimestamp);
  21. big_endian_writer_.WriteU32(kSendPacketCount);
  22. big_endian_writer_.WriteU32(kSendOctetCount);
  23. }
  24. void TestRtcpPacketBuilder::AddSrWithNtp(uint32_t remote_ssrc,
  25. uint32_t ntp_high,
  26. uint32_t ntp_low,
  27. uint32_t rtp_timestamp) {
  28. AddRtcpHeader(200, 0);
  29. big_endian_writer_.WriteU32(remote_ssrc);
  30. big_endian_writer_.WriteU32(ntp_high);
  31. big_endian_writer_.WriteU32(ntp_low);
  32. big_endian_writer_.WriteU32(rtp_timestamp);
  33. big_endian_writer_.WriteU32(kSendPacketCount);
  34. big_endian_writer_.WriteU32(kSendOctetCount);
  35. }
  36. void TestRtcpPacketBuilder::AddRr(uint32_t remote_ssrc,
  37. int number_of_report_blocks) {
  38. AddRtcpHeader(201, number_of_report_blocks);
  39. big_endian_writer_.WriteU32(remote_ssrc);
  40. }
  41. void TestRtcpPacketBuilder::AddRb(uint32_t local_ssrc) {
  42. big_endian_writer_.WriteU32(local_ssrc);
  43. big_endian_writer_.WriteU32(kLoss);
  44. big_endian_writer_.WriteU32(kExtendedMax);
  45. big_endian_writer_.WriteU32(kTestJitter);
  46. big_endian_writer_.WriteU32(kLastSr);
  47. big_endian_writer_.WriteU32(kDelayLastSr);
  48. }
  49. void TestRtcpPacketBuilder::AddXrHeader(uint32_t remote_ssrc) {
  50. AddRtcpHeader(207, 0);
  51. big_endian_writer_.WriteU32(remote_ssrc);
  52. }
  53. void TestRtcpPacketBuilder::AddXrUnknownBlock() {
  54. big_endian_writer_.WriteU8(9); // Block type.
  55. big_endian_writer_.WriteU8(0); // Reserved.
  56. big_endian_writer_.WriteU16(4); // Block length.
  57. // First receiver same as sender of this report.
  58. big_endian_writer_.WriteU32(0);
  59. big_endian_writer_.WriteU32(0);
  60. big_endian_writer_.WriteU32(0);
  61. big_endian_writer_.WriteU32(0);
  62. }
  63. void TestRtcpPacketBuilder::AddUnknownBlock() {
  64. AddRtcpHeader(99, 0);
  65. big_endian_writer_.WriteU32(42);
  66. big_endian_writer_.WriteU32(42);
  67. big_endian_writer_.WriteU32(42);
  68. }
  69. void TestRtcpPacketBuilder::AddXrDlrrBlock(uint32_t remote_ssrc) {
  70. big_endian_writer_.WriteU8(5); // Block type.
  71. big_endian_writer_.WriteU8(0); // Reserved.
  72. big_endian_writer_.WriteU16(3); // Block length.
  73. // First receiver same as sender of this report.
  74. big_endian_writer_.WriteU32(remote_ssrc);
  75. big_endian_writer_.WriteU32(kLastRr);
  76. big_endian_writer_.WriteU32(kDelayLastRr);
  77. }
  78. void TestRtcpPacketBuilder::AddXrExtendedDlrrBlock(uint32_t remote_ssrc) {
  79. big_endian_writer_.WriteU8(5); // Block type.
  80. big_endian_writer_.WriteU8(0); // Reserved.
  81. big_endian_writer_.WriteU16(9); // Block length.
  82. big_endian_writer_.WriteU32(0xaaaaaaaa);
  83. big_endian_writer_.WriteU32(0xaaaaaaaa);
  84. big_endian_writer_.WriteU32(0xaaaaaaaa);
  85. // First receiver same as sender of this report.
  86. big_endian_writer_.WriteU32(remote_ssrc);
  87. big_endian_writer_.WriteU32(kLastRr);
  88. big_endian_writer_.WriteU32(kDelayLastRr);
  89. big_endian_writer_.WriteU32(0xbbbbbbbb);
  90. big_endian_writer_.WriteU32(0xbbbbbbbb);
  91. big_endian_writer_.WriteU32(0xbbbbbbbb);
  92. }
  93. void TestRtcpPacketBuilder::AddXrRrtrBlock() {
  94. big_endian_writer_.WriteU8(4); // Block type.
  95. big_endian_writer_.WriteU8(0); // Reserved.
  96. big_endian_writer_.WriteU16(2); // Block length.
  97. big_endian_writer_.WriteU32(kNtpHigh);
  98. big_endian_writer_.WriteU32(kNtpLow);
  99. }
  100. void TestRtcpPacketBuilder::AddNack(uint32_t remote_ssrc, uint32_t local_ssrc) {
  101. AddRtcpHeader(205, 1);
  102. big_endian_writer_.WriteU32(remote_ssrc);
  103. big_endian_writer_.WriteU32(local_ssrc);
  104. big_endian_writer_.WriteU16(kMissingPacket);
  105. big_endian_writer_.WriteU16(0);
  106. }
  107. void TestRtcpPacketBuilder::AddSendReportRequest(uint32_t remote_ssrc,
  108. uint32_t local_ssrc) {
  109. AddRtcpHeader(205, 5);
  110. big_endian_writer_.WriteU32(remote_ssrc);
  111. big_endian_writer_.WriteU32(local_ssrc);
  112. }
  113. void TestRtcpPacketBuilder::AddCast(uint32_t remote_ssrc,
  114. uint32_t local_ssrc,
  115. base::TimeDelta target_delay) {
  116. AddRtcpHeader(206, 15);
  117. big_endian_writer_.WriteU32(remote_ssrc);
  118. big_endian_writer_.WriteU32(local_ssrc);
  119. big_endian_writer_.WriteU8('C');
  120. big_endian_writer_.WriteU8('A');
  121. big_endian_writer_.WriteU8('S');
  122. big_endian_writer_.WriteU8('T');
  123. big_endian_writer_.WriteU8(kAckFrameId);
  124. big_endian_writer_.WriteU8(3); // Loss fields.
  125. big_endian_writer_.WriteU16(target_delay.InMilliseconds());
  126. big_endian_writer_.WriteU8(kLostFrameId);
  127. big_endian_writer_.WriteU16(kRtcpCastAllPacketsLost);
  128. big_endian_writer_.WriteU8(0); // Lost packet id mask.
  129. big_endian_writer_.WriteU8(kFrameIdWithLostPackets);
  130. big_endian_writer_.WriteU16(kLostPacketId1);
  131. big_endian_writer_.WriteU8(0x2); // Lost packet id mask.
  132. big_endian_writer_.WriteU8(kFrameIdWithLostPackets);
  133. big_endian_writer_.WriteU16(kLostPacketId3);
  134. big_endian_writer_.WriteU8(0); // Lost packet id mask.
  135. }
  136. void TestRtcpPacketBuilder::AddCst2(
  137. const std::vector<FrameId>& later_received_frames) {
  138. big_endian_writer_.WriteU8('C');
  139. big_endian_writer_.WriteU8('S');
  140. big_endian_writer_.WriteU8('T');
  141. big_endian_writer_.WriteU8('2');
  142. big_endian_writer_.WriteU8(kFeedbackSeq);
  143. std::vector<uint8_t> ack_bitmasks;
  144. for (FrameId ack_frame : later_received_frames) {
  145. const int64_t bit_index = ack_frame - (FrameId::first() + kAckFrameId) - 2;
  146. CHECK_LE(INT64_C(0), bit_index);
  147. const size_t index = static_cast<size_t>(bit_index) / 8;
  148. const size_t bit_index_within_byte = static_cast<size_t>(bit_index) % 8;
  149. if (index >= ack_bitmasks.size())
  150. ack_bitmasks.resize(index + 1);
  151. ack_bitmasks[index] |= 1 << bit_index_within_byte;
  152. }
  153. CHECK_LT(ack_bitmasks.size(), 256u);
  154. big_endian_writer_.WriteU8(ack_bitmasks.size());
  155. for (uint8_t ack_bits : ack_bitmasks)
  156. big_endian_writer_.WriteU8(ack_bits);
  157. // Pad to ensure the extra CST2 data chunk is 32-bit aligned.
  158. for (size_t num_bytes_written = 6 + ack_bitmasks.size();
  159. num_bytes_written % 4; ++num_bytes_written) {
  160. big_endian_writer_.WriteU8(0);
  161. }
  162. }
  163. void TestRtcpPacketBuilder::AddErrorCst2() {
  164. big_endian_writer_.WriteU8('C');
  165. big_endian_writer_.WriteU8('A');
  166. big_endian_writer_.WriteU8('S');
  167. big_endian_writer_.WriteU8('T');
  168. big_endian_writer_.WriteU8(kFeedbackSeq);
  169. big_endian_writer_.WriteU8(0);
  170. big_endian_writer_.WriteU8(0);
  171. big_endian_writer_.WriteU8(0);
  172. }
  173. void TestRtcpPacketBuilder::AddPli(uint32_t remote_ssrc, uint32_t local_ssrc) {
  174. AddRtcpHeader(206, 1);
  175. big_endian_writer_.WriteU32(remote_ssrc);
  176. big_endian_writer_.WriteU32(local_ssrc);
  177. }
  178. void TestRtcpPacketBuilder::AddReceiverLog(uint32_t remote_ssrc) {
  179. AddRtcpHeader(204, 2);
  180. big_endian_writer_.WriteU32(remote_ssrc);
  181. big_endian_writer_.WriteU8('C');
  182. big_endian_writer_.WriteU8('A');
  183. big_endian_writer_.WriteU8('S');
  184. big_endian_writer_.WriteU8('T');
  185. }
  186. void TestRtcpPacketBuilder::AddReceiverFrameLog(uint32_t rtp_timestamp,
  187. int num_events,
  188. uint32_t event_timesamp_base) {
  189. big_endian_writer_.WriteU32(rtp_timestamp);
  190. big_endian_writer_.WriteU8(static_cast<uint8_t>(num_events - 1));
  191. big_endian_writer_.WriteU8(static_cast<uint8_t>(event_timesamp_base >> 16));
  192. big_endian_writer_.WriteU8(static_cast<uint8_t>(event_timesamp_base >> 8));
  193. big_endian_writer_.WriteU8(static_cast<uint8_t>(event_timesamp_base));
  194. }
  195. void TestRtcpPacketBuilder::AddReceiverEventLog(uint16_t event_data,
  196. CastLoggingEvent event,
  197. uint16_t event_timesamp_delta) {
  198. big_endian_writer_.WriteU16(event_data);
  199. uint8_t event_id = ConvertEventTypeToWireFormat(event);
  200. uint16_t type_and_delta = static_cast<uint16_t>(event_id) << 12;
  201. type_and_delta += event_timesamp_delta & 0x0fff;
  202. big_endian_writer_.WriteU16(type_and_delta);
  203. }
  204. std::unique_ptr<media::cast::Packet> TestRtcpPacketBuilder::GetPacket() {
  205. PatchLengthField();
  206. return std::make_unique<media::cast::Packet>(buffer_, buffer_ + Length());
  207. }
  208. const uint8_t* TestRtcpPacketBuilder::Data() {
  209. PatchLengthField();
  210. return buffer_;
  211. }
  212. base::BigEndianReader* TestRtcpPacketBuilder::Reader() {
  213. big_endian_reader_ = base::BigEndianReader(Data(), Length());
  214. return &big_endian_reader_;
  215. }
  216. void TestRtcpPacketBuilder::PatchLengthField() {
  217. if (ptr_of_length_) {
  218. // Back-patch the packet length. The client must have taken
  219. // care of proper padding to 32-bit words.
  220. int this_packet_length = (big_endian_writer_.ptr() - ptr_of_length_ - 2);
  221. DCHECK_EQ(0, this_packet_length % 4)
  222. << "Packets must be a multiple of 32 bits long";
  223. *ptr_of_length_ = this_packet_length >> 10;
  224. *(ptr_of_length_ + 1) = (this_packet_length >> 2) & 0xFF;
  225. ptr_of_length_ = nullptr;
  226. }
  227. }
  228. // Set the 5-bit value in the 1st byte of the header
  229. // and the payload type. Set aside room for the length field,
  230. // and make provision for back-patching it.
  231. void TestRtcpPacketBuilder::AddRtcpHeader(int payload, int format_or_count) {
  232. PatchLengthField();
  233. big_endian_writer_.WriteU8(0x80 | (format_or_count & 0x1F));
  234. big_endian_writer_.WriteU8(payload);
  235. ptr_of_length_ = big_endian_writer_.ptr();
  236. // Initialize length to "clearly illegal".
  237. big_endian_writer_.WriteU16(0xDEAD);
  238. }
  239. } // namespace cast
  240. } // namespace media