video_frame.c File Reference

🎬 Video frame buffer management for client-specific ASCII rendering More...

Go to the source code of this file.

Functions
video_frame_buffer_t *	video_frame_buffer_create (uint32_t client_id)
void	video_frame_buffer_destroy (video_frame_buffer_t *vfb)
video_frame_t *	video_frame_begin_write (video_frame_buffer_t *vfb)
void	video_frame_commit (video_frame_buffer_t *vfb)
const video_frame_t *	video_frame_get_latest (video_frame_buffer_t *vfb)
void	video_frame_get_stats (video_frame_buffer_t *vfb, video_frame_stats_t *stats)
simple_frame_swap_t *	simple_frame_swap_create (void)
void	simple_frame_swap_destroy (simple_frame_swap_t *sfs)
void	simple_frame_swap_update (simple_frame_swap_t *sfs, const void *data, size_t size)
const video_frame_t *	simple_frame_swap_get (simple_frame_swap_t *sfs)

Detailed Description

🎬 Video frame buffer management for client-specific ASCII rendering

Definition in file video_frame.c.

Function Documentation

simple_frame_swap_create()

simple_frame_swap_t * simple_frame_swap_create

(

void

)

Definition at line 204 of file video_frame.c.

                                                    {
  simple_frame_swap_t *sfs = SAFE_CALLOC(1, sizeof(simple_frame_swap_t), simple_frame_swap_t *);
 
  // Pre-allocate both frames
  const size_t frame_size = (size_t)MAX_FRAME_BUFFER_SIZE;
  sfs->frame_a.data = SAFE_MALLOC(frame_size, void *);
  sfs->frame_b.data = SAFE_MALLOC(frame_size, void *);
 
  atomic_store(&sfs->current_frame, (uintptr_t)&sfs->frame_a);
  atomic_store(&sfs->use_frame_a, false); // Next write goes to frame_b
 
  return sfs;
}

simple_frame_swap_destroy()

void simple_frame_swap_destroy

(

simple_frame_swap_t *

sfs

)

Definition at line 218 of file video_frame.c.

                                                         {
  if (!sfs) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Simple frame swap is NULL");
    return;
  }
  SAFE_FREE(sfs->frame_a.data);
  SAFE_FREE(sfs->frame_b.data);
  SAFE_FREE(sfs);
}

simple_frame_swap_get()

const video_frame_t * simple_frame_swap_get

(

simple_frame_swap_t *

sfs

)

Definition at line 252 of file video_frame.c.

                                                                     {
  if (!sfs) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Simple frame swap is NULL");
    return NULL;
  }
  uintptr_t frame_ptr = atomic_load(&sfs->current_frame);
  return (const video_frame_t *)(void *)frame_ptr; // NOLINT(bugprone-casting-through-void,performance-no-int-to-ptr)
}

simple_frame_swap_update()

void simple_frame_swap_update	(	simple_frame_swap_t *	sfs,
		const void *	data,
		size_t	size
	)

Definition at line 228 of file video_frame.c.

                                                                                       {
  if (!sfs || !data) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Simple frame swap or data is NULL");
    return;
  }
 
  // Determine which frame to write to
  bool use_a = atomic_load(&sfs->use_frame_a);
  video_frame_t *write_frame = use_a ? &sfs->frame_a : &sfs->frame_b;
 
  // Copy data to write frame
  if (size <= (size_t)MAX_FRAME_BUFFER_SIZE) {
    SAFE_MEMCPY(write_frame->data, size, data, size);
    write_frame->size = size;
    write_frame->capture_timestamp_ns = time_get_ns();
 
    // Atomically update current frame pointer
    atomic_store(&sfs->current_frame, (uintptr_t)write_frame);
 
    // Toggle for next write
    atomic_store(&sfs->use_frame_a, !use_a);
  }
}

References time_get_ns().

video_frame_begin_write()

video_frame_t * video_frame_begin_write

(

video_frame_buffer_t *

vfb

)

