--- a/b2g/installer/package-manifest.in
+++ b/b2g/installer/package-manifest.in
@@ -263,16 +263,19 @@
 @BINPATH@/components/necko_http.xpt
 @BINPATH@/components/necko_res.xpt
 @BINPATH@/components/necko_socket.xpt
 @BINPATH@/components/necko_strconv.xpt
 @BINPATH@/components/necko_viewsource.xpt
 @BINPATH@/components/necko_websocket.xpt
 @BINPATH@/components/necko_wifi.xpt
 @BINPATH@/components/necko_wyciwyg.xpt
+#ifdef MOZ_RTSP
+@BINPATH@/components/necko_rtsp.xpt
+#endif
 @BINPATH@/components/necko.xpt
 @BINPATH@/components/loginmgr.xpt
 @BINPATH@/components/parentalcontrols.xpt
 #ifdef MOZ_WEBRTC
 @BINPATH@/components/peerconnection.xpt
 #endif
 @BINPATH@/components/places.xpt
 @BINPATH@/components/plugin.xpt

--- a/content/media/moz.build
+++ b/content/media/moz.build
@@ -77,16 +77,17 @@ EXPORTS += [
     'MediaDecoderOwner.h',
     'MediaDecoderReader.h',
     'MediaDecoderStateMachine.h',
     'MediaMetadataManager.h',
     'MediaRecorder.h',
     'MediaResource.h',
     'MediaSegment.h',
     'MediaStreamGraph.h',
+    'RtspMediaResource.h',
     'SharedBuffer.h',
     'StreamBuffer.h',
     'TimeVarying.h',
     'TrackUnionStream.h',
     'VideoFrameContainer.h',
     'VideoSegment.h',
     'VideoUtils.h',
     'VorbisUtils.h',
@@ -124,16 +125,17 @@ CPP_SOURCES += [
     'MediaCache.cpp',
     'MediaDecoder.cpp',
     'MediaDecoderReader.cpp',
     'MediaDecoderStateMachine.cpp',
     'MediaRecorder.cpp',
     'MediaResource.cpp',
     'MediaStreamGraph.cpp',
     'MediaStreamTrack.cpp',
+    'RtspMediaResource.cpp',
     'StreamBuffer.cpp',
     'TextTrack.cpp',
     'TextTrackCue.cpp',
     'TextTrackCueList.cpp',
     'TextTrackList.cpp',
     'TextTrackRegion.cpp',
     'TextTrackRegionList.cpp',
     'VideoFrameContainer.cpp',

--- a/content/media/omx/moz.build
+++ b/content/media/omx/moz.build
@@ -13,12 +13,22 @@ EXPORTS += [
 
 CPP_SOURCES += [
     'MediaOmxDecoder.cpp',
     'MediaOmxReader.cpp',
     'OmxDecoder.cpp',
     'OMXCodecProxy.cpp',
 ]
 
+if CONFIG['MOZ_RTSP']:
+    EXPORTS += [
+        'RtspOmxDecoder.h',
+        'RtspOmxReader.h',
+    ]
+    CPP_SOURCES += [
+        'RtspOmxDecoder.cpp',
+        'RtspOmxReader.cpp',
+    ]
+
 LIBXUL_LIBRARY = True
 
 LIBRARY_NAME = 'gkconomx_s'
 

--- a/layout/build/nsLayoutModule.cpp
+++ b/layout/build/nsLayoutModule.cpp
@@ -225,16 +225,17 @@ static void Shutdown();
 #include "nsIMediaManager.h"
 #include "nsMixedContentBlocker.h"
 
 #include "AudioChannelService.h"
 
 #include "mozilla/dom/power/PowerManagerService.h"
 #include "mozilla/dom/alarm/AlarmHalService.h"
 #include "mozilla/dom/time/TimeService.h"
+#include "StreamingProtocolService.h"
 
 #include "mozilla/dom/telephony/TelephonyFactory.h"
 #include "nsITelephonyProvider.h"
 
 #ifdef MOZ_WIDGET_GONK
 #include "GonkGPSGeolocationProvider.h"
 #endif
 #include "MediaManager.h"
@@ -246,16 +247,17 @@ using namespace mozilla::dom::telephony;
 using mozilla::dom::alarm::AlarmHalService;
 using mozilla::dom::indexedDB::IndexedDatabaseManager;
 using mozilla::dom::power::PowerManagerService;
 using mozilla::dom::quota::QuotaManager;
 using mozilla::dom::TCPSocketChild;
 using mozilla::dom::TCPSocketParent;
 using mozilla::dom::TCPServerSocketChild;
 using mozilla::dom::time::TimeService;
+using mozilla::net::StreamingProtocolControllerService;
 
 // Transformiix
 /* 5d5d92cd-6bf8-11d9-bf4a-000a95dc234c */
 #define TRANSFORMIIX_NODESET_CID \
 { 0x5d5d92cd, 0x6bf8, 0x11d9, { 0xbf, 0x4a, 0x0, 0x0a, 0x95, 0xdc, 0x23, 0x4c } }
 
 #define TRANSFORMIIX_NODESET_CONTRACTID \
 "@mozilla.org/transformiix-nodeset;1"
@@ -323,16 +325,19 @@ NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsIMobileMessageDatabaseService,
                                          SmsServicesFactory::CreateMobileMessageDatabaseService)
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsIPowerManagerService,
                                          PowerManagerService::GetInstance)
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsIAlarmHalService,
                                          AlarmHalService::GetInstance)
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsITimeService,
                                          TimeService::GetInstance)
+NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsIStreamingProtocolControllerService,
+                                         StreamingProtocolControllerService::GetInstance)
+
 #ifdef MOZ_GAMEPAD
 using mozilla::dom::GamepadServiceTest;
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(GamepadServiceTest,
                                          GamepadServiceTest::CreateService)
 #endif
 
 #ifdef MOZ_WIDGET_GONK
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsIGeolocationProvider,
@@ -799,16 +804,17 @@ NS_DEFINE_NAMED_CID(MOBILE_MESSAGE_SERVI
 NS_DEFINE_NAMED_CID(MOBILE_MESSAGE_DATABASE_SERVICE_CID);
 NS_DEFINE_NAMED_CID(NS_POWERMANAGERSERVICE_CID);
 NS_DEFINE_NAMED_CID(OSFILECONSTANTSSERVICE_CID);
 NS_DEFINE_NAMED_CID(NS_ALARMHALSERVICE_CID);
 NS_DEFINE_NAMED_CID(TCPSOCKETCHILD_CID);
 NS_DEFINE_NAMED_CID(TCPSOCKETPARENT_CID);
 NS_DEFINE_NAMED_CID(TCPSERVERSOCKETCHILD_CID);
 NS_DEFINE_NAMED_CID(NS_TIMESERVICE_CID);
+NS_DEFINE_NAMED_CID(NS_MEDIASTREAMCONTROLLERSERVICE_CID);
 #ifdef MOZ_WIDGET_GONK
 NS_DEFINE_NAMED_CID(GONK_GPS_GEOLOCATION_PROVIDER_CID);
 #endif
 NS_DEFINE_NAMED_CID(NS_MEDIAMANAGERSERVICE_CID);
 #ifdef MOZ_GAMEPAD
 NS_DEFINE_NAMED_CID(NS_GAMEPAD_TEST_CID);
 #endif
 #ifdef MOZ_WEBSPEECH
@@ -1088,16 +1094,17 @@ static const mozilla::Module::CIDEntry k
   { &kMOBILE_MESSAGE_DATABASE_SERVICE_CID, false, nullptr, nsIMobileMessageDatabaseServiceConstructor },
   { &kNS_POWERMANAGERSERVICE_CID, false, nullptr, nsIPowerManagerServiceConstructor },
   { &kOSFILECONSTANTSSERVICE_CID, true, nullptr, OSFileConstantsServiceConstructor },
   { &kNS_ALARMHALSERVICE_CID, false, nullptr, nsIAlarmHalServiceConstructor },
   { &kTCPSOCKETCHILD_CID, false, nullptr, TCPSocketChildConstructor },
   { &kTCPSOCKETPARENT_CID, false, nullptr, TCPSocketParentConstructor },
   { &kTCPSERVERSOCKETCHILD_CID, false, nullptr, TCPServerSocketChildConstructor },
   { &kNS_TIMESERVICE_CID, false, nullptr, nsITimeServiceConstructor },
+  { &kNS_MEDIASTREAMCONTROLLERSERVICE_CID, false, NULL, nsIStreamingProtocolControllerServiceConstructor },
 #ifdef MOZ_WIDGET_GONK
   { &kGONK_GPS_GEOLOCATION_PROVIDER_CID, false, nullptr, nsIGeolocationProviderConstructor },
 #endif
   { &kNS_MEDIAMANAGERSERVICE_CID, false, nullptr, nsIMediaManagerServiceConstructor },
 #ifdef MOZ_GAMEPAD
   { &kNS_GAMEPAD_TEST_CID, false, nullptr, GamepadServiceTestConstructor },
 #endif
 #ifdef ACCESSIBILITY
@@ -1244,16 +1251,17 @@ static const mozilla::Module::ContractID
   { MOBILE_MESSAGE_DATABASE_SERVICE_CONTRACTID, &kMOBILE_MESSAGE_DATABASE_SERVICE_CID },
   { POWERMANAGERSERVICE_CONTRACTID, &kNS_POWERMANAGERSERVICE_CID },
   { OSFILECONSTANTSSERVICE_CONTRACTID, &kOSFILECONSTANTSSERVICE_CID },
   { ALARMHALSERVICE_CONTRACTID, &kNS_ALARMHALSERVICE_CID },
   { "@mozilla.org/tcp-socket-child;1", &kTCPSOCKETCHILD_CID },
   { "@mozilla.org/tcp-socket-parent;1", &kTCPSOCKETPARENT_CID },
   { "@mozilla.org/tcp-server-socket-child;1", &kTCPSERVERSOCKETCHILD_CID },
   { TIMESERVICE_CONTRACTID, &kNS_TIMESERVICE_CID },
+  { MEDIASTREAMCONTROLLERSERVICE_CONTRACTID, &kNS_MEDIASTREAMCONTROLLERSERVICE_CID },
 #ifdef MOZ_WIDGET_GONK
   { GONK_GPS_GEOLOCATION_PROVIDER_CONTRACTID, &kGONK_GPS_GEOLOCATION_PROVIDER_CID },
 #endif
 #ifdef MOZ_GAMEPAD
   { NS_GAMEPAD_TEST_CONTRACTID, &kNS_GAMEPAD_TEST_CID },
 #endif
   { MEDIAMANAGERSERVICE_CONTRACTID, &kNS_MEDIAMANAGERSERVICE_CID },
 #ifdef ACCESSIBILITY

--- a/netwerk/base/public/moz.build
+++ b/netwerk/base/public/moz.build
@@ -90,16 +90,18 @@ XPIDL_SOURCES += [
     'nsISocketTransport.idl',
     'nsISocketTransportService.idl',
     'nsISpeculativeConnect.idl',
     'nsIStandardURL.idl',
     'nsIStreamListener.idl',
     'nsIStreamListenerTee.idl',
     'nsIStreamLoader.idl',
     'nsIStreamTransportService.idl',
+    'nsIStreamingProtocolController.idl',
+    'nsIStreamingProtocolService.idl',
     'nsISyncStreamListener.idl',
     'nsISystemProxySettings.idl',
     'nsIThreadRetargetableRequest.idl',
     'nsIThreadRetargetableStreamListener.idl',
     'nsITimedChannel.idl',
     'nsITraceableChannel.idl',
     'nsITransport.idl',
     'nsIUDPServerSocket.idl',

new file mode 100644
--- /dev/null
+++ b/netwerk/base/public/nsIStreamingProtocolController.idl
@@ -0,0 +1,179 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim: set sw=4 ts=4 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+interface nsIURI;
+
+#include "nsISupports.idl"
+
+%{C++
+#define MEDIASTREAM_FRAMETYPE_NORMAL          0x00000001
+#define MEDIASTREAM_FRAMETYPE_DISCONTINUITY   0x00000002
+%}
+
+/**
+ * Metadata of the media stream.
+ */
+[uuid(294adb30-856c-11e2-9e96-0800200c9a66)]
+interface nsIStreamingProtocolMetaData : nsISupports
+{
+    /**
+     * Frame type.
+     */
+    attribute uint32_t frameType;
+
+    /**
+     * The total tracks for the given media stream session.
+     */
+    attribute uint32_t totalTracks;
+
+    /**
+     * The mime type of the track.
+     */
+    attribute ACString mimeType;
+
+    /**
+     * The width of the resolution.
+     */
+    attribute unsigned long width;
+
+    /**
+     * The height of the resolution.
+     */
+    attribute unsigned long height;
+
+    /**
+     * The duration of the media stream.
+     */
+    attribute unsigned long long duration;
+
+    /**
+     * The sample rate of the media stream.
+     */
+    attribute unsigned long sampleRate;
+
+    /**
+     * The timestamp indicates the stream absolute position
+     * relative to the beginning of the presentation.
+     */
+    attribute unsigned long long timeStamp;
+
+    /**
+     * The total number of audio channels in the media stream.
+     */
+    attribute unsigned long channelCount;
+
+    /**
+     * The AAC audio codec specific data.
+     */
+    attribute ACString esdsData;
+
+    /**
+     * The AVCC format extradata of H.264 stream.
+     */
+    attribute ACString avccData;
+};
+
+/**
+ * nsIStreamingProtocolListener
+ */
+[scriptable, uuid(c4f6b660-892e-11e2-9e96-0800200c9a66)]
+interface nsIStreamingProtocolListener : nsISupports
+{
+    /**
+     * Called when the data may be read without blocking the calling thread.
+     * @param index The track number of the media stream.
+     * @param data Raw data of the media stream on given track number.
+     * @param length The length of the raw data.
+     * @param offset The offset in the data stream from the start of the media
+     *               presentation in bytes.
+     * @param meta The meta data of the frame.
+     */
+    void onMediaDataAvailable(in uint8_t index,
+                              in ACString data,
+                              in uint32_t length,
+                              in uint32_t offset,
+                              in nsIStreamingProtocolMetaData meta);
+
+    /**
+     * Called when the meta data for a given session is available.
+     * @param index The track number of the media stream.
+     * @param meta The meta data of the media stream.
+     */
+    void onConnected(in uint8_t index, in nsIStreamingProtocolMetaData meta);
+
+    /**
+     * Called when the Rtsp session is closed.
+     * @param index Track number of the media stream.
+     * @param reason The reason of disconnection.
+     */
+    void onDisconnected(in uint8_t index, in uint32_t reason);
+};
+
+/**
+ * Media stream controller API: control and retrieve meta data from media stream.
+ */
+[uuid(a9bdd4b0-8559-11e2-9e96-0800200c9a66)]
+interface nsIStreamingProtocolController : nsISupports
+{
+    /**
+     * Preprare the URI before we can start the connection.
+     * @param aUri The URI of the media stream.
+     */
+    void init(in nsIURI aUri);
+
+    /**
+     * Asynchronously open this controller.  Data is fed to the specified
+     * media stream listener as it becomes available. If asyncOpen returns
+     * successfully, the controller is responsible for keeping itself alive
+     * until it has called onStopRequest on aListener.
+     *
+     * @param aListener The nsIStreamingProtocolListener implementation
+     */
+    void asyncOpen(in nsIStreamingProtocolListener aListener);
+
+    /*
+     * Get the metadata of a track.
+     * @param index Index of a track.
+     * @return A nsIStreamingProtocolMetaData.
+     */
+    nsIStreamingProtocolMetaData getTrackMetaData(in octet index);
+
+    /*
+     * Tell the streaming server to start sending media data.
+     */
+    void play();
+
+    /*
+     * Tell the streaming server to pause sending media data.
+     */
+    void pause();
+
+    /*
+     * Tell the streaming server to resume the suspended media stream.
+     */
+    void resume();
+
+    /*
+     * Tell the streaming server to suspend the media stream.
+     */
+    void suspend();
+
+    /*
+     * Tell the streaming server to send media data in specific time.
+     * @param seekTimeUs Start time of the media stream in microseconds.
+     */
+    void seek(in unsigned long long seekTimeUs);
+
+    /*
+     * Tell the streaming server to stop the
+     * media stream and close the connection.
+     */
+    void stop();
+
+    /**
+     * Total number of audio/video tracks.
+     */
+    readonly attribute octet totalTracks;
+};

new file mode 100644
--- /dev/null
+++ b/netwerk/base/public/nsIStreamingProtocolService.idl
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim: set sw=4 ts=4 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+interface nsIStreamingProtocolController;
+interface nsIChannel;
+
+#include "nsISupports.idl"
+
+%{C++
+#define NS_MEDIASTREAMCONTROLLERSERVICE_CID                                   \
+  { 0x94838530, 0x8627, 0x11e2,                                               \
+    {                                                                         \
+      0x9e, 0x96, 0x08, 0x00,                                                 \
+      0x20, 0x0c, 0x9a, 0x66                                                  \
+    }                                                                         \
+  }
+#define MEDIASTREAMCONTROLLERSERVICE_CONTRACTID                               \
+  "@mozilla.org/mediastream/mediastreamcontrollerservice;1"
+%}
+
+/**
+ * Media stream controller Service API.
+ */
+[uuid(94838530-8627-11e2-9e96-0800200c9a66)]
+interface nsIStreamingProtocolControllerService : nsISupports
+{
+    /*
+     * Create a new media stream controller from the given channel.
+     * @param channel nsIChannel for the given URI.
+     */
+    nsIStreamingProtocolController create(in nsIChannel channel);
+};

--- a/netwerk/base/src/Makefile.in
+++ b/netwerk/base/src/Makefile.in
@@ -1,16 +1,21 @@
 # vim:set ts=8 sw=8 sts=8 noet:
 #
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 LOCAL_INCLUDES	+= -I$(topsrcdir)/dom/base
 
+ifdef MOZ_RTSP
+LOCAL_INCLUDES  += -I$(topsrcdir)/netwerk/protocol/rtsp/controller
+LOCAL_INCLUDES  += -I$(topsrcdir)/netwerk/protocol/rtsp/rtsp
+endif
+
 ifdef MOZ_ENABLE_QTNETWORK
 	LOCAL_INCLUDES += -I$(srcdir)/../../system/qt
 	OS_INCLUDES += $(MOZ_QT_CFLAGS)
 endif
 
 include $(topsrcdir)/config/rules.mk
 include $(topsrcdir)/ipc/chromium/chromium-config.mk
 

new file mode 100644
--- /dev/null
+++ b/netwerk/base/src/StreamingProtocolService.cpp
@@ -0,0 +1,71 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "base/basictypes.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "StreamingProtocolService.h"
+#include "mozilla/net/NeckoChild.h"
+#include "nsIURI.h"
+
+#ifdef MOZ_RTSP
+#include "RtspControllerChild.h"
+#include "RtspController.h"
+#endif
+
+namespace mozilla {
+namespace net {
+
+NS_IMPL_ISUPPORTS1(StreamingProtocolControllerService,
+                   nsIStreamingProtocolControllerService)
+
+/* static */
+StaticRefPtr<StreamingProtocolControllerService> sSingleton;
+
+/* static */
+already_AddRefed<StreamingProtocolControllerService>
+StreamingProtocolControllerService::GetInstance()
+{
+  if (!sSingleton) {
+    sSingleton = new StreamingProtocolControllerService();
+    ClearOnShutdown(&sSingleton);
+  }
+  nsRefPtr<StreamingProtocolControllerService> service = sSingleton.get();
+  return service.forget();
+}
+
+NS_IMETHODIMP
+StreamingProtocolControllerService::Create(nsIChannel *aChannel, nsIStreamingProtocolController **aResult)
+{
+  nsRefPtr<nsIStreamingProtocolController> mediacontroller;
+  nsCOMPtr<nsIURI> uri;
+  nsAutoCString scheme;
+
+  NS_ENSURE_ARG_POINTER(aChannel);
+  aChannel->GetURI(getter_AddRefs(uri));
+
+  nsresult rv = uri->GetScheme(scheme);
+  if (NS_FAILED(rv)) return rv;
+
+#ifdef MOZ_RTSP
+  if (scheme.EqualsLiteral("rtsp")) {
+    if (IsNeckoChild()) {
+      mediacontroller = new RtspControllerChild(aChannel);
+    } else {
+      mediacontroller = new RtspController(aChannel);
+    }
+  }
+#endif
+
+  if (!mediacontroller) {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  mediacontroller->Init(uri);
+
+  mediacontroller.forget(aResult);
+  return NS_OK;
+}
+
+} // namespace net
+} // namespace mozilla

new file mode 100644
--- /dev/null
+++ b/netwerk/base/src/StreamingProtocolService.h
@@ -0,0 +1,33 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_net_StreamingProtocolControllerService_h
+#define mozilla_net_StreamingProtocolControllerService_h
+
+#include "mozilla/StaticPtr.h"
+#include "nsIStreamingProtocolService.h"
+#include "nsIStreamingProtocolController.h"
+#include "nsCOMPtr.h"
+#include "nsIChannel.h"
+
+namespace mozilla {
+namespace net {
+
+/**
+ * This class implements a service to help to create streaming protocol controller.
+ */
+class StreamingProtocolControllerService : public nsIStreamingProtocolControllerService
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSISTREAMINGPROTOCOLCONTROLLERSERVICE
+
+  StreamingProtocolControllerService() {};
+  virtual ~StreamingProtocolControllerService() {};
+  static already_AddRefed<StreamingProtocolControllerService> GetInstance();
+};
+} // namespace dom
+} // namespace mozilla
+
+#endif //mozilla_net_StreamingProtocolControllerService_h

--- a/netwerk/base/src/moz.build
+++ b/netwerk/base/src/moz.build
@@ -69,16 +69,17 @@ CPP_SOURCES += [
     'nsSyncStreamListener.cpp',
     'nsTemporaryFileInputStream.cpp',
     'nsTransportUtils.cpp',
     'nsUDPServerSocket.cpp',
     'nsURIChecker.cpp',
     'nsURLHelper.cpp',
     'nsURLParsers.cpp',
     'nsUnicharStreamLoader.cpp',
+    'StreamingProtocolService.cpp',
 ]
 
 if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'os2':
     CPP_SOURCES += [
         'nsURLHelperOS2.cpp',
     ]
 elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows':
     CPP_SOURCES += [

--- a/netwerk/build/Makefile.in
+++ b/netwerk/build/Makefile.in
@@ -13,16 +13,20 @@ SHARED_LIBRARY_LIBS = \
   ../cache/$(LIB_PREFIX)nkcache_s.$(LIB_SUFFIX) \
   ../cache2/$(LIB_PREFIX)nkcache2_s.$(LIB_SUFFIX) \
   ../protocol/about/$(LIB_PREFIX)nkabout_s.$(LIB_SUFFIX) \
   $(foreach d,$(filter-out about,$(NECKO_PROTOCOLS)), \
     ../protocol/$(d)/$(LIB_PREFIX)nk$(d)_s.$(LIB_SUFFIX)) \
   ../ipc/$(LIB_PREFIX)neckoipc_s.$(LIB_SUFFIX) \
   $(NULL)
 
+ifdef MOZ_RTSP
+SHARED_LIBRARY_LIBS += ../protocol/rtsp/$(LIB_PREFIX)nkrtsp_s.$(LIB_SUFFIX)
+endif
+
 ifdef MOZ_SRTP
 SHARED_LIBRARY_LIBS += \
   ../srtp/src/$(LIB_PREFIX)nksrtp_s.$(LIB_SUFFIX) \
   $(NULL)
 endif
 
 ifdef MOZ_SCTP
 SHARED_LIBRARY_LIBS += \
@@ -96,10 +100,14 @@ endif
 ifdef NECKO_WIFI
 SHARED_LIBRARY_LIBS += \
   ../wifi/$(LIB_PREFIX)neckowifi_s.$(LIB_SUFFIX) \
   $(NULL)
 LOCAL_INCLUDES += -I$(srcdir)/../wifi
 
 endif
 
+ifdef MOZ_RTSP
+    LOCAL_INCLUDES += -I$(srcdir)/../protocol/rtsp
+endif
+
 include $(topsrcdir)/config/rules.mk
 include $(topsrcdir)/ipc/chromium/chromium-config.mk

--- a/netwerk/build/nsNetCID.h
+++ b/netwerk/build/nsNetCID.h
@@ -666,16 +666,28 @@
 { /* {dc01dbbb-a5bb-4cbb-82bb-085cce06c0bb} */       \
   0xdc01dbbb,                                        \
   0xa5bb,                                            \
   0x4cbb,                                            \
   {0x82, 0xbb, 0x08, 0x5c, 0xce, 0x06, 0xc0, 0xbb}   \
 }
 
 /******************************************************************************
+ * netwerk/protocol/rtsp / classes
+ */
+
+#define NS_RTSPPROTOCOLHANDLER_CID                   \
+{ /* {5bb4b980-7b10-11e2-b92a-0800200c9a66} */       \
+  0x5bb4b980,                                        \
+  0x7b10,                                            \
+  0x11e2,                                            \
+  {0xb9, 0x2a, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66}   \
+}
+
+/******************************************************************************
  * netwerk/protocol/about/ classes
  */
 
 #define NS_ABOUTPROTOCOLHANDLER_CID                  \
 { /* 9e3b6c90-2f75-11d3-8cd0-0060b0fc14a3 */         \
     0x9e3b6c90,                                      \
     0x2f75,                                          \
     0x11d3,                                          \

--- a/netwerk/build/nsNetModule.cpp
+++ b/netwerk/build/nsNetModule.cpp
@@ -312,16 +312,25 @@ type##Constructor(nsISupports *aOuter, R
 
 WEB_SOCKET_HANDLER_CONSTRUCTOR(WebSocketChannel, false)
 WEB_SOCKET_HANDLER_CONSTRUCTOR(WebSocketSSLChannel, true)
 #undef WEB_SOCKET_HANDLER_CONSTRUCTOR
 } // namespace mozilla::net
 } // namespace mozilla
 #endif
 
+#ifdef MOZ_RTSP
+#include "RtspHandler.h"
+namespace mozilla {
+namespace net {
+NS_GENERIC_FACTORY_CONSTRUCTOR(RtspHandler)
+} // namespace mozilla::net
+} // namespace mozilla
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "nsURIChecker.h"
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsURIChecker)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "nsURLParsers.h"
@@ -781,16 +790,19 @@ NS_DEFINE_NAMED_CID(NS_VIEWSOURCEHANDLER
 #endif
 #ifdef NECKO_PROTOCOL_wyciwyg
 NS_DEFINE_NAMED_CID(NS_WYCIWYGPROTOCOLHANDLER_CID);
 #endif
 #ifdef NECKO_PROTOCOL_websocket
 NS_DEFINE_NAMED_CID(NS_WEBSOCKETPROTOCOLHANDLER_CID);
 NS_DEFINE_NAMED_CID(NS_WEBSOCKETSSLPROTOCOLHANDLER_CID);
 #endif
+#ifdef MOZ_RTSP
+NS_DEFINE_NAMED_CID(NS_RTSPPROTOCOLHANDLER_CID);
+#endif
 #if defined(XP_WIN)
 NS_DEFINE_NAMED_CID(NS_NETWORK_LINK_SERVICE_CID);
 #elif defined(MOZ_WIDGET_COCOA)
 NS_DEFINE_NAMED_CID(NS_NETWORK_LINK_SERVICE_CID);
 #elif defined(MOZ_ENABLE_QTNETWORK)
 NS_DEFINE_NAMED_CID(NS_NETWORK_LINK_SERVICE_CID);
 #elif defined(MOZ_WIDGET_ANDROID)
 NS_DEFINE_NAMED_CID(NS_NETWORK_LINK_SERVICE_CID);
@@ -918,16 +930,19 @@ static const mozilla::Module::CIDEntry k
     { &kNS_WYCIWYGPROTOCOLHANDLER_CID, false, nullptr, nsWyciwygProtocolHandlerConstructor },
 #endif
 #ifdef NECKO_PROTOCOL_websocket
     { &kNS_WEBSOCKETPROTOCOLHANDLER_CID, false, nullptr,
       mozilla::net::WebSocketChannelConstructor },
     { &kNS_WEBSOCKETSSLPROTOCOLHANDLER_CID, false, nullptr,
       mozilla::net::WebSocketSSLChannelConstructor },
 #endif
+#ifdef MOZ_RTSP
+    { &kNS_RTSPPROTOCOLHANDLER_CID, false, NULL, mozilla::net::RtspHandlerConstructor },
+#endif
 #if defined(XP_WIN)
     { &kNS_NETWORK_LINK_SERVICE_CID, false, nullptr, nsNotifyAddrListenerConstructor },
 #elif defined(MOZ_WIDGET_COCOA)
     { &kNS_NETWORK_LINK_SERVICE_CID, false, nullptr, nsNetworkLinkServiceConstructor },
 #elif defined(MOZ_ENABLE_QTNETWORK)
     { &kNS_NETWORK_LINK_SERVICE_CID, false, nullptr, nsQtNetworkLinkServiceConstructor },
 #elif defined(MOZ_WIDGET_ANDROID)
     { &kNS_NETWORK_LINK_SERVICE_CID, false, nullptr, nsAndroidNetworkLinkServiceConstructor },
@@ -1058,16 +1073,19 @@ static const mozilla::Module::ContractID
 #endif
 #ifdef NECKO_PROTOCOL_wyciwyg
     { NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "wyciwyg", &kNS_WYCIWYGPROTOCOLHANDLER_CID },
 #endif
 #ifdef NECKO_PROTOCOL_websocket
     { NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "ws", &kNS_WEBSOCKETPROTOCOLHANDLER_CID },
     { NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "wss", &kNS_WEBSOCKETSSLPROTOCOLHANDLER_CID },
 #endif
+#ifdef MOZ_RTSP
+    { NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "rtsp", &kNS_RTSPPROTOCOLHANDLER_CID },
+#endif
 #if defined(XP_WIN)
     { NS_NETWORK_LINK_SERVICE_CONTRACTID, &kNS_NETWORK_LINK_SERVICE_CID },
 #elif defined(MOZ_WIDGET_COCOA)
     { NS_NETWORK_LINK_SERVICE_CONTRACTID, &kNS_NETWORK_LINK_SERVICE_CID },
 #elif defined(MOZ_ENABLE_QTNETWORK)
     { NS_NETWORK_LINK_SERVICE_CONTRACTID, &kNS_NETWORK_LINK_SERVICE_CID },
 #elif defined(MOZ_WIDGET_ANDROID)
     { NS_NETWORK_LINK_SERVICE_CONTRACTID, &kNS_NETWORK_LINK_SERVICE_CID },

--- a/netwerk/ipc/NeckoChild.cpp
+++ b/netwerk/ipc/NeckoChild.cpp
@@ -11,16 +11,19 @@
 #include "mozilla/net/HttpChannelChild.h"
 #include "mozilla/net/CookieServiceChild.h"
 #include "mozilla/net/WyciwygChannelChild.h"
 #include "mozilla/net/FTPChannelChild.h"
 #include "mozilla/net/WebSocketChannelChild.h"
 #include "mozilla/net/RemoteOpenFileChild.h"
 #include "mozilla/dom/network/TCPSocketChild.h"
 #include "mozilla/dom/network/TCPServerSocketChild.h"
+#ifdef MOZ_RTSP
+#include "mozilla/net/RtspControllerChild.h"
+#endif
 
 using mozilla::dom::TCPSocketChild;
 using mozilla::dom::TCPServerSocketChild;
 
 namespace mozilla {
 namespace net {
 
 PNeckoChild *gNeckoChild = nullptr;
@@ -150,16 +153,33 @@ NeckoChild::AllocPWebSocketChild(PBrowse
 bool
 NeckoChild::DeallocPWebSocketChild(PWebSocketChild* child)
 {
   WebSocketChannelChild* p = static_cast<WebSocketChannelChild*>(child);
   p->ReleaseIPDLReference();
   return true;
 }
 
+PRtspControllerChild*
+NeckoChild::AllocPRtspControllerChild()
+{
+  NS_NOTREACHED("AllocPRtspController should not be called");
+  return nullptr;
+}
+
+bool
+NeckoChild::DeallocPRtspControllerChild(PRtspControllerChild* child)
+{
+#ifdef MOZ_RTSP
+  RtspControllerChild* p = static_cast<RtspControllerChild*>(child);
+  p->ReleaseIPDLReference();
+#endif
+  return true;
+}
+
 PTCPSocketChild*
 NeckoChild::AllocPTCPSocketChild()
 {
   TCPSocketChild* p = new TCPSocketChild();
   p->AddIPDLReference();
   return p;
 }
 

--- a/netwerk/ipc/NeckoChild.h
+++ b/netwerk/ipc/NeckoChild.h
@@ -45,16 +45,18 @@ protected:
   virtual bool DeallocPTCPSocketChild(PTCPSocketChild*);
   virtual PTCPServerSocketChild* AllocPTCPServerSocketChild(const uint16_t& aLocalPort,
                                                        const uint16_t& aBacklog,
                                                        const nsString& aBinaryType);
   virtual bool DeallocPTCPServerSocketChild(PTCPServerSocketChild*);
   virtual PRemoteOpenFileChild* AllocPRemoteOpenFileChild(const URIParams&,
                                                           const OptionalURIParams&);
   virtual bool DeallocPRemoteOpenFileChild(PRemoteOpenFileChild*);
+  virtual PRtspControllerChild* AllocPRtspControllerChild();
+  virtual bool DeallocPRtspControllerChild(PRtspControllerChild*);
 };
 
 /**
  * Reference to the PNecko Child protocol.
  * Null if this is not a content process.
  */
 extern PNeckoChild *gNeckoChild;
 

--- a/netwerk/ipc/NeckoParent.cpp
+++ b/netwerk/ipc/NeckoParent.cpp
@@ -7,16 +7,19 @@
 
 #include "nsHttp.h"
 #include "mozilla/net/NeckoParent.h"
 #include "mozilla/net/HttpChannelParent.h"
 #include "mozilla/net/CookieServiceParent.h"
 #include "mozilla/net/WyciwygChannelParent.h"
 #include "mozilla/net/FTPChannelParent.h"
 #include "mozilla/net/WebSocketChannelParent.h"
+#ifdef MOZ_RTSP
+#include "mozilla/net/RtspControllerParent.h"
+#endif
 #include "mozilla/net/RemoteOpenFileParent.h"
 #include "mozilla/dom/ContentParent.h"
 #include "mozilla/dom/TabParent.h"
 #include "mozilla/dom/network/TCPSocketParent.h"
 #include "mozilla/dom/network/TCPServerSocketParent.h"
 #include "mozilla/ipc/URIUtils.h"
 #include "mozilla/LoadContext.h"
 #include "mozilla/AppProcessChecker.h"
@@ -298,16 +301,38 @@ NeckoParent::AllocPWebSocketParent(PBrow
 bool
 NeckoParent::DeallocPWebSocketParent(PWebSocketParent* actor)
 {
   WebSocketChannelParent* p = static_cast<WebSocketChannelParent*>(actor);
   p->Release();
   return true;
 }
 
+PRtspControllerParent*
+NeckoParent::AllocPRtspControllerParent()
+{
+#ifdef MOZ_RTSP
+  RtspControllerParent* p = new RtspControllerParent();
+  p->AddRef();
+  return p;
+#else
+  return nullptr;
+#endif
+}
+
+bool
+NeckoParent::DeallocPRtspControllerParent(PRtspControllerParent* actor)
+{
+#ifdef MOZ_RTSP
+  RtspControllerParent* p = static_cast<RtspControllerParent*>(actor);
+  p->Release();
+#endif
+  return true;
+}
+
 PTCPSocketParent*
 NeckoParent::AllocPTCPSocketParent()
 {
   TCPSocketParent* p = new TCPSocketParent();
   p->AddIPDLReference();
   return p;
 }
 

--- a/netwerk/ipc/NeckoParent.h
+++ b/netwerk/ipc/NeckoParent.h
@@ -120,16 +120,18 @@ protected:
                                    const uint16_t& flags);
   virtual bool RecvCancelHTMLDNSPrefetch(const nsString& hostname,
                                          const uint16_t& flags,
                                          const nsresult& reason);
 
   virtual mozilla::ipc::IProtocol*
   CloneProtocol(Channel* aChannel,
                 mozilla::ipc::ProtocolCloneContext* aCtx) MOZ_OVERRIDE;
+  virtual PRtspControllerParent* AllocPRtspControllerParent();
+  virtual bool DeallocPRtspControllerParent(PRtspControllerParent*);
 
 private:
   nsCString mCoreAppsBasePath;
   nsCString mWebAppsBasePath;
 };
 
 } // namespace net
 } // namespace mozilla

--- a/netwerk/ipc/PNecko.ipdl
+++ b/netwerk/ipc/PNecko.ipdl
@@ -12,16 +12,17 @@ include protocol PBrowser;
 include protocol PWyciwygChannel;
 include protocol PFTPChannel;
 include protocol PWebSocket;
 include protocol PTCPSocket;
 include protocol PTCPServerSocket;
 include protocol PRemoteOpenFile;
 include protocol PBlob; //FIXME: bug #792908
 
+include protocol PRtspController;
 include URIParams;
 include InputStreamParams;
 include NeckoChannelParams;
 
 include "SerializedLoadContext.h";
 
 using IPC::SerializedLoadContext;
 
@@ -35,16 +36,17 @@ sync protocol PNecko
   manages PHttpChannel;
   manages PCookieService;
   manages PWyciwygChannel;
   manages PFTPChannel;
   manages PWebSocket;
   manages PTCPSocket;
   manages PTCPServerSocket;
   manages PRemoteOpenFile;
+  manages PRtspController;
 
 parent:
   __delete__();
 
   PCookieService();
   PHttpChannel(nullable PBrowser browser,
                SerializedLoadContext loadContext,
                HttpChannelCreationArgs args);
@@ -53,16 +55,17 @@ parent:
               FTPChannelCreationArgs args);
 
   PWebSocket(PBrowser browser, SerializedLoadContext loadContext);
   PTCPServerSocket(uint16_t localPort, uint16_t backlog, nsString binaryType);
   PRemoteOpenFile(URIParams fileuri, OptionalURIParams appuri);
 
   HTMLDNSPrefetch(nsString hostname, uint16_t flags);
   CancelHTMLDNSPrefetch(nsString hostname, uint16_t flags, nsresult reason);
