video_frame.c

Go to the documentation of this file.

 
#include <ascii-chat/video/rgba/video_frame.h>
#include <ascii-chat/common.h>
#include <ascii-chat/asciichat_errno.h> // For asciichat_errno system
#include <ascii-chat/debug/named.h>
#include <ascii-chat/buffer_pool.h>
#include <ascii-chat/util/time.h>
#include <string.h>
#include <stdlib.h>
 
video_frame_buffer_t *video_frame_buffer_create(const char *client_id) {
  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 *);
 
  // Copy client_id string - we own this memory now
  // (caller's client_id may be a stack variable that goes out of scope)
  size_t client_id_len = strlen(client_id) + 1;
  char *client_id_copy = SAFE_MALLOC(client_id_len, char *);
  if (!client_id_copy) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate memory for client_id copy");
    SAFE_FREE(vfb);
    return NULL;
  }
  asciichat_error_t strcpy_result = SAFE_STRCPY(client_id_copy, client_id_len, client_id);
  if (strcpy_result != ASCIICHAT_OK) {
    log_error("Failed to copy client_id: %s", asciichat_error_string(strcpy_result));
    SAFE_FREE(client_id_copy);
    SAFE_FREE(vfb);
    return NULL;
  }
  vfb->client_id = client_id_copy;
  vfb->active = true;
 
  // Initialize double buffers
  vfb->front_buffer = &vfb->frames[0];
  vfb->back_buffer = &vfb->frames[1];
 
  // DEBUG: Log buffer initialization
  log_info("VFB_INIT: vfb=%p, vfb->frames=%p, &frames[0]=%p, &frames[1]=%p, setting back_buffer=%p", (void *)vfb,
           (void *)vfb->frames, (void *)&vfb->frames[0], (void *)&vfb->frames[1], (void *)vfb->back_buffer);
 
  // 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();
 
  log_info("VFB_ALLOC_START: client_id=%s, frame_size=%zu (2MB=%zu), pool=%p", client_id, frame_size,
           (size_t)(2 * 1024 * 1024), (void *)pool);
 
  // 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;
 
  // Initialize allocated_buffer_size to 0 - will be set AFTER successful allocation
  vfb->allocated_buffer_size = 0;
 
  // Attempt pool allocation
  if (pool) {
    vfb->frames[0].data = buffer_pool_alloc(pool, frame_size);
    vfb->frames[1].data = buffer_pool_alloc(pool, frame_size);
    log_info("VFB_POOL_ALLOC: frame[0].data=%p, frame[1].data=%p (from pool)", (void *)vfb->frames[0].data,
             (void *)vfb->frames[1].data);
  } else {
    log_warn("VFB_NO_POOL: pool is NULL, will use malloc fallback");
  }
 
  // Fallback to aligned malloc if pool allocation failed or returned undersized buffer
  // Note: buffer_pool_alloc may return undersized buffers if pool is exhausted and falls back to SAFE_MALLOC
  if (!vfb->frames[0].data || !vfb->frames[1].data) {
    log_info("VFB_MALLOC_FALLBACK: frame[0]=%s, frame[1]=%s", vfb->frames[0].data ? "OK" : "allocating",
             vfb->frames[1].data ? "OK" : "allocating");
    // 64-byte cache-line alignment improves performance for large video frames
    // CRITICAL: Always use SAFE_MALLOC_ALIGNED for fallback to guarantee minimum size and alignment
    if (!vfb->frames[0].data) {
      vfb->frames[0].data = SAFE_MALLOC_ALIGNED(frame_size, 64, void *);
      if (vfb->frames[0].data) {
        log_info("VFB_MALLOC_FRAME0: allocated %zu bytes with 64-byte alignment", frame_size);
      }
    }
    if (!vfb->frames[1].data) {
      vfb->frames[1].data = SAFE_MALLOC_ALIGNED(frame_size, 64, void *);
      if (vfb->frames[1].data) {
        log_info("VFB_MALLOC_FRAME1: allocated %zu bytes with 64-byte alignment", frame_size);
      }
    }
    log_info("VFB_MALLOC_RESULT: frame[0].data=%p, frame[1].data=%p (allocated with malloc)",
             (void *)vfb->frames[0].data, (void *)vfb->frames[1].data);
  }
 
  // CRITICAL: Only set allocated_buffer_size after BOTH buffers are successfully allocated
  // This prevents claiming 2MB buffers when actual allocation failed or returned smaller buffers
  if (!vfb->frames[0].data || !vfb->frames[1].data) {
    log_error("VFB_ALLOC_FAILED: frame[0].data=%p, frame[1].data=%p (cannot create frame buffer)",
              (void *)vfb->frames[0].data, (void *)vfb->frames[1].data);
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate video frame buffers");
    video_frame_buffer_destroy(vfb);
    return NULL;
  }
 
  // CRITICAL: Verify we actually got 2MB buffers, not undersized fallbacks
  // The buffer pool may return undersized buffers if exhausted, but we REQUIRE full-sized allocations
  // Do this by checking if allocations came from fallback or if pool returned a pointer we got
  // Since we can't check actual size from buffer_pool_alloc(), we enforce that both allocations succeeded
  // and use SAFE_MALLOC_ALIGNED as fallback which guarantees correct size
 
  // After our allocation logic above:
  // - Pool allocations go through buffer_pool_alloc (may be undersized)
  // - Fallback allocations use SAFE_MALLOC_ALIGNED (guaranteed 2MB)
  // We verify BOTH succeeded with the fallback already ensuring size
 
  vfb->allocated_buffer_size = frame_size; // Set to requested size
 
  log_info("VFB_ALLOC_FINAL: allocated_buffer_size=%zu (requested=%zu), frame[0].data=%p, frame[1].data=%p",
           vfb->allocated_buffer_size, frame_size, (void *)vfb->frames[0].data, (void *)vfb->frames[1].data);
 
  log_info("VFB_ALLOC_SUCCESS: client_id=%s, allocated_buffer_size=%zu, frames[0].data=%p, frames[1].data=%p",
           client_id, vfb->allocated_buffer_size, (void *)vfb->frames[0].data, (void *)vfb->frames[1].data);
 
  // 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
  log_info("VFB_MUTEX_INIT_START: About to init mutex for client_id=%s", client_id);
  if (mutex_init(&vfb->swap_mutex, "video_frame_swap") != 0) {
    log_error("VFB_MUTEX_INIT_FAILED: mutex_init returned error");
    SET_ERRNO(ERROR_PLATFORM_INIT, "Failed to initialize mutex for video frame buffer");
    video_frame_buffer_destroy(vfb);
    return NULL;
  }
  log_info("VFB_MUTEX_INIT_DONE: mutex initialized successfully");
  atomic_store_bool(&vfb->new_frame_available, false);
 
  // Initialize statistics
  atomic_store_u64(&vfb->total_frames_received, 0);
  atomic_store_u64(&vfb->total_frames_dropped, 0);
  atomic_store_u64(&vfb->last_frame_sequence, 0);
 
  log_debug("Created video frame buffer for client %u with double buffering", client_id);
 
  // DEBUG: Final state check
  log_info("VFB_FINAL: vfb=%p, back_buffer=%p (should be %p), frames[0].data=%p, frames[1].data=%p, allocated_size=%zu",
           (void *)vfb, (void *)vfb->back_buffer, (void *)&vfb->frames[1], (void *)vfb->frames[0].data,
           (void *)vfb->frames[1].data, vfb->allocated_buffer_size);
 
  NAMED_REGISTER_VIDEO_FRAME_BUFFER(vfb, "buffer", NULL);
 
  // Register atomic fields with descriptive names - vfb is their parent
  NAMED_REGISTER_ATOMIC(&vfb->new_frame_available, "new_frame_available_flag", (uintptr_t)(const void *)(vfb));
  NAMED_REGISTER_ATOMIC(&vfb->total_frames_received, "total_frames_received_counter", (uintptr_t)(const void *)(vfb));
  NAMED_REGISTER_ATOMIC(&vfb->total_frames_dropped, "total_frames_dropped_counter", (uintptr_t)(const void *)(vfb));
  NAMED_REGISTER_ATOMIC(&vfb->last_frame_sequence, "last_frame_sequence_number", (uintptr_t)(const void *)(vfb));
 
  return vfb;
}
 