Definition at line 113 of file video_frame.c.

                                                                  {
  if (!vfb) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Video frame buffer is NULL");
    return NULL;
  }
  if (!vfb->active) {
    SET_ERRNO(ERROR_INVALID_STATE, "vfb->active is not true");
    return NULL;
  }
 
  // Writer always owns the back buffer
  return vfb->back_buffer;
}

Referenced by client_video_render_thread(), and handle_image_frame_packet().

video_frame_buffer_create()

video_frame_buffer_t * video_frame_buffer_create

(

uint32_t

client_id

)

Definition at line 16 of file video_frame.c.

                                                                    {
  if (client_id == 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Client ID is 0");
    return NULL;
  }
 
  video_frame_buffer_t *vfb = SAFE_CALLOC(1, sizeof(video_frame_buffer_t), video_frame_buffer_t *);
 
  vfb->client_id = client_id;
  vfb->active = true;
 
  // Initialize double buffers
  vfb->front_buffer = &vfb->frames[0];
  vfb->back_buffer = &vfb->frames[1];
 
  // Pre-allocate frame data buffers (2MB each for HD video)
  const size_t frame_size = (size_t)MAX_FRAME_BUFFER_SIZE;
  buffer_pool_t *pool = buffer_pool_get_global();
 
  // Initialize frames - size starts at 0 until actual data is written!
  vfb->frames[0].size = 0; // Start with 0 - will be set when data is written
  vfb->frames[1].size = 0; // Start with 0 - will be set when data is written
  vfb->frames[0].data = NULL;
  vfb->frames[1].data = NULL;
 
  // Store the allocated buffer size for cleanup (different from data size!)
  vfb->allocated_buffer_size = frame_size;
 
  if (pool) {
    vfb->frames[0].data = buffer_pool_alloc(pool, frame_size);
    vfb->frames[1].data = buffer_pool_alloc(pool, frame_size);
  }
 
  if (!vfb->frames[0].data || !vfb->frames[1].data) {
    // Fallback to aligned malloc if pool is exhausted or not available
    // 64-byte cache-line alignment improves performance for large video frames
    if (!vfb->frames[0].data)
      vfb->frames[0].data = SAFE_MALLOC_ALIGNED(frame_size, 64, void *);
    if (!vfb->frames[1].data)
      vfb->frames[1].data = SAFE_MALLOC_ALIGNED(frame_size, 64, void *);
  }
 
  // When buffers are allocated from the pool, they may contain leftover data from previous clients
  // This ensures frames with size=0 are truly empty, preventing ghost frames during reconnection
  if (vfb->frames[0].data) {
    memset(vfb->frames[0].data, 0, frame_size);
  }
  if (vfb->frames[1].data) {
    memset(vfb->frames[1].data, 0, frame_size);
  }
 
  // Initialize synchronization
  if (mutex_init(&vfb->swap_mutex) != 0) {
    SET_ERRNO(ERROR_PLATFORM_INIT, "Failed to initialize mutex for video frame buffer");
    video_frame_buffer_destroy(vfb);
    return NULL;
  }
  atomic_store(&vfb->new_frame_available, false);
 
  // Initialize statistics
  atomic_store(&vfb->total_frames_received, 0);
  atomic_store(&vfb->total_frames_dropped, 0);
  atomic_store(&vfb->last_frame_sequence, 0);
 
  log_debug("Created video frame buffer for client %u with double buffering", client_id);
  return vfb;
}

References buffer_pool_alloc(), buffer_pool_get_global(), mutex_init(), and video_frame_buffer_destroy().

Referenced by add_client(), and add_webrtc_client().

video_frame_buffer_destroy()

void video_frame_buffer_destroy

(

video_frame_buffer_t *

vfb

)

Definition at line 84 of file video_frame.c.

                                                           {
  if (!vfb) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Video frame buffer is NULL");
    return;
  }
 
  vfb->active = false;
 
  // Free frame data
  buffer_pool_t *pool = buffer_pool_get_global();
  if (vfb->frames[0].data) {
    if (pool) {
      buffer_pool_free(pool, vfb->frames[0].data, vfb->allocated_buffer_size);
    } else {
      SAFE_FREE(vfb->frames[0].data);
    }
  }
  if (vfb->frames[1].data) {
    if (pool) {
      buffer_pool_free(pool, vfb->frames[1].data, vfb->allocated_buffer_size);
    } else {
      SAFE_FREE(vfb->frames[1].data);
    }
  }
 
  mutex_destroy(&vfb->swap_mutex);
  SAFE_FREE(vfb);
}

