input: add a way to pipe multiple commands

Very similar to typical shell semantics. If a command writes output to
a result, the next command can now read those results and use it. The
current implementation assumes that the only command results will always
be strings and does not attempt to deal with any other type. This can
always be expanded in the future if a need arises.

Author: Dudemanguy

DOCS/interface-changes/command-piping.txt

@@ -0,0 +1 @@
+commands can now pipe output into each other e.g. `expand-text "foo" | show-text -`

DOCS/man/input.rst

@@ -69,6 +69,16 @@ You can bind multiple commands to one key. For example:
 
 | a show-text "command 1" ; show-text "command 2"
 
+Some commands also write output to a result. You can pipe the result to the next
+command in a way similar to the shell.
+
+| a expand-text "text" | show-text -
+
+``|`` Is the special character that designates the pipe. It is functionally
+similar to using ``;``. Specifying ``-`` indicates that the argument will
+receive the output of the previous run command. It is possible to specify ``-``
+multiple times.
+
 It's also possible to bind a command to a sequence of keys:
 
 | a-b-c show-text "command run after a, b, c have been pressed"

input/cmd.c

@@ -313,7 +313,7 @@ struct mp_cmd *mp_input_parse_cmd_node(struct mp_log *log, mpv_node *node)
 static bool read_token(bstr str, bstr *out_rest, bstr *out_token)
 {
     bstr t = bstr_lstrip(str);
-    int next = bstrcspn(t, WHITESPACE "#;");
+    int next = bstrcspn(t, WHITESPACE "#;|");
     if (!next)
         return false;
     *out_token = bstr_splice(t, 0, next);
@@ -417,11 +417,15 @@ static struct mp_cmd *parse_cmd_str(struct mp_log *log, void *tmp,
             break;
 
         struct mp_cmd_arg arg = {.type = opt};
-        r = m_option_parse(ctx->log, opt, bstr0(cmd->name), cur_token, &arg.v);
-        if (r < 0) {
-            MP_ERR(ctx, "Command %s: argument %d can't be parsed: %s.\n",
-                   cmd->name, i + 1, m_option_strerror(r));
-            goto error;
+        if (bstrcmp0(cur_token, "-") == 0) {
+            arg.substitute = true;
+        } else {
+            r = m_option_parse(ctx->log, opt, bstr0(cmd->name), cur_token, &arg.v);
+            if (r < 0) {
+                MP_ERR(ctx, "Command %s: argument %d can't be parsed: %s.\n",
+                       cmd->name, i + 1, m_option_strerror(r));
+                goto error;
+            }
         }
 
         MP_TARRAY_APPEND(cmd, cmd->args, cmd->nargs, arg);
@@ -465,7 +469,8 @@ mp_cmd_t *mp_input_parse_cmd_str(struct mp_log *log, bstr str, const char *loc)
         str = bstr_lstrip(str);
         // read_token just to check whether it's trailing whitespace only
         bstr u1, u2;
-        if (!bstr_eatstart0(&str, ";") || !read_token(str, &u1, &u2))
+        bool receive_pipe = bstr_startswith(str, bstr0("|"));
+        if ((!bstr_eatstart0(&str, ";") && !bstr_eatstart0(&str, "|")) || !read_token(str, &u1, &u2))
             break;
         // Multi-command. Since other input.c code uses queue_next for its
         // own purposes, a pseudo-command is used to wrap the command list.
@@ -489,6 +494,7 @@ mp_cmd_t *mp_input_parse_cmd_str(struct mp_log *log, bstr str, const char *loc)
             cmd = NULL;
             goto done;
         }
+        sub->receive_pipe = receive_pipe;
         talloc_steal(cmd, sub);
         *p_prev = sub;
         p_prev = &sub->queue_next;

input/cmd.h

@@ -97,6 +97,7 @@ struct mp_cmd_arg {
         char **str_list;
         void *p;
     } v;
+    bool substitute;
 };
 
 typedef struct mp_cmd {
@@ -114,6 +115,7 @@ typedef struct mp_cmd {
     bool repeated : 1;
     bool mouse_move : 1;
     bool canceled : 1;
+    bool receive_pipe : 1; // can read output from previous command
     int mouse_x, mouse_y;
     struct mp_cmd *queue_next;
     double scale;               // for scaling numeric arguments

player/command.c

@@ -5296,11 +5296,37 @@ struct cmd_list_ctx {
     int num_sub;
 };
 
+static bool substitute_args(struct MPContext *ctx, struct mp_cmd *cmd,
+                            struct mpv_node *replace)
+{
+    if (!cmd->receive_pipe)
+        return true;
+
+    // TODO: allow more types?
+    if (replace->format != MPV_FORMAT_STRING)
+        return false;
+
+    for (int i = 0; i < cmd->nargs; ++i) {
+        if (!cmd->args[i].substitute)
+            continue;
+        int r = m_option_parse(ctx->log, cmd->args[i].type, bstr0(cmd->name),
+                               bstr0(replace->u.string), &cmd->args[i].v);
+        if (r < 0)
+            return false;
+    }
+    return true;
+}
+
 static void continue_cmd_list(struct cmd_list_ctx *list);
 
 static void on_cmd_list_sub_completion(struct mp_cmd_ctx *cmd)
 {
     struct cmd_list_ctx *list = cmd->on_completion_priv;
+    if (cmd->cmd->receive_pipe)
+        mpv_free_node_contents(&list->parent->previous_result);
+
+    if (cmd->cmd->queue_next && cmd->cmd->queue_next->receive_pipe)
+        list->parent->previous_result = cmd->result;
 
     if (list->current_valid && mp_thread_id_equal(list->current_tid, mp_thread_current_id())) {
         list->completed_recursive = true;
@@ -5327,6 +5353,11 @@ static void continue_cmd_list(struct cmd_list_ctx *list)
             list->current_valid = true;
             list->current_tid = mp_thread_current_id();
 
+            if (!substitute_args(list->mpctx, sub, &list->parent->previous_result)) {
+                MP_ERR(list->mpctx, "Pipe input for command '%s' could not be parse.\n", sub->name);
+                talloc_free(sub);
+                continue;
+            }
             run_command(list->mpctx, sub, NULL, on_cmd_list_sub_completion, list);
 
             list->current_valid = false;
@@ -5376,7 +5407,8 @@ void mp_cmd_ctx_complete(struct mp_cmd_ctx *cmd)
         cmd->on_completion(cmd);
     if (cmd->abort)
         mp_abort_remove(cmd->mpctx, cmd->abort);
-    mpv_free_node_contents(&cmd->result);
+    if (!cmd->cmd->queue_next || !cmd->cmd->queue_next->receive_pipe)
+        mpv_free_node_contents(&cmd->result);
     talloc_free(cmd);
 }
 
@@ -5440,6 +5472,11 @@ void run_command(struct MPContext *mpctx, struct mp_cmd *cmd,
         mp_abort_add(mpctx, ctx->abort);
     }
 
+    if (ctx->on_completion_priv) {
+        struct cmd_list_ctx *list = ctx->on_completion_priv;
+        ctx->previous_result = list->parent->previous_result;
+    }
+
     struct MPOpts *opts = mpctx->opts;
     ctx->on_osd = cmd->flags & MP_ON_OSD_FLAGS;
     bool auto_osd = ctx->on_osd == MP_ON_OSD_AUTO;

player/command.h

@@ -52,6 +52,7 @@ struct mp_cmd_ctx {
     // completion callback).
     bool success;       // true by default
     struct mpv_node result;
+    struct mpv_node previous_result; // result from the previously run command
     // Command handlers can set this to false if returning from the command
     // handler does not complete the command. It stops the common command code
     // from signaling the completion automatically, and you can call