VoIP Calls

[dependencies]
whatsapp-rust = { git = "https://github.com/oxidezap/whatsapp-rust", features = ["voip"] }
async-channel = "2"  # needed to implement AudioSource / AudioSink / VideoSource / VideoSink
tokio = { version = "1.48", features = ["macros", "rt-multi-thread"] }

[dependencies]
whatsapp-rust = { version = "0.7", features = ["voip"] }  # update when released
async-channel = "2"
tokio = { version = "1.48", features = ["macros", "rt-multi-thread"] }

use whatsapp_rust::client::Client;
use whatsapp_rust::types::events::Event;
use whatsapp_rust::wacore::types::call::CallAction;

async fn on_event(client: &Client, event: Event) -> anyhow::Result<()> {
    match event {
        Event::IncomingCall(incoming) => {
            // Borrow the action so `incoming` is not partially moved before `.accept(&incoming)`.
            if let CallAction::Offer { is_video, .. } = &incoming.action {
                let mut call = client.voip()
                    .accept(&incoming)
                    .audio(mic_source, speaker_sink);
                if *is_video {
                    // Required to answer a video-from-the-start offer.
                    call = call.video(camera_source, video_sink);
                }
                // If `is_video` was false, `start()` accepts audio-only — video can still be
                // added later via `CallHandle::start_video`.
                let handle = call.start().await?;

                // Resolves when either side hangs up
                handle.wait_ended().await;
            }
        }
        _ => {}
    }
    Ok(())
}

use whatsapp_rust::types::Jid;

let peer: Jid = "15551234567@s.whatsapp.net".parse()?;

let handle = client.voip()
    .call(&peer)
    .audio(mic_source, speaker_sink)
    .video(camera_source, video_sink) // omit for an audio-only call
    .start()
    .await?;

// End the call from your side: sends <terminate> to the peer and tears down local media.
// CallHandle exposes call_id() / peer_jid() / call_creator() for exactly this.
client.voip()
    .terminate(handle.call_id(), &handle.peer_jid(), handle.call_creator())
    .await?;

// Or wait for the remote side to hang up
handle.wait_ended().await;

cargo run -p whatsapp-rust-voip-cli -- loopback

use whatsapp_rust::voip::{AudioSource, AudioSink};
use async_channel;

struct MyMic { receiver: async_channel::Receiver<Vec<i16>> }
struct MySpeaker { sender: async_channel::Sender<Vec<i16>> }

impl AudioSource for MyMic {
    // Frames are 16 kHz wideband PCM (60 ms = 960 samples per Vec)
    fn frames(&self) -> async_channel::Receiver<Vec<i16>> {
        self.receiver.clone()
    }
}

impl AudioSink for MySpeaker {
    fn playout(&self) -> async_channel::Sender<Vec<i16>> {
        self.sender.clone()
    }
}

PCM source ── MLOW adapter ──┐
                             ├── RTP + SRTP/WARP ── WhatsApp relay
encoded source/sink ─────────┘

use whatsapp_rust::bytes::Bytes;
use whatsapp_rust::voip::{AudioFormat, EncodedAudioFrame};

let (encoded_tx, encoded_rx) = async_channel::bounded::<Bytes>(3);
let (playout_tx, playout_rx) = async_channel::bounded::<EncodedAudioFrame>(3);

let call = client
    .voip()
    .call(&peer)
    .encoded_audio(AudioFormat::OPUS_16KHZ_60MS, encoded_rx, playout_tx)
    .start()
    .await?;

// Feed your encoder's output in: encoded_tx.send(packet).await?; (one raw Opus packet per Bytes)
// Drain decoded frames for playback: while let Ok(frame) = playout_rx.recv().await { play(frame.data) }

WA_AUDIO_CODEC=mlow cargo run -p whatsapp-rust-voip-cli --release -- listen accept
WA_AUDIO_CODEC=opus cargo run -p whatsapp-rust-voip-cli --release -- listen accept

WA_AUDIO_CODEC=opus WA_AUDIO_PROFILE=pt111 cargo run -p whatsapp-rust-voip-cli --release -- listen accept

use whatsapp_rust::voip::{VideoSource, VideoSink, VideoFrame};
use async_channel;

struct MyCamera { receiver: async_channel::Receiver<Vec<u8>> }
struct MyDisplay { sender: async_channel::Sender<VideoFrame> }

impl VideoSource for MyCamera {
    // Each item is one complete H.264 Annex-B access unit.
    fn frames(&self) -> async_channel::Receiver<Vec<u8>> {
        self.receiver.clone()
    }

    // RTP clock increment between access units (90_000 / fps). Must be non-zero;
    // defaults to the 15 fps cadence if not overridden.
    fn rtp_timestamp_stride(&self) -> u32 {
        90_000 / 20 // 20 fps
    }
}

impl VideoSink for MyDisplay {
    fn playout(&self) -> async_channel::Sender<VideoFrame> {
        self.sender.clone()
    }
}

handle.start_video(camera_source, video_sink).await?;

CallEvent::VideoStateChanged { state, upgrade_token: Some(token), .. } if state.is_upgrade_request() => {
    // Sends both the accept and the Enabled stanza in one call — no extra step needed on this side.
    handle.accept_video(token, camera_source, video_sink).await?;
}

handle.stop_video().await?; // Idempotent.