webcam.c

Go to the documentation of this file.

 
#include <stdio.h>
 
#include "webcam.h"
#include "common.h"
#include "options/options.h"
#include "video/image.h"
#include "platform/string.h"
 
static webcam_context_t *global_webcam_ctx = NULL;
 
asciichat_error_t webcam_init(unsigned short int webcam_index) {
  // Check if test pattern mode is enabled
  if (GET_OPTION(test_pattern)) {
    log_info("Test pattern mode enabled - not opening real webcam");
    log_info("Test pattern resolution: 1280x720");
    return ASCIICHAT_OK;
  }
 
#ifdef __linux__
  log_info("Initializing webcam with V4L2 (Linux)");
  log_info("Attempting to open webcam with index %d using V4L2 (Linux)...", webcam_index);
#elif defined(__APPLE__)
  log_info("Initializing webcam with AVFoundation (macOS)");
  log_info("Attempting to open webcam with index %d using AVFoundation (macOS)...", webcam_index);
#elif defined(_WIN32)
  log_info("Initializing webcam with Media Foundation (Windows)");
  log_info("Attempting to open webcam with index %d using Media Foundation (Windows)...", webcam_index);
#else
  log_info("Initializing webcam with Unknown platform");
  log_info("Attempting to open webcam with index %d using Unknown platform...", webcam_index);
#endif
 
  asciichat_error_t result = webcam_init_context(&global_webcam_ctx, webcam_index);
  if (result != ASCIICHAT_OK) {
    SET_ERRNO(result, "Failed to connect to webcam (error code: %d)", result);
    return result;
  }
 
  // Get image dimensions
  int width, height;
  if (webcam_get_dimensions(global_webcam_ctx, &width, &height) == ASCIICHAT_OK) {
    log_info("Webcam opened successfully! Resolution: %dx%d", width, height);
  } else {
    SET_ERRNO(ERROR_WEBCAM, "Webcam opened but failed to get dimensions");
  }
 
  return result;
}
 
image_t *webcam_read(void) {
  // Check if test pattern mode is enabled
  if (GET_OPTION(test_pattern)) {
    // Use cached test pattern for 60 FPS performance
    // Generate once on first call, reuse for subsequent calls
    static image_t *cached_pattern = NULL;
    static int frame_counter = 0;
 
    if (!cached_pattern) {
      // Generate a colorful test pattern ONCE on first call
      cached_pattern = image_new(1280, 720);
      if (!cached_pattern) {
        SET_ERRNO(ERROR_MEMORY, "Failed to allocate test pattern frame");
        return NULL;
      }
 
      // Generate a simple color bar pattern (FAST - no per-pixel calculations)
      for (int y = 0; y < cached_pattern->h; y++) {
        for (int x = 0; x < cached_pattern->w; x++) {
          rgb_pixel_t *pixel = &cached_pattern->pixels[y * cached_pattern->w + x];
 
          // Simple color bars (8 vertical sections)
          int grid_x = x / 160;
 
          // Base pattern: color bars (no floating-point math)
          switch (grid_x) {
          case 0: // Red
            pixel->r = 255;
            pixel->g = 0;
            pixel->b = 0;
            break;
          case 1: // Green
            pixel->r = 0;
            pixel->g = 255;
            pixel->b = 0;
            break;
          case 2: // Blue
            pixel->r = 0;
            pixel->g = 0;
            pixel->b = 255;
            break;
          case 3: // Yellow
            pixel->r = 255;
            pixel->g = 255;
            pixel->b = 0;
            break;
          case 4: // Cyan
            pixel->r = 0;
            pixel->g = 255;
            pixel->b = 255;
            break;
          case 5: // Magenta
            pixel->r = 255;
            pixel->g = 0;
            pixel->b = 255;
            break;
          case 6: // White
            pixel->r = 255;
            pixel->g = 255;
            pixel->b = 255;
            break;
          case 7: // Gray gradient
          default: {
            uint8_t gray = (uint8_t)((y * 255) / cached_pattern->h);
            pixel->r = gray;
            pixel->g = gray;
            pixel->b = gray;
            break;
          }
          }
 
          // Add grid lines for visual separation
          if (x % 160 == 0 || y % 120 == 0) {
            pixel->r = 0;
            pixel->g = 0;
            pixel->b = 0;
          }
        }
      }
    }
 
    frame_counter++;
 
    // Clone the cached pattern for each call (caller owns and frees it)
    // This is MUCH faster than regenerating the pattern each time
    image_t *test_frame = image_new(cached_pattern->w, cached_pattern->h);
    if (!test_frame) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate test pattern frame");
      return NULL;
    }
 
    // Fast memcpy instead of per-pixel loop
    memcpy(test_frame->pixels, cached_pattern->pixels,
           (size_t)cached_pattern->w * cached_pattern->h * sizeof(rgb_pixel_t));
 
    // Apply horizontal flip if requested (same as real webcam)
    if (GET_OPTION(webcam_flip)) {
      for (int y = 0; y < test_frame->h; y++) {
        for (int x = 0; x < test_frame->w / 2; x++) {
          rgb_pixel_t temp = test_frame->pixels[y * test_frame->w + x];
          test_frame->pixels[y * test_frame->w + x] = test_frame->pixels[y * test_frame->w + (test_frame->w - 1 - x)];
          test_frame->pixels[y * test_frame->w + (test_frame->w - 1 - x)] = temp;
        }
      }
    }
 
    return test_frame;
  }
 
  if (!global_webcam_ctx) {
    SET_ERRNO(ERROR_WEBCAM, "Webcam not initialized - global_webcam_ctx is NULL");
    return NULL;
  }
 
  image_t *frame = webcam_read_context(global_webcam_ctx);
 
  if (!frame) {
    return NULL;
  }
 
  // Apply horizontal flip if requested
  if (GET_OPTION(webcam_flip) && frame->w > 1) {
    // Flip the image horizontally - optimized for large images
    // Process entire rows to improve cache locality
    rgb_pixel_t *left = frame->pixels;
    rgb_pixel_t *right = frame->pixels + frame->w - 1;
 
    for (int y = 0; y < frame->h; y++) {
      rgb_pixel_t *row_left = left;
      rgb_pixel_t *row_right = right;
 
      // Swap pixels from both ends moving inward
      for (int x = 0; x < frame->w / 2; x++) {
        rgb_pixel_t temp = *row_left;
        *row_left++ = *row_right;
        *row_right-- = temp;
      }
 
      // Move to next row
      left += frame->w;
      right += frame->w;
    }
  }
 
  return frame;
}
 
