Slic3r::GUI::MediaPlayCtrl Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/MediaPlayCtrl.h>

Inheritance diagram for Slic3r::GUI::MediaPlayCtrl:

Collaboration diagram for Slic3r::GUI::MediaPlayCtrl:

Classes
struct	MediaTask

Public Member Functions
	MediaPlayCtrl (wxWindow *parent, wxMediaCtrl3 *media_ctrl, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize)
	~MediaPlayCtrl ()
void	SetMachineObject (MachineObject *obj)
void	SetWebMediaController (IMediaController *ctrl)
void	StopWebStream ()
bool	IsStreaming () const
void	ToggleStream ()
void	msw_rescale ()
void	jump_to_play ()

Protected Member Functions
void	onStateChanged (wxMediaEvent &event)
void	Play ()
void	Stop (wxString const &msg={}, wxString const &msg2={})
void	TogglePlay ()
void	SetStatus (wxString const &msg, bool hyperlink=true)
void	on_webrtc_status (WebRtcMediaController::Status status)

Private Member Functions
void	load ()
void	on_show_hide (wxShowEvent &evt)
void	media_proc ()
CameraStreamMode	current_mode () const
void	set_active_media_controller (CameraStreamMode mode)

Static Private Member Functions
static bool	start_stream_service (bool *need_install=nullptr)
static bool	get_stream_url (std::string *url=nullptr)

Private Attributes
std::shared_ptr< int >	m_token = std::make_shared<int>(0)
wxMediaCtrl3 *	m_media_ctrl
IMediaController *	m_active_media_controller = nullptr
IMediaController *	m_web_ctrl = nullptr
std::unique_ptr< WebRtcMediaController >	m_webrtc_ctrl
CameraStreamMode	m_last_mode = CameraStreamMode::none
std::uint64_t	m_webrtc_epoch = 0
std::string	m_agent_camera_url
bool	m_web_user_stopped = false
wxMediaState	m_last_state = MEDIASTATE_IDLE
std::string	m_machine
int	m_lan_proto = 0
std::string	m_lan_ip
std::string	m_lan_user
std::string	m_lan_passwd
std::string	m_dev_ver
std::string	m_tutk_state
bool	m_camera_exists = false
bool	m_lan_mode = false
int	m_remote_proto = 0
bool	m_device_busy = false
bool	m_disable_lan = false
wxString	m_url
std::deque< MediaTask >	m_tasks
boost::mutex	m_mutex
boost::condition_variable	m_cond
boost::thread	m_thread
bool	m_streaming = false
bool	m_user_triggered = false
int	m_failed_retry = 0
int	m_failed_code = 0
std::vector< double >	m_stat
std::set< int >	m_last_failed_codes
wxDateTime	m_last_user_play
wxDateTime	m_next_retry
::Button *	m_button_play
::Label *	m_label_stat
::Label *	m_label_status

Static Private Attributes
static const wxMediaState	MEDIASTATE_IDLE = static_cast<wxMediaState>(3)
static const wxMediaState	MEDIASTATE_INITIALIZING = static_cast<wxMediaState>(4)
static const wxMediaState	MEDIASTATE_LOADING = static_cast<wxMediaState>(5)
static const wxMediaState	MEDIASTATE_BUFFERING = static_cast<wxMediaState>(6)

Detailed Description

---

Class Documentation

Slic3r::GUI::MediaPlayCtrl::MediaTask

struct Slic3r::GUI::MediaPlayCtrl::MediaTask

Collaboration diagram for Slic3r::GUI::MediaPlayCtrl::MediaTask:

Class Members
wxString	command
IMediaController *	controller = nullptr

Constructor & Destructor Documentation

MediaPlayCtrl()

Slic3r::GUI::MediaPlayCtrl::MediaPlayCtrl	(	wxWindow *	parent,
		wxMediaCtrl3 *	media_ctrl,
		const wxPoint &	pos = wxDefaultPosition,
		const wxSize &	size = wxDefaultSize )

    : wxPanel(parent, wxID_ANY, pos, size)
    , m_media_ctrl(media_ctrl)
    , m_active_media_controller(media_ctrl)
{
    SetLabel("MediaPlayCtrl");
    SetBackgroundColour(*wxWHITE);
    m_media_ctrl->Bind(wxEVT_MEDIA_STATECHANGED, &MediaPlayCtrl::onStateChanged, this);
    m_media_ctrl->SetIdleImage(from_u8(resources_dir() + "/images/live_stream_default.png"));
 
    m_button_play = new Button(this, "", "media_play", wxBORDER_NONE);
    m_button_play->SetCanFocus(false);
 
    m_label_status = new Label(this, "");
    m_label_status->SetForegroundColour(wxColour("#323A3C"));
 
    m_label_stat = new Label(this, "");
    m_label_stat->SetForegroundColour(wxColour("#323A3C"));
    m_media_ctrl->Bind(EVT_MEDIA_CTRL_STAT, [this](auto & e) {
#if !BBL_RELEASE_TO_PUBLIC
        wxSize size = m_media_ctrl->GetVideoSize();
        m_label_stat->SetLabel(e.GetString() + wxString::Format(" VS:%ix%i", size.x, size.y));
#endif
        wxString str = e.GetString();
        m_stat.clear();
        for (auto k : {"FPS:", "BPS:", "T:", "B:"}) {
            auto ik = str.Find(k);
            double value = 0;
            if (ik != wxString::npos) {
                ik += strlen(k);
                auto ip = str.find(' ', ik);
                if (ip == wxString::npos) ip = str.Length();
                auto v = str.Mid(ik, ip - ik);
                if (strcmp(k, "T:") == 0 && v.Length() == 8) {
                    long h = 0,m = 0,s = 0;
                    v.Left(2).ToLong(&h);
                    v.Mid(3, 2).ToLong(&m);
                    v.Mid(6, 2).ToLong(&s);
                    value = h * 3600. + m * 60 + s;
                } else {
                    v.ToDouble(&value);
                    if (v.Right(1) == "K") value *= 1024;
                    else if (v.Right(1) == "%") value *= 0.01;
                }
            }
            m_stat.push_back(value);
        }
    });
 
    m_button_play->Bind(wxEVT_COMMAND_BUTTON_CLICKED, [this](auto &e) { TogglePlay(); });
    m_button_play->Bind(wxEVT_RIGHT_UP, [this](auto & e) {
        if (m_active_media_controller)
            m_active_media_controller->Play();
    });
    // Orca: live-view FAQ link binding removed (vendor URL)
 
    Bind(wxEVT_RIGHT_UP, [this](auto & e) {
        wxClipboard & c = *wxTheClipboard;
        if (c.Open()) {
            if (wxGetKeyState(WXK_SHIFT)) {
                if (c.IsSupported(wxDF_TEXT)) {
                    wxTextDataObject data;
                    c.GetData(data);
                    Stop();
                    m_url = data.GetText();
                    load();
                }
            } else {
                c.SetData(new wxTextDataObject(m_url));
            }
            c.Close();
        }
    });
 
    wxBoxSizer * sizer = new wxBoxSizer(wxHORIZONTAL);
    sizer->Add(m_button_play, 0, wxEXPAND | wxALL, 0);
    sizer->Add(m_label_stat, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(25));
    sizer->AddStretchSpacer(1);
    sizer->Add(m_label_status, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(25));
    SetSizer(sizer);
 
    m_thread = boost::thread([this] {
        media_proc();
    });
 
//#if BBL_RELEASE_TO_PUBLIC
//    m_next_retry = wxDateTime::Now();
//#endif
 
    parent->Bind(wxEVT_SHOW, &MediaPlayCtrl::on_show_hide, this);
    parent->GetParent()->GetParent()->Bind(wxEVT_SHOW, &MediaPlayCtrl::on_show_hide, this);
 
    m_lan_user = "bblp";
    m_lan_passwd = "bblp";
}

References Slic3r::GUI::from_u8(), load(), m_active_media_controller, m_button_play, m_label_stat, m_label_status, m_lan_passwd, m_lan_user, m_media_ctrl, m_stat, m_thread, m_url, media_proc(), on_show_hide(), onStateChanged(), Slic3r::resources_dir(), Stop(), and TogglePlay().

Referenced by ToggleStream().

