ffmpeg_decoder.c

Go to the documentation of this file.

 
/* Storage capacities in elements; text buffers include the terminating NUL. */
#define MEDIA_FFMPEG_DECODER_DECODER_NAME_BUFFER_SIZE 256
 
#include <ascii-chat/otel.h>
#include <ascii-chat/media/ffmpeg_decoder.h>
#include <ascii-chat/common.h>
#include <libplatform/atomic.h>
#include <ascii-chat/log/log.h>
#include <ascii-chat/log/io.h>
#include <ascii-chat/debug/named.h>
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/video/rgba/image.h>
#include <libplatform/system.h>
#include <libplatform/util/string.h>
#include <libplatform/mutex.h>
#include <libplatform/cond.h>
#include <libplatform/thread.h>
#include <ascii-chat/util/time.h>
#include <ascii-chat/util/url.h>
#include <ascii-chat/options/options.h>
 
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/imgutils.h>
#include <libavutil/opt.h>
#include <libavutil/log.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>
#include <string.h>
#include <inttypes.h>
 
/* ============================================================================
 * FFmpeg Logging Suppression
 * ============================================================================ */

static void ffmpeg_silent_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
  (void)avcl;  // unused
  (void)level; // unused
  (void)fmt;   // unused
  (void)vl;    // unused
  // Do nothing - silently discard all FFmpeg logs
}
 
/* ============================================================================
 * Constants
 * ============================================================================ */

#define TARGET_SAMPLE_RATE 48000

#define TARGET_CHANNELS 2

#define AVIO_BUFFER_SIZE (64 * 1024)
 
/* ============================================================================
 * FFmpeg Decoder Structure
 * ============================================================================ */

struct ffmpeg_decoder_t {
  // Format context
  AVFormatContext *format_ctx; 
 
  // Video stream
  AVCodecContext *video_codec_ctx; 
  int video_stream_idx;            
  struct SwsContext *sws_ctx;      
 
  // Audio stream
  AVCodecContext *audio_codec_ctx; 
  int audio_stream_idx;            
  struct SwrContext *swr_ctx;      
 
  // Frame and packet buffers
  AVFrame *frame;   
  AVPacket *packet; 
 
  // Decoded image cache - double-buffered for prefetching
  image_t *current_image; 
 
  // Audio sample buffer (for partial frame handling)
  float *audio_buffer;        
  size_t audio_buffer_size;   
  size_t audio_buffer_offset; 
 
  // Background thread for frame prefetching (reduces YouTube HTTP blocking)
  platform_thread_t prefetch_thread; 
  image_t *prefetch_image_a;         
  image_t *prefetch_image_b;         
  image_t *current_prefetch_image;   
  _Atomic bool prefetch_frame_ready; 
  asciichat_error_context_t prefetch_failure;
  _Atomic bool prefetch_failed;
  bool prefetch_thread_running;      
  _Atomic bool prefetch_should_stop; 
  _Atomic bool seeking_in_progress;  
  _Atomic uint64_t seek_generation;  
  cond_t prefetch_cond;              
  mutex_t prefetch_mutex;            
  mutex_t read_frame_mutex;          
 
  // Track which buffer is being read by main thread
  image_t *current_read_buffer; 
  bool buffer_a_in_use;         
  bool buffer_b_in_use;         
 
  // State flags
  atomic_t eof_reached; 
  bool is_stdin;        
  bool video_draining;  
 
  // Stdin I/O context
  AVIOContext *avio_ctx;      
  unsigned char *avio_buffer; 
 
  // Position tracking
  double last_video_pts; 
  double last_audio_pts; 
 
  // Sample-based position tracking
  uint64_t audio_samples_read; 
  int audio_sample_rate;       
 
  // Exit signal callback (for graceful shutdown during blocking I/O)
  atomic_ptr_t should_exit_callback;    
  atomic_ptr_t exit_callback_user_data; 
};
 
/* ============================================================================
 * Stdin I/O Callbacks
 * ============================================================================ */
 
/* ============================================================================
 * Memory-based AVIO for stdin buffering
 * ============================================================================ */

typedef struct {
  uint8_t *data; 
  size_t size;   
} stdin_buffer_t;

typedef struct {
  stdin_buffer_t *buffer; 
  size_t pos;             
} stdin_buffer_reader_t;

static int memory_read_packet(void *opaque, uint8_t *buf, int buf_size) {
  stdin_buffer_reader_t *reader = (stdin_buffer_reader_t *)opaque;
 
  if (!reader || !reader->buffer || reader->pos >= reader->buffer->size)
    return AVERROR_EOF;
 
  int to_read = buf_size;
  if (reader->pos + to_read > reader->buffer->size)
    to_read = (int)(reader->buffer->size - reader->pos);
 
  memcpy(buf, reader->buffer->data + reader->pos, to_read);
  reader->pos += to_read;
 
  return to_read;
}

static int64_t memory_seek_packet(void *opaque, int64_t offset, int whence) {
  stdin_buffer_reader_t *reader = (stdin_buffer_reader_t *)opaque;
 
  if (!reader || !reader->buffer)
    return -1;
 
  int64_t new_pos = 0;
  if (whence == SEEK_SET) {
    new_pos = offset;
  } else if (whence == SEEK_CUR) {
    new_pos = (int64_t)reader->pos + offset;
  } else if (whence == SEEK_END) {
    new_pos = (int64_t)reader->buffer->size + offset;
  } else {
    return -1;
  }
 
  if (new_pos < 0 || new_pos > (int64_t)reader->buffer->size)
    return -1;
 
  reader->pos = (size_t)new_pos;
  return new_pos;
}

static stdin_buffer_t *stdin_buffer_read_all(void) {
  stdin_buffer_t *sb = SAFE_MALLOC(sizeof(stdin_buffer_t), stdin_buffer_t *);
  if (!sb)
    return NULL;
 
  sb->data = NULL;
  sb->size = 0;
 
  // Read stdin in 64KB chunks
  const size_t chunk_size = 65536;
  uint8_t chunk_buffer[chunk_size];
  size_t total_capacity = 0;
  int chunk_count = 0;
 
  while (1) {
    size_t bytes_read = fread(chunk_buffer, 1, chunk_size, stdin);
    if (bytes_read == 0)
      break;
    chunk_count++;
 
    // Grow buffer if needed
    if (sb->size + bytes_read > total_capacity) {
      total_capacity = (sb->size + bytes_read) * 2; // Always double capacity
      uint8_t *new_data = SAFE_MALLOC(total_capacity, uint8_t *);
      if (!new_data) {
        SAFE_FREE(sb->data);
        SAFE_FREE(sb);
        return NULL;
      }
      if (sb->data) {
        memcpy(new_data, sb->data, sb->size);
        SAFE_FREE(sb->data);
      }
      sb->data = new_data;
    }
 
    // Copy chunk to buffer
    memcpy(sb->data + sb->size, chunk_buffer, bytes_read);
    sb->size += bytes_read;
  }
 
  log_debug("Buffered stdin: %zu bytes in %d chunks (capacity: %zu)", sb->size, chunk_count, total_capacity);
  if (sb->size > 0) {
    log_info(
        "  First 16 bytes of stdin: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
        sb->data[0], sb->data[1], sb->data[2], sb->data[3], sb->data[4], sb->data[5], sb->data[6], sb->data[7],
        sb->data[8], sb->data[9], sb->data[10], sb->data[11], sb->data[12], sb->data[13], sb->data[14], sb->data[15]);
  }
  return sb;
}

static stdin_buffer_t *g_stdin_buffer = NULL;
 
/* ============================================================================
 * Helper Functions
 * ============================================================================ */

static inline double av_q2d_safe(AVRational r) {
  return (r.den != 0) ? ((double)r.num / (double)r.den) : 0.0;
}

static double get_frame_pts_seconds(AVFrame *frame, AVRational time_base) {
  if (frame->pts == AV_NOPTS_VALUE) {
    return -1.0;
  }
  return (double)frame->pts * av_q2d_safe(time_base);
}

static int ffmpeg_interrupt_callback(void *opaque) {
  ffmpeg_decoder_t *decoder = (ffmpeg_decoder_t *)opaque;
  if (!decoder) {
    return 0;
  }
 
  // Interrupt traced_packet_read() if a seek is in progress
  if (decoder->seeking_in_progress) {
    return 1;
  }
 
  // Interrupt traced_packet_read() if application is shutting down
  // This allows Ctrl+C to abort blocking I/O operations like YouTube HTTP requests
  bool (*cancel)(void *) = (bool (*)(void *))atomic_ptr_load(&decoder->should_exit_callback);
  void *data = atomic_ptr_load(&decoder->exit_callback_user_data);
  if (cancel && cancel(data)) {
    return 1;
  }
 
  return 0;
}

 
static void ffmpeg_otel_result(int result, bool streaming) {
  // EOF, buffering and application cancellation are expected control flow.
  if (result < 0 && result != AVERROR_EXIT && !(streaming && (result == AVERROR_EOF || result == AVERROR(EAGAIN))))
    gotel_current_error("ffmpeg.error", "FFmpeg operation failed");
}
 
