Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

5.4 KB
Raw Blame
use std::{thread, time::Duration};

use cap_media_info::{AudioInfo, FFRational};
use ffmpeg::{
    codec::{context, encoder},
    format::{self, Sample, sample::Type},
    frame,
    threading::Config,
};

use crate::audio::{
    audio_encoder::AudioEncoder, base::AudioEncoderBase, buffered_resampler::BufferedResampler,
};

pub struct OpusEncoder {
    base: AudioEncoderBase,
}

#[derive(thiserror::Error, Debug)]
pub enum OpusEncoderError {
    #[error("{0:?}")]
    FFmpeg(#[from] ffmpeg::Error),
    #[error("Opus codec not found")]
    CodecNotFound,
    #[error("Sample rate not supported: {0}")]
    RateNotSupported(i32),
    #[error("Resampler: {0}")]
    Resampler(ffmpeg::Error),
}

impl OpusEncoder {
    const OUTPUT_BITRATE: usize = 128 * 1000; // 128k
    const SAMPLE_FORMAT: Sample = Sample::F32(Type::Packed);

    pub fn factory(
        input_config: AudioInfo,
    ) -> impl FnOnce(&mut format::context::Output) -> Result<Self, OpusEncoderError> {
        move |o| Self::init(input_config, o)
    }

    pub fn init(
        input_config: AudioInfo,
        output: &mut format::context::Output,
    ) -> Result<Self, OpusEncoderError> {
        let codec = encoder::find_by_name("libopus").ok_or(OpusEncoderError::CodecNotFound)?;
        let mut encoder_ctx = context::Context::new_with_codec(codec);
        let thread_count = thread::available_parallelism()
            .map(|v| v.get())
            .unwrap_or(1);
        encoder_ctx.set_threading(Config::count(thread_count));
        let mut encoder = encoder_ctx.encoder().audio()?;

        let rate = {
            let mut rates = codec
                .audio()
                .unwrap()
                .rates()
                .into_iter()
                .flatten()
                .collect::<Vec<_>>();
            rates.sort();

            select_output_rate(input_config.rate(), &rates)
                .ok_or(OpusEncoderError::RateNotSupported(input_config.rate()))?
        };

        let mut output_config = input_config;
        output_config.sample_format = Self::SAMPLE_FORMAT;
        output_config.sample_rate = rate as u32;
        // libopus rejects surround layouts without an explicit mapping
        // family; multichannel interfaces (5.1 mics) would fail to start a
        // recording at all. Voice capture doesn't need surround: downmix to
        // stereo via the resampler instead.
        output_config.channels = output_config.channels.min(2);

        let resampler = BufferedResampler::new(input_config, output_config)
            .map_err(OpusEncoderError::Resampler)?;

        encoder.set_bit_rate(Self::OUTPUT_BITRATE);
        encoder.set_rate(rate);
        encoder.set_format(output_config.sample_format);
        encoder.set_channel_layout(output_config.channel_layout());
        encoder.set_time_base(FFRational(1, output_config.rate()));

        let encoder = encoder.open()?;

        let mut output_stream = output.add_stream(codec)?;
        let stream_index = output_stream.index();
        output_stream.set_time_base(FFRational(1, output_config.rate()));
        output_stream.set_parameters(&encoder);

        Ok(Self {
            base: AudioEncoderBase::new(encoder, resampler, stream_index),
        })
    }

    pub fn queue_frame(
        &mut self,
        frame: frame::Audio,
        timestamp: Duration,
        output: &mut format::context::Output,
    ) -> Result<(), ffmpeg::Error> {
        self.base.send_frame(frame, timestamp, output)
    }

    pub fn flush(&mut self, output: &mut format::context::Output) -> Result<(), ffmpeg::Error> {
        self.base.flush(output)
    }

    pub fn queue_frame_to(
        &mut self,
        frame: frame::Audio,
        timestamp: Duration,
        sink: &mut impl crate::PacketSink,
    ) -> Result<(), ffmpeg::Error> {
        self.base.send_frame(frame, timestamp, sink)
    }

    pub fn flush_to(&mut self, sink: &mut impl crate::PacketSink) -> Result<(), ffmpeg::Error> {
        self.base.flush(sink)
    }
}

fn select_output_rate(input_rate: i32, supported_rates: &[i32]) -> Option<i32> {
    supported_rates
        .iter()
        .copied()
        .find(|&rate| rate >= input_rate)
        .or_else(|| supported_rates.iter().copied().max())
}

impl AudioEncoder for OpusEncoder {
    fn send_frame(&mut self, frame: frame::Audio, output: &mut format::context::Output) {
        let _ = self.queue_frame(frame, Duration::MAX, output);
    }

    fn try_send_frame(
        &mut self,
        frame: frame::Audio,
        output: &mut format::context::Output,
    ) -> Result<(), ffmpeg::Error> {
        self.queue_frame(frame, Duration::MAX, output)
    }

    fn flush(&mut self, output: &mut format::context::Output) -> Result<(), ffmpeg::Error> {
        self.flush(output)
    }
}

#[cfg(test)]
mod tests {
    use super::select_output_rate;

    #[test]
    fn chooses_matching_rate_when_available() {
        let supported = [8_000, 12_000, 16_000, 24_000, 48_000];
        assert_eq!(select_output_rate(16_000, &supported), Some(16_000));
    }

    #[test]
    fn clamps_to_highest_supported_rate_when_input_is_higher() {
        let supported = [8_000, 12_000, 16_000, 24_000, 48_000];
        assert_eq!(select_output_rate(96_000, &supported), Some(48_000));
    }

    #[test]
    fn clamps_to_lowest_supported_rate_when_input_is_lower() {
        let supported = [8_000, 12_000, 16_000, 24_000, 48_000];
        assert_eq!(select_output_rate(4_000, &supported), Some(8_000));
    }
}