Increment version and update common jar

AndroidManifest.xml

@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.limelight"
-    android:versionCode="31"
-    android:versionName="2.5.3.1" >
+    android:versionCode="34"
+    android:versionName="2.5.5" >
 
     <uses-sdk
         android:minSdkVersion="16"

gen/com/limelight/R.java

@@ -49,13 +49,14 @@ or to a theme attribute in the form "<code>?[<i>package</i>:][<i>type</i>:]<i>na
         public static final int config720p30Selected=0x7f08000f;
         public static final int config720p60Selected=0x7f080010;
         public static final int decoderConfigGroup=0x7f080002;
+        public static final int disableToasts=0x7f080014;
         public static final int discoveryText=0x7f08000b;
-        public static final int enableSops=0x7f080014;
+        public static final int enableSops=0x7f080016;
         public static final int hardwareDec=0x7f080005;
         public static final int hostTextView=0x7f080000;
         public static final int manuallyAddPc=0x7f08000c;
         public static final int pcListView=0x7f080008;
-        public static final int rowTextView=0x7f080016;
+        public static final int rowTextView=0x7f080017;
         public static final int settingsButton=0x7f08000d;
         public static final int softwareDec=0x7f080003;
         public static final int streamConfigGroup=0x7f08000e;

jni/evdev_reader/Android.mk

@@ -0,0 +1,12 @@
+# Android.mk for Limelight's Evdev Reader
+MY_LOCAL_PATH := $(call my-dir)
+
+include $(call all-subdir-makefiles)
+
+LOCAL_PATH := $(MY_LOCAL_PATH)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE    := evdev_reader
+LOCAL_SRC_FILES := evdev_reader.c
+
+include $(BUILD_SHARED_LIBRARY)

jni/evdev_reader/evdev_reader.c

@@ -0,0 +1,65 @@
+#include <stdlib.h>
+#include <jni.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <linux/input.h>
+#include <unistd.h>
+
+JNIEXPORT jint JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_open(JNIEnv *env, jobject this, jstring absolutePath) {
+	const char *path;
+	
+	path = (*env)->GetStringUTFChars(env, absolutePath, NULL);
+	
+	return open(path, O_RDWR);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_grab(JNIEnv *env, jobject this, jint fd) {
+    return ioctl(fd, EVIOCGRAB, 1) == 0;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_ungrab(JNIEnv *env, jobject this, jint fd) {
+    return ioctl(fd, EVIOCGRAB, 0) == 0;
+}
+
+// isMouse() and friends are based on Android's EventHub.cpp
+
+#define test_bit(bit, array)    (array[bit/8] & (1<<(bit%8)))
+
+JNIEXPORT jboolean JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_isMouse(JNIEnv *env, jobject this, jint fd) {
+    unsigned char keyBitmask[(KEY_MAX + 1) / 8];
+    unsigned char relBitmask[(REL_MAX + 1) / 8];
+    
+    ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keyBitmask)), keyBitmask);
+    ioctl(fd, EVIOCGBIT(EV_REL, sizeof(relBitmask)), relBitmask);
+    
+    // If this device has all required features of a mouse, it's a mouse!
+    return test_bit(BTN_MOUSE, keyBitmask) &&
+        test_bit(REL_X, relBitmask) &&
+        test_bit(REL_Y, relBitmask);
+}
+
+JNIEXPORT jint JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_read(JNIEnv *env, jobject this, jint fd, jbyteArray buffer) {
+    jint ret;
+    jbyte *data = (*env)->GetByteArrayElements(env, buffer, NULL);
+    if (data == NULL) {
+        return -1;
+    }
+
+    ret = read(fd, data, sizeof(struct input_event));
+    
+    (*env)->ReleaseByteArrayElements(env, buffer, data, 0);
+
+	return ret;
+}
+
+JNIEXPORT jint JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_close(JNIEnv *env, jobject this, jint fd) {
+	return close(fd);
+}

jni/nv_opus_dec/libopus/build_android.sh

@@ -14,7 +14,8 @@ export PATH=$PATH:$TOOLCHAIN_PATH/bin
     --build=x86_64-unknown-linux-gnu \
     --host=$TOOLCHAIN_BIN_PREFIX \
     --target=$TOOLCHAIN_BIN_PREFIX \
-    CFLAGS="--sysroot=$SYSROOT -O2 $ADDI_CFLAGS"
+    CFLAGS="--sysroot=$SYSROOT -O2 $ADDI_CFLAGS" \
+    $ADDI_CONFIGURE_FLAGS
 make clean
 make -j$PARALLEL_JOBS
 mkdir android/$CPU
@@ -28,6 +29,7 @@ SYSROOT_CPU=mips
 TOOLCHAIN_BIN_PREFIX=mipsel-linux-android
 TOOLCHAIN_DIR=mipsel-linux-android-4.9
 ADDI_CFLAGS="-mips32 -mhard-float -EL -mno-dsp"
+ADDI_CONFIGURE_FLAGS="--enable-fixed-point" # fixed point
 build_one
 }
 
@@ -38,6 +40,7 @@ SYSROOT_CPU=mips64
 TOOLCHAIN_BIN_PREFIX=mips64el-linux-android
 TOOLCHAIN_DIR=mips64el-linux-android-4.9
 ADDI_CFLAGS="-mips64r6"
+ADDI_CONFIGURE_FLAGS="--enable-fixed-point" # fixed point
 build_one
 }
 
@@ -48,6 +51,7 @@ SYSROOT_CPU=x86
 TOOLCHAIN_BIN_PREFIX=i686-linux-android
 TOOLCHAIN_DIR=x86-4.9
 ADDI_CFLAGS="-march=i686 -mtune=atom -mstackrealign -msse -msse2 -msse3 -mssse3 -mfpmath=sse -m32"
+ADDI_CONFIGURE_FLAGS="" # floating point for SSE optimizations
 build_one
 }
 
@@ -58,6 +62,7 @@ SYSROOT_CPU=x86_64
 TOOLCHAIN_BIN_PREFIX=x86_64-linux-android
 TOOLCHAIN_DIR=x86_64-4.9
 ADDI_CFLAGS="-msse -msse2 -msse3 -mssse3 -msse4 -msse4.1 -msse4.2 -mpopcnt -m64"
+ADDI_CONFIGURE_FLAGS="" # floating point for SSE optimizations
 build_one
 }
 
@@ -69,10 +74,12 @@ TOOLCHAIN_BIN_PREFIX=arm-linux-androideabi
 TOOLCHAIN_DIR=arm-linux-androideabi-4.9
 ADDI_CFLAGS="-marm -mfpu=vfpv3-d16"
 ADDI_LDFLAGS=""
-ADDI_CONFIGURE_FLAGS=""
+ADDI_CONFIGURE_FLAGS="--enable-fixed-point" # fixed point for NEON, EDSP, Media
 build_one
 }
 
+# ARMv8 doesn't currently have assembly in the opus project. We still use fixed point
+# anyway in the hopes that it will be more performant even without assembly.
 function build_armv8
 {
 CPU=aarch64
@@ -81,7 +88,7 @@ TOOLCHAIN_BIN_PREFIX=aarch64-linux-android
 TOOLCHAIN_DIR=aarch64-linux-android-4.9
 ADDI_CFLAGS=""
 ADDI_LDFLAGS=""
-ADDI_CONFIGURE_FLAGS=""
+ADDI_CONFIGURE_FLAGS="--enable-fixed-point"
 build_one
 }
 

jni/nv_opus_dec/libopus/inc/opus.h

@@ -592,6 +592,20 @@ OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_packet_get_nb_samples(const unsigne
   * @retval OPUS_INVALID_PACKET The compressed data passed is corrupted or of an unsupported type
   */
 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_decoder_get_nb_samples(const OpusDecoder *dec, const unsigned char packet[], opus_int32 len) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2);
+
+/** Applies soft-clipping to bring a float signal within the [-1,1] range. If
+  * the signal is already in that range, nothing is done. If there are values
+  * outside of [-1,1], then the signal is clipped as smoothly as possible to
+  * both fit in the range and avoid creating excessive distortion in the
+  * process.
+  * @param [in,out] pcm <tt>float*</tt>: Input PCM and modified PCM
+  * @param [in] frame_size <tt>int</tt> Number of samples per channel to process
+  * @param [in] channels <tt>int</tt>: Number of channels
+  * @param [in,out] softclip_mem <tt>float*</tt>: State memory for the soft clipping process (one float per channel, initialized to zero)
+  */
+OPUS_EXPORT void opus_pcm_soft_clip(float *pcm, int frame_size, int channels, float *softclip_mem);
+
+
 /**@}*/
 
 /** @defgroup opus_repacketizer Repacketizer
@@ -897,6 +911,64 @@ OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_repacketizer_get_nb_frames(OpusRepa
   */
 OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_repacketizer_out(OpusRepacketizer *rp, unsigned char *data, opus_int32 maxlen) OPUS_ARG_NONNULL(1);
 
+/** Pads a given Opus packet to a larger size (possibly changing the TOC sequence).
+  * @param[in,out] data <tt>const unsigned char*</tt>: The buffer containing the
+  *                                                   packet to pad.
+  * @param len <tt>opus_int32</tt>: The size of the packet.
+  *                                 This must be at least 1.
+  * @param new_len <tt>opus_int32</tt>: The desired size of the packet after padding.
+  *                                 This must be at least as large as len.
+  * @returns an error code
+  * @retval #OPUS_OK \a on success.
+  * @retval #OPUS_BAD_ARG \a len was less than 1 or new_len was less than len.
+  * @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet.
+  */
+OPUS_EXPORT int opus_packet_pad(unsigned char *data, opus_int32 len, opus_int32 new_len);
+
+/** Remove all padding from a given Opus packet and rewrite the TOC sequence to
+  * minimize space usage.
+  * @param[in,out] data <tt>const unsigned char*</tt>: The buffer containing the
+  *                                                   packet to strip.
+  * @param len <tt>opus_int32</tt>: The size of the packet.
+  *                                 This must be at least 1.
+  * @returns The new size of the output packet on success, or an error code
+  *          on failure.
+  * @retval #OPUS_BAD_ARG \a len was less than 1.
+  * @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet.
+  */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_packet_unpad(unsigned char *data, opus_int32 len);
+
+/** Pads a given Opus multi-stream packet to a larger size (possibly changing the TOC sequence).
+  * @param[in,out] data <tt>const unsigned char*</tt>: The buffer containing the
+  *                                                   packet to pad.
+  * @param len <tt>opus_int32</tt>: The size of the packet.
+  *                                 This must be at least 1.
+  * @param new_len <tt>opus_int32</tt>: The desired size of the packet after padding.
+  *                                 This must be at least 1.
+  * @param nb_streams <tt>opus_int32</tt>: The number of streams (not channels) in the packet.
+  *                                 This must be at least as large as len.
+  * @returns an error code
+  * @retval #OPUS_OK \a on success.
+  * @retval #OPUS_BAD_ARG \a len was less than 1.
+  * @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet.
+  */
+OPUS_EXPORT int opus_multistream_packet_pad(unsigned char *data, opus_int32 len, opus_int32 new_len, int nb_streams);
+
+/** Remove all padding from a given Opus multi-stream packet and rewrite the TOC sequence to
+  * minimize space usage.
+  * @param[in,out] data <tt>const unsigned char*</tt>: The buffer containing the
+  *                                                   packet to strip.
+  * @param len <tt>opus_int32</tt>: The size of the packet.
+  *                                 This must be at least 1.
+  * @param nb_streams <tt>opus_int32</tt>: The number of streams (not channels) in the packet.
+  *                                 This must be at least 1.
+  * @returns The new size of the output packet on success, or an error code
+  *          on failure.
+  * @retval #OPUS_BAD_ARG \a len was less than 1 or new_len was less than len.
+  * @retval #OPUS_INVALID_PACKET \a data did not contain a valid Opus packet.
+  */
+OPUS_EXPORT OPUS_WARN_UNUSED_RESULT opus_int32 opus_multistream_packet_unpad(unsigned char *data, opus_int32 len, int nb_streams);
+
 /**@}*/
 
 #ifdef __cplusplus

