Slic3r::GUI::WebRtcMediaController Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/WebRtcMediaController.hpp>

Inheritance diagram for Slic3r::GUI::WebRtcMediaController:

Collaboration diagram for Slic3r::GUI::WebRtcMediaController:

Classes
struct	Status

Public Member Functions
	WebRtcMediaController (std::function< void(const wxImage &, wxSize)> frame_sink, std::function< void(Status)> on_status)
	~WebRtcMediaController () override
void	set_signalling_channel (std::unique_ptr< ICameraSignalingChannel > channel)
std::uint64_t	epoch () const
bool	is_active () const
void	Load (wxURI) override
void	Play () override
void	Stop () override
wxMediaState	GetState () override
wxSize	GetVideoSize () const override
virtual int	GetLastError () const

Private Member Functions
void	teardown (bool notify)
void	report (Status status)
void	bind_data_channel (const std::shared_ptr< rtc::DataChannel > &dc)
void	on_ready (std::vector< CameraIceServer > servers)
void	on_answer (std::string sdp)
void	on_ice (std::string candidate, std::string mid)
void	on_unavailable (CameraUnavailableReason reason, std::string detail)
void	decode_loop ()
void	enqueue_jpeg (std::vector< std::byte > jpeg)
void	deliver_jpeg (std::vector< std::byte > jpeg)

Private Attributes
std::mutex	m_mutex
std::condition_variable	m_cond
std::deque< std::vector< std::byte > >	m_jpeg_queue
std::vector< std::pair< std::string, std::string > >	m_pending_candidates
bool	m_remote_description_set = false
std::unique_ptr< ICameraSignalingChannel >	m_pending_signaling
std::unique_ptr< ICameraSignalingChannel >	m_signaling
std::shared_ptr< rtc::PeerConnection >	m_peer_connection
std::shared_ptr< rtc::DataChannel >	m_data_channel
std::thread	m_decode_thread
std::atomic< bool >	m_alive {false}
std::atomic< std::uint64_t >	m_epoch {0}
wxMediaState	m_state = static_cast<wxMediaState>(3)
wxSize	m_video_size = wxDefaultSize
std::function< void(const wxImage &, wxSize)>	m_frame_sink
std::function< void(Status)>	m_on_status
bool	m_has_frame = false
std::chrono::steady_clock::time_point	m_last_frame_time {}

Detailed Description

Constructor & Destructor Documentation

WebRtcMediaController()

Slic3r::GUI::WebRtcMediaController::WebRtcMediaController	(	std::function< void(const wxImage &, wxSize)>	frame_sink,
		std::function< void(Status)>	on_status )

    : m_frame_sink(std::move(frame_sink))
    , m_on_status(std::move(on_status))
{
}

References m_frame_sink, and m_on_status.

~WebRtcMediaController()

Slic3r::GUI::WebRtcMediaController::~WebRtcMediaController ( )

override

{
    Stop();
}

References Stop().

Here is the call graph for this function:

Member Function Documentation

bind_data_channel()

void Slic3r::GUI::WebRtcMediaController::bind_data_channel ( const std::shared_ptr< rtc::DataChannel > & dc )

private

{
    const std::string label = dc->label();
    dc->onOpen([label] { BOOST_LOG_TRIVIAL(info) << "WebRTC: data channel '" << label << "' open"; });
    dc->onClosed([label] { BOOST_LOG_TRIVIAL(info) << "WebRTC: data channel '" << label << "' closed"; });
    dc->onError([label](std::string e) {
        BOOST_LOG_TRIVIAL(warning) << "WebRTC: data channel '" << label << "' error: " << e;
    });
    dc->onMessage(
        [this](rtc::binary data) {
            if (m_alive.load())
                enqueue_jpeg(std::vector<std::byte>(data.begin(), data.end()));
        },
        [](rtc::string) {});
}

References enqueue_jpeg(), and m_alive.

Referenced by on_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_loop()

void Slic3r::GUI::WebRtcMediaController::decode_loop ( )

private