Here is the call graph for this function:

Here is the caller graph for this function:

~MediaPlayCtrl()

Slic3r::GUI::MediaPlayCtrl::~MediaPlayCtrl

(

)

{
    if (m_webrtc_ctrl)
        m_webrtc_ctrl->Stop();
    m_media_ctrl->EndExternalStream();
    {
        boost::unique_lock lock(m_mutex);
        m_tasks.push_back({"<exit>", nullptr});
        m_cond.notify_all();
    }
    while (!m_thread.try_join_for(boost::chrono::milliseconds(10))) {
        wxEventLoopBase::GetActive()->Yield();
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": " << this;
}

References m_cond, m_media_ctrl, m_mutex, m_tasks, m_thread, and m_webrtc_ctrl.

Member Function Documentation

current_mode()

CameraStreamMode Slic3r::GUI::MediaPlayCtrl::current_mode ( ) const

private

{
    auto agent = wxGetApp().getAgent();
    return agent ? agent->get_camera_stream_mode() : CameraStreamMode::none;
}

References Slic3r::none.

Referenced by load(), Play(), SetMachineObject(), and SetWebMediaController().

Here is the caller graph for this function:

get_stream_url()

bool Slic3r::GUI::MediaPlayCtrl::get_stream_url ( std::string * url = nullptr )

staticprivate

{
#ifdef __WIN32__
    HANDLE shm = ::OpenFileMapping(FILE_MAP_READ, FALSE, L"bambu_stream_url");
    if (shm == NULL) return false;
    if (url) {
        char *addr = (char *) MapViewOfFile(shm, FILE_MAP_READ, 0, 0, 0);
        if (addr) {
            *url = addr;
            UnmapViewOfFile(addr);
            url = nullptr;
        }
    }
    CloseHandle(shm);
#else
    std::string file_url = data_dir() + "/cameratools/url.txt";
    key_t key = ::ftok(file_url.c_str(), 1000);
    int shm = ::shmget(key, 1024, 0);
    if (shm == -1) return false;
    struct shmid_ds ds;
    ::shmctl(shm, IPC_STAT, &ds);
    if (ds.shm_nattch == 0) {
        return false;
    }
    if (url) {
        char *addr = (char *) ::shmat(shm, nullptr, 0);
        if (addr != (void*) -1) {
            *url = addr;
            ::shmdt(addr);
            url = nullptr;
        }
    }
#endif
    return url == nullptr;
}

References Slic3r::data_dir(), get_stream_url(), and L.

Referenced by get_stream_url(), SetMachineObject(), and ToggleStream().

Here is the call graph for this function:

Here is the caller graph for this function:

IsStreaming()

bool Slic3r::GUI::MediaPlayCtrl::IsStreaming

(

)

const

{ return m_streaming; }

References IsStreaming(), and m_streaming.

Referenced by IsStreaming().

Here is the call graph for this function:

Here is the caller graph for this function:

jump_to_play()

void Slic3r::GUI::MediaPlayCtrl::jump_to_play

(

)

{
    if (m_last_state != MEDIASTATE_IDLE)
        return;
    TogglePlay();
}

References jump_to_play(), m_last_state, MEDIASTATE_IDLE, and TogglePlay().

Referenced by Slic3r::GUI::MultiMachineItem::MultiMachineItem(), and jump_to_play().

Here is the call graph for this function:

Here is the caller graph for this function:

load()

void Slic3r::GUI::MediaPlayCtrl::load ( )

private

{
    m_last_state = MEDIASTATE_LOADING;
    SetStatus(_L("Loading..."));
    const auto mode = current_mode();
    if (mode == CameraStreamMode::none && wxGetApp().app_config->get("internal_developer_mode") == "true") {
        std::string file_h264 = data_dir() + "/video.h264";
        std::string file_info = data_dir() + "/video.info";
        BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl dump video to " << file_h264;
        // closed by BambuSource
        FILE *dump_h264_file = boost::nowide::fopen(file_h264.c_str(), "wb");
        FILE *dump_info_file = boost::nowide::fopen(file_info.c_str(), "wb");
        m_url                = m_url + "&dump_h264=" + boost::lexical_cast<std::string>(dump_h264_file);
        m_url                = m_url + "&dump_info=" + boost::lexical_cast<std::string>(dump_info_file);
    }
    boost::unique_lock lock(m_mutex);
    m_tasks.push_back({m_url, m_active_media_controller});
    m_cond.notify_all();
}

References _L, current_mode(), Slic3r::data_dir(), load(), m_active_media_controller, m_cond, m_last_state, m_mutex, m_tasks, m_url, MEDIASTATE_LOADING, Slic3r::none, and SetStatus().

Referenced by MediaPlayCtrl(), load(), and Play().

Here is the call graph for this function:

Here is the caller graph for this function:

media_proc()

void Slic3r::GUI::MediaPlayCtrl::media_proc ( )

private

{
    boost::unique_lock lock(m_mutex);
    while (true) {
        while (m_tasks.empty()) {
            m_cond.wait(lock);
        }
        MediaTask task = m_tasks.front();
        if (m_tasks.size() >= 2 && !task.command.IsEmpty() && task.command[0] != '<' &&
            m_tasks[1].command == "<stop>" && task.controller == m_tasks[1].controller) {
            BOOST_LOG_TRIVIAL(trace) << "MediaPlayCtrl: busy skip url: " << task.command;
            m_tasks.pop_front();
            m_tasks.pop_front();
            continue;
        }
        lock.unlock();
        if (task.command == "<stop>") {
            BOOST_LOG_TRIVIAL(info) <<  "MediaPlayCtrl: start stop";
            if (task.controller)
                task.controller->Stop();
            BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl: end stop";
        }
        else if (task.command == "<exit>") {
            break;
        }
        else if (task.command == "<play>") {
            BOOST_LOG_TRIVIAL(info) <<  "MediaPlayCtrl: start play";
            if (task.controller)
                task.controller->Play();
            BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl: end play";
        }
        else {
            BOOST_LOG_TRIVIAL(info) <<  "MediaPlayCtrl: start load";
            if (task.controller)
                task.controller->Load(wxURI(task.command));
            BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl: end load";
        }
        lock.lock();
        m_tasks.pop_front();
        wxMediaEvent theEvent(wxEVT_MEDIA_STATECHANGED, m_media_ctrl->GetId());
        theEvent.SetId(0);
        m_media_ctrl->GetEventHandler()->AddPendingEvent(theEvent);
    }
}

References Slic3r::GUI::MediaPlayCtrl::MediaTask::command, Slic3r::GUI::MediaPlayCtrl::MediaTask::controller, Slic3r::GUI::IMediaController::Load(), m_cond, m_media_ctrl, m_mutex, m_tasks, media_proc(), Slic3r::GUI::IMediaController::Play(), Slic3r::GUI::IMediaController::Stop(), and Slic3r::trace().

Referenced by MediaPlayCtrl(), and media_proc().

Here is the call graph for this function:

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::MediaPlayCtrl::msw_rescale

(

)

                                {
    m_button_play->Rescale();
}

References m_button_play, and msw_rescale().

Referenced by msw_rescale().

Here is the call graph for this function:

Here is the caller graph for this function:

on_show_hide()

void Slic3r::GUI::MediaPlayCtrl::on_show_hide ( wxShowEvent & evt )

private

{
    evt.Skip();
    if (m_isBeingDeleted) return;
    m_failed_retry = 0;
    if (!IsShownOnScreen())
        Stop();
}

References m_failed_retry, on_show_hide(), and Stop().

Referenced by MediaPlayCtrl(), and on_show_hide().

Here is the call graph for this function:

Here is the caller graph for this function:

on_webrtc_status()

void Slic3r::GUI::MediaPlayCtrl::on_webrtc_status ( WebRtcMediaController::Status status )

protected

{
    // Drop CallAfter-queued events from a superseded Play attempt.
    if (status.epoch != m_webrtc_epoch)
        return;
    if (status.kind == WebRtcMediaController::Status::Connecting) {
        m_last_state = MEDIASTATE_INITIALIZING;
        SetStatus(_L("Initializing..."), false);
    } else if (status.kind == WebRtcMediaController::Status::Playing) {
        m_last_state = wxMEDIASTATE_PLAYING;
        m_failed_code = 0;
        m_failed_retry = 0;
        SetStatus(_L("Playing..."), false);
    } else if (status.kind == WebRtcMediaController::Status::Failed) {
        m_failed_code = static_cast<int>(status.code) + 1;
        Stop();
    }
    // Status::Stopped needs no action: a genuine failure arrives as Failed, and
    // a stop we initiated is already handled by Stop() itself.
}

References _L, Slic3r::GUI::WebRtcMediaController::Status::code, Slic3r::GUI::WebRtcMediaController::Status::Connecting, Slic3r::GUI::WebRtcMediaController::Status::epoch, Slic3r::GUI::WebRtcMediaController::Status::Failed, Slic3r::GUI::WebRtcMediaController::Status::kind, m_failed_code, m_failed_retry, m_last_state, m_webrtc_epoch, MEDIASTATE_INITIALIZING, Slic3r::GUI::WebRtcMediaController::Status::Playing, SetStatus(), and Stop().

Referenced by set_active_media_controller().

Here is the call graph for this function:

Here is the caller graph for this function:

onStateChanged()

void Slic3r::GUI::MediaPlayCtrl::onStateChanged ( wxMediaEvent & event )

protected

{
    auto last_state = m_last_state;
    if (m_active_media_controller != m_media_ctrl)
        return;
    auto state      = m_active_media_controller->GetState();
    BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::onStateChanged: " << state << ", last_state: " << last_state;
    if ((int) state < 0) return;
    {
        boost::unique_lock lock(m_mutex);
        if (!m_tasks.empty()) {
            BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::onStateChanged: skip when task not finished";
            return;
        }
    }
    if ((last_state == MEDIASTATE_IDLE || last_state == MEDIASTATE_INITIALIZING) && state == wxMEDIASTATE_STOPPED) { return; }
    if ((last_state == wxMEDIASTATE_PAUSED || last_state == wxMEDIASTATE_PLAYING) && state == wxMEDIASTATE_STOPPED) {
        m_failed_code = m_active_media_controller->GetLastError();
        Stop();
        return;
    }
    if (last_state == MEDIASTATE_LOADING && (state == wxMEDIASTATE_STOPPED || state == wxMEDIASTATE_PAUSED)) {
        wxSize size = m_active_media_controller->GetVideoSize();
        BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::onStateChanged: size: " << size.x << "x" << size.y;
        m_failed_code = m_active_media_controller->GetLastError();
        if (size.GetWidth() >= 320) {
            m_last_state = state;
            m_failed_code = 0;
            SetStatus(_L("Playing..."), false);
 
 
            m_failed_retry = 0;
            m_disable_lan = false;
            boost::unique_lock lock(m_mutex);
            m_tasks.push_back({"<play>", m_active_media_controller});
            m_cond.notify_all();
        } else if (event.GetId()) {
            if (m_failed_code == 0)
                m_failed_code = 2;
            Stop();
        }
    } else {
        m_last_state = state;
    }
}

References _L, m_active_media_controller, m_cond, m_disable_lan, m_failed_code, m_failed_retry, m_last_state, m_media_ctrl, m_mutex, m_tasks, MEDIASTATE_IDLE, MEDIASTATE_INITIALIZING, MEDIASTATE_LOADING, onStateChanged(), SetStatus(), and Stop().

Referenced by MediaPlayCtrl(), and onStateChanged().

Here is the call graph for this function:

Here is the caller graph for this function:

Play()

void Slic3r::GUI::MediaPlayCtrl::Play ( )

protected

{
    if ((m_next_retry.IsValid() && wxDateTime::Now() < m_next_retry) || !IsShownOnScreen() || m_last_state != MEDIASTATE_IDLE)
        return;
 
    const CameraStreamMode mode = current_mode();
    set_active_media_controller(mode);
    m_last_mode = mode;
    auto agent = wxGetApp().getAgent();
 
    auto printer_agent = agent ? agent->get_printer_agent() : nullptr;
    const bool is_bbl = (printer_agent ? printer_agent->get_agent_info().id : "") == BBL_PRINTER_AGENT_ID;
 
    if (!is_bbl) {
        const bool is_webrtc = mode == CameraStreamMode::webrtc;
        const bool is_snapshot = mode == CameraStreamMode::http_snapshot;
        const bool is_http_stream = mode == CameraStreamMode::http || mode == CameraStreamMode::https || mode == CameraStreamMode::rtsp;
        if (!is_webrtc && !is_snapshot && !is_http_stream)
            return;
 
        auto *webrtc_ctrl = is_webrtc ? dynamic_cast<WebRtcMediaController *>(m_active_media_controller) : nullptr;
        if (is_webrtc && (!webrtc_ctrl || !m_media_ctrl)) {
            Stop(_L("Please confirm if the printer is connected."));
            return;
        }
        if (webrtc_ctrl && webrtc_ctrl->is_active())
            return;
 
        m_failed_code = 0;
        if (!m_active_media_controller || m_machine.empty() || !IsEnabled() || !m_camera_exists ||
            (!is_webrtc && m_url.IsEmpty())) {
            Stop(_L("Please confirm if the printer is connected."));
            return;
        }
 
        if (is_webrtc) {
            BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::Play webrtc: last_state=" << m_last_state << " failed_retry=" << m_failed_retry
                                    << " shown=" << IsShownOnScreen();
            auto channel = agent ? agent->create_camera_signaling_channel(m_machine, wxGetApp().get_printer_cloud_provider()) : nullptr;
            if (!channel) {
                Stop(_L("Sign in to OrcaCloud to view the camera."));
                return;
            }
            webrtc_ctrl->set_signalling_channel(std::move(channel));
            m_media_ctrl->BeginExternalStream();
            m_last_state = MEDIASTATE_INITIALIZING;
            SetStatus(_L("Initializing..."), false);
        } else if (is_snapshot) {
            m_last_state = wxMEDIASTATE_PLAYING;
            SetStatus(_L("Playing..."), false);
        }
 
        m_button_play->SetIcon("media_stop");
        if (m_active_media_controller == m_media_ctrl) {
            // wxMediaCtrl3 reports when it has a decoded frame; load() waits for
            // that event before queuing Play so the stream is not marked stopped.
            load();
        } else {
            m_active_media_controller->Load(wxURI(m_url));
            m_active_media_controller->Play();
        }
        if (webrtc_ctrl) {
            m_webrtc_epoch = webrtc_ctrl->epoch();
        }
        return;
    }
 
    m_failed_code = 0;
    if (m_machine.empty()) {
        Stop(_L("Please confirm if the printer is connected."));
        return;
    }
    if (!IsEnabled()) {
        Stop(_L("Please confirm if the printer is connected."));
        return;
    }
    if (m_device_busy) {
        Stop(_L("The printer is currently busy downloading. Please try again after it finishes."));
        m_failed_retry = 0;
        return;
    }
    if (!m_camera_exists) {
        Stop(_L("Printer camera is malfunctioning."));
        return;
    }
 
    BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::Play: " << m_lan_proto << m_remote_proto << m_disable_lan;
    std::string  agent_version = agent ? agent->get_version() : "";
    if (m_lan_proto > LiveviewLocal::LVL_Disable && (m_lan_mode || !m_remote_proto) && !m_disable_lan && !m_lan_ip.empty()) {
        m_disable_lan = m_remote_proto && !m_lan_mode; // try remote next time
        std::string url;
        if (m_lan_proto == LiveviewLocal::LVL_Local)
            url = "bambu:///local/" + m_lan_ip + ".?port=6000&user=" + m_lan_user + "&passwd=" + m_lan_passwd;
        else if (m_lan_proto == LiveviewLocal::LVL_Rtsps)
            url = "bambu:///rtsps___" + m_lan_user + ":" + m_lan_passwd + "@" + m_lan_ip + "/streaming/live/1?proto=rtsps";
        else if (m_lan_proto == LiveviewLocal::LVL_Rtsp)
            url = "bambu:///rtsp___" + m_lan_user + ":" + m_lan_passwd + "@" + m_lan_ip + "/streaming/live/1?proto=rtsp";
        url += "&device=" + m_machine;
        url += "&net_ver=" + agent_version;
        url += "&dev_ver=" + m_dev_ver;
        url += "&cli_id=" + wxGetApp().app_config->get("slicer_uuid");
        url += "&cli_ver=" + std::string(SLIC3R_VERSION);
        BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl: " << hide_passwd(hide_id_middle_string(url, url.find(m_lan_ip), m_lan_ip.length()), {m_lan_passwd});
        m_url = url;
        load();
        m_button_play->SetIcon("media_stop");
        return;
    }
 
    // m_lan_mode && m_lan_proto > LVL_Disable (use local tunnel)
    // m_lan_mode && m_lan_proto == LVL_Disable (*)
    // m_lan_mode && m_lan_proto == LVL_None (x)
    // !m_lan_mode && m_remote_proto (go on)
    // !m_lan_mode && !m_remote_proto && m_lan_proto > LVL_None (use local tunnel)
    // !m_lan_mode && !m_remote_proto && m_lan_proto == LVL_Disable (*)
    // !m_lan_mode && !m_remote_proto && m_lan_proto == LVL_None (x)
 
    if (m_lan_proto <= LiveviewLocal::LVL_Disable && (m_lan_mode || !m_remote_proto)) {
        Stop(m_lan_proto == LiveviewLocal::LVL_None
            ? _L("A problem occurred. Please update the printer firmware and try again.")
            : _L("LAN Only Liveview is off. Please turn on the liveview on printer screen."));
        return;
    }
 
    m_disable_lan = false;
    m_failed_code = 0;
    m_last_state  = MEDIASTATE_INITIALIZING;
    m_button_play->SetIcon("media_stop");
 
    if (!m_remote_proto) { // not support tutk
        m_failed_code = -1;
        m_url = "bambu:///local/";
        Stop(_L("Please enter the IP of the printer to connect."));
        return;
    }
 
    m_label_stat->SetLabel({});
    SetStatus(_L("Initializing..."));
 
    if (agent) {
        std::string protocols[] = {"", "\"tutk\"", "\"agora\"", "\"tutk\",\"agora\""};
        agent->get_camera_url(m_machine + "|" + m_dev_ver + "|" + protocols[m_remote_proto],
                [this, m = m_machine, v = agent_version, dv = m_dev_ver, token = std::weak_ptr(m_token)](std::string url) {
            if (token.expired()) {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": token has been expired";
                return;
            }
 
            if (boost::algorithm::starts_with(url, "bambu:///")) {
                url += "&device=" + into_u8(m);
                url += "&net_ver=" + v;
                url += "&dev_ver=" + dv;
                url += "&refresh_url=" + boost::lexical_cast<std::string>(&refresh_agora_url);
                url += "&cli_id=" + wxGetApp().app_config->get("slicer_uuid");
                url += "&cli_ver=" + std::string(SLIC3R_VERSION);
            }
            BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl: " << hide_passwd(url,
                    {"?uid=", "authkey=", "passwd=", "license=", "token="});
            CallAfter([this, m, url] {
                if (m != m_machine) {
                    BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl drop late ttcode for machine: " << m;
                    return;
                }
                if (m_last_state == MEDIASTATE_INITIALIZING) {
                    if (url.empty() || !boost::algorithm::starts_with(url, "bambu:///")) {
                        m_failed_code = 3;
                        if (boost::ends_with(url, "]")) {
                            size_t n = url.find_last_of('[');
                            if (n != std::string::npos)
                                m_failed_code = std::atoi(url.substr(n + 1, url.length() - n - 2).c_str());
                        }
                        Stop(_L("Connection Failed. Please check the network and try again"), from_u8(url));
                    } else {
                        m_url = url;
                        load();
                    }
                } else {
                    BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl drop late ttcode for state: " << m_last_state;
                }
            });
        }, wxGetApp().get_printer_cloud_provider());
    }
}