jni/nv_opus_dec/libopus/inc/opus_custom.h

@@ -42,15 +42,15 @@ extern "C" {
 #endif
 
 #ifdef CUSTOM_MODES
-#define OPUS_CUSTOM_EXPORT OPUS_EXPORT
-#define OPUS_CUSTOM_EXPORT_STATIC OPUS_EXPORT
+# define OPUS_CUSTOM_EXPORT OPUS_EXPORT
+# define OPUS_CUSTOM_EXPORT_STATIC OPUS_EXPORT
 #else
-#define OPUS_CUSTOM_EXPORT
-#ifdef CELT_C
-#define OPUS_CUSTOM_EXPORT_STATIC static inline
-#else
-#define OPUS_CUSTOM_EXPORT_STATIC
-#endif
+# define OPUS_CUSTOM_EXPORT
+# ifdef OPUS_BUILD
+#  define OPUS_CUSTOM_EXPORT_STATIC static OPUS_INLINE
+# else
+#  define OPUS_CUSTOM_EXPORT_STATIC
+# endif
 #endif
 
 /** @defgroup opus_custom Opus Custom
@@ -126,6 +126,9 @@ OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT OpusCustomMode *opus_custom_mode_crea
   */
 OPUS_CUSTOM_EXPORT void opus_custom_mode_destroy(OpusCustomMode *mode);
 
+
+#if !defined(OPUS_BUILD) || defined(CELT_ENCODER_C)
+
 /* Encoder */
 /** Gets the size of an OpusCustomEncoder structure.
   * @param [in] mode <tt>OpusCustomMode *</tt>: Mode configuration
@@ -137,6 +140,28 @@ OPUS_CUSTOM_EXPORT_STATIC OPUS_WARN_UNUSED_RESULT int opus_custom_encoder_get_si
     int channels
 ) OPUS_ARG_NONNULL(1);
 
+# ifdef CUSTOM_MODES
+/** Initializes a previously allocated encoder state
+  * The memory pointed to by st must be the size returned by opus_custom_encoder_get_size.
+  * This is intended for applications which use their own allocator instead of malloc.
+  * @see opus_custom_encoder_create(),opus_custom_encoder_get_size()
+  * To reset a previously initialized state use the OPUS_RESET_STATE CTL.
+  * @param [in] st <tt>OpusCustomEncoder*</tt>: Encoder state
+  * @param [in] mode <tt>OpusCustomMode *</tt>: Contains all the information about the characteristics of
+  *  the stream (must be the same characteristics as used for the
+  *  decoder)
+  * @param [in] channels <tt>int</tt>: Number of channels
+  * @return OPUS_OK Success or @ref opus_errorcodes
+  */
+OPUS_CUSTOM_EXPORT int opus_custom_encoder_init(
+    OpusCustomEncoder *st,
+    const OpusCustomMode *mode,
+    int channels
+) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2);
+# endif
+#endif
+
+
 /** Creates a new encoder state. Each stream needs its own encoder
   * state (can't be shared across simultaneous streams).
   * @param [in] mode <tt>OpusCustomMode*</tt>: Contains all the information about the characteristics of
@@ -152,23 +177,6 @@ OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT OpusCustomEncoder *opus_custom_encode
     int *error
 ) OPUS_ARG_NONNULL(1);
 
-/** Initializes a previously allocated encoder state
-  * The memory pointed to by st must be the size returned by opus_custom_encoder_get_size.
-  * This is intended for applications which use their own allocator instead of malloc.
-  * @see opus_custom_encoder_create(),opus_custom_encoder_get_size()
-  * To reset a previously initialized state use the OPUS_RESET_STATE CTL.
-  * @param [in] st <tt>OpusCustomEncoder*</tt>: Encoder state
-  * @param [in] mode <tt>OpusCustomMode *</tt>: Contains all the information about the characteristics of
-  *  the stream (must be the same characteristics as used for the
-  *  decoder)
-  * @param [in] channels <tt>int</tt>: Number of channels
-  * @return OPUS_OK Success or @ref opus_errorcodes
-  */
-OPUS_CUSTOM_EXPORT_STATIC int opus_custom_encoder_init(
-    OpusCustomEncoder *st,
-    const OpusCustomMode *mode,
-    int channels
-) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2);
 
 /** Destroys a an encoder state.
   * @param[in] st <tt>OpusCustomEncoder*</tt>: State to be freed.
@@ -229,6 +237,8 @@ OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT int opus_custom_encode(
   */
 OPUS_CUSTOM_EXPORT int opus_custom_encoder_ctl(OpusCustomEncoder * OPUS_RESTRICT st, int request, ...) OPUS_ARG_NONNULL(1);
 
+
+#if !defined(OPUS_BUILD) || defined(CELT_DECODER_C)
 /* Decoder */
 
 /** Gets the size of an OpusCustomDecoder structure.
@@ -241,20 +251,6 @@ OPUS_CUSTOM_EXPORT_STATIC OPUS_WARN_UNUSED_RESULT int opus_custom_decoder_get_si
     int channels
 ) OPUS_ARG_NONNULL(1);
 
-/** Creates a new decoder state. Each stream needs its own decoder state (can't
-  * be shared across simultaneous streams).
-  * @param [in] mode <tt>OpusCustomMode</tt>: Contains all the information about the characteristics of the
-  *          stream (must be the same characteristics as used for the encoder)
-  * @param [in] channels <tt>int</tt>: Number of channels
-  * @param [out] error <tt>int*</tt>: Returns an error code
-  * @return Newly created decoder state.
-  */
-OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT OpusCustomDecoder *opus_custom_decoder_create(
-    const OpusCustomMode *mode,
-    int channels,
-    int *error
-) OPUS_ARG_NONNULL(1);
-
 /** Initializes a previously allocated decoder state
   * The memory pointed to by st must be the size returned by opus_custom_decoder_get_size.
   * This is intended for applications which use their own allocator instead of malloc.
@@ -273,6 +269,23 @@ OPUS_CUSTOM_EXPORT_STATIC int opus_custom_decoder_init(
     int channels
 ) OPUS_ARG_NONNULL(1) OPUS_ARG_NONNULL(2);
 
+#endif
+
+
+/** Creates a new decoder state. Each stream needs its own decoder state (can't
+  * be shared across simultaneous streams).
+  * @param [in] mode <tt>OpusCustomMode</tt>: Contains all the information about the characteristics of the
+  *          stream (must be the same characteristics as used for the encoder)
+  * @param [in] channels <tt>int</tt>: Number of channels
+  * @param [out] error <tt>int*</tt>: Returns an error code
+  * @return Newly created decoder state.
+  */
+OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT OpusCustomDecoder *opus_custom_decoder_create(
+    const OpusCustomMode *mode,
+    int channels,
+    int *error
+) OPUS_ARG_NONNULL(1);
+
 /** Destroys a an decoder state.
   * @param[in] st <tt>OpusCustomDecoder*</tt>: State to be freed.
   */

jni/nv_opus_dec/libopus/inc/opus_defines.h

