Linux

your-project/
  demo/
    include/h/          # SDK headers
    lib/zoom_meeting_sdk/
      libmeetingsdk.so
      libmeetingsdk.so.1  # symlink
      qt_libs/
      json/translations.json
    meeting_sdk_demo.cpp
    CMakeLists.txt
    config.txt

cp -r h/* demo/include/h/
cp lib*.so demo/lib/zoom_meeting_sdk/
cp -r qt_libs demo/lib/zoom_meeting_sdk/
cp translation.json demo/lib/zoom_meeting_sdk/json/

# Create required symlink
cd demo/lib/zoom_meeting_sdk/
ln -s libmeetingsdk.so libmeetingsdk.so.1

meeting_number: "1234567890"
token: "YOUR_JWT_TOKEN"
meeting_password: "password123"
recording_token: ""
GetVideoRawData: "true"
GetAudioRawData: "true"
SendVideoRawData: "false"
SendAudioRawData: "false"

cd demo
cmake -B build
cd build
make
cd ../bin
./meetingSDKDemo

┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│  InitSDK    │───►│  AuthSDK    │───►│ JoinMeeting │───►│ Raw Data    │
│             │    │  (JWT)      │    │             │    │ Subscribe   │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
                         │                   │
                         ▼                   ▼
                   OnAuthComplete      onInMeeting
                     callback           callback

#include "zoom_sdk.h"

USING_ZOOM_SDK_NAMESPACE

void InitMeetingSDK() {
    SDKError err(SDKERR_SUCCESS);
    InitParam initParam;

    initParam.strWebDomain = "https://zoom.us";
    initParam.strSupportUrl = "https://zoom.us";
    initParam.emLanguageID = LANGUAGE_English;
    initParam.enableLogByDefault = true;
    initParam.enableGenerateDump = true;

    err = InitSDK(initParam);
    if (err != SDKERR_SUCCESS) {
        std::cerr << "Init meetingSdk:error" << std::endl;
    }
}

#include "auth_service_interface.h"

IAuthService* m_pAuthService;

void OnAuthenticationComplete() {
    JoinMeeting();  // Called on successful auth
}

void AuthMeetingSDK() {
    CreateAuthService(&m_pAuthService);
    
    m_pAuthService->SetEvent(
        new AuthServiceEventListener(&OnAuthenticationComplete)
    );
    
    AuthContext param;
    param.jwt_token = token.c_str();  // Your JWT token
    m_pAuthService->SDKAuth(param);
}

#include "meeting_service_interface.h"

IMeetingService* m_pMeetingService;
ISettingService* m_pSettingService;

void JoinMeeting() {
    CreateMeetingService(&m_pMeetingService);
    CreateSettingService(&m_pSettingService);
    
    // Set event listeners
    m_pMeetingService->SetEvent(
        new MeetingServiceEventListener(&onMeetingJoined, &onMeetingEnds, &onInMeeting)
    );
    
    // Prepare join parameters
    JoinParam joinParam;
    joinParam.userType = SDK_UT_WITHOUT_LOGIN;
    
    JoinParam4WithoutLogin& params = joinParam.param.withoutloginuserJoin;
    params.meetingNumber = std::stoull(meeting_number);
    params.userName = "BotUser";
    params.psw = meeting_password.c_str();
    params.isVideoOff = false;
    params.isAudioOff = false;
    
    m_pMeetingService->Join(joinParam);
}

#include "rawdata/rawdata_renderer_interface.h"
#include "rawdata/zoom_rawdata_api.h"

class ZoomSDKRenderer : public IZoomSDKRendererDelegate {
public:
    void onRawDataFrameReceived(YUVRawDataI420* data) override {
        // YUV420 (I420) format - contiguous planar data (no strides)
        int width = data->GetStreamWidth();
        int height = data->GetStreamHeight();
        
        // Y plane: width * height bytes
        outputFile.write(data->GetYBuffer(), width * height);
        // U plane: (width/2) * (height/2) bytes
        outputFile.write(data->GetUBuffer(), (width / 2) * (height / 2));
        // V plane: (width/2) * (height/2) bytes
        outputFile.write(data->GetVBuffer(), (width / 2) * (height / 2));
    }
    
    void onRawDataStatusChanged(RawDataStatus status) override {}
    void onRendererBeDestroyed() override {}
};

// Subscribe after joining
IZoomSDKRenderer* videoHelper;
ZoomSDKRenderer* videoSource = new ZoomSDKRenderer();

createRenderer(&videoHelper, videoSource);
videoHelper->setRawDataResolution(ZoomSDKResolution_720P);
videoHelper->subscribe(userID, RAW_DATA_TYPE_VIDEO);

#include "rawdata/rawdata_audio_helper_interface.h"

class ZoomSDKAudioRawData : public IZoomSDKAudioRawDataDelegate {
public:
    void onMixedAudioRawDataReceived(AudioRawData* data) override {
        // Process PCM audio (mixed from all participants)
        pcmFile.write((char*)data->GetBuffer(), data->GetBufferLen());
    }
    
    void onOneWayAudioRawDataReceived(AudioRawData* data, uint32_t node_id) override {
        // Process audio from specific participant
    }
};

// Subscribe after joining
IZoomSDKAudioRawDataHelper* audioHelper = GetAudioRawdataHelper();
audioHelper->subscribe(new ZoomSDKAudioRawData());

#include <glib.h>

GMainLoop* loop;

gboolean timeout_callback(gpointer data) {
    return TRUE;  // Keep running
}

int main(int argc, char* argv[]) {
    InitMeetingSDK();
    AuthMeetingSDK();
    
    loop = g_main_loop_new(NULL, FALSE);
    g_timeout_add(1000, timeout_callback, loop);
    g_main_loop_run(loop);
    
    return 0;
}

ffplay -video_size 640x360 -pixel_format yuv420p -f rawvideo video.yuv

ffmpeg -video_size 640x360 -pixel_format yuv420p -f rawvideo -i video.yuv -c:v libx264 output.mp4

ffplay -f s16le -ar 32000 -ac 1 audio.pcm

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

ffmpeg -video_size 640x360 -pixel_format yuv420p -f rawvideo -i video.yuv \
       -f s16le -ar 32000 -ac 1 -i audio.pcm \
       -c:v libx264 -c:a aac -shortest output.mp4