X-Git-Url: https://develop.uap-core.de/gitweb/uwplayer.git/blobdiff_plain/38abddf60d71d5efbac50802127d2103ec196686..92835e632a2570c851ecd45af5c3b97af2037322:/application/player.c

diff --git a/application/player.c b/application/player.c
index 8e03fbc..2d63135 100644
--- a/application/player.c
+++ b/application/player.c
@@ -21,6 +21,7 @@
  */
 
 #include "player.h"
+#include "main.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -29,15 +30,36 @@
 #include <spawn.h>
 #include <sys/wait.h>
 #include <signal.h>
-
+#include <poll.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/un.h>
 #include <pthread.h>
 
+#include "json.h"
+#include "utils.h"
+#include "settings.h"
+#include "playlist.h"
+
 extern char **environ;
 
+#define STR_BUFSIZE 512
 #define WID_ARG_BUFSIZE 24
 
+#define PLAYER_POLL_TIMEOUT 500
+#define PLAYER_IN_BUFSIZE   8192
+
+static void json_print(JSONValue *value, char *name, int indent);
+
 static void* start_player(void *data);
-static void* player_io_thread(void *data);
+
+static void player_io(Player *p);
+
+static void handle_json_rpc_msg(Player *player, JSONValue *v);
+static void handle_json_rpc_reqid(Player *player, JSONValue *v, int reqid);
+static void handle_json_rpc_event(Player *player, JSONValue *v, JSONValue *event);
 
 void PlayerOpenFile(MainWindow *win) {
     pthread_t tid;
@@ -46,87 +68,540 @@ void PlayerOpenFile(MainWindow *win) {
     }
 }
 