static int traced_format_open(AVFormatContext **format, const char *path, const AVInputFormat *input,
                              AVDictionary **options) {
  ASCII_OTEL_SCOPE(FFMPEG_FORMAT_OPEN);
  ASCII_OTEL_ATTR_STRING("media.source.kind", !path ? "stdin" : strstr(path, "://") ? "network" : "file");
  int result = avformat_open_input(format, path, input, options);
  ASCII_OTEL_ATTR_INT("ffmpeg.result", result);
  ffmpeg_otel_result(result, false);
  return result;
}
static int traced_format_probe(AVFormatContext *format, AVDictionary **options) {
  ASCII_OTEL_SCOPE(FFMPEG_PROBE);
  int result = avformat_find_stream_info(format, options);
  ASCII_OTEL_ATTR_INT("ffmpeg.result", result);
  if (result >= 0 && format->iformat)
    ASCII_OTEL_ATTR_STRING("media.container", format->iformat->name);
  ffmpeg_otel_result(result, false);
  return result;
}
static int traced_packet_read(AVFormatContext *format, AVPacket *packet) {
  ASCII_OTEL_SCOPE(FFMPEG_PACKET_READ);
  int result = av_read_frame(format, packet);
  ASCII_OTEL_ATTR_INT("ffmpeg.result", result);
  if (result >= 0)
    ASCII_OTEL_ATTR_INT("media.packet.size", packet->size);
  ffmpeg_otel_result(result, true);
  return result;
}
static int traced_packet_send(AVCodecContext *codec, const AVPacket *packet) {
  ASCII_OTEL_SCOPE(FFMPEG_PACKET_SEND);
  ASCII_OTEL_ATTR_STRING("media.type", codec->codec_type == AVMEDIA_TYPE_AUDIO ? "audio" : "video");
  ASCII_OTEL_ATTR_STRING("media.codec", avcodec_get_name(codec->codec_id));
  ASCII_OTEL_ATTR_INT("media.decoder.draining", packet == NULL);
  int result = avcodec_send_packet(codec, packet);
  ASCII_OTEL_ATTR_INT("ffmpeg.result", result);
  ffmpeg_otel_result(result, true);
  return result;
}
static int traced_frame_receive(AVCodecContext *codec, AVFrame *frame) {
  ASCII_OTEL_SCOPE(FFMPEG_FRAME_RECEIVE);
  ASCII_OTEL_ATTR_STRING("media.type", codec->codec_type == AVMEDIA_TYPE_AUDIO ? "audio" : "video");
  int result = avcodec_receive_frame(codec, frame);
  ASCII_OTEL_ATTR_INT("ffmpeg.result", result);
  ffmpeg_otel_result(result, true);
  return result;
}
static int traced_video_scale(struct SwsContext *context, const uint8_t *const data[], const int stride[], int start,
                              int height, uint8_t *const output[], const int output_stride[]) {
  ASCII_OTEL_SCOPE(FFMPEG_SCALE);
  ASCII_OTEL_ATTR_INT("video.frame.height", height);
  int result = sws_scale(context, data, stride, start, height, output, output_stride);
  ASCII_OTEL_ATTR_INT("ffmpeg.result", result);
  ffmpeg_otel_result(result, false);
  return result;
}
static int traced_audio_resample(struct SwrContext *context, uint8_t **output, int capacity, const uint8_t **input,
                                 int samples) {
  ASCII_OTEL_SCOPE(FFMPEG_RESAMPLE);
  ASCII_OTEL_ATTR_INT("audio.input.samples", samples);
  int result = swr_convert(context, output, capacity, input, samples);
  ASCII_OTEL_ATTR_INT("audio.output.samples", result > 0 ? result : 0);
  ffmpeg_otel_result(result, false);
  return result;
}
 
