API Reference

#include "ipc.h"

bool success = ipc_init("/tmp/gslapper.sock");
if (!success) {
    fprintf(stderr, "Failed to initialize IPC server\n");
}

// At program exit or on signal
ipc_shutdown();

#include <poll.h>

// In main event loop
struct pollfd fds[2];
fds[0].fd = wl_display_get_fd(display);
fds[0].events = POLLIN;
fds[1].fd = ipc_get_wakeup_fd();
fds[1].events = POLLIN;

while (running) {
    poll(fds, 2, -1);
    // Handle events...
}

// After poll() returns with IPC event
if (fds[1].revents & POLLIN) {
    ipc_drain_wakeup();  // Clear pipe

    // Now process commands
    ipc_command_t *cmd = ipc_dequeue_command();
    // ...
}

while ((cmd = ipc_dequeue_command()) != NULL) {
    // Process cmd->cmd_line
    // Send response to cmd->client_fd
    ipc_send_response(cmd->client_fd, "OK\n");

    // Cleanup
    free(cmd->cmd_line);
    free(cmd);
}

ipc_send_response(client_fd, "OK: Wallpaper changed\n");
ipc_send_response(client_fd, "ERROR: File not found\n");
ipc_send_response(client_fd, "STATUS: playing video /path/to/video.mp4\n");

#include <sys/socket.h>
#include <sys/un.h>

int connect_to_ipc(const char *socket_path) {
    int fd = socket(AF_UNIX, SOCK_STREAM, 0);
    struct sockaddr_un addr;
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);

    if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
        return -1;
    }
    return fd;
}

void send_ipc_command(int fd, const char *cmd) {
    write(fd, cmd, strlen(cmd));

    char response[1024];
    ssize_t n = read(fd, response, sizeof(response) - 1);
    if (n > 0) {
        response[n] = '\0';
        printf("Response: %s\n", response);
    }
}

int main() {
    int fd = connect_to_ipc("/tmp/gslapper.sock");
    if (fd < 0) {
        perror("Failed to connect");
        return 1;
    }

    send_ipc_command(fd, "pause\n");
    send_ipc_command(fd, "query\n");
    send_ipc_command(fd, "change /path/to/new/video.mp4\n");

    close(fd);
    return 0;
}

typedef struct ipc_command {
    char *cmd_line;          // Full command string from client
    int client_fd;            // Client socket file descriptor
    struct ipc_command *next;  // Next command in queue (linked list)
} ipc_command_t;

typedef struct preload_entry {
    char *path;              // File path of preloaded image
    gpointer frame_data;       // GLib pointer to frame data
    gsize frame_size;         // Size of frame data in bytes
    gint width;               // Image width in pixels
    gint height;              // Image height in pixels
    struct preload_entry *next; // Next entry in cache (linked list)
} preload_entry_t;

struct wallpaper_state {
    char *output;        // Monitor name (e.g., "DP-1", "DP-3")
    char *path;         // Full path to video or image file
    bool is_image;      // true = static image, false = video
    char *options;       // GStreamer options string (e.g., "loop panscan=0.8")
    double position;    // Video position in seconds (0.0 for images)
    bool paused;        // Pause state for videos (false by default)
};

version=1
output=DP-1
path=/home/user/Videos/wallpaper.mp4
is_image=false
options=loop panscan=0.8
position=123.45
paused=0

#include "state.h"

char *path = get_state_file_path("DP-1");
if (path) {
    printf("State file: %s\n", path);
    free(path);
}

struct wallpaper_state state = {
    .output = "DP-1",
    .path = "/home/user/Videos/wallpaper.mp4",
    .is_image = false,
    .options = "loop panscan=0.8",
    .position = 123.45,
    .paused = false
};

char *state_path = get_state_file_path("DP-1");
if (state_path && save_state_file(state_path, &state) == 0) {
    printf("State saved successfully\n");
}
free(state_path);

struct wallpaper_state state;
char *state_path = get_state_file_path("DP-1");

if (state_path && load_state_file(state_path, &state) == 0) {
    printf("Restoring: %s\n", state.path);
    printf("Options: %s\n", state.options);
    printf("Position: %.2f\n", state.position);
}

struct wallpaper_state *state = malloc(sizeof(struct wallpaper_state));
// ... fill state ...

// Free allocated strings
free_wallpaper_state(state);

// Free structure itself
free(state);

#include "cflogprinter.h"

cflp_success("State saved to %s", state_path);
// Output (green): ✓ State saved to /home/user/.local/state/gslapper/state.txt

cflp_error("Failed to open file: %s", path);
// Output (red bold): ✗ Failed to open file: /path/to/file.txt

cflp_warning("Video codec not found, falling back to software decoding");
// Output (yellow): ⚠ Video codec not found, falling back to software decoding

if (VERBOSE) {
    cflp_info("Initializing GStreamer pipeline...");
}
// Output (if VERBOSE): ℹ Initializing GStreamer pipeline...

cflp_custom(CYAN, "Loading image: %s", path);
cflp_custom(MAGENTA, "Status: %s", status);
cflp_custom(RESET, "Back to normal color");

#define RED         "\033[1;31m"    // Bold red
#define GREEN       "\033[0;32m"    // Green
#define YELLOW      "\033[0;33m"    // Yellow
#define BLUE        "\033[0;34m"    // Blue
#define MAGENTA     "\033[0;35m"    // Magenta
#define CYAN        "\033[0;36m"    // Cyan
#define RESET       "\033[0m"       // Reset to default

