clean up warnings

bark/src/receive.rs

@@ -2,23 +2,18 @@ use std::array;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use bark_core::audio::Frame;
-use bark_core::receive::pipeline::Pipeline;
-use bark_core::receive::timing::Timing;
 use bytemuck::Zeroable;
 use structopt::StructOpt;
 
-use bark_core::receive::queue::{AudioPts, PacketQueue};
+use bark_core::receive::queue::AudioPts;
 
-use bark_protocol::FRAMES_PER_PACKET;
 use bark_protocol::time::{Timestamp, SampleDuration, TimestampDelta, ClockDelta};
 use bark_protocol::types::{AudioPacketHeader, ReceiverId, SessionId, TimePhase, TimestampMicros};
-use bark_protocol::types::stats::receiver::{ReceiverStats, StreamStatus};
+use bark_protocol::types::stats::receiver::ReceiverStats;
 use bark_protocol::packet::{Audio, Time, PacketKind, StatsReply};
 
 use crate::audio::config::{DEFAULT_PERIOD, DEFAULT_BUFFER, DeviceOpt};
 use crate::audio::Output;
-use crate::config::Device;
 use crate::receive::output::OutputRef;
 use crate::receive::stream::Stream as ReceiveStream;
 use crate::socket::{ProtocolSocket, Socket, SocketOpt};
@@ -166,52 +161,6 @@ impl Receiver {
             }
         }
     }
-
-    /*
-    pub fn write_audio(&mut self, buffer: &mut [Frame], pts: Timestamp) -> usize {
-        // get stream start timing information:
-        let Some(stream) = self.stream.as_mut() else {
-            // stream hasn't started, just fill buffer with silence and return
-            buffer[0..FRAMES_PER_PACKET].fill(Frame::zeroed());
-            return FRAMES_PER_PACKET;
-        };
-
-        // get next packet from queue, or None if missing (packet loss)
-        let queue_item = stream.queue.pop_front();
-
-        let (packet, stream_pts) = queue_item.as_ref()
-            .map(|item| (Some(&item.audio), Some(item.pts)))
-            .unwrap_or_default();
-
-        let timing = stream_pts.map(|stream_pts| Timing {
-            real: pts,
-            play: stream_pts,
-        });
-
-        // adjust resampler rate based on stream timing info
-        if let Some(timing) = timing {
-            stream.pipeline.set_timing(timing);
-
-            if stream.pipeline.slew() {
-                self.stats.set_stream(StreamStatus::Slew);
-            } else {
-                self.stats.set_stream(StreamStatus::Sync);
-            }
-
-            self.stats.set_audio_latency(timing.real, timing.play);
-        }
-
-        // pass packet through decode pipeline
-        let frames = stream.pipeline.process(packet, buffer);
-
-        // report stats and return
-        self.stats.set_buffer_length(
-            SampleDuration::from_frame_count(
-                (FRAMES_PER_PACKET * stream.queue.len()).try_into().unwrap()));
-
-        frames
-    }
-    */
 }
 
 struct Aggregate<T> {
@@ -285,43 +234,6 @@ pub fn run(opt: ReceiveOpt) -> Result<(), RunError> {
         recv: Receiver::new(output),
     }));
 
-    /*
-    std::thread::spawn({
-        let state = state.clone();
-        move || {
-            thread::set_name("bark/audio");
-
-            loop {
-                let mut state = state.lock().unwrap();
-
-                let delay = output.delay().unwrap();
-                state.recv.stats.set_output_latency(delay);
-
-                let pts = time::now();
-                let pts = Timestamp::from_micros_lossy(pts);
-                let pts = pts.add(delay);
-
-                // this should be large enough for `write_audio` to process an
-                // entire packet with:
-                let mut buffer = [Frame::zeroed(); FRAMES_PER_PACKET * 2];
-                let count = state.recv.write_audio(&mut buffer, pts);
-
-                // drop lock before calling `Output::write` (blocking!)
-                drop(state);
-
-                // send audio to ALSA
-                match output.write(&buffer[0..count]) {
-                    Ok(()) => {}
-                    Err(e) => {
-                        log::error!("error playing audio: {e}");
-                        break;
-                    }
-                };
-            }
-        }
-    });
-    */
-
     let socket = Socket::open(opt.socket)
         .map_err(RunError::Listen)?;
 

bark/src/receive/stream.rs

@@ -1,13 +1,14 @@
-use std::{sync::Mutex, thread};
+use std::thread;
 
 use bark_core::{audio::Frame, receive::{pipeline::Pipeline, queue::{AudioPts, PacketQueue}, timing::Timing}};
-use bark_protocol::{time::{ClockDelta, SampleDuration, Timestamp, TimestampDelta}, types::{stats::receiver::StreamStatus, AudioPacketHeader, SessionId}, FRAMES_PER_PACKET};
+use bark_protocol::time::{SampleDuration, Timestamp, TimestampDelta};
+use bark_protocol::types::{stats::receiver::StreamStatus, AudioPacketHeader, SessionId};
+use bark_protocol::FRAMES_PER_PACKET;
 use bytemuck::Zeroable;
 
 use crate::time;
 use crate::receive::output::OutputRef;
 use crate::receive::queue::{self, Disconnected, QueueReceiver, QueueSender};
-use crate::receive::Aggregate;
 
 pub struct Stream {
     tx: QueueSender,
@@ -20,7 +21,6 @@ impl Stream {
         let (tx, rx) = queue::channel(queue);
 
         let state = StreamState {
-            clock_delta: Aggregate::new(),
             queue: rx,
             pipeline: Pipeline::new(header),
             output,
@@ -46,7 +46,6 @@ impl Stream {
 }
 
 struct StreamState {
-    clock_delta: Aggregate<ClockDelta>,
     queue: QueueReceiver,
     pipeline: Pipeline,
     output: OutputRef,
@@ -130,10 +129,3 @@ fn run_stream(mut stream: StreamState) {
         }
     }
 }
-
-/// Adjust pts from remote time to local time
-fn adjust_pts(stream: &StreamState, pts: Timestamp) -> Option<Timestamp> {
-    stream.clock_delta.median().map(|delta| {
-        pts.adjust(TimestampDelta::from_clock_delta_lossy(delta))
-    })
-}