@@ -46,7 +46,7 @@ extern "C" {
 #define OPUS_OK                0
 /** One or more invalid/out of range arguments @hideinitializer*/
 #define OPUS_BAD_ARG          -1
-/** The mode struct passed is invalid @hideinitializer*/
+/** Not enough bytes allocated in the buffer @hideinitializer*/
 #define OPUS_BUFFER_TOO_SMALL -2
 /** An internal error was detected @hideinitializer*/
 #define OPUS_INTERNAL_ERROR   -3
@@ -98,6 +98,18 @@ extern "C" {
 # define OPUS_RESTRICT restrict
 #endif
 
+#if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) )
+# if OPUS_GNUC_PREREQ(2,7)
+#  define OPUS_INLINE __inline__
+# elif (defined(_MSC_VER))
+#  define OPUS_INLINE __inline
+# else
+#  define OPUS_INLINE
+# endif
+#else
+# define OPUS_INLINE inline
+#endif
+
 /**Warning attributes for opus functions
   * NONNULL is not used in OPUS_BUILD to avoid the compiler optimizing out
   * some paranoid null checks. */
@@ -148,8 +160,11 @@ extern "C" {
 #define OPUS_GET_GAIN_REQUEST                4045 /* Should have been 4035 */
 #define OPUS_SET_LSB_DEPTH_REQUEST           4036
 #define OPUS_GET_LSB_DEPTH_REQUEST           4037
-
 #define OPUS_GET_LAST_PACKET_DURATION_REQUEST 4039
+#define OPUS_SET_EXPERT_FRAME_DURATION_REQUEST 4040
+#define OPUS_GET_EXPERT_FRAME_DURATION_REQUEST 4041
+#define OPUS_SET_PREDICTION_DISABLED_REQUEST 4042
+#define OPUS_GET_PREDICTION_DISABLED_REQUEST 4043
 
 /* Don't use 4045, it's already taken by OPUS_GET_GAIN_REQUEST */
 
@@ -157,6 +172,7 @@ extern "C" {
 #define __opus_check_int(x) (((void)((x) == (opus_int32)0)), (opus_int32)(x))
 #define __opus_check_int_ptr(ptr) ((ptr) + ((ptr) - (opus_int32*)(ptr)))
 #define __opus_check_uint_ptr(ptr) ((ptr) + ((ptr) - (opus_uint32*)(ptr)))
+#define __opus_check_val16_ptr(ptr) ((ptr) + ((ptr) - (opus_val16*)(ptr)))
 /** @endcond */
 
 /** @defgroup opus_ctlvalues Pre-defined values for CTL interface
@@ -185,6 +201,14 @@ extern "C" {
 #define OPUS_BANDWIDTH_SUPERWIDEBAND         1104 /**<12 kHz bandpass @hideinitializer*/
 #define OPUS_BANDWIDTH_FULLBAND              1105 /**<20 kHz bandpass @hideinitializer*/
 
+#define OPUS_FRAMESIZE_ARG                   5000 /**< Select frame size from the argument (default) */
+#define OPUS_FRAMESIZE_2_5_MS                5001 /**< Use 2.5 ms frames */
+#define OPUS_FRAMESIZE_5_MS                  5002 /**< Use 5 ms frames */
+#define OPUS_FRAMESIZE_10_MS                 5003 /**< Use 10 ms frames */
+#define OPUS_FRAMESIZE_20_MS                 5004 /**< Use 20 ms frames */
+#define OPUS_FRAMESIZE_40_MS                 5005 /**< Use 40 ms frames */
+#define OPUS_FRAMESIZE_60_MS                 5006 /**< Use 60 ms frames */
+
 /**@}*/
 
 
@@ -430,14 +454,6 @@ extern "C" {
   * @hideinitializer */
 #define OPUS_GET_APPLICATION(x) OPUS_GET_APPLICATION_REQUEST, __opus_check_int_ptr(x)
 
-/** Gets the sampling rate the encoder or decoder was initialized with.
-  * This simply returns the <code>Fs</code> value passed to opus_encoder_init()
-  * or opus_decoder_init().
-  * @param[out] x <tt>opus_int32 *</tt>: Sampling rate of encoder or decoder.
-  * @hideinitializer
-  */
-#define OPUS_GET_SAMPLE_RATE(x) OPUS_GET_SAMPLE_RATE_REQUEST, __opus_check_int_ptr(x)
-
 /** Gets the total samples of delay added by the entire codec.
   * This can be queried by the encoder and then the provided number of samples can be
   * skipped on from the start of the decoder's output to provide time aligned input
@@ -521,10 +537,52 @@ extern "C" {
   * @hideinitializer */
 #define OPUS_GET_LSB_DEPTH(x) OPUS_GET_LSB_DEPTH_REQUEST, __opus_check_int_ptr(x)
 
-/** Gets the duration (in samples) of the last packet successfully decoded or concealed.
-  * @param[out] x <tt>opus_int32 *</tt>: Number of samples (at current sampling rate).
+/** Configures the encoder's use of variable duration frames.
+  * When variable duration is enabled, the encoder is free to use a shorter frame
+  * size than the one requested in the opus_encode*() call.
+  * It is then the user's responsibility
+  * to verify how much audio was encoded by checking the ToC byte of the encoded
+  * packet. The part of the audio that was not encoded needs to be resent to the
+  * encoder for the next call. Do not use this option unless you <b>really</b>
+  * know what you are doing.
+  * @see OPUS_GET_EXPERT_VARIABLE_DURATION
+  * @param[in] x <tt>opus_int32</tt>: Allowed values:
+  * <dl>
+  * <dt>OPUS_FRAMESIZE_ARG</dt><dd>Select frame size from the argument (default).</dd>
+  * <dt>OPUS_FRAMESIZE_2_5_MS</dt><dd>Use 2.5 ms frames.</dd>
+  * <dt>OPUS_FRAMESIZE_5_MS</dt><dd>Use 2.5 ms frames.</dd>
+  * <dt>OPUS_FRAMESIZE_10_MS</dt><dd>Use 10 ms frames.</dd>
+  * <dt>OPUS_FRAMESIZE_20_MS</dt><dd>Use 20 ms frames.</dd>
+  * <dt>OPUS_FRAMESIZE_40_MS</dt><dd>Use 40 ms frames.</dd>
+  * <dt>OPUS_FRAMESIZE_60_MS</dt><dd>Use 60 ms frames.</dd>
+  * <dt>OPUS_FRAMESIZE_VARIABLE</dt><dd>Optimize the frame size dynamically.</dd>
+  * </dl>
   * @hideinitializer */
-#define OPUS_GET_LAST_PACKET_DURATION(x) OPUS_GET_LAST_PACKET_DURATION_REQUEST, __opus_check_int_ptr(x)
+#define OPUS_SET_EXPERT_FRAME_DURATION(x) OPUS_SET_EXPERT_FRAME_DURATION_REQUEST, __opus_check_int(x)
+/** Gets the encoder's configured use of variable duration frames.
+  * @see OPUS_SET_EXPERT_VARIABLE_DURATION
+  * @param[out] x <tt>opus_int32 *</tt>: Returns one of the following values:
+  * <dl>
+  * <dt>OPUS_FRAMESIZE_ARG</dt><dd>Select frame size from the argument (default).</dd>
+  * <dt>OPUS_FRAMESIZE_2_5_MS</dt><dd>Use 2.5 ms frames.</dd>
+  * <dt>OPUS_FRAMESIZE_5_MS</dt><dd>Use 2.5 ms frames.</dd>
+  * <dt>OPUS_FRAMESIZE_10_MS</dt><dd>Use 10 ms frames.</dd>
+  * <dt>OPUS_FRAMESIZE_20_MS</dt><dd>Use 20 ms frames.</dd>
+  * <dt>OPUS_FRAMESIZE_40_MS</dt><dd>Use 40 ms frames.</dd>
+  * <dt>OPUS_FRAMESIZE_60_MS</dt><dd>Use 60 ms frames.</dd>
+  * <dt>OPUS_FRAMESIZE_VARIABLE</dt><dd>Optimize the frame size dynamically.</dd>
+  * </dl>
+  * @hideinitializer */
+#define OPUS_GET_EXPERT_FRAME_DURATION(x) OPUS_GET_EXPERT_FRAME_DURATION_REQUEST, __opus_check_int_ptr(x)
+
+/** If set to 1, disables almost all use of prediction, making frames almost
+    completely independent. This reduces quality. (default : 0)
+  * @hideinitializer */
+#define OPUS_SET_PREDICTION_DISABLED(x) OPUS_SET_PREDICTION_DISABLED_REQUEST, __opus_check_int(x)
+/** Gets the encoder's configured prediction status.
+  * @hideinitializer */
+#define OPUS_GET_PREDICTION_DISABLED(x) OPUS_GET_PREDICTION_DISABLED_REQUEST, __opus_check_int_ptr(x)
+
 /**@}*/
 
 /** @defgroup opus_genericctls Generic CTLs
@@ -578,18 +636,6 @@ extern "C" {
   * @hideinitializer */
 #define OPUS_GET_FINAL_RANGE(x) OPUS_GET_FINAL_RANGE_REQUEST, __opus_check_uint_ptr(x)
 
-/** Gets the pitch of the last decoded frame, if available.
-  * This can be used for any post-processing algorithm requiring the use of pitch,
-  * e.g. time stretching/shortening. If the last frame was not voiced, or if the
-  * pitch was not coded in the frame, then zero is returned.
-  *
-  * This CTL is only implemented for decoder instances.
-  *
-  * @param[out] x <tt>opus_int32 *</tt>: pitch period at 48 kHz (or 0 if not available)
-  *
-  * @hideinitializer */
-#define OPUS_GET_PITCH(x) OPUS_GET_PITCH_REQUEST, __opus_check_int_ptr(x)
-
 /** Gets the encoder's configured bandpass or the decoder's last bandpass.
   * @see OPUS_SET_BANDWIDTH
   * @param[out] x <tt>opus_int32 *</tt>: Returns one of the following values:
@@ -604,6 +650,14 @@ extern "C" {
   * @hideinitializer */
 #define OPUS_GET_BANDWIDTH(x) OPUS_GET_BANDWIDTH_REQUEST, __opus_check_int_ptr(x)
 
+/** Gets the sampling rate the encoder or decoder was initialized with.
+  * This simply returns the <code>Fs</code> value passed to opus_encoder_init()
+  * or opus_decoder_init().
+  * @param[out] x <tt>opus_int32 *</tt>: Sampling rate of encoder or decoder.
+  * @hideinitializer
+  */
+#define OPUS_GET_SAMPLE_RATE(x) OPUS_GET_SAMPLE_RATE_REQUEST, __opus_check_int_ptr(x)
+
 /**@}*/
 
 /** @defgroup opus_decoderctls Decoder related CTLs
@@ -628,6 +682,23 @@ extern "C" {
   * @hideinitializer */
 #define OPUS_GET_GAIN(x) OPUS_GET_GAIN_REQUEST, __opus_check_int_ptr(x)
 
+/** Gets the duration (in samples) of the last packet successfully decoded or concealed.
+  * @param[out] x <tt>opus_int32 *</tt>: Number of samples (at current sampling rate).
+  * @hideinitializer */
+#define OPUS_GET_LAST_PACKET_DURATION(x) OPUS_GET_LAST_PACKET_DURATION_REQUEST, __opus_check_int_ptr(x)
+
+/** Gets the pitch of the last decoded frame, if available.
+  * This can be used for any post-processing algorithm requiring the use of pitch,
+  * e.g. time stretching/shortening. If the last frame was not voiced, or if the
+  * pitch was not coded in the frame, then zero is returned.
+  *
+  * This CTL is only implemented for decoder instances.
+  *
+  * @param[out] x <tt>opus_int32 *</tt>: pitch period at 48 kHz (or 0 if not available)
+  *
+  * @hideinitializer */
+#define OPUS_GET_PITCH(x) OPUS_GET_PITCH_REQUEST, __opus_check_int_ptr(x)
+
 /**@}*/
 
 /** @defgroup opus_libinfo Opus library information functions

res/layout/activity_stream_settings.xml

@@ -54,7 +54,7 @@
             android:id="@+id/advancedSettingsButton"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:layout_below="@+id/enableSops"
+            android:layout_below="@+id/disableToasts"
             android:layout_centerHorizontal="true"
             android:layout_marginTop="15dp"
             android:text="Advanced Settings" />
@@ -74,6 +74,14 @@
             android:layout_below="@+id/stretchToFill"
             android:layout_marginTop="15dp"
             android:text="Allow GFE to modify game settings for optimal streaming" />
+        
+        <CheckBox
+            android:id="@+id/disableToasts"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_below="@+id/enableSops"
+            android:layout_marginTop="15dp"
+            android:text="Disable on-screen connection warning messages" />
 
     </RelativeLayout>
 	

src/com/limelight/Game.java

@@ -4,12 +4,16 @@ package com.limelight;
 import com.limelight.binding.PlatformBinding;
 import com.limelight.binding.input.ControllerHandler;
 import com.limelight.binding.input.KeyboardTranslator;
+import com.limelight.binding.input.TouchContext;
+import com.limelight.binding.input.evdev.EvdevListener;
+import com.limelight.binding.input.evdev.EvdevWatcher;
 import com.limelight.binding.video.ConfigurableDecoderRenderer;
 import com.limelight.nvstream.NvConnection;
 import com.limelight.nvstream.NvConnectionListener;
 import com.limelight.nvstream.StreamConfiguration;
 import com.limelight.nvstream.av.video.VideoDecoderRenderer;
 import com.limelight.nvstream.input.KeyboardPacket;
+import com.limelight.nvstream.input.MouseButtonPacket;
 import com.limelight.utils.Dialog;
 import com.limelight.utils.SpinnerDialog;
 
@@ -38,13 +42,15 @@ import android.view.WindowManager;
 import android.widget.Toast;
 
 
-public class Game extends Activity implements SurfaceHolder.Callback, OnGenericMotionListener, OnTouchListener, NvConnectionListener {
+public class Game extends Activity implements SurfaceHolder.Callback,
+	OnGenericMotionListener, OnTouchListener, NvConnectionListener, EvdevListener
+{
 	private int lastMouseX = Integer.MIN_VALUE;
 	private int lastMouseY = Integer.MIN_VALUE;
 	private int lastButtonState = 0;
-	private int lastTouchX = 0;
-	private int lastTouchY = 0;
-	private boolean hasMoved = false;
+	
+	// Only 2 touches are supported
+	private TouchContext[] touchContextMap = new TouchContext[2];
 	
 	private ControllerHandler controllerHandler;
 	private KeyboardTranslator keybTranslator;
@@ -60,6 +66,9 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 	private boolean connected = false;
 	
 	private boolean stretchToFit;
+	private boolean toastsDisabled;
+	
+	private EvdevWatcher evdevWatcher;
 	
 	private ConfigurableDecoderRenderer decoderRenderer;
 	
@@ -81,6 +90,7 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 	public static final String BITRATE_PREF_STRING = "Bitrate";
 	public static final String STRETCH_PREF_STRING = "Stretch";
 	public static final String SOPS_PREF_STRING = "Sops";
+	public static final String DISABLE_TOASTS_PREF_STRING = "NoToasts";
 	
 	public static final int BITRATE_DEFAULT_720_30 = 5;
 	public static final int BITRATE_DEFAULT_720_60 = 10;
@@ -94,6 +104,7 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 	public static final int DEFAULT_BITRATE = BITRATE_DEFAULT_720_60;
 	public static final boolean DEFAULT_STRETCH = false;
 	public static final boolean DEFAULT_SOPS = true;
+	public static final boolean DEFAULT_DISABLE_TOASTS = false;
 	
 	public static final int FORCE_HARDWARE_DECODER = -1;
 	public static final int AUTOSELECT_DECODER = 0;
@@ -156,6 +167,7 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 		refreshRate = prefs.getInt(REFRESH_RATE_PREF_STRING, DEFAULT_REFRESH_RATE);
 		bitrate = prefs.getInt(BITRATE_PREF_STRING, DEFAULT_BITRATE);
 		sops = prefs.getBoolean(SOPS_PREF_STRING, DEFAULT_SOPS);
+		toastsDisabled = prefs.getBoolean(DISABLE_TOASTS_PREF_STRING, DEFAULT_DISABLE_TOASTS);
 		
 		Display display = getWindowManager().getDefaultDisplay();
 		display.getSize(screenSize);
@@ -177,16 +189,20 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 		String host = Game.this.getIntent().getStringExtra(EXTRA_HOST);
 		String app = Game.this.getIntent().getStringExtra(EXTRA_APP);
 		String uniqueId = Game.this.getIntent().getStringExtra(EXTRA_UNIQUEID);
-        
-		// Start the connection
-		conn = new NvConnection(host, uniqueId, Game.this,
-				new StreamConfiguration(app, width, height, refreshRate, bitrate * 1000, sops),
-				PlatformBinding.getCryptoProvider(this));
-		keybTranslator = new KeyboardTranslator(conn);
-		controllerHandler = new ControllerHandler(conn);
 		
 		decoderRenderer = new ConfigurableDecoderRenderer();
 		decoderRenderer.initializeWithFlags(drFlags);
+        
+		StreamConfiguration config = 
+				new StreamConfiguration(app, width, height,
+						refreshRate, bitrate * 1000, sops,
+						(decoderRenderer.getCapabilities() &
+								VideoDecoderRenderer.CAPABILITY_ADAPTIVE_RESOLUTION) != 0);
+		
+		// Initialize the connection
+		conn = new NvConnection(host, uniqueId, Game.this, config, PlatformBinding.getCryptoProvider(this));
+		keybTranslator = new KeyboardTranslator(conn);
+		controllerHandler = new ControllerHandler(conn);
 		
 		SurfaceHolder sh = sv.getHolder();
 		if (stretchToFit || !decoderRenderer.isHardwareAccelerated()) {
@@ -194,6 +210,17 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 			sh.setFixedSize(width, height);
 		}
 		
+		// Initialize touch contexts
+		for (int i = 0; i < touchContextMap.length; i++) {
+			touchContextMap[i] = new TouchContext(conn, i);
+		}
+		
+		if (LimelightBuildProps.ROOT_BUILD) {
+			// Start watching for raw input
+			evdevWatcher = new EvdevWatcher(this);
+			evdevWatcher.start();
+		}
+		
 		// The connection will be started when the surface gets created
 		sh.addCallback(this);
 	}
@@ -277,6 +304,10 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 		if (message != null) {
 			Toast.makeText(this, message, Toast.LENGTH_LONG).show();
 		}
+		
+		if (evdevWatcher != null) {
+			evdevWatcher.shutdown();
+		}
 
 		finish();
 	}
@@ -368,43 +399,13 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 		return true;
 	}
 	
-	public void touchDownEvent(int eventX, int eventY)
-	{
-		lastTouchX = eventX;
-		lastTouchY = eventY;
-		hasMoved = false;
-	}
-	
-	public void touchUpEvent(int eventX, int eventY)
-	{
-		if (!hasMoved)
-		{
-			// We haven't moved so send a click
-
-			// Lower the mouse button
-			conn.sendMouseButtonDown((byte) 0x01);
-			
-			// We need to sleep a bit here because some games
-			// do input detection by polling
-			try {
-				Thread.sleep(100);
-			} catch (InterruptedException e) {}
-			
-			// Raise the mouse button
-			conn.sendMouseButtonUp((byte) 0x01);
+	private TouchContext getTouchContext(int actionIndex)
+	{	
+		if (actionIndex < touchContextMap.length) {
+			return touchContextMap[actionIndex];
 		}
-	}
-	
-	public void touchMoveEvent(int eventX, int eventY)
-	{
-		if (eventX != lastTouchX || eventY != lastTouchY)
-		{
-			hasMoved = true;
-			conn.sendMouseMove((short)(eventX - lastTouchX),
-					(short)(eventY - lastTouchY));
-			
-			lastTouchX = eventX;
-			lastTouchY = eventY;
+		else {
+			return null;
 		}
 	}
 	
@@ -416,19 +417,36 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 			if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN ||
 				event.getSource() == InputDevice.SOURCE_STYLUS)
 			{
-				int eventX = (int)event.getX();
-				int eventY = (int)event.getY();
+				int actionIndex = event.getActionIndex();
 				
+				int eventX = (int)event.getX(actionIndex);
+				int eventY = (int)event.getY(actionIndex);
+				
+				TouchContext context = getTouchContext(actionIndex);
+				if (context == null) {
+					return super.onTouchEvent(event);
+				}
+								
 				switch (event.getActionMasked())
 				{
+				case MotionEvent.ACTION_POINTER_DOWN:
 				case MotionEvent.ACTION_DOWN:
-					touchDownEvent(eventX, eventY);
+					context.touchDownEvent(eventX, eventY);
 					break;
+				case MotionEvent.ACTION_POINTER_UP:
 				case MotionEvent.ACTION_UP:
-					touchUpEvent(eventX, eventY);
+					context.touchUpEvent(eventX, eventY);
+					if (actionIndex == 0 && event.getPointerCount() > 1) {
+						// The original secondary touch now becomes primary
+						context.touchDownEvent((int)event.getX(1), (int)event.getY(1));
+					}
 					break;
 				case MotionEvent.ACTION_MOVE:
-					touchMoveEvent(eventX, eventY);
+					// ACTION_MOVE is special because it always has actionIndex == 0
+					// We'll call the move handlers for all indexes manually
+					for (int i = 0; i < touchContextMap.length; i++) {
+						touchContextMap[i].touchMoveEvent(eventX, eventY);
+					}
 					break;
 				default:
 					return super.onTouchEvent(event);
@@ -441,28 +459,28 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 				
 				if ((changedButtons & MotionEvent.BUTTON_PRIMARY) != 0) {
 					if ((event.getButtonState() & MotionEvent.BUTTON_PRIMARY) != 0) {
-						conn.sendMouseButtonDown((byte) 0x01);
+						conn.sendMouseButtonDown(MouseButtonPacket.BUTTON_LEFT);
 					}
 					else {
-						conn.sendMouseButtonUp((byte) 0x01);
+						conn.sendMouseButtonUp(MouseButtonPacket.BUTTON_LEFT);
 					}
 				}
 				
 				if ((changedButtons & MotionEvent.BUTTON_SECONDARY) != 0) {
 					if ((event.getButtonState() & MotionEvent.BUTTON_SECONDARY) != 0) {
-						conn.sendMouseButtonDown((byte) 0x03);
+						conn.sendMouseButtonDown(MouseButtonPacket.BUTTON_RIGHT);
 					}
 					else {
-						conn.sendMouseButtonUp((byte) 0x03);
+						conn.sendMouseButtonUp(MouseButtonPacket.BUTTON_RIGHT);
 					}
 				}
 				
 				if ((changedButtons & MotionEvent.BUTTON_TERTIARY) != 0) {
 					if ((event.getButtonState() & MotionEvent.BUTTON_TERTIARY) != 0) {
-						conn.sendMouseButtonDown((byte) 0x02);
+						conn.sendMouseButtonDown(MouseButtonPacket.BUTTON_MIDDLE);
 					}
 					else {
-						conn.sendMouseButtonUp((byte) 0x02);
+						conn.sendMouseButtonUp(MouseButtonPacket.BUTTON_MIDDLE);
 					}
 				}
 				
@@ -489,9 +507,19 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 			}		
 		}
 		else if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0)
-		{	
-			// Send a mouse move update (if neccessary)
-			updateMousePosition((int)event.getX(), (int)event.getY());
+		{
+			switch (event.getActionMasked())
+			{
+			case MotionEvent.ACTION_HOVER_MOVE:
+				// Send a mouse move update (if neccessary)
+				updateMousePosition((int)event.getX(), (int)event.getY());
+				break;
+			case MotionEvent.ACTION_SCROLL:
+				// Send the vertical scroll packet
+				byte vScrollClicks = (byte) event.getAxisValue(MotionEvent.AXIS_VSCROLL);
+				conn.sendMouseScroll(vScrollClicks);
+				break;
+			}
 			return true;
 		}
 	    
@@ -547,8 +575,10 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 
 	@Override
 	public void stageFailed(Stage stage) {
-		spinner.dismiss();
-		spinner = null;
+		if (spinner != null) {
+			spinner.dismiss();
+			spinner = null;
+		}
 
 		if (!displayedFailureDialog) {
 			displayedFailureDialog = true;
@@ -571,8 +601,10 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 
 	@Override
 	public void connectionStarted() {
-		spinner.dismiss();
-		spinner = null;
+		if (spinner != null) {
+			spinner.dismiss();
+			spinner = null;
+		}
 		
 		connecting = false;
 		connected = true;
@@ -592,12 +624,14 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 
 	@Override
 	public void displayTransientMessage(final String message) {
-		runOnUiThread(new Runnable() {
-			@Override
-			public void run() {
-				Toast.makeText(Game.this, message, Toast.LENGTH_LONG).show();
-			}
-		});
+		if (!toastsDisabled) {
+			runOnUiThread(new Runnable() {
+				@Override
+				public void run() {
+					Toast.makeText(Game.this, message, Toast.LENGTH_LONG).show();
+				}
+			});	
+		}
 	}
 
 	@Override
@@ -627,4 +661,42 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 			connected = false;
 		}
 	}
+
+	@Override
+	public void mouseMove(int deltaX, int deltaY) {
+		conn.sendMouseMove((short) deltaX, (short) deltaY);
+	}
+
+	@Override
+	public void mouseButtonEvent(int buttonId, boolean down) {
+		byte buttonIndex;
+		
+		switch (buttonId)
+		{
+		case EvdevListener.BUTTON_LEFT:
+			buttonIndex = MouseButtonPacket.BUTTON_LEFT;
+			break;
+		case EvdevListener.BUTTON_MIDDLE:
+			buttonIndex = MouseButtonPacket.BUTTON_MIDDLE;
+			break;
+		case EvdevListener.BUTTON_RIGHT:
+			buttonIndex = MouseButtonPacket.BUTTON_RIGHT;
+			break;
+		default:
+			LimeLog.warning("Unhandled button: "+buttonId);
+			return;
+		}
+		
+		if (down) {
+			conn.sendMouseButtonDown(buttonIndex);
+		}
+		else {
+			conn.sendMouseButtonUp(buttonIndex);
+		}
+	}
+
+	@Override
+	public void mouseScroll(byte amount) {
+		conn.sendMouseScroll(amount);
+	}
 }

src/com/limelight/LimelightBuildProps.java

@@ -0,0 +1,5 @@
+package com.limelight;
+
+public class LimelightBuildProps {
+	public static final boolean ROOT_BUILD = false;
+}

src/com/limelight/PcView.java

@@ -156,7 +156,7 @@ public class PcView extends Activity {
 		}
 	}
 	
-	private void stopComputerUpdates() {
+	private void stopComputerUpdates(boolean wait) {
 		if (managerBinder != null) {
 			if (!runningPolling) {
 				return;
@@ -165,6 +165,11 @@ public class PcView extends Activity {
 			freezeUpdates = true;
 			
 			managerBinder.stopPolling();
+			
+			if (wait) {
+				managerBinder.waitForPollingStopped();
+			}
+			
 			runningPolling = false;
 		}
 	}
@@ -189,7 +194,7 @@ public class PcView extends Activity {
 	protected void onPause() {
 		super.onPause();
 		
-		stopComputerUpdates();
+		stopComputerUpdates(false);
 	}
 	
 	@Override
@@ -201,7 +206,7 @@ public class PcView extends Activity {
 	
 	@Override
     public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
-		stopComputerUpdates();
+		stopComputerUpdates(false);
 		
 		// Call superclass
 		super.onCreateContextMenu(menu, v, menuInfo);
@@ -258,6 +263,9 @@ public class PcView extends Activity {
 				NvHTTP httpConn;
 				String message;
 				try {
+					// Stop updates and wait while pairing
+					stopComputerUpdates(true);
+					
 					InetAddress addr = null;
 					if (computer.reachability == ComputerDetails.Reachability.LOCAL) {
 						addr = computer.localIp;
@@ -312,6 +320,9 @@ public class PcView extends Activity {
 						Toast.makeText(PcView.this, toastMessage, Toast.LENGTH_LONG).show();
 					}
 				});
+				
+				// Start polling again
+				startComputerUpdates();
 			}
 		}).start();
 	}

src/com/limelight/StreamSettings.java

@@ -19,7 +19,7 @@ public class StreamSettings extends Activity {
 	private Button advancedSettingsButton;
 	private SharedPreferences prefs;
 	private RadioButton rbutton720p30, rbutton720p60, rbutton1080p30, rbutton1080p60;
-	private CheckBox stretchToFill, enableSops;
+	private CheckBox stretchToFill, enableSops, toastsDisabled;
 	
 	@Override
 	protected void onStop() {
@@ -36,6 +36,7 @@ public class StreamSettings extends Activity {
 		
 		this.stretchToFill = (CheckBox) findViewById(R.id.stretchToFill);
 		this.enableSops = (CheckBox) findViewById(R.id.enableSops);
+		this.toastsDisabled = (CheckBox) findViewById(R.id.disableToasts);
 		this.advancedSettingsButton = (Button) findViewById(R.id.advancedSettingsButton);
 		this.rbutton720p30 = (RadioButton) findViewById(R.id.config720p30Selected);
 		this.rbutton720p60 = (RadioButton) findViewById(R.id.config720p60Selected);
@@ -49,6 +50,7 @@ public class StreamSettings extends Activity {
 
 		stretchToFill.setChecked(prefs.getBoolean(Game.STRETCH_PREF_STRING, Game.DEFAULT_STRETCH));
 		enableSops.setChecked(prefs.getBoolean(Game.SOPS_PREF_STRING, Game.DEFAULT_SOPS));
+		toastsDisabled.setChecked(prefs.getBoolean(Game.DISABLE_TOASTS_PREF_STRING, Game.DEFAULT_DISABLE_TOASTS));
 		
 		rbutton720p30.setChecked(false);
 		rbutton720p60.setChecked(false);
@@ -132,5 +134,12 @@ public class StreamSettings extends Activity {
 				prefs.edit().putBoolean(Game.SOPS_PREF_STRING, isChecked).commit();
 			}
 		});
+		toastsDisabled.setOnCheckedChangeListener(new OnCheckedChangeListener() {
+			@Override
+			public void onCheckedChanged(CompoundButton buttonView,
+					boolean isChecked) {
+				prefs.edit().putBoolean(Game.DISABLE_TOASTS_PREF_STRING, isChecked).commit();
+			}
+		});
 	}
 }

src/com/limelight/binding/input/TouchContext.java

@@ -0,0 +1,93 @@
+package com.limelight.binding.input;
+
+import com.limelight.nvstream.NvConnection;
+import com.limelight.nvstream.input.MouseButtonPacket;
+
+public class TouchContext {
+	private int lastTouchX = 0;
+	private int lastTouchY = 0;
+	private int originalTouchX = 0;
+	private int originalTouchY = 0;
+	private long originalTouchTime = 0;
+	
+	private NvConnection conn;
+	private int actionIndex;
+	
+	private static final int TAP_MOVEMENT_THRESHOLD = 10;
+	private static final int TAP_TIME_THRESHOLD = 250;
+	
+	public TouchContext(NvConnection conn, int actionIndex)
+	{
+		this.conn = conn;
+		this.actionIndex = actionIndex;
+	}
+	
+	private boolean isTap()
+	{
+		int xDelta = Math.abs(lastTouchX - originalTouchX);
+		int yDelta = Math.abs(lastTouchY - originalTouchY);
+		long timeDelta = System.currentTimeMillis() - originalTouchTime;
+		
+		return xDelta <= TAP_MOVEMENT_THRESHOLD &&
+				yDelta <= TAP_MOVEMENT_THRESHOLD &&
+				timeDelta <= TAP_TIME_THRESHOLD;
+	}
+	
+	private byte getMouseButtonIndex()
+	{
+		if (actionIndex == 1) {
+			return MouseButtonPacket.BUTTON_RIGHT;
+		}
+		else {
+			return MouseButtonPacket.BUTTON_LEFT;
+		}
+	}
+	
+	public boolean touchDownEvent(int eventX, int eventY)
+	{
+		originalTouchX = lastTouchX = eventX;
+		originalTouchY = lastTouchY = eventY;
+		originalTouchTime = System.currentTimeMillis();
+		
+		return true;
+	}
+	
+	public void touchUpEvent(int eventX, int eventY)
+	{
+		if (isTap())
+		{
+			byte buttonIndex = getMouseButtonIndex();
+			
+			// Lower the mouse button
+			conn.sendMouseButtonDown(buttonIndex);
+			
+			// We need to sleep a bit here because some games
+			// do input detection by polling
+			try {
+				Thread.sleep(100);
+			} catch (InterruptedException e) {}
+			
+			// Raise the mouse button
+			conn.sendMouseButtonUp(buttonIndex);
+		}
+	}
+	
+	public boolean touchMoveEvent(int eventX, int eventY)
+	{	
+		if (eventX != lastTouchX || eventY != lastTouchY)
+		{
+			// We only send moves for the primary touch point
+			if (actionIndex == 0) {
+				conn.sendMouseMove((short)(eventX - lastTouchX),
+						(short)(eventY - lastTouchY));
+			}
+			
+			lastTouchX = eventX;
+			lastTouchY = eventY;
+			
+			return true;
+		}
+		
+		return false;
+	}
+}

src/com/limelight/binding/input/evdev/EvdevEvent.java

@@ -0,0 +1,31 @@
+package com.limelight.binding.input.evdev;
+
+public class EvdevEvent {
+	public static final int EVDEV_MIN_EVENT_SIZE = 16;
+	public static final int EVDEV_MAX_EVENT_SIZE = 24;
+	
+	/* Event types */
+	public static final short EV_SYN = 0x00;
+	public static final short EV_KEY = 0x01;
+	public static final short EV_REL = 0x02;
+	
+	/* Relative axes */
+	public static final short REL_X = 0x00;
+	public static final short REL_Y = 0x01;
+	public static final short REL_WHEEL = 0x08;
+	
+	/* Buttons */
+	public static final short BTN_LEFT = 0x110;
+	public static final short BTN_RIGHT = 0x111;
+	public static final short BTN_MIDDLE = 0x112;
+	
+	public short type;
+	public short code;
+	public int value;
+	
+	public EvdevEvent(short type, short code, int value) {
+		this.type = type;
+		this.code = code;
+		this.value = value;
+	}
+}

src/com/limelight/binding/input/evdev/EvdevHandler.java

@@ -0,0 +1,134 @@
+package com.limelight.binding.input.evdev;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import com.limelight.LimeLog;
+
+public class EvdevHandler {
+
+	private String absolutePath;
+	private EvdevListener listener;
+	private boolean shutdown = false;
+	
+	private Thread handlerThread = new Thread() {
+		@Override
+		public void run() {
+			// All the finally blocks here make this code look like a mess
+			// but it's important that we get this right to avoid causing
+			// system-wide input problems.
+			
+			// Open the /dev/input/eventX file
+			int fd = EvdevReader.open(absolutePath);
+			if (fd == -1) {
+				LimeLog.warning("Unable to open "+absolutePath);
+				return;
+			}
+
+			try {
+				// Check if it's a mouse
+				if (!EvdevReader.isMouse(fd)) {
+					// We only handle mice
+					return;
+				}
+
+				// Grab it for ourselves
+				if (!EvdevReader.grab(fd)) {
+					LimeLog.warning("Unable to grab "+absolutePath);
+					return;
+				}
+
+				LimeLog.info("Grabbed device for raw mouse input: "+absolutePath);
+
+				ByteBuffer buffer = ByteBuffer.allocate(EvdevEvent.EVDEV_MAX_EVENT_SIZE).order(ByteOrder.nativeOrder());
+
+				try {
+					int deltaX = 0;
+					int deltaY = 0;
+					byte deltaScroll = 0;
+
+					while (!isInterrupted() && !shutdown) {
+						EvdevEvent event = EvdevReader.read(fd, buffer);
+						if (event == null) {
+							return;
+						}
+
+						switch (event.type)
+						{
+						case EvdevEvent.EV_SYN:
+							if (deltaX != 0 || deltaY != 0) {
+								listener.mouseMove(deltaX, deltaY);
+								deltaX = deltaY = 0;
+							}
+							if (deltaScroll != 0) {
+								listener.mouseScroll(deltaScroll);
+								deltaScroll = 0;
+							}
+							break;
+
+						case EvdevEvent.EV_REL:
+							switch (event.code)
+							{
+							case EvdevEvent.REL_X:
+								deltaX = event.value;
+								break;
+							case EvdevEvent.REL_Y:
+								deltaY = event.value;
+								break;
+							case EvdevEvent.REL_WHEEL:
+								deltaScroll = (byte) event.value;
+								break;
+							}
+							break;
+
+						case EvdevEvent.EV_KEY:
+							switch (event.code)
+							{
+							case EvdevEvent.BTN_LEFT:
+								listener.mouseButtonEvent(EvdevListener.BUTTON_LEFT,
+										event.value != 0);
+								break;
+							case EvdevEvent.BTN_MIDDLE:
+								listener.mouseButtonEvent(EvdevListener.BUTTON_MIDDLE,
+										event.value != 0);
+								break;
+							case EvdevEvent.BTN_RIGHT:
+								listener.mouseButtonEvent(EvdevListener.BUTTON_RIGHT,
+										event.value != 0);
+								break;
+							}
+						}
+					}
+				} finally {
+					// Release our grab
+					EvdevReader.ungrab(fd);
+				}
+			} finally {
+				// Close the file
+				EvdevReader.close(fd);
+			}
+		}
+	};
+	
+	public EvdevHandler(String absolutePath, EvdevListener listener) {
+		this.absolutePath = absolutePath;
+		this.listener = listener;
+	}
+	
+	public void start() {
+		handlerThread.start();
+	}
+	
+	public void stop() {
+		shutdown = true;
+		handlerThread.interrupt();
+		
+		try {
+			handlerThread.join();
+		} catch (InterruptedException e) {}
+	}
+	
+	public void notifyDeleted() {
+		stop();
+	}
+}

src/com/limelight/binding/input/evdev/EvdevListener.java

@@ -0,0 +1,11 @@
+package com.limelight.binding.input.evdev;
+
+public interface EvdevListener {
+	public static final int BUTTON_LEFT = 1;
+	public static final int BUTTON_MIDDLE = 2;
+	public static final int BUTTON_RIGHT = 3;
+	
+	public void mouseMove(int deltaX, int deltaY);
+	public void mouseButtonEvent(int buttonId, boolean down);
+	public void mouseScroll(byte amount);
+}

src/com/limelight/binding/input/evdev/EvdevReader.java

@@ -0,0 +1,83 @@
+package com.limelight.binding.input.evdev;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+
+import com.limelight.LimeLog;
+
+public class EvdevReader {
+	static {
+		System.loadLibrary("evdev_reader");
+	}
+	
+	// Requires root to chmod /dev/input/eventX
+	public static boolean setPermissions(String[] files, int octalPermissions) {		
+		ProcessBuilder builder = new ProcessBuilder("su");
+		
+		try {
+			Process p = builder.start();
+			
+			OutputStream stdin = p.getOutputStream();
+			for (String file : files) {
+				stdin.write(String.format("chmod %o %s\n", octalPermissions, file).getBytes("UTF-8"));
+			}
+			stdin.write("exit\n".getBytes("UTF-8"));
+			stdin.flush();
+			
+			p.waitFor();
+			p.destroy();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		
+		return false;
+	}
+	
+	// Returns the fd to be passed to other function or -1 on error
+	public static native int open(String fileName);
+	
+	// Prevent other apps (including Android itself) from using the device while "grabbed"
+	public static native boolean grab(int fd);
+	public static native boolean ungrab(int fd);
+	
+	// Returns true if the device is a mouse
+	public static native boolean isMouse(int fd);
+	
+	// Returns the bytes read or -1 on error
+	private static native int read(int fd, byte[] buffer);
+	
+	// Takes a byte buffer to use to read the output into.
+	// This buffer MUST be in native byte order and at least
+	// EVDEV_MAX_EVENT_SIZE bytes long.
+	public static EvdevEvent read(int fd, ByteBuffer buffer) {
+		int bytesRead = read(fd, buffer.array());
+		if (bytesRead < 0) {
+			LimeLog.warning("Failed to read: "+bytesRead);
+			return null;
+		}
+		else if (bytesRead < EvdevEvent.EVDEV_MIN_EVENT_SIZE) {
+			LimeLog.warning("Short read: "+bytesRead);
+			return null;
+		}
+		
+		buffer.limit(bytesRead);
+		buffer.rewind();
+		
+		// Throw away the time stamp
+		if (bytesRead == EvdevEvent.EVDEV_MAX_EVENT_SIZE) {
+			buffer.getLong();
+			buffer.getLong();
+		} else {
+			buffer.getInt();
+			buffer.getInt();
+		}
+		
+		return new EvdevEvent(buffer.getShort(), buffer.getShort(), buffer.getInt());
+	}
+	
+	// Closes the fd from open()
+	public static native int close(int fd);
+}

src/com/limelight/binding/input/evdev/EvdevWatcher.java

@@ -0,0 +1,132 @@
+package com.limelight.binding.input.evdev;
+
+import java.io.File;
+import java.util.HashMap;
+
+import com.limelight.LimeLog;
+
+import android.os.FileObserver;
+
+public class EvdevWatcher {
+	private static final String PATH = "/dev/input";
+	private static final String REQUIRED_FILE_PREFIX = "event";
+	
+	private HashMap<String, EvdevHandler> handlers = new HashMap<String, EvdevHandler>();
+	private boolean shutdown = false;
+	private boolean init = false;
+	private EvdevListener listener;
+	private Thread startThread;
+	
+	private FileObserver observer = new FileObserver(PATH, FileObserver.CREATE | FileObserver.DELETE) {
+		@Override
+		public void onEvent(int event, String fileName) {
+			if (fileName == null) {
+				return;
+			}
+			
+			if (!fileName.startsWith(REQUIRED_FILE_PREFIX)) {
+				return;
+			}
+			
+			synchronized (handlers) {
+				if (shutdown) {
+					return;
+				}
+				
+				if ((event & FileObserver.CREATE) != 0) {
+					LimeLog.info("Starting evdev handler for "+fileName);
+					
+					if (!init) {
+						// If this a real new device, update permissions again so we can read it
+						EvdevReader.setPermissions(new String[]{PATH + "/" + fileName}, 0666);
+					}
+					
+					EvdevHandler handler = new EvdevHandler(PATH + "/" + fileName, listener);
+					handler.start();
+					
+					handlers.put(fileName, handler);
+				}
+				
+				if ((event & FileObserver.DELETE) != 0) {
+					LimeLog.info("Halting evdev handler for "+fileName);
+					
+					EvdevHandler handler = handlers.remove(fileName);
+					if (handler != null) {
+						handler.notifyDeleted();
+					}
+				}
+			}
+		}
+	};
+	
+	public EvdevWatcher(EvdevListener listener) {
+		this.listener = listener;
+	}
+	
+	private File[] rundownWithPermissionsChange(int newPermissions) {
+		// Rundown existing files
+		File devInputDir = new File(PATH);
+		File[] files = devInputDir.listFiles();
+		
+		// Set desired permissions
+		String[] filePaths = new String[files.length];
+		for (int i = 0; i < files.length; i++) {
+			filePaths[i] = files[i].getAbsolutePath();
+		}
+		EvdevReader.setPermissions(filePaths, newPermissions);
+		
+		return files;
+	}
+	
+	public void start() {
+		startThread = new Thread() {
+			@Override
+			public void run() {
+				// List all files and allow us access
+				File[] files = rundownWithPermissionsChange(0666);
+				
+				init = true;
+				for (File f : files) {
+					observer.onEvent(FileObserver.CREATE, f.getName());
+				}
+				
+				// Done with initial onEvent calls
+				init = false;
+				
+				// Start watching for new files
+				observer.startWatching();
+				
+				synchronized (startThread) {
+					// Wait to be awoken again by shutdown()
+					try {
+						startThread.wait();
+					} catch (InterruptedException e) {}
+				}
+				
+				// Giveup eventX permissions
+				rundownWithPermissionsChange(066);
+			}
+		};
+		startThread.start();
+	}
+	
+	public void shutdown() {
+		// Let start thread cleanup on it's own sweet time
+		synchronized (startThread) {
+			startThread.notify();
+		}
+		
+		// Stop the observer
+		observer.stopWatching();
+		
+		synchronized (handlers) {
+			// Stop creating new handlers
+			shutdown = true;
+			
+			// Stop all handlers
+			for (EvdevHandler handler : handlers.values()) {
+				handler.stop();
+			}
+		}
+	}
+}

src/com/limelight/binding/video/ConfigurableDecoderRenderer.java

@@ -25,7 +25,7 @@ public class ConfigurableDecoderRenderer implements VideoDecoderRenderer {
 	public void initializeWithFlags(int drFlags) {
 		if ((drFlags & VideoDecoderRenderer.FLAG_FORCE_HARDWARE_DECODING) != 0 ||
 				((drFlags & VideoDecoderRenderer.FLAG_FORCE_SOFTWARE_DECODING) == 0 &&
-				MediaCodecDecoderRenderer.findSafeDecoder() != null)) {
+				MediaCodecDecoderRenderer.findProbableSafeDecoder() != null)) {
 			decoderRenderer = new MediaCodecDecoderRenderer();
 		}
 		else {

src/com/limelight/binding/video/MediaCodecDecoderRenderer.java

@@ -5,12 +5,16 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.concurrent.locks.LockSupport;
 
+import org.jcodec.codecs.h264.io.model.SeqParameterSet;
+import org.jcodec.codecs.h264.io.model.VUIParameters;
+
 import com.limelight.LimeLog;
 import com.limelight.nvstream.av.ByteBufferDescriptor;
 import com.limelight.nvstream.av.DecodeUnit;
 import com.limelight.nvstream.av.video.VideoDecoderRenderer;
 import com.limelight.nvstream.av.video.VideoDepacketizer;
 
+import android.annotation.TargetApi;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.media.MediaCodecInfo.CodecCapabilities;
@@ -18,6 +22,7 @@ import android.media.MediaCodecInfo.CodecProfileLevel;
 import android.media.MediaCodecList;
 import android.media.MediaFormat;
 import android.media.MediaCodec.BufferInfo;
+import android.os.Build;
 import android.view.SurfaceHolder;
 
 public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
@@ -28,21 +33,28 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 	private boolean needsSpsBitstreamFixup;
 	private boolean needsSpsNumRefFixup;
 	private VideoDepacketizer depacketizer;
+	private boolean adaptivePlayback;
 	
 	private long totalTimeMs;
 	private long decoderTimeMs;
 	private int totalFrames;
 	
-	private final static byte[] BITSTREAM_RESTRICTIONS = new byte[] {(byte) 0xF1, (byte) 0x83, 0x2A, 0x00};
+	private String decoderName;
+	private int numSpsIn;
+	private int numPpsIn;
+	private int numIframeIn;
 	
 	public static final List<String> blacklistedDecoderPrefixes;
 	public static final List<String> spsFixupBitstreamFixupDecoderPrefixes;
 	public static final List<String> spsFixupNumRefFixupDecoderPrefixes;
+	public static final List<String> whitelistedAdaptiveResolutionPrefixes;
 	
 	static {
 		blacklistedDecoderPrefixes = new LinkedList<String>();
 		
-		// Nothing here right now :)
+		// Software decoders that don't support H264 high profile
+		blacklistedDecoderPrefixes.add("omx.google");
+		blacklistedDecoderPrefixes.add("AVCDecoder");
 	}
 	
 	static {
@@ -55,6 +67,59 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 		spsFixupNumRefFixupDecoderPrefixes.add("omx.TI");
 		spsFixupNumRefFixupDecoderPrefixes.add("omx.qcom");
 		spsFixupNumRefFixupDecoderPrefixes.add("omx.sec");
+		
+		whitelistedAdaptiveResolutionPrefixes = new LinkedList<String>();
+		whitelistedAdaptiveResolutionPrefixes.add("omx.nvidia");
+		whitelistedAdaptiveResolutionPrefixes.add("omx.qcom");
+		whitelistedAdaptiveResolutionPrefixes.add("omx.sec");
+		whitelistedAdaptiveResolutionPrefixes.add("omx.TI");
+	}
+	
+	@TargetApi(Build.VERSION_CODES.KITKAT)
+	public MediaCodecDecoderRenderer() {
+		//dumpDecoders();
+		
+		MediaCodecInfo decoder = findProbableSafeDecoder();
+		if (decoder == null) {
+			decoder = findFirstDecoder();
+		}
+		if (decoder == null) {
+			// This case is handled later in setup()
+			return;
+		}
+		
+		decoderName = decoder.getName();
+		
+		// Possibly enable adaptive playback on KitKat and above
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+			try {
+				if (decoder.getCapabilitiesForType("video/avc").
+						isFeatureSupported(CodecCapabilities.FEATURE_AdaptivePlayback))
+				{
+					// This will make getCapabilities() return that adaptive playback is supported
+					LimeLog.info("Adaptive playback supported (FEATURE_AdaptivePlayback)");
+					adaptivePlayback = true;
+				}
+			} catch (Exception e) {
+				// Tolerate buggy codecs
+			}
+		}
+				
+		if (!adaptivePlayback) {
+			if (isDecoderInList(whitelistedAdaptiveResolutionPrefixes, decoderName)) {
+				LimeLog.info("Adaptive playback supported (whitelist)");
+				adaptivePlayback = true;
+			}
+		}
+		
+		needsSpsBitstreamFixup = isDecoderInList(spsFixupBitstreamFixupDecoderPrefixes, decoderName);
+		needsSpsNumRefFixup = isDecoderInList(spsFixupNumRefFixupDecoderPrefixes, decoderName);
+		if (needsSpsBitstreamFixup) {
+			LimeLog.info("Decoder "+decoderName+" needs SPS bitstream restrictions fixup");
+		}
+		if (needsSpsNumRefFixup) {
+			LimeLog.info("Decoder "+decoderName+" needs SPS ref num fixup");
+		}
 	}
 	
 	private static boolean isDecoderInList(List<String> decoderList, String decoderName) {
@@ -70,7 +135,8 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 		return false;
 	}
 	
-	public static void dumpDecoders() {
+	public static String dumpDecoders() throws Exception {
+		String str = "";
 		for (int i = 0; i < MediaCodecList.getCodecCount(); i++) {
 			MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
 			
@@ -79,19 +145,63 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 				continue;
 			}
 			
-			LimeLog.info("Decoder: "+codecInfo.getName());
+			str += "Decoder: "+codecInfo.getName()+"\n";
 			for (String type : codecInfo.getSupportedTypes()) {
-				LimeLog.info("\t"+type);
+				str += "\t"+type+"\n";
 				CodecCapabilities caps = codecInfo.getCapabilitiesForType(type);
 				
 				for (CodecProfileLevel profile : caps.profileLevels) {
-					LimeLog.info("\t\t"+profile.profile+" "+profile.level);
+					str += "\t\t"+profile.profile+" "+profile.level+"\n";
 				}
 			}
 		}
+		return str;
+	}
+	
+	private static MediaCodecInfo findFirstDecoder() {
+		for (int i = 0; i < MediaCodecList.getCodecCount(); i++) {
+			MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
+						
+			// Skip encoders
+			if (codecInfo.isEncoder()) {
+				continue;
+			}
+			
+			// Check for explicitly blacklisted decoders
+			if (isDecoderInList(blacklistedDecoderPrefixes, codecInfo.getName())) {
+				LimeLog.info("Skipping blacklisted decoder: "+codecInfo.getName());
+				continue;
+			}
+			
+			// Find a decoder that supports H.264
+			for (String mime : codecInfo.getSupportedTypes()) {
+				if (mime.equalsIgnoreCase("video/avc")) {
+					LimeLog.info("First decoder choice is "+codecInfo.getName());
+					return codecInfo;
+				}
+			}
+		}
+		
+		return null;
+	}
+	
+	public static MediaCodecInfo findProbableSafeDecoder() {
+		// First look for decoders we know are safe
+		try {
+			// If this function completes, it will determine if the decoder is safe
+			return findKnownSafeDecoder();
+		} catch (Exception e) {
+			// Some buggy devices seem to throw exceptions
+			// from getCapabilitiesForType() so we'll just assume
+			// they're okay and go with the first one we find
+			return findFirstDecoder();
+		}
 	}
 
-	public static MediaCodecInfo findSafeDecoder() {
+	// We declare this method as explicitly throwing Exception
+	// since some bad decoders can throw IllegalArgumentExceptions unexpectedly
+	// and we want to be sure all callers are handling this possibility
+	private static MediaCodecInfo findKnownSafeDecoder() throws Exception {
 		for (int i = 0; i < MediaCodecList.getCodecCount(); i++) {
 			MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
 						
@@ -128,41 +238,33 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 		return null;
 	}
 	
+	@TargetApi(Build.VERSION_CODES.KITKAT)
 	@Override
 	public boolean setup(int width, int height, int redrawRate, Object renderTarget, int drFlags) {
-		//dumpDecoders();
+		if (decoderName == null) {
+			LimeLog.severe("No available hardware decoder!");
+			return false;
+		}
 		
-		// It's nasty to put all this in a try-catch block,
-		// but codecs have been known to throw all sorts of crazy runtime exceptions
+		// Codecs have been known to throw all sorts of crazy runtime exceptions
 		// due to implementation problems
 		try {
-			MediaCodecInfo safeDecoder = findSafeDecoder();
-			if (safeDecoder != null) {
-				videoDecoder = MediaCodec.createByCodecName(safeDecoder.getName());
-				needsSpsBitstreamFixup = isDecoderInList(spsFixupBitstreamFixupDecoderPrefixes, safeDecoder.getName());
-				needsSpsNumRefFixup = isDecoderInList(spsFixupNumRefFixupDecoderPrefixes, safeDecoder.getName());
-				if (needsSpsBitstreamFixup) {
-					LimeLog.info("Decoder "+safeDecoder.getName()+" needs SPS bitstream restrictions fixup");
-				}
-				if (needsSpsNumRefFixup) {
-					LimeLog.info("Decoder "+safeDecoder.getName()+" needs SPS ref num fixup");
-				}
-			}
-			else {
-				videoDecoder = MediaCodec.createDecoderByType("video/avc");
-				needsSpsBitstreamFixup = false;
-				needsSpsNumRefFixup = false;
-			}
+			videoDecoder = MediaCodec.createByCodecName(decoderName);
 		} catch (Exception e) {
 			return false;
 		}
 		
 		MediaFormat videoFormat = MediaFormat.createVideoFormat("video/avc", width, height);
+		
+		// Adaptive playback can also be enabled by the whitelist on pre-KitKat devices
+		// so we don't fill these pre-KitKat
+		if (adaptivePlayback && Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+			videoFormat.setInteger(MediaFormat.KEY_MAX_WIDTH, width);
+			videoFormat.setInteger(MediaFormat.KEY_MAX_HEIGHT, height);
+		}
+		
 		videoDecoder.configure(videoFormat, ((SurfaceHolder)renderTarget).getSurface(), null, 0);
 		videoDecoder.setVideoScalingMode(MediaCodec.VIDEO_SCALING_MODE_SCALE_TO_FIT);
-		videoDecoder.start();
-
-		videoDecoderInputBuffers = videoDecoder.getInputBuffers();
 		
 		LimeLog.info("Using hardware decoding");
 		
@@ -190,43 +292,48 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 						}
 					}
 					
-					int outIndex = videoDecoder.dequeueOutputBuffer(info, 0);
-				    if (outIndex >= 0) {
-				    	long presentationTimeUs = info.presentationTimeUs;
-					    int lastIndex = outIndex;
-					    
-					    // Get the last output buffer in the queue
-					    while ((outIndex = videoDecoder.dequeueOutputBuffer(info, 0)) >= 0) {
-					    	videoDecoder.releaseOutputBuffer(lastIndex, false);
-					    	lastIndex = outIndex;
-					    	presentationTimeUs = info.presentationTimeUs;
+					try {
+						int outIndex = videoDecoder.dequeueOutputBuffer(info, 0);
+
+					    if (outIndex >= 0) {
+					    	long presentationTimeUs = info.presentationTimeUs;
+						    int lastIndex = outIndex;
+						    
+						    // Get the last output buffer in the queue
+						    while ((outIndex = videoDecoder.dequeueOutputBuffer(info, 0)) >= 0) {
+						    	videoDecoder.releaseOutputBuffer(lastIndex, false);
+						    	lastIndex = outIndex;
+						    	presentationTimeUs = info.presentationTimeUs;
+						    }
+						    
+						    // Render the last buffer
+					    	videoDecoder.releaseOutputBuffer(lastIndex, true);
+					    	
+						    // Add delta time to the totals (excluding probable outliers)
+						    long delta = System.currentTimeMillis()-(presentationTimeUs/1000);
+						    if (delta > 5 && delta < 300) {
+						    	decoderTimeMs += delta;
+							    totalTimeMs += delta;
+						    }
+					    } else {
+						    switch (outIndex) {
+						    case MediaCodec.INFO_TRY_AGAIN_LATER:
+						    	LockSupport.parkNanos(1);
+						    	break;
+						    case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
+						    	LimeLog.info("Output buffers changed");
+							    break;
+						    case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
+						    	LimeLog.info("Output format changed");
+						    	LimeLog.info("New output Format: " + videoDecoder.getOutputFormat());
+						    	break;
+						    default:
+						      break;
+						    }
 					    }
-					    
-					    // Render the last buffer
-				    	videoDecoder.releaseOutputBuffer(lastIndex, true);
-				    	
-					    // Add delta time to the totals (excluding probable outliers)
-					    long delta = System.currentTimeMillis()-(presentationTimeUs/1000);
-					    if (delta > 5 && delta < 300) {
-					    	decoderTimeMs += delta;
-						    totalTimeMs += delta;
-					    }
-				    } else {
-					    switch (outIndex) {
-					    case MediaCodec.INFO_TRY_AGAIN_LATER:
-					    	LockSupport.parkNanos(1);
-					    	break;
-					    case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
-					    	LimeLog.info("Output buffers changed");
-						    break;
-					    case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
-					    	LimeLog.info("Output format changed");
-					    	LimeLog.info("New output Format: " + videoDecoder.getOutputFormat());
-					    	break;
-					    default:
-					      break;
-					    }
-				    }
+					} catch (Exception e) {
+						throw new RendererException(MediaCodecDecoderRenderer.this, e);
+					}
 				}
 			}
 		};
@@ -238,17 +345,26 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 	@Override
 	public boolean start(VideoDepacketizer depacketizer) {
 		this.depacketizer = depacketizer;
+		
+		// Start the decoder
+		videoDecoder.start();
+		videoDecoderInputBuffers = videoDecoder.getInputBuffers();
+		
+		// Start the rendering thread
 		startRendererThread();
 		return true;
 	}
 
 	@Override
 	public void stop() {
+		// Halt the rendering thread
 		rendererThread.interrupt();
-
 		try {
 			rendererThread.join();
 		} catch (InterruptedException e) { }
+		
+		// Stop the decoder
+		videoDecoder.stop();
 	}
 
 	@Override
@@ -266,7 +382,11 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 				return false;
 			}
 			
-			inputIndex = videoDecoder.dequeueInputBuffer(100000);
+			try {
+				inputIndex = videoDecoder.dequeueInputBuffer(100000);
+			} catch (Exception e) {
+				throw new RendererException(this, e);
+			}
 		} while (inputIndex < 0);
 		
 		ByteBuffer buf = videoDecoderInputBuffers[inputIndex];
@@ -288,70 +408,60 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 		}
 		if ((decodeUnitFlags & DecodeUnit.DU_FLAG_SYNC_FRAME) != 0) {
 			codecFlags |= MediaCodec.BUFFER_FLAG_SYNC_FRAME;
+			numIframeIn++;
 		}
 		
-		if ((decodeUnitFlags & DecodeUnit.DU_FLAG_CODEC_CONFIG) != 0 &&
-			(needsSpsBitstreamFixup || needsSpsNumRefFixup)) {
+		if ((decodeUnitFlags & DecodeUnit.DU_FLAG_CODEC_CONFIG) != 0) {
 			ByteBufferDescriptor header = decodeUnit.getBufferList().get(0);
 			if (header.data[header.offset+4] == 0x67) {
-				byte last = header.data[header.length+header.offset-1];
-
-				// TI OMAP4 requires a reference frame count of 1 to decode successfully
-				if (needsSpsNumRefFixup) {
-					LimeLog.info("Fixing up num ref frames");
-					this.replace(header, 80, 9, new byte[] {0x40}, 3);
-				}
-
-				// The SPS that comes in the current H264 bytestream doesn't set bitstream_restriction_flag
-				// or max_dec_frame_buffering which increases decoding latency on Tegra.
-				// We manually modify the SPS here to speed-up decoding if the decoder was flagged as needing it.
-				int spsLength;
-				if (needsSpsBitstreamFixup) {
-					if (!needsSpsNumRefFixup) {
-						switch (header.length) {
-						case 26:
-							LimeLog.info("Adding bitstream restrictions to SPS (26)");
-							buf.put(header.data, header.offset, 24);
-							buf.put((byte) 0x11);
-							buf.put((byte) 0xe3);
-							buf.put((byte) 0x06);
-							buf.put((byte) 0x50);
-							spsLength = header.length + 2;
-							break;
-						case 27:
-							LimeLog.info("Adding bitstream restrictions to SPS (27)");
-							buf.put(header.data, header.offset, 25);
-							buf.put((byte) 0x04);
-							buf.put((byte) 0x78);
-							buf.put((byte) 0xc1);
-							buf.put((byte) 0x94);
-							spsLength = header.length + 2;
-							break;
-						default:
-							LimeLog.warning("Unknown SPS of length "+header.length);
-							buf.put(header.data, header.offset, header.length);
-							spsLength = header.length;
-							break;
-						}
-					}
-					else {
-						// Set bitstream restrictions to only buffer single frame
-						// (starts 9 bits before stop bit and 6 bits earlier because of the shortening above)
-						this.replace(header, header.length*8+Integer.numberOfLeadingZeros(last & - last)%8-9-6, 2, BITSTREAM_RESTRICTIONS, 3*8);
-						buf.put(header.data, header.offset, header.length);
-						spsLength = header.length;
+				numSpsIn++;
+				
+				if (needsSpsBitstreamFixup || needsSpsNumRefFixup) {
+					ByteBuffer spsBuf = ByteBuffer.wrap(header.data);
+					
+					// Skip to the start of the NALU data
+					spsBuf.position(header.offset+5);
+					
+					SeqParameterSet sps = SeqParameterSet.read(spsBuf);
+										
+					// TI OMAP4 requires a reference frame count of 1 to decode successfully
+					if (needsSpsNumRefFixup) {
+						LimeLog.info("Fixing up num ref frames");
+						sps.num_ref_frames = 1;
 					}
 
-				}
-				else {
-					buf.put(header.data, header.offset, header.length);
-					spsLength = header.length;
-				}
+					// The SPS that comes in the current H264 bytestream doesn't set bitstream_restriction_flag
+					// or max_dec_frame_buffering which increases decoding latency on Tegra.
+					if (needsSpsBitstreamFixup) {
+						LimeLog.info("Adding bitstream restrictions");
 
-				videoDecoder.queueInputBuffer(inputIndex,
-						0, spsLength,
-						currentTime * 1000, codecFlags);
-				return true;
+						sps.vuiParams.bitstreamRestriction = new VUIParameters.BitstreamRestriction();
+						sps.vuiParams.bitstreamRestriction.motion_vectors_over_pic_boundaries_flag = false;
+						sps.vuiParams.bitstreamRestriction.max_bytes_per_pic_denom = 0;
+						sps.vuiParams.bitstreamRestriction.max_bits_per_mb_denom = 0;
+						sps.vuiParams.bitstreamRestriction.log2_max_mv_length_horizontal = 16;
+						sps.vuiParams.bitstreamRestriction.log2_max_mv_length_vertical = 16;
+						sps.vuiParams.bitstreamRestriction.num_reorder_frames = 0;
+						sps.vuiParams.bitstreamRestriction.max_dec_frame_buffering = 1;
+					}
+					
+					// Write the annex B header
+					buf.put(header.data, header.offset, 5);
+					
+					// Write the modified SPS to the input buffer
+					sps.write(buf);
+					
+					try {
+						videoDecoder.queueInputBuffer(inputIndex,
+								0, buf.position(),
+								currentTime * 1000, codecFlags);
+					} catch (Exception e) {
+						throw new RendererException(this, e, buf, codecFlags);
+					}
+					return true;
+				}
+			} else if (header.data[header.offset+4] == 0x68) {
+				numPpsIn++;
 			}
 		}
 
@@ -361,95 +471,21 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 			buf.put(desc.data, desc.offset, desc.length);
 		}
 
-		videoDecoder.queueInputBuffer(inputIndex,
-				0, decodeUnit.getDataLength(),
-				currentTime * 1000, codecFlags);
+		try {
+			videoDecoder.queueInputBuffer(inputIndex,
+					0, decodeUnit.getDataLength(),
+					currentTime * 1000, codecFlags);
+		} catch (Exception e) {
+			throw new RendererException(this, e, buf, codecFlags);
+		}
 		
 		return true;
 	}
 
 	@Override
 	public int getCapabilities() {
-		return 0;
-	}
-
-	/**
-	 * Replace bits in array 
-	 * @param source array in which bits should be replaced
-	 * @param srcOffset offset in bits where replacement should take place
-	 * @param srcLength length in bits of data that should be replaced
-	 * @param data data array with the the replacement data
-	 * @param dataLength length of replacement data in bits
-	 */
-	public void replace(ByteBufferDescriptor source, int srcOffset, int srcLength, byte[] data, int dataLength) {
-		//Add 7 to always round up
-		int length = (source.length*8-srcLength+dataLength+7)/8;
-
-		int bitOffset = srcOffset%8;
-		int byteOffset = srcOffset/8;
-
-		byte dest[] = null;
-		int offset = 0;
-		if (length>source.length) {
-			dest = new byte[length];
-
-			//Copy the first bytes
-			System.arraycopy(source.data, source.offset, dest, offset, byteOffset);
-		} else {
-			dest = source.data;
-			offset = source.offset;
-		}
-
-		int byteLength = (bitOffset+dataLength+7)/8;
-		int bitTrailing = 8 - (srcOffset+dataLength) % 8;
-		for (int i=0;i<byteLength;i++) {
-			byte result = 0;
-			if (i != 0)
-				result = (byte) (data[i-1] << 8-bitOffset);
-			else if (bitOffset > 0)
-				result = (byte) (source.data[byteOffset+source.offset] & (0xFF << 8-bitOffset));
-
-			if (i == 0 || i != byteLength-1) {
-				byte moved = (byte) ((data[i]&0xFF) >>> bitOffset);
-				result |= moved;
-			}
-
-			if (i == byteLength-1 && bitTrailing > 0) {
-				int sourceOffset = srcOffset+srcLength/8;
-				int bitMove = (dataLength-srcLength)%8;
-				if (bitMove<0) {
-					result |= (byte) (source.data[sourceOffset+source.offset] << -bitMove & (0xFF >>> bitTrailing));
-					result |= (byte) (source.data[sourceOffset+1+source.offset] << -bitMove & (0xFF >>> 8+bitMove));
-				} else {
-					byte moved = (byte) ((source.data[sourceOffset+source.offset]&0xFF) >>> bitOffset);
-					result |= moved;
-				}
-			}
-
-			dest[i+byteOffset+offset] = result;
-		}
-
-		//Source offset
-		byteOffset += srcLength/8;
-		bitOffset = (srcOffset+dataLength-srcLength)%8;
-
-		//Offset in destination
-		int destOffset = (srcOffset+dataLength)/8;
-
-		for (int i=1;i<source.length-byteOffset;i++) {
-			int diff = destOffset >= byteOffset-1?i:source.length-byteOffset-i;
-
-			byte result = 0;
-			result = (byte) (source.data[byteOffset+diff-1+source.offset] << 8-bitOffset);
-			byte moved = (byte) ((source.data[byteOffset+diff+source.offset]&0xFF) >>> bitOffset);
-			result ^= moved;
-
-			dest[diff+destOffset+offset] = result;
-		}
-
-		source.data = dest;
-		source.offset = offset;
-		source.length = length;
+		return adaptivePlayback ?
+				VideoDecoderRenderer.CAPABILITY_ADAPTIVE_RESOLUTION : 0;
 	}
 
 	@Override
@@ -467,4 +503,54 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 		}
 		return (int)(totalTimeMs / totalFrames);
 	}