void webcam_cleanup(void) {
  if (GET_OPTION(test_pattern)) {
    log_info("Test pattern mode - no webcam resources to release");
    return;
  }
 
  if (global_webcam_ctx) {
    webcam_cleanup_context(global_webcam_ctx);
    global_webcam_ctx = NULL;
    // log_info("Webcam resources released");
  } else {
    log_info("Webcam was not opened, nothing to release");
  }
}
 
void webcam_flush(void) {
  if (GET_OPTION(test_pattern)) {
    return; // Test pattern doesn't need flushing
  }
 
  if (global_webcam_ctx) {
    webcam_flush_context(global_webcam_ctx);
  }
}
 
void webcam_print_init_error_help(asciichat_error_t error_code) {
  // Platform-specific error messages and troubleshooting help
#ifdef __linux__
  safe_fprintf(stderr, "\n");
 
  if (error_code == ERROR_WEBCAM) {
    safe_fprintf(stderr, "Webcam initialization failed on Linux.\n\n");
    safe_fprintf(stderr, "Common solutions:\n");
    safe_fprintf(stderr, "  1. Check if a camera is connected:\n");
    safe_fprintf(stderr, "       ls /dev/video*\n\n");
    safe_fprintf(stderr, "  2. If no camera is available, use test pattern mode:\n");
    safe_fprintf(stderr, "       ascii-chat client --test-pattern\n\n");
    safe_fprintf(stderr, "  3. Install V4L2 drivers if needed:\n");
    safe_fprintf(stderr, "       sudo apt-get install v4l-utils\n");
  } else if (error_code == ERROR_WEBCAM_PERMISSION) {
    safe_fprintf(stderr, "Camera permission denied.\n\n");
    safe_fprintf(stderr, "Fix permissions with:\n");
    safe_fprintf(stderr, "  sudo usermod -a -G video $USER\n");
    safe_fprintf(stderr, "Then log out and log back in for changes to take effect.\n");
  } else if (error_code == ERROR_WEBCAM_IN_USE) {
    safe_fprintf(stderr, "Camera is already in use by another application.\n\n");
    safe_fprintf(stderr, "Try closing other camera apps or use test pattern mode:\n");
    safe_fprintf(stderr, "  ascii-chat client --test-pattern\n");
  } else {
    safe_fprintf(stderr, "Webcam error on Linux.\n\n");
    safe_fprintf(stderr, "General troubleshooting:\n");
    safe_fprintf(stderr, "* Check camera: ls /dev/video*\n");
    safe_fprintf(stderr, "* Check permissions: groups | grep video\n");
    safe_fprintf(stderr, "* Use test pattern: ascii-chat client --test-pattern\n");
  }
  (void)fflush(stderr);
#elif defined(__APPLE__)
  (void)error_code;
  safe_fprintf(stderr, "\n");
  safe_fprintf(stderr, "On macOS, you may need to grant camera permissions:\n");
  safe_fprintf(stderr,
               "* Say \"yes\" to the popup about system camera access that you see when running this program for the "
               "first time.\n");
  safe_fprintf(
      stderr, "* If you said \"no\" to the popup, go to System Preferences > Security & Privacy > Privacy > Camera.\n");
  safe_fprintf(stderr,
               "   Now flip the switch next to your terminal application in that privacy list to allow ascii-chat to "
               "access your camera.\n");
  safe_fprintf(stderr, "   Then just run this program again.\n");
  (void)fflush(stderr);
#elif defined(_WIN32)
  if (error_code == ERROR_WEBCAM_IN_USE) {
    // Device is in use by another application - this is a fatal error on Windows
    safe_fprintf(stderr, "\n");
    safe_fprintf(stderr, "Webcam is already in use by another application.\n");
    safe_fprintf(stderr, "Windows allows only one application to access the webcam at a time.\n");
    safe_fprintf(stderr, "\n");
    safe_fprintf(stderr, "To use ascii-chat with multiple clients, try these alternatives:\n");
    safe_fprintf(stderr, "  --test-pattern    Generate a colorful test pattern instead of using webcam\n");
    safe_fprintf(stderr, "  --file VIDEO.mp4  Use a video file as input (to be implemented)\n");
    safe_fprintf(stderr, "\n");
    safe_fprintf(stderr, "Example: ascii-chat client --test-pattern\n");
    (void)fflush(stderr);
  } else {
    // Other webcam errors - general failure
    safe_fprintf(stderr, "\n");
    safe_fprintf(stderr, "On Windows, this might be because:\n");
    safe_fprintf(stderr, "* Camera permissions are not granted\n");
    safe_fprintf(stderr, "* Camera driver issues\n");
    safe_fprintf(stderr, "* No webcam device found\n");
    (void)fflush(stderr);
  }
#else
  // Unknown platform
  (void)error_code;
  safe_fprintf(stderr, "\nWebcam initialization failed on unsupported platform.\n");
  (void)fflush(stderr);
#endif
}
 
