commit 772ecb60cf54c48e5bc8fb815afbb9ddbb19b408
Author: Sophie <info@soophie.de>
Date: Mon, 13 Jan 2025 22:16:50 +0100
Initial commit
Diffstat:
| A | Makefile | | | 21 | +++++++++++++++++++++ |
| A | README.md | | | 3 | +++ |
| A | include/ini.h | | | 479 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | include/rx.h | | | 34 | ++++++++++++++++++++++++++++++++++ |
| A | mods/byb.c | | | 50 | ++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | rx.ini | | | 143 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | src/main.c | | | 38 | ++++++++++++++++++++++++++++++++++++++ |
| A | src/rx.c | | | 245 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
8 files changed, 1013 insertions(+), 0 deletions(-)
diff --git a/Makefile b/Makefile
@@ -0,0 +1,21 @@
+CC=cc
+CFLAGS=-Werror -Wall -Wextra -pedantic
+MODFLAGS=-shared -fPIC
+LIBS=-lraylib -lmpv
+DEBUG=-g -rdynamic
+
+build: src/*.c
+ mkdir -p ./build
+ $(CC) -o ./build/rx $(CFLAGS) $(LIBS) $(DEBUG) $^
+
+build-byb: mods/byb.c
+ $(CC) -o ./build/byb.so $(CFLAGS) $(MODFLAGS) $(DEBUG) -lcurl $^
+
+install: build
+ cp build/rx ~/.local/bin/rx
+
+run: build
+ ./build/rx
+
+clean:
+ rm -rf ./build
diff --git a/README.md b/README.md
@@ -0,0 +1,3 @@
+# rx
+
+A terminal-based radio player
diff --git a/include/ini.h b/include/ini.h
@@ -0,0 +1,479 @@
+/* inih -- simple .INI file parser
+
+SPDX-License-Identifier: BSD-3-Clause
+
+Copyright (C) 2009-2020, Ben Hoyt
+
+inih is released under the New BSD license (see LICENSE.txt). Go to the project
+home page for more info:
+
+https://github.com/benhoyt/inih
+
+*/
+
+#ifndef INI_H
+#define INI_H
+
+/* Make this header file easier to include in C++ code */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+
+/* Nonzero if ini_handler callback should accept lineno parameter. */
+#ifndef INI_HANDLER_LINENO
+#define INI_HANDLER_LINENO 0
+#endif
+
+/* Visibility symbols, required for Windows DLLs */
+#ifndef INI_API
+#if defined _WIN32 || defined __CYGWIN__
+# ifdef INI_SHARED_LIB
+# ifdef INI_SHARED_LIB_BUILDING
+# define INI_API __declspec(dllexport)
+# else
+# define INI_API __declspec(dllimport)
+# endif
+# else
+# define INI_API
+# endif
+#else
+# if defined(__GNUC__) && __GNUC__ >= 4
+# define INI_API __attribute__ ((visibility ("default")))
+# else
+# define INI_API
+# endif
+#endif
+#endif
+
+/* Typedef for prototype of handler function. */
+#if INI_HANDLER_LINENO
+typedef int (*ini_handler)(void* user, const char* section,
+ const char* name, const char* value,
+ int lineno);
+#else
+typedef int (*ini_handler)(void* user, const char* section,
+ const char* name, const char* value);
+#endif
+
+/* Typedef for prototype of fgets-style reader function. */
+typedef char* (*ini_reader)(char* str, int num, void* stream);
+
+/* Parse given INI-style file. May have [section]s, name=value pairs
+ (whitespace stripped), and comments starting with ';' (semicolon). Section
+ is "" if name=value pair parsed before any section heading. name:value
+ pairs are also supported as a concession to Python's configparser.
+
+ For each name=value pair parsed, call handler function with given user
+ pointer as well as section, name, and value (data only valid for duration
+ of handler call). Handler should return nonzero on success, zero on error.
+
+ Returns 0 on success, line number of first error on parse error (doesn't
+ stop on first error), -1 on file open error, or -2 on memory allocation
+ error (only when INI_USE_STACK is zero).
+*/
+INI_API int ini_parse(const char* filename, ini_handler handler, void* user);
+
+/* Same as ini_parse(), but takes a FILE* instead of filename. This doesn't
+ close the file when it's finished -- the caller must do that. */
+INI_API int ini_parse_file(FILE* file, ini_handler handler, void* user);
+
+/* Same as ini_parse(), but takes an ini_reader function pointer instead of
+ filename. Used for implementing custom or string-based I/O (see also
+ ini_parse_string). */
+INI_API int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
+ void* user);
+
+/* Same as ini_parse(), but takes a zero-terminated string with the INI data
+instead of a file. Useful for parsing INI data from a network socket or
+already in memory. */
+INI_API int ini_parse_string(const char* string, ini_handler handler, void* user);
+
+/* Nonzero to allow multi-line value parsing, in the style of Python's
+ configparser. If allowed, ini_parse() will call the handler with the same
+ name for each subsequent line parsed. */
+#ifndef INI_ALLOW_MULTILINE
+#define INI_ALLOW_MULTILINE 1
+#endif
+
+/* Nonzero to allow a UTF-8 BOM sequence (0xEF 0xBB 0xBF) at the start of
+ the file. See https://github.com/benhoyt/inih/issues/21 */
+#ifndef INI_ALLOW_BOM
+#define INI_ALLOW_BOM 1
+#endif
+
+/* Chars that begin a start-of-line comment. Per Python configparser, allow
+ both ; and # comments at the start of a line by default. */
+#ifndef INI_START_COMMENT_PREFIXES
+#define INI_START_COMMENT_PREFIXES ";#"
+#endif
+
+/* Nonzero to allow inline comments (with valid inline comment characters
+ specified by INI_INLINE_COMMENT_PREFIXES). Set to 0 to turn off and match
+ Python 3.2+ configparser behaviour. */
+#ifndef INI_ALLOW_INLINE_COMMENTS
+#define INI_ALLOW_INLINE_COMMENTS 1
+#endif
+#ifndef INI_INLINE_COMMENT_PREFIXES
+#define INI_INLINE_COMMENT_PREFIXES ";"
+#endif
+
+/* Nonzero to use stack for line buffer, zero to use heap (malloc/free). */
+#ifndef INI_USE_STACK
+#define INI_USE_STACK 1
+#endif
+
+/* Maximum line length for any line in INI file (stack or heap). Note that
+ this must be 3 more than the longest line (due to '\r', '\n', and '\0'). */
+#ifndef INI_MAX_LINE
+#define INI_MAX_LINE 200
+#endif
+
+/* Nonzero to allow heap line buffer to grow via realloc(), zero for a
+ fixed-size buffer of INI_MAX_LINE bytes. Only applies if INI_USE_STACK is
+ zero. */
+#ifndef INI_ALLOW_REALLOC
+#define INI_ALLOW_REALLOC 0
+#endif
+
+/* Initial size in bytes for heap line buffer. Only applies if INI_USE_STACK
+ is zero. */
+#ifndef INI_INITIAL_ALLOC
+#define INI_INITIAL_ALLOC 200
+#endif
+
+/* Stop parsing on first error (default is to keep parsing). */
+#ifndef INI_STOP_ON_FIRST_ERROR
+#define INI_STOP_ON_FIRST_ERROR 0
+#endif
+
+/* Nonzero to call the handler at the start of each new section (with
+ name and value NULL). Default is to only call the handler on
+ each name=value pair. */
+#ifndef INI_CALL_HANDLER_ON_NEW_SECTION
+#define INI_CALL_HANDLER_ON_NEW_SECTION 0
+#endif
+
+/* Nonzero to allow a name without a value (no '=' or ':' on the line) and
+ call the handler with value NULL in this case. Default is to treat
+ no-value lines as an error. */
+#ifndef INI_ALLOW_NO_VALUE
+#define INI_ALLOW_NO_VALUE 0
+#endif
+
+/* Nonzero to use custom ini_malloc, ini_free, and ini_realloc memory
+ allocation functions (INI_USE_STACK must also be 0). These functions must
+ have the same signatures as malloc/free/realloc and behave in a similar
+ way. ini_realloc is only needed if INI_ALLOW_REALLOC is set. */
+#ifndef INI_CUSTOM_ALLOCATOR
+#define INI_CUSTOM_ALLOCATOR 0
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef INI_IMPL
+
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "ini.h"
+
+#if !INI_USE_STACK
+#if INI_CUSTOM_ALLOCATOR
+#include <stddef.h>
+void* ini_malloc(size_t size);
+void ini_free(void* ptr);
+void* ini_realloc(void* ptr, size_t size);
+#else
+#include <stdlib.h>
+#define ini_malloc malloc
+#define ini_free free
+#define ini_realloc realloc
+#endif
+#endif
+
+#define MAX_SECTION 50
+#define MAX_NAME 50
+
+/* Used by ini_parse_string() to keep track of string parsing state. */
+typedef struct {
+ const char* ptr;
+ size_t num_left;
+} ini_parse_string_ctx;
+
+/* Strip whitespace chars off end of given string, in place. Return s. */
+static char* ini_rstrip(char* s)
+{
+ char* p = s + strlen(s);
+ while (p > s && isspace((unsigned char)(*--p)))
+ *p = '\0';
+ return s;
+}
+
+/* Return pointer to first non-whitespace char in given string. */
+static char* ini_lskip(const char* s)
+{
+ while (*s && isspace((unsigned char)(*s)))
+ s++;
+ return (char*)s;
+}
+
+/* Return pointer to first char (of chars) or inline comment in given string,
+ or pointer to NUL at end of string if neither found. Inline comment must
+ be prefixed by a whitespace character to register as a comment. */
+static char* ini_find_chars_or_comment(const char* s, const char* chars)
+{
+#if INI_ALLOW_INLINE_COMMENTS
+ int was_space = 0;
+ while (*s && (!chars || !strchr(chars, *s)) &&
+ !(was_space && strchr(INI_INLINE_COMMENT_PREFIXES, *s))) {
+ was_space = isspace((unsigned char)(*s));
+ s++;
+ }
+#else
+ while (*s && (!chars || !strchr(chars, *s))) {
+ s++;
+ }
+#endif
+ return (char*)s;
+}
+
+/* Similar to strncpy, but ensures dest (size bytes) is
+ NUL-terminated, and doesn't pad with NULs. */
+static char* ini_strncpy0(char* dest, const char* src, size_t size)
+{
+ /* Could use strncpy internally, but it causes gcc warnings (see issue #91) */
+ size_t i;
+ for (i = 0; i < size - 1 && src[i]; i++)
+ dest[i] = src[i];
+ dest[i] = '\0';
+ return dest;
+}
+
+/* See documentation in header file. */
+int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
+ void* user)
+{
+ /* Uses a fair bit of stack (use heap instead if you need to) */
+#if INI_USE_STACK
+ char line[INI_MAX_LINE];
+ size_t max_line = INI_MAX_LINE;
+#else
+ char* line;
+ size_t max_line = INI_INITIAL_ALLOC;
+#endif
+#if INI_ALLOW_REALLOC && !INI_USE_STACK
+ char* new_line;
+ size_t offset;
+#endif
+ char section[MAX_SECTION] = "";
+#if INI_ALLOW_MULTILINE
+ char prev_name[MAX_NAME] = "";
+#endif
+
+ char* start;
+ char* end;
+ char* name;
+ char* value;
+ int lineno = 0;
+ int error = 0;
+
+#if !INI_USE_STACK
+ line = (char*)ini_malloc(INI_INITIAL_ALLOC);
+ if (!line) {
+ return -2;
+ }
+#endif
+
+#if INI_HANDLER_LINENO
+#define HANDLER(u, s, n, v) handler(u, s, n, v, lineno)
+#else
+#define HANDLER(u, s, n, v) handler(u, s, n, v)
+#endif
+
+ /* Scan through stream line by line */
+ while (reader(line, (int)max_line, stream) != NULL) {
+#if INI_ALLOW_REALLOC && !INI_USE_STACK
+ offset = strlen(line);
+ while (offset == max_line - 1 && line[offset - 1] != '\n') {
+ max_line *= 2;
+ if (max_line > INI_MAX_LINE)
+ max_line = INI_MAX_LINE;
+ new_line = ini_realloc(line, max_line);
+ if (!new_line) {
+ ini_free(line);
+ return -2;
+ }
+ line = new_line;
+ if (reader(line + offset, (int)(max_line - offset), stream) == NULL)
+ break;
+ if (max_line >= INI_MAX_LINE)
+ break;
+ offset += strlen(line + offset);
+ }
+#endif
+
+ lineno++;
+
+ start = line;
+#if INI_ALLOW_BOM
+ if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
+ (unsigned char)start[1] == 0xBB &&
+ (unsigned char)start[2] == 0xBF) {
+ start += 3;
+ }
+#endif
+ start = ini_rstrip(ini_lskip(start));
+
+ if (strchr(INI_START_COMMENT_PREFIXES, *start)) {
+ /* Start-of-line comment */
+ }
+#if INI_ALLOW_MULTILINE
+ else if (*prev_name && *start && start > line) {
+#if INI_ALLOW_INLINE_COMMENTS
+ end = ini_find_chars_or_comment(start, NULL);
+ if (*end)
+ *end = '\0';
+ ini_rstrip(start);
+#endif
+ /* Non-blank line with leading whitespace, treat as continuation
+ of previous name's value (as per Python configparser). */
+ if (!HANDLER(user, section, prev_name, start) && !error)
+ error = lineno;
+ }
+#endif
+ else if (*start == '[') {
+ /* A "[section]" line */
+ end = ini_find_chars_or_comment(start + 1, "]");
+ if (*end == ']') {
+ *end = '\0';
+ ini_strncpy0(section, start + 1, sizeof(section));
+#if INI_ALLOW_MULTILINE
+ *prev_name = '\0';
+#endif
+#if INI_CALL_HANDLER_ON_NEW_SECTION
+ if (!HANDLER(user, section, NULL, NULL) && !error)
+ error = lineno;
+#endif
+ }
+ else if (!error) {
+ /* No ']' found on section line */
+ error = lineno;
+ }
+ }
+ else if (*start) {
+ /* Not a comment, must be a name[=:]value pair */
+ end = ini_find_chars_or_comment(start, "=:");
+ if (*end == '=' || *end == ':') {
+ *end = '\0';
+ name = ini_rstrip(start);
+ value = end + 1;
+#if INI_ALLOW_INLINE_COMMENTS
+ end = ini_find_chars_or_comment(value, NULL);
+ if (*end)
+ *end = '\0';
+#endif
+ value = ini_lskip(value);
+ ini_rstrip(value);
+
+#if INI_ALLOW_MULTILINE
+ ini_strncpy0(prev_name, name, sizeof(prev_name));
+#endif
+ /* Valid name[=:]value pair found, call handler */
+ if (!HANDLER(user, section, name, value) && !error)
+ error = lineno;
+ }
+ else if (!error) {
+ /* No '=' or ':' found on name[=:]value line */
+#if INI_ALLOW_NO_VALUE
+ *end = '\0';
+ name = ini_rstrip(start);
+ if (!HANDLER(user, section, name, NULL) && !error)
+ error = lineno;
+#else
+ error = lineno;
+#endif
+ }
+ }
+
+#if INI_STOP_ON_FIRST_ERROR
+ if (error)
+ break;
+#endif
+ }
+
+#if !INI_USE_STACK
+ ini_free(line);
+#endif
+
+ return error;
+}
+
+/* See documentation in header file. */
+int ini_parse_file(FILE* file, ini_handler handler, void* user)
+{
+ return ini_parse_stream((ini_reader)fgets, file, handler, user);
+}
+
+/* See documentation in header file. */
+int ini_parse(const char* filename, ini_handler handler, void* user)
+{
+ FILE* file;
+ int error;
+
+ file = fopen(filename, "r");
+ if (!file)
+ return -1;
+ error = ini_parse_file(file, handler, user);
+ fclose(file);
+ return error;
+}
+
+/* An ini_reader function to read the next line from a string buffer. This
+ is the fgets() equivalent used by ini_parse_string(). */
+static char* ini_reader_string(char* str, int num, void* stream) {
+ ini_parse_string_ctx* ctx = (ini_parse_string_ctx*)stream;
+ const char* ctx_ptr = ctx->ptr;
+ size_t ctx_num_left = ctx->num_left;
+ char* strp = str;
+ char c;
+
+ if (ctx_num_left == 0 || num < 2)
+ return NULL;
+
+ while (num > 1 && ctx_num_left != 0) {
+ c = *ctx_ptr++;
+ ctx_num_left--;
+ *strp++ = c;
+ if (c == '\n')
+ break;
+ num--;
+ }
+
+ *strp = '\0';
+ ctx->ptr = ctx_ptr;
+ ctx->num_left = ctx_num_left;
+ return str;
+}
+
+/* See documentation in header file. */
+int ini_parse_string(const char* string, ini_handler handler, void* user) {
+ ini_parse_string_ctx ctx;
+
+ ctx.ptr = string;
+ ctx.num_left = strlen(string);
+ return ini_parse_stream((ini_reader)ini_reader_string, &ctx, handler,
+ user);
+}
+
+#endif /* INI_IMPL */
+#endif /* INI_H */
diff --git a/include/rx.h b/include/rx.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <stdbool.h>
+#include <time.h>
+#include <mpv/client.h>
+
+#define RX_UPDATE_COUNT 50
+
+typedef struct {
+ char uid[256];
+ char name[256];
+ char *addr;
+ char *url;
+ char *resolver;
+} rx_station_t;
+
+typedef struct {
+ bool quit;
+ rx_station_t *stations;
+ size_t stations_len;
+ const rx_station_t *curr;
+ mpv_handle *ctx;
+ int idx;
+ int count;
+ char *title;
+ int loading;
+ int error;
+ char message[500];
+} rx_t;
+
+void rx_init(rx_t *self);
+void rx_update(rx_t *self);
+void rx_draw(rx_t *self);
+void rx_free(rx_t *self);
diff --git a/mods/byb.c b/mods/byb.c
@@ -0,0 +1,50 @@
+#include <stdlib.h>
+#include <string.h>
+#include <curl/curl.h>
+#define LIB_STR_IMPL
+#include <libstr.h>
+
+#define RX_BYB_URL "https://playerservices.streamtheworld.com/api/livestream?station=BYB_RADIO&transports=http%2Chls&version=1.10&request.preventCache=1735994936887"
+
+size_t rx_curl_write(void *ptr, size_t size, size_t nmemb, void *data) {
+ size_t len = size * nmemb;
+ char **curl_data = (char **) data;
+ str_append_len(curl_data, ptr, len);
+ return len;
+}
+
+char *rx_resolve(void) {
+ CURL *curl = curl_easy_init();
+ if (!curl) {
+ fprintf(stderr, "CURL init failed!\n");
+ return NULL;
+ }
+ char *curl_data = NULL;
+ curl_easy_setopt(curl, CURLOPT_URL, RX_BYB_URL);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, rx_curl_write);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, &curl_data);
+ CURLcode code = curl_easy_perform(curl);
+ if (code != CURLE_OK) {
+ curl_easy_cleanup(curl);
+ fprintf(stderr, "CURL fetch failed!\n%s\n", curl_easy_strerror(code));
+ return NULL;
+ }
+ curl_easy_cleanup(curl);
+ char *url = NULL;
+ size_t set = 0;
+ for (size_t i = 0; i < strlen(curl_data); i++) {
+ if(strncmp(curl_data + i, "<ip>", 4) == 0) {
+ set = i + 4;
+ continue;
+ }
+ if (set && curl_data[i] == '<') {
+ size_t len = i - set;
+ str_append(&url, "https://");
+ str_append_len(&url, curl_data + set, len);
+ str_append(&url, "/BYB_RADIO.mp3");
+ break;
+ }
+ }
+ free(curl_data);
+ return url;
+}
diff --git a/rx.ini b/rx.ini
@@ -0,0 +1,143 @@
+[stations]
+uid=BYB
+name=Backyard Bend Radio
+addr=Bend, US
+resolver=build/byb.so
+
+[stations]
+uid=RPD
+name=Radio Paradise
+addr=Eur
+url=https://stream.radioparadise.com/aac-320
+
+[stations]
+uid=BR2
+name=BBC Radio 2
+addr=London, UK
+url=https://as-hls-ww-live.akamaized.net/pool_904/live/ww/bbc_radio_two/bbc_radio_two.isml/bbc_radio_two-audio%3d96000.norewind.m3u8
+
+[stations]
+uid=PWR
+name=Pure West Radio
+addr=Pembroke, UK
+url=https://streaming.broadcastradio.com:8582/purewest
+
+[stations]
+uid=BWV
+name=BAY WAVE
+addr=Shiogama, JP
+url=https://mtist.as.smartstream.ne.jp/30056/livestream/playlist.m3u8
+
+[stations]
+uid=KSW
+name=Kishiwada
+addr=Kishiwada, JP
+url=http://61.89.201.27:8000/radikishi.mp3"
+
+[stations]
+uid=KBO
+name=KBOO 90.7
+addr=Portland, US
+url=http://live.kboo.fm:8000/high.m3u
+
+[stations]
+uid=WPR
+name=Whisperings Radio
+addr=???
+url=https://pianosolo.streamguys1.com/live?us_privacy=1YNN
+
+[stations]
+uid=TWV
+name=97.3 The Wave
+addr=St. John, CA
+url=http://mbsradio.leanstream.co/CHNSFM-MP3
+
+[stations]
+uid=COK
+name=Choku 86.1
+addr=Nogata, JP
+url=https://mtist.as.smartstream.ne.jp/30085/livestream/playlist.m3u8
+
+[stations]
+uid=NWJ
+name=NHK World Japan
+addr=Tokyo, JP
+url=https://nhkwlive-radio.akamaized.net/hls/live/2032383/radio-rs4/index_06.m3u8
+
+[stations]
+uid=RRM
+name=Radio Record Megamix
+addr=St. Petersburg, RU
+url=https://radiorecord.hostingradio.ru/mix96.aacp
+
+[stations]
+uid=RAR
+name=Retro Album Rock
+addr=Nashville, US
+url=http://das-edge13-live365-dal02.cdnstream.com/a89824
+
+[stations]
+uid=GVH
+name=Gravity House
+addr=Montreal, CA
+url=http://176.9.7.145:8114/stream
+
+[stations]
+uid=AMA
+name=A.M. Ambient
+addr=???
+url=http://radio.stereoscenic.com/ama-h
+
+[stations]
+uid=J1G
+name=J1 Gold
+addr=Tokyo, JP
+url=https://jenny.torontocast.com:2000/stream/J1GOLD
+
+[stations]
+uid=J1H
+name=J1 Hits
+addr=Tokyo, JP
+url=https://jenny.torontocast.com:2000/stream/J1HITS
+
+[stations]
+uid=TOT
+name=KPPT 100.7 The Otter
+addr=Newport, US
+url=https://pacnw.streamguys1.com/live
+
+[stations]
+uid=BOW
+name=Blown
+addr=Milverton, CA
+url=http://crucialvelocity.ca/blown128.m3u
+
+[stations]
+uid=CHR
+name=CHQR 770
+addr=Calgary, CA
+url=http://live.leanstream.co/CHQRAM
+
+[stations]
+uid=CKQ
+name=CKQR 99.3 The Goat
+addr=Castlegar, CA
+url=https://vistaradio.streamb.live/SB00085
+
+[stations]
+uid=ASY
+name=Ashiya Radio
+addr=Ashiya, JP
+url=https://s3.radio.co/sc8d895604/listen
+
+[stations]
+uid=NTG
+name=Nostalgie
+addr=Paris, FR
+url=https://scdn.nrjaudio.fm/fr/40106/aac_64.mp3?cdn_path=audio_lbs12&access_token=427b54a3cea144ba93dd6dfe429e45a4
+
+[stations]
+uid=NWP
+name=Nightwave Plaza
+addr=???
+url=http://radio.plaza.one/mp3
diff --git a/src/main.c b/src/main.c
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <execinfo.h>
+#include <unistd.h>
+
+#include "../include/rx.h"
+
+#define BACKTRACE_SIZE 10
+
+void handle_segfault(int signal) {
+ void *list[BACKTRACE_SIZE];
+ size_t size = backtrace(list, BACKTRACE_SIZE);
+ fprintf(stderr, "ERROR: signal %d:\n", signal);
+ backtrace_symbols_fd(list, size, STDERR_FILENO);
+ exit(EXIT_FAILURE);
+}
+
+rx_t rx;
+
+void do_update(void) {
+ rx_update(&rx);
+ rx_draw(&rx);
+}
+
+int main(void) {
+ rx_init(&rx);
+ struct sigaction sigint_action;
+ sigint_action.sa_handler = handle_segfault;
+ sigint_action.sa_flags = 0;
+ sigemptyset(&sigint_action.sa_mask);
+ sigaction(SIGSEGV, &sigint_action, NULL);
+ while (!rx.quit) {
+ do_update();
+ }
+ rx_free(&rx);
+ return EXIT_SUCCESS;
+}
diff --git a/src/rx.c b/src/rx.c
@@ -0,0 +1,245 @@
+#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");
+ for (size_t i = 0; i < self->stations_len; i++) {
+ const rx_station_t *station = &self->stations[i];
+ if (i == (size_t) self->idx) {
+ term_write("> ");
+ }
+ else {
+ term_write(" ");
+ }
+ int pad = 3; // floor(log10(self->stations_len) + 1);
+ term_writef("%0*d ", pad, i + 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");
+ }
+ }
+ }
+ }
+ 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;
+}