encoder.c

Go to the documentation of this file.

#include <defer.h>
#include <ascii-chat/otel.h>
#include <ascii-chat/stats/runtime.h>
 
#include <ascii-chat/video/h265/encoder.h>
#include <ascii-chat/common.h>
#include <ascii-chat/debug/named.h>
#include <ascii-chat/log/io.h>
#include <ascii-chat/util/time.h>
#include <libplatform/system.h>
 
#include <libavcodec/avcodec.h>
#include <libavutil/frame.h>
#include <libavutil/imgutils.h>
#include <libavutil/opt.h>
 
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
 
static int h265_thread_count(void) {
#ifdef _WIN32
  SYSTEM_INFO sysinfo;
  GetSystemInfo(&sysinfo);
  long cores = (long)sysinfo.dwNumberOfProcessors;
#else
  long cores = sysconf(_SC_NPROCESSORS_ONLN);
#endif
  if (cores <= 0)
    cores = 4;
  int half = (int)(cores / 2);
  return half > 4 ? half : 4;
}
 
static bool is_hardware_encoder(const AVCodec *codec) {
  if (!codec || !codec->name)
    return false;
  return strstr(codec->name, "_d3d12va") != NULL || strstr(codec->name, "_nvenc") != NULL ||
         strstr(codec->name, "_qsv") != NULL || strstr(codec->name, "_amf") != NULL ||
         strstr(codec->name, "_mf") != NULL;
}
 
static const AVCodec *video_encoder_find_codec(video_codec_t codec_type) {
  const AVCodec *codec = avcodec_find_encoder_by_name(codec_type == VIDEO_CODEC_H264 ? "libx264" : "libx265");
  if (!codec)
    codec = avcodec_find_encoder(codec_type == VIDEO_CODEC_H264 ? AV_CODEC_ID_H264 : AV_CODEC_ID_HEVC);
  return is_hardware_encoder(codec) ? NULL : codec;
}
 
bool video_encoder_is_available(video_codec_t codec) {
  if (codec != VIDEO_CODEC_H265 && codec != VIDEO_CODEC_H264)
    return false;
  return video_encoder_find_codec(codec) != NULL;
}

typedef struct h265_encoder {
  AVCodecContext *codec_ctx;
  const AVCodec *codec;
  AVFrame *frame;
  AVPacket *packet;
 
  uint16_t current_width;
  uint16_t current_height;
 
  uint8_t *yuv_buf;
  size_t yuv_buf_size;
 
  bool codec_opened;
  bool request_keyframe;
 
  uint64_t frames_submitted;
  uint64_t total_frames;
  uint64_t keyframes;
  uint32_t avg_bitrate;
} h265_encoder_t;
 
h265_encoder_t *h265_encoder_create(uint16_t initial_width, uint16_t initial_height) {
  ASCII_OTEL_SCOPE(H265_ENCODER_CREATE);
  return video_encoder_create(VIDEO_CODEC_H265, initial_width, initial_height);
}
 
