Wire up transport sequence number / send time callbacks to webrtc via libjingle.

talk/session/media/channel.cc

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 173 matching lines @@
       enabled_(false),
       writable_(false),
       rtp_ready_to_send_(false),
       rtcp_ready_to_send_(false),
       was_ever_writable_(false),
       local_content_direction_(MD_INACTIVE),
       remote_content_direction_(MD_INACTIVE),
       has_received_packet_(false),
       dtls_keyed_(false),
       secure_required_(false),
-      rtp_abs_sendtime_extn_id_(-1) {
+      rtp_abs_sendtime_extn_id_(-1),
+      rtp_transport_sequence_number_extn_id_(-1) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   LOG(LS_INFO) << "Created channel for " << content_name;
 }
 
 BaseChannel::~BaseChannel() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   Deinit();
   StopConnectionMonitor();
   FlushRtcpMessages();  // Send any outstanding RTCP packets.
   worker_thread_->Clear(this);  // eats any outstanding messages or packets
@@ skipping 131 matching lines @@
   // setting new channel
   UpdateWritableState_w();
   SetReadyToSend(true, new_tc && new_tc->writable());
 }
 
 void BaseChannel::ConnectToTransportChannel(TransportChannel* tc) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   tc->SignalWritableState.connect(this, &BaseChannel::OnWritableState);
   tc->SignalReadPacket.connect(this, &BaseChannel::OnChannelRead);
+  tc->SignalSentPacket.connect(this, &BaseChannel::OnPacketSent);
   tc->SignalReadyToSend.connect(this, &BaseChannel::OnReadyToSend);
 }
 
 void BaseChannel::DisconnectFromTransportChannel(TransportChannel* tc) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   tc->SignalWritableState.disconnect(this);
   tc->SignalReadPacket.disconnect(this);
   tc->SignalReadyToSend.disconnect(this);
 }
@@ skipping 114 matching lines @@
   // OnChannelRead gets called from P2PSocket; now pass data to MediaEngine
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // When using RTCP multiplexing we might get RTCP packets on the RTP
   // transport. We feed RTP traffic into the demuxer to determine if it is RTCP.
   bool rtcp = PacketIsRtcp(channel, data, len);
   rtc::Buffer packet(data, len);
   HandlePacket(rtcp, &packet, packet_time);
 }
 