References _L, Slic3r::BBL_PRINTER_AGENT_ID, current_mode(), Slic3r::GUI::from_u8(), Slic3r::GUI::hide_id_middle_string(), Slic3r::GUI::hide_passwd(), Slic3r::http, Slic3r::http_snapshot, Slic3r::https, Slic3r::GUI::into_u8(), load(), Slic3r::LVL_Disable, Slic3r::LVL_Local, Slic3r::LVL_None, Slic3r::LVL_Rtsp, Slic3r::LVL_Rtsps, m_active_media_controller, m_button_play, m_camera_exists, m_dev_ver, m_device_busy, m_disable_lan, m_failed_code, m_failed_retry, m_label_stat, m_lan_ip, m_lan_mode, m_lan_passwd, m_lan_proto, m_lan_user, m_last_mode, m_last_state, m_machine, m_media_ctrl, m_next_retry, m_remote_proto, m_token, m_url, m_webrtc_epoch, MEDIASTATE_IDLE, MEDIASTATE_INITIALIZING, Slic3r::GUI::refresh_agora_url(), Slic3r::rtsp, set_active_media_controller(), SetStatus(), Stop(), and Slic3r::webrtc.

Referenced by TogglePlay().

Here is the call graph for this function:

Here is the caller graph for this function:

