Making FakeNetworkPipe demux audio and video packets.

webrtc/test/fake_network_pipe.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/test/fake_network_pipe.h"
 
 #include <assert.h>
 #include <math.h>
 #include <string.h>
 
 #include <algorithm>
 #include <cmath>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/call/call.h"
+#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
 namespace {
 constexpr int64_t kDefaultProcessIntervalMs = 5;
 }
 
-FakeNetworkPipe::FakeNetworkPipe(Clock* clock,
-                                 const FakeNetworkPipe::Config& config,
-                                 MediaType media_type)
-    : FakeNetworkPipe(clock, config, media_type, 1) {}
+FakeNetworkPipe::FakeNetworkPipe(
+    Clock* clock,
+    const FakeNetworkPipe::Config& config,
+    const std::map<uint8_t, MediaType>& payload_type_map)
+    : FakeNetworkPipe(clock, config, payload_type_map, 1) {}
 
-FakeNetworkPipe::FakeNetworkPipe(Clock* clock,
-                                 const FakeNetworkPipe::Config& config,
-                                 MediaType media_type,
-                                 uint64_t seed)
+FakeNetworkPipe::FakeNetworkPipe(
+    Clock* clock,
+    const FakeNetworkPipe::Config& config,
+    const std::map<uint8_t, MediaType>& payload_type_map,
+    uint64_t seed)
     : clock_(clock),
-      media_type_(media_type),
       packet_receiver_(NULL),
       random_(seed),
       config_(),
       dropped_packets_(0),
       sent_packets_(0),
       total_packet_delay_(0),
       bursting_(false),
       next_process_time_(clock_->TimeInMilliseconds()),
-      last_log_time_(clock_->TimeInMilliseconds()) {
+      last_log_time_(clock_->TimeInMilliseconds()),
+      payload_type_map_(payload_type_map) {
   SetConfig(config);
 }
 
 FakeNetworkPipe::~FakeNetworkPipe() {
   while (!capacity_link_.empty()) {
     delete capacity_link_.front();
     capacity_link_.pop();
   }
   while (!delay_link_.empty()) {
     delete *delay_link_.begin();
@@ skipping 135 matching lines @@
       // |time_now| might be later than when the packet should have arrived, due
       // to NetworkProcess being called too late. For stats, use the time it
       // should have been on the link.
       total_packet_delay_ += packet->arrival_time() - packet->send_time();
     }
     sent_packets_ += packets_to_deliver.size();
   }
   while (!packets_to_deliver.empty()) {
     NetworkPacket* packet = packets_to_deliver.front();
     packets_to_deliver.pop();
-    packet_receiver_->DeliverPacket(media_type_, packet->data(),
-                                    packet->data_length(), PacketTime());
+
+    const uint8_t* const packet_data = packet->data();
+    const size_t packet_length = packet->data_length();
+    MediaType media_type = MediaType::ANY;
+    if (!RtpHeaderParser::IsRtcp(packet_data, packet_length)) {
+      RTC_CHECK_GE(packet_length, 2);
+      const uint8_t pt = packet_data[1] & 0x7f;

[stefan-webrtc, 2017/04/06 11:54:51]

payload_type

+      std::map<uint8_t, MediaType>::const_iterator it =
+          payload_type_map_.find(pt);
+      RTC_CHECK(it != payload_type_map_.end())

[minyue-webrtc, 2017/04/06 11:33:38]

I made it very strict here. All payloads have to be registered. I think it is
good to disallow any unexpected payload.

[perkj_webrtc, 2017/04/06 13:49:53]

but it will break upstream since that is not the current behaviour. 
You will have to allow the old behaviour or use type ANY until this has landed
and upstream projects changed.

[minyue-webrtc, 2017/04/06 18:45:10]

Ok. and so, is the change of ctor definition also needs to consider backward
compatibility?

[perkj_webrtc, 2017/04/06 19:13:14]

no, the "deprecated" version is used.

+          << "payload type " << static_cast<int>(pt) << " unknown.";
+      media_type = it->second;
+    }
+    packet_receiver_->DeliverPacket(media_type, packet_data, packet_length,
+                                    PacketTime());
     delete packet;
   }
 
   next_process_time_ = !delay_link_.empty()
                            ? (*delay_link_.begin())->arrival_time()
                            : time_now + kDefaultProcessIntervalMs;
 }
 
 int64_t FakeNetworkPipe::TimeUntilNextProcess() const {
   rtc::CritScope crit(&lock_);
   return std::max<int64_t>(next_process_time_ - clock_->TimeInMilliseconds(),
                            0);
 }
 
 }  // namespace webrtc