rx

rx.c (6956B)

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <dlfcn.h>
 #include <math.h>
 #include <mpv/client.h>
 #define LIB_TERM_IMPL
 #include <libterm.h>
 #define LIB_STR_IMPL
 #include <libstr.h>
 
 #include "../include/rx.h"
 #define INI_IMPL
 #include "../include/ini.h"
 
 static int rx_ini_load(void *user, const char *section, const char *name, const char *value) {
   rx_t *self = (rx_t *) user;
   if (strcmp(section, "stations") == 0) {
     if (strcmp(name, "uid") == 0) {
       self->stations = realloc(self->stations, sizeof(rx_station_t) * (self->stations_len + 1));
       self->stations[self->stations_len] = (rx_station_t) {
         .addr = NULL,
         .url = NULL,
         .resolver = NULL,
       };
       self->stations_len++;
     }
     rx_station_t *station = &self->stations[self->stations_len - 1];
     if (strcmp(name, "uid") == 0) {
       size_t len = strlen(value);
       memcpy(station->uid, value, len);
       station->uid[len] = '\0';
     }
     if (strcmp(name, "name") == 0) {
       size_t len = strlen(value);
       memcpy(station->name, value, len);
       station->name[len] = '\0';
     }
     if (strcmp(name, "addr") == 0) {
       size_t len = strlen(value);
       station->addr = malloc(sizeof(char) * (len + 1));
       memcpy(station->addr, value, len);
       station->addr[len] = '\0';
     }
     if (strcmp(name, "url") == 0) {
       size_t len = strlen(value);
       station->url = malloc(sizeof(char) * (len + 1));
       memcpy(station->url, value, len);
       station->url[len] = '\0';
     }
     if (strcmp(name, "resolver") == 0) {
       size_t len = strlen(value);
       station->resolver = malloc(sizeof(char) * (len + 1));
       memcpy(station->resolver, value, len);
       station->resolver[len] = '\0';
     }
   }
   return 1;
 }
 
 void rx_init(rx_t *self) {
   self->stations = NULL;
   self->stations_len = 0;
   char *config_path = NULL;
   char *home_path = getenv("HOME");
   if (home_path != NULL) {
     str_appendf(&config_path, "%s/.config/rx/", home_path);
   }
   str_append(&config_path, "rx.ini");
   ini_parse(config_path, rx_ini_load, self);
   free(config_path);
   self->curr = NULL;
   self->ctx = mpv_create();
   mpv_initialize(self->ctx);
   self->idx = 0;
   self->count = 0;
   self->title = NULL;
   self->loading = 0;
   self->error = 0;
   term_enable_raw_mode();
   term_write("\x1b[?25l");
 }
 
 void rx_update(rx_t *self) {
   int key = term_poll_key(100);
   switch (key) {
     case 'q': {
       self->quit = true;
       break;
     }
     case 'j': {
       if ((size_t) self->idx < self->stations_len - 1) {
         self->idx++;
       }
       break;
     }
     case 'k': {
       if (self->idx > 0) {
         self->idx--;
       }
       break;
     }
     case KEY_ENTER: {
       const rx_station_t *station = &self->stations[self->idx];
       char *resolver = station->resolver;
       char *url = NULL;
       if (resolver != NULL) {
         char *resolver_path = NULL;
         char *home_path = getenv("HOME");
         if (home_path != NULL) {
           str_appendf(&resolver_path, "%s/.config/rx/mods/", home_path);
         }
         str_append(&resolver_path, resolver);
         void *handle = dlopen(resolver_path, RTLD_LAZY);
         free(resolver_path);
         if (handle == NULL) {
           fprintf(stderr, "%s\n", dlerror());
           break;
         }
         char *(*resolve_fn)(void) = (char *(*)(void)) dlsym(handle, "rx_resolve");
         const char *err = dlerror();
         if (err != 0) {
           fprintf(stderr, "%s\n", err);
           break;
         }
         url = resolve_fn();
         dlclose(handle);
       }
       else {
         size_t len = strlen(station->url);
         url = malloc(sizeof(char) * (len + 1));
         memcpy(url, station->url, len);
         url[len] = '\0';
       }
       if (url != NULL) {
         const char *cmd[] = { "loadfile", url, NULL };
         mpv_command(self->ctx, cmd);
         free(url);
       }
       self->curr = station;
       self->title = NULL;
       self->loading = 1;
       self->error = 0;
       break;
     }
     case KEY_BACKSPACE: {
       const char *cmd[] = { "stop", NULL };
       mpv_command(self->ctx, cmd);
       self->curr = NULL;
       self->loading = 0;
       self->error = 0;
       break;
     }
     default:
       break;
   }
   if (self->count == RX_UPDATE_COUNT) {
     if (self->title != NULL) {
       mpv_free(self->title);
       self->title = NULL;
     }
     self->title = mpv_get_property_string(self->ctx, "metadata/icy-title");
     self->count = 0;
   }
   self->count++;
   mpv_get_property(self->ctx, "core-idle", MPV_FORMAT_FLAG, &self->loading);
   mpv_event *event = mpv_wait_event(self->ctx, 0);
   if (event->event_id == MPV_EVENT_END_FILE) {
     mpv_event_end_file *end_file = (mpv_event_end_file *) event->data;
     if (end_file->reason == MPV_END_FILE_REASON_ERROR) {
       self->error = 1;
       const char* err = mpv_error_string(end_file->error);
       size_t len = strlen(err);
       memcpy(self->message, err, len);
       self->message[len] = '\0';
     }
   }
 }
 
 void rx_draw(rx_t *self) {
   term_write("\x1b[2J");
   term_write("\x1b[H");
   term_write("\r\n");
   int rows = 0;
   int cols = 0;
   term_read_window_size(&rows, &cols);
   size_t len = rows - 5;
   for (size_t i = 0; i < len; i++) {
     if (i + self->idx >= self->stations_len) {
       term_write("\r\n");
       continue;
     }
     const rx_station_t *station = &self->stations[i + self->idx];
     if (i + self->idx == (size_t) self->idx) {
       term_write("> ");
     }
     else {
       term_write("  ");
     }
     int pad = 3; // floor(log10(self->stations_len) + 1);
     term_writef("%0*d ", pad, i + self->idx + 1);
     term_writef("[%s] %s", station->uid, station->name);
     if (station->addr != NULL) {
       term_writef(" (%s)", station->addr);
     }
     term_write("\r\n");
   }
   term_write("\r\n");
   const rx_station_t *station = self->curr;
   if (station != NULL) {
     term_writef("[%s] %s\r\n", station->uid, station->name);
     if (self->error) {
       term_writef("error: %s\r\n", self->message);
     }
     else {
       if (self->loading) {
         term_write("loading...\r\n");
       }
       else {
         if (self->title != NULL && strlen(self->title) > 0) {
           term_writef("title: %s\r\n", self->title);
         }
         else {
           term_write("title: ???\r\n");
         }
       }
     }
   }
   else {
     term_write("[???] no station\r\n");
     term_write("...\r\n");
   }
   term_flush();
 }
 
 void rx_free(rx_t *self) {
   mpv_terminate_destroy(self->ctx);
   term_write("\x1b[2J");
   term_write("\x1b[H");
   term_write("\x1b[?25h");
   term_flush();
   term_disable_raw_mode();
   for (size_t i = 0; i < self->stations_len; i++) {
     rx_station_t *station = &self->stations[i];
     if (station->addr != NULL) {
       free(station->addr);
     }
     if (station->url != NULL) {
       free(station->url);
     }
     if (station->resolver != NULL) {
       free(station->resolver);
     }
   }
   free(self->stations);
   self->stations_len = 0;
 }