+	
+	public class RendererException extends RuntimeException {
+		private static final long serialVersionUID = 8985937536997012406L;
+		
+		private Exception originalException;
+		private MediaCodecDecoderRenderer renderer;
+		private ByteBuffer currentBuffer;
+		private int currentCodecFlags;
+		
+		public RendererException(MediaCodecDecoderRenderer renderer, Exception e) {
+			this.renderer = renderer;
+			this.originalException = e;
+		}
+		
+		public RendererException(MediaCodecDecoderRenderer renderer, Exception e, ByteBuffer currentBuffer, int currentCodecFlags) {
+			this.renderer = renderer;
+			this.originalException = e;
+			this.currentBuffer = currentBuffer;
+			this.currentCodecFlags = currentCodecFlags;
+		}
+		
+		public String toString() {
+			String str = "";
+			
+			str += "Decoder: "+renderer.decoderName+"\n";
+			str += "In stats: "+renderer.numSpsIn+", "+renderer.numPpsIn+", "+renderer.numIframeIn+"\n";
+			str += "Total frames: "+renderer.totalFrames+"\n";
+			
+			if (currentBuffer != null) {
+				str += "Current buffer: ";
+				currentBuffer.flip();
+				while (currentBuffer.hasRemaining() && currentBuffer.position() < 10) {
+					str += String.format("%02x ", currentBuffer.get());
+				}
+				str += "\n";
+				str += "Buffer codec flags: "+currentCodecFlags+"\n";
+			}
+			
+			str += "Full decoder dump:\n";
+			try {
+				str += dumpDecoders();
+			} catch (Exception e) {
+				str += e.getMessage();
+			}
+			
+			str += originalException.toString();
+			
+			return str;
+		}
+	}
 }