set_active_media_controller()

void Slic3r::GUI::MediaPlayCtrl::set_active_media_controller ( CameraStreamMode mode )

private

{
    switch (mode) {
    case CameraStreamMode::http_snapshot:
        if (auto *web_ctrl = dynamic_cast<WebMediaController *>(m_web_ctrl))
            web_ctrl->set_mode(mode);
        m_active_media_controller = m_web_ctrl;
        break;
    case CameraStreamMode::webrtc:
        if (!m_webrtc_ctrl) {
            m_webrtc_ctrl = std::make_unique<WebRtcMediaController>(
                [this](const wxImage& image, wxSize size) { m_media_ctrl->SetExternalFrame(image, size); },
                [this, token = std::weak_ptr<int>(m_token)](WebRtcMediaController::Status status) {
                    if (token.expired())
                        return;
                    CallAfter([this, status] { on_webrtc_status(status); });
                });
        }
        m_active_media_controller = m_webrtc_ctrl.get();
        break;
    default:
        m_active_media_controller = m_media_ctrl;
        break;
    }
}

References Slic3r::http_snapshot, m_active_media_controller, m_media_ctrl, m_token, m_web_ctrl, m_webrtc_ctrl, on_webrtc_status(), and Slic3r::webrtc.

Referenced by Play(), SetMachineObject(), and SetWebMediaController().

Here is the call graph for this function:

Here is the caller graph for this function:

SetMachineObject()

void Slic3r::GUI::MediaPlayCtrl::SetMachineObject

(

MachineObject *

obj

)