h265_encoder_t *video_encoder_create(video_codec_t codec_type, uint16_t initial_width, uint16_t initial_height) {
  ASCII_OTEL_SCOPE(VIDEO_ENCODER_CREATE);
  ASCII_OTEL_ATTR_STRING("video.codec", codec_type == VIDEO_CODEC_H264 ? "h264" : "h265");
  ASCII_OTEL_ATTR_INT("video.frame.width", initial_width);
  ASCII_OTEL_ATTR_INT("video.frame.height", initial_height);
  if (codec_type != VIDEO_CODEC_H265 && codec_type != VIDEO_CODEC_H264) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Expected HEVC or H.264 codec");
    return NULL;
  }
  if (initial_width == 0 || initial_height == 0) {
    SET_ERRNO(ERROR_MEDIA_INIT, "Frame dimensions must be non-zero");
    return NULL;
  }
 
  h265_encoder_t *enc = SAFE_CALLOC(1, sizeof(h265_encoder_t), h265_encoder_t *);
  if (!enc) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate encoder structure");
    return NULL;
  }
 
  defer_named(cleanup, h265_encoder_destroy(enc));
 
  const AVCodec *codec = video_encoder_find_codec(codec_type);
  if (!codec) {
    SET_ERRNO(ERROR_MEDIA_INIT, "%s encoder not found", codec_type == VIDEO_CODEC_H264 ? "H.264" : "HEVC");
    return NULL;
  }
  enc->codec = codec;
 
  enc->codec_ctx = avcodec_alloc_context3(codec);
  if (!enc->codec_ctx) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate codec context");
    return NULL;
  }
 
  // Configure codec context
  enc->codec_ctx->width = initial_width;
  enc->codec_ctx->height = initial_height;
  enc->codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
  enc->codec_ctx->time_base = (AVRational){1, 30};
  enc->codec_ctx->framerate = (AVRational){30, 1};
 
  // Set ultrafast preset for low-latency encoding
  if (av_opt_set(enc->codec_ctx->priv_data, "preset", "ultrafast", 0) < 0) {
    log_warn("Failed to set preset to ultrafast, using default");
  }
  if (av_opt_set(enc->codec_ctx->priv_data, "tune", "zerolatency", 0) < 0) {
    log_warn("Failed to set tune to zerolatency, using default");
  }
 
  enc->codec_ctx->thread_count = h265_thread_count();
 
  // Defer avcodec_open2 to first encode call. The initial resolution (800x600) is
  // usually wrong — the actual frame resolution is only known when the first capture
  // arrives. Opening the codec here would create an x265 thread pool (~1s) that gets
  // immediately discarded on reconfigure, wasting startup time.
  enc->codec_opened = false;
 
  // Allocate frame and packet
  enc->frame = av_frame_alloc();
  enc->packet = av_packet_alloc();
 
  if (!enc->frame || !enc->packet) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate frame/packet");
    return NULL;
  }
 
  enc->current_width = initial_width;
  enc->current_height = initial_height;
 
  // Allocate YUV420P buffer (Y plane + U/V planes)
  size_t stride = initial_width;
  enc->yuv_buf_size = stride * initial_height * 3 / 2;
  enc->yuv_buf = SAFE_MALLOC(enc->yuv_buf_size, uint8_t *);
  if (!enc->yuv_buf) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate YUV buffer");
    return NULL;
  }
 
  log_info("FFmpeg video encoder created: %ux%u (codec: %s)", initial_width, initial_height, codec->name);
 
  // Register encoder for debugging
  NAMED_REGISTER_H265_ENCODER(enc, "h265_encoder", NULL);
 
  defer_cancel(cleanup);
  return enc;
}
 
void h265_encoder_destroy(h265_encoder_t *encoder) {
  if (!encoder)
    return;
 
  if (encoder->frame) {
    av_frame_free(&encoder->frame);
  }
  if (encoder->packet) {
    av_packet_free(&encoder->packet);
  }
  if (encoder->codec_ctx) {
    LOG_IO("video encoder", { avcodec_free_context(&encoder->codec_ctx); });
  }
  if (encoder->yuv_buf) {
    SAFE_FREE(encoder->yuv_buf);
  }
  SAFE_FREE(encoder);
}
 
