Finish implementing time-pos, sub-add and event ipc

1 files changed, 313 insertions, 33 deletions

diff --git a/video_player/src/main.cpp b/video_player/src/main.cpp
index 3a06f92..42ff936 100644
--- a/video_player/src/main.cpp
+++ b/video_player/src/main.cpp
@@ -3,18 +3,55 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
+#include <locale.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <thread>
+#include <mutex>
 
 #include <mpv/client.h>
+#include <json/json.h>
+
+#define COMMAND_BUFFER_MAX_SIZE 2048
 
 static void usage() {
-    fprintf(stderr, "usage: quickmedia-video-player [--wid <window_id>] <file>\n");
+    fprintf(stderr, "usage: quickmedia-video-player [--wid <window_id>] [--ipc-fd <fd>] [--no-config] <file>\n");
     fprintf(stderr, "  --wid <window_id>    The window to embed the video player into. Optional\n");
+    fprintf(stderr, "  --ipc-fd <fd>        A bi-directional (socketpair) file descriptor to receive commands from. Optional\n");
+    fprintf(stderr, "  --no-config          Do not load the users mpv config (~/.config/mpv/mpv.conf). Optional, the users mpv config is loaded by default\n");
     fprintf(stderr, "examples:\n");
     fprintf(stderr, "  quickmedia-video-player video.mp4\n");
-    fprintf(stderr, "  quickmedia-video-player --wid 30481231 video.mp4\n");
+    fprintf(stderr, "  quickmedia-video-player --wid 30481231 -- video.mp4\n");
     exit(1);
 }
 
