http_renderer.h File Reference

Go to the source code of this file.

Data Structures
struct	http_render_frame_t
struct	http_render_source_t
struct	http_render_options_t
struct	http_render_request_t
struct	http_render_result_t
struct	http_renderer_config_t
struct	http_renderer_process_request_t
struct	http_renderer_process_result_t
struct	http_renderer_job

Macros
#define	HTTP_RENDERER_MAX_OUTPUT   (8u * 1024u * 1024u)
#define	HTTP_RENDERER_MAX_FRAMES   120

Typedefs
typedef struct http_renderer	http_renderer_t
typedef struct http_renderer_job	http_renderer_job_t
typedef void(*	http_renderer_job_fn) (void *context, atomic_t *cancelled)

Enumerations
enum	http_render_source_type_t {   HTTP_RENDER_SOURCE_UPLOAD , HTTP_RENDER_SOURCE_FILE , HTTP_RENDER_SOURCE_URL , HTTP_RENDER_SOURCE_WEBCAM ,   HTTP_RENDER_SOURCE_VISUALIZATION }
enum	http_render_output_type_t {   HTTP_RENDER_OUTPUT_TEXT , HTTP_RENDER_OUTPUT_JSON , HTTP_RENDER_OUTPUT_HTML , HTTP_RENDER_OUTPUT_FILE ,   HTTP_RENDER_OUTPUT_FILES }

Functions
void	http_render_request_init (http_render_request_t *request)
void	http_render_result_destroy (http_render_result_t *result)
asciichat_error_t	http_render_result_add_text_frame (http_render_result_t *result, const char *text, size_t length, uint64_t timestamp_ms)
asciichat_error_t	http_render_result_add_file_frame (http_render_result_t *result, const char *path, uint64_t timestamp_ms)
void	http_renderer_process (http_renderer_process_request_t *request, atomic_t *cancelled, http_renderer_process_result_t *result)
void	http_renderer_process_result_destroy (http_renderer_process_result_t *result)
asciichat_error_t	http_renderer_render_file (const char *path, const http_render_request_t *request, http_render_result_t *result, atomic_t *cancelled)
asciichat_error_t	http_renderer_job_start (http_renderer_job_t *job, const char *name, http_renderer_job_fn execute, void *context)
void	http_renderer_job_cancel (http_renderer_job_t *job)
bool	http_renderer_job_is_done (const http_renderer_job_t *job)
void	http_renderer_job_join (http_renderer_job_t *job)
void	http_renderer_job_reset (http_renderer_job_t *job)
asciichat_error_t	http_renderer_init (http_renderer_t **out, const http_renderer_config_t *config)
asciichat_error_t	http_renderer_submit (http_renderer_t *renderer, const http_render_request_t *request, void *user_data, http_renderer_job_t **out_job)
asciichat_error_t	http_renderer_cancel (http_renderer_job_t *job)
void	http_renderer_reap (http_renderer_t *renderer, bool all)
void	http_renderer_stop (http_renderer_t *renderer)
void	http_renderer_destroy (http_renderer_t **renderer)
void	http_renderer_job_wait (http_renderer_job_t *job)

Macro Definition Documentation

HTTP_RENDERER_MAX_FRAMES

#define HTTP_RENDERER_MAX_FRAMES   120

Definition at line 30 of file http_renderer.h.

Referenced by http_renderer_render_file().

HTTP_RENDERER_MAX_OUTPUT

#define HTTP_RENDERER_MAX_OUTPUT   (8u * 1024u * 1024u)

Definition at line 13 of file http_renderer.h.

Referenced by http_renderer_init(), and http_renderer_process().

Typedef Documentation

http_renderer_job_fn

typedef void(* http_renderer_job_fn) (void *context, atomic_t *cancelled)

Definition at line 120 of file http_renderer.h.

http_renderer_job_t

typedef struct http_renderer_job http_renderer_job_t

Definition at line 80 of file http_renderer.h.

http_renderer_t

typedef struct http_renderer http_renderer_t

Definition at line 79 of file http_renderer.h.

Enumeration Type Documentation

