http_renderer.c File Reference

Go to the source code of this file.

Data Structures
struct	http_renderer

Functions
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_job_wait (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_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)
asciichat_error_t	http_renderer_render_file (const char *path, const http_render_request_t *request, http_render_result_t *result, atomic_t *cancelled)

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_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.