struct wl_state {
    struct wl_display *display;           // Wayland display connection
    struct wl_compositor *compositor;     // Compositor interface
    struct zwlr_layer_shell_v1 *layer_shell; // Layer shell protocol
    struct wl_list outputs;               // List of display_output structures
    char *monitor;                       // User-selected output name (or '*')
    int surface_layer;                    // Layer level (background, bottom, top, overlay)
};

struct display_output {
    uint32_t wl_name;                  // Wayland output name (numeric)
    struct wl_output *wl_output;         // Output interface
    char *name;                         // Output name string (e.g., "DP-1")
    char *identifier;                    // Output model/serial string

    struct wl_state *state;              // Parent state reference
    struct wl_surface *surface;           // Wayland surface
    struct zwlr_layer_surface_v1 *layer_surface; // Layer surface
    struct wl_egl_window *egl_window;    // EGL window
    EGLSurface *egl_surface;             // EGL surface

    uint32_t width, height;             // Output dimensions
    uint32_t scale;                     // Output scale factor (DPI)

    struct wl_list link;                 // Link in state.outputs list

    struct wl_callback *frame_callback;   // Frame callback
    bool redraw_needed;                  // Flag for frame request
};

static GstElement *pipeline;             // Main GStreamer pipeline
static GstBus *bus;                   // Pipeline bus for events/messages
static char *allocated_uri;            // URI for current media (for cleanup)
static bool using_waylandsink;        // Whether using waylandsink for direct rendering

static GLuint video_texture = 0;       // OpenGL texture for video frames
static GLuint shader_program = 0;       // Default shader program
static GLuint transition_shader_program = 0; // Transition effect shader
static GLuint vao = 0, vbo = 0;    // Vertex array/buffer objects

// Smart texture management to reduce reallocations
static struct {
    GLuint texture;
    int current_width;
    int current_height;
    gboolean initialized;
} texture_manager = {0};

// Video frame data for thread-safe texture updates
static struct {
    gboolean has_new_frame;
    gint width, height;
    gpointer data;
    gsize size;
    gint last_width, last_height;     // Track dimension changes
} video_frame_data = {0};

static struct timespec last_render_time = {0};
static long long target_frame_time_ns = 33333333;  // Default ~30 FPS
static int frame_rate_cap = 30;                   // Default 30 FPS
static int frames_skipped = 0;                     // Adaptive skipping

static char *state_file_path = NULL;
static bool systemd_mode = false;
static bool save_state_on_exit = true;
static bool restore_flag = false;
static bool save_state_flag = false;

static double restore_position = 0.0;
static bool restore_paused = false;

typedef enum {
    TRANSITION_NONE = 0,
    TRANSITION_FADE
} transition_type_t;

typedef struct {
    transition_type_t type;       // Transition effect type
    bool active;                 // Currently in transition
    bool enabled;                // Transitions globally enabled
    float duration;              // Transition duration in seconds
    float elapsed;               // Time since transition started
    float progress;              // 0.0 to 1.0 (0% to 100%)

    GLuint old_texture;          // Previous wallpaper texture
    GLuint new_texture;          // New wallpaper texture
    int old_width, old_height;  // Old wallpaper dimensions
    int new_width, new_height;  // New wallpaper dimensions
    float old_scale_x, old_scale_y; // Old scaling factors
    float alpha_old, alpha_new;   // Blend factors

    struct timespec start_time;    // Transition start time
} transition_state_t;

static struct {
    char **pauselist;          // List of app names for auto-pause
    char **stoplist;           // List of app names for auto-stop

    int argc;                   // Saved argc for restart
    char **argv_copy;           // Saved argv for restart
    char *save_info;            // Saved command info

    bool auto_pause;             // Auto-pause when wallpaper hidden
    bool auto_stop;              // Auto-stop when wallpaper hidden

    int is_paused;              // Current pause state
    bool frame_ready;            // New frame available flag
    bool stop_render_loop;        // Flag to stop rendering loop
} app_state = {0};

#include "ipc.h"
#include <stdio.h>

int main() {
    // Start gSlapper with IPC
    system("gslapper -I /tmp/gslapper.sock -o 'loop' DP-1 /path/to/video.mp4 &");
    sleep(2);  // Wait for startup

    // Connect to IPC
    int fd = socket(AF_UNIX, SOCK_STREAM, 0);
    struct sockaddr_un addr;
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, "/tmp/gslapper.sock", sizeof(addr.sun_path) - 1);

    if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
        perror("Connect failed");
        return 1;
    }

    // Interactive control
    char input[256];
    while (1) {
        printf("> ");
        fgets(input, sizeof(input), stdin);

        if (strcmp(input, "pause\n") == 0) {
            write(fd, "pause\n", 6);
        } else if (strcmp(input, "resume\n") == 0) {
            write(fd, "resume\n", 7);
        } else if (strcmp(input, "quit\n") == 0) {
            write(fd, "stop\n", 5);
            break;
        }

        // Read response
        char response[1024];
        ssize_t n = read(fd, response, sizeof(response) - 1);
        if (n > 0) {
            response[n] = '\0';
            printf("%s", response);
        }
    }

    close(fd);
    return 0;
}

#include "state.h"
#include <dirent.h>

void switch_wallpaper(const char *new_path) {
    struct wallpaper_state state;
    char *state_path = get_state_file_path("DP-1");

    // Load current state
    if (state_path && load_state_file(state_path, &state) == 0) {
        // Update path
        free(state.path);
        state.path = strdup(new_path);

        // Save state
        if (save_state_file(state_path, &state) == 0) {
            printf("State updated: %s\n", new_path);
        }
    }

    free(state_path);
}