attempt desktop audio playback

gui/src/imp/web.rs

@@ -74,20 +74,22 @@ impl<T> ResultExt<T> for Result<T, JsError> {
 pub struct AudioSystem(AudioContext);
 
 impl AudioSystem {
-    pub fn new(sender: UnboundedSender<ControlPacket<Serverbound>>) -> Result<Self, Error> {
+    pub fn new() -> Result<Self, Error> {
         // Create MediaStreams to playback decoded audio
         // The audio context is used to reproduce audio.
         let audio_context = configure_audio_context();
+        Ok(AudioSystem(audio_context))
+    }
 
-        let audio_context_worklet = audio_context.clone();
+    pub fn start_recording(&mut self, each: impl FnMut(Vec<u8>) + 'static) -> Result<(), Error> {
+        let audio_context_worklet = self.0.clone();
         spawn(async move {
-            match create_encoder_worklet(&audio_context_worklet, sender).await {
+            match run_encoder_worklet(&audio_context_worklet, each).await {
                 Ok(node) => info!("created encoder worklet: {:?}", &node),
                 Err(err) => error!("could not create encoder worklet: {err}"),
             }
         });
-
-        Ok(AudioSystem(audio_context))
+        Ok(())
     }
 
     pub fn create_player(&mut self) -> Result<AudioPlayer, Error> {
@@ -191,9 +193,9 @@ impl PromiseExt for Promise {
     }
 }
 
-async fn create_encoder_worklet(
+async fn run_encoder_worklet(
     audio_context: &AudioContext,
-    packets: UnboundedSender<ControlPacket<mumble_protocol::Serverbound>>,
+    mut each: impl FnMut(Vec<u8>) + 'static,
 ) -> Result<AudioWorkletNode, Error> {
     let stream = window()
         .unwrap()
@@ -234,35 +236,12 @@ async fn create_encoder_worklet(
     let encoder_error: Closure<dyn FnMut(JsValue)> =
         Closure::new(|e| error!("error encoding audio {:?}", e));
 
-    let download_buffer = std::cell::RefCell::new(Vec::new());
-
     // This knows what MediaStreamTrackGenerator to use as it closes around it
-    let mut sequence_num = 0;
     let output: Closure<dyn FnMut(EncodedAudioChunk)> =
         Closure::new(move |audio_data: EncodedAudioChunk| {
             let mut array = vec![0u8; audio_data.byte_length() as usize];
             audio_data.copy_to_with_u8_slice(&mut array);
-
-            download_buffer.borrow_mut().push(array.clone());
-            if download_buffer.borrow().len() > 200 {
-                //download_data(download_buffer.borrow().to_vec(), "download_buffer.opus");
-                //download_data(
-                //    ass::encode(download_buffer.borrow().to_vec(), 960, 0),
-                //    "download_buffer.opus",
-                //);
-                download_buffer.borrow_mut().clear();
-            }
-
-            let _ =
-                packets.unbounded_send(ControlPacket::UDPTunnel(Box::new(VoicePacket::Audio {
-                    _dst: std::marker::PhantomData,
-                    target: 0,
-                    session_id: (),
-                    seq_num: sequence_num,
-                    payload: VoicePacketPayload::Opus(array.into(), false),
-                    position_info: None,
-                })));
-            sequence_num = sequence_num.wrapping_add(2);
+            each(array);
         });
 
     let audio_encoder = AudioEncoder::new(&AudioEncoderInit::new(