// Fallback implementations for unsupported platforms
#if !defined(__linux__) && !defined(__APPLE__) && !defined(_WIN32)
asciichat_error_t webcam_init_context(webcam_context_t **ctx, unsigned short int device_index) {
  (void)ctx;
  (void)device_index;
  SET_ERRNO(ERROR_WEBCAM, "Webcam platform not supported on this system");
  return ERROR_WEBCAM;
}
 
void webcam_cleanup_context(webcam_context_t *ctx) {
  (void)ctx;
  log_warn("Webcam cleanup called on unsupported platform");
}
 
void webcam_flush_context(webcam_context_t *ctx) {
  (void)ctx;
  // No-op on unsupported platforms
}
 
image_t *webcam_read_context(webcam_context_t *ctx) {
  (void)ctx;
  SET_ERRNO(ERROR_WEBCAM, "Webcam read not supported on this platform");
  return NULL;
}
 
asciichat_error_t webcam_get_dimensions(webcam_context_t *ctx, int *width, int *height) {
  (void)ctx;
  (void)width;
  (void)height;
  return SET_ERRNO(ERROR_WEBCAM, "Webcam get dimensions not supported on this platform");
}
 
asciichat_error_t webcam_list_devices(webcam_device_info_t **out_devices, unsigned int *out_count) {
  if (out_devices)
    *out_devices = NULL;
  if (out_count)
    *out_count = 0;
  return SET_ERRNO(ERROR_WEBCAM, "Webcam device enumeration not supported on this platform");
}
 
void webcam_free_device_list(webcam_device_info_t *devices) {
  (void)devices;
  // No-op on unsupported platforms
}
#endif