Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

33.2 KB
Raw Blame
use anyhow::{Context, Result, anyhow};
use cap_muxer_protocol::{
    Frame, InitAudio, InitVideo, PACKET_FLAG_KEYFRAME, Packet, ProtocolError, STREAM_INDEX_AUDIO,
    STREAM_INDEX_VIDEO, StartParams, read_frame,
};
use ffmpeg::{codec, format};
use std::collections::VecDeque;
use std::ffi::CString;
use std::io::{self, BufReader, Write};
use std::path::PathBuf;
use std::process::ExitCode;
use std::sync::{Arc, Condvar, Mutex, PoisonError};

const EXIT_OK: u8 = 0;
const EXIT_PROTOCOL_ERROR: u8 = 10;
const EXIT_FFMPEG_ERROR: u8 = 20;
const EXIT_INIT_ERROR: u8 = 30;
const EXIT_ABORT: u8 = 40;
const EXIT_BAD_STATE: u8 = 50;
pub const EXIT_DISK_FULL: u8 = 60;

fn main() -> ExitCode {
    init_tracing();

    match run() {
        Ok(()) => ExitCode::from(EXIT_OK),
        Err(MuxerError::Protocol(err)) => {
            report(format_args!("cap-muxer protocol error: {err}"));
            ExitCode::from(EXIT_PROTOCOL_ERROR)
        }
        Err(MuxerError::DiskFull(err)) => {
            report(format_args!("cap-muxer disk full: {err:#}"));
            ExitCode::from(EXIT_DISK_FULL)
        }
        Err(MuxerError::FFmpeg(err)) => {
            report(format_args!("cap-muxer ffmpeg error: {err:#}"));
            ExitCode::from(EXIT_FFMPEG_ERROR)
        }
        Err(MuxerError::Init(err)) => {
            report(format_args!("cap-muxer init error: {err:#}"));
            ExitCode::from(EXIT_INIT_ERROR)
        }
        Err(MuxerError::Abort(reason)) => {
            report(format_args!("cap-muxer parent abort: {reason}"));
            ExitCode::from(EXIT_ABORT)
        }
        Err(MuxerError::BadState(reason)) => {
            report(format_args!("cap-muxer bad state: {reason}"));
            ExitCode::from(EXIT_BAD_STATE)
        }
    }
}

/// Writes to stderr without panicking: when the recorder dies, the pipe it
/// read our stderr through is closed, and the open fragment must still be
/// finished after that.
fn report(message: std::fmt::Arguments) {
    let _ = writeln!(io::stderr(), "{message}");
}

fn init_tracing() {
    let filter = std::env::var("CAP_MUXER_LOG").unwrap_or_else(|_| "info".to_string());
    let _ = tracing_subscriber::fmt()
        .with_env_filter(filter)
        .with_writer(std::io::stderr)
        .log_internal_errors(false)
        .try_init();
}

#[derive(thiserror::Error, Debug)]
enum MuxerError {
    #[error("{0}")]
    Protocol(#[from] ProtocolError),
    #[error("{0:#}")]
    FFmpeg(anyhow::Error),
    #[error("{0:#}")]
    Init(anyhow::Error),
    #[error("{0}")]
    Abort(String),
    #[error("{0}")]
    BadState(String),
    #[error("{0:#}")]
    DiskFull(anyhow::Error),
}

fn classify_io_error(err: &ffmpeg::Error) -> bool {
    let ffmpeg::Error::Other { errno } = err else {
        return false;
    };
    if *errno == libc::ENOSPC {
        return true;
    }
    #[cfg(windows)]
    if *errno == 112 {
        return true;
    }
    false
}

const DEFAULT_FRAME_QUEUE_BYTES: usize = 64 * 1024 * 1024;

fn resolve_queue_capacity() -> usize {
    std::env::var("CAP_MUXER_IO_BUF_MB")
        .ok()
        .and_then(|s| s.parse::<usize>().ok())
        .filter(|&mb| mb > 0 && mb <= 1024)
        .map(|mb| mb * 1024 * 1024)
        .unwrap_or(DEFAULT_FRAME_QUEUE_BYTES)
}

struct FrameQueueInner {
    frames: VecDeque<Frame>,
    bytes: usize,
    cancelled: bool,
    reader_done: bool,
    reader_err: Option<ProtocolError>,
    capacity_bytes: usize,
}

struct FrameQueue {
    state: Mutex<FrameQueueInner>,
    data_cv: Condvar,
    space_cv: Condvar,
}

impl FrameQueue {
    fn new(capacity_bytes: usize) -> Self {
        Self {
            state: Mutex::new(FrameQueueInner {
                frames: VecDeque::with_capacity(256),
                bytes: 0,
                cancelled: false,
                reader_done: false,
                reader_err: None,
                capacity_bytes,
            }),
            data_cv: Condvar::new(),
            space_cv: Condvar::new(),
        }
    }

