video/h265/decoder.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/decoder.h>
#include <ascii-chat/common.h>
#include <ascii-chat/debug/named.h>
#include <ascii-chat/log/io.h>
#include <libplatform/system.h>
 
#include <libavcodec/avcodec.h>
#include <libavutil/frame.h>
 
#include <string.h>
#include <stdlib.h>
#include <limits.h>
 
typedef struct h265_decoder {
  AVCodecContext *codec_ctx;
  AVFrame *frame;
  AVPacket *packet;
  AVCodecParserContext *parser;
 
  uint16_t last_width;
  uint16_t last_height;
 
  uint64_t total_frames;
  uint64_t keyframes;
} h265_decoder_t;
 
h265_decoder_t *h265_decoder_create(void) {
  ASCII_OTEL_SCOPE(H265_DECODER_CREATE);
  h265_decoder_t *dec = SAFE_CALLOC(1, sizeof(h265_decoder_t), h265_decoder_t *);
  if (!dec) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate decoder structure");
    return NULL;
  }
 
  defer_named(cleanup, h265_decoder_destroy(dec));
 
  // Find HEVC decoder
  const AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_HEVC);
  if (!codec) {
    SET_ERRNO(ERROR_MEDIA_INIT, "HEVC decoder not found");
    return NULL;
  }
 
  dec->codec_ctx = avcodec_alloc_context3(codec);
  if (!dec->codec_ctx) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate codec context");
    return NULL;
  }
 
  // Open decoder (capture x265 library output during initialization)
  int codec_open_result = 0;
  LOG_IO("hevc", { codec_open_result = avcodec_open2(dec->codec_ctx, codec, NULL); });
 
  if (codec_open_result < 0) {
    SET_ERRNO(ERROR_MEDIA_INIT, "Failed to open HEVC decoder");
    return NULL;
  }
 
  // Allocate frame and packet
  dec->frame = av_frame_alloc();
  dec->packet = av_packet_alloc();
  dec->parser = av_parser_init(AV_CODEC_ID_HEVC);
 
  if (!dec->frame || !dec->packet || !dec->parser) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate frame/packet/parser");
    return NULL;
  }
 
  log_info("FFmpeg HEVC decoder created");
 
  // Register decoder for debugging
  NAMED_REGISTER_H265_DECODER(dec, "h265_decoder", NULL);
 
  defer_cancel(cleanup);
  return dec;
}
 
void h265_decoder_destroy(h265_decoder_t *decoder) {
  if (!decoder)
    return;
 
  if (decoder->frame) {
    av_frame_free(&decoder->frame);
  }
  if (decoder->packet) {
    av_packet_free(&decoder->packet);
  }
  if (decoder->parser) {
    av_parser_close(decoder->parser);
  }
  if (decoder->codec_ctx) {
    avcodec_free_context(&decoder->codec_ctx);
  }
  SAFE_FREE(decoder);
}
 
