encoder.c File Reference

FFmpeg HEVC encoder for ASCII art frames. More...

Go to the source code of this file.

Data Structures
struct	h265_encoder
	h265 encoder is intentionally a small, concrete record. Fields such as codec_ctx, codec, frame, packet give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed. More...

Typedefs
typedef struct h265_encoder	h265_encoder_t
	h265 encoder is intentionally a small, concrete record. Fields such as codec_ctx, codec, frame, packet give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed.

Functions
bool	video_encoder_is_available (video_codec_t codec)
h265_encoder_t *	h265_encoder_create (uint16_t initial_width, uint16_t initial_height)
h265_encoder_t *	video_encoder_create (video_codec_t codec_type, uint16_t initial_width, uint16_t initial_height)
void	h265_encoder_destroy (h265_encoder_t *encoder)
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)
void	h265_encoder_request_keyframe (h265_encoder_t *encoder)
asciichat_error_t	h265_encoder_flush (h265_encoder_t *encoder, uint8_t *output_buf, size_t *output_size)
void	h265_encoder_get_stats (h265_encoder_t *encoder, uint64_t *total_frames, uint64_t *keyframes, uint32_t *avg_bitrate)

Detailed Description

FFmpeg HEVC encoder for ASCII art frames.

Definition in file encoder.c.

Typedef Documentation

h265_encoder_t

typedef struct h265_encoder h265_encoder_t

h265 encoder is intentionally a small, concrete record. Fields such as codec_ctx, codec, frame, packet give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed.

Function Documentation

h265_encode()

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 )

Encode an RGB24 upload frame

The encoder automatically detects size changes and reinitializes when needed. The output packet includes frame dimensions so decoder can reconfigure.

Parameters

encoder	Encoder handle
width	Current frame width in pixels
height	Current frame height in pixels
ascii_data	RGB24 pixel data (width × height × 3 bytes)
output_buf	Buffer for encoded output
output_size	Input: buffer size, Output: actual encoded size

Returns

Error code (ASCIICHAT_OK on success)

OUTPUT PACKET FORMAT: [flags: u8][width: u16][height: u16][x265_data...]

Definition at line 317 of file encoder.c.

                                                                        {
  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;
}

References ASCII_OTEL_ATTR_INT, ASCII_OTEL_ATTR_STRING, ascii_otel_metric(), ASCII_OTEL_SCOPE, ASCIICHAT_OK, h265_encoder::codec, h265_encoder::codec_ctx, h265_encoder::current_height, h265_encoder::current_width, EAGAIN, ERROR_INTERNAL, ERROR_MEDIA_DECODE, ERROR_MEDIA_INIT, ERROR_NETWORK_SIZE, h265_encoder::frame, h265_encoder::frames_submitted, H265_ENCODER_FLAG_KEYFRAME, H265_ENCODER_FLAG_SIZE_CHANGE, height, h265_encoder::keyframes, log_debug_every, log_dev, log_error, h265_encoder::packet, h265_encoder::request_keyframe, SET_ERRNO, stats_counter_add(), STATS_COUNTER_FRAMES_ENCODED, STATS_DURATION_ENCODE, stats_duration_record(), stats_runtime_scope(), h265_encoder::total_frames, US_PER_SEC_INT, width, and h265_encoder::yuv_buf.

Referenced by acip_send_image_frame_h265(), h265_client_capture_and_encode(), and threaded_send_image_frame_encoded().

h265_encoder_create()

h265_encoder_t * h265_encoder_create	(	uint16_t	initial_width,
		uint16_t	initial_height )

Create a new x265 encoder for ASCII frames

Parameters

initial_width	Initial frame width (characters)
initial_height	Initial frame height (characters)

Returns

Encoder handle, or NULL on error

Definition at line 86 of file encoder.c.

                                                                                     {
  ASCII_OTEL_SCOPE(H265_ENCODER_CREATE);
  return video_encoder_create(VIDEO_CODEC_H265, initial_width, initial_height);
}

References ASCII_OTEL_SCOPE, VIDEO_CODEC_H265, and video_encoder_create().

Referenced by h265_client_context_create().

h265_encoder_destroy()

void h265_encoder_destroy

(

h265_encoder_t *

encoder

)

Destroy an x265 encoder

Parameters

encoder

Encoder to destroy (may be NULL)

Definition at line 179 of file encoder.c.

                                                   {
  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);
}

References h265_encoder::codec_ctx, h265_encoder::frame, LOG_IO, h265_encoder::packet, SAFE_FREE, and h265_encoder::yuv_buf.

Referenced by h265_client_context_create(), h265_client_context_destroy(), and video_encoder_create().

h265_encoder_flush()

asciichat_error_t h265_encoder_flush	(	h265_encoder_t *	encoder,
		uint8_t *	output_buf,
		size_t *	output_size )

Flush remaining buffered frames from encoder

