diff --git a/include/media/AudioSystem.h b/include/media/AudioSystem.h
index 2218fad..d64ecd4 100644
--- a/include/media/AudioSystem.h
+++ b/include/media/AudioSystem.h
@@ -107,12 +107,6 @@
                                audio_stream_type_t stream,
                                uint32_t* latency);
 
-    // DEPRECATED
-    static status_t getOutputSamplingRate(int* samplingRate, int stream = AUDIO_STREAM_DEFAULT);
-
-    // DEPRECATED
-    static status_t getOutputFrameCount(int* frameCount, int stream = AUDIO_STREAM_DEFAULT);
-
     static bool routedToA2dpOutput(audio_stream_type_t streamType);
 
     static status_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,
diff --git a/media/libmedia/AudioSystem.cpp b/media/libmedia/AudioSystem.cpp
index 767c452..488edac 100644
--- a/media/libmedia/AudioSystem.cpp
+++ b/media/libmedia/AudioSystem.cpp
@@ -205,11 +205,6 @@
     return volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0;
 }
 
-// DEPRECATED
-status_t AudioSystem::getOutputSamplingRate(int* samplingRate, int streamType) {
-    return getOutputSamplingRate(samplingRate, (audio_stream_type_t)streamType);
-}
-
 status_t AudioSystem::getOutputSamplingRate(int* samplingRate, audio_stream_type_t streamType)
 {
     audio_io_handle_t output;
@@ -252,11 +247,6 @@
     return NO_ERROR;
 }
 
-// DEPRECATED
-status_t AudioSystem::getOutputFrameCount(int* frameCount, int streamType) {
-    return getOutputFrameCount(frameCount, (audio_stream_type_t)streamType);
-}
-
 status_t AudioSystem::getOutputFrameCount(int* frameCount, audio_stream_type_t streamType)
 {
     audio_io_handle_t output;
diff --git a/media/libmedia/IAudioFlinger.cpp b/media/libmedia/IAudioFlinger.cpp
index bb936ec..55658db 100644
--- a/media/libmedia/IAudioFlinger.cpp
+++ b/media/libmedia/IAudioFlinger.cpp
@@ -106,7 +106,7 @@
         data.writeInt32(format);
         data.writeInt32(channelMask);
         data.writeInt32(frameCount);
-        track_flags_t lFlags = flags != NULL ? *flags : TRACK_DEFAULT;
+        track_flags_t lFlags = flags != NULL ? *flags : (track_flags_t) TRACK_DEFAULT;
         data.writeInt32(lFlags);
         data.writeStrongBinder(sharedBuffer->asBinder());
         data.writeInt32((int32_t) output);
diff --git a/media/libstagefright/ACodec.cpp b/media/libstagefright/ACodec.cpp
index 0ca027b..84b4962 100644
--- a/media/libstagefright/ACodec.cpp
+++ b/media/libstagefright/ACodec.cpp
@@ -937,7 +937,8 @@
             }
 
             err = setupAACCodec(
-                    encoder, numChannels, sampleRate, bitRate, aacProfile, isADTS != 0);
+                    encoder, numChannels, sampleRate, bitRate, aacProfile,
+                    isADTS != 0);
         }
     } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_NB)) {
         err = setupAMRCodec(encoder, false /* isWAMR */, bitRate);
@@ -986,6 +987,10 @@
         }
     }
 
+    if (err != OK) {
+        return err;
+    }
+
     if (!msg->findInt32("encoder-delay", &mEncoderDelay)) {
         mEncoderDelay = 0;
     }
diff --git a/media/libstagefright/wifi-display/ANetworkSession.cpp b/media/libstagefright/wifi-display/ANetworkSession.cpp
index 819cd62..62a6e7f 100644
--- a/media/libstagefright/wifi-display/ANetworkSession.cpp
+++ b/media/libstagefright/wifi-display/ANetworkSession.cpp
@@ -407,6 +407,24 @@
         do {
             const sp<ABuffer> &datagram = *mOutDatagrams.begin();
 
+            uint8_t *data = datagram->data();
+            if (data[0] == 0x80 && (data[1] & 0x7f) == 33) {
+                int64_t nowUs = ALooper::GetNowUs();
+
+                uint32_t prevRtpTime = U32_AT(&data[4]);
+
+                // 90kHz time scale
+                uint32_t rtpTime = (nowUs * 9ll) / 100ll;
+                int32_t diffTime = (int32_t)rtpTime - (int32_t)prevRtpTime;
+
+                ALOGV("correcting rtpTime by %.0f ms", diffTime / 90.0);
+
+                data[4] = rtpTime >> 24;
+                data[5] = (rtpTime >> 16) & 0xff;
+                data[6] = (rtpTime >> 8) & 0xff;
+                data[7] = rtpTime & 0xff;
+            }
+
             int n;
             do {
                 n = send(mSocket, datagram->data(), datagram->size(), 0);
@@ -424,6 +442,9 @@
         } while (err == OK && !mOutDatagrams.empty());
 
         if (err == -EAGAIN) {
+            if (!mOutDatagrams.empty()) {
+                ALOGI("%d datagrams remain queued.", mOutDatagrams.size());
+            }
             err = OK;
         }
 
diff --git a/media/libstagefright/wifi-display/Android.mk b/media/libstagefright/wifi-display/Android.mk
index 611bfff..75098f1 100644
--- a/media/libstagefright/wifi-display/Android.mk
+++ b/media/libstagefright/wifi-display/Android.mk
@@ -17,6 +17,7 @@
         source/Sender.cpp               \
         source/TSPacketizer.cpp         \
         source/WifiDisplaySource.cpp    \
+        TimeSeries.cpp                  \
 
 LOCAL_C_INCLUDES:= \
         $(TOP)/frameworks/av/media/libstagefright \
diff --git a/media/libstagefright/wifi-display/TimeSeries.cpp b/media/libstagefright/wifi-display/TimeSeries.cpp
new file mode 100644
index 0000000..d882d98
--- /dev/null
+++ b/media/libstagefright/wifi-display/TimeSeries.cpp
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2012, 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.
+ */
+
+#include "TimeSeries.h"
+
+#include <math.h>
+#include <string.h>
+
+namespace android {
+
+TimeSeries::TimeSeries()
+    : mCount(0),
+      mSum(0.0) {
+}
+
+void TimeSeries::add(double val) {
+    if (mCount < kHistorySize) {
+        mValues[mCount++] = val;
+        mSum += val;
+    } else {
+        mSum -= mValues[0];
+        memmove(&mValues[0], &mValues[1], (kHistorySize - 1) * sizeof(double));
+        mValues[kHistorySize - 1] = val;
+        mSum += val;
+    }
+}
+
+double TimeSeries::mean() const {
+    if (mCount < 1) {
+        return 0.0;
+    }
+
+    return mSum / mCount;
+}
+
+double TimeSeries::sdev() const {
+    if (mCount < 1) {
+        return 0.0;
+    }
+
+    double m = mean();
+
+    double sum = 0.0;
+    for (size_t i = 0; i < mCount; ++i) {
+        double tmp = mValues[i] - m;
+        tmp *= tmp;
+
+        sum += tmp;
+    }
+
+    return sqrt(sum / mCount);
+}
+
+}  // namespace android
diff --git a/media/libstagefright/wifi-display/TimeSeries.h b/media/libstagefright/wifi-display/TimeSeries.h
new file mode 100644
index 0000000..c818d51
--- /dev/null
+++ b/media/libstagefright/wifi-display/TimeSeries.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2012, 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 TIME_SERIES_H_
+
+#define TIME_SERIES_H_
+
+#include <sys/types.h>
+
+namespace android {
+
+struct TimeSeries {
+    TimeSeries();
+
+    void add(double val);
+
+    double mean() const;
+    double sdev() const;
+
+private:
+    enum {
+        kHistorySize = 20
+    };
+    double mValues[kHistorySize];
+
+    size_t mCount;
+    double mSum;
+};
+
+}  // namespace android
+
+#endif  // TIME_SERIES_H_
+
diff --git a/media/libstagefright/wifi-display/source/Converter.cpp b/media/libstagefright/wifi-display/source/Converter.cpp
index 01a394f..82c98b9 100644
--- a/media/libstagefright/wifi-display/source/Converter.cpp
+++ b/media/libstagefright/wifi-display/source/Converter.cpp
@@ -48,6 +48,7 @@
       mInputFormat(format),
       mIsVideo(false),
       mIsPCMAudio(usePCMAudio),
+      mNeedToManuallyPrependSPSPPS(false),
       mDoMoreWorkPending(false)
 #if ENABLE_SILENCE_DETECTION
       ,mFirstSilentFrameUs(-1ll)
@@ -94,6 +95,10 @@
     return mOutputFormat;
 }
 