+void BaseChannel::OnPacketSent(TransportChannel* channel,
+                               const rtc::SentPacket& packet_sent) {
+  ASSERT(channel == transport_channel_ || channel == rtcp_transport_channel_);
+  if (channel == transport_channel_) {
+    media_channel_->OnPacketSent(packet_sent);

[pthatcher1, 2015/09/25 23:24:57]

This means that all 3 channels (audio, video, and data) will get called back for
all of the packets for all three.  That seems a bit overkill.  And in the future
when we have N channels, it will be worse.  Can we just call directly into the
Call object somehow?

[stefan-webrtc, 2015/09/28 12:10:49]

That would be nicer. I'll look into it.

+  }
+}
+
 void BaseChannel::OnReadyToSend(TransportChannel* channel) {
   ASSERT(channel == transport_channel_ || channel == rtcp_transport_channel_);
   SetReadyToSend(channel == rtcp_transport_channel_, true);
 }
 
 void BaseChannel::SetReadyToSend(bool rtcp, bool ready) {
   if (rtcp) {
     rtcp_ready_to_send_ = ready;
   } else {
     rtp_ready_to_send_ = ready;
@@ skipping 64 matching lines @@
     // inside libsrtp for a RTP packet. A external HMAC module will be writing
     // a fake HMAC value. This is ONLY done for a RTP packet.
     // Socket layer will update rtp sendtime extension header if present in
     // packet with current time before updating the HMAC.
 #if !defined(ENABLE_EXTERNAL_AUTH)
       res = srtp_filter_.ProtectRtp(
           data, len, static_cast<int>(packet->capacity()), &len);
 #else
       options.packet_time_params.rtp_sendtime_extension_id =
           rtp_abs_sendtime_extn_id_;
+      options.transport_sequence_number =
+          ParseTransportSequenceNumberHeaderExtension(data, len);

[pthatcher1, 2015/09/25 23:24:57]

I really think is the wrong place for this.  It would be much better to change
BaseChannel::SendPacket to take a packet_id as parameter, perhaps by replacing
dscp with packet_options like it is in the lower layers.  Then the layer
creating the packet can just put the ID on the packet rather than having to do
this crazy parsing thing.

[stefan-webrtc, 2015/09/28 12:10:50]

Yes, I definitely agree that it would make more sense to pass the sequence
number with the packet all the way from where it is created. I'll discuss with
others to see if we can change the WebRTC transport interface to allow this.

[stefan-webrtc, 2015/10/02 13:29:12]

Done.

       res = srtp_filter_.ProtectRtp(
           data, len, static_cast<int>(packet->capacity()), &len,
           &options.packet_time_params.srtp_packet_index);
       // If protection succeeds, let's get auth params from srtp.
       if (res) {
         uint8* auth_key = NULL;
         int key_len;
         res = srtp_filter_.GetRtpAuthParams(
             &auth_key, &key_len, &options.packet_time_params.srtp_auth_tag_len);
         if (res) {
@@ skipping 44 matching lines @@
   if (ret != static_cast<int>(packet->size())) {
     if (channel->GetError() == EWOULDBLOCK) {
       LOG(LS_WARNING) << "Got EWOULDBLOCK from socket.";
       SetReadyToSend(rtcp, false);
     }
     return false;
   }
   return true;
 }
 
+int32_t BaseChannel::ParseTransportSequenceNumberHeaderExtension(
+    uint8_t* data,
+    size_t length) const {
+  //  0                   1                   2                   3
+  //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+  // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  // |V=2|P|X|  CC   |M|     PT      |       sequence number         |
+  // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  // |                           timestamp                           |
+  // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  // |           synchronization source (SSRC) identifier            |
+  // +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+  // |            contributing source (CSRC) identifiers             |
+  // |                             ....                              |
+  // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+  // Return if extension bit is not set.
+  if (!(data[0] & 0x10)) {
+    return -1;
+  }
+
+  size_t cc_count = data[0] & 0x0F;
+  const size_t kMinRtpHeaderLength = 12;
+  size_t header_length_without_extension = kMinRtpHeaderLength + 4 * cc_count;
+
+  data += header_length_without_extension;
+
+  // Getting extension profile ID and length.
+  uint16 profile_id = rtc::GetBE16(data);
+  // Length is in 32 bit words.
+  uint16 extension_length_in_32bits = rtc::GetBE16(data + 2);
+  size_t extension_length = extension_length_in_32bits * 4;
+
+  const size_t kRtpExtensionHeaderLength = 4;
+  data += kRtpExtensionHeaderLength;  // Moving past extension header.
+
+  int32_t transport_sequence_number = -1;
+  // The transport sequence number is a one byte header extension.
+  if (profile_id == 0xBEDE) {  // One byte extension header.
+    //  0
+    //  0 1 2 3 4 5 6 7
+    // +-+-+-+-+-+-+-+-+
+    // |  ID   |length |
+    // +-+-+-+-+-+-+-+-+
+
+    //  0                   1                   2                   3
+    //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    // |       0xBE    |    0xDE       |           length=3            |
+    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    // |  ID   | L=0   |     data      |  ID   |  L=1  |   data...
+    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    //       ...data   |    0 (pad)    |    0 (pad)    |  ID   | L=3   |
+    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    // |                          data                                 |
+    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    const uint8_t* extension_start = data;
+    const uint8_t* extension_end = extension_start + extension_length;
+
+    while (data < extension_end) {
+      const int id = (*data & 0xF0) >> 4;
+      const size_t length = (*data & 0x0F) + 1;
+      const size_t kOneByteHeaderLength = 1;
+      if (data + kOneByteHeaderLength + length > extension_end) {
+        break;
+      }
+      // The 4-bit length is the number minus one of data bytes of this header
+      // extension element following the one-byte header.
+      if (id == rtp_transport_sequence_number_extn_id_) {
+        transport_sequence_number = rtc::GetBE24(data + kOneByteHeaderLength);
+        break;
+      }
+      data += kOneByteHeaderLength + length;
+      // Counting padding bytes.
+      while ((data < extension_end) && (*data == 0)) {
+        ++data;
+      }
+    }
+  }
+  return transport_sequence_number;
+}
+
 bool BaseChannel::WantsPacket(bool rtcp, rtc::Buffer* packet) {
   // Protect ourselves against crazy data.
   if (!ValidPacket(rtcp, packet)) {
     LOG(LS_ERROR) << "Dropping incoming " << content_name_ << " "
                   << PacketType(rtcp)
                   << " packet: wrong size=" << packet->size();
     return false;
   }
 
   // Bundle filter handles both rtp and rtcp packets.
@@ skipping 594 matching lines @@
         desc << "Failed to add remote stream ssrc: " << it->first_ssrc();
         SafeSetError(desc.str(), error_desc);
         ret = false;
       }
     }
   }
   remote_streams_ = streams;
   return ret;
 }
 