References buffer_pool_free(), buffer_pool_get_global(), and mutex_destroy().

Referenced by add_client(), add_webrtc_client(), cleanup_client_media_buffers(), and video_frame_buffer_create().

video_frame_commit()

void video_frame_commit

(

video_frame_buffer_t *

vfb

)

Definition at line 127 of file video_frame.c.

                                                   {
  if (!vfb) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Video frame buffer or active is NULL");
    return;
  }
  if (!vfb->active) {
    SET_ERRNO(ERROR_INVALID_STATE, "vfb->active is not true");
    return;
  }
 
  // Check if reader has consumed the previous frame
  if (atomic_load(&vfb->new_frame_available)) {
    // Reader hasn't consumed yet - we're dropping a frame
    uint64_t drops = atomic_fetch_add(&vfb->total_frames_dropped, 1) + 1;
    // Throttle drop logging - only log every 100 drops to avoid spam
    if (drops == 1 || drops % 100 == 0) {
      log_dev_every(4500 * US_PER_MS_INT, "Dropping frame for client %u (reader too slow, total drops: %llu)",
                    vfb->client_id, (unsigned long long)drops);
    }
  }
 
  // Pointer swap using mutex for thread safety
  // The send thread reads front_buffer while render thread swaps
  // Without this mutex, the send thread could read a stale front_buffer pointer
  // mid-swap, causing it to see size=0 on newly-initialized frames
  mutex_lock(&vfb->swap_mutex);
  video_frame_t *temp = vfb->front_buffer;
  vfb->front_buffer = vfb->back_buffer;
  vfb->back_buffer = temp;
  mutex_unlock(&vfb->swap_mutex);
 
  // Signal reader that new frame is available
  atomic_store(&vfb->new_frame_available, true);
  atomic_fetch_add(&vfb->total_frames_received, 1);
}

Referenced by client_video_render_thread(), and handle_image_frame_packet().

video_frame_get_latest()

const video_frame_t * video_frame_get_latest

(

video_frame_buffer_t *

vfb

)

Definition at line 163 of file video_frame.c.

                                                                       {
  if (!vfb) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Video frame buffer is not active");
    return NULL;
  }
  if (!vfb->active) {
    SET_ERRNO(ERROR_INVALID_STATE, "vfb->active is not true");
    return NULL;
  }
 
  // Mark that we've consumed any new frame
  atomic_exchange(&vfb->new_frame_available, false);
 
  // Use mutex to safely read front_buffer pointer
  // (in case render thread is swapping)
  // This ensures we get a consistent pointer and don't read mid-swap
  mutex_lock(&vfb->swap_mutex);
  const video_frame_t *result = vfb->front_buffer;
  mutex_unlock(&vfb->swap_mutex);
 
  return result;
}

Referenced by client_send_thread_func().

video_frame_get_stats()

void video_frame_get_stats	(	video_frame_buffer_t *	vfb,
		video_frame_stats_t *	stats
	)

Definition at line 186 of file video_frame.c.

                                                                                  {
  if (!vfb || !stats) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Video frame buffer or stats is NULL");
    return;
  }
  if (!vfb->active) {
    SET_ERRNO(ERROR_INVALID_STATE, "vfb->active is not true");
    return;
  }
 
  stats->total_frames = atomic_load(&vfb->total_frames_received);
  stats->dropped_frames = atomic_load(&vfb->total_frames_dropped);
  stats->drop_rate = (stats->total_frames > 0) ? (float)stats->dropped_frames / (float)stats->total_frames : 0.0f;
  stats->avg_decode_time_ns = atomic_load(&vfb->avg_decode_time_ns);
  stats->avg_render_time_ns = atomic_load(&vfb->avg_render_time_ns);
}

Referenced by stats_logger_thread(), and update_server_stats().