static asciichat_error_t h265_encoder_open_codec(h265_encoder_t *encoder, uint16_t width, uint16_t height) {
  // Free existing context if re-opening at a different resolution
  if (encoder->codec_ctx) {
    LOG_IO("video encoder", { avcodec_free_context(&encoder->codec_ctx); });
  }
 
  const AVCodec *codec = encoder->codec;
  encoder->codec_ctx = avcodec_alloc_context3(codec);
  if (!encoder->codec_ctx) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate codec context for %ux%u", width, height);
  }
 
  encoder->codec_ctx->width = width;
  encoder->codec_ctx->height = height;
  encoder->codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
  encoder->codec_ctx->time_base = (AVRational){1, 30};
  encoder->codec_ctx->framerate = (AVRational){30, 1};
  encoder->codec_ctx->thread_count = h265_thread_count();
  encoder->codec_ctx->max_b_frames = 0;
  encoder->codec_ctx->gop_size = 30;
  // Recovery frames must be independently decodable after discarded output.
  if (encoder->codec->id == AV_CODEC_ID_H264) {
    av_opt_set(encoder->codec_ctx->priv_data, "x264-params", "repeat-headers=1", 0);
    av_opt_set(encoder->codec_ctx->priv_data, "forced-idr", "1", 0);
  } else {
    // FFmpeg can override zerolatency's frame-thread count with thread_count.
    // Keep parallelism within a frame so each submitted frame is available immediately.
    av_opt_set(encoder->codec_ctx->priv_data, "x265-params", "repeat-headers=1:open-gop=0:frame-threads=1", 0);
    av_opt_set(encoder->codec_ctx->priv_data, "forced-idr", "1", 0);
  }
 
  if (av_opt_set(encoder->codec_ctx->priv_data, "preset", "ultrafast", 0) < 0) {
    log_warn("Failed to set preset to ultrafast");
  }
  if (av_opt_set(encoder->codec_ctx->priv_data, "tune", "zerolatency", 0) < 0) {
    log_warn("Failed to set tune to zerolatency");
  }
 
  log_dev("[H265_OPEN] avcodec_open2 for %ux%u (threads=%d)", width, height, encoder->codec_ctx->thread_count);
  int codec_open_result = 0;
  LOG_IO("video encoder", { codec_open_result = avcodec_open2(encoder->codec_ctx, codec, NULL); });
 
  if (codec_open_result < 0) {
    return SET_ERRNO(ERROR_MEDIA_INIT, "Failed to open %s encoder for %ux%u", codec->name, width, height);
  }
 
  // Resize YUV buffer if needed
  size_t new_yuv_size = width * height * 3 / 2;
  if (new_yuv_size > encoder->yuv_buf_size) {
    uint8_t *new_buf = SAFE_MALLOC(new_yuv_size, uint8_t *);
    if (!new_buf) {
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate YUV buffer for %ux%u", width, height);
    }
    SAFE_FREE(encoder->yuv_buf);
    encoder->yuv_buf = new_buf;
    encoder->yuv_buf_size = new_yuv_size;
  }
 
  encoder->current_width = width;
  encoder->current_height = height;
  encoder->codec_opened = true;
  encoder->request_keyframe = true;
 
  log_info("Video encoder %s opened for %ux%u", codec->name, width, height);
  return ASCIICHAT_OK;
}
 
static asciichat_error_t h265_encoder_reconfigure(h265_encoder_t *encoder, uint16_t new_width, uint16_t new_height) {
  ASCII_OTEL_SCOPE(H265_ENCODER_RECONFIGURE);
  if (encoder->codec_opened && encoder->current_width == new_width && encoder->current_height == new_height) {
    return ASCIICHAT_OK;
  }
  return h265_encoder_open_codec(encoder, new_width, new_height);
}
 