static void *ffmpeg_decoder_prefetch_thread_func(void *arg) {
  ffmpeg_decoder_t *decoder = (ffmpeg_decoder_t *)arg;
  if (!decoder || !decoder->prefetch_image_a || !decoder->prefetch_image_b) {
    return NULL;
  }
 
  log_debug("Video prefetch thread started");
  bool use_image_a = true; // Track which buffer we're using (critical for correct buffer swapping)
 
  mutex_lock(&decoder->prefetch_mutex);
  while (true) {
 
    // The consumer releases the previous image and wakes us when taking the
    // next frame. Seek completion and shutdown also signal this condition.
    while (!decoder->prefetch_should_stop &&
           (atomic_load_bool(&decoder->eof_reached) || decoder->seeking_in_progress || decoder->prefetch_frame_ready ||
            (decoder->buffer_a_in_use && decoder->buffer_b_in_use)))
      cond_wait(&decoder->prefetch_cond, &decoder->prefetch_mutex);
    if (decoder->prefetch_should_stop) {
      break;
    }
 
    use_image_a = !decoder->buffer_a_in_use;
    uint64_t generation = decoder->seek_generation;
    uint64_t read_start_ns = time_get_ns();
    bool frame_decoded = false;
    bool reached_eof = false;
    bool packet_rejected = false;
    asciichat_errno_scope_t decode_scope = errno_checkpoint();
 
    // Release prefetch mutex but hold read_frame_mutex to prevent concurrent traced_packet_read() calls from audio
    // thread
    mutex_unlock(&decoder->prefetch_mutex);
    mutex_lock(&decoder->read_frame_mutex);
    if (generation != decoder->seek_generation || decoder->seeking_in_progress) {
      mutex_unlock(&decoder->read_frame_mutex);
      mutex_lock(&decoder->prefetch_mutex);
      continue;
    }
    // Interrupted reads are expected. Publish a failure only after deciding
    // whether this attempt was cancelled or superseded by a seek.
    bool notifications_suppressed = errno_notifications_suppress(true);
 
    ASCII_OTEL_SCOPE(FFMPEG_VIDEO_DECODE);
    ASCII_OTEL_ATTR_STRING("media.codec", avcodec_get_name(decoder->video_codec_ctx->codec_id));
    int decode_result = 0;
    // Read packets until we get a video frame - read_frame_mutex HELD
    while (true) {
      int ret;
      if (decoder->video_draining) {
        ret = decode_result = traced_frame_receive(decoder->video_codec_ctx, decoder->frame);
        if (ret == AVERROR_EOF) {
          atomic_store_bool(&decoder->eof_reached, true);
          reached_eof = true;
          break;
        }
        if (ret < 0) {
          break;
        }
      } else {
        ret = decode_result = traced_packet_read(decoder->format_ctx, decoder->packet);
        if (ret < 0) {
          if (ret != AVERROR_EOF) {
            break;
          }
 
          ret = decode_result = traced_packet_send(decoder->video_codec_ctx, NULL);
          decoder->video_draining = true;
          if (ret < 0 && ret != AVERROR_EOF) {
            break;
          }
 
          ret = decode_result = traced_frame_receive(decoder->video_codec_ctx, decoder->frame);
          if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) {
            atomic_store_bool(&decoder->eof_reached, true);
            reached_eof = true;
            break;
          }
          if (ret < 0) {
            break;
          }
        } else {
          // Check if this is a video packet
          if (decoder->packet->stream_index != decoder->video_stream_idx) {
            av_packet_unref(decoder->packet);
            continue;
          }
 
          // Send packet to decoder
          ret = decode_result = traced_packet_send(decoder->video_codec_ctx, decoder->packet);
          av_packet_unref(decoder->packet);
 
          if (ret == AVERROR(EAGAIN))
            continue;
          if (ret < 0) {
            packet_rejected = true;
            break;
          }
 
          // Receive decoded frame
          ret = decode_result = traced_frame_receive(decoder->video_codec_ctx, decoder->frame);
          if (ret == AVERROR(EAGAIN)) {
            continue; // Need more packets
          } else if (ret < 0) {
            break;
          }
        }
      }
 
      // Frame decoded - mutex still held
      // Update position tracking
      decoder->last_video_pts =
          get_frame_pts_seconds(decoder->frame, decoder->format_ctx->streams[decoder->video_stream_idx]->time_base);
 
      // Convert frame to RGB24
      int width = decoder->video_codec_ctx->width;
      ASCII_OTEL_ATTR_INT("video.frame.width", width);
      ASCII_OTEL_ATTR_INT("video.frame.height", decoder->video_codec_ctx->height);
      int height = decoder->video_codec_ctx->height;
 
      // Get current decode buffer based on which one we're using
      // (Buffer availability was already checked before entering the decode loop)
      image_t *decode_buffer = use_image_a ? decoder->prefetch_image_a : decoder->prefetch_image_b;
 
      // Reallocate if needed (width/height changed)
      if (decode_buffer->w != width || decode_buffer->h != height) {
        image_t *replacement = image_new((size_t)width, (size_t)height);
        if (!replacement) {
          SET_ERRNO(ERROR_MEMORY, "Failed to allocate prefetch image buffer");
          break;
        }
        image_destroy(decode_buffer);
        decode_buffer = replacement;
        // Update decoder's pointer to the reallocated buffer
        if (use_image_a) {
          decoder->prefetch_image_a = decode_buffer;
        } else {
          decoder->prefetch_image_b = decode_buffer;
        }
      }
 
      // Convert pixel format (rgb_pixel_t is 3 bytes: r, g, b)
      uint8_t *dst_data[1] = {(uint8_t *)decode_buffer->pixels};
      int dst_linesize[1] = {width * 3};
 
      static int decode_count = 0;
      if (++decode_count <= 3) {
        log_debug("[FRAME_DECODE] Frame %d: width=%d, height=%d, codec_pix_fmt=%d, frame_pix_fmt=%d (is_stdin=%d)",
                  decode_count, width, height, decoder->video_codec_ctx->pix_fmt, decoder->frame->format,
                  decoder->is_stdin);
      }
 
      // For fragmented MP4 from stdin, pixel format might not be set - default to YUV420p
      // which is standard for H.264/H.265 video codecs
      int pix_fmt_to_use = decoder->video_codec_ctx->pix_fmt;
      if (pix_fmt_to_use == AV_PIX_FMT_NONE) {
        if (decoder->frame->format != AV_PIX_FMT_NONE) {
          pix_fmt_to_use = decoder->frame->format;
          log_debug("[SWSCALE_FIX] Using frame->format=%d instead of codec pix_fmt (was NONE)", decoder->frame->format);
        } else {
          // Fragmented MP4: Default to YUV420p (standard for H.264/H.265)
          pix_fmt_to_use = AV_PIX_FMT_YUV420P;
          log_debug("[SWSCALE_FIX] Fragmented format: Using hardcoded YUV420p (frame->format was also NONE)");
        }
      }
 
      // Lazy initialize swscale context if not done at startup (happens with HTTP/stdin streams)
      if (!decoder->sws_ctx) {
        log_debug("Lazy init swscale: width=%d, height=%d, pix_fmt=%d", width, height, pix_fmt_to_use);
        if (width > 0 && height > 0 && pix_fmt_to_use != AV_PIX_FMT_NONE) {
          LOG_IO("swscaler", {
            decoder->sws_ctx = sws_getContext(width, height, pix_fmt_to_use, width, height, AV_PIX_FMT_RGB24,
                                              SWS_BILINEAR, NULL, NULL, NULL);
          });
          if (!decoder->sws_ctx) {
            SET_ERRNO(ERROR_MEDIA_DECODE,
                      "Failed to create swscale context: pix_fmt=%d (might be unsupported for conversion)",
                      pix_fmt_to_use);
            break;
          }
 
          // Set proper colorspace for H.264 video (BT.709)
          // sws_setColorspaceDetails(ctx, inv_table, srcRange, table, dstRange, brightness, contrast, saturation)
          const int *inv_table = sws_getCoefficients(SWS_CS_ITU709);
          const int *table = sws_getCoefficients(SWS_CS_ITU709);
          int ret_cs = sws_setColorspaceDetails(decoder->sws_ctx, inv_table, 0, table, 0, 0, 1 << 16, 1 << 16);
          if (ret_cs < 0) {
            log_warn("Failed to set BT.709 colorspace details (code=%d), continuing with defaults", ret_cs);
          } else {
            log_debug("Set BT.709 colorspace for H.264 YUV->RGB conversion");
          }
 
          log_debug("Lazy initialized swscale context with %dx%d from pix_fmt=%d", width, height, pix_fmt_to_use);
        } else {
          SET_ERRNO(ERROR_MEDIA_DECODE,
                    "Cannot initialize swscale: width=%d, height=%d, pix_fmt=%d (AV_PIX_FMT_NONE=%d)", width, height,
                    pix_fmt_to_use, AV_PIX_FMT_NONE);
          break;
        }
      }
 
      if (decode_count <= 3) {
        // Log input YUV data
        uint8_t *y_data = decoder->frame->data[0];
        uint8_t *u_data = decoder->frame->data[1];
        uint8_t *v_data = decoder->frame->data[2];
        log_debug("[YUV_INPUT] Frame %d: Y[0]=%u, U[0]=%u, V[0]=%u (linesize=%d,%d,%d)", decode_count,
                  y_data ? y_data[0] : 255, u_data ? u_data[0] : 255, v_data ? v_data[0] : 255,
                  decoder->frame->linesize[0], decoder->frame->linesize[1], decoder->frame->linesize[2]);
      }
 
      int ret_scale = traced_video_scale(decoder->sws_ctx, (const uint8_t *const *)decoder->frame->data,
                                         decoder->frame->linesize, 0, height, dst_data, dst_linesize);
      if (ret_scale <= 0) {
        SET_ERRNO(ERROR_MEDIA_DECODE, "Video conversion failed: %d", ret_scale);
        break;
      }
      if (decode_count <= 3) {
        log_debug("[SWS_SCALE] Frame %d: returned %d", decode_count, ret_scale);
        rgb_pixel_t *test_px = (rgb_pixel_t *)decode_buffer->pixels;
        log_debug("[SWS_RESULT] Frame %d: RGB[0]=(%u,%u,%u)", decode_count, test_px[0].r, test_px[0].g, test_px[0].b);
      }
 
      frame_decoded = true;
      break; // Exit while loop
    }
 
    // Release read_frame_mutex now that traced_packet_read() is done
    mutex_unlock(&decoder->read_frame_mutex);
 
    // Shutdown can race a buffered read without FFmpeg returning AVERROR_EXIT.
    // The caller's cancellation request is authoritative for this operation.
    bool (*cancel)(void *) = (bool (*)(void *))atomic_ptr_load(&decoder->should_exit_callback);
    bool cancelled = cancel && cancel(atomic_ptr_load(&decoder->exit_callback_user_data));
 
    if (frame_decoded) {
      char read_time_str[TIME_DURATION_BUFFER_SIZE];
      time_pretty(time_elapsed_ns(read_start_ns, time_get_ns()), -1, read_time_str, sizeof(read_time_str));
      log_dev_every(5 * US_PER_SEC_INT, "PREFETCH: decoded frame in %s", read_time_str);
    }
 
    // Re-acquire mutex to update prefetch state
    mutex_lock(&decoder->prefetch_mutex);
 
    // Mutex now held - update prefetch state
    bool obsolete = generation != decoder->seek_generation;
    bool interrupted = decoder->prefetch_should_stop || decoder->seeking_in_progress || obsolete || cancelled;
    errno_notifications_suppress(notifications_suppressed);
    if (interrupted)
      errno_scope_end(decode_scope, ASCIICHAT_ERRNO_HANDLED);
    if (obsolete) {
      frame_decoded = false;
      reached_eof = false;
    }
    if (!frame_decoded && !reached_eof && !interrupted) {
      if (!errno_peek_since(decode_scope, &decoder->prefetch_failure)) {
        if (packet_rejected)
          SET_ERRNO(ERROR_MEDIA_DECODE, "Video decoder rejected packet: %d", decode_result);
        else
          SET_ERRNO(ERROR_MEDIA_DECODE, "Background video decoding failed (FFmpeg result %d)", decode_result);
        if (!errno_peek_since(decode_scope, &decoder->prefetch_failure)) {
          decoder->prefetch_failure.code = ERROR_MEDIA_DECODE;
          SAFE_STRNCPY(decoder->prefetch_failure.context_message, "Background video decoding failed",
                       sizeof(decoder->prefetch_failure.context_message));
        }
      }
    }
 
    if (!frame_decoded && !reached_eof && !interrupted)
      atomic_store_explicit(&decoder->prefetch_failed, true, memory_order_release);
 
    if (frame_decoded) {
      // Get current decode buffer
      image_t *decode_buffer = use_image_a ? decoder->prefetch_image_a : decoder->prefetch_image_b;
 
      // Update the current prefetch image (main thread will pull from this)
      decoder->current_prefetch_image = decode_buffer;
      atomic_store_explicit(&decoder->prefetch_frame_ready, true, memory_order_release);
 
    } else if (cancelled || (!reached_eof && !interrupted)) {
      // A decoder error terminates prefetch; EOF waits for rewind above.
      break;
    }
  }
 
  mutex_unlock(&decoder->prefetch_mutex);
  log_debug("Video prefetch thread stopped");
  return NULL;
}