{
    int stall_polls = 0;
    std::unique_lock<std::mutex> lock(m_mutex);
    while (m_alive.load()) {
        const bool woke = m_cond.wait_for(lock, std::chrono::seconds(2), [this] {
            return !m_alive.load() || !m_jpeg_queue.empty();
        });
        if (!m_alive.load())
            break;
        if (!woke && !m_has_frame) {
            const int pc_state = m_peer_connection ? static_cast<int>(m_peer_connection->state()) : -1;
            std::string dc = "none";
            if (m_data_channel)
                dc = "label='" + m_data_channel->label() + "' open=" +
                     (m_data_channel->isOpen() ? "1" : "0");
            lock.unlock();
            BOOST_LOG_TRIVIAL(info) << "WebRTC: waiting for frames; peer_state=" << pc_state
                                    << " data_channel=" << dc;
            if (++stall_polls >= 8) { // ~16s connected with no frame -> give up so the UI can retry
                report({Status::Failed, Status::TIMEOUT});
                lock.lock();
                break;
            }
            lock.lock();
            continue;
        }
        stall_polls = 0;
        if (!m_jpeg_queue.empty()) {
            auto jpeg = std::move(m_jpeg_queue.front());
            m_jpeg_queue.pop_front();
            lock.unlock();
            deliver_jpeg(std::move(jpeg));
            lock.lock();
        }
    }
}

References deliver_jpeg(), Slic3r::GUI::WebRtcMediaController::Status::Failed, m_alive, m_cond, m_data_channel, m_has_frame, m_jpeg_queue, m_mutex, m_peer_connection, report(), and Slic3r::GUI::WebRtcMediaController::Status::TIMEOUT.

Referenced by Play().

Here is the call graph for this function:

Here is the caller graph for this function:

deliver_jpeg()

void Slic3r::GUI::WebRtcMediaController::deliver_jpeg ( std::vector< std::byte > jpeg )

private

{
    const auto now = std::chrono::steady_clock::now();
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (m_last_frame_time != std::chrono::steady_clock::time_point{} &&
            now - m_last_frame_time < std::chrono::milliseconds(33))
            return;
        m_last_frame_time = now;
    }
    wxMemoryInputStream stream(jpeg.data(), jpeg.size());
    wxImage image;
    if (!image.LoadFile(stream, wxBITMAP_TYPE_JPEG)) {
        report({Status::Failed, Status::DECODE_ERROR});
        return;
    }
    bool first_frame = false;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_video_size = image.GetSize();
        first_frame = !m_has_frame;
        m_has_frame = true;
    }
    if (m_frame_sink)
        m_frame_sink(image, image.GetSize());
    if (first_frame)
        report({Status::Playing});
}

References Slic3r::GUI::WebRtcMediaController::Status::DECODE_ERROR, Slic3r::GUI::WebRtcMediaController::Status::Failed, m_frame_sink, m_has_frame, m_last_frame_time, m_mutex, m_video_size, Slic3r::GUI::WebRtcMediaController::Status::Playing, and report().

Referenced by decode_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

enqueue_jpeg()

void Slic3r::GUI::WebRtcMediaController::enqueue_jpeg ( std::vector< std::byte > jpeg )

private

{
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_jpeg_queue.size() >= 4)
        m_jpeg_queue.pop_front();
    m_jpeg_queue.emplace_back(std::move(jpeg));
    m_cond.notify_one();
}

References m_cond, m_jpeg_queue, and m_mutex.

Referenced by bind_data_channel().

Here is the caller graph for this function:

epoch()

std::uint64_t Slic3r::GUI::WebRtcMediaController::epoch ( ) const

inline

{ return m_epoch.load(); }

References m_epoch.

GetLastError()

virtual int Slic3r::GUI::IMediaController::GetLastError ( ) const

inlinevirtualinherited

Reimplemented in wxMediaCtrl3.

{ return {}; };

GetState()

wxMediaState Slic3r::GUI::WebRtcMediaController::GetState ( )

overridevirtual

Reimplemented from Slic3r::GUI::IMediaController.

{
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_state;
}

References m_mutex, and m_state.

GetVideoSize()

wxSize Slic3r::GUI::WebRtcMediaController::GetVideoSize ( ) const

overridevirtual

Reimplemented from Slic3r::GUI::IMediaController.

{
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_video_size;
}

References m_mutex, and m_video_size.

is_active()

bool Slic3r::GUI::WebRtcMediaController::is_active ( ) const

inline

{ return m_alive.load(); }

References m_alive.

