diff --git a/BUILD.gn b/BUILD.gn
index 429aebb07b..3cdad3fb9f 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -70,6 +70,7 @@ rtc_shared_library("libwebrtc") {
     "include/rtc_mediaconstraints.h",
     "include/rtc_peerconnection.h",
     "include/rtc_peerconnection_factory.h",
+    "include/rtc_rtp_capabilities.h",
     "include/rtc_rtp_parameters.h",
     "include/rtc_rtp_receiver.h",
     "include/rtc_rtp_sender.h",
@@ -109,6 +110,8 @@ rtc_shared_library("libwebrtc") {
     "src/rtc_peerconnection_factory_impl.h",
     "src/rtc_peerconnection_impl.cc",
     "src/rtc_peerconnection_impl.h",
+    "src/rtc_rtp_capabilities_impl.cc",
+    "src/rtc_rtp_capabilities_impl.h",
     "src/rtc_rtp_parameters_impl.cc",
     "src/rtc_rtp_parameters_impl.h",
     "src/rtc_rtp_receiver_impl.cc",
diff --git a/include/rtc_peerconnection_factory.h b/include/rtc_peerconnection_factory.h
index 51f56204cf..33ee6bb873 100644
--- a/include/rtc_peerconnection_factory.h
+++ b/include/rtc_peerconnection_factory.h
@@ -18,6 +18,7 @@ namespace libwebrtc {
 class RTCPeerConnection;
 class RTCAudioDevice;
 class RTCVideoDevice;
+class RTCRtpCapabilities;
 
 class RTCPeerConnectionFactory : public RefCountInterface {
  public:
@@ -60,6 +61,12 @@ class RTCPeerConnectionFactory : public RefCountInterface {
 
   virtual scoped_refptr<RTCMediaStream> CreateStream(
       const string stream_id) = 0;
+
+  virtual scoped_refptr<RTCRtpCapabilities> GetRtpSenderCapabilities(
+      RTCMediaType media_type) = 0;
+
+  virtual scoped_refptr<RTCRtpCapabilities> GetRtpReceiverCapabilities(
+      RTCMediaType media_type) = 0;
 };
 
 }  // namespace libwebrtc
diff --git a/include/rtc_rtp_capabilities.h b/include/rtc_rtp_capabilities.h
new file mode 100644
index 0000000000..e8d5302c53
--- /dev/null
+++ b/include/rtc_rtp_capabilities.h
@@ -0,0 +1,62 @@
+#ifndef LIB_WBBRTC_RTC_RTP_CAPABILITIES_HXX
+#define LIB_WBBRTC_RTC_RTP_CAPABILITIES_HXX
+
+#include "base/refcount.h"
+#include "base/scoped_ref_ptr.h"
+
+#include "rtc_rtp_parameters.h"
+#include "rtc_types.h"
+
+
+namespace libwebrtc {
+
+class RTCRtpCodecCapability : public RefCountInterface {
+ public:
+  LIB_WEBRTC_API static scoped_refptr<RTCRtpCodecCapability> Create();
+
+  virtual void set_mime_type(const string& mime_type) = 0;
+  virtual void set_clock_rate(int clock_rate) = 0;
+  virtual void set_channels(int channels) = 0;
+  virtual void set_sdp_fmtp_line(const string& sdp_fmtp_line) = 0;
+
+  virtual string mime_type() const = 0;
+  virtual int clock_rate() const = 0;
+  virtual int channels() const = 0;
+  virtual string sdp_fmtp_line() const = 0;
+
+ protected:
+  virtual ~RTCRtpCodecCapability() {}
+};
+
+class RTCRtpHeaderExtensionCapability : public RefCountInterface {
+public:
+  virtual const string uri() = 0;
+  virtual void set_uri(const string uri) = 0;
+
+  virtual int preferred_id() = 0;
+  virtual void set_preferred_id(int value) = 0;
+
+  virtual bool preferred_encrypt() = 0;
+  virtual void set_preferred_encrypt(bool value) = 0;
+};
+
+class RTCRtpCapabilities : public RefCountInterface {
+public:
+  virtual const vector<scoped_refptr<RTCRtpCodecCapability>> codecs() = 0;
+  virtual void set_codecs(
+      const vector<scoped_refptr<RTCRtpCodecCapability>> codecs) = 0;
+
+  virtual const vector<scoped_refptr<RTCRtpHeaderExtensionCapability>>
+  header_extensions() = 0;
+
+  virtual void set_header_extensions(
+      const vector<scoped_refptr<RTCRtpHeaderExtensionCapability>>
+          header_extensions) = 0;
+
+  //virtual const vector<scoped_refptr<RTCFecMechanism>> fec() = 0;
+  //virtual void set_fec(const vector<scoped_refptr<RTCFecMechanism>> fec) = 0;
+};
+
+}  // namespace libwebrtc
+
+#endif  // LIB_WBBRTC_RTC_RTP_CAPABILITIES_HXX
diff --git a/include/rtc_rtp_parameters.h b/include/rtc_rtp_parameters.h
index 3e929c01d1..d90a733a65 100644
--- a/include/rtc_rtp_parameters.h
+++ b/include/rtc_rtp_parameters.h
@@ -59,73 +59,6 @@ class RTCRtcpFeedback : public RefCountInterface {
   virtual bool operator!=(scoped_refptr<RTCRtcpFeedback> o) = 0;
 };
 
-/* class RTCRtpCodecCapability : public RefCountInterface {
-  virtual const string mine_type() const = 0;
-
-  virtual const string name() = 0;
-
-  virtual void set_name(const string name) = 0;
-
-  virtual RTCMediaType kind() = 0;
-  virtual void set_kind(RTCMediaType value) = 0;
-
-  virtual int clock_rate() = 0;
-  virtual void set_clock_rate(int value) = 0;
-
-  virtual int preferred_payload_type() = 0;
-  virtual void set_preferred_payload_type(int value) = 0;
-
-  virtual int max_ptime() = 0;
-  virtual void set_max_ptime(int value) = 0;
-
-  virtual int ptime() = 0;
-  virtual void set_ptime(int value) = 0;
-
-  virtual int num_channels() = 0;
-  virtual void set_num_channels(int value) = 0;
-
-  virtual vector<scoped_refptr<RTCRtcpFeedback>> rtcp_feedback() = 0;
-  virtual void set_rtcp_feedback(vector<scoped_refptr<RTCRtcpFeedback>>
-rtcp_feecbacks) = 0;
-
-  virtual const map<string,string> parameters() = 0;
-  virtual void set_parameters(const map<string, string> parameters) = 0;
-
-  virtual const map<string, string> ptions() = 0;
-  virtual void set_options(map<string, string> options) = 0;
-
-  virtual int max_temporal_layer_extensions() = 0;
-  virtual void set_max_temporal_layer_extensions(int value) = 0;
-
-  virtual int max_spatial_layer_extensions() = 0;
-  virtual void set_max_spatial_layer_extensions(int value) = 0;
-
-  virtual bool svc_multi_stream_support() = 0;
-  virtual void set_svc_multi_stream_support(bool value) = 0;
-
-  virtual bool operator==(scoped_refptr<RTCRtpCodecCapability> o) const = 0;
-  virtual bool operator!=(scoped_refptr<RTCRtpCodecCapability> o) const = 0;
-};*/
-
-class RTCRtpHeaderExtensionCapability : public RefCountInterface {
-  virtual const string uri() = 0;
-  virtual void set_uri(const string uri) = 0;
-
-  virtual int preferred_id() = 0;
-  virtual void set_preferred_id(int value) = 0;
-
-  virtual bool preferred_encrypt() = 0;
-  virtual void set_preferred_encrypt(bool value) = 0;
-
-  virtual RTCRtpTransceiverDirection direction() = 0;
-  virtual void set_direction(RTCRtpTransceiverDirection value) = 0;
-
-  virtual bool operator==(
-      scoped_refptr<RTCRtpHeaderExtensionCapability> o) const = 0;
-  virtual bool operator!=(
-      scoped_refptr<RTCRtpHeaderExtensionCapability> o) const = 0;
-};
-
 class RTCRtpExtension : public RefCountInterface {
  public:
   enum RTCFilter {
@@ -201,27 +134,10 @@ class RTCRtpCodecParameters : public RefCountInterface {
 
   virtual bool operator==(scoped_refptr<RTCRtpCodecParameters> o) = 0;
   virtual bool operator!=(scoped_refptr<RTCRtpCodecParameters> o) = 0;
-};
-
-/*
-class RTCRtpCapabilities : public RefCountInterface {
-  virtual const vector<scoped_refptr<RTCRtpCodecCapability>> codecs() = 0;
-  virtual void set_codecs(
-      const vector<scoped_refptr<RTCRtpCodecCapability>> codecs) = 0;
 
-  virtual const vector<scoped_refptr<RTCRtpHeaderExtensionCapability>>
-  header_extensions() = 0;
-
-  virtual void set_header_extensions(
-      const vector<scoped_refptr<RTCRtpHeaderExtensionCapability>>
-          header_extensions) = 0;
-
-  virtual const vector<scoped_refptr<RTCFecMechanism>> fec() = 0;
-  virtual void set_fec(const vector<scoped_refptr<RTCFecMechanism>> fec) = 0;
-
-  virtual bool operator==(scoped_refptr<RTCRtpCapabilities> o) = 0;
-  virtual bool operator!=(scoped_refptr<RTCRtpCapabilities> o) = 0;
-};*/
+ protected:
+  virtual ~RTCRtpCodecParameters() {}
+};
 
 class RTCRtcpParameters : public RefCountInterface {
  public:
diff --git a/include/rtc_rtp_transceiver.h b/include/rtc_rtp_transceiver.h
index e52a7bc1cd..aebeac99e0 100644
--- a/include/rtc_rtp_transceiver.h
+++ b/include/rtc_rtp_transceiver.h
@@ -2,6 +2,7 @@
 #define LIB_WEBRTC_RTC_RTP_TRANSCEIVER_HXX
 
 #include "base/refcount.h"
+#include "rtc_rtp_capabilities.h"
 #include "rtc_rtp_parameters.h"
 #include "rtc_rtp_receiver.h"
 #include "rtc_rtp_sender.h"
@@ -55,19 +56,8 @@ class RTCRtpTransceiver : public RefCountInterface {
 
   virtual void StopInternal() = 0;
 
-  // virtual string set_codec_preferences(vector<RTCRtpCodecCapability> codecs)
-  // = 0;
-
-  // virtual vector<RTCRtpCodecCapability> codec_preferences() const = 0;
-
-  // virtual vector<RTCRtpHeaderExtensionCapability> HeaderExtensionsToOffer()
-  // const = 0;
-
-  // virtual std::vector<RTCRtpHeaderExtensionCapability>
-  // HeaderExtensionsNegotiated() const = 0;
-
-  // virtual webrtc::RTCError SetOfferedRtpHeaderExtensions(vector<const
-  // RTCRtpHeaderExtensionCapability> header_extensions_to_offer);
+  virtual void SetCodecPreferences(
+      vector<scoped_refptr<RTCRtpCodecCapability>> codecs) = 0;
 };
 
 }  // namespace libwebrtc
diff --git a/src/rtc_peerconnection_factory_impl.cc b/src/rtc_peerconnection_factory_impl.cc
index 1e9d30c5bd..e0794e717b 100644
--- a/src/rtc_peerconnection_factory_impl.cc
+++ b/src/rtc_peerconnection_factory_impl.cc
@@ -3,9 +3,11 @@
 #include "rtc_media_stream_impl.h"
 #include "rtc_mediaconstraints_impl.h"
 #include "rtc_peerconnection_impl.h"
+#include "rtc_rtp_capabilities_impl.h"
 #include "rtc_video_device_impl.h"
 #include "rtc_video_source_impl.h"
 
+
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/create_peerconnection_factory.h"
@@ -296,4 +298,61 @@ scoped_refptr<RTCAudioTrack> RTCPeerConnectionFactoryImpl::CreateAudioTrack(
   return track;
 }
 
+scoped_refptr<RTCRtpCapabilities>
+RTCPeerConnectionFactoryImpl::GetRtpSenderCapabilities(
+    RTCMediaType media_type) {
+  if (rtc::Thread::Current() != signaling_thread_) {
+    scoped_refptr<RTCRtpCapabilities> capabilities =
+        signaling_thread_->Invoke<scoped_refptr<RTCRtpCapabilities>>(
+            RTC_FROM_HERE, [this, media_type] {
+              return GetRtpSenderCapabilities(media_type);
+            });
+    return capabilities;
+  }
+
+  cricket::MediaType type = cricket::MediaType::MEDIA_TYPE_AUDIO;
+  switch (media_type) {
+    case RTCMediaType::AUDIO:
+      type = cricket::MediaType::MEDIA_TYPE_AUDIO;
+      break;
+    case RTCMediaType::VIDEO:
+      type = cricket::MediaType::MEDIA_TYPE_VIDEO;
+      break;
+    default:
+      break;
+  }
+  webrtc::RtpCapabilities rtp_capabilities =
+      rtc_peerconnection_factory_->GetRtpSenderCapabilities(type);
+  return scoped_refptr<RTCRtpCapabilities>(
+      new RefCountedObject<RTCRtpCapabilitiesImpl>(rtp_capabilities));
+}
+
+scoped_refptr<RTCRtpCapabilities>
+RTCPeerConnectionFactoryImpl::GetRtpReceiverCapabilities(
+    RTCMediaType media_type) {
+  if (rtc::Thread::Current() != signaling_thread_) {
+    scoped_refptr<RTCRtpCapabilities> capabilities =
+        signaling_thread_->Invoke<scoped_refptr<RTCRtpCapabilities>>(
+            RTC_FROM_HERE, [this, media_type] {
+              return GetRtpSenderCapabilities(media_type);
+            });
+    return capabilities;
+  }
+  cricket::MediaType type = cricket::MediaType::MEDIA_TYPE_AUDIO;
+  switch (media_type) {
+    case RTCMediaType::AUDIO:
+      type = cricket::MediaType::MEDIA_TYPE_AUDIO;
+      break;
+    case RTCMediaType::VIDEO:
+      type = cricket::MediaType::MEDIA_TYPE_VIDEO;
+      break;
+    default:
+      break;
+  }
+  webrtc::RtpCapabilities rtp_capabilities =
+      rtc_peerconnection_factory_->GetRtpReceiverCapabilities(type);
+  return scoped_refptr<RTCRtpCapabilities>(
+      new RefCountedObject<RTCRtpCapabilitiesImpl>(rtp_capabilities));
+}
+
 }  // namespace libwebrtc
diff --git a/src/rtc_peerconnection_factory_impl.h b/src/rtc_peerconnection_factory_impl.h
index 8fa573fb0d..578cd768f5 100644
--- a/src/rtc_peerconnection_factory_impl.h
+++ b/src/rtc_peerconnection_factory_impl.h
@@ -72,6 +72,12 @@ class RTCPeerConnectionFactoryImpl : public RTCPeerConnectionFactory {
     return rtc_peerconnection_factory_;
   }
 
+  scoped_refptr<RTCRtpCapabilities> GetRtpSenderCapabilities(
+      RTCMediaType media_type) override;
+
+  scoped_refptr<RTCRtpCapabilities> GetRtpReceiverCapabilities(
+      RTCMediaType media_type) override;
+
  protected:
   void CreateAudioDeviceModule_w();
 
diff --git a/src/rtc_rtp_capabilities_impl.cc b/src/rtc_rtp_capabilities_impl.cc
new file mode 100644
index 0000000000..2f9256bd90
--- /dev/null
+++ b/src/rtc_rtp_capabilities_impl.cc
@@ -0,0 +1,184 @@
+#include "rtc_rtp_capabilities_impl.h"
+
+namespace libwebrtc {
+
+scoped_refptr<RTCRtpCodecCapability> RTCRtpCodecCapability::Create() {
+  return new RefCountedObject<RTCRtpCodecCapabilityImpl>();
+}
+
+inline std::vector<std::string> split(std::string s, std::string delimiter) {
+  std::vector<std::string> tokens;
+  size_t pos = 0;
+  std::string token;
+  while ((pos = s.find(delimiter)) != std::string::npos) {
+    token = s.substr(0, pos);
+    tokens.push_back(token);
+    s.erase(0, pos + delimiter.length());
+  }
+  if (int(s.length()) > 0) {
+    tokens.push_back(s);
+  }
+  return tokens;
+}
+
+template <class T>
+std::string join(T& val, std::string delim) {
+  std::string str;
+  typename T::iterator it;
+  const typename T::iterator itlast = val.end() - 1;
+  for (it = val.begin(); it != val.end(); it++) {
+    str += *it;
+    if (it != itlast) {
+      str += delim;
+    }
+  }
+  return str;
+}
+
+RTCRtpCapabilitiesImpl::RTCRtpCapabilitiesImpl(
+    webrtc::RtpCapabilities rtp_capabilities)
+    : rtp_capabilities_(rtp_capabilities) {}
+
+const vector<scoped_refptr<RTCRtpCodecCapability>>
+RTCRtpCapabilitiesImpl::codecs() {
+  std::vector<scoped_refptr<RTCRtpCodecCapability>> codecs;
+  for (auto& codec : rtp_capabilities_.codecs) {
+    codecs.push_back(new RefCountedObject<RTCRtpCodecCapabilityImpl>(codec));
+  }
+  return codecs;
+}
+
+void RTCRtpCapabilitiesImpl::set_codecs(
+    vector<scoped_refptr<RTCRtpCodecCapability>> codecs) {
+  rtp_capabilities_.codecs.clear();
+  for (auto& codec : codecs.std_vector()) {
+    auto impl = static_cast<RTCRtpCodecCapabilityImpl*>(codec.get());
+    rtp_capabilities_.codecs.push_back(impl->rtp_codec_capability());
+  }
+}
+
+const vector<scoped_refptr<RTCRtpHeaderExtensionCapability>>
+RTCRtpCapabilitiesImpl::header_extensions() {
+  std::vector<scoped_refptr<RTCRtpHeaderExtensionCapability>> header_extensions;
+  for (auto& header_extension : rtp_capabilities_.header_extensions) {
+    header_extensions.push_back(
+        new RefCountedObject<RTCRtpHeaderExtensionCapabilityImpl>(
+            header_extension));
+  }
+  return header_extensions;
+}
+
+void RTCRtpCapabilitiesImpl::set_header_extensions(
+    vector<scoped_refptr<RTCRtpHeaderExtensionCapability>> header_extensions) {
+  rtp_capabilities_.header_extensions.clear();
+  for (auto& header_extension : header_extensions.std_vector()) {
+    auto impl = static_cast<RTCRtpHeaderExtensionCapabilityImpl*>(
+        header_extension.get());
+    rtp_capabilities_.header_extensions.push_back(
+        impl->rtp_header_extension_capability());
+  }
+}
+
+webrtc::RtpCapabilities RTCRtpCapabilitiesImpl::rtp_capabilities() {
+  return rtp_capabilities_;
+}
+
+RTCRtpCodecCapabilityImpl::RTCRtpCodecCapabilityImpl(
+    webrtc::RtpCodecCapability rtp_codec_capability)
+    : rtp_codec_capability_(rtp_codec_capability) {}
+
+string RTCRtpCodecCapabilityImpl::mime_type() const {
+  return rtp_codec_capability_.mime_type();
+}
+
+void RTCRtpCodecCapabilityImpl::set_mime_type(const string& mime_type) {
+  std::vector<std::string> mime_type_split = split(mime_type.std_string(), "/");
+  rtp_codec_capability_.name = mime_type_split[1];
+  cricket::MediaType kind = cricket::MEDIA_TYPE_AUDIO;
+  if (mime_type_split[0] == "audio") {
+    kind = cricket::MEDIA_TYPE_AUDIO;
+  } else if (mime_type_split[0] == "video") {
+    kind = cricket::MEDIA_TYPE_VIDEO;
+  } else {
+    kind = cricket::MEDIA_TYPE_DATA;
+  }
+  rtp_codec_capability_.kind = kind;
+}
+
+int RTCRtpCodecCapabilityImpl::clock_rate() const {
+  return rtp_codec_capability_.clock_rate.value_or(-1);
+}
+
+void RTCRtpCodecCapabilityImpl::set_clock_rate(int clock_rate) {
+  rtp_codec_capability_.clock_rate = clock_rate;
+}
+
+int RTCRtpCodecCapabilityImpl::channels() const {
+  return rtp_codec_capability_.num_channels.value_or(1);
+}
+
+void RTCRtpCodecCapabilityImpl::set_channels(int channels) {
+  rtp_codec_capability_.num_channels = channels;
+}
+
+string RTCRtpCodecCapabilityImpl::sdp_fmtp_line() const {
+  std::vector<std::string> strarr;
+  for (auto parameter : rtp_codec_capability_.parameters) {
+    if (parameter.first == "") {
+      strarr.push_back(parameter.second);
+    } else {
+      strarr.push_back(parameter.first + "=" + parameter.second);
+    }
+  }
+  return join(strarr, ";");
+}
+
+void RTCRtpCodecCapabilityImpl::set_sdp_fmtp_line(const string& sdp_fmtp_line) {
+  std::vector<std::string> parameters = split(sdp_fmtp_line.std_string(), ";");
+  for (auto parameter : parameters) {
+    if (parameter.find("=") != std::string::npos) {
+      std::vector<std::string> parameter_split = split(parameter, "=");
+      rtp_codec_capability_.parameters[parameter_split[0]] = parameter_split[1];
+    } else {
+      rtp_codec_capability_.parameters[""] = parameter;
+    }
+  }
+}
+
+webrtc::RtpCodecCapability RTCRtpCodecCapabilityImpl::rtp_codec_capability() {
+  return rtp_codec_capability_;
+}
+
+RTCRtpHeaderExtensionCapabilityImpl::RTCRtpHeaderExtensionCapabilityImpl(
+    webrtc::RtpHeaderExtensionCapability rtp_header_extension_capability)
+    : rtp_header_extension_capability_(rtp_header_extension_capability) {}
+
+const string RTCRtpHeaderExtensionCapabilityImpl::uri() {
+  return rtp_header_extension_capability_.uri;
+}
+
+void RTCRtpHeaderExtensionCapabilityImpl::set_uri(const string uri) {
+  rtp_header_extension_capability_.uri = uri.c_string();
+}
+
+webrtc::RtpHeaderExtensionCapability
+RTCRtpHeaderExtensionCapabilityImpl::rtp_header_extension_capability() {
+  return rtp_header_extension_capability_;
+}
+
+int RTCRtpHeaderExtensionCapabilityImpl::preferred_id() {
+  return rtp_header_extension_capability_.preferred_id.value_or(-1);
+}
+
+void RTCRtpHeaderExtensionCapabilityImpl::set_preferred_id(int value) {
+  rtp_header_extension_capability_.preferred_id = value;
+}
+
+bool RTCRtpHeaderExtensionCapabilityImpl::preferred_encrypt() {
+  return rtp_header_extension_capability_.preferred_encrypt;
+}
+void RTCRtpHeaderExtensionCapabilityImpl::set_preferred_encrypt(bool value) {
+  rtp_header_extension_capability_.preferred_encrypt = value;
+}
+
+}  // namespace libwebrtc
diff --git a/src/rtc_rtp_capabilities_impl.h b/src/rtc_rtp_capabilities_impl.h
new file mode 100644
index 0000000000..52c54ffbeb
--- /dev/null
+++ b/src/rtc_rtp_capabilities_impl.h
@@ -0,0 +1,69 @@
+#ifndef LIB_WBBRTC_RTC_RTP_CAPABILITIES_IMPL_HXX
+#define LIB_WBBRTC_RTC_RTP_CAPABILITIES_IMPL_HXX
+
+#include "api/rtp_parameters.h"
+#include "rtc_rtp_capabilities.h"
+
+namespace libwebrtc {
+
+class RTCRtpCapabilitiesImpl : public RTCRtpCapabilities {
+ public:
+  RTCRtpCapabilitiesImpl(webrtc::RtpCapabilities rtp_capabilities);
+  virtual const vector<scoped_refptr<RTCRtpCodecCapability>> codecs() override;
+  virtual void set_codecs(
+      vector<scoped_refptr<RTCRtpCodecCapability>> codecs) override;
+  virtual const vector<scoped_refptr<RTCRtpHeaderExtensionCapability>>
+  header_extensions() override;
+  virtual void set_header_extensions(
+      vector<scoped_refptr<RTCRtpHeaderExtensionCapability>> header_extensions)
+      override;
+
+  webrtc::RtpCapabilities rtp_capabilities();
+
+ private:
+  webrtc::RtpCapabilities rtp_capabilities_;
+};
+
+class RTCRtpCodecCapabilityImpl : public RTCRtpCodecCapability {
+ public:
+  RTCRtpCodecCapabilityImpl() {}
+  RTCRtpCodecCapabilityImpl(webrtc::RtpCodecCapability rtp_codec_capability);
+  virtual void set_mime_type(const string& mime_type) override;
+  virtual void set_clock_rate(int clock_rate) override;
+  virtual void set_channels(int channels) override;
+  virtual void set_sdp_fmtp_line(const string& sdp_fmtp_line) override;
+
+  virtual string mime_type() const override;
+  virtual int clock_rate() const override;
+  virtual int channels() const override;
+  virtual string sdp_fmtp_line() const override;
+
+  webrtc::RtpCodecCapability rtp_codec_capability();
+
+ private:
+  webrtc::RtpCodecCapability rtp_codec_capability_;
+};
+
+class RTCRtpHeaderExtensionCapabilityImpl
+    : public RTCRtpHeaderExtensionCapability {
+ public:
+  RTCRtpHeaderExtensionCapabilityImpl(
+      webrtc::RtpHeaderExtensionCapability rtp_header_extension_capability);
+  virtual const string uri() override;
+  virtual void set_uri(const string uri) override;
+
+  virtual int preferred_id() override;
+  virtual void set_preferred_id(int value) override;
+
+  virtual bool preferred_encrypt() override;
+  virtual void set_preferred_encrypt(bool value) override;
+
+  webrtc::RtpHeaderExtensionCapability rtp_header_extension_capability();
+
+ private:
+  webrtc::RtpHeaderExtensionCapability rtp_header_extension_capability_;
+};
+
+}  // namespace libwebrtc
+
+#endif  // LIB_WBBRTC_RTC_RTP_CAPABILITIES_IMPL_HXX
diff --git a/src/rtc_rtp_parameters_impl.cc b/src/rtc_rtp_parameters_impl.cc
index 1d709ae48a..823bafe2ce 100644
--- a/src/rtc_rtp_parameters_impl.cc
+++ b/src/rtc_rtp_parameters_impl.cc
@@ -39,7 +39,7 @@ void RTCRtpEncodingParametersImpl::set_network_priority(RTCPriority value) {
 }
 
 int RTCRtpEncodingParametersImpl::max_bitrate_bps() {
-  return rtp_encoding_parameters_.max_bitrate_bps.value();
+  return rtp_encoding_parameters_.max_bitrate_bps.value_or(0);
 }
 
 void RTCRtpEncodingParametersImpl::set_max_bitrate_bps(int value) {
@@ -47,7 +47,7 @@ void RTCRtpEncodingParametersImpl::set_max_bitrate_bps(int value) {
 }
 
 int RTCRtpEncodingParametersImpl::min_bitrate_bps() {
-  return rtp_encoding_parameters_.min_bitrate_bps.value();
+  return rtp_encoding_parameters_.min_bitrate_bps.value_or(0);
 }
 
 void RTCRtpEncodingParametersImpl::set_min_bitrate_bps(int value) {
@@ -55,7 +55,7 @@ void RTCRtpEncodingParametersImpl::set_min_bitrate_bps(int value) {
 }
 
 double RTCRtpEncodingParametersImpl::max_framerate() {
-  return rtp_encoding_parameters_.max_framerate.value();
+  return rtp_encoding_parameters_.max_framerate.value_or(0);
 }
 
 void RTCRtpEncodingParametersImpl::set_max_framerate(double value) {
@@ -63,7 +63,7 @@ void RTCRtpEncodingParametersImpl::set_max_framerate(double value) {
 }
 
 int RTCRtpEncodingParametersImpl::num_temporal_layers() {
-  return rtp_encoding_parameters_.num_temporal_layers.value();
+  return rtp_encoding_parameters_.num_temporal_layers.value_or(1);
 }
 
 void RTCRtpEncodingParametersImpl::set_num_temporal_layers(int value) {
@@ -71,7 +71,7 @@ void RTCRtpEncodingParametersImpl::set_num_temporal_layers(int value) {
 }
 
 double RTCRtpEncodingParametersImpl::scale_resolution_down_by() {
-  return rtp_encoding_parameters_.scale_resolution_down_by.value();
+  return rtp_encoding_parameters_.scale_resolution_down_by.value_or(1.0);
 }
 
 void RTCRtpEncodingParametersImpl::set_scale_resolution_down_by(double value) {
@@ -342,7 +342,7 @@ void RTCRtpCodecParametersImpl::set_payload_type(int value) {
 }
 
 int RTCRtpCodecParametersImpl::clock_rate() {
-  return rtp_codec_parameters_.clock_rate.value();
+  return rtp_codec_parameters_.clock_rate.value_or(0);
 }
 
 void RTCRtpCodecParametersImpl::set_clock_rate(int value) {
@@ -350,7 +350,7 @@ void RTCRtpCodecParametersImpl::set_clock_rate(int value) {
 }
 
 int RTCRtpCodecParametersImpl::num_channels() {
-  return rtp_codec_parameters_.num_channels.value();
+  return rtp_codec_parameters_.num_channels.value_or(1);
 }
 
 void RTCRtpCodecParametersImpl::set_num_channels(int value) {
@@ -358,7 +358,7 @@ void RTCRtpCodecParametersImpl::set_num_channels(int value) {
 }
 
 int RTCRtpCodecParametersImpl::max_ptime() {
-  return rtp_codec_parameters_.max_ptime.value();
+  return rtp_codec_parameters_.max_ptime.value_or(0);
 }
 
 void RTCRtpCodecParametersImpl::set_max_ptime(int value) {
@@ -366,7 +366,7 @@ void RTCRtpCodecParametersImpl::set_max_ptime(int value) {
 }
 
 int RTCRtpCodecParametersImpl::ptime() {
-  return rtp_codec_parameters_.ptime.value();
+  return rtp_codec_parameters_.ptime.value_or(0);
 }
 
 void RTCRtpCodecParametersImpl::set_ptime(int value) {
diff --git a/src/rtc_rtp_transceiver_impl.cc b/src/rtc_rtp_transceiver_impl.cc
index 8acb3dc372..6286ad034b 100644
--- a/src/rtc_rtp_transceiver_impl.cc
+++ b/src/rtc_rtp_transceiver_impl.cc
@@ -1,4 +1,5 @@
 #include "rtc_rtp_transceiver_impl.h"
+#include <src/rtc_rtp_capabilities_impl.h>
 #include <src/rtc_rtp_parameters_impl.h>
 #include <src/rtc_rtp_receiver_impl.h>
 #include <src/rtc_rtp_sender_impl.h>
@@ -148,4 +149,15 @@ const string RTCRtpTransceiverImpl::mid() const {
 RTCMediaType RTCRtpTransceiverImpl::media_type() const {
   return static_cast<RTCMediaType>(rtp_transceiver_->media_type());
 }
+
+void RTCRtpTransceiverImpl::SetCodecPreferences(
+    vector<scoped_refptr<RTCRtpCodecCapability>> codecs) {
+  std::vector<webrtc::RtpCodecCapability> list;
+  for (auto codec : codecs.std_vector()) {
+    auto impl = static_cast<RTCRtpCodecCapabilityImpl*>(codec.get());
+    list.push_back(impl->rtp_codec_capability());
+  }
+  rtp_transceiver_->SetCodecPreferences(list);
+}
+
 }  // namespace libwebrtc
diff --git a/src/rtc_rtp_transceiver_impl.h b/src/rtc_rtp_transceiver_impl.h
index 212872814f..a20119d56e 100644
--- a/src/rtc_rtp_transceiver_impl.h
+++ b/src/rtc_rtp_transceiver_impl.h
@@ -46,6 +46,8 @@ class RTCRtpTransceiverImpl : public RTCRtpTransceiver {
   virtual RTCRtpTransceiverDirection fired_direction() const override;
   virtual const string StopStandard() override;
   virtual void StopInternal() override;
+  virtual void SetCodecPreferences(
+      vector<scoped_refptr<RTCRtpCodecCapability>> codecs) override;
 
   rtc::scoped_refptr<webrtc::RtpTransceiverInterface> rtp_transceiver();