    fn push(&self, frame: Frame) -> bool {
        let frame_bytes = frame_size_hint(&frame);
        let mut guard = self.state.lock().unwrap_or_else(PoisonError::into_inner);
        while !guard.cancelled
            && guard.bytes + frame_bytes > guard.capacity_bytes
            && !guard.frames.is_empty()
        {
            guard = self
                .space_cv
                .wait(guard)
                .unwrap_or_else(PoisonError::into_inner);
        }
        if guard.cancelled {
            return false;
        }
        guard.bytes = guard.bytes.saturating_add(frame_bytes);
        guard.frames.push_back(frame);
        drop(guard);
        self.data_cv.notify_one();
        true
    }

    fn cancel(&self) {
        let mut guard = self.state.lock().unwrap_or_else(PoisonError::into_inner);
        guard.cancelled = true;
        guard.frames.clear();
        guard.bytes = 0;
        drop(guard);
        self.data_cv.notify_all();
        self.space_cv.notify_all();
    }

    fn mark_reader_done(&self, err: Option<ProtocolError>) {
        let mut guard = self.state.lock().unwrap_or_else(PoisonError::into_inner);
        guard.reader_done = true;
        if err.is_some() {
            guard.reader_err = err;
        }
        drop(guard);
        self.data_cv.notify_all();
        self.space_cv.notify_all();
    }