http_render_output_type_t

enum http_render_output_type_t

Enumerator
HTTP_RENDER_OUTPUT_TEXT
HTTP_RENDER_OUTPUT_JSON
HTTP_RENDER_OUTPUT_HTML
HTTP_RENDER_OUTPUT_FILE
HTTP_RENDER_OUTPUT_FILES

Definition at line 22 of file http_renderer.h.

             {
  HTTP_RENDER_OUTPUT_TEXT,
  HTTP_RENDER_OUTPUT_JSON,
  HTTP_RENDER_OUTPUT_HTML,
  HTTP_RENDER_OUTPUT_FILE,
  HTTP_RENDER_OUTPUT_FILES
} http_render_output_type_t;

http_render_source_type_t

enum http_render_source_type_t

Enumerator
HTTP_RENDER_SOURCE_UPLOAD
HTTP_RENDER_SOURCE_FILE
HTTP_RENDER_SOURCE_URL
HTTP_RENDER_SOURCE_WEBCAM
HTTP_RENDER_SOURCE_VISUALIZATION

Definition at line 15 of file http_renderer.h.

             {
  HTTP_RENDER_SOURCE_UPLOAD,
  HTTP_RENDER_SOURCE_FILE,
  HTTP_RENDER_SOURCE_URL,
  HTTP_RENDER_SOURCE_WEBCAM,
  HTTP_RENDER_SOURCE_VISUALIZATION
} http_render_source_type_t;

Function Documentation

http_render_request_init()

void http_render_request_init

(

http_render_request_t *

request

)

Definition at line 216 of file http_renderer.c.

                                                              {
  if (!request)
    return;
  memset(request, 0, sizeof(*request));
  request->source.type = HTTP_RENDER_SOURCE_UPLOAD;
  request->output_type = HTTP_RENDER_OUTPUT_TEXT;
}

References HTTP_RENDER_OUTPUT_TEXT, HTTP_RENDER_SOURCE_UPLOAD, http_render_request_t::output_type, http_render_request_t::source, and http_render_source_t::type.

http_render_result_add_file_frame()

asciichat_error_t http_render_result_add_file_frame	(	http_render_result_t *	result,
		const char *	path,
		uint64_t	timestamp_ms )