+  PRtspController();
 
 both:
   PTCPSocket();
 };
 
 
 } // namespace net
 } // namespace mozilla

new file mode 100644
--- /dev/null
+++ b/netwerk/ipc/PRtspController.ipdl
@@ -0,0 +1,63 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 ft=cpp : */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+include protocol PNecko;
+include URIParams;
+
+namespace mozilla {
+namespace net {
+
+/**
+ * Defined meta data format.
+ */
+union RtspMetaValue
+{
+  bool;
+  uint8_t;
+  uint32_t;
+  uint64_t;
+  nsCString;
+};
+
+/**
+ * Key-value pair.
+ */
+struct RtspMetadataParam
+{
+  nsCString name;
+  RtspMetaValue value;
+};
+
+async protocol PRtspController
+{
+  manager PNecko;
+
+parent:
+  AsyncOpen(URIParams aURI);
+  Play();
+  Pause();
+  Resume();
+  Suspend();
+  Seek(uint64_t offset);
+  Stop();
+  __delete__();
+
+child:
+  OnMediaDataAvailable(uint8_t index,
+                       nsCString data,
+                       uint32_t length,
+                       uint32_t offset,
+                       RtspMetadataParam[] meta);
+  OnConnected(uint8_t index,
+              RtspMetadataParam[] meta);
+  OnDisconnected(uint8_t index,
+                 uint32_t reason);
+  AsyncOpenFailed(uint8_t reason);
+};
+
+} //namespace net
+} //namespace mozilla

--- a/netwerk/ipc/moz.build
+++ b/netwerk/ipc/moz.build
@@ -30,16 +30,17 @@ CPP_SOURCES += [
     'RemoteOpenFileChild.cpp',
     'RemoteOpenFileParent.cpp',
 ]
 
 IPDL_SOURCES = [
     'NeckoChannelParams.ipdlh',
     'PNecko.ipdl',
     'PRemoteOpenFile.ipdl',
+    'PRtspController.ipdl',
 ]
 
 FAIL_ON_WARNINGS = True
 
 LIBXUL_LIBRARY = True
 
 LIBRARY_NAME = 'neckoipc_s'
 

--- a/netwerk/protocol/moz.build
+++ b/netwerk/protocol/moz.build
@@ -12,8 +12,14 @@ PARALLEL_DIRS += [
     'file',
     'ftp',
     'http',
     'res',
     'viewsource',
     'websocket',
     'wyciwyg',
 ]