Load()

void Slic3r::GUI::WebRtcMediaController::Load ( wxURI )

inlineoverridevirtual

Implements Slic3r::GUI::IMediaController.

{}

on_answer()

void Slic3r::GUI::WebRtcMediaController::on_answer ( std::string sdp )

private

{
    std::shared_ptr<rtc::PeerConnection> peer_connection;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        peer_connection = m_peer_connection;
    }
    BOOST_LOG_TRIVIAL(info) << "WebRTC: applying remote answer (" << sdp.size() << " bytes), ANSWER SDP:\n" << sdp;
    if (!peer_connection)
        return;
    try {
        peer_connection->setRemoteDescription(rtc::Description(sdp, "answer"));
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(warning) << "WebRTC: setRemoteDescription failed: " << e.what();
        report({Status::Failed, Status::ICE_FAILED});
        return;
    }
 
    // Flush any remote candidates that arrived before the answer.
    std::vector<std::pair<std::string, std::string>> pending;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_remote_description_set = true;
        pending.swap(m_pending_candidates);
    }
    BOOST_LOG_TRIVIAL(info) << "WebRTC: remote description set, flushing " << pending.size()
                            << " buffered candidate(s)";
    for (const auto& c : pending) {
        try {
            peer_connection->addRemoteCandidate(rtc::Candidate(c.first, c.second));
        } catch (const std::exception& e) {
            BOOST_LOG_TRIVIAL(warning) << "WebRTC: addRemoteCandidate (buffered) failed: " << e.what();
        }
    }
}

References Slic3r::GUI::WebRtcMediaController::Status::Failed, Slic3r::GUI::WebRtcMediaController::Status::ICE_FAILED, m_mutex, m_peer_connection, m_pending_candidates, m_remote_description_set, and report().

Referenced by Play().

Here is the call graph for this function:

Here is the caller graph for this function:

on_ice()

void Slic3r::GUI::WebRtcMediaController::on_ice ( std::string candidate, std::string mid )

private

{
    std::shared_ptr<rtc::PeerConnection> peer_connection;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (!m_remote_description_set) {
            m_pending_candidates.emplace_back(std::move(candidate), std::move(mid));
            return;
        }
        peer_connection = m_peer_connection;
    }
    if (!peer_connection)
        return;
    try {
        peer_connection->addRemoteCandidate(rtc::Candidate(candidate, mid));
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(warning) << "WebRTC: addRemoteCandidate failed: " << e.what();
    }
}

References m_mutex, m_peer_connection, m_pending_candidates, and m_remote_description_set.

Referenced by Play().

Here is the caller graph for this function:

on_ready()

void Slic3r::GUI::WebRtcMediaController::on_ready ( std::vector< CameraIceServer > servers )

private

