capture.c

Go to the documentation of this file.

 
#include "capture.h"
#include "main.h"
#include "server.h"
#include "video/webcam/webcam.h"
#include "video/image.h"
#include "common.h"
#include "util/endian.h"
#include "asciichat_errno.h"
#include "options/options.h"
#include "options/rcu.h" // For RCU-based options access
#include "util/time.h"
#include "util/format.h"
#include "util/image.h"
#include "util/endian.h"
#include "util/thread.h"
#include "util/endian.h"
#include "util/fps.h"
#include "network/acip/send.h"
#include "network/acip/client.h"
#include <stdatomic.h>
#include <time.h>
#include <string.h>
#include "platform/abstraction.h"
#include "thread_pool.h"
 
/* ============================================================================
 * Capture Thread Management
 * ============================================================================ */
 
__attribute__((unused)) static asciichat_thread_t g_capture_thread;
 
static bool g_capture_thread_created = false;
 
static atomic_bool g_capture_thread_exited = false;
 
/* ============================================================================
 * Frame Processing Constants
 * ============================================================================ */
// Use FRAME_INTERVAL_MS from common.h
#define MAX_FRAME_WIDTH 480
#define MAX_FRAME_HEIGHT 270
 
/* ============================================================================
 * Frame Processing Functions
 * ============================================================================ */
static void calculate_optimal_dimensions(ssize_t original_width, ssize_t original_height, ssize_t max_width,
                                         ssize_t max_height, ssize_t *result_width, ssize_t *result_height) {
  // Calculate original aspect ratio
  float img_aspect = (float)original_width / (float)original_height;
  // Check if image needs resizing
  if (original_width <= max_width && original_height <= max_height) {
    // Image is already within bounds - use as-is
    *result_width = original_width;
    *result_height = original_height;
    return;
  }
  // Determine scaling factor based on which dimension is the limiting factor
  if ((float)max_width / (float)max_height > img_aspect) {
    // Max box is wider than image aspect - scale by height
    *result_height = max_height;
    *result_width = (ssize_t)(max_height * img_aspect);
  } else {
    // Max box is taller than image aspect - scale by width
    *result_width = max_width;
    *result_height = (ssize_t)(max_width / img_aspect);
  }
}
static image_t *process_frame_for_transmission(image_t *original_image, ssize_t max_width, ssize_t max_height) {
  if (!original_image) {
    return NULL;
  }
  // Calculate optimal dimensions
  ssize_t resized_width, resized_height;
  calculate_optimal_dimensions(original_image->w, original_image->h, max_width, max_height, &resized_width,
                               &resized_height);
  // Check if resizing is needed
  if (original_image->w == resized_width && original_image->h == resized_height) {
    // No resizing needed - create a copy to preserve original
    image_t *copy = image_new(original_image->w, original_image->h);
    if (!copy) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate image copy");
      return NULL;
    }
    // Copy pixel data
    memcpy(copy->pixels, original_image->pixels, (size_t)original_image->w * original_image->h * sizeof(rgb_pixel_t));
    return copy;
  }
  // Create new image for resized frame
  image_t *resized = image_new(resized_width, resized_height);
  if (!resized) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate resized image buffer");
    // Do not destroy original_image - caller owns it
    return NULL;
  }
 
  // Perform resizing operation
  image_resize(original_image, resized);
 
  // Return resized image without destroying original
  // Caller is responsible for destroying both input and output
  return resized;
}
/* ============================================================================
 * Capture Thread Implementation
 * ============================================================================ */
 