{
    const CameraStreamMode mode = current_mode();
    if (mode != m_last_mode) {
        if (m_last_state != MEDIASTATE_IDLE) {
            m_failed_code = 0; // a mode switch is not a stream failure - don't arm back-off
            Stop(" ");
        }
        m_last_mode = mode;
    }
    set_active_media_controller(mode);
 
    const bool uses_local_camera_url = mode == CameraStreamMode::http || mode == CameraStreamMode::https ||
                                       mode == CameraStreamMode::http_snapshot || mode == CameraStreamMode::rtsp;
    const bool uses_webrtc = mode == CameraStreamMode::webrtc;
    const std::string machine = obj ? obj->get_dev_id() : "";
    bool changed = false;
 
    if (uses_local_camera_url) {
        auto agent = wxGetApp().getAgent();
        std::string url = agent ? agent->get_local_camera_stream_url() : "";
        m_camera_exists = !url.empty();
        Enable(obj && m_camera_exists);
        changed = machine != m_machine || url != m_agent_camera_url;
        m_agent_camera_url = url;
        m_url = from_u8(url);
    } else if (uses_webrtc) {
        m_camera_exists = obj != nullptr;
        Enable(obj != nullptr);
        changed = machine != m_machine;
        BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::SetMachineObject webrtc: changed=" << changed
                                << " last_state=" << m_last_state << " web_user_stopped=" << m_web_user_stopped;
        m_url.clear();
        m_agent_camera_url.clear();
    } else {
        if (obj) {
            m_camera_exists  = obj->has_ipcam;
            m_dev_ver        = obj->get_ota_version();
            m_lan_mode       = obj->is_lan_mode_printer();
            m_lan_proto      = obj->liveview_local;
            m_remote_proto   = obj->get_liveview_remote();
            m_lan_ip         = obj->get_dev_ip();
            m_lan_passwd     = obj->get_access_code();
            m_device_busy    = obj->is_camera_busy_off();
            m_tutk_state     = obj->tutk_state;
 
            if (DevPrinterConfigUtil::get_printer_series_str(obj->printer_type) == "series_o" && BBLNetworkPlugin::instance().use_legacy_network()) {
                // Legacy plugin cannot support remote play for H2D, force using local mode
                m_remote_proto = LiveviewRemote::LVR_None;
            }
        } else {
            m_camera_exists = false;
            m_lan_mode = false;
            m_lan_proto = LiveviewLocal::LVL_None;
            m_lan_ip.clear();
            m_lan_passwd.clear();
            m_dev_ver.clear();
            m_tutk_state.clear();
            m_remote_proto = 0;
            m_device_busy = false;
        }
        Enable(obj && obj->is_info_ready() && obj->m_push_count > 0);
        if (machine == m_machine)
            return;
 
        m_machine = machine;
        BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl switch machine: " << m_machine;
        m_disable_lan = false;
        m_failed_retry = 0;
        m_last_failed_codes.clear();
        m_last_user_play = wxDateTime::Now();
        std::string stream_url;
        if (get_stream_url(&stream_url)) {
            m_streaming = boost::algorithm::contains(stream_url, "device=" + m_machine);
        } else {
            m_streaming = false;
        }
        if (m_last_state != MEDIASTATE_IDLE)
            Stop(" ");
        if (m_next_retry.IsValid()) // Try open 2 seconds later, to avoid state conflict
            m_next_retry = wxDateTime::Now() + wxTimeSpan::Seconds(2);
        else
            SetStatus("", false);
        return;
    }
 
    m_machine = machine;
    if (!changed)
        return;
 
    // A genuine target switch is not a stream failure and should clear the
    // manual-stop state before the new target is allowed to play.
    m_web_user_stopped = false;
    if (uses_local_camera_url) {
        m_failed_code = 0;
        m_failed_retry = 0;
        m_next_retry = wxDateTime();
    }
    if (m_last_state != MEDIASTATE_IDLE)
        Stop(" ");
}

References current_mode(), Slic3r::Enable, Slic3r::GUI::from_u8(), Slic3r::MachineObject::get_access_code(), Slic3r::MachineObject::get_dev_id(), Slic3r::MachineObject::get_dev_ip(), Slic3r::MachineObject::get_liveview_remote(), Slic3r::MachineObject::get_ota_version(), Slic3r::DevPrinterConfigUtil::get_printer_series_str(), get_stream_url(), Slic3r::MachineObject::has_ipcam, Slic3r::http, Slic3r::http_snapshot, Slic3r::https, Slic3r::BBLNetworkPlugin::instance(), Slic3r::MachineObject::is_camera_busy_off(), Slic3r::MachineObject::is_info_ready(), Slic3r::MachineObject::is_lan_mode_printer(), Slic3r::MachineObject::liveview_local, Slic3r::LVL_None, Slic3r::LVR_None, m_agent_camera_url, m_camera_exists, m_dev_ver, m_device_busy, m_disable_lan, m_failed_code, m_failed_retry, m_lan_ip, m_lan_mode, m_lan_passwd, m_lan_proto, m_last_failed_codes, m_last_mode, m_last_state, m_last_user_play, m_machine, m_next_retry, Slic3r::MachineObject::m_push_count, m_remote_proto, m_streaming, m_tutk_state, m_url, m_web_user_stopped, MEDIASTATE_IDLE, Slic3r::MachineObject::printer_type, Slic3r::rtsp, set_active_media_controller(), SetStatus(), Stop(), Slic3r::MachineObject::tutk_state, and Slic3r::webrtc.

Here is the call graph for this function:

SetStatus()

void Slic3r::GUI::MediaPlayCtrl::SetStatus ( wxString const & msg, bool hyperlink = true )

protected

{
    auto msg = msg2;
    if (m_failed_code != 0) {
        int state2 = m_last_state >= MEDIASTATE_IDLE ? m_last_state - MEDIASTATE_IDLE :
                                                       m_last_state + MEDIASTATE_BUFFERING - MEDIASTATE_IDLE;
        msg += wxString::Format(" [%d:%d]", state2, m_failed_code);
    }
    BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::SetStatus: " << msg.ToUTF8().data() << " tutk_state: " << m_tutk_state;
#ifdef __WXMSW__
    OutputDebugStringA("MediaPlayCtrl::SetStatus: ");
    OutputDebugStringA(msg.ToUTF8().data());
    OutputDebugStringA("\n");
#endif // __WXMSW__
    m_label_status->SetLabel(msg);
    m_label_status->Wrap(GetSize().GetWidth() - 120 - m_label_stat->GetSize().GetWidth());
    long style = m_label_status->GetWindowStyle() & ~LB_HYPERLINK;
    if (hyperlink) {
        style |= LB_HYPERLINK;
    }
    m_label_status->SetWindowStyle(style);
    m_label_status->InvalidateBestSize();
    Layout();
}

References LB_HYPERLINK, m_failed_code, m_label_stat, m_label_status, m_last_state, m_tutk_state, MEDIASTATE_BUFFERING, MEDIASTATE_IDLE, SetStatus(), and style.

Referenced by load(), on_webrtc_status(), onStateChanged(), Play(), SetMachineObject(), SetStatus(), Stop(), and StopWebStream().

Here is the call graph for this function:

Here is the caller graph for this function:

SetWebMediaController()

void Slic3r::GUI::MediaPlayCtrl::SetWebMediaController

(

IMediaController *

ctrl

)

{
    m_web_ctrl = ctrl;
    set_active_media_controller(current_mode());
}

References current_mode(), m_web_ctrl, and set_active_media_controller().

Here is the call graph for this function:

start_stream_service()

bool Slic3r::GUI::MediaPlayCtrl::start_stream_service ( bool * need_install = nullptr )

staticprivate

{
#ifdef __WIN32__
    auto tools_dir = boost::nowide::widen(data_dir())  + L"\\cameratools\\";
    auto file_source = tools_dir + L"bambu_source.exe";
    auto file_ffmpeg = tools_dir + L"ffmpeg.exe";
    auto file_ff_cfg = tools_dir + L"ffmpeg.cfg";
#else
    auto tools_dir   = data_dir() + "/cameratools/";
    auto file_source = tools_dir + "bambu_source";
    auto file_ffmpeg = tools_dir + "ffmpeg";
    auto file_ff_cfg = tools_dir + "ffmpeg.cfg";
#endif
    if (!boost::filesystem::exists(file_source) || !boost::filesystem::exists(file_ffmpeg) || !boost::filesystem::exists(file_ff_cfg)) {
        if (need_install) *need_install = true;
        return false;
    }
    std::string file_url  = data_dir() + "/cameratools/url.txt";
    if (!boost::filesystem::exists(file_url)) {
        boost::nowide::ofstream file(file_url);
        file.close();
    }
    wxString file_url2 = L"bambu:///camera/" + from_u8(file_url);
    file_url2.Replace("\\", "/");
    file_url2 = wxURI(file_url2).BuildURI();
    try {
        std::string configs;
        load_string_file(file_ff_cfg, configs);
        std::vector<std::string> configss;
        boost::algorithm::split(configss, configs, boost::algorithm::is_any_of("\r\n"));
        configss.erase(std::remove(configss.begin(), configss.end(), std::string()), configss.end());
        boost::process::pipe intermediate;
        boost::filesystem::path start_dir(boost::filesystem::path(data_dir()) / "plugins");
#ifdef __WXMSW__
        auto plugins_dir = boost::nowide::widen(data_dir()) + L"\\plugins\\";
        for (auto dll : {L"BambuSource.dll", L"live555.dll"}) {
            auto file_dll  = tools_dir + dll;
            auto file_dll2 = plugins_dir + dll;
            if (!boost::filesystem::exists(file_dll) || boost::filesystem::last_write_time(file_dll) != boost::filesystem::last_write_time(file_dll2))
                boost::filesystem::copy_file(file_dll2, file_dll, boost::filesystem::copy_options::overwrite_existing);
        }
        boost::process::child process_source(file_source, file_url2.ToStdWstring(), boost::process::start_dir(tools_dir),
                                             boost::process::windows::create_no_window,
                                             boost::process::std_out > intermediate, boost::process::limit_handles);
        boost::process::child process_ffmpeg(file_ffmpeg, configss, boost::process::windows::create_no_window,
                                             boost::process::std_in < intermediate, boost::process::limit_handles);
#else
        boost::filesystem::permissions(file_source, boost::filesystem::owner_exe | boost::filesystem::add_perms);
        boost::filesystem::permissions(file_ffmpeg, boost::filesystem::owner_exe | boost::filesystem::add_perms);
        boost::process::child process_source(file_source, file_url2.data().AsInternal(), boost::process::start_dir(start_dir),
                                             boost::process::std_out > intermediate, boost::process::limit_handles);
        boost::process::child process_ffmpeg(file_ffmpeg, configss, boost::process::std_in < intermediate, boost::process::limit_handles);
#endif
        process_source.detach();
        process_ffmpeg.detach();
    } catch (std::exception &e) {
        BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl failed to start camera stream: " << decode_path(e.what());
        return false;
    }
    return true;
}