+
+if CONFIG['MOZ_RTSP']:
+    PARALLEL_DIRS += [
+        'rtsp',
+    ]
+

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/Makefile.in
@@ -0,0 +1,25 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+DEPTH     = @DEPTH@
+topsrcdir = @top_srcdir@
+srcdir    = @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+LOCAL_INCLUDES = \
+  -I$(srcdir)/../../base/src \
+  -I$(topsrcdir)/content/base/src \
+  -I$(topsrcdir)/content/events/src \
+  -I$(topsrcdir)/xpcom/ds \
+  -I$(srcdir) \
+  -I$(srcdir)/rtsp \
+  -I$(srcdir)/controller \
+  -I$(ANDROID_SOURCE)/frameworks/base/media/libstagefright/mpeg2ts \
+  $(NULL)
+
+include $(topsrcdir)/config/rules.mk
+include $(topsrcdir)/ipc/chromium/chromium-config.mk
+
+DEFINES += -DIMPL_NS_NET -Wno-multichar -DFORCE_PR_LOG

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/RtspChannel.cpp
@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "RtspChannel.h"
+#include "nsIURI.h"
+#include "nsAutoPtr.h"
+#include "nsStandardURL.h"
+
+namespace mozilla {
+namespace net {
+
+NS_IMPL_ISUPPORTS_INHERITED1(RtspChannel,
+                             nsBaseChannel,
+                             nsIChannel)
+
+//-----------------------------------------------------------------------------
+// RtspChannel::nsIChannel
+//-----------------------------------------------------------------------------
+
+NS_IMETHODIMP
+RtspChannel::AsyncOpen(nsIStreamListener *aListener, nsISupports *aContext)
+{
+  MOZ_ASSERT(aListener);
+
+  nsCOMPtr<nsIURI> uri = nsBaseChannel::URI();
+  NS_ENSURE_TRUE(uri, NS_ERROR_ILLEGAL_VALUE);
+
+  nsAutoCString uriSpec;
+  uri->GetSpec(uriSpec);
+
+  mListener = aListener;
+  mListenerContext = aContext;
+
+  // Call OnStartRequest directly. mListener is expected to create/load an
+  // RtspMediaResource which will create an RtspMediaController. This controller
+  // manages the control and data streams to and from the network.
+  mListener->OnStartRequest(this, aContext);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspChannel::GetContentType(nsACString& aContentType)
+{
+  aContentType.AssignLiteral("RTSP");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspChannel::Init(nsIURI* aUri)
+{
+  MOZ_ASSERT(aUri);
+
+  nsBaseChannel::Init();
+  nsBaseChannel::SetURI(aUri);
+  return NS_OK;
+}
+
+} // namespace mozilla::net
+} // namespace mozilla

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/RtspChannel.h
@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef RtspChannel_h
+#define RtspChannel_h
+
+#include "nsBaseChannel.h"
+
+namespace mozilla {
+namespace net {
+
+//-----------------------------------------------------------------------------
+// RtspChannel is a dummy channel used to aid MediaResource creation in
+// HTMLMediaElement. Actual network control and data flows are managed by an
+// RtspController object created and owned by RtspMediaResource.
+// Therefore, when RtspChannel::AsyncOpen is called, mListener->OnStartRequest
+// will be called immediately. It is expected that an RtspMediaResource object
+// will be created in that calling context or after; the RtspController object
+// will be created internally by RtspMediaResource."
+
+class RtspChannel : public nsBaseChannel
+                  , public nsIStreamListener
+{
+public:
+  NS_DECL_ISUPPORTS
+
+  RtspChannel() { }
+
+  ~RtspChannel() { }
+
+  // Overrides nsBaseChannel::AsyncOpen and call listener's OnStartRequest immediately.
+  NS_IMETHOD AsyncOpen(nsIStreamListener *listener,
+                       nsISupports *aContext) MOZ_OVERRIDE MOZ_FINAL;
+  // Set Rtsp URL.
+  NS_IMETHOD Init(nsIURI* uri);
+  // Overrides nsBaseChannel::GetContentType, return streaming protocol type "RTSP".
+  NS_IMETHOD GetContentType(nsACString & aContentType) MOZ_OVERRIDE MOZ_FINAL;
+
+  NS_IMETHOD OpenContentStream(bool aAsync,
+                               nsIInputStream **aStream,
+                               nsIChannel **aChannel) MOZ_OVERRIDE MOZ_FINAL
+  {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+
+  // nsIRequestObserver
+  NS_IMETHOD OnStartRequest(nsIRequest *aRequest,
+                            nsISupports *aContext) MOZ_OVERRIDE MOZ_FINAL
+  {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+
+  NS_IMETHOD OnStopRequest(nsIRequest *aRequest,
+                           nsISupports *aContext,
+                           nsresult aStatusCode) MOZ_OVERRIDE MOZ_FINAL
+  {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+
+  // nsIStreamListener
+  NS_IMETHOD OnDataAvailable(nsIRequest *aRequest,
+                             nsISupports *aContext,
+                             nsIInputStream *aInputStream,
+                             uint64_t aOffset,
+                             uint32_t aCount) MOZ_OVERRIDE MOZ_FINAL
+  {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+};
+
+}
+} // namespace mozilla::net
+#endif // RtspChannel_h

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/RtspHandler.cpp
@@ -0,0 +1,95 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "RtspChannel.h"
+#include "RtspHandler.h"
+#include "nsILoadGroup.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIURI.h"
+#include "nsAutoPtr.h"
+#include "nsStandardURL.h"
+#include "mozilla/net/NeckoChild.h"
+
+namespace mozilla {
+namespace net {
+
+NS_IMPL_ISUPPORTS1(RtspHandler, nsIProtocolHandler)
+
+//-----------------------------------------------------------------------------
+// RtspHandler::nsIProtocolHandler
+//-----------------------------------------------------------------------------
+
+NS_IMETHODIMP
+RtspHandler::GetScheme(nsACString &aScheme)
+{
+  aScheme.AssignLiteral("rtsp");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspHandler::GetDefaultPort(int32_t *aDefaultPort)
+{
+  *aDefaultPort = kDefaultRtspPort;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspHandler::GetProtocolFlags(uint32_t *aProtocolFlags)
+{
+  *aProtocolFlags = URI_NORELATIVE | URI_NOAUTH | URI_INHERITS_SECURITY_CONTEXT |
+    URI_LOADABLE_BY_ANYONE | URI_NON_PERSISTABLE | URI_SYNC_LOAD_IS_OK;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspHandler::NewURI(const nsACString & aSpec,
+                    const char *aOriginCharset,
+                    nsIURI *aBaseURI, nsIURI **aResult)
+{
+  int32_t port;
+
+  nsresult rv = GetDefaultPort(&port);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsRefPtr<nsStandardURL> url = new nsStandardURL();
+  rv = url->Init(nsIStandardURL::URLTYPE_AUTHORITY, port, aSpec,
+                 aOriginCharset, aBaseURI);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  url.forget(aResult);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspHandler::NewChannel(nsIURI *aURI, nsIChannel **aResult)
+{
+  bool isRtsp = false;
+  nsRefPtr<RtspChannel> rtspChannel;
+
+  nsresult rv = aURI->SchemeIs("rtsp", &isRtsp);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(isRtsp, NS_ERROR_UNEXPECTED);
+
+  rtspChannel = new RtspChannel();
+
+  rv = rtspChannel->Init(aURI);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rtspChannel.forget(aResult);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspHandler::AllowPort(int32_t port, const char *scheme, bool *aResult)
+{
+  // Do not override any blacklisted ports.
+  *aResult = false;
+  return NS_OK;
+}
+
+} // namespace net
+} // namespace mozilla

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/RtspHandler.h
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef RtspHandler_h
+#define RtspHandler_h
+
+#include "nsIProtocolHandler.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+namespace mozilla {
+namespace net {
+
+
+class RtspHandler : public nsIProtocolHandler
+{
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPROTOCOLHANDLER
+
+  RtspHandler() { }
+  ~RtspHandler() { }
+  const static int32_t kDefaultRtspPort = 554;
+};
+
+} // namespace net
+} // namespace mozilla
+
+#endif // RtspHandler_h

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/controller/RtspController.cpp
@@ -0,0 +1,371 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "RtspController.h"
+#include "RtspMetaData.h"
+#include "nsIURI.h"
+#include "nsICryptoHash.h"
+#include "nsIRunnable.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsICancelable.h"
+#include "nsIStreamConverterService.h"
+#include "nsIIOService2.h"
+#include "nsIProtocolProxyService.h"
+#include "nsIProxyInfo.h"
+#include "nsIProxiedChannel.h"
+
+#include "nsAutoPtr.h"
+#include "nsStandardURL.h"
+#include "nsNetCID.h"
+#include "nsServiceManagerUtils.h"
+#include "nsXPIDLString.h"
+#include "nsCRT.h"
+#include "nsThreadUtils.h"
+#include "nsError.h"
+#include "nsStringStream.h"
+#include "nsAlgorithm.h"
+#include "nsProxyRelease.h"
+#include "nsNetUtil.h"
+#include "mozilla/Attributes.h"
+#include "TimeStamp.h"
+#include "mozilla/Telemetry.h"
+#include "prlog.h"
+
+#include "plbase64.h"
+#include "prmem.h"
+#include "prnetdb.h"
+#include "prbit.h"
+#include "zlib.h"
+#include <algorithm>
+#include "nsDebug.h"
+
+extern PRLogModuleInfo* gRtspLog;
+#undef LOG
+#define LOG(args) PR_LOG(gRtspLog, PR_LOG_DEBUG, args)
+
+namespace mozilla {
+namespace net {
+
+NS_IMPL_ISUPPORTS1(RtspController,
+                   nsIStreamingProtocolController)
+
+RtspController::RtspController(nsIChannel *channel)
+  : mState(INIT)
+{
+  LOG(("RtspController::RtspController()"));
+}
+
+RtspController::~RtspController()
+{
+  LOG(("RtspController::~RtspController()"));
+  if (mRtspSource.get()) {
+    mRtspSource.clear();
+  }
+}
+
+NS_IMETHODIMP
+RtspController::GetTrackMetaData(uint8_t index,
+                                 nsIStreamingProtocolMetaData * *_retval)
+{
+  LOG(("RtspController::GetTrackMetaData()"));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspController::Play(void)
+{
+  LOG(("RtspController::Play()"));
+  if (!mRtspSource.get()) {
+    MOZ_ASSERT(mRtspSource.get(), "mRtspSource should not be null!");
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  if (mState != CONNECTED) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  mRtspSource->play();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspController::Pause(void)
+{
+  LOG(("RtspController::Pause()"));
+  if (!mRtspSource.get()) {
+    MOZ_ASSERT(mRtspSource.get(), "mRtspSource should not be null!");
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  if (mState != CONNECTED) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  mRtspSource->pause();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspController::Resume(void)
+{
+  LOG(("RtspController::Resume()"));
+  if (!mRtspSource.get()) {
+    MOZ_ASSERT(mRtspSource.get(), "mRtspSource should not be null!");
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  if (mState != CONNECTED) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  mRtspSource->play();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspController::Suspend(void)
+{
+  LOG(("RtspController::Suspend()"));
+  if (!mRtspSource.get()) {
+    MOZ_ASSERT(mRtspSource.get(), "mRtspSource should not be null!");
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  if (mState != CONNECTED) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  mRtspSource->pause();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspController::Seek(uint64_t seekTimeUs)
+{
+  LOG(("RtspController::Seek() %llu", seekTimeUs));
+  if (!mRtspSource.get()) {
+    MOZ_ASSERT(mRtspSource.get(), "mRtspSource should not be null!");
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  if (mState != CONNECTED) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  mRtspSource->seek(seekTimeUs);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspController::Stop()
+{
+  LOG(("RtspController::Stop()"));
+  mState = INIT;
+  if (!mRtspSource.get()) {
+    MOZ_ASSERT(mRtspSource.get(), "mRtspSource should not be null!");
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  mRtspSource->stop();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspController::GetTotalTracks(uint8_t *aTracks)
+{
+  LOG(("RtspController::GetTotalTracks()"));
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+RtspController::AsyncOpen(nsIStreamingProtocolListener *aListener)
+{
+  if (!aListener) {
+    LOG(("RtspController::AsyncOpen() illegal listener"));
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  mListener = aListener;
+
+  if (!mURI) {
+    LOG(("RtspController::AsyncOpen() illegal URI"));
+    return NS_ERROR_ILLEGAL_VALUE;
+  }
+
+  nsAutoCString uriSpec;
+  mURI->GetSpec(uriSpec);
+  LOG(("RtspController AsyncOpen uri=%s", uriSpec.get()));
+
+  if (!mRtspSource.get()) {
+    mRtspSource = new android::RTSPSource(this, uriSpec.get(), false, 0);
+  }
+  // Connect to Rtsp Server.
+  mRtspSource->start();
+
+  return NS_OK;
+}
+
+class SendMediaDataTask : public nsRunnable
+{
+public:
+  SendMediaDataTask(nsIStreamingProtocolListener *listener,
+                    uint8_t index,
+                    const nsACString & data,
+                    uint32_t length,
+                    uint32_t offset,
+                    nsIStreamingProtocolMetaData *meta)
+    : mIndex(index)
+    , mLength(length)
+    , mOffset(offset)
+    , mMetaData(meta)
+    , mListener(listener)
+  {
+    mData.Assign(data);
+  }
+
+  NS_IMETHOD Run()
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+    mListener->OnMediaDataAvailable(mIndex, mData, mLength,
+                                    mOffset, mMetaData);
+    return NS_OK;
+  }
+
+private:
+  uint8_t mIndex;
+  nsCString mData;
+  uint32_t mLength;
+  uint32_t mOffset;
+  nsRefPtr<nsIStreamingProtocolMetaData> mMetaData;
+  nsCOMPtr<nsIStreamingProtocolListener> mListener;
+};
+
+NS_IMETHODIMP
+RtspController::OnMediaDataAvailable(uint8_t index,
+                                     const nsACString & data,
+                                     uint32_t length,
+                                     uint32_t offset,
+                                     nsIStreamingProtocolMetaData *meta)
+{
+  if (mListener && mState == CONNECTED) {
+    nsRefPtr<SendMediaDataTask> task =
+      new SendMediaDataTask(mListener, index, data, length, offset, meta);
+    return NS_DispatchToMainThread(task);
+  }
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+class SendOnConnectedTask : public nsRunnable
+{
+public:
+  SendOnConnectedTask(nsIStreamingProtocolListener *listener,
+                      uint8_t index,
+                      nsIStreamingProtocolMetaData *meta)
+    : mListener(listener)
+    , mIndex(index)
+    , mMetaData(meta)
+  { }
+
+  NS_IMETHOD Run()
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+    mListener->OnConnected(mIndex, mMetaData);
+    return NS_OK;
+  }
+
+private:
+  nsCOMPtr<nsIStreamingProtocolListener> mListener;
+  uint8_t mIndex;
+  nsRefPtr<nsIStreamingProtocolMetaData> mMetaData;
+};
+
+
+NS_IMETHODIMP
+RtspController::OnConnected(uint8_t index,
+                            nsIStreamingProtocolMetaData *meta)
+{
+  LOG(("RtspController::OnConnected()"));
+  mState = CONNECTED;
+  if (mListener) {
+    nsRefPtr<SendOnConnectedTask> task =
+      new SendOnConnectedTask(mListener, index, meta);
+    return NS_DispatchToMainThread(task);
+  }
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+class SendOnDisconnectedTask : public nsRunnable
+{
+public:
+  SendOnDisconnectedTask(nsIStreamingProtocolListener *listener,
+                         uint8_t index,
+                         uint32_t reason)
+    : mListener(listener)
+    , mIndex(index)
+    , mReason(reason)
+  { }
+
+  NS_IMETHOD Run()
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+    mListener->OnDisconnected(mIndex, mReason);
+    return NS_OK;
+  }
+
+private:
+  nsCOMPtr<nsIStreamingProtocolListener> mListener;
+  uint8_t mIndex;
+  uint32_t mReason;
+};
+
+NS_IMETHODIMP
+RtspController::OnDisconnected(uint8_t index,
+                               uint32_t reason)
+{
+  LOG(("RtspController::OnDisconnected()"));
+  mState = DISCONNECTED;
+  if (mListener) {
+    nsRefPtr<SendOnDisconnectedTask> task =
+      new SendOnDisconnectedTask(mListener, index, reason);
+    return NS_DispatchToMainThread(task);
+  }
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+RtspController::Init(nsIURI *aURI)
+{
+  nsresult rv;
+
+  if (!aURI) {
+    LOG(("RtspController::Init() - invalid URI"));
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  nsAutoCString host;
+  int32_t port = -1;
+
+  rv = aURI->GetAsciiHost(host);
+  if (NS_FAILED(rv)) return rv;
+
+  // Reject the URL if it doesn't specify a host
+  if (host.IsEmpty())
+    return NS_ERROR_MALFORMED_URI;
+
+  rv = aURI->GetPort(&port);
+  if (NS_FAILED(rv)) return rv;
+
+  rv = aURI->GetAsciiSpec(mSpec);
+  if (NS_FAILED(rv)) return rv;
+
+  mURI = aURI;
+
+  return NS_OK;
+}
+
+} // namespace mozilla::net
+} // namespace mozilla

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/controller/RtspController.h
@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef RtspController_h
+#define RtspController_h
+
+#include "nsIStreamingProtocolController.h"
+#include "nsIChannel.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "RTSPSource.h"
+
+namespace mozilla {
+namespace net {
+
+class RtspController : public nsIStreamingProtocolController
+                     , public nsIStreamingProtocolListener
+{
+public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSISTREAMINGPROTOCOLCONTROLLER
+  NS_DECL_NSISTREAMINGPROTOCOLLISTENER
+
+  RtspController(nsIChannel *channel);
+  ~RtspController();
+
+private:
+  enum State {
+    INIT,
+    CONNECTED,
+    DISCONNECTED
+  };
+
+  // RTSP URL refer to a stream or an aggregate of streams.
+  nsCOMPtr<nsIURI> mURI;
+  // The nsIStreamingProtocolListener implementation.
+  nsCOMPtr<nsIStreamingProtocolListener> mListener;
+  // ASCII encoded URL spec.
+  nsCString mSpec;
+  // Indicate the connection state between the
+  // media streaming server and the Rtsp client.
+  State mState;
+  // Rtsp Streaming source.
+  android::sp<android::RTSPSource> mRtspSource;
+};
+
+}
+} // namespace mozilla::net
+#endif

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/controller/RtspControllerChild.cpp
@@ -0,0 +1,466 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "RtspControllerChild.h"
+#include "RtspMetaData.h"
+#include "mozilla/dom/TabChild.h"
+#include "mozilla/net/NeckoChild.h"
+#include "nsITabChild.h"
+#include "nsILoadContext.h"
+#include "nsNetUtil.h"
+#include "mozilla/ipc/InputStreamUtils.h"
+#include "mozilla/ipc/URIUtils.h"
+#include "nsStringStream.h"
+#include "prlog.h"
+
+PRLogModuleInfo* gRtspChildLog = nullptr;
+#undef LOG
+#define LOG(args) PR_LOG(gRtspChildLog, PR_LOG_DEBUG, args)
+
+const uint32_t kRtspTotalTracks = 2;
+using namespace mozilla::ipc;
+
+namespace mozilla {
+namespace net {
+
+NS_IMPL_ADDREF(RtspControllerChild)
+
+NS_IMETHODIMP_(nsrefcnt) RtspControllerChild::Release()
+{
+  NS_PRECONDITION(0 != mRefCnt, "dup release");
+  // Enable this to find non-threadsafe destructors:
+  // NS_ASSERT_OWNINGTHREAD(RtspControllerChild);
+  --mRefCnt;
+  NS_LOG_RELEASE(this, mRefCnt, "RtspControllerChild");
+
+  if (mRefCnt == 1 && mIPCOpen) {
+    Send__delete__(this);
+    return mRefCnt;
+  }
+
+  if (mRefCnt == 0) {
+    mRefCnt = 1; /* stabilize */
+    delete this;
+    return 0;
+  }
+  return mRefCnt;
+}
+
+NS_INTERFACE_MAP_BEGIN(RtspControllerChild)
+  NS_INTERFACE_MAP_ENTRY(nsIStreamingProtocolController)
+  NS_INTERFACE_MAP_ENTRY(nsIStreamingProtocolListener)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIStreamingProtocolController)
+NS_INTERFACE_MAP_END
+
+RtspControllerChild::RtspControllerChild(nsIChannel *channel)
+  : mIPCOpen(false)
+  , mChannel(channel)
+  , mTotalTracks(0)
+  , mSuspendCount(0)
+{
+#if defined(PR_LOGGING)
+  if (!gRtspChildLog)
+    gRtspChildLog = PR_NewLogModule("nsRtspChild");
+#endif
+  AddIPDLReference();
+  gNeckoChild->SendPRtspControllerConstructor(this);
+}
+
+RtspControllerChild::~RtspControllerChild()
+{
+  LOG(("RtspControllerChild::~RtspControllerChild()"));
+}
+
+bool
+RtspControllerChild::RecvOnMediaDataAvailable(
+                       const uint8_t& index,
+                       const nsCString& data,
+                       const uint32_t& length,
+                       const uint32_t& offset,
+                       const InfallibleTArray<RtspMetadataParam>& metaArray)
+{
+  nsRefPtr<RtspMetaData> meta = new RtspMetaData();
+  nsresult rv = meta->DeserializeRtspMetaData(metaArray);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  if (mListener) {
+    mListener->OnMediaDataAvailable(index, data, length, offset, meta.get());
+  }
+  return true;
+}
+
+void
+RtspControllerChild::AddMetaData(
+                       already_AddRefed<nsIStreamingProtocolMetaData> meta)
+{
+  mMetaArray.AppendElement(meta);
+}
+
+int
+RtspControllerChild::GetMetaDataLength()
+{
+  return mMetaArray.Length();
+}
+
+bool
+RtspControllerChild::RecvOnConnected(
+                       const uint8_t& index,
+                       const InfallibleTArray<RtspMetadataParam>& metaArray)
+{
+  uint32_t tracks;
+
+  // Deserialize meta data.
+  nsRefPtr<RtspMetaData> meta = new RtspMetaData();
+  nsresult rv = meta->DeserializeRtspMetaData(metaArray);
+  NS_ENSURE_SUCCESS(rv, false);
+  meta->GetTotalTracks(&tracks);
+  if (tracks <= 0) {
+    LOG(("RtspControllerChild::RecvOnConnected invalid tracks %d", tracks));
+    // Set the default value.
+    tracks = kRtspTotalTracks;
+  }
+  mTotalTracks = tracks;
+  AddMetaData(meta.forget());
+
+  // Notify the listener when meta data of tracks are available.
+  if ((index + 1) == tracks) {
+    // The controller provide |GetTrackMetaData| method for his client.
+    if (mListener) {
+      mListener->OnConnected(index, nullptr);
+    }
+  }
+  return true;
+}
+
+bool
+RtspControllerChild::RecvOnDisconnected(
+                       const uint8_t& index,
+                       const uint32_t& reason)
+{
+  LOG(("RtspControllerChild::RecvOnDisconnected %d %d", index, reason));
+  if (mListener) {
+    mListener->OnDisconnected(index, reason);
+  }
+  return true;
+}
+
+bool
+RtspControllerChild::RecvAsyncOpenFailed(const uint8_t& reason)
+{
+  LOG(("RtspControllerChild::RecvAsyncOpenFailed %d", reason));
+  if (mListener) {
+    mListener->OnDisconnected(0, NS_ERROR_CONNECTION_REFUSED);
+  }
+  return true;
+}
+
+void
+RtspControllerChild::AddIPDLReference()
+{
+  NS_ABORT_IF_FALSE(!mIPCOpen,
+                    "Attempt to retain more than one IPDL reference");
+  mIPCOpen = true;
+  AddRef();
+}
+
+void
+RtspControllerChild::ReleaseIPDLReference()
+{
+  NS_ABORT_IF_FALSE(mIPCOpen, "Attempt to release nonexistent IPDL reference");
+  mIPCOpen = false;
+  Release();
+}
+
+NS_IMETHODIMP
+RtspControllerChild::GetTrackMetaData(
+                       uint8_t index,
+                       nsIStreamingProtocolMetaData **result)
+{
+  if (GetMetaDataLength() <= 0 || index >= GetMetaDataLength()) {
+    LOG(("RtspControllerChild:: meta data is not available"));
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+  LOG(("RtspControllerChild::GetTrackMetaData() %d", index));
+  NS_IF_ADDREF(*result = mMetaArray[index]);
+  return NS_OK;
+}
+
+enum IPCEvent
+{
+  SendNoneEvent = 0,
+  SendPlayEvent,
+  SendPauseEvent,
+  SendSeekEvent,
+  SendResumeEvent,
+  SendSuspendEvent,
+  SendStopEvent
+};
+
+class SendIPCEvent : public nsRunnable
+{
+public:
+  SendIPCEvent(RtspControllerChild *aController, IPCEvent aEvent)
+    : mController(aController)
+    , mEvent(aEvent)
+    , mSeekTime(0)
+  {
+  }
+
+  SendIPCEvent(RtspControllerChild *aController,
+               IPCEvent aEvent,
+               uint64_t aSeekTime)
+    : mController(aController)
+    , mEvent(aEvent)
+    , mSeekTime(aSeekTime)
+  {
+  }
+
+  NS_IMETHOD Run()
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    if (mEvent == SendPlayEvent) {
+      mController->SendPlay();
+    } else if (mEvent == SendPauseEvent) {
+      mController->SendPause();
+    } else if (mEvent == SendSeekEvent) {
+      mController->SendSeek(mSeekTime);
+    } else if (mEvent == SendResumeEvent) {
+      mController->SendResume();
+    } else if (mEvent == SendSuspendEvent) {
+      mController->SendSuspend();
+    } else if (mEvent == SendStopEvent) {
+      mController->SendStop();
+    } else {
+      LOG(("RtspControllerChild::SendIPCEvent"));
+    }
+    return NS_OK;
+  }
+private:
+  nsRefPtr<RtspControllerChild> mController;
+  IPCEvent mEvent;
+  uint64_t mSeekTime;
+};
+
+NS_IMETHODIMP
+RtspControllerChild::Play(void)
+{
+  LOG(("RtspControllerChild::Play()"));
+  NS_ENSURE_SUCCESS(mIPCOpen, NS_ERROR_FAILURE);
+
+  if (NS_IsMainThread()) {
+    if (!SendPlay())
+      return NS_ERROR_FAILURE;
+  } else {
+    nsresult rv = NS_DispatchToMainThread(
+                    new SendIPCEvent(this, SendPlayEvent));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspControllerChild::Pause(void)
+{
+  LOG(("RtspControllerChild::Pause()"));
+  NS_ENSURE_SUCCESS(mIPCOpen, NS_ERROR_FAILURE);
+
+  if (NS_IsMainThread()) {
+    if (!SendPause())
+      return NS_ERROR_FAILURE;
+  } else {
+    nsresult rv = NS_DispatchToMainThread(
+                    new SendIPCEvent(this, SendPauseEvent));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspControllerChild::Resume(void)
+{
+  LOG(("RtspControllerChild::Resume()"));
+  NS_ENSURE_SUCCESS(mIPCOpen, NS_ERROR_FAILURE);
+  NS_ENSURE_TRUE(mSuspendCount > 0, NS_ERROR_UNEXPECTED);
+
+  if (!--mSuspendCount) {
+    if (NS_IsMainThread()) {
+      if (!SendResume())
+        return NS_ERROR_FAILURE;
+    } else {
+      nsresult rv = NS_DispatchToMainThread(
+                      new SendIPCEvent(this, SendResumeEvent));
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspControllerChild::Suspend(void)
+{
+  LOG(("RtspControllerChild::Suspend()"));
+  NS_ENSURE_SUCCESS(mIPCOpen, NS_ERROR_FAILURE);
+
+  if (!mSuspendCount++) {
+    if (NS_IsMainThread()) {
+      if (!SendSuspend())
+        return NS_ERROR_FAILURE;
+    } else {
+      nsresult rv = NS_DispatchToMainThread(
+                      new SendIPCEvent(this, SendSuspendEvent));
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspControllerChild::Seek(uint64_t seekTimeUs)
+{
+  LOG(("RtspControllerChild::Seek() %llu", seekTimeUs));
+  NS_ENSURE_SUCCESS(mIPCOpen, NS_ERROR_FAILURE);
+
+  if (NS_IsMainThread()) {
+    if (!SendSeek(seekTimeUs))
+      return NS_ERROR_FAILURE;
+  } else {
+    nsresult rv = NS_DispatchToMainThread(
+                    new SendIPCEvent(this, SendSeekEvent, seekTimeUs));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspControllerChild::Stop()
+{
+  LOG(("RtspControllerChild::Stop()"));
+  NS_ENSURE_SUCCESS(mIPCOpen, NS_ERROR_FAILURE);
+
+  if (NS_IsMainThread()) {
+    if (!SendStop())
+      return NS_ERROR_FAILURE;
+  } else {
+    nsresult rv = NS_DispatchToMainThread(
+                    new SendIPCEvent(this, SendStopEvent));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspControllerChild::GetTotalTracks(uint8_t *aTracks)
+{
+  NS_ENSURE_ARG_POINTER(aTracks);
+  *aTracks = kRtspTotalTracks;
+  if (mTotalTracks) {
+    *aTracks = mTotalTracks;
+  }
+  LOG(("RtspControllerChild::GetTracks() %d", *aTracks));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspControllerChild::OnMediaDataAvailable(uint8_t index,
+                                          const nsACString & data,
+                                          uint32_t length,
+                                          uint32_t offset,
+                                          nsIStreamingProtocolMetaData *meta)
+{
+  LOG(("RtspControllerChild::OnMediaDataAvailable()"));
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+RtspControllerChild::OnConnected(uint8_t index,
+                                 nsIStreamingProtocolMetaData *meta)
+
+{
+  LOG(("RtspControllerChild::OnConnected()"));
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+RtspControllerChild::OnDisconnected(uint8_t index,
+                                    uint32_t reason)
+{
+  LOG(("RtspControllerChild::OnDisconnected()"));
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+RtspControllerChild::Init(nsIURI *aURI)
+{
+  nsresult rv;
+
+  if (!aURI) {
+    LOG(("RtspControllerChild::Init() - invalid URI"));
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  nsAutoCString host;
+  int32_t port = -1;
+
+  rv = aURI->GetAsciiHost(host);
+  if (NS_FAILED(rv)) return rv;
+
+  // Reject the URL if it doesn't specify a host
+  if (host.IsEmpty())
+    return NS_ERROR_MALFORMED_URI;
+
+  rv = aURI->GetPort(&port);
+  if (NS_FAILED(rv)) return rv;
+
+  rv = aURI->GetAsciiSpec(mSpec);
+  if (NS_FAILED(rv)) return rv;
+
+  if (!strncmp(mSpec.get(), "rtsp:", 5) == 0)
+    return NS_ERROR_UNEXPECTED;
+
+  mURI = aURI;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspControllerChild::AsyncOpen(nsIStreamingProtocolListener *aListener)
+{
+  LOG(("RtspControllerChild::AsyncOpen()"));
+  if (!aListener) {
+    LOG(("RtspControllerChild::AsyncOpen() - invalid listener"));
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+  mListener = aListener;
+
+  if (!mChannel) {
+    LOG(("RtspControllerChild::AsyncOpen() - invalid URI"));
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  nsCOMPtr<nsIURI> uri;
+  URIParams uriParams;
+  mChannel->GetURI(getter_AddRefs(uri));
+  if (!uri) {
+    LOG(("RtspControllerChild::AsyncOpen() - invalid URI"));
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+  SerializeURI(uri, uriParams);
+
+  if (!mIPCOpen || !SendAsyncOpen(uriParams)) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+} // namespace net
+} // namespace mozilla

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/controller/RtspControllerChild.h
@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef RtspControllerChild_h
+#define RtspControllerChild_h
+
+#include "mozilla/net/PRtspControllerChild.h"
+#include "nsIStreamingProtocolController.h"
+#include "nsIChannel.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "nsTArray.h"
+
+namespace mozilla {
+namespace net {
+
+class RtspControllerChild : public nsIStreamingProtocolController
+                          , public nsIStreamingProtocolListener
+                          , public PRtspControllerChild
+{
+ public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSISTREAMINGPROTOCOLCONTROLLER
+  NS_DECL_NSISTREAMINGPROTOCOLLISTENER
+
+  RtspControllerChild(nsIChannel *channel);
+  ~RtspControllerChild();
+
+  bool RecvOnConnected(const uint8_t& index,
+                       const InfallibleTArray<RtspMetadataParam>& meta);
+
+  bool RecvOnMediaDataAvailable(
+         const uint8_t& index,
+         const nsCString& data,
+         const uint32_t& length,
+         const uint32_t& offset,
+         const InfallibleTArray<RtspMetadataParam>& meta);
+
+  bool RecvOnDisconnected(const uint8_t& index,
+                          const uint32_t& reason);
+
+  bool RecvAsyncOpenFailed(const uint8_t& reason);
+  void AddIPDLReference();
+  void ReleaseIPDLReference();
+  void AddMetaData(already_AddRefed<nsIStreamingProtocolMetaData> meta);
+  int  GetMetaDataLength();
+
+ private:
+  bool mIPCOpen;
+  // Dummy channel used to aid MediaResource creation in HTMLMediaElement.
+  nsCOMPtr<nsIChannel> mChannel;
+  // The nsIStreamingProtocolListener implementation.
+  nsCOMPtr<nsIStreamingProtocolListener> mListener;
+  // RTSP URL refer to a stream or an aggregate of streams.
+  nsCOMPtr<nsIURI> mURI;
+  // Array refer to metadata of the media stream.
+  nsTArray<nsCOMPtr<nsIStreamingProtocolMetaData>> mMetaArray;
+  // ASCII encoded URL spec
+  nsCString mSpec;
+  // The total tracks for the given media stream session.
+  uint32_t mTotalTracks;
+  // Current suspension depth for this channel object
+  uint32_t mSuspendCount;
+};
+} // namespace net
+} // namespace mozilla
+
+#endif // RtspControllerChild_h

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/controller/RtspControllerParent.cpp
@@ -0,0 +1,264 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "RtspControllerParent.h"
+#include "RtspController.h"
+#include "nsIAuthPromptProvider.h"
+#include "mozilla/ipc/InputStreamUtils.h"
+#include "mozilla/ipc/URIUtils.h"
+#include "nsNetUtil.h"
+#include "prlog.h"
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+PRLogModuleInfo* gRtspLog;
+#undef LOG
+#define LOG(args) PR_LOG(gRtspLog, PR_LOG_DEBUG, args)
+
+using namespace mozilla::ipc;
+
+namespace mozilla {
+namespace net {
+
+NS_IMPL_ISUPPORTS2(RtspControllerParent,
+                   nsIInterfaceRequestor,
+                   nsIStreamingProtocolListener)
+
+RtspControllerParent::RtspControllerParent()
+  : mIPCOpen(true)
+{
+#if defined(PR_LOGGING)
+  if (!gRtspLog)
+    gRtspLog = PR_NewLogModule("nsRtsp");
+#endif
+}
+
+RtspControllerParent::~RtspControllerParent()
+{
+}
+
+void
+RtspControllerParent::ActorDestroy(ActorDestroyReason why)
+{
+  LOG(("RtspControllerParent::ActorDestroy()"));
+  mIPCOpen = false;
+
+  NS_ENSURE_TRUE_VOID(mController);
+  mController->Stop();
+  mController = nullptr;
+}
+
+bool
+RtspControllerParent::RecvAsyncOpen(const URIParams& aURI)
+{
+  LOG(("RtspControllerParent::RecvAsyncOpen()"));
+
+  mURI = DeserializeURI(aURI);
+
+  mController = new RtspController(nullptr);
+  mController->Init(mURI);
+  nsresult rv = mController->AsyncOpen(this);
+  if (NS_SUCCEEDED(rv)) return true;
+
+  mController = nullptr;
+  return SendAsyncOpenFailed(rv);
+}
+
+bool
+RtspControllerParent::RecvPlay()
+{
+  LOG(("RtspControllerParent::RecvPlay()"));
+  NS_ENSURE_TRUE(mController, NS_ERROR_NOT_INITIALIZED);
+
+  nsresult rv = mController->Play();
+  NS_ENSURE_SUCCESS(rv, false);
+  return true;
+}
+
+bool
+RtspControllerParent::RecvPause()
+{
+  LOG(("RtspControllerParent::RecvPause()"));
+  NS_ENSURE_TRUE(mController, NS_ERROR_NOT_INITIALIZED);
+
+  nsresult rv = mController->Pause();
+  NS_ENSURE_SUCCESS(rv, false);
+  return true;
+}
+
+bool
+RtspControllerParent::RecvResume()
+{
+  LOG(("RtspControllerParent::RecvResume()"));
+  NS_ENSURE_TRUE(mController, NS_ERROR_NOT_INITIALIZED);
+
+  nsresult rv = mController->Resume();
+  NS_ENSURE_SUCCESS(rv, false);
+  return true;
+}
+
+bool
+RtspControllerParent::RecvSuspend()
+{
+  LOG(("RtspControllerParent::RecvSuspend()"));
+  NS_ENSURE_TRUE(mController, NS_ERROR_NOT_INITIALIZED);
+
+  nsresult rv = mController->Suspend();
+  NS_ENSURE_SUCCESS(rv, false);
+  return true;
+}
+
+bool
+RtspControllerParent::RecvSeek(const uint64_t& offset)
+{
+  LOG(("RtspControllerParent::RecvSeek()"));
+  NS_ENSURE_TRUE(mController, NS_ERROR_NOT_INITIALIZED);
+
+  nsresult rv = mController->Seek(offset);
+  NS_ENSURE_SUCCESS(rv, false);
+  return true;
+}
+
+bool
+RtspControllerParent::RecvStop()
+{
+  LOG(("RtspControllerParent::RecvStop()"));
+  NS_ENSURE_TRUE(mController, NS_ERROR_NOT_INITIALIZED);
+
+  nsresult rv = mController->Stop();
+  NS_ENSURE_SUCCESS(rv, false);
+  return true;
+}
+
+NS_IMETHODIMP
+RtspControllerParent::OnMediaDataAvailable(uint8_t index,
+                                           const nsACString & data,
+                                           uint32_t length,
+                                           uint32_t offset,
+                                           nsIStreamingProtocolMetaData *meta)
+{
+  NS_ENSURE_ARG_POINTER(meta);
+  uint32_t int32Value;
+  uint64_t int64Value;
+
+  LOG(("RtspControllerParent:: OnMediaDataAvailable %d:%d time %lld",
+       index, length, int64Value));
+
+  // Serialize meta data.
+  nsCString name;
+  name.AssignLiteral("TIMESTAMP");
+  nsresult rv = meta->GetTimeStamp(&int64Value);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+  InfallibleTArray<RtspMetadataParam> metaData;
+  metaData.AppendElement(RtspMetadataParam(name, int64Value));
+
+  name.AssignLiteral("FRAMETYPE");
+  rv = meta->GetFrameType(&int32Value);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+  metaData.AppendElement(RtspMetadataParam(name, int32Value));
+
+  nsCString stream;
+  stream.Assign(data);
+  if (!mIPCOpen ||
+      !SendOnMediaDataAvailable(index, stream, length, offset, metaData)) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspControllerParent::OnConnected(uint8_t index,
+                                  nsIStreamingProtocolMetaData *meta)
+{
+  NS_ENSURE_ARG_POINTER(meta);
+  uint32_t int32Value;
+  uint64_t int64Value;
+
+  LOG(("RtspControllerParent:: OnConnected"));
+  // Serialize meta data.
+  InfallibleTArray<RtspMetadataParam> metaData;
+  nsCString name;
+  name.AssignLiteral("TRACKS");
+  nsresult rv = meta->GetTotalTracks(&int32Value);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+  metaData.AppendElement(RtspMetadataParam(name, int32Value));
+
+  name.AssignLiteral("MIMETYPE");
+  nsCString mimeType;
+  rv = meta->GetMimeType(mimeType);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+  metaData.AppendElement(RtspMetadataParam(name, mimeType));
+
+  name.AssignLiteral("WIDTH");
+  rv = meta->GetWidth(&int32Value);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+  metaData.AppendElement(RtspMetadataParam(name, int32Value));
+
+  name.AssignLiteral("HEIGHT");
+  rv = meta->GetHeight(&int32Value);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+  metaData.AppendElement(RtspMetadataParam(name, int32Value));
+
+  name.AssignLiteral("DURATION");
+  rv = meta->GetDuration(&int64Value);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+  metaData.AppendElement(RtspMetadataParam(name, int64Value));
+
+  name.AssignLiteral("SAMPLERATE");
+  rv = meta->GetSampleRate(&int32Value);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+  metaData.AppendElement(RtspMetadataParam(name, int32Value));
+
+  name.AssignLiteral("TIMESTAMP");
+  rv = meta->GetTimeStamp(&int64Value);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+  metaData.AppendElement(RtspMetadataParam(name, int64Value));
+
+  name.AssignLiteral("CHANNELCOUNT");
+  rv = meta->GetChannelCount(&int32Value);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+  metaData.AppendElement(RtspMetadataParam(name, int32Value));
+
+  nsCString esds;
+  rv = meta->GetEsdsData(esds);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+  name.AssignLiteral("ESDS");
+  metaData.AppendElement(RtspMetadataParam(name, esds));
+
+  nsCString avcc;
+  rv = meta->GetAvccData(avcc);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+  name.AssignLiteral("AVCC");
+  metaData.AppendElement(RtspMetadataParam(name, avcc));
+
+  if (!mIPCOpen || !SendOnConnected(index, metaData)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspControllerParent::OnDisconnected(uint8_t index,
+                                     uint32_t reason)
+{
+  LOG(("RtspControllerParent::OnDisconnected()"));
+  if (!mIPCOpen || !SendOnDisconnected(index, reason)) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspControllerParent::GetInterface(const nsIID & iid, void **result)
+{
+  LOG(("RtspControllerParent::GetInterface()"));
+  return QueryInterface(iid, result);
+}
+
+} // namespace net
+} // namespace mozilla

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/controller/RtspControllerParent.h
@@ -0,0 +1,55 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef RtspControllerParent_h
+#define RtspControllerParent_h
+
+#include "mozilla/net/PRtspControllerParent.h"
+#include "mozilla/net/NeckoParent.h"
+#include "nsIStreamingProtocolController.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsILoadContext.h"
+#include "nsIURI.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+class nsIAuthPromptProvider;
+
+namespace mozilla {
+namespace net {
+
+class RtspControllerParent : public PRtspControllerParent
+                           , public nsIInterfaceRequestor
+                           , public nsIStreamingProtocolListener
+{
+ public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIINTERFACEREQUESTOR
+  NS_DECL_NSISTREAMINGPROTOCOLLISTENER
+
+  RtspControllerParent();
+  ~RtspControllerParent();
+
+  bool RecvAsyncOpen(const URIParams& aURI);
+  bool RecvPlay();
+  bool RecvPause();
+  bool RecvResume();
+  bool RecvSuspend();
+  bool RecvSeek(const uint64_t& offset);
+  bool RecvStop();
+
+ private:
+  bool mIPCOpen;
+  void ActorDestroy(ActorDestroyReason why);
+  // RTSP URL refer to a stream or an aggregate of streams.
+  nsCOMPtr<nsIURI> mURI;
+  // The nsIStreamingProtocolController implementation.
+  nsCOMPtr<nsIStreamingProtocolController> mController;
+};
+
+} // namespace net
+} // namespace mozilla
+#endif // RtspControllerParent_h

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/controller/RtspMetaData.cpp
@@ -0,0 +1,249 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "RtspMetaData.h"
+#include "prlog.h"
+
+using namespace mozilla;
+
+namespace mozilla {
+namespace net {
+
+NS_IMPL_ISUPPORTS1(RtspMetaData, nsIStreamingProtocolMetaData)
+
+RtspMetaData::RtspMetaData()
+ : mIndex(0)
+ , mWidth(0)
+ , mHeight(0)
+ , mDuration(0)
+ , mSampleRate(0)
+ , mCurrentTimeStamp(0)
+ , mChannelCount(0)
+{
+  mMimeType.AssignLiteral("NONE");
+}
+
+RtspMetaData::~RtspMetaData()
+{
+
+}
+
+nsresult
+RtspMetaData::DeserializeRtspMetaData(const InfallibleTArray<RtspMetadataParam>& metaArray)
+{
+  nsresult rv;
+
+  // Deserialize meta data.
+  for (uint32_t i = 0; i < metaArray.Length(); i++) {
+    const RtspMetaValue& value = metaArray[i].value();
+    const nsCString& name = metaArray[i].name();
+
+    if (name.EqualsLiteral("FRAMETYPE")) {
+      rv = SetFrameType(value);
+      NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+    } else if (name.EqualsLiteral("TIMESTAMP")) {
+      rv = SetTimeStamp(value);
+      NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+    } else if (name.EqualsLiteral("TRACKS")) {
+      rv = SetTotalTracks(value);
+      NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+    } else if(name.EqualsLiteral("MIMETYPE")) {
+      rv = SetMimeType(value);
+      NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+    } else if (name.EqualsLiteral("WIDTH")) {
+      rv = SetWidth(value);
+      NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+    } else if (name.EqualsLiteral("HEIGHT")) {
+      rv = SetHeight(value);
+      NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+    } else if (name.EqualsLiteral("SAMPLERATE")) {
+      rv = SetSampleRate(value);
+      NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+    } else if(name.EqualsLiteral("DURATION")) {
+      rv = SetDuration(value);
+      NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+    } else if (name.EqualsLiteral("CHANNELCOUNT")) {
+      rv = SetChannelCount(value);
+      NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+    } else if (name.EqualsLiteral("ESDS")) {
+      rv = SetEsdsData(value);
+      NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+    } else if (name.EqualsLiteral("AVCC")) {
+      rv = SetAvccData(value);
+      NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::GetFrameType(uint32_t *aFrameType)
+{
+  NS_ENSURE_ARG_POINTER(aFrameType);
+  *aFrameType = mFrameType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::SetFrameType(uint32_t aFrameType)
+{
+  mFrameType = aFrameType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::GetTotalTracks(uint32_t *aTracks)
+{
+  NS_ENSURE_ARG_POINTER(aTracks);
+  *aTracks = mTotalTracks;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::SetTotalTracks(uint32_t aTracks)
+{
+  mTotalTracks = aTracks;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::GetMimeType(nsACString & aMimeType)
+{
+  aMimeType.Assign(mMimeType);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::SetMimeType(const nsACString & aMimeType)
+{
+  mMimeType.Assign(aMimeType);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::GetWidth(uint32_t *aWidth)
+{
+  NS_ENSURE_ARG_POINTER(aWidth);
+  *aWidth = mWidth;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::SetWidth(uint32_t aWidth)
+{
+  mWidth = aWidth;
+  return NS_OK;
+}
+
+/* attribute unsigned long height; */
+NS_IMETHODIMP
+RtspMetaData::GetHeight(uint32_t *aHeight)
+{
+  NS_ENSURE_ARG_POINTER(aHeight);
+  *aHeight = mHeight;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::SetHeight(uint32_t aHeight)
+{
+  mHeight = aHeight;
+  return NS_OK;
+}
+
+/* attribute unsigned long long duration; */
+NS_IMETHODIMP
+RtspMetaData::GetDuration(uint64_t *aDuration)
+{
+  NS_ENSURE_ARG_POINTER(aDuration);
+  *aDuration = mDuration;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::SetDuration(uint64_t aDuration)
+{
+  mDuration = aDuration;
+  return NS_OK;
+}
+
+/* attribute unsigned long sampleRate; */
+NS_IMETHODIMP
+RtspMetaData::GetSampleRate(uint32_t *aSampleRate)
+{
+  NS_ENSURE_ARG_POINTER(aSampleRate);
+  *aSampleRate = mSampleRate;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::SetSampleRate(uint32_t aSampleRate)
+{
+  mSampleRate = aSampleRate;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::GetTimeStamp(uint64_t *aTimeStamp)
+{
+  NS_ENSURE_ARG_POINTER(aTimeStamp);
+  *aTimeStamp = mCurrentTimeStamp;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::SetTimeStamp(uint64_t aTimeStamp)
+{
+  mCurrentTimeStamp = aTimeStamp;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::GetChannelCount(uint32_t *aChannelCount)
+{
+  NS_ENSURE_ARG_POINTER(aChannelCount);
+  *aChannelCount = mChannelCount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::SetChannelCount(uint32_t aChannelCount)
+{
+  mChannelCount = aChannelCount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::GetEsdsData(nsACString & aESDS)
+{
+  aESDS.Assign(mESDS);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::SetEsdsData(const nsACString & aESDS)
+{
+  mESDS.Assign(aESDS);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::GetAvccData(nsACString & aAVCC)
+{
+  aAVCC.Assign(mAVCC);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RtspMetaData::SetAvccData(const nsACString & aAVCC)
+{
+  mAVCC.Assign(aAVCC);
+  return NS_OK;
+}
+
+} // namespace mozilla::net
+} // namespace mozilla

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/controller/RtspMetaData.h
@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef RtspMetaData_h
+#define RtspMetaData_h
+
+#include "mozilla/net/PRtspController.h"
+#include "nsIStreamingProtocolController.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+namespace mozilla {
+namespace net {
+
+class RtspMetaData : public nsIStreamingProtocolMetaData
+{
+ public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSISTREAMINGPROTOCOLMETADATA
+
+  RtspMetaData();
+  ~RtspMetaData();
+
+  nsresult DeserializeRtspMetaData(const InfallibleTArray<RtspMetadataParam>& metaArray);
+
+ private:
+  uint32_t  mFrameType;
+  uint32_t  mIndex;
+  uint32_t  mTotalTracks;
+  uint32_t  mWidth;
+  uint32_t  mHeight;
+  uint64_t  mDuration;
+  uint32_t  mSampleRate;
+  uint64_t  mCurrentTimeStamp;
+  uint32_t  mChannelCount;
+  nsCString mMimeType;
+  nsCString mESDS;
+  nsCString mAVCC;
+};
+
+} // namespace net
+} // namespace mozilla
+
+#endif // RtspMetaData_h

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/moz.build
@@ -0,0 +1,49 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+XPIDL_MODULE = 'necko_rtsp'
+
+MODULE = 'necko'
+
+EXPORTS.mozilla.net += [
+    'RtspChannel.h',
+    'RtspHandler.h',
+    'controller/RtspController.h',
+    'controller/RtspControllerChild.h',
+    'controller/RtspControllerParent.h',
+    'controller/RtspMetaData.h',
+    'rtsp/RTSPSource.h',
+]
+
+CPP_SOURCES += [
+    'RtspChannel.cpp',
+    'RtspHandler.cpp',
+    'controller/RtspController.cpp',
+    'controller/RtspControllerChild.cpp',
+    'controller/RtspControllerParent.cpp',
+    'controller/RtspMetaData.cpp',
+    'rtsp/AAMRAssembler.cpp',
+    'rtsp/AAVCAssembler.cpp',
+    'rtsp/AH263Assembler.cpp',
+    'rtsp/AMPEG4AudioAssembler.cpp',
+    'rtsp/AMPEG4ElementaryAssembler.cpp',
+    'rtsp/APacketSource.cpp',
+    'rtsp/ARTPAssembler.cpp',
+    'rtsp/ARTPConnection.cpp',
+    'rtsp/ARTPSource.cpp',
+    'rtsp/ARTPWriter.cpp',
+    'rtsp/ARTSPConnection.cpp',
+    'rtsp/ARawAudioAssembler.cpp',
+    'rtsp/ASessionDescription.cpp',
+    'rtsp/RTSPSource.cpp',
+]
+
+FAIL_ON_WARNINGS = True
+
+LIBXUL_LIBRARY = True
+
+MSVC_ENABLE_PGO = True
+
+LIBRARY_NAME = 'nkrtsp_s'

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/rtsp/AAMRAssembler.cpp
@@ -0,0 +1,234 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "AAMRAssembler"
+#include <utils/Log.h>
+
+#include "AAMRAssembler.h"
+
+#include "ARTPSource.h"
+
+#include <media/stagefright/foundation/ABuffer.h>
+#include <media/stagefright/foundation/ADebug.h>
+#include <media/stagefright/foundation/AMessage.h>
+#include <media/stagefright/foundation/hexdump.h>
+#include <media/stagefright/Utils.h>
+
+namespace android {
+
+static bool GetAttribute(const char *s, const char *key, AString *value) {
+    value->clear();
+
+    size_t keyLen = strlen(key);
+
+    for (;;) {
+        const char *colonPos = strchr(s, ';');
+
+        size_t len =
+            (colonPos == NULL) ? strlen(s) : colonPos - s;
+
+        if (len >= keyLen + 1 && s[keyLen] == '=' && !strncmp(s, key, keyLen)) {
+            value->setTo(&s[keyLen + 1], len - keyLen - 1);
+            return true;
+        }
+        if (len == keyLen && !strncmp(s, key, keyLen)) {
+            value->setTo("1");
+            return true;
+        }
+
+        if (colonPos == NULL) {
+            return false;
+        }
+
+        s = colonPos + 1;
+    }
+}
+
+AAMRAssembler::AAMRAssembler(
+        const sp<AMessage> &notify, bool isWide, const AString &params)
+    : mIsWide(isWide),
+      mNotifyMsg(notify),
+      mNextExpectedSeqNoValid(false),
+      mNextExpectedSeqNo(0) {
+    AString value;
+    CHECK(GetAttribute(params.c_str(), "octet-align", &value) && value == "1");
+    CHECK(!GetAttribute(params.c_str(), "crc", &value) || value == "0");
+    CHECK(!GetAttribute(params.c_str(), "interleaving", &value));
+}
+
+AAMRAssembler::~AAMRAssembler() {
+}
+
+ARTPAssembler::AssemblyStatus AAMRAssembler::assembleMore(
+        const sp<ARTPSource> &source) {
+    return addPacket(source);
+}
+
+static size_t getFrameSize(bool isWide, unsigned FT) {
+    static const size_t kFrameSizeNB[9] = {
+        95, 103, 118, 134, 148, 159, 204, 244, 39
+    };
+    static const size_t kFrameSizeWB[10] = {
+        132, 177, 253, 285, 317, 365, 397, 461, 477, 40
+    };
+
+    if (FT == 15) {
+        return 1;
+    }
+
+    size_t frameSize = isWide ? kFrameSizeWB[FT] : kFrameSizeNB[FT];
+
+    // Round up bits to bytes and add 1 for the header byte.
+    frameSize = (frameSize + 7) / 8 + 1;
+
+    return frameSize;
+}
+
+ARTPAssembler::AssemblyStatus AAMRAssembler::addPacket(
+        const sp<ARTPSource> &source) {
+    List<sp<ABuffer> > *queue = source->queue();
+
+    if (queue->empty()) {
+        return NOT_ENOUGH_DATA;
+    }
+
+    if (mNextExpectedSeqNoValid) {
+        List<sp<ABuffer> >::iterator it = queue->begin();
+        while (it != queue->end()) {
+            if ((uint32_t)(*it)->int32Data() >= mNextExpectedSeqNo) {
+                break;
+            }
+
+            it = queue->erase(it);
+        }
+
+        if (queue->empty()) {
+            return NOT_ENOUGH_DATA;
+        }
+    }
+
+    sp<ABuffer> buffer = *queue->begin();
+
+    if (!mNextExpectedSeqNoValid) {
+        mNextExpectedSeqNoValid = true;
+        mNextExpectedSeqNo = (uint32_t)buffer->int32Data();
+    } else if ((uint32_t)buffer->int32Data() != mNextExpectedSeqNo) {
+        LOGV("Not the sequence number I expected");
+
+        return WRONG_SEQUENCE_NUMBER;
+    }
+
+    // hexdump(buffer->data(), buffer->size());
+
+    if (buffer->size() < 1) {
+        queue->erase(queue->begin());
+        ++mNextExpectedSeqNo;
+
+        LOGV("AMR packet too short.");
+
+        return MALFORMED_PACKET;
+    }
+
+    unsigned payloadHeader = buffer->data()[0];
+    unsigned CMR = payloadHeader >> 4;
+    CHECK_EQ(payloadHeader & 0x0f, 0u);  // RR
+
+    Vector<uint8_t> tableOfContents;
+
+    size_t offset = 1;
+    size_t totalSize = 0;
+    for (;;) {
+        if (offset >= buffer->size()) {
+            queue->erase(queue->begin());
+            ++mNextExpectedSeqNo;
+
+            LOGV("Unable to parse TOC.");
+
+            return MALFORMED_PACKET;
+        }
+
+        uint8_t toc = buffer->data()[offset++];
+
+        unsigned FT = (toc >> 3) & 0x0f;
+        if ((toc & 3) != 0
+                || (mIsWide && FT > 9 && FT != 15)
+                || (!mIsWide && FT > 8 && FT != 15)) {
+            queue->erase(queue->begin());
+            ++mNextExpectedSeqNo;
+
+            LOGV("Illegal TOC entry.");
+
+            return MALFORMED_PACKET;
+        }
+
+        totalSize += getFrameSize(mIsWide, (toc >> 3) & 0x0f);
+
+        tableOfContents.push(toc);
+
+        if (0 == (toc & 0x80)) {
+            break;
+        }
+    }
+
+    sp<ABuffer> accessUnit = new ABuffer(totalSize);
+    CopyTimes(accessUnit, buffer);
+
+    size_t dstOffset = 0;
+    for (size_t i = 0; i < tableOfContents.size(); ++i) {
+        uint8_t toc = tableOfContents[i];
+
+        size_t frameSize = getFrameSize(mIsWide, (toc >> 3) & 0x0f);
+
+        if (offset + frameSize - 1 > buffer->size()) {
+            queue->erase(queue->begin());
+            ++mNextExpectedSeqNo;
+
+            LOGV("AMR packet too short.");
+
+            return MALFORMED_PACKET;
+        }
+
+        accessUnit->data()[dstOffset++] = toc;
+        memcpy(accessUnit->data() + dstOffset,
+               buffer->data() + offset, frameSize - 1);
+
+        offset += frameSize - 1;
+        dstOffset += frameSize - 1;
+    }
+
+    sp<AMessage> msg = mNotifyMsg->dup();
+    msg->setObject("access-unit", accessUnit);
+    msg->post();
+
+    queue->erase(queue->begin());
+    ++mNextExpectedSeqNo;
+
+    return OK;
+}
+
+void AAMRAssembler::packetLost() {
+    CHECK(mNextExpectedSeqNoValid);
+    ++mNextExpectedSeqNo;
+}
+
+void AAMRAssembler::onByeReceived() {
+    sp<AMessage> msg = mNotifyMsg->dup();
+    msg->setInt32("eos", true);
+    msg->post();
+}
+
+}  // namespace android

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/rtsp/AAMRAssembler.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef A_AMR_ASSEMBLER_H_
+
+#define A_AMR_ASSEMBLER_H_
+
+#include "ARTPAssembler.h"
+
+#include <utils/List.h>
+
+#include <stdint.h>
+
+namespace android {
+
+struct AMessage;
+struct AString;
+
+struct AAMRAssembler : public ARTPAssembler {
+    AAMRAssembler(
+            const sp<AMessage> &notify, bool isWide,
+            const AString &params);
+
+protected:
+    virtual ~AAMRAssembler();
+
+    virtual AssemblyStatus assembleMore(const sp<ARTPSource> &source);
+    virtual void onByeReceived();
+    virtual void packetLost();
+
+private:
+    bool mIsWide;
+
+    sp<AMessage> mNotifyMsg;
+    bool mNextExpectedSeqNoValid;
+    uint32_t mNextExpectedSeqNo;
+
+    AssemblyStatus addPacket(const sp<ARTPSource> &source);
+
+    DISALLOW_EVIL_CONSTRUCTORS(AAMRAssembler);
+};
+
+}  // namespace android
+
+#endif  // A_AMR_ASSEMBLER_H_
+

new file mode 100644
--- /dev/null
+++ b/netwerk/protocol/rtsp/rtsp/AAVCAssembler.cpp
@@ -0,0 +1,376 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "AAVCAssembler"
+#include <utils/Log.h>
+
+#include "AAVCAssembler.h"
+
+#include "ARTPSource.h"
+
+#include <media/stagefright/foundation/ABuffer.h>
+#include <media/stagefright/foundation/ADebug.h>
+#include <media/stagefright/foundation/AMessage.h>
+#include <media/stagefright/foundation/hexdump.h>
+
+#include <stdint.h>
+
+namespace android {
+
+// static
+AAVCAssembler::AAVCAssembler(const sp<AMessage> &notify)
+    : mNotifyMsg(notify),
+      mAccessUnitRTPTime(0),
+      mNextExpectedSeqNoValid(false),
+      mNextExpectedSeqNo(0),
+      mAccessUnitDamaged(false) {
+}
+
+AAVCAssembler::~AAVCAssembler() {
+}
+
+ARTPAssembler::AssemblyStatus AAVCAssembler::addNALUnit(
+        const sp<ARTPSource> &source) {
+    List<sp<ABuffer> > *queue = source->queue();
+
+    if (queue->empty()) {
+        return NOT_ENOUGH_DATA;
+    }
+
+    if (mNextExpectedSeqNoValid) {
+        List<sp<ABuffer> >::iterator it = queue->begin();
+        while (it != queue->end()) {
+            if ((uint32_t)(*it)->int32Data() >= mNextExpectedSeqNo) {
+                break;
+            }
+
+            it = queue->erase(it);
+        }
+
+        if (queue->empty()) {
+            return NOT_ENOUGH_DATA;
+        }
+    }
+
+    sp<ABuffer> buffer = *queue->begin();
+
+    if (!mNextExpectedSeqNoValid) {
+        mNextExpectedSeqNoValid = true;
+        mNextExpectedSeqNo = (uint32_t)buffer->int32Data();
+    } else if ((uint32_t)buffer->int32Data() != mNextExpectedSeqNo) {
+        LOGV("Not the sequence number I expected");
+
+        return WRONG_SEQUENCE_NUMBER;
+    }
+
+    const uint8_t *data = buffer->data();
+    size_t size = buffer->size();
+
+    if (size < 1 || (data[0] & 0x80)) {
+        // Corrupt.
+
+        LOGV("Ignoring corrupt buffer.");
+        queue->erase(queue->begin());
+
+        ++mNextExpectedSeqNo;
+        return MALFORMED_PACKET;
+    }
+
+    unsigned nalType = data[0] & 0x1f;
+    if (nalType >= 1 && nalType <= 23) {
+        addSingleNALUnit(buffer);
+        queue->erase(queue->begin());
+        ++mNextExpectedSeqNo;
+        return OK;
+    } else if (nalType == 28) {
+        // FU-A
+        return addFragmentedNALUnit(queue);
+    } else if (nalType == 24) {
+        // STAP-A
+        bool success = addSingleTimeAggregationPacket(buffer);
+        queue->erase(queue->begin());
+        ++mNextExpectedSeqNo;
+
+        return success ? OK : MALFORMED_PACKET;
+    } else {
+        LOGV("Ignoring unsupported buffer (nalType=%d)", nalType);
+
+        queue->erase(queue->begin());
+        ++mNextExpectedSeqNo;
+
+        return MALFORMED_PACKET;
+    }
+}
+
+void AAVCAssembler::addSingleNALUnit(const sp<ABuffer> &buffer) {
+    LOGV("addSingleNALUnit of size %d", buffer->size());
+#if !LOG_NDEBUG
+    hexdump(buffer->data(), buffer->size());
+#endif
+
+    uint32_t rtpTime;
+    CHECK(buffer->meta()->findInt32("rtp-time", (int32_t *)&rtpTime));
+
+    if (!mNALUnits.empty() && rtpTime != mAccessUnitRTPTime) {
+        submitAccessUnit();
+    }
+    mAccessUnitRTPTime = rtpTime;
+
+    mNALUnits.push_back(buffer);
+}
+
+bool AAVCAssembler::addSingleTimeAggregationPacket(const sp<ABuffer> &buffer) {
+    const uint8_t *data = buffer->data();
+    size_t size = buffer->size();
+
+    if (size < 3) {
+        LOGV("Discarding too small STAP-A packet.");
+        return false;
+    }
+
+    ++data;
+    --size;
+    while (size >= 2) {
+        size_t nalSize = (data[0] << 8) | data[1];
+
+        if (size < nalSize + 2) {
+            LOGV("Discarding malformed STAP-A packet.");
+            return false;
+        }
+
+        sp<ABuffer> unit = new ABuffer(nalSize);
+        memcpy(unit->data(), &data[2], nalSize);
+
+        CopyTimes(unit, buffer);
+
+        addSingleNALUnit(unit);
+
+        data += 2 + nalSize;
+        size -= 2 + nalSize;
+    }
+
+    if (size != 0) {
+        LOGV("Unexpected padding at end of STAP-A packet.");
+    }
+
+    return true;
+}
+
+ARTPAssembler::AssemblyStatus AAVCAssembler::addFragmentedNALUnit(
+        List<sp<ABuffer> > *queue) {
+    CHECK(!queue->empty());
+
+    sp<ABuffer> buffer = *queue->begin();
+    const uint8_t *data = buffer->data();
+    size_t size = buffer->size();
+
+    CHECK(size > 0);
+    unsigned indicator = data[0];
+
+    CHECK((indicator & 0x1f) == 28);
+
+    if (size < 2) {
+        LOGV("Ignoring malformed FU buffer (size = %d)", size);
+
+        queue->erase(queue->begin());
+        ++mNextExpectedSeqNo;
+        return MALFORMED_PACKET;
+    }
+
+    if (!(data[1] & 0x80)) {
+        // Start bit not set on the first buffer.
+
+        LOGV("Start bit not set on first buffer");
+
+        queue->erase(queue->begin());
+        ++mNextExpectedSeqNo;
+        return MALFORMED_PACKET;
+    }
+
+    uint32_t nalType = data[1] & 0x1f;
+    uint32_t nri = (data[0] >> 5) & 3;
+
+    uint32_t expectedSeqNo = (uint32_t)buffer->int32Data() + 1;
+    size_t totalSize = size - 2;
+    size_t totalCount = 1;
+    bool complete = false;
+
+    if (data[1] & 0x40) {
+        // Huh? End bit also set on the first buffer.
+
+        LOGV("Grrr. This isn't fragmented at all.");
+
+        complete = true;
+    } else {
+        List<sp<ABuffer> >::iterator it = ++queue->begin();
+        while (it != queue->end()) {
+            LOGV("sequence length %d", totalCount);
+
+            const sp<ABuffer> &buffer = *it;
+
+            const uint8_t *data = buffer->data();
+            size_t size = buffer->size();
+
+            if ((uint32_t)buffer->int32Data() != expectedSeqNo) {
+                LOGV("sequence not complete, expected seqNo %d, got %d",
+                     expectedSeqNo, (uint32_t)buffer->int32Data());
+
+                return WRONG_SEQUENCE_NUMBER;
+            }
+
+            if (size < 2
+                    || data[0] != indicator
+                    || (data[1] & 0x1f) != nalType
+                    || (data[1] & 0x80)) {
+                LOGV("Ignoring malformed FU buffer.");
+
+                // Delete the whole start of the FU.
+
+                it = queue->begin();
+                for (size_t i = 0; i <= totalCount; ++i) {
+                    it = queue->erase(it);
+                }
+
+                mNextExpectedSeqNo = expectedSeqNo + 1;
+
+                return MALFORMED_PACKET;
+            }
+
+            totalSize += size - 2;
+            ++totalCount;
+
+            expectedSeqNo = expectedSeqNo + 1;
+
+            if (data[1] & 0x40) {
+                // This is the last fragment.
+                complete = true;
+                break;
+            }
+
+            ++it;
+        }
+    }
+
+    if (!complete) {
+        return NOT_ENOUGH_DATA;
+    }
+
+    mNextExpectedSeqNo = expectedSeqNo;
+
+    // We found all the fragments that make up the complete NAL unit.
+
+    // Leave room for the header. So far totalSize did not include the
+    // header byte.
+    ++totalSize;
+
+    sp<ABuffer> unit = new ABuffer(totalSize);
+    CopyTimes(unit, *queue->begin());
+
+    unit->data()[0] = (nri << 5) | nalType;
+
+    size_t offset = 1;
+    List<sp<ABuffer> >::iterator it = queue->begin();
+    for (size_t i = 0; i < totalCount; ++i) {
+        const sp<ABuffer> &buffer = *it;
+
+        LOGV("piece #%d/%d", i + 1, totalCount);
+#if !LOG_NDEBUG
+        hexdump(buffer->data(), buffer->size());
+#endif
+
+        memcpy(unit->data() + offset, buffer->data() + 2, buffer->size() - 2);
+        offset += buffer->size() - 2;
+
+        it = queue->erase(it);
+    }
+
+    unit->setRange(0, totalSize);
+
+    addSingleNALUnit(unit);
+
+    LOGV("successfully assembled a NAL unit from fragments.");
+
+    return OK;
+}
+
+void AAVCAssembler::submitAccessUnit() {
+    CHECK(!mNALUnits.empty());
+
+    LOGV("Access unit complete (%d nal units)", mNALUnits.size());
+
+    size_t totalSize = 0;
+    for (List<sp<ABuffer> >::iterator it = mNALUnits.begin();
+         it != mNALUnits.end(); ++it) {
+        totalSize += 4 + (*it)->size();
+    }
+
+    sp<ABuffer> accessUnit = new ABuffer(totalSize);
+    size_t offset = 0;
+    for (List<sp<ABuffer> >::iterator it = mNALUnits.begin();
+         it != mNALUnits.end(); ++it) {
+        memcpy(accessUnit->data() + offset, "\x00\x00\x00\x01", 4);
+        offset += 4;
+
+        sp<ABuffer> nal = *it;
+        memcpy(accessUnit->data() + offset, nal->data(), nal->size());
+        offset += nal->size();
+    }
+
+    CopyTimes(accessUnit, *mNALUnits.begin());
+
+#if 0
+    printf(mAccessUnitDamaged ? "X" : ".");
+    fflush(stdout);
+#endif
+
+    if (mAccessUnitDamaged) {
+        accessUnit->meta()->setInt32("damaged", true);
+    }
+
+    mNALUnits.clear();
+    mAccessUnitDamaged = false;
+
+    sp<AMessage> msg = mNotifyMsg->dup();
+    msg->setObject("access-unit", accessUnit);
+    msg->post();
+}
+
+ARTPAssembler::AssemblyStatus AAVCAssembler::assembleMore(
+        const sp<ARTPSource> &source) {
+    AssemblyStatus status = addNALUnit(source);
+    if (status == MALFORMED_PACKET) {
+        mAccessUnitDamaged = true;
+    }
+    return status;
+}
+
+void AAVCAssembler::packetLost() {
+    CHECK(mNextExpectedSeqNoValid);
+    LOGV("packetLost (expected %d)", mNextExpectedSeqNo);
+
+    ++mNextExpectedSeqNo;
+
+    mAccessUnitDamaged = true;
+}
+
+void AAVCAssembler::onByeReceived() {
+    sp<AMessage> msg = mNotifyMsg->dup();
+    msg->setInt32("eos", true);
+    msg->post();
+}
+
+}  // namespace android