static void h265_encoder_ascii_to_yuv420(const uint8_t *rgb_data, uint16_t width, uint16_t height, uint8_t *yuv_buf) {
  uint8_t *y_plane = yuv_buf;
  uint8_t *u_plane = y_plane + width * height;
  uint8_t *v_plane = u_plane + (width / 2) * (height / 2);
 
  // Convert RGB24 to YUV420p
  // Y = 0.299*R + 0.587*G + 0.114*B (standard luma formula)
  // U = -0.14713*R - 0.28886*G + 0.436*B (offset by 128)
  // V = 0.615*R - 0.51499*G - 0.10001*B (offset by 128)
 
  // Process Y plane (each pixel)
  for (uint32_t i = 0; i < (uint32_t)width * (uint32_t)height; i++) {
    uint8_t r = rgb_data[i * 3];
    uint8_t g = rgb_data[i * 3 + 1];
    uint8_t b = rgb_data[i * 3 + 2];
 
    // Calculate Y (luma)
    y_plane[i] = (uint8_t)(((66 * r + 129 * g + 25 * b + 128) >> 8) + 16);
  }
 
  // Process U and V planes (subsampled 2x2)
  for (uint32_t y = 0; y < (uint32_t)height; y += 2) {
    for (uint32_t x = 0; x < (uint32_t)width; x += 2) {
      // Average 2x2 RGB block for chroma
      uint32_t idx00 = ((y)*width + x) * 3;
      uint32_t idx10 = ((y)*width + x + 1) * 3;
      uint32_t idx01 = ((y + 1) * width + x) * 3;
      uint32_t idx11 = ((y + 1) * width + x + 1) * 3;
 
      uint16_t r_avg = (rgb_data[idx00] + rgb_data[idx10] + rgb_data[idx01] + rgb_data[idx11]) / 4;
      uint16_t g_avg = (rgb_data[idx00 + 1] + rgb_data[idx10 + 1] + rgb_data[idx01 + 1] + rgb_data[idx11 + 1]) / 4;
      uint16_t b_avg = (rgb_data[idx00 + 2] + rgb_data[idx10 + 2] + rgb_data[idx01 + 2] + rgb_data[idx11 + 2]) / 4;
 
      // Calculate U (Cb)
      int16_t u = (int16_t)((((-38 * r_avg - 74 * g_avg + 112 * b_avg + 128) >> 8) + 128));
      u_plane[(y / 2) * (width / 2) + (x / 2)] = (uint8_t)(u < 0 ? 0 : (u > 255 ? 255 : u));
 
      // Calculate V (Cr)
      int16_t v = (int16_t)((((112 * r_avg - 94 * g_avg - 18 * b_avg + 128) >> 8) + 128));
      v_plane[(y / 2) * (width / 2) + (x / 2)] = (uint8_t)(v < 0 ? 0 : (v > 255 ? 255 : v));
    }
  }
}
 