Sends a NULL frame to the encoder to flush all buffered frames. This should be called before destroying the encoder or when you need to ensure all encoded data is retrieved.

Parameters

encoder	Encoder handle
output_buf	Buffer for encoded output
output_size	Input: buffer size, Output: actual encoded size

Returns

Error code (ASCIICHAT_OK on success, ASCIICHAT_OK with size=0 when no more data)

USAGE: // After final h265_encode() call, flush remaining frames while (size > 0) { size = max_size; h265_encoder_flush(encoder, buf, &size); if (size > 0) { // Send the flushed frame... } }

Definition at line 445 of file encoder.c.

                                                                                                        {
  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;
}

References ASCII_OTEL_ATTR_INT, ASCII_OTEL_ATTR_STRING, ascii_otel_metric(), ASCII_OTEL_SCOPE, ASCIICHAT_OK, h265_encoder::codec, h265_encoder::codec_ctx, h265_encoder::codec_opened, h265_encoder::current_height, h265_encoder::current_width, EAGAIN, ERROR_INTERNAL, ERROR_MEDIA_DECODE, ERROR_NETWORK_SIZE, H265_ENCODER_FLAG_KEYFRAME, h265_encoder::keyframes, log_debug, log_dev, log_error, h265_encoder::packet, SET_ERRNO, stats_counter_add(), STATS_COUNTER_FRAMES_ENCODED, STATS_DURATION_ENCODE, stats_duration_record(), stats_runtime_scope(), and h265_encoder::total_frames.

h265_encoder_get_stats()

void h265_encoder_get_stats	(	h265_encoder_t *	encoder,
		uint64_t *	total_frames,
		uint64_t *	keyframes,
		uint32_t *	avg_bitrate )

Get encoder statistics

Parameters

encoder	Encoder handle
total_frames	Output: total frames encoded
keyframes	Output: total keyframes encoded
avg_bitrate	Output: average bitrate in bits per second

Definition at line 533 of file encoder.c.

                                                   {
  if (!encoder)
    return;
 
  if (total_frames)
    *total_frames = encoder->total_frames;
  if (keyframes)
    *keyframes = encoder->keyframes;
  if (avg_bitrate)
    *avg_bitrate = encoder->avg_bitrate;
}

References h265_encoder::avg_bitrate, h265_encoder::keyframes, and h265_encoder::total_frames.

Referenced by h265_client_get_stats().

h265_encoder_request_keyframe()

void h265_encoder_request_keyframe

(

h265_encoder_t *

encoder

)

Request a keyframe on the next encode

Forces the encoder to produce an I-frame (keyframe) on the next call to h265_encoder_encode(). Useful for error recovery or stream synchronization.

Parameters

encoder

Encoder handle

Definition at line 439 of file encoder.c.

                                                            {
  if (encoder) {
    encoder->request_keyframe = true;
  }
}

References h265_encoder::request_keyframe.

Referenced by acip_send_image_frame_h265(), h265_client_request_keyframe(), and threaded_send_image_frame_encoded().

video_encoder_create()

h265_encoder_t * video_encoder_create	(	video_codec_t	codec,
		uint16_t	initial_width,
		uint16_t	initial_height )

Create an HEVC or H.264 RGB24 upload encoder with the shared frame envelope. The legacy h265 encode/destroy functions also operate on H.264 instances.

Definition at line 91 of file encoder.c.

                                                                                                                {
  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;
}

References ASCII_OTEL_ATTR_INT, ASCII_OTEL_ATTR_STRING, ASCII_OTEL_SCOPE, h265_encoder::codec, h265_encoder::codec_ctx, h265_encoder::codec_opened, h265_encoder::current_height, h265_encoder::current_width, ERROR_INVALID_PARAM, ERROR_MEDIA_INIT, ERROR_MEMORY, h265_encoder::frame, h265_encoder_destroy(), log_info, log_warn, NAMED_REGISTER_H265_ENCODER, h265_encoder::packet, SAFE_CALLOC, SAFE_MALLOC, SET_ERRNO, VIDEO_CODEC_H264, VIDEO_CODEC_H265, h265_encoder::yuv_buf, and h265_encoder::yuv_buf_size.

Referenced by h265_encoder_create(), and threaded_send_image_frame_encoded().

video_encoder_is_available()

bool video_encoder_is_available

(

video_codec_t

codec

)

Return whether a usable software encoder is registered for codec.

This probe is side-effect free: it does not allocate, open a codec context, or set errno. Automatic capture uses it to avoid probing unavailable codecs and reporting expected fallback failures to the user.

Definition at line 54 of file encoder.c.

                                                     {
  if (codec != VIDEO_CODEC_H265 && codec != VIDEO_CODEC_H264)
    return false;
  return video_encoder_find_codec(codec) != NULL;
}

References VIDEO_CODEC_H264, and VIDEO_CODEC_H265.