References Slic3r::data_dir(), Slic3r::decode_path(), Slic3r::from_u8(), L, Slic3r::load_string_file(), and start_stream_service().

Referenced by start_stream_service(), and ToggleStream().

Here is the call graph for this function:

Here is the caller graph for this function:

Stop()

void Slic3r::GUI::MediaPlayCtrl::Stop ( wxString const & msg = {}, wxString const & msg2 = {} )

protected

{
    const bool webrtc_active = m_last_mode == CameraStreamMode::webrtc &&
                               dynamic_cast<WebRtcMediaController *>(m_active_media_controller) != nullptr;
    BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::Stop: last_state=" << m_last_state
                            << " webrtc_active=" << webrtc_active << " failed_code=" << m_failed_code
                            << " msg='" << msg.ToUTF8().data() << "'";
    if (webrtc_active) {
        m_active_media_controller->Stop();
        m_media_ctrl->EndExternalStream();
    }
    switch (m_last_mode) {
    case CameraStreamMode::http:
    case CameraStreamMode::https:
    case CameraStreamMode::http_snapshot: {
        const bool snapshot = m_last_mode == CameraStreamMode::http_snapshot;
        if (m_last_state != MEDIASTATE_IDLE) {
            if (snapshot) {
                if (m_active_media_controller)
                    m_active_media_controller->Stop();
            } else {
                // http/https mode plays through the ffmpeg backend (m_media_ctrl), not
                // the webview - tear its read thread down too, otherwise it keeps
                // pulling and painting frames after the UI says "Video Stopped".
                boost::unique_lock lock(m_mutex);
                m_tasks.push_back({"<stop>", m_active_media_controller});
                m_cond.notify_all();
            }
            m_button_play->SetIcon("media_play");
            m_last_state = MEDIASTATE_IDLE;
            if (!msg.IsEmpty())
                SetStatus(msg);
            else
                SetStatus(_L("Video Stopped."), false);
            // Keep retries bounded for an explicit or retry-driven playback attempt.
            // m_failed_retry is cleared on success (onStateChanged) and on a deliberate
            // machine switch (SetMachineObject); manual playback via TogglePlay resets it.
            if (m_failed_code != 0) {
                const bool auto_retry = wxGetApp().app_config->get("liveview", "auto_retry") != "false";
                ++m_failed_retry;
                m_next_retry = auto_retry
                    ? wxDateTime::Now() + wxTimeSpan::Seconds(std::min(5 * m_failed_retry, 30))
                    : wxDateTime::Now() + wxTimeSpan::Days(1); // "off": wait for a manual retry
            }
        } else if (!msg.IsEmpty()) {
            SetStatus(msg, false);
        }
        return;
    }
    default:
        break;
    }
 
    int last_state = m_last_state;
 
    if (m_last_state != MEDIASTATE_IDLE) {
        m_media_ctrl->InvalidateBestSize();
        m_button_play->SetIcon("media_play");
        boost::unique_lock lock(m_mutex);
        if (!webrtc_active)
            m_tasks.push_back({"<stop>", m_active_media_controller});
        m_cond.notify_all();
        if (!msg.IsEmpty())
            SetStatus(msg);
        else if (m_failed_code) {
            auto iter = error_messages.find(m_failed_code);
            auto msg2 = iter == error_messages.end()
                ? _L("Please check the network and try again. You can restart or update the printer if the issue persists.")
                : _L(iter->second.c_str());
            if (m_failed_code == 1) {
                if (m_last_state == wxMEDIASTATE_PLAYING)
                    msg2 = _L("The printer has been logged out and cannot connect.");
            }
#if !BBL_RELEASE_TO_PUBLIC && defined(__WINDOWS__)
            if (m_failed_code < 0)
                boost::thread ping_thread = Slic3r::create_thread([] {
                    start_ping_test();
                });
#endif
            SetStatus(msg2);
        } else
            SetStatus(_L("Video Stopped."), false);
        m_last_state = MEDIASTATE_IDLE;
        bool auto_retry = wxGetApp().app_config->get("liveview", "auto_retry") != "false";
        if (!auto_retry || m_failed_code >= 100 || m_failed_code == 1) // not keep retry on local error or EOS
            m_next_retry = wxDateTime();
    } else if (!msg.IsEmpty()) {
        SetStatus(msg, false);
        return;
    } else {
        m_failed_code = 0;
        return;
    }
 
    auto tunnel = m_url.empty() ? "" : into_u8(wxURI(m_url).GetPath()).substr(1);
    if (auto n = tunnel.find_first_of("/_"); n != std::string::npos)
        tunnel = tunnel.substr(0, n);
    if (last_state != wxMEDIASTATE_PLAYING && m_failed_code != 0
            && m_last_failed_codes.find(m_failed_code) == m_last_failed_codes.end()
            && (m_user_triggered || m_failed_retry > 3)) {
        m_last_failed_codes.insert(m_failed_code);
    }
 
    m_url.clear();
    ++m_failed_retry;
    bool local = tunnel == "local" || tunnel == "rtsp" ||
                 tunnel == "rtsps";
    if (m_failed_code < 0 && last_state != wxMEDIASTATE_PLAYING && local && (m_failed_retry > 1 || m_user_triggered)) {
        m_next_retry = wxDateTime(); // stop retry
        if (wxGetApp().show_modal_ip_address_enter_dialog(false, _L("LAN Connection Failed (Failed to start liveview)"))) {
            m_failed_retry = 0;
            m_user_triggered = true;
            if (m_last_user_play + wxTimeSpan::Minutes(5) < wxDateTime::Now()) {
                m_last_failed_codes.clear();
                m_last_user_play = wxDateTime::Now();
            }
            m_next_retry   = wxDateTime::Now();
            return;
        }
    }
    m_user_triggered = false;
    if (m_next_retry.IsValid())
        m_next_retry = wxDateTime::Now() + wxTimeSpan::Seconds(5 * m_failed_retry);
}

References _L, Slic3r::create_thread(), Slic3r::GUI::error_messages, Slic3r::http, Slic3r::http_snapshot, Slic3r::https, Slic3r::GUI::into_u8(), m_active_media_controller, m_button_play, m_cond, m_failed_code, m_failed_retry, m_last_failed_codes, m_last_mode, m_last_state, m_last_user_play, m_media_ctrl, m_mutex, m_next_retry, m_tasks, m_url, m_user_triggered, MEDIASTATE_IDLE, SetStatus(), Slic3r::GUI::start_ping_test(), and Slic3r::webrtc.

Referenced by MediaPlayCtrl(), on_show_hide(), on_webrtc_status(), onStateChanged(), Play(), SetMachineObject(), and TogglePlay().

Here is the call graph for this function:

Here is the caller graph for this function:

StopWebStream()

void Slic3r::GUI::MediaPlayCtrl::StopWebStream

(

)

{
    if (m_last_state == MEDIASTATE_IDLE)
        return;
    if (m_active_media_controller && m_active_media_controller == m_web_ctrl)
        m_active_media_controller->Stop();
    m_button_play->SetIcon("media_play");
    m_last_state = MEDIASTATE_IDLE;
    SetStatus(_L("Video Stopped."), false);
}