{
    init_rtc_logger_once();
    rtc::Configuration configuration;
    // Allow complete-JPEG DataChannel messages up to 1 MiB. This value is
    // advertised in SDP and becomes the upper bound for frames OrcaSonar can
    // send to OrcaSlicer.
    configuration.maxMessageSize = 1024 * 1024;
    for (const CameraIceServer& server : servers) {
        try {
            rtc::IceServer ice_server(server.urls);
            ice_server.username = server.username;
            ice_server.password = server.credential;
            configuration.iceServers.emplace_back(std::move(ice_server));
        } catch (const std::exception& e) {
            BOOST_LOG_TRIVIAL(warning) << "WebRTC: invalid ICE server: " << e.what();
        }
    }
 
    BOOST_LOG_TRIVIAL(info) << "WebRTC: creating peer connection with " << configuration.iceServers.size() << " ice servers";
    auto peer_connection = std::make_shared<rtc::PeerConnection>(std::move(configuration));
    peer_connection->onLocalDescription([this](rtc::Description description) {
        if (!m_alive.load())
            return;
        const std::string sdp(description);
        BOOST_LOG_TRIVIAL(info) << "WebRTC: local description ready (" << description.typeString()
                                << "), OFFER SDP:\n" << sdp;
        std::lock_guard<std::mutex> lock(m_mutex);
        if (m_signaling)
            m_signaling->send_offer(sdp);
    });
    peer_connection->onLocalCandidate([this](rtc::Candidate candidate) {
        if (!m_alive.load())
            return;
        std::lock_guard<std::mutex> lock(m_mutex);
        if (m_signaling)
            m_signaling->send_ice(std::string(candidate), candidate.mid());
    });
    peer_connection->onStateChange([this](rtc::PeerConnection::State state) {
        BOOST_LOG_TRIVIAL(info) << "WebRTC: peer state -> " << static_cast<int>(state);
        if (!m_alive.load())
            return;
        if (state == rtc::PeerConnection::State::Failed || state == rtc::PeerConnection::State::Disconnected)
            report({Status::Failed, Status::ICE_FAILED});
    });
    peer_connection->onGatheringStateChange([](rtc::PeerConnection::GatheringState state) {
        BOOST_LOG_TRIVIAL(info) << "WebRTC: gathering state -> " << static_cast<int>(state);
    });
 
    // Accept a DataChannel opened by the remote peer (OrcaSonar may create the
    // "camera" channel from its side rather than answering the one we offer).
    peer_connection->onDataChannel([this](std::shared_ptr<rtc::DataChannel> dc) {
        BOOST_LOG_TRIVIAL(info) << "WebRTC: remote opened data channel '" << dc->label() << "'";
        bind_data_channel(dc);
        std::lock_guard<std::mutex> lock(m_mutex);
        m_data_channel = std::move(dc);
    });
 
    rtc::DataChannelInit init;
    init.reliability.unordered = true;
    // init.reliability.maxPacketLifeTime = std::chrono::milliseconds(350);
    // Request one complete JPEG frame per DataChannel message. OrcaSonar
    // keeps the legacy chunked protocol for clients that omit this property.
    init.protocol = "orca-jpeg";
    auto data_channel = peer_connection->createDataChannel("camera", init);
    if (data_channel)
        bind_data_channel(data_channel);
 
    // Camera media is carried as one complete JPEG per DataChannel message;
    // no RTP video track or application-level framing is required.
 
    std::shared_ptr<rtc::PeerConnection> peer_for_description;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (!m_alive.load())
            return;
        m_peer_connection = std::move(peer_connection);
        peer_for_description = m_peer_connection;
        m_data_channel = std::move(data_channel);
    }
    if (peer_for_description)
        peer_for_description->setLocalDescription();
}

References bind_data_channel(), Slic3r::GUI::WebRtcMediaController::Status::Failed, Slic3r::GUI::WebRtcMediaController::Status::ICE_FAILED, m_alive, m_data_channel, m_mutex, m_peer_connection, m_signaling, and report().

Referenced by Play().

Here is the call graph for this function:

Here is the caller graph for this function:

on_unavailable()

void Slic3r::GUI::WebRtcMediaController::on_unavailable ( CameraUnavailableReason reason, std::string detail )

private

{
    BOOST_LOG_TRIVIAL(warning) << "WebRTC camera unavailable: " << detail;
    Status::Code code = Status::UNAVAILABLE_ERROR;
    if (reason == CameraUnavailableReason::Busy)
        code = Status::UNAVAILABLE_BUSY;
    else if (reason == CameraUnavailableReason::Disabled)
        code = Status::UNAVAILABLE_DISABLED;
    else if (reason == CameraUnavailableReason::Closed)
        code = Status::SIGNALING_CLOSED;
    report({Status::Failed, code});
}

References Slic3r::Busy, Slic3r::Closed, Slic3r::Disabled, Slic3r::GUI::WebRtcMediaController::Status::Failed, report(), Slic3r::GUI::WebRtcMediaController::Status::SIGNALING_CLOSED, Slic3r::GUI::WebRtcMediaController::Status::UNAVAILABLE_BUSY, Slic3r::GUI::WebRtcMediaController::Status::UNAVAILABLE_DISABLED, and Slic3r::GUI::WebRtcMediaController::Status::UNAVAILABLE_ERROR.

Referenced by Play().

Here is the call graph for this function:

Here is the caller graph for this function:

Play()

void Slic3r::GUI::WebRtcMediaController::Play ( )

overridevirtual

Implements Slic3r::GUI::IMediaController.