src/com/limelight/computers/ComputerManagerService.java

@@ -46,6 +46,8 @@ public class ComputerManagerService extends Service {
 	private ThreadPoolExecutor pollingPool;
 	private Timer pollingTimer;
 	private ComputerManagerListener listener = null;
+	private AtomicInteger activePolls = new AtomicInteger(0);
+	private boolean stopped;
 
 	private DiscoveryService.DiscoveryBinder discoveryBinder;
 	private ServiceConnection discoveryServiceConnection = new ServiceConnection() {
@@ -69,6 +71,9 @@ public class ComputerManagerService extends Service {
 	
 	public class ComputerManagerBinder extends Binder {
 		public void startPolling(ComputerManagerListener listener) {
+			// Not stopped
+			stopped = false;
+			
 			// Set the listener
 			ComputerManagerService.this.listener = listener;
 			
@@ -92,6 +97,14 @@ public class ComputerManagerService extends Service {
 			}
 		}
 		
+		public void waitForPollingStopped() {
+			while (activePolls.get() != 0) {
+				try {
+					Thread.sleep(250);
+				} catch (InterruptedException e) {}
+			}
+		}
+		
 		public boolean addComputerBlocking(InetAddress addr) {
 			return ComputerManagerService.this.addComputerBlocking(addr);
 		}
@@ -116,6 +129,9 @@ public class ComputerManagerService extends Service {
 	
 	@Override
 	public boolean onUnbind(Intent intent) {
+		// Stopped now
+		stopped = true;
+		
 		// Stop mDNS autodiscovery
 		discoveryBinder.stopDiscovery();
 		
@@ -385,15 +401,23 @@ public class ComputerManagerService extends Service {
 			public void run() {
 				boolean newPc = (details.name == null);
 				
+				if (stopped) {
+					return;
+				}
+				
 				if (!getLocalDatabaseReference()) {
 					return;
 				}
 				
+				activePolls.incrementAndGet();
+				
 				// Poll the machine
 				if (!doPollMachine(details)) {
 					details.state = ComputerDetails.State.OFFLINE;
 					details.reachability = ComputerDetails.Reachability.OFFLINE;
 				}
+				
+				activePolls.decrementAndGet();
 
 				// If it's online, update our persistent state
 				if (details.state == ComputerDetails.State.ONLINE) {