+bool Converter::needToManuallyPrependSPSPPS() const {
+    return mNeedToManuallyPrependSPSPPS;
+}
+
 static int32_t getBitrate(const char *propName, int32_t defaultValue) {
     char val[PROPERTY_VALUE_MAX];
     if (property_get(propName, val, NULL)) {
@@ -157,16 +162,45 @@
         mOutputFormat->setInt32("bitrate-mode", OMX_Video_ControlRateConstant);
         mOutputFormat->setInt32("frame-rate", 30);
         mOutputFormat->setInt32("i-frame-interval", 1);  // Iframes every 1 secs
-        mOutputFormat->setInt32("prepend-sps-pps-to-idr-frames", 1);
     }
 
     ALOGV("output format is '%s'", mOutputFormat->debugString(0).c_str());
 
-    status_t err = mEncoder->configure(
-            mOutputFormat,
-            NULL /* nativeWindow */,
-            NULL /* crypto */,
-            MediaCodec::CONFIGURE_FLAG_ENCODE);
+    mNeedToManuallyPrependSPSPPS = false;
+
+    status_t err = NO_INIT;
+
+    if (!isAudio) {
+        sp<AMessage> tmp = mOutputFormat->dup();
+        tmp->setInt32("prepend-sps-pps-to-idr-frames", 1);
+
+        err = mEncoder->configure(
+                tmp,
+                NULL /* nativeWindow */,
+                NULL /* crypto */,
+                MediaCodec::CONFIGURE_FLAG_ENCODE);
+
+        if (err == OK) {
+            // Encoder supported prepending SPS/PPS, we don't need to emulate
+            // it.
+            mOutputFormat = tmp;
+        } else {
+            mNeedToManuallyPrependSPSPPS = true;
+
+            ALOGI("We going to manually prepend SPS and PPS to IDR frames.");
+        }
+    }
+
+    if (err != OK) {
+        // We'll get here for audio or if we failed to configure the encoder
+        // to automatically prepend SPS/PPS in the case of video.
+
+        err = mEncoder->configure(
+                    mOutputFormat,
+                    NULL /* nativeWindow */,
+                    NULL /* crypto */,
+                    MediaCodec::CONFIGURE_FLAG_ENCODE);
+    }
 
     if (err != OK) {
         return err;
diff --git a/media/libstagefright/wifi-display/source/Converter.h b/media/libstagefright/wifi-display/source/Converter.h
index 2cdeda3..0665eea 100644
--- a/media/libstagefright/wifi-display/source/Converter.h
+++ b/media/libstagefright/wifi-display/source/Converter.h
@@ -44,6 +44,7 @@
     size_t getInputBufferCount() const;
 
     sp<AMessage> getOutputFormat() const;
+    bool needToManuallyPrependSPSPPS() const;
 
     void feedAccessUnit(const sp<ABuffer> &accessUnit);
     void signalEOS();
@@ -78,6 +79,7 @@
     bool mIsVideo;
     bool mIsPCMAudio;
     sp<AMessage> mOutputFormat;
+    bool mNeedToManuallyPrependSPSPPS;
 
     sp<MediaCodec> mEncoder;
     sp<AMessage> mEncoderActivityNotify;
diff --git a/media/libstagefright/wifi-display/source/PlaybackSession.cpp b/media/libstagefright/wifi-display/source/PlaybackSession.cpp
index f1e7140..4e5eb52 100644
--- a/media/libstagefright/wifi-display/source/PlaybackSession.cpp
+++ b/media/libstagefright/wifi-display/source/PlaybackSession.cpp
@@ -26,6 +26,7 @@
 #include "Sender.h"
 #include "TSPacketizer.h"
 #include "include/avc_utils.h"
+#include "WifiDisplaySource.h"
 
 #include <binder/IServiceManager.h>
 #include <gui/ISurfaceComposer.h>
@@ -81,7 +82,10 @@
     bool hasOutputBuffer(int64_t *timeUs) const;
     void queueOutputBuffer(const sp<ABuffer> &accessUnit);
     sp<ABuffer> dequeueOutputBuffer();
+
+#if SUSPEND_VIDEO_IF_IDLE
     bool isSuspended() const;
+#endif
 
     size_t countQueuedOutputBuffers() const {
         return mQueuedOutputBuffers.size();
@@ -279,7 +283,6 @@
 void WifiDisplaySource::PlaybackSession::Track::queueOutputBuffer(
         const sp<ABuffer> &accessUnit) {
     mQueuedOutputBuffers.push_back(accessUnit);
-
     mLastOutputBufferQueuedTimeUs = ALooper::GetNowUs();
 }
 
@@ -292,6 +295,7 @@
     return outputBuffer;
 }
 
+#if SUSPEND_VIDEO_IF_IDLE
 bool WifiDisplaySource::PlaybackSession::Track::isSuspended() const {
     if (!mQueuedOutputBuffers.empty()) {
         return false;
@@ -307,6 +311,7 @@
     // this track suspended for the time being.
     return (ALooper::GetNowUs() - mLastOutputBufferQueuedTimeUs) > 60000ll;
 }
+#endif
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -443,8 +448,13 @@
                 ssize_t packetizerTrackIndex = track->packetizerTrackIndex();
 
                 if (packetizerTrackIndex < 0) {
-                    packetizerTrackIndex =
-                        mPacketizer->addTrack(track->getFormat());
+                    sp<AMessage> trackFormat = track->getFormat()->dup();
+                    if (mHDCP != NULL && !track->isAudio()) {
+                        // HDCP2.0 _and_ HDCP 2.1 specs say to set the version
+                        // inside the HDCP descriptor to 0x20!!!
+                        trackFormat->setInt32("hdcp-version", 0x20);
+                    }
+                    packetizerTrackIndex = mPacketizer->addTrack(trackFormat);
 
                     CHECK_GE(packetizerTrackIndex, 0);
 
@@ -642,8 +652,10 @@
     sp<Converter> converter =
         new Converter(notify, codecLooper, format, usePCMAudio);
 
-    if (converter->initCheck() != OK) {
-        return converter->initCheck();
+    err = converter->initCheck();
+    if (err != OK) {
+        ALOGE("%s converter returned err %d", isVideo ? "video" : "audio", err);
+        return err;
     }
 
     looper()->registerHandler(converter);
@@ -735,11 +747,19 @@
 }
 
 int32_t WifiDisplaySource::PlaybackSession::width() const {
+#if USE_1080P
+    return 1920;
+#else
     return 1280;
+#endif
 }
 
 int32_t WifiDisplaySource::PlaybackSession::height() const {
+#if USE_1080P
+    return 1080;
+#else
     return 720;
+#endif
 }
 
 void WifiDisplaySource::PlaybackSession::requestIDRFrame() {
@@ -767,7 +787,7 @@
 }
 
 status_t WifiDisplaySource::PlaybackSession::packetizeAccessUnit(
-        size_t trackIndex, const sp<ABuffer> &accessUnit,
+        size_t trackIndex, sp<ABuffer> accessUnit,
         sp<ABuffer> *packets) {
     const sp<Track> &track = mTracks.valueFor(trackIndex);
 
@@ -776,9 +796,20 @@
     bool isHDCPEncrypted = false;
     uint64_t inputCTR;
     uint8_t HDCP_private_data[16];
+
+    bool manuallyPrependSPSPPS =
+        !track->isAudio()
+        && track->converter()->needToManuallyPrependSPSPPS()
+        && IsIDR(accessUnit);
+
     if (mHDCP != NULL && !track->isAudio()) {
         isHDCPEncrypted = true;
 
+        if (manuallyPrependSPSPPS) {
+            accessUnit = mPacketizer->prependCSD(
+                    track->packetizerTrackIndex(), accessUnit);
+        }
+
         status_t err = mHDCP->encrypt(
                 accessUnit->data(), accessUnit->size(),
                 trackIndex  /* streamCTR */,
@@ -858,6 +889,8 @@
 #endif
 
         flags |= TSPacketizer::IS_ENCRYPTED;
+    } else if (manuallyPrependSPSPPS) {
+        flags |= TSPacketizer::PREPEND_SPS_PPS_TO_IDR_FRAMES;
     }
 
     int64_t timeUs = ALooper::GetNowUs();
@@ -930,12 +963,21 @@
                 minTrackIndex = mTracks.keyAt(i);
                 minTimeUs = timeUs;
             }
-        } else if (!track->isSuspended()) {
+        }
+#if SUSPEND_VIDEO_IF_IDLE
+        else if (!track->isSuspended()) {
             // We still consider this track "live", so it should keep
             // delivering output data whose time stamps we'll have to
             // consider for proper interleaving.
             return false;
         }
+#else
+        else {
+            // We need access units available on all tracks to be able to
+            // dequeue the earliest one.
+            return false;
+        }
+#endif
     }
 
     if (minTrackIndex < 0) {
@@ -950,6 +992,7 @@
 
     if (err != OK) {
         notifySessionDead();
+        return false;
     }
 
     if ((ssize_t)minTrackIndex == mVideoTrackIndex) {
@@ -957,6 +1000,17 @@
     }
     mSender->queuePackets(minTimeUs, packets);
 
+#if 0
+    if (minTrackIndex == mVideoTrackIndex) {
+        int64_t nowUs = ALooper::GetNowUs();
+
+        // Latency from "data acquired" to "ready to send if we wanted to".
+        ALOGI("[%s] latencyUs = %lld ms",
+              minTrackIndex == mVideoTrackIndex ? "video" : "audio",
+              (nowUs - minTimeUs) / 1000ll);
+    }
+#endif
+
     return true;
 }
 
diff --git a/media/libstagefright/wifi-display/source/PlaybackSession.h b/media/libstagefright/wifi-display/source/PlaybackSession.h
index cc8b244..dabc1c4 100644
--- a/media/libstagefright/wifi-display/source/PlaybackSession.h
+++ b/media/libstagefright/wifi-display/source/PlaybackSession.h
@@ -127,7 +127,7 @@
     bool allTracksHavePacketizerIndex();
 
     status_t packetizeAccessUnit(
-            size_t trackIndex, const sp<ABuffer> &accessUnit,
+            size_t trackIndex, sp<ABuffer> accessUnit,
             sp<ABuffer> *packets);
 
     status_t packetizeQueuedAccessUnits();
diff --git a/media/libstagefright/wifi-display/source/RepeaterSource.cpp b/media/libstagefright/wifi-display/source/RepeaterSource.cpp
index 641e63f..72be927 100644
--- a/media/libstagefright/wifi-display/source/RepeaterSource.cpp
+++ b/media/libstagefright/wifi-display/source/RepeaterSource.cpp
@@ -125,11 +125,14 @@
                 return mResult;
             }
 
+#if SUSPEND_VIDEO_IF_IDLE
             int64_t nowUs = ALooper::GetNowUs();
             if (nowUs - mLastBufferUpdateUs > 1000000ll) {
                 mLastBufferUpdateUs = -1ll;
                 stale = true;
-            } else {
+            } else
+#endif
+            {
                 mBuffer->add_ref();
                 *buffer = mBuffer;
                 (*buffer)->meta_data()->setInt64(kKeyTime, bufferTimeUs);
diff --git a/media/libstagefright/wifi-display/source/RepeaterSource.h b/media/libstagefright/wifi-display/source/RepeaterSource.h
index e4aa2b6..a13973c 100644
--- a/media/libstagefright/wifi-display/source/RepeaterSource.h
+++ b/media/libstagefright/wifi-display/source/RepeaterSource.h
@@ -6,6 +6,8 @@
 #include <media/stagefright/foundation/AHandlerReflector.h>
 #include <media/stagefright/MediaSource.h>
 
+#define SUSPEND_VIDEO_IF_IDLE   1
+
 namespace android {
 
 // This MediaSource delivers frames at a constant rate by repeating buffers
diff --git a/media/libstagefright/wifi-display/source/Sender.cpp b/media/libstagefright/wifi-display/source/Sender.cpp
index ea12424..9048691 100644
--- a/media/libstagefright/wifi-display/source/Sender.cpp
+++ b/media/libstagefright/wifi-display/source/Sender.cpp
@@ -21,6 +21,7 @@
 #include "Sender.h"
 
 #include "ANetworkSession.h"
+#include "TimeSeries.h"
 
 #include <media/stagefright/foundation/ABuffer.h>
 #include <media/stagefright/foundation/ADebug.h>
@@ -29,79 +30,8 @@
 #include <media/stagefright/MediaErrors.h>
 #include <media/stagefright/Utils.h>
 
-#include <math.h>
-
-#define DEBUG_JITTER    0
-
 namespace android {
 
-////////////////////////////////////////////////////////////////////////////////
-
-#if DEBUG_JITTER
-struct TimeSeries {
-    TimeSeries();
-
-    void add(double val);
-
-    double mean() const;
-    double sdev() const;
-
-private:
-    enum {
-        kHistorySize = 20
-    };
-    double mValues[kHistorySize];
-
-    size_t mCount;
-    double mSum;
-};
-
-TimeSeries::TimeSeries()
-    : mCount(0),
-      mSum(0.0) {
-}
-
-void TimeSeries::add(double val) {
-    if (mCount < kHistorySize) {
-        mValues[mCount++] = val;
-        mSum += val;
-    } else {
-        mSum -= mValues[0];
-        memmove(&mValues[0], &mValues[1], (kHistorySize - 1) * sizeof(double));
-        mValues[kHistorySize - 1] = val;
-        mSum += val;
-    }
-}
-
-double TimeSeries::mean() const {
-    if (mCount < 1) {
-        return 0.0;
-    }
-
-    return mSum / mCount;
-}
-
-double TimeSeries::sdev() const {
-    if (mCount < 1) {
-        return 0.0;
-    }
-
-    double m = mean();
-
-    double sum = 0.0;
-    for (size_t i = 0; i < mCount; ++i) {
-        double tmp = mValues[i] - m;
-        tmp *= tmp;
-
-        sum += tmp;
-    }
-
-    return sqrt(sum / mCount);
-}
-#endif  // DEBUG_JITTER
-
-////////////////////////////////////////////////////////////////////////////////
-
 static size_t kMaxRTPPacketSize = 1500;
 static size_t kMaxNumTSPacketsPerRTPPacket = (kMaxRTPPacketSize - 12) / 188;
 
@@ -110,14 +40,13 @@
         const sp<AMessage> &notify)
     : mNetSession(netSession),
       mNotify(notify),
-      mTSQueue(new ABuffer(12 + kMaxNumTSPacketsPerRTPPacket * 188)),
       mTransportMode(TRANSPORT_UDP),
       mRTPChannel(0),
       mRTCPChannel(0),
       mRTPPort(0),
       mRTPSessionID(0),
       mRTCPSessionID(0),
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
       mRTPRetransmissionSessionID(0),
       mRTCPRetransmissionSessionID(0),
 #endif
@@ -128,7 +57,7 @@
       mFirstOutputBufferReadyTimeUs(-1ll),
       mFirstOutputBufferSentTimeUs(-1ll),
       mRTPSeqNo(0),
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
       mRTPRetransmissionSeqNo(0),
 #endif
       mLastNTPTime(0),
@@ -148,15 +77,13 @@
     ,mLogFile(NULL)
 #endif
 {
-    mTSQueue->setRange(0, 12);
-
 #if LOG_TRANSPORT_STREAM
     mLogFile = fopen("/system/etc/log.ts", "wb");
 #endif
 }
 
 Sender::~Sender() {
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
     if (mRTCPRetransmissionSessionID != 0) {
         mNetSession->destroySession(mRTCPRetransmissionSessionID);
     }
@@ -217,7 +144,7 @@
     sp<AMessage> rtpNotify = new AMessage(kWhatRTPNotify, id());
     sp<AMessage> rtcpNotify = new AMessage(kWhatRTCPNotify, id());
 
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
     sp<AMessage> rtpRetransmissionNotify =
         new AMessage(kWhatRTPRetransmissionNotify, id());
 
@@ -264,7 +191,7 @@
             }
         }
 
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
         if (mTransportMode == TRANSPORT_UDP) {
             int32_t rtpRetransmissionSession;
 
@@ -358,44 +285,67 @@
 }
 
 void Sender::queuePackets(
-        int64_t timeUs, const sp<ABuffer> &packets) {
-    bool isVideo = false;
+        int64_t timeUs, const sp<ABuffer> &tsPackets) {
+    const size_t numTSPackets = tsPackets->size() / 188;
 
-    int32_t dummy;
-    if (packets->meta()->findInt32("isVideo", &dummy)) {
-        isVideo = true;
+    const size_t numRTPPackets =
+        (numTSPackets + kMaxNumTSPacketsPerRTPPacket - 1)
+            / kMaxNumTSPacketsPerRTPPacket;
+
+    sp<ABuffer> udpPackets = new ABuffer(
+            numRTPPackets * (12 + kMaxNumTSPacketsPerRTPPacket * 188));
+
+    udpPackets->meta()->setInt64("timeUs", timeUs);
+
+    size_t dstOffset = 0;
+    for (size_t i = 0; i < numTSPackets; ++i) {
+        if ((i % kMaxNumTSPacketsPerRTPPacket) == 0) {
+            static const bool kMarkerBit = false;
+
+            uint8_t *rtp = udpPackets->data() + dstOffset;
+            rtp[0] = 0x80;
+            rtp[1] = 33 | (kMarkerBit ? (1 << 7) : 0);  // M-bit
+            rtp[2] = (mRTPSeqNo >> 8) & 0xff;
+            rtp[3] = mRTPSeqNo & 0xff;
+            rtp[4] = 0x00;  // rtp time to be filled in later.
+            rtp[5] = 0x00;
+            rtp[6] = 0x00;
+            rtp[7] = 0x00;
+            rtp[8] = kSourceID >> 24;
+            rtp[9] = (kSourceID >> 16) & 0xff;
+            rtp[10] = (kSourceID >> 8) & 0xff;
+            rtp[11] = kSourceID & 0xff;
+
+            ++mRTPSeqNo;
+
+            dstOffset += 12;
+        }
+
+        memcpy(udpPackets->data() + dstOffset,
+               tsPackets->data() + 188 * i,
+               188);
+
+        dstOffset += 188;
     }
 
-    int64_t delayUs;
-    int64_t whenUs;
+    udpPackets->setRange(0, dstOffset);
 
-    if (mFirstOutputBufferReadyTimeUs < 0ll) {
-        mFirstOutputBufferReadyTimeUs = timeUs;
-        mFirstOutputBufferSentTimeUs = whenUs = ALooper::GetNowUs();
-        delayUs = 0ll;
-    } else {
-        int64_t nowUs = ALooper::GetNowUs();
+    sp<AMessage> msg = new AMessage(kWhatDrainQueue, id());
+    msg->setBuffer("udpPackets", udpPackets);
+    msg->post();
 
-        whenUs = (timeUs - mFirstOutputBufferReadyTimeUs)
-                + mFirstOutputBufferSentTimeUs;
-
-        delayUs = whenUs - nowUs;
+#if LOG_TRANSPORT_STREAM
+    if (mLogFile != NULL) {
+        fwrite(tsPackets->data(), 1, tsPackets->size(), mLogFile);
     }
-
-    sp<AMessage> msg = new AMessage(kWhatQueuePackets, id());
-    msg->setBuffer("packets", packets);
-
-    packets->meta()->setInt64("timeUs", timeUs);
-    packets->meta()->setInt64("whenUs", whenUs);
-    packets->meta()->setInt64("delayUs", delayUs);
-    msg->post(delayUs > 0 ? delayUs : 0);
+#endif
 }
 
 void Sender::onMessageReceived(const sp<AMessage> &msg) {
     switch (msg->what()) {
         case kWhatRTPNotify:
         case kWhatRTCPNotify:
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
         case kWhatRTPRetransmissionNotify:
         case kWhatRTCPRetransmissionNotify:
 #endif
@@ -419,7 +369,7 @@
                     CHECK(msg->findString("detail", &detail));
 
                     if ((msg->what() == kWhatRTPNotify
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
                             || msg->what() == kWhatRTPRetransmissionNotify
 #endif
                         ) && !errorOccuredDuringSend) {
@@ -443,7 +393,7 @@
                     } else if (sessionID == mRTCPSessionID) {
                         mRTCPSessionID = 0;
                     }
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
                     else if (sessionID == mRTPRetransmissionSessionID) {
                         mRTPRetransmissionSessionID = 0;
                     } else if (sessionID == mRTCPRetransmissionSessionID) {
@@ -465,7 +415,7 @@
 
                     status_t err;
                     if (msg->what() == kWhatRTCPNotify
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
                             || msg->what() == kWhatRTCPRetransmissionNotify
 #endif
                        )
@@ -507,12 +457,12 @@
             break;
         }
 
-        case kWhatQueuePackets:
+        case kWhatDrainQueue:
         {
-            sp<ABuffer> packets;
-            CHECK(msg->findBuffer("packets", &packets));
+            sp<ABuffer> udpPackets;
+            CHECK(msg->findBuffer("udpPackets", &udpPackets));
 
-            onQueuePackets(packets);
+            onDrainQueue(udpPackets);
             break;
         }
 
@@ -532,156 +482,6 @@
     }
 }
 
-void Sender::onQueuePackets(const sp<ABuffer> &packets) {
-#if DEBUG_JITTER
-    int32_t dummy;
-    if (packets->meta()->findInt32("isVideo", &dummy)) {
-        static int64_t lastTimeUs = 0ll;
-        int64_t nowUs = ALooper::GetNowUs();
-
-        static TimeSeries series;
-        series.add((double)(nowUs - lastTimeUs));
-
-        ALOGI("deltaTimeUs = %lld us, mean %.2f, sdev %.2f",
-              nowUs - lastTimeUs, series.mean(), series.sdev());
-
-        lastTimeUs = nowUs;
-    }
-#endif
-
-    int64_t startTimeUs = ALooper::GetNowUs();
-
-    for (size_t offset = 0;
-            offset < packets->size(); offset += 188) {
-        bool lastTSPacket = (offset + 188 >= packets->size());
-
-        appendTSData(
-                packets->data() + offset,
-                188,
-                true /* timeDiscontinuity */,
-                lastTSPacket /* flush */);
-    }
-
-#if 0
-    int64_t netTimeUs = ALooper::GetNowUs() - startTimeUs;
-
-    int64_t whenUs;
-    CHECK(packets->meta()->findInt64("whenUs", &whenUs));
-
-    int64_t delayUs;
-    CHECK(packets->meta()->findInt64("delayUs", &delayUs));
-
-    bool isVideo = false;
-    int32_t dummy;
-    if (packets->meta()->findInt32("isVideo", &dummy)) {
-        isVideo = true;
-    }
-
-    int64_t nowUs = ALooper::GetNowUs();
-
-    if (nowUs - whenUs > 2000) {
-        ALOGI("[%s] delayUs = %lld us, delta = %lld us",
-              isVideo ? "video" : "audio", delayUs, nowUs - netTimeUs - whenUs);
-    }
-#endif
-
-#if LOG_TRANSPORT_STREAM
-    if (mLogFile != NULL) {
-        fwrite(packets->data(), 1, packets->size(), mLogFile);
-    }
-#endif
-}
-
-ssize_t Sender::appendTSData(
-        const void *data, size_t size, bool timeDiscontinuity, bool flush) {
-    CHECK_EQ(size, 188);
-
-    CHECK_LE(mTSQueue->size() + size, mTSQueue->capacity());
-
-    memcpy(mTSQueue->data() + mTSQueue->size(), data, size);
-    mTSQueue->setRange(0, mTSQueue->size() + size);
-
-    if (flush || mTSQueue->size() == mTSQueue->capacity()) {
-        // flush
-
-        int64_t nowUs = ALooper::GetNowUs();
-
-#if TRACK_BANDWIDTH
-        if (mFirstPacketTimeUs < 0ll) {
-            mFirstPacketTimeUs = nowUs;
-        }
-#endif
-
-        // 90kHz time scale
-        uint32_t rtpTime = (nowUs * 9ll) / 100ll;
-
-        uint8_t *rtp = mTSQueue->data();
-        rtp[0] = 0x80;
-        rtp[1] = 33 | (timeDiscontinuity ? (1 << 7) : 0);  // M-bit
-        rtp[2] = (mRTPSeqNo >> 8) & 0xff;
-        rtp[3] = mRTPSeqNo & 0xff;
-        rtp[4] = rtpTime >> 24;
-        rtp[5] = (rtpTime >> 16) & 0xff;
-        rtp[6] = (rtpTime >> 8) & 0xff;
-        rtp[7] = rtpTime & 0xff;
-        rtp[8] = kSourceID >> 24;
-        rtp[9] = (kSourceID >> 16) & 0xff;
-        rtp[10] = (kSourceID >> 8) & 0xff;
-        rtp[11] = kSourceID & 0xff;
-
-        ++mRTPSeqNo;
-        ++mNumRTPSent;
-        mNumRTPOctetsSent += mTSQueue->size() - 12;
-
-        mLastRTPTime = rtpTime;
-        mLastNTPTime = GetNowNTP();
-
-        if (mTransportMode == TRANSPORT_TCP_INTERLEAVED) {
-            sp<AMessage> notify = mNotify->dup();
-            notify->setInt32("what", kWhatBinaryData);
-
-            sp<ABuffer> data = new ABuffer(mTSQueue->size());
-            memcpy(data->data(), rtp, mTSQueue->size());
-
-            notify->setInt32("channel", mRTPChannel);
-            notify->setBuffer("data", data);
-            notify->post();
-        } else {
-            sendPacket(mRTPSessionID, rtp, mTSQueue->size());
-
-#if TRACK_BANDWIDTH
-            mTotalBytesSent += mTSQueue->size();
-            int64_t delayUs = ALooper::GetNowUs() - mFirstPacketTimeUs;
-
-            if (delayUs > 0ll) {
-                ALOGI("approx. net bandwidth used: %.2f Mbit/sec",
-                        mTotalBytesSent * 8.0 / delayUs);
-            }
-#endif
-        }
-
-#if ENABLE_RETRANSMISSION
-        mTSQueue->setInt32Data(mRTPSeqNo - 1);
-
-        mHistory.push_back(mTSQueue);
-        ++mHistoryLength;
-
-        if (mHistoryLength > kMaxHistoryLength) {
-            mTSQueue = *mHistory.begin();
-            mHistory.erase(mHistory.begin());
-
-            --mHistoryLength;
-        } else {
-            mTSQueue = new ABuffer(12 + kMaxNumTSPacketsPerRTPPacket * 188);
-        }
-#endif
-
-        mTSQueue->setRange(0, 12);
-    }
-
-    return size;
-}
-
 void Sender::scheduleSendSR() {
     if (mSendSRPending || mRTCPSessionID == 0) {
         return;
@@ -851,6 +651,7 @@
             if (retransmit) {
                 ALOGI("retransmitting seqNo %d", bufferSeqNo);
 
+#if RETRANSMISSION_ACCORDING_TO_RFC_XXXX
                 sp<ABuffer> retransRTP = new ABuffer(2 + buffer->size());
                 uint8_t *rtp = retransRTP->data();
                 memcpy(rtp, buffer->data(), 12);
@@ -865,6 +666,10 @@
                 sendPacket(
                         mRTPRetransmissionSessionID,
                         retransRTP->data(), retransRTP->size());
+#else
+                sendPacket(
+                        mRTPSessionID, buffer->data(), buffer->size());
+#endif
 
                 if (bufferSeqNo == seqNo) {
                     foundSeqNo = true;
@@ -975,5 +780,91 @@
     notify->post();
 }
 
+void Sender::onDrainQueue(const sp<ABuffer> &udpPackets) {
+    static const size_t kFullRTPPacketSize =
+        12 + 188 * kMaxNumTSPacketsPerRTPPacket;
+
+    size_t srcOffset = 0;
+    while (srcOffset < udpPackets->size()) {
+        uint8_t *rtp = udpPackets->data() + srcOffset;
+
+        size_t rtpPacketSize = udpPackets->size() - srcOffset;
+        if (rtpPacketSize > kFullRTPPacketSize) {
+            rtpPacketSize = kFullRTPPacketSize;
+        }
+
+        int64_t nowUs = ALooper::GetNowUs();
+        mLastNTPTime = GetNowNTP();
+
+        // 90kHz time scale
+        uint32_t rtpTime = (nowUs * 9ll) / 100ll;
+
+        rtp[4] = rtpTime >> 24;
+        rtp[5] = (rtpTime >> 16) & 0xff;
+        rtp[6] = (rtpTime >> 8) & 0xff;
+        rtp[7] = rtpTime & 0xff;
+
+        ++mNumRTPSent;
+        mNumRTPOctetsSent += rtpPacketSize - 12;
+
+        mLastRTPTime = rtpTime;
+
+        if (mTransportMode == TRANSPORT_TCP_INTERLEAVED) {
+            sp<AMessage> notify = mNotify->dup();
+            notify->setInt32("what", kWhatBinaryData);
+
+            sp<ABuffer> data = new ABuffer(rtpPacketSize);
+            memcpy(data->data(), rtp, rtpPacketSize);
+
+            notify->setInt32("channel", mRTPChannel);
+            notify->setBuffer("data", data);
+            notify->post();
+        } else {
+            sendPacket(mRTPSessionID, rtp, rtpPacketSize);
+
+#if TRACK_BANDWIDTH
+            mTotalBytesSent += rtpPacketSize->size();
+            int64_t delayUs = ALooper::GetNowUs() - mFirstPacketTimeUs;
+
+            if (delayUs > 0ll) {
+                ALOGI("approx. net bandwidth used: %.2f Mbit/sec",
+                        mTotalBytesSent * 8.0 / delayUs);
+            }
+#endif
+        }
+
+#if ENABLE_RETRANSMISSION
+        addToHistory(rtp, rtpPacketSize);
+#endif
+
+        srcOffset += rtpPacketSize;
+    }
+
+#if 0
+    int64_t timeUs;
+    CHECK(udpPackets->meta()->findInt64("timeUs", &timeUs));
+
+    ALOGI("dTimeUs = %lld us", ALooper::GetNowUs() - timeUs);
+#endif
+}
+
+#if ENABLE_RETRANSMISSION
+void Sender::addToHistory(const uint8_t *rtp, size_t rtpPacketSize) {
+    sp<ABuffer> packet = new ABuffer(rtpPacketSize);
+    memcpy(packet->data(), rtp, rtpPacketSize);
+
+    unsigned rtpSeqNo = U16_AT(&rtp[2]);
+    packet->setInt32Data(rtpSeqNo);
+
+    mHistory.push_back(packet);
+    ++mHistoryLength;
+
+    if (mHistoryLength > kMaxHistoryLength) {
+        mHistory.erase(mHistory.begin());
+        --mHistoryLength;
+    }
+}
+#endif
+
 }  // namespace android
 
diff --git a/media/libstagefright/wifi-display/source/Sender.h b/media/libstagefright/wifi-display/source/Sender.h
index e476e84..73e3d19 100644
--- a/media/libstagefright/wifi-display/source/Sender.h
+++ b/media/libstagefright/wifi-display/source/Sender.h
@@ -23,9 +23,17 @@
 namespace android {
 
 #define LOG_TRANSPORT_STREAM            0
-#define ENABLE_RETRANSMISSION           0
 #define TRACK_BANDWIDTH                 0
 
+#define ENABLE_RETRANSMISSION                   0
+
+// If retransmission is enabled the following define determines what
+// kind we support, if RETRANSMISSION_ACCORDING_TO_RFC_XXXX is 0
+// we'll send NACKs on the original RTCP channel and retransmit packets
+// on the original RTP channel, otherwise a separate channel pair is used
+// for this purpose.
+#define RETRANSMISSION_ACCORDING_TO_RFC_XXXX    0
+
 struct ABuffer;
 struct ANetworkSession;
 
@@ -51,7 +59,7 @@
 
     int32_t getRTPPort() const;
 
-    void queuePackets(int64_t timeUs, const sp<ABuffer> &packets);
+    void queuePackets(int64_t timeUs, const sp<ABuffer> &tsPackets);
     void scheduleSendSR();
 
 protected:
@@ -60,13 +68,13 @@
 
 private:
     enum {
-        kWhatQueuePackets,
+        kWhatDrainQueue,
         kWhatSendSR,
         kWhatRTPNotify,
         kWhatRTCPNotify,
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
         kWhatRTPRetransmissionNotify,
-        kWhatRTCPRetransmissionNotify
+        kWhatRTCPRetransmissionNotify,
 #endif
     };
 
@@ -75,15 +83,13 @@
     static const uint32_t kSourceID = 0xdeadbeef;
     static const size_t kMaxHistoryLength = 128;
 
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
     static const size_t kRetransmissionPortOffset = 120;
 #endif
 
     sp<ANetworkSession> mNetSession;
     sp<AMessage> mNotify;
 
-    sp<ABuffer> mTSQueue;
-
     TransportMode mTransportMode;
     AString mClientIP;
 
@@ -96,7 +102,7 @@
     int32_t mRTPSessionID;
     int32_t mRTCPSessionID;
 
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
     int32_t mRTPRetransmissionSessionID;
     int32_t mRTCPRetransmissionSessionID;
 #endif
@@ -106,12 +112,11 @@
     bool mRTPConnected;
     bool mRTCPConnected;
 
-
     int64_t mFirstOutputBufferReadyTimeUs;
     int64_t mFirstOutputBufferSentTimeUs;
 
     uint32_t mRTPSeqNo;
-#if ENABLE_RETRANSMISSION
+#if ENABLE_RETRANSMISSION && RETRANSMISSION_ACCORDING_TO_RFC_XXXX
     uint32_t mRTPRetransmissionSeqNo;
 #endif
 
@@ -133,22 +138,18 @@
     uint64_t mTotalBytesSent;
 #endif
 
+#if LOG_TRANSPORT_STREAM
+    FILE *mLogFile;
+#endif
+
     void onSendSR();
     void addSR(const sp<ABuffer> &buffer);
     void addSDES(const sp<ABuffer> &buffer);
     static uint64_t GetNowNTP();
 
-#if LOG_TRANSPORT_STREAM
-    FILE *mLogFile;
-#endif
-
-    ssize_t appendTSData(
-            const void *data, size_t size, bool timeDiscontinuity, bool flush);
-
-    void onQueuePackets(const sp<ABuffer> &packets);
-
 #if ENABLE_RETRANSMISSION
     status_t parseTSFB(const uint8_t *data, size_t size);
+    void addToHistory(const uint8_t *rtp, size_t rtpPacketSize);
 #endif
 
     status_t parseRTCP(const sp<ABuffer> &buffer);
@@ -158,6 +159,8 @@
     void notifyInitDone();
     void notifySessionDead();
 
+    void onDrainQueue(const sp<ABuffer> &udpPackets);
+
     DISALLOW_EVIL_CONSTRUCTORS(Sender);
 };
 
diff --git a/media/libstagefright/wifi-display/source/TSPacketizer.cpp b/media/libstagefright/wifi-display/source/TSPacketizer.cpp
index a5679ad..ef57a4d 100644
--- a/media/libstagefright/wifi-display/source/TSPacketizer.cpp
+++ b/media/libstagefright/wifi-display/source/TSPacketizer.cpp
@@ -314,6 +314,25 @@
         mDescriptors.push_back(descriptor);
     }
 
+    int32_t hdcpVersion;
+    if (mFormat->findInt32("hdcp-version", &hdcpVersion)) {
+        // HDCP descriptor
+
+        CHECK(hdcpVersion == 0x20 || hdcpVersion == 0x21);
+
+        sp<ABuffer> descriptor = new ABuffer(7);
+        uint8_t *data = descriptor->data();
+        data[0] = 0x05;  // descriptor_tag
+        data[1] = 5;  // descriptor_length
+        data[2] = 'H';
+        data[3] = 'D';
+        data[4] = 'C';
+        data[5] = 'P';
+        data[6] = hdcpVersion;
+
+        mDescriptors.push_back(descriptor);
+    }
+
     mFinalized = true;
 }
 
diff --git a/media/libstagefright/wifi-display/source/WifiDisplaySource.cpp b/media/libstagefright/wifi-display/source/WifiDisplaySource.cpp
index b16c5d0..78d6e62 100644
--- a/media/libstagefright/wifi-display/source/WifiDisplaySource.cpp
+++ b/media/libstagefright/wifi-display/source/WifiDisplaySource.cpp
@@ -534,9 +534,15 @@
     //   use "28 00 02 02 00000020 00000000 00000000 00 0000 0000 00 none none\r\n"
     // For 720p24:
     //   use "78 00 02 02 00008000 00000000 00000000 00 0000 0000 00 none none\r\n"
+    // For 1080p30:
+    //   use "38 00 02 02 00000080 00000000 00000000 00 0000 0000 00 none none\r\n"
     AString body = StringPrintf(
         "wfd_video_formats: "
+#if USE_1080P
+        "38 00 02 02 00000080 00000000 00000000 00 0000 0000 00 none none\r\n"
+#else
         "28 00 02 02 00000020 00000000 00000000 00 0000 0000 00 none none\r\n"
+#endif
         "wfd_audio_codecs: %s\r\n"
         "wfd_presentation_URL: rtsp://%s/wfd1.0/streamid=0 none\r\n"
         "wfd_client_rtp_ports: RTP/AVP/%s;unicast %d 0 mode=play\r\n",
@@ -773,8 +779,10 @@
 
         status_t err = makeHDCP();
         if (err != OK) {
-            ALOGE("Unable to instantiate HDCP component.");
-            return err;
+            ALOGE("Unable to instantiate HDCP component. "
+                  "Not using HDCP after all.");
+
+            mUsingHDCP = false;
         }
     }
 
diff --git a/media/libstagefright/wifi-display/source/WifiDisplaySource.h b/media/libstagefright/wifi-display/source/WifiDisplaySource.h
index 02fa0a6..1e855e7 100644
--- a/media/libstagefright/wifi-display/source/WifiDisplaySource.h
+++ b/media/libstagefright/wifi-display/source/WifiDisplaySource.h
@@ -26,6 +26,8 @@
 
 namespace android {
 
+#define USE_1080P       0
+
 struct IHDCP;
 struct IRemoteDisplayClient;
 struct ParsedMessage;
diff --git a/media/libstagefright/wifi-display/wfd.cpp b/media/libstagefright/wifi-display/wfd.cpp
index 011edab..03a1123 100644
--- a/media/libstagefright/wifi-display/wfd.cpp
+++ b/media/libstagefright/wifi-display/wfd.cpp
@@ -23,22 +23,163 @@
 
 #include <binder/ProcessState.h>
 #include <binder/IServiceManager.h>
+#include <gui/SurfaceComposerClient.h>
+#include <media/AudioSystem.h>
 #include <media/IMediaPlayerService.h>
+#include <media/IRemoteDisplay.h>
+#include <media/IRemoteDisplayClient.h>
 #include <media/stagefright/DataSource.h>
 #include <media/stagefright/foundation/ADebug.h>
 
 namespace android {
 
-}  // namespace android
-
 static void usage(const char *me) {
     fprintf(stderr,
             "usage:\n"
             "           %s -c host[:port]\tconnect to wifi source\n"
-            "           -u uri        \tconnect to an rtsp uri\n",
+            "               -u uri        \tconnect to an rtsp uri\n"
+            "               -l ip[:port] \tlisten on the specified port "
+            "(create a sink)\n",
             me);
 }
 
+struct RemoteDisplayClient : public BnRemoteDisplayClient {
+    RemoteDisplayClient();
+
+    virtual void onDisplayConnected(
+            const sp<ISurfaceTexture> &surfaceTexture,
+            uint32_t width,
+            uint32_t height,
+            uint32_t flags);
+
+    virtual void onDisplayDisconnected();
+    virtual void onDisplayError(int32_t error);
+
+    void waitUntilDone();
+
+protected:
+    virtual ~RemoteDisplayClient();
+
+private:
+    Mutex mLock;
+    Condition mCondition;
+
+    bool mDone;
+
+    sp<SurfaceComposerClient> mComposerClient;
+    sp<ISurfaceTexture> mSurfaceTexture;
+    sp<IBinder> mDisplayBinder;
+
+    DISALLOW_EVIL_CONSTRUCTORS(RemoteDisplayClient);
+};
+
+RemoteDisplayClient::RemoteDisplayClient()
+    : mDone(false) {
+    mComposerClient = new SurfaceComposerClient;
+    CHECK_EQ(mComposerClient->initCheck(), (status_t)OK);
+}
+
+RemoteDisplayClient::~RemoteDisplayClient() {
+}
+
+void RemoteDisplayClient::onDisplayConnected(
+        const sp<ISurfaceTexture> &surfaceTexture,
+        uint32_t width,
+        uint32_t height,
+        uint32_t flags) {
+    ALOGI("onDisplayConnected width=%u, height=%u, flags = 0x%08x",
+          width, height, flags);
+
+    mSurfaceTexture = surfaceTexture;
+    mDisplayBinder = mComposerClient->createDisplay(
+            String8("foo"), false /* secure */);
+
+    SurfaceComposerClient::openGlobalTransaction();
+    mComposerClient->setDisplaySurface(mDisplayBinder, mSurfaceTexture);
+
+    Rect layerStackRect(1280, 720);  // XXX fix this.
+    Rect displayRect(1280, 720);
+
+    mComposerClient->setDisplayProjection(
+            mDisplayBinder, 0 /* 0 degree rotation */,
+            layerStackRect,
+            displayRect);
+
+    SurfaceComposerClient::closeGlobalTransaction();
+}
+
+void RemoteDisplayClient::onDisplayDisconnected() {
+    ALOGI("onDisplayDisconnected");
+
+    Mutex::Autolock autoLock(mLock);
+    mDone = true;
+    mCondition.broadcast();
+}
+
+void RemoteDisplayClient::onDisplayError(int32_t error) {
+    ALOGI("onDisplayError error=%d", error);
+
+    Mutex::Autolock autoLock(mLock);
+    mDone = true;
+    mCondition.broadcast();
+}
+
+void RemoteDisplayClient::waitUntilDone() {
+    Mutex::Autolock autoLock(mLock);
+    while (!mDone) {
+        mCondition.wait(mLock);
+    }
+}
+
+static status_t enableAudioSubmix(bool enable) {
+    status_t err = AudioSystem::setDeviceConnectionState(
+            AUDIO_DEVICE_IN_REMOTE_SUBMIX,
+            enable
+                ? AUDIO_POLICY_DEVICE_STATE_AVAILABLE
+                : AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
+            NULL /* device_address */);
+
+    if (err != OK) {
+        return err;
+    }
+
+    err = AudioSystem::setDeviceConnectionState(
+            AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
+            enable
+                ? AUDIO_POLICY_DEVICE_STATE_AVAILABLE
+                : AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
+            NULL /* device_address */);
+
+    return err;
+}
+
+static void createSource(const AString &addr, int32_t port) {
+    sp<IServiceManager> sm = defaultServiceManager();
+    sp<IBinder> binder = sm->getService(String16("media.player"));
+    sp<IMediaPlayerService> service =
+        interface_cast<IMediaPlayerService>(binder);
+
+    CHECK(service.get() != NULL);
+
+    enableAudioSubmix(true /* enable */);
+
+    String8 iface;
+    iface.append(addr.c_str());
+    iface.append(StringPrintf(":%d", port).c_str());
+
+    sp<RemoteDisplayClient> client = new RemoteDisplayClient;
+    sp<IRemoteDisplay> display = service->listenForRemoteDisplay(client, iface);
+
+    client->waitUntilDone();
+
+    display->dispose();
+    display.clear();
+
+    enableAudioSubmix(false /* enable */);
+}
+
+}  // namespace android
+
 int main(int argc, char **argv) {
     using namespace android;
 
@@ -50,6 +191,9 @@
     int32_t connectToPort = -1;
     AString uri;
 
+    AString listenOnAddr;
+    int32_t listenOnPort = -1;
+
     int res;
     while ((res = getopt(argc, argv, "hc:l:u:")) >= 0) {
         switch (res) {
@@ -81,6 +225,28 @@
                 break;
             }
 
+            case 'l':
+            {
+                const char *colonPos = strrchr(optarg, ':');
+
+                if (colonPos == NULL) {
+                    listenOnAddr = optarg;
+                    listenOnPort = WifiDisplaySource::kWifiDisplayDefaultPort;
+                } else {
+                    listenOnAddr.setTo(optarg, colonPos - optarg);
+
+                    char *end;
+                    listenOnPort = strtol(colonPos + 1, &end, 10);
+
+                    if (*end != '\0' || end == colonPos + 1
+                            || listenOnPort < 1 || listenOnPort > 65535) {
+                        fprintf(stderr, "Illegal port specified.\n");
+                        exit(1);
+                    }
+                }
+                break;
+            }
+
             case '?':
             case 'h':
             default:
@@ -89,6 +255,18 @@
         }
     }
 
+    if (connectToPort >= 0 && listenOnPort >= 0) {
+        fprintf(stderr,
+                "You can connect to a source or create one, "
+                "but not both at the same time.\n");
+        exit(1);
+    }
+
+    if (listenOnPort >= 0) {
+        createSource(listenOnAddr, listenOnPort);
+        exit(0);
+    }
+
     if (connectToPort < 0 && uri.empty()) {
         fprintf(stderr,
                 "You need to select either source host or uri.\n");
diff --git a/services/audioflinger/AudioResamplerSinc.cpp b/services/audioflinger/AudioResamplerSinc.cpp
index 7d3681c..d68b839 100644
--- a/services/audioflinger/AudioResamplerSinc.cpp
+++ b/services/audioflinger/AudioResamplerSinc.cpp
@@ -470,6 +470,9 @@
      *
      */
 
+    mVolumeSIMD[0] = 0;
+    mVolumeSIMD[1] = 0;
+
     // Load the constants for coefficients
     int ok = pthread_once(&once_control, init_routine);
     if (ok != 0) {
@@ -494,6 +497,12 @@
     mRingFull = mImpulse + (numCoefs+1)*mChannelCount;
 }
 
+void AudioResamplerSinc::setVolume(int16_t left, int16_t right) {
+    AudioResampler::setVolume(left, right);
+    mVolumeSIMD[0] = int32_t(left)<<16;
+    mVolumeSIMD[1] = int32_t(right)<<16;
+}
+
 void AudioResamplerSinc::resample(int32_t* out, size_t outFrameCount,
             AudioBufferProvider* provider)
 {
@@ -568,11 +577,9 @@
         }
 
         // handle boundary case
-        int32_t l, r;
         while (CC_LIKELY(outputIndex < outputSampleCount)) {
-            filterCoefficient<CHANNELS>(l, r, phaseFraction, impulse, vRL);
-            out[outputIndex++] += l;
-            out[outputIndex++] += r;
+            filterCoefficient<CHANNELS>(&out[outputIndex], phaseFraction, impulse, vRL);
+            outputIndex += 2;
 
             phaseFraction += phaseIncrement;
             const size_t phaseIndex = phaseFraction >> kNumPhaseBits;
@@ -628,19 +635,22 @@
 
 template<int CHANNELS>
 void AudioResamplerSinc::filterCoefficient(
-        int32_t& l, int32_t& r, uint32_t phase, const int16_t *samples, uint32_t vRL)
+        int32_t* out, uint32_t phase, const int16_t *samples, uint32_t vRL)
 {
+    // NOTE: be very careful when modifying the code here. register
+    // pressure is very high and a small change might cause the compiler
+    // to generate far less efficient code.
+    // Always sanity check the result with objdump or test-resample.
+
     // compute the index of the coefficient on the positive side and
     // negative side
     const Constants& c(*mConstants);
+    const int32_t ONE = c.cMask | c.pMask;
     uint32_t indexP = ( phase & c.cMask) >> c.cShift;
-    uint32_t indexN = (-phase & c.cMask) >> c.cShift;
     uint32_t lerpP  = ( phase & c.pMask) >> c.pShift;
-    uint32_t lerpN  = (-phase & c.pMask) >> c.pShift;
-    if ((indexP == 0) && (lerpP == 0)) {
-        indexN = c.cMask >> c.cShift;
-        lerpN  = c.pMask >> c.pShift;
-    }
+    uint32_t indexN = ((ONE-phase) & c.cMask) >> c.cShift;
+    uint32_t lerpN  = ((ONE-phase) & c.pMask) >> c.pShift;
+
     const size_t offset = c.halfNumCoefs;
     indexP *= offset;
     indexN *= offset;
@@ -650,19 +660,19 @@
     int16_t const* sP = samples;
     int16_t const* sN = samples + CHANNELS;
 
-    l = 0;
-    r = 0;
     size_t count = offset;
 
     if (!USE_NEON) {
+        int32_t l = 0;
+        int32_t r = 0;
         for (size_t i=0 ; i<count ; i++) {
             interpolate<CHANNELS>(l, r, coefsP++, offset, lerpP, sP);
             sP -= CHANNELS;
             interpolate<CHANNELS>(l, r, coefsN++, offset, lerpN, sN);
             sN += CHANNELS;
         }
-        l = 2 * mulRL(1, l, vRL);
-        r = 2 * mulRL(0, r, vRL);
+        out[0] += 2 * mulRL(1, l, vRL);
+        out[1] += 2 * mulRL(0, r, vRL);
     } else if (CHANNELS == 1) {
         int32_t const* coefsP1 = coefsP + offset;
         int32_t const* coefsN1 = coefsN + offset;
@@ -670,15 +680,16 @@
         asm (
             "vmov.32        d2[0], %[lerpP]          \n"    // load the positive phase
             "vmov.32        d2[1], %[lerpN]          \n"    // load the negative phase
-            "veor           q0, q0                   \n"    // result, initialize to 0
+            "veor           q0, q0, q0               \n"    // result, initialize to 0
+            "vshl.s32       d2, d2, #16              \n"    // convert to 32 bits
 
             "1:                                      \n"
             "vld1.16        { d4}, [%[sP]]           \n"    // load 4 16-bits stereo samples
-            "vld1.32        { q8}, [%[coefsP0]]!     \n"    // load 4 32-bits coefs
-            "vld1.32        { q9}, [%[coefsP1]]!     \n"    // load 4 32-bits coefs for interpolation
+            "vld1.32        { q8}, [%[coefsP0]:128]! \n"    // load 4 32-bits coefs
+            "vld1.32        { q9}, [%[coefsP1]:128]! \n"    // load 4 32-bits coefs for interpolation
             "vld1.16        { d6}, [%[sN]]!          \n"    // load 4 16-bits stereo samples
-            "vld1.32        {q10}, [%[coefsN0]]!     \n"    // load 4 32-bits coefs
-            "vld1.32        {q11}, [%[coefsN1]]!     \n"    // load 4 32-bits coefs for interpolation
+            "vld1.32        {q10}, [%[coefsN0]:128]! \n"    // load 4 32-bits coefs
+            "vld1.32        {q11}, [%[coefsN1]:128]! \n"    // load 4 32-bits coefs for interpolation
 
             "vrev64.16      d4, d4                   \n"    // reverse 2 frames of the positive side
 
@@ -703,12 +714,16 @@
 
             "bne            1b                       \n"    // loop
 
+            "vld1.s32       {d2}, [%[vLR]]           \n"    // load volumes
+            "vld1.s32       {d3}, %[out]             \n"    // load the output
             "vpadd.s32      d0, d0, d1               \n"    // add all 4 partial sums
             "vpadd.s32      d0, d0, d0               \n"    // together
+            "vdup.i32       d0, d0[0]                \n"    // interleave L,R channels
+            "vqrdmulh.s32   d0, d0, d2               \n"    // apply volume
+            "vadd.s32       d3, d3, d0               \n"    // accumulate result
+            "vst1.s32       {d0}, %[out]             \n"    // store result
 
-            "vmov.s32       %[l], d0[0]              \n"    // save result in ARM register
-
-            : [l]  "=r" (l),
+            : [out]     "=Uv" (out[0]),
               [count]   "+r" (count),
               [coefsP0] "+r" (coefsP),
               [coefsP1] "+r" (coefsP1),
@@ -716,16 +731,14 @@
               [coefsN1] "+r" (coefsN1),
               [sP]      "+r" (sP),
               [sN]      "+r" (sN)
-            : [lerpP]   "r" (lerpP<<16),
-              [lerpN]   "r" (lerpN<<16),
-              [vRL]     "r" (vRL)
+            : [lerpP]   "r" (lerpP),
+              [lerpN]   "r" (lerpN),
+              [vLR]     "r" (mVolumeSIMD)
             : "cc", "memory",
               "q0", "q1", "q2", "q3",
               "q8", "q9", "q10", "q11",
               "q12", "q14"
         );
-        l = 2 * mulRL(1, l, vRL);
-        r = l;
     } else if (CHANNELS == 2) {
         int32_t const* coefsP1 = coefsP + offset;
         int32_t const* coefsN1 = coefsN + offset;
@@ -733,16 +746,17 @@
         asm (
             "vmov.32        d2[0], %[lerpP]          \n"    // load the positive phase
             "vmov.32        d2[1], %[lerpN]          \n"    // load the negative phase
-            "veor           q0, q0                   \n"    // result, initialize to 0
-            "veor           q4, q4                   \n"    // result, initialize to 0
+            "veor           q0, q0, q0               \n"    // result, initialize to 0
+            "veor           q4, q4, q4               \n"    // result, initialize to 0
+            "vshl.s32       d2, d2, #16              \n"    // convert to 32 bits
 
             "1:                                      \n"
             "vld2.16        {d4,d5}, [%[sP]]         \n"    // load 4 16-bits stereo samples
-            "vld1.32        { q8}, [%[coefsP0]]!     \n"    // load 4 32-bits coefs
-            "vld1.32        { q9}, [%[coefsP1]]!     \n"    // load 4 32-bits coefs for interpolation
+            "vld1.32        { q8}, [%[coefsP0]:128]! \n"    // load 4 32-bits coefs
+            "vld1.32        { q9}, [%[coefsP1]:128]! \n"    // load 4 32-bits coefs for interpolation
             "vld2.16        {d6,d7}, [%[sN]]!        \n"    // load 4 16-bits stereo samples
-            "vld1.32        {q10}, [%[coefsN0]]!     \n"    // load 4 32-bits coefs
-            "vld1.32        {q11}, [%[coefsN1]]!     \n"    // load 4 32-bits coefs for interpolation
+            "vld1.32        {q10}, [%[coefsN0]:128]! \n"    // load 4 32-bits coefs
+            "vld1.32        {q11}, [%[coefsN1]:128]! \n"    // load 4 32-bits coefs for interpolation
 
             "vrev64.16      d4, d4                   \n"    // reverse 2 frames of the positive side
             "vrev64.16      d5, d5                   \n"    // reverse 2 frames of the positive side
@@ -774,16 +788,18 @@
 
             "bne            1b                       \n"    // loop
 
-            "vpadd.s32      d0, d0, d1               \n"    // add all 4 partial sums
-            "vpadd.s32      d8, d8, d9               \n"    // add all 4 partial sums
+            "vld1.s32       {d2}, [%[vLR]]           \n"    // load volumes
+            "vld1.s32       {d3}, %[out]             \n"    // load the output
+            "vpadd.s32      d0, d0, d1               \n"    // add all 4 partial sums from q0
+            "vpadd.s32      d8, d8, d9               \n"    // add all 4 partial sums from q4
             "vpadd.s32      d0, d0, d0               \n"    // together
             "vpadd.s32      d8, d8, d8               \n"    // together
+            "vtrn.s32       d0, d8                   \n"    // interlace L,R channels
+            "vqrdmulh.s32   d0, d0, d2               \n"    // apply volume
+            "vadd.s32       d3, d3, d0               \n"    // accumulate result
+            "vst1.s32       {d0}, %[out]             \n"    // store result
 
-            "vmov.s32       %[l], d0[0]              \n"    // save result in ARM register
-            "vmov.s32       %[r], d8[0]              \n"    // save result in ARM register
-
-            : [l]  "=r" (l),
-              [r]  "=r" (r),
+            : [out]     "=Uv" (out[0]),
               [count]   "+r" (count),
               [coefsP0] "+r" (coefsP),
               [coefsP1] "+r" (coefsP1),
@@ -791,16 +807,14 @@
               [coefsN1] "+r" (coefsN1),
               [sP]      "+r" (sP),
               [sN]      "+r" (sN)
-            : [lerpP]   "r" (lerpP<<16),
-              [lerpN]   "r" (lerpN<<16),
-              [vRL]     "r" (vRL)
+            : [lerpP]   "r" (lerpP),
+              [lerpN]   "r" (lerpN),
+              [vLR]     "r" (mVolumeSIMD)
             : "cc", "memory",
               "q0", "q1", "q2", "q3", "q4",
               "q8", "q9", "q10", "q11",
               "q12", "q13", "q14", "q15"
         );
-        l = 2 * mulRL(1, l, vRL);
-        r = 2 * mulRL(0, r, vRL);
     }
 }
 
diff --git a/services/audioflinger/AudioResamplerSinc.h b/services/audioflinger/AudioResamplerSinc.h
index 1b14019..09c6866 100644
--- a/services/audioflinger/AudioResamplerSinc.h
+++ b/services/audioflinger/AudioResamplerSinc.h
@@ -44,13 +44,15 @@
 private:
     void init();
 
+    virtual void setVolume(int16_t left, int16_t right);
+
     template<int CHANNELS>
     void resample(int32_t* out, size_t outFrameCount,
             AudioBufferProvider* provider);
 
     template<int CHANNELS>
     inline void filterCoefficient(
-            int32_t& l, int32_t& r, uint32_t phase, const int16_t *samples, uint32_t vRL);
+            int32_t* out, uint32_t phase, const int16_t *samples, uint32_t vRL);
 
     template<int CHANNELS>
     inline void interpolate(
@@ -65,6 +67,7 @@
     int16_t *mState;
     int16_t *mImpulse;
     int16_t *mRingFull;
+    int32_t mVolumeSIMD[2];
 
     const int32_t * mFirCoefs;
     static const int32_t mFirCoefsDown[];
@@ -75,14 +78,11 @@
     static const int32_t RESAMPLE_FIR_LERP_INT_BITS  = 7;
 
     struct Constants {
-        // we have 16 coefs samples per zero-crossing
         int coefsBits;
         int cShift;
         uint32_t cMask;
-
         int pShift;
         uint32_t pMask;
-
         // number of zero-crossing on each side
         unsigned int halfNumCoefs;
     };
diff --git a/services/audioflinger/test-resample.cpp b/services/audioflinger/test-resample.cpp
index 3b66530..b082e8c 100644
--- a/services/audioflinger/test-resample.cpp
+++ b/services/audioflinger/test-resample.cpp
@@ -177,7 +177,7 @@
             double t = double(i) / input_freq;
             double y = sin(M_PI * k * t * t);
             int16_t yi = floor(y * 32767.0 + 0.5);
-            for (size_t j=0 ; j<channels ; j++) {
+            for (size_t j=0 ; j<(size_t)channels ; j++) {
                 in[i*channels + j] = yi / (1+j);
             }
         }