asciichat_error_t h265_decode(h265_decoder_t *decoder, const uint8_t *encoded_packet, size_t packet_size,
                              uint16_t *output_width, uint16_t *output_height, uint8_t *output_buf,
                              size_t *output_size) {
  ASCII_OTEL_SCOPE(H265_DECODE);
  if (!decoder || !encoded_packet || !output_width || !output_height || !output_buf || !output_size) {
    return SET_ERRNO(ERROR_INTERNAL, "Invalid decoder arguments");
  }
 
  if (packet_size < 5) {
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Packet too small (minimum 5 bytes)");
  }
 
  // Parse header
  uint8_t flags = encoded_packet[0];
  uint16_t width = ((uint16_t)encoded_packet[1] << 8) | encoded_packet[2];
  uint16_t height = ((uint16_t)encoded_packet[3] << 8) | encoded_packet[4];
 
  if (width == 0 || height == 0) {
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid frame dimensions: %ux%u", width, height);
  }
 
  size_t required_output = width * height;
  if (*output_size < required_output) {
    *output_size = required_output;
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Output buffer too small: need %zu, have %zu", required_output, *output_size);
  }
 
  // Decode HEVC data
  if (packet_size > 5) {
    const uint8_t *hevc_data = encoded_packet + 5;
    size_t hevc_size = packet_size - 5;
 
    // Send packet to decoder
    // FFmpeg owns packet storage and requires zero padding after the payload.
    // The wire buffer belongs to the caller and may be stack allocated.
    if (hevc_size > INT_MAX)
      return SET_ERRNO(ERROR_NETWORK_SIZE, "Encoded video packet exceeds FFmpeg limits");
    av_packet_unref(decoder->packet);
    if (av_new_packet(decoder->packet, (int)hevc_size) < 0)
      return SET_ERRNO(ERROR_MEMORY, "Cannot allocate decoder packet");
    memcpy(decoder->packet->data, hevc_data, hevc_size);
 
    uint64_t stats_codec_start = time_get_ns();
    int send_result = avcodec_send_packet(decoder->codec_ctx, decoder->packet);
    av_packet_unref(decoder->packet);
    if (send_result < 0) {
      return SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to send packet to decoder");
    }
 
    int stats_decode_result = avcodec_receive_frame(decoder->codec_ctx, decoder->frame);
    stats_duration_record(stats_runtime_scope(), STATS_DURATION_DECODE, time_get_ns() - stats_codec_start);
    if (stats_decode_result < 0) {
      return SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to receive decoded frame");
    }
  } else {
    // Empty packet - just signal a frame boundary
    if (avcodec_send_packet(decoder->codec_ctx, NULL) < 0) {
      return SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to flush decoder");
    }
  }
 
  // Extract Y plane (grayscale intensity)
  uint8_t *y_plane = decoder->frame->data[0];
  int y_stride = decoder->frame->linesize[0];
  int img_width = decoder->frame->width;
  int img_height = decoder->frame->height;
 
  if (img_width != (int)width || img_height != (int)height) {
    log_warn("Image dimensions mismatch: expected %ux%u, got %dx%d", width, height, img_width, img_height);
  }
 
  // Copy Y plane to output (ASCII intensity values)
  for (int y = 0; y < img_height && y < (int)height; y++) {
    memcpy(output_buf + y * width, y_plane + y * y_stride, width);
  }
 
  *output_width = width;
  *output_height = height;
  *output_size = width * height;
 
  decoder->last_width = width;
  decoder->last_height = height;
  decoder->total_frames++;
  ASCII_OTEL_ATTR_STRING("video.codec", "h265");
  ASCII_OTEL_ATTR_INT("video.frame.width", width);
  ASCII_OTEL_ATTR_INT("video.frame.height", height);
  ASCII_OTEL_ATTR_INT("video.frame.keyframe", (flags & H265_DECODER_FLAG_KEYFRAME) != 0);
  ASCII_OTEL_ATTR_INT("video.packet.size", (int64_t)packet_size);
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_DECODE_BYTES, (double)packet_size);
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_DECODE_FRAMES, 1);
  ascii_otel_metric(ASCII_OTEL_METRIC_VIDEO_DECODE_BYTES_OUT, (double)*output_size);
  stats_counter_add(stats_runtime_scope(), STATS_COUNTER_FRAMES_DECODED, 1);
 
  if (flags & H265_DECODER_FLAG_KEYFRAME) {
    decoder->keyframes++;
  }
 
  return ASCIICHAT_OK;
}
 
void h265_decoder_get_stats(h265_decoder_t *decoder, uint64_t *total_frames, uint64_t *keyframes, uint16_t *last_width,
                            uint16_t *last_height) {
  if (!decoder)
    return;
 
  if (total_frames)
    *total_frames = decoder->total_frames;
  if (keyframes)
    *keyframes = decoder->keyframes;
  if (last_width)
    *last_width = decoder->last_width;
  if (last_height)
    *last_height = decoder->last_height;
}