-static void* start_player(void *data) {
-    MainWindow *win = data;
+static int prepare_player(Player *player, char *log_arg, char *ipc_arg) {
+    // create tmp directory for IPC
+    char *player_tmp = NULL;
+    char buf[STR_BUFSIZE];
+    snprintf(buf, STR_BUFSIZE, "/tmp/uwplayer-%x", rand());
+    int mkdir_success = 0;
+    for(int t=0;t<5;t++) {
+        if(!mkdir(buf, S_IRWXU)) {
+            mkdir_success = 1;
+            break;
+        } else if(errno != EEXIST) {
+            break;
+        }
+    }
+    if(!mkdir_success) return 1;
+    player_tmp = strdup(buf);
+    player->tmp = player_tmp;
+    
+    // prepare log/ipc args and create log fifo
+    int err = 0;
+    
+    if(snprintf(log_arg, STR_BUFSIZE, "--log-file=%s/%s", player_tmp, "log.fifo") >= STR_BUFSIZE) {
+        err = 1;
+    }
+    if(snprintf(ipc_arg, STR_BUFSIZE, "--input-ipc-server=%s/%s", player_tmp, "ipc.socket") >= STR_BUFSIZE) {
+        err = 1;
+    }
+    
+    snprintf(buf, STR_BUFSIZE, "%s/log.fifo", player_tmp);
+    if(err || mkfifo(buf, S_IRUSR|S_IWUSR)) {
+        rmdir(player_tmp);
+        return 1;
+    }
+    
+    return 0;
+}
+
+static void* wait_for_process(void *data) {
+    Player *player = data;
+    int status = 0;
+    waitpid(player->process, &status, 0);
+    
+    printf("waitpid: %d\n", status);
+
+    player->isactive = FALSE;
+    player->status = status;
+    SetPlayerWindow(0);
+    
+    return NULL;
+}
+
+static int start_player_process(Player *player, MainWindow *win) {
+    char log_arg[STR_BUFSIZE];
+    char ipc_arg[STR_BUFSIZE];
+    
+    if(prepare_player(player, log_arg, ipc_arg)) {
+        return 1;
+    }
     
-    char *player_bin = "/usr/local/bin/mpv"; // TODO: get bin from settings
+    char *player_bin = SettingsGetPlayerBin();
+    if(!player_bin) {
+        fprintf(stderr, "No mpv binary available\n");
+        return 1;
+    }
     
     // -wid parameter value for embedding the player in the player_widget
     Window wid = XtWindow(win->player_widget);
     char wid_arg[WID_ARG_BUFSIZE];
     if(snprintf(wid_arg, WID_ARG_BUFSIZE, "%lu", wid) >= WID_ARG_BUFSIZE) {
-        return NULL;
+        return 1;
     }
     
     // create player arg list
     char *args[32];
-    args[0] = player_bin;
-    args[1] = "-wid";
-    args[2] = wid_arg;
-    args[3] = win->file;
-    args[4] = NULL;
-    
-    // redirect stdin/stdout
-    int pout[2];
-    int pin[2];
-    if(pipe(pout)) {
-        perror("pipe");
-        return NULL;
-    }
-    if(pipe(pin)) {
-        perror("pipe");
-        return NULL;
-    }
+    int ac = 0;
+    args[ac++] = player_bin;
+    args[ac++] = "-wid";
+    args[ac++] = wid_arg;
+    //args[ac++] = "--no-terminal";
+    args[ac++] = "--player-operation-mode=pseudo-gui";
+    args[ac++] = log_arg;
+    args[ac++] = ipc_arg;
+    args[ac++] = win->file;
+    args[ac++] = NULL;
     
     posix_spawn_file_actions_t actions;
     posix_spawn_file_actions_init(&actions);
     
-    posix_spawn_file_actions_adddup2(&actions, pin[0], STDIN_FILENO);
-    posix_spawn_file_actions_adddup2(&actions, pout[1], STDOUT_FILENO);
+    //posix_spawn_file_actions_adddup2(&actions, pin[0], STDIN_FILENO);
+    //posix_spawn_file_actions_adddup2(&actions, pout[1], STDOUT_FILENO);
     
     // start player
     pid_t player_pid;
     if(posix_spawn(&player_pid, player_bin, &actions, NULL, args, environ)) {
         perror("posix_spawn");
-        return NULL;
+        return 1;
     }
     posix_spawn_file_actions_destroy(&actions);
     
+    player->process = player_pid;
+    player->isactive = TRUE;
+    
+    pthread_t tid;
+    if(pthread_create(&tid, NULL, wait_for_process, player)) {
+        perror("pthread_create");
+    }
+    
+    return 0;
+}
+
+static int wait_for_ipc(Player *player) {
+    char buf[STR_BUFSIZE];
+    snprintf(buf, STR_BUFSIZE, "%s/log.fifo", player->tmp); // cannot fail
+    
+    // open log
+    int fd_log = open(buf, O_RDONLY);
+    if(fd_log < 0) {
+        perror("Cannot open log");
+        return 1;
+    }
+    player->log = fd_log;
+    
+    // read log until IPC socket is created
+    char *scan_str = "Listening to IPC";
+    int scan_pos = 0;
+    int scan_len = strlen(scan_str);
+    int ipc_listen = 0;
+    ssize_t r;
+    while((r = read(fd_log, buf, STR_BUFSIZE)) > 0) {
+        for(int i=0;i<r;i++) {
+            char c = buf[i];
+            char *s_str = buf+i;
+            
+            if(scan_pos == scan_len) {
+                ipc_listen = 1;
+                break;
+            }
+            
+            if(scan_str[scan_pos] == c) {
+                scan_pos++;
+            } else {
+                scan_pos = 0;
+            }
+        }
+        if(ipc_listen) break;
+    }
+    
+    return 0;
+}
+
+static int connect_to_ipc(Player *player) {  
+    // connect to IPC socket
+    int fd_ipc = socket(AF_UNIX, SOCK_STREAM, 0);
+    if(fd_ipc < 0) {
+        perror("Cannot create IPC socket");
+        return 1;
+    }
+    player->ipc = fd_ipc;
+    
+    char buf[STR_BUFSIZE];
+    snprintf(buf, STR_BUFSIZE, "%s/%s", player->tmp, "ipc.socket"); // cannot fail
+    
+    struct sockaddr_un ipc_addr;
+    memset(&ipc_addr, 0, sizeof(struct sockaddr_un));
+    ipc_addr.sun_family = AF_UNIX;
+    memcpy(ipc_addr.sun_path, buf, strlen(buf));
+    if(connect(fd_ipc, (struct sockaddr *)&ipc_addr, sizeof(ipc_addr)) == -1) {
+        perror("Cannot connect to IPC socket");
+        return 1;
+    }
+    
+    return 0;
+}
+
+static Boolean update_player_window(XtPointer data) {
+    MainWindow *win = data;
+    WindowUpdate(win);
+    return 0;
+}
+
+static void* start_player(void *data) {
+    MainWindow *win = data;
+    
     Player *player = malloc(sizeof(Player));
     memset(player, 0, sizeof(Player));
     
-    player->in = pin[1];
-    player->out = pout[0];
-    close(pin[0]);
-    close(pout[1]);
-    player->process = player_pid;
-    player->isactive = TRUE;
+    // start mpv
+    if(start_player_process(player, win)) {
+        PlayerDestroy(player);
+        return NULL;
+    } 
     
+    // wait until IPC socket is ready
+    if(wait_for_ipc(player)) {
+        PlayerDestroy(player);
+        return NULL;
+    }
+    //close(player->log);
+     
+    if(connect_to_ipc(player)) {
+        PlayerDestroy(player);
+        return NULL;
+    }
+    
+    // set player in main window
     if(win->player) {
         PlayerDestroy(win->player);
     }
     win->player = player;
     
-    // start thread for mplayer IO
-    pthread_t tid;
-    if(pthread_create(&tid, NULL, player_io_thread, player)) {
-        perror("pthread_create");
-    }
+    // update main window
+    AppExecProc(update_player_window, win);
+    
+    // IO
+    player_io(player);
     
     return NULL;
 }
 
+static void player_io(Player *p) {
+    struct pollfd fds[2];
+    fds[0].fd = p->ipc;
+    fds[0].events = POLLIN;
+    fds[0].revents = 0;
+    fds[1].fd = p->log;
+    fds[1].events = POLLIN;
+    fds[1].revents = 0;
+    JSONParser *js = json_parser_new();
+     
+    char buf[PLAYER_IN_BUFSIZE];
+    while(p->isactive && (poll(fds, 2, PLAYER_POLL_TIMEOUT) >= 0)) {
+        if(fds[0].revents == POLLIN) {
+            ssize_t r;
+            if((r = read(fds[0].fd, buf, PLAYER_IN_BUFSIZE)) <= 0) {
+                break;
+            }
+            //fwrite(buf, 1, r, stdout);
+            fflush(stdout);
+            json_parser_fill(js, buf, r);
+            
+            JSONValue *value;
+            int ret;
+            while((ret = json_read_value(js, &value)) == 1) {
+                handle_json_rpc_msg(p, value);
+                json_value_free(value);
+            }
+            
+            if(ret == -1) {
+                fprintf(stderr, "JSON-RPC error\n");
+                break;
+            }
+        }
+        if(fds[1].revents == POLLIN) {
+            // just read to clean the log pipe
+            read(fds[1].fd, buf, PLAYER_IN_BUFSIZE);
+        }
+        
+        //char *cmd = "{ \"command\": [\"get_property\", \"playback-time\"], request_id=\"" REQ_ID_PLAYBACK_TIME "\" }\n";
+        //write(p->ipc, cmd, strlen(cmd));
+    }
+    
+    
+    printf("PlayerEnd: %s\n", strerror(errno));
+    fflush(stdout);
+}
+
+
+static void handle_json_rpc_msg(Player *player, JSONValue *v) {
+    if(v->type != JSON_OBJECT) return;
+      
+    JSONValue *request_id_v = json_obj_get(&v->value.object, "request_id");
+    JSONValue *event = NULL;
+    if(request_id_v && request_id_v->type == JSON_STRING) {
+        int request_id = 0;
+        if(request_id_v->value.string.length == 2) {
+            request_id = 10 * (request_id_v->value.string.string[0] - '0') + (request_id_v->value.string.string[1] - '0');
+            handle_json_rpc_reqid(player, v, request_id);
+            return;
+        }
+    } else if ((event = json_obj_get(&v->value.object, "event")) != NULL) {
+        handle_json_rpc_event(player, v, event);
+    }
+    
+    //json_print(v, NULL, 0);
+}
+
+static Boolean player_widget_set_size(XtPointer data) {
+    Player *player = data;
+    MainWindow *win = GetMainWindow();
+    
+    if(!win->adjustWindowSize) {
+        return 0;
+    }
+        
+    Dimension win_width, win_height;
+    XtVaGetValues(win->window, XmNwidth, &win_width, XmNheight, &win_height, NULL);
+    Dimension player_width, player_height;
+    XtVaGetValues(win->player_widget, XmNwidth, &player_width, XmNheight, &player_height, NULL);
+
+    Dimension new_width = player->width + win_width - player_width;
+    Dimension new_height = player->height + win_height - player_height;
+    
+    // set window size
+    XtVaSetValues(win->window, XmNwidth, new_width, XmNheight, new_height, NULL);
+    
+    // set window aspect ratio
+    XSizeHints hints;
+    hints.flags = PAspect;
+    hints.min_aspect.x = new_width;
+    hints.min_aspect.y = new_height;
+    hints.max_aspect.x = new_width;
+    hints.max_aspect.y = new_height;
+    XSetWMNormalHints(XtDisplay(win->window), XtWindow(win->window), &hints);
+    
+    return 0;
+}
+
+
+
+static void player_set_size(Player *player, int width, int height) {
+    if(width >= 0) {
+        player->width = width;
+    }
+    if(height >= 0) {
+        player->height = height;
+    }
+    if(player->width > 0 && player->height > 0) {
+        AppExecProc(player_widget_set_size, player);
+    }
+}
+
+static void handle_json_rpc_reqid(Player *player, JSONValue *v, int reqid) {
+    JSONValue *data = json_obj_get(&v->value.object, "data");
+    if(!data) return;
+    
+    switch(reqid) {
+        case REQ_ID_PLAYBACK_TIME_INT: {
+            if(data->type == JSON_NUMBER) {
+                player->playback_time = data->value.number.value;
+            }
+            break;
+        }
+        case REQ_ID_WIDTH_INT: {
+            if(data->type == JSON_INTEGER) {
+                player_set_size(player, data->value.integer.value, -1);
+            }
+            break;
+        }
+        case REQ_ID_HEIGHT_INT: {
+            if(data->type == JSON_INTEGER) {
+                player_set_size(player, -1, data->value.integer.value);
+            }
+            break;
+        }
+    }
+}
+
+static Boolean get_player_window(XtPointer data) {
+    Player *p = data;
+    MainWindow *win = GetMainWindow();
+    
+    Widget player_wid = win->player_widget;
+    Window root, parent;
+    Window *child;
+    unsigned int nchild;
+    XQueryTree(XtDisplay(player_wid), XtWindow(player_wid), &root, &parent, &child, &nchild);
+    if(nchild > 0) {
+        p->window = child[0];
+        XFree(child);
+        
+        SetPlayerWindow(p->window);
+        XSelectInput(XtDisplay(win->player_widget), p->window, PointerMotionMask);
+    }
+    
+    return 0;
+}
+
+#define CURSOR_AUTOHIDE_THRESHOLD_SEC  4
+
+static Boolean hide_cursor(XtPointer data) {
+    MainWindow *win = data;
+    WindowHidePlayerCursor(win);
+    return 0;
+}
+
+static void check_hide_cursor(Player *p) {
+    MainWindow *win = GetMainWindow();
+    if(win->cursorhidden) return;
+    
+    if(p->playback_time - win->motion_playback_time > CURSOR_AUTOHIDE_THRESHOLD_SEC) {
+        AppExecProc(hide_cursor, win);
+    }
+}
+
+static void handle_json_rpc_event(Player *p, JSONValue *v, JSONValue *event) {
+    if(!json_strcmp(event, "property-change")) {
+        JSONValue *name = json_obj_get(&v->value.object, "name");
+        JSONValue *data = json_obj_get(&v->value.object, "data");
+        if(!json_strcmp(name, "playback-time")) {
+            if(data && data->type == JSON_NUMBER) {
+                p->playback_time = data->value.number.value;
+                //printf("playback-time: %f\n", p->playback_time);
+                check_hide_cursor(p);
+            }
+        } else if(!json_strcmp(name, "eof-reached")) {
+            if(data && data->type == JSON_LITERAL && data->value.literal.literal == JSON_TRUE) {
+                PlayerEOF(p);
+            }
+        } else if(!json_strcmp(name, "osd-height")) {
+            if(data->type == JSON_NUMBER) {
+                p->osd_height = data->value.number.value;
+            }
+        }
+    } else if(!p->isstarted && !json_strcmp(event, "playback-restart")) {
+        char *cmd = "{ \"command\": [\"observe_property\", 1, \"playback-time\"] }\n"
+                    "{ \"command\": [\"observe_property\", 1, \"eof-reached\"] }\n"
+                    "{ \"command\": [\"observe_property\", 1, \"osd-height\"] }\n"
+                    "{ \"command\": [\"get_property\", \"width\"], request_id=\"" REQ_ID_WIDTH "\" }\n"
+                    "{ \"command\": [\"get_property\", \"height\"], request_id=\"" REQ_ID_HEIGHT "\" }\n"
+                    "{ \"command\": [\"set_property\", \"keep-open\", true] }\n";
+        write(p->ipc, cmd, strlen(cmd));
+        p->isstarted = TRUE;
+        
+        AppExecProc(get_player_window, p);
+    }
+}
+
 void PlayerDestroy(Player *p) {
+    if(p->log >= 0) {
+        close(p->log);
+    }
+    if(p->ipc >= 0) {
+        close(p->ipc);
+    }
+    
+    if(p->tmp) {
+        free(p->tmp);
+    }
+    
     if(p->isactive) {
-        close(p->in);
-        close(p->out);
         kill(p->process, SIGTERM);
     }
+    
+    SetPlayerWindow(0);
     free(p);
 }
 
-static void* player_io_thread(void *data) {
-    Player *player = data;
+
+static void json_print(JSONValue *value, char *name, int indent) {
+    if(name) {
+        printf("%*s%s: ", indent*4, "", name);
+    } else {
+        printf("%*s", indent*4, "");
+    }
+    
+    
+    switch(value->type) {
+        case JSON_OBJECT: {
+            printf("{\n");
+            
+            for(int i=0;i<value->value.object.size;i++) {
+                JSONObjValue val = value->value.object.values[i];
+                json_print(val.value, val.name, indent+1);
+                if(i+1 < value->value.object.size) {
+                    printf(",\n");
+                } else {
+                    printf("\n");
+                }
+            }
+            
+            printf("%*s}", indent*4, "");
+            break;
+        }
+        case JSON_ARRAY: {
+            printf("[\n");
+            
+            for(int i=0;i<value->value.object.size;i++) {
+                JSONValue *v = value->value.array.array[i];
+                json_print(v, NULL, indent+1);
+                if(i+1 < value->value.array.size) {
+                    printf(",\n");
+                } else {
+                    printf("\n");
+                }
+            }
+            
+            printf("%*s]", indent*4, "");
+            break;
+        }
+        case JSON_STRING: {
+            printf("\"%s\"", value->value.string.string);
+            break;
+        }
+        case JSON_INTEGER: {
+            printf("%i", (int)value->value.integer.value);
+            break;
+        }
+        case JSON_NUMBER: {
+            printf("%f", value->value.number.value);
+            break;
+        }
+        case JSON_LITERAL: {
+            char *lit = "NULL";
+            switch(value->value.literal.literal) {
+                case JSON_NULL: break;
+                case JSON_TRUE: lit = "true"; break;
+                case JSON_FALSE: lit = "false"; break;
+            }
+            printf("%s\n", lit);
+            break;
+        }
+    }
+    
+    if(indent == 0) {
+        putchar('\n');
+    }
+}
+
+static Boolean play_next(XtPointer data) {
+    MainWindow *win = GetMainWindow();
+    PlayListPlayNext(win, false);    
+    return 0;
+}
+
+void PlayerEOF(Player *p) {
+    MainWindow *win = GetMainWindow();
+    if(win->playlist.repeatTrack) {
+        char *cmd = "{ \"command\": [\"set_property\", \"playback-time\", 0] }\n";
+        write(p->ipc, cmd, strlen(cmd));
+    } else {
+        AppExecProc(play_next, NULL);
+    }
+}
+
+void PlayerHandleInput(MainWindow *win, Player *p, XmDrawingAreaCallbackStruct *cb) {
     
-    return NULL;
 }