Send Raw Audio

┌─────────────────────────────────────────────────────────────────┐
│                    AUDIO INJECTION FLOW                         │
├─────────────────────────────────────────────────────────────────┤
│  Your Audio Source (file, TTS, generated)                       │
│       ↓                                                         │
│  PCM format (16-bit, 32000 Hz)                                  │
│       ↓                                                         │
│  IZoomVideoSDKVirtualAudioMic::onMicInitialize()                │
│       ↓                                                         │
│  IZoomVideoSDKAudioSender::send()                               │
│       ↓                                                         │
│  Participants hear your custom audio                            │
└─────────────────────────────────────────────────────────────────┘

#pragma once
#include <windows.h>
#include <thread>
#include <atomic>
#include <fstream>
#include "zoom_video_sdk_interface.h"

USING_ZOOM_VIDEO_SDK_NAMESPACE

class VirtualMic : public IZoomVideoSDKVirtualAudioMic {
public:
    VirtualMic();
    ~VirtualMic();
    
    // Set audio source file
    void SetAudioFile(const std::string& pcmFile);
    
    // IZoomVideoSDKVirtualAudioMic interface
    void onMicInitialize(IZoomVideoSDKAudioSender* sender) override;
    void onMicStartSend() override;
    void onMicStopSend() override;
    void onMicUninitialized() override;
    
private:
    void SendLoop();
    void GenerateSineWave(char* buffer, int samples, int frequency);
    
    IZoomVideoSDKAudioSender* m_sender;
    std::thread m_sendThread;
    std::atomic<bool> m_sending;
    std::string m_audioFile;
    std::ifstream m_fileStream;
    
    static const int SAMPLE_RATE = 32000;
    static const int CHANNELS = 1;
    static const int BITS_PER_SAMPLE = 16;
};

#include "VirtualMic.h"
#include <iostream>
#include <chrono>
#include <cmath>

VirtualMic::VirtualMic()
    : m_sender(nullptr)
    , m_sending(false) {
}

VirtualMic::~VirtualMic() {
    m_sending = false;
    if (m_sendThread.joinable()) {

void StartVirtualMic() {
    IZoomVideoSDKAudioHelper* audioHelper = sdk->getAudioHelper();
    if (!audioHelper) return;
    
    // Create virtual mic
    VirtualMic* virtualMic = new VirtualMic();
    
    // Optional: set audio file
    // virtualMic->SetAudioFile("audio.pcm");
    
    // Set as audio source
    ZoomVideoSDKErrors err = audioHelper->setExternalAudioSource(virtualMic);
    if (err != ZoomVideoSDKErrors_Success) {
        std::cout << "setExternalAudioSource failed: " << err << std::endl;
        return;
    }
    
    // Start audio (this triggers onMicStartSend)
    audioHelper->startAudio();
}

ffmpeg -i input.wav -f s16le -ar 32000 -ac 1 output.pcm

ffmpeg -i input.mp3 -f s16le -ar 32000 -ac 1 output.pcm

ZoomVideoSDKErrors send(
    char* data,        // PCM audio buffer
    unsigned int length,    // Buffer size in bytes
    int sampleRate         // Must be 32000
);

audioHelper->setExternalAudioSource(virtualMic);
audioHelper->startAudio();  // Required!

auto chunkInterval = std::chrono::milliseconds(20);
// ... send chunk ...
auto elapsed = std::chrono::steady_clock::now() - startTime;
std::this_thread::sleep_for(chunkInterval - elapsed);

ffmpeg -ar 32000 ...  # Not 44100!

const double amplitude = 16000;  // 50% volume