    fn pop(&self) -> PopResult {
        let mut guard = self.state.lock().unwrap_or_else(PoisonError::into_inner);
        loop {
            if let Some(frame) = guard.frames.pop_front() {
                let size = frame_size_hint(&frame);
                guard.bytes = guard.bytes.saturating_sub(size);
                drop(guard);
                self.space_cv.notify_one();
                return PopResult::Frame(frame);
            }
            if guard.cancelled {
                return PopResult::Drained;
            }
            if guard.reader_done {
                let err = guard.reader_err.take();
                return match err {
                    Some(err) => PopResult::Error(err),
                    None => PopResult::Drained,
                };
            }
            guard = self
                .data_cv
                .wait(guard)
                .unwrap_or_else(PoisonError::into_inner);
        }
    }
}

enum PopResult {
    Frame(Frame),
    Drained,
    Error(ProtocolError),
}

fn frame_size_hint(frame: &Frame) -> usize {
    const HEADER_OVERHEAD: usize = 64;
    match frame {
        Frame::InitVideo(v) => HEADER_OVERHEAD + v.extradata.len() + v.codec.len(),
        Frame::InitAudio(a) => HEADER_OVERHEAD + a.extradata.len() + a.codec.len(),
        Frame::Start(p) => {
            HEADER_OVERHEAD
                + p.output_directory.len()
                + p.init_segment_name.len()
                + p.media_segment_pattern.len()
        }
        Frame::Packet(p) => HEADER_OVERHEAD + p.data.len(),
        Frame::Finish => HEADER_OVERHEAD,
        Frame::Abort(reason) => HEADER_OVERHEAD + reason.len(),
    }
}

fn cancel_reader(queue: &FrameQueue, reader_handle: std::thread::JoinHandle<()>) {
    queue.cancel();
    drop(reader_handle);
}

fn run() -> Result<(), MuxerError> {
    ffmpeg::init().map_err(|e| MuxerError::Init(anyhow::Error::from(e)))?;

    let capacity_bytes = resolve_queue_capacity();
    let queue = Arc::new(FrameQueue::new(capacity_bytes));
    tracing::info!(
        capacity_mb = capacity_bytes / 1024 / 1024,
        "cap-muxer async frame queue initialized"
    );

    let reader_handle = {
        let queue = Arc::clone(&queue);
        std::thread::Builder::new()
            .name("cap-muxer-stdin-reader".to_string())
            .spawn(move || {
                let stdin = io::stdin();
                let mut reader = BufReader::with_capacity(1024 * 1024, stdin.lock());
                loop {
                    match read_frame(&mut reader) {
                        Ok(frame) => {
                            if !queue.push(frame) {
                                return;
                            }
                        }
                        Err(ProtocolError::Io(ref ioe))
                            if ioe.kind() == io::ErrorKind::UnexpectedEof =>
                        {
                            queue.mark_reader_done(None);
                            return;
                        }
                        Err(e) => {
                            queue.mark_reader_done(Some(e));
                            return;
                        }
                    }
                }
            })
            .map_err(|e| MuxerError::Init(anyhow!("spawn stdin reader thread: {e}")))?
    };

    let mut state = State::default();
    let mut result = Ok(());

    loop {
        match queue.pop() {
            PopResult::Frame(frame) => match handle_frame(&mut state, frame) {
                Ok(Control::Continue) => {}
                Ok(Control::Finish) => {
                    break;
                }
                Err(e) => {
                    result = Err(e);
                    break;
                }
            },
            PopResult::Drained => {
                tracing::warn!("cap-muxer stdin closed without Finish; attempting graceful finish");
                break;
            }
            PopResult::Error(e) => {
                result = Err(MuxerError::Protocol(e));
                break;
            }
        }
    }

    cancel_reader(&queue, reader_handle);
    let finish_result = state.finish();

    result?;
    finish_result?;

    writeln!(io::stderr(), "cap-muxer finished cleanly").ok();
    Ok(())
}

enum Control {
    Continue,
    Finish,
}

#[derive(Default)]
struct State {
    init_video: Option<InitVideo>,
    init_audio: Option<InitAudio>,
    started: bool,
    output: Option<OpenOutput>,
}

struct OpenOutput {
    ctx: format::context::Output,
    video_stream_index: Option<usize>,
    audio_stream_index: Option<usize>,
    video_time_base: Option<ffmpeg::Rational>,
    audio_time_base: Option<ffmpeg::Rational>,
    packets_written_video: u64,
    packets_written_audio: u64,
    video_keyframe_seen: bool,
    video_packets_dropped_pre_keyframe: u64,
    audio_packets_dropped_pre_video: u64,
    pending_video_packet: Option<Packet>,
    pending_audio_packet: Option<Packet>,
    last_video_duration_input_tb: Option<i64>,
    last_audio_duration_input_tb: Option<i64>,
    start_ts: Option<std::time::Instant>,
    _base_path: PathBuf,
}

impl State {
    fn finish(&mut self) -> Result<(), MuxerError> {
        if let Some(out) = self.output.as_mut() {
            flush_pending_packets(out, self.init_video.as_ref(), self.init_audio.as_ref())?;
        }
        if let Some(mut out) = self.output.take() {
            if out.packets_written_video == 0 && out.packets_written_audio == 0 {
                // FFmpeg 7.1 divides by zero when finalizing an empty DASH manifest;
                // dropping the initialized context still closes its files and streams.
                return Ok(());
            }
            out.ctx.write_trailer().map_err(|e| {
                let err = anyhow!("write_trailer: {e}");
                if classify_io_error(&e) {
                    MuxerError::DiskFull(err)
                } else {
                    MuxerError::FFmpeg(err)
                }
            })?;
            let elapsed = out
                .start_ts
                .map(|t| t.elapsed().as_secs_f64())
                .unwrap_or(0.0);
            writeln!(
                io::stderr(),
                "cap-muxer trailer written; video_packets={} audio_packets={} duration_secs={:.2}",
                out.packets_written_video,
                out.packets_written_audio,
                elapsed
            )
            .ok();
        }
        Ok(())
    }
}

fn handle_frame(state: &mut State, frame: Frame) -> Result<Control, MuxerError> {
    match frame {
        Frame::InitVideo(init) => {
            if state.started {
                return Err(MuxerError::BadState("init_video after start".to_string()));
            }
            state.init_video = Some(init);
            Ok(Control::Continue)
        }
        Frame::InitAudio(init) => {
            if state.started {
                return Err(MuxerError::BadState("init_audio after start".to_string()));
            }
            state.init_audio = Some(init);
            Ok(Control::Continue)
        }
        Frame::Start(params) => {
            if state.started {
                return Err(MuxerError::BadState("duplicate start".to_string()));
            }
            let output = open_output(state, &params)?;
            state.output = Some(output);
            state.started = true;
            Ok(Control::Continue)
        }
        Frame::Packet(packet) => {
            if !state.started {
                return Err(MuxerError::BadState("packet before start".to_string()));
            }
            write_packet(state, packet)?;
            Ok(Control::Continue)
        }
        Frame::Finish => Ok(Control::Finish),
        Frame::Abort(reason) => Err(MuxerError::Abort(reason)),
    }
}

fn open_output(state: &mut State, params: &StartParams) -> Result<OpenOutput, MuxerError> {
    let base_path = PathBuf::from(&params.output_directory);
    std::fs::create_dir_all(&base_path)
        .with_context(|| format!("create_dir_all({})", base_path.display()))
        .map_err(MuxerError::Init)?;

    let manifest_path = base_path.join("dash_manifest.mpd");

    #[cfg(target_os = "windows")]
    let manifest_path_str = manifest_path.to_string_lossy().replace('\\', "/");
    #[cfg(not(target_os = "windows"))]
    let manifest_path_str = manifest_path.to_string_lossy().to_string();

    let mut output = format::output_as(&manifest_path_str, "dash")
        .map_err(|e| MuxerError::FFmpeg(anyhow!("format::output_as: {e}")))?;

    unsafe {
        let opts = output.as_mut_ptr();
        let set_opt = |key: &str, value: &str| {
            let k = CString::new(key).unwrap();
            let v = CString::new(value).unwrap();
            ffmpeg::ffi::av_opt_set((*opts).priv_data, k.as_ptr(), v.as_ptr(), 0);
        };
        set_opt("init_seg_name", &params.init_segment_name);
        set_opt("media_seg_name", &params.media_segment_pattern);
        let segment_duration_secs = state
            .init_video
            .as_ref()
            .map(|v| v.segment_duration_ms as f64 / 1000.0)
            .unwrap_or(2.0);
        set_opt("seg_duration", &segment_duration_secs.to_string());
        set_opt("use_timeline", "1");
        set_opt("use_template", "1");
        set_opt("single_file", "0");
        set_opt("hls_playlist", "1");
        set_opt(
            "format_options",
            "movflags=+negative_cts_offsets+skip_trailer",
        );
    }

    let mut video_stream_index = None;
    let mut audio_stream_index = None;
    let mut video_time_base = None;
    let mut audio_time_base = None;

    if let Some(init) = &state.init_video {
        let codec = codec::encoder::find_by_name(&init.codec)
            .ok_or_else(|| MuxerError::Init(anyhow!("video codec not found: {}", init.codec)))?;

        let mut stream = output
            .add_stream(codec)
            .map_err(|e| MuxerError::FFmpeg(anyhow!("add_stream video: {e}")))?;

        unsafe {
            let st = stream.as_mut_ptr();
            let cp = (*st).codecpar;
            (*cp).codec_type = ffmpeg::ffi::AVMediaType::AVMEDIA_TYPE_VIDEO;
            (*cp).codec_id = codec.id().into();
            (*cp).width = init.width as i32;
            (*cp).height = init.height as i32;
            (*cp).format = ffmpeg::ffi::AVPixelFormat::AV_PIX_FMT_YUV420P as i32;
            (*cp).bit_rate = 0;

            if !init.extradata.is_empty() {
                let size = init.extradata.len() as i32;
                let ptr = ffmpeg::ffi::av_mallocz(
                    size as usize + ffmpeg::ffi::AV_INPUT_BUFFER_PADDING_SIZE as usize,
                ) as *mut u8;
                if ptr.is_null() {
                    return Err(MuxerError::Init(anyhow!(
                        "failed to allocate extradata buffer"
                    )));
                }
                std::ptr::copy_nonoverlapping(init.extradata.as_ptr(), ptr, init.extradata.len());
                (*cp).extradata = ptr;
                (*cp).extradata_size = size;
            }
        }

        let tb = ffmpeg::Rational::new(init.time_base_num, init.time_base_den);
        stream.set_time_base(tb);
        video_stream_index = Some(stream.index());
        video_time_base = Some(tb);
    }

    if let Some(init) = &state.init_audio {
        let codec = codec::encoder::find_by_name(&init.codec)
            .ok_or_else(|| MuxerError::Init(anyhow!("audio codec not found: {}", init.codec)))?;

        let mut stream = output
            .add_stream(codec)
            .map_err(|e| MuxerError::FFmpeg(anyhow!("add_stream audio: {e}")))?;

        unsafe {
            let st = stream.as_mut_ptr();
            let cp = (*st).codecpar;
            (*cp).codec_type = ffmpeg::ffi::AVMediaType::AVMEDIA_TYPE_AUDIO;
            (*cp).codec_id = codec.id().into();
            (*cp).sample_rate = init.sample_rate as i32;
            (*cp).ch_layout.nb_channels = init.channels as i32;
            (*cp).ch_layout.order = ffmpeg::ffi::AVChannelOrder::AV_CHANNEL_ORDER_NATIVE;
            (*cp).ch_layout.u.mask = match init.channels {
                1 => ffmpeg::ffi::AV_CH_LAYOUT_MONO,
                2 => ffmpeg::ffi::AV_CH_LAYOUT_STEREO,
                _ => ffmpeg::ffi::AV_CH_LAYOUT_STEREO,
            };

            if !init.extradata.is_empty() {
                let size = init.extradata.len() as i32;
                let ptr = ffmpeg::ffi::av_mallocz(
                    size as usize + ffmpeg::ffi::AV_INPUT_BUFFER_PADDING_SIZE as usize,
                ) as *mut u8;
                if ptr.is_null() {
                    return Err(MuxerError::Init(anyhow!(
                        "failed to allocate audio extradata buffer"
                    )));
                }
                std::ptr::copy_nonoverlapping(init.extradata.as_ptr(), ptr, init.extradata.len());
                (*cp).extradata = ptr;
                (*cp).extradata_size = size;
            }
        }

        let tb = ffmpeg::Rational::new(init.time_base_num, init.time_base_den);
        stream.set_time_base(tb);
        audio_stream_index = Some(stream.index());
        audio_time_base = Some(tb);
    }

    output.write_header().map_err(|e| {
        let err = anyhow!("write_header: {e}");
        if classify_io_error(&e) {
            MuxerError::DiskFull(err)
        } else {
            MuxerError::FFmpeg(err)
        }
    })?;

    Ok(OpenOutput {
        ctx: output,
        video_stream_index,
        audio_stream_index,
        video_time_base,
        audio_time_base,
        packets_written_video: 0,
        packets_written_audio: 0,
        video_keyframe_seen: video_stream_index.is_none(),
        video_packets_dropped_pre_keyframe: 0,
        audio_packets_dropped_pre_video: 0,
        pending_video_packet: None,
        pending_audio_packet: None,
        last_video_duration_input_tb: None,
        last_audio_duration_input_tb: None,
        start_ts: Some(std::time::Instant::now()),
        _base_path: base_path,
    })
}

fn write_packet(state: &mut State, packet: Packet) -> Result<(), MuxerError> {
    let Some(out) = state.output.as_mut() else {
        return Err(MuxerError::BadState("no output".to_string()));
    };

    if packet.stream_index == STREAM_INDEX_VIDEO {
        let is_keyframe = packet.flags & PACKET_FLAG_KEYFRAME != 0;
        if !out.video_keyframe_seen {
            if !is_keyframe {
                out.video_packets_dropped_pre_keyframe += 1;
                if out.video_packets_dropped_pre_keyframe == 1
                    || out.video_packets_dropped_pre_keyframe.is_multiple_of(30)
                {
                    tracing::warn!(
                        dropped = out.video_packets_dropped_pre_keyframe,
                        "cap-muxer discarding non-keyframe video packets before first keyframe"
                    );
                }
                return Ok(());
            }
            out.video_keyframe_seen = true;
            if out.video_packets_dropped_pre_keyframe > 0 {
                tracing::info!(
                    dropped = out.video_packets_dropped_pre_keyframe,
                    "cap-muxer first video keyframe received"
                );
            }
        }
    } else if packet.stream_index == STREAM_INDEX_AUDIO
        && out.video_stream_index.is_some()
        && !out.video_keyframe_seen
    {
        out.audio_packets_dropped_pre_video += 1;
        if out.audio_packets_dropped_pre_video == 1
            || out.audio_packets_dropped_pre_video.is_multiple_of(100)
        {
            tracing::debug!(
                dropped = out.audio_packets_dropped_pre_video,
                "cap-muxer holding audio until first video keyframe"
            );
        }
        return Ok(());
    }

    let ready_packet = match packet.stream_index {
        STREAM_INDEX_VIDEO => queue_packet_for_stream(
            &mut out.pending_video_packet,
            &mut out.last_video_duration_input_tb,
            packet,
        ),
        STREAM_INDEX_AUDIO => queue_packet_for_stream(
            &mut out.pending_audio_packet,
            &mut out.last_audio_duration_input_tb,
            packet,
        ),
        other => {
            return Err(MuxerError::BadState(format!(
                "unknown stream index {other}"
            )));
        }
    };

    if let Some((ready_packet, duration_input_tb)) = ready_packet {
        write_ready_packet(out, ready_packet, duration_input_tb)?;
    }

    Ok(())
}

fn queue_packet_for_stream(
    pending: &mut Option<Packet>,
    last_duration_input_tb: &mut Option<i64>,
    packet: Packet,
) -> Option<(Packet, i64)> {
    let derived_duration = pending.as_ref().map(|previous| {
        derive_duration_from_adjacent_dts(previous, &packet, *last_duration_input_tb)
    });

    let previous = pending.replace(packet);

    match (previous, derived_duration) {
        (Some(previous), Some(duration)) => {
            if duration > 0 {
                *last_duration_input_tb = Some(duration);
            }
            Some((previous, duration))
        }
        _ => None,
    }
}

fn derive_duration_from_adjacent_dts(
    current: &Packet,
    next: &Packet,
    last_duration_input_tb: Option<i64>,
) -> i64 {
    let dts_delta = next.dts.saturating_sub(current.dts);
    if dts_delta > 0 {
        return dts_delta;
    }

    resolve_packet_duration(current.duration, last_duration_input_tb, None)
}

fn resolve_packet_duration(
    packet_duration: u64,
    last_duration_input_tb: Option<i64>,
    fallback_duration_input_tb: Option<i64>,
) -> i64 {
    i64::try_from(packet_duration)
        .ok()
        .filter(|duration| *duration > 0)
        .or(last_duration_input_tb.filter(|duration| *duration > 0))
        .or(fallback_duration_input_tb.filter(|duration| *duration > 0))
        .unwrap_or(1)
}

fn flush_pending_packets(
    out: &mut OpenOutput,
    video_init: Option<&InitVideo>,
    audio_init: Option<&InitAudio>,
) -> Result<(), MuxerError> {
    let pending_video = out.pending_video_packet.take().map(|packet| {
        let fallback_duration = video_init.and_then(nominal_video_duration_input_tb);
        let duration = resolve_packet_duration(
            packet.duration,
            out.last_video_duration_input_tb,
            fallback_duration,
        );
        if duration > 0 {
            out.last_video_duration_input_tb = Some(duration);
        }
        (packet, duration)
    });

    let pending_audio = out.pending_audio_packet.take().map(|packet| {
        let fallback_duration = audio_init.and_then(nominal_audio_duration_input_tb);
        let duration = resolve_packet_duration(
            packet.duration,
            out.last_audio_duration_input_tb,
            fallback_duration,
        );
        if duration > 0 {
            out.last_audio_duration_input_tb = Some(duration);
        }
        (packet, duration)
    });

    if let Some((packet, duration)) = pending_video {
        write_ready_packet(out, packet, duration)?;
    }

    if let Some((packet, duration)) = pending_audio {
        write_ready_packet(out, packet, duration)?;
    }

    Ok(())
}

fn nominal_video_duration_input_tb(init: &InitVideo) -> Option<i64> {
    if init.frame_rate_num <= 0
        || init.frame_rate_den <= 0
        || init.time_base_num <= 0
        || init.time_base_den <= 0
    {
        return None;
    }

    let numerator = i128::from(init.time_base_den) * i128::from(init.frame_rate_den);
    let denominator = i128::from(init.time_base_num) * i128::from(init.frame_rate_num);
    if denominator <= 0 {
        return None;
    }

    let duration = (numerator + denominator / 2) / denominator;
    i64::try_from(duration)
        .ok()
        .filter(|duration| *duration > 0)
}

fn nominal_audio_duration_input_tb(init: &InitAudio) -> Option<i64> {
    if init.time_base_num <= 0 || init.time_base_den <= 0 {
        return None;
    }

    let sample_rate = i64::from(init.sample_rate);
    if sample_rate <= 0 {
        return None;
    }

    let numerator = i128::from(1024i64) * i128::from(init.time_base_den);
    let denominator = i128::from(sample_rate) * i128::from(init.time_base_num);
    if denominator <= 0 {
        return None;
    }

    let duration = (numerator + denominator / 2) / denominator;
    i64::try_from(duration)
        .ok()
        .filter(|duration| *duration > 0)
}

fn write_ready_packet(
    out: &mut OpenOutput,
    packet: Packet,
    duration_input_tb: i64,
) -> Result<(), MuxerError> {
    let (stream_index, time_base) = match packet.stream_index {
        STREAM_INDEX_VIDEO => (
            out.video_stream_index
                .ok_or_else(|| MuxerError::BadState("video not initialized".to_string()))?,
            out.video_time_base
                .ok_or_else(|| MuxerError::BadState("no video time base".to_string()))?,
        ),
        STREAM_INDEX_AUDIO => (
            out.audio_stream_index
                .ok_or_else(|| MuxerError::BadState("audio not initialized".to_string()))?,
            out.audio_time_base
                .ok_or_else(|| MuxerError::BadState("no audio time base".to_string()))?,
        ),
        other => {
            return Err(MuxerError::BadState(format!(
                "unknown stream index {other}"
            )));
        }
    };

    let mut ff_packet = ffmpeg::Packet::copy(&packet.data);
    ff_packet.set_stream(stream_index);
    ff_packet.set_pts(Some(packet.pts));
    ff_packet.set_dts(Some(packet.dts));
    ff_packet.set_duration(duration_input_tb.max(0));
    if packet.flags & PACKET_FLAG_KEYFRAME != 0 {
        ff_packet.set_flags(ffmpeg::packet::Flags::KEY);
    }

    let stream_tb = out.ctx.stream(stream_index).unwrap().time_base();
    ff_packet.rescale_ts(time_base, stream_tb);

    ff_packet.write_interleaved(&mut out.ctx).map_err(|e| {
        let err = anyhow!("write_interleaved: {e}");
        if classify_io_error(&e) {
            MuxerError::DiskFull(err)
        } else {
            MuxerError::FFmpeg(err)
        }
    })?;

    match packet.stream_index {
        STREAM_INDEX_VIDEO => out.packets_written_video += 1,
        STREAM_INDEX_AUDIO => out.packets_written_audio += 1,
        _ => {}
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::mpsc::{self, RecvTimeoutError};
    use std::time::Duration;

    fn packet(stream_index: u8, pts: i64, dts: i64, duration: u64) -> Packet {
        Packet {
            stream_index,
            pts,
            dts,
            duration,
            flags: 0,
            data: Vec::new(),
        }
    }

    #[test]
    fn derives_duration_from_next_packet_dts() {
        let current = packet(STREAM_INDEX_VIDEO, 100, 90, 0);
        let next = packet(STREAM_INDEX_VIDEO, 133, 123, 0);

        assert_eq!(derive_duration_from_adjacent_dts(&current, &next, None), 33);
    }

    #[test]
    fn falls_back_to_packet_duration_when_dts_does_not_advance() {
        let current = packet(STREAM_INDEX_VIDEO, 100, 90, 41);
        let next = packet(STREAM_INDEX_VIDEO, 133, 90, 0);

        assert_eq!(
            derive_duration_from_adjacent_dts(&current, &next, Some(33)),
            41
        );
    }

    #[test]
    fn falls_back_to_last_duration_when_packet_duration_is_zero() {
        assert_eq!(resolve_packet_duration(0, Some(33), Some(41)), 33);
    }

    #[test]
    fn computes_nominal_video_duration_from_time_base_and_frame_rate() {
        let init = InitVideo {
            codec: "h264".to_string(),
            width: 1920,
            height: 1080,
            frame_rate_num: 60,
            frame_rate_den: 1,
            time_base_num: 1,
            time_base_den: 1_000_000,
            extradata: Vec::new(),
            segment_duration_ms: 2_000,
        };

        assert_eq!(nominal_video_duration_input_tb(&init), Some(16_667));
    }

    #[test]
    fn computes_nominal_audio_duration_from_aac_frame_size() {
        let init = InitAudio {
            codec: "aac".to_string(),
            sample_rate: 48_000,
            channels: 2,
            sample_format: "fltp".to_string(),
            time_base_num: 1,
            time_base_den: 48_000,
            extradata: Vec::new(),
        };

        assert_eq!(nominal_audio_duration_input_tb(&init), Some(1_024));
    }

    #[test]
    fn empty_finish_closes_initialized_files_before_state_is_dropped() {
        ffmpeg::init().unwrap();
        let directory = std::env::temp_dir().join(format!(
            "cap-muxer-empty-{}-{}",
            std::process::id(),
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos()
        ));
        std::fs::create_dir(&directory).unwrap();
        let mut state = State::default();
        handle_frame(
            &mut state,
            Frame::InitVideo(InitVideo {
                codec: "libx264".into(),
                width: 640,
                height: 360,
                frame_rate_num: 30,
                frame_rate_den: 1,
                time_base_num: 1,
                time_base_den: 90_000,
                extradata: Vec::new(),
                segment_duration_ms: 2_000,
            }),
        )
        .unwrap();
        handle_frame(
            &mut state,
            Frame::Start(StartParams {
                output_directory: directory.to_string_lossy().into_owned(),
                init_segment_name: "init.mp4".into(),
                media_segment_pattern: "segment_$Number%03d$.m4s".into(),
            }),
        )
        .unwrap();
        let init_path = directory.join("init.mp4");
        assert!(init_path.is_file());
        state.finish().unwrap();
        for path in [init_path, directory.join("dash_manifest.mpd")] {
            let mut options = std::fs::OpenOptions::new();
            options.read(true).write(true);
            #[cfg(windows)]
            {
                use std::os::windows::fs::OpenOptionsExt;
                options.share_mode(0);
            }
            let file = options.open(&path).unwrap();
            assert_eq!(file.metadata().unwrap().len(), 0);
            drop(file);
            let renamed = path.with_extension("closed");
            std::fs::rename(&path, &renamed).unwrap();
            std::fs::rename(&renamed, &path).unwrap();
        }
        assert!(!directory.join("dash_manifest.mpd.tmp").exists());
        state.finish().unwrap();
        std::fs::remove_dir_all(directory).unwrap();
    }

    #[test]
    fn cancellation_releases_producer_blocked_by_full_queue() {
        let queue = Arc::new(FrameQueue::new(frame_size_hint(&Frame::Finish)));
        assert!(queue.push(Frame::Finish));

        let (started_tx, started_rx) = mpsc::channel();
        let (result_tx, result_rx) = mpsc::channel();
        let producer = {
            let queue = Arc::clone(&queue);
            std::thread::spawn(move || {
                started_tx.send(()).unwrap();
                result_tx.send(queue.push(Frame::Finish)).unwrap();
            })
        };

        started_rx.recv_timeout(Duration::from_secs(1)).unwrap();
        assert!(matches!(
            result_rx.recv_timeout(Duration::from_millis(50)),
            Err(RecvTimeoutError::Timeout)
        ));

        queue.cancel();

        assert!(!result_rx.recv_timeout(Duration::from_secs(1)).unwrap());
        producer.join().unwrap();
        assert!(matches!(queue.pop(), PopResult::Drained));
    }

    #[test]
    fn cancellation_rejects_late_pushes() {
        let queue = FrameQueue::new(frame_size_hint(&Frame::Finish));

        queue.cancel();

        assert!(!queue.push(Frame::Finish));
        assert!(matches!(queue.pop(), PopResult::Drained));
    }

    #[test]
    fn cancellation_does_not_wait_for_reader_input_to_close() {
        let queue = Arc::new(FrameQueue::new(frame_size_hint(&Frame::Finish)));
        let (input_closed_tx, input_closed_rx) = mpsc::channel();
        let reader_handle = std::thread::spawn(move || {
            let _ = input_closed_rx.recv();
        });
        let (shutdown_done_tx, shutdown_done_rx) = mpsc::channel();
        let shutdown_thread = {
            let queue = Arc::clone(&queue);
            std::thread::spawn(move || {
                cancel_reader(&queue, reader_handle);
                shutdown_done_tx.send(()).unwrap();
            })
        };

        shutdown_done_rx
            .recv_timeout(Duration::from_secs(1))
            .unwrap();

        input_closed_tx.send(()).unwrap();
        shutdown_thread.join().unwrap();
    }
}