static asciichat_error_t open_codec_context(AVFormatContext *fmt_ctx, enum AVMediaType type, int *stream_idx,
                                            AVCodecContext **codec_ctx) {
  ASCII_OTEL_SCOPE(FFMPEG_CODEC_OPEN);
  ASCII_OTEL_ATTR_STRING("media.type", type == AVMEDIA_TYPE_AUDIO ? "audio" : "video");
  int ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
  if (ret < 0) {
    // Stream not found - not an error, just means no stream of this type
    *stream_idx = -1;
    *codec_ctx = NULL;
    return ASCIICHAT_OK;
  }
 
  *stream_idx = ret;
  AVStream *stream = fmt_ctx->streams[ret];
 
  // Find decoder
  const AVCodec *codec = avcodec_find_decoder(stream->codecpar->codec_id);
  if (!codec) {
    return SET_ERRNO(ERROR_MEDIA_DECODE, "Codec not found for stream %d", ret);
  }
 
  ASCII_OTEL_ATTR_STRING("media.codec", codec->name);
  // Allocate codec context
  *codec_ctx = avcodec_alloc_context3(codec);
  if (!*codec_ctx) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate codec context");
  }
 
  // Copy codec parameters
  ret = avcodec_parameters_to_context(*codec_ctx, stream->codecpar);
  if (ret < 0) {
    avcodec_free_context(codec_ctx);
    return SET_ERRNO(ret == AVERROR(ENOMEM) ? ERROR_MEMORY : ERROR_MEDIA_DECODE, "Failed to copy codec parameters");
  }
 
  // Open codec
  ret = avcodec_open2(*codec_ctx, codec, NULL);
  if (ret < 0) {
    avcodec_free_context(codec_ctx);
    return SET_ERRNO(ret == AVERROR(ENOMEM) ? ERROR_MEMORY : ERROR_MEDIA_DECODE, "Failed to open codec");
  }
 
  return ASCIICHAT_OK;
}
 
// A missing/unsupported stream can fall back to the other media type. Allocation
// and other initialization failures still fail decoder creation with their cause.
static asciichat_error_t open_optional_codec_context(AVFormatContext *format, enum AVMediaType type, int *stream_index,
                                                     AVCodecContext **context) {
  asciichat_errno_scope_t scope = errno_scope_begin();
  asciichat_error_t result = open_codec_context(format, type, stream_index, context);
  if (result == ERROR_MEDIA_DECODE && HAS_ERRNO_CODE_SINCE(scope, ERROR_MEDIA_DECODE)) {
    LOG_ERRNO_IF_SET("Optional media stream unavailable");
    avcodec_free_context(context);
    *stream_index = -1;
    errno_scope_end(scope, ASCIICHAT_ERRNO_DISMISSED);
    return ASCIICHAT_OK;
  }
  if (result != ASCIICHAT_OK)
    return result;
  ASSERT_NO_ERRNO_SINCE(scope);
  errno_scope_end(scope, ASCIICHAT_ERRNO_HANDLED);
  return ASCIICHAT_OK;
}
 
/* ============================================================================
 * Decoder Lifecycle
 * ============================================================================ */
 
ffmpeg_decoder_t *ffmpeg_decoder_create(const char *path) {
  return ffmpeg_decoder_create_interruptible(path, NULL, NULL);
}
 
ffmpeg_decoder_t *ffmpeg_decoder_create_interruptible(const char *path, bool (*cancel)(void *), void *data) {
  return ffmpeg_decoder_create_with_request_options(path, cancel, data, NULL, NULL, NULL);
}
 