{
    std::unique_ptr<ICameraSignalingChannel> channel = std::move(m_pending_signaling);
    // Tear down any previous attempt WITHOUT notifying: the Stopped that would
    // otherwise be delivered (async, via CallAfter) races the new attempt's
    // Connecting and makes the consumer cancel a session that is mid-connect.
    teardown(false);
    if (!channel)
        return;
 
    m_epoch.fetch_add(1);
    m_alive.store(true);
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_signaling = std::move(channel);
        m_jpeg_queue.clear();
        m_pending_candidates.clear();
        m_remote_description_set = false;
        m_video_size = wxDefaultSize;
        m_has_frame = false;
        m_last_frame_time = {};
    }
 
    ICameraSignalingChannel* signaling = nullptr;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        signaling = m_signaling.get();
    }
    signaling->on_ready = [this](std::vector<CameraIceServer> servers) {
        if (m_alive.load())
            on_ready(std::move(servers));
    };
    signaling->on_answer = [this](std::string sdp) {
        if (m_alive.load())
            on_answer(std::move(sdp));
    };
    signaling->on_ice = [this](std::string candidate, std::string mid) {
        if (m_alive.load())
            on_ice(std::move(candidate), std::move(mid));
    };
    signaling->on_unavailable = [this](CameraUnavailableReason reason, std::string detail) {
        if (m_alive.load())
            on_unavailable(reason, std::move(detail));
    };
 
    m_decode_thread = std::thread([this] { decode_loop(); });
    report({Status::Connecting});
    signaling->open();
}

References Slic3r::GUI::WebRtcMediaController::Status::Connecting, decode_loop(), m_alive, m_decode_thread, m_epoch, m_has_frame, m_jpeg_queue, m_last_frame_time, m_mutex, m_pending_candidates, m_pending_signaling, m_remote_description_set, m_signaling, m_video_size, on_answer(), Slic3r::ICameraSignalingChannel::on_answer, on_ice(), Slic3r::ICameraSignalingChannel::on_ice, on_ready(), Slic3r::ICameraSignalingChannel::on_ready, on_unavailable(), Slic3r::ICameraSignalingChannel::on_unavailable, Slic3r::ICameraSignalingChannel::open(), report(), and teardown().

Here is the call graph for this function:

report()

void Slic3r::GUI::WebRtcMediaController::report ( Status status )

private

{
    status.epoch = m_epoch.load();
    BOOST_LOG_TRIVIAL(info) << "WebRTC: report kind=" << static_cast<int>(status.kind)
                            << " code=" << static_cast<int>(status.code) << " epoch=" << status.epoch;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (status.kind == Status::Connecting)
            m_state = static_cast<wxMediaState>(4);
        else if (status.kind == Status::Playing)
            m_state = wxMEDIASTATE_PLAYING;
        else
            m_state = static_cast<wxMediaState>(3);
    }
    if (m_on_status)
        m_on_status(status);
}

References Slic3r::GUI::WebRtcMediaController::Status::code, Slic3r::GUI::WebRtcMediaController::Status::Connecting, Slic3r::GUI::WebRtcMediaController::Status::epoch, Slic3r::GUI::WebRtcMediaController::Status::kind, m_epoch, m_mutex, m_on_status, m_state, and Slic3r::GUI::WebRtcMediaController::Status::Playing.

Referenced by decode_loop(), deliver_jpeg(), on_answer(), on_ready(), on_unavailable(), Play(), and teardown().

Here is the caller graph for this function:

set_signalling_channel()

void Slic3r::GUI::WebRtcMediaController::set_signalling_channel

(

std::unique_ptr< ICameraSignalingChannel >

channel

)

{
    m_pending_signaling = std::move(channel);
}

References m_pending_signaling.

Stop()

void Slic3r::GUI::WebRtcMediaController::Stop ( )

overridevirtual

Implements Slic3r::GUI::IMediaController.

{
    teardown(true);
}

References teardown().

Referenced by ~WebRtcMediaController().

Here is the call graph for this function:

Here is the caller graph for this function:

teardown()

void Slic3r::GUI::WebRtcMediaController::teardown ( bool notify )

private