asciichat_error_t h265_encode(h265_encoder_t *encoder, uint16_t width, uint16_t height, const uint8_t *ascii_data,
                              uint8_t *output_buf, size_t *output_size) {
  ASCII_OTEL_SCOPE(H265_ENCODE);
  ASCII_OTEL_ATTR_INT("video.frame.width", width);
  ASCII_OTEL_ATTR_INT("video.frame.height", height);
  if (encoder && encoder->codec)
    ASCII_OTEL_ATTR_STRING("video.codec", encoder->codec->id == AV_CODEC_ID_H264 ? "h264" : "h265");
  if (!encoder || !ascii_data || !output_buf || !output_size) {
    return SET_ERRNO(ERROR_INTERNAL, "Invalid encoder arguments");
  }
 
  if (!width || !height || (width & 1) || (height & 1)) {
    return SET_ERRNO(ERROR_MEDIA_INIT, "Video encoding requires non-zero even dimensions, got %ux%u", width, height);
  }
 
  if (*output_size < 5) {
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Output buffer too small (minimum 5 bytes)");
  }
 
  bool size_changed = width != encoder->current_width || height != encoder->current_height;
  asciichat_error_t result = h265_encoder_reconfigure(encoder, width, height);
  if (result != ASCIICHAT_OK) {
    return result;
  }
 
  h265_encoder_ascii_to_yuv420(ascii_data, width, height, encoder->yuv_buf);
 
  // Setup frame data pointers
  encoder->frame->data[0] = encoder->yuv_buf;
  encoder->frame->data[1] = encoder->yuv_buf + width * height;
  encoder->frame->data[2] = encoder->yuv_buf + width * height + (width / 2) * (height / 2);
  encoder->frame->linesize[0] = width;
  encoder->frame->linesize[1] = width / 2;
  encoder->frame->linesize[2] = width / 2;
  encoder->frame->width = width;
  encoder->frame->height = height;
  encoder->frame->format = AV_PIX_FMT_YUV420P;
 
  encoder->frame->pts = (int64_t)encoder->frames_submitted++;
  encoder->frame->pict_type = AV_PICTURE_TYPE_NONE;
 
  // Request keyframe if needed
  if (encoder->request_keyframe) {
    encoder->frame->pict_type = AV_PICTURE_TYPE_I;
    encoder->request_keyframe = false;
  }
 
  // Encode frame
  uint64_t stats_codec_start = time_get_ns();
  int send_ret = avcodec_send_frame(encoder->codec_ctx, encoder->frame);
  if (send_ret < 0) {
    stats_duration_record(stats_runtime_scope(), STATS_DURATION_ENCODE, time_get_ns() - stats_codec_start);
    log_error("avcodec_send_frame failed: %d", send_ret);
    return SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to send frame to encoder");
  }
 
  int recv_ret = avcodec_receive_packet(encoder->codec_ctx, encoder->packet);
  stats_duration_record(stats_runtime_scope(), STATS_DURATION_ENCODE, time_get_ns() - stats_codec_start);
  if (recv_ret == AVERROR(EAGAIN)) {
    // EAGAIN is normal - encoder needs more frames before outputting a packet
    log_dev("EAGAIN - encoder buffering frames (normal), waiting for next frame");
    *output_size = 0; // No output this time
    return ASCIICHAT_OK;
  }
  if (recv_ret < 0) {
    log_error("avcodec_receive_packet failed: %d (EAGAIN=%d)", recv_ret, AVERROR(EAGAIN));
    return SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to receive encoded packet");
  }
  log_debug_every(US_PER_SEC_INT, "Got encoded packet: size=%d", (int)encoder->packet->size);
 
  uint8_t flags = 0;
  if (encoder->packet->flags & AV_PKT_FLAG_KEY) {
    flags |= H265_ENCODER_FLAG_KEYFRAME;
    encoder->keyframes++;
  }
 
  if (size_changed) {
    flags |= H265_ENCODER_FLAG_SIZE_CHANGE;
  }
 
  size_t header_size = 5;
  size_t packet_size = encoder->packet->size;
  size_t required_size = header_size + packet_size;
 
  if (required_size > *output_size) {
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Output buffer too small: need %zu, have %zu", required_size, *output_size);
  }
 
  // Write header: [flags][width:u16][height:u16]
  output_buf[0] = flags;
  output_buf[1] = (width >> 8) & 0xFF;
  output_buf[2] = width & 0xFF;
  output_buf[3] = (height >> 8) & 0xFF;
  output_buf[4] = height & 0xFF;
 
  // Write encoded data
  if (packet_size > 0) {
    memcpy(output_buf + header_size, encoder->packet->data, packet_size);
  }
 
  *output_size = required_size;
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_BYTES, (double)required_size);
  if (encoder->packet->flags & AV_PKT_FLAG_KEY)
    ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_KEYFRAMES, 1);
  ASCII_OTEL_ATTR_INT("video.packet.size", (int64_t)required_size);
  ASCII_OTEL_ATTR_INT("video.frame.keyframe", (encoder->packet->flags & AV_PKT_FLAG_KEY) != 0);
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_ENCODE_FRAMES, 1);
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_ENCODE_INPUT, (double)width * height * 3);
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_ENCODE_BYTES_IN, (double)width * height * 3);
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_ENCODE_BYTES_OUT, (double)required_size);
  encoder->total_frames++;
  stats_counter_add(stats_runtime_scope(), STATS_COUNTER_FRAMES_ENCODED, 1);
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_WIDTH, encoder->frame->width);
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_HEIGHT, encoder->frame->height);
  if (required_size)
    ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_RATIO,
                      (double)encoder->frame->width * encoder->frame->height * 3 / (double)required_size);
  log_dev("[H265_ENCODE_DONE] Encoding complete, output_size=%zu", required_size);
 
  return ASCIICHAT_OK;
}
 
void h265_encoder_request_keyframe(h265_encoder_t *encoder) {
  if (encoder) {
    encoder->request_keyframe = true;
  }
}
 