-void BaseChannel::MaybeCacheRtpAbsSendTimeHeaderExtension(
+void BaseChannel::MaybeCacheRtpHeaderExtensions(
     const std::vector<RtpHeaderExtension>& extensions) {
   const RtpHeaderExtension* send_time_extension =
       FindHeaderExtension(extensions, kRtpAbsoluteSenderTimeHeaderExtension);
   rtp_abs_sendtime_extn_id_ =
       send_time_extension ? send_time_extension->id : -1;
+
+  const RtpHeaderExtension* transport_sequence_number = FindHeaderExtension(
+      extensions, kRtpTransportSequenceNumberHeaderExtension);
+  rtp_transport_sequence_number_extn_id_ =
+      transport_sequence_number ? transport_sequence_number->id : -1;
 }
 
 void BaseChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
     case MSG_RTPPACKET:
     case MSG_RTCPPACKET: {
       PacketMessageData* data = static_cast<PacketMessageData*>(pmsg->pdata);
       SendPacket(pmsg->message_id == MSG_RTCPPACKET, &data->packet, data->dscp);
       delete data;  // because it is Posted
       break;
@@ skipping 273 matching lines @@
   // TODO(pthatcher): Move remote streams into AudioRecvParameters,
   // and only give it to the media channel once we have a local
   // description too (without a local description, we won't be able to
   // recv them anyway).
   if (!UpdateRemoteStreams_w(audio->streams(), action, error_desc)) {
     SafeSetError("Failed to set remote audio description streams.", error_desc);
     return false;
   }
 
   if (audio->rtp_header_extensions_set()) {
-    MaybeCacheRtpAbsSendTimeHeaderExtension(audio->rtp_header_extensions());
+    MaybeCacheRtpHeaderExtensions(audio->rtp_header_extensions());
   }
 
   set_remote_content_direction(content->direction());
   ChangeState();
   return true;
 }
 
 void VoiceChannel::HandleEarlyMediaTimeout() {
   // This occurs on the main thread, not the worker thread.
   if (!received_media_) {
@@ skipping 305 matching lines @@
   // TODO(pthatcher): Move remote streams into VideoRecvParameters,
   // and only give it to the media channel once we have a local
   // description too (without a local description, we won't be able to
   // recv them anyway).
   if (!UpdateRemoteStreams_w(video->streams(), action, error_desc)) {
     SafeSetError("Failed to set remote video description streams.", error_desc);
     return false;
   }
 
   if (video->rtp_header_extensions_set()) {
-    MaybeCacheRtpAbsSendTimeHeaderExtension(video->rtp_header_extensions());
+    MaybeCacheRtpHeaderExtensions(video->rtp_header_extensions());
   }
 
   set_remote_content_direction(content->direction());
   ChangeState();
   return true;
 }
 
 bool VideoChannel::ApplyViewRequest_w(const ViewRequest& request) {
   bool ret = true;
   // Set the send format for each of the local streams. If the view request
@@ skipping 525 matching lines @@
   return (data_channel_type_ == DCT_RTP);
 }
 
 void DataChannel::OnStreamClosedRemotely(uint32 sid) {
   rtc::TypedMessageData<uint32>* message =
       new rtc::TypedMessageData<uint32>(sid);
   signaling_thread()->Post(this, MSG_STREAMCLOSEDREMOTELY, message);
 }
 
 }  // namespace cricket