void video_frame_buffer_destroy(video_frame_buffer_t *vfb) {
  if (!vfb) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Video frame buffer is NULL");
    return;
  }
 
  NAMED_UNREGISTER(vfb);
 
  // Unregister atomic fields
  NAMED_UNREGISTER(&vfb->new_frame_available);
  NAMED_UNREGISTER(&vfb->total_frames_received);
  NAMED_UNREGISTER(&vfb->total_frames_dropped);
  NAMED_UNREGISTER(&vfb->last_frame_sequence);
 
  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);
 
  // Free the allocated client_id string
  SAFE_FREE(vfb->client_id);
 
  SAFE_FREE(vfb);
}
 
video_frame_t *video_frame_begin_write(video_frame_buffer_t *vfb) {
  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;
}
 
void video_frame_commit(video_frame_buffer_t *vfb) {
  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;
  }
 
  // Keep the unread check, pointer swap, and publication atomic with respect
  // to readers. Checking front_buffer before taking this mutex races with a
  // reader consuming the previous frame and with another commit swapping it.
  mutex_lock(&vfb->swap_mutex);
  if (atomic_load_bool(&vfb->new_frame_available) && vfb->front_buffer->size > 0) {
    uint64_t drops = atomic_fetch_add_u64(&vfb->total_frames_dropped, 1) + 1;
    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);
    }
  }
  video_frame_t *temp = vfb->front_buffer;
  vfb->front_buffer = vfb->back_buffer;
  vfb->back_buffer = temp;
  atomic_store_bool(&vfb->new_frame_available, true);
  mutex_unlock(&vfb->swap_mutex);
 
  atomic_fetch_add_u64(&vfb->total_frames_received, 1);
}
 
