waycap_rs/encoders/
opus_encoder.rs1use crossbeam::channel::{bounded, Receiver, Sender};
2use ffmpeg_next::{self as ffmpeg, Rational};
3use std::collections::VecDeque;
4
5use crate::types::audio_frame::EncodedAudioFrame;
6
7use super::audio::{boost_with_rms, AudioEncoder};
8
9pub struct OpusEncoder {
10 encoder: Option<ffmpeg::codec::encoder::Audio>,
11 next_pts: i64,
12 leftover_data: VecDeque<f32>,
13 encoded_samples_recv: Option<Receiver<EncodedAudioFrame>>,
14 encoded_samples_sender: Sender<EncodedAudioFrame>,
15 capture_timestamps: VecDeque<i64>,
16}
17
18impl OpusEncoder {
19 fn create_encoder() -> crate::types::error::Result<ffmpeg::codec::encoder::Audio> {
20 let encoder_codec = ffmpeg::codec::encoder::find(ffmpeg_next::codec::Id::OPUS)
21 .ok_or(ffmpeg::Error::EncoderNotFound)?;
22
23 let mut encoder_ctx = ffmpeg::codec::context::Context::new_with_codec(encoder_codec)
24 .encoder()
25 .audio()?;
26
27 encoder_ctx.set_rate(48000);
28 encoder_ctx.set_bit_rate(70_000);
29 encoder_ctx.set_format(ffmpeg::format::Sample::F32(
30 ffmpeg_next::format::sample::Type::Packed,
31 ));
32 encoder_ctx.set_time_base(Rational::new(1, 48000));
33 encoder_ctx.set_frame_rate(Some(Rational::new(1, 48000)));
34 encoder_ctx.set_channel_layout(ffmpeg::channel_layout::ChannelLayout::STEREO);
35
36 let encoder = encoder_ctx.open()?;
37
38 Ok(encoder)
39 }
40}
41
42impl AudioEncoder for OpusEncoder {
43 fn new() -> crate::types::error::Result<Self>
44 where
45 Self: Sized,
46 {
47 let encoder = Self::create_encoder()?;
48 let (frame_tx, frame_rx): (Sender<EncodedAudioFrame>, Receiver<EncodedAudioFrame>) =
49 bounded(10);
50 Ok(Self {
51 encoder: Some(encoder),
52 next_pts: 0,
53 leftover_data: VecDeque::with_capacity(10),
54 encoded_samples_recv: Some(frame_rx),
55 encoded_samples_sender: frame_tx,
56 capture_timestamps: VecDeque::with_capacity(10),
57 })
58 }
59
60 fn process(
61 &mut self,
62 mut raw_frame: crate::types::audio_frame::RawAudioFrame,
63 ) -> crate::types::error::Result<()> {
64 if let Some(ref mut encoder) = self.encoder {
65 let n_channels = encoder.channels() as usize;
66 let total_samples = raw_frame.samples.len();
67
68 if !total_samples.is_multiple_of(n_channels) {
69 return Err(crate::types::error::WaycapError::FFmpeg(
70 ffmpeg::Error::InvalidData,
71 ));
72 }
73
74 let frame_size = encoder.frame_size() as usize;
75 let chunk_size = frame_size * n_channels;
76
77 boost_with_rms(&mut raw_frame.samples)?;
80 self.leftover_data.extend(raw_frame.samples);
81
82 while self.leftover_data.len() >= chunk_size {
84 let frame_samples: Vec<f32> = self.leftover_data.drain(..chunk_size).collect();
85 let mut frame = ffmpeg::frame::Audio::new(
86 encoder.format(),
87 frame_size,
88 encoder.channel_layout(),
89 );
90
91 frame.plane_mut(0).copy_from_slice(&frame_samples);
93 frame.set_pts(Some(self.next_pts));
94 frame.set_rate(encoder.rate());
95
96 self.capture_timestamps.push_back(raw_frame.timestamp);
97 encoder.send_frame(&frame)?;
98
99 let mut packet = ffmpeg::codec::packet::Packet::empty();
101 if encoder.receive_packet(&mut packet).is_ok() {
102 if let Some(data) = packet.data() {
103 let pts = packet.pts().unwrap_or(0);
104 match self.encoded_samples_sender.try_send(EncodedAudioFrame {
105 data: data.to_vec(),
106 pts,
107 timestamp: self.capture_timestamps.pop_front().unwrap_or(0),
108 }) {
109 Ok(_) => {}
110 Err(crossbeam::channel::TrySendError::Full(_)) => {
111 log::error!("Could not send encoded audio frame. Receiver is full");
112 }
113 Err(crossbeam::channel::TrySendError::Disconnected(_)) => {
114 log::error!(
115 "Could not send encoded audio frame. Receiver disconnected"
116 );
117 }
118 }
119 }
120 }
121
122 self.next_pts += frame_size as i64;
123 }
124 }
125
126 Ok(())
127 }
128
129 fn get_encoder(&self) -> &Option<ffmpeg_next::codec::encoder::Audio> {
130 &self.encoder
131 }
132
133 fn drain(&mut self) -> crate::types::error::Result<()> {
134 if let Some(ref mut encoder) = self.encoder {
135 encoder.send_eof()?;
136 let mut packet = ffmpeg::codec::packet::Packet::empty();
137 while encoder.receive_packet(&mut packet).is_ok() {} }
139
140 Ok(())
141 }
142
143 fn drop_encoder(&mut self) {
144 self.encoder.take();
145 }
146
147 fn reset(&mut self) -> crate::types::error::Result<()> {
148 self.drop_encoder();
149 self.capture_timestamps.clear();
150 self.encoder = Some(Self::create_encoder()?);
151
152 Ok(())
153 }
154
155 fn get_encoded_recv(&mut self) -> Option<Receiver<EncodedAudioFrame>> {
156 self.encoded_samples_recv.clone()
157 }
158}