References _L, m_active_media_controller, m_button_play, m_last_state, m_web_ctrl, MEDIASTATE_IDLE, and SetStatus().

Here is the call graph for this function:

TogglePlay()

void Slic3r::GUI::MediaPlayCtrl::TogglePlay ( )

protected

{
    BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::TogglePlay";
    if (m_last_state != MEDIASTATE_IDLE) {
        m_next_retry = wxDateTime();
        m_web_user_stopped = true;
        Stop();
    } else {
        m_failed_retry = 0;
        m_user_triggered = true;
        m_web_user_stopped = false;
        if (m_last_user_play + wxTimeSpan::Minutes(5) < wxDateTime::Now()) {
            m_last_failed_codes.clear();
            m_last_user_play = wxDateTime::Now();
        }
        m_next_retry = wxDateTime::Now();
        Play();
    }
}

References m_failed_retry, m_last_failed_codes, m_last_state, m_last_user_play, m_next_retry, m_user_triggered, m_web_user_stopped, MEDIASTATE_IDLE, Play(), and Stop().

Referenced by MediaPlayCtrl(), and jump_to_play().

Here is the call graph for this function:

Here is the caller graph for this function:

ToggleStream()

void Slic3r::GUI::MediaPlayCtrl::ToggleStream

(

)

{
    std::string file_url = data_dir() + "/cameratools/url.txt";
    if (m_streaming) {
        boost::nowide::ofstream file(file_url);
        file.close();
        m_streaming = false;
        return;
    } else if (!boost::filesystem::exists(file_url)) {
        boost::nowide::ofstream file(file_url);
        file.close();
    }
    std::string url;
    if (!get_stream_url(&url)) {
        // create stream pipeline
        bool need_install = false;
        if (!start_stream_service(&need_install)) {
            if (!need_install) return;
            auto res = MessageDialog(this->GetParent(), _L("Virtual Camera Tools is required for this task!\nDo you want to install them?"), _L("Info"),
                                    wxOK | wxCANCEL).ShowModal();
            if (res == wxID_OK) {
                // download tools
                struct DownloadProgressDialog2 : DownloadProgressDialog
                {
                    MediaPlayCtrl *ctrl;
                    DownloadProgressDialog2(MediaPlayCtrl *ctrl) : DownloadProgressDialog(_L("Downloading Virtual Camera Tools")), ctrl(ctrl) {}
                    struct UpgradeNetworkJob2 : UpgradeNetworkJob
                    {
                        UpgradeNetworkJob2() {
                            name         = "cameratools";
                            package_name = "camera_tools.zip";
                        }
                    };
                    std::unique_ptr<UpgradeNetworkJob> make_job() override
                    { return std::make_unique<UpgradeNetworkJob2>(); }
                    void                               on_finish() override
                    {
                        ctrl->CallAfter([ctrl = this->ctrl] { ctrl->ToggleStream(); });
                        EndModal(wxID_CLOSE);
                    }
                };
                DownloadProgressDialog2 dlg(this);
                dlg.ShowModal();
            }
            return;
        }
    }
    if (!url.empty() && wxGetApp().app_config->get("not_show_vcamera_stop_prev") != "1") {
        MessageDialog dlg(this->GetParent(), _L("Another virtual camera is running.\nOrca Slicer supports only a single virtual camera.\nDo you want to stop this virtual camera?"), _L("Warning"),
                                 wxYES | wxCANCEL | wxICON_INFORMATION);
        dlg.show_dsa_button();
        auto          res = dlg.ShowModal();
        if (dlg.get_checkbox_state())
            wxGetApp().app_config->set("not_show_vcamera_stop_prev", "1");
        if (res == wxID_CANCEL) return;
    }
    if (m_lan_proto > LiveviewLocal::LVL_Disable && (m_lan_mode || !m_remote_proto) && !m_disable_lan && !m_lan_ip.empty()) {
        std::string url;
        if (m_lan_proto == LiveviewLocal::LVL_Local)
            url = "bambu:///local/" + m_lan_ip + ".?port=6000&user=" + m_lan_user + "&passwd=" + m_lan_passwd;
        else if (m_lan_proto == LiveviewLocal::LVL_Rtsps)
            url = "bambu:///rtsps___" + m_lan_user + ":" + m_lan_passwd + "@" + m_lan_ip + "/streaming/live/1?proto=rtsps";
        else if (m_lan_proto == LiveviewLocal::LVL_Rtsp)
            url = "bambu:///rtsp___" + m_lan_user + ":" + m_lan_passwd + "@" + m_lan_ip + "/streaming/live/1?proto=rtsp";
        url += "&device=" + into_u8(m_machine);
        url += "&dev_ver=" + m_dev_ver;
        BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::ToggleStream: " << hide_passwd(hide_id_middle_string(url, url.find(m_lan_ip), m_lan_ip.length()), {m_lan_passwd});
        std::string             file_url = data_dir() + "/cameratools/url.txt";
        boost::nowide::ofstream file(file_url);
        auto                    url2 = encode_path(url.c_str());
        file.write(url2.c_str(), url2.size());
        file.close();
        m_streaming = true;
        return;
    }
    NetworkAgent *agent = wxGetApp().getAgent();
    if (!agent) return;
    std::string protocols[] = {"", "\"tutk\"", "\"agora\"", "\"tutk\",\"agora\""};
    agent->get_camera_url(m_machine + "|" + m_dev_ver + "|" + protocols[m_remote_proto],
            [this, m = m_machine, v = agent->get_version(), dv = m_dev_ver](std::string url) {
        if (boost::algorithm::starts_with(url, "bambu:///")) {
            url += "&device=" + m;
            url += "&net_ver=" + v;
            url += "&dev_ver=" + dv;
            url += "&refresh_url=" + boost::lexical_cast<std::string>(&refresh_agora_url);
            url += "&cli_id=" + wxGetApp().app_config->get("slicer_uuid");
            url += "&cli_ver=" + std::string(SLIC3R_VERSION);
        }
        BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::ToggleStream: " << hide_passwd(url,
                {"?uid=", "authkey=", "passwd=", "license=", "token="});
        CallAfter([this, m, url] {
            if (m != m_machine) return;
            if (url.empty() || !boost::algorithm::starts_with(url, "bambu:///")) {
                MessageDialog(this->GetParent(), wxString::Format(_L("Virtual camera initialize failed (%s)!"), url.empty() ? _L("Network unreachable") : from_u8(url)), _L("Information"),
                              wxICON_INFORMATION)
                    .ShowModal();
                return;
            }
            std::string             file_url = data_dir() + "/cameratools/url.txt";
            boost::nowide::ofstream file(file_url);
            auto                    url2 = encode_path(url.c_str());
            file.write(url2.c_str(), url2.size());
            file.close();
            m_streaming = true;
        });
    }, wxGetApp().get_printer_cloud_provider());
}

References MediaPlayCtrl(), _L, Slic3r::data_dir(), Slic3r::encode_path(), Slic3r::GUI::from_u8(), Slic3r::NetworkAgent::get_camera_url(), Slic3r::GUI::MsgDialog::get_checkbox_state(), get_stream_url(), Slic3r::NetworkAgent::get_version(), Slic3r::GUI::hide_id_middle_string(), Slic3r::GUI::hide_passwd(), Slic3r::GUI::into_u8(), Slic3r::LVL_Disable, Slic3r::LVL_Local, Slic3r::LVL_Rtsp, Slic3r::LVL_Rtsps, m_dev_ver, m_disable_lan, m_lan_ip, m_lan_mode, m_lan_passwd, m_lan_proto, m_lan_user, m_machine, m_remote_proto, m_streaming, Slic3r::GUI::MsgDialog::show_dsa_button(), Slic3r::GUI::DPIAware< P >::ShowModal(), start_stream_service(), and ToggleStream().

Referenced by ToggleStream().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_active_media_controller

IMediaController* Slic3r::GUI::MediaPlayCtrl::m_active_media_controller = nullptr

private

Referenced by MediaPlayCtrl(), load(), onStateChanged(), Play(), set_active_media_controller(), Stop(), and StopWebStream().

m_agent_camera_url