+static ssize_t read_eintr(int fd, void *buffer, size_t size) {
+    while(true) {
+        ssize_t bytes_read = read(fd, buffer, size);
+        if(bytes_read == -1) {
+            if(errno != EINTR)
+                return -1;
+        } else {
+            return bytes_read;
+        }
+    }
+}
+
+static ssize_t write_all(int fd, const void *buffer, size_t size) {
+    ssize_t bytes_written = 0;
+    while((size_t)bytes_written < size) {
+        ssize_t written = write(fd, (char*)buffer + bytes_written, size - bytes_written);
+        if(written == -1) {
+            if(errno != EINTR)
+                return -1;
+        } else {
+            bytes_written += written;
+        }
+    }
+    return bytes_written;
+}
+
 static bool string_to_long(const char *str, long &result) {
     errno = 0;
     char *endptr = NULL;
@@ -22,22 +59,193 @@ static bool string_to_long(const char *str, long &result) {
     return endptr != str && errno == 0;
 }
 
+static bool fd_is_valid(int fd) {
+    errno = 0;
+    return fcntl(fd, F_GETFD) != -1 && errno != EBADF;
+}
+
+static size_t ipc_handler(mpv_handle *mpv_ctx, int fd, char *buffer, size_t buffer_size, bool &disconnected) {
+    ssize_t bytes_read = read_eintr(fd, buffer, buffer_size);
+    if(bytes_read < 0) {
+        fprintf(stderr, "Error: ipc read failed, error: %s\n", strerror(errno));
+        //exit(3);
+        disconnected = false;
+        return 0;
+    }
+
+    mpv_wakeup(mpv_ctx);
+    disconnected = (bytes_read == 0);
+    return bytes_read;
+}
+
+static Json::Value handle_json_command_time_pos(mpv_handle *mpv_ctx) {
+    double time_pos = 0.0;
+    const int res = mpv_get_property(mpv_ctx, "time-pos", MPV_FORMAT_DOUBLE, &time_pos);
+
+    Json::Value response_json(Json::objectValue);
+    if(res < 0) {
+        response_json["status"] = "error";
+        response_json["message"] = mpv_error_string(res);
+    } else {
+        response_json["status"] = "success";
+        response_json["data"] = time_pos;
+    }
+    return response_json;
+}
+
+static Json::Value handle_json_command_sub_add(mpv_handle *mpv_ctx, const Json::Value &json_root) {
+    Json::Value response_json(Json::objectValue);
+
+    const Json::Value &data_json = json_root["data"];
+    if(!data_json.isObject()) {
+        response_json["status"] = "error";
+        response_json["message"] = "expected \"data\" to be an object";
+        return response_json;
+    }
+
+    const Json::Value &file_json = data_json["file"];
+    const Json::Value &title_json = data_json["title"];
+    const Json::Value &language_json = data_json["language"];
+
+    if(!file_json.isString()) {
+        response_json["status"] = "error";
+        response_json["message"] = "expected \"data.file\" to be a string";
+        return response_json;
+    }
+
+    if(!title_json.isString() && !title_json.isNull()) {
+        response_json["status"] = "error";
+        response_json["message"] = "expected optional field \"data.title\" to be a string or omitted";
+        return response_json;
+    }
+
+    if(!language_json.isString() && !language_json.isNull()) {
+        response_json["status"] = "error";
+        response_json["message"] = "expected optional field \"data.language\" to be a string or omitted";
+        return response_json;
+    }
+
+    std::vector<const char*> args;
+    args.push_back("sub-add");
+    args.push_back(file_json.asCString());
+    args.push_back("auto");
+    if(title_json.isString())
+        args.push_back(title_json.asCString());
+    if(language_json.isString()) {
+        if(!title_json.isString())
+            args.push_back(language_json.asCString());
+        args.push_back(language_json.asCString());
+    }
+    args.push_back(nullptr);
+    
+    const int res = mpv_command_async(mpv_ctx, 0, args.data());
+    if(res < 0) {
+        response_json["status"] = "error";
+        response_json["message"] = mpv_error_string(res);
+    } else {
+        response_json["status"] = "success";
+    }
+    return response_json;
+}
+
+static void handle_json_command(mpv_handle *mpv_ctx, const Json::Value &json_root, int fd) {
+    if(!json_root.isObject()) {
+        fprintf(stderr, "Error: expected command json root to be an object\n");
+        return;
+    }
+
+    const Json::Value &command_json = json_root["command"];
+    if(!command_json.isString()) {
+        fprintf(stderr, "Error: command json is missing field \"command\" or it's not a string\n");
+        return;
+    }
+
+    Json::Value response_json;
+    if(strcmp(command_json.asCString(), "time-pos") == 0) {
+        response_json = handle_json_command_time_pos(mpv_ctx);
+    } else if(strcmp(command_json.asCString(), "sub-add") == 0) {
+        response_json = handle_json_command_sub_add(mpv_ctx, json_root);
+    } else {
+        Json::Value response_json(Json::objectValue);
+        response_json["status"] = "error";
+        response_json["message"] = "invalid command " + command_json.asString() + ", expected time-pos or sub-add";
+    }
+
+    Json::StreamWriterBuilder builder;
+    builder["commentStyle"] = "None";
+    builder["indentation"] = "";
+    const std::string response_str = Json::writeString(builder, response_json) + "\n";
+
+    ssize_t bytes_written = write_all(fd, response_str.data(), response_str.size());
+    if(bytes_written < 0) {
+        fprintf(stderr, "Error: ipc write failed, error: %s\n", strerror(errno));
+        //exit(3);
+        return;
+    }
+}
+
+static void handle_request_commands_line_by_line(mpv_handle *mpv_ctx, int fd, char *command_buffer, size_t &command_buffer_size, Json::Value &json_root, std::string &json_errors) {
+    size_t command_offset = 0;
+    while(command_offset < command_buffer_size) {
+        const void *space_p = memchr(command_buffer + command_offset, '\n', command_buffer_size - command_offset);
+        if(!space_p)
+            space_p = command_buffer + command_buffer_size;
+
+        Json::CharReaderBuilder json_builder;
+        std::unique_ptr<Json::CharReader> json_reader(json_builder.newCharReader());
+        json_errors.clear();
+        if(json_reader->parse(command_buffer + command_offset, (const char*)space_p, &json_root, &json_errors)) {
+            handle_json_command(mpv_ctx, json_root, fd);
+        } else {
+            fprintf(stderr, "Error: failed to parse command as json, error: %s\n", json_errors.c_str());
+        }
+        command_offset = ((const char*)space_p + 1) - command_buffer;
+    }
+    command_buffer_size = 0;
+}
+
+static void send_event(const char *event_name, int fd) {
+    Json::Value json_root(Json::objectValue);
+    json_root["name"] = event_name;
+
+    Json::StreamWriterBuilder builder;
+    builder["commentStyle"] = "None";
+    builder["indentation"] = "";
+    const std::string response_str = Json::writeString(builder, json_root) + "\n";
+
+    ssize_t bytes_written = write_all(fd, response_str.data(), response_str.size());
+    if(bytes_written < 0) {
+        fprintf(stderr, "Error: ipc write failed, error: %s\n", strerror(errno));
+        //exit(3);
+        return;
+    }
+}
+
 static inline void check_error(int status) {
     if (status < 0) {
-        fprintf(stderr, "mpv API error: %s\n", mpv_error_string(status));
+        fprintf(stderr, "Error: mpv error: %s\n", mpv_error_string(status));
         exit(2);
     }
 }
 
-int main(int argc, char **argv) {
+struct Args {
     long wid_num = 0;
+    long ipc_fd_num = 0;
+
     const char *wid = nullptr;
+    const char *ipc_fd = nullptr;
     const char *file_to_play = nullptr;
 
+    bool no_config = false;
+};
+
+static Args parse_args(int argc, char **argv) {
+    Args args;
+
     for(int i = 1; i < argc; ++i) {
         const char *arg = argv[i];
         if(strcmp(arg, "--wid") == 0) {
-            if(wid) {
+            if(args.wid) {
                 fprintf(stderr, "Error: option --wid was specified multiple times\n");
                 usage();
             }
@@ -47,8 +255,23 @@ int main(int argc, char **argv) {
                 usage();
             }
 
-            wid = argv[i + 1];
+            args.wid = argv[i + 1];
+            ++i;
+        } else if(strcmp(arg, "--ipc-fd") == 0) {
+            if(args.ipc_fd) {
+                fprintf(stderr, "Error: option --ipc-fd was specified multiple times\n");
+                usage();
+            }
+
+            if(i + 1 == argc) {
+                fprintf(stderr, "Error: missing fd after option --ipc-fd\n");
+                usage();
+            }
+
+            args.ipc_fd = argv[i + 1];
             ++i;
+        } else if(strcmp(arg, "--no-config") == 0) {
+            args.no_config = true;
         } else if(strcmp(arg, "--") == 0) {
             if(i + 1 == argc) {
                 fprintf(stderr, "Error: missing file option after --\n");
@@ -58,63 +281,120 @@ int main(int argc, char **argv) {
                 usage();
             }
 
-            file_to_play = argv[i + 1];
+            args.file_to_play = argv[i + 1];
             ++i;
         } else if(strncmp(arg, "--", 2) == 0) {
             fprintf(stderr, "Error: invalid option %s\n", arg);
             usage();
         } else {
-            if(file_to_play) {
+            if(args.file_to_play) {
                 fprintf(stderr, "Error: file option was specified multiple times\n");
                 usage();
             }
 
-            file_to_play = arg;
+            args.file_to_play = arg;
         }
     }
 
-    if(!file_to_play) {
+    if(!args.file_to_play) {
         fprintf(stderr, "Error: missing file option\n");
         usage();
     }
 
-    if(wid) {
-        if(!string_to_long(wid, wid_num)) {
-            fprintf(stderr, "Error: invalid number %s was specified for option --wid\n", wid);
+    if(args.wid) {
+        if(!string_to_long(args.wid, args.wid_num)) {
+            fprintf(stderr, "Error: invalid number %s was specified for option --wid\n", args.wid);
             usage();
         }
     }
 
-    mpv_handle *ctx = mpv_create();
-    if (!ctx) {
-        printf("failed creating context\n");
+    if(args.ipc_fd) {
+        if(!string_to_long(args.ipc_fd, args.ipc_fd_num)) {
+            fprintf(stderr, "Error: invalid number %s was specified for option --ipc-fd\n", args.ipc_fd);
+            usage();
+        }
+
+        if(!fd_is_valid(args.ipc_fd_num)) {
+            fprintf(stderr, "Error: invalid fd %s was specified for option --ipc-fd\n", args.ipc_fd);
+            usage();
+        }
+    }
+
+    return args;
+}
+
+int main(int argc, char **argv) {
+    // This is needed for mpv_create or it will fail
+    setlocale(LC_ALL, "C");
+
+    Args args = parse_args(argc, argv);
+
+    mpv_handle *mpv_ctx = mpv_create();
+    if (!mpv_ctx) {
+        fprintf(stderr, "Error: failed to create mpv context\n");
         return 1;
     }
 
-    check_error(mpv_set_option_string(ctx, "input-default-bindings", "yes"));
-    check_error(mpv_set_option_string(ctx, "input-vo-keyboard", "yes"));
-    check_error(mpv_set_option_string(ctx, "osc", "yes"));
+    check_error(mpv_set_option_string(mpv_ctx, "input-default-bindings", "yes"));
+    check_error(mpv_set_option_string(mpv_ctx, "input-vo-keyboard", "yes"));
+    check_error(mpv_set_option_string(mpv_ctx, "osc", "yes"));
     
-    check_error(mpv_set_option_string(ctx, "profile", "gpu-hq"));
-    check_error(mpv_set_option_string(ctx, "vo", "gpu"));
-    check_error(mpv_set_option_string(ctx, "hwdec", "auto"));
-    check_error(mpv_set_option_string(ctx, "config", "yes"));
+    check_error(mpv_set_option_string(mpv_ctx, "profile", "gpu-hq"));
+    check_error(mpv_set_option_string(mpv_ctx, "vo", "gpu"));
+    check_error(mpv_set_option_string(mpv_ctx, "hwdec", "auto"));
+    if(!args.no_config)
+        check_error(mpv_set_option_string(mpv_ctx, "config", "yes"));
+
+    if(args.wid)
+        check_error(mpv_set_option_string(mpv_ctx, "wid", args.wid));
 
-    if(wid)
-        check_error(mpv_set_option_string(ctx, "wid", wid));
+    check_error(mpv_initialize(mpv_ctx));
 
-    check_error(mpv_initialize(ctx));
+    const char *cmd[] = { "loadfile", args.file_to_play, NULL };
+    check_error(mpv_command(mpv_ctx, cmd));
 
-    const char *cmd[] = { "loadfile", file_to_play, NULL };
-    check_error(mpv_command(ctx, cmd));
+    char command_buffer[COMMAND_BUFFER_MAX_SIZE];
+    size_t command_buffer_size = 0;
+    std::mutex command_mutex;
+    bool ipc_disconnected = false;
 
-    while (true) {
-        mpv_event *event = mpv_wait_event(ctx, 10000);
-        printf("event: %s\n", mpv_event_name(event->event_id));
-        if (event->event_id == MPV_EVENT_SHUTDOWN)
+    bool running = true;
+    // TODO: Clean cleanup instead of terminating... To make that possible we need to find a way to wake up the read call that is waiting for data
+    if(args.ipc_fd) {
+        std::thread([&]() mutable {
+            while(running) {
+                command_buffer_size = ipc_handler(mpv_ctx, args.ipc_fd_num, command_buffer, COMMAND_BUFFER_MAX_SIZE, ipc_disconnected);
+                std::lock_guard<std::mutex> lock(command_mutex); // Wait until the command has been handled in the main loop in the main thread
+            }
+        }).detach();
+    }
+
+    Json::Value json_root;
+    std::string json_errors;
+
+    while (running) {
+        mpv_event *event = mpv_wait_event(mpv_ctx, -1.0);
+        if (event->event_id == MPV_EVENT_SHUTDOWN) {
+            running = false;
             break;
+        }
+
+        if(event->event_id != MPV_EVENT_NONE)
+            send_event(mpv_event_name(event->event_id), args.ipc_fd_num);
+
+        // TODO: Check if we can get here without mpv_wakeup being called from ipc_handler
+        std::lock_guard<std::mutex> lock(command_mutex);
+
+        // Other end of the ipc socket has disconnected
+        if(ipc_disconnected) {
+            fprintf(stderr, "Warning: the other end of the ipc fd was closed, closing the video player...\n");
+            running = false;
+            break;
+        }
+
+        handle_request_commands_line_by_line(mpv_ctx, args.ipc_fd_num, command_buffer, command_buffer_size, json_root, json_errors);
     }
 
-    mpv_terminate_destroy(ctx);
+    mpv_terminate_destroy(mpv_ctx);
     return 0;
 }