input: rewrite -key-fifo-size limiting logic

Instead of strictly limiting the number of total entries in the
internal fifo, make the overall buffer bigger and try to limit entries
based on how many bound commands they're expected to generate. Now
doubleclick and button down events aren't counted for that limit.
Normally the sequence down-doubleclick-up generates at most one
command, so this better matches the quantity we actually want to
limit. Also add a mechanism to clear the button combination state kept
by input.c when the fifo is full; this avoids "stuck button" problems
due to button release events being dropped.

The key combination state clearing is partially based on MPlayer 1
changes by Reimar Döffinger (though overall the effects of this commit
are quite different). It still doesn't make "stuck button" problems
completely impossible; at least if the VO gets closed while a button
was down then nothing will send a button up event or reset state.

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)

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;

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

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)