{
    const bool was_alive = m_alive.exchange(false);
    if (!was_alive && !m_decode_thread.joinable())
        return;
 
    m_cond.notify_all();
    std::unique_ptr<ICameraSignalingChannel> signaling;
    std::shared_ptr<rtc::PeerConnection> peer_connection;
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        signaling = std::move(m_signaling);
        peer_connection = std::move(m_peer_connection);
        m_data_channel.reset();
    }
    if (signaling)
        signaling->close();
    if (peer_connection)
        peer_connection->close();
    if (m_decode_thread.joinable())
        m_decode_thread.join();
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_jpeg_queue.clear();
    }
    if (was_alive && notify)
        report({Status::Stopped});
}

References m_alive, m_cond, m_data_channel, m_decode_thread, m_jpeg_queue, m_mutex, m_peer_connection, m_signaling, report(), and Slic3r::GUI::WebRtcMediaController::Status::Stopped.

Referenced by Play(), and Stop().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_alive

std::atomic<bool> Slic3r::GUI::WebRtcMediaController::m_alive {false}

private

{false};

Referenced by bind_data_channel(), decode_loop(), is_active(), on_ready(), Play(), and teardown().

m_cond

std::condition_variable Slic3r::GUI::WebRtcMediaController::m_cond

private

Referenced by decode_loop(), enqueue_jpeg(), and teardown().

m_data_channel

std::shared_ptr<rtc::DataChannel> Slic3r::GUI::WebRtcMediaController::m_data_channel

private

Referenced by decode_loop(), on_ready(), and teardown().

m_decode_thread

std::thread Slic3r::GUI::WebRtcMediaController::m_decode_thread

private

Referenced by Play(), and teardown().

m_epoch

std::atomic<std::uint64_t> Slic3r::GUI::WebRtcMediaController::m_epoch {0}

private

{0};

Referenced by epoch(), Play(), and report().

m_frame_sink

std::function<void(const wxImage&, wxSize)> Slic3r::GUI::WebRtcMediaController::m_frame_sink

private

Referenced by WebRtcMediaController(), and deliver_jpeg().

m_has_frame

bool Slic3r::GUI::WebRtcMediaController::m_has_frame = false

private

Referenced by decode_loop(), deliver_jpeg(), and Play().

m_jpeg_queue

std::deque<std::vector<std::byte> > Slic3r::GUI::WebRtcMediaController::m_jpeg_queue

private

Referenced by decode_loop(), enqueue_jpeg(), Play(), and teardown().

m_last_frame_time

std::chrono::steady_clock::time_point Slic3r::GUI::WebRtcMediaController::m_last_frame_time {}

private

{};

Referenced by deliver_jpeg(), and Play().

m_mutex

std::mutex Slic3r::GUI::WebRtcMediaController::m_mutex

mutableprivate

Referenced by decode_loop(), deliver_jpeg(), enqueue_jpeg(), GetState(), GetVideoSize(), on_answer(), on_ice(), on_ready(), Play(), report(), and teardown().

m_on_status

std::function<void(Status)> Slic3r::GUI::WebRtcMediaController::m_on_status

private

Referenced by WebRtcMediaController(), and report().

m_peer_connection

std::shared_ptr<rtc::PeerConnection> Slic3r::GUI::WebRtcMediaController::m_peer_connection

private

Referenced by decode_loop(), on_answer(), on_ice(), on_ready(), and teardown().

m_pending_candidates

std::vector<std::pair<std::string, std::string> > Slic3r::GUI::WebRtcMediaController::m_pending_candidates

private

Referenced by on_answer(), on_ice(), and Play().

m_pending_signaling

std::unique_ptr<ICameraSignalingChannel> Slic3r::GUI::WebRtcMediaController::m_pending_signaling

private

Referenced by Play(), and set_signalling_channel().

m_remote_description_set

bool Slic3r::GUI::WebRtcMediaController::m_remote_description_set = false

private

Referenced by on_answer(), on_ice(), and Play().

m_signaling

std::unique_ptr<ICameraSignalingChannel> Slic3r::GUI::WebRtcMediaController::m_signaling

private

Referenced by on_ready(), Play(), and teardown().

m_state

wxMediaState Slic3r::GUI::WebRtcMediaController::m_state = static_cast<wxMediaState>(3)

private

Referenced by GetState(), and report().

m_video_size

wxSize Slic3r::GUI::WebRtcMediaController::m_video_size = wxDefaultSize

private

Referenced by deliver_jpeg(), GetVideoSize(), and Play().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/WebRtcMediaController.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/WebRtcMediaController.cpp