diff --git a/modules/interface/module_common_types.h b/modules/interface/module_common_types.h
index 57a1dfb..48b0323 100644
--- a/modules/interface/module_common_types.h
+++ b/modules/interface/module_common_types.h
@@ -44,6 +44,7 @@
     uint32_t arrOfCSRCs[kRtpCsrcSize];
     uint8_t paddingLength;
     uint16_t headerLength;
+    int payload_type_frequency;
     RTPHeaderExtension extension;
 };
 
@@ -93,13 +94,13 @@
     RTPVideoHeaderVP8       VP8;
 };
 
-enum RTPVideoCodecTypes
+enum RtpVideoCodecTypes
 {
-    kRTPVideoGeneric  = 0,
-    kRTPVideoVP8      = 8,
-    kRTPVideoNoVideo  = 10,
-    kRTPVideoFEC      = 11,
-    kRTPVideoI420     = 12
+    kRtpVideoNone,
+    kRtpVideoGeneric,
+    kRtpVideoVp8,
+    kRtpVideoFec,
+    kRtpVideoI420
 };
 struct RTPVideoHeader
 {
@@ -109,7 +110,7 @@
     bool                    isFirstPacket;   // first packet in frame
     uint8_t           simulcastIdx;    // Index if the simulcast encoder creating
                                              // this frame, 0 if not using simulcast.
-    RTPVideoCodecTypes      codec;
+    RtpVideoCodecTypes      codec;
     RTPVideoTypeHeader      codecHeader;
 };
 union RTPTypeHeader
diff --git a/modules/modules.gyp b/modules/modules.gyp
index 4e9c808..523a14e 100644
--- a/modules/modules.gyp
+++ b/modules/modules.gyp
@@ -168,7 +168,6 @@
             'remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.h',
             'remote_bitrate_estimator/rtp_to_ntp_unittest.cc',
             'rtp_rtcp/source/mock/mock_rtp_payload_strategy.h',
-            'rtp_rtcp/source/mock/mock_rtp_receiver_video.h',
             'rtp_rtcp/source/fec_test_helper.cc',
             'rtp_rtcp/source/fec_test_helper.h',
             'rtp_rtcp/source/nack_rtx_unittest.cc',
diff --git a/modules/rtp_rtcp/interface/receive_statistics.h b/modules/rtp_rtcp/interface/receive_statistics.h
new file mode 100644
index 0000000..fc47bf8
--- /dev/null
+++ b/modules/rtp_rtcp/interface/receive_statistics.h
@@ -0,0 +1,54 @@
+/*
+ *  Copyright (c) 2013 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.
+ */
+
+#ifndef WEBRTC_MODULES_RTP_RTCP_INTERFACE_RECEIVE_STATISTICS_H_
+#define WEBRTC_MODULES_RTP_RTCP_INTERFACE_RECEIVE_STATISTICS_H_
+
+#include "webrtc/modules/interface/module.h"
+#include "webrtc/modules/interface/module_common_types.h"
+#include "webrtc/typedefs.h"
+
+namespace webrtc {
+
+class Clock;
+
+class ReceiveStatistics : public Module {
+ public:
+  struct RtpReceiveStatistics {
+    uint8_t fraction_lost;
+    uint32_t cumulative_lost;
+    uint32_t extended_max_sequence_number;
+    uint32_t jitter;
+    uint32_t max_jitter;
+  };
+
+  virtual ~ReceiveStatistics() {}
+
+  static ReceiveStatistics* Create(Clock* clock);
+
+  virtual void IncomingPacket(const RTPHeader& rtp_header, size_t bytes,
+                              bool retransmitted, bool in_order) = 0;
+
+  virtual bool Statistics(RtpReceiveStatistics* statistics, bool reset) = 0;
+
+  virtual bool Statistics(RtpReceiveStatistics* statistics, int32_t* missing,
+                          bool reset) = 0;
+
+  virtual void GetDataCounters(uint32_t* bytes_received,
+                               uint32_t* packets_received) const = 0;
+
+  virtual uint32_t BitrateReceived() = 0;
+
+  virtual void ResetStatistics() = 0;
+
+  virtual void ResetDataCounters() = 0;
+};
+}  // namespace webrtc
+#endif  // WEBRTC_MODULES_RTP_RTCP_INTERFACE_RECEIVE_STATISTICS_H_
diff --git a/modules/rtp_rtcp/source/rtp_payload_registry.h b/modules/rtp_rtcp/interface/rtp_payload_registry.h
similarity index 86%
rename from modules/rtp_rtcp/source/rtp_payload_registry.h
rename to modules/rtp_rtcp/interface/rtp_payload_registry.h
index 465a4ed..f5aca81 100644
--- a/modules/rtp_rtcp/source/rtp_payload_registry.h
+++ b/modules/rtp_rtcp/interface/rtp_payload_registry.h
@@ -8,8 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_PAYLOAD_REGISTRY_H_
-#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_PAYLOAD_REGISTRY_H_
+#ifndef WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_PAYLOAD_REGISTRY_H_
+#define WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_PAYLOAD_REGISTRY_H_
 
 #include "webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
@@ -21,7 +21,7 @@
 // of payload handling.
 class RTPPayloadStrategy {
  public:
-  virtual ~RTPPayloadStrategy() {};
+  virtual ~RTPPayloadStrategy() {}
 
   virtual bool CodecsMustBeUnique() const = 0;
 
@@ -42,10 +42,13 @@
       const uint8_t channels,
       const uint32_t rate) const = 0;
 
+  virtual int GetPayloadTypeFrequency(
+      const ModuleRTPUtility::Payload& payload) const = 0;
+
   static RTPPayloadStrategy* CreateStrategy(const bool handling_audio);
 
  protected:
-   RTPPayloadStrategy() {};
+  RTPPayloadStrategy() {}
 };
 
 class RTPPayloadRegistry {
@@ -73,7 +76,11 @@
       const uint32_t rate,
       int8_t* payload_type) const;
 
-  int32_t PayloadTypeToPayload(
+  bool GetPayloadSpecifics(uint8_t payload_type, PayloadUnion* payload) const;
+
+  int GetPayloadTypeFrequency(uint8_t payload_type) const;
+
+  bool PayloadTypeToPayload(
     const uint8_t payload_type,
     ModuleRTPUtility::Payload*& payload) const;
 
@@ -116,4 +123,4 @@
 
 }  // namespace webrtc
 
-#endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_PAYLOAD_REGISTRY_H_
+#endif  // WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_PAYLOAD_REGISTRY_H_
diff --git a/modules/rtp_rtcp/interface/rtp_receiver.h b/modules/rtp_rtcp/interface/rtp_receiver.h
new file mode 100644
index 0000000..0e47d01
--- /dev/null
+++ b/modules/rtp_rtcp/interface/rtp_receiver.h
@@ -0,0 +1,120 @@
+/*
+ *  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.
+ */
+
+#ifndef WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RECEIVER_H_
+#define WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RECEIVER_H_
+
+#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
+#include "webrtc/typedefs.h"
+
+namespace webrtc {
+
+class RTPPayloadRegistry;
+
+class TelephoneEventHandler {
+ public:
+  virtual ~TelephoneEventHandler() {}
+
+  // The following three methods implement the TelephoneEventHandler interface.
+  // Forward DTMFs to decoder for playout.
+  virtual void SetTelephoneEventForwardToDecoder(bool forward_to_decoder) = 0;
+
+  // Is forwarding of outband telephone events turned on/off?
+  virtual bool TelephoneEventForwardToDecoder() const = 0;
+
+  // Is TelephoneEvent configured with payload type payload_type
+  virtual bool TelephoneEventPayloadType(const int8_t payload_type) const = 0;
+};
+
+class RtpReceiver {
+ public:
+  // Creates a video-enabled RTP receiver.
+  static RtpReceiver* CreateVideoReceiver(
+      int id, Clock* clock,
+      RtpData* incoming_payload_callback,
+      RtpFeedback* incoming_messages_callback,
+      RTPPayloadRegistry* rtp_payload_registry);
+
+  // Creates an audio-enabled RTP receiver.
+  static RtpReceiver* CreateAudioReceiver(
+      int id, Clock* clock,
+      RtpAudioFeedback* incoming_audio_feedback,
+      RtpData* incoming_payload_callback,
+      RtpFeedback* incoming_messages_callback,
+      RTPPayloadRegistry* rtp_payload_registry);
+
+  virtual ~RtpReceiver() {}
+
+  // Returns a TelephoneEventHandler if available.
+  virtual TelephoneEventHandler* GetTelephoneEventHandler() = 0;
+
+  // Registers a receive payload in the payload registry and notifies the media
+  // receiver strategy.
+  virtual int32_t RegisterReceivePayload(
+      const char payload_name[RTP_PAYLOAD_NAME_SIZE],
+      const int8_t payload_type,
+      const uint32_t frequency,
+      const uint8_t channels,
+      const uint32_t rate) = 0;
+
+  // De-registers |payload_type| from the payload registry.
+  virtual int32_t DeRegisterReceivePayload(const int8_t payload_type) = 0;
+
+  // Parses the media specific parts of an RTP packet and updates the receiver
+  // state. This for instance means that any changes in SSRC and payload type is
+  // detected and acted upon.
+  virtual bool IncomingRtpPacket(RTPHeader* rtp_header,
+                                 const uint8_t* incoming_rtp_packet,
+                                 int incoming_rtp_packet_length,
+                                 PayloadUnion payload_specific,
+                                 bool in_order) = 0;
+
+  // Returns the currently configured NACK method.
+  virtual NACKMethod NACK() const = 0;
+
+  // Turn negative acknowledgement (NACK) requests on/off.
+  virtual int32_t SetNACKStatus(const NACKMethod method,
+                                int max_reordering_threshold) = 0;
+
+  // Returns the last received timestamp.
+  virtual uint32_t TimeStamp() const = 0;
+  // Returns the time in milliseconds when the last timestamp was received.
+  virtual int32_t LastReceivedTimeMs() const = 0;
+
+  // Returns the remote SSRC of the currently received RTP stream.
+  virtual uint32_t SSRC() const = 0;
+
+  // Returns the current remote CSRCs.
+  virtual int32_t CSRCs(uint32_t array_of_csrc[kRtpCsrcSize]) const = 0;
+
+  // Returns the current energy of the RTP stream received.
+  virtual int32_t Energy(uint8_t array_of_energy[kRtpCsrcSize]) const = 0;
+
+  // Enable/disable RTX and set the SSRC to be used.
+  virtual void SetRTXStatus(bool enable, uint32_t ssrc) = 0;
+
+  // Returns the current RTX status and the SSRC and payload type used.
+  virtual void RTXStatus(bool* enable, uint32_t* ssrc,
+                         int* payload_type) const = 0;
+
+  // Sets the RTX payload type.
+  virtual void SetRtxPayloadType(int payload_type) = 0;
+
+  // Returns true if the packet with RTP header |header| is likely to be a
+  // retransmitted packet, false otherwise.
+  virtual bool RetransmitOfOldPacket(const RTPHeader& header, int jitter,
+                                     int min_rtt) const = 0;
+
+  // Returns true if |sequence_number| is received in order, false otherwise.
+  virtual bool InOrderPacket(const uint16_t sequence_number) const = 0;
+};
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RECEIVER_H_
diff --git a/modules/rtp_rtcp/interface/rtp_rtcp.h b/modules/rtp_rtcp/interface/rtp_rtcp.h
index 5c25fbe..2171d48 100644
--- a/modules/rtp_rtcp/interface/rtp_rtcp.h
+++ b/modules/rtp_rtcp/interface/rtp_rtcp.h
@@ -19,8 +19,9 @@
 namespace webrtc {
 // Forward declarations.
 class PacedSender;
+class ReceiveStatistics;
 class RemoteBitrateEstimator;
-class RemoteBitrateObserver;
+class RtpReceiver;
 class Transport;
 
 class RtpRtcp : public Module {
@@ -57,8 +58,7 @@
     bool audio;
     Clock* clock;
     RtpRtcp* default_module;
-    RtpData* incoming_data;
-    RtpFeedback* incoming_messages;
+    ReceiveStatistics* receive_statistics;
     Transport* outgoing_transport;
     RtcpFeedback* rtcp_feedback;
     RtcpIntraFrameObserver* intra_frame_callback;
@@ -68,6 +68,7 @@
     RemoteBitrateEstimator* remote_bitrate_estimator;
     PacedSender* paced_sender;
   };
+
   /*
    *   Create a RTP/RTCP module object using the system clock.
    *
@@ -81,174 +82,11 @@
    *
    ***************************************************************************/
 
-    /*
-    *   configure a RTP packet timeout value
-    *
-    *   RTPtimeoutMS   - time in milliseconds after last received RTP packet
-    *   RTCPtimeoutMS  - time in milliseconds after last received RTCP packet
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t SetPacketTimeout(
-        const uint32_t RTPtimeoutMS,
-        const uint32_t RTCPtimeoutMS) = 0;
-
-    /*
-    *   Set periodic dead or alive notification
-    *
-    *   enable              - turn periodic dead or alive notification on/off
-    *   sampleTimeSeconds   - sample interval in seconds for dead or alive
-    *                         notifications
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t SetPeriodicDeadOrAliveStatus(
-        const bool enable,
-        const uint8_t sampleTimeSeconds) = 0;
-
-    /*
-    *   Get periodic dead or alive notification status
-    *
-    *   enable              - periodic dead or alive notification on/off
-    *   sampleTimeSeconds   - sample interval in seconds for dead or alive
-    *                         notifications
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t PeriodicDeadOrAliveStatus(
-        bool& enable,
-        uint8_t& sampleTimeSeconds) = 0;
-
-    /*
-    *   set voice codec name and payload type
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t RegisterReceivePayload(
-        const CodecInst& voiceCodec) = 0;
-
-    /*
-    *   set video codec name and payload type
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t RegisterReceivePayload(
-        const VideoCodec& videoCodec) = 0;
-
-    /*
-    *   get payload type for a voice codec
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t ReceivePayloadType(
-        const CodecInst& voiceCodec,
-        int8_t* plType) = 0;
-
-    /*
-    *   get payload type for a video codec
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t ReceivePayloadType(
-        const VideoCodec& videoCodec,
-        int8_t* plType) = 0;
-
-    /*
-    *   Remove a registered payload type from list of accepted payloads
-    *
-    *   payloadType - payload type of codec
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t DeRegisterReceivePayload(
-        const int8_t payloadType) = 0;
-
-    /*
-    *   Get last received remote timestamp
-    */
-    virtual uint32_t RemoteTimestamp() const = 0;
-
-    /*
-    *   Get the local time of the last received remote timestamp
-    */
-    virtual int64_t LocalTimeOfRemoteTimeStamp() const = 0;
-
-    /*
-    *   Get the current estimated remote timestamp
-    *
-    *   timestamp   - estimated timestamp
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t EstimatedRemoteTimeStamp(
-        uint32_t& timestamp) const = 0;
-
-    /*
-    *   Get incoming SSRC
-    */
-    virtual uint32_t RemoteSSRC() const = 0;
-
-    /*
-    *   Get remote CSRC
-    *
-    *   arrOfCSRC   - array that will receive the CSRCs
-    *
-    *   return -1 on failure else the number of valid entries in the list
-    */
-    virtual int32_t RemoteCSRCs(
-        uint32_t arrOfCSRC[kRtpCsrcSize]) const  = 0;
-
-    /*
-    *   get the currently configured SSRC filter
-    *
-    *   allowedSSRC - SSRC that will be allowed through
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t SSRCFilter(uint32_t& allowedSSRC) const = 0;
-
-    /*
-    *   set a SSRC to be used as a filter for incoming RTP streams
-    *
-    *   allowedSSRC - SSRC that will be allowed through
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t SetSSRCFilter(const bool enable,
-                                  const uint32_t allowedSSRC) = 0;
-
-    /*
-    * Turn on/off receiving RTX (RFC 4588) on a specific SSRC.
-    */
-    virtual int32_t SetRTXReceiveStatus(bool enable, uint32_t SSRC) = 0;
-
-    // Sets the payload type to expected for received RTX packets. Note
-    // that this doesn't enable RTX, only the payload type is set.
-    virtual void SetRtxReceivePayloadType(int payload_type) = 0;
-
-    /*
-    * Get status of receiving RTX (RFC 4588) on a specific SSRC.
-    */
-    virtual int32_t RTXReceiveStatus(bool* enable,
-                                     uint32_t* SSRC,
-                                     int* payloadType) const = 0;
-
-    /*
-    *   called by the network module when we receive a packet
-    *
-    *   incomingPacket - incoming packet buffer
-    *   packetLength   - length of incoming buffer
-    *   parsed_rtp_header - the parsed RTP header
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t IncomingRtpPacket(const uint8_t* incomingPacket,
-                                      const uint16_t packetLength,
-                                      const RTPHeader& parsed_rtp_header) = 0;
-
     virtual int32_t IncomingRtcpPacket(const uint8_t* incoming_packet,
                                        uint16_t incoming_packet_length) = 0;
 
+    virtual void SetRemoteSSRC(const uint32_t ssrc) = 0;
+
     /**************************************************************************
     *
     *   Sender
@@ -609,32 +447,6 @@
         const uint8_t pictureID) = 0;
 
     /*
-    *   Reset RTP statistics
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t ResetStatisticsRTP() = 0;
-
-    /*
-    *   statistics of our localy created statistics of the received RTP stream
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t StatisticsRTP(
-        uint8_t* fraction_lost,  // scale 0 to 255
-        uint32_t* cum_lost,      // number of lost packets
-        uint32_t* ext_max,       // highest sequence number received
-        uint32_t* jitter,
-        uint32_t* max_jitter = NULL) const = 0;
-
-    /*
-    *   Reset RTP data counters for the receiving side
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t ResetReceiveDataCountersRTP() = 0;
-
-    /*
     *   Reset RTP data counters for the sending side
     *
     *   return -1 on failure else 0
@@ -648,9 +460,7 @@
     */
     virtual int32_t DataCountersRTP(
         uint32_t* bytesSent,
-        uint32_t* packetsSent,
-        uint32_t* bytesReceived,
-        uint32_t* packetsReceived) const = 0;
+        uint32_t* packetsSent) const = 0;
     /*
     *   Get received RTCP sender info
     *
@@ -731,18 +541,6 @@
     /*
     *   (NACK)
     */
-    virtual NACKMethod NACK() const  = 0;
-
-    /*
-    *   Turn negative acknowledgement requests on/off
-    *   |max_reordering_threshold| should be set to how much a retransmitted
-    *   packet can be expected to be reordered (in sequence numbers) compared to
-    *   a packet which has not been retransmitted.
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t SetNACKStatus(const NACKMethod method,
-                                  int max_reordering_threshold) = 0;
 
     /*
      *  TODO(holmer): Propagate this API to VideoEngine.
@@ -798,19 +596,6 @@
         const uint16_t packetSizeSamples) = 0;
 
     /*
-    *   Forward DTMF to decoder for playout.
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int SetTelephoneEventForwardToDecoder(bool forwardToDecoder) = 0;
-
-    /*
-    *   Returns true if received DTMF events are forwarded to the decoder using
-    *    the OnPlayTelephoneEvent callback.
-    */
-    virtual bool TelephoneEventForwardToDecoder() const = 0;
-
-    /*
     *   SendTelephoneEventActive
     *
     *   return true if we currently send a telephone event and 100 ms after an
diff --git a/modules/rtp_rtcp/interface/rtp_rtcp_defines.h b/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
index 500ab53..9754203 100644
--- a/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
+++ b/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
@@ -11,22 +11,39 @@
 #ifndef WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_DEFINES_H_
 #define WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_DEFINES_H_
 
+#include <stddef.h>
+
 #include "webrtc/modules/interface/module_common_types.h"
 #include "webrtc/system_wrappers/interface/clock.h"
 #include "webrtc/typedefs.h"
 
-#ifndef NULL
-    #define NULL    0
-#endif
-
 #define RTCP_CNAME_SIZE 256    // RFC 3550 page 44, including null termination
 #define IP_PACKET_SIZE 1500    // we assume ethernet
 #define MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS 10
 #define TIMEOUT_SEI_MESSAGES_MS 30000   // in milliseconds
 
-namespace webrtc{
+namespace webrtc {
 
-const int32_t kDefaultVideoFrequency = 90000;
+const int kVideoPayloadTypeFrequency = 90000;
+
+struct AudioPayload
+{
+    uint32_t    frequency;
+    uint8_t     channels;
+    uint32_t    rate;
+};
+
+struct VideoPayload
+{
+    RtpVideoCodecTypes   videoCodecType;
+    uint32_t       maxRate;
+};
+
+union PayloadUnion
+{
+    AudioPayload Audio;
+    VideoPayload Video;
+};
 
 enum RTCPMethod
 {
@@ -145,6 +162,9 @@
         const uint8_t* payloadData,
         const uint16_t payloadSize,
         const WebRtcRTPHeader* rtpHeader) = 0;
+
+    virtual bool OnRecoveredPacket(const uint8_t* packet,
+                                   int packet_length) = 0;
 protected:
     virtual ~RtpData() {}
 };
@@ -162,8 +182,6 @@
         const int32_t /*id*/,
         const RTCPVoIPMetric* /*metric*/)  {};
 
-    virtual void OnRTCPPacketTimeout(const int32_t /*id*/)  {};
-
     virtual void OnReceiveReportReceived(const int32_t id,
                                          const uint32_t senderSSRC)  {};
 
@@ -186,14 +204,6 @@
         const uint8_t channels,
         const uint32_t rate) = 0;
 
-    virtual void OnPacketTimeout(const int32_t id) = 0;
-
-    virtual void OnReceivedPacket(const int32_t id,
-                                  const RtpRtcpPacketType packetType) = 0;
-
-    virtual void OnPeriodicDeadOrAlive(const int32_t id,
-                                       const RTPAliveType alive) = 0;
-
     virtual void OnIncomingSSRCChanged( const int32_t id,
                                         const uint32_t SSRC) = 0;
 
@@ -201,6 +211,8 @@
                                         const uint32_t CSRC,
                                         const bool added) = 0;
 
+    virtual void OnResetStatistics() = 0;
+
 protected:
     virtual ~RtpFeedback() {}
 };
@@ -268,32 +280,32 @@
    return 0;
  }
 
- virtual void OnPacketTimeout(const int32_t id) {}
-
- virtual void OnReceivedPacket(const int32_t id,
-                               const RtpRtcpPacketType packetType) {}
-
- virtual void OnPeriodicDeadOrAlive(const int32_t id,
-                                    const RTPAliveType alive) {}
-
- virtual void OnIncomingSSRCChanged(const int32_t id,
+  virtual void OnIncomingSSRCChanged(const int32_t id,
                                     const uint32_t SSRC) {}
 
  virtual void OnIncomingCSRCChanged(const int32_t id,
                                     const uint32_t CSRC,
                                     const bool added) {}
+
+ virtual void OnResetStatistics() {}
 };
 
 // Null object version of RtpData.
 class NullRtpData : public RtpData {
  public:
   virtual ~NullRtpData() {}
+
   virtual int32_t OnReceivedPayloadData(
       const uint8_t* payloadData,
       const uint16_t payloadSize,
       const WebRtcRTPHeader* rtpHeader) {
-   return 0;
- }
+    return 0;
+  }
+
+  virtual bool OnRecoveredPacket(const uint8_t* packet,
+                                 int packet_length) {
+    return true;
+  }
 };
 
 // Null object version of RtpAudioFeedback.
diff --git a/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h b/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
index 0d39f8b..674a5b5 100644
--- a/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
+++ b/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
@@ -35,53 +35,9 @@
       int32_t(RtpRtcp* module));
   MOCK_METHOD0(DeRegisterSyncModule,
       int32_t());
-  MOCK_METHOD0(InitReceiver,
-      int32_t());
-  MOCK_METHOD1(RegisterIncomingDataCallback,
-      int32_t(RtpData* incomingDataCallback));
-  MOCK_METHOD1(RegisterIncomingRTPCallback,
-      int32_t(RtpFeedback* incomingMessagesCallback));
-  MOCK_METHOD2(SetPacketTimeout,
-      int32_t(const uint32_t RTPtimeoutMS, const uint32_t RTCPtimeoutMS));
-  MOCK_METHOD2(SetPeriodicDeadOrAliveStatus,
-      int32_t(const bool enable, const uint8_t sampleTimeSeconds));
-  MOCK_METHOD2(PeriodicDeadOrAliveStatus,
-      int32_t(bool &enable, uint8_t &sampleTimeSeconds));
-  MOCK_METHOD1(RegisterReceivePayload,
-      int32_t(const CodecInst& voiceCodec));
-  MOCK_METHOD1(RegisterReceivePayload,
-      int32_t(const VideoCodec& videoCodec));
-  MOCK_METHOD2(ReceivePayloadType,
-      int32_t(const CodecInst& voiceCodec, int8_t* plType));
-  MOCK_METHOD2(ReceivePayloadType,
-      int32_t(const VideoCodec& videoCodec, int8_t* plType));
-  MOCK_METHOD1(DeRegisterReceivePayload,
-      int32_t(const int8_t payloadType));
-  MOCK_CONST_METHOD0(RemoteTimestamp,
-      uint32_t());
-  MOCK_CONST_METHOD0(LocalTimeOfRemoteTimeStamp,
-        int64_t());
-  MOCK_CONST_METHOD1(EstimatedRemoteTimeStamp,
-      int32_t(uint32_t& timestamp));
-  MOCK_CONST_METHOD0(RemoteSSRC,
-      uint32_t());
-  MOCK_CONST_METHOD1(RemoteCSRCs,
-      int32_t(uint32_t arrOfCSRC[kRtpCsrcSize]));
-  MOCK_CONST_METHOD1(SSRCFilter,
-      int32_t(uint32_t& allowedSSRC));
-  MOCK_METHOD2(SetSSRCFilter,
-      int32_t(const bool enable, const uint32_t allowedSSRC));
-  MOCK_METHOD2(SetRTXReceiveStatus,
-      int32_t(bool enable, uint32_t ssrc));
-  MOCK_CONST_METHOD3(RTXReceiveStatus,
-      int32_t(bool* enable, uint32_t* ssrc, int* payload_type));
-  MOCK_METHOD1(SetRtxReceivePayloadType,
-      void(int));
-  MOCK_METHOD3(IncomingRtpPacket,
-      int32_t(const uint8_t* incomingPacket, const uint16_t packetLength,
-              const webrtc::RTPHeader& header));
   MOCK_METHOD2(IncomingRtcpPacket,
       int32_t(const uint8_t* incomingPacket, uint16_t packetLength));
+  MOCK_METHOD1(SetRemoteSSRC, void(const uint32_t ssrc));
   MOCK_METHOD4(IncomingAudioNTP,
       int32_t(const uint32_t audioReceivedNTPsecs,
               const uint32_t audioReceivedNTPfrac,
@@ -196,16 +152,10 @@
       int32_t(const uint64_t pictureID));
   MOCK_METHOD1(SendRTCPSliceLossIndication,
       int32_t(const uint8_t pictureID));
-  MOCK_METHOD0(ResetStatisticsRTP,
-      int32_t());
-  MOCK_CONST_METHOD5(StatisticsRTP,
-      int32_t(uint8_t *fraction_lost, uint32_t *cum_lost, uint32_t *ext_max, uint32_t *jitter, uint32_t *max_jitter));
-  MOCK_METHOD0(ResetReceiveDataCountersRTP,
-      int32_t());
   MOCK_METHOD0(ResetSendDataCountersRTP,
       int32_t());
-  MOCK_CONST_METHOD4(DataCountersRTP,
-      int32_t(uint32_t *bytesSent, uint32_t *packetsSent, uint32_t *bytesReceived, uint32_t *packetsReceived));
+  MOCK_CONST_METHOD2(DataCountersRTP,
+      int32_t(uint32_t *bytesSent, uint32_t *packetsSent));
   MOCK_METHOD1(RemoteRTCPStat,
       int32_t(RTCPSenderInfo* senderInfo));
   MOCK_CONST_METHOD1(RemoteRTCPStat,
@@ -224,8 +174,6 @@
       int32_t(const bool enable));
   MOCK_METHOD3(SetREMBData,
       int32_t(const uint32_t bitrate, const uint8_t numberOfSSRC, const uint32_t* SSRC));
-  MOCK_METHOD1(SetRemoteBitrateObserver,
-      bool(RemoteBitrateObserver*));
   MOCK_CONST_METHOD0(IJ,
       bool());
   MOCK_METHOD1(SetIJStatus,
@@ -252,9 +200,6 @@
       int32_t(RtpAudioFeedback* messagesCallback));
   MOCK_METHOD1(SetAudioPacketSize,
       int32_t(const uint16_t packetSizeSamples));
-  MOCK_METHOD1(SetTelephoneEventForwardToDecoder, int(bool forwardToDecoder));
-  MOCK_CONST_METHOD0(TelephoneEventForwardToDecoder,
-      bool());
   MOCK_CONST_METHOD1(SendTelephoneEventActive,
       bool(int8_t& telephoneEvent));
   MOCK_METHOD3(SendTelephoneEventOutband,
diff --git a/modules/rtp_rtcp/source/bitrate.cc b/modules/rtp_rtcp/source/bitrate.cc
index e3995ad..1dc314f 100644
--- a/modules/rtp_rtcp/source/bitrate.cc
+++ b/modules/rtp_rtcp/source/bitrate.cc
@@ -57,6 +57,10 @@
   return static_cast<uint32_t>(bitrate);
 }
 
+int64_t Bitrate::time_last_rate_update() const {
+  return time_last_rate_update_;
+}
+
 void Bitrate::Process() {
   // Triggered by timer.
   int64_t now = clock_->TimeInMilliseconds();
diff --git a/modules/rtp_rtcp/source/bitrate.h b/modules/rtp_rtcp/source/bitrate.h
index 49a857c..7599684 100644
--- a/modules/rtp_rtcp/source/bitrate.h
+++ b/modules/rtp_rtcp/source/bitrate.h
@@ -42,6 +42,8 @@
   // Bitrate last second, updated now.
   uint32_t BitrateNow() const;
 
+  int64_t time_last_rate_update() const;
+
  protected:
   Clock* clock_;
 
diff --git a/modules/rtp_rtcp/source/mock/mock_rtp_payload_strategy.h b/modules/rtp_rtcp/source/mock/mock_rtp_payload_strategy.h
index 6e1cf93..ccf82e5 100644
--- a/modules/rtp_rtcp/source/mock/mock_rtp_payload_strategy.h
+++ b/modules/rtp_rtcp/source/mock/mock_rtp_payload_strategy.h
@@ -12,7 +12,7 @@
 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_MOCK_MOCK_RTP_PAYLOAD_REGISTRY_H_
 
 #include "testing/gmock/include/gmock/gmock.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
 
 namespace webrtc {
 
@@ -27,6 +27,8 @@
            const uint32_t rate));
   MOCK_CONST_METHOD2(UpdatePayloadRate,
       void(ModuleRTPUtility::Payload* payload, const uint32_t rate));
+  MOCK_CONST_METHOD1(GetPayloadTypeFrequency, int(
+      const ModuleRTPUtility::Payload& payload));
   MOCK_CONST_METHOD5(CreatePayloadType,
       ModuleRTPUtility::Payload*(
           const char payloadName[RTP_PAYLOAD_NAME_SIZE],
diff --git a/modules/rtp_rtcp/source/mock/mock_rtp_receiver_video.h b/modules/rtp_rtcp/source/mock/mock_rtp_receiver_video.h
deleted file mode 100644
index ea533ff..0000000
--- a/modules/rtp_rtcp/source/mock/mock_rtp_receiver_video.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- *  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.
- */
-
-#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_MOCK_MOCK_RTP_RECEIVER_VIDEO_H_
-#define WEBRTC_MODULES_RTP_RTCP_SOURCE_MOCK_MOCK_RTP_RECEIVER_VIDEO_H_
-
-#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h"
-
-namespace webrtc {
-
-class MockRTPReceiverVideo : public RTPReceiverVideo {
- public:
-  MockRTPReceiverVideo() : RTPReceiverVideo(0, NULL, NULL) {}
-  MOCK_METHOD1(ChangeUniqueId,
-      void(const int32_t id));
-  MOCK_METHOD3(ReceiveRecoveredPacketCallback,
-      int32_t(WebRtcRTPHeader* rtpHeader,
-              const uint8_t* payloadData,
-              const uint16_t payloadDataLength));
-  MOCK_METHOD3(CallbackOfReceivedPayloadData,
-      int32_t(const uint8_t* payloadData,
-              const uint16_t payloadSize,
-              const WebRtcRTPHeader* rtpHeader));
-  MOCK_CONST_METHOD0(TimeStamp,
-      uint32_t());
-  MOCK_CONST_METHOD0(SequenceNumber,
-      uint16_t());
-  MOCK_CONST_METHOD2(PayloadTypeToPayload,
-      uint32_t(const uint8_t payloadType,
-               ModuleRTPUtility::Payload*& payload));
-  MOCK_CONST_METHOD2(RetransmitOfOldPacket,
-      bool(const uint16_t sequenceNumber,
-           const uint32_t rtpTimeStamp));
-  MOCK_CONST_METHOD0(REDPayloadType,
-      int8_t());
-  MOCK_CONST_METHOD0(HaveNotReceivedPackets,
-        bool());
-};
-
-}  // namespace webrtc
-
-#endif  //WEBRTC_MODULES_RTP_RTCP_SOURCE_MOCK_MOCK_RTP_RECEIVER_VIDEO_H_
diff --git a/modules/rtp_rtcp/source/nack_rtx_unittest.cc b/modules/rtp_rtcp/source/nack_rtx_unittest.cc
index e780f5f..ecf4a07 100644
--- a/modules/rtp_rtcp/source/nack_rtx_unittest.cc
+++ b/modules/rtp_rtcp/source/nack_rtx_unittest.cc
@@ -15,7 +15,10 @@
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/common_types.h"
+#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
@@ -30,7 +33,7 @@
 const int kTestNumberOfRtxPackets = 149;
 const int kNumFrames = 30;
 
-class VerifyingRtxReceiver : public RtpData
+class VerifyingRtxReceiver : public NullRtpData
 {
  public:
   VerifyingRtxReceiver() {}
@@ -47,6 +50,20 @@
   std::list<uint16_t> sequence_numbers_;
 };
 
+class TestRtpFeedback : public NullRtpFeedback {
+ public:
+  TestRtpFeedback(RtpRtcp* rtp_rtcp) : rtp_rtcp_(rtp_rtcp) {}
+  virtual ~TestRtpFeedback() {}
+
+  virtual void OnIncomingSSRCChanged(const int32_t id,
+                                     const uint32_t SSRC) {
+    rtp_rtcp_->SetRemoteSSRC(SSRC);
+  }
+
+ private:
+  RtpRtcp* rtp_rtcp_;
+};
+
 class RtxLoopBackTransport : public webrtc::Transport {
  public:
   explicit RtxLoopBackTransport(uint32_t rtx_ssrc)
@@ -56,11 +73,17 @@
         consecutive_drop_end_(0),
         rtx_ssrc_(rtx_ssrc),
         count_rtx_ssrc_(0),
+        rtp_payload_registry_(NULL),
+        rtp_receiver_(NULL),
         module_(NULL) {
   }
 
-  void SetSendModule(RtpRtcp* rtpRtcpModule) {
+  void SetSendModule(RtpRtcp* rtpRtcpModule,
+                     RTPPayloadRegistry* rtp_payload_registry,
+                     RtpReceiver* receiver) {
     module_ = rtpRtcpModule;
+    rtp_payload_registry_ = rtp_payload_registry;
+    rtp_receiver_ = receiver;
   }
 
   void DropEveryNthPacket(int n) {
@@ -94,8 +117,14 @@
     if (!parser->Parse(static_cast<const uint8_t*>(data), len, &header)) {
       return -1;
     }
-    if (module_->IncomingRtpPacket(static_cast<const uint8_t*>(data), len,
-                                   header) < 0) {
+    PayloadUnion payload_specific;
+    if (!rtp_payload_registry_->GetPayloadSpecifics(header.payloadType,
+                                                   &payload_specific)) {
+      return -1;
+    }
+    if (!rtp_receiver_->IncomingRtpPacket(&header,
+                                          static_cast<const uint8_t*>(data),
+                                          len, payload_specific, true)) {
       return -1;
     }
     return len;
@@ -113,6 +142,8 @@
   int consecutive_drop_end_;
   uint32_t rtx_ssrc_;
   int count_rtx_ssrc_;
+  RTPPayloadRegistry* rtp_payload_registry_;
+  RtpReceiver* rtp_receiver_;
   RtpRtcp* module_;
   std::set<uint16_t> expected_sequence_numbers_;
 };
@@ -120,7 +151,8 @@
 class RtpRtcpRtxNackTest : public ::testing::Test {
  protected:
   RtpRtcpRtxNackTest()
-      : rtp_rtcp_module_(NULL),
+      : rtp_payload_registry_(0, RTPPayloadStrategy::CreateStrategy(false)),
+        rtp_rtcp_module_(NULL),
         transport_(kTestSsrc + 1),
         receiver_(),
         payload_data_length(sizeof(payload_data)),
@@ -132,19 +164,27 @@
     configuration.id = kTestId;
     configuration.audio = false;
     configuration.clock = &fake_clock;
-    configuration.incoming_data = &receiver_;
+    receive_statistics_.reset(ReceiveStatistics::Create(&fake_clock));
+    configuration.receive_statistics = receive_statistics_.get();
     configuration.outgoing_transport = &transport_;
     rtp_rtcp_module_ = RtpRtcp::CreateRtpRtcp(configuration);
 
+    rtp_feedback_.reset(new TestRtpFeedback(rtp_rtcp_module_));
+
+    rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver(
+        kTestId, &fake_clock, &receiver_, rtp_feedback_.get(),
+        &rtp_payload_registry_));
+
     EXPECT_EQ(0, rtp_rtcp_module_->SetSSRC(kTestSsrc));
     EXPECT_EQ(0, rtp_rtcp_module_->SetRTCPStatus(kRtcpCompound));
-    EXPECT_EQ(0, rtp_rtcp_module_->SetNACKStatus(kNackRtcp, 450));
+    EXPECT_EQ(0, rtp_receiver_->SetNACKStatus(kNackRtcp, 450));
     EXPECT_EQ(0, rtp_rtcp_module_->SetStorePacketsStatus(true, 600));
     EXPECT_EQ(0, rtp_rtcp_module_->SetSendingStatus(true));
     EXPECT_EQ(0, rtp_rtcp_module_->SetSequenceNumber(kTestSequenceNumber));
     EXPECT_EQ(0, rtp_rtcp_module_->SetStartTimestamp(111111));
 
-    transport_.SetSendModule(rtp_rtcp_module_);
+    transport_.SetSendModule(rtp_rtcp_module_, &rtp_payload_registry_,
+                             rtp_receiver_.get());
 
     VideoCodec video_codec;
     memset(&video_codec, 0, sizeof(video_codec));
@@ -152,7 +192,11 @@
     memcpy(video_codec.plName, "I420", 5);
 
     EXPECT_EQ(0, rtp_rtcp_module_->RegisterSendPayload(video_codec));
-    EXPECT_EQ(0, rtp_rtcp_module_->RegisterReceivePayload(video_codec));
+    EXPECT_EQ(0, rtp_receiver_->RegisterReceivePayload(video_codec.plName,
+                                                       video_codec.plType,
+                                                       90000,
+                                                       0,
+                                                       video_codec.maxBitrate));
 
     for (int n = 0; n < payload_data_length; n++) {
       payload_data[n] = n % 10;
@@ -196,7 +240,7 @@
   }
 
   void RunRtxTest(RtxMode rtx_method, int loss) {
-    EXPECT_EQ(0, rtp_rtcp_module_->SetRTXReceiveStatus(true, kTestSsrc + 1));
+    rtp_receiver_->SetRTXStatus(true, kTestSsrc + 1);
     EXPECT_EQ(0, rtp_rtcp_module_->SetRTXSendStatus(rtx_method, true,
         kTestSsrc + 1));
     transport_.DropEveryNthPacket(loss);
@@ -224,7 +268,11 @@
     delete rtp_rtcp_module_;
   }
 
+  scoped_ptr<ReceiveStatistics> receive_statistics_;
+  RTPPayloadRegistry rtp_payload_registry_;
+  scoped_ptr<RtpReceiver> rtp_receiver_;
   RtpRtcp* rtp_rtcp_module_;
+  scoped_ptr<TestRtpFeedback> rtp_feedback_;
   RtxLoopBackTransport transport_;
   VerifyingRtxReceiver receiver_;
   uint8_t  payload_data[65000];
diff --git a/modules/rtp_rtcp/source/receive_statistics_impl.cc b/modules/rtp_rtcp/source/receive_statistics_impl.cc
new file mode 100644
index 0000000..10be3c5
--- /dev/null
+++ b/modules/rtp_rtcp/source/receive_statistics_impl.cc
@@ -0,0 +1,294 @@
+/*
+ *  Copyright (c) 2013 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/modules/rtp_rtcp/source/receive_statistics_impl.h"
+
+#include "webrtc/modules/rtp_rtcp/source/bitrate.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
+#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
+#include "webrtc/system_wrappers/interface/scoped_ptr.h"
+#include "webrtc/system_wrappers/interface/trace_event.h"
+
+namespace webrtc {
+
+enum { kRateUpdateIntervalMs = 1000 };
+
+ReceiveStatistics* ReceiveStatistics::Create(Clock* clock) {
+  return new ReceiveStatisticsImpl(clock);
+}
+
+ReceiveStatisticsImpl::ReceiveStatisticsImpl(Clock* clock)
+    : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
+      clock_(clock),
+      incoming_bitrate_(clock),
+      ssrc_(0),
+      jitter_q4_(0),
+      jitter_max_q4_(0),
+      cumulative_loss_(0),
+      jitter_q4_transmission_time_offset_(0),
+      local_time_last_received_timestamp_(0),
+      last_received_timestamp_(0),
+      last_received_transmission_time_offset_(0),
+
+      received_seq_first_(0),
+      received_seq_max_(0),
+      received_seq_wraps_(0),
+
+      received_packet_oh_(12),  // RTP header.
+      received_byte_count_(0),
+      received_retransmitted_packets_(0),
+      received_inorder_packet_count_(0),
+
+      last_report_inorder_packets_(0),
+      last_report_old_packets_(0),
+      last_report_seq_max_(0),
+      last_reported_statistics_() {}
+
+void ReceiveStatisticsImpl::ResetStatistics() {
+  CriticalSectionScoped lock(crit_sect_.get());
+  last_report_inorder_packets_ = 0;
+  last_report_old_packets_ = 0;
+  last_report_seq_max_ = 0;
+  memset(&last_reported_statistics_, 0, sizeof(last_reported_statistics_));
+  jitter_q4_ = 0;
+  jitter_max_q4_ = 0;
+  cumulative_loss_ = 0;
+  jitter_q4_transmission_time_offset_ = 0;
+  received_seq_wraps_ = 0;
+  received_seq_max_ = 0;
+  received_seq_first_ = 0;
+  received_byte_count_ = 0;
+  received_retransmitted_packets_ = 0;
+  received_inorder_packet_count_ = 0;
+}
+
+void ReceiveStatisticsImpl::ResetDataCounters() {
+  CriticalSectionScoped lock(crit_sect_.get());
+  received_byte_count_ = 0;
+  received_retransmitted_packets_ = 0;
+  received_inorder_packet_count_ = 0;
+  last_report_inorder_packets_ = 0;
+}
+
+void ReceiveStatisticsImpl::IncomingPacket(const RTPHeader& header,
+                                           size_t bytes,
+                                           bool retransmitted,
+                                           bool in_order) {
+  ssrc_ = header.ssrc;
+  incoming_bitrate_.Update(bytes);
+
+  received_byte_count_ += bytes;
+
+  if (received_seq_max_ == 0 && received_seq_wraps_ == 0) {
+    // This is the first received report.
+    received_seq_first_ = header.sequenceNumber;
+    received_seq_max_ = header.sequenceNumber;
+    received_inorder_packet_count_ = 1;
+    // Current time in samples.
+    local_time_last_received_timestamp_ =
+        ModuleRTPUtility::GetCurrentRTP(clock_, header.payload_type_frequency);
+    return;
+  }
+
+  // Count only the new packets received. That is, if packets 1, 2, 3, 5, 4, 6
+  // are received, 4 will be ignored.
+  if (in_order) {
+    // Current time in samples.
+    const uint32_t RTPtime =
+        ModuleRTPUtility::GetCurrentRTP(clock_, header.payload_type_frequency);
+    received_inorder_packet_count_++;
+
+    // Wrong if we use RetransmitOfOldPacket.
+    int32_t seq_diff =
+        header.sequenceNumber - received_seq_max_;
+    if (seq_diff < 0) {
+      // Wrap around detected.
+      received_seq_wraps_++;
+    }
+    // New max.
+    received_seq_max_ = header.sequenceNumber;
+
+    if (header.timestamp != last_received_timestamp_ &&
+        received_inorder_packet_count_ > 1) {
+      int32_t time_diff_samples =
+          (RTPtime - local_time_last_received_timestamp_) -
+          (header.timestamp - last_received_timestamp_);
+
+      time_diff_samples = abs(time_diff_samples);
+
+      // lib_jingle sometimes deliver crazy jumps in TS for the same stream.
+      // If this happens, don't update jitter value. Use 5 secs video frequency
+      // as the threshold.
+      if (time_diff_samples < 450000) {
+        // Note we calculate in Q4 to avoid using float.
+        int32_t jitter_diff_q4 = (time_diff_samples << 4) - jitter_q4_;
+        jitter_q4_ += ((jitter_diff_q4 + 8) >> 4);
+      }
+
+      // Extended jitter report, RFC 5450.
+      // Actual network jitter, excluding the source-introduced jitter.
+      int32_t time_diff_samples_ext =
+        (RTPtime - local_time_last_received_timestamp_) -
+        ((header.timestamp +
+          header.extension.transmissionTimeOffset) -
+         (last_received_timestamp_ +
+          last_received_transmission_time_offset_));
+
+      time_diff_samples_ext = abs(time_diff_samples_ext);
+
+      if (time_diff_samples_ext < 450000) {
+        int32_t jitter_diffQ4TransmissionTimeOffset =
+          (time_diff_samples_ext << 4) - jitter_q4_transmission_time_offset_;
+        jitter_q4_transmission_time_offset_ +=
+          ((jitter_diffQ4TransmissionTimeOffset + 8) >> 4);
+      }
+    }
+    last_received_timestamp_ = header.timestamp;
+    local_time_last_received_timestamp_ = RTPtime;
+  } else {
+    if (retransmitted) {
+      received_retransmitted_packets_++;
+    } else {
+      received_inorder_packet_count_++;
+    }
+  }
+
+  uint16_t packet_oh = header.headerLength + header.paddingLength;
+
+  // Our measured overhead. Filter from RFC 5104 4.2.1.2:
+  // avg_OH (new) = 15/16*avg_OH (old) + 1/16*pckt_OH,
+  received_packet_oh_ = (15 * received_packet_oh_ + packet_oh) >> 4;
+}
+
+bool ReceiveStatisticsImpl::Statistics(RtpReceiveStatistics* statistics,
+                                       bool reset) {
+  int32_t missing;
+  return Statistics(statistics, &missing, reset);
+}
+
+bool ReceiveStatisticsImpl::Statistics(RtpReceiveStatistics* statistics,
+                                       int32_t*  missing, bool reset) {
+  CriticalSectionScoped lock(crit_sect_.get());
+
+  if (missing == NULL) {
+    return false;
+  }
+  if (received_seq_first_ == 0 && received_byte_count_ == 0) {
+    // We have not received anything.
+    return false;
+  }
+  if (!reset) {
+    if (last_report_inorder_packets_ == 0) {
+      // No report.
+      return false;
+    }
+    // Just get last report.
+    *statistics = last_reported_statistics_;
+    return true;
+  }
+
+  if (last_report_inorder_packets_ == 0) {
+    // First time we send a report.
+    last_report_seq_max_ = received_seq_first_ - 1;
+  }
+  // Calculate fraction lost.
+  uint16_t exp_since_last = (received_seq_max_ - last_report_seq_max_);
+
+  if (last_report_seq_max_ > received_seq_max_) {
+    // Can we assume that the seq_num can't go decrease over a full RTCP period?
+    exp_since_last = 0;
+  }
+
+  // Number of received RTP packets since last report, counts all packets but
+  // not re-transmissions.
+  uint32_t rec_since_last =
+      received_inorder_packet_count_ - last_report_inorder_packets_;
+
+  // With NACK we don't know the expected retransmissions during the last
+  // second. We know how many "old" packets we have received. We just count
+  // the number of old received to estimate the loss, but it still does not
+  // guarantee an exact number since we run this based on time triggered by
+  // sending of an RTP packet. This should have a minimum effect.
+
+  // With NACK we don't count old packets as received since they are
+  // re-transmitted. We use RTT to decide if a packet is re-ordered or
+  // re-transmitted.
+  uint32_t retransmitted_packets =
+      received_retransmitted_packets_ - last_report_old_packets_;
+  rec_since_last += retransmitted_packets;
+
+  *missing = 0;
+  if (exp_since_last > rec_since_last) {
+    *missing = (exp_since_last - rec_since_last);
+  }
+  uint8_t local_fraction_lost = 0;
+  if (exp_since_last) {
+    // Scale 0 to 255, where 255 is 100% loss.
+    local_fraction_lost = (uint8_t)((255 * (*missing)) / exp_since_last);
+  }
+  statistics->fraction_lost = local_fraction_lost;
+
+  // We need a counter for cumulative loss too.
+  cumulative_loss_ += *missing;
+
+  if (jitter_q4_ > jitter_max_q4_) {
+    jitter_max_q4_ = jitter_q4_;
+  }
+  statistics->cumulative_lost = cumulative_loss_;
+  statistics->extended_max_sequence_number = (received_seq_wraps_ << 16) +
+      received_seq_max_;
+  // Note: internal jitter value is in Q4 and needs to be scaled by 1/16.
+  statistics->jitter = jitter_q4_ >> 4;
+  statistics->max_jitter = jitter_max_q4_ >> 4;
+  if (reset) {
+    // Store this report.
+    last_reported_statistics_ = *statistics;
+
+    // Only for report blocks in RTCP SR and RR.
+    last_report_inorder_packets_ = received_inorder_packet_count_;
+    last_report_old_packets_ = received_retransmitted_packets_;
+    last_report_seq_max_ = received_seq_max_;
+  }
+  return true;
+}
+
+void ReceiveStatisticsImpl::GetDataCounters(
+    uint32_t* bytes_received, uint32_t* packets_received) const {
+  CriticalSectionScoped lock(crit_sect_.get());
+
+  if (bytes_received) {
+    *bytes_received = received_byte_count_;
+  }
+  if (packets_received) {
+    *packets_received =
+        received_retransmitted_packets_ + received_inorder_packet_count_;
+  }
+}
+
+uint32_t ReceiveStatisticsImpl::BitrateReceived() {
+  return incoming_bitrate_.BitrateNow();
+}
+
+int32_t ReceiveStatisticsImpl::TimeUntilNextProcess() {
+  int time_since_last_update = clock_->TimeInMilliseconds() -
+      incoming_bitrate_.time_last_rate_update();
+  return std::max(kRateUpdateIntervalMs - time_since_last_update, 0);
+}
+
+int32_t ReceiveStatisticsImpl::Process() {
+  incoming_bitrate_.Process();
+  TRACE_COUNTER_ID1("webrtc_rtp", "RTPReceiverBitrate", ssrc_,
+                    incoming_bitrate_.BitrateLast());
+  TRACE_COUNTER_ID1("webrtc_rtp", "RTPReceiverPacketRate", ssrc_,
+                    incoming_bitrate_.PacketRate());
+  return 0;
+}
+
+}  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/receive_statistics_impl.h b/modules/rtp_rtcp/source/receive_statistics_impl.h
new file mode 100644
index 0000000..1207606
--- /dev/null
+++ b/modules/rtp_rtcp/source/receive_statistics_impl.h
@@ -0,0 +1,77 @@
+/*
+ *  Copyright (c) 2013 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.
+ */
+
+#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RECEIVE_STATISTICS_IMPL_H_
+#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RECEIVE_STATISTICS_IMPL_H_
+
+#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
+
+#include <algorithm>
+
+#include "webrtc/modules/rtp_rtcp/source/bitrate.h"
+#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
+#include "webrtc/system_wrappers/interface/scoped_ptr.h"
+
+namespace webrtc {
+
+class CriticalSectionWrapper;
+
+class ReceiveStatisticsImpl : public ReceiveStatistics {
+ public:
+  explicit ReceiveStatisticsImpl(Clock* clock);
+
+  // Implements ReceiveStatistics.
+  void IncomingPacket(const RTPHeader& header, size_t bytes,
+                      bool old_packet, bool in_order);
+  bool Statistics(RtpReceiveStatistics* statistics, bool reset);
+  bool Statistics(RtpReceiveStatistics* statistics, int32_t* missing,
+                  bool reset);
+  void GetDataCounters(uint32_t* bytes_received,
+                       uint32_t* packets_received) const;
+  uint32_t BitrateReceived();
+  void ResetStatistics();
+  void ResetDataCounters();
+
+  // Implements Module.
+  int32_t TimeUntilNextProcess();
+  int32_t Process();
+
+ private:
+  scoped_ptr<CriticalSectionWrapper> crit_sect_;
+  Clock* clock_;
+  Bitrate incoming_bitrate_;
+  uint32_t ssrc_;
+  // Stats on received RTP packets.
+  uint32_t jitter_q4_;
+  uint32_t jitter_max_q4_;
+  uint32_t cumulative_loss_;
+  uint32_t jitter_q4_transmission_time_offset_;
+
+  uint32_t local_time_last_received_timestamp_;
+  uint32_t last_received_timestamp_;
+  int32_t last_received_transmission_time_offset_;
+  uint16_t received_seq_first_;
+  uint16_t received_seq_max_;
+  uint16_t received_seq_wraps_;
+
+  // Current counter values.
+  uint16_t received_packet_oh_;
+  uint32_t received_byte_count_;
+  uint32_t received_retransmitted_packets_;
+  uint32_t received_inorder_packet_count_;
+
+  // Counter values when we sent the last report.
+  uint32_t last_report_inorder_packets_;
+  uint32_t last_report_old_packets_;
+  uint16_t last_report_seq_max_;
+  RtpReceiveStatistics last_reported_statistics_;
+};
+}  // namespace webrtc
+#endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RECEIVE_STATISTICS_IMPL_H_
diff --git a/modules/rtp_rtcp/source/receiver_fec.cc b/modules/rtp_rtcp/source/receiver_fec.cc
index e99cd4d..aa90702 100644
--- a/modules/rtp_rtcp/source/receiver_fec.cc
+++ b/modules/rtp_rtcp/source/receiver_fec.cc
@@ -14,14 +14,16 @@
 
 #include "webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
+#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
 #include "webrtc/system_wrappers/interface/trace.h"
 
 // RFC 5109
 namespace webrtc {
-ReceiverFEC::ReceiverFEC(const int32_t id, RTPReceiverVideo* owner)
+ReceiverFEC::ReceiverFEC(const int32_t id, RtpData* callback)
     : id_(id),
-      owner_(owner),
+      crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
+      recovered_packet_callback_(callback),
       fec_(new ForwardErrorCorrection(id)),
       payload_type_fec_(-1) {}
 
@@ -42,6 +44,7 @@
 }
 
 void ReceiverFEC::SetPayloadTypeFEC(const int8_t payload_type) {
+  CriticalSectionScoped cs(crit_sect_.get());
   payload_type_fec_ = payload_type;
 }
 //     0                   1                    2                   3
@@ -76,6 +79,8 @@
                                           const uint8_t* incoming_rtp_packet,
                                           const uint16_t payload_data_length,
                                           bool& FECpacket) {
+  CriticalSectionScoped cs(crit_sect_.get());
+
   if (payload_type_fec_ == -1) {
     return -1;
   }
@@ -221,12 +226,18 @@
 }
 
 int32_t ReceiverFEC::ProcessReceivedFEC() {
+  crit_sect_->Enter();
   if (!received_packet_list_.empty()) {
     // Send received media packet to VCM.
     if (!received_packet_list_.front()->is_fec) {
-      if (ParseAndReceivePacket(received_packet_list_.front()->pkt) != 0) {
+      ForwardErrorCorrection::Packet* packet =
+          received_packet_list_.front()->pkt;
+      crit_sect_->Leave();
+      if (!recovered_packet_callback_->OnRecoveredPacket(packet->data,
+                                                         packet->length)) {
         return -1;
       }
+      crit_sect_->Enter();
     }
     if (fec_->DecodeFEC(&received_packet_list_, &recovered_packet_list_) != 0) {
       return -1;
@@ -239,27 +250,16 @@
   for (; it != recovered_packet_list_.end(); ++it) {
     if ((*it)->returned)  // Already sent to the VCM and the jitter buffer.
       continue;
-    if (ParseAndReceivePacket((*it)->pkt) != 0) {
+    ForwardErrorCorrection::Packet* packet = (*it)->pkt;
+    crit_sect_->Leave();
+    if (!recovered_packet_callback_->OnRecoveredPacket(packet->data,
+                                                       packet->length)) {
       return -1;
     }
+    crit_sect_->Enter();
     (*it)->returned = true;
   }
-  return 0;
-}
-
-int ReceiverFEC::ParseAndReceivePacket(
-    const ForwardErrorCorrection::Packet* packet) {
-  WebRtcRTPHeader header;
-  memset(&header, 0, sizeof(header));
-  ModuleRTPUtility::RTPHeaderParser parser(packet->data, packet->length);
-  if (!parser.Parse(header.header)) {
-    return -1;
-  }
-  if (owner_->ReceiveRecoveredPacketCallback(
-          &header, &packet->data[header.header.headerLength],
-          packet->length - header.header.headerLength) != 0) {
-    return -1;
-  }
+  crit_sect_->Leave();
   return 0;
 }
 
diff --git a/modules/rtp_rtcp/source/receiver_fec.h b/modules/rtp_rtcp/source/receiver_fec.h
index 2a13975..653a93e 100644
--- a/modules/rtp_rtcp/source/receiver_fec.h
+++ b/modules/rtp_rtcp/source/receiver_fec.h
@@ -15,14 +15,16 @@
 
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
+#include "webrtc/system_wrappers/interface/scoped_ptr.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
-class RTPReceiverVideo;
+
+class CriticalSectionWrapper;
 
 class ReceiverFEC {
  public:
-  ReceiverFEC(const int32_t id, RTPReceiverVideo* owner);
+  ReceiverFEC(const int32_t id, RtpData* callback);
   virtual ~ReceiverFEC();
 
   int32_t AddReceivedFECPacket(const WebRtcRTPHeader* rtp_header,
@@ -35,10 +37,9 @@
   void SetPayloadTypeFEC(const int8_t payload_type);
 
  private:
-  int ParseAndReceivePacket(const ForwardErrorCorrection::Packet* packet);
-
   int id_;
-  RTPReceiverVideo* owner_;
+  scoped_ptr<CriticalSectionWrapper> crit_sect_;
+  RtpData* recovered_packet_callback_;
   ForwardErrorCorrection* fec_;
   // TODO(holmer): In the current version received_packet_list_ is never more
   // than one packet, since we process FEC every time a new packet
diff --git a/modules/rtp_rtcp/source/receiver_fec_unittest.cc b/modules/rtp_rtcp/source/receiver_fec_unittest.cc
index 46b8eb4..981f237 100644
--- a/modules/rtp_rtcp/source/receiver_fec_unittest.cc
+++ b/modules/rtp_rtcp/source/receiver_fec_unittest.cc
@@ -16,20 +16,31 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
-#include "webrtc/modules/rtp_rtcp/source/mock/mock_rtp_receiver_video.h"
 #include "webrtc/modules/rtp_rtcp/source/receiver_fec.h"
 
 using ::testing::_;
 using ::testing::Args;
 using ::testing::ElementsAreArray;
+using ::testing::Return;
 
 namespace webrtc {
 
+class MockRtpData : public RtpData {
+ public:
+  MOCK_METHOD3(OnReceivedPayloadData,
+      int32_t(const uint8_t* payloadData,
+              const uint16_t payloadSize,
+              const WebRtcRTPHeader* rtpHeader));
+
+  MOCK_METHOD2(OnRecoveredPacket,
+      bool(const uint8_t* packet, int packet_length));
+};
+
 class ReceiverFecTest : public ::testing::Test {
  protected:
   virtual void SetUp() {
     fec_ = new ForwardErrorCorrection(0);
-    receiver_fec_ = new ReceiverFEC(0, &rtp_receiver_video_);
+    receiver_fec_ = new ReceiverFEC(0, &rtp_data_callback_);
     generator_ = new FrameGenerator();
     receiver_fec_->SetPayloadTypeFEC(kFecPayloadType);
   }
@@ -64,11 +75,10 @@
     // Verify that the content of the reconstructed packet is equal to the
     // content of |packet|, and that the same content is received |times| number
     // of times in a row.
-    EXPECT_CALL(rtp_receiver_video_, ReceiveRecoveredPacketCallback(
-                                         _, _, packet->length - kRtpHeaderSize))
-        .With(Args<1, 2>(ElementsAreArray(packet->data + kRtpHeaderSize,
-                                          packet->length - kRtpHeaderSize)))
-        .Times(times);
+    EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, packet->length))
+        .With(Args<0, 1>(ElementsAreArray(packet->data,
+                                          packet->length)))
+        .Times(times).WillRepeatedly(Return(true));
   }
 
   void BuildAndAddRedMediaPacket(RtpPacket* packet) {
@@ -92,7 +102,7 @@
   }
 
   ForwardErrorCorrection* fec_;
-  MockRTPReceiverVideo rtp_receiver_video_;
+  MockRtpData rtp_data_callback_;
   ReceiverFEC* receiver_fec_;
   FrameGenerator* generator_;
 };
@@ -255,8 +265,8 @@
   GenerateFEC(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
 
   BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front());
-  EXPECT_CALL(rtp_receiver_video_, ReceiveRecoveredPacketCallback(_, _, _))
-      .Times(1);
+  EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
+      .Times(1).WillRepeatedly(Return(true));
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFEC());
   delayed_fec = fec_packets.front();
 
@@ -270,15 +280,15 @@
   for (std::list<RtpPacket*>::iterator it = media_rtp_packets_batch2.begin();
        it != media_rtp_packets_batch2.end(); ++it) {
     BuildAndAddRedMediaPacket(*it);
-    EXPECT_CALL(rtp_receiver_video_, ReceiveRecoveredPacketCallback(_, _, _))
-        .Times(1);
+    EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
+        .Times(1).WillRepeatedly(Return(true));
     EXPECT_EQ(0, receiver_fec_->ProcessReceivedFEC());
   }
 
   // Add the delayed FEC packet. One packet should be reconstructed.
   BuildAndAddRedFecPacket(delayed_fec);
-  EXPECT_CALL(rtp_receiver_video_, ReceiveRecoveredPacketCallback(_, _, _))
-      .Times(1);
+  EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
+      .Times(1).WillRepeatedly(Return(true));
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFEC());
 
   DeletePackets(&media_packets_batch1);
@@ -299,8 +309,8 @@
   GenerateFEC(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
 
   BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front());
-  EXPECT_CALL(rtp_receiver_video_, ReceiveRecoveredPacketCallback(_, _, _))
-      .Times(1);
+  EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
+      .Times(1).WillRepeatedly(Return(true));
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFEC());
   delayed_fec = fec_packets.front();
 
@@ -314,15 +324,15 @@
   for (std::list<RtpPacket*>::iterator it = media_rtp_packets_batch2.begin();
        it != media_rtp_packets_batch2.end(); ++it) {
     BuildAndAddRedMediaPacket(*it);
-    EXPECT_CALL(rtp_receiver_video_, ReceiveRecoveredPacketCallback(_, _, _))
-        .Times(1);
+    EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
+        .Times(1).WillRepeatedly(Return(true));
     EXPECT_EQ(0, receiver_fec_->ProcessReceivedFEC());
   }
 
   // Add the delayed FEC packet. No packet should be reconstructed since the
   // first media packet of that frame has been dropped due to being too old.
   BuildAndAddRedFecPacket(delayed_fec);
-  EXPECT_CALL(rtp_receiver_video_, ReceiveRecoveredPacketCallback(_, _, _))
+  EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
       .Times(0);
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFEC());
 
@@ -346,7 +356,7 @@
          it != fec_packets.end(); ++it) {
       // Only FEC packets inserted. No packets recoverable at this time.
       BuildAndAddRedFecPacket(*it);
-      EXPECT_CALL(rtp_receiver_video_, ReceiveRecoveredPacketCallback(_, _, _))
+      EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
           .Times(0);
       EXPECT_EQ(0, receiver_fec_->ProcessReceivedFEC());
     }
@@ -360,8 +370,8 @@
   // and should've been dropped. Only the media packet we inserted will be
   // returned.
   BuildAndAddRedMediaPacket(media_rtp_packets.front());
-  EXPECT_CALL(rtp_receiver_video_, ReceiveRecoveredPacketCallback(_, _, _))
-      .Times(1);
+  EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
+      .Times(1).WillRepeatedly(Return(true));
   EXPECT_EQ(0, receiver_fec_->ProcessReceivedFEC());
 
   DeletePackets(&media_packets);
diff --git a/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc b/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
index 10566d6..e7c7bcb 100644
--- a/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_format_remb_unittest.cc
@@ -115,13 +115,15 @@
   uint32_t SSRC = 456789;
   EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpNonCompound));
   EXPECT_EQ(0, rtcp_sender_->SetREMBData(1234, 1, &SSRC));
-  EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpRemb));
+  EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpRemb, NULL));
 }
 
 TEST_F(RtcpFormatRembTest, TestCompund) {
   uint32_t SSRCs[2] = {456789, 98765};
   EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
   EXPECT_EQ(0, rtcp_sender_->SetREMBData(1234, 2, SSRCs));
-  EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpRemb));
+  ReceiveStatistics::RtpReceiveStatistics receive_stats;
+  memset(&receive_stats, 0, sizeof(receive_stats));
+  EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpRemb, &receive_stats));
 }
 }  // namespace
diff --git a/modules/rtp_rtcp/source/rtcp_receiver.cc b/modules/rtp_rtcp/source/rtcp_receiver.cc
index b86728a..698325c 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -141,6 +141,11 @@
     return 0;
 }
 
+uint32_t RTCPReceiver::RemoteSSRC() const {
+  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  return _remoteSSRC;
+}
+
 void RTCPReceiver::RegisterRtcpObservers(
     RtcpIntraFrameObserver* intra_frame_callback,
     RtcpBandwidthObserver* bandwidth_callback,
@@ -183,7 +188,7 @@
   return 0;
 }
 
-int32_t RTCPReceiver::RTT(const uint32_t remoteSSRC,
+int32_t RTCPReceiver::RTT(uint32_t remoteSSRC,
                           uint16_t* RTT,
                           uint16_t* avgRTT,
                           uint16_t* minRTT,
@@ -1410,43 +1415,4 @@
   return num;
 }
 
-int32_t
-RTCPReceiver::SetPacketTimeout(const uint32_t timeoutMS)
-{
-    CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
-    _packetTimeOutMS = timeoutMS;
-    return 0;
-}
-
-void RTCPReceiver::PacketTimeout()
-{
-    if(_packetTimeOutMS == 0)
-    {
-        // not configured
-        return;
-    }
-
-    bool packetTimeOut = false;
-    {
-        CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
-        if(_lastReceived == 0)
-        {
-            // not active
-            return;
-        }
-
-        int64_t now = _clock->TimeInMilliseconds();
-        if(now - _lastReceived > _packetTimeOutMS)
-        {
-            packetTimeOut = true;
-            _lastReceived = 0;  // only one callback
-        }
-    }
-    CriticalSectionScoped lock(_criticalSectionFeedbacks);
-    if(packetTimeOut && _cbRtcpFeedback)
-    {
-        _cbRtcpFeedback->OnRTCPPacketTimeout(_id);
-    }
-}
-
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtcp_receiver.h b/modules/rtp_rtcp/source/rtcp_receiver.h
index a86eef4..45e3b68 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver.h
+++ b/modules/rtp_rtcp/source/rtcp_receiver.h
@@ -42,6 +42,7 @@
     void SetSSRC( const uint32_t ssrc);
     void SetRelaySSRC( const uint32_t ssrc);
     int32_t SetRemoteSSRC( const uint32_t ssrc);
+    uint32_t RemoteSSRC() const;
 
     uint32_t RelaySSRC() const;
 
@@ -67,7 +68,7 @@
                 uint32_t *rtcp_timestamp) const;
 
     // get rtt
-    int32_t RTT(const uint32_t remoteSSRC,
+    int32_t RTT(uint32_t remoteSSRC,
                 uint16_t* RTT,
                 uint16_t* avgRTT,
                 uint16_t* minRTT,
@@ -106,9 +107,6 @@
 
     int32_t UpdateTMMBR();
 
-    int32_t SetPacketTimeout(const uint32_t timeoutMS);
-    void PacketTimeout();
-
 protected:
     RTCPHelp::RTCPReportBlockInformation* CreateReportBlockInformation(const uint32_t remoteSSRC);
     RTCPHelp::RTCPReportBlockInformation* GetReportBlockInformation(const uint32_t remoteSSRC) const;
diff --git a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
index 445c553..d5c1120 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
@@ -136,7 +136,7 @@
 
 // This test transport verifies that no functions get called.
 class TestTransport : public Transport,
-                      public RtpData {
+                      public NullRtpData {
  public:
   explicit TestTransport()
       : rtcp_receiver_(NULL) {
diff --git a/modules/rtp_rtcp/source/rtcp_sender.cc b/modules/rtp_rtcp/source/rtcp_sender.cc
index 2905737..ff9190d 100644
--- a/modules/rtp_rtcp/source/rtcp_sender.cc
+++ b/modules/rtp_rtcp/source/rtcp_sender.cc
@@ -268,7 +268,7 @@
     }
     if(sendRTCPBye)
     {
-        return SendRTCP(kRtcpBye);
+        return SendRTCP(kRtcpBye, NULL);
     }
     return 0;
 }
@@ -373,12 +373,10 @@
     _SSRC = ssrc;
 }
 
-int32_t
-RTCPSender::SetRemoteSSRC( const uint32_t ssrc)
+void RTCPSender::SetRemoteSSRC(uint32_t ssrc)
 {
     CriticalSectionScoped lock(_criticalSectionRTCPSender);
     _remoteSSRC = ssrc;
-    return 0;
 }
 
 int32_t
@@ -1534,11 +1532,13 @@
 }
 
 int32_t
-RTCPSender::SendRTCP(const uint32_t packetTypeFlags,
-                     const int32_t nackSize,       // NACK
-                     const uint16_t* nackList,     // NACK
-                     const bool repeat,                  // FIR
-                     const uint64_t pictureID)     // SLI & RPSI
+RTCPSender::SendRTCP(
+    uint32_t packetTypeFlags,
+    const ReceiveStatistics::RtpReceiveStatistics* receive_stats,
+    int32_t nackSize,
+    const uint16_t* nackList,
+    bool repeat,
+    uint64_t pictureID)
 {
     uint32_t rtcpPacketTypeFlags = packetTypeFlags;
     uint32_t pos = 0;
@@ -1570,13 +1570,15 @@
             rtcpPacketTypeFlags & kRtcpSr ||
             rtcpPacketTypeFlags & kRtcpRr)
         {
-            // get statistics from our RTPreceiver outside critsect
-            if(_rtpRtcp.ReportBlockStatistics(&received.fractionLost,
-                                              &received.cumulativeLost,
-                                              &received.extendedHighSeqNum,
-                                              &received.jitter,
-                                              &jitterTransmissionOffset) == 0)
+            // Do we have receive statistics to send?
+            if (receive_stats)
             {
+                received.fractionLost = receive_stats->fraction_lost;
+                received.cumulativeLost = receive_stats->cumulative_lost;
+                received.extendedHighSeqNum =
+                    receive_stats->extended_max_sequence_number;
+                received.jitter = receive_stats->jitter;
+                jitterTransmissionOffset = 0;
                 hasReceived = true;
 
                 uint32_t lastReceivedRRNTPsecs = 0;
diff --git a/modules/rtp_rtcp/source/rtcp_sender.h b/modules/rtp_rtcp/source/rtcp_sender.h
index 9be2f3f..06c07f4 100644
--- a/modules/rtp_rtcp/source/rtcp_sender.h
+++ b/modules/rtp_rtcp/source/rtcp_sender.h
@@ -17,6 +17,7 @@
 
 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
+#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
@@ -26,7 +27,7 @@
 
 namespace webrtc {
 
-class ModuleRtpRtcpImpl; 
+class ModuleRtpRtcpImpl;
 
 class NACKStringBuilder
 {
@@ -70,7 +71,7 @@
 
     void SetSSRC( const uint32_t ssrc);
 
-    int32_t SetRemoteSSRC( const uint32_t ssrc);
+    void SetRemoteSSRC(uint32_t ssrc);
 
     int32_t SetCameraDelay(const int32_t delayMS);
 
@@ -88,11 +89,13 @@
 
     uint32_t LastSendReport(uint32_t& lastRTCPTime);
 
-    int32_t SendRTCP(const uint32_t rtcpPacketTypeFlags,
-                     const int32_t nackSize = 0,
-                     const uint16_t* nackList = 0,
-                     const bool repeat = false,
-                     const uint64_t pictureID = 0);
+    int32_t SendRTCP(
+        uint32_t rtcpPacketTypeFlags,
+        const ReceiveStatistics::RtpReceiveStatistics* receive_stats,
+        int32_t nackSize = 0,
+        const uint16_t* nackList = 0,
+        bool repeat = false,
+        uint64_t pictureID = 0);
 
     int32_t AddReportBlock(const uint32_t SSRC,
                            const RTCPReportBlock* receiveBlock);
diff --git a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
index 9b1d15c..3c0681d 100644
--- a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
@@ -20,9 +20,12 @@
 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_observer.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 
 namespace webrtc {
@@ -216,7 +219,7 @@
 }
 
 class TestTransport : public Transport,
-                      public RtpData {
+                      public NullRtpData {
  public:
   TestTransport()
       : rtcp_receiver_(NULL) {
@@ -276,6 +279,8 @@
   RtcpSenderTest()
       : over_use_detector_options_(),
         system_clock_(Clock::GetRealTimeClock()),
+        rtp_payload_registry_(new RTPPayloadRegistry(
+            0, RTPPayloadStrategy::CreateStrategy(false))),
         remote_bitrate_observer_(),
         remote_bitrate_estimator_(
             RemoteBitrateEstimatorFactory().Create(
@@ -287,11 +292,12 @@
     configuration.id = 0;
     configuration.audio = false;
     configuration.clock = system_clock_;
-    configuration.incoming_data = test_transport_;
     configuration.outgoing_transport = test_transport_;
     configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get();
 
     rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration);
+    rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver(
+        0, system_clock_, test_transport_, NULL, rtp_payload_registry_.get()));
     rtcp_sender_ = new RTCPSender(0, false, system_clock_, rtp_rtcp_impl_);
     rtcp_receiver_ = new RTCPReceiver(0, system_clock_, rtp_rtcp_impl_);
     test_transport_->SetRTCPReceiver(rtcp_receiver_);
@@ -314,6 +320,8 @@
 
   OverUseDetectorOptions over_use_detector_options_;
   Clock* system_clock_;
+  scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
+  scoped_ptr<RtpReceiver> rtp_receiver_;
   ModuleRtpRtcpImpl* rtp_rtcp_impl_;
   RTCPSender* rtcp_sender_;
   RTCPReceiver* rtcp_receiver_;
@@ -327,7 +335,7 @@
 
 TEST_F(RtcpSenderTest, RtcpOff) {
   EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpOff));
-  EXPECT_EQ(-1, rtcp_sender_->SendRTCP(kRtcpSr));
+  EXPECT_EQ(-1, rtcp_sender_->SendRTCP(kRtcpSr, NULL));
 }
 
 TEST_F(RtcpSenderTest, IJStatus) {
@@ -351,18 +359,27 @@
   strncpy(codec_inst.plName, "VP8", webrtc::kPayloadNameSize - 1);
   codec_inst.codecType = webrtc::kVideoCodecVP8;
   codec_inst.plType = payload;
-  EXPECT_EQ(0, rtp_rtcp_impl_->RegisterReceivePayload(codec_inst));
+  EXPECT_EQ(0, rtp_receiver_->RegisterReceivePayload(codec_inst.plName,
+                                                     codec_inst.plType,
+                                                     90000,
+                                                     0,
+                                                     codec_inst.maxBitrate));
 
   // Make sure RTP packet has been received.
   scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
   RTPHeader header;
   EXPECT_TRUE(parser->Parse(packet_, packet_length, &header));
-  EXPECT_EQ(0, rtp_rtcp_impl_->IncomingRtpPacket(packet_, packet_length,
-                                                 header));
+  PayloadUnion payload_specific;
+  EXPECT_TRUE(rtp_payload_registry_->GetPayloadSpecifics(header.payloadType,
+                                                        &payload_specific));
+  EXPECT_TRUE(rtp_receiver_->IncomingRtpPacket(&header, packet_, packet_length,
+                                               payload_specific, true));
 
   EXPECT_EQ(0, rtcp_sender_->SetIJStatus(true));
   EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
-  EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpRr));
+  ReceiveStatistics::RtpReceiveStatistics receive_stats;
+  memset(&receive_stats, 0, sizeof(receive_stats));
+  EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpRr, &receive_stats));
 
   // Transmission time offset packet should be received.
   ASSERT_TRUE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags &
@@ -372,7 +389,9 @@
 TEST_F(RtcpSenderTest, TestCompound_NoRtpReceived) {
   EXPECT_EQ(0, rtcp_sender_->SetIJStatus(true));
   EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound));
-  EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpRr));
+  // |receive_stats| is NULL since no data has been received.
+  ReceiveStatistics::RtpReceiveStatistics* receive_stats = NULL;
+  EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpRr, receive_stats));
 
   // Transmission time offset packet should not be received.
   ASSERT_FALSE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags &
@@ -390,7 +409,9 @@
   TMMBRSet bounding_set;
   EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3));
   ASSERT_EQ(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags);
-  EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpSr));
+  ReceiveStatistics::RtpReceiveStatistics receive_stats;
+  memset(&receive_stats, 0, sizeof(receive_stats));
+  EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpSr, &receive_stats));
   // We now expect the packet to show up in the rtcp_packet_info_ of
   // test_transport_.
   ASSERT_NE(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags);
@@ -412,7 +433,9 @@
 
   EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3));
   ASSERT_EQ(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags);
-  EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpSr));
+  ReceiveStatistics::RtpReceiveStatistics receive_stats;
+  memset(&receive_stats, 0, sizeof(receive_stats));
+  EXPECT_EQ(0, rtcp_sender_->SendRTCP(kRtcpSr, &receive_stats));
   // We now expect the packet to show up in the rtcp_packet_info_ of
   // test_transport_.
   ASSERT_NE(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags);
diff --git a/modules/rtp_rtcp/source/rtp_payload_registry.cc b/modules/rtp_rtcp/source/rtp_payload_registry.cc
index cb689ee..dee05fe 100644
--- a/modules/rtp_rtcp/source/rtp_payload_registry.cc
+++ b/modules/rtp_rtcp/source/rtp_payload_registry.cc
@@ -8,7 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include "webrtc/modules/rtp_rtcp/source/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
 
 #include "webrtc/system_wrappers/interface/trace.h"
 
@@ -21,8 +21,7 @@
       rtp_payload_strategy_(rtp_payload_strategy),
       red_payload_type_(-1),
       last_received_payload_type_(-1),
-      last_received_media_payload_type_(-1) {
-}
+      last_received_media_payload_type_(-1) {}
 
 RTPPayloadRegistry::~RTPPayloadRegistry() {
   while (!payload_type_map_.empty()) {
@@ -226,7 +225,29 @@
   return -1;
 }
 
-int32_t RTPPayloadRegistry::PayloadTypeToPayload(
+bool RTPPayloadRegistry::GetPayloadSpecifics(uint8_t payload_type,
+                                             PayloadUnion* payload) const {
+  ModuleRTPUtility::PayloadTypeMap::const_iterator it =
+    payload_type_map_.find(payload_type);
+
+  // Check that this is a registered payload type.
+  if (it == payload_type_map_.end()) {
+    return false;
+  }
+  *payload = it->second->typeSpecific;
+  return true;
+}
+
+int RTPPayloadRegistry::GetPayloadTypeFrequency(
+    uint8_t payload_type) const {
+  ModuleRTPUtility::Payload* payload;
+  if (!PayloadTypeToPayload(payload_type, payload)) {
+    return -1;
+  }
+  return rtp_payload_strategy_->GetPayloadTypeFrequency(*payload);
+}
+
+bool RTPPayloadRegistry::PayloadTypeToPayload(
   const uint8_t payload_type,
   ModuleRTPUtility::Payload*& payload) const {
 
@@ -235,10 +256,10 @@
 
   // Check that this is a registered payload type.
   if (it == payload_type_map_.end()) {
-    return -1;
+    return false;
   }
   payload = it->second;
-  return 0;
+  return true;
 }
 
 bool RTPPayloadRegistry::ReportMediaPayloadType(
@@ -289,6 +310,11 @@
     payload->audio = true;
     return payload;
   }
+
+  int GetPayloadTypeFrequency(
+      const ModuleRTPUtility::Payload& payload) const {
+    return payload.typeSpecific.Audio.frequency;
+  }
 };
 
 class RTPPayloadVideoStrategy : public RTPPayloadStrategy {
@@ -315,15 +341,15 @@
       const uint32_t frequency,
       const uint8_t channels,
       const uint32_t rate) const {
-    RtpVideoCodecTypes videoType = kRtpGenericVideo;
+    RtpVideoCodecTypes videoType = kRtpVideoGeneric;
     if (ModuleRTPUtility::StringCompare(payloadName, "VP8", 3)) {
-      videoType = kRtpVp8Video;
+      videoType = kRtpVideoVp8;
     } else if (ModuleRTPUtility::StringCompare(payloadName, "I420", 4)) {
-      videoType = kRtpGenericVideo;
+      videoType = kRtpVideoGeneric;
     } else if (ModuleRTPUtility::StringCompare(payloadName, "ULPFEC", 6)) {
-      videoType = kRtpFecVideo;
+      videoType = kRtpVideoFec;
     } else {
-      videoType = kRtpGenericVideo;
+      videoType = kRtpVideoGeneric;
     }
     ModuleRTPUtility::Payload* payload = new ModuleRTPUtility::Payload;
 
@@ -334,6 +360,11 @@
     payload->audio = false;
     return payload;
   }
+
+  int GetPayloadTypeFrequency(
+      const ModuleRTPUtility::Payload& payload) const {
+    return kVideoPayloadTypeFrequency;
+  }
 };
 
 RTPPayloadStrategy* RTPPayloadStrategy::CreateStrategy(
diff --git a/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc b/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc
index 2f1e916..8ef1074 100644
--- a/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc
@@ -8,7 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include "webrtc/modules/rtp_rtcp/source/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -74,8 +74,8 @@
   EXPECT_TRUE(new_payload_created) << "A new payload WAS created.";
 
   ModuleRTPUtility::Payload* retrieved_payload = NULL;
-  EXPECT_EQ(0, rtp_payload_registry_->PayloadTypeToPayload(payload_type,
-                                                           retrieved_payload));
+  EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(payload_type,
+                                                          retrieved_payload));
 
   // We should get back the exact pointer to the payload returned by the
   // payload strategy.
@@ -83,7 +83,7 @@
 
   // Now forget about it and verify it's gone.
   EXPECT_EQ(0, rtp_payload_registry_->DeRegisterReceivePayload(payload_type));
-  EXPECT_EQ(-1, rtp_payload_registry_->PayloadTypeToPayload(
+  EXPECT_FALSE(rtp_payload_registry_->PayloadTypeToPayload(
       payload_type, retrieved_payload));
 }
 
@@ -101,8 +101,8 @@
   ASSERT_EQ(red_type_of_the_day, rtp_payload_registry_->red_payload_type());
 
   ModuleRTPUtility::Payload* retrieved_payload = NULL;
-  EXPECT_EQ(0, rtp_payload_registry_->PayloadTypeToPayload(red_type_of_the_day,
-                                                           retrieved_payload));
+  EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(red_type_of_the_day,
+                                                          retrieved_payload));
   EXPECT_FALSE(retrieved_payload->audio);
   EXPECT_STRCASEEQ("red", retrieved_payload->name);
 }
@@ -131,11 +131,11 @@
 
   // Ensure both payloads are preserved.
   ModuleRTPUtility::Payload* retrieved_payload = NULL;
-  EXPECT_EQ(0, rtp_payload_registry_->PayloadTypeToPayload(payload_type,
-                                                           retrieved_payload));
+  EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(payload_type,
+                                                          retrieved_payload));
   EXPECT_EQ(first_payload_on_heap, retrieved_payload);
-  EXPECT_EQ(0, rtp_payload_registry_->PayloadTypeToPayload(payload_type - 1,
-                                                           retrieved_payload));
+  EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(payload_type - 1,
+                                                          retrieved_payload));
   EXPECT_EQ(second_payload_on_heap, retrieved_payload);
 
   // Ok, update the rate for one of the codecs. If either the incoming rate or
@@ -170,10 +170,10 @@
       kTypicalChannels, kTypicalRate, &ignored));
 
   ModuleRTPUtility::Payload* retrieved_payload = NULL;
-  EXPECT_EQ(-1, rtp_payload_registry_->PayloadTypeToPayload(
+  EXPECT_FALSE(rtp_payload_registry_->PayloadTypeToPayload(
       payload_type, retrieved_payload)) << "The first payload should be "
           "deregistered because the only thing that differs is payload type.";
-  EXPECT_EQ(0, rtp_payload_registry_->PayloadTypeToPayload(
+  EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(
       payload_type - 1, retrieved_payload)) <<
           "The second payload should still be registered though.";
 
@@ -185,10 +185,10 @@
       kTypicalPayloadName, payload_type + 1, kTypicalFrequency,
       kTypicalChannels, kTypicalRate, &ignored));
 
-  EXPECT_EQ(0, rtp_payload_registry_->PayloadTypeToPayload(
+  EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(
       payload_type - 1, retrieved_payload)) <<
           "Not compatible; both payloads should be kept.";
-  EXPECT_EQ(0, rtp_payload_registry_->PayloadTypeToPayload(
+  EXPECT_TRUE(rtp_payload_registry_->PayloadTypeToPayload(
       payload_type + 1, retrieved_payload)) <<
           "Not compatible; both payloads should be kept.";
 }
diff --git a/modules/rtp_rtcp/source/rtp_receiver.cc b/modules/rtp_rtcp/source/rtp_receiver.cc
deleted file mode 100644
index 4fc557f..0000000
--- a/modules/rtp_rtcp/source/rtp_receiver.cc
+++ /dev/null
@@ -1,1140 +0,0 @@
-/*
- *  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/modules/rtp_rtcp/source/rtp_receiver.h"
-
-#include <cassert>
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
-#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
-#include "webrtc/system_wrappers/interface/trace.h"
-#include "webrtc/system_wrappers/interface/trace_event.h"
-
-namespace webrtc {
-
-using ModuleRTPUtility::AudioPayload;
-using ModuleRTPUtility::GetCurrentRTP;
-using ModuleRTPUtility::Payload;
-using ModuleRTPUtility::RTPPayloadParser;
-using ModuleRTPUtility::StringCompare;
-using ModuleRTPUtility::VideoPayload;
-
-RTPReceiver::RTPReceiver(const int32_t id,
-                         Clock* clock,
-                         ModuleRtpRtcpImpl* owner,
-                         RtpAudioFeedback* incoming_audio_messages_callback,
-                         RtpData* incoming_payload_callback,
-                         RtpFeedback* incoming_messages_callback,
-                         RTPReceiverStrategy* rtp_media_receiver,
-                         RTPPayloadRegistry* rtp_payload_registry)
-    : Bitrate(clock),
-      rtp_payload_registry_(rtp_payload_registry),
-      rtp_media_receiver_(rtp_media_receiver),
-      id_(id),
-      rtp_rtcp_(*owner),
-      cb_rtp_feedback_(incoming_messages_callback),
-
-      critical_section_rtp_receiver_(
-        CriticalSectionWrapper::CreateCriticalSection()),
-      last_receive_time_(0),
-      last_received_payload_length_(0),
-
-      packet_timeout_ms_(0),
-
-      ssrc_(0),
-      num_csrcs_(0),
-      current_remote_csrc_(),
-      num_energy_(0),
-      current_remote_energy_(),
-      use_ssrc_filter_(false),
-      ssrc_filter_(0),
-
-      jitter_q4_(0),
-      jitter_max_q4_(0),
-      cumulative_loss_(0),
-      jitter_q4_transmission_time_offset_(0),
-      local_time_last_received_timestamp_(0),
-      last_received_frame_time_ms_(0),
-      last_received_timestamp_(0),
-      last_received_sequence_number_(0),
-      last_received_transmission_time_offset_(0),
-
-      received_seq_first_(0),
-      received_seq_max_(0),
-      received_seq_wraps_(0),
-
-      received_packet_oh_(12),  // RTP header.
-      received_byte_count_(0),
-      received_old_packet_count_(0),
-      received_inorder_packet_count_(0),
-
-      last_report_inorder_packets_(0),
-      last_report_old_packets_(0),
-      last_report_seq_max_(0),
-      last_report_fraction_lost_(0),
-      last_report_cumulative_lost_(0),
-      last_report_extended_high_seq_num_(0),
-      last_report_jitter_(0),
-      last_report_jitter_transmission_time_offset_(0),
-
-      nack_method_(kNackOff),
-      max_reordering_threshold_(kDefaultMaxReorderingThreshold),
-      rtx_(false),
-      ssrc_rtx_(0),
-      payload_type_rtx_(-1) {
-  assert(incoming_audio_messages_callback &&
-         incoming_messages_callback &&
-         incoming_payload_callback);
-
-  memset(current_remote_csrc_, 0, sizeof(current_remote_csrc_));
-  memset(current_remote_energy_, 0, sizeof(current_remote_energy_));
-
-  WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, id, "%s created", __FUNCTION__);
-}
-
-RTPReceiver::~RTPReceiver() {
-  for (int i = 0; i < num_csrcs_; ++i) {
-    cb_rtp_feedback_->OnIncomingCSRCChanged(id_, current_remote_csrc_[i],
-                                            false);
-  }
-  delete critical_section_rtp_receiver_;
-  WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, id_, "%s deleted", __FUNCTION__);
-}
-
-RtpVideoCodecTypes RTPReceiver::VideoCodecType() const {
-  ModuleRTPUtility::PayloadUnion media_specific;
-  rtp_media_receiver_->GetLastMediaSpecificPayload(&media_specific);
-  return media_specific.Video.videoCodecType;
-}
-
-uint32_t RTPReceiver::MaxConfiguredBitrate() const {
-  ModuleRTPUtility::PayloadUnion media_specific;
-  rtp_media_receiver_->GetLastMediaSpecificPayload(&media_specific);
-  return media_specific.Video.maxRate;
-}
-
-bool RTPReceiver::REDPayloadType(const int8_t payload_type) const {
-  return rtp_payload_registry_->red_payload_type() == payload_type;
-}
-
-int8_t RTPReceiver::REDPayloadType() const {
-  return rtp_payload_registry_->red_payload_type();
-}
-
-int32_t RTPReceiver::SetPacketTimeout(const uint32_t timeout_ms) {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  packet_timeout_ms_ = timeout_ms;
-  return 0;
-}
-
-bool RTPReceiver::HaveNotReceivedPackets() const {
-  return last_receive_time_ == 0;
-}
-
-void RTPReceiver::PacketTimeout() {
-  bool packet_time_out = false;
-  {
-    CriticalSectionScoped lock(critical_section_rtp_receiver_);
-    if (packet_timeout_ms_ == 0) {
-      // Not configured.
-      return;
-    }
-
-    if (HaveNotReceivedPackets()) {
-      // Not active.
-      return;
-    }
-
-    int64_t now = clock_->TimeInMilliseconds();
-
-    if (now - last_receive_time_ > packet_timeout_ms_) {
-      packet_time_out = true;
-      last_receive_time_ = 0;            // Only one callback.
-      rtp_payload_registry_->ResetLastReceivedPayloadTypes();
-    }
-  }
-  if (packet_time_out) {
-    cb_rtp_feedback_->OnPacketTimeout(id_);
-  }
-}
-
-void RTPReceiver::ProcessDeadOrAlive(const bool rtcp_alive,
-                                     const int64_t now) {
-  RTPAliveType alive = kRtpDead;
-
-  if (last_receive_time_ + 1000 > now) {
-    // Always alive if we have received a RTP packet the last second.
-    alive = kRtpAlive;
-
-  } else {
-    if (rtcp_alive) {
-      alive = rtp_media_receiver_->ProcessDeadOrAlive(
-          last_received_payload_length_);
-    } else {
-      // No RTP packet for 1 sec and no RTCP: dead.
-    }
-  }
-
-  cb_rtp_feedback_->OnPeriodicDeadOrAlive(id_, alive);
-}
-
-uint16_t RTPReceiver::PacketOHReceived() const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  return received_packet_oh_;
-}
-
-uint32_t RTPReceiver::PacketCountReceived() const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  return received_inorder_packet_count_;
-}
-
-uint32_t RTPReceiver::ByteCountReceived() const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  return received_byte_count_;
-}
-
-int32_t RTPReceiver::RegisterReceivePayload(
-    const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-    const int8_t payload_type,
-    const uint32_t frequency,
-    const uint8_t channels,
-    const uint32_t rate) {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-
-  // TODO(phoglund): Try to streamline handling of the RED codec and some other
-  // cases which makes it necessary to keep track of whether we created a
-  // payload or not.
-  bool created_new_payload = false;
-  int32_t result = rtp_payload_registry_->RegisterReceivePayload(
-      payload_name, payload_type, frequency, channels, rate,
-      &created_new_payload);
-  if (created_new_payload) {
-    if (rtp_media_receiver_->OnNewPayloadTypeCreated(payload_name, payload_type,
-                                                     frequency) != 0) {
-      WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_,
-                   "%s failed to register payload",
-                   __FUNCTION__);
-      return -1;
-    }
-  }
-  return result;
-}
-
-int32_t RTPReceiver::DeRegisterReceivePayload(
-    const int8_t payload_type) {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  return rtp_payload_registry_->DeRegisterReceivePayload(payload_type);
-}
-
-int32_t RTPReceiver::ReceivePayloadType(
-    const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-    const uint32_t frequency,
-    const uint8_t channels,
-    const uint32_t rate,
-    int8_t* payload_type) const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  return rtp_payload_registry_->ReceivePayloadType(
-      payload_name, frequency, channels, rate, payload_type);
-}
-
-NACKMethod RTPReceiver::NACK() const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  return nack_method_;
-}
-
-// Turn negative acknowledgment requests on/off.
-int32_t RTPReceiver::SetNACKStatus(const NACKMethod method,
-                                   int max_reordering_threshold) {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  if (max_reordering_threshold < 0) {
-    return -1;
-  } else if (method == kNackRtcp) {
-    max_reordering_threshold_ = max_reordering_threshold;
-  } else {
-    max_reordering_threshold_ = kDefaultMaxReorderingThreshold;
-  }
-  nack_method_ = method;
-  return 0;
-}
-
-void RTPReceiver::SetRTXStatus(bool enable, uint32_t ssrc) {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  rtx_ = enable;
-  ssrc_rtx_ = ssrc;
-}
-
-void RTPReceiver::RTXStatus(bool* enable, uint32_t* ssrc,
-                            int* payload_type) const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  *enable = rtx_;
-  *ssrc = ssrc_rtx_;
-  *payload_type = payload_type_rtx_;
-}
-
-void RTPReceiver::SetRtxPayloadType(int payload_type) {
-  CriticalSectionScoped cs(critical_section_rtp_receiver_);
-  payload_type_rtx_ = payload_type;
-}
-
-uint32_t RTPReceiver::SSRC() const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  return ssrc_;
-}
-
-// Get remote CSRC.
-int32_t RTPReceiver::CSRCs(
-    uint32_t array_of_csrcs[kRtpCsrcSize]) const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-
-  assert(num_csrcs_ <= kRtpCsrcSize);
-
-  if (num_csrcs_ > 0) {
-    memcpy(array_of_csrcs, current_remote_csrc_,
-           sizeof(uint32_t)*num_csrcs_);
-  }
-  return num_csrcs_;
-}
-
-int32_t RTPReceiver::Energy(
-    uint8_t array_of_energy[kRtpCsrcSize]) const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-
-  assert(num_energy_ <= kRtpCsrcSize);
-
-  if (num_energy_ > 0) {
-    memcpy(array_of_energy, current_remote_energy_,
-           sizeof(uint8_t)*num_csrcs_);
-  }
-  return num_energy_;
-}
-
-int32_t RTPReceiver::IncomingRTPPacket(
-  RTPHeader* rtp_header,
-  const uint8_t* packet,
-  const uint16_t packet_length) {
-  TRACE_EVENT0("webrtc_rtp", "RTPRecv::Packet");
-  // The rtp_header argument contains the parsed RTP header.
-  int length = packet_length - rtp_header->paddingLength;
-
-  // Sanity check.
-  if ((length - rtp_header->headerLength) < 0) {
-    WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_,
-                 "%s invalid argument",
-                 __FUNCTION__);
-    return -1;
-  }
-  if (rtx_) {
-    if (ssrc_rtx_ == rtp_header->ssrc) {
-      // Sanity check, RTX packets has 2 extra header bytes.
-      if (rtp_header->headerLength + kRtxHeaderSize > packet_length) {
-        return -1;
-      }
-      // If a specific RTX payload type is negotiated, set back to the media
-      // payload type and treat it like a media packet from here.
-      if (payload_type_rtx_ != -1) {
-        if (payload_type_rtx_ == rtp_header->payloadType &&
-            rtp_payload_registry_->last_received_media_payload_type() != -1) {
-          rtp_header->payloadType =
-              rtp_payload_registry_->last_received_media_payload_type();
-        } else {
-          WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, id_,
-                       "Incorrect RTX configuration, dropping packet.");
-          return -1;
-        }
-      }
-      rtp_header->ssrc = ssrc_;
-      rtp_header->sequenceNumber =
-        (packet[rtp_header->headerLength] << 8) +
-        packet[1 + rtp_header->headerLength];
-      // Count the RTX header as part of the RTP
-      rtp_header->headerLength += 2;
-    }
-  }
-  if (use_ssrc_filter_) {
-    if (rtp_header->ssrc != ssrc_filter_) {
-      WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, id_,
-                   "%s drop packet due to SSRC filter",
-                   __FUNCTION__);
-      return -1;
-    }
-  }
-  if (last_receive_time_ == 0) {
-    // Trigger only once.
-    if (length - rtp_header->headerLength == 0) {
-      // Keep-alive packet.
-      cb_rtp_feedback_->OnReceivedPacket(id_, kPacketKeepAlive);
-    } else {
-      cb_rtp_feedback_->OnReceivedPacket(id_, kPacketRtp);
-    }
-  }
-  int8_t first_payload_byte = 0;
-  if (length > 0) {
-    first_payload_byte = packet[rtp_header->headerLength];
-  }
-  // Trigger our callbacks.
-  CheckSSRCChanged(rtp_header);
-
-  bool is_red = false;
-  ModuleRTPUtility::PayloadUnion specific_payload = {};
-
-  if (CheckPayloadChanged(rtp_header,
-                          first_payload_byte,
-                          is_red,
-                          &specific_payload) == -1) {
-    if (length - rtp_header->headerLength == 0) {
-      // OK, keep-alive packet.
-      WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, id_,
-                   "%s received keepalive",
-                   __FUNCTION__);
-      return 0;
-    }
-    WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, id_,
-                 "%s received invalid payloadtype",
-                 __FUNCTION__);
-    return -1;
-  }
-  WebRtcRTPHeader webrtc_rtp_header;
-  memset(&webrtc_rtp_header, 0, sizeof(webrtc_rtp_header));
-  webrtc_rtp_header.header = *rtp_header;
-  CheckCSRC(&webrtc_rtp_header);
-
-  uint16_t payload_data_length =
-    ModuleRTPUtility::GetPayloadDataLength(*rtp_header, packet_length);
-
-  bool is_first_packet_in_frame =
-      SequenceNumber() + 1 == rtp_header->sequenceNumber &&
-      TimeStamp() != rtp_header->timestamp;
-  bool is_first_packet = is_first_packet_in_frame || HaveNotReceivedPackets();
-
-  int32_t ret_val = rtp_media_receiver_->ParseRtpPacket(
-      &webrtc_rtp_header, specific_payload, is_red, packet, packet_length,
-      clock_->TimeInMilliseconds(), is_first_packet);
-
-  if (ret_val < 0) {
-    return ret_val;
-  }
-
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-
-  // This compares to received_seq_max_. We store the last received after we
-  // have done the callback.
-  bool old_packet = RetransmitOfOldPacket(rtp_header->sequenceNumber,
-                                          rtp_header->timestamp);
-
-  // This updates received_seq_max_ and other members.
-  UpdateStatistics(rtp_header, payload_data_length, old_packet);
-
-  // Need to be updated after RetransmitOfOldPacket and
-  // RetransmitOfOldPacketUpdateStatistics.
-  last_receive_time_ = clock_->TimeInMilliseconds();
-  last_received_payload_length_ = payload_data_length;
-
-  if (!old_packet) {
-    if (last_received_timestamp_ != rtp_header->timestamp) {
-      last_received_timestamp_ = rtp_header->timestamp;
-      last_received_frame_time_ms_ = clock_->TimeInMilliseconds();
-    }
-    last_received_sequence_number_ = rtp_header->sequenceNumber;
-    last_received_transmission_time_offset_ =
-      rtp_header->extension.transmissionTimeOffset;
-  }
-  return ret_val;
-}
-
-// Implementation note: we expect to have the critical_section_rtp_receiver_
-// critsect when we call this.
-void RTPReceiver::UpdateStatistics(const RTPHeader* rtp_header,
-                                   const uint16_t bytes,
-                                   const bool old_packet) {
-  uint32_t frequency_hz = rtp_media_receiver_->GetFrequencyHz();
-
-  Bitrate::Update(bytes);
-
-  received_byte_count_ += bytes;
-
-  if (received_seq_max_ == 0 && received_seq_wraps_ == 0) {
-    // This is the first received report.
-    received_seq_first_ = rtp_header->sequenceNumber;
-    received_seq_max_ = rtp_header->sequenceNumber;
-    received_inorder_packet_count_ = 1;
-    local_time_last_received_timestamp_ =
-      GetCurrentRTP(clock_, frequency_hz);  // Time in samples.
-    return;
-  }
-
-  // Count only the new packets received.
-  if (InOrderPacket(rtp_header->sequenceNumber)) {
-    const uint32_t RTPtime =
-      GetCurrentRTP(clock_, frequency_hz);  // Time in samples.
-    received_inorder_packet_count_++;
-
-    // Wrong if we use RetransmitOfOldPacket.
-    int32_t seq_diff =
-        rtp_header->sequenceNumber - received_seq_max_;
-    if (seq_diff < 0) {
-      // Wrap around detected.
-      received_seq_wraps_++;
-    }
-    // new max
-    received_seq_max_ = rtp_header->sequenceNumber;
-
-    if (rtp_header->timestamp != last_received_timestamp_ &&
-        received_inorder_packet_count_ > 1) {
-      int32_t time_diff_samples =
-          (RTPtime - local_time_last_received_timestamp_) -
-          (rtp_header->timestamp - last_received_timestamp_);
-
-      time_diff_samples = abs(time_diff_samples);
-
-      // lib_jingle sometimes deliver crazy jumps in TS for the same stream.
-      // If this happens, don't update jitter value. Use 5 secs video frequency
-      // as the treshold.
-      if (time_diff_samples < 450000) {
-        // Note we calculate in Q4 to avoid using float.
-        int32_t jitter_diff_q4 = (time_diff_samples << 4) - jitter_q4_;
-        jitter_q4_ += ((jitter_diff_q4 + 8) >> 4);
-      }
-
-      // Extended jitter report, RFC 5450.
-      // Actual network jitter, excluding the source-introduced jitter.
-      int32_t time_diff_samples_ext =
-        (RTPtime - local_time_last_received_timestamp_) -
-        ((rtp_header->timestamp +
-          rtp_header->extension.transmissionTimeOffset) -
-         (last_received_timestamp_ +
-          last_received_transmission_time_offset_));
-
-      time_diff_samples_ext = abs(time_diff_samples_ext);
-
-      if (time_diff_samples_ext < 450000) {
-        int32_t jitter_diffQ4TransmissionTimeOffset =
-          (time_diff_samples_ext << 4) - jitter_q4_transmission_time_offset_;
-        jitter_q4_transmission_time_offset_ +=
-          ((jitter_diffQ4TransmissionTimeOffset + 8) >> 4);
-      }
-    }
-    local_time_last_received_timestamp_ = RTPtime;
-  } else {
-    if (old_packet) {
-      received_old_packet_count_++;
-    } else {
-      received_inorder_packet_count_++;
-    }
-  }
-
-  uint16_t packet_oh =
-      rtp_header->headerLength + rtp_header->paddingLength;
-
-  // Our measured overhead. Filter from RFC 5104 4.2.1.2:
-  // avg_OH (new) = 15/16*avg_OH (old) + 1/16*pckt_OH,
-  received_packet_oh_ = (15 * received_packet_oh_ + packet_oh) >> 4;
-}
-
-// Implementation note: we expect to have the critical_section_rtp_receiver_
-// critsect when we call this.
-bool RTPReceiver::RetransmitOfOldPacket(
-    const uint16_t sequence_number,
-    const uint32_t rtp_time_stamp) const {
-  if (InOrderPacket(sequence_number)) {
-    return false;
-  }
-
-  uint32_t frequency_khz = rtp_media_receiver_->GetFrequencyHz() / 1000;
-  int64_t time_diff_ms = clock_->TimeInMilliseconds() -
-      last_receive_time_;
-
-  // Diff in time stamp since last received in order.
-  int32_t rtp_time_stamp_diff_ms =
-      static_cast<int32_t>(rtp_time_stamp - last_received_timestamp_) /
-      frequency_khz;
-
-  uint16_t min_rtt = 0;
-  int32_t max_delay_ms = 0;
-  rtp_rtcp_.RTT(ssrc_, NULL, NULL, &min_rtt, NULL);
-  if (min_rtt == 0) {
-    // Jitter variance in samples.
-    float jitter = jitter_q4_ >> 4;
-
-    // Jitter standard deviation in samples.
-    float jitter_std = sqrt(jitter);
-
-    // 2 times the standard deviation => 95% confidence.
-    // And transform to milliseconds by dividing by the frequency in kHz.
-    max_delay_ms = static_cast<int32_t>((2 * jitter_std) / frequency_khz);
-
-    // Min max_delay_ms is 1.
-    if (max_delay_ms == 0) {
-      max_delay_ms = 1;
-    }
-  } else {
-    max_delay_ms = (min_rtt / 3) + 1;
-  }
-  if (time_diff_ms > rtp_time_stamp_diff_ms + max_delay_ms) {
-    return true;
-  }
-  return false;
-}
-
-bool RTPReceiver::InOrderPacket(const uint16_t sequence_number) const {
-  if (IsNewerSequenceNumber(sequence_number, received_seq_max_)) {
-    return true;
-  } else {
-    // If we have a restart of the remote side this packet is still in order.
-    return !IsNewerSequenceNumber(sequence_number, received_seq_max_ -
-                                  max_reordering_threshold_);
-  }
-}
-
-uint16_t RTPReceiver::SequenceNumber() const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  return last_received_sequence_number_;
-}
-
-uint32_t RTPReceiver::TimeStamp() const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  return last_received_timestamp_;
-}
-
-int32_t RTPReceiver::LastReceivedTimeMs() const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  return last_received_frame_time_ms_;
-}
-
-// Compute time stamp of the last incoming packet that is the first packet of
-// its frame.
-int32_t RTPReceiver::EstimatedRemoteTimeStamp(
-    uint32_t& timestamp) const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  uint32_t frequency_hz = rtp_media_receiver_->GetFrequencyHz();
-
-  if (local_time_last_received_timestamp_ == 0) {
-    WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, id_,
-                 "%s invalid state", __FUNCTION__);
-    return -1;
-  }
-  // Time in samples.
-  uint32_t diff = GetCurrentRTP(clock_, frequency_hz) -
-                        local_time_last_received_timestamp_;
-
-  timestamp = last_received_timestamp_ + diff;
-  return 0;
-}
-
-// Get the currently configured SSRC filter.
-int32_t RTPReceiver::SSRCFilter(uint32_t& allowed_ssrc) const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-  if (use_ssrc_filter_) {
-    allowed_ssrc = ssrc_filter_;
-    return 0;
-  }
-  WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, id_,
-               "%s invalid state", __FUNCTION__);
-  return -1;
-}
-
-// Set a SSRC to be used as a filter for incoming RTP streams.
-int32_t RTPReceiver::SetSSRCFilter(
-    const bool enable, const uint32_t allowed_ssrc) {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-
-  use_ssrc_filter_ = enable;
-  if (enable) {
-    ssrc_filter_ = allowed_ssrc;
-  } else {
-    ssrc_filter_ = 0;
-  }
-  return 0;
-}
-
-// Implementation note: must not hold critsect when called.
-void RTPReceiver::CheckSSRCChanged(const RTPHeader* rtp_header) {
-  bool new_ssrc = false;
-  bool re_initialize_decoder = false;
-  char payload_name[RTP_PAYLOAD_NAME_SIZE];
-  uint32_t frequency = kDefaultVideoFrequency;
-  uint8_t channels = 1;
-  uint32_t rate = 0;
-
-  {
-    CriticalSectionScoped lock(critical_section_rtp_receiver_);
-
-    int8_t last_received_payload_type =
-        rtp_payload_registry_->last_received_payload_type();
-    if (ssrc_ != rtp_header->ssrc ||
-        (last_received_payload_type == -1 && ssrc_ == 0)) {
-      // We need the payload_type_ to make the call if the remote SSRC is 0.
-      new_ssrc = true;
-
-      ResetStatistics();
-
-      last_received_timestamp_      = 0;
-      last_received_sequence_number_ = 0;
-      last_received_transmission_time_offset_ = 0;
-      last_received_frame_time_ms_ = 0;
-
-      // Do we have a SSRC? Then the stream is restarted.
-      if (ssrc_) {
-        // Do we have the same codec? Then re-initialize coder.
-        if (rtp_header->payloadType == last_received_payload_type) {
-          re_initialize_decoder = true;
-
-          Payload* payload;
-          if (rtp_payload_registry_->PayloadTypeToPayload(
-              rtp_header->payloadType, payload) != 0) {
-            return;
-          }
-          assert(payload);
-          payload_name[RTP_PAYLOAD_NAME_SIZE - 1] = 0;
-          strncpy(payload_name, payload->name, RTP_PAYLOAD_NAME_SIZE - 1);
-          if (payload->audio) {
-            frequency = payload->typeSpecific.Audio.frequency;
-            channels = payload->typeSpecific.Audio.channels;
-            rate = payload->typeSpecific.Audio.rate;
-          } else {
-            frequency = kDefaultVideoFrequency;
-          }
-        }
-      }
-      ssrc_ = rtp_header->ssrc;
-    }
-  }
-  if (new_ssrc) {
-    // We need to get this to our RTCP sender and receiver.
-    // We need to do this outside critical section.
-    rtp_rtcp_.SetRemoteSSRC(rtp_header->ssrc);
-    cb_rtp_feedback_->OnIncomingSSRCChanged(id_, rtp_header->ssrc);
-  }
-  if (re_initialize_decoder) {
-    if (-1 == cb_rtp_feedback_->OnInitializeDecoder(
-        id_, rtp_header->payloadType, payload_name, frequency,
-        channels, rate)) {
-      // New stream, same codec.
-      WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_,
-                   "Failed to create decoder for payload type:%d",
-                   rtp_header->payloadType);
-    }
-  }
-}
-
-// Implementation note: must not hold critsect when called.
-// TODO(phoglund): Move as much as possible of this code path into the media
-// specific receivers. Basically this method goes through a lot of trouble to
-// compute something which is only used by the media specific parts later. If
-// this code path moves we can get rid of some of the rtp_receiver ->
-// media_specific interface (such as CheckPayloadChange, possibly get/set
-// last known payload).
-int32_t RTPReceiver::CheckPayloadChanged(
-  const RTPHeader* rtp_header,
-  const int8_t first_payload_byte,
-  bool& is_red,
-  ModuleRTPUtility::PayloadUnion* specific_payload) {
-  bool re_initialize_decoder = false;
-
-  char payload_name[RTP_PAYLOAD_NAME_SIZE];
-  int8_t payload_type = rtp_header->payloadType;
-
-  {
-    CriticalSectionScoped lock(critical_section_rtp_receiver_);
-
-    int8_t last_received_payload_type =
-        rtp_payload_registry_->last_received_payload_type();
-    if (payload_type != last_received_payload_type) {
-      if (REDPayloadType(payload_type)) {
-        // Get the real codec payload type.
-        payload_type = first_payload_byte & 0x7f;
-        is_red = true;
-
-        if (REDPayloadType(payload_type)) {
-          // Invalid payload type, traced by caller. If we proceeded here,
-          // this would be set as |_last_received_payload_type|, and we would no
-          // longer catch corrupt packets at this level.
-          return -1;
-        }
-
-        // When we receive RED we need to check the real payload type.
-        if (payload_type == last_received_payload_type) {
-          rtp_media_receiver_->GetLastMediaSpecificPayload(specific_payload);
-          return 0;
-        }
-      }
-      bool should_reset_statistics = false;
-      bool should_discard_changes = false;
-
-      rtp_media_receiver_->CheckPayloadChanged(
-        payload_type, specific_payload, &should_reset_statistics,
-        &should_discard_changes);
-
-      if (should_reset_statistics) {
-        ResetStatistics();
-      }
-      if (should_discard_changes) {
-        is_red = false;
-        return 0;
-      }
-
-      Payload* payload;
-      if (rtp_payload_registry_->PayloadTypeToPayload(payload_type,
-                                                      payload) != 0) {
-        // Not a registered payload type.
-        return -1;
-      }
-      assert(payload);
-      payload_name[RTP_PAYLOAD_NAME_SIZE - 1] = 0;
-      strncpy(payload_name, payload->name, RTP_PAYLOAD_NAME_SIZE - 1);
-
-      rtp_payload_registry_->set_last_received_payload_type(payload_type);
-
-      re_initialize_decoder = true;
-
-      rtp_media_receiver_->SetLastMediaSpecificPayload(payload->typeSpecific);
-      rtp_media_receiver_->GetLastMediaSpecificPayload(specific_payload);
-
-      if (!payload->audio) {
-        if (VideoCodecType() == kRtpFecVideo) {
-          // Only reset the decoder on media packets.
-          re_initialize_decoder = false;
-        } else {
-          bool media_type_unchanged =
-              rtp_payload_registry_->ReportMediaPayloadType(payload_type);
-          if (media_type_unchanged) {
-            // Only reset the decoder if the media codec type has changed.
-            re_initialize_decoder = false;
-          }
-        }
-      }
-      if (re_initialize_decoder) {
-        ResetStatistics();
-      }
-    } else {
-      rtp_media_receiver_->GetLastMediaSpecificPayload(specific_payload);
-      is_red = false;
-    }
-  }  // End critsect.
-
-  if (re_initialize_decoder) {
-    if (-1 == rtp_media_receiver_->InvokeOnInitializeDecoder(
-        cb_rtp_feedback_, id_, payload_type, payload_name,
-        *specific_payload)) {
-      return -1;  // Wrong payload type.
-    }
-  }
-  return 0;
-}
-
-// Implementation note: must not hold critsect when called.
-void RTPReceiver::CheckCSRC(const WebRtcRTPHeader* rtp_header) {
-  int32_t num_csrcs_diff = 0;
-  uint32_t old_remote_csrc[kRtpCsrcSize];
-  uint8_t old_num_csrcs = 0;
-
-  {
-    CriticalSectionScoped lock(critical_section_rtp_receiver_);
-
-    if (!rtp_media_receiver_->ShouldReportCsrcChanges(
-        rtp_header->header.payloadType)) {
-      return;
-    }
-    num_energy_ = rtp_header->type.Audio.numEnergy;
-    if (rtp_header->type.Audio.numEnergy > 0 &&
-        rtp_header->type.Audio.numEnergy <= kRtpCsrcSize) {
-      memcpy(current_remote_energy_,
-             rtp_header->type.Audio.arrOfEnergy,
-             rtp_header->type.Audio.numEnergy);
-    }
-    old_num_csrcs  = num_csrcs_;
-    if (old_num_csrcs > 0) {
-      // Make a copy of old.
-      memcpy(old_remote_csrc, current_remote_csrc_,
-             num_csrcs_ * sizeof(uint32_t));
-    }
-    const uint8_t num_csrcs = rtp_header->header.numCSRCs;
-    if ((num_csrcs > 0) && (num_csrcs <= kRtpCsrcSize)) {
-      // Copy new.
-      memcpy(current_remote_csrc_,
-             rtp_header->header.arrOfCSRCs,
-             num_csrcs * sizeof(uint32_t));
-    }
-    if (num_csrcs > 0 || old_num_csrcs > 0) {
-      num_csrcs_diff = num_csrcs - old_num_csrcs;
-      num_csrcs_ = num_csrcs;  // Update stored CSRCs.
-    } else {
-      // No change.
-      return;
-    }
-  }  // End critsect.
-
-  bool have_called_callback = false;
-  // Search for new CSRC in old array.
-  for (uint8_t i = 0; i < rtp_header->header.numCSRCs; ++i) {
-    const uint32_t csrc = rtp_header->header.arrOfCSRCs[i];
-
-    bool found_match = false;
-    for (uint8_t j = 0; j < old_num_csrcs; ++j) {
-      if (csrc == old_remote_csrc[j]) {  // old list
-        found_match = true;
-        break;
-      }
-    }
-    if (!found_match && csrc) {
-      // Didn't find it, report it as new.
-      have_called_callback = true;
-      cb_rtp_feedback_->OnIncomingCSRCChanged(id_, csrc, true);
-    }
-  }
-  // Search for old CSRC in new array.
-  for (uint8_t i = 0; i < old_num_csrcs; ++i) {
-    const uint32_t csrc = old_remote_csrc[i];
-
-    bool found_match = false;
-    for (uint8_t j = 0; j < rtp_header->header.numCSRCs; ++j) {
-      if (csrc == rtp_header->header.arrOfCSRCs[j]) {
-        found_match = true;
-        break;
-      }
-    }
-    if (!found_match && csrc) {
-      // Did not find it, report as removed.
-      have_called_callback = true;
-      cb_rtp_feedback_->OnIncomingCSRCChanged(id_, csrc, false);
-    }
-  }
-  if (!have_called_callback) {
-    // If the CSRC list contain non-unique entries we will end up here.
-    // Using CSRC 0 to signal this event, not interop safe, other
-    // implementations might have CSRC 0 as a valid value.
-    if (num_csrcs_diff > 0) {
-      cb_rtp_feedback_->OnIncomingCSRCChanged(id_, 0, true);
-    } else if (num_csrcs_diff < 0) {
-      cb_rtp_feedback_->OnIncomingCSRCChanged(id_, 0, false);
-    }
-  }
-}
-
-int32_t RTPReceiver::ResetStatistics() {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-
-  last_report_inorder_packets_ = 0;
-  last_report_old_packets_ = 0;
-  last_report_seq_max_ = 0;
-  last_report_fraction_lost_ = 0;
-  last_report_cumulative_lost_ = 0;
-  last_report_extended_high_seq_num_ = 0;
-  last_report_jitter_ = 0;
-  last_report_jitter_transmission_time_offset_ = 0;
-  jitter_q4_ = 0;
-  jitter_max_q4_ = 0;
-  cumulative_loss_ = 0;
-  jitter_q4_transmission_time_offset_ = 0;
-  received_seq_wraps_ = 0;
-  received_seq_max_ = 0;
-  received_seq_first_ = 0;
-  received_byte_count_ = 0;
-  received_old_packet_count_ = 0;
-  received_inorder_packet_count_ = 0;
-  return 0;
-}
-
-int32_t RTPReceiver::ResetDataCounters() {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-
-  received_byte_count_ = 0;
-  received_old_packet_count_ = 0;
-  received_inorder_packet_count_ = 0;
-  last_report_inorder_packets_ = 0;
-
-  return 0;
-}
-
-int32_t RTPReceiver::Statistics(
-    uint8_t*  fraction_lost,
-    uint32_t* cum_lost,
-    uint32_t* ext_max,
-    uint32_t* jitter,
-    uint32_t* max_jitter,
-    uint32_t* jitter_transmission_time_offset,
-    bool reset) const {
-  int32_t missing;
-  return Statistics(fraction_lost,
-                    cum_lost,
-                    ext_max,
-                    jitter,
-                    max_jitter,
-                    jitter_transmission_time_offset,
-                    &missing,
-                    reset);
-}
-
-int32_t RTPReceiver::Statistics(
-    uint8_t*  fraction_lost,
-    uint32_t* cum_lost,
-    uint32_t* ext_max,
-    uint32_t* jitter,
-    uint32_t* max_jitter,
-    uint32_t* jitter_transmission_time_offset,
-    int32_t*  missing,
-    bool reset) const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-
-  if (missing == NULL) {
-    return -1;
-  }
-  if (received_seq_first_ == 0 && received_byte_count_ == 0) {
-    // We have not received anything. -1 required by RTCP sender.
-    return -1;
-  }
-  if (!reset) {
-    if (last_report_inorder_packets_ == 0) {
-      // No report.
-      return -1;
-    }
-    // Just get last report.
-    if (fraction_lost) {
-      *fraction_lost = last_report_fraction_lost_;
-    }
-    if (cum_lost) {
-      *cum_lost = last_report_cumulative_lost_;  // 24 bits valid.
-    }
-    if (ext_max) {
-      *ext_max = last_report_extended_high_seq_num_;
-    }
-    if (jitter) {
-      *jitter = last_report_jitter_;
-    }
-    if (max_jitter) {
-      // Note: internal jitter value is in Q4 and needs to be scaled by 1/16.
-      *max_jitter = (jitter_max_q4_ >> 4);
-    }
-    if (jitter_transmission_time_offset) {
-      *jitter_transmission_time_offset =
-        last_report_jitter_transmission_time_offset_;
-    }
-    return 0;
-  }
-
-  if (last_report_inorder_packets_ == 0) {
-    // First time we send a report.
-    last_report_seq_max_ = received_seq_first_ - 1;
-  }
-  // Calculate fraction lost.
-  uint16_t exp_since_last = (received_seq_max_ - last_report_seq_max_);
-
-  if (last_report_seq_max_ > received_seq_max_) {
-    // Can we assume that the seq_num can't go decrease over a full RTCP period?
-    exp_since_last = 0;
-  }
-
-  // Number of received RTP packets since last report, counts all packets but
-  // not re-transmissions.
-  uint32_t rec_since_last =
-      received_inorder_packet_count_ - last_report_inorder_packets_;
-
-  if (nack_method_ == kNackOff) {
-    // This is needed for re-ordered packets.
-    uint32_t old_packets =
-        received_old_packet_count_ - last_report_old_packets_;
-    rec_since_last += old_packets;
-  } else {
-    // With NACK we don't know the expected retransmitions during the last
-    // second. We know how many "old" packets we have received. We just count
-    // the number of old received to estimate the loss, but it still does not
-    // guarantee an exact number since we run this based on time triggered by
-    // sending of a RTP packet. This should have a minimum effect.
-
-    // With NACK we don't count old packets as received since they are
-    // re-transmitted. We use RTT to decide if a packet is re-ordered or
-    // re-transmitted.
-  }
-
-  *missing = 0;
-  if (exp_since_last > rec_since_last) {
-    *missing = (exp_since_last - rec_since_last);
-  }
-  uint8_t local_fraction_lost = 0;
-  if (exp_since_last) {
-    // Scale 0 to 255, where 255 is 100% loss.
-    local_fraction_lost = (uint8_t)((255 * (*missing)) / exp_since_last);
-  }
-  if (fraction_lost) {
-    *fraction_lost = local_fraction_lost;
-  }
-
-  // We need a counter for cumulative loss too.
-  cumulative_loss_ += *missing;
-
-  if (jitter_q4_ > jitter_max_q4_) {
-    jitter_max_q4_ = jitter_q4_;
-  }
-  if (cum_lost) {
-    *cum_lost =  cumulative_loss_;
-  }
-  if (ext_max) {
-    *ext_max = (received_seq_wraps_ << 16) + received_seq_max_;
-  }
-  // Note: internal jitter value is in Q4 and needs to be scaled by 1/16.
-  if (jitter) {
-    *jitter = (jitter_q4_ >> 4);
-  }
-  if (max_jitter) {
-    *max_jitter = (jitter_max_q4_ >> 4);
-  }
-  if (jitter_transmission_time_offset) {
-    *jitter_transmission_time_offset =
-      (jitter_q4_transmission_time_offset_ >> 4);
-  }
-  if (reset) {
-    // Store this report.
-    last_report_fraction_lost_ = local_fraction_lost;
-    last_report_cumulative_lost_ = cumulative_loss_;  // 24 bits valid.
-    last_report_extended_high_seq_num_ =
-        (received_seq_wraps_ << 16) + received_seq_max_;
-    last_report_jitter_  = (jitter_q4_ >> 4);
-    last_report_jitter_transmission_time_offset_ =
-      (jitter_q4_transmission_time_offset_ >> 4);
-
-    // Only for report blocks in RTCP SR and RR.
-    last_report_inorder_packets_ = received_inorder_packet_count_;
-    last_report_old_packets_ = received_old_packet_count_;
-    last_report_seq_max_ = received_seq_max_;
-  }
-  return 0;
-}
-
-int32_t RTPReceiver::DataCounters(
-    uint32_t* bytes_received,
-    uint32_t* packets_received) const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_);
-
-  if (bytes_received) {
-    *bytes_received = received_byte_count_;
-  }
-  if (packets_received) {
-    *packets_received =
-        received_old_packet_count_ + received_inorder_packet_count_;
-  }
-  return 0;
-}
-
-void RTPReceiver::ProcessBitrate() {
-  CriticalSectionScoped cs(critical_section_rtp_receiver_);
-
-  Bitrate::Process();
-  TRACE_COUNTER_ID1("webrtc_rtp",
-                    "RTPReceiverBitrate", ssrc_, BitrateLast());
-  TRACE_COUNTER_ID1("webrtc_rtp",
-                    "RTPReceiverPacketRate", ssrc_, PacketRate());
-}
-
-}  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_receiver.h b/modules/rtp_rtcp/source/rtp_receiver.h
deleted file mode 100644
index ce7e0a2..0000000
--- a/modules/rtp_rtcp/source/rtp_receiver.h
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- *  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.
- */
-
-#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_RECEIVER_H_
-#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_RECEIVER_H_
-
-#include <map>
-
-#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
-#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
-#include "webrtc/modules/rtp_rtcp/source/bitrate.h"
-#include "webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_payload_registry.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
-#include "webrtc/system_wrappers/interface/scoped_ptr.h"
-#include "webrtc/typedefs.h"
-
-namespace webrtc {
-
-class RtpRtcpFeedback;
-class ModuleRtpRtcpImpl;
-class Trace;
-class RTPReceiverAudio;
-class RTPReceiverVideo;
-class RTPReceiverStrategy;
-
-class RTPReceiver : public Bitrate {
- public:
-  // Callbacks passed in here may not be NULL (use Null Object callbacks if you
-  // want callbacks to do nothing). This class takes ownership of the media
-  // receiver but nothing else.
-  RTPReceiver(const int32_t id,
-              Clock* clock,
-              ModuleRtpRtcpImpl* owner,
-              RtpAudioFeedback* incoming_audio_messages_callback,
-              RtpData* incoming_payload_callback,
-              RtpFeedback* incoming_messages_callback,
-              RTPReceiverStrategy* rtp_media_receiver,
-              RTPPayloadRegistry* rtp_payload_registry);
-
-  virtual ~RTPReceiver();
-
-  RtpVideoCodecTypes VideoCodecType() const;
-  uint32_t MaxConfiguredBitrate() const;
-
-  int32_t SetPacketTimeout(const uint32_t timeout_ms);
-  void PacketTimeout();
-
-  void ProcessDeadOrAlive(const bool RTCPalive, const int64_t now);
-
-  void ProcessBitrate();
-
-  int32_t RegisterReceivePayload(
-      const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-      const int8_t payload_type,
-      const uint32_t frequency,
-      const uint8_t channels,
-      const uint32_t rate);
-
-  int32_t DeRegisterReceivePayload(const int8_t payload_type);
-
-  int32_t ReceivePayloadType(
-      const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-      const uint32_t frequency,
-      const uint8_t channels,
-      const uint32_t rate,
-      int8_t* payload_type) const;
-
-  int32_t IncomingRTPPacket(
-      RTPHeader* rtpheader,
-      const uint8_t* incoming_rtp_packet,
-      const uint16_t incoming_rtp_packet_length);
-
-  NACKMethod NACK() const ;
-
-  // Turn negative acknowledgement requests on/off.
-  int32_t SetNACKStatus(const NACKMethod method, int max_reordering_threshold);
-
-  // Returns the last received timestamp.
-  virtual uint32_t TimeStamp() const;
-  int32_t LastReceivedTimeMs() const;
-  virtual uint16_t SequenceNumber() const;
-
-  int32_t EstimatedRemoteTimeStamp(uint32_t& timestamp) const;
-
-  uint32_t SSRC() const;
-
-  int32_t CSRCs(uint32_t array_of_csrc[kRtpCsrcSize]) const;
-
-  int32_t Energy(uint8_t array_of_energy[kRtpCsrcSize]) const;
-
-  // Get the currently configured SSRC filter.
-  int32_t SSRCFilter(uint32_t& allowed_ssrc) const;
-
-  // Set a SSRC to be used as a filter for incoming RTP streams.
-  int32_t SetSSRCFilter(const bool enable, const uint32_t allowed_ssrc);
-
-  int32_t Statistics(uint8_t*  fraction_lost,
-                     uint32_t* cum_lost,
-                     uint32_t* ext_max,
-                     uint32_t* jitter,  // Will be moved from JB.
-                     uint32_t* max_jitter,
-                     uint32_t* jitter_transmission_time_offset,
-                     bool reset) const;
-
-  int32_t Statistics(uint8_t*  fraction_lost,
-                     uint32_t* cum_lost,
-                     uint32_t* ext_max,
-                     uint32_t* jitter,  // Will be moved from JB.
-                     uint32_t* max_jitter,
-                     uint32_t* jitter_transmission_time_offset,
-                     int32_t* missing,
-                     bool reset) const;
-
-  int32_t DataCounters(uint32_t* bytes_received,
-                       uint32_t* packets_received) const;
-
-  int32_t ResetStatistics();
-
-  int32_t ResetDataCounters();
-
-  uint16_t PacketOHReceived() const;
-
-  uint32_t PacketCountReceived() const;
-
-  uint32_t ByteCountReceived() const;
-
-  int32_t RegisterRtpHeaderExtension(const RTPExtensionType type,
-                                     const uint8_t id);
-
-  int32_t DeregisterRtpHeaderExtension(const RTPExtensionType type);
-
-  void GetHeaderExtensionMapCopy(RtpHeaderExtensionMap* map) const;
-
-  // RTX.
-  void SetRTXStatus(bool enable, uint32_t ssrc);
-
-  void RTXStatus(bool* enable, uint32_t* ssrc, int* payload_type) const;
-
-  void SetRtxPayloadType(int payload_type);
-
-  virtual int8_t REDPayloadType() const;
-
-  bool HaveNotReceivedPackets() const;
-
-  virtual bool RetransmitOfOldPacket(const uint16_t sequence_number,
-                                     const uint32_t rtp_time_stamp) const;
-
-  void UpdateStatistics(const RTPHeader* rtp_header,
-                        const uint16_t bytes,
-                        const bool old_packet);
-
- private:
-  // Returns whether RED is configured with payload_type.
-  bool REDPayloadType(const int8_t payload_type) const;
-
-  bool InOrderPacket(const uint16_t sequence_number) const;
-
-  void CheckSSRCChanged(const RTPHeader* rtp_header);
-  void CheckCSRC(const WebRtcRTPHeader* rtp_header);
-  int32_t CheckPayloadChanged(const RTPHeader* rtp_header,
-                              const int8_t first_payload_byte,
-                              bool& isRED,
-                              ModuleRTPUtility::PayloadUnion* payload);
-
-  void UpdateNACKBitRate(int32_t bytes, uint32_t now);
-  bool ProcessNACKBitRate(uint32_t now);
-
-  RTPPayloadRegistry*             rtp_payload_registry_;
-  scoped_ptr<RTPReceiverStrategy> rtp_media_receiver_;
-
-  int32_t           id_;
-  ModuleRtpRtcpImpl&      rtp_rtcp_;
-
-  RtpFeedback*            cb_rtp_feedback_;
-
-  CriticalSectionWrapper* critical_section_rtp_receiver_;
-  mutable int64_t   last_receive_time_;
-  uint16_t          last_received_payload_length_;
-
-  uint32_t          packet_timeout_ms_;
-
-  // SSRCs.
-  uint32_t            ssrc_;
-  uint8_t             num_csrcs_;
-  uint32_t            current_remote_csrc_[kRtpCsrcSize];
-  uint8_t             num_energy_;
-  uint8_t             current_remote_energy_[kRtpCsrcSize];
-
-  bool                      use_ssrc_filter_;
-  uint32_t            ssrc_filter_;
-
-  // Stats on received RTP packets.
-  uint32_t            jitter_q4_;
-  mutable uint32_t    jitter_max_q4_;
-  mutable uint32_t    cumulative_loss_;
-  uint32_t            jitter_q4_transmission_time_offset_;
-
-  uint32_t            local_time_last_received_timestamp_;
-  int64_t                   last_received_frame_time_ms_;
-  uint32_t            last_received_timestamp_;
-  uint16_t            last_received_sequence_number_;
-  int32_t             last_received_transmission_time_offset_;
-  uint16_t            received_seq_first_;
-  uint16_t            received_seq_max_;
-  uint16_t            received_seq_wraps_;
-
-  // Current counter values.
-  uint16_t            received_packet_oh_;
-  uint32_t            received_byte_count_;
-  uint32_t            received_old_packet_count_;
-  uint32_t            received_inorder_packet_count_;
-
-  // Counter values when we sent the last report.
-  mutable uint32_t    last_report_inorder_packets_;
-  mutable uint32_t    last_report_old_packets_;
-  mutable uint16_t    last_report_seq_max_;
-  mutable uint8_t     last_report_fraction_lost_;
-  mutable uint32_t    last_report_cumulative_lost_;  // 24 bits valid.
-  mutable uint32_t    last_report_extended_high_seq_num_;
-  mutable uint32_t    last_report_jitter_;
-  mutable uint32_t    last_report_jitter_transmission_time_offset_;
-
-  NACKMethod nack_method_;
-  int max_reordering_threshold_;
-
-  bool rtx_;
-  uint32_t ssrc_rtx_;
-  int payload_type_rtx_;
-};
-
-}  // namespace webrtc
-
-#endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_RECEIVER_H_
diff --git a/modules/rtp_rtcp/source/rtp_receiver_audio.cc b/modules/rtp_rtcp/source/rtp_receiver_audio.cc
index dd49ec5..fc8a748 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_audio.cc
+++ b/modules/rtp_rtcp/source/rtp_receiver_audio.cc
@@ -20,13 +20,18 @@
 #include "webrtc/system_wrappers/interface/trace_event.h"
 
 namespace webrtc {
+RTPReceiverStrategy* RTPReceiverStrategy::CreateAudioStrategy(
+    int32_t id, RtpData* data_callback,
+    RtpAudioFeedback* incoming_messages_callback) {
+  return new RTPReceiverAudio(id, data_callback, incoming_messages_callback);
+}
+
 RTPReceiverAudio::RTPReceiverAudio(const int32_t id,
                                    RtpData* data_callback,
                                    RtpAudioFeedback* incoming_messages_callback)
     : RTPReceiverStrategy(data_callback),
+      TelephoneEventHandler(),
       id_(id),
-      critical_section_rtp_receiver_audio_(
-          CriticalSectionWrapper::CreateCriticalSection()),
       last_received_frequency_(8000),
       telephone_event_forward_to_decoder_(false),
       telephone_event_payload_type_(-1),
@@ -37,42 +42,36 @@
       cng_payload_type_(-1),
       g722_payload_type_(-1),
       last_received_g722_(false),
+      num_energy_(0),
+      current_remote_energy_(),
       cb_audio_feedback_(incoming_messages_callback) {
   last_payload_.Audio.channels = 1;
-}
-
-uint32_t RTPReceiverAudio::AudioFrequency() const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_audio_.get());
-  if (last_received_g722_) {
-    return 8000;
-  }
-  return last_received_frequency_;
+  memset(current_remote_energy_, 0, sizeof(current_remote_energy_));
 }
 
 // Outband TelephoneEvent(DTMF) detection
-int RTPReceiverAudio::SetTelephoneEventForwardToDecoder(
+void RTPReceiverAudio::SetTelephoneEventForwardToDecoder(
     bool forward_to_decoder) {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_audio_.get());
+  CriticalSectionScoped lock(crit_sect_.get());
   telephone_event_forward_to_decoder_ = forward_to_decoder;
-  return 0;
 }
 
 // Is forwarding of outband telephone events turned on/off?
 bool RTPReceiverAudio::TelephoneEventForwardToDecoder() const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_audio_.get());
+  CriticalSectionScoped lock(crit_sect_.get());
   return telephone_event_forward_to_decoder_;
 }
 
 bool RTPReceiverAudio::TelephoneEventPayloadType(
-    const int8_t payload_type) const {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_audio_.get());
+    int8_t payload_type) const {
+  CriticalSectionScoped lock(crit_sect_.get());
   return (telephone_event_payload_type_ == payload_type) ? true : false;
 }
 
-bool RTPReceiverAudio::CNGPayloadType(const int8_t payload_type,
+bool RTPReceiverAudio::CNGPayloadType(int8_t payload_type,
                                       uint32_t* frequency,
                                       bool* cng_payload_type_has_changed) {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_audio_.get());
+  CriticalSectionScoped lock(crit_sect_.get());
   *cng_payload_type_has_changed = false;
 
   //  We can have four CNG on 8000Hz, 16000Hz, 32000Hz and 48000Hz.
@@ -118,8 +117,7 @@
   return false;
 }
 
-bool RTPReceiverAudio::ShouldReportCsrcChanges(
-    uint8_t payload_type) const {
+bool RTPReceiverAudio::ShouldReportCsrcChanges(uint8_t payload_type) const {
   // Don't do this for DTMF packets, otherwise it's fine.
   return !TelephoneEventPayloadType(payload_type);
 }
@@ -158,9 +156,9 @@
 // -   G7221     frame         N/A
 int32_t RTPReceiverAudio::OnNewPayloadTypeCreated(
     const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-    const int8_t payload_type,
-    const uint32_t frequency) {
-  CriticalSectionScoped lock(critical_section_rtp_receiver_audio_.get());
+    int8_t payload_type,
+    uint32_t frequency) {
+  CriticalSectionScoped lock(crit_sect_.get());
 
   if (ModuleRTPUtility::StringCompare(payload_name, "telephone-event", 15)) {
     telephone_event_payload_type_ = payload_type;
@@ -183,18 +181,24 @@
   return 0;
 }
 
-int32_t RTPReceiverAudio::ParseRtpPacket(
-    WebRtcRTPHeader* rtp_header,
-    const ModuleRTPUtility::PayloadUnion& specific_payload,
-    const bool is_red,
-    const uint8_t* packet,
-    const uint16_t packet_length,
-    const int64_t timestamp_ms,
-    const bool is_first_packet) {
+int32_t RTPReceiverAudio::ParseRtpPacket(WebRtcRTPHeader* rtp_header,
+                                         const PayloadUnion& specific_payload,
+                                         bool is_red,
+                                         const uint8_t* packet,
+                                         uint16_t packet_length,
+                                         int64_t timestamp_ms,
+                                         bool is_first_packet) {
   TRACE_EVENT2("webrtc_rtp", "Audio::ParseRtp",
                "seqnum", rtp_header->header.sequenceNumber,
                "timestamp", rtp_header->header.timestamp);
   rtp_header->type.Audio.numEnergy = rtp_header->header.numCSRCs;
+  num_energy_ = rtp_header->type.Audio.numEnergy;
+  if (rtp_header->type.Audio.numEnergy > 0 &&
+      rtp_header->type.Audio.numEnergy <= kRtpCsrcSize) {
+    memcpy(current_remote_energy_,
+           rtp_header->type.Audio.arrOfEnergy,
+           rtp_header->type.Audio.numEnergy);
+  }
   const uint8_t* payload_data =
       ModuleRTPUtility::GetPayloadData(rtp_header->header, packet);
   const uint16_t payload_data_length =
@@ -207,8 +211,12 @@
                                  is_red);
 }
 
-int32_t RTPReceiverAudio::GetFrequencyHz() const {
-  return AudioFrequency();
+int RTPReceiverAudio::GetPayloadTypeFrequency() const {
+  CriticalSectionScoped lock(crit_sect_.get());
+  if (last_received_g722_) {
+    return 8000;
+  }
+  return last_received_frequency_;
 }
 
 RTPAliveType RTPReceiverAudio::ProcessDeadOrAlive(
@@ -223,11 +231,10 @@
   }
 }
 
-void RTPReceiverAudio::CheckPayloadChanged(
-    const int8_t payload_type,
-    ModuleRTPUtility::PayloadUnion* specific_payload,
-    bool* should_reset_statistics,
-    bool* should_discard_changes) {
+void RTPReceiverAudio::CheckPayloadChanged(int8_t payload_type,
+                                           PayloadUnion* specific_payload,
+                                           bool* should_reset_statistics,
+                                           bool* should_discard_changes) {
   *should_discard_changes = false;
   *should_reset_statistics = false;
 
@@ -251,12 +258,24 @@
   }
 }
 
+int RTPReceiverAudio::Energy(uint8_t array_of_energy[kRtpCsrcSize]) const {
+  CriticalSectionScoped cs(crit_sect_.get());
+
+  assert(num_energy_ <= kRtpCsrcSize);
+
+  if (num_energy_ > 0) {
+    memcpy(array_of_energy, current_remote_energy_,
+           sizeof(uint8_t) * num_energy_);
+  }
+  return num_energy_;
+}
+
 int32_t RTPReceiverAudio::InvokeOnInitializeDecoder(
     RtpFeedback* callback,
-    const int32_t id,
-    const int8_t payload_type,
+    int32_t id,
+    int8_t payload_type,
     const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-    const ModuleRTPUtility::PayloadUnion& specific_payload) const {
+    const PayloadUnion& specific_payload) const {
   if (-1 == callback->OnInitializeDecoder(id,
                                           payload_type,
                                           payload_name,
@@ -277,9 +296,9 @@
 int32_t RTPReceiverAudio::ParseAudioCodecSpecific(
     WebRtcRTPHeader* rtp_header,
     const uint8_t* payload_data,
-    const uint16_t payload_length,
-    const ModuleRTPUtility::AudioPayload& audio_specific,
-    const bool is_red) {
+    uint16_t payload_length,
+    const AudioPayload& audio_specific,
+    bool is_red) {
 
   if (payload_length == 0) {
     return 0;
@@ -288,7 +307,7 @@
   bool telephone_event_packet =
       TelephoneEventPayloadType(rtp_header->header.payloadType);
   if (telephone_event_packet) {
-    CriticalSectionScoped lock(critical_section_rtp_receiver_audio_.get());
+    CriticalSectionScoped lock(crit_sect_.get());
 
     // RFC 4733 2.3
     // 0                   1                   2                   3
@@ -333,7 +352,7 @@
   }
 
   {
-    CriticalSectionScoped lock(critical_section_rtp_receiver_audio_.get());
+    CriticalSectionScoped lock(crit_sect_.get());
 
     if (!telephone_event_packet) {
       last_received_frequency_ = audio_specific.frequency;
diff --git a/modules/rtp_rtcp/source/rtp_receiver_audio.h b/modules/rtp_rtcp/source/rtp_receiver_audio.h
index 67b30c0..5a52629 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_audio.h
+++ b/modules/rtp_rtcp/source/rtp_receiver_audio.h
@@ -13,8 +13,8 @@
 
 #include <set>
 
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
@@ -25,16 +25,16 @@
 class CriticalSectionWrapper;
 
 // Handles audio RTP packets. This class is thread-safe.
-class RTPReceiverAudio : public RTPReceiverStrategy {
+class RTPReceiverAudio : public RTPReceiverStrategy,
+                         public TelephoneEventHandler {
  public:
   RTPReceiverAudio(const int32_t id,
                    RtpData* data_callback,
                    RtpAudioFeedback* incoming_messages_callback);
 
-  uint32_t AudioFrequency() const;
-
+  // The following three methods implement the TelephoneEventHandler interface.
   // Forward DTMFs to decoder for playout.
-  int SetTelephoneEventForwardToDecoder(bool forward_to_decoder);
+  void SetTelephoneEventForwardToDecoder(bool forward_to_decoder);
 
   // Is forwarding of outband telephone events turned on/off?
   bool TelephoneEventForwardToDecoder() const;
@@ -42,22 +42,25 @@
   // Is TelephoneEvent configured with payload type payload_type
   bool TelephoneEventPayloadType(const int8_t payload_type) const;
 
+  TelephoneEventHandler* GetTelephoneEventHandler() {
+    return this;
+  }
+
   // Returns true if CNG is configured with payload type payload_type. If so,
   // the frequency and cng_payload_type_has_changed are filled in.
   bool CNGPayloadType(const int8_t payload_type,
                       uint32_t* frequency,
                       bool* cng_payload_type_has_changed);
 
-  int32_t ParseRtpPacket(
-      WebRtcRTPHeader* rtp_header,
-      const ModuleRTPUtility::PayloadUnion& specific_payload,
-      const bool is_red,
-      const uint8_t* packet,
-      const uint16_t packet_length,
-      const int64_t timestamp_ms,
-      const bool is_first_packet);
+  int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header,
+                         const PayloadUnion& specific_payload,
+                         bool is_red,
+                         const uint8_t* packet,
+                         uint16_t packet_length,
+                         int64_t timestamp_ms,
+                         bool is_first_packet);
 
-  int32_t GetFrequencyHz() const;
+  int GetPayloadTypeFrequency() const;
 
   RTPAliveType ProcessDeadOrAlive(uint16_t last_payload_length) const;
 
@@ -65,44 +68,45 @@
 
   int32_t OnNewPayloadTypeCreated(
       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-      const int8_t payload_type,
-      const uint32_t frequency);
+      int8_t payload_type,
+      uint32_t frequency);
 
   int32_t InvokeOnInitializeDecoder(
       RtpFeedback* callback,
-      const int32_t id,
-      const int8_t payload_type,
+      int32_t id,
+      int8_t payload_type,
       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-      const ModuleRTPUtility::PayloadUnion& specific_payload) const;
+      const PayloadUnion& specific_payload) const;
 
   // We do not allow codecs to have multiple payload types for audio, so we
   // need to override the default behavior (which is to do nothing).
   void PossiblyRemoveExistingPayloadType(
       ModuleRTPUtility::PayloadTypeMap* payload_type_map,
       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-      const size_t payload_name_length,
-      const uint32_t frequency,
-      const uint8_t channels,
-      const uint32_t rate) const;
+      size_t payload_name_length,
+      uint32_t frequency,
+      uint8_t channels,
+      uint32_t rate) const;
 
   // We need to look out for special payload types here and sometimes reset
   // statistics. In addition we sometimes need to tweak the frequency.
-  void CheckPayloadChanged(const int8_t payload_type,
-                           ModuleRTPUtility::PayloadUnion* specific_payload,
+  void CheckPayloadChanged(int8_t payload_type,
+                           PayloadUnion* specific_payload,
                            bool* should_reset_statistics,
                            bool* should_discard_changes);
 
+  int Energy(uint8_t array_of_energy[kRtpCsrcSize]) const;
+
  private:
 
   int32_t ParseAudioCodecSpecific(
       WebRtcRTPHeader* rtp_header,
       const uint8_t* payload_data,
-      const uint16_t payload_length,
-      const ModuleRTPUtility::AudioPayload& audio_specific,
-      const bool is_red);
+      uint16_t payload_length,
+      const AudioPayload& audio_specific,
+      bool is_red);
 
   int32_t id_;
-  scoped_ptr<CriticalSectionWrapper> critical_section_rtp_receiver_audio_;
 
   uint32_t last_received_frequency_;
 
@@ -121,6 +125,9 @@
   int8_t g722_payload_type_;
   bool last_received_g722_;
 
+  uint8_t num_energy_;
+  uint8_t current_remote_energy_[kRtpCsrcSize];
+
   RtpAudioFeedback* cb_audio_feedback_;
 };
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_receiver_impl.cc b/modules/rtp_rtcp/source/rtp_receiver_impl.cc
new file mode 100644
index 0000000..7037957
--- /dev/null
+++ b/modules/rtp_rtcp/source/rtp_receiver_impl.cc
@@ -0,0 +1,643 @@
+/*
+ *  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/modules/rtp_rtcp/source/rtp_receiver_impl.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <cassert>
+
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
+#include "webrtc/system_wrappers/interface/trace.h"
+#include "webrtc/system_wrappers/interface/trace_event.h"
+
+namespace webrtc {
+
+using ModuleRTPUtility::GetCurrentRTP;
+using ModuleRTPUtility::Payload;
+using ModuleRTPUtility::RTPPayloadParser;
+using ModuleRTPUtility::StringCompare;
+
+RtpReceiver* RtpReceiver::CreateVideoReceiver(
+    int id, Clock* clock,
+    RtpData* incoming_payload_callback,
+    RtpFeedback* incoming_messages_callback,
+    RTPPayloadRegistry* rtp_payload_registry) {
+  if (!incoming_payload_callback)
+    incoming_payload_callback = NullObjectRtpData();
+  if (!incoming_messages_callback)
+    incoming_messages_callback = NullObjectRtpFeedback();
+  return new RtpReceiverImpl(
+      id, clock, NullObjectRtpAudioFeedback(), incoming_messages_callback,
+      rtp_payload_registry,
+      RTPReceiverStrategy::CreateVideoStrategy(id, incoming_payload_callback));
+}
+
+RtpReceiver* RtpReceiver::CreateAudioReceiver(
+    int id, Clock* clock,
+    RtpAudioFeedback* incoming_audio_feedback,
+    RtpData* incoming_payload_callback,
+    RtpFeedback* incoming_messages_callback,
+    RTPPayloadRegistry* rtp_payload_registry) {
+  if (!incoming_audio_feedback)
+    incoming_audio_feedback = NullObjectRtpAudioFeedback();
+  if (!incoming_payload_callback)
+    incoming_payload_callback = NullObjectRtpData();
+  if (!incoming_messages_callback)
+    incoming_messages_callback = NullObjectRtpFeedback();
+  return new RtpReceiverImpl(
+      id, clock, incoming_audio_feedback, incoming_messages_callback,
+      rtp_payload_registry,
+      RTPReceiverStrategy::CreateAudioStrategy(id, incoming_payload_callback,
+                                               incoming_audio_feedback));
+}
+
+RtpReceiverImpl::RtpReceiverImpl(int32_t id,
+                         Clock* clock,
+                         RtpAudioFeedback* incoming_audio_messages_callback,
+                         RtpFeedback* incoming_messages_callback,
+                         RTPPayloadRegistry* rtp_payload_registry,
+                         RTPReceiverStrategy* rtp_media_receiver)
+    : clock_(clock),
+      rtp_payload_registry_(rtp_payload_registry),
+      rtp_media_receiver_(rtp_media_receiver),
+      id_(id),
+      cb_rtp_feedback_(incoming_messages_callback),
+      critical_section_rtp_receiver_(
+        CriticalSectionWrapper::CreateCriticalSection()),
+      last_receive_time_(0),
+      last_received_payload_length_(0),
+      ssrc_(0),
+      num_csrcs_(0),
+      current_remote_csrc_(),
+      nack_method_(kNackOff),
+      max_reordering_threshold_(kDefaultMaxReorderingThreshold),
+      rtx_(false),
+      ssrc_rtx_(0),
+      payload_type_rtx_(-1) {
+  assert(incoming_audio_messages_callback && incoming_messages_callback);
+
+  memset(current_remote_csrc_, 0, sizeof(current_remote_csrc_));
+
+  WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, id, "%s created", __FUNCTION__);
+}
+
+RtpReceiverImpl::~RtpReceiverImpl() {
+  for (int i = 0; i < num_csrcs_; ++i) {
+    cb_rtp_feedback_->OnIncomingCSRCChanged(id_, current_remote_csrc_[i],
+                                            false);
+  }
+  delete critical_section_rtp_receiver_;
+  WEBRTC_TRACE(kTraceMemory, kTraceRtpRtcp, id_, "%s deleted", __FUNCTION__);
+}
+
+RTPReceiverStrategy* RtpReceiverImpl::GetMediaReceiver() const {
+  return rtp_media_receiver_.get();
+}
+
+RtpVideoCodecTypes RtpReceiverImpl::VideoCodecType() const {
+  PayloadUnion media_specific;
+  rtp_media_receiver_->GetLastMediaSpecificPayload(&media_specific);
+  return media_specific.Video.videoCodecType;
+}
+
+int32_t RtpReceiverImpl::RegisterReceivePayload(
+    const char payload_name[RTP_PAYLOAD_NAME_SIZE],
+    const int8_t payload_type,
+    const uint32_t frequency,
+    const uint8_t channels,
+    const uint32_t rate) {
+  CriticalSectionScoped lock(critical_section_rtp_receiver_);
+
+  // TODO(phoglund): Try to streamline handling of the RED codec and some other
+  // cases which makes it necessary to keep track of whether we created a
+  // payload or not.
+  bool created_new_payload = false;
+  int32_t result = rtp_payload_registry_->RegisterReceivePayload(
+      payload_name, payload_type, frequency, channels, rate,
+      &created_new_payload);
+  if (created_new_payload) {
+    if (rtp_media_receiver_->OnNewPayloadTypeCreated(payload_name, payload_type,
+                                                     frequency) != 0) {
+      WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_,
+                   "%s failed to register payload",
+                   __FUNCTION__);
+      return -1;
+    }
+  }
+  return result;
+}
+
+int32_t RtpReceiverImpl::DeRegisterReceivePayload(
+    const int8_t payload_type) {
+  CriticalSectionScoped lock(critical_section_rtp_receiver_);
+  return rtp_payload_registry_->DeRegisterReceivePayload(payload_type);
+}
+
+NACKMethod RtpReceiverImpl::NACK() const {
+  CriticalSectionScoped lock(critical_section_rtp_receiver_);
+  return nack_method_;
+}
+
+// Turn negative acknowledgment requests on/off.
+int32_t RtpReceiverImpl::SetNACKStatus(const NACKMethod method,
+                                   int max_reordering_threshold) {
+  CriticalSectionScoped lock(critical_section_rtp_receiver_);
+  if (max_reordering_threshold < 0) {
+    return -1;
+  } else if (method == kNackRtcp) {
+    max_reordering_threshold_ = max_reordering_threshold;
+  } else {
+    max_reordering_threshold_ = kDefaultMaxReorderingThreshold;
+  }
+  nack_method_ = method;
+  return 0;
+}
+
+void RtpReceiverImpl::SetRTXStatus(bool enable, uint32_t ssrc) {
+  CriticalSectionScoped lock(critical_section_rtp_receiver_);
+  rtx_ = enable;
+  ssrc_rtx_ = ssrc;
+}
+
+void RtpReceiverImpl::RTXStatus(bool* enable, uint32_t* ssrc,
+                            int* payload_type) const {
+  CriticalSectionScoped lock(critical_section_rtp_receiver_);
+  *enable = rtx_;
+  *ssrc = ssrc_rtx_;
+  *payload_type = payload_type_rtx_;
+}
+
+void RtpReceiverImpl::SetRtxPayloadType(int payload_type) {
+  CriticalSectionScoped cs(critical_section_rtp_receiver_);
+  payload_type_rtx_ = payload_type;
+}
+
+uint32_t RtpReceiverImpl::SSRC() const {
+  CriticalSectionScoped lock(critical_section_rtp_receiver_);
+  return ssrc_;
+}
+
+// Get remote CSRC.
+int32_t RtpReceiverImpl::CSRCs(uint32_t array_of_csrcs[kRtpCsrcSize]) const {
+  CriticalSectionScoped lock(critical_section_rtp_receiver_);
+
+  assert(num_csrcs_ <= kRtpCsrcSize);
+
+  if (num_csrcs_ > 0) {
+    memcpy(array_of_csrcs, current_remote_csrc_, sizeof(uint32_t)*num_csrcs_);
+  }
+  return num_csrcs_;
+}
+
+int32_t RtpReceiverImpl::Energy(
+    uint8_t array_of_energy[kRtpCsrcSize]) const {
+  return rtp_media_receiver_->Energy(array_of_energy);
+}
+
+bool RtpReceiverImpl::IncomingRtpPacket(
+  RTPHeader* rtp_header,
+  const uint8_t* packet,
+  int packet_length,
+  PayloadUnion payload_specific,
+  bool in_order) {
+  TRACE_EVENT0("webrtc_rtp", "RTPRecv::Packet");
+  // The rtp_header argument contains the parsed RTP header.
+  int length = packet_length - rtp_header->paddingLength;
+
+  // Sanity check.
+  if ((length - rtp_header->headerLength) < 0) {
+    WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_,
+                 "%s invalid argument",
+                 __FUNCTION__);
+    return false;
+  }
+  {
+    CriticalSectionScoped cs(critical_section_rtp_receiver_);
+    // TODO(holmer): Make rtp_header const after RTX has been broken out.
+    if (rtx_) {
+      if (ssrc_rtx_ == rtp_header->ssrc) {
+        // Sanity check, RTX packets has 2 extra header bytes.
+        if (rtp_header->headerLength + kRtxHeaderSize > packet_length) {
+          return false;
+        }
+        // If a specific RTX payload type is negotiated, set back to the media
+        // payload type and treat it like a media packet from here.
+        if (payload_type_rtx_ != -1) {
+          if (payload_type_rtx_ == rtp_header->payloadType &&
+              rtp_payload_registry_->last_received_media_payload_type() != -1) {
+            rtp_header->payloadType =
+                rtp_payload_registry_->last_received_media_payload_type();
+          } else {
+            WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, id_,
+                         "Incorrect RTX configuration, dropping packet.");
+            return false;
+          }
+        }
+        rtp_header->ssrc = ssrc_;
+        rtp_header->sequenceNumber =
+          (packet[rtp_header->headerLength] << 8) +
+          packet[1 + rtp_header->headerLength];
+        // Count the RTX header as part of the RTP
+        rtp_header->headerLength += 2;
+      }
+    }
+  }
+  int8_t first_payload_byte = 0;
+  if (length > 0) {
+    first_payload_byte = packet[rtp_header->headerLength];
+  }
+  // Trigger our callbacks.
+  CheckSSRCChanged(rtp_header);
+
+  bool is_red = false;
+  bool should_reset_statistics = false;
+
+  if (CheckPayloadChanged(rtp_header,
+                          first_payload_byte,
+                          is_red,
+                          &payload_specific,
+                          &should_reset_statistics) == -1) {
+    if (length - rtp_header->headerLength == 0) {
+      // OK, keep-alive packet.
+      WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, id_,
+                   "%s received keepalive",
+                   __FUNCTION__);
+      return true;
+    }
+    WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, id_,
+                 "%s received invalid payloadtype",
+                 __FUNCTION__);
+    return false;
+  }
+  if (should_reset_statistics) {
+    cb_rtp_feedback_->OnResetStatistics();
+  }
+  WebRtcRTPHeader webrtc_rtp_header;
+  memset(&webrtc_rtp_header, 0, sizeof(webrtc_rtp_header));
+  webrtc_rtp_header.header = *rtp_header;
+  CheckCSRC(&webrtc_rtp_header);
+
+  uint16_t payload_data_length =
+    ModuleRTPUtility::GetPayloadDataLength(*rtp_header, packet_length);
+
+  bool is_first_packet_in_frame = false;
+  bool is_first_packet = false;
+  {
+    CriticalSectionScoped lock(critical_section_rtp_receiver_);
+    is_first_packet_in_frame =
+          last_received_sequence_number_ + 1 == rtp_header->sequenceNumber &&
+          TimeStamp() != rtp_header->timestamp;
+    is_first_packet = is_first_packet_in_frame || last_receive_time_ == 0;
+  }
+
+  int32_t ret_val = rtp_media_receiver_->ParseRtpPacket(
+      &webrtc_rtp_header, payload_specific, is_red, packet, packet_length,
+      clock_->TimeInMilliseconds(), is_first_packet);
+
+  if (ret_val < 0) {
+    return false;
+  }
+
+  {
+    CriticalSectionScoped lock(critical_section_rtp_receiver_);
+
+    last_receive_time_ = clock_->TimeInMilliseconds();
+    last_received_payload_length_ = payload_data_length;
+
+    if (in_order) {
+      if (last_received_timestamp_ != rtp_header->timestamp) {
+        last_received_timestamp_ = rtp_header->timestamp;
+        last_received_frame_time_ms_ = clock_->TimeInMilliseconds();
+      }
+      last_received_sequence_number_ = rtp_header->sequenceNumber;
+    }
+  }
+  return true;
+}
+
+// Implementation note: we expect to have the critical_section_rtp_receiver_
+// critsect when we call this.
+bool RtpReceiverImpl::RetransmitOfOldPacket(const RTPHeader& header,
+                                        int jitter, int min_rtt) const {
+  if (InOrderPacket(header.sequenceNumber)) {
+    return false;
+  }
+
+  CriticalSectionScoped cs(critical_section_rtp_receiver_);
+  uint32_t frequency_khz = header.payload_type_frequency / 1000;
+  int64_t time_diff_ms = clock_->TimeInMilliseconds() -
+      last_receive_time_;
+
+  // Diff in time stamp since last received in order.
+  int32_t rtp_time_stamp_diff_ms =
+      static_cast<int32_t>(header.timestamp - last_received_timestamp_) /
+      frequency_khz;
+
+  int32_t max_delay_ms = 0;
+  if (min_rtt == 0) {
+    // Jitter standard deviation in samples.
+    float jitter_std = sqrt(static_cast<float>(jitter));
+
+    // 2 times the standard deviation => 95% confidence.
+    // And transform to milliseconds by dividing by the frequency in kHz.
+    max_delay_ms = static_cast<int32_t>((2 * jitter_std) / frequency_khz);
+
+    // Min max_delay_ms is 1.
+    if (max_delay_ms == 0) {
+      max_delay_ms = 1;
+    }
+  } else {
+    max_delay_ms = (min_rtt / 3) + 1;
+  }
+  if (time_diff_ms > rtp_time_stamp_diff_ms + max_delay_ms) {
+    return true;
+  }
+  return false;
+}
+
+bool RtpReceiverImpl::InOrderPacket(const uint16_t sequence_number) const {
+  CriticalSectionScoped cs(critical_section_rtp_receiver_);
+  if (IsNewerSequenceNumber(sequence_number, last_received_sequence_number_)) {
+    return true;
+  } else {
+    // If we have a restart of the remote side this packet is still in order.
+    return !IsNewerSequenceNumber(sequence_number,
+                                  last_received_sequence_number_ -
+                                  max_reordering_threshold_);
+  }
+}
+
+TelephoneEventHandler* RtpReceiverImpl::GetTelephoneEventHandler() {
+  return rtp_media_receiver_->GetTelephoneEventHandler();
+}
+
+uint32_t RtpReceiverImpl::TimeStamp() const {
+  CriticalSectionScoped lock(critical_section_rtp_receiver_);
+  return last_received_timestamp_;
+}
+
+int32_t RtpReceiverImpl::LastReceivedTimeMs() const {
+  CriticalSectionScoped lock(critical_section_rtp_receiver_);
+  return last_received_frame_time_ms_;
+}
+
+// Implementation note: must not hold critsect when called.
+void RtpReceiverImpl::CheckSSRCChanged(const RTPHeader* rtp_header) {
+  bool new_ssrc = false;
+  bool re_initialize_decoder = false;
+  char payload_name[RTP_PAYLOAD_NAME_SIZE];
+  uint8_t channels = 1;
+  uint32_t rate = 0;
+
+  {
+    CriticalSectionScoped lock(critical_section_rtp_receiver_);
+
+    int8_t last_received_payload_type =
+        rtp_payload_registry_->last_received_payload_type();
+    if (ssrc_ != rtp_header->ssrc ||
+        (last_received_payload_type == -1 && ssrc_ == 0)) {
+      // We need the payload_type_ to make the call if the remote SSRC is 0.
+      new_ssrc = true;
+
+      cb_rtp_feedback_->OnResetStatistics();
+
+      last_received_timestamp_      = 0;
+      last_received_sequence_number_ = 0;
+      last_received_frame_time_ms_ = 0;
+
+      // Do we have a SSRC? Then the stream is restarted.
+      if (ssrc_) {
+        // Do we have the same codec? Then re-initialize coder.
+        if (rtp_header->payloadType == last_received_payload_type) {
+          re_initialize_decoder = true;
+
+          Payload* payload;
+          if (!rtp_payload_registry_->PayloadTypeToPayload(
+              rtp_header->payloadType, payload)) {
+            return;
+          }
+          assert(payload);
+          payload_name[RTP_PAYLOAD_NAME_SIZE - 1] = 0;
+          strncpy(payload_name, payload->name, RTP_PAYLOAD_NAME_SIZE - 1);
+          if (payload->audio) {
+            channels = payload->typeSpecific.Audio.channels;
+            rate = payload->typeSpecific.Audio.rate;
+          }
+        }
+      }
+      ssrc_ = rtp_header->ssrc;
+    }
+  }
+  if (new_ssrc) {
+    // We need to get this to our RTCP sender and receiver.
+    // We need to do this outside critical section.
+    cb_rtp_feedback_->OnIncomingSSRCChanged(id_, rtp_header->ssrc);
+  }
+  if (re_initialize_decoder) {
+    if (-1 == cb_rtp_feedback_->OnInitializeDecoder(
+        id_, rtp_header->payloadType, payload_name,
+        rtp_header->payload_type_frequency, channels, rate)) {
+      // New stream, same codec.
+      WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_,
+                   "Failed to create decoder for payload type:%d",
+                   rtp_header->payloadType);
+    }
+  }
+}
+
+// Implementation note: must not hold critsect when called.
+// TODO(phoglund): Move as much as possible of this code path into the media
+// specific receivers. Basically this method goes through a lot of trouble to
+// compute something which is only used by the media specific parts later. If
+// this code path moves we can get rid of some of the rtp_receiver ->
+// media_specific interface (such as CheckPayloadChange, possibly get/set
+// last known payload).
+int32_t RtpReceiverImpl::CheckPayloadChanged(
+  const RTPHeader* rtp_header,
+  const int8_t first_payload_byte,
+  bool& is_red,
+  PayloadUnion* specific_payload,
+  bool* should_reset_statistics) {
+  bool re_initialize_decoder = false;
+
+  char payload_name[RTP_PAYLOAD_NAME_SIZE];
+  int8_t payload_type = rtp_header->payloadType;
+
+  {
+    CriticalSectionScoped lock(critical_section_rtp_receiver_);
+
+    int8_t last_received_payload_type =
+        rtp_payload_registry_->last_received_payload_type();
+    if (payload_type != last_received_payload_type) {
+      if (rtp_payload_registry_->red_payload_type() == payload_type) {
+        // Get the real codec payload type.
+        payload_type = first_payload_byte & 0x7f;
+        is_red = true;
+
+        if (rtp_payload_registry_->red_payload_type() == payload_type) {
+          // Invalid payload type, traced by caller. If we proceeded here,
+          // this would be set as |_last_received_payload_type|, and we would no
+          // longer catch corrupt packets at this level.
+          return -1;
+        }
+
+        // When we receive RED we need to check the real payload type.
+        if (payload_type == last_received_payload_type) {
+          rtp_media_receiver_->GetLastMediaSpecificPayload(specific_payload);
+          return 0;
+        }
+      }
+      *should_reset_statistics = false;
+      bool should_discard_changes = false;
+
+      rtp_media_receiver_->CheckPayloadChanged(
+        payload_type, specific_payload, should_reset_statistics,
+        &should_discard_changes);
+
+      if (should_discard_changes) {
+        is_red = false;
+        return 0;
+      }
+
+      Payload* payload;
+      if (!rtp_payload_registry_->PayloadTypeToPayload(payload_type, payload)) {
+        // Not a registered payload type.
+        return -1;
+      }
+      assert(payload);
+      payload_name[RTP_PAYLOAD_NAME_SIZE - 1] = 0;
+      strncpy(payload_name, payload->name, RTP_PAYLOAD_NAME_SIZE - 1);
+
+      rtp_payload_registry_->set_last_received_payload_type(payload_type);
+
+      re_initialize_decoder = true;
+
+      rtp_media_receiver_->SetLastMediaSpecificPayload(payload->typeSpecific);
+      rtp_media_receiver_->GetLastMediaSpecificPayload(specific_payload);
+
+      if (!payload->audio) {
+        if (VideoCodecType() == kRtpVideoFec) {
+          // Only reset the decoder on media packets.
+          re_initialize_decoder = false;
+        } else {
+          bool media_type_unchanged =
+              rtp_payload_registry_->ReportMediaPayloadType(payload_type);
+          if (media_type_unchanged) {
+            // Only reset the decoder if the media codec type has changed.
+            re_initialize_decoder = false;
+          }
+        }
+      }
+      if (re_initialize_decoder) {
+        *should_reset_statistics = true;
+      }
+    } else {
+      rtp_media_receiver_->GetLastMediaSpecificPayload(specific_payload);
+      is_red = false;
+    }
+  }  // End critsect.
+
+  if (re_initialize_decoder) {
+    if (-1 == rtp_media_receiver_->InvokeOnInitializeDecoder(
+        cb_rtp_feedback_, id_, payload_type, payload_name,
+        *specific_payload)) {
+      return -1;  // Wrong payload type.
+    }
+  }
+  return 0;
+}
+
+// Implementation note: must not hold critsect when called.
+void RtpReceiverImpl::CheckCSRC(const WebRtcRTPHeader* rtp_header) {
+  int32_t num_csrcs_diff = 0;
+  uint32_t old_remote_csrc[kRtpCsrcSize];
+  uint8_t old_num_csrcs = 0;
+
+  {
+    CriticalSectionScoped lock(critical_section_rtp_receiver_);
+
+    if (!rtp_media_receiver_->ShouldReportCsrcChanges(
+        rtp_header->header.payloadType)) {
+      return;
+    }
+    old_num_csrcs  = num_csrcs_;
+    if (old_num_csrcs > 0) {
+      // Make a copy of old.
+      memcpy(old_remote_csrc, current_remote_csrc_,
+             num_csrcs_ * sizeof(uint32_t));
+    }
+    const uint8_t num_csrcs = rtp_header->header.numCSRCs;
+    if ((num_csrcs > 0) && (num_csrcs <= kRtpCsrcSize)) {
+      // Copy new.
+      memcpy(current_remote_csrc_,
+             rtp_header->header.arrOfCSRCs,
+             num_csrcs * sizeof(uint32_t));
+    }
+    if (num_csrcs > 0 || old_num_csrcs > 0) {
+      num_csrcs_diff = num_csrcs - old_num_csrcs;
+      num_csrcs_ = num_csrcs;  // Update stored CSRCs.
+    } else {
+      // No change.
+      return;
+    }
+  }  // End critsect.
+
+  bool have_called_callback = false;
+  // Search for new CSRC in old array.
+  for (uint8_t i = 0; i < rtp_header->header.numCSRCs; ++i) {
+    const uint32_t csrc = rtp_header->header.arrOfCSRCs[i];
+
+    bool found_match = false;
+    for (uint8_t j = 0; j < old_num_csrcs; ++j) {
+      if (csrc == old_remote_csrc[j]) {  // old list
+        found_match = true;
+        break;
+      }
+    }
+    if (!found_match && csrc) {
+      // Didn't find it, report it as new.
+      have_called_callback = true;
+      cb_rtp_feedback_->OnIncomingCSRCChanged(id_, csrc, true);
+    }
+  }
+  // Search for old CSRC in new array.
+  for (uint8_t i = 0; i < old_num_csrcs; ++i) {
+    const uint32_t csrc = old_remote_csrc[i];
+
+    bool found_match = false;
+    for (uint8_t j = 0; j < rtp_header->header.numCSRCs; ++j) {
+      if (csrc == rtp_header->header.arrOfCSRCs[j]) {
+        found_match = true;
+        break;
+      }
+    }
+    if (!found_match && csrc) {
+      // Did not find it, report as removed.
+      have_called_callback = true;
+      cb_rtp_feedback_->OnIncomingCSRCChanged(id_, csrc, false);
+    }
+  }
+  if (!have_called_callback) {
+    // If the CSRC list contain non-unique entries we will end up here.
+    // Using CSRC 0 to signal this event, not interop safe, other
+    // implementations might have CSRC 0 as a valid value.
+    if (num_csrcs_diff > 0) {
+      cb_rtp_feedback_->OnIncomingCSRCChanged(id_, 0, true);
+    } else if (num_csrcs_diff < 0) {
+      cb_rtp_feedback_->OnIncomingCSRCChanged(id_, 0, false);
+    }
+  }
+}
+
+}  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_receiver_impl.h b/modules/rtp_rtcp/source/rtp_receiver_impl.h
new file mode 100644
index 0000000..2bf332b
--- /dev/null
+++ b/modules/rtp_rtcp/source/rtp_receiver_impl.h
@@ -0,0 +1,122 @@
+/*
+ *  Copyright (c) 2013 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.
+ */
+
+#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_RECEIVER_IMPL_H_
+#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_RECEIVER_IMPL_H_
+
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h"
+#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
+#include "webrtc/system_wrappers/interface/scoped_ptr.h"
+#include "webrtc/typedefs.h"
+
+namespace webrtc {
+
+class RtpReceiverImpl : public RtpReceiver {
+ public:
+  // Callbacks passed in here may not be NULL (use Null Object callbacks if you
+  // want callbacks to do nothing). This class takes ownership of the media
+  // receiver but nothing else.
+  RtpReceiverImpl(int32_t id,
+                  Clock* clock,
+                  RtpAudioFeedback* incoming_audio_messages_callback,
+                  RtpFeedback* incoming_messages_callback,
+                  RTPPayloadRegistry* rtp_payload_registry,
+                  RTPReceiverStrategy* rtp_media_receiver);
+
+  virtual ~RtpReceiverImpl();
+
+  RTPReceiverStrategy* GetMediaReceiver() const;
+
+  int32_t RegisterReceivePayload(
+      const char payload_name[RTP_PAYLOAD_NAME_SIZE],
+      const int8_t payload_type,
+      const uint32_t frequency,
+      const uint8_t channels,
+      const uint32_t rate);
+
+  int32_t DeRegisterReceivePayload(const int8_t payload_type);
+
+  bool IncomingRtpPacket(
+      RTPHeader* rtp_header,
+      const uint8_t* incoming_rtp_packet,
+      int incoming_rtp_packet_length,
+      PayloadUnion payload_specific,
+      bool in_order);
+
+  NACKMethod NACK() const;
+
+  // Turn negative acknowledgement requests on/off.
+  int32_t SetNACKStatus(const NACKMethod method, int max_reordering_threshold);
+
+  // Returns the last received timestamp.
+  virtual uint32_t TimeStamp() const;
+  int32_t LastReceivedTimeMs() const;
+
+  uint32_t SSRC() const;
+
+  int32_t CSRCs(uint32_t array_of_csrc[kRtpCsrcSize]) const;
+
+  int32_t Energy(uint8_t array_of_energy[kRtpCsrcSize]) const;
+
+  // RTX.
+  void SetRTXStatus(bool enable, uint32_t ssrc);
+
+  void RTXStatus(bool* enable, uint32_t* ssrc, int* payload_type) const;
+
+  void SetRtxPayloadType(int payload_type);
+
+  virtual bool RetransmitOfOldPacket(const RTPHeader& header,
+                                     int jitter, int min_rtt) const;
+  bool InOrderPacket(const uint16_t sequence_number) const;
+  TelephoneEventHandler* GetTelephoneEventHandler();
+
+ private:
+  RtpVideoCodecTypes VideoCodecType() const;
+
+  void CheckSSRCChanged(const RTPHeader* rtp_header);
+  void CheckCSRC(const WebRtcRTPHeader* rtp_header);
+  int32_t CheckPayloadChanged(const RTPHeader* rtp_header,
+                              const int8_t first_payload_byte,
+                              bool& isRED,
+                              PayloadUnion* payload,
+                              bool* should_reset_statistics);
+
+  Clock* clock_;
+  RTPPayloadRegistry* rtp_payload_registry_;
+  scoped_ptr<RTPReceiverStrategy> rtp_media_receiver_;
+
+  int32_t id_;
+
+  RtpFeedback* cb_rtp_feedback_;
+
+  CriticalSectionWrapper* critical_section_rtp_receiver_;
+  int64_t last_receive_time_;
+  uint16_t last_received_payload_length_;
+
+  // SSRCs.
+  uint32_t ssrc_;
+  uint8_t num_csrcs_;
+  uint32_t current_remote_csrc_[kRtpCsrcSize];
+
+  uint32_t last_received_timestamp_;
+  int64_t last_received_frame_time_ms_;
+  uint16_t last_received_sequence_number_;
+
+  NACKMethod nack_method_;
+  int max_reordering_threshold_;
+
+  bool rtx_;
+  uint32_t ssrc_rtx_;
+  int payload_type_rtx_;
+};
+}  // namespace webrtc
+#endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_RECEIVER_IMPL_H_
diff --git a/modules/rtp_rtcp/source/rtp_receiver_strategy.cc b/modules/rtp_rtcp/source/rtp_receiver_strategy.cc
index 8831e12..14763ba 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_strategy.cc
+++ b/modules/rtp_rtcp/source/rtp_receiver_strategy.cc
@@ -12,21 +12,30 @@
 
 #include <cstdlib>
 
+#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
+
 namespace webrtc {
 
 RTPReceiverStrategy::RTPReceiverStrategy(RtpData* data_callback)
-    : data_callback_(data_callback) {
+    : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
+      data_callback_(data_callback) {
   memset(&last_payload_, 0, sizeof(last_payload_));
 }
 
 void RTPReceiverStrategy::GetLastMediaSpecificPayload(
-  ModuleRTPUtility::PayloadUnion* payload) const {
+    PayloadUnion* payload) const {
+  CriticalSectionScoped cs(crit_sect_.get());
   memcpy(payload, &last_payload_, sizeof(*payload));
 }
 
 void RTPReceiverStrategy::SetLastMediaSpecificPayload(
-  const ModuleRTPUtility::PayloadUnion& payload) {
+    const PayloadUnion& payload) {
+  CriticalSectionScoped cs(crit_sect_.get());
   memcpy(&last_payload_, &payload, sizeof(last_payload_));
 }
 
+int RTPReceiverStrategy::Energy(uint8_t array_of_energy[kRtpCsrcSize]) const {
+  return 0;
+}
+
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_receiver_strategy.h b/modules/rtp_rtcp/source/rtp_receiver_strategy.h
index 8e8fa1d..69be56f 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_strategy.h
+++ b/modules/rtp_rtcp/source/rtp_receiver_strategy.h
@@ -14,23 +14,24 @@
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
+#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
+#include "webrtc/system_wrappers/interface/scoped_ptr.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
+class TelephoneEventHandler;
+
 // This strategy deals with media-specific RTP packet processing.
 // This class is not thread-safe and must be protected by its caller.
 class RTPReceiverStrategy {
  public:
-  // The data callback is where we should send received payload data.
-  // See ParseRtpPacket. This class does not claim ownership of the callback.
-  // Implementations must NOT hold any critical sections while calling the
-  // callback.
-  //
-  // Note: Implementations may call the callback for other reasons than calls
-  // to ParseRtpPacket, for instance if the implementation somehow recovers a
-  // packet.
-  RTPReceiverStrategy(RtpData* data_callback);
+  static RTPReceiverStrategy* CreateVideoStrategy(int32_t id,
+                                                  RtpData* data_callback);
+  static RTPReceiverStrategy* CreateAudioStrategy(
+      int32_t id, RtpData* data_callback,
+      RtpAudioFeedback* incoming_messages_callback);
+
   virtual ~RTPReceiverStrategy() {}
 
   // Parses the RTP packet and calls the data callback with the payload data.
@@ -39,21 +40,22 @@
   // make changes in the data as necessary. The specific_payload argument
   // provides audio or video-specific data. The is_first_packet argument is true
   // if this packet is either the first packet ever or the first in its frame.
-  virtual int32_t ParseRtpPacket(
-    WebRtcRTPHeader* rtp_header,
-    const ModuleRTPUtility::PayloadUnion& specific_payload,
-    const bool is_red,
-    const uint8_t* packet,
-    const uint16_t packet_length,
-    const int64_t timestamp_ms,
-    const bool is_first_packet) = 0;
+  virtual int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header,
+                                 const PayloadUnion& specific_payload,
+                                 bool is_red,
+                                 const uint8_t* packet,
+                                 uint16_t packet_length,
+                                 int64_t timestamp_ms,
+                                 bool is_first_packet) = 0;
+
+  virtual TelephoneEventHandler* GetTelephoneEventHandler() = 0;
 
   // Retrieves the last known applicable frequency.
-  virtual int32_t GetFrequencyHz() const = 0;
+  virtual int GetPayloadTypeFrequency() const = 0;
 
   // Computes the current dead-or-alive state.
   virtual RTPAliveType ProcessDeadOrAlive(
-    uint16_t last_payload_length) const = 0;
+      uint16_t last_payload_length) const = 0;
 
   // Returns true if we should report CSRC changes for this payload type.
   // TODO(phoglund): should move out of here along with other payload stuff.
@@ -63,40 +65,49 @@
   // the payload registry.
   virtual int32_t OnNewPayloadTypeCreated(
       const char payloadName[RTP_PAYLOAD_NAME_SIZE],
-      const int8_t payloadType,
-      const uint32_t frequency) = 0;
+      int8_t payloadType,
+      uint32_t frequency) = 0;
 
   // Invokes the OnInitializeDecoder callback in a media-specific way.
   virtual int32_t InvokeOnInitializeDecoder(
-    RtpFeedback* callback,
-    const int32_t id,
-    const int8_t payload_type,
-    const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-    const ModuleRTPUtility::PayloadUnion& specific_payload) const = 0;
+      RtpFeedback* callback,
+      int32_t id,
+      int8_t payload_type,
+      const char payload_name[RTP_PAYLOAD_NAME_SIZE],
+      const PayloadUnion& specific_payload) const = 0;
 
   // Checks if the payload type has changed, and returns whether we should
   // reset statistics and/or discard this packet.
-  virtual void CheckPayloadChanged(
-    const int8_t payload_type,
-    ModuleRTPUtility::PayloadUnion* specific_payload,
-    bool* should_reset_statistics,
-    bool* should_discard_changes) {
+  virtual void CheckPayloadChanged(int8_t payload_type,
+                                   PayloadUnion* specific_payload,
+                                   bool* should_reset_statistics,
+                                   bool* should_discard_changes) {
     // Default: Keep changes and don't reset statistics.
     *should_discard_changes = false;
     *should_reset_statistics = false;
   }
 
   // Stores / retrieves the last media specific payload for later reference.
-  void GetLastMediaSpecificPayload(
-    ModuleRTPUtility::PayloadUnion* payload) const;
-  void SetLastMediaSpecificPayload(
-    const ModuleRTPUtility::PayloadUnion& payload);
+  void GetLastMediaSpecificPayload(PayloadUnion* payload) const;
+  void SetLastMediaSpecificPayload(const PayloadUnion& payload);
+
+  int Energy(uint8_t array_of_energy[kRtpCsrcSize]) const;
 
  protected:
-  ModuleRTPUtility::PayloadUnion last_payload_;
+  // The data callback is where we should send received payload data.
+  // See ParseRtpPacket. This class does not claim ownership of the callback.
+  // Implementations must NOT hold any critical sections while calling the
+  // callback.
+  //
+  // Note: Implementations may call the callback for other reasons than calls
+  // to ParseRtpPacket, for instance if the implementation somehow recovers a
+  // packet.
+  RTPReceiverStrategy(RtpData* data_callback);
+
+  scoped_ptr<CriticalSectionWrapper> crit_sect_;
+  PayloadUnion last_payload_;
   RtpData* data_callback_;
 };
-
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_RECEIVER_STRATEGY_H_
diff --git a/modules/rtp_rtcp/source/rtp_receiver_video.cc b/modules/rtp_rtcp/source/rtp_receiver_video.cc
index b5e8662..62fcdb1 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_video.cc
+++ b/modules/rtp_rtcp/source/rtp_receiver_video.cc
@@ -15,9 +15,9 @@
 #include <cassert>  // assert
 #include <cstring>  // memcpy()
 
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
 #include "webrtc/modules/rtp_rtcp/source/receiver_fec.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_payload_registry.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
@@ -29,21 +29,18 @@
   return (x & 0x3fff) * uint32_t(pow(10.0f, (2 + (x >> 14))));
 }
 
-RTPReceiverVideo::RTPReceiverVideo(
-    const int32_t id,
-    const RTPPayloadRegistry* rtp_rtp_payload_registry,
-    RtpData* data_callback)
+RTPReceiverStrategy* RTPReceiverStrategy::CreateVideoStrategy(
+    int32_t id, RtpData* data_callback) {
+  return new RTPReceiverVideo(id, data_callback);
+}
+
+RTPReceiverVideo::RTPReceiverVideo(int32_t id, RtpData* data_callback)
     : RTPReceiverStrategy(data_callback),
       id_(id),
-      rtp_rtp_payload_registry_(rtp_rtp_payload_registry),
-      critical_section_receiver_video_(
-          CriticalSectionWrapper::CreateCriticalSection()),
-      current_fec_frame_decoded_(false),
       receive_fec_(NULL) {
 }
 
 RTPReceiverVideo::~RTPReceiverVideo() {
-  delete critical_section_receiver_video_;
   delete receive_fec_;
 }
 
@@ -55,12 +52,12 @@
 
 int32_t RTPReceiverVideo::OnNewPayloadTypeCreated(
     const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-    const int8_t payload_type,
-    const uint32_t frequency) {
+    int8_t payload_type,
+    uint32_t frequency) {
   if (ModuleRTPUtility::StringCompare(payload_name, "ULPFEC", 6)) {
     // Enable FEC if not enabled.
     if (receive_fec_ == NULL) {
-      receive_fec_ = new ReceiverFEC(id_, this);
+      receive_fec_ = new ReceiverFEC(id_, data_callback_);
     }
     receive_fec_->SetPayloadTypeFEC(payload_type);
   }
@@ -69,15 +66,16 @@
 
 int32_t RTPReceiverVideo::ParseRtpPacket(
     WebRtcRTPHeader* rtp_header,
-    const ModuleRTPUtility::PayloadUnion& specific_payload,
-    const bool is_red,
+    const PayloadUnion& specific_payload,
+    bool is_red,
     const uint8_t* packet,
-    const uint16_t packet_length,
-    const int64_t timestamp_ms,
-    const bool is_first_packet) {
+    uint16_t packet_length,
+    int64_t timestamp_ms,
+    bool is_first_packet) {
   TRACE_EVENT2("webrtc_rtp", "Video::ParseRtp",
                "seqnum", rtp_header->header.sequenceNumber,
                "timestamp", rtp_header->header.timestamp);
+  rtp_header->type.Video.codec = specific_payload.Video.videoCodecType;
   const uint8_t* payload_data =
       ModuleRTPUtility::GetPayloadData(rtp_header->header, packet);
   const uint16_t payload_data_length =
@@ -93,8 +91,8 @@
                                  is_first_packet);
 }
 
-int32_t RTPReceiverVideo::GetFrequencyHz() const {
-  return kDefaultVideoFrequency;
+int RTPReceiverVideo::GetPayloadTypeFrequency() const {
+  return kVideoPayloadTypeFrequency;
 }
 
 RTPAliveType RTPReceiverVideo::ProcessDeadOrAlive(
@@ -104,13 +102,13 @@
 
 int32_t RTPReceiverVideo::InvokeOnInitializeDecoder(
     RtpFeedback* callback,
-    const int32_t id,
-    const int8_t payload_type,
+    int32_t id,
+    int8_t payload_type,
     const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-    const ModuleRTPUtility::PayloadUnion& specific_payload) const {
+    const PayloadUnion& specific_payload) const {
   // For video we just go with default values.
   if (-1 == callback->OnInitializeDecoder(
-      id, payload_type, payload_name, kDefaultVideoFrequency, 1, 0)) {
+      id, payload_type, payload_name, kVideoPayloadTypeFrequency, 1, 0)) {
     WEBRTC_TRACE(kTraceError,
                  kTraceRtpRtcp,
                  id,
@@ -127,29 +125,29 @@
 int32_t RTPReceiverVideo::ParseVideoCodecSpecific(
     WebRtcRTPHeader* rtp_header,
     const uint8_t* payload_data,
-    const uint16_t payload_data_length,
-    const RtpVideoCodecTypes video_type,
-    const bool is_red,
+    uint16_t payload_data_length,
+    RtpVideoCodecTypes video_type,
+    bool is_red,
     const uint8_t* incoming_rtp_packet,
-    const uint16_t incoming_rtp_packet_size,
-    const int64_t now_ms,
-    const bool is_first_packet) {
+    uint16_t incoming_rtp_packet_size,
+    int64_t now_ms,
+    bool is_first_packet) {
   int32_t ret_val = 0;
 
-  critical_section_receiver_video_->Enter();
+  crit_sect_->Enter();
 
   if (is_red) {
     if (receive_fec_ == NULL) {
-      critical_section_receiver_video_->Leave();
+      crit_sect_->Leave();
       return -1;
     }
+    crit_sect_->Leave();
     bool FECpacket = false;
     ret_val = receive_fec_->AddReceivedFECPacket(
         rtp_header, incoming_rtp_packet, payload_data_length, FECpacket);
     if (ret_val != -1) {
       ret_val = receive_fec_->ProcessReceivedFEC();
     }
-    critical_section_receiver_video_->Leave();
 
     if (ret_val == 0 && FECpacket) {
       // Callback with the received FEC packet.
@@ -158,21 +156,17 @@
       // empty payload and data length.
       rtp_header->frameType = kFrameEmpty;
       // We need this for the routing.
-      int32_t ret_val = SetCodecType(video_type, rtp_header);
-      if (ret_val != 0) {
-        return ret_val;
-      }
+      rtp_header->type.Video.codec = video_type;
       // Pass the length of FEC packets so that they can be accounted for in
       // the bandwidth estimator.
       ret_val = data_callback_->OnReceivedPayloadData(
           NULL, payload_data_length, rtp_header);
     }
   } else {
-    // will leave the critical_section_receiver_video_ critsect
+    // will leave the crit_sect_ critsect
     ret_val = ParseVideoCodecSpecificSwitch(rtp_header,
                                             payload_data,
                                             payload_data_length,
-                                            video_type,
                                             is_first_packet);
   }
   return ret_val;
@@ -214,82 +208,11 @@
   return rtp_header_length;
 }
 
-int32_t RTPReceiverVideo::ReceiveRecoveredPacketCallback(
-    WebRtcRTPHeader* rtp_header,
-    const uint8_t* payload_data,
-    const uint16_t payload_data_length) {
-  // TODO(pwestin) Re-factor this to avoid the messy critsect handling.
-  critical_section_receiver_video_->Enter();
-
-  current_fec_frame_decoded_ = true;
-
-  ModuleRTPUtility::Payload* payload = NULL;
-  if (rtp_rtp_payload_registry_->PayloadTypeToPayload(
-          rtp_header->header.payloadType, payload) != 0) {
-    critical_section_receiver_video_->Leave();
-    return -1;
-  }
-  // here we can re-create the original lost packet so that we can use it for
-  // the relay we need to re-create the RED header too
-  uint8_t recovered_packet[IP_PACKET_SIZE];
-  uint16_t rtp_header_length =
-      (uint16_t) BuildRTPheader(rtp_header, recovered_packet);
-
-  const uint8_t kREDForFECHeaderLength = 1;
-
-  // replace pltype
-  recovered_packet[1] &= 0x80;  // Reset.
-  recovered_packet[1] += rtp_rtp_payload_registry_->red_payload_type();
-
-  // add RED header
-  recovered_packet[rtp_header_length] = rtp_header->header.payloadType;
-  // f-bit always 0
-
-  memcpy(recovered_packet + rtp_header_length + kREDForFECHeaderLength,
-         payload_data,
-         payload_data_length);
-
-  // A recovered packet can be the first packet, but we lack the ability to
-  // detect it at the moment since we do not store the history of recently
-  // received packets. Most codecs like VP8 deal with this in other ways.
-  bool is_first_packet = false;
-
-  return ParseVideoCodecSpecificSwitch(
-      rtp_header,
-      payload_data,
-      payload_data_length,
-      payload->typeSpecific.Video.videoCodecType,
-      is_first_packet);
-}
-
-int32_t RTPReceiverVideo::SetCodecType(
-    const RtpVideoCodecTypes video_type,
-    WebRtcRTPHeader* rtp_header) const {
-  switch (video_type) {
-    case kRtpGenericVideo:
-      rtp_header->type.Video.codec = kRTPVideoGeneric;
-      break;
-    case kRtpVp8Video:
-      rtp_header->type.Video.codec = kRTPVideoVP8;
-      break;
-    case kRtpFecVideo:
-      rtp_header->type.Video.codec = kRTPVideoFEC;
-      break;
-  }
-  return 0;
-}
-
 int32_t RTPReceiverVideo::ParseVideoCodecSpecificSwitch(
     WebRtcRTPHeader* rtp_header,
     const uint8_t* payload_data,
-    const uint16_t payload_data_length,
-    const RtpVideoCodecTypes video_type,
-    const bool is_first_packet) {
-  int32_t ret_val = SetCodecType(video_type, rtp_header);
-  if (ret_val != 0) {
-    critical_section_receiver_video_->Leave();
-    return ret_val;
-  }
+    uint16_t payload_data_length,
+    bool is_first_packet) {
   WEBRTC_TRACE(kTraceStream,
                kTraceRtpRtcp,
                id_,
@@ -297,25 +220,26 @@
                __FUNCTION__,
                rtp_header->header.timestamp);
 
-  // All receive functions release critical_section_receiver_video_ before
-  // returning.
-  switch (video_type) {
-    case kRtpGenericVideo:
+  // Critical section has already been taken.
+  switch (rtp_header->type.Video.codec) {
+    case kRtpVideoGeneric:
       rtp_header->type.Video.isFirstPacket = is_first_packet;
       return ReceiveGenericCodec(rtp_header, payload_data, payload_data_length);
-    case kRtpVp8Video:
+    case kRtpVideoVp8:
       return ReceiveVp8Codec(rtp_header, payload_data, payload_data_length);
-    case kRtpFecVideo:
+    case kRtpVideoFec:
       break;
+    default:
+      assert(false);
   }
-  critical_section_receiver_video_->Leave();
+  // Releasing the already taken critical section here.
+  crit_sect_->Leave();
   return -1;
 }
 
-int32_t RTPReceiverVideo::ReceiveVp8Codec(
-    WebRtcRTPHeader* rtp_header,
-    const uint8_t* payload_data,
-    const uint16_t payload_data_length) {
+int32_t RTPReceiverVideo::ReceiveVp8Codec(WebRtcRTPHeader* rtp_header,
+                                          const uint8_t* payload_data,
+                                          uint16_t payload_data_length) {
   bool success;
   ModuleRTPUtility::RTPPayload parsed_packet;
   if (payload_data_length == 0) {
@@ -323,12 +247,12 @@
     parsed_packet.info.VP8.dataLength = 0;
   } else {
     ModuleRTPUtility::RTPPayloadParser rtp_payload_parser(
-        kRtpVp8Video, payload_data, payload_data_length, id_);
+        kRtpVideoVp8, payload_data, payload_data_length, id_);
 
     success = rtp_payload_parser.Parse(parsed_packet);
   }
   // from here down we only work on local data
-  critical_section_receiver_video_->Leave();
+  crit_sect_->Leave();
 
   if (!success) {
     return -1;
@@ -391,7 +315,7 @@
   rtp_header->type.Video.isFirstPacket =
       (generic_header & RtpFormatVideoGeneric::kFirstPacketBit) != 0;
 
-  critical_section_receiver_video_->Leave();
+  crit_sect_->Leave();
 
   if (data_callback_->OnReceivedPayloadData(
           payload_data, payload_data_length, rtp_header) != 0) {
diff --git a/modules/rtp_rtcp/source/rtp_receiver_video.h b/modules/rtp_rtcp/source/rtp_receiver_video.h
index 520e201..cd5286b 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_video.h
+++ b/modules/rtp_rtcp/source/rtp_receiver_video.h
@@ -22,27 +22,28 @@
 class CriticalSectionWrapper;
 class ModuleRtpRtcpImpl;
 class ReceiverFEC;
-class RTPReceiver;
-class RTPPayloadRegistry;
+class RtpReceiver;
 
 class RTPReceiverVideo : public RTPReceiverStrategy {
  public:
-  RTPReceiverVideo(const int32_t id,
-                   const RTPPayloadRegistry* rtp_payload_registry,
-                   RtpData* data_callback);
+  RTPReceiverVideo(const int32_t id, RtpData* data_callback);
 
   virtual ~RTPReceiverVideo();
 
   int32_t ParseRtpPacket(
       WebRtcRTPHeader* rtp_header,
-      const ModuleRTPUtility::PayloadUnion& specific_payload,
-      const bool is_red,
+      const PayloadUnion& specific_payload,
+      bool is_red,
       const uint8_t* packet,
-      const uint16_t packet_length,
-      const int64_t timestamp,
-      const bool is_first_packet);
+      uint16_t packet_length,
+      int64_t timestamp,
+      bool is_first_packet);
 
-  int32_t GetFrequencyHz() const;
+  TelephoneEventHandler* GetTelephoneEventHandler() {
+    return NULL;
+  }
+
+  int GetPayloadTypeFrequency() const;
 
   RTPAliveType ProcessDeadOrAlive(uint16_t last_payload_length) const;
 
@@ -50,41 +51,32 @@
 
   int32_t OnNewPayloadTypeCreated(
       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-      const int8_t payload_type,
-      const uint32_t frequency);
+      int8_t payload_type,
+      uint32_t frequency);
 
   int32_t InvokeOnInitializeDecoder(
       RtpFeedback* callback,
-      const int32_t id,
-      const int8_t payload_type,
+      int32_t id,
+      int8_t payload_type,
       const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-      const ModuleRTPUtility::PayloadUnion& specific_payload) const;
-
-  virtual int32_t ReceiveRecoveredPacketCallback(
-      WebRtcRTPHeader* rtp_header,
-      const uint8_t* payload_data,
-      const uint16_t payload_data_length);
+      const PayloadUnion& specific_payload) const;
 
   void SetPacketOverHead(uint16_t packet_over_head);
 
  protected:
-  int32_t SetCodecType(const RtpVideoCodecTypes video_type,
-                       WebRtcRTPHeader* rtp_header) const;
-
   int32_t ParseVideoCodecSpecificSwitch(
       WebRtcRTPHeader* rtp_header,
       const uint8_t* payload_data,
-      const uint16_t payload_data_length,
-      const RtpVideoCodecTypes video_type,
-      const bool is_first_packet);
+      uint16_t payload_data_length,
+      bool is_first_packet);
 
   int32_t ReceiveGenericCodec(WebRtcRTPHeader* rtp_header,
                               const uint8_t* payload_data,
-                              const uint16_t payload_data_length);
+                              uint16_t payload_data_length);
 
   int32_t ReceiveVp8Codec(WebRtcRTPHeader* rtp_header,
                           const uint8_t* payload_data,
-                          const uint16_t payload_data_length);
+                          uint16_t payload_data_length);
 
   int32_t BuildRTPheader(const WebRtcRTPHeader* rtp_header,
                          uint8_t* data_buffer) const;
@@ -93,21 +85,17 @@
   int32_t ParseVideoCodecSpecific(
       WebRtcRTPHeader* rtp_header,
       const uint8_t* payload_data,
-      const uint16_t payload_data_length,
-      const RtpVideoCodecTypes video_type,
-      const bool is_red,
+      uint16_t payload_data_length,
+      RtpVideoCodecTypes video_type,
+      bool is_red,
       const uint8_t* incoming_rtp_packet,
-      const uint16_t incoming_rtp_packet_size,
-      const int64_t now_ms,
-      const bool is_first_packet);
+      uint16_t incoming_rtp_packet_size,
+      int64_t now_ms,
+      bool is_first_packet);
 
   int32_t id_;
-  const RTPPayloadRegistry* rtp_rtp_payload_registry_;
-
-  CriticalSectionWrapper* critical_section_receiver_video_;
 
   // FEC
-  bool current_fec_frame_decoded_;
   ReceiverFEC* receive_fec_;
 };
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_rtcp.gypi b/modules/rtp_rtcp/source/rtp_rtcp.gypi
index bc3320b..8c4f366 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp.gypi
+++ b/modules/rtp_rtcp/source/rtp_rtcp.gypi
@@ -28,11 +28,16 @@
       },
       'sources': [
         # Common
+        '../interface/receive_statistics.h',
         '../interface/rtp_header_parser.h',
+        '../interface/rtp_payload_registry.h',
+        '../interface/rtp_receiver.h',
         '../interface/rtp_rtcp.h',
         '../interface/rtp_rtcp_defines.h',
         'bitrate.cc',
         'bitrate.h',
+        'receive_statistics_impl.cc',
+        'receive_statistics_impl.h',
         'rtp_header_parser.cc',
         'rtp_rtcp_config.h',
         'rtp_rtcp_impl.cc',
@@ -47,8 +52,8 @@
         'rtcp_utility.h',
         'rtp_header_extension.cc',
         'rtp_header_extension.h',
-        'rtp_receiver.cc',
-        'rtp_receiver.h',
+        'rtp_receiver_impl.cc',
+        'rtp_receiver_impl.h',
         'rtp_sender.cc',
         'rtp_sender.h',
         'rtp_utility.cc',
@@ -75,7 +80,6 @@
         'producer_fec.h',
         'rtp_packet_history.cc',
         'rtp_packet_history.h',
-        'rtp_payload_registry.h',
         'rtp_payload_registry.cc',
         'rtp_receiver_strategy.cc',
         'rtp_receiver_strategy.h',
@@ -93,6 +97,7 @@
         'vp8_partition_aggregator.h',
         # Mocks
         '../mocks/mock_rtp_rtcp.h',
+        'mock/mock_rtp_payload_strategy.h',
       ], # source
       # TODO(jschuh): Bug 1348: fix size_t to int truncations.
       'msvs_disabled_warnings': [ 4267, ],
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index 99cadf2..6d6c520 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -14,8 +14,6 @@
 #include <string.h>
 
 #include "webrtc/common_types.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/system_wrappers/interface/trace.h"
 
@@ -38,28 +36,12 @@
 
 namespace webrtc {
 
-static RtpData* NullObjectRtpData() {
-  static NullRtpData null_rtp_data;
-  return &null_rtp_data;
-}
-
-static RtpFeedback* NullObjectRtpFeedback() {
-  static NullRtpFeedback null_rtp_feedback;
-  return &null_rtp_feedback;
-}
-
-static RtpAudioFeedback* NullObjectRtpAudioFeedback() {
-  static NullRtpAudioFeedback null_rtp_audio_feedback;
-  return &null_rtp_audio_feedback;
-}
-
 RtpRtcp::Configuration::Configuration()
     : id(-1),
       audio(false),
       clock(NULL),
       default_module(NULL),
-      incoming_data(NullObjectRtpData()),
-      incoming_messages(NullObjectRtpFeedback()),
+      receive_statistics(NULL),
       outgoing_transport(NULL),
       rtcp_feedback(NULL),
       intra_frame_callback(NULL),
@@ -85,10 +67,7 @@
 }
 
 ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
-    : rtp_payload_registry_(
-          configuration.id,
-          RTPPayloadStrategy::CreateStrategy(configuration.audio)),
-      rtp_sender_(configuration.id,
+    : rtp_sender_(configuration.id,
                   configuration.audio,
                   configuration.clock,
                   configuration.outgoing_transport,
@@ -98,14 +77,12 @@
                    this),
       rtcp_receiver_(configuration.id, configuration.clock, this),
       clock_(configuration.clock),
-      rtp_telephone_event_handler_(NULL),
+      receive_statistics_(configuration.receive_statistics),
       id_(configuration.id),
       audio_(configuration.audio),
       collision_detected_(false),
       last_process_time_(configuration.clock->TimeInMilliseconds()),
       last_bitrate_process_time_(configuration.clock->TimeInMilliseconds()),
-      last_packet_timeout_process_time_(
-          configuration.clock->TimeInMilliseconds()),
       last_rtt_process_time_(configuration.clock->TimeInMilliseconds()),
       packet_overhead_(28),  // IPV4 UDP.
       critical_section_module_ptrs_(
@@ -114,9 +91,6 @@
           CriticalSectionWrapper::CreateCriticalSection()),
       default_module_(
           static_cast<ModuleRtpRtcpImpl*>(configuration.default_module)),
-      dead_or_alive_active_(false),
-      dead_or_alive_timeout_ms_(0),
-      dead_or_alive_last_timer_(0),
       nack_method_(kNackOff),
       nack_last_time_sent_full_(0),
       nack_last_seq_number_sent_(0),
@@ -127,26 +101,6 @@
       , plot1_(NULL),
 #endif
       rtt_observer_(configuration.rtt_observer) {
-  RTPReceiverStrategy* rtp_receiver_strategy;
-  if (configuration.audio) {
-    // If audio, we need to be able to handle telephone events too, so stash
-    // away the audio receiver for those situations.
-    rtp_telephone_event_handler_ =
-        new RTPReceiverAudio(configuration.id, configuration.incoming_data,
-                             configuration.audio_messages);
-    rtp_receiver_strategy = rtp_telephone_event_handler_;
-  } else {
-    rtp_receiver_strategy =
-        new RTPReceiverVideo(configuration.id, &rtp_payload_registry_,
-                             configuration.incoming_data);
-  }
-  rtp_receiver_.reset(new RTPReceiver(
-      configuration.id, configuration.clock, this,
-      configuration.audio_messages, configuration.incoming_data,
-      configuration.incoming_messages, rtp_receiver_strategy,
-      &rtp_payload_registry_));
-
-
   send_video_codec_.codecType = kVideoCodecUnknown;
 
   if (default_module_) {
@@ -235,24 +189,14 @@
 
 // Process any pending tasks such as timeouts (non time critical events).
 int32_t ModuleRtpRtcpImpl::Process() {
-    const int64_t now = clock_->TimeInMilliseconds();
+  const int64_t now = clock_->TimeInMilliseconds();
   last_process_time_ = now;
 
-  if (now >=
-      last_packet_timeout_process_time_ + kRtpRtcpPacketTimeoutProcessTimeMs) {
-    rtp_receiver_->PacketTimeout();
-    rtcp_receiver_.PacketTimeout();
-    last_packet_timeout_process_time_ = now;
-  }
-
   if (now >= last_bitrate_process_time_ + kRtpRtcpBitrateProcessTimeMs) {
     rtp_sender_.ProcessBitrate();
-    rtp_receiver_->ProcessBitrate();
     last_bitrate_process_time_ = now;
   }
 
-  ProcessDeadOrAliveTimer();
-
   const bool default_instance(child_modules_.empty() ? false : true);
   if (!default_instance) {
     if (rtcp_sender_.Sending()) {
@@ -297,8 +241,14 @@
         }
       }
     }
-    if (rtcp_sender_.TimeToSendRTCPReport())
-      rtcp_sender_.SendRTCP(kRtcpReport);
+    if (rtcp_sender_.TimeToSendRTCPReport()) {
+      ReceiveStatistics::RtpReceiveStatistics receive_stats;
+      if (receive_statistics_->Statistics(&receive_stats, true)) {
+        rtcp_sender_.SendRTCP(kRtcpReport, &receive_stats);
+      } else {
+        rtcp_sender_.SendRTCP(kRtcpReport, NULL);
+      }
+    }
   }
 
   if (UpdateRTCPReceiveInformationTimers()) {
@@ -308,230 +258,6 @@
   return 0;
 }
 
-void ModuleRtpRtcpImpl::ProcessDeadOrAliveTimer() {
-  bool RTCPalive = false;
-  int64_t now = 0;
-  bool do_callback = false;
-
-  // Do operations on members under lock but avoid making the
-  // ProcessDeadOrAlive() callback under the same lock.
-  {
-    CriticalSectionScoped lock(critical_section_module_ptrs_.get());
-    if (dead_or_alive_active_) {
-      now = clock_->TimeInMilliseconds();
-      if (now > dead_or_alive_timeout_ms_ + dead_or_alive_last_timer_) {
-        // RTCP is alive if we have received a report the last 12 seconds.
-        dead_or_alive_last_timer_ += dead_or_alive_timeout_ms_;
-
-        if (rtcp_receiver_.LastReceived() + 12000 > now)
-          RTCPalive = true;
-
-        do_callback = true;
-      }
-    }
-  }
-
-  if (do_callback)
-    rtp_receiver_->ProcessDeadOrAlive(RTCPalive, now);
-}
-
-int32_t ModuleRtpRtcpImpl::SetPeriodicDeadOrAliveStatus(
-    const bool enable,
-    const uint8_t sample_time_seconds) {
-  if (enable) {
-    WEBRTC_TRACE(kTraceModuleCall,
-                 kTraceRtpRtcp,
-                 id_,
-                 "SetPeriodicDeadOrAliveStatus(enable, %d)",
-                 sample_time_seconds);
-  } else {
-    WEBRTC_TRACE(kTraceModuleCall,
-                 kTraceRtpRtcp,
-                 id_,
-                 "SetPeriodicDeadOrAliveStatus(disable)");
-  }
-  if (sample_time_seconds == 0) {
-    return -1;
-  }
-  {
-    CriticalSectionScoped lock(critical_section_module_ptrs_.get());
-    dead_or_alive_active_ = enable;
-    dead_or_alive_timeout_ms_ = sample_time_seconds * 1000;
-    // Trigger the first after one period.
-    dead_or_alive_last_timer_ = clock_->TimeInMilliseconds();
-  }
-  return 0;
-}
-
-int32_t ModuleRtpRtcpImpl::PeriodicDeadOrAliveStatus(
-    bool& enable,
-    uint8_t& sample_time_seconds) {
-  WEBRTC_TRACE(kTraceModuleCall,
-               kTraceRtpRtcp,
-               id_,
-               "PeriodicDeadOrAliveStatus()");
-
-  enable = dead_or_alive_active_;
-  sample_time_seconds =
-      static_cast<uint8_t>(dead_or_alive_timeout_ms_ / 1000);
-  return 0;
-}
-
-int32_t ModuleRtpRtcpImpl::SetPacketTimeout(
-    const uint32_t rtp_timeout_ms,
-    const uint32_t rtcp_timeout_ms) {
-  WEBRTC_TRACE(kTraceModuleCall,
-               kTraceRtpRtcp,
-               id_,
-               "SetPacketTimeout(%u,%u)",
-               rtp_timeout_ms,
-               rtcp_timeout_ms);
-
-  if (rtp_receiver_->SetPacketTimeout(rtp_timeout_ms) == 0) {
-    return rtcp_receiver_.SetPacketTimeout(rtcp_timeout_ms);
-  }
-  return -1;
-}
-
-int32_t ModuleRtpRtcpImpl::RegisterReceivePayload(
-    const CodecInst& voice_codec) {
-  WEBRTC_TRACE(kTraceModuleCall,
-               kTraceRtpRtcp,
-               id_,
-               "RegisterReceivePayload(voice_codec)");
-
-  return rtp_receiver_->RegisterReceivePayload(
-      voice_codec.plname,
-      voice_codec.pltype,
-      voice_codec.plfreq,
-      voice_codec.channels,
-      (voice_codec.rate < 0) ? 0 : voice_codec.rate);
-}
-
-int32_t ModuleRtpRtcpImpl::RegisterReceivePayload(
-    const VideoCodec& video_codec) {
-  WEBRTC_TRACE(kTraceModuleCall,
-               kTraceRtpRtcp,
-               id_,
-               "RegisterReceivePayload(video_codec)");
-
-  return rtp_receiver_->RegisterReceivePayload(video_codec.plName,
-                                               video_codec.plType,
-                                               90000,
-                                               0,
-                                               video_codec.maxBitrate);
-}
-
-int32_t ModuleRtpRtcpImpl::ReceivePayloadType(
-    const CodecInst& voice_codec,
-  int8_t* pl_type) {
-  WEBRTC_TRACE(kTraceModuleCall,
-               kTraceRtpRtcp,
-               id_,
-               "ReceivePayloadType(voice_codec)");
-
-  return rtp_receiver_->ReceivePayloadType(
-           voice_codec.plname,
-           voice_codec.plfreq,
-           voice_codec.channels,
-           (voice_codec.rate < 0) ? 0 : voice_codec.rate,
-           pl_type);
-}
-
-int32_t ModuleRtpRtcpImpl::ReceivePayloadType(
-    const VideoCodec& video_codec,
-  int8_t* pl_type) {
-  WEBRTC_TRACE(kTraceModuleCall,
-               kTraceRtpRtcp,
-               id_,
-               "ReceivePayloadType(video_codec)");
-
-  return rtp_receiver_->ReceivePayloadType(video_codec.plName,
-                                           90000,
-                                           0,
-                                           video_codec.maxBitrate,
-                                           pl_type);
-}
-
-int32_t ModuleRtpRtcpImpl::DeRegisterReceivePayload(
-    const int8_t payload_type) {
-  WEBRTC_TRACE(kTraceModuleCall,
-               kTraceRtpRtcp,
-               id_,
-               "DeRegisterReceivePayload(%d)",
-               payload_type);
-
-  return rtp_receiver_->DeRegisterReceivePayload(payload_type);
-}
-
-// Get the currently configured SSRC filter.
-int32_t ModuleRtpRtcpImpl::SSRCFilter(
-    uint32_t& allowed_ssrc) const {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SSRCFilter()");
-
-  return rtp_receiver_->SSRCFilter(allowed_ssrc);
-}
-
-// Set a SSRC to be used as a filter for incoming RTP streams.
-int32_t ModuleRtpRtcpImpl::SetSSRCFilter(
-    const bool enable,
-    const uint32_t allowed_ssrc) {
-  if (enable) {
-    WEBRTC_TRACE(kTraceModuleCall,
-                 kTraceRtpRtcp,
-                 id_,
-                 "SetSSRCFilter(enable, 0x%x)",
-                 allowed_ssrc);
-  } else {
-    WEBRTC_TRACE(kTraceModuleCall,
-                 kTraceRtpRtcp,
-                 id_,
-                 "SetSSRCFilter(disable)");
-  }
-
-  return rtp_receiver_->SetSSRCFilter(enable, allowed_ssrc);
-}
-
-// Get last received remote timestamp.
-uint32_t ModuleRtpRtcpImpl::RemoteTimestamp() const {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RemoteTimestamp()");
-
-  return rtp_receiver_->TimeStamp();
-}
-
-int64_t ModuleRtpRtcpImpl::LocalTimeOfRemoteTimeStamp() const {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
-               "LocalTimeOfRemoteTimeStamp()");
-
-  return rtp_receiver_->LastReceivedTimeMs();
-}
-
-// Get the current estimated remote timestamp.
-int32_t ModuleRtpRtcpImpl::EstimatedRemoteTimeStamp(
-    uint32_t& timestamp) const {
-  WEBRTC_TRACE(kTraceModuleCall,
-               kTraceRtpRtcp,
-               id_,
-               "EstimatedRemoteTimeStamp()");
-
-  return rtp_receiver_->EstimatedRemoteTimeStamp(timestamp);
-}
-
-// Get incoming SSRC.
-uint32_t ModuleRtpRtcpImpl::RemoteSSRC() const {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RemoteSSRC()");
-
-  return rtp_receiver_->SSRC();
-}
-
-// Get remote CSRC
-int32_t ModuleRtpRtcpImpl::RemoteCSRCs(
-    uint32_t arr_of_csrc[kRtpCsrcSize]) const {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RemoteCSRCs()");
-
-  return rtp_receiver_->CSRCs(arr_of_csrc);
-}
-
 int32_t ModuleRtpRtcpImpl::SetRTXSendStatus(RtxMode mode, bool set_ssrc,
                                             uint32_t ssrc) {
   rtp_sender_.SetRTXStatus(mode, set_ssrc, ssrc);
@@ -544,42 +270,10 @@
   return 0;
 }
 
-int32_t ModuleRtpRtcpImpl::SetRTXReceiveStatus(bool enable,
-                                               uint32_t ssrc) {
-  rtp_receiver_->SetRTXStatus(enable, ssrc);
-  return 0;
-}
-
-int32_t ModuleRtpRtcpImpl::RTXReceiveStatus(bool* enable, uint32_t* ssrc,
-                                            int* payload_type) const {
-  rtp_receiver_->RTXStatus(enable, ssrc, payload_type);
-  return 0;
-}
-
 void ModuleRtpRtcpImpl::SetRtxSendPayloadType(int payload_type) {
   rtp_sender_.SetRtxPayloadType(payload_type);
 }
 
-void ModuleRtpRtcpImpl::SetRtxReceivePayloadType(int payload_type) {
-  rtp_receiver_->SetRtxPayloadType(payload_type);
-}
-
-// Called by the network module when we receive a packet.
-int32_t ModuleRtpRtcpImpl::IncomingRtpPacket(
-    const uint8_t* incoming_packet,
-    const uint16_t incoming_packet_length,
-    const RTPHeader& parsed_rtp_header) {
-  WEBRTC_TRACE(kTraceStream,
-               kTraceRtpRtcp,
-               id_,
-               "IncomingRtpPacket(packet_length:%u)",
-               incoming_packet_length);
-  RTPHeader rtp_header_copy = parsed_rtp_header;
-  return rtp_receiver_->IncomingRTPPacket(&rtp_header_copy,
-                                          incoming_packet,
-                                          incoming_packet_length);
-}
-
 int32_t ModuleRtpRtcpImpl::IncomingRtcpPacket(
     const uint8_t* rtcp_packet,
     const uint16_t length) {
@@ -882,7 +576,12 @@
   if (!have_child_modules) {
     // Don't send RTCP from default module.
     if (rtcp_sender_.TimeToSendRTCPReport(kVideoFrameKey == frame_type)) {
-      rtcp_sender_.SendRTCP(kRtcpReport);
+      ReceiveStatistics::RtpReceiveStatistics receive_stats;
+      if (receive_statistics_->Statistics(&receive_stats, true)) {
+        rtcp_sender_.SendRTCP(kRtcpReport, &receive_stats);
+      } else {
+        rtcp_sender_.SendRTCP(kRtcpReport, NULL);
+      }
     }
     return rtp_sender_.SendOutgoingData(frame_type,
                                         payload_type,
@@ -1185,12 +884,6 @@
   return rtcp_receiver_.CNAME(remote_ssrc, c_name);
 }
 
-uint16_t ModuleRtpRtcpImpl::RemoteSequenceNumber() const {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "RemoteSequenceNumber()");
-
-  return rtp_receiver_->SequenceNumber();
-}
-
 int32_t ModuleRtpRtcpImpl::RemoteNTP(
     uint32_t* received_ntpsecs,
     uint32_t* received_ntpfrac,
@@ -1230,21 +923,6 @@
   rtcp_receiver_.SetRTT(static_cast<uint16_t>(rtt));
 }
 
-// Reset RTP statistics.
-int32_t ModuleRtpRtcpImpl::ResetStatisticsRTP() {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "ResetStatisticsRTP()");
-
-  return rtp_receiver_->ResetStatistics();
-}
-
-// Reset RTP data counters for the receiving side.
-int32_t ModuleRtpRtcpImpl::ResetReceiveDataCountersRTP() {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
-               "ResetReceiveDataCountersRTP()");
-
-  return rtp_receiver_->ResetDataCounters();
-}
-
 // Reset RTP data counters for the sending side.
 int32_t ModuleRtpRtcpImpl::ResetSendDataCountersRTP() {
   WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
@@ -1259,8 +937,18 @@
 int32_t ModuleRtpRtcpImpl::SendRTCP(uint32_t rtcp_packet_type) {
   WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "SendRTCP(0x%x)",
                rtcp_packet_type);
-
-  return  rtcp_sender_.SendRTCP(rtcp_packet_type);
+  ReceiveStatistics::RtpReceiveStatistics receive_stats;
+  if (rtcp_sender_.Status() == kRtcpCompound ||
+      (rtcp_packet_type & kRtcpReport) ||
+      (rtcp_packet_type & kRtcpSr) ||
+      (rtcp_packet_type & kRtcpRr)) {
+    if (receive_statistics_->Statistics(&receive_stats, true)) {
+      return rtcp_sender_.SendRTCP(rtcp_packet_type, &receive_stats);
+    } else {
+      return rtcp_sender_.SendRTCP(rtcp_packet_type, NULL);
+    }
+  }
+  return rtcp_sender_.SendRTCP(rtcp_packet_type, NULL);
 }
 
 int32_t ModuleRtpRtcpImpl::SetRTCPApplicationSpecificData(
@@ -1283,32 +971,9 @@
   return  rtcp_sender_.SetRTCPVoIPMetrics(voip_metric);
 }
 
-// Our locally created statistics of the received RTP stream.
-int32_t ModuleRtpRtcpImpl::StatisticsRTP(
-    uint8_t*  fraction_lost,
-    uint32_t* cum_lost,
-    uint32_t* ext_max,
-    uint32_t* jitter,
-    uint32_t* max_jitter) const {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "StatisticsRTP()");
-
-  uint32_t jitter_transmission_time_offset = 0;
-
-  int32_t ret_val = rtp_receiver_->Statistics(
-      fraction_lost, cum_lost, ext_max, jitter, max_jitter,
-      &jitter_transmission_time_offset, (rtcp_sender_.Status() == kRtcpOff));
-  if (ret_val == -1) {
-    WEBRTC_TRACE(kTraceWarning, kTraceRtpRtcp, id_,
-                 "StatisticsRTP() no statistics available");
-  }
-  return ret_val;
-}
-
 int32_t ModuleRtpRtcpImpl::DataCountersRTP(
     uint32_t* bytes_sent,
-    uint32_t* packets_sent,
-    uint32_t* bytes_received,
-    uint32_t* packets_received) const {
+    uint32_t* packets_sent) const {
   WEBRTC_TRACE(kTraceStream, kTraceRtpRtcp, id_, "DataCountersRTP()");
 
   if (bytes_sent) {
@@ -1317,36 +982,7 @@
   if (packets_sent) {
     *packets_sent = rtp_sender_.Packets();
   }
-  return rtp_receiver_->DataCounters(bytes_received, packets_received);
-}
-
-int32_t ModuleRtpRtcpImpl::ReportBlockStatistics(
-    uint8_t* fraction_lost,
-    uint32_t* cum_lost,
-    uint32_t* ext_max,
-    uint32_t* jitter,
-    uint32_t* jitter_transmission_time_offset) {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "ReportBlockStatistics()");
-  int32_t missing = 0;
-  int32_t ret = rtp_receiver_->Statistics(fraction_lost,
-                                          cum_lost,
-                                          ext_max,
-                                          jitter,
-                                          NULL,
-                                          jitter_transmission_time_offset,
-                                          &missing,
-                                                true);
-
-#ifdef MATLAB
-  if (plot1_ == NULL) {
-    plot1_ = eng.NewPlot(new MatlabPlot());
-    plot1_->AddTimeLine(30, "b", "lost", clock_->TimeInMilliseconds());
-  }
-  plot1_->Append("lost", missing);
-  plot1_->Plot();
-#endif
-
-  return ret;
+  return 0;
 }
 
 int32_t ModuleRtpRtcpImpl::RemoteRTCPStat(RTCPSenderInfo* sender_info) {
@@ -1461,52 +1097,6 @@
   return rtcp_sender_.SetTMMBN(bounding_set, max_bitrate_kbit);
 }
 
-// (NACK) Negative acknowledgment.
-
-// Is Negative acknowledgment requests on/off?
-NACKMethod ModuleRtpRtcpImpl::NACK() const {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_, "NACK()");
-
-  NACKMethod child_method = kNackOff;
-  const bool default_instance(child_modules_.empty() ? false : true);
-  if (default_instance) {
-    // For default we need to check all child modules too.
-    CriticalSectionScoped lock(critical_section_module_ptrs_.get());
-    std::list<ModuleRtpRtcpImpl*>::const_iterator it =
-      child_modules_.begin();
-    while (it != child_modules_.end()) {
-      RtpRtcp* module = *it;
-      if (module) {
-        NACKMethod nackMethod = module->NACK();
-        if (nackMethod != kNackOff) {
-          child_method = nackMethod;
-          break;
-        }
-      }
-      it++;
-    }
-  }
-
-  NACKMethod method = nack_method_;
-  if (child_method != kNackOff) {
-    method = child_method;
-  }
-  return method;
-}
-
-// Turn negative acknowledgment requests on/off.
-int32_t ModuleRtpRtcpImpl::SetNACKStatus(
-    NACKMethod method, int max_reordering_threshold) {
-  WEBRTC_TRACE(kTraceModuleCall,
-               kTraceRtpRtcp,
-               id_,
-               "SetNACKStatus(%u)", method);
-
-  nack_method_ = method;
-  rtp_receiver_->SetNACKStatus(method, max_reordering_threshold);
-  return 0;
-}
-
 // Returns the currently configured retransmission mode.
 int ModuleRtpRtcpImpl::SelectiveRetransmissions() const {
   WEBRTC_TRACE(kTraceModuleCall,
@@ -1536,7 +1126,7 @@
                "SendNACK(size:%u)", size);
 
   uint16_t avg_rtt = 0;
-  rtcp_receiver_.RTT(rtp_receiver_->SSRC(), NULL, &avg_rtt, NULL, NULL);
+  rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &avg_rtt, NULL, NULL);
 
   int64_t wait_time = 5 + ((avg_rtt * 3) >> 1);  // 5 + RTT * 1.5.
   if (wait_time == 5) {
@@ -1575,13 +1165,15 @@
   }
   nack_last_seq_number_sent_ = nack_list[start_id + nackLength - 1];
 
-  switch (nack_method_) {
-    case kNackRtcp:
-      return rtcp_sender_.SendRTCP(kRtcpNack, nackLength, &nack_list[start_id]);
-    case kNackOff:
-      return -1;
-  };
-  return -1;
+  ReceiveStatistics::RtpReceiveStatistics receive_stats;
+  if (rtcp_sender_.Status() == kRtcpCompound &&
+      receive_statistics_->Statistics(&receive_stats, true)) {
+    return rtcp_sender_.SendRTCP(kRtcpNack, &receive_stats, nackLength,
+                                 &nack_list[start_id]);
+  } else {
+    return rtcp_sender_.SendRTCP(kRtcpNack, NULL, nackLength,
+                                 &nack_list[start_id]);
+  }
 }
 
 // Store the sent packets, needed to answer to a Negative acknowledgment
@@ -1601,29 +1193,6 @@
   return 0;  // TODO(pwestin): change to void.
 }
 
-// Forward DTMFs to decoder for playout.
-int ModuleRtpRtcpImpl::SetTelephoneEventForwardToDecoder(
-    bool forward_to_decoder) {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
-               "SetTelephoneEventForwardToDecoder(forward_to_decoder:%d)",
-               forward_to_decoder);
-
-  assert(audio_);
-  assert(rtp_telephone_event_handler_);
-  return rtp_telephone_event_handler_->SetTelephoneEventForwardToDecoder(
-      forward_to_decoder);
-}
-
-// Is forwarding of out-band telephone events turned on/off?
-bool ModuleRtpRtcpImpl::TelephoneEventForwardToDecoder() const {
-  WEBRTC_TRACE(kTraceModuleCall, kTraceRtpRtcp, id_,
-               "TelephoneEventForwardToDecoder()");
-
-  assert(audio_);
-  assert(rtp_telephone_event_handler_);
-  return rtp_telephone_event_handler_->TelephoneEventForwardToDecoder();
-}
-
 // Send a TelephoneEvent tone using RFC 2833 (4733).
 int32_t ModuleRtpRtcpImpl::SendTelephoneEventOutband(
     const uint8_t key,
@@ -1716,10 +1285,6 @@
   return rtp_sender_.RED(&payload_type);
 }
 
-RtpVideoCodecTypes ModuleRtpRtcpImpl::ReceivedVideoCodec() const {
-  return rtp_receiver_->VideoCodecType();
-}
-
 RtpVideoCodecTypes ModuleRtpRtcpImpl::SendVideoCodec() const {
   return rtp_sender_.VideoCodecType();
 }
@@ -1785,9 +1350,9 @@
     case kKeyFrameReqFirRtp:
       return rtp_sender_.SendRTPIntraRequest();
     case kKeyFrameReqPliRtcp:
-      return rtcp_sender_.SendRTCP(kRtcpPli);
+      return SendRTCP(kRtcpPli);
     case kKeyFrameReqFirRtcp:
-      return rtcp_sender_.SendRTCP(kRtcpFir);
+      return SendRTCP(kRtcpFir);
   }
   return -1;
 }
@@ -1799,7 +1364,14 @@
                id_,
                "SendRTCPSliceLossIndication (picture_id:%d)",
                picture_id);
-  return rtcp_sender_.SendRTCP(kRtcpSli, 0, 0, false, picture_id);
+  ReceiveStatistics::RtpReceiveStatistics receive_stats;
+  if (rtcp_sender_.Status() == kRtcpCompound &&
+      receive_statistics_->Statistics(&receive_stats, true)) {
+    return rtcp_sender_.SendRTCP(kRtcpSli, &receive_stats, 0, 0, false,
+                                 picture_id);
+  } else {
+    return rtcp_sender_.SendRTCP(kRtcpSli, NULL, 0, 0, false, picture_id);
+  }
 }
 
 int32_t ModuleRtpRtcpImpl::SetCameraDelay(const int32_t delay_ms) {
@@ -1923,7 +1495,7 @@
     }
     if (kRtcpOff != rtcp_sender_.Status()) {
       // Send RTCP bye on the current SSRC.
-      rtcp_sender_.SendRTCP(kRtcpBye);
+      SendRTCP(kRtcpBye);
     }
     // Change local SSRC and inform all objects about the new SSRC.
     rtcp_sender_.SetSSRC(new_ssrc);
@@ -1931,10 +1503,6 @@
   }
 }
 
-uint32_t ModuleRtpRtcpImpl::BitrateReceivedNow() const {
-  return rtp_receiver_->BitrateNow();
-}
-
 void ModuleRtpRtcpImpl::BitrateSent(uint32_t* total_rate,
                                     uint32_t* video_rate,
                                     uint32_t* fec_rate,
@@ -1996,12 +1564,19 @@
 }
 
 void ModuleRtpRtcpImpl::OnRequestSendReport() {
-  rtcp_sender_.SendRTCP(kRtcpSr);
+  SendRTCP(kRtcpSr);
 }
 
 int32_t ModuleRtpRtcpImpl::SendRTCPReferencePictureSelection(
     const uint64_t picture_id) {
-  return rtcp_sender_.SendRTCP(kRtcpRpsi, 0, 0, false, picture_id);
+  ReceiveStatistics::RtpReceiveStatistics receive_stats;
+  if (rtcp_sender_.Status() == kRtcpCompound &&
+      receive_statistics_->Statistics(&receive_stats, true)) {
+    return rtcp_sender_.SendRTCP(kRtcpRpsi, &receive_stats, 0, 0, false,
+                                 picture_id);
+  } else {
+    return rtcp_sender_.SendRTCP(kRtcpRpsi, NULL, 0, 0, false, picture_id);
+  }
 }
 
 uint32_t ModuleRtpRtcpImpl::SendTimeOfSendReport(
@@ -2016,7 +1591,7 @@
     return;
   }
   uint16_t avg_rtt = 0;
-  rtcp_receiver_.RTT(rtp_receiver_->SSRC(), NULL, &avg_rtt, NULL, NULL);
+  rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &avg_rtt, NULL, NULL);
   rtp_sender_.OnReceivedNACK(nack_sequence_numbers, avg_rtt);
 }
 
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/modules/rtp_rtcp/source/rtp_rtcp_impl.h
index c70f7cb..fd70751 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.h
@@ -17,8 +17,6 @@
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_payload_registry.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
 
@@ -43,72 +41,12 @@
 
   // Receiver part.
 
-  // Configure a timeout value.
-  virtual int32_t SetPacketTimeout(const uint32_t rtp_timeout_ms,
-                                   const uint32_t rtcp_timeout_ms);
-
-  // Set periodic dead or alive notification.
-  virtual int32_t SetPeriodicDeadOrAliveStatus(
-      const bool enable,
-      const uint8_t sample_time_seconds);
-
-  // Get periodic dead or alive notification status.
-  virtual int32_t PeriodicDeadOrAliveStatus(
-      bool& enable,
-      uint8_t& sample_time_seconds);
-
-  virtual int32_t RegisterReceivePayload(const CodecInst& voice_codec);
-
-  virtual int32_t RegisterReceivePayload(const VideoCodec& video_codec);
-
-  virtual int32_t ReceivePayloadType(const CodecInst& voice_codec,
-                                     int8_t* pl_type);
-
-  virtual int32_t ReceivePayloadType(const VideoCodec& video_codec,
-                                     int8_t* pl_type);
-
-  virtual int32_t DeRegisterReceivePayload(
-      const int8_t payload_type);
-
-  // Get the currently configured SSRC filter.
-  virtual int32_t SSRCFilter(uint32_t& allowed_ssrc) const;
-
-  // Set a SSRC to be used as a filter for incoming RTP streams.
-  virtual int32_t SetSSRCFilter(const bool enable,
-                                const uint32_t allowed_ssrc);
-
-  // Get last received remote timestamp.
-  virtual uint32_t RemoteTimestamp() const;
-
-  // Get the local time of the last received remote timestamp.
-  virtual int64_t LocalTimeOfRemoteTimeStamp() const;
-
-  // Get the current estimated remote timestamp.
-  virtual int32_t EstimatedRemoteTimeStamp(
-      uint32_t& timestamp) const;
-
-  virtual uint32_t RemoteSSRC() const;
-
-  virtual int32_t RemoteCSRCs(
-      uint32_t arr_of_csrc[kRtpCsrcSize]) const;
-
-  virtual int32_t SetRTXReceiveStatus(const bool enable,
-                                      const uint32_t ssrc);
-
-  virtual int32_t RTXReceiveStatus(bool* enable, uint32_t* ssrc,
-                                   int* payloadType) const;
-
-  virtual void SetRtxReceivePayloadType(int payload_type);
-
-  // Called when we receive an RTP packet.
-  virtual int32_t IncomingRtpPacket(const uint8_t* incoming_packet,
-                                    const uint16_t packet_length,
-                                    const RTPHeader& parsed_rtp_header);
-
   // Called when we receive an RTCP packet.
   virtual int32_t IncomingRtcpPacket(const uint8_t* incoming_packet,
                                      uint16_t incoming_packet_length);
 
+  virtual void SetRemoteSSRC(const uint32_t ssrc);
+
   // Sender part.
 
   virtual int32_t RegisterSendPayload(const CodecInst& voice_codec);
@@ -239,32 +177,11 @@
   // Normal SR and RR are triggered via the process function.
   virtual int32_t SendRTCP(uint32_t rtcp_packet_type = kRtcpReport);
 
-  // Statistics of our locally created statistics of the received RTP stream.
-  virtual int32_t StatisticsRTP(uint8_t*  fraction_lost,
-                                uint32_t* cum_lost,
-                                uint32_t* ext_max,
-                                uint32_t* jitter,
-                                uint32_t* max_jitter = NULL) const;
-
-  // Reset RTP statistics.
-  virtual int32_t ResetStatisticsRTP();
-
-  virtual int32_t ResetReceiveDataCountersRTP();
-
   virtual int32_t ResetSendDataCountersRTP();
 
   // Statistics of the amount of data sent and received.
   virtual int32_t DataCountersRTP(uint32_t* bytes_sent,
-                                  uint32_t* packets_sent,
-                                  uint32_t* bytes_received,
-                                  uint32_t* packets_received) const;
-
-  virtual int32_t ReportBlockStatistics(
-      uint8_t* fraction_lost,
-      uint32_t* cum_lost,
-      uint32_t* ext_max,
-      uint32_t* jitter,
-      uint32_t* jitter_transmission_time_offset);
+                                  uint32_t* packets_sent) const;
 
   // Get received RTCP report, sender info.
   virtual int32_t RemoteRTCPStat(RTCPSenderInfo* sender_info);
@@ -313,13 +230,6 @@
 
   // (NACK) Negative acknowledgment part.
 
-  // Is Negative acknowledgment requests on/off?
-  virtual NACKMethod NACK() const;
-
-  // Turn negative acknowledgment requests on/off.
-  virtual int32_t SetNACKStatus(const NACKMethod method,
-                                int max_reordering_threshold);
-
   virtual int SelectiveRetransmissions() const;
 
   virtual int SetSelectiveRetransmissions(uint8_t settings);
@@ -349,12 +259,6 @@
   virtual int32_t SetAudioPacketSize(
       const uint16_t packet_size_samples);
 
-  // Forward DTMFs to decoder for playout.
-  virtual int SetTelephoneEventForwardToDecoder(bool forward_to_decoder);
-
-  // Is forwarding of outband telephone events turned on/off?
-  virtual bool TelephoneEventForwardToDecoder() const;
-
   virtual bool SendTelephoneEventActive(int8_t& telephone_event) const;
 
   // Send a TelephoneEvent tone using RFC 2833 (4733).
@@ -382,8 +286,6 @@
 
   // Video part.
 
-  virtual RtpVideoCodecTypes ReceivedVideoCodec() const;
-
   virtual RtpVideoCodecTypes SendVideoCodec() const;
 
   virtual int32_t SendRTCPSliceLossIndication(
@@ -425,8 +327,6 @@
                            uint32_t* fec_rate,
                            uint32_t* nackRate) const;
 
-  virtual void SetRemoteSSRC(const uint32_t ssrc);
-
   virtual uint32_t SendTimeOfSendReport(const uint32_t send_report);
 
   // Good state of RTP receiver inform sender.
@@ -456,8 +356,6 @@
 
   bool UpdateRTCPReceiveInformationTimers();
 
-  void ProcessDeadOrAliveTimer();
-
   uint32_t BitrateReceivedNow() const;
 
   // Get remote SequenceNumber.
@@ -466,10 +364,7 @@
   // Only for internal testing.
   uint32_t LastSendReport(uint32_t& last_rtcptime);
 
-  RTPPayloadRegistry        rtp_payload_registry_;
-
   RTPSender                 rtp_sender_;
-  scoped_ptr<RTPReceiver>   rtp_receiver_;
 
   RTCPSender                rtcp_sender_;
   RTCPReceiver              rtcp_receiver_;
@@ -479,14 +374,13 @@
  private:
   int64_t RtcpReportInterval();
 
-  RTPReceiverAudio*         rtp_telephone_event_handler_;
+  ReceiveStatistics* receive_statistics_;
 
   int32_t             id_;
   const bool                audio_;
   bool                      collision_detected_;
   int64_t             last_process_time_;
   int64_t             last_bitrate_process_time_;
-  int64_t             last_packet_timeout_process_time_;
   int64_t             last_rtt_process_time_;
   uint16_t            packet_overhead_;
 
@@ -495,10 +389,6 @@
   ModuleRtpRtcpImpl*            default_module_;
   std::list<ModuleRtpRtcpImpl*> child_modules_;
 
-  // Dead or alive.
-  bool                  dead_or_alive_active_;
-  uint32_t        dead_or_alive_timeout_ms_;
-  int64_t         dead_or_alive_last_timer_;
   // Send side
   NACKMethod            nack_method_;
   uint32_t        nack_last_time_sent_full_;
diff --git a/modules/rtp_rtcp/source/rtp_sender.cc b/modules/rtp_rtcp/source/rtp_sender.cc
index b72aa35..278cada 100644
--- a/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/modules/rtp_rtcp/source/rtp_sender.cc
@@ -350,7 +350,7 @@
       return 0;
     }
   }
-  RtpVideoCodecTypes video_type = kRtpGenericVideo;
+  RtpVideoCodecTypes video_type = kRtpVideoGeneric;
   if (CheckPayloadType(payload_type, &video_type) != 0) {
     WEBRTC_TRACE(kTraceError, kTraceRtpRtcp, id_,
                  "%s invalid argument failed to find payload_type:%d",
@@ -1183,7 +1183,7 @@
       }
       frequency_hz = frequency;
     } else {
-      frequency_hz = kDefaultVideoFrequency;
+      frequency_hz = kVideoPayloadTypeFrequency;
     }
     uint32_t RTPtime = ModuleRTPUtility::GetCurrentRTP(clock_, frequency_hz);
 
diff --git a/modules/rtp_rtcp/source/rtp_sender_video.cc b/modules/rtp_rtcp/source/rtp_sender_video.cc
index 1db4377..2d2c8d9 100644
--- a/modules/rtp_rtcp/source/rtp_sender_video.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_video.cc
@@ -37,7 +37,7 @@
     _rtpSender(*rtpSender),
     _sendVideoCritsect(CriticalSectionWrapper::CreateCriticalSection()),
 
-    _videoType(kRtpGenericVideo),
+    _videoType(kRtpVideoGeneric),
     _videoCodecInformation(NULL),
     _maxBitrate(0),
     _retransmissionSettings(kRetransmitBaseLayer),
@@ -89,13 +89,13 @@
     ModuleRTPUtility::Payload*& payload) {
   CriticalSectionScoped cs(_sendVideoCritsect);
 
-  RtpVideoCodecTypes videoType = kRtpGenericVideo;
+  RtpVideoCodecTypes videoType = kRtpVideoGeneric;
   if (ModuleRTPUtility::StringCompare(payloadName, "VP8",3)) {
-    videoType = kRtpVp8Video;
+    videoType = kRtpVideoVp8;
   } else if (ModuleRTPUtility::StringCompare(payloadName, "I420", 4)) {
-    videoType = kRtpGenericVideo;
+    videoType = kRtpVideoGeneric;
   } else {
-    videoType = kRtpGenericVideo;
+    videoType = kRtpVideoGeneric;
   }
   payload = new ModuleRTPUtility::Payload;
   payload->name[RTP_PAYLOAD_NAME_SIZE - 1] = 0;
@@ -302,11 +302,11 @@
     int32_t retVal = -1;
     switch(videoType)
     {
-    case kRtpGenericVideo:
+    case kRtpVideoGeneric:
         retVal = SendGeneric(frameType, payloadType, captureTimeStamp,
                              capture_time_ms, payloadData, payloadSize);
         break;
-    case kRtpVp8Video:
+    case kRtpVideoVp8:
         retVal = SendVP8(frameType,
                          payloadType,
                          captureTimeStamp,
diff --git a/modules/rtp_rtcp/source/rtp_utility.cc b/modules/rtp_rtcp/source/rtp_utility.cc
index 4a3a143..25afd73 100644
--- a/modules/rtp_rtcp/source/rtp_utility.cc
+++ b/modules/rtp_rtcp/source/rtp_utility.cc
@@ -46,6 +46,21 @@
 
 namespace webrtc {
 
+RtpData* NullObjectRtpData() {
+  static NullRtpData null_rtp_data;
+  return &null_rtp_data;
+}
+
+RtpFeedback* NullObjectRtpFeedback() {
+  static NullRtpFeedback null_rtp_feedback;
+  return &null_rtp_feedback;
+}
+
+RtpAudioFeedback* NullObjectRtpAudioFeedback() {
+  static NullRtpAudioFeedback null_rtp_audio_feedback;
+  return &null_rtp_audio_feedback;
+}
+
 namespace ModuleRTPUtility {
 
 enum {
@@ -188,9 +203,9 @@
   type = videoType;
 
   switch (type) {
-    case kRtpGenericVideo:
+    case kRtpVideoGeneric:
       break;
-    case kRtpVp8Video: {
+    case kRtpVideoVp8: {
       info.VP8.nonReferenceFrame = false;
       info.VP8.beginningOfPartition = false;
       info.VP8.partitionID = 0;
@@ -567,9 +582,9 @@
   parsedPacket.SetType(_videoType);
 
   switch (_videoType) {
-    case kRtpGenericVideo:
+    case kRtpVideoGeneric:
       return ParseGeneric(parsedPacket);
-    case kRtpVp8Video:
+    case kRtpVideoVp8:
       return ParseVP8(parsedPacket);
     default:
       return false;
diff --git a/modules/rtp_rtcp/source/rtp_utility.h b/modules/rtp_rtcp/source/rtp_utility.h
index 3bae732..e95830e 100644
--- a/modules/rtp_rtcp/source/rtp_utility.h
+++ b/modules/rtp_rtcp/source/rtp_utility.h
@@ -19,15 +19,13 @@
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
-enum RtpVideoCodecTypes
-{
-    kRtpGenericVideo  = 0,
-    kRtpFecVideo      = 10,
-    kRtpVp8Video      = 11
-};
 
 const uint8_t kRtpMarkerBitMask = 0x80;
 
+RtpData* NullObjectRtpData();
+RtpFeedback* NullObjectRtpFeedback();
+RtpAudioFeedback* NullObjectRtpAudioFeedback();
+
 namespace ModuleRTPUtility
 {
     // January 1970, in NTP seconds.
@@ -36,22 +34,6 @@
     // Magic NTP fractional unit.
     const double NTP_FRAC = 4.294967296E+9;
 
-    struct AudioPayload
-    {
-        uint32_t    frequency;
-        uint8_t     channels;
-        uint32_t    rate;
-    };
-    struct VideoPayload
-    {
-        RtpVideoCodecTypes   videoCodecType;
-        uint32_t       maxRate;
-    };
-    union PayloadUnion
-    {
-        AudioPayload Audio;
-        VideoPayload Video;
-    };
     struct Payload
     {
         char name[RTP_PAYLOAD_NAME_SIZE];
diff --git a/modules/rtp_rtcp/source/rtp_utility_unittest.cc b/modules/rtp_rtcp/source/rtp_utility_unittest.cc
index b7b3db8..02a89fc 100644
--- a/modules/rtp_rtcp/source/rtp_utility_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_utility_unittest.cc
@@ -76,13 +76,13 @@
   payload[0] = 0x14;  // Binary 0001 0100; S = 1, PartID = 4.
   payload[1] = 0x01;  // P frame.
 
-  RTPPayloadParser rtpPayloadParser(kRtpVp8Video, payload, 4, 0);
+  RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 4, 0);
 
   RTPPayload parsedPacket;
   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 
   EXPECT_EQ(ModuleRTPUtility::kPFrame, parsedPacket.frameType);
-  EXPECT_EQ(kRtpVp8Video, parsedPacket.type);
+  EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 
   VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 1 /*S*/, 4 /*PartID*/);
   VerifyExtensions(parsedPacket.info.VP8, 0 /*I*/, 0 /*L*/, 0 /*T*/, 0 /*K*/);
@@ -97,13 +97,13 @@
   payload[1] = 0x80;
   payload[2] = 17;
 
-  RTPPayloadParser rtpPayloadParser(kRtpVp8Video, payload, 10, 0);
+  RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 10, 0);
 
   RTPPayload parsedPacket;
   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 
   EXPECT_EQ(ModuleRTPUtility::kPFrame, parsedPacket.frameType);
-  EXPECT_EQ(kRtpVp8Video, parsedPacket.type);
+  EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 
   VerifyBasicHeader(parsedPacket.info.VP8, 1 /*N*/, 0 /*S*/, 0 /*PartID*/);
   VerifyExtensions(parsedPacket.info.VP8, 1 /*I*/, 0 /*L*/, 0 /*T*/, 0 /*K*/);
@@ -117,7 +117,7 @@
   // Re-use payload, but change to long PictureID.
   payload[2] = 0x80 | 17;
   payload[3] = 17;
-  RTPPayloadParser rtpPayloadParser2(kRtpVp8Video, payload, 10, 0);
+  RTPPayloadParser rtpPayloadParser2(kRtpVideoVp8, payload, 10, 0);
 
   ASSERT_TRUE(rtpPayloadParser2.Parse(parsedPacket));
 
@@ -136,13 +136,13 @@
   payload[1] = 0x40;
   payload[2] = 17;
 
-  RTPPayloadParser rtpPayloadParser(kRtpVp8Video, payload, 13, 0);
+  RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 13, 0);
 
   RTPPayload parsedPacket;
   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 
   EXPECT_EQ(ModuleRTPUtility::kIFrame, parsedPacket.frameType);
-  EXPECT_EQ(kRtpVp8Video, parsedPacket.type);
+  EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 
   VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 1 /*S*/, 0 /*PartID*/);
   VerifyExtensions(parsedPacket.info.VP8, 0 /*I*/, 1 /*L*/, 0 /*T*/, 0 /*K*/);
@@ -159,13 +159,13 @@
   payload[1] = 0x20;
   payload[2] = 0x80;  // TID(2) + LayerSync(false)
 
-  RTPPayloadParser rtpPayloadParser(kRtpVp8Video, payload, 10, 0);
+  RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 10, 0);
 
   RTPPayload parsedPacket;
   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 
   EXPECT_EQ(ModuleRTPUtility::kPFrame, parsedPacket.frameType);
-  EXPECT_EQ(kRtpVp8Video, parsedPacket.type);
+  EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 
   VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 0 /*S*/, 8 /*PartID*/);
   VerifyExtensions(parsedPacket.info.VP8, 0 /*I*/, 0 /*L*/, 1 /*T*/, 0 /*K*/);
@@ -183,13 +183,13 @@
   payload[1] = 0x10;  // K = 1.
   payload[2] = 0x11;  // KEYIDX = 17 decimal.
 
-  RTPPayloadParser rtpPayloadParser(kRtpVp8Video, payload, 10, 0);
+  RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 10, 0);
 
   RTPPayload parsedPacket;
   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 
   EXPECT_EQ(ModuleRTPUtility::kPFrame, parsedPacket.frameType);
-  EXPECT_EQ(kRtpVp8Video, parsedPacket.type);
+  EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 
   VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 0 /*S*/, 8 /*PartID*/);
   VerifyExtensions(parsedPacket.info.VP8, 0 /*I*/, 0 /*L*/, 0 /*T*/, 1 /*K*/);
@@ -209,13 +209,13 @@
   payload[4] = 42;           // Tl0PicIdx.
   payload[5] = 0x40 | 0x20 | 0x11;  // TID(1) + LayerSync(true) + KEYIDX(17).
 
-  RTPPayloadParser rtpPayloadParser(kRtpVp8Video, payload, 10, 0);
+  RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 10, 0);
 
   RTPPayload parsedPacket;
   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 
   EXPECT_EQ(ModuleRTPUtility::kPFrame, parsedPacket.frameType);
-  EXPECT_EQ(kRtpVp8Video, parsedPacket.type);
+  EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 
   VerifyBasicHeader(parsedPacket.info.VP8, 0 /*N*/, 0 /*S*/, 8 /*PartID*/);
   VerifyExtensions(parsedPacket.info.VP8, 1 /*I*/, 1 /*L*/, 1 /*T*/, 1 /*K*/);
@@ -236,7 +236,7 @@
   payload[2] = 0x80 | 17;  // ... but only 2 bytes PictureID is provided.
   payload[3] = 17;  // PictureID, low 8 bits.
 
-  RTPPayloadParser rtpPayloadParser(kRtpVp8Video, payload, 4, 0);
+  RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, payload, 4, 0);
 
   RTPPayload parsedPacket;
   EXPECT_FALSE(rtpPayloadParser.Parse(parsedPacket));
@@ -258,13 +258,13 @@
   ASSERT_EQ(0, packetizer.NextPacket(packet, &send_bytes, &last));
   ASSERT_TRUE(last);
 
-  RTPPayloadParser rtpPayloadParser(kRtpVp8Video, packet, send_bytes, 0);
+  RTPPayloadParser rtpPayloadParser(kRtpVideoVp8, packet, send_bytes, 0);
 
   RTPPayload parsedPacket;
   ASSERT_TRUE(rtpPayloadParser.Parse(parsedPacket));
 
   EXPECT_EQ(ModuleRTPUtility::kIFrame, parsedPacket.frameType);
-  EXPECT_EQ(kRtpVp8Video, parsedPacket.type);
+  EXPECT_EQ(kRtpVideoVp8, parsedPacket.type);
 
   VerifyBasicHeader(parsedPacket.info.VP8,
                     inputHeader.nonReference /*N*/,
diff --git a/modules/rtp_rtcp/test/testAPI/test_api.cc b/modules/rtp_rtcp/test/testAPI/test_api.cc
index 1eaf0f0..6789e04 100644
--- a/modules/rtp_rtcp/test/testAPI/test_api.cc
+++ b/modules/rtp_rtcp/test/testAPI/test_api.cc
@@ -33,6 +33,10 @@
     configuration.audio = true;
     configuration.clock = &fake_clock;
     module = RtpRtcp::CreateRtpRtcp(configuration);
+    rtp_payload_registry_.reset(new RTPPayloadRegistry(
+            test_id, RTPPayloadStrategy::CreateStrategy(true)));
+    rtp_receiver_.reset(RtpReceiver::CreateAudioReceiver(
+        test_id, &fake_clock, NULL, NULL, NULL, rtp_payload_registry_.get()));
   }
 
   virtual void TearDown() {
@@ -40,6 +44,8 @@
   }
 
   int test_id;
+  scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
+  scoped_ptr<RtpReceiver> rtp_receiver_;
   RtpRtcp* module;
   uint32_t test_ssrc;
   uint32_t test_timestamp;
@@ -103,9 +109,9 @@
   EXPECT_EQ(0, module->SetTMMBRStatus(false));
   EXPECT_FALSE(module->TMMBR());
 
-  EXPECT_EQ(kNackOff, module->NACK());
-  EXPECT_EQ(0, module->SetNACKStatus(kNackRtcp, 450));
-  EXPECT_EQ(kNackRtcp, module->NACK());
+  EXPECT_EQ(kNackOff, rtp_receiver_->NACK());
+  EXPECT_EQ(0, rtp_receiver_->SetNACKStatus(kNackRtcp, 450));
+  EXPECT_EQ(kNackRtcp, rtp_receiver_->NACK());
 }
 
 TEST_F(RtpRtcpAPITest, RTXSender) {
@@ -129,7 +135,7 @@
   EXPECT_EQ(0, module->SetRTXSendStatus(kRtxRetransmitted, false, 1));
   EXPECT_EQ(0, module->RTXSendStatus(&rtx_mode, &ssrc, &payload_type));
   EXPECT_EQ(kRtxRetransmitted, rtx_mode);
-  EXPECT_EQ(kRtxPayloadType ,payload_type);
+  EXPECT_EQ(kRtxPayloadType, payload_type);
 }
 
 TEST_F(RtpRtcpAPITest, RTXReceiver) {
@@ -137,14 +143,14 @@
   unsigned int ssrc = 0;
   const int kRtxPayloadType = 119;
   int payload_type = -1;
-  EXPECT_EQ(0, module->SetRTXReceiveStatus(true, 1));
-  module->SetRtxReceivePayloadType(kRtxPayloadType);
-  EXPECT_EQ(0, module->RTXReceiveStatus(&enable, &ssrc, &payload_type));
+  rtp_receiver_->SetRTXStatus(true, 1);
+  rtp_receiver_->SetRtxPayloadType(kRtxPayloadType);
+  rtp_receiver_->RTXStatus(&enable, &ssrc, &payload_type);
   EXPECT_TRUE(enable);
   EXPECT_EQ(1u, ssrc);
   EXPECT_EQ(kRtxPayloadType ,payload_type);
-  EXPECT_EQ(0, module->SetRTXReceiveStatus(false, 0));
-  EXPECT_EQ(0, module->RTXReceiveStatus(&enable, &ssrc, &payload_type));
+  rtp_receiver_->SetRTXStatus(false, 0);
+  rtp_receiver_->RTXStatus(&enable, &ssrc, &payload_type);
   EXPECT_FALSE(enable);
   EXPECT_EQ(kRtxPayloadType ,payload_type);
 }
diff --git a/modules/rtp_rtcp/test/testAPI/test_api.h b/modules/rtp_rtcp/test/testAPI/test_api.h
index 7cce3c8..1a13ab9 100644
--- a/modules/rtp_rtcp/test/testAPI/test_api.h
+++ b/modules/rtp_rtcp/test/testAPI/test_api.h
@@ -10,7 +10,10 @@
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/common_types.h"
+#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
@@ -24,10 +27,18 @@
   LoopBackTransport()
     : _count(0),
       _packetLoss(0),
+      rtp_payload_registry_(NULL),
+      rtp_receiver_(NULL),
       _rtpRtcpModule(NULL) {
   }
-  void SetSendModule(RtpRtcp* rtpRtcpModule) {
+  void SetSendModule(RtpRtcp* rtpRtcpModule,
+                     RTPPayloadRegistry* payload_registry,
+                     RtpReceiver* receiver,
+                     ReceiveStatistics* receive_statistics) {
     _rtpRtcpModule = rtpRtcpModule;
+    rtp_payload_registry_ = payload_registry;
+    rtp_receiver_ = receiver;
+    receive_statistics_ = receive_statistics;
   }
   void DropEveryNthPacket(int n) {
     _packetLoss = n;
@@ -44,8 +55,15 @@
     if (!parser->Parse(static_cast<const uint8_t*>(data), len, &header)) {
       return -1;
     }
-    if (_rtpRtcpModule->IncomingRtpPacket(static_cast<const uint8_t*>(data),
-                                          len, header) < 0) {
+    PayloadUnion payload_specific;
+    if (!rtp_payload_registry_->GetPayloadSpecifics(
+        header.payloadType, &payload_specific)) {
+      return -1;
+    }
+    receive_statistics_->IncomingPacket(header, len, false, true);
+    if (!rtp_receiver_->IncomingRtpPacket(&header,
+                                          static_cast<const uint8_t*>(data),
+                                          len, payload_specific, true)) {
       return -1;
     }
     return len;
@@ -59,10 +77,13 @@
  private:
   int _count;
   int _packetLoss;
+  ReceiveStatistics* receive_statistics_;
+  RTPPayloadRegistry* rtp_payload_registry_;
+  RtpReceiver* rtp_receiver_;
   RtpRtcp* _rtpRtcpModule;
 };
 
-class RtpReceiver : public RtpData {
+class TestRtpReceiver : public NullRtpData {
  public:
 
   virtual int32_t OnReceivedPayloadData(
diff --git a/modules/rtp_rtcp/test/testAPI/test_api_audio.cc b/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
index d285bff..02414e1 100644
--- a/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
+++ b/modules/rtp_rtcp/test/testAPI/test_api_audio.cc
@@ -16,13 +16,14 @@
 
 #include "webrtc/common_types.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 
 using namespace webrtc;
 
 #define test_rate 64000u
 
-class VerifyingAudioReceiver : public RtpData {
+class VerifyingAudioReceiver : public NullRtpData {
  public:
   virtual int32_t OnReceivedPayloadData(
       const uint8_t* payloadData,
@@ -58,7 +59,7 @@
   }
 };
 
-class RTPCallback : public RtpFeedback {
+class RTPCallback : public NullRtpFeedback {
  public:
   virtual int32_t OnInitializeDecoder(
       const int32_t id,
@@ -73,24 +74,9 @@
     }
     return 0;
   }
-  virtual void OnPacketTimeout(const int32_t id) {
-  }
-  virtual void OnReceivedPacket(const int32_t id,
-                                const RtpRtcpPacketType packetType) {
-  }
-  virtual void OnPeriodicDeadOrAlive(const int32_t id,
-                                     const RTPAliveType alive) {
-  }
-  virtual void OnIncomingSSRCChanged(const int32_t id,
-                                     const uint32_t SSRC) {
-  }
-  virtual void OnIncomingCSRCChanged(const int32_t id,
-                                     const uint32_t CSRC,
-                                     const bool added) {
-  }
 };
 
-class AudioFeedback : public RtpAudioFeedback {
+class AudioFeedback : public NullRtpAudioFeedback {
   virtual void OnReceivedTelephoneEvent(const int32_t id,
                                         const uint8_t event,
                                         const bool end) {
@@ -110,11 +96,6 @@
       expectedEvent = 32;
     }
   }
-  virtual void OnPlayTelephoneEvent(const int32_t id,
-                                    const uint8_t event,
-                                    const uint16_t lengthMs,
-                                    const uint8_t volume) {
-  };
 };
 
 class RtpRtcpAudioTest : public ::testing::Test {
@@ -137,26 +118,41 @@
     transport1 = new LoopBackTransport();
     transport2 = new LoopBackTransport();
 
+    receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock));
+    receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock));
+
+    rtp_payload_registry1_.reset(new RTPPayloadRegistry(
+        test_id, RTPPayloadStrategy::CreateStrategy(true)));
+    rtp_payload_registry2_.reset(new RTPPayloadRegistry(
+        test_id, RTPPayloadStrategy::CreateStrategy(true)));
+
     RtpRtcp::Configuration configuration;
     configuration.id = test_id;
     configuration.audio = true;
     configuration.clock = &fake_clock;
-    configuration.incoming_data = data_receiver1;
+    configuration.receive_statistics = receive_statistics1_.get();
     configuration.outgoing_transport = transport1;
     configuration.audio_messages = audioFeedback;
 
     module1 = RtpRtcp::CreateRtpRtcp(configuration);
+    rtp_receiver1_.reset(RtpReceiver::CreateAudioReceiver(
+        test_id, &fake_clock, audioFeedback, data_receiver1, NULL,
+        rtp_payload_registry1_.get()));
 
     configuration.id = test_id + 1;
-    configuration.incoming_data = data_receiver2;
-    configuration.incoming_messages = rtp_callback;
+    configuration.receive_statistics = receive_statistics2_.get();
     configuration.outgoing_transport = transport2;
     configuration.audio_messages = audioFeedback;
 
     module2 = RtpRtcp::CreateRtpRtcp(configuration);
+    rtp_receiver2_.reset(RtpReceiver::CreateAudioReceiver(
+            test_id + 1, &fake_clock, audioFeedback, data_receiver2, NULL,
+            rtp_payload_registry2_.get()));
 
-    transport1->SetSendModule(module2);
-    transport2->SetSendModule(module1);
+    transport1->SetSendModule(module2, rtp_payload_registry2_.get(),
+                              rtp_receiver2_.get(), receive_statistics2_.get());
+    transport2->SetSendModule(module1, rtp_payload_registry1_.get(),
+                              rtp_receiver1_.get(), receive_statistics1_.get());
   }
 
   virtual void TearDown() {
@@ -173,6 +169,12 @@
   int test_id;
   RtpRtcp* module1;
   RtpRtcp* module2;
+  scoped_ptr<ReceiveStatistics> receive_statistics1_;
+  scoped_ptr<ReceiveStatistics> receive_statistics2_;
+  scoped_ptr<RtpReceiver> rtp_receiver1_;
+  scoped_ptr<RtpReceiver> rtp_receiver2_;
+  scoped_ptr<RTPPayloadRegistry> rtp_payload_registry1_;
+  scoped_ptr<RTPPayloadRegistry> rtp_payload_registry2_;
   VerifyingAudioReceiver* data_receiver1;
   VerifyingAudioReceiver* data_receiver2;
   LoopBackTransport* transport1;
@@ -191,63 +193,93 @@
   EXPECT_EQ(0, module1->SetStartTimestamp(test_timestamp));
 
   // Test detection at the end of a DTMF tone.
-  EXPECT_EQ(0, module2->SetTelephoneEventForwardToDecoder(true));
+  //EXPECT_EQ(0, module2->SetTelephoneEventForwardToDecoder(true));
 
   EXPECT_EQ(0, module1->SetSendingStatus(true));
 
   // Start basic RTP test.
 
   // Send an empty RTP packet.
-  // Should fail since we have not registerd the payload type.
+  // Should fail since we have not registered the payload type.
   EXPECT_EQ(-1, module1->SendOutgoingData(webrtc::kAudioFrameSpeech,
                                           96, 0, -1, NULL, 0));
 
-  CodecInst voiceCodec;
-  voiceCodec.pltype = 96;
-  voiceCodec.plfreq = 8000;
-  memcpy(voiceCodec.plname, "PCMU", 5);
+  CodecInst voice_codec;
+  voice_codec.pltype = 96;
+  voice_codec.plfreq = 8000;
+  memcpy(voice_codec.plname, "PCMU", 5);
 
-  EXPECT_EQ(0, module1->RegisterSendPayload(voiceCodec));
-  EXPECT_EQ(0, module1->RegisterReceivePayload(voiceCodec));
-  EXPECT_EQ(0, module2->RegisterSendPayload(voiceCodec));
-  voiceCodec.rate = test_rate;
-  EXPECT_EQ(0, module2->RegisterReceivePayload(voiceCodec));
+  EXPECT_EQ(0, module1->RegisterSendPayload(voice_codec));
+  EXPECT_EQ(0, rtp_receiver1_->RegisterReceivePayload(
+      voice_codec.plname,
+      voice_codec.pltype,
+      voice_codec.plfreq,
+      voice_codec.channels,
+      (voice_codec.rate < 0) ? 0 : voice_codec.rate));
+  EXPECT_EQ(0, module2->RegisterSendPayload(voice_codec));
+  voice_codec.rate = test_rate;
+  EXPECT_EQ(0, rtp_receiver2_->RegisterReceivePayload(
+      voice_codec.plname,
+      voice_codec.pltype,
+      voice_codec.plfreq,
+      voice_codec.channels,
+      (voice_codec.rate < 0) ? 0 : voice_codec.rate));
   printf("4\n");
 
   const uint8_t test[5] = "test";
   EXPECT_EQ(0, module1->SendOutgoingData(webrtc::kAudioFrameSpeech, 96,
                                          0, -1, test, 4));
 
-  EXPECT_EQ(test_ssrc, module2->RemoteSSRC());
-  EXPECT_EQ(test_timestamp, module2->RemoteTimestamp());
+  EXPECT_EQ(test_ssrc, rtp_receiver2_->SSRC());
+  EXPECT_EQ(test_timestamp, rtp_receiver2_->TimeStamp());
 }
 
 TEST_F(RtpRtcpAudioTest, RED) {
-  CodecInst voiceCodec;
-  voiceCodec.pltype = 96;
-  voiceCodec.plfreq = 8000;
-  memcpy(voiceCodec.plname, "PCMU", 5);
+  CodecInst voice_codec;
+  voice_codec.pltype = 96;
+  voice_codec.plfreq = 8000;
+  memcpy(voice_codec.plname, "PCMU", 5);
 
-  EXPECT_EQ(0, module1->RegisterSendPayload(voiceCodec));
-  EXPECT_EQ(0, module1->RegisterReceivePayload(voiceCodec));
-  EXPECT_EQ(0, module2->RegisterSendPayload(voiceCodec));
-  voiceCodec.rate = test_rate;
-  EXPECT_EQ(0, module2->RegisterReceivePayload(voiceCodec));
+  EXPECT_EQ(0, module1->RegisterSendPayload(voice_codec));
+  EXPECT_EQ(0, rtp_receiver1_->RegisterReceivePayload(
+      voice_codec.plname,
+      voice_codec.pltype,
+      voice_codec.plfreq,
+      voice_codec.channels,
+      (voice_codec.rate < 0) ? 0 : voice_codec.rate));
+  EXPECT_EQ(0, module2->RegisterSendPayload(voice_codec));
+  voice_codec.rate = test_rate;
+  EXPECT_EQ(0, rtp_receiver2_->RegisterReceivePayload(
+      voice_codec.plname,
+      voice_codec.pltype,
+      voice_codec.plfreq,
+      voice_codec.channels,
+      (voice_codec.rate < 0) ? 0 : voice_codec.rate));
 
   EXPECT_EQ(0, module1->SetSSRC(test_ssrc));
   EXPECT_EQ(0, module1->SetStartTimestamp(test_timestamp));
   EXPECT_EQ(0, module1->SetSendingStatus(true));
 
-  voiceCodec.pltype = 127;
-  voiceCodec.plfreq = 8000;
-  memcpy(voiceCodec.plname, "RED", 4);
+  voice_codec.pltype = 127;
+  voice_codec.plfreq = 8000;
+  memcpy(voice_codec.plname, "RED", 4);
 
-  EXPECT_EQ(0, module1->SetSendREDPayloadType(voiceCodec.pltype));
+  EXPECT_EQ(0, module1->SetSendREDPayloadType(voice_codec.pltype));
   int8_t red = 0;
   EXPECT_EQ(0, module1->SendREDPayloadType(red));
-  EXPECT_EQ(voiceCodec.pltype, red);
-  EXPECT_EQ(0, module1->RegisterReceivePayload(voiceCodec));
-  EXPECT_EQ(0, module2->RegisterReceivePayload(voiceCodec));
+  EXPECT_EQ(voice_codec.pltype, red);
+  EXPECT_EQ(0, rtp_receiver1_->RegisterReceivePayload(
+      voice_codec.plname,
+      voice_codec.pltype,
+      voice_codec.plfreq,
+      voice_codec.channels,
+      (voice_codec.rate < 0) ? 0 : voice_codec.rate));
+  EXPECT_EQ(0, rtp_receiver2_->RegisterReceivePayload(
+      voice_codec.plname,
+      voice_codec.pltype,
+      voice_codec.plfreq,
+      voice_codec.channels,
+      (voice_codec.rate < 0) ? 0 : voice_codec.rate));
 
   RTPFragmentationHeader fragmentation;
   fragmentation.fragmentationVectorSize = 2;
@@ -275,28 +307,43 @@
 }
 
 TEST_F(RtpRtcpAudioTest, DTMF) {
-  CodecInst voiceCodec;
-  voiceCodec.pltype = 96;
-  voiceCodec.plfreq = 8000;
-  memcpy(voiceCodec.plname, "PCMU", 5);
+  CodecInst voice_codec;
+  voice_codec.pltype = 96;
+  voice_codec.plfreq = 8000;
+  memcpy(voice_codec.plname, "PCMU", 5);
 
-  EXPECT_EQ(0, module1->RegisterSendPayload(voiceCodec));
-  EXPECT_EQ(0, module1->RegisterReceivePayload(voiceCodec));
-  EXPECT_EQ(0, module2->RegisterSendPayload(voiceCodec));
-  voiceCodec.rate = test_rate;
-  EXPECT_EQ(0, module2->RegisterReceivePayload(voiceCodec));
+  EXPECT_EQ(0, module1->RegisterSendPayload(voice_codec));
+  EXPECT_EQ(0, rtp_receiver1_->RegisterReceivePayload(
+      voice_codec.plname,
+      voice_codec.pltype,
+      voice_codec.plfreq,
+      voice_codec.channels,
+      (voice_codec.rate < 0) ? 0 : voice_codec.rate));
+  EXPECT_EQ(0, module2->RegisterSendPayload(voice_codec));
+  voice_codec.rate = test_rate;
+  EXPECT_EQ(0, rtp_receiver2_->RegisterReceivePayload(
+      voice_codec.plname,
+      voice_codec.pltype,
+      voice_codec.plfreq,
+      voice_codec.channels,
+      (voice_codec.rate < 0) ? 0 : voice_codec.rate));
 
   EXPECT_EQ(0, module1->SetSSRC(test_ssrc));
   EXPECT_EQ(0, module1->SetStartTimestamp(test_timestamp));
   EXPECT_EQ(0, module1->SetSendingStatus(true));
 
   // Prepare for DTMF.
-  voiceCodec.pltype = 97;
-  voiceCodec.plfreq = 8000;
-  memcpy(voiceCodec.plname, "telephone-event", 16);
+  voice_codec.pltype = 97;
+  voice_codec.plfreq = 8000;
+  memcpy(voice_codec.plname, "telephone-event", 16);
 
-  EXPECT_EQ(0, module1->RegisterSendPayload(voiceCodec));
-  EXPECT_EQ(0, module2->RegisterReceivePayload(voiceCodec));
+  EXPECT_EQ(0, module1->RegisterSendPayload(voice_codec));
+  EXPECT_EQ(0, rtp_receiver2_->RegisterReceivePayload(
+        voice_codec.plname,
+        voice_codec.pltype,
+        voice_codec.plfreq,
+        voice_codec.channels,
+        (voice_codec.rate < 0) ? 0 : voice_codec.rate));
 
   // Start DTMF test.
   uint32_t timeStamp = 160;
diff --git a/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc b/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
index 632041c..412c7e2 100644
--- a/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
+++ b/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
@@ -14,7 +14,9 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/common_types.h"
+#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/test/testAPI/test_api.h"
 
@@ -68,6 +70,20 @@
   RtpRtcp* _rtpRtcpModule;
 };
 
+class TestRtpFeedback : public NullRtpFeedback {
+ public:
+  TestRtpFeedback(RtpRtcp* rtp_rtcp) : rtp_rtcp_(rtp_rtcp) {}
+  virtual ~TestRtpFeedback() {}
+
+  virtual void OnIncomingSSRCChanged(const int32_t id,
+                                     const uint32_t SSRC) {
+    rtp_rtcp_->SetRemoteSSRC(SSRC);
+  }
+
+ private:
+  RtpRtcp* rtp_rtcp_;
+};
+
 class RtpRtcpRtcpTest : public ::testing::Test {
  protected:
   RtpRtcpRtcpTest() : fake_clock(123456) {
@@ -81,31 +97,55 @@
   ~RtpRtcpRtcpTest() {}
 
   virtual void SetUp() {
-    receiver = new RtpReceiver();
+    receiver = new TestRtpReceiver();
     transport1 = new LoopBackTransport();
     transport2 = new LoopBackTransport();
     myRTCPFeedback1 = new RtcpCallback();
     myRTCPFeedback2 = new RtcpCallback();
 
+    receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock));
+    receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock));
+
     RtpRtcp::Configuration configuration;
     configuration.id = test_id;
     configuration.audio = true;
     configuration.clock = &fake_clock;
+    configuration.receive_statistics = receive_statistics1_.get();
     configuration.outgoing_transport = transport1;
     configuration.rtcp_feedback = myRTCPFeedback1;
     configuration.intra_frame_callback = myRTCPFeedback1;
-    configuration.incoming_data = receiver;
+
+    rtp_payload_registry1_.reset(new RTPPayloadRegistry(
+            test_id, RTPPayloadStrategy::CreateStrategy(true)));
+    rtp_payload_registry2_.reset(new RTPPayloadRegistry(
+            test_id, RTPPayloadStrategy::CreateStrategy(true)));
 
     module1 = RtpRtcp::CreateRtpRtcp(configuration);
 
+    rtp_feedback1_.reset(new TestRtpFeedback(module1));
+
+    rtp_receiver1_.reset(RtpReceiver::CreateAudioReceiver(
+        test_id, &fake_clock, NULL, receiver, rtp_feedback1_.get(),
+        rtp_payload_registry1_.get()));
+
+    configuration.receive_statistics = receive_statistics2_.get();
     configuration.id = test_id + 1;
     configuration.outgoing_transport = transport2;
     configuration.rtcp_feedback = myRTCPFeedback2;
     configuration.intra_frame_callback = myRTCPFeedback2;
+
     module2 = RtpRtcp::CreateRtpRtcp(configuration);
 
-    transport1->SetSendModule(module2);
-    transport2->SetSendModule(module1);
+    rtp_feedback2_.reset(new TestRtpFeedback(module2));
+
+    rtp_receiver2_.reset(RtpReceiver::CreateAudioReceiver(
+        test_id + 1, &fake_clock, NULL, receiver, rtp_feedback2_.get(),
+        rtp_payload_registry2_.get()));
+
+    transport1->SetSendModule(module2, rtp_payload_registry2_.get(),
+                              rtp_receiver2_.get(), receive_statistics2_.get());
+    transport2->SetSendModule(module1, rtp_payload_registry1_.get(),
+                              rtp_receiver1_.get(), receive_statistics1_.get());
     myRTCPFeedback1->SetModule(module1);
     myRTCPFeedback2->SetModule(module2);
 
@@ -121,16 +161,26 @@
 
     EXPECT_EQ(0, module1->SetSendingStatus(true));
 
-    CodecInst voiceCodec;
-    voiceCodec.pltype = 96;
-    voiceCodec.plfreq = 8000;
-    voiceCodec.rate = 64000;
-    memcpy(voiceCodec.plname, "PCMU", 5);
+    CodecInst voice_codec;
+    voice_codec.pltype = 96;
+    voice_codec.plfreq = 8000;
+    voice_codec.rate = 64000;
+    memcpy(voice_codec.plname, "PCMU", 5);
 
-    EXPECT_EQ(0, module1->RegisterSendPayload(voiceCodec));
-    EXPECT_EQ(0, module1->RegisterReceivePayload(voiceCodec));
-    EXPECT_EQ(0, module2->RegisterSendPayload(voiceCodec));
-    EXPECT_EQ(0, module2->RegisterReceivePayload(voiceCodec));
+    EXPECT_EQ(0, module1->RegisterSendPayload(voice_codec));
+    EXPECT_EQ(0, rtp_receiver1_->RegisterReceivePayload(
+        voice_codec.plname,
+        voice_codec.pltype,
+        voice_codec.plfreq,
+        voice_codec.channels,
+        (voice_codec.rate < 0) ? 0 : voice_codec.rate));
+    EXPECT_EQ(0, module2->RegisterSendPayload(voice_codec));
+    EXPECT_EQ(0, rtp_receiver2_->RegisterReceivePayload(
+        voice_codec.plname,
+        voice_codec.pltype,
+        voice_codec.plfreq,
+        voice_codec.channels,
+        (voice_codec.rate < 0) ? 0 : voice_codec.rate));
 
     // We need to send one RTP packet to get the RTCP packet to be accepted by
     // the receiving module.
@@ -151,9 +201,17 @@
   }
 
   int test_id;
+  scoped_ptr<TestRtpFeedback> rtp_feedback1_;
+  scoped_ptr<TestRtpFeedback> rtp_feedback2_;
+  scoped_ptr<ReceiveStatistics> receive_statistics1_;
+  scoped_ptr<ReceiveStatistics> receive_statistics2_;
+  scoped_ptr<RTPPayloadRegistry> rtp_payload_registry1_;
+  scoped_ptr<RTPPayloadRegistry> rtp_payload_registry2_;
+  scoped_ptr<RtpReceiver> rtp_receiver1_;
+  scoped_ptr<RtpReceiver> rtp_receiver2_;
   RtpRtcp* module1;
   RtpRtcp* module2;
-  RtpReceiver* receiver;
+  TestRtpReceiver* receiver;
   LoopBackTransport* transport1;
   LoopBackTransport* transport2;
   RtcpCallback* myRTCPFeedback1;
@@ -173,7 +231,7 @@
 
 TEST_F(RtpRtcpRtcpTest, RTCP_CNAME) {
   uint32_t testOfCSRC[webrtc::kRtpCsrcSize];
-  EXPECT_EQ(2, module2->RemoteCSRCs(testOfCSRC));
+  EXPECT_EQ(2, rtp_receiver2_->CSRCs(testOfCSRC));
   EXPECT_EQ(test_CSRC[0], testOfCSRC[0]);
   EXPECT_EQ(test_CSRC[1], testOfCSRC[1]);
 
@@ -192,10 +250,10 @@
   module2->Process();
 
   char cName[RTCP_CNAME_SIZE];
-  EXPECT_EQ(-1, module2->RemoteCNAME(module2->RemoteSSRC() + 1, cName));
+  EXPECT_EQ(-1, module2->RemoteCNAME(rtp_receiver2_->SSRC() + 1, cName));
 
   // Check multiple CNAME.
-  EXPECT_EQ(0, module2->RemoteCNAME(module2->RemoteSSRC(), cName));
+  EXPECT_EQ(0, module2->RemoteCNAME(rtp_receiver2_->SSRC(), cName));
   EXPECT_EQ(0, strncmp(cName, "john.doe@test.test", RTCP_CNAME_SIZE));
 
   EXPECT_EQ(0, module2->RemoteCNAME(test_CSRC[0], cName));
@@ -207,7 +265,7 @@
   EXPECT_EQ(0, module1->SetSendingStatus(false));
 
   // Test that BYE clears the CNAME
-  EXPECT_EQ(-1, module2->RemoteCNAME(module2->RemoteSSRC(), cName));
+  EXPECT_EQ(-1, module2->RemoteCNAME(rtp_receiver2_->SSRC(), cName));
 }
 
 TEST_F(RtpRtcpRtcpTest, RTCP) {
@@ -276,20 +334,12 @@
   EXPECT_EQ(static_cast<uint32_t>(0),
             reportBlockReceived.cumulativeLost);
 
-  uint8_t  fraction_lost = 0;  // scale 0 to 255
-  uint32_t cum_lost = 0;       // number of lost packets
-  uint32_t ext_max = 0;        // highest sequence number received
-  uint32_t jitter = 0;
-  uint32_t max_jitter = 0;
-  EXPECT_EQ(0, module2->StatisticsRTP(&fraction_lost,
-                                      &cum_lost,
-                                      &ext_max,
-                                      &jitter,
-                                      &max_jitter));
-  EXPECT_EQ(0, fraction_lost);
-  EXPECT_EQ((uint32_t)0, cum_lost);
-  EXPECT_EQ(test_sequence_number, ext_max);
-  EXPECT_EQ(reportBlockReceived.jitter, jitter);
+  ReceiveStatistics::RtpReceiveStatistics stats;
+  EXPECT_TRUE(receive_statistics2_->Statistics(&stats, true));
+  EXPECT_EQ(0, stats.fraction_lost);
+  EXPECT_EQ((uint32_t)0, stats.cumulative_lost);
+  EXPECT_EQ(test_sequence_number, stats.extended_max_sequence_number);
+  EXPECT_EQ(reportBlockReceived.jitter, stats.jitter);
 
   uint16_t RTT;
   uint16_t avgRTT;
diff --git a/modules/rtp_rtcp/test/testAPI/test_api_video.cc b/modules/rtp_rtcp/test/testAPI/test_api_video.cc
index 75d3ff9..b509dd8 100644
--- a/modules/rtp_rtcp/test/testAPI/test_api_video.cc
+++ b/modules/rtp_rtcp/test/testAPI/test_api_video.cc
@@ -15,6 +15,8 @@
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/common_types.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
@@ -26,6 +28,7 @@
  protected:
   RtpRtcpVideoTest()
       : test_id_(123),
+        rtp_payload_registry_(0, RTPPayloadStrategy::CreateStrategy(false)),
         test_ssrc_(3456),
         test_timestamp_(4567),
         test_sequence_number_(2345),
@@ -35,23 +38,26 @@
 
   virtual void SetUp() {
     transport_ = new LoopBackTransport();
-    receiver_ = new RtpReceiver();
+    receiver_ = new TestRtpReceiver();
+    receive_statistics_.reset(ReceiveStatistics::Create(&fake_clock));
     RtpRtcp::Configuration configuration;
     configuration.id = test_id_;
     configuration.audio = false;
     configuration.clock = &fake_clock;
-    configuration.incoming_data = receiver_;
     configuration.outgoing_transport = transport_;
 
     video_module_ = RtpRtcp::CreateRtpRtcp(configuration);
+    rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver(
+        test_id_, &fake_clock, receiver_, NULL, &rtp_payload_registry_));
 
     EXPECT_EQ(0, video_module_->SetRTCPStatus(kRtcpCompound));
     EXPECT_EQ(0, video_module_->SetSSRC(test_ssrc_));
-    EXPECT_EQ(0, video_module_->SetNACKStatus(kNackRtcp, 450));
+    EXPECT_EQ(0, rtp_receiver_->SetNACKStatus(kNackRtcp, 450));
     EXPECT_EQ(0, video_module_->SetStorePacketsStatus(true, 600));
     EXPECT_EQ(0, video_module_->SetSendingStatus(true));
 
-    transport_->SetSendModule(video_module_);
+    transport_->SetSendModule(video_module_, &rtp_payload_registry_,
+                              rtp_receiver_.get(), receive_statistics_.get());
 
     VideoCodec video_codec;
     memset(&video_codec, 0, sizeof(video_codec));
@@ -59,7 +65,11 @@
     memcpy(video_codec.plName, "I420", 5);
 
     EXPECT_EQ(0, video_module_->RegisterSendPayload(video_codec));
-    EXPECT_EQ(0, video_module_->RegisterReceivePayload(video_codec));
+    EXPECT_EQ(0, rtp_receiver_->RegisterReceivePayload(video_codec.plName,
+                                                       video_codec.plType,
+                                                       90000,
+                                                       0,
+                                                       video_codec.maxBitrate));
 
     payload_data_length_ = sizeof(video_frame_);
 
@@ -117,9 +127,12 @@
   }
 
   int test_id_;
+  scoped_ptr<ReceiveStatistics> receive_statistics_;
+  RTPPayloadRegistry rtp_payload_registry_;
+  scoped_ptr<RtpReceiver> rtp_receiver_;
   RtpRtcp* video_module_;
   LoopBackTransport* transport_;
-  RtpReceiver* receiver_;
+  TestRtpReceiver* receiver_;
   uint32_t test_ssrc_;
   uint32_t test_timestamp_;
   uint16_t test_sequence_number_;
@@ -147,7 +160,11 @@
   codec.codecType = kVideoCodecVP8;
   codec.plType = kPayloadType;
   strncpy(codec.plName, "VP8", 4);
-  EXPECT_EQ(0, video_module_->RegisterReceivePayload(codec));
+  EXPECT_EQ(0, rtp_receiver_->RegisterReceivePayload(codec.plName,
+                                                     codec.plType,
+                                                     90000,
+                                                     0,
+                                                     codec.maxBitrate));
   for (int frame_idx = 0; frame_idx < 10; ++frame_idx) {
     for (int packet_idx = 0; packet_idx < 5; ++packet_idx) {
       int packet_size = PaddingPacket(padding_packet, timestamp, seq_num,
@@ -156,8 +173,12 @@
       RTPHeader header;
       scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
       EXPECT_TRUE(parser->Parse(padding_packet, packet_size, &header));
-      EXPECT_EQ(0, video_module_->IncomingRtpPacket(padding_packet,
-                                                    packet_size, header));
+      PayloadUnion payload_specific;
+      EXPECT_TRUE(rtp_payload_registry_.GetPayloadSpecifics(header.payloadType,
+                                                           &payload_specific));
+      EXPECT_TRUE(rtp_receiver_->IncomingRtpPacket(&header, padding_packet,
+                                                   packet_size,
+                                                   payload_specific, true));
       EXPECT_EQ(0, receiver_->payload_size());
       EXPECT_EQ(packet_size - 12, receiver_->rtp_header().header.paddingLength);
     }
diff --git a/modules/video_coding/main/interface/video_coding_defines.h b/modules/video_coding/main/interface/video_coding_defines.h
index b1b52bd..1a749bc 100644
--- a/modules/video_coding/main/interface/video_coding_defines.h
+++ b/modules/video_coding/main/interface/video_coding_defines.h
@@ -119,7 +119,7 @@
 // Callback class used for informing the user of the incoming bit rate and frame rate.
 class VCMReceiveStatisticsCallback {
  public:
-  virtual int32_t ReceiveStatistics(const uint32_t bitRate,
+  virtual int32_t OnReceiveStatisticsUpdate(const uint32_t bitRate,
                                           const uint32_t frameRate) = 0;
 
  protected:
diff --git a/modules/video_coding/main/source/decoding_state_unittest.cc b/modules/video_coding/main/source/decoding_state_unittest.cc
index d1c5569..509ca9e 100644
--- a/modules/video_coding/main/source/decoding_state_unittest.cc
+++ b/modules/video_coding/main/source/decoding_state_unittest.cc
@@ -37,7 +37,7 @@
   packet->timestamp = 1;
   packet->seqNum = 0xffff;
   packet->frameType = kVideoFrameDelta;
-  packet->codecSpecificHeader.codec = kRTPVideoVP8;
+  packet->codecSpecificHeader.codec = kRtpVideoVp8;
   packet->codecSpecificHeader.codecHeader.VP8.pictureId = 0x007F;
   frame.InsertPacket(*packet, 0, false, 0);
   // Always start with a key frame.
@@ -208,7 +208,7 @@
   VCMFrameBuffer frame;
   VCMPacket* packet = new VCMPacket();
   packet->frameType = kVideoFrameDelta;
-  packet->codecSpecificHeader.codec = kRTPVideoVP8;
+  packet->codecSpecificHeader.codec = kRtpVideoVp8;
   packet->timestamp = 0;
   packet->seqNum = 0;
   packet->codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0;
@@ -361,7 +361,7 @@
   VCMPacket packet;
   frame.Reset();
   packet.frameType = kVideoFrameKey;
-  packet.codecSpecificHeader.codec = kRTPVideoVP8;
+  packet.codecSpecificHeader.codec = kRtpVideoVp8;
   packet.timestamp = 0;
   packet.seqNum = 0;
   packet.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0;
diff --git a/modules/video_coding/main/source/encoded_frame.cc b/modules/video_coding/main/source/encoded_frame.cc
index eb16509..bfefee9 100644
--- a/modules/video_coding/main/source/encoded_frame.cc
+++ b/modules/video_coding/main/source/encoded_frame.cc
@@ -104,7 +104,7 @@
     {
         switch (header->codec)
         {
-            case kRTPVideoVP8:
+            case kRtpVideoVp8:
             {
                 if (_codecSpecificInfo.codecType != kVideoCodecVP8)
                 {
diff --git a/modules/video_coding/main/source/packet.cc b/modules/video_coding/main/source/packet.cc
index 4604572..86583da 100644
--- a/modules/video_coding/main/source/packet.cc
+++ b/modules/video_coding/main/source/packet.cc
@@ -94,7 +94,7 @@
 {
     switch(videoHeader.codec)
     {
-        case kRTPVideoVP8:
+        case kRtpVideoVp8:
             {
                 // Handle all packets within a frame as depending on the previous packet
                 // TODO(holmer): This should be changed to make fragments independent
@@ -111,7 +111,7 @@
                 codec = kVideoCodecVP8;
                 break;
             }
-        case kRTPVideoI420:
+        case kRtpVideoI420:
             {
                 codec = kVideoCodecI420;
                 break;
diff --git a/modules/video_coding/main/source/session_info.cc b/modules/video_coding/main/source/session_info.cc
index 24f8b16..e36d2a7 100644
--- a/modules/video_coding/main/source/session_info.cc
+++ b/modules/video_coding/main/source/session_info.cc
@@ -50,35 +50,35 @@
 
 int VCMSessionInfo::PictureId() const {
   if (packets_.empty() ||
-      packets_.front().codecSpecificHeader.codec != kRTPVideoVP8)
+      packets_.front().codecSpecificHeader.codec != kRtpVideoVp8)
     return kNoPictureId;
   return packets_.front().codecSpecificHeader.codecHeader.VP8.pictureId;
 }
 
 int VCMSessionInfo::TemporalId() const {
   if (packets_.empty() ||
-      packets_.front().codecSpecificHeader.codec != kRTPVideoVP8)
+      packets_.front().codecSpecificHeader.codec != kRtpVideoVp8)
     return kNoTemporalIdx;
   return packets_.front().codecSpecificHeader.codecHeader.VP8.temporalIdx;
 }
 
 bool VCMSessionInfo::LayerSync() const {
   if (packets_.empty() ||
-        packets_.front().codecSpecificHeader.codec != kRTPVideoVP8)
+        packets_.front().codecSpecificHeader.codec != kRtpVideoVp8)
     return false;
   return packets_.front().codecSpecificHeader.codecHeader.VP8.layerSync;
 }
 
 int VCMSessionInfo::Tl0PicId() const {
   if (packets_.empty() ||
-      packets_.front().codecSpecificHeader.codec != kRTPVideoVP8)
+      packets_.front().codecSpecificHeader.codec != kRtpVideoVp8)
     return kNoTl0PicIdx;
   return packets_.front().codecSpecificHeader.codecHeader.VP8.tl0PicIdx;
 }
 
 bool VCMSessionInfo::NonReference() const {
   if (packets_.empty() ||
-      packets_.front().codecSpecificHeader.codec != kRTPVideoVP8)
+      packets_.front().codecSpecificHeader.codec != kRtpVideoVp8)
     return false;
   return packets_.front().codecSpecificHeader.codecHeader.VP8.nonReference;
 }
diff --git a/modules/video_coding/main/source/session_info_unittest.cc b/modules/video_coding/main/source/session_info_unittest.cc
index 4b35a08..4163359 100644
--- a/modules/video_coding/main/source/session_info_unittest.cc
+++ b/modules/video_coding/main/source/session_info_unittest.cc
@@ -66,7 +66,7 @@
     TestSessionInfo::SetUp();
     vp8_header_ = &packet_header_.type.Video.codecHeader.VP8;
     packet_header_.frameType = kVideoFrameDelta;
-    packet_header_.type.Video.codec = kRTPVideoVP8;
+    packet_header_.type.Video.codec = kRtpVideoVp8;
     vp8_header_->InitRTPVideoHeaderVP8();
     fragmentation_.VerifyAndAllocateFragmentationHeader(kMaxVP8Partitions);
   }
diff --git a/modules/video_coding/main/source/video_coding_impl.cc b/modules/video_coding/main/source/video_coding_impl.cc
index c996b85..b86d6a8 100644
--- a/modules/video_coding/main/source/video_coding_impl.cc
+++ b/modules/video_coding/main/source/video_coding_impl.cc
@@ -157,7 +157,8 @@
             uint32_t bitRate;
             uint32_t frameRate;
             _receiver.ReceiveStatistics(&bitRate, &frameRate);
-            _receiveStatsCallback->ReceiveStatistics(bitRate, frameRate);
+            _receiveStatsCallback->OnReceiveStatisticsUpdate(bitRate,
+                                                             frameRate);
         }
 
         // Size of render buffer.
diff --git a/modules/video_coding/main/source/video_coding_impl_unittest.cc b/modules/video_coding/main/source/video_coding_impl_unittest.cc
index d4fde8a..0a38582 100644
--- a/modules/video_coding/main/source/video_coding_impl_unittest.cc
+++ b/modules/video_coding/main/source/video_coding_impl_unittest.cc
@@ -192,7 +192,7 @@
   header.header.payloadType = kUnusedPayloadType;
   header.header.ssrc = 1;
   header.header.headerLength = 12;
-  header.type.Video.codec = kRTPVideoVP8;
+  header.type.Video.codec = kRtpVideoVp8;
   for (int i = 0; i < 10; ++i) {
     EXPECT_CALL(packet_request_callback_, ResendPackets(_, _))
         .Times(0);
@@ -216,7 +216,7 @@
   header.header.payloadType = kUnusedPayloadType;
   header.header.ssrc = 1;
   header.header.headerLength = 12;
-  header.type.Video.codec = kRTPVideoVP8;
+  header.type.Video.codec = kRtpVideoVp8;
   // Insert one video frame to get one frame decoded.
   header.frameType = kVideoFrameKey;
   header.type.Video.isFirstPacket = true;
@@ -270,7 +270,7 @@
   header.header.payloadType = kUnusedPayloadType;
   header.header.ssrc = 1;
   header.header.headerLength = 12;
-  header.type.Video.codec = kRTPVideoVP8;
+  header.type.Video.codec = kRtpVideoVp8;
   header.type.Video.codecHeader.VP8.pictureId = -1;
   header.type.Video.codecHeader.VP8.tl0PicIdx = -1;
   for (int i = 0; i < 3; ++i) {
diff --git a/modules/video_coding/main/source/video_coding_robustness_unittest.cc b/modules/video_coding/main/source/video_coding_robustness_unittest.cc
index a259aee..3c53945 100644
--- a/modules/video_coding/main/source/video_coding_robustness_unittest.cc
+++ b/modules/video_coding/main/source/video_coding_robustness_unittest.cc
@@ -67,7 +67,7 @@
     rtp_info.header.sequenceNumber = seq_no;
     rtp_info.header.markerBit = marker_bit;
     rtp_info.header.payloadType = video_codec_.plType;
-    rtp_info.type.Video.codec = kRTPVideoVP8;
+    rtp_info.type.Video.codec = kRtpVideoVp8;
     rtp_info.type.Video.codecHeader.VP8.InitRTPVideoHeaderVP8();
     rtp_info.type.Video.isFirstPacket = first;
 
diff --git a/modules/video_coding/main/test/codec_database_test.cc b/modules/video_coding/main/test/codec_database_test.cc
index b62995c..84ddcef 100644
--- a/modules/video_coding/main/test/codec_database_test.cc
+++ b/modules/video_coding/main/test/codec_database_test.cc
@@ -151,7 +151,7 @@
     // Testing with VP8.
     VideoCodingModule::Codec(kVideoCodecVP8, &sendCodec);
     _vcm->RegisterSendCodec(&sendCodec, 1, 1440);
-    _encodeCompleteCallback->SetCodecType(kRTPVideoVP8);
+    _encodeCompleteCallback->SetCodecType(kRtpVideoVp8);
     _vcm->InitializeReceiver();
     TEST (_vcm->AddVideoFrame(sourceFrame) == VCM_OK );
     _vcm->InitializeSender();
@@ -196,7 +196,7 @@
     VideoCodingModule::Codec(kVideoCodecVP8, &vp8EncSettings);
     _vcm->RegisterTransportCallback(_encodeCallback); // encode returns error if callback uninitialized
     _encodeCallback->RegisterReceiverVCM(_vcm);
-    _encodeCallback->SetCodecType(kRTPVideoVP8);
+    _encodeCallback->SetCodecType(kRtpVideoVp8);
     TEST(_vcm->RegisterExternalEncoder(encoder, vp8EncSettings.plType) == VCM_OK);
     TEST(_vcm->RegisterSendCodec(&vp8EncSettings, 4, 1440) == VCM_OK);
     TEST(_vcm->AddVideoFrame(sourceFrame) == VCM_OK);
@@ -232,7 +232,7 @@
     TEST(_vcm->RegisterReceiveCodec(&receiveCodec, 1, true) == VCM_OK); // Require key frame
     _vcm->RegisterTransportCallback(_encodeCallback); // encode returns error if callback uninitialized
     _encodeCallback->RegisterReceiverVCM(_vcm);
-    _encodeCallback->SetCodecType(kRTPVideoVP8);
+    _encodeCallback->SetCodecType(kRtpVideoVp8);
     TEST(_vcm->AddVideoFrame(sourceFrame) == VCM_OK);
     TEST(_vcm->Decode() == VCM_OK);
     TEST(_vcm->ResetDecoder() == VCM_OK);
diff --git a/modules/video_coding/main/test/generic_codec_test.cc b/modules/video_coding/main/test/generic_codec_test.cc
index 1a9ca39..0335349 100644
--- a/modules/video_coding/main/test/generic_codec_test.cc
+++ b/modules/video_coding/main/test/generic_codec_test.cc
@@ -549,7 +549,7 @@
     WebRtcRTPHeader rtpInfo;
     rtpInfo.header.markerBit = true; // end of frame
     rtpInfo.type.Video.codecHeader.VP8.InitRTPVideoHeaderVP8();
-    rtpInfo.type.Video.codec = kRTPVideoVP8;
+    rtpInfo.type.Video.codec = kRtpVideoVp8;
     rtpInfo.header.payloadType = payloadType;
     rtpInfo.header.sequenceNumber = _seqNo;
     _seqNo += 2;
diff --git a/modules/video_coding/main/test/media_opt_test.cc b/modules/video_coding/main/test/media_opt_test.cc
index 04da2e8..490e940 100644
--- a/modules/video_coding/main/test/media_opt_test.cc
+++ b/modules/video_coding/main/test/media_opt_test.cc
@@ -18,6 +18,7 @@
 #include <time.h>
 #include <vector>
 
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
 #include "webrtc/modules/video_coding/main/interface/video_coding.h"
 #include "webrtc/modules/video_coding/main/test/test_macros.h"
 #include "webrtc/modules/video_coding/main/test/test_util.h"
@@ -202,7 +203,6 @@
     RtpRtcp::Configuration configuration;
     configuration.id = 1;
     configuration.audio = false;
-    configuration.incoming_data = _dataCallback;
     configuration.outgoing_transport = _outgoingTransport;
     _rtp = RtpRtcp::CreateRtpRtcp(configuration);
 
@@ -211,21 +211,33 @@
     // Registering codecs for the RTP module
 
     // Register receive and send payload
-    VideoCodec videoCodec;
-    strncpy(videoCodec.plName, "VP8", 32);
-    videoCodec.plType = VCM_VP8_PAYLOAD_TYPE;
-    _rtp->RegisterReceivePayload(videoCodec);
-    _rtp->RegisterSendPayload(videoCodec);
+    VideoCodec video_codec;
+    strncpy(video_codec.plName, "VP8", 32);
+    video_codec.plType = VCM_VP8_PAYLOAD_TYPE;
+    rtp_receiver_->RegisterReceivePayload(video_codec.plName,
+                                          video_codec.plType,
+                                          90000,
+                                          0,
+                                          video_codec.maxBitrate);
+    _rtp->RegisterSendPayload(video_codec);
 
-    strncpy(videoCodec.plName, "ULPFEC", 32);
-    videoCodec.plType = VCM_ULPFEC_PAYLOAD_TYPE;
-    _rtp->RegisterReceivePayload(videoCodec);
-    _rtp->RegisterSendPayload(videoCodec);
+    strncpy(video_codec.plName, "ULPFEC", 32);
+    video_codec.plType = VCM_ULPFEC_PAYLOAD_TYPE;
+    rtp_receiver_->RegisterReceivePayload(video_codec.plName,
+                                          video_codec.plType,
+                                          90000,
+                                          0,
+                                          video_codec.maxBitrate);
+    _rtp->RegisterSendPayload(video_codec);
 
-    strncpy(videoCodec.plName, "RED", 32);
-    videoCodec.plType = VCM_RED_PAYLOAD_TYPE;
-    _rtp->RegisterReceivePayload(videoCodec);
-    _rtp->RegisterSendPayload(videoCodec);
+    strncpy(video_codec.plName, "RED", 32);
+    video_codec.plType = VCM_RED_PAYLOAD_TYPE;
+    rtp_receiver_->RegisterReceivePayload(video_codec.plName,
+                                          video_codec.plType,
+                                          90000,
+                                          0,
+                                          video_codec.maxBitrate);
+    _rtp->RegisterSendPayload(video_codec);
 
     if (_nackFecEnabled == 1)
         _rtp->SetGenericFECStatus(_nackFecEnabled, VCM_RED_PAYLOAD_TYPE,
diff --git a/modules/video_coding/main/test/media_opt_test.h b/modules/video_coding/main/test/media_opt_test.h
index cdbd53d..7f6d5e3 100644
--- a/modules/video_coding/main/test/media_opt_test.h
+++ b/modules/video_coding/main/test/media_opt_test.h
@@ -53,6 +53,7 @@
 private:
 
     webrtc::VideoCodingModule*       _vcm;
+    webrtc::RtpReceiver*             rtp_receiver_;
     webrtc::RtpRtcp*                 _rtp;
     webrtc::RTPSendCompleteCallback* _outgoingTransport;
     RtpDataCallback*                 _dataCallback;
diff --git a/modules/video_coding/main/test/mt_rx_tx_test.cc b/modules/video_coding/main/test/mt_rx_tx_test.cc
index 59b4454..c711578 100644
--- a/modules/video_coding/main/test/mt_rx_tx_test.cc
+++ b/modules/video_coding/main/test/mt_rx_tx_test.cc
@@ -16,6 +16,8 @@
 
 #include <string.h>
 
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/video_coding/main/interface/video_coding.h"
 #include "webrtc/modules/video_coding/main/test/media_opt_test.h"
@@ -152,29 +154,46 @@
     RtpRtcp::Configuration configuration;
     configuration.id = 1;
     configuration.audio = false;
-    configuration.incoming_data = &dataCallback;
     configuration.outgoing_transport = outgoingTransport;
     RtpRtcp* rtp = RtpRtcp::CreateRtpRtcp(configuration);
+    scoped_ptr<RTPPayloadRegistry> registry(new RTPPayloadRegistry(
+        -1, RTPPayloadStrategy::CreateStrategy(false)));
+    scoped_ptr<RtpReceiver> rtp_receiver(
+        RtpReceiver::CreateVideoReceiver(-1, Clock::GetRealTimeClock(),
+                                         &dataCallback, NULL, registry.get()));
 
     // registering codecs for the RTP module
-    VideoCodec videoCodec;
-    strncpy(videoCodec.plName, "ULPFEC", 32);
-    videoCodec.plType = VCM_ULPFEC_PAYLOAD_TYPE;
-    TEST(rtp->RegisterReceivePayload(videoCodec) == 0);
+    VideoCodec video_codec;
+    strncpy(video_codec.plName, "ULPFEC", 32);
+    video_codec.plType = VCM_ULPFEC_PAYLOAD_TYPE;
+    TEST(rtp_receiver->RegisterReceivePayload(video_codec.plName,
+                                              video_codec.plType,
+                                              90000,
+                                              0,
+                                              video_codec.maxBitrate) == 0);
 
-    strncpy(videoCodec.plName, "RED", 32);
-    videoCodec.plType = VCM_RED_PAYLOAD_TYPE;
-    TEST(rtp->RegisterReceivePayload(videoCodec) == 0);
+    strncpy(video_codec.plName, "RED", 32);
+    video_codec.plType = VCM_RED_PAYLOAD_TYPE;
+    TEST(rtp_receiver->RegisterReceivePayload(video_codec.plName,
+                                              video_codec.plType,
+                                              90000,
+                                              0,
+                                              video_codec.maxBitrate) == 0);
 
-    strncpy(videoCodec.plName, args.codecName.c_str(), 32);
-    videoCodec.plType = VCM_VP8_PAYLOAD_TYPE;
-    videoCodec.maxBitrate = 10000;
-    videoCodec.codecType = args.codecType;
-    TEST(rtp->RegisterReceivePayload(videoCodec) == 0);
-    TEST(rtp->RegisterSendPayload(videoCodec) == 0);
+    strncpy(video_codec.plName, args.codecName.c_str(), 32);
+    video_codec.plType = VCM_VP8_PAYLOAD_TYPE;
+    video_codec.maxBitrate = 10000;
+    video_codec.codecType = args.codecType;
+    TEST(rtp_receiver->RegisterReceivePayload(video_codec.plName,
+                                              video_codec.plType,
+                                              90000,
+                                              0,
+                                              video_codec.maxBitrate) == 0);
+    TEST(rtp->RegisterSendPayload(video_codec) == 0);
 
     // inform RTP Module of error resilience features
-    TEST(rtp->SetGenericFECStatus(fecEnabled, VCM_RED_PAYLOAD_TYPE, VCM_ULPFEC_PAYLOAD_TYPE) == 0);
+    TEST(rtp->SetGenericFECStatus(fecEnabled, VCM_RED_PAYLOAD_TYPE,
+                                  VCM_ULPFEC_PAYLOAD_TYPE) == 0);
 
     //VCM
     if (vcm->InitializeReceiver() < 0)
@@ -238,7 +257,8 @@
     FecProtectionParams delta_params = protectionCallback.DeltaFecParameters();
     FecProtectionParams key_params = protectionCallback.KeyFecParameters();
     rtp->SetFecParameters(&delta_params, &key_params);
-    rtp->SetNACKStatus(nackEnabled ? kNackRtcp : kNackOff, kMaxPacketAgeToNack);
+    rtp_receiver->SetNACKStatus(nackEnabled ? kNackRtcp : kNackOff,
+        kMaxPacketAgeToNack);
 
     vcm->SetChannelParameters(static_cast<uint32_t>(1000 * bitRate),
                               (uint8_t) lossRate, rttMS);
diff --git a/modules/video_coding/main/test/mt_test_common.cc b/modules/video_coding/main/test/mt_test_common.cc
index 04b180d..cdf57ee 100644
--- a/modules/video_coding/main/test/mt_test_common.cc
+++ b/modules/video_coding/main/test/mt_test_common.cc
@@ -13,6 +13,8 @@
 #include <cmath>
 
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
 #include "webrtc/modules/utility/interface/rtp_dump.h"
 #include "webrtc/system_wrappers/interface/clock.h"
 
@@ -95,7 +97,14 @@
           delete packet;
           return -1;
         }
-        if (_rtp->IncomingRtpPacket(packet->data, packet->length, header) < 0)
+        PayloadUnion payload_specific;
+        if (!rtp_payload_registry_->GetPayloadSpecifics(
+            header.payloadType, &payload_specific)) {
+          return -1;
+        }
+        if (!rtp_receiver_->IncomingRtpPacket(&header, packet->data,
+                                              packet->length, payload_specific,
+                                              true))
         {
             delete packet;
             return -1;
diff --git a/modules/video_coding/main/test/normal_test.cc b/modules/video_coding/main/test/normal_test.cc
index 04efa45..22d5fb2 100644
--- a/modules/video_coding/main/test/normal_test.cc
+++ b/modules/video_coding/main/test/normal_test.cc
@@ -95,7 +95,7 @@
   switch (_test.VideoType())
   {
   case kVideoCodecVP8:
-    rtpInfo.type.Video.codec = kRTPVideoVP8;
+    rtpInfo.type.Video.codec = kRtpVideoVp8;
     rtpInfo.type.Video.codecHeader.VP8.InitRTPVideoHeaderVP8();
     rtpInfo.type.Video.codecHeader.VP8.nonReference =
         videoHdr->codecHeader.VP8.nonReference;
@@ -103,7 +103,7 @@
         videoHdr->codecHeader.VP8.pictureId;
     break;
   case kVideoCodecI420:
-    rtpInfo.type.Video.codec = kRTPVideoI420;
+    rtpInfo.type.Video.codec = kRtpVideoI420;
     break;
   default:
     assert(false);
diff --git a/modules/video_coding/main/test/receiver_tests.h b/modules/video_coding/main/test/receiver_tests.h
index 095a231..47f9572 100644
--- a/modules/video_coding/main/test/receiver_tests.h
+++ b/modules/video_coding/main/test/receiver_tests.h
@@ -21,7 +21,7 @@
 #include <string>
 #include <stdio.h>
 
-class RtpDataCallback : public webrtc::RtpData {
+class RtpDataCallback : public webrtc::NullRtpData {
  public:
   RtpDataCallback(webrtc::VideoCodingModule* vcm) : vcm_(vcm) {}
   virtual ~RtpDataCallback() {}
diff --git a/modules/video_coding/main/test/rtp_player.cc b/modules/video_coding/main/test/rtp_player.cc
index 0e440da..78099d5 100644
--- a/modules/video_coding/main/test/rtp_player.cc
+++ b/modules/video_coding/main/test/rtp_player.cc
@@ -14,6 +14,8 @@
 #include <map>
 
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/video_coding/main/source/internal_defines.h"
 #include "webrtc/modules/video_coding/main/test/pcap_file_reader.h"
@@ -216,8 +218,9 @@
     RtpRtcp::Configuration configuration;
     configuration.id = 1;
     configuration.audio = false;
-    configuration.incoming_data = handler->payload_sink_.get();
-    handler->rtp_module_.reset(RtpRtcp::CreateRtpRtcp(configuration));
+    handler->rtp_module_.reset(RtpReceiver::CreateVideoReceiver(
+        configuration.id, configuration.clock, handler->payload_sink_.get(),
+        NULL, handler->rtp_payload_registry_.get()));
     if (handler->rtp_module_.get() == NULL) {
       return -1;
     }
@@ -226,9 +229,6 @@
                                             kMaxPacketAgeToNack) < 0) {
       return -1;
     }
-    handler->rtp_module_->SetRTCPStatus(kRtcpNonCompound);
-    handler->rtp_module_->SetREMBStatus(true);
-    handler->rtp_module_->SetSSRCFilter(true, ssrc);
     handler->rtp_header_parser_->RegisterRtpHeaderExtension(
         kRtpExtensionTransmissionTimeOffset,
         kDefaultTransmissionTimeOffsetExtensionId);
@@ -240,7 +240,11 @@
       strncpy(codec.plName, it->name().c_str(), sizeof(codec.plName)-1);
       codec.plType = it->payload_type();
       codec.codecType = it->codec_type();
-      if (handler->rtp_module_->RegisterReceivePayload(codec) < 0) {
+      if (handler->rtp_module_->RegisterReceivePayload(codec.plName,
+                                                       codec.plType,
+                                                       90000,
+                                                       0,
+                                                       codec.maxBitrate) < 0) {
         return -1;
       }
     }
@@ -249,20 +253,18 @@
     return 0;
   }
 
-  void Process() {
-    for (HandlerMapIt it = handlers_.begin(); it != handlers_.end(); ++it) {
-      it->second->rtp_module_->Process();
-    }
-  }
-
   void IncomingPacket(const uint8_t* data, uint32_t length) {
     for (HandlerMapIt it = handlers_.begin(); it != handlers_.end(); ++it) {
-      if (it->second->rtp_header_parser_->IsRtcp(data, length)) {
-        it->second->rtp_module_->IncomingRtcpPacket(data, length);
-      } else {
+      if (!it->second->rtp_header_parser_->IsRtcp(data, length)) {
         RTPHeader header;
         it->second->rtp_header_parser_->Parse(data, length, &header);
-        it->second->rtp_module_->IncomingRtpPacket(data, length, header);
+        PayloadUnion payload_specific;
+        it->second->rtp_payload_registry_->GetPayloadSpecifics(
+            header.payloadType, &payload_specific);
+        bool in_order =
+            it->second->rtp_module_->InOrderPacket(header.sequenceNumber);
+        it->second->rtp_module_->IncomingRtpPacket(&header, data, length,
+                                                   payload_specific, in_order);
       }
     }
   }
@@ -273,6 +275,8 @@
     Handler(uint32_t ssrc, const PayloadTypes& payload_types,
             LostPackets* lost_packets)
         : rtp_header_parser_(RtpHeaderParser::Create()),
+          rtp_payload_registry_(new RTPPayloadRegistry(
+              0, RTPPayloadStrategy::CreateStrategy(false))),
           rtp_module_(),
           payload_sink_(),
           ssrc_(ssrc),
@@ -296,7 +300,8 @@
     }
 
     scoped_ptr<RtpHeaderParser> rtp_header_parser_;
-    scoped_ptr<RtpRtcp> rtp_module_;
+    scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
+    scoped_ptr<RtpReceiver> rtp_module_;
     scoped_ptr<PayloadSinkInterface> payload_sink_;
 
    private:
@@ -366,8 +371,6 @@
 
     // Send any packets from packet source.
     if (!end_of_file_ && (TimeUntilNextPacket() == 0 || first_packet_)) {
-      ssrc_handlers_.Process();
-
       if (first_packet_) {
         next_packet_length_ = sizeof(next_packet_);
         if (packet_source_->NextPacket(next_packet_, &next_packet_length_,
diff --git a/modules/video_coding/main/test/test_callbacks.cc b/modules/video_coding/main/test/test_callbacks.cc
index bbd7aea..c14c8b1 100644
--- a/modules/video_coding/main/test/test_callbacks.cc
+++ b/modules/video_coding/main/test/test_callbacks.cc
@@ -14,6 +14,8 @@
 
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
 #include "webrtc/modules/utility/interface/rtp_dump.h"
 #include "webrtc/modules/video_coding/main/test/test_macros.h"
 #include "webrtc/system_wrappers/interface/clock.h"
@@ -34,7 +36,7 @@
     _encodeComplete(false),
     _width(0),
     _height(0),
-    _codecType(kRTPVideoNoVideo)
+    _codecType(kRtpVideoNone)
 {
     //
 }
@@ -73,14 +75,14 @@
     rtpInfo.type.Video.width = (uint16_t)_width;
     switch (_codecType)
     {
-    case webrtc::kRTPVideoVP8:
+    case webrtc::kRtpVideoVp8:
         rtpInfo.type.Video.codecHeader.VP8.InitRTPVideoHeaderVP8();
         rtpInfo.type.Video.codecHeader.VP8.nonReference =
             videoHdr->codecHeader.VP8.nonReference;
         rtpInfo.type.Video.codecHeader.VP8.pictureId =
             videoHdr->codecHeader.VP8.pictureId;
         break;
-    case webrtc::kRTPVideoI420:
+    case webrtc::kRtpVideoI420:
         break;
     default:
         assert(false);
@@ -209,6 +211,8 @@
                                                  const char* filename):
     _clock(clock),
     _sendCount(0),
+    rtp_payload_registry_(NULL),
+    rtp_receiver_(NULL),
     _rtp(NULL),
     _lossPct(0),
     _burstLength(0),
@@ -299,7 +303,14 @@
           delete packet;
           return -1;
         }
-        if (_rtp->IncomingRtpPacket(packet->data, packet->length, header) < 0)
+        PayloadUnion payload_specific;
+        if (!rtp_payload_registry_->GetPayloadSpecifics(
+            header.payloadType, &payload_specific)) {
+          return -1;
+        }
+        if (!rtp_receiver_->IncomingRtpPacket(&header, packet->data,
+                                              packet->length, payload_specific,
+                                              true))
         {
             delete packet;
             return -1;
diff --git a/modules/video_coding/main/test/test_callbacks.h b/modules/video_coding/main/test/test_callbacks.h
index 14d76bc..f2375d1 100644
--- a/modules/video_coding/main/test/test_callbacks.h
+++ b/modules/video_coding/main/test/test_callbacks.h
@@ -29,6 +29,7 @@
 
 namespace webrtc
 {
+class RTPPayloadRegistry;
 class RtpDump;
 
 // Send Side - Packetization callback - send an encoded frame to the VCMReceiver
@@ -59,7 +60,7 @@
     // Return encode complete (true/false)
     bool EncodeComplete();
     // Inform callback of codec used
-    void SetCodecType(RTPVideoCodecTypes codecType)
+    void SetCodecType(RtpVideoCodecTypes codecType)
     {_codecType = codecType;}
     // Inform callback of frame dimensions
     void SetFrameDimensions(int32_t width, int32_t height)
@@ -82,7 +83,7 @@
     bool               _encodeComplete;
     int32_t      _width;
     int32_t      _height;
-    RTPVideoCodecTypes _codecType;
+    RtpVideoCodecTypes _codecType;
 
 }; // end of VCMEncodeCompleteCallback
 
@@ -113,7 +114,7 @@
     // Return encode complete (true/false)
     bool EncodeComplete();
     // Inform callback of codec used
-    void SetCodecType(RTPVideoCodecTypes codecType)
+    void SetCodecType(RtpVideoCodecTypes codecType)
     {_codecType = codecType;}
 
     // Inform callback of frame dimensions
@@ -130,7 +131,7 @@
     RtpRtcp*           _RTPModule;
     int16_t      _width;
     int16_t      _height;
-    RTPVideoCodecTypes _codecType;
+    RtpVideoCodecTypes _codecType;
 }; // end of VCMEncodeCompleteCallback
 
 // Decode Complete callback
@@ -188,6 +189,8 @@
 
     Clock*                  _clock;
     uint32_t          _sendCount;
+    RTPPayloadRegistry* rtp_payload_registry_;
+    RtpReceiver* rtp_receiver_;
     RtpRtcp*                _rtp;
     double                  _lossPct;
     double                  _burstLength;
diff --git a/modules/video_coding/main/test/test_util.cc b/modules/video_coding/main/test/test_util.cc
index 159de17..aad2b53 100644
--- a/modules/video_coding/main/test/test_util.cc
+++ b/modules/video_coding/main/test/test_util.cc
@@ -146,12 +146,12 @@
   return 0;
 }
 
-webrtc::RTPVideoCodecTypes ConvertCodecType(const char* plname) {
+webrtc::RtpVideoCodecTypes ConvertCodecType(const char* plname) {
   if (strncmp(plname,"VP8" , 3) == 0) {
-    return webrtc::kRTPVideoVP8;
+    return webrtc::kRtpVideoVp8;
   } else if (strncmp(plname,"I420" , 5) == 0) {
-    return webrtc::kRTPVideoI420;
+    return webrtc::kRtpVideoI420;
   } else {
-    return webrtc::kRTPVideoNoVideo; // Default value
+    return webrtc::kRtpVideoNone;  // Default value
   }
 }
diff --git a/modules/video_coding/main/test/test_util.h b/modules/video_coding/main/test/test_util.h
index 48dd35a..c08786a 100644
--- a/modules/video_coding/main/test/test_util.h
+++ b/modules/video_coding/main/test/test_util.h
@@ -102,6 +102,6 @@
 };
 
 // Codec type conversion
-webrtc::RTPVideoCodecTypes ConvertCodecType(const char* plname);
+webrtc::RtpVideoCodecTypes ConvertCodecType(const char* plname);
 
 #endif
diff --git a/modules/video_coding/main/test/vcm_payload_sink_factory.cc b/modules/video_coding/main/test/vcm_payload_sink_factory.cc
index ccc74e9..beee0cd 100644
--- a/modules/video_coding/main/test/vcm_payload_sink_factory.cc
+++ b/modules/video_coding/main/test/vcm_payload_sink_factory.cc
@@ -67,6 +67,12 @@
     return vcm_->IncomingPacket(payload_data, payload_size, *rtp_header);
   }
 
+  virtual bool OnRecoveredPacket(const uint8_t* packet,
+                                 int packet_length) {
+    // We currently don't handle FEC.
+    return true;
+  }
+
   // VCMPacketRequestCallback
   virtual int32_t ResendPackets(const uint16_t* sequence_numbers,
                                 uint16_t length) {
diff --git a/video_engine/include/vie_network.h b/video_engine/include/vie_network.h
index 575eed1..e1c6bb2 100644
--- a/video_engine/include/vie_network.h
+++ b/video_engine/include/vie_network.h
@@ -32,24 +32,6 @@
   PacketReceived = 1
 };
 
-// This class declares an abstract interface for a user defined observer. It is
-// up to the VideoEngine user to implement a derived class which implements the
-// observer class. The observer is registered using RegisterObserver() and
-// deregistered using DeregisterObserver().
-class WEBRTC_DLLEXPORT ViENetworkObserver {
- public:
-  // This method will be called periodically delivering a dead‐or‐alive
-  // decision for a specified channel.
-  virtual void OnPeriodicDeadOrAlive(const int video_channel,
-                                     const bool alive) = 0;
-
-  // This method is called once if a packet timeout occurred.
-  virtual void PacketTimeout(const int video_channel,
-                             const ViEPacketTimeout timeout) = 0;
- protected:
-  virtual ~ViENetworkObserver() {}
-};
-
 class WEBRTC_DLLEXPORT ViENetwork {
  public:
   // Default values.
@@ -96,27 +78,6 @@
   // over the network.
   virtual int SetMTU(int video_channel, unsigned int mtu) = 0;
 
-  // This function enables or disables warning reports if packets have not
-  // been received for a specified time interval.
-  virtual int SetPacketTimeoutNotification(const int video_channel,
-                                           bool enable,
-                                           int timeout_seconds) = 0;
-
-  // Registers an instance of a user implementation of the ViENetwork
-  // observer.
-  virtual int RegisterObserver(const int video_channel,
-                               ViENetworkObserver& observer) = 0;
-
-  // Removes a registered instance of ViENetworkObserver.
-  virtual int DeregisterObserver(const int video_channel) = 0;
-
-  // This function enables or disables the periodic dead‐or‐alive callback
-  // functionality for a specified channel.
-  virtual int SetPeriodicDeadOrAliveStatus(
-      const int video_channel,
-      const bool enable,
-      const unsigned int sample_time_seconds = KDefaultSampleTimeSeconds) = 0;
-
  protected:
   ViENetwork() {}
   virtual ~ViENetwork() {}
diff --git a/video_engine/test/auto_test/source/vie_autotest_network.cc b/video_engine/test/auto_test/source/vie_autotest_network.cc
index d8edcf5..df5b5ef 100644
--- a/video_engine/test/auto_test/source/vie_autotest_network.cc
+++ b/video_engine/test/auto_test/source/vie_autotest_network.cc
@@ -25,24 +25,6 @@
 #include <qos.h>
 #endif
 
-class ViEAutoTestNetworkObserver: public webrtc::ViENetworkObserver
-{
-public:
-    ViEAutoTestNetworkObserver()
-    {
-    }
-    virtual ~ViEAutoTestNetworkObserver()
-    {
-    }
-    virtual void OnPeriodicDeadOrAlive(const int videoChannel, const bool alive)
-    {
-    }
-    virtual void PacketTimeout(const int videoChannel,
-                               const webrtc::ViEPacketTimeout timeout)
-    {
-    }
-};
-
 void ViEAutoTest::ViENetworkStandardTest()
 {
     TbInterfaces ViE("ViENetworkStandardTest"); // Create VIE
@@ -545,26 +527,6 @@
         EXPECT_NE(0, ViE.network->SetMTU(tbChannel.videoChannel, 1600));
         // Valid input
         EXPECT_EQ(0, ViE.network->SetMTU(tbChannel.videoChannel, 800));
-
-        //
-        // Observer and timeout
-        //
-        ViEAutoTestNetworkObserver vieTestObserver;
-        EXPECT_EQ(0, ViE.network->RegisterObserver(
-            tbChannel.videoChannel, vieTestObserver));
-        EXPECT_NE(0, ViE.network->RegisterObserver(
-            tbChannel.videoChannel, vieTestObserver));
-        EXPECT_EQ(0, ViE.network->SetPeriodicDeadOrAliveStatus(
-            tbChannel.videoChannel, true)); // No observer
-        EXPECT_EQ(0, ViE.network->DeregisterObserver(tbChannel.videoChannel));
-
-        EXPECT_NE(0, ViE.network->DeregisterObserver(tbChannel.videoChannel));
-        EXPECT_NE(0, ViE.network->SetPeriodicDeadOrAliveStatus(
-            tbChannel.videoChannel, true)); // No observer
-
-        // Packet timout notification
-        EXPECT_EQ(0, ViE.network->SetPacketTimeoutNotification(
-            tbChannel.videoChannel, true, 10));
     }
 
     //***************************************************************
diff --git a/video_engine/vie_channel.cc b/video_engine/vie_channel.cc
index 78a9015..77c3c26 100644
--- a/video_engine/vie_channel.cc
+++ b/video_engine/vie_channel.cc
@@ -15,6 +15,7 @@
 
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/pacing/include/paced_sender.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/utility/interface/process_thread.h"
 #include "webrtc/modules/video_coding/main/interface/video_coding.h"
@@ -74,7 +75,7 @@
       default_rtp_rtcp_(default_rtp_rtcp),
       rtp_rtcp_(NULL),
       vcm_(*VideoCodingModule::Create(ViEModuleId(engine_id, channel_id))),
-      vie_receiver_(channel_id, &vcm_, remote_bitrate_estimator),
+      vie_receiver_(channel_id, &vcm_, remote_bitrate_estimator, this),
       vie_sender_(channel_id),
       vie_sync_(&vcm_, this),
       stats_observer_(new ChannelStatsObserver(this)),
@@ -83,16 +84,13 @@
       do_key_frame_callbackRequest_(false),
       rtp_observer_(NULL),
       rtcp_observer_(NULL),
-      networkObserver_(NULL),
       intra_frame_observer_(intra_frame_observer),
       rtt_observer_(rtt_observer),
       paced_sender_(paced_sender),
       bandwidth_observer_(bandwidth_observer),
-      rtp_packet_timeout_(false),
       send_timestamp_extension_id_(kInvalidRtpExtensionId),
       absolute_send_time_extension_id_(kInvalidRtpExtensionId),
       receive_absolute_send_time_enabled_(false),
-      using_packet_spread_(false),
       external_transport_(NULL),
       decoder_reset_(true),
       wait_for_key_frame_(false),
@@ -112,8 +110,6 @@
   configuration.id = ViEModuleId(engine_id, channel_id);
   configuration.audio = false;
   configuration.default_module = default_rtp_rtcp;
-  configuration.incoming_data = &vie_receiver_;
-  configuration.incoming_messages = this;
   configuration.outgoing_transport = &vie_sender_;
   configuration.rtcp_feedback = this;
   configuration.intra_frame_callback = intra_frame_observer;
@@ -121,6 +117,7 @@
   configuration.rtt_observer = rtt_observer;
   configuration.remote_bitrate_estimator = remote_bitrate_estimator;
   configuration.paced_sender = paced_sender;
+  configuration.receive_statistics = vie_receiver_.GetReceiveStatistics();
 
   rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(configuration));
   vie_receiver_.SetRtpRtcpModule(rtp_rtcp_.get());
@@ -132,6 +129,13 @@
                "%s: channel_id: %d, engine_id: %d)", __FUNCTION__, channel_id_,
                engine_id_);
 
+  if (module_process_thread_.RegisterModule(
+      vie_receiver_.GetReceiveStatistics()) != 0) {
+    WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
+                 "%s: Failed to register receive-statistics to process thread",
+                 __FUNCTION__);
+    return -1;
+  }
   // RTP/RTCP initialization.
   if (rtp_rtcp_->SetSendingMediaStatus(false) != 0) {
     WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
@@ -197,7 +201,10 @@
   VideoCodec video_codec;
   if (vcm_.Codec(kVideoCodecVP8, &video_codec) == VCM_OK) {
     rtp_rtcp_->RegisterSendPayload(video_codec);
-    rtp_rtcp_->RegisterReceivePayload(video_codec);
+    // TODO(holmer): Can we call SetReceiveCodec() here instead?
+    if (!vie_receiver_.RegisterPayload(video_codec)) {
+      return -1;
+    }
     vcm_.RegisterReceiveCodec(&video_codec, number_of_cores_);
     vcm_.RegisterSendCodec(&video_codec, number_of_cores_,
                            rtp_rtcp_->MaxDataPayloadLength());
@@ -215,6 +222,7 @@
                channel_id_, engine_id_);
 
   // Make sure we don't get more callbacks from the RTP module.
+  module_process_thread_.DeRegisterModule(vie_receiver_.GetReceiveStatistics());
   module_process_thread_.DeRegisterModule(rtp_rtcp_.get());
   module_process_thread_.DeRegisterModule(&vcm_);
   module_process_thread_.DeRegisterModule(&vie_sync_);
@@ -270,7 +278,6 @@
       (*it)->SetSendingMediaStatus(false);
     }
   }
-  NACKMethod nack_method = rtp_rtcp_->NACK();
 
   bool fec_enabled = false;
   uint8_t payload_type_red;
@@ -317,12 +324,6 @@
         WEBRTC_TRACE(kTraceWarning, kTraceVideo, ViEId(engine_id_, channel_id_),
                      "%s: RTP::SetRTCPStatus failure", __FUNCTION__);
       }
-      if (nack_method != kNackOff) {
-        rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_);
-        rtp_rtcp->SetNACKStatus(nack_method, max_nack_reordering_threshold_);
-      } else if (paced_sender_) {
-        rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_);
-      }
       if (fec_enabled) {
         rtp_rtcp->SetGenericFECStatus(fec_enabled, payload_type_red,
             payload_type_fec);
@@ -444,12 +445,7 @@
   WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
                "%s", __FUNCTION__);
 
-  int8_t old_pltype = -1;
-  if (rtp_rtcp_->ReceivePayloadType(video_codec, &old_pltype) != -1) {
-    rtp_rtcp_->DeRegisterReceivePayload(old_pltype);
-  }
-
-  if (rtp_rtcp_->RegisterReceivePayload(video_codec) != 0) {
+  if (!vie_receiver_.SetReceiveCodec(video_codec)) {
     WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
                  "%s: Could not register receive payload type", __FUNCTION__);
     return -1;
@@ -659,8 +655,8 @@
                    "%s: Could not enable NACK, RTPC not on ", __FUNCTION__);
       return -1;
     }
-    if (rtp_rtcp_->SetNACKStatus(nackMethod,
-                                 max_nack_reordering_threshold_) != 0) {
+    if (!vie_receiver_.SetNackStatus(true,
+                                     max_nack_reordering_threshold_)) {
       WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
                    "%s: Could not set NACK method %d", __FUNCTION__,
                    nackMethod);
@@ -678,7 +674,6 @@
          it != simulcast_rtp_rtcp_.end();
          it++) {
       RtpRtcp* rtp_rtcp = *it;
-      rtp_rtcp->SetNACKStatus(nackMethod, max_nack_reordering_threshold_);
       rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_);
     }
   } else {
@@ -690,14 +685,13 @@
       if (paced_sender_ == NULL) {
         rtp_rtcp->SetStorePacketsStatus(false, 0);
       }
-      rtp_rtcp->SetNACKStatus(kNackOff, max_nack_reordering_threshold_);
     }
     vcm_.RegisterPacketRequestCallback(NULL);
     if (paced_sender_ == NULL) {
       rtp_rtcp_->SetStorePacketsStatus(false, 0);
     }
-    if (rtp_rtcp_->SetNACKStatus(kNackOff,
-                                 max_nack_reordering_threshold_) != 0) {
+    if (!vie_receiver_.SetNackStatus(false,
+                                     max_nack_reordering_threshold_)) {
       WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
                    "%s: Could not turn off NACK", __FUNCTION__);
       return -1;
@@ -977,14 +971,15 @@
 }
 
 int32_t ViEChannel::SetRemoteSSRCType(const StreamType usage,
-                                      const uint32_t SSRC) const {
+                                      const uint32_t SSRC) {
   WEBRTC_TRACE(webrtc::kTraceInfo,
                webrtc::kTraceVideo,
                ViEId(engine_id_, channel_id_),
                "%s(usage:%d, SSRC: 0x%x)",
                __FUNCTION__, usage, SSRC);
 
-  return rtp_rtcp_->SetRTXReceiveStatus(true, SSRC);
+  vie_receiver_.SetRtxStatus(true, SSRC);
+  return 0;
 }
 
 // TODO(mflodman) Add kViEStreamTypeRtx.
@@ -1014,7 +1009,7 @@
   WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
                __FUNCTION__);
 
-  *ssrc = rtp_rtcp_->RemoteSSRC();
+  *ssrc = vie_receiver_.GetRemoteSsrc();
   return 0;
 }
 
@@ -1025,7 +1020,7 @@
   uint32_t arrayCSRC[kRtpCsrcSize];
   memset(arrayCSRC, 0, sizeof(arrayCSRC));
 
-  int num_csrcs = rtp_rtcp_->RemoteCSRCs(arrayCSRC);
+  int num_csrcs = vie_receiver_.GetCsrcs(arrayCSRC);
   if (num_csrcs > 0) {
     memcpy(CSRCs, arrayCSRC, num_csrcs * sizeof(uint32_t));
     for (int idx = 0; idx < num_csrcs; idx++) {
@@ -1055,12 +1050,7 @@
 }
 
 void ViEChannel::SetRtxReceivePayloadType(int payload_type) {
-  rtp_rtcp_->SetRtxReceivePayloadType(payload_type);
-  CriticalSectionScoped cs(rtp_rtcp_cs_.get());
-  for (std::list<RtpRtcp*>::iterator it = simulcast_rtp_rtcp_.begin();
-       it != simulcast_rtp_rtcp_.end(); it++) {
-    (*it)->SetRtxReceivePayloadType(payload_type);
-  }
+  vie_receiver_.SetRtxPayloadType(payload_type);
 }
 
 int32_t ViEChannel::SetStartSequenceNumber(uint16_t sequence_number) {
@@ -1096,7 +1086,7 @@
   WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
                __FUNCTION__);
 
-  uint32_t remoteSSRC = rtp_rtcp_->RemoteSSRC();
+  uint32_t remoteSSRC = vie_receiver_.GetRemoteSsrc();
   return rtp_rtcp_->RemoteCNAME(remoteSSRC, rtcp_cname);
 }
 
@@ -1203,7 +1193,7 @@
   //      it++) {
   //   RtpRtcp* rtp_rtcp = *it;
   // }
-  uint32_t remote_ssrc = rtp_rtcp_->RemoteSSRC();
+  uint32_t remote_ssrc = vie_receiver_.GetRemoteSsrc();
 
   // Get all RTCP receiver report blocks that have been received on this
   // channel. If we receive RTP packets from a remote source we know the
@@ -1246,24 +1236,33 @@
   return 0;
 }
 
+// TODO(holmer): This is a bad function name as it implies that it returns the
+// received RTCP, while it actually returns the statistics which will be sent
+// in the RTCP.
 int32_t ViEChannel::GetReceivedRtcpStatistics(uint16_t* fraction_lost,
-                                                    uint32_t* cumulative_lost,
-                                                    uint32_t* extended_max,
-                                                    uint32_t* jitter_samples,
-                                                    int32_t* rtt_ms) {
+                                              uint32_t* cumulative_lost,
+                                              uint32_t* extended_max,
+                                              uint32_t* jitter_samples,
+                                              int32_t* rtt_ms) {
   WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
                "%s", __FUNCTION__);
 
   uint8_t frac_lost = 0;
-  if (rtp_rtcp_->StatisticsRTP(&frac_lost, cumulative_lost, extended_max,
-                              jitter_samples) != 0) {
+  ReceiveStatistics* receive_statistics = vie_receiver_.GetReceiveStatistics();
+  ReceiveStatistics::RtpReceiveStatistics receive_stats;
+  if (!receive_statistics || !receive_statistics->Statistics(
+      &receive_stats, rtp_rtcp_->RTCP() == kRtcpOff)) {
     WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
                  "%s: Could not get received RTP statistics", __FUNCTION__);
     return -1;
   }
+  *fraction_lost = receive_stats.fraction_lost;
+  *cumulative_lost = receive_stats.cumulative_lost;
+  *extended_max = receive_stats.extended_max_sequence_number;
+  *jitter_samples = receive_stats.jitter;
   *fraction_lost = frac_lost;
 
-  uint32_t remote_ssrc = rtp_rtcp_->RemoteSSRC();
+  uint32_t remote_ssrc = vie_receiver_.GetRemoteSsrc();
   uint16_t dummy = 0;
   uint16_t rtt = 0;
   if (rtp_rtcp_->RTT(remote_ssrc, &rtt, &dummy, &dummy, &dummy) != 0) {
@@ -1275,16 +1274,15 @@
 }
 
 int32_t ViEChannel::GetRtpStatistics(uint32_t* bytes_sent,
-                                           uint32_t* packets_sent,
-                                           uint32_t* bytes_received,
-                                           uint32_t* packets_received) const {
+                                     uint32_t* packets_sent,
+                                     uint32_t* bytes_received,
+                                     uint32_t* packets_received) const {
   WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
                __FUNCTION__);
 
-  if (rtp_rtcp_->DataCountersRTP(bytes_sent,
-                                 packets_sent,
-                                 bytes_received,
-                                 packets_received) != 0) {
+  ReceiveStatistics* receive_statistics = vie_receiver_.GetReceiveStatistics();
+  receive_statistics->GetDataCounters(bytes_received, packets_received);
+  if (rtp_rtcp_->DataCountersRTP(bytes_sent, packets_sent) != 0) {
     WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
                  "%s: Could not get counters", __FUNCTION__);
     return -1;
@@ -1296,7 +1294,7 @@
     uint32_t bytes_sent_temp = 0;
     uint32_t packets_sent_temp = 0;
     RtpRtcp* rtp_rtcp = *it;
-    rtp_rtcp->DataCountersRTP(&bytes_sent_temp, &packets_sent_temp, NULL, NULL);
+    rtp_rtcp->DataCountersRTP(&bytes_sent_temp, &packets_sent_temp);
     bytes_sent += bytes_sent_temp;
     packets_sent += packets_sent_temp;
   }
@@ -1557,92 +1555,6 @@
   return rtp_rtcp_->MaxDataPayloadLength();
 }
 
-int32_t ViEChannel::SetPacketTimeoutNotification(
-    bool enable, uint32_t timeout_seconds) {
-  WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
-               __FUNCTION__);
-  if (enable) {
-    uint32_t timeout_ms = 1000 * timeout_seconds;
-    if (rtp_rtcp_->SetPacketTimeout(timeout_ms, 0) != 0) {
-      WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
-                   "%s", __FUNCTION__);
-      return -1;
-    }
-  } else {
-    if (rtp_rtcp_->SetPacketTimeout(0, 0) != 0) {
-      WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
-                   "%s", __FUNCTION__);
-      return -1;
-    }
-  }
-  return 0;
-}
-
-int32_t ViEChannel::RegisterNetworkObserver(
-    ViENetworkObserver* observer) {
-  CriticalSectionScoped cs(callback_cs_.get());
-  if (observer) {
-    if (networkObserver_) {
-      WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
-                   "%s: observer alread added", __FUNCTION__);
-      return -1;
-    }
-    WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
-                 "%s: observer added", __FUNCTION__);
-    networkObserver_ = observer;
-  } else {
-    if (!networkObserver_) {
-      WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
-                   "%s: no observer added", __FUNCTION__);
-      return -1;
-    }
-    WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
-                 "%s: observer removed", __FUNCTION__);
-    networkObserver_ = NULL;
-  }
-  return 0;
-}
-
-bool ViEChannel::NetworkObserverRegistered() {
-  CriticalSectionScoped cs(callback_cs_.get());
-  return networkObserver_ != NULL;
-}
-
-int32_t ViEChannel::SetPeriodicDeadOrAliveStatus(
-  const bool enable, const uint32_t sample_time_seconds) {
-  WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
-               __FUNCTION__);
-
-  CriticalSectionScoped cs(callback_cs_.get());
-  if (!networkObserver_) {
-    WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
-                 "%s: no observer added", __FUNCTION__);
-    return -1;
-  }
-
-  bool enabled = false;
-  uint8_t current_sampletime_seconds = 0;
-
-  // Get old settings.
-  rtp_rtcp_->PeriodicDeadOrAliveStatus(enabled, current_sampletime_seconds);
-  // Set new settings.
-  if (rtp_rtcp_->SetPeriodicDeadOrAliveStatus(
-        enable, static_cast<uint8_t>(sample_time_seconds)) != 0) {
-    WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(engine_id_, channel_id_),
-                 "%s: Could not set periodic dead-or-alive status",
-                 __FUNCTION__);
-    return -1;
-  }
-  if (!enable) {
-    // Restore last utilized sample time.
-    // Without this trick, the sample time would always be reset to default
-    // (2 sec), each time dead-or-alive was disabled without sample-time
-    // parameter.
-    rtp_rtcp_->SetPeriodicDeadOrAliveStatus(enable, current_sampletime_seconds);
-  }
-  return 0;
-}
-
 int32_t ViEChannel::EnableColorEnhancement(bool enable) {
   WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
                "%s(enable: %d)", __FUNCTION__, enable);
@@ -1699,9 +1611,9 @@
   }
 
   uint32_t arr_ofCSRC[kRtpCsrcSize];
-  int32_t no_of_csrcs = rtp_rtcp_->RemoteCSRCs(arr_ofCSRC);
+  int32_t no_of_csrcs = vie_receiver_.GetCsrcs(arr_ofCSRC);
   if (no_of_csrcs <= 0) {
-    arr_ofCSRC[0] = rtp_rtcp_->RemoteSSRC();
+    arr_ofCSRC[0] = rtp_rtcp_->SSRC();
     no_of_csrcs = 1;
   }
   WEBRTC_TRACE(kTraceStream, kTraceVideo, ViEId(engine_id_, channel_id_),
@@ -1720,8 +1632,8 @@
   return 0;
 }
 
-int32_t ViEChannel::ReceiveStatistics(const uint32_t bit_rate,
-                                            const uint32_t frame_rate) {
+int32_t ViEChannel::OnReceiveStatisticsUpdate(const uint32_t bit_rate,
+                                              const uint32_t frame_rate) {
   CriticalSectionScoped cs(callback_cs_.get());
   if (codec_observer_) {
     WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
@@ -1874,8 +1786,10 @@
   } else {
     module_process_thread_.DeRegisterModule(&vie_sync_);
   }
-  return vie_sync_.ConfigureSync(ve_channel_id, ve_sync_interface,
-                                 rtp_rtcp_.get());
+  return vie_sync_.ConfigureSync(ve_channel_id,
+                                 ve_sync_interface,
+                                 rtp_rtcp_.get(),
+                                 vie_receiver_.GetRtpReceiver());
 }
 
 int32_t ViEChannel::VoiceChannel() {
@@ -1947,52 +1861,6 @@
   return 0;
 }
 
-void ViEChannel::OnPacketTimeout(const int32_t id) {
-  assert(ChannelId(id) == channel_id_);
-  WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
-               __FUNCTION__);
-
-  CriticalSectionScoped cs(callback_cs_.get());
-  if (networkObserver_) {
-    networkObserver_->PacketTimeout(channel_id_, NoPacket);
-    rtp_packet_timeout_ = true;
-  }
-}
-
-void ViEChannel::OnReceivedPacket(const int32_t id,
-                                  const RtpRtcpPacketType packet_type) {
-  assert(ChannelId(id) == channel_id_);
-  WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_), "%s",
-               __FUNCTION__);
-  if (rtp_packet_timeout_ && packet_type == kPacketRtp) {
-    CriticalSectionScoped cs(callback_cs_.get());
-    if (networkObserver_) {
-      networkObserver_->PacketTimeout(channel_id_, PacketReceived);
-    }
-
-    // Reset even if no observer set, might have been removed during timeout.
-    rtp_packet_timeout_ = false;
-  }
-}
-
-void ViEChannel::OnPeriodicDeadOrAlive(const int32_t id,
-                                       const RTPAliveType alive) {
-  assert(ChannelId(id) == channel_id_);
-  WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
-               "%s(id=%d, alive=%d)", __FUNCTION__, id, alive);
-
-  CriticalSectionScoped cs(callback_cs_.get());
-  if (!networkObserver_) {
-    return;
-  }
-  bool is_alive = true;
-  if (alive == kRtpDead) {
-    is_alive = false;
-  }
-  networkObserver_->OnPeriodicDeadOrAlive(channel_id_, is_alive);
-  return;
-}
-
 void ViEChannel::OnIncomingSSRCChanged(const int32_t id,
                                        const uint32_t SSRC) {
   if (channel_id_ != ChannelId(id)) {
@@ -2005,6 +1873,8 @@
   WEBRTC_TRACE(kTraceInfo, kTraceVideo, ViEId(engine_id_, channel_id_),
                "%s: %u", __FUNCTION__, SSRC);
 
+  rtp_rtcp_->SetRemoteSSRC(SSRC);
+
   CriticalSectionScoped cs(callback_cs_.get());
   {
     if (rtp_observer_) {
@@ -2037,4 +1907,8 @@
   }
 }
 
+void ViEChannel::OnResetStatistics() {
+  vie_receiver_.GetReceiveStatistics()->ResetStatistics();
+}
+
 }  // namespace webrtc
diff --git a/video_engine/vie_channel.h b/video_engine/vie_channel.h
index 090582b..fc86dfc 100644
--- a/video_engine/vie_channel.h
+++ b/video_engine/vie_channel.h
@@ -41,7 +41,6 @@
 class ThreadWrapper;
 class ViEDecoderObserver;
 class ViEEffectFilter;
-class ViENetworkObserver;
 class ViERTCPObserver;
 class ViERTPObserver;
 class VideoCodingModule;
@@ -209,16 +208,12 @@
       const int frequency,
       const uint8_t channels,
       const uint32_t rate);
-  virtual void OnPacketTimeout(const int32_t id);
-  virtual void OnReceivedPacket(const int32_t id,
-                                const RtpRtcpPacketType packet_type);
-  virtual void OnPeriodicDeadOrAlive(const int32_t id,
-                                     const RTPAliveType alive);
   virtual void OnIncomingSSRCChanged(const int32_t id,
                                      const uint32_t SSRC);
   virtual void OnIncomingCSRCChanged(const int32_t id,
                                      const uint32_t CSRC,
                                      const bool added);
+  virtual void OnResetStatistics();
 
   int32_t SetLocalReceiver(const uint16_t rtp_port,
                            const uint16_t rtcp_port,
@@ -241,7 +236,7 @@
                         char* ip_address,
                         uint32_t ip_address_length);
 
-  int32_t SetRemoteSSRCType(const StreamType usage, const uint32_t SSRC) const;
+  int32_t SetRemoteSSRCType(const StreamType usage, const uint32_t SSRC);
 
   int32_t StartSend();
   int32_t StopSend();
@@ -270,12 +265,6 @@
   int32_t SetMaxPacketBurstSize(uint16_t max_number_of_packets);
   int32_t SetPacketBurstSpreadState(bool enable, const uint16_t frame_periodMS);
 
-  int32_t SetPacketTimeoutNotification(bool enable, uint32_t timeout_seconds);
-  int32_t RegisterNetworkObserver(ViENetworkObserver* observer);
-  bool NetworkObserverRegistered();
-  int32_t SetPeriodicDeadOrAliveStatus(
-      const bool enable, const uint32_t sample_time_seconds);
-
   int32_t EnableColorEnhancement(bool enable);
 
   // Gets the modules used by the channel.
@@ -295,7 +284,7 @@
       const EncodedVideoData& frame_to_store);
 
   // Implements VideoReceiveStatisticsCallback.
-  virtual int32_t ReceiveStatistics(const uint32_t bit_rate,
+  virtual int32_t OnReceiveStatisticsUpdate(const uint32_t bit_rate,
                                     const uint32_t frame_rate);
 
   // Implements VideoFrameTypeCallback.
@@ -368,13 +357,11 @@
   bool do_key_frame_callbackRequest_;
   ViERTPObserver* rtp_observer_;
   ViERTCPObserver* rtcp_observer_;
-  ViENetworkObserver* networkObserver_;
   RtcpIntraFrameObserver* intra_frame_observer_;
   RtcpRttObserver* rtt_observer_;
   PacedSender* paced_sender_;
 
   scoped_ptr<RtcpBandwidthObserver> bandwidth_observer_;
-  bool rtp_packet_timeout_;
   int send_timestamp_extension_id_;
   int absolute_send_time_extension_id_;
   bool receive_absolute_send_time_enabled_;
diff --git a/video_engine/vie_codec_impl.cc b/video_engine/vie_codec_impl.cc
index b98b0f8..691bd71 100644
--- a/video_engine/vie_codec_impl.cc
+++ b/video_engine/vie_codec_impl.cc
@@ -247,7 +247,7 @@
   shared_data_->channel_manager()->UpdateSsrcs(video_channel, ssrcs);
 
   // Update the protection mode, we might be switching NACK/FEC.
-  vie_encoder->UpdateProtectionMethod();
+  vie_encoder->UpdateProtectionMethod(vie_encoder->nack_enabled());
 
   // Get new best format for frame provider.
   if (frame_provider) {
diff --git a/video_engine/vie_encoder.cc b/video_engine/vie_encoder.cc
index e91645b..85b004a 100644
--- a/video_engine/vie_encoder.cc
+++ b/video_engine/vie_encoder.cc
@@ -725,7 +725,7 @@
   return 0;
 }
 
-int32_t ViEEncoder::UpdateProtectionMethod() {
+int32_t ViEEncoder::UpdateProtectionMethod(bool enable_nack) {
   bool fec_enabled = false;
   uint8_t dummy_ptype_red = 0;
   uint8_t dummy_ptypeFEC = 0;
@@ -738,25 +738,23 @@
   if (error) {
     return -1;
   }
-
-  bool nack_enabled = (default_rtp_rtcp_->NACK() == kNackOff) ? false : true;
-  if (fec_enabled_ == fec_enabled && nack_enabled_ == nack_enabled) {
+  if (fec_enabled_ == fec_enabled && nack_enabled_ == enable_nack) {
     // No change needed, we're already in correct state.
     return 0;
   }
   fec_enabled_ = fec_enabled;
-  nack_enabled_ = nack_enabled;
+  nack_enabled_ = enable_nack;
 
   // Set Video Protection for VCM.
-  if (fec_enabled && nack_enabled) {
+  if (fec_enabled && nack_enabled_) {
     vcm_.SetVideoProtection(webrtc::kProtectionNackFEC, true);
   } else {
     vcm_.SetVideoProtection(webrtc::kProtectionFEC, fec_enabled_);
-    vcm_.SetVideoProtection(webrtc::kProtectionNack, nack_enabled_);
+    vcm_.SetVideoProtection(webrtc::kProtectionNackSender, nack_enabled_);
     vcm_.SetVideoProtection(webrtc::kProtectionNackFEC, false);
   }
 
-  if (fec_enabled || nack_enabled) {
+  if (fec_enabled_ || nack_enabled_) {
     WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo,
                  ViEId(engine_id_, channel_id_), "%s: FEC status ",
                  __FUNCTION__, fec_enabled);
diff --git a/video_engine/vie_encoder.h b/video_engine/vie_encoder.h
index 368f91b..babd74e 100644
--- a/video_engine/vie_encoder.h
+++ b/video_engine/vie_encoder.h
@@ -114,7 +114,8 @@
 
   int CodecTargetBitrate(uint32_t* bitrate) const;
   // Loss protection.
-  int32_t UpdateProtectionMethod();
+  int32_t UpdateProtectionMethod(bool enable_nack);
+  bool nack_enabled() const { return nack_enabled_; }
 
   // Buffering mode.
   void SetSenderBufferingMode(int target_delay_ms);
diff --git a/video_engine/vie_network_impl.cc b/video_engine/vie_network_impl.cc
index e9082da..0afd2fe 100644
--- a/video_engine/vie_network_impl.cc
+++ b/video_engine/vie_network_impl.cc
@@ -196,99 +196,4 @@
   }
   return 0;
 }
-
-int ViENetworkImpl::SetPacketTimeoutNotification(const int video_channel,
-                                                 bool enable,
-                                                 int timeout_seconds) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVideo,
-               ViEId(shared_data_->instance_id(), video_channel),
-               "%s(channel: %d, enable: %d, timeout_seconds: %u)",
-               __FUNCTION__, video_channel, enable, timeout_seconds);
-  ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
-  ViEChannel* vie_channel = cs.Channel(video_channel);
-  if (!vie_channel) {
-    WEBRTC_TRACE(kTraceError, kTraceVideo,
-                 ViEId(shared_data_->instance_id(), video_channel),
-                 "Channel doesn't exist");
-    shared_data_->SetLastError(kViENetworkInvalidChannelId);
-    return -1;
-  }
-  if (vie_channel->SetPacketTimeoutNotification(enable,
-                                                timeout_seconds) != 0) {
-    shared_data_->SetLastError(kViENetworkUnknownError);
-    return -1;
-  }
-  return 0;
-}
-
-int ViENetworkImpl::RegisterObserver(const int video_channel,
-                                     ViENetworkObserver& observer) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVideo,
-               ViEId(shared_data_->instance_id(), video_channel),
-               "%s(channel: %d)", __FUNCTION__, video_channel);
-  ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
-  ViEChannel* vie_channel = cs.Channel(video_channel);
-  if (!vie_channel) {
-    WEBRTC_TRACE(kTraceError, kTraceVideo,
-                 ViEId(shared_data_->instance_id(), video_channel),
-                 "Channel doesn't exist");
-    shared_data_->SetLastError(kViENetworkInvalidChannelId);
-    return -1;
-  }
-  if (vie_channel->RegisterNetworkObserver(&observer) != 0) {
-    shared_data_->SetLastError(kViENetworkObserverAlreadyRegistered);
-    return -1;
-  }
-  return 0;
-}
-
-int ViENetworkImpl::DeregisterObserver(const int video_channel) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVideo,
-               ViEId(shared_data_->instance_id(), video_channel),
-               "%s(channel: %d)", __FUNCTION__, video_channel);
-  ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
-  ViEChannel* vie_channel = cs.Channel(video_channel);
-  if (!vie_channel) {
-    WEBRTC_TRACE(kTraceError, kTraceVideo,
-                 ViEId(shared_data_->instance_id(), video_channel),
-                 "Channel doesn't exist");
-    shared_data_->SetLastError(kViENetworkInvalidChannelId);
-    return -1;
-  }
-  if (!vie_channel->NetworkObserverRegistered()) {
-    shared_data_->SetLastError(kViENetworkObserverNotRegistered);
-    return -1;
-  }
-  return vie_channel->RegisterNetworkObserver(NULL);
-}
-
-int ViENetworkImpl::SetPeriodicDeadOrAliveStatus(
-    const int video_channel,
-    bool enable,
-    unsigned int sample_time_seconds) {
-  WEBRTC_TRACE(kTraceApiCall, kTraceVideo,
-               ViEId(shared_data_->instance_id(), video_channel),
-               "%s(channel: %d, enable: %d, sample_time_seconds: %ul)",
-               __FUNCTION__, video_channel, enable, sample_time_seconds);
-  ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
-  ViEChannel* vie_channel = cs.Channel(video_channel);
-  if (!vie_channel) {
-    WEBRTC_TRACE(kTraceError, kTraceVideo,
-                 ViEId(shared_data_->instance_id(), video_channel),
-                 "Channel doesn't exist");
-    shared_data_->SetLastError(kViENetworkInvalidChannelId);
-    return -1;
-  }
-  if (!vie_channel->NetworkObserverRegistered()) {
-    shared_data_->SetLastError(kViENetworkObserverNotRegistered);
-    return -1;
-  }
-  if (vie_channel->SetPeriodicDeadOrAliveStatus(enable, sample_time_seconds)
-      != 0) {
-    shared_data_->SetLastError(kViENetworkUnknownError);
-    return -1;
-  }
-  return 0;
-}
-
 }  // namespace webrtc
diff --git a/video_engine/vie_network_impl.h b/video_engine/vie_network_impl.h
index da79f44..d49c2fe 100644
--- a/video_engine/vie_network_impl.h
+++ b/video_engine/vie_network_impl.h
@@ -37,16 +37,6 @@
                                  const void* data,
                                  const int length);
   virtual int SetMTU(int video_channel, unsigned int mtu);
-  virtual int SetPacketTimeoutNotification(const int video_channel,
-                                           bool enable,
-                                           int timeout_seconds);
-  virtual int RegisterObserver(const int video_channel,
-                               ViENetworkObserver& observer);
-  virtual int DeregisterObserver(const int video_channel);
-  virtual int SetPeriodicDeadOrAliveStatus(
-      const int video_channel,
-      const bool enable,
-      const unsigned int sample_time_seconds);
 
  protected:
   explicit ViENetworkImpl(ViESharedData* shared_data);
diff --git a/video_engine/vie_receiver.cc b/video_engine/vie_receiver.cc
index a39dbee..fc986ea 100644
--- a/video_engine/vie_receiver.cc
+++ b/video_engine/vie_receiver.cc
@@ -13,7 +13,10 @@
 #include <vector>
 
 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
+#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/utility/interface/rtp_dump.h"
 #include "webrtc/modules/video_coding/main/interface/video_coding.h"
@@ -25,10 +28,18 @@
 
 ViEReceiver::ViEReceiver(const int32_t channel_id,
                          VideoCodingModule* module_vcm,
-                         RemoteBitrateEstimator* remote_bitrate_estimator)
+                         RemoteBitrateEstimator* remote_bitrate_estimator,
+                         RtpFeedback* rtp_feedback)
     : receive_cs_(CriticalSectionWrapper::CreateCriticalSection()),
       channel_id_(channel_id),
       rtp_header_parser_(RtpHeaderParser::Create()),
+      rtp_payload_registry_(new RTPPayloadRegistry(
+          channel_id, RTPPayloadStrategy::CreateStrategy(false))),
+      rtp_receiver_(RtpReceiver::CreateVideoReceiver(
+          channel_id, Clock::GetRealTimeClock(), this, rtp_feedback,
+          rtp_payload_registry_.get())),
+      rtp_receive_statistics_(ReceiveStatistics::Create(
+          Clock::GetRealTimeClock())),
       rtp_rtcp_(NULL),
       vcm_(module_vcm),
       remote_bitrate_estimator_(remote_bitrate_estimator),
@@ -51,6 +62,59 @@
   }
 }
 
+bool ViEReceiver::SetReceiveCodec(const VideoCodec& video_codec) {
+  int8_t old_pltype = -1;
+  if (rtp_payload_registry_->ReceivePayloadType(video_codec.plName,
+                                                kVideoPayloadTypeFrequency,
+                                                0,
+                                                video_codec.maxBitrate,
+                                                &old_pltype) != -1) {
+    rtp_payload_registry_->DeRegisterReceivePayload(old_pltype);
+  }
+
+  if (rtp_receiver_->RegisterReceivePayload(video_codec.plName,
+                                            video_codec.plType,
+                                            kVideoPayloadTypeFrequency,
+                                            0,
+                                            video_codec.maxBitrate) != 0) {
+    return false;
+  }
+  return true;
+}
+
+bool ViEReceiver::RegisterPayload(const VideoCodec& video_codec) {
+  if (rtp_receiver_->RegisterReceivePayload(video_codec.plName,
+                                            video_codec.plType,
+                                            kVideoPayloadTypeFrequency,
+                                            0,
+                                            video_codec.maxBitrate) != 0) {
+    return false;
+  }
+  return true;
+}
+
+bool ViEReceiver::SetNackStatus(bool enable,
+                                int max_nack_reordering_threshold) {
+  return rtp_receiver_->SetNACKStatus(enable ? kNackRtcp : kNackOff,
+                                      max_nack_reordering_threshold) == 0;
+}
+
+void ViEReceiver::SetRtxStatus(bool enable, uint32_t ssrc) {
+  rtp_receiver_->SetRTXStatus(true, ssrc);
+}
+
+void ViEReceiver::SetRtxPayloadType(uint32_t payload_type) {
+  rtp_receiver_->SetRtxPayloadType(payload_type);
+}
+
+uint32_t ViEReceiver::GetRemoteSsrc() const {
+  return rtp_receiver_->SSRC();
+}
+
+int ViEReceiver::GetCsrcs(uint32_t* csrcs) const {
+  return rtp_receiver_->CSRCs(csrcs);
+}
+
 int ViEReceiver::RegisterExternalDecryption(Encryption* decryption) {
   CriticalSectionScoped cs(receive_cs_.get());
   if (external_decryption_) {
@@ -77,6 +141,10 @@
   rtp_rtcp_ = module;
 }
 
+RtpReceiver* ViEReceiver::GetRtpReceiver() const {
+  return rtp_receiver_.get();
+}
+
 void ViEReceiver::RegisterSimulcastRtpRtcpModules(
     const std::list<RtpRtcp*>& rtp_modules) {
   CriticalSectionScoped cs(receive_cs_.get());
@@ -140,6 +208,25 @@
   return 0;
 }
 
+bool ViEReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
+                                    int rtp_packet_length) {
+  RTPHeader header;
+  if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) {
+    WEBRTC_TRACE(kTraceDebug, webrtc::kTraceVideo, channel_id_,
+                 "IncomingPacket invalid RTP header");
+    return false;
+  }
+  header.payload_type_frequency = kVideoPayloadTypeFrequency;
+  PayloadUnion payload_specific;
+  if (!rtp_payload_registry_->GetPayloadSpecifics(header.payloadType,
+                                                 &payload_specific)) {
+    return false;
+  }
+  return rtp_receiver_->IncomingRtpPacket(&header, rtp_packet,
+                                          rtp_packet_length,
+                                          payload_specific, false);
+}
+
 int ViEReceiver::InsertRTPPacket(const int8_t* rtp_packet,
                                  int rtp_packet_length) {
   // TODO(mflodman) Change decrypt to get rid of this cast.
@@ -185,9 +272,19 @@
   const int payload_size = received_packet_length - header.headerLength;
   remote_bitrate_estimator_->IncomingPacket(TickTime::MillisecondTimestamp(),
                                             payload_size, header);
-  assert(rtp_rtcp_);  // Should be set by owner at construction time.
-  return rtp_rtcp_->IncomingRtpPacket(received_packet, received_packet_length,
-                                      header);
+  header.payload_type_frequency = kVideoPayloadTypeFrequency;
+  bool in_order = rtp_receiver_->InOrderPacket(header.sequenceNumber);
+  bool retransmitted = !in_order && IsPacketRetransmitted(header);
+  rtp_receive_statistics_->IncomingPacket(header, received_packet_length,
+                                          retransmitted, in_order);
+  PayloadUnion payload_specific;
+  if (!rtp_payload_registry_->GetPayloadSpecifics(header.payloadType,
+                                                  &payload_specific)) {
+    return -1;
+  }
+  return rtp_receiver_->IncomingRtpPacket(&header, received_packet,
+                                          received_packet_length,
+                                          payload_specific, in_order) ? 0 : -1;
 }
 
 int ViEReceiver::InsertRTCPPacket(const int8_t* rtcp_packet,
@@ -296,7 +393,7 @@
   // LatestEstimate returns an error if there is no valid bitrate estimate, but
   // ViEReceiver instead returns a zero estimate.
   remote_bitrate_estimator_->LatestEstimate(&ssrcs, available_bandwidth);
-  if (std::find(ssrcs.begin(), ssrcs.end(), rtp_rtcp_->RemoteSSRC()) !=
+  if (std::find(ssrcs.begin(), ssrcs.end(), rtp_receiver_->SSRC()) !=
       ssrcs.end()) {
     *available_bandwidth /= ssrcs.size();
   } else {
@@ -304,4 +401,25 @@
   }
 }
 
+ReceiveStatistics* ViEReceiver::GetReceiveStatistics() const {
+  return rtp_receive_statistics_.get();
+}
+
+bool ViEReceiver::IsPacketRetransmitted(const RTPHeader& header) const {
+  bool rtx_enabled = false;
+  uint32_t rtx_ssrc = 0;
+  int rtx_payload_type = 0;
+  rtp_receiver_->RTXStatus(&rtx_enabled, &rtx_ssrc, &rtx_payload_type);
+  if (!rtx_enabled) {
+    // Check if this is a retransmission.
+    ReceiveStatistics::RtpReceiveStatistics stats;
+    if (rtp_receive_statistics_->Statistics(&stats, false)) {
+      uint16_t min_rtt = 0;
+      rtp_rtcp_->RTT(rtp_receiver_->SSRC(), NULL, NULL, &min_rtt, NULL);
+      return rtp_receiver_->RetransmitOfOldPacket(header, stats.jitter,
+                                                  min_rtt);
+    }
+  }
+  return false;
+}
 }  // namespace webrtc
diff --git a/video_engine/vie_receiver.h b/video_engine/vie_receiver.h
index 904a951..6301437 100644
--- a/video_engine/vie_receiver.h
+++ b/video_engine/vie_receiver.h
@@ -14,6 +14,7 @@
 #include <list>
 
 #include "webrtc/engine_configurations.h"
+#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
 #include "webrtc/typedefs.h"
@@ -23,23 +24,39 @@
 
 class CriticalSectionWrapper;
 class Encryption;
+class ReceiveStatistics;
 class RemoteBitrateEstimator;
 class RtpDump;
 class RtpHeaderParser;
+class RTPPayloadRegistry;
+class RtpReceiver;
 class RtpRtcp;
 class VideoCodingModule;
 
 class ViEReceiver : public RtpData {
  public:
   ViEReceiver(const int32_t channel_id, VideoCodingModule* module_vcm,
-              RemoteBitrateEstimator* remote_bitrate_estimator);
+              RemoteBitrateEstimator* remote_bitrate_estimator,
+              RtpFeedback* rtp_feedback);
   ~ViEReceiver();
 
+  bool SetReceiveCodec(const VideoCodec& video_codec);
+  bool RegisterPayload(const VideoCodec& video_codec);
+
+  bool SetNackStatus(bool enable, int max_nack_reordering_threshold);
+  void SetRtxStatus(bool enable, uint32_t ssrc);
+  void SetRtxPayloadType(uint32_t payload_type);
+
+  uint32_t GetRemoteSsrc() const;
+  int GetCsrcs(uint32_t* csrcs) const;
+
   int RegisterExternalDecryption(Encryption* decryption);
   int DeregisterExternalDecryption();
 
   void SetRtpRtcpModule(RtpRtcp* module);
 
+  RtpReceiver* GetRtpReceiver() const;
+
   void RegisterSimulcastRtpRtcpModules(const std::list<RtpRtcp*>& rtp_modules);
 
   bool SetReceiveTimestampOffsetStatus(bool enable, int id);
@@ -54,6 +71,8 @@
   // Receives packets from external transport.
   int ReceivedRTPPacket(const void* rtp_packet, int rtp_packet_length);
   int ReceivedRTCPPacket(const void* rtcp_packet, int rtcp_packet_length);
+  virtual bool OnRecoveredPacket(const uint8_t* packet,
+                                 int packet_length) OVERRIDE;
 
   // Implements RtpData.
   virtual int32_t OnReceivedPayloadData(
@@ -63,13 +82,19 @@
 
   void EstimatedReceiveBandwidth(unsigned int* available_bandwidth) const;
 
+  ReceiveStatistics* GetReceiveStatistics() const;
+
  private:
   int InsertRTPPacket(const int8_t* rtp_packet, int rtp_packet_length);
   int InsertRTCPPacket(const int8_t* rtcp_packet, int rtcp_packet_length);
+  bool IsPacketRetransmitted(const RTPHeader& header) const;
 
   scoped_ptr<CriticalSectionWrapper> receive_cs_;
   const int32_t channel_id_;
   scoped_ptr<RtpHeaderParser> rtp_header_parser_;
+  scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
+  scoped_ptr<RtpReceiver> rtp_receiver_;
+  scoped_ptr<ReceiveStatistics> rtp_receive_statistics_;
   RtpRtcp* rtp_rtcp_;
   std::list<RtpRtcp*> rtp_rtcp_simulcast_;
   VideoCodingModule* vcm_;
diff --git a/video_engine/vie_rtp_rtcp_impl.cc b/video_engine/vie_rtp_rtcp_impl.cc
index d8ead12..ecfa1b6 100644
--- a/video_engine/vie_rtp_rtcp_impl.cc
+++ b/video_engine/vie_rtp_rtcp_impl.cc
@@ -501,7 +501,7 @@
     shared_data_->SetLastError(kViERtpRtcpUnknownError);
     return -1;
   }
-  vie_encoder->UpdateProtectionMethod();
+  vie_encoder->UpdateProtectionMethod(enable);
   return 0;
 }
 
@@ -542,7 +542,7 @@
     shared_data_->SetLastError(kViERtpRtcpUnknownError);
     return -1;
   }
-  vie_encoder->UpdateProtectionMethod();
+  vie_encoder->UpdateProtectionMethod(false);
   return 0;
 }
 
@@ -587,7 +587,7 @@
     shared_data_->SetLastError(kViERtpRtcpUnknownError);
     return -1;
   }
-  vie_encoder->UpdateProtectionMethod();
+  vie_encoder->UpdateProtectionMethod(enable);
   return 0;
 }
 
diff --git a/video_engine/vie_sync_module.cc b/video_engine/vie_sync_module.cc
index aecfa2a..906f7df 100644
--- a/video_engine/vie_sync_module.cc
+++ b/video_engine/vie_sync_module.cc
@@ -10,6 +10,7 @@
 
 #include "webrtc/video_engine/vie_sync_module.h"
 
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/video_coding/main/interface/video_coding.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
@@ -24,15 +25,15 @@
 enum { kSyncInterval = 1000};
 
 int UpdateMeasurements(StreamSynchronization::Measurements* stream,
-                       const RtpRtcp* rtp_rtcp) {
-  stream->latest_timestamp = rtp_rtcp->RemoteTimestamp();
-  stream->latest_receive_time_ms = rtp_rtcp->LocalTimeOfRemoteTimeStamp();
+                       const RtpRtcp& rtp_rtcp, const RtpReceiver& receiver) {
+  stream->latest_timestamp = receiver.TimeStamp();
+  stream->latest_receive_time_ms = receiver.LastReceivedTimeMs();
   synchronization::RtcpMeasurement measurement;
-  if (0 != rtp_rtcp->RemoteNTP(&measurement.ntp_secs,
-                               &measurement.ntp_frac,
-                               NULL,
-                               NULL,
-                               &measurement.rtp_timestamp)) {
+  if (0 != rtp_rtcp.RemoteNTP(&measurement.ntp_secs,
+                              &measurement.ntp_frac,
+                              NULL,
+                              NULL,
+                              &measurement.rtp_timestamp)) {
     return -1;
   }
   if (measurement.ntp_secs == 0 && measurement.ntp_frac == 0) {
@@ -60,6 +61,7 @@
     : data_cs_(CriticalSectionWrapper::CreateCriticalSection()),
       vcm_(vcm),
       vie_channel_(vie_channel),
+      video_receiver_(NULL),
       video_rtp_rtcp_(NULL),
       voe_channel_id_(-1),
       voe_sync_interface_(NULL),
@@ -72,10 +74,12 @@
 
 int ViESyncModule::ConfigureSync(int voe_channel_id,
                                  VoEVideoSync* voe_sync_interface,
-                                 RtpRtcp* video_rtcp_module) {
+                                 RtpRtcp* video_rtcp_module,
+                                 RtpReceiver* video_receiver) {
   CriticalSectionScoped cs(data_cs_.get());
   voe_channel_id_ = voe_channel_id;
   voe_sync_interface_ = voe_sync_interface;
+  video_receiver_ = video_receiver;
   video_rtp_rtcp_ = video_rtcp_module;
   sync_.reset(new StreamSynchronization(voe_channel_id, vie_channel_->Id()));
 
@@ -129,16 +133,21 @@
       playout_buffer_delay_ms;
 
   RtpRtcp* voice_rtp_rtcp = NULL;
-  if (0 != voe_sync_interface_->GetRtpRtcp(voe_channel_id_, voice_rtp_rtcp)) {
+  RtpReceiver* voice_receiver = NULL;
+  if (0 != voe_sync_interface_->GetRtpRtcp(voe_channel_id_, &voice_rtp_rtcp,
+                                           &voice_receiver)) {
     return 0;
   }
   assert(voice_rtp_rtcp);
+  assert(voice_receiver);
 
-  if (UpdateMeasurements(&video_measurement_, video_rtp_rtcp_) != 0) {
+  if (UpdateMeasurements(&video_measurement_, *video_rtp_rtcp_,
+                         *video_receiver_) != 0) {
     return 0;
   }
 
-  if (UpdateMeasurements(&audio_measurement_, voice_rtp_rtcp) != 0) {
+  if (UpdateMeasurements(&audio_measurement_, *voice_rtp_rtcp,
+                         *voice_receiver) != 0) {
     return 0;
   }
 
diff --git a/video_engine/vie_sync_module.h b/video_engine/vie_sync_module.h
index 51246c1..cc0d92b 100644
--- a/video_engine/vie_sync_module.h
+++ b/video_engine/vie_sync_module.h
@@ -36,7 +36,8 @@
 
   int ConfigureSync(int voe_channel_id,
                     VoEVideoSync* voe_sync_interface,
-                    RtpRtcp* video_rtcp_module);
+                    RtpRtcp* video_rtcp_module,
+                    RtpReceiver* video_receiver);
 
   int VoiceChannel();
 
@@ -51,6 +52,7 @@
   scoped_ptr<CriticalSectionWrapper> data_cs_;
   VideoCodingModule* vcm_;
   ViEChannel* vie_channel_;
+  RtpReceiver* video_receiver_;
   RtpRtcp* video_rtp_rtcp_;
   int voe_channel_id_;
   VoEVideoSync* voe_sync_interface_;
diff --git a/voice_engine/channel.cc b/voice_engine/channel.cc
index dbcccf1..b6b8c29 100644
--- a/voice_engine/channel.cc
+++ b/voice_engine/channel.cc
@@ -12,6 +12,10 @@
 
 #include "webrtc/modules/audio_device/include/audio_device.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
+#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h"
 #include "webrtc/modules/utility/interface/audio_frame_operations.h"
 #include "webrtc/modules/utility/interface/process_thread.h"
 #include "webrtc/modules/utility/interface/rtp_dump.h"
@@ -367,8 +371,8 @@
     assert(channel == _channelId);
 
     // Reset RTP-module counters since a new incoming RTP stream is detected
-    _rtpRtcpModule->ResetReceiveDataCountersRTP();
-    _rtpRtcpModule->ResetStatisticsRTP();
+    rtp_receive_statistics_->ResetDataCounters();
+    rtp_receive_statistics_->ResetStatistics();
 
     if (_rtpObserver)
     {
@@ -404,6 +408,10 @@
     }
 }
 
+void Channel::OnResetStatistics() {
+  rtp_receive_statistics_->ResetStatistics();
+}
+
 void
 Channel::OnApplicationDataReceived(int32_t id,
                                    uint8_t subType,
@@ -629,18 +637,16 @@
     UpdatePacketDelay(rtpHeader->header.timestamp,
                       rtpHeader->header.sequenceNumber);
 
-    if (kNackOff != _rtpRtcpModule->NACK()) {  // Is NACK on?
-        uint16_t round_trip_time = 0;
-        _rtpRtcpModule->RTT(_rtpRtcpModule->RemoteSSRC(), &round_trip_time,
-                            NULL, NULL, NULL);
+    uint16_t round_trip_time = 0;
+    _rtpRtcpModule->RTT(rtp_receiver_->SSRC(), &round_trip_time,
+                        NULL, NULL, NULL);
 
-        std::vector<uint16_t> nack_list = _audioCodingModule.GetNackList(
-            round_trip_time);
-        if (!nack_list.empty()) {
-          // Can't use nack_list.data() since it's not supported by all
-          // compilers.
-          ResendPackets(&(nack_list[0]), static_cast<int>(nack_list.size()));
-        }
+    std::vector<uint16_t> nack_list = _audioCodingModule.GetNackList(
+        round_trip_time);
+    if (!nack_list.empty()) {
+      // Can't use nack_list.data() since it's not supported by all
+      // compilers.
+      ResendPackets(&(nack_list[0]), static_cast<int>(nack_list.size()));
     }
     return 0;
 }
@@ -883,6 +889,15 @@
     _instanceId(instanceId),
     _channelId(channelId),
     rtp_header_parser_(RtpHeaderParser::Create()),
+    rtp_payload_registry_(
+        new RTPPayloadRegistry(channelId,
+                               RTPPayloadStrategy::CreateStrategy(true))),
+    rtp_receive_statistics_(ReceiveStatistics::Create(
+        Clock::GetRealTimeClock())),
+    rtp_receiver_(RtpReceiver::CreateAudioReceiver(
+        VoEModuleId(instanceId, channelId), Clock::GetRealTimeClock(), this,
+        this, this, rtp_payload_registry_.get())),
+    telephone_event_handler_(rtp_receiver_->GetTelephoneEventHandler()),
     _audioCodingModule(*AudioCodingModule::Create(
         VoEModuleId(instanceId, channelId))),
     _rtpDumpIn(*RtpDump::CreateRtpDump()),
@@ -982,11 +997,10 @@
     RtpRtcp::Configuration configuration;
     configuration.id = VoEModuleId(instanceId, channelId);
     configuration.audio = true;
-    configuration.incoming_data = this;
-    configuration.incoming_messages = this;
     configuration.outgoing_transport = this;
     configuration.rtcp_feedback = this;
     configuration.audio_messages = this;
+    configuration.receive_statistics = rtp_receive_statistics_.get();
 
     _rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration));
 
@@ -1134,12 +1148,9 @@
     // disabled by the user.
     // After StopListen (when no sockets exists), RTCP packets will no longer
     // be transmitted since the Transport object will then be invalid.
-
-    const bool rtpRtcpFail =
-        ((_rtpRtcpModule->SetTelephoneEventForwardToDecoder(true) == -1) ||
-        // RTCP is enabled by default
-        (_rtpRtcpModule->SetRTCPStatus(kRtcpCompound) == -1));
-    if (rtpRtcpFail)
+    telephone_event_handler_->SetTelephoneEventForwardToDecoder(true);
+    // RTCP is enabled by default.
+    if (_rtpRtcpModule->SetRTCPStatus(kRtcpCompound) == -1)
     {
         _engineStatisticsPtr->SetLastError(
             VE_RTP_RTCP_MODULE_ERROR, kTraceError,
@@ -1170,7 +1181,12 @@
     {
         // Open up the RTP/RTCP receiver for all supported codecs
         if ((_audioCodingModule.Codec(idx, &codec) == -1) ||
-            (_rtpRtcpModule->RegisterReceivePayload(codec) == -1))
+            (rtp_receiver_->RegisterReceivePayload(
+                codec.plname,
+                codec.pltype,
+                codec.plfreq,
+                codec.channels,
+                (codec.rate < 0) ? 0 : codec.rate) == -1))
         {
             WEBRTC_TRACE(kTraceWarning, kTraceVoice,
                          VoEId(_instanceId,_channelId),
@@ -1480,12 +1496,7 @@
     }
 
     // Recover DTMF detection status.
-    int32_t ret = _rtpRtcpModule->SetTelephoneEventForwardToDecoder(true);
-    if (ret != 0) {
-        _engineStatisticsPtr->SetLastError(
-            VE_INVALID_OPERATION, kTraceWarning,
-            "StopReceiving() failed to restore telephone-event status.");
-    }
+    telephone_event_handler_->SetTelephoneEventForwardToDecoder(true);
     RegisterReceiveCodecsToRTPModule();
     _receiving = false;
     return 0;
@@ -1737,10 +1748,15 @@
         CodecInst rxCodec = codec;
 
         // Get payload type for the given codec
-        _rtpRtcpModule->ReceivePayloadType(rxCodec, &pltype);
+        rtp_payload_registry_->ReceivePayloadType(
+            rxCodec.plname,
+            rxCodec.plfreq,
+            rxCodec.channels,
+            (rxCodec.rate < 0) ? 0 : rxCodec.rate,
+            &pltype);
         rxCodec.pltype = pltype;
 
-        if (_rtpRtcpModule->DeRegisterReceivePayload(pltype) != 0)
+        if (rtp_receiver_->DeRegisterReceivePayload(pltype) != 0)
         {
             _engineStatisticsPtr->SetLastError(
                     VE_RTP_RTCP_MODULE_ERROR,
@@ -1759,11 +1775,21 @@
         return 0;
     }
 
-    if (_rtpRtcpModule->RegisterReceivePayload(codec) != 0)
+    if (rtp_receiver_->RegisterReceivePayload(
+        codec.plname,
+        codec.pltype,
+        codec.plfreq,
+        codec.channels,
+        (codec.rate < 0) ? 0 : codec.rate) != 0)
     {
         // First attempt to register failed => de-register and try again
-        _rtpRtcpModule->DeRegisterReceivePayload(codec.pltype);
-        if (_rtpRtcpModule->RegisterReceivePayload(codec) != 0)
+        rtp_receiver_->DeRegisterReceivePayload(codec.pltype);
+        if (rtp_receiver_->RegisterReceivePayload(
+            codec.plname,
+            codec.pltype,
+            codec.plfreq,
+            codec.channels,
+            (codec.rate < 0) ? 0 : codec.rate) != 0)
         {
             _engineStatisticsPtr->SetLastError(
                 VE_RTP_RTCP_MODULE_ERROR, kTraceError,
@@ -1791,7 +1817,12 @@
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::GetRecPayloadType()");
     int8_t payloadType(-1);
-    if (_rtpRtcpModule->ReceivePayloadType(codec, &payloadType) != 0)
+    if (rtp_payload_registry_->ReceivePayloadType(
+        codec.plname,
+        codec.plfreq,
+        codec.channels,
+        (codec.rate < 0) ? 0 : codec.rate,
+        &payloadType) != 0)
     {
         _engineStatisticsPtr->SetLastError(
             VE_RTP_RTCP_MODULE_ERROR, kTraceWarning,
@@ -2151,12 +2182,22 @@
                  "IncomingPacket invalid RTP header");
     return -1;
   }
+  bool retransmitted = IsPacketRetransmitted(header);
+  bool in_order = rtp_receiver_->InOrderPacket(header.sequenceNumber);
+  rtp_receive_statistics_->IncomingPacket(header, static_cast<uint16_t>(length),
+                                          retransmitted, in_order);
+  PayloadUnion payload_specific;
+  if (!rtp_payload_registry_->GetPayloadSpecifics(header.payloadType,
+                                                 &payload_specific)) {
+    return -1;
+  }
   // Deliver RTP packet to RTP/RTCP module for parsing
   // The packet will be pushed back to the channel thru the
   // OnReceivedPayloadData callback so we don't push it to the ACM here
-  if (_rtpRtcpModule->IncomingRtpPacket(reinterpret_cast<const uint8_t*>(data),
+  if (!rtp_receiver_->IncomingRtpPacket(&header,
+                                        reinterpret_cast<const uint8_t*>(data),
                                         static_cast<uint16_t>(length),
-                                        header) == -1) {
+                                        payload_specific, in_order)) {
     _engineStatisticsPtr->SetLastError(
         VE_SOCKET_TRANSPORT_MODULE_ERROR, kTraceWarning,
         "Channel::IncomingRTPPacket() RTP packet is invalid");
@@ -2164,6 +2205,24 @@
   return 0;
 }
 
+bool Channel::IsPacketRetransmitted(const RTPHeader& header) const {
+  bool rtx_enabled = false;
+  uint32_t rtx_ssrc = 0;
+  int rtx_payload_type = 0;
+  rtp_receiver_->RTXStatus(&rtx_enabled, &rtx_ssrc, &rtx_payload_type);
+  if (!rtx_enabled) {
+    // Check if this is a retransmission.
+    ReceiveStatistics::RtpReceiveStatistics stats;
+    if (rtp_receive_statistics_->Statistics(&stats, false)) {
+      uint16_t min_rtt = 0;
+      _rtpRtcpModule->RTT(rtp_receiver_->SSRC(), NULL, NULL, &min_rtt, NULL);
+      return rtp_receiver_->RetransmitOfOldPacket(header, stats.jitter,
+                                                  min_rtt);
+    }
+  }
+  return false;
+}
+
 int32_t Channel::ReceivedRTCPPacket(const int8_t* data, int32_t length) {
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
                "Channel::ReceivedRTCPPacket()");
@@ -2188,141 +2247,6 @@
   return 0;
 }
 
-int32_t
-Channel::SetPacketTimeoutNotification(bool enable, int timeoutSeconds)
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::SetPacketTimeoutNotification()");
-    if (enable)
-    {
-        const uint32_t RTPtimeoutMS = 1000*timeoutSeconds;
-        const uint32_t RTCPtimeoutMS = 0;
-        _rtpRtcpModule->SetPacketTimeout(RTPtimeoutMS, RTCPtimeoutMS);
-        _rtpPacketTimeOutIsEnabled = true;
-        _rtpTimeOutSeconds = timeoutSeconds;
-    }
-    else
-    {
-        _rtpRtcpModule->SetPacketTimeout(0, 0);
-        _rtpPacketTimeOutIsEnabled = false;
-        _rtpTimeOutSeconds = 0;
-    }
-    return 0;
-}
-
-int32_t
-Channel::GetPacketTimeoutNotification(bool& enabled, int& timeoutSeconds)
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::GetPacketTimeoutNotification()");
-    enabled = _rtpPacketTimeOutIsEnabled;
-    if (enabled)
-    {
-        timeoutSeconds = _rtpTimeOutSeconds;
-    }
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "GetPacketTimeoutNotification() => enabled=%d,"
-                 " timeoutSeconds=%d",
-                 enabled, timeoutSeconds);
-    return 0;
-}
-
-int32_t
-Channel::RegisterDeadOrAliveObserver(VoEConnectionObserver& observer)
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::RegisterDeadOrAliveObserver()");
-    CriticalSectionScoped cs(&_callbackCritSect);
-
-    if (_connectionObserverPtr)
-    {
-        _engineStatisticsPtr->SetLastError(VE_INVALID_OPERATION, kTraceError,
-            "RegisterDeadOrAliveObserver() observer already enabled");
-        return -1;
-    }
-
-    _connectionObserverPtr = &observer;
-    _connectionObserver = true;
-
-    return 0;
-}
-
-int32_t
-Channel::DeRegisterDeadOrAliveObserver()
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::DeRegisterDeadOrAliveObserver()");
-    CriticalSectionScoped cs(&_callbackCritSect);
-
-    if (!_connectionObserverPtr)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_INVALID_OPERATION, kTraceWarning,
-            "DeRegisterDeadOrAliveObserver() observer already disabled");
-        return 0;
-    }
-
-    _connectionObserver = false;
-    _connectionObserverPtr = NULL;
-
-    return 0;
-}
-
-int32_t
-Channel::SetPeriodicDeadOrAliveStatus(bool enable, int sampleTimeSeconds)
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::SetPeriodicDeadOrAliveStatus()");
-    if (!_connectionObserverPtr)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId,_channelId),
-                     "SetPeriodicDeadOrAliveStatus() connection observer has"
-                     " not been registered");
-    }
-    if (enable)
-    {
-        ResetDeadOrAliveCounters();
-    }
-    bool enabled(false);
-    uint8_t currentSampleTimeSec(0);
-    // Store last state (will be used later if dead-or-alive is disabled).
-    _rtpRtcpModule->PeriodicDeadOrAliveStatus(enabled, currentSampleTimeSec);
-    // Update the dead-or-alive state.
-    if (_rtpRtcpModule->SetPeriodicDeadOrAliveStatus(
-        enable, (uint8_t)sampleTimeSeconds) != 0)
-    {
-        _engineStatisticsPtr->SetLastError(
-                VE_RTP_RTCP_MODULE_ERROR,
-                kTraceError,
-                "SetPeriodicDeadOrAliveStatus() failed to set dead-or-alive "
-                "status");
-        return -1;
-    }
-    if (!enable)
-    {
-        // Restore last utilized sample time.
-        // Without this, the sample time would always be reset to default
-        // (2 sec), each time dead-or-alived was disabled without sample-time
-        // parameter.
-        _rtpRtcpModule->SetPeriodicDeadOrAliveStatus(enable,
-                                                    currentSampleTimeSec);
-    }
-    return 0;
-}
-
-int32_t
-Channel::GetPeriodicDeadOrAliveStatus(bool& enabled, int& sampleTimeSeconds)
-{
-    _rtpRtcpModule->PeriodicDeadOrAliveStatus(
-        enabled,
-        (uint8_t&)sampleTimeSeconds);
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "GetPeriodicDeadOrAliveStatus() => enabled=%d,"
-                 " sampleTimeSeconds=%d",
-                 enabled, sampleTimeSeconds);
-    return 0;
-}
-
 int Channel::StartPlayingFileLocally(const char* fileName,
                                      bool loop,
                                      FileFormats format,
@@ -3131,8 +3055,8 @@
 }
 
 int Channel::SendTelephoneEventOutband(unsigned char eventCode,
-                                          int lengthMs, int attenuationDb,
-                                          bool playDtmfEvent)
+                                       int lengthMs, int attenuationDb,
+                                       bool playDtmfEvent)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SendTelephoneEventOutband(..., playDtmfEvent=%d)",
@@ -3661,7 +3585,7 @@
 int
 Channel::GetRemoteSSRC(unsigned int& ssrc)
 {
-    ssrc = _rtpRtcpModule->RemoteSSRC();
+    ssrc = rtp_receiver_->SSRC();
     WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
                  VoEId(_instanceId,_channelId),
                  "GetRemoteSSRC() => ssrc=%lu", ssrc);
@@ -3809,7 +3733,7 @@
         return -1;
     }
     char cname[RTCP_CNAME_SIZE];
-    const uint32_t remoteSSRC = _rtpRtcpModule->RemoteSSRC();
+    const uint32_t remoteSSRC = rtp_receiver_->SSRC();
     if (_rtpRtcpModule->RemoteCNAME(remoteSSRC, cname) != 0)
     {
         _engineStatisticsPtr->SetLastError(
@@ -3884,7 +3808,7 @@
           return -1;
         }
 
-        uint32_t remoteSSRC = _rtpRtcpModule->RemoteSSRC();
+        uint32_t remoteSSRC = rtp_receiver_->SSRC();
         std::vector<RTCPReportBlock>::const_iterator it = remote_stats.begin();
         for (; it != remote_stats.end(); ++it) {
           if (it->remoteSSRC == remoteSSRC)
@@ -3976,24 +3900,15 @@
         unsigned int& maxJitterMs,
         unsigned int& discardedPackets)
 {
-    uint8_t fraction_lost(0);
-    uint32_t cum_lost(0);
-    uint32_t ext_max(0);
-    uint32_t jitter(0);
-    uint32_t max_jitter(0);
-
     // The jitter statistics is updated for each received RTP packet and is
     // based on received packets.
-    if (_rtpRtcpModule->StatisticsRTP(&fraction_lost,
-                                     &cum_lost,
-                                     &ext_max,
-                                     &jitter,
-                                     &max_jitter) != 0)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_CANNOT_RETRIEVE_RTP_STAT, kTraceWarning,
-            "GetRTPStatistics() failed to read RTP statistics from the "
-            "RTP/RTCP module");
+    ReceiveStatistics::RtpReceiveStatistics statistics;
+    if (!rtp_receive_statistics_->Statistics(
+        &statistics, _rtpRtcpModule->RTCP() == kRtcpOff)) {
+      _engineStatisticsPtr->SetLastError(
+          VE_CANNOT_RETRIEVE_RTP_STAT, kTraceWarning,
+          "GetRTPStatistics() failed to read RTP statistics from the "
+          "RTP/RTCP module");
     }
 
     const int32_t playoutFrequency =
@@ -4001,8 +3916,8 @@
     if (playoutFrequency > 0)
     {
         // Scale RTP statistics given the current playout frequency
-        maxJitterMs = max_jitter / (playoutFrequency / 1000);
-        averageJitterMs = jitter / (playoutFrequency / 1000);
+        maxJitterMs = statistics.max_jitter / (playoutFrequency / 1000);
+        averageJitterMs = statistics.jitter / (playoutFrequency / 1000);
     }
 
     discardedPackets = _numberOfDiscardedPackets;
@@ -4078,32 +3993,23 @@
 int
 Channel::GetRTPStatistics(CallStatistics& stats)
 {
-    uint8_t fraction_lost(0);
-    uint32_t cum_lost(0);
-    uint32_t ext_max(0);
-    uint32_t jitter(0);
-    uint32_t max_jitter(0);
-
     // --- Part one of the final structure (four values)
 
     // The jitter statistics is updated for each received RTP packet and is
     // based on received packets.
-    if (_rtpRtcpModule->StatisticsRTP(&fraction_lost,
-                                     &cum_lost,
-                                     &ext_max,
-                                     &jitter,
-                                     &max_jitter) != 0)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_CANNOT_RETRIEVE_RTP_STAT, kTraceWarning,
-            "GetRTPStatistics() failed to read RTP statistics from the "
-            "RTP/RTCP module");
+    ReceiveStatistics::RtpReceiveStatistics statistics;
+    if (!rtp_receive_statistics_->Statistics(
+        &statistics, _rtpRtcpModule->RTCP() == kRtcpOff)) {
+      _engineStatisticsPtr->SetLastError(
+          VE_CANNOT_RETRIEVE_RTP_STAT, kTraceWarning,
+          "GetRTPStatistics() failed to read RTP statistics from the "
+          "RTP/RTCP module");
     }
 
-    stats.fractionLost = fraction_lost;
-    stats.cumulativeLost = cum_lost;
-    stats.extendedMax = ext_max;
-    stats.jitterSamples = jitter;
+    stats.fractionLost = statistics.fraction_lost;
+    stats.cumulativeLost = statistics.cumulative_lost;
+    stats.extendedMax = statistics.extended_max_sequence_number;
+    stats.jitterSamples = statistics.jitter;
 
     WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
                  VoEId(_instanceId, _channelId),
@@ -4125,7 +4031,7 @@
     } else
     {
         // The remote SSRC will be zero if no RTP packet has been received.
-        uint32_t remoteSSRC = _rtpRtcpModule->RemoteSSRC();
+        uint32_t remoteSSRC = rtp_receiver_->SSRC();
         if (remoteSSRC > 0)
         {
             uint16_t avgRTT(0);
@@ -4162,10 +4068,10 @@
     uint32_t bytesReceived(0);
     uint32_t packetsReceived(0);
 
+    rtp_receive_statistics_->GetDataCounters(&bytesReceived, &packetsReceived);
+
     if (_rtpRtcpModule->DataCountersRTP(&bytesSent,
-                                       &packetsSent,
-                                       &bytesReceived,
-                                       &packetsReceived) != 0)
+                                        &packetsSent) != 0)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice,
                      VoEId(_instanceId, _channelId),
@@ -4247,8 +4153,8 @@
 void Channel::SetNACKStatus(bool enable, int maxNumberOfPackets) {
   // None of these functions can fail.
   _rtpRtcpModule->SetStorePacketsStatus(enable, maxNumberOfPackets);
-  _rtpRtcpModule->SetNACKStatus(enable ? kNackRtcp : kNackOff,
-                                maxNumberOfPackets);
+  rtp_receiver_->SetNACKStatus(enable ? kNackRtcp : kNackOff,
+      maxNumberOfPackets);
   if (enable)
     _audioCodingModule.EnableNack(maxNumberOfPackets);
   else
@@ -4631,7 +4537,7 @@
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::ResetRTCPStatistics()");
     uint32_t remoteSSRC(0);
-    remoteSSRC = _rtpRtcpModule->RemoteSSRC();
+    remoteSSRC = rtp_receiver_->SSRC();
     return _rtpRtcpModule->ResetRTT(remoteSSRC);
 }
 
@@ -4660,7 +4566,7 @@
     uint16_t maxRTT;
     uint16_t minRTT;
     // The remote SSRC will be zero if no RTP packet has been received.
-    remoteSSRC = _rtpRtcpModule->RemoteSSRC();
+    remoteSSRC = rtp_receiver_->SSRC();
     if (remoteSSRC == 0)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId,_channelId),
@@ -4870,11 +4776,12 @@
 }
 
 int
-Channel::GetRtpRtcp(RtpRtcp* &rtpRtcpModule) const
+Channel::GetRtpRtcp(RtpRtcp** rtpRtcpModule, RtpReceiver** rtp_receiver) const
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::GetRtpRtcp()");
-    rtpRtcpModule = _rtpRtcpModule.get();
+    *rtpRtcpModule = _rtpRtcpModule.get();
+    *rtp_receiver = rtp_receiver_.get();
     return 0;
 }
 
@@ -5094,15 +5001,6 @@
 int
 Channel::GetDeadOrAliveCounters(int& countDead, int& countAlive) const
 {
-    bool enabled;
-    uint8_t timeSec;
-
-    _rtpRtcpModule->PeriodicDeadOrAliveStatus(enabled, timeSec);
-    if (!enabled)
-        return (-1);
-
-    countDead = static_cast<int> (_countDeadDetections);
-    countAlive = static_cast<int> (_countAliveDetections);
     return 0;
 }
 
@@ -5202,7 +5100,12 @@
     {
         // Open up the RTP/RTCP receiver for all supported codecs
         if ((_audioCodingModule.Codec(idx, &codec) == -1) ||
-            (_rtpRtcpModule->RegisterReceivePayload(codec) == -1))
+            (rtp_receiver_->RegisterReceivePayload(
+                codec.plname,
+                codec.pltype,
+                codec.plfreq,
+                codec.channels,
+                (codec.rate < 0) ? 0 : codec.rate) == -1))
         {
             WEBRTC_TRACE(
                          kTraceWarning,
diff --git a/voice_engine/channel.h b/voice_engine/channel.h
index a1e16fe..756ac88 100644
--- a/voice_engine/channel.h
+++ b/voice_engine/channel.h
@@ -35,16 +35,21 @@
 
 namespace webrtc
 {
-class CriticalSectionWrapper;
-class ProcessThread;
 class AudioDeviceModule;
-class RtpRtcp;
+class CriticalSectionWrapper;
 class FileWrapper;
+class ProcessThread;
+class ReceiveStatistics;
 class RtpDump;
-class VoiceEngineObserver;
+class RTPPayloadRegistry;
+class RtpReceiver;
+class RTPReceiverAudio;
+class RtpRtcp;
+class TelephoneEventHandler;
 class VoEMediaProcess;
-class VoERTPObserver;
 class VoERTCPObserver;
+class VoERTPObserver;
+class VoiceEngineObserver;
 
 struct CallStatistics;
 struct ReportBlock;
@@ -133,12 +138,6 @@
     int32_t DeRegisterExternalTransport();
     int32_t ReceivedRTPPacket(const int8_t* data, int32_t length);
     int32_t ReceivedRTCPPacket(const int8_t* data, int32_t length);
-    int32_t SetPacketTimeoutNotification(bool enable, int timeoutSeconds);
-    int32_t GetPacketTimeoutNotification(bool& enabled, int& timeoutSeconds);
-    int32_t RegisterDeadOrAliveObserver(VoEConnectionObserver& observer);
-    int32_t DeRegisterDeadOrAliveObserver();
-    int32_t SetPeriodicDeadOrAliveStatus(bool enable, int sampleTimeSeconds);
-    int32_t GetPeriodicDeadOrAliveStatus(bool& enabled, int& sampleTimeSeconds);
 
     // VoEFile
     int StartPlayingFileLocally(const char* fileName, bool loop,
@@ -215,7 +214,7 @@
     int SetInitSequenceNumber(short sequenceNumber);
 
     // VoEVideoSyncExtended
-    int GetRtpRtcp(RtpRtcp* &rtpRtcpModule) const;
+    int GetRtpRtcp(RtpRtcp** rtpRtcpModule, RtpReceiver** rtp_receiver) const;
 
     // VoEEncryption
     int RegisterExternalEncryption(Encryption& encryption);
@@ -307,6 +306,11 @@
                                   uint16_t payloadSize,
                                   const WebRtcRTPHeader* rtpHeader);
 
+    bool OnRecoveredPacket(const uint8_t* packet, int packet_length) {
+      // Generic FEC not supported for audio.
+      return true;
+    }
+
 public:
     // From RtpFeedback in the RTP/RTCP module
     int32_t OnInitializeDecoder(
@@ -330,6 +334,8 @@
     void OnIncomingCSRCChanged(int32_t id,
                                uint32_t CSRC, bool added);
 
+    void OnResetStatistics();
+
 public:
     // From RtcpFeedback in the RTP/RTCP module
     void OnApplicationDataReceived(int32_t id,
@@ -426,6 +432,7 @@
     uint32_t EncodeAndSend();
 
 private:
+    bool IsPacketRetransmitted(const RTPHeader& header) const;
     int ResendPackets(const uint16_t* sequence_numbers, int length);
     int InsertInbandDtmfTone();
     int32_t MixOrReplaceAudioWithFile(int mixingFrequency);
@@ -446,6 +453,10 @@
 
 private:
     scoped_ptr<RtpHeaderParser> rtp_header_parser_;
+    scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
+    scoped_ptr<ReceiveStatistics> rtp_receive_statistics_;
+    scoped_ptr<RtpReceiver> rtp_receiver_;
+    TelephoneEventHandler* telephone_event_handler_;
     scoped_ptr<RtpRtcp> _rtpRtcpModule;
     AudioCodingModule& _audioCodingModule;
     RtpDump& _rtpDumpIn;
diff --git a/voice_engine/include/voe_network.h b/voice_engine/include/voe_network.h
index 7bcf903..8259e32 100644
--- a/voice_engine/include/voe_network.h
+++ b/voice_engine/include/voe_network.h
@@ -89,31 +89,6 @@
     virtual int ReceivedRTCPPacket(
         int channel, const void* data, unsigned int length) = 0;
 
-    // Enables or disables warnings that report if packets have not been
-    // received in |timeoutSeconds| seconds for a specific |channel|.
-    virtual int SetPacketTimeoutNotification(
-        int channel, bool enable, int timeoutSeconds = 2) = 0;
-
-    // Gets the current time-out notification status.
-    virtual int GetPacketTimeoutNotification(
-        int channel, bool& enabled, int& timeoutSeconds) = 0;
-
-    // Installs the observer class implementation for a specified |channel|.
-    virtual int RegisterDeadOrAliveObserver(
-        int channel, VoEConnectionObserver& observer) = 0;
-
-    // Removes the observer class implementation for a specified |channel|.
-    virtual int DeRegisterDeadOrAliveObserver(int channel) = 0;
-
-    // Enables or disables the periodic dead-or-alive callback functionality
-    // for a specified |channel|.
-    virtual int SetPeriodicDeadOrAliveStatus(
-        int channel, bool enable, int sampleTimeSeconds = 2) = 0;
-
-    // Gets the current dead-or-alive notification status.
-    virtual int GetPeriodicDeadOrAliveStatus(
-        int channel, bool& enabled, int& sampleTimeSeconds) = 0;
-
 protected:
     VoENetwork() {}
     virtual ~VoENetwork() {}
diff --git a/voice_engine/include/voe_video_sync.h b/voice_engine/include/voe_video_sync.h
index ef811a9..cf16d3b 100644
--- a/voice_engine/include/voe_video_sync.h
+++ b/voice_engine/include/voe_video_sync.h
@@ -37,6 +37,7 @@
 
 namespace webrtc {
 
+class RtpReceiver;
 class RtpRtcp;
 class VoiceEngine;
 
@@ -92,7 +93,8 @@
     // Get the received RTP timestamp
     virtual int GetPlayoutTimestamp(int channel, unsigned int& timestamp) = 0;
 
-    virtual int GetRtpRtcp (int channel, RtpRtcp* &rtpRtcpModule) = 0;
+    virtual int GetRtpRtcp (int channel, RtpRtcp** rtpRtcpModule,
+                            RtpReceiver** rtp_receiver) = 0;
 
 protected:
     VoEVideoSync() { }
diff --git a/voice_engine/test/auto_test/standard/call_report_test.cc b/voice_engine/test/auto_test/standard/call_report_test.cc
index 26df80b..ee98dc1 100644
--- a/voice_engine/test/auto_test/standard/call_report_test.cc
+++ b/voice_engine/test/auto_test/standard/call_report_test.cc
@@ -54,29 +54,6 @@
   EXPECT_NE(-1, delays.max);
 }
 
-TEST_F(CallReportTest, DeadOrAliveSummaryFailsIfDeadOrAliveTrackingNotActive) {
-  int count_the_dead;
-  int count_the_living;
-  EXPECT_EQ(-1, voe_call_report_->GetDeadOrAliveSummary(channel_,
-                                                        count_the_dead,
-                                                        count_the_living));
-}
-
-TEST_F(CallReportTest,
-       DeadOrAliveSummarySucceedsIfDeadOrAliveTrackingIsActive) {
-  EXPECT_EQ(0, voe_network_->SetPeriodicDeadOrAliveStatus(channel_, true, 1));
-  Sleep(1200);
-
-  int count_the_dead;
-  int count_the_living;
-  EXPECT_EQ(0, voe_call_report_->GetDeadOrAliveSummary(channel_,
-                                                       count_the_dead,
-                                                       count_the_living));
-
-  EXPECT_GE(count_the_dead, 0);
-  EXPECT_GE(count_the_living, 0);
-}
-
 TEST_F(CallReportTest, WriteReportToFileFailsOnBadInput) {
   EXPECT_EQ(-1, voe_call_report_->WriteReportToFile(NULL));
 }
diff --git a/voice_engine/test/auto_test/standard/network_test.cc b/voice_engine/test/auto_test/standard/network_test.cc
index 1c83799..79daf59 100644
--- a/voice_engine/test/auto_test/standard/network_test.cc
+++ b/voice_engine/test/auto_test/standard/network_test.cc
@@ -23,100 +23,6 @@
 
 using ::testing::Between;
 
-TEST_F(NetworkTest,
-    CallsObserverOnTimeoutAndRestartWhenPacketTimeoutNotificationIsEnabled) {
-  // First, get rid of the default, asserting observer and install our observer.
-  EXPECT_EQ(0, voe_base_->DeRegisterVoiceEngineObserver());
-  webrtc::MockVoEObserver mock_observer;
-  EXPECT_EQ(0, voe_base_->RegisterVoiceEngineObserver(mock_observer));
-
-  // Define expectations.
-  int expected_error = VE_RECEIVE_PACKET_TIMEOUT;
-  EXPECT_CALL(mock_observer, CallbackOnError(channel_, expected_error))
-      .Times(1);
-  expected_error = VE_PACKET_RECEIPT_RESTARTED;
-    EXPECT_CALL(mock_observer, CallbackOnError(channel_, expected_error))
-      .Times(1);
-
-  // Get some speech going.
-  Sleep(500);
-
-  // Enable packet timeout.
-  EXPECT_EQ(0, voe_network_->SetPacketTimeoutNotification(channel_, true, 1));
-
-  // Trigger a timeout.
-  EXPECT_EQ(0, voe_base_->StopSend(channel_));
-  Sleep(1500);
-
-  // Trigger a restart event.
-  EXPECT_EQ(0, voe_base_->StartSend(channel_));
-  Sleep(500);
-}
-
-TEST_F(NetworkTest, DoesNotCallDeRegisteredObserver) {
-  // De-register the default observer. This test will fail if the observer gets
-  // called for any reason, so if this de-register doesn't work the test will
-  // fail.
-  EXPECT_EQ(0, voe_base_->DeRegisterVoiceEngineObserver());
-
-  // Get some speech going.
-  Sleep(500);
-
-  // Enable packet timeout.
-  EXPECT_EQ(0, voe_network_->SetPacketTimeoutNotification(channel_, true, 1));
-
-  // Trigger a timeout.
-  EXPECT_EQ(0, voe_base_->StopSend(channel_));
-  Sleep(1500);
-}
-
-// TODO(phoglund): flaky on Linux
-TEST_F(NetworkTest,
-       DISABLED_ON_LINUX(DeadOrAliveObserverSeesAliveMessagesIfEnabled)) {
-  if (!FLAGS_include_timing_dependent_tests) {
-    TEST_LOG("Skipping test - running in slow execution environment...\n");
-    return;
-  }
-
-  webrtc::MockVoeConnectionObserver mock_observer;
-  EXPECT_EQ(0, voe_network_->RegisterDeadOrAliveObserver(
-      channel_, mock_observer));
-
-  // We should be called about 4 times in four seconds, but 3 is OK too.
-  EXPECT_CALL(mock_observer, OnPeriodicDeadOrAlive(channel_, true))
-      .Times(Between(3, 4));
-
-  EXPECT_EQ(0, voe_network_->SetPeriodicDeadOrAliveStatus(channel_, true, 1));
-  Sleep(4000);
-
-  EXPECT_EQ(0, voe_network_->DeRegisterDeadOrAliveObserver(channel_));
-}
-
-TEST_F(NetworkTest, DeadOrAliveObserverSeesDeadMessagesIfEnabled) {
-  if (!FLAGS_include_timing_dependent_tests) {
-    TEST_LOG("Skipping test - running in slow execution environment...\n");
-    return;
-  }
-
-  // "When do you see them?" - "All the time!"
-  webrtc::MockVoeConnectionObserver mock_observer;
-  EXPECT_EQ(0, voe_network_->RegisterDeadOrAliveObserver(
-      channel_, mock_observer));
-
-  Sleep(500);
-
-  // We should be called about 4 times in four seconds, but 3 is OK too.
-  EXPECT_CALL(mock_observer, OnPeriodicDeadOrAlive(channel_, false))
-      .Times(Between(3, 4));
-
-  EXPECT_EQ(0, voe_network_->SetPeriodicDeadOrAliveStatus(channel_, true, 1));
-  EXPECT_EQ(0, voe_rtp_rtcp_->SetRTCPStatus(channel_, false));
-  EXPECT_EQ(0, voe_base_->StopSend(channel_));
-  Sleep(4000);
-
-  EXPECT_EQ(0, voe_network_->DeRegisterDeadOrAliveObserver(channel_));
-}
-
 TEST_F(NetworkTest, CanSwitchToExternalTransport) {
   EXPECT_EQ(0, voe_base_->StopReceive(channel_));
   EXPECT_EQ(0, voe_base_->DeleteChannel(channel_));
diff --git a/voice_engine/test/auto_test/voe_extended_test.cc b/voice_engine/test/auto_test/voe_extended_test.cc
index 9568e89..0504903 100644
--- a/voice_engine/test/auto_test/voe_extended_test.cc
+++ b/voice_engine/test/auto_test/voe_extended_test.cc
@@ -1158,24 +1158,6 @@
    ANL();
    */
 
-  int nDead = 0;
-  int nAlive = 0;
-  TEST(GetDeadOrAliveSummary);
-  ANL();
-  // All results should be -1 since dead-or-alive is not active
-  TEST_MUSTPASS(report->GetDeadOrAliveSummary(0, nDead, nAlive) != -1);
-  MARK();
-  TEST_MUSTPASS(voe_network ->SetPeriodicDeadOrAliveStatus(0, true, 1));
-  SleepMs(2000);
-  // All results should be >= 0 since dead-or-alive is active
-  TEST_MUSTPASS(report->GetDeadOrAliveSummary(0, nDead, nAlive));
-  MARK();
-  TEST_MUSTPASS(nDead == -1);
-  TEST_MUSTPASS(nAlive == -1)
-  TEST_MUSTPASS(voe_network ->SetPeriodicDeadOrAliveStatus(0, false));
-  AOK();
-  ANL();
-
   TEST(WriteReportToFile);
   ANL();
 
@@ -4183,218 +4165,8 @@
 
   // >> end of SetExternalTransport
   // ------------------------------------------------------------------------
-
-  // ------------------------------------------------------------------------
-  // >> RegisterDeadOrAliveObserver
-  // >> DeRegisterDeadOrAliveObserver
-  //
-  // - VE initialized
-  // - no existing channels
-  // - no media
-  TEST(RegisterDeadOrAliveObserver);
-  ANL();
-  TEST(DeRegisterDeadOrAliveObserver);
-  ANL();
-
-  // call without valid channel
-  TEST_MUSTPASS(!voe_network ->RegisterDeadOrAliveObserver(0, *this));
-  MARK();
-  TEST_ERROR(VE_CHANNEL_NOT_VALID);
-
-  TEST_MUSTPASS(voe_base_->CreateChannel());
-
-  TEST_MUSTPASS(voe_network ->RegisterDeadOrAliveObserver(0, *this));
-  MARK();
-  TEST_MUSTPASS(!voe_network ->RegisterDeadOrAliveObserver(0, *this));
-  MARK(); // already registered
-  TEST_ERROR(VE_INVALID_OPERATION);
-  TEST_MUSTPASS(voe_network ->DeRegisterDeadOrAliveObserver(0));
-  MARK();
-  TEST_MUSTPASS(voe_network ->DeRegisterDeadOrAliveObserver(0));
-  MARK(); // OK to do it again
-  TEST_MUSTPASS(voe_network ->RegisterDeadOrAliveObserver(0, *this));
-  MARK();
-  TEST_MUSTPASS(voe_network ->DeRegisterDeadOrAliveObserver(0));
-  MARK();
-
-  TEST_MUSTPASS(voe_base_->DeleteChannel(0));
-
-  // STATE: dead-or-alive observer is disabled
-
-  // >> end of RegisterDeadOrAliveObserver
-  // ------------------------------------------------------------------------
-
-  // ------------------------------------------------------------------------
-  // >> SetPeriodicDeadOrAliveStatus
-  // >> GetPeriodicDeadOrAliveStatus
-  //
-  // - VE initialized
-  // - no existing channels
-  // - no media
-
-  // call without valid channel
-  TEST_MUSTPASS(!voe_network ->SetPeriodicDeadOrAliveStatus(0, false));
-  MARK();
-  TEST_ERROR(VE_CHANNEL_NOT_VALID);
-
-  TEST_MUSTPASS(voe_base_->CreateChannel());
-
-  // Invalid paramters
-  TEST_MUSTPASS(!voe_network ->SetPeriodicDeadOrAliveStatus(0, true, 0));
-  MARK();
-  TEST_ERROR(VE_INVALID_ARGUMENT);
-  TEST_MUSTPASS(!voe_network ->SetPeriodicDeadOrAliveStatus(0, true, 151));
-  MARK();
-  TEST_ERROR(VE_INVALID_ARGUMENT);
-  TEST_MUSTPASS(!voe_network ->SetPeriodicDeadOrAliveStatus(1, true, 10));
-  MARK();
-  TEST_ERROR(VE_CHANNEL_NOT_VALID);
-
-  int sampleTime(0);
-  bool enabled;
-
-  // Valid parameters
-  TEST_MUSTPASS(voe_network ->SetPeriodicDeadOrAliveStatus(0, true, 1));
-  MARK();
-  TEST_MUSTPASS(
-      voe_network ->GetPeriodicDeadOrAliveStatus(0, enabled, sampleTime));
-  TEST_MUSTPASS(enabled != true);
-  TEST_MUSTPASS(sampleTime != 1);
-  TEST_MUSTPASS(voe_network ->SetPeriodicDeadOrAliveStatus(0, true, 150));
-  MARK();
-  TEST_MUSTPASS(
-      voe_network ->GetPeriodicDeadOrAliveStatus(0, enabled, sampleTime));
-  TEST_MUSTPASS(enabled != true);
-  TEST_MUSTPASS(sampleTime != 150);
-  TEST_MUSTPASS(voe_network ->SetPeriodicDeadOrAliveStatus(0, false));
-  MARK();
-  TEST_MUSTPASS(
-      voe_network ->GetPeriodicDeadOrAliveStatus(0, enabled, sampleTime));
-  TEST_MUSTPASS(enabled != false);
-  TEST_MUSTPASS(sampleTime != 150); // ensure last set time isnt modified
-
-  StartMedia(0, 2000, true, true, true);
-
-  // STATE: full duplex media is active
-
-  // test the dead-or-alive mechanism
-  TEST_MUSTPASS(voe_network ->RegisterDeadOrAliveObserver(0, *this));
-  MARK();
-  TEST_LOG("\nVerify that Alive callbacks are received (dT=2sec): ");
-  fflush(NULL);
-  TEST_MUSTPASS(voe_network ->SetPeriodicDeadOrAliveStatus(0, true, 2));
-  SleepMs(6000);
-  TEST_LOG("\nChange dT to 1 second: ");
-  fflush(NULL);
-  TEST_MUSTPASS(voe_network ->SetPeriodicDeadOrAliveStatus(0, true, 1));
-  SleepMs(6000);
-  TEST_LOG("\nDisable dead-or-alive callbacks: ");
-  fflush(NULL);
-  TEST_MUSTPASS(voe_network ->SetPeriodicDeadOrAliveStatus(0, false));
-  SleepMs(6000);
-  TEST_LOG("\nStop sending and enable callbacks again.\n");
-  TEST_LOG("Verify that Dead callbacks are received (dT=2sec): ");
-  fflush(NULL);
-  TEST_MUSTPASS(voe_base_->StopSend(0));
-  TEST_MUSTPASS(voe_network ->SetPeriodicDeadOrAliveStatus(0, true, 2));
-  SleepMs(6000);
-  TEST_MUSTPASS(voe_base_->StartSend(0));
-  TEST_LOG("\nRestart sending.\n");
-  TEST_LOG("Verify that Alive callbacks are received again (dT=2sec): ");
-  fflush(NULL);
-  SleepMs(6000);
-  TEST_LOG("\nDisable dead-or-alive callbacks.");
-  fflush(NULL);
-  TEST_MUSTPASS(voe_network ->SetPeriodicDeadOrAliveStatus(0, false));
-  TEST_MUSTPASS(voe_network ->DeRegisterDeadOrAliveObserver(0));
-  MARK();
-
-  StopMedia(0);
-
-  TEST_MUSTPASS(voe_base_->DeleteChannel(0));
-  ANL();
-  AOK();
-  ANL();
-  ANL();
-
-  // >> end of SetPeriodicDeadOrAliveStatus
-  // ------------------------------------------------------------------------
-
-  // ------------------------------------------------------------------------
-  // >> SetPacketTimeoutNotification
-  // >> GetPacketTimeoutNotification
-  //
-  // - VE initialized
-  // - no existing channels
-  // - no media
-  // - NOTE: dynamic tests are performed in standard test
-
-  int timeOut(0);
-
-  TEST(SetPacketTimeoutNotification);
-  ANL();
-  TEST(GetPacketTimeoutNotification);
-  ANL();
-
-  // call without existing valid channel
-  TEST_MUSTPASS(!voe_network ->SetPacketTimeoutNotification(0, false));
-  MARK();
-  TEST_ERROR(VE_CHANNEL_NOT_VALID);
-
-  TEST_MUSTPASS(voe_base_->CreateChannel());
-
-  // invalid function calls
-  TEST_MUSTPASS(!voe_network ->SetPacketTimeoutNotification(0, true, 0));
-  MARK();
-  TEST_ERROR(VE_INVALID_ARGUMENT);
-  TEST_MUSTPASS(!voe_network ->SetPacketTimeoutNotification(0, true, 151));
-  MARK();
-  TEST_ERROR(VE_INVALID_ARGUMENT);
-
-  // valid function calls (no active media)
-  TEST_MUSTPASS(voe_network ->SetPacketTimeoutNotification(0, true, 2));
-  MARK();
-  TEST_MUSTPASS(voe_network ->GetPacketTimeoutNotification(0, enabled,
-                                                           timeOut));
-  MARK();
-  TEST_MUSTPASS(enabled != true);
-  TEST_MUSTPASS(timeOut != 2);
-  TEST_MUSTPASS(voe_network ->SetPacketTimeoutNotification(0, false));
-  MARK();
-  TEST_MUSTPASS(voe_network ->GetPacketTimeoutNotification(0, enabled,
-                                                           timeOut));
-  MARK();
-  TEST_MUSTPASS(enabled != false);
-  TEST_MUSTPASS(voe_network ->SetPacketTimeoutNotification(0, true, 10));
-  MARK();
-  TEST_MUSTPASS(voe_network ->GetPacketTimeoutNotification(0, enabled,
-                                                           timeOut));
-  MARK();
-  TEST_MUSTPASS(enabled != true);
-  TEST_MUSTPASS(timeOut != 10);
-  TEST_MUSTPASS(voe_network ->SetPacketTimeoutNotification(0, true, 2));
-  MARK();
-  TEST_MUSTPASS(voe_network ->GetPacketTimeoutNotification(0, enabled,
-                                                           timeOut));
-  MARK();
-  TEST_MUSTPASS(enabled != true);
-  TEST_MUSTPASS(timeOut != 2);
-  TEST_MUSTPASS(voe_network ->SetPacketTimeoutNotification(0, false));
-  MARK();
-  TEST_MUSTPASS(voe_network ->GetPacketTimeoutNotification(0, enabled,
-                                                           timeOut));
-  MARK();
-  TEST_MUSTPASS(enabled != false);
-
-  TEST_MUSTPASS(voe_base_->DeleteChannel(0));
-  ANL();
-  AOK();
-  ANL();
-  ANL();
   return 0;
 }
-  // >> end of SetPacketTimeoutNotification
-  // ------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 //  VoEExtendedTest::TestRTP_RTCP
diff --git a/voice_engine/voe_network_impl.cc b/voice_engine/voe_network_impl.cc
index 6252170..ee87562 100644
--- a/voice_engine/voe_network_impl.cc
+++ b/voice_engine/voe_network_impl.cc
@@ -165,158 +165,4 @@
     }
     return channelPtr->ReceivedRTCPPacket((const int8_t*) data, length);
 }
-
-int VoENetworkImpl::SetPacketTimeoutNotification(int channel,
-                                                 bool enable,
-                                                 int timeoutSeconds)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-                 "SetPacketTimeoutNotification(channel=%d, enable=%d, "
-                 "timeoutSeconds=%d)",
-                 channel, (int) enable, timeoutSeconds);
-    if (!_shared->statistics().Initialized())
-    {
-        _shared->SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-    if (enable &&
-        ((timeoutSeconds < kVoiceEngineMinPacketTimeoutSec) ||
-        (timeoutSeconds > kVoiceEngineMaxPacketTimeoutSec)))
-    {
-        _shared->SetLastError(VE_INVALID_ARGUMENT, kTraceError,
-            "SetPacketTimeoutNotification() invalid timeout size");
-        return -1;
-    }
-    voe::ScopedChannel sc(_shared->channel_manager(), channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
-            "SetPacketTimeoutNotification() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->SetPacketTimeoutNotification(enable, timeoutSeconds);
-}
-
-int VoENetworkImpl::GetPacketTimeoutNotification(int channel,
-                                                 bool& enabled,
-                                                 int& timeoutSeconds)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-                 "GetPacketTimeoutNotification(channel=%d, enabled=?,"
-                 " timeoutSeconds=?)", channel);
-    if (!_shared->statistics().Initialized())
-    {
-        _shared->SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-    voe::ScopedChannel sc(_shared->channel_manager(), channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
-            "GetPacketTimeoutNotification() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->GetPacketTimeoutNotification(enabled, timeoutSeconds);
-}
-
-int VoENetworkImpl::RegisterDeadOrAliveObserver(int channel,
-                                                VoEConnectionObserver&
-                                                observer)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-                 "RegisterDeadOrAliveObserver(channel=%d, observer=0x%x)",
-                 channel, &observer);
-    if (!_shared->statistics().Initialized())
-    {
-        _shared->SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-    voe::ScopedChannel sc(_shared->channel_manager(), channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
-            "RegisterDeadOrAliveObserver() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->RegisterDeadOrAliveObserver(observer);
-}
-
-int VoENetworkImpl::DeRegisterDeadOrAliveObserver(int channel)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-                 "DeRegisterDeadOrAliveObserver(channel=%d)", channel);
-    if (!_shared->statistics().Initialized())
-    {
-        _shared->SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-    voe::ScopedChannel sc(_shared->channel_manager(), channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
-            "DeRegisterDeadOrAliveObserver() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->DeRegisterDeadOrAliveObserver();
-}
-
-int VoENetworkImpl::SetPeriodicDeadOrAliveStatus(int channel, bool enable,
-                                                 int sampleTimeSeconds)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-                 "SetPeriodicDeadOrAliveStatus(channel=%d, enable=%d,"
-                 " sampleTimeSeconds=%d)",
-                 channel, enable, sampleTimeSeconds);
-    if (!_shared->statistics().Initialized())
-    {
-        _shared->SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-    if (enable &&
-        ((sampleTimeSeconds < kVoiceEngineMinSampleTimeSec) ||
-        (sampleTimeSeconds > kVoiceEngineMaxSampleTimeSec)))
-    {
-        _shared->SetLastError(VE_INVALID_ARGUMENT, kTraceError,
-            "SetPeriodicDeadOrAliveStatus() invalid sample time");
-        return -1;
-    }
-    voe::ScopedChannel sc(_shared->channel_manager(), channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
-            "SetPeriodicDeadOrAliveStatus() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->SetPeriodicDeadOrAliveStatus(enable, sampleTimeSeconds);
-}
-
-int VoENetworkImpl::GetPeriodicDeadOrAliveStatus(int channel,
-                                                 bool& enabled,
-                                                 int& sampleTimeSeconds)
-{
-    WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
-                 "GetPeriodicDeadOrAliveStatus(channel=%d, enabled=?,"
-                 " sampleTimeSeconds=?)", channel);
-    if (!_shared->statistics().Initialized())
-    {
-        _shared->SetLastError(VE_NOT_INITED, kTraceError);
-        return -1;
-    }
-    voe::ScopedChannel sc(_shared->channel_manager(), channel);
-    voe::Channel* channelPtr = sc.ChannelPtr();
-    if (channelPtr == NULL)
-    {
-        _shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
-            "GetPeriodicDeadOrAliveStatus() failed to locate channel");
-        return -1;
-    }
-    return channelPtr->GetPeriodicDeadOrAliveStatus(enabled,
-                                                    sampleTimeSeconds);
-}
-
 }  // namespace webrtc
diff --git a/voice_engine/voe_network_impl.h b/voice_engine/voe_network_impl.h
index 194899b..6a703cf 100644
--- a/voice_engine/voe_network_impl.h
+++ b/voice_engine/voe_network_impl.h
@@ -34,27 +34,6 @@
                                    const void* data,
                                    unsigned int length);
 
-    virtual int SetPacketTimeoutNotification(int channel,
-                                             bool enable,
-                                             int timeoutSeconds = 2);
-
-    virtual int GetPacketTimeoutNotification(int channel,
-                                             bool& enabled,
-                                             int& timeoutSeconds);
-
-    virtual int RegisterDeadOrAliveObserver(int channel,
-                                            VoEConnectionObserver& observer);
-
-    virtual int DeRegisterDeadOrAliveObserver(int channel);
-
-    virtual int SetPeriodicDeadOrAliveStatus(int channel,
-                                             bool enable,
-                                             int sampleTimeSeconds = 2);
-
-    virtual int GetPeriodicDeadOrAliveStatus(int channel,
-                                             bool& enabled,
-                                             int& sampleTimeSeconds);
-
 protected:
     VoENetworkImpl(voe::SharedData* shared);
     virtual ~VoENetworkImpl();
diff --git a/voice_engine/voe_video_sync_impl.cc b/voice_engine/voe_video_sync_impl.cc
index 91c0750..a0654f7 100644
--- a/voice_engine/voe_video_sync_impl.cc
+++ b/voice_engine/voe_video_sync_impl.cc
@@ -216,7 +216,8 @@
     return 0;
 }
 
-int VoEVideoSyncImpl::GetRtpRtcp(int channel, RtpRtcp* &rtpRtcpModule)
+int VoEVideoSyncImpl::GetRtpRtcp(int channel, RtpRtcp** rtpRtcpModule,
+                                 RtpReceiver** rtp_receiver)
 {
     WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
                  "GetRtpRtcp(channel=%i)", channel);
@@ -234,7 +235,7 @@
             "GetPlayoutTimestamp() failed to locate channel");
         return -1;
     }
-    return channelPtr->GetRtpRtcp(rtpRtcpModule);
+    return channelPtr->GetRtpRtcp(rtpRtcpModule, rtp_receiver);
 }
 
 int VoEVideoSyncImpl::GetLeastRequiredDelayMs(int channel) const {
diff --git a/voice_engine/voe_video_sync_impl.h b/voice_engine/voe_video_sync_impl.h
index e0ec3f2..8c516fb 100644
--- a/voice_engine/voe_video_sync_impl.h
+++ b/voice_engine/voe_video_sync_impl.h
@@ -38,7 +38,8 @@
 
     virtual int GetPlayoutTimestamp(int channel, unsigned int& timestamp);
 
-    virtual int GetRtpRtcp(int channel, RtpRtcp* &rtpRtcpModule);
+    virtual int GetRtpRtcp(int channel, RtpRtcp** rtpRtcpModule,
+                           RtpReceiver** rtp_receiver);
 
 protected:
     VoEVideoSyncImpl(voe::SharedData* shared);