client.h File Reference

Client-side H.265 media capture and encoding pipeline. More...

Go to the source code of this file.

Typedefs
typedef struct h265_client_encoder	h265_client_encoder_t

Enumerations
enum	h265_media_source_t { H265_SOURCE_TEST_PATTERN = 0 , H265_SOURCE_FILE = 1 , H265_SOURCE_URL = 2 , H265_SOURCE_WEBCAM = 3 }

Functions
h265_client_context_t *	h265_client_context_create (uint16_t width, uint16_t height)
void	h265_client_context_destroy (h265_client_context_t *ctx)
asciichat_error_t	h265_client_init_media_source (h265_client_context_t *ctx, h265_media_source_t source_type, const char *source_location)
asciichat_error_t	h265_client_capture_and_encode (h265_client_context_t *ctx, uint8_t *output_buf, size_t *output_size)
void	h265_client_request_keyframe (h265_client_context_t *ctx)
void	h265_client_get_stats (h265_client_context_t *ctx, uint64_t *total_frames, uint64_t *keyframes, uint32_t *avg_bitrate)

Detailed Description

Client-side H.265 media capture and encoding pipeline.

The client encodes media from various sources into H.265 and sends encoded frames to the server:

• Test pattern: Procedurally generated color grids
• File: Local video files (MP4, MKV, AVI, etc.) via FFmpeg
• URL: Remote streams (HTTP, RTSP, HLS, DASH, YouTube, etc.) via FFmpeg + yt-dlp
• Webcam: Live camera input via PortAudio/libwebsockets

Each media source is decoded to RGBA, then:

1. Converted to ASCII art via color-to-character mapping
2. Encoded to H.265 with h265_encoder
3. Sent to server in H.265 packets

Definition in file src/session/h265/client.h.

Typedef Documentation

h265_client_encoder_t

typedef struct h265_client_encoder h265_client_encoder_t

Definition at line 26 of file src/session/h265/client.h.

Enumeration Type Documentation

h265_media_source_t

enum h265_media_source_t

Media source type

Enumerator
H265_SOURCE_TEST_PATTERN
H265_SOURCE_FILE
H265_SOURCE_URL
H265_SOURCE_WEBCAM

Definition at line 31 of file src/session/h265/client.h.

             {
  H265_SOURCE_TEST_PATTERN = 0, // Procedural test pattern
  H265_SOURCE_FILE = 1,         // Local file
  H265_SOURCE_URL = 2,          // Remote URL (with yt-dlp support)
  H265_SOURCE_WEBCAM = 3,       // Live camera
} h265_media_source_t;

Function Documentation

h265_client_capture_and_encode()

asciichat_error_t h265_client_capture_and_encode	(	h265_client_context_t *	ctx,
		uint8_t *	output_buf,
		size_t *	output_size )

Capture and encode the next frame Reads from the media source, converts to ASCII, and encodes to H.265

Parameters

ctx	Client context
output_buf	Output buffer for H.265 packet
output_size	Input: buffer size, Output: actual packet size

Returns

Error code (ASCIICHAT_OK on success)

The output packet includes: [flags: u8][width: u16][height: u16][x265_data...] as defined in h265_encoder

Definition at line 124 of file src/session/h265/client.c.

                                                                                                                       {
  if (!ctx || !output_buf || !output_size) {
    return SET_ERRNO(ERROR_INTERNAL, "Invalid arguments to capture_and_encode");
  }
 
  if (!ctx->encoder) {
    return SET_ERRNO(ERROR_INTERNAL, "Encoder not initialized");
  }
 
  memset(ctx->frame_buf, 128, ctx->frame_buf_size);
 
  asciichat_error_t result =
      h265_encode(ctx->encoder, ctx->current_width, ctx->current_height, ctx->frame_buf, output_buf, output_size);
 
  return result;
}

References h265_client_context::current_height, h265_client_context::current_width, h265_client_context::encoder, ERROR_INTERNAL, h265_client_context::frame_buf, h265_client_context::frame_buf_size, h265_encode(), and SET_ERRNO.

h265_client_context_create()

h265_client_context_t * h265_client_context_create	(	uint16_t	width,
		uint16_t	height )

Create a client H.265 encoding context Initializes the encoder and media pipeline

Parameters

width	Initial frame width (characters)
height	Initial frame height (characters)

Returns

Context handle, or NULL on error

Definition at line 30 of file src/session/h265/client.c.

                                                                                   {
  if (width == 0 || height == 0) {
    SET_ERRNO(ERROR_MEDIA_INIT, "Frame dimensions must be non-zero");
    return NULL;
  }
  if ((size_t)width * height > SIZE_MAX / 3) {
    SET_ERRNO(ERROR_MEDIA_INIT, "RGB frame dimensions exceed addressable storage");
    return NULL;
  }
 
  h265_client_context_t *ctx = SAFE_CALLOC(1, sizeof(h265_client_context_t), h265_client_context_t *);
  if (!ctx) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate client context");
    return NULL;
  }
 
  ctx->encoder = h265_encoder_create(width, height);
  if (!ctx->encoder) {
    SET_ERRNO(ERROR_MEDIA_INIT, "Failed to create H.265 encoder");
    SAFE_FREE(ctx);
    return NULL;
  }
 
  ctx->current_width = width;
  ctx->current_height = height;
  ctx->frame_buf_size = (size_t)width * height * 3;
  ctx->frame_buf = SAFE_MALLOC(ctx->frame_buf_size, uint8_t *);
  if (!ctx->frame_buf) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate frame buffer");
    h265_encoder_destroy(ctx->encoder);
    SAFE_FREE(ctx);
    return NULL;
  }
 
  log_info("H.265 client context created: %ux%u", width, height);
  return ctx;
}

