Use RtpHeaderParser in VideoCall implementation.

BUG=1827
R=stefan@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/1962004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@4483 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/video_engine/internal/video_call.cc

@@ -15,8 +15,6 @@
 #include <map>
 #include <vector>
 
-#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/video_engine/include/vie_base.h"
 #include "webrtc/video_engine/include/vie_codec.h"
 #include "webrtc/video_engine/include/vie_rtp_rtcp.h"
@@ -32,6 +30,7 @@ VideoCall::VideoCall(webrtc::VideoEngine* video_engine,
     : config_(config),
       receive_lock_(RWLockWrapper::CreateRWLock()),
       send_lock_(RWLockWrapper::CreateRWLock()),
+      rtp_header_parser_(RtpHeaderParser::Create()),
       video_engine_(video_engine) {
   assert(video_engine != NULL);
   assert(config.send_transport != NULL);
@@ -74,9 +73,8 @@ newapi::VideoSendStream* VideoCall::CreateSendStream(
   assert(config.codec.numberOfSimulcastStreams == 0 ||
          config.codec.numberOfSimulcastStreams == config.rtp.ssrcs.size());
 
-  VideoSendStream* send_stream =
-      new VideoSendStream(config_.send_transport, config_.overuse_detection,
-                          video_engine_, config);
+  VideoSendStream* send_stream = new VideoSendStream(
+      config_.send_transport, config_.overuse_detection, video_engine_, config);
 
   WriteLockScoped write_lock(*send_lock_);
   for (size_t i = 0; i < config.rtp.ssrcs.size(); ++i) {
@@ -104,8 +102,8 @@ VideoReceiveStream::Config VideoCall::GetDefaultReceiveConfig() {
 
 newapi::VideoReceiveStream* VideoCall::CreateReceiveStream(
     const newapi::VideoReceiveStream::Config& config) {
-  VideoReceiveStream* receive_stream = new VideoReceiveStream(
-      video_engine_, config, config_.send_transport);
+  VideoReceiveStream* receive_stream =
+      new VideoReceiveStream(video_engine_, config, config_.send_transport);
 
   WriteLockScoped write_lock(*receive_lock_);
   assert(receive_ssrcs_.find(config.rtp.ssrc) == receive_ssrcs_.end());
@@ -132,67 +130,66 @@ uint32_t VideoCall::ReceiveBitrateEstimate() {
   return 0;
 }
 
-bool VideoCall::DeliverRtcp(ModuleRTPUtility::RTPHeaderParser* rtp_parser,
-                            const void* packet, size_t length) {
+bool VideoCall::DeliverRtcp(const uint8_t* packet, size_t length) {
   // TODO(pbos): Figure out what channel needs it actually.
   //             Do NOT broadcast! Also make sure it's a valid packet.
   bool rtcp_delivered = false;
-  ReadLockScoped read_lock(*receive_lock_);
-  for (std::map<uint32_t, newapi::VideoReceiveStream*>::iterator it =
-           receive_ssrcs_.begin();
-       it != receive_ssrcs_.end(); ++it) {
-    if (static_cast<VideoReceiveStream*>(it->second)
-            ->DeliverRtcp(static_cast<const uint8_t*>(packet), length)) {
-      rtcp_delivered = true;
+  {
+    ReadLockScoped read_lock(*receive_lock_);
+    for (std::map<uint32_t, VideoReceiveStream*>::iterator it =
+             receive_ssrcs_.begin();
+         it != receive_ssrcs_.end();
+         ++it) {
+      if (it->second->DeliverRtcp(static_cast<const uint8_t*>(packet),
+                                  length)) {
+        rtcp_delivered = true;
+      }
     }
   }
 
-  if (rtcp_delivered)
-    return true;
-
-  for (std::map<uint32_t, newapi::VideoSendStream*>::iterator it =
-           send_ssrcs_.begin();
-       it != send_ssrcs_.end();
-       ++it) {
-    if (static_cast<VideoSendStream*>(it->second)
-            ->DeliverRtcp(static_cast<const uint8_t*>(packet), length)) {
-      rtcp_delivered = true;
+  {
+    ReadLockScoped read_lock(*send_lock_);
+    for (std::map<uint32_t, VideoSendStream*>::iterator it =
+             send_ssrcs_.begin();
+         it != send_ssrcs_.end();
+         ++it) {
+      if (it->second->DeliverRtcp(static_cast<const uint8_t*>(packet),
+                                  length)) {
+        rtcp_delivered = true;
+      }
     }
   }
   return rtcp_delivered;
 }
 
-bool VideoCall::DeliverRtp(ModuleRTPUtility::RTPHeaderParser* rtp_parser,
-                           const void* packet, size_t length) {
-  RTPHeader rtp_header;
+bool VideoCall::DeliverRtp(const RTPHeader& header,
+                           const uint8_t* packet,
+                           size_t length) {
+  VideoReceiveStream* receiver;
+  {
+    ReadLockScoped read_lock(*receive_lock_);
+    std::map<uint32_t, VideoReceiveStream*>::iterator it =
+        receive_ssrcs_.find(header.ssrc);
+    if (it == receive_ssrcs_.end()) {
+      // TODO(pbos): Log some warning, SSRC without receiver.
+      return false;
+    }
 
-  // TODO(pbos): ExtensionMap if there are extensions
-  if (!rtp_parser->Parse(rtp_header)) {
-    // TODO(pbos): Should this error be reported and trigger something?
-    return false;
+    receiver = it->second;
   }
-
-  ReadLockScoped read_lock(*receive_lock_);
-  if (receive_ssrcs_.find(rtp_header.ssrc) == receive_ssrcs_.end()) {
-    // TODO(pbos): Log some warning, SSRC without receiver.
-    return false;
-  }
-
-  VideoReceiveStream* receiver =
-      static_cast<VideoReceiveStream*>(receive_ssrcs_[rtp_header.ssrc]);
   return receiver->DeliverRtp(static_cast<const uint8_t*>(packet), length);
 }
 
-bool VideoCall::DeliverPacket(const void* packet, size_t length) {
-  // TODO(pbos): Respect the constness of packet.
-  ModuleRTPUtility::RTPHeaderParser rtp_parser(
-      const_cast<uint8_t*>(static_cast<const uint8_t*>(packet)), length);
+bool VideoCall::DeliverPacket(const uint8_t* packet, size_t length) {
+  // TODO(pbos): ExtensionMap if there are extensions.
+  if (RtpHeaderParser::IsRtcp(packet, static_cast<int>(length)))
+    return DeliverRtcp(packet, length);
 
-  if (rtp_parser.RTCP()) {
-    return DeliverRtcp(&rtp_parser, packet, length);
-  }
+  RTPHeader rtp_header;
+  if (!rtp_header_parser_->Parse(packet, static_cast<int>(length), &rtp_header))
+    return false;
 
-  return DeliverRtp(&rtp_parser, packet, length);
+  return DeliverRtp(rtp_header, packet, length);
 }
 
 }  // namespace internal

webrtc/video_engine/internal/video_call.h

@@ -13,8 +13,7 @@
 #include <map>
 #include <vector>
 
-#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
 #include "webrtc/system_wrappers/interface/rw_lock_wrapper.h"
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
 #include "webrtc/video_engine/internal/video_receive_stream.h"
@@ -59,21 +58,24 @@ class VideoCall : public newapi::VideoCall, public newapi::PacketReceiver {
   virtual uint32_t SendBitrateEstimate() OVERRIDE;
   virtual uint32_t ReceiveBitrateEstimate() OVERRIDE;
 
-  virtual bool DeliverPacket(const void* packet, size_t length) OVERRIDE;
+  virtual bool DeliverPacket(const uint8_t* packet, size_t length) OVERRIDE;
 
  private:
-  bool DeliverRtp(ModuleRTPUtility::RTPHeaderParser* rtp_parser,
-                  const void* packet, size_t length);
-  bool DeliverRtcp(ModuleRTPUtility::RTPHeaderParser* rtp_parser,
-                   const void* packet, size_t length);
+  bool DeliverRtcp(const uint8_t* packet, size_t length);
+  bool DeliverRtp(const RTPHeader& header,
+                  const uint8_t* packet,
+                  size_t length);
 
   newapi::VideoCall::Config config_;
 
-  std::map<uint32_t, newapi::VideoReceiveStream*> receive_ssrcs_;
+  std::map<uint32_t, VideoReceiveStream*> receive_ssrcs_;
   scoped_ptr<RWLockWrapper> receive_lock_;
-  std::map<uint32_t, newapi::VideoSendStream*> send_ssrcs_;
+
+  std::map<uint32_t, VideoSendStream*> send_ssrcs_;
   scoped_ptr<RWLockWrapper> send_lock_;
 
+  scoped_ptr<RtpHeaderParser> rtp_header_parser_;
+
   webrtc::VideoEngine* video_engine_;
   ViERTP_RTCP* rtp_rtcp_;
   ViECodec* codec_;

webrtc/video_engine/new_include/video_engine.h

@@ -27,7 +27,7 @@ const char* Version();
 
 class PacketReceiver {
  public:
-  virtual bool DeliverPacket(const void* packet, size_t length) = 0;
+  virtual bool DeliverPacket(const uint8_t* packet, size_t length) = 0;
 
  protected:
   virtual ~PacketReceiver() {}

webrtc/video_engine/test/full_stack.cc

@@ -98,11 +98,10 @@ class VideoAnalyzer : public newapi::PacketReceiver,
     }
   }
 
-  virtual bool DeliverPacket(const void* packet, size_t length) OVERRIDE {
+  virtual bool DeliverPacket(const uint8_t* packet, size_t length) OVERRIDE {
     scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
     RTPHeader header;
-    parser->Parse(
-        static_cast<const uint8_t*>(packet), static_cast<int>(length), &header);
+    parser->Parse(packet, static_cast<int>(length), &header);
     {
       CriticalSectionScoped cs(crit_.get());
       recv_times_[header.timestamp - rtp_timestamp_delta_] =