ffmpeg_decoder_t *ffmpeg_decoder_create_with_request_options(const char *path, bool (*cancel)(void *), void *data,
                                                             const char *headers, const char *cookies,
                                                             const char *proxy) {
  ASCII_OTEL_SCOPE(FFMPEG_DECODER_CREATE_INTERRUPTIBLE);
  if (!path) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Path is NULL");
    return NULL;
  }
 
  // Suppress FFmpeg's verbose debug logging (H.264 codec warnings, etc.)
  // Only set this once, it's a global setting
  static bool ffmpeg_log_level_set = false;
  if (!ffmpeg_log_level_set) {
    av_log_set_level(AV_LOG_QUIET);                  // Suppress all FFmpeg logging
    av_log_set_callback(ffmpeg_silent_log_callback); // Install silent callback to discard all output
    ffmpeg_log_level_set = true;
  }
 
  ffmpeg_decoder_t *decoder = SAFE_MALLOC(sizeof(ffmpeg_decoder_t), ffmpeg_decoder_t *);
  if (!decoder) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate decoder");
    return NULL;
  }
 
  memset(decoder, 0, sizeof(*decoder));
  atomic_ptr_store(&decoder->should_exit_callback, (void *)cancel);
  atomic_ptr_store(&decoder->exit_callback_user_data, data);
  decoder->format_ctx = avformat_alloc_context();
  if (!decoder->format_ctx) {
    SAFE_FREE(decoder);
    return NULL;
  }
  decoder->format_ctx->interrupt_callback.callback = ffmpeg_interrupt_callback;
  decoder->format_ctx->interrupt_callback.opaque = decoder;
  decoder->video_stream_idx = -1;
  decoder->audio_stream_idx = -1;
  decoder->last_video_pts = -1.0;
  decoder->last_audio_pts = -1.0;
 
  // Capture FFmpeg's probing output (FFmpeg may write directly to either stream)
  int ret = 0;
  LOG_IO("ffmpeg", {
    // Configure FFmpeg options for HTTP streaming performance
    AVDictionary *options = NULL;
 
    // FFmpeg accepts HTTP authorities that the application URL validator rejects.
    // Classify the protocol rather than validating the host for timeout settings.
    bool is_http = path && (platform_strncasecmp(path, "http://", sizeof("http://") - 1) == 0 ||
                            platform_strncasecmp(path, "https://", sizeof("https://") - 1) == 0);
    asciichat_errno_scope_t url_scope = errno_scope_begin();
    bool is_url = is_http || (path && strstr(path, "://") && url_is_valid(path));
    errno_scope_end(url_scope, ASCIICHAT_ERRNO_DISMISSED);
    if (is_url) {
      if (headers && *headers)
        av_dict_set(&options, "headers", headers, 0);
      if (cookies && *cookies)
        av_dict_set(&options, "cookies", cookies, 0);
      if (proxy)
        av_dict_set(&options, "http_proxy", proxy, 0);
      // Limit probing to 32KB for faster format detection
      av_dict_set(&options, "probesize", "32768", 0);
      // Analyze for 100ms max to determine streams quickly
      av_dict_set(&options, "analyzeduration", "100000", 0);
      // Enable auto-reconnection for interrupted connections
      av_dict_set(&options, "reconnect", "1", 0);
      // Allow reconnection for streamed protocols
      av_dict_set(&options, "reconnect_streamed", "1", 0);
      // Set reasonable I/O timeout (10 seconds)
      av_dict_set(&options, "rw_timeout", "10000000", 0);
      // Enable HTTP persistent connection (keep-alive) for better performance
      av_dict_set(&options, "http_persistent", "1", 0);
      // Reduce connect timeout to fail faster if server is unreachable
      av_dict_set(&options, "connect_timeout", "5000000", 0);
    }
 
    // Open input file
    ret = traced_format_open(&decoder->format_ctx, path, NULL, &options);
    av_dict_free(&options); // Free options dictionary
 
    if (ret >= 0) {
      // Find stream info
      if (traced_format_probe(decoder->format_ctx, NULL) < 0) {
        ret = -1;
      }
    }
  });
 
  if (ret < 0) {
    if (ret == -1) {
      SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to find stream info");
    } else {
      SET_ERRNO(ERROR_MEDIA_OPEN, "Failed to open media file: %s", path);
    }
    if (decoder->format_ctx) {
      avformat_close_input(&decoder->format_ctx);
    }
    SAFE_FREE(decoder);
    return NULL;
  }
 
  // Install interrupt callback to allow seeking to interrupt long traced_packet_read() calls
  // Do this AFTER finding stream info to ensure format context is fully initialized
  if (decoder->format_ctx) {
    decoder->format_ctx->interrupt_callback.callback = ffmpeg_interrupt_callback;
    decoder->format_ctx->interrupt_callback.opaque = decoder;
  }
 
  // Open video codec
  asciichat_error_t err = open_optional_codec_context(decoder->format_ctx, AVMEDIA_TYPE_VIDEO,
                                                      &decoder->video_stream_idx, &decoder->video_codec_ctx);
  if (err != ASCIICHAT_OK) {
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  // Open audio codec - audio is enabled by default (no option needed)
  // Always try to open audio codec, don't rely on GET_OPTION(audio_enabled) which has a default issue
  err = open_optional_codec_context(decoder->format_ctx, AVMEDIA_TYPE_AUDIO, &decoder->audio_stream_idx,
                                    &decoder->audio_codec_ctx);
  if (err != ASCIICHAT_OK) {
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  // Require at least one stream
  if (decoder->video_stream_idx < 0 && decoder->audio_stream_idx < 0) {
    SET_ERRNO(ERROR_MEDIA_DECODE, "No video or audio streams found");
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  // Allocate frame and packet
  decoder->frame = av_frame_alloc();
  decoder->packet = av_packet_alloc();
  if (!decoder->frame || !decoder->packet) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate frame/packet");
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  // Initialize swscale context for video if present
  if (decoder->video_codec_ctx) {
    // Validate codec context has valid dimensions and pixel format
    // For HTTP streams, these might not be valid until first frame is read
    if (decoder->video_codec_ctx->width <= 0 || decoder->video_codec_ctx->height <= 0) {
      log_warn("Video codec has invalid dimensions (%dx%d), will initialize swscale on first frame",
               decoder->video_codec_ctx->width, decoder->video_codec_ctx->height);
      // Don't create swscale context yet - will create it lazily on first frame read
    } else if (decoder->video_codec_ctx->pix_fmt == AV_PIX_FMT_NONE) {
      log_warn("Video codec has invalid pixel format, will initialize swscale on first frame");
      // Don't create swscale context yet - will create it lazily on first frame read
    } else {
      // Create swscale context with valid parameters
      LOG_IO("swscaler", {
        decoder->sws_ctx =
            sws_getContext(decoder->video_codec_ctx->width, decoder->video_codec_ctx->height,
                           decoder->video_codec_ctx->pix_fmt, decoder->video_codec_ctx->width,
                           decoder->video_codec_ctx->height, AV_PIX_FMT_RGB24, SWS_BILINEAR, NULL, NULL, NULL);
      });
      if (!decoder->sws_ctx) {
        SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to create swscale context");
        ffmpeg_decoder_destroy(decoder);
        return NULL;
      }
    }
  }
 
  // Initialize swresample context for audio if present
  if (decoder->audio_codec_ctx) {
    // Store output sample rate for position tracking
    decoder->audio_sample_rate = TARGET_SAMPLE_RATE;
 
    // Allocate resampler context
    decoder->swr_ctx = swr_alloc();
    if (!decoder->swr_ctx) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate swresample context");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    // Set options
    av_opt_set_chlayout(decoder->swr_ctx, "in_chlayout", &decoder->audio_codec_ctx->ch_layout, 0);
    av_opt_set_int(decoder->swr_ctx, "in_sample_rate", decoder->audio_codec_ctx->sample_rate, 0);
    av_opt_set_sample_fmt(decoder->swr_ctx, "in_sample_fmt", decoder->audio_codec_ctx->sample_fmt, 0);
 
    AVChannelLayout out_ch_layout = AV_CHANNEL_LAYOUT_STEREO;
    av_opt_set_chlayout(decoder->swr_ctx, "out_chlayout", &out_ch_layout, 0);
    av_opt_set_int(decoder->swr_ctx, "out_sample_rate", TARGET_SAMPLE_RATE, 0);
    av_opt_set_sample_fmt(decoder->swr_ctx, "out_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
 
    // A mono source stays centered at unity gain in the stereo pipeline.
    if (decoder->audio_codec_ctx->ch_layout.nb_channels == 1) {
      const double matrix[] = {1.0, 1.0};
      swr_set_matrix(decoder->swr_ctx, matrix, 1);
    }
    // Initialize
    if (swr_init(decoder->swr_ctx) < 0) {
      SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to initialize swresample context");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    // Allocate audio buffer (10 seconds worth)
    decoder->audio_buffer_size = TARGET_SAMPLE_RATE * TARGET_CHANNELS * 10;
    decoder->audio_buffer = SAFE_MALLOC(decoder->audio_buffer_size * sizeof(float), float *);
    if (!decoder->audio_buffer) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate audio buffer");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
  }
 
  // Initialize video frame prefetching system (for YouTube streaming)
  if (decoder->video_stream_idx >= 0) {
    int width = decoder->video_codec_ctx->width;
    int height = decoder->video_codec_ctx->height;
 
    // Create two prefetch image buffers for double-buffering
    decoder->prefetch_image_a = image_new((size_t)width, (size_t)height);
    decoder->prefetch_image_b = image_new((size_t)width, (size_t)height);
    if (!decoder->prefetch_image_a || !decoder->prefetch_image_b) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate prefetch image buffers");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    decoder->current_prefetch_image = decoder->prefetch_image_a;
    decoder->prefetch_frame_ready = false;
 
    // Initialize prefetch mutex
    if (mutex_init(&decoder->prefetch_mutex, "ffmpeg_prefetch") != 0) {
      SET_ERRNO(ERROR_MEMORY, "Failed to initialize prefetch mutex");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    if (cond_init(&decoder->prefetch_cond, "ffmpeg_prefetch") != 0) {
      SET_ERRNO(ERROR_MEMORY, "Failed to initialize prefetch condition variable");
      mutex_destroy(&decoder->prefetch_mutex);
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    if (mutex_init(&decoder->read_frame_mutex, "ffmpeg_read_frame") != 0) {
      SET_ERRNO(ERROR_MEMORY, "Failed to initialize read_frame mutex");
      mutex_destroy(&decoder->prefetch_mutex);
      cond_destroy(&decoder->prefetch_cond);
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    decoder->prefetch_thread_running = false;
    decoder->prefetch_should_stop = false;
  }
 
  log_debug("FFmpeg decoder opened: %s (video=%s, audio=%s)", path, decoder->video_stream_idx >= 0 ? "yes" : "no",
            decoder->audio_stream_idx >= 0 ? "yes" : "no");
 
  char decoder_name[MEDIA_FFMPEG_DECODER_DECODER_NAME_BUFFER_SIZE];
  snprintf(decoder_name, sizeof(decoder_name), "%s", path);
  NAMED_REGISTER_FFMPEG_DECODER(decoder, decoder_name, NULL);
  NAMED_REGISTER_ATOMIC(&decoder->eof_reached, "ffmpeg_eof", decoder);
 
  return decoder;
}
 
ffmpeg_decoder_t *ffmpeg_decoder_create_stdin(void) {
  ASCII_OTEL_SCOPE(FFMPEG_DECODER_CREATE_STDIN);
  // Buffer entire stdin on first call (shared between video and audio decoders)
  if (!g_stdin_buffer) {
    log_debug("Reading stdin into buffer...");
    g_stdin_buffer = stdin_buffer_read_all();
    if (!g_stdin_buffer) {
      SET_ERRNO(ERROR_MEDIA_OPEN, "Failed to read stdin into buffer");
      return NULL;
    }
  }
 
  ffmpeg_decoder_t *decoder = SAFE_MALLOC(sizeof(ffmpeg_decoder_t), ffmpeg_decoder_t *);
  if (!decoder) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate decoder");
    return NULL;
  }
 
  memset(decoder, 0, sizeof(*decoder));
  decoder->video_stream_idx = -1;
  decoder->audio_stream_idx = -1;
  decoder->is_stdin = true;
  decoder->last_video_pts = -1.0;
  decoder->last_audio_pts = -1.0;
 
  // Create per-decoder reader (each decoder gets independent position tracking)
  stdin_buffer_reader_t *reader = SAFE_MALLOC(sizeof(stdin_buffer_reader_t), stdin_buffer_reader_t *);
  if (!reader) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer reader");
    SAFE_FREE(decoder);
    return NULL;
  }
  reader->buffer = g_stdin_buffer;
  reader->pos = 0; // Each decoder starts from position 0
 
  // AVIO takes ownership of this buffer and may resize or free it with av_free().
  decoder->avio_buffer = av_malloc(AVIO_BUFFER_SIZE);
  if (!decoder->avio_buffer) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate AVIO buffer");
    SAFE_FREE(reader);
    SAFE_FREE(decoder);
    return NULL;
  }
 
  decoder->avio_ctx = avio_alloc_context(decoder->avio_buffer, // internal buffer for AVIO
                                         AVIO_BUFFER_SIZE,     // buffer size
                                         0,                    // write_flag
                                         reader,               // opaque (per-decoder reader)
                                         memory_read_packet,
                                         NULL,              // write_packet
                                         memory_seek_packet // seek (memory is seekable)
  );
 
  if (!decoder->avio_ctx) {
    SET_ERRNO(ERROR_MEMORY, "Failed to create AVIO context");
    av_free(decoder->avio_buffer);
    decoder->avio_buffer = NULL;
    SAFE_FREE(decoder);
    return NULL;
  }
 
  // Mark AVIO context as seekable (memory buffer supports seeking)
  decoder->avio_ctx->seekable = AVIO_SEEKABLE_NORMAL;
 
  // Allocate format context
  decoder->format_ctx = avformat_alloc_context();
  if (!decoder->format_ctx) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate format context");
    av_freep(&decoder->avio_ctx->buffer);
    avio_context_free(&decoder->avio_ctx);
    SAFE_FREE(decoder);
    return NULL;
  }
 
  decoder->format_ctx->pb = decoder->avio_ctx;
  decoder->format_ctx->flags |= AVFMT_FLAG_CUSTOM_IO; // Tell FFmpeg to use our custom AVIO context
 
  // Capture FFmpeg's probing output
  int ret = 0;
  LOG_IO("ffmpeg", {
    // Open input from buffered stdin
    ret = traced_format_open(&decoder->format_ctx, NULL, NULL, NULL);
    if (ret >= 0) {
      // Find stream info
      if (traced_format_probe(decoder->format_ctx, NULL) < 0) {
        ret = -1;
      }
    }
  });
 
  if (ret < 0) {
    if (ret == -1) {
      SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to find stream info from stdin buffer");
    } else {
      SET_ERRNO(ERROR_MEDIA_OPEN, "Failed to open stdin buffer");
    }
    av_freep(&decoder->avio_ctx->buffer);
    avio_context_free(&decoder->avio_ctx);
    if (decoder->format_ctx) {
      avformat_free_context(decoder->format_ctx);
    }
    SAFE_FREE(decoder);
    return NULL;
  }
 
  // Open codecs (same as file-based decoder)
  asciichat_error_t err = open_optional_codec_context(decoder->format_ctx, AVMEDIA_TYPE_VIDEO,
                                                      &decoder->video_stream_idx, &decoder->video_codec_ctx);
  if (err != ASCIICHAT_OK) {
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  if (GET_OPTION(audio_enabled)) {
    err = open_optional_codec_context(decoder->format_ctx, AVMEDIA_TYPE_AUDIO, &decoder->audio_stream_idx,
                                      &decoder->audio_codec_ctx);
    if (err != ASCIICHAT_OK) {
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
  } else {
    decoder->audio_stream_idx = -1;
    decoder->audio_codec_ctx = NULL;
    log_debug("Audio decoding disabled by user option");
  }
 
  if (decoder->video_stream_idx < 0 && decoder->audio_stream_idx < 0) {
    SET_ERRNO(ERROR_MEDIA_DECODE, "No video or audio streams found in stdin");
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  // Allocate frame and packet
  decoder->frame = av_frame_alloc();
  decoder->packet = av_packet_alloc();
  if (!decoder->frame || !decoder->packet) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate frame/packet");
    ffmpeg_decoder_destroy(decoder);
    return NULL;
  }
 
  // Initialize swscale/swresample (same as file-based)
  if (decoder->video_codec_ctx) {
    // Validate codec context has valid dimensions and pixel format
    // For stdin/HTTP streams, these might not be valid until first frame is read
    if (decoder->video_codec_ctx->width <= 0 || decoder->video_codec_ctx->height <= 0) {
      log_warn("Video codec has invalid dimensions (%dx%d), will initialize swscale on first frame",
               decoder->video_codec_ctx->width, decoder->video_codec_ctx->height);
      // Don't create swscale context yet - will create it lazily on first frame read
    } else if (decoder->video_codec_ctx->pix_fmt == AV_PIX_FMT_NONE) {
      log_warn("Video codec has invalid pixel format, will initialize swscale on first frame");
      // Don't create swscale context yet - will create it lazily on first frame read
    } else {
      // Create swscale context with valid parameters
      LOG_IO("swscaler", {
        decoder->sws_ctx =
            sws_getContext(decoder->video_codec_ctx->width, decoder->video_codec_ctx->height,
                           decoder->video_codec_ctx->pix_fmt, decoder->video_codec_ctx->width,
                           decoder->video_codec_ctx->height, AV_PIX_FMT_RGB24, SWS_BILINEAR, NULL, NULL, NULL);
      });
      if (!decoder->sws_ctx) {
        SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to create swscale context");
        ffmpeg_decoder_destroy(decoder);
        return NULL;
      }
    }
  }
 
  if (decoder->audio_codec_ctx) {
    decoder->swr_ctx = swr_alloc();
    if (!decoder->swr_ctx) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate swresample context");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    av_opt_set_chlayout(decoder->swr_ctx, "in_chlayout", &decoder->audio_codec_ctx->ch_layout, 0);
    av_opt_set_int(decoder->swr_ctx, "in_sample_rate", decoder->audio_codec_ctx->sample_rate, 0);
    av_opt_set_sample_fmt(decoder->swr_ctx, "in_sample_fmt", decoder->audio_codec_ctx->sample_fmt, 0);
 
    AVChannelLayout out_ch_layout = AV_CHANNEL_LAYOUT_STEREO;
    av_opt_set_chlayout(decoder->swr_ctx, "out_chlayout", &out_ch_layout, 0);
    av_opt_set_int(decoder->swr_ctx, "out_sample_rate", TARGET_SAMPLE_RATE, 0);
    av_opt_set_sample_fmt(decoder->swr_ctx, "out_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
    if (decoder->audio_codec_ctx->ch_layout.nb_channels == 1) {
      const double matrix[] = {1.0, 1.0};
      swr_set_matrix(decoder->swr_ctx, matrix, 1);
    }
 
    if (swr_init(decoder->swr_ctx) < 0) {
      SET_ERRNO(ERROR_MEDIA_DECODE, "Failed to initialize swresample context");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    decoder->audio_buffer_size = TARGET_SAMPLE_RATE * TARGET_CHANNELS * 10;
    decoder->audio_buffer = SAFE_MALLOC(decoder->audio_buffer_size * sizeof(float), float *);
    if (!decoder->audio_buffer) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate audio buffer");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
  }
 
  // Initialize video frame prefetching system for stdin (same as file-based)
  if (decoder->video_stream_idx >= 0) {
    int width = decoder->video_codec_ctx->width;
    int height = decoder->video_codec_ctx->height;
 
    // For stdin sources, dimensions might be invalid initially (0x0)
    // Use default dimensions for prefetch buffers; they'll be resized on first frame
    if (width <= 0 || height <= 0) {
      width = 1920;  // Default width for stdin
      height = 1080; // Default height for stdin
      log_debug("stdin: Using default prefetch dimensions %dx%d (will be resized on first frame)", width, height);
    }
 
    // Create two prefetch image buffers for double-buffering
    decoder->prefetch_image_a = image_new((size_t)width, (size_t)height);
    decoder->prefetch_image_b = image_new((size_t)width, (size_t)height);
    if (!decoder->prefetch_image_a || !decoder->prefetch_image_b) {
      SET_ERRNO(ERROR_MEMORY, "Failed to allocate prefetch image buffers");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    decoder->current_prefetch_image = decoder->prefetch_image_a;
    decoder->prefetch_frame_ready = false;
 
    // Initialize prefetch mutex
    if (mutex_init(&decoder->prefetch_mutex, "ffmpeg_prefetch") != 0) {
      SET_ERRNO(ERROR_MEMORY, "Failed to initialize prefetch mutex");
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    if (cond_init(&decoder->prefetch_cond, "ffmpeg_prefetch") != 0) {
      SET_ERRNO(ERROR_MEMORY, "Failed to initialize prefetch condition variable");
      mutex_destroy(&decoder->prefetch_mutex);
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
 
    if (mutex_init(&decoder->read_frame_mutex, "ffmpeg_read_frame") != 0) {
      SET_ERRNO(ERROR_MEMORY, "Failed to initialize read_frame mutex");
      mutex_destroy(&decoder->prefetch_mutex);
      cond_destroy(&decoder->prefetch_cond);
      ffmpeg_decoder_destroy(decoder);
      return NULL;
    }
  }
 
  log_debug("FFmpeg decoder opened from stdin (video=%s, audio=%s)", decoder->video_stream_idx >= 0 ? "yes" : "no",
            decoder->audio_stream_idx >= 0 ? "yes" : "no");
 
  NAMED_REGISTER_FFMPEG_DECODER(decoder, "stdin", NULL);
  NAMED_REGISTER_ATOMIC(&decoder->eof_reached, "ffmpeg_eof", decoder);
 
  return decoder;
}
 
void ffmpeg_decoder_destroy(ffmpeg_decoder_t *decoder) {
  ASCII_OTEL_SCOPE(FFMPEG_DECODER_DESTROY);
  if (!decoder) {
    return;
  }
 
  NAMED_UNREGISTER(&decoder->eof_reached);
  NAMED_UNREGISTER(decoder);
 
  // Stop prefetch thread (signal it to stop and wait for it to finish)
  if (decoder->prefetch_thread_running) {
    mutex_lock(&decoder->prefetch_mutex);
    decoder->prefetch_should_stop = true;
    cond_signal(&decoder->prefetch_cond);
    mutex_unlock(&decoder->prefetch_mutex);
 
    // Wait for thread to finish
    thread_join(&decoder->prefetch_thread, NULL);
    decoder->prefetch_thread_running = false;
  }
 
  // Clean up prefetch state
  cond_destroy(&decoder->prefetch_cond);
  mutex_destroy(&decoder->prefetch_mutex);
  mutex_destroy(&decoder->read_frame_mutex);
 
  // Free prefetch image buffers
  if (decoder->prefetch_image_a) {
    image_destroy(decoder->prefetch_image_a);
    decoder->prefetch_image_a = NULL;
  }
  if (decoder->prefetch_image_b) {
    image_destroy(decoder->prefetch_image_b);
    decoder->prefetch_image_b = NULL;
  }
 
  // Don't destroy current_image - it points to one of the prefetch buffers
  // which have already been destroyed above
  decoder->current_image = NULL;
 
  // Free audio buffer
  SAFE_FREE(decoder->audio_buffer);
 
  // Free swscale context
  if (decoder->sws_ctx) {
    sws_freeContext(decoder->sws_ctx);
    decoder->sws_ctx = NULL;
  }
 
  // Free swresample context
  if (decoder->swr_ctx) {
    swr_free(&decoder->swr_ctx);
  }
 
  // Free frame and packet
  if (decoder->frame) {
    av_frame_free(&decoder->frame);
  }
  if (decoder->packet) {
    av_packet_free(&decoder->packet);
  }
 
  // Free codec contexts
  if (decoder->video_codec_ctx) {
    avcodec_free_context(&decoder->video_codec_ctx);
  }
  if (decoder->audio_codec_ctx) {
    avcodec_free_context(&decoder->audio_codec_ctx);
  }
 
  // Free format context
  if (decoder->format_ctx) {
    avformat_close_input(&decoder->format_ctx);
  }
 
  // Free AVIO context (stdin only)
  if (decoder->avio_ctx) {
    // Free the opaque reader for stdin
    if (decoder->is_stdin) {
      SAFE_FREE(decoder->avio_ctx->opaque);
    }
    av_freep(&decoder->avio_ctx->buffer);
    avio_context_free(&decoder->avio_ctx);
  }
 
  SAFE_FREE(decoder);
}
 
/* ============================================================================
 * Video Operations
 * ============================================================================ */
 
ffmpeg_frame_status_t ffmpeg_decoder_poll_video(ffmpeg_decoder_t *decoder, image_t **frame,
                                                asciichat_error_context_t *failure) {
  ASCII_OTEL_SCOPE(FFMPEG_DECODER_POLL_VIDEO);
  if (frame)
    *frame = NULL;
  if (failure)
    memset(failure, 0, sizeof(*failure));
  if (!decoder || !frame || !failure) {
    asciichat_errno_scope_t scope = errno_checkpoint();
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid video poll outputs");
    if (failure && !errno_peek_since(scope, failure))
      failure->code = ERROR_INVALID_PARAM;
    return FFMPEG_FRAME_FAILED;
  }
  // Empty polls need no protected state. EOF and errors still confirm under
  // the mutex so a final pending frame takes precedence over termination.
  if (!atomic_load_explicit(&decoder->prefetch_frame_ready, memory_order_acquire) &&
      !atomic_load_explicit(&decoder->prefetch_failed, memory_order_acquire) && !ffmpeg_decoder_at_end(decoder))
    return FFMPEG_FRAME_WAITING;
 
  mutex_lock(&decoder->prefetch_mutex);
  if (decoder->prefetch_frame_ready && decoder->current_prefetch_image) {
    // Taking the next image releases the previous reader-owned buffer.
    if (decoder->current_read_buffer == decoder->prefetch_image_a)
      decoder->buffer_a_in_use = false;
    else if (decoder->current_read_buffer == decoder->prefetch_image_b)
      decoder->buffer_b_in_use = false;
    *frame = decoder->current_prefetch_image;
    decoder->prefetch_frame_ready = false;
    if (*frame == decoder->prefetch_image_a)
      decoder->buffer_a_in_use = true;
    else if (*frame == decoder->prefetch_image_b)
      decoder->buffer_b_in_use = true;
    decoder->current_read_buffer = *frame;
    decoder->current_image = *frame;
    cond_signal(&decoder->prefetch_cond);
    mutex_unlock(&decoder->prefetch_mutex);
    return FFMPEG_FRAME_READY;
  }
  *failure = decoder->prefetch_failure;
  bool eof = ffmpeg_decoder_at_end(decoder);
  mutex_unlock(&decoder->prefetch_mutex);
  if (failure->code != ASCIICHAT_OK)
    return FFMPEG_FRAME_FAILED;
  return eof ? FFMPEG_FRAME_EOF : FFMPEG_FRAME_WAITING;
}
 
image_t *ffmpeg_decoder_read_video_frame(ffmpeg_decoder_t *decoder) {
  ASCII_OTEL_SCOPE(FFMPEG_DECODER_READ_VIDEO_FRAME);
  image_t *frame = NULL;
  asciichat_error_context_t failure = {0};
  if (ffmpeg_decoder_poll_video(decoder, &frame, &failure) == FFMPEG_FRAME_FAILED)
    errno_import(&failure);
  return frame;
}

asciichat_error_t ffmpeg_decoder_start_prefetch(ffmpeg_decoder_t *decoder) {
  if (!decoder || decoder->video_stream_idx < 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Decoder has no initialized video prefetch buffers");
  }
 
  if (!decoder->prefetch_image_a || !decoder->prefetch_image_b) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Decoder has no initialized video prefetch buffers");
  }
 
  // Already running
  if (decoder->prefetch_thread_running) {
    return ASCIICHAT_OK;
  }
 
  // Reset stop flag and create thread
  decoder->prefetch_should_stop = false;
  memset(&decoder->prefetch_failure, 0, sizeof(decoder->prefetch_failure));
  atomic_store(&decoder->prefetch_failed, false);
 
  int thread_err = platform_thread_create(&decoder->prefetch_thread, "ffmpeg_prefetch",
                                          ffmpeg_decoder_prefetch_thread_func, decoder);
  if (thread_err != 0) {
    return SET_ERRNO(ERROR_THREAD, "Failed to create video prefetch thread");
  }
 
  decoder->prefetch_thread_running = true;
  return ASCIICHAT_OK;
}

void ffmpeg_decoder_stop_prefetch(ffmpeg_decoder_t *decoder) {
  if (!decoder || !decoder->prefetch_thread_running) {
    return;
  }
 
  mutex_lock(&decoder->prefetch_mutex);
  decoder->prefetch_should_stop = true;
  cond_signal(&decoder->prefetch_cond);
  mutex_unlock(&decoder->prefetch_mutex);
  // Wait up to 2 seconds for thread to stop
  // The interrupt callback should cause av_read_frame to abort quickly
  if (thread_join_timeout(&decoder->prefetch_thread, NULL, 2000 * NS_PER_MS_INT) == ASCIICHAT_OK)
    decoder->prefetch_thread_running = false;
  // A timed-out worker remains owned and must be joined by decoder destruction.
  else
    log_warn("Video prefetch thread is still stopping");
}
 
void ffmpeg_decoder_set_exit_callback(ffmpeg_decoder_t *decoder, bool (*should_exit_callback)(void *),
                                      void *user_data) {
  if (!decoder) {
    return;
  }
  atomic_ptr_store(&decoder->exit_callback_user_data, user_data);
  atomic_ptr_store(&decoder->should_exit_callback, (void *)should_exit_callback);
}
 
bool ffmpeg_decoder_is_prefetch_running(ffmpeg_decoder_t *decoder) {
  if (!decoder) {
    return false;
  }
  return decoder->prefetch_thread_running;
}
 
bool ffmpeg_decoder_has_video(ffmpeg_decoder_t *decoder) {
  return decoder && decoder->video_stream_idx >= 0;
}
 
asciichat_error_t ffmpeg_decoder_get_video_dimensions(ffmpeg_decoder_t *decoder, int *width, int *height) {
  if (!decoder || decoder->video_stream_idx < 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Decoder has no video stream");
  }
 
  if (width) {
    *width = decoder->video_codec_ctx->width;
  }
  if (height) {
    *height = decoder->video_codec_ctx->height;
  }
 
  return ASCIICHAT_OK;
}
 
double ffmpeg_decoder_get_video_fps(ffmpeg_decoder_t *decoder) {
  if (!decoder || decoder->video_stream_idx < 0) {
    return -1.0;
  }
 
  AVStream *stream = decoder->format_ctx->streams[decoder->video_stream_idx];
 
  // Try avg_frame_rate first (average frame rate from entire stream)
  double fps = av_q2d_safe(stream->avg_frame_rate);
 
  // Fallback to r_frame_rate if avg_frame_rate is invalid or zero
  // r_frame_rate is the "real" frame rate based on codec parameters
  // This is more reliable for YouTube videos and some video codecs
  if (fps <= 0.0) {
    fps = av_q2d_safe(stream->r_frame_rate);
  }
 
  return fps;
}
 
/* ============================================================================
 * Audio Operations
 * ============================================================================ */
 
size_t ffmpeg_decoder_read_audio_samples(ffmpeg_decoder_t *decoder, float *buffer, size_t num_samples) {
  ASCII_OTEL_SCOPE(FFMPEG_DECODER_READ_AUDIO_SAMPLES);
  // Keep channels and the playback clock aligned even with odd caller capacity.
  num_samples -= num_samples % TARGET_CHANNELS;
  if (!decoder || decoder->audio_stream_idx < 0 || !buffer || num_samples == 0) {
    return 0;
  }
 
  mutex_lock(&decoder->read_frame_mutex);
  size_t samples_written = 0;
 
  // First, drain any buffered samples
  if (decoder->audio_buffer_offset > 0) {
    size_t available = decoder->audio_buffer_offset;
    size_t to_copy = (available < num_samples) ? available : num_samples;
 
    memcpy(buffer, decoder->audio_buffer, to_copy * sizeof(float));
    samples_written += to_copy;
 
    // Shift buffer
    if (to_copy < available) {
      memmove(decoder->audio_buffer, decoder->audio_buffer + to_copy, (available - to_copy) * sizeof(float));
    }
    decoder->audio_buffer_offset -= to_copy;
 
    if (samples_written >= num_samples) {
      decoder->audio_samples_read += samples_written / TARGET_CHANNELS;
      mutex_unlock(&decoder->read_frame_mutex);
      return samples_written;
    }
  }
 
  // Read more packets to fill the request
  static uint64_t packet_count = 0;
 
  while (samples_written < num_samples) {
    int ret = traced_packet_read(decoder->format_ctx, decoder->packet);
    if (ret < 0) {
      if (ret == AVERROR_EOF) {
        atomic_store_bool(&decoder->eof_reached, true);
      }
      break;
    }
 
    // Check if this is an audio packet
    if (decoder->packet->stream_index != decoder->audio_stream_idx) {
      av_packet_unref(decoder->packet);
      continue;
    }
 
    packet_count++;
    log_debug_every(US_PER_SEC_INT, "Audio packet #%lu: pts=%ld dts=%ld duration=%d size=%d", packet_count,
                    decoder->packet->pts, decoder->packet->dts, decoder->packet->duration, decoder->packet->size);
 
    // Send packet to decoder
    ret = traced_packet_send(decoder->audio_codec_ctx, decoder->packet);
    av_packet_unref(decoder->packet);
 
    if (ret < 0) {
      char error_message[AV_ERROR_MAX_STRING_SIZE];
      av_strerror(ret, error_message, sizeof(error_message));
      log_warn_every(US_PER_SEC_INT, "Error sending audio packet to decoder: %s", error_message);
      continue;
    }
 
    // Receive all decoded frames from this packet
    // Important: a single packet can produce multiple frames. Must drain all before next packet.
    while (1) {
      ret = traced_frame_receive(decoder->audio_codec_ctx, decoder->frame);
      if (ret == AVERROR(EAGAIN)) {
        break; // No more frames from this packet, get next packet
      } else if (ret < 0) {
        log_warn_every(US_PER_SEC_INT, "Error receiving audio frame from decoder");
        goto audio_read_done;
      }
 
      // Update position tracking
      decoder->last_audio_pts =
          get_frame_pts_seconds(decoder->frame, decoder->format_ctx->streams[decoder->audio_stream_idx]->time_base);
 
      // Resample the complete frame and retain output beyond this callback's
      // requested block. Flushing the resampler between packets would insert
      // padding into inputs whose sample rate differs from the output rate.
      uint8_t *out_ptr = (uint8_t *)decoder->audio_buffer;
      int converted =
          traced_audio_resample(decoder->swr_ctx, &out_ptr, (int)(decoder->audio_buffer_size / TARGET_CHANNELS),
                                (const uint8_t **)decoder->frame->data, decoder->frame->nb_samples);
 
      if (converted > 0) {
        size_t available = (size_t)converted * TARGET_CHANNELS;
        size_t remaining = num_samples - samples_written;
        size_t to_copy = available < remaining ? available : remaining;
        memcpy(buffer + samples_written, decoder->audio_buffer, to_copy * sizeof(float));
        samples_written += to_copy;
        decoder->audio_buffer_offset = available - to_copy;
        if (decoder->audio_buffer_offset > 0)
          memmove(decoder->audio_buffer, decoder->audio_buffer + to_copy, decoder->audio_buffer_offset * sizeof(float));
      }
 
      if (samples_written >= num_samples) {
        goto audio_read_done;
      }
    }
  }
 
audio_read_done:
  // Flush resampler buffer if we haven't filled the full request
  // The resampler may have buffered samples that need to be output
  if (samples_written < num_samples && atomic_load_bool(&decoder->eof_reached)) {
    int remaining_space = (int)((num_samples - samples_written) / TARGET_CHANNELS);
    uint8_t *out_ptr = (uint8_t *)(buffer + samples_written);
    int flushed = traced_audio_resample(decoder->swr_ctx, &out_ptr, remaining_space, NULL, 0);
    if (flushed > 0) {
      samples_written += (size_t)flushed * TARGET_CHANNELS;
    }
  }
 
  // Update sample-based position tracking
  decoder->audio_samples_read += samples_written / TARGET_CHANNELS;
  mutex_unlock(&decoder->read_frame_mutex);
 
  return samples_written;
}
 
bool ffmpeg_decoder_has_audio(ffmpeg_decoder_t *decoder) {
  return decoder && decoder->audio_stream_idx >= 0;
}
 
/* ============================================================================
 * Playback Control
 * ============================================================================ */
 
asciichat_error_t ffmpeg_decoder_rewind(ffmpeg_decoder_t *decoder) {
  return ffmpeg_decoder_seek_to_timestamp(decoder, 0);
}
 
asciichat_error_t ffmpeg_decoder_seek_to_timestamp(ffmpeg_decoder_t *decoder, double timestamp_sec) {
  ASCII_OTEL_SCOPE(FFMPEG_DECODER_SEEK_TO_TIMESTAMP);
  if (!decoder) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing decoder for seek");
  }
 
  if (decoder->is_stdin) {
    return ERROR_NOT_SUPPORTED; // Cannot seek stdin
  }
 
  // Hold mutex during entire seek operation to prevent race with prefetch thread
  mutex_lock(&decoder->prefetch_mutex);
 
  // Set flag to pause prefetch thread via condition variable
  decoder->seeking_in_progress = true;
  ++decoder->seek_generation;
  // Serialize codec and partial-audio state with the existing packet reader.
  mutex_lock(&decoder->read_frame_mutex);
  // The old reader has stopped. Holding both guards prevents another read;
  // the seek must not cancel its own I/O through the interrupt callback.
  decoder->seeking_in_progress = false;
  if (decoder->format_ctx->pb && decoder->format_ctx->pb->error == AVERROR_EXIT)
    decoder->format_ctx->pb->error = 0;
 
  // Convert seconds to FFmpeg time base units (AV_TIME_BASE = 1,000,000)
  int64_t target_ts = (int64_t)(timestamp_sec * AV_TIME_BASE);
 
  // For HTTP streams, use simple keyframe seeking (faster than frame-accurate seeking)
  // HTTP seeking is expensive and can break stream state, so prefer speed over precision
  int seek_ret = av_seek_frame(decoder->format_ctx, -1, target_ts, AVSEEK_FLAG_BACKWARD);
  if (seek_ret < 0) {
    // Fallback: try without backward flag
    seek_ret = av_seek_frame(decoder->format_ctx, -1, target_ts, 0);
  }
 
  if (seek_ret < 0) {
    decoder->seeking_in_progress = false;
    mutex_unlock(&decoder->read_frame_mutex);
    cond_signal(&decoder->prefetch_cond);
    mutex_unlock(&decoder->prefetch_mutex);
    return SET_ERRNO(ERROR_MEDIA_SEEK, "Failed to seek to timestamp %.2f seconds", timestamp_sec);
  }
 
  // Flush codec buffers AFTER seeking
  if (decoder->video_codec_ctx) {
    avcodec_flush_buffers(decoder->video_codec_ctx);
  }
  if (decoder->audio_codec_ctx) {
    avcodec_flush_buffers(decoder->audio_codec_ctx);
  }
 
  // Reset state
  atomic_store_bool(&decoder->eof_reached, false);
  decoder->video_draining = false;
  decoder->audio_buffer_offset = 0;
  // Clear any stale audio data in buffer
  if (decoder->audio_buffer) {
    memset(decoder->audio_buffer, 0, decoder->audio_buffer_size * sizeof(float));
  }
  decoder->last_video_pts = -1.0;
  decoder->last_audio_pts = -1.0;
  decoder->prefetch_frame_ready = false;
  // Set audio_samples_read to match the seek target so position tracking works correctly
  decoder->audio_samples_read = (uint64_t)(timestamp_sec * decoder->audio_sample_rate);
 
  // The consumer retains its image across seeks until it takes a replacement.
 
  // Resume prefetch thread
  decoder->seeking_in_progress = false;
  mutex_unlock(&decoder->read_frame_mutex);
  cond_signal(&decoder->prefetch_cond);
 
  // Release mutex - prefetch thread can resume
  mutex_unlock(&decoder->prefetch_mutex);
 
  return ASCIICHAT_OK;
}
 
bool ffmpeg_decoder_at_end(ffmpeg_decoder_t *decoder) {
  return decoder && atomic_load_bool(&decoder->eof_reached);
}
 
double ffmpeg_decoder_get_duration(ffmpeg_decoder_t *decoder) {
  if (!decoder || !decoder->format_ctx) {
    return -1.0;
  }
 
  if (decoder->format_ctx->duration == AV_NOPTS_VALUE) {
    return -1.0;
  }
 
  return (double)decoder->format_ctx->duration / AV_TIME_BASE;
}
 
double ffmpeg_decoder_get_position(ffmpeg_decoder_t *decoder) {
  if (!decoder) {
    return -1.0;
  }
 
  // Prefer sample-based position tracking (continuous, works before frames are decoded)
  if (decoder->audio_sample_rate > 0 && decoder->audio_samples_read >= 0) {
    return (double)decoder->audio_samples_read / (double)decoder->audio_sample_rate;
  }
 
  // Fallback to frame-based position if available
  if (decoder->last_video_pts >= 0.0) {
    return decoder->last_video_pts;
  } else if (decoder->last_audio_pts >= 0.0) {
    return decoder->last_audio_pts;
  }
 
  return -1.0;
}