4 files changed, 71 insertions, 25 deletions

diff --git a/DOCS/man/en/mplayer.1 b/DOCS/man/en/mplayer.1
index 7d96bd2773..0f3a2b2aa6 100644
--- a/DOCS/man/en/mplayer.1
+++ b/DOCS/man/en/mplayer.1
@@ -922,13 +922,10 @@ several 'echo "seek 10" > mp_pipe' and the pipe will stay valid.
 .TP
 .B \-key\-fifo\-size <2\-65000>
 Specify the size of the FIFO that buffers key events (default: 7).
-A FIFO of size n can buffer (n\-1) events.
-If it is too small some events may be lost
-(leading to "stuck mouse buttons" and similar effects).
-If it is too big, MPlayer may seem to hang while it
-processes the buffered events.
-To get the same behavior as before this option was introduced,
-set it to 2 for Linux or 1024 for Windows.
+If it is too small some events may be lost.
+The main disadvantage of setting it to a very large value is that if you
+hold down a key triggering some particularly slow command then the player
+may be unresponsive while it processes all the queued commands.
 .
 .TP
 .B \-lircconf <filename> (LIRC only)
diff --git a/input/input.c b/input/input.c
index 4c69d00400..9a74abcdfb 100644
--- a/input/input.c
+++ b/input/input.c
@@ -1318,8 +1318,17 @@ static mp_cmd_t *read_events(struct input_ctx *ictx, int time)
 #endif
 
         int code;
-        while ((code = key_fds[i].read_func.key(key_fds[i].ctx,
-                                                key_fds[i].fd)) >= 0) {
+        while (1) {
+            code = key_fds[i].read_func.key(key_fds[i].ctx, key_fds[i].fd);
+            if (code < 0) {
+                if (code == MP_INPUT_RELEASE_ALL) {
+                    memset(ictx->key_down, 0, sizeof(ictx->key_down));
+                    ictx->num_key_down = 0;
+                    ictx->last_key_down = 0;
+                    continue;
+                }
+                break;
+            }
             mp_cmd_t *ret = interpret_key(ictx, code);
             if (ret)
                 return ret;
diff --git a/input/input.h b/input/input.h
index 2e48679856..10469f13ad 100644
--- a/input/input.h
+++ b/input/input.h
@@ -181,6 +181,9 @@ typedef enum {
 #define MP_INPUT_NOTHING -3
 //! Input will be available if you try again
 #define MP_INPUT_RETRY -4
+// Key FIFO was full - release events may be lost, zero button-down status
+#define MP_INPUT_RELEASE_ALL -5
+
 
 #ifndef MP_MAX_KEY_DOWN
 #define MP_MAX_KEY_DOWN 32
diff --git a/mp_fifo.c b/mp_fifo.c
index b470c55a83..4bda7209e0 100644
--- a/mp_fifo.c
+++ b/mp_fifo.c
@@ -17,6 +17,8 @@
  */
 
 #include <stdlib.h>
+#include <assert.h>
+#include <stdbool.h>
 #include "osdep/timer.h"
 #include "input/input.h"
 #include "input/keycodes.h"
@@ -29,8 +31,10 @@ struct mp_fifo {
     struct MPOpts *opts;
     int *data;
     int readpos;
-    int writepos;
     int size;
+    int num_entries;
+    int max_up;
+    int num_up;
     int last_key_down;
     unsigned last_down_time;
 };
@@ -39,33 +43,66 @@ struct mp_fifo *mp_fifo_create(struct MPOpts *opts)
 {
     struct mp_fifo *fifo = talloc_zero(NULL, struct mp_fifo);
     fifo->opts = opts;
-    fifo->size = opts->key_fifo_size;
+    /* Typical mouse wheel use will generate a sequence repeating 3 events:
+     * down, doubleclick, up, down, doubleclick, up, ...
+     * Normally only one of those event types triggers a command,
+     * so allow opts->key_fifo_size such repeats.
+     */
+    fifo->max_up = opts->key_fifo_size;
+    fifo->size = opts->key_fifo_size * 3;
     fifo->data = talloc_array_ptrtype(fifo, fifo->data, fifo->size);
     return fifo;
 }
 
+static bool is_up(int code)
+{
+    return code > 0 && !(code & MP_KEY_DOWN)
+        && !(code >= MOUSE_BTN0_DBL && code < MOUSE_BTN_DBL_END);
+}
+
+static int fifo_peek(struct mp_fifo *fifo, int offset)
+{
+    return fifo->data[(fifo->readpos + offset) % fifo->size];
+}
+
+static int fifo_read(struct mp_fifo *fifo)
+{
+    int code = fifo_peek(fifo, 0);
+    fifo->readpos += 1;
+    fifo->readpos %= fifo->size;
+    fifo->num_entries--;
+    fifo->num_up -= is_up(code);
+    assert(fifo->num_entries >= 0);
+    assert(fifo->num_up >= 0);
+    return code;
+}
+
+static void fifo_write(struct mp_fifo *fifo, int code)
+{
+    fifo->data[(fifo->readpos + fifo->num_entries) % fifo->size] = code;
+    fifo->num_entries++;
+    fifo->num_up += is_up(code);
+    assert(fifo->num_entries <= fifo->size);
+    assert(fifo->num_up <= fifo->max_up);
+}
+
 static void mplayer_put_key_internal(struct mp_fifo *fifo, int code)
 {
-    int fifo_free = fifo->readpos - fifo->writepos - 1;
-    if (fifo_free < 0)
-        fifo_free += fifo->size;
-    if (!fifo_free)
-        return; // FIFO FULL!!
-    // reserve some space for key release events to avoid stuck keys
-    if((code & MP_KEY_DOWN) && fifo_free < (fifo->size >> 1))
-        return;
-    fifo->data[fifo->writepos++] = code;
-    fifo->writepos %= fifo->size;
+    // Clear key-down state if we're forced to drop entries
+    if (fifo->num_entries >= fifo->size - 1
+        || fifo->num_up >= fifo->max_up) {
+        if (fifo_peek(fifo, fifo->num_entries - 1) != MP_INPUT_RELEASE_ALL)
+            fifo_write(fifo, MP_INPUT_RELEASE_ALL);
+    } else
+        fifo_write(fifo, code);
 }
 
 int mplayer_get_key(void *ctx, int fd)
 {
     struct mp_fifo *fifo = ctx;
-    if (fifo->writepos == fifo->readpos)
+    if (!fifo->num_entries)
         return MP_INPUT_NOTHING;
-    int key = fifo->data[fifo->readpos++];
-    fifo->readpos %= fifo->size;
-    return key;
+    return fifo_read(fifo);
 }
 
 static void put_double(struct mp_fifo *fifo, int code)