Definition at line 270 of file http_renderer.c.

                                                                           {
  if (!result || !path || !*path)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid file frame");
  asciichat_error_t err = http_render_result_reserve_frame(result);
  if (err != ASCIICHAT_OK)
    return err;
  http_render_frame_t *frame = &result->frames[result->frame_count++];
  SAFE_STRNCPY(frame->path, path, sizeof(frame->path));
  frame->timestamp_ms = timestamp_ms;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, http_render_result_t::frame_count, http_render_result_t::frames, http_render_frame_t::path, SAFE_STRNCPY, SET_ERRNO, and http_render_frame_t::timestamp_ms.

Referenced by http_renderer_process().

http_render_result_add_text_frame()

asciichat_error_t http_render_result_add_text_frame	(	http_render_result_t *	result,
		const char *	text,
		size_t	length,
		uint64_t	timestamp_ms )

Definition at line 254 of file http_renderer.c.

                                                                           {
  if (!result || (!text && length))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid text frame");
  asciichat_error_t err = http_render_result_reserve_frame(result);
  if (err != ASCIICHAT_OK)
    return err;
  http_render_frame_t *frame = &result->frames[result->frame_count++];
  frame->text = SAFE_MALLOC(length + 1, char *);
  SAFE_MEMCPY(frame->text, length + 1, text, length);
  frame->text[length] = '\0';
  frame->text_length = length;
  frame->timestamp_ms = timestamp_ms;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, http_render_result_t::frame_count, http_render_result_t::frames, SAFE_MALLOC, SAFE_MEMCPY, SET_ERRNO, http_render_frame_t::text, http_render_frame_t::text_length, and http_render_frame_t::timestamp_ms.

Referenced by http_renderer_process(), and http_renderer_render_file().

http_render_result_destroy()

void http_render_result_destroy

(

http_render_result_t *

result

)

Definition at line 224 of file http_renderer.c.

                                                              {
  if (!result)
    return;
  SAFE_FREE(result->ascii);
  for (size_t i = 0; i < result->frame_count; ++i)
    SAFE_FREE(result->frames[i].text);
  SAFE_FREE(result->frames);
  result->frame_count = 0;
  result->frame_capacity = 0;
  result->ascii_length = 0;
  result->output_path[0] = '\0';
  result->mime_type[0] = '\0';
}

References http_render_result_t::ascii, http_render_result_t::ascii_length, http_render_result_t::frame_capacity, http_render_result_t::frame_count, http_render_result_t::frames, http_render_result_t::mime_type, http_render_result_t::output_path, SAFE_FREE, and http_render_frame_t::text.

Referenced by http_renderer_reap().

http_renderer_cancel()

asciichat_error_t http_renderer_cancel

(

http_renderer_job_t *

job

)

Definition at line 160 of file http_renderer.c.

                                                                 {
  if (!job || !job->renderer)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP renderer job");
  http_renderer_job_cancel(job);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, http_renderer_job_cancel(), http_renderer_job::renderer, and SET_ERRNO.

http_renderer_destroy()

void http_renderer_destroy

(

http_renderer_t **

renderer

)

Definition at line 206 of file http_renderer.c.

                                                       {
  if (!renderer || !*renderer)
    return;
  http_renderer_stop(*renderer);
  http_renderer_reap(*renderer, true);
  mutex_destroy(&(*renderer)->lock);
  SAFE_FREE(*renderer);
}

References http_renderer_reap(), http_renderer_stop(), and SAFE_FREE.

Referenced by api_server_main().

http_renderer_init()

asciichat_error_t http_renderer_init	(	http_renderer_t **	out,
		const http_renderer_config_t *	config )

Definition at line 108 of file http_renderer.c.

                                                                                                  {
  if (!out || !config)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing HTTP renderer configuration");
  *out = NULL;
  http_renderer_t *renderer = SAFE_CALLOC(1, sizeof(*renderer), http_renderer_t *);
  renderer->config = *config;
  if (!renderer->config.max_jobs)
    renderer->config.max_jobs = 1;
  if (!renderer->config.max_output_bytes)
    renderer->config.max_output_bytes = HTTP_RENDERER_MAX_OUTPUT;
  if (mutex_init(&renderer->lock, "http_renderer") != 0) {
    SAFE_FREE(renderer);
    return SET_ERRNO(ERROR_THREAD, "Cannot initialize HTTP renderer lock");
  }
  *out = renderer;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, http_renderer::config, ERROR_INVALID_PARAM, ERROR_THREAD, HTTP_RENDERER_MAX_OUTPUT, http_renderer::lock, http_renderer_config_t::max_jobs, http_renderer_config_t::max_output_bytes, out, SAFE_CALLOC, SAFE_FREE, and SET_ERRNO.

Referenced by api_server_main().

http_renderer_job_cancel()

void http_renderer_job_cancel

(

http_renderer_job_t *

job

)

Definition at line 61 of file http_renderer.c.

                                                        {
  if (job && job->started)
    atomic_store_bool(&job->cancelled, true);
}

References http_renderer_job::cancelled, and http_renderer_job::started.

Referenced by http_renderer_cancel(), http_renderer_stop(), mcp_dispatch(), mcp_http_run(), mcp_server_main(), and mcp_stdio_run().

http_renderer_job_is_done()

bool http_renderer_job_is_done

(

const http_renderer_job_t *

job

)

Definition at line 66 of file http_renderer.c.

                                                               {
  return job && job->started && atomic_load_bool((atomic_t *)&job->done);
}

References http_renderer_job::done, and http_renderer_job::started.

Referenced by http_renderer_reap(), and mcp_jobs_reap().

http_renderer_job_join()

void http_renderer_job_join

(

http_renderer_job_t *

job

)

Definition at line 70 of file http_renderer.c.

                                                      {
  if (job && job->started) {
    thread_join(&job->thread, NULL);
    job->started = false;
  }
}

References http_renderer_job::started, and http_renderer_job::thread.

Referenced by http_renderer_job_reset(), http_renderer_job_wait(), http_renderer_reap(), and mcp_jobs_reap().

http_renderer_job_reset()

void http_renderer_job_reset

(

http_renderer_job_t *

job

)

Definition at line 77 of file http_renderer.c.

                                                       {
  if (job) {
    http_renderer_job_join(job);
    memset(job, 0, sizeof(*job));
  }
}

References http_renderer_job_join().

http_renderer_job_start()

asciichat_error_t http_renderer_job_start	(	http_renderer_job_t *	job,
		const char *	name,
		http_renderer_job_fn	execute,
		void *	context )

Definition at line 46 of file http_renderer.c.

                                                         {
  if (!job || !execute || job->started)
    return SET_ERRNO(ERROR_INVALID_STATE, "Renderer job is already active");
  memset(job, 0, sizeof(*job));
  job->execute = execute;
  job->context = context;
  atomic_store_bool(&job->cancelled, false);
  atomic_store_bool(&job->done, false);
  if (platform_thread_create(&job->thread, name ? name : "http-render", http_renderer_job_main, job))
    return SET_ERRNO(ERROR_THREAD, "Cannot start renderer job");
  job->started = true;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, http_renderer_job::cancelled, http_renderer_job::context, http_renderer_job::done, ERROR_INVALID_STATE, ERROR_THREAD, http_renderer_job::execute, SET_ERRNO, http_renderer_job::started, and http_renderer_job::thread.

Referenced by mcp_dispatch().

http_renderer_job_wait()

void http_renderer_job_wait

(

http_renderer_job_t *

job

)

Definition at line 167 of file http_renderer.c.

                                                      {
  http_renderer_job_join(job);
}

References http_renderer_job_join().

http_renderer_process()

void http_renderer_process	(	http_renderer_process_request_t *	request,
		atomic_t *	cancelled,
		http_renderer_process_result_t *	result )

Definition at line 112 of file http_renderer_process.c.

                                                                   {
  memset(result, 0, sizeof(*result));
  if (r->output_type != HTTP_RENDER_OUTPUT_TEXT && r->output_type != HTTP_RENDER_OUTPUT_FILE) {
    SAFE_STRNCPY(result->error, "Renderer output must select text or files", sizeof(result->error));
    return;
  }
  render_worker_t w = {.cancelled = cancelled, .result = result, .started = time_get_ns(), .timeout = r->timeout_ms};
  result->text = SAFE_CALLOC(HTTP_RENDERER_MAX_OUTPUT + 1, 1, char *);
  if (uv_loop_init(&w.loop)) {
    SAFE_STRNCPY(result->error, "Cannot initialize renderer event loop", sizeof(result->error));
    return;
  }
  uv_pipe_init(&w.loop, &w.output, 0);
  uv_pipe_init(&w.loop, &w.errors, 0);
  uv_timer_init(&w.loop, &w.timer);
  w.output.data = w.errors.data = w.timer.data = w.process.data = &w;
  uv_stdio_container_t streams[3] = {0};
  streams[0].flags = UV_IGNORE;
  streams[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
  streams[1].data.stream = (uv_stream_t *)&w.output;
  streams[2].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
  streams[2].data.stream = (uv_stream_t *)&w.errors;
  // Only runtime essentials are inherited; user config, ASCII_CHAT_* and credentials are excluded.
  const char *keys[] = {
      "PATH", "SystemRoot", "WINDIR", "TEMP", "TMP", "TMPDIR", "LD_LIBRARY_PATH", "DYLD_LIBRARY_PATH", "TESTING", NULL};
  char *env[MCP_RENDER_ENV_CAPACITY] = {0};
  size_t ne = 0;
  for (size_t i = 0; keys[i]; ++i) {
    const char *v = platform_getenv(keys[i]);
    if (v) {
      size_t n = strlen(keys[i]) + strlen(v) + 2;
      env[ne] = SAFE_MALLOC(n, char *);
      SAFE_SNPRINTF(env[ne], n, "%s=%s", keys[i], v);
      ++ne;
    }
  }
  // The private staging directory provides an isolated home for media libraries.
  if (r->stage_dir[0]) {
    size_t n = strlen(r->stage_dir) + sizeof("HOME=");
    env[ne] = SAFE_MALLOC(n, char *);
    SAFE_SNPRINTF(env[ne], n, "HOME=%s", r->stage_dir);
    ++ne;
  }
  env[ne++] = platform_strdup("ASCII_CHAT_MCP_WORKER=1");
  env[ne++] = platform_strdup("ASCII_CHAT_OTEL_ENABLED_TELEMETRY=none");
  if (r->capture_webcam)
    env[ne++] = platform_strdup("ASCII_CHAT_MCP_WEBCAM=1");
  uv_process_options_t opts = {
      .exit_cb = exited, .file = r->argv[0], .args = r->argv, .env = env, .stdio_count = 3, .stdio = streams};
  int rc = uv_spawn(&w.loop, &w.process, &opts);
  for (size_t i = 0; i < ne; ++i)
    SAFE_FREE(env[i]);
  if (rc) {
    SAFE_SNPRINTF(result->error, sizeof(result->error), "Cannot start renderer: %s", uv_strerror(rc));
    uv_close((uv_handle_t *)&w.output, NULL);
    uv_close((uv_handle_t *)&w.errors, NULL);
    uv_close((uv_handle_t *)&w.timer, NULL);
  } else {
    uv_read_start((uv_stream_t *)&w.output, allocate, read_output);
    uv_read_start((uv_stream_t *)&w.errors, allocate, read_output);
    uv_timer_start(&w.timer, tick, 20, 20);
  }
  uv_run(&w.loop, UV_RUN_DEFAULT);
  uv_loop_close(&w.loop);
  result->elapsed_ms = (time_get_ns() - w.started) / 1000000;
  if (rc || w.failed)
    return;
  result->error[0] = '\0';
  if (!result->length && !r->stage_file[0]) {
    SAFE_STRNCPY(result->error, "Renderer returned no ASCII art", sizeof(result->error));
    return;
  }
  if (r->stage_file[0]) {
    uv_fs_t fs;
    int e = uv_fs_stat(NULL, &fs, r->stage_file, NULL);
    bool valid = e == 0 && fs.statbuf.st_size > 0;
    uv_fs_req_cleanup(&fs);
    if (!valid) {
      SAFE_STRNCPY(result->error, "Renderer did not create an output file", sizeof(result->error));
      return;
    }
    // Hard-link publication is atomic and fails if any file/symlink already owns the destination.
    // Staging beside the destination keeps this on the same filesystem.
    e = uv_fs_link(NULL, &fs, r->stage_file, r->output_path, NULL);
    uv_fs_req_cleanup(&fs);
    if (e) {
      SAFE_SNPRINTF(result->error, sizeof(result->error), "Cannot save without replacing an existing file: %s",
                    uv_strerror(e));
      return;
    }
    SAFE_STRNCPY(result->output_path, r->output_path, sizeof(result->output_path));
  }
  http_render_result_t frames = {0};
  if (result->text && result->length)
    (void)http_render_result_add_text_frame(&frames, result->text, result->length, 0);
  if (result->output_path[0])
    (void)http_render_result_add_file_frame(&frames, result->output_path, 0);
  result->frames = frames.frames;
  result->frame_count = frames.frame_count;
}

References http_renderer_process_request_t::argv, http_renderer_process_request_t::capture_webcam, http_renderer_process_result_t::elapsed_ms, http_renderer_process_result_t::error, render_worker_t::errors, render_worker_t::failed, http_render_result_t::frame_count, http_renderer_process_result_t::frame_count, http_render_result_t::frames, http_renderer_process_result_t::frames, HTTP_RENDER_OUTPUT_FILE, HTTP_RENDER_OUTPUT_TEXT, http_render_result_add_file_frame(), http_render_result_add_text_frame(), HTTP_RENDERER_MAX_OUTPUT, http_renderer_process_result_t::length, render_worker_t::loop, MCP_RENDER_ENV_CAPACITY, render_worker_t::output, http_renderer_process_request_t::output_path, http_renderer_process_result_t::output_path, http_renderer_process_request_t::output_type, platform_getenv(), render_worker_t::process, SAFE_CALLOC, SAFE_FREE, SAFE_MALLOC, SAFE_SNPRINTF, SAFE_STRNCPY, http_renderer_process_request_t::stage_dir, http_renderer_process_request_t::stage_file, render_worker_t::started, http_renderer_process_result_t::text, http_renderer_process_request_t::timeout_ms, render_worker_t::timer, and valid.

http_renderer_process_result_destroy()

void http_renderer_process_result_destroy

(

http_renderer_process_result_t *

result

)

Definition at line 214 of file http_renderer_process.c.

                                                                                  {
  if (!result)
    return;
  for (size_t i = 0; i < result->frame_count; ++i)
    SAFE_FREE(result->frames[i].text);
  SAFE_FREE(result->frames);
  SAFE_FREE(result->text);
  memset(result, 0, sizeof(*result));
}

References http_renderer_process_result_t::frame_count, http_renderer_process_result_t::frames, SAFE_FREE, http_render_frame_t::text, and http_renderer_process_result_t::text.

http_renderer_reap()

void http_renderer_reap	(	http_renderer_t *	renderer,
		bool	all )

Definition at line 171 of file http_renderer.c.

                                                             {
  if (!renderer)
    return;
  for (;;) {
    mutex_lock(&renderer->lock);
    http_renderer_job_t **link = &renderer->jobs;
    http_renderer_job_t *job = NULL;
    while (*link) {
      if (all || ((*link)->user_data == NULL && http_renderer_job_is_done(*link))) {
        job = *link;
        *link = job->next;
        --renderer->active_jobs;
        break;
      }
      link = &(*link)->next;
    }
    mutex_unlock(&renderer->lock);
    if (!job)
      return;
    http_renderer_job_join(job);
    http_render_result_destroy(&job->result);
    SAFE_FREE(job);
  }
}

References http_renderer::active_jobs, http_render_result_destroy(), http_renderer_job_is_done(), http_renderer_job_join(), http_renderer::jobs, http_renderer::lock, http_renderer_job::next, http_renderer_job::result, and SAFE_FREE.

Referenced by http_renderer_destroy().

http_renderer_render_file()

asciichat_error_t http_renderer_render_file	(	const char *	path,
		const http_render_request_t *	request,
		http_render_result_t *	result,
		atomic_t *	cancelled )

Definition at line 335 of file http_renderer.c.

                                                                                               {
  if (!path || !request || !result)
    return SET_ERRNO(ERROR_INVALID_PARAM, "HTTP render requires a source path, request, and result");
  memset(result, 0, sizeof(*result));
  uint64_t started = time_get_ns();
  ffmpeg_decoder_t *decoder = ffmpeg_decoder_create_interruptible(path, http_renderer_cancel_requested, cancelled);
  if (!decoder)
    return SET_ERRNO(ERROR_MEDIA_INIT, "Cannot decode uploaded image");
  if (ffmpeg_decoder_start_prefetch(decoder) != ASCIICHAT_OK) {
    ffmpeg_decoder_destroy(decoder);
    return SET_ERRNO(ERROR_MEDIA_INIT, "Cannot start image decoder");
  }
  image_t *image = NULL;
  uint64_t deadline = started + (request->timeout_ms ? request->timeout_ms : 10000) * NS_PER_MS_INT;
  for (;;) {
    if (cancelled && atomic_load_bool(cancelled)) {
      ffmpeg_decoder_destroy(decoder);
      result->cancelled = true;
      return SET_ERRNO(ERROR_INVALID_STATE, "HTTP image render cancelled");
    }
    asciichat_error_context_t failure = {0};
    ffmpeg_frame_status_t status = ffmpeg_decoder_poll_video(decoder, &image, &failure);
    if (status == FFMPEG_FRAME_READY)
      break;
    if (status == FFMPEG_FRAME_FAILED || status == FFMPEG_FRAME_EOF) {
      errno_import(&failure);
      ffmpeg_decoder_destroy(decoder);
      return SET_ERRNO(ERROR_MEDIA_INIT, "Uploaded data does not contain a decodable image");
    }
    if (time_get_ns() >= deadline) {
      ffmpeg_decoder_destroy(decoder);
      return SET_ERRNO(ERROR_MEDIA_DECODE, "Image decoding timed out");
    }
    platform_sleep_ms(1);
  }
  if (!image) {
    ffmpeg_decoder_destroy(decoder);
    return SET_ERRNO(ERROR_MEDIA_INIT, "Uploaded data does not contain a decodable image");
  }
  if (image->w > 8192 || image->h > 8192) {
    image_destroy(image);
    ffmpeg_decoder_destroy(decoder);
    return SET_ERRNO(ERROR_BUFFER_OVERFLOW, "Decoded image dimensions exceed the configured limit");
  }
  size_t total = 0;
  size_t limit = request->max_output_bytes ? request->max_output_bytes : 8u * 1024u * 1024u;
  for (;;) {
    if (image->w > 8192 || image->h > 8192) {
      image_destroy(image);
      ffmpeg_decoder_destroy(decoder);
      return SET_ERRNO(ERROR_BUFFER_OVERFLOW, "Decoded image dimensions exceed the configured limit");
    }
    char *ascii = http_renderer_render_image(image, request);
    image_destroy(image);
    if (!ascii) {
      ffmpeg_decoder_destroy(decoder);
      return SET_ERRNO(ERROR_MEDIA_INIT, "Cannot convert image to ASCII");
    }
    size_t length = strlen(ascii);
    if (length > limit - (total > limit ? limit : total)) {
      free(ascii);
      ffmpeg_decoder_destroy(decoder);
      return SET_ERRNO(ERROR_BUFFER_OVERFLOW, "Rendered output exceeds the configured limit");
    }
    if (http_render_result_add_text_frame(result, ascii, length, (time_get_ns() - started) / 1000000) != ASCIICHAT_OK) {
      free(ascii);
      ffmpeg_decoder_destroy(decoder);
      return SET_ERRNO(ERROR_BUFFER_OVERFLOW, "Cannot store rendered frame");
    }
    if (!result->ascii) {
      result->ascii = SAFE_MALLOC(length + 1, char *);
      SAFE_MEMCPY(result->ascii, length + 1, ascii, length + 1);
      result->ascii_length = length;
    }
    total += length;
    free(ascii);
    if (result->frame_count >= HTTP_RENDERER_MAX_FRAMES)
      break;
    if (cancelled && atomic_load_bool(cancelled)) {
      result->cancelled = true;
      ffmpeg_decoder_destroy(decoder);
      return SET_ERRNO(ERROR_INVALID_STATE, "HTTP image render cancelled");
    }
    asciichat_error_context_t failure = {0};
    image = NULL;
    ffmpeg_frame_status_t status = ffmpeg_decoder_poll_video(decoder, &image, &failure);
    if (status == FFMPEG_FRAME_EOF)
      break;
    if (status == FFMPEG_FRAME_FAILED) {
      ffmpeg_decoder_destroy(decoder);
      return SET_ERRNO(ERROR_MEDIA_INIT, "Video frame decoding failed");
    }
    while (status == FFMPEG_FRAME_WAITING) {
      if (time_get_ns() >= deadline) {
        ffmpeg_decoder_destroy(decoder);
        return SET_ERRNO(ERROR_MEDIA_DECODE, "Image decoding timed out");
      }
      platform_sleep_ms(1);
      status = ffmpeg_decoder_poll_video(decoder, &image, &failure);
    }
    if (!image)
      break;
  }
  ffmpeg_decoder_destroy(decoder);
  result->elapsed_ms = (time_get_ns() - started) / 1000000;
  return result->frame_count ? ASCIICHAT_OK : SET_ERRNO(ERROR_MEDIA_INIT, "Renderer returned no frames");
}

References http_render_result_t::ascii, http_render_result_t::ascii_length, ASCIICHAT_OK, http_render_result_t::cancelled, http_render_result_t::elapsed_ms, errno_import(), ERROR_BUFFER_OVERFLOW, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_MEDIA_DECODE, ERROR_MEDIA_INIT, ffmpeg_decoder_create_interruptible(), ffmpeg_decoder_destroy(), ffmpeg_decoder_poll_video(), ffmpeg_decoder_start_prefetch(), FFMPEG_FRAME_EOF, FFMPEG_FRAME_FAILED, FFMPEG_FRAME_READY, FFMPEG_FRAME_WAITING, http_render_result_t::frame_count, image_t::h, http_render_result_add_text_frame(), HTTP_RENDERER_MAX_FRAMES, image_destroy(), http_render_request_t::max_output_bytes, NS_PER_MS_INT, platform_sleep_ms(), SAFE_MALLOC, SAFE_MEMCPY, SET_ERRNO, http_render_request_t::timeout_ms, and image_t::w.

http_renderer_stop()

void http_renderer_stop

(

http_renderer_t *

renderer

)

Definition at line 196 of file http_renderer.c.

                                                   {
  if (!renderer)
    return;
  mutex_lock(&renderer->lock);
  renderer->stopping = true;
  for (http_renderer_job_t *job = renderer->jobs; job; job = job->next)
    http_renderer_job_cancel(job);
  mutex_unlock(&renderer->lock);
}

References http_renderer_job_cancel(), http_renderer::jobs, http_renderer::lock, http_renderer_job::next, and http_renderer::stopping.

Referenced by http_renderer_destroy().

http_renderer_submit()

asciichat_error_t http_renderer_submit	(	http_renderer_t *	renderer,
		const http_render_request_t *	request,
		void *	user_data,
		http_renderer_job_t **	out_job )

Definition at line 126 of file http_renderer.c.

                                                                      {
  if (!renderer || !request || !out_job)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP renderer submission");
  *out_job = NULL;
  mutex_lock(&renderer->lock);
  if (renderer->stopping || renderer->active_jobs >= renderer->config.max_jobs) {
    mutex_unlock(&renderer->lock);
    return SET_ERRNO(ERROR_BUFFER_FULL, "HTTP renderer has no available job capacity");
  }
  http_renderer_job_t *job = SAFE_CALLOC(1, sizeof(*job), http_renderer_job_t *);
  job->renderer = renderer;
  job->request = *request;
  job->user_data = user_data;
  if (!job->request.timeout_ms)
    job->request.timeout_ms = renderer->config.timeout_ms;
  if (!job->request.max_output_bytes)
    job->request.max_output_bytes = renderer->config.max_output_bytes;
  atomic_store_bool(&job->cancelled, false);
  atomic_store_bool(&job->done, false);
  if (platform_thread_create(&job->thread, "http-render", http_renderer_job_main, job)) {
    SAFE_FREE(job);
    mutex_unlock(&renderer->lock);
    return SET_ERRNO(ERROR_THREAD, "Cannot start HTTP renderer job");
  }
  job->started = true;
  job->next = renderer->jobs;
  renderer->jobs = job;
  ++renderer->active_jobs;
  mutex_unlock(&renderer->lock);
  *out_job = job;
  return ASCIICHAT_OK;
}

References http_renderer::active_jobs, ASCIICHAT_OK, http_renderer_job::cancelled, http_renderer::config, http_renderer_job::done, ERROR_BUFFER_FULL, ERROR_INVALID_PARAM, ERROR_THREAD, http_renderer::jobs, http_renderer::lock, http_renderer_config_t::max_jobs, http_render_request_t::max_output_bytes, http_renderer_config_t::max_output_bytes, http_renderer_job::next, http_renderer_job::renderer, http_renderer_job::request, SAFE_CALLOC, SAFE_FREE, SET_ERRNO, http_renderer_job::started, http_renderer::stopping, http_renderer_job::thread, http_render_request_t::timeout_ms, http_renderer_config_t::timeout_ms, and http_renderer_job::user_data.