moved server to C

airlink.c

@@ -0,0 +1,329 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/select.h>
+#include <sys/wait.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <time.h>
+
+// --- Configuration ---
+#define PORT_VIDEO 5000
+#define PORT_AUDIO 5001
+#define DEVICE_VIDEO "/dev/video20"
+#define SINK_AUDIO "AirLink_Sink"
+#define SOURCE_MIC "AirLink_Mic"
+#define BUFFER_SIZE 65535
+
+// --- Globals ---
+pid_t pid_video_process = 0;
+pid_t pid_audio_process = 0;
+int pipe_video_fd = -1;
+int pipe_audio_fd = -1;
+int socket_video = -1;
+int socket_audio = -1;
+int is_running = 1;
+
+// Stats tracking
+typedef struct {
+    long long bytes_video;
+    long long bytes_audio;
+    int packets_video;
+    int packets_audio;
+    time_t last_log_time;
+} TrafficStats;
+
+TrafficStats stats = {0, 0, 0, 0, 0};
+
+// --- Helpers ---
+
+void kill_process(pid_t *pid) {
+    if (*pid > 0) {
+        kill(*pid, SIGTERM);
+        waitpid(*pid, NULL, 0); // Wait to prevent zombies
+        *pid = 0;
+    }
+}
+
+// Generates a black screen on the virtual camera (used for Pause/Stop)
+void render_black_screen() {
+    kill_process(&pid_video_process);
+    if (pipe_video_fd != -1) { close(pipe_video_fd); pipe_video_fd = -1; }
+
+    printf("[STATE] Rendering black screen (Privacy Mode)\n");
+    // We run this as a blocking system call because it's a short "state change" operation
+    char cmd[512];
+    snprintf(cmd, sizeof(cmd), 
+        "ffmpeg -hide_banner -loglevel error -f lavfi -i color=black:s=1280x720 "
+        "-pix_fmt yuyv422 -frames:v 5 -f v4l2 %s > /dev/null 2>&1", 
+        DEVICE_VIDEO);
+    system(cmd);
+}
+
+void cleanup(int sig) {
+    is_running = 0;
+    printf("\n[INFO] Shutting down services...\n");
+    
+    kill_process(&pid_video_process);
+    kill_process(&pid_audio_process);
+
+    // Clean up PulseAudio modules
+    char cmd[256];
+    snprintf(cmd, sizeof(cmd), "pactl unload-module %s > /dev/null 2>&1", SINK_AUDIO);
+    system(cmd);
+    system("pactl unload-module AirLink_Mic > /dev/null 2>&1");
+    
+    // Stop Avahi
+    system("pkill -f 'avahi-publish-service -s AirLink'");
+    
+    // Final Black Screen
+    render_black_screen();
+    
+    exit(0);
+}
+
+// Spawns a process and returns the Write FD for its STDIN
+pid_t spawn_worker(char *const cmd[], int *fd_in) {
+    int pipefd[2];
+    if (pipe(pipefd) == -1) return -1;
+
+    pid_t pid = fork();
+    if (pid == 0) {
+        // Child
+        close(pipefd[1]); // Close write end
+        dup2(pipefd[0], STDIN_FILENO); // Redirect pipe read to STDIN
+        close(pipefd[0]);
+        
+        // Close other file descriptors to be safe
+        for (int i = 3; i < 256; i++) close(i);
+        
+        execvp(cmd[0], cmd);
+        exit(1); // Should not reach here
+    } else if (pid > 0) {
+        // Parent
+        close(pipefd[0]); // Close read end
+        *fd_in = pipefd[1]; // Keep write end
+        return pid;
+    }
+    return -1;
+}
+
+void initialize_system() {
+    printf("[INIT] Configuring Kernel Modules and Audio Subsystem...\n");
+    
+    // Video: Reload v4l2loopback
+    system("sudo modprobe -r v4l2loopback 2>/dev/null");
+    char v4l2_cmd[256];
+    snprintf(v4l2_cmd, sizeof(v4l2_cmd), 
+        "sudo modprobe v4l2loopback video_nr=20 card_label=AirLink_Cam exclusive_caps=1");
+    system(v4l2_cmd);
+    
+    // Audio: Null Sink
+    char pa_cmd[512];
+    snprintf(pa_cmd, sizeof(pa_cmd), 
+        "pactl load-module module-null-sink sink_name=%s "
+        "sink_properties=device.description='AirLink_Audio' rate=48000 channels=1 >/dev/null 2>&1", 
+        SINK_AUDIO);
+    system(pa_cmd);
+    
+    // Audio: Remap Source (Virtual Mic)
+    snprintf(pa_cmd, sizeof(pa_cmd), 
+        "pactl load-module module-remap-source source_name=%s "
+        "master=%s.monitor source_properties=device.description='AirLink_Mic' channels=1 >/dev/null 2>&1", 
+        SOURCE_MIC, SINK_AUDIO);
+    system(pa_cmd);
+}
+
+void start_video_stream() {
+    // Check if already running
+    if (pid_video_process > 0 && waitpid(pid_video_process, NULL, WNOHANG) == 0) return;
+
+    // FFmpeg command to read raw H264 from stdin and write to V4L2
+    char *cmd[] = {
+        "ffmpeg", 
+        "-fflags", "nobuffer", 
+        "-flags", "low_delay",
+        "-analyzeduration", "0", 
+        "-probesize", "32",
+        "-hide_banner", 
+        "-loglevel", "quiet",
+        "-f", "h264", 
+        "-i", "pipe:0",
+        "-vf", "scale=1280:720:force_original_aspect_ratio=decrease,pad=1280:720:(ow-iw)/2:(oh-ih)/2",
+        "-vsync", "0", 
+        "-copyts", 
+        "-pix_fmt", "yuyv422",
+        "-f", "v4l2", DEVICE_VIDEO, 
+        NULL
+    };
+    
+    pid_video_process = spawn_worker(cmd, &pipe_video_fd);
+    signal(SIGPIPE, SIG_IGN); // Prevent crash if ffmpeg dies
+}
+
+void start_audio_stream() {
+    if (pid_audio_process > 0 && waitpid(pid_audio_process, NULL, WNOHANG) == 0) return;
+
+    // Use a shell to pipe ffmpeg decoder directly to pacat
+    // Input: Raw PCM or Encoded Audio -> FFmpeg -> Raw PCM -> Pacat
+    // Based on Python: Raw s16le incoming -> Pacat
+    // If incoming is already raw PCM (s16le, 48k, mono), we can skip ffmpeg or just use it as pass-through.
+    // We will use the shell wrapper for simplicity of piping.
+    
+    int pipefd[2];
+    if (pipe(pipefd) == -1) return;
+
+    pid_audio_process = fork();
+    if (pid_audio_process == 0) {
+        close(pipefd[1]);
+        dup2(pipefd[0], STDIN_FILENO);
+        
+        // Command: Decode (ensure format) -> Play
+        // We assume the Android app sends raw PCM (s16le) as per your Python script audio logic
+        execl("/bin/sh", "sh", "-c", 
+            "ffmpeg -hide_banner -loglevel quiet -fflags nobuffer -f s16le -ar 48000 -ac 1 -i pipe:0 "
+            "-f s16le -ar 48000 -ac 1 pipe:1 | "
+            "pacat --playback --device=AirLink_Sink --rate=48000 --channels=1 --format=s16le --latency-msec=20", 
+            NULL);
+        exit(1);
+    }
+    close(pipefd[0]);
+    pipe_audio_fd = pipefd[1];
+}
+
+void print_stats() {
+    time_t now = time(NULL);
+    if (stats.last_log_time == 0) stats.last_log_time = now;
+
+    double delta = difftime(now, stats.last_log_time);
+    if (delta >= 1.0) {
+        double video_mbps = (stats.bytes_video * 8.0) / (1000.0 * 1000.0) / delta;
+        double audio_kbps = (stats.bytes_audio * 8.0) / 1000.0 / delta;
+        
+        printf("[STATS] Video: %6.2f Mbps (%d pps) | Audio: %6.2f Kbps (%d pps)\n",
+            video_mbps, stats.packets_video,
+            audio_kbps, stats.packets_audio);
+            
+        // Reset
+        stats.bytes_video = 0;
+        stats.bytes_audio = 0;
+        stats.packets_video = 0;
+        stats.packets_audio = 0;
+        stats.last_log_time = now;
+    }
+}
+
+int main() {
+    signal(SIGINT, cleanup);
+    
+    initialize_system();
+
+    // Start Avahi Advertising (Background)
+    system("avahi-publish-service -s AirLink _procam._udp 5000 &");
+
+    // Create UDP Sockets
+    socket_video = socket(AF_INET, SOCK_DGRAM, 0);
+    socket_audio = socket(AF_INET, SOCK_DGRAM, 0);
+
+    // Set large kernel buffers to prevent drops
+    int rcvbuf_video = 4 * 1024 * 1024; // 4MB
+    int rcvbuf_audio = 512 * 1024;      // 512KB
+    setsockopt(socket_video, SOL_SOCKET, SO_RCVBUF, &rcvbuf_video, sizeof(rcvbuf_video));
+    setsockopt(socket_audio, SOL_SOCKET, SO_RCVBUF, &rcvbuf_audio, sizeof(rcvbuf_audio));
+
+    struct sockaddr_in addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+    addr.sin_port = htons(PORT_VIDEO);
+    if (bind(socket_video, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+        perror("Bind Video Failed"); return 1;
+    }
+
+    addr.sin_port = htons(PORT_AUDIO);
+    if (bind(socket_audio, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+        perror("Bind Audio Failed"); return 1;
+    }
+
+    printf("[READY] Server listening on Ports %d (Video) & %d (Audio)\n", PORT_VIDEO, PORT_AUDIO);
+
+    start_video_stream();
+    start_audio_stream();
+
+    unsigned char buffer[BUFFER_SIZE];
+    fd_set readfds;
+    int max_fd = (socket_video > socket_audio ? socket_video : socket_audio) + 1;
+    
+    struct sockaddr_in src_addr;
+    socklen_t src_len;
+
+    while (is_running) {
+        print_stats();
+
+        // Check process health and restart if needed
+        if (waitpid(pid_video_process, NULL, WNOHANG) > 0) start_video_stream();
+        if (waitpid(pid_audio_process, NULL, WNOHANG) > 0) start_audio_stream();
+
+        FD_ZERO(&readfds);
+        FD_SET(socket_video, &readfds);
+        FD_SET(socket_audio, &readfds);
+
+        struct timeval tv = {1, 0}; // 1 second timeout (allows stats to print even if idle)
+        int activity = select(max_fd, &readfds, NULL, NULL, &tv);
+
+        if (activity < 0 && errno != EINTR) break;
+
+        // --- Handle Video & Control ---
+        if (FD_ISSET(socket_video, &readfds)) {
+            src_len = sizeof(src_addr);
+            int n = recvfrom(socket_video, buffer, sizeof(buffer), 0, (struct sockaddr*)&src_addr, &src_len);
+            
+            if (n > 0) {
+                // Control Packet Handling
+                if (n < 16) {
+                    if (memcmp(buffer, "PING", 4) == 0) {
+                        sendto(socket_video, "PONG", 4, 0, (struct sockaddr*)&src_addr, src_len);
+                    } 
+                    else if (memcmp(buffer, "HEARTBEAT", 9) == 0) {
+                        sendto(socket_video, "ACK", 3, 0, (struct sockaddr*)&src_addr, src_len);
+                    }
+                    else if (memcmp(buffer, "PAUSE", 5) == 0 || memcmp(buffer, "BYE", 3) == 0) {
+                        render_black_screen();
+                    }
+                } 
+                else {
+                    // Video Data
+                    if (pid_video_process == 0) start_video_stream();
+                    write(pipe_video_fd, buffer, n);
+                    
+                    // Update Stats
+                    stats.bytes_video += n;
+                    stats.packets_video++;
+                }
+            }
+        }
+
+        // --- Handle Audio ---
+        if (FD_ISSET(socket_audio, &readfds)) {
+            int n = recvfrom(socket_audio, buffer, sizeof(buffer), 0, NULL, NULL);
+            if (n > 0) {
+                // Audio Data (ignore control packets on this port usually)
+                if (n > 16) {
+                    write(pipe_audio_fd, buffer, n);
+                    
+                    // Update Stats
+                    stats.bytes_audio += n;
+                    stats.packets_audio++;
+                }
+            }
+        }
+    }
+
+    return 0;
+}