References h265_client_context::current_height, h265_client_context::current_width, h265_client_context::encoder, ERROR_MEDIA_INIT, ERROR_MEMORY, h265_client_context::frame_buf, h265_client_context::frame_buf_size, h265_encoder_create(), h265_encoder_destroy(), height, log_info, SAFE_CALLOC, SAFE_FREE, SAFE_MALLOC, SET_ERRNO, and width.

h265_client_context_destroy()

void h265_client_context_destroy

(

h265_client_context_t *

ctx

)

Destroy the client context and encoder

Parameters

ctx	Context to destroy (may be NULL)

Definition at line 68 of file src/session/h265/client.c.

                                                             {
  if (!ctx)
    return;
 
  if (ctx->encoder) {
    h265_encoder_destroy(ctx->encoder);
  }
  if (ctx->frame_buf) {
    SAFE_FREE(ctx->frame_buf);
  }
  if (ctx->source_location) {
    SAFE_FREE(ctx->source_location);
  }
  SAFE_FREE(ctx);
}

References h265_client_context::encoder, h265_client_context::frame_buf, h265_encoder_destroy(), SAFE_FREE, and h265_client_context::source_location.

h265_client_get_stats()

void h265_client_get_stats	(	h265_client_context_t *	ctx,
		uint64_t *	total_frames,
		uint64_t *	keyframes,
		uint32_t *	avg_bitrate )

Get encoder statistics

Parameters

ctx	Client context
total_frames	Output: total frames encoded
keyframes	Output: total keyframes encoded
avg_bitrate	Output: average bitrate in bits per second

Definition at line 147 of file src/session/h265/client.c.

                                                  {
  if (!ctx || !ctx->encoder)
    return;
 
  h265_encoder_get_stats(ctx->encoder, total_frames, keyframes, avg_bitrate);
}

References h265_client_context::encoder, and h265_encoder_get_stats().

h265_client_init_media_source()

asciichat_error_t h265_client_init_media_source	(	h265_client_context_t *	ctx,
		h265_media_source_t	source_type,
		const char *	source_location )

Initialize media source for the client encoder This prepares the media pipeline (opens file, connects to stream, etc.)

Parameters

ctx	Client context
source_type	Type of media source (file, URL, webcam, test pattern)
source_location	File path, URL, or device path (NULL for test pattern)

Returns

Error code (ASCIICHAT_OK on success)

Examples: h265_client_init_media_source(ctx, H265_SOURCE_FILE, "/path/to/video.mp4") h265_client_init_media_source(ctx, H265_SOURCE_URL, "https://www.youtube.com/watch?v=...") h265_client_init_media_source(ctx, H265_SOURCE_WEBCAM, "/dev/video0") h265_client_init_media_source(ctx, H265_SOURCE_TEST_PATTERN, NULL)

Definition at line 84 of file src/session/h265/client.c.

                                                                             {
  if (!ctx) {
    return SET_ERRNO(ERROR_INTERNAL, "Invalid client context");
  }
 
  ctx->source_type = source_type;
 
  if (source_location) {
    size_t source_len = strlen(source_location) + 1;
    ctx->source_location = SAFE_MALLOC(source_len, char *);
    if (!ctx->source_location) {
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate source location string");
    }
    asciichat_error_t strcpy_result = SAFE_STRCPY(ctx->source_location, source_len, source_location);
    if (strcpy_result != ASCIICHAT_OK) {
      log_error("Failed to copy source location string: %s", asciichat_error_format(NULL, strcpy_result));
      SAFE_FREE(ctx->source_location);
      return strcpy_result;
    }
  }
 
  switch (source_type) {
  case H265_SOURCE_TEST_PATTERN:
    log_info("H.265 client media source: test pattern");
    break;
  case H265_SOURCE_FILE:
    log_info("H.265 client media source: file '%s'", source_location);
    break;
  case H265_SOURCE_URL:
    log_info("H.265 client media source: URL '%s'", source_location);
    break;
  case H265_SOURCE_WEBCAM:
    log_info("H.265 client media source: webcam '%s'", source_location);
    break;
  }
 
  return ASCIICHAT_OK;
}

References asciichat_error_format(), ASCIICHAT_OK, ERROR_INTERNAL, ERROR_MEMORY, H265_SOURCE_FILE, H265_SOURCE_TEST_PATTERN, H265_SOURCE_URL, H265_SOURCE_WEBCAM, log_error, log_info, SAFE_FREE, SAFE_MALLOC, SAFE_STRCPY, SET_ERRNO, h265_client_context::source_location, and h265_client_context::source_type.

h265_client_request_keyframe()

void h265_client_request_keyframe

(

h265_client_context_t *

ctx

)

Request a keyframe on the next encode Used for error recovery and stream synchronization

Parameters

ctx	Client context

Definition at line 141 of file src/session/h265/client.c.

                                                              {
  if (ctx && ctx->encoder) {
    h265_encoder_request_keyframe(ctx->encoder);
  }
}

References h265_client_context::encoder, and h265_encoder_request_keyframe().