std::string Slic3r::GUI::MediaPlayCtrl::m_agent_camera_url

private

Referenced by SetMachineObject().

m_button_play

::Button* Slic3r::GUI::MediaPlayCtrl::m_button_play

private

Referenced by MediaPlayCtrl(), msw_rescale(), Play(), Stop(), and StopWebStream().

m_camera_exists

bool Slic3r::GUI::MediaPlayCtrl::m_camera_exists = false

private

Referenced by Play(), and SetMachineObject().

m_cond

boost::condition_variable Slic3r::GUI::MediaPlayCtrl::m_cond

private

Referenced by ~MediaPlayCtrl(), load(), media_proc(), onStateChanged(), and Stop().

m_dev_ver

std::string Slic3r::GUI::MediaPlayCtrl::m_dev_ver

private

Referenced by Play(), SetMachineObject(), and ToggleStream().

m_device_busy

bool Slic3r::GUI::MediaPlayCtrl::m_device_busy = false

private

Referenced by Play(), and SetMachineObject().

m_disable_lan

bool Slic3r::GUI::MediaPlayCtrl::m_disable_lan = false

private

Referenced by onStateChanged(), Play(), SetMachineObject(), and ToggleStream().

m_failed_code

int Slic3r::GUI::MediaPlayCtrl::m_failed_code = 0

private

Referenced by on_webrtc_status(), onStateChanged(), Play(), SetMachineObject(), SetStatus(), and Stop().

m_failed_retry

int Slic3r::GUI::MediaPlayCtrl::m_failed_retry = 0

private

Referenced by on_show_hide(), on_webrtc_status(), onStateChanged(), Play(), SetMachineObject(), Stop(), and TogglePlay().

m_label_stat

::Label* Slic3r::GUI::MediaPlayCtrl::m_label_stat

private

Referenced by MediaPlayCtrl(), Play(), and SetStatus().

m_label_status

::Label* Slic3r::GUI::MediaPlayCtrl::m_label_status

private

Referenced by MediaPlayCtrl(), and SetStatus().

m_lan_ip

std::string Slic3r::GUI::MediaPlayCtrl::m_lan_ip

private

Referenced by Play(), SetMachineObject(), and ToggleStream().

m_lan_mode

bool Slic3r::GUI::MediaPlayCtrl::m_lan_mode = false

private

Referenced by Play(), SetMachineObject(), and ToggleStream().

m_lan_passwd

std::string Slic3r::GUI::MediaPlayCtrl::m_lan_passwd

private

Referenced by MediaPlayCtrl(), Play(), SetMachineObject(), and ToggleStream().

m_lan_proto

int Slic3r::GUI::MediaPlayCtrl::m_lan_proto = 0

private

Referenced by Play(), SetMachineObject(), and ToggleStream().

m_lan_user

std::string Slic3r::GUI::MediaPlayCtrl::m_lan_user

private

Referenced by MediaPlayCtrl(), Play(), and ToggleStream().

m_last_failed_codes

std::set<int> Slic3r::GUI::MediaPlayCtrl::m_last_failed_codes

private

Referenced by SetMachineObject(), Stop(), and TogglePlay().

m_last_mode

CameraStreamMode Slic3r::GUI::MediaPlayCtrl::m_last_mode = CameraStreamMode::none

private

Referenced by Play(), SetMachineObject(), and Stop().

m_last_state

wxMediaState Slic3r::GUI::MediaPlayCtrl::m_last_state = MEDIASTATE_IDLE

private

Referenced by jump_to_play(), load(), on_webrtc_status(), onStateChanged(), Play(), SetMachineObject(), SetStatus(), Stop(), StopWebStream(), and TogglePlay().

m_last_user_play

wxDateTime Slic3r::GUI::MediaPlayCtrl::m_last_user_play

private

Referenced by SetMachineObject(), Stop(), and TogglePlay().

m_machine

std::string Slic3r::GUI::MediaPlayCtrl::m_machine

private

Referenced by Play(), SetMachineObject(), and ToggleStream().

m_media_ctrl

wxMediaCtrl3* Slic3r::GUI::MediaPlayCtrl::m_media_ctrl

private

Referenced by MediaPlayCtrl(), ~MediaPlayCtrl(), media_proc(), onStateChanged(), Play(), set_active_media_controller(), and Stop().

m_mutex

boost::mutex Slic3r::GUI::MediaPlayCtrl::m_mutex

private

Referenced by ~MediaPlayCtrl(), load(), media_proc(), onStateChanged(), and Stop().

m_next_retry

wxDateTime Slic3r::GUI::MediaPlayCtrl::m_next_retry

private

Referenced by Play(), SetMachineObject(), Stop(), and TogglePlay().

m_remote_proto

int Slic3r::GUI::MediaPlayCtrl::m_remote_proto = 0

private

Referenced by Play(), SetMachineObject(), and ToggleStream().

m_stat

std::vector<double> Slic3r::GUI::MediaPlayCtrl::m_stat

private

Referenced by MediaPlayCtrl().

m_streaming

bool Slic3r::GUI::MediaPlayCtrl::m_streaming = false

private

Referenced by IsStreaming(), SetMachineObject(), and ToggleStream().

m_tasks

std::deque<MediaTask> Slic3r::GUI::MediaPlayCtrl::m_tasks

private

Referenced by ~MediaPlayCtrl(), load(), media_proc(), onStateChanged(), and Stop().

m_thread

boost::thread Slic3r::GUI::MediaPlayCtrl::m_thread

private

Referenced by MediaPlayCtrl(), and ~MediaPlayCtrl().

m_token

std::shared_ptr<int> Slic3r::GUI::MediaPlayCtrl::m_token = std::make_shared<int>(0)

private

Referenced by Play(), and set_active_media_controller().

m_tutk_state

std::string Slic3r::GUI::MediaPlayCtrl::m_tutk_state

private

Referenced by SetMachineObject(), and SetStatus().

m_url

wxString Slic3r::GUI::MediaPlayCtrl::m_url

private

Referenced by MediaPlayCtrl(), load(), Play(), SetMachineObject(), and Stop().

m_user_triggered

bool Slic3r::GUI::MediaPlayCtrl::m_user_triggered = false

private

Referenced by Stop(), and TogglePlay().

m_web_ctrl

IMediaController* Slic3r::GUI::MediaPlayCtrl::m_web_ctrl = nullptr

private

Referenced by set_active_media_controller(), SetWebMediaController(), and StopWebStream().

m_web_user_stopped

bool Slic3r::GUI::MediaPlayCtrl::m_web_user_stopped = false

private

Referenced by SetMachineObject(), and TogglePlay().

m_webrtc_ctrl

std::unique_ptr<WebRtcMediaController> Slic3r::GUI::MediaPlayCtrl::m_webrtc_ctrl

private

Referenced by ~MediaPlayCtrl(), and set_active_media_controller().

m_webrtc_epoch

std::uint64_t Slic3r::GUI::MediaPlayCtrl::m_webrtc_epoch = 0

private

Referenced by on_webrtc_status(), and Play().

MEDIASTATE_BUFFERING

const wxMediaState Slic3r::GUI::MediaPlayCtrl::MEDIASTATE_BUFFERING = static_cast<wxMediaState>(6)

inlinestaticprivate

Referenced by SetStatus().

MEDIASTATE_IDLE

const wxMediaState Slic3r::GUI::MediaPlayCtrl::MEDIASTATE_IDLE = static_cast<wxMediaState>(3)

inlinestaticprivate

Referenced by jump_to_play(), onStateChanged(), Play(), SetMachineObject(), SetStatus(), Stop(), StopWebStream(), and TogglePlay().

MEDIASTATE_INITIALIZING

const wxMediaState Slic3r::GUI::MediaPlayCtrl::MEDIASTATE_INITIALIZING = static_cast<wxMediaState>(4)

inlinestaticprivate

Referenced by on_webrtc_status(), onStateChanged(), and Play().

MEDIASTATE_LOADING

const wxMediaState Slic3r::GUI::MediaPlayCtrl::MEDIASTATE_LOADING = static_cast<wxMediaState>(5)

inlinestaticprivate

Referenced by load(), and onStateChanged().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/MediaPlayCtrl.h
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/MediaPlayCtrl.cpp