webcam.c File Reference

Go to the source code of this file.

Functions
asciichat_error_t	webcam_init (unsigned short int webcam_index)
image_t *	webcam_read (void)
void	webcam_destroy (void)
void	webcam_flush (void)
void	webcam_print_init_error_help (asciichat_error_t error_code)
asciichat_error_t	webcam_init_context (webcam_context_t **ctx, unsigned short int device_index)
void	webcam_cleanup_context (webcam_context_t *ctx)
void	webcam_flush_context (webcam_context_t *ctx)
image_t *	webcam_read_context (webcam_context_t *ctx)
asciichat_error_t	webcam_get_dimensions (webcam_context_t *ctx, int *width, int *height)
asciichat_error_t	webcam_list_devices (webcam_device_info_t **out_devices, unsigned int *out_count)
void	webcam_free_device_list (webcam_device_info_t *devices)

Function Documentation

webcam_cleanup_context()

void webcam_cleanup_context

(

webcam_context_t *

ctx

)

Definition at line 246 of file video/webcam/webcam.c.

                                                   {
  (void)ctx;
  log_warn("Webcam cleanup called on unsupported platform");
}

Referenced by media_source_destroy(), and webcam_destroy().

webcam_destroy()

void webcam_destroy

(

void

)

Definition at line 131 of file video/webcam/webcam.c.

                          {
  // Free cached webcam frame if it was allocated (from test pattern or real webcam)
  if (cached_webcam_frame) {
    image_destroy(cached_webcam_frame);
    cached_webcam_frame = NULL;
  }
 
  if (GET_OPTION(test_pattern)) {
    log_debug("Test pattern mode - webcam context cleanup skipped");
    return;
  }
 
  if (global_webcam_ctx) {
    webcam_cleanup_context(global_webcam_ctx);
    global_webcam_ctx = NULL;
    // log_info("Webcam resources released");
  } else {
    log_dev("Webcam was not opened, nothing to release");
  }
}

References image_destroy(), and webcam_cleanup_context().

Referenced by ascii_read_destroy(), asciichat_shared_destroy(), and session_client_like_run().

webcam_flush()

void webcam_flush

(

void

)

Definition at line 152 of file video/webcam/webcam.c.

                        {
  if (GET_OPTION(test_pattern)) {
    return; // Test pattern doesn't need flushing
  }
 
  if (global_webcam_ctx) {
    webcam_flush_context(global_webcam_ctx);
  }
}

References webcam_flush_context().

webcam_flush_context()

void webcam_flush_context

(

webcam_context_t *

ctx

)

Definition at line 251 of file video/webcam/webcam.c.

                                                 {
  (void)ctx;
  // No-op on unsupported platforms
}

Referenced by webcam_flush().

webcam_free_device_list()

void webcam_free_device_list

(

webcam_device_info_t *

devices

)

Definition at line 277 of file video/webcam/webcam.c.

                                                            {
  (void)devices;
  // No-op on unsupported platforms
}

webcam_get_dimensions()

asciichat_error_t webcam_get_dimensions	(	webcam_context_t *	ctx,
		int *	width,
		int *	height
	)

Definition at line 262 of file video/webcam/webcam.c.

                                                                                        {
  (void)ctx;
  (void)width;
  (void)height;
  return SET_ERRNO(ERROR_WEBCAM, "Webcam get dimensions not supported on this platform");
}

Referenced by webcam_init().

webcam_init()

asciichat_error_t webcam_init

(

unsigned short int

webcam_index

)

Definition at line 20 of file video/webcam/webcam.c.

                                                               {
  // 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: 320x240");
    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;
}

References webcam_get_dimensions(), and webcam_init_context().

Referenced by ascii_read_init().

webcam_init_context()

asciichat_error_t webcam_init_context	(	webcam_context_t **	ctx,
		unsigned short int	device_index
	)

Definition at line 239 of file video/webcam/webcam.c.

                                                                                               {
  (void)ctx;
  (void)device_index;
  SET_ERRNO(ERROR_WEBCAM, "Webcam platform not supported on this system");
  return ERROR_WEBCAM;
}

Referenced by media_source_create(), and webcam_init().

webcam_list_devices()

asciichat_error_t webcam_list_devices	(	webcam_device_info_t **	out_devices,
		unsigned int *	out_count
	)

Definition at line 269 of file video/webcam/webcam.c.

                                                                                                   {
  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");
}

webcam_print_init_error_help()

void webcam_print_init_error_help

(

asciichat_error_t

error_code

)

Definition at line 162 of file video/webcam/webcam.c.

                                                                {
  // 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
}

References error_code, and safe_fprintf().

Referenced by client_main().

webcam_read()

image_t * webcam_read

(

void

)

Definition at line 59 of file video/webcam/webcam.c.

                           {
  // Check if test pattern mode is enabled
  if (GET_OPTION(test_pattern)) {
    // Allocate cached frame once (like FFmpeg's current_image)
    // Reuse same buffer for each call to avoid repeated allocations
    if (!cached_webcam_frame) {
      cached_webcam_frame = image_new(320, 240);
      if (!cached_webcam_frame) {
        SET_ERRNO(ERROR_MEMORY, "Failed to allocate test pattern frame");
        return NULL;
      }
    }
 
    // Generate animated test pattern each frame
    // Animation is based on frame counter, respects FPS setting
    unsigned int animation_phase = frame_counter / 2; // Slow down animation
    frame_counter++;
 
    for (int y = 0; y < cached_webcam_frame->h; y++) {
      for (int x = 0; x < cached_webcam_frame->w; x++) {
        rgb_pixel_t *pixel = &cached_webcam_frame->pixels[y * cached_webcam_frame->w + x];
 
        // Animated color bars that shift based on frame counter
        int animated_x = (x + animation_phase) % cached_webcam_frame->w;
        int grid_x = animated_x / 40;
 
        // Base pattern: color bars that animate horizontally
        switch (grid_x % 3) {
        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
        default:
          pixel->r = 0;
          pixel->g = 0;
          pixel->b = 255;
          break;
        }
 
        // Add animated grid lines
        if (animated_x % 40 == 0 || y % 30 == 0) {
          pixel->r = 0;
          pixel->g = 0;
          pixel->b = 0;
        }
      }
    }
 
    return cached_webcam_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;
  }
 
  return frame;
}

References image_new(), and webcam_read_context().

Referenced by media_source_read_video().

webcam_read_context()

image_t * webcam_read_context

(

webcam_context_t *

ctx

)

Definition at line 256 of file video/webcam/webcam.c.

                                                    {
  (void)ctx;
  SET_ERRNO(ERROR_WEBCAM, "Webcam read not supported on this platform");
  return NULL;
}

Referenced by media_source_read_video(), and webcam_read().