const video_frame_t *video_frame_get_latest(video_frame_buffer_t *vfb) {
  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;
  }
 
  mutex_lock(&vfb->swap_mutex);
  if (!atomic_load_bool(&vfb->new_frame_available)) {
    mutex_unlock(&vfb->swap_mutex);
    return NULL;
  }
  atomic_store_bool(&vfb->new_frame_available, false);
  const video_frame_t *result = vfb->front_buffer;
  mutex_unlock(&vfb->swap_mutex);
 
  return result;
}
 
const video_frame_t *video_frame_peek_latest(video_frame_buffer_t *vfb) {
  if (!vfb || !vfb->active)
    return NULL;
  mutex_lock(&vfb->swap_mutex);
  const video_frame_t *frame = vfb->front_buffer;
  const video_frame_t *result = frame && frame->size > 0 ? frame : NULL;
  mutex_unlock(&vfb->swap_mutex);
  return result;
}
 
void video_frame_get_stats(video_frame_buffer_t *vfb, video_frame_stats_t *stats) {
  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_u64(&vfb->total_frames_received);
  stats->dropped_frames = atomic_load_u64(&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_u64(&vfb->avg_decode_time_ns);
  stats->avg_render_time_ns = atomic_load_u64(&vfb->avg_render_time_ns);
}
 
// Simple frame swap implementation for basic cases
simple_frame_swap_t *simple_frame_swap_create(void) {
  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_u64(&sfs->current_frame, 0);
  atomic_store_bool(&sfs->use_frame_a, false); // Next write goes to frame_b
 
  return sfs;
}
 
void simple_frame_swap_destroy(simple_frame_swap_t *sfs) {
  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);
}
 
void simple_frame_swap_update(simple_frame_swap_t *sfs, const void *data, size_t size) {
  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_bool(&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_u64(&sfs->current_frame, (uintptr_t)write_frame);
 
    // Toggle for next write
    atomic_store_bool(&sfs->use_frame_a, !use_a);
  }
}
 
const video_frame_t *simple_frame_swap_get(simple_frame_swap_t *sfs) {
  if (!sfs) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Simple frame swap is NULL");
    return NULL;
  }
  uintptr_t frame_ptr = atomic_load_u64(&sfs->current_frame);
  return (const video_frame_t *)(void *)frame_ptr; // NOLINT(bugprone-casting-through-void,performance-no-int-to-ptr)
}