static void *webcam_capture_thread_func(void *arg) {
  (void)arg;
  struct timespec last_capture_time = {0, 0};
 
  // FPS tracking for webcam capture thread
  static fps_t fps_tracker = {0};
  static bool fps_tracker_initialized = false;
  static uint64_t capture_frame_count = 0;
  static struct timespec last_capture_frame_time = {0, 0};
  static const uint32_t expected_capture_fps = 144;
  if (!fps_tracker_initialized) {
    fps_init(&fps_tracker, 144, "WEBCAM_TX");
    fps_tracker_initialized = true;
  }
 
  while (!should_exit() && !server_connection_is_lost()) {
    // Check connection status
    if (!server_connection_is_active()) {
      platform_sleep_usec(100 * 1000); // Wait for connection
      continue;
    }
 
    // Frame rate limiting using monotonic clock
    // Always capture at 144fps to support high-refresh displays, regardless of client's rendering FPS
    const long CAPTURE_INTERVAL_MS = 1000 / 144; // ~6.94ms for 144fps
    struct timespec current_time;
    (void)clock_gettime(CLOCK_MONOTONIC, &current_time);
    long elapsed_ms = (current_time.tv_sec - last_capture_time.tv_sec) * 1000 +
                      (current_time.tv_nsec - last_capture_time.tv_nsec) / 1000000;
    if (elapsed_ms < CAPTURE_INTERVAL_MS) {
      platform_sleep_usec((CAPTURE_INTERVAL_MS - elapsed_ms) * 1000);
      continue;
    }
 
    image_t *image = webcam_read();
 
    if (!image) {
      log_info("No frame available from webcam yet (webcam_read returned NULL)");
      platform_sleep_usec(10000); // 10ms delay before retry
      continue;
    }
 
    // Track frame for FPS reporting
    (void)clock_gettime(CLOCK_MONOTONIC, &current_time);
    fps_frame(&fps_tracker, &current_time, "webcam frame captured");
 
    // Process frame for network transmission
    // process_frame_for_transmission() always returns a new image that we own
    // We must free the original image after processing
    image_t *processed_image = process_frame_for_transmission(image, MAX_FRAME_WIDTH, MAX_FRAME_HEIGHT);
    if (!processed_image) {
      SET_ERRNO(ERROR_INVALID_STATE, "Failed to process frame for transmission");
      // Free the original image from webcam_read() - it's our responsibility
      image_destroy(image);
      continue;
    }
 
    // Free the original image - we've created a copy/resize in process_frame_for_transmission
    // The processed_image is a new allocation we own
    image_destroy(image);
 
    // processed_image is always a new image (copy or resized) - we own it and must destroy it
    // Serialize image data for network transmission
 
    // Check connection before sending
    if (!server_connection_is_active()) {
      log_warn("Connection lost before sending, stopping video transmission");
      image_destroy(processed_image);
      break;
    }
 
    // Send frame packet to server using proper packet format
    // This handles the full image_frame_packet_t structure with all required fields
    acip_transport_t *transport = server_connection_get_transport();
    asciichat_error_t send_result = acip_send_image_frame(transport, (const void *)processed_image->pixels,
                                                          (uint32_t)processed_image->w, (uint32_t)processed_image->h,
                                                          1); // pixel_format = 1 (RGB24)
 
    if (send_result != ASCIICHAT_OK) {
      // Signal connection loss for reconnection
      log_error("Failed to send image frame: %d", send_result);
      server_connection_lost();
      image_destroy(processed_image);
      break;
    }
 
    // FPS tracking - frame successfully captured and sent
    capture_frame_count++;
 
    // Calculate time since last frame
    uint64_t frame_interval_us =
        ((uint64_t)current_time.tv_sec * 1000000 + (uint64_t)current_time.tv_nsec / 1000) -
        ((uint64_t)last_capture_frame_time.tv_sec * 1000000 + (uint64_t)last_capture_frame_time.tv_nsec / 1000);
    last_capture_frame_time = current_time;
 
    // Expected frame interval in microseconds (6944us for 144fps)
    uint64_t expected_interval_us = 1000000 / expected_capture_fps;
    uint64_t lag_threshold_us = expected_interval_us + (expected_interval_us / 2); // 50% over expected
 
    // Log warning if frame took too long to capture
    if (capture_frame_count > 1 && frame_interval_us > lag_threshold_us) {
      log_warn_every(LOG_RATE_FAST,
                     "CLIENT CAPTURE LAG: Frame captured %.1fms late (expected %.1fms, got %.1fms, actual fps: %.1f)",
                     (double)(frame_interval_us - expected_interval_us) / 1000.0, (double)expected_interval_us / 1000.0,
                     (double)frame_interval_us / 1000.0, 1000000.0 / (double)frame_interval_us);
    }
 
    // Update capture timing
    last_capture_time = current_time;
 
    // Clean up resources
    image_destroy(processed_image);
    processed_image = NULL;
  }
 
#ifdef DEBUG_THREADS
  log_info("Webcam capture thread stopped");
#endif
 
  atomic_store(&g_capture_thread_exited, true);
 
  // Clean up thread-local error context before exit
  asciichat_errno_cleanup();
 
  return NULL;
}
/* ============================================================================
 * Public Interface Functions
 * ============================================================================ */
int capture_init() {
  // Initialize webcam capture
  int webcam_index = GET_OPTION(webcam_index);
  int result = webcam_init(webcam_index);
  if (result != 0) {
    SET_ERRNO(ERROR_WEBCAM, "Failed to initialize webcam (error code: %d)", result);
    // Preserve specific error code (e.g., WEBCAM vs WEBCAM_IN_USE)
    return result;
  }
  return 0;
}
int capture_start_thread() {
  if (THREAD_IS_CREATED(g_capture_thread_created)) {
    log_warn("Capture thread already created");
    return 0;
  }
 
  // Start webcam capture thread
  atomic_store(&g_capture_thread_exited, false);
  if (thread_pool_spawn(g_client_worker_pool, webcam_capture_thread_func, NULL, 2, "webcam_capture") != ASCIICHAT_OK) {
    SET_ERRNO(ERROR_THREAD, "Webcam capture thread creation failed");
    LOG_ERRNO_IF_SET("Webcam capture thread creation failed");
    return -1;
  }
 
  g_capture_thread_created = true;
  log_info("Webcam capture thread created successfully");
 
  // Notify server we're starting to send video
  if (threaded_send_stream_start_packet(STREAM_TYPE_VIDEO) < 0) {
    LOG_ERRNO_IF_SET("Failed to send stream start packet");
  }
 
  return 0;
}
void capture_stop_thread() {
  if (!THREAD_IS_CREATED(g_capture_thread_created)) {
    return;
  }
 
  // Flush webcam to interrupt any blocking ReadSample operations
  // This allows the capture thread to notice should_exit() and exit cleanly
  webcam_flush();
 
  // Wait for thread to exit gracefully
  int wait_count = 0;
  while (wait_count < 20 && !atomic_load(&g_capture_thread_exited)) {
    platform_sleep_usec(100000); // 100ms
    // Keep flushing in case the thread went back into a blocking read
    if (wait_count % 5 == 0) {
      webcam_flush();
    }
    wait_count++;
  }
 
  if (!atomic_load(&g_capture_thread_exited)) {
    log_warn("Capture thread not responding after 2 seconds - will be joined by thread pool");
  }
 
  // Thread will be joined by thread_pool_stop_all() in protocol_stop_connection()
  g_capture_thread_created = false;
}
bool capture_thread_exited() {
  return atomic_load(&g_capture_thread_exited);
}
void capture_cleanup() {
  capture_stop_thread();
  webcam_cleanup();
}