asciichat_error_t h265_encoder_flush(h265_encoder_t *encoder, uint8_t *output_buf, size_t *output_size) {
  ASCII_OTEL_SCOPE(H265_ENCODER_FLUSH);
  if (!encoder || !output_buf || !output_size) {
    return SET_ERRNO(ERROR_INTERNAL, "Invalid encoder or output parameters for flush");
  }
 
  if (*output_size < 5) {
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Output buffer too small (minimum 5 bytes)");
  }
 
  if (!encoder->codec_opened) {
    *output_size = 0;
    return ASCIICHAT_OK;
  }
 
  // Send NULL frame to signal end of stream (flushes encoder)
  log_debug("H265_FLUSH: Sending NULL frame to encoder to flush buffered data");
  uint64_t stats_codec_start = time_get_ns();
  int send_ret = avcodec_send_frame(encoder->codec_ctx, NULL);
  if (send_ret < 0) {
    stats_duration_record(stats_runtime_scope(), STATS_DURATION_ENCODE, time_get_ns() - stats_codec_start);
    log_error("H265_FLUSH: avcodec_send_frame(NULL) failed: %d", send_ret);
    return SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to flush encoder");
  }
 
  // Try to receive a packet
  log_debug("H265_FLUSH: Attempting to receive flushed packet...");
  int recv_ret = avcodec_receive_packet(encoder->codec_ctx, encoder->packet);
  stats_duration_record(stats_runtime_scope(), STATS_DURATION_ENCODE, time_get_ns() - stats_codec_start);
  if (recv_ret == AVERROR(EAGAIN)) {
    log_dev("H265_FLUSH: EAGAIN - no more frames available");
    *output_size = 0;
    return ASCIICHAT_OK;
  }
  if (recv_ret == AVERROR_EOF) {
    log_debug("H265_FLUSH: EOF - encoder is flushed");
    *output_size = 0;
    return ASCIICHAT_OK;
  }
  if (recv_ret < 0) {
    log_error("H265_FLUSH: avcodec_receive_packet failed: %d", recv_ret);
    return SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to receive flushed packet");
  }
 
  log_debug("H265_FLUSH: Got flushed packet: size=%d", (int)encoder->packet->size);
 
  // Check if packet size exceeds output buffer
  size_t header_size = 5;
  size_t packet_size = encoder->packet->size;
  size_t required_size = header_size + packet_size;
 
  if (required_size > *output_size) {
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Output buffer too small: need %zu, have %zu", required_size, *output_size);
  }
 
  // Write header: [flags][width:u16][height:u16]
  uint8_t flags = 0;
  if (encoder->packet->flags & AV_PKT_FLAG_KEY) {
    flags |= H265_ENCODER_FLAG_KEYFRAME;
    encoder->keyframes++;
  }
 
  output_buf[0] = flags;
  output_buf[1] = (encoder->current_width >> 8) & 0xFF;
  output_buf[2] = encoder->current_width & 0xFF;
  output_buf[3] = (encoder->current_height >> 8) & 0xFF;
  output_buf[4] = encoder->current_height & 0xFF;
 
  // Write encoded data
  if (packet_size > 0) {
    memcpy(output_buf + header_size, encoder->packet->data, packet_size);
  }
 
  *output_size = required_size;
  ASCII_OTEL_ATTR_INT("video.packet.size", (int64_t)required_size);
  if (encoder->codec)
    ASCII_OTEL_ATTR_STRING("video.codec", encoder->codec->id == AV_CODEC_ID_H264 ? "h264" : "h265");
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_ENCODE_FRAMES, 1);
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_ENCODE_BYTES_OUT, (double)required_size);
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_BYTES, (double)required_size);
  if (encoder->packet->flags & AV_PKT_FLAG_KEY)
    ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_KEYFRAMES, 1);
  encoder->total_frames++;
  stats_counter_add(stats_runtime_scope(), STATS_COUNTER_FRAMES_ENCODED, 1);
 
  return ASCIICHAT_OK;
}
 
void h265_encoder_get_stats(h265_encoder_t *encoder, uint64_t *total_frames, uint64_t *keyframes,
                            uint32_t *avg_bitrate) {
  if (!encoder)
    return;
 
  if (total_frames)
    *total_frames = encoder->total_frames;
  if (keyframes)
    *keyframes = encoder->keyframes;
  if (avg_bitrate)
    *avg_bitrate = encoder->avg_bitrate;
}