wxMediaCtrl3 Class Reference

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

Inheritance diagram for wxMediaCtrl3:

Collaboration diagram for wxMediaCtrl3:

Public Member Functions
	wxMediaCtrl3 (wxWindow *parent)
	~wxMediaCtrl3 () override
void	Load (wxURI url) override
void	Play () override
void	Stop () override
void	SetExternalFrame (const wxImage &frame, wxSize videoSize)
void	BeginExternalStream ()
void	EndExternalStream ()
void	SetIdleImage (wxString const &image)
wxMediaState	GetState () override
int	GetLastError () const override
wxSize	GetVideoSize () const override

Protected Member Functions
void	paintEvent (wxPaintEvent &evt)
wxSize	DoGetBestSize () const override
void	DoSetSize (int x, int y, int width, int height, int sizeFlags) override
void	PlayThread ()
int	PlayFfmpeg (std::shared_ptr< wxURI > const &url, std::unique_lock< std::mutex > &lock)
void	NotifyStopped ()

Static Protected Member Functions
static void	bambu_log (void *ctx, int level, tchar const *msg)
static int	ffmpeg_interrupt_callback (void *opaque)

Private Attributes
wxString	m_idle_image
wxMediaState	m_state = wxMEDIASTATE_STOPPED
int	m_error = 0
wxSize	m_video_size = wxDefaultSize
wxSize	m_frame_size = wxDefaultSize
wxImage	m_frame
std::shared_ptr< wxURI >	m_url
std::shared_ptr< wxURI >	m_active_url
bool	m_external = false
std::uint64_t	m_last_PTS {0}
std::chrono::system_clock::time_point	m_last_PTS_expected
std::chrono::system_clock::time_point	m_last_PTS_practical
std::mutex	m_mutex
std::condition_variable	m_cond
std::thread	m_thread
std::atomic_bool	m_refresh_pending {false}

Detailed Description

Constructor & Destructor Documentation

wxMediaCtrl3()

wxMediaCtrl3::wxMediaCtrl3

(

wxWindow *

parent

)

    : wxWindow(parent, wxID_ANY)
    , BambuLib(StaticBambuLib::get(this))
    , m_thread([this] { PlayThread(); })
{
    SetBackgroundColour("#000001ff");
}

References m_thread, and PlayThread().

Referenced by bambu_log(), and ffmpeg_interrupt_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

~wxMediaCtrl3()

wxMediaCtrl3::~wxMediaCtrl3 ( )

override

{
    {
        std::unique_lock<std::mutex> lk(m_mutex);
        m_url.reset(new wxURI);
        m_frame = wxImage(m_idle_image);
        m_cond.notify_all();
    }
    m_thread.join();
}

References m_cond, m_frame, m_idle_image, m_mutex, m_thread, and m_url.

Member Function Documentation

bambu_log()

void wxMediaCtrl3::bambu_log ( void * ctx, int level, tchar const * msg )

staticprotected

{
#ifdef _WIN32
    wxString msg(msg2);
#else
    wxString msg = wxString::FromUTF8(msg2);
#endif
    if (level == 1) {
        if (msg.EndsWith("]")) {
            int n = msg.find_last_of('[');
            if (n != wxString::npos) {
                long val = 0;
                wxMediaCtrl3 *ctrl = (wxMediaCtrl3 *) ctx;
                if (msg.SubString(n + 1, msg.Length() - 2).ToLong(&val)) {
                    std::unique_lock<std::mutex> lk(ctrl->m_mutex);
                    ctrl->m_error = (int) val;
                }
            }
        } else if (msg.Contains("stat_log")) {
            wxCommandEvent evt(EVT_MEDIA_CTRL_STAT);
            wxMediaCtrl3 *ctrl = (wxMediaCtrl3 *) ctx;
            evt.SetEventObject(ctrl);
            evt.SetString(msg.Mid(msg.Find(' ') + 1));
            wxPostEvent(ctrl, evt);
        }
    }
    BOOST_LOG_TRIVIAL(info) << msg.ToUTF8().data();
}

References wxMediaCtrl3(), m_error, and m_mutex.

Referenced by PlayThread().

Here is the call graph for this function:

Here is the caller graph for this function:

BeginExternalStream()

void wxMediaCtrl3::BeginExternalStream

(

)

{
    std::unique_lock<std::mutex> lk(m_mutex);
    m_external = true;
    m_url.reset();
    m_active_url.reset();
    m_video_size = wxDefaultSize;
    m_frame = wxImage(m_idle_image);
    m_cond.notify_all();
    Refresh();
}

References m_active_url, m_cond, m_external, m_frame, m_idle_image, m_mutex, m_url, and m_video_size.

DoGetBestSize()

wxSize wxMediaCtrl3::DoGetBestSize ( ) const

overrideprotected

{
    return {-1, -1};
}

DoSetSize()

void wxMediaCtrl3::DoSetSize ( int x, int y, int width, int height, int sizeFlags )

overrideprotected

{
    wxWindow::DoSetSize(x, y, width, height, sizeFlags);
    if (sizeFlags == wxSIZE_USE_EXISTING) return;
    wxMediaCtrl_OnSize(this, m_video_size, width, height);
    std::unique_lock<std::mutex> lk(m_mutex);
    adjust_frame_size(m_frame_size, m_video_size, GetSize());
    Refresh();
}

References adjust_frame_size(), m_frame_size, m_mutex, m_video_size, and wxMediaCtrl_OnSize().

Here is the call graph for this function:

EndExternalStream()

void wxMediaCtrl3::EndExternalStream

(

)

{
    std::unique_lock<std::mutex> lk(m_mutex);
    m_external = false;
    m_url.reset();
    m_active_url.reset();
    m_video_size = wxDefaultSize;
    m_frame = wxImage(m_idle_image);
    m_cond.notify_all();
    Refresh();
}

References m_active_url, m_cond, m_external, m_frame, m_idle_image, m_mutex, m_url, and m_video_size.

ffmpeg_interrupt_callback()

int wxMediaCtrl3::ffmpeg_interrupt_callback ( void * opaque )

staticprotected

{
    auto *ctrl = static_cast<wxMediaCtrl3 *>(opaque);
    std::lock_guard<std::mutex> lock(ctrl->m_mutex);
    return ctrl->m_url != ctrl->m_active_url;
}

References wxMediaCtrl3().

Referenced by PlayFfmpeg().

Here is the call graph for this function:

Here is the caller graph for this function:

GetLastError()

int wxMediaCtrl3::GetLastError ( ) const

overridevirtual

Reimplemented from Slic3r::GUI::IMediaController.

{
    std::unique_lock<std::mutex> lk(m_mutex);
    return m_error;
}

References m_error, and m_mutex.

GetState()

wxMediaState wxMediaCtrl3::GetState ( )

overridevirtual

Reimplemented from Slic3r::GUI::IMediaController.

{
    std::unique_lock<std::mutex> lk(m_mutex);
    return m_state;
}

References m_mutex, and m_state.

GetVideoSize()

wxSize wxMediaCtrl3::GetVideoSize ( ) const

overridevirtual

Reimplemented from Slic3r::GUI::IMediaController.

{
    std::unique_lock<std::mutex> lk(m_mutex);
    return m_video_size;
}

References m_mutex, and m_video_size.

Load()

void wxMediaCtrl3::Load ( wxURI url )

overridevirtual

Implements Slic3r::GUI::IMediaController.

{
    std::unique_lock<std::mutex> lk(m_mutex);
    if (m_external)
        return;
    m_video_size = wxDefaultSize;
    m_error = 0;
    m_url.reset(new wxURI(url));
    m_cond.notify_all();
}

References m_cond, m_error, m_external, m_mutex, m_url, and m_video_size.

NotifyStopped()

void wxMediaCtrl3::NotifyStopped ( )

protected

{
    m_state = wxMEDIASTATE_STOPPED;
    wxMediaEvent event(wxEVT_MEDIA_STATECHANGED);
    event.SetId(GetId());
    event.SetEventObject(this);
    wxPostEvent(this, event);
}

References m_state.

Referenced by PlayFfmpeg(), PlayThread(), and Stop().

Here is the caller graph for this function:

paintEvent()

void wxMediaCtrl3::paintEvent ( wxPaintEvent & evt )

protected

{
    wxPaintDC dc(this);
    auto      size = GetSize();
    if (size.x <= 0 || size.y <= 0)
        return;
    std::unique_lock<std::mutex> lk(m_mutex);
    if (!m_frame.IsOk())
        return;
    auto size2 = m_frame.GetSize();
    if (size2.x != m_frame_size.x && size2.y == m_frame_size.y)
        size2.x = m_frame_size.x;
    auto size3 = (size - size2) / 2;
    if (size2.x != size.x && size2.y != size.y) {
        double scale = 1.;
        if (size.x * size2.y > size.y * size2.x) {
            size3 = {size.x * size2.y / size.y, size2.y};
            scale = double(size.y) / size2.y;
        } else {
            size3 = {size2.x, size.y * size2.x / size.x};
            scale = double(size.x) / size2.x;
        }
        dc.SetUserScale(scale, scale);
        size3 = (size3 - size2) / 2;
    }
    dc.DrawBitmap(m_frame, size3.x, size3.y);
}

References m_frame, m_frame_size, m_mutex, and scale().

Referenced by wxDEFINE_EVENT().

Here is the call graph for this function:

Here is the caller graph for this function:

Play()

void wxMediaCtrl3::Play ( )

overridevirtual

Implements Slic3r::GUI::IMediaController.

{
    std::unique_lock<std::mutex> lk(m_mutex);
    if (m_external)
        return;
    if (m_state != wxMEDIASTATE_PLAYING) {
        m_state = wxMEDIASTATE_PLAYING;
        wxMediaEvent event(wxEVT_MEDIA_STATECHANGED);
        event.SetId(GetId());
        event.SetEventObject(this);
        wxPostEvent(this, event);
    }
}

References m_external, m_mutex, and m_state.

PlayFfmpeg()

int wxMediaCtrl3::PlayFfmpeg ( std::shared_ptr< wxURI > const & url, std::unique_lock< std::mutex > & lock )

protected

{
    static std::once_flag logger_once;
    std::call_once(logger_once, install_ffmpeg_logger);
 
    if (avformat_network_init() < 0)
        return 2;
 
    AVFormatContext *format_context = avformat_alloc_context();
    if (!format_context) {
        avformat_network_deinit();
        return 2;
    }
 
    format_context->interrupt_callback = {&wxMediaCtrl3::ffmpeg_interrupt_callback, this};
    format_context->flags |= AVFMT_FLAG_NOBUFFER;
    format_context->max_delay = 0;
    m_active_url = url;
 
    auto finish = [&](int error) {
        lock.unlock();
        avformat_close_input(&format_context);
        avformat_network_deinit();
        lock.lock();
        m_active_url.reset();
        return error;
    };
 
    const std::string uri = url->BuildURI().ToUTF8().data();
    const wxString scheme = url->GetScheme();
    const bool http_stream = scheme.CmpNoCase("http") == 0 || scheme.CmpNoCase("https") == 0;
    AVDictionary *options = nullptr;
    if (http_stream) {
        // Live multipart MJPEG. fflags=nobuffer / AVFMT_FLAG_NOBUFFER / max_delay=0
        // (set above) are the low-latency levers - they disable the demuxer
        // read-ahead queue. probesize / analyzeduration only bound the one-off
        // avformat_find_stream_info() at open; a 32-byte budget returned before a
        // whole JPEG frame was seen, so width/height came back unset and the open
        // was rejected. Give it room to identify one frame (a startup cost only).
        // rw_timeout / timeout bound a wedged connect or read so a stale stream
        // fails fast and is retried, instead of the reader thread hanging.
        // avioflags=direct is deliberately NOT set: unbuffered reads make the
        // mpjpeg demuxer emit "Packet corrupt" and bail on any short read across
        // a multipart boundary.
        av_dict_set(&options, "fflags", "nobuffer", 0);
        av_dict_set(&options, "probesize", "5000000", 0);
        av_dict_set(&options, "analyzeduration", "1000000", 0);
        av_dict_set(&options, "rw_timeout", "5000000", 0);
        av_dict_set(&options, "timeout", "5000000", 0);
    } else {
        av_dict_set(&options, "rtsp_transport", "tcp", 0);
    }
    lock.unlock();
    int error = avformat_open_input(&format_context, uri.c_str(), nullptr, &options);
    av_dict_free(&options);
    lock.lock();
    if (error < 0)
        return finish(2);
 
    lock.unlock();
    error = avformat_find_stream_info(format_context, nullptr);
    lock.lock();
    if (error < 0)
        return finish(2);
 
    const int video_stream = av_find_best_stream(format_context, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
    if (video_stream < 0)
        return finish(2);
 
    AVVideoDecoder decoder;
    if (decoder.open(*format_context->streams[video_stream]->codecpar) < 0)
        return finish(2);
 
    // Prefer the dimensions the container reported. A small probe budget, or a
    // camera that doesn't announce a size up front, can leave these unset - in
    // that case fill them in from the first frame that decodes (below) rather
    // than failing the open outright.
    auto apply_video_size = [&](wxSize size) {
        if (!size.IsFullySpecified() || size.x <= 0 || size.y <= 0)
            return false;
        m_video_size = size;
        adjust_frame_size(m_frame_size, m_video_size, GetSize());
        NotifyStopped();
        return true;
    };
    bool have_size = apply_video_size({format_context->streams[video_stream]->codecpar->width,
                                      format_context->streams[video_stream]->codecpar->height});
    int size_probe_frames = 0; // frames spent still waiting for a usable size
 
    AVPacket *packet = av_packet_alloc();
    if (!packet)
        return finish(2);
 
    while (m_url == url) {
        lock.unlock();
        error = av_read_frame(format_context, packet);
        lock.lock();
        if (m_url != url)
            break;
        if (error < 0)
            break;
        if (packet->stream_index == video_stream) {
            const int decode_error = decoder.decode(*packet);
            if (decode_error == 0) {
                if (!have_size) {
                    have_size = apply_video_size(decoder.decoded_frame_size());
                    if (!have_size) {
                        av_packet_unref(packet);
                        // MJPEG yields a sized frame on the first full packet; if
                        // several seconds of frames never do, treat it as a bad
                        // stream instead of sitting in "Loading..." forever.
                        if (++size_probe_frames > 120)
                            break;
                        continue;
                    }
                }
                auto frame_size = m_frame_size;
                lock.unlock();
#ifdef _WIN32
                wxBitmap frame;
                decoder.toWxBitmap(frame, frame_size);
#else
                wxImage frame;
                decoder.toWxImage(frame, frame_size);
#endif
                lock.lock();
                if (m_url != url)
                    break;
                if (frame.IsOk())
                    m_frame = frame;
                if (!m_refresh_pending.exchange(true)) {
                    CallAfter([this] {
                        m_refresh_pending.store(false);
                        Refresh();
                    });
                }
            }
        }
        av_packet_unref(packet);
    }
 
    av_packet_free(&packet);
    return finish(m_url == url ? 2 : 1);
}

References adjust_frame_size(), AVVideoDecoder::decode(), AVVideoDecoder::decoded_frame_size(), ffmpeg_interrupt_callback(), install_ffmpeg_logger(), m_active_url, m_frame, m_frame_size, m_refresh_pending, m_url, m_video_size, NotifyStopped(), AVVideoDecoder::open(), AVVideoDecoder::toWxBitmap(), and AVVideoDecoder::toWxImage().

Referenced by PlayThread().

Here is the call graph for this function:

Here is the caller graph for this function:

PlayThread()

void wxMediaCtrl3::PlayThread ( )

protected

{
    using namespace std::chrono_literals;
    std::shared_ptr<wxURI> url;
    std::unique_lock<std::mutex> lk(m_mutex);
    while (true) {
        m_cond.wait(lk, [this, &url] { return m_url != url; });
        url = m_url;
        if (url == nullptr)
            continue;
        if (!url->HasScheme())
            break;
        const wxString scheme = url->GetScheme();
        const bool generic_ffmpeg = scheme.CmpNoCase("http") == 0 || scheme.CmpNoCase("https") == 0 ||
                                    scheme.CmpNoCase("rtsp") == 0 || scheme.CmpNoCase("rtsps") == 0;
        int error = 0;
        if (generic_ffmpeg) {
            error = PlayFfmpeg(url, lk);
        } else {
            lk.unlock();
            Bambu_Tunnel tunnel = nullptr;
            error = Bambu_Create(&tunnel, m_url->BuildURI().ToUTF8());
            if (error == 0) {
                Bambu_SetLogger(tunnel, &wxMediaCtrl3::bambu_log, this);
                error = Bambu_Open(tunnel);
                if (error == 0)
                    error = Bambu_would_block;
            }
            lk.lock();
            while (error == int(Bambu_would_block)) {
                m_cond.wait_for(lk, 100ms);
                if (m_url != url) {
                    error = 1;
                    break;
                }
                lk.unlock();
                error = Bambu_StartStream(tunnel, true);
                lk.lock();
            }
            Bambu_StreamInfo info;
            if (error == 0)
                error = Bambu_GetStreamInfo(tunnel, 0, &info);
            AVVideoDecoder decoder;
            int minFrameDuration = 0;
            if (error == 0) {
                decoder.open(info);
                m_video_size = { info.format.video.width, info.format.video.height };
                adjust_frame_size(m_frame_size, m_video_size, GetSize());
                minFrameDuration = 800 / info.format.video.frame_rate; // 80%
                NotifyStopped();
            }
            Bambu_Sample sample;
            while (error == 0) {
                lk.unlock();
                error = Bambu_ReadSample(tunnel, &sample);
                lk.lock();
                while (error == int(Bambu_would_block)) {
                    m_cond.wait_for(lk, 100ms);
                    if (m_url != url) {
                        error = 1;
                        break;
                    }
                    lk.unlock();
                    error = Bambu_ReadSample(tunnel, &sample);
                    lk.lock();
                }
                if (error == 0) {
                    auto frame_size = m_frame_size;
                    lk.unlock();
                    decoder.decode(sample);
#ifdef _WIN32
                    wxBitmap bm;
                    decoder.toWxBitmap(bm, frame_size);
#else
                    wxImage bm;
                    decoder.toWxImage(bm, frame_size);
#endif
                    lk.lock();
                    if (m_url != url) {
                        error = 1;
                        break;
                    }
                    if (bm.IsOk()) {
                        auto now = std::chrono::system_clock::now();
                        if (m_last_PTS && (sample.decode_time - m_last_PTS) < 30000000ULL) { // 3s
                            auto next_PTS_expected = m_last_PTS_expected + std::chrono::milliseconds((sample.decode_time - m_last_PTS) / 10000ULL);
                            // The frame is late, catch up a little
                            auto next_PTS_practical = m_last_PTS_practical + std::chrono::milliseconds(minFrameDuration);
                            auto next_PTS = std::max(next_PTS_expected, next_PTS_practical);
                            if(now < next_PTS)
                                std::this_thread::sleep_until(next_PTS);
                            else
                                next_PTS = now;
                            //auto text = wxString::Format(L"wxMediaCtrl3 pts diff %ld\n", std::chrono::duration_cast<std::chrono::milliseconds>(next_PTS - next_PTS_expected).count());
                            //OutputDebugString(text);
                            m_last_PTS = sample.decode_time;
                            m_last_PTS_expected = next_PTS_expected;
                            m_last_PTS_practical = next_PTS;
                        } else {
                            // Resync
                            m_last_PTS           = sample.decode_time;
                            m_last_PTS_expected  = now;
                            m_last_PTS_practical = now;
                        }
                        m_frame = bm;
                    }
                    CallAfter([this] { Refresh(); });
                }
            }
            if (tunnel) {
                lk.unlock();
                Bambu_Close(tunnel);
                Bambu_Destroy(tunnel);
                tunnel = nullptr;
                lk.lock();
            }
        }
        if (m_url == url)
            m_error = error;
        m_frame_size = wxDefaultSize;
        m_video_size = wxDefaultSize;
        NotifyStopped();
    }
 
}

References adjust_frame_size(), Bambu_Close(), Bambu_Create(), Bambu_Destroy(), Bambu_GetStreamInfo(), bambu_log(), Bambu_Open(), Bambu_ReadSample(), Bambu_SetLogger(), Bambu_StartStream(), Bambu_would_block, AVVideoDecoder::decode(), __Bambu_Sample::decode_time, __Bambu_StreamInfo::format, m_cond, m_error, m_frame, m_frame_size, m_last_PTS, m_last_PTS_expected, m_last_PTS_practical, m_mutex, m_url, m_video_size, NotifyStopped(), AVVideoDecoder::open(), PlayFfmpeg(), AVVideoDecoder::toWxBitmap(), and AVVideoDecoder::toWxImage().

Referenced by wxMediaCtrl3().

Here is the call graph for this function:

Here is the caller graph for this function:

SetExternalFrame()

void wxMediaCtrl3::SetExternalFrame	(	const wxImage &	frame,
		wxSize	videoSize )

{
    if (!frame.IsOk())
        return;
    {
        std::unique_lock<std::mutex> lk(m_mutex);
        if (!m_external)
            return;
        m_frame = frame;
        m_video_size = videoSize.IsFullySpecified() ? videoSize : frame.GetSize();
        adjust_frame_size(m_frame_size, m_video_size, GetSize());
    }
    CallAfter([this] { Refresh(); });
}

References adjust_frame_size(), m_external, m_frame, m_frame_size, m_mutex, and m_video_size.

Here is the call graph for this function:

SetIdleImage()

void wxMediaCtrl3::SetIdleImage

(

wxString const &

image

)

{
    if (m_idle_image == image)
        return;
    m_idle_image = image;
    if (m_url == nullptr) {
        std::unique_lock<std::mutex> lk(m_mutex);
        m_frame = wxImage(m_idle_image);
        assert(m_frame.IsOk());
        Refresh();
    }
}

References m_frame, m_idle_image, m_mutex, and m_url.

Stop()

void wxMediaCtrl3::Stop ( )

overridevirtual

Implements Slic3r::GUI::IMediaController.

{
    std::unique_lock<std::mutex> lk(m_mutex);
    m_url.reset();
    m_frame = wxImage(m_idle_image);
    NotifyStopped();
    m_cond.notify_all();
    Refresh();
}

References m_cond, m_frame, m_idle_image, m_mutex, m_url, and NotifyStopped().

Here is the call graph for this function:

Member Data Documentation

m_active_url

std::shared_ptr<wxURI> wxMediaCtrl3::m_active_url

private

Referenced by BeginExternalStream(), EndExternalStream(), and PlayFfmpeg().

m_cond

std::condition_variable wxMediaCtrl3::m_cond

private

Referenced by ~wxMediaCtrl3(), BeginExternalStream(), EndExternalStream(), Load(), PlayThread(), and Stop().

m_error

int wxMediaCtrl3::m_error = 0

private

Referenced by bambu_log(), GetLastError(), Load(), and PlayThread().

m_external

bool wxMediaCtrl3::m_external = false

private

Referenced by BeginExternalStream(), EndExternalStream(), Load(), Play(), and SetExternalFrame().

m_frame

wxImage wxMediaCtrl3::m_frame

private

Referenced by ~wxMediaCtrl3(), BeginExternalStream(), EndExternalStream(), paintEvent(), PlayFfmpeg(), PlayThread(), SetExternalFrame(), SetIdleImage(), and Stop().

m_frame_size

wxSize wxMediaCtrl3::m_frame_size = wxDefaultSize

private

Referenced by DoSetSize(), paintEvent(), PlayFfmpeg(), PlayThread(), and SetExternalFrame().

m_idle_image

wxString wxMediaCtrl3::m_idle_image

private

Referenced by ~wxMediaCtrl3(), BeginExternalStream(), EndExternalStream(), SetIdleImage(), and Stop().

m_last_PTS

std::uint64_t wxMediaCtrl3::m_last_PTS {0}

private

{0};

Referenced by PlayThread().

m_last_PTS_expected

std::chrono::system_clock::time_point wxMediaCtrl3::m_last_PTS_expected

private

Referenced by PlayThread().

m_last_PTS_practical

std::chrono::system_clock::time_point wxMediaCtrl3::m_last_PTS_practical

private

Referenced by PlayThread().

m_mutex

std::mutex wxMediaCtrl3::m_mutex

mutableprivate

Referenced by ~wxMediaCtrl3(), bambu_log(), BeginExternalStream(), DoSetSize(), EndExternalStream(), GetLastError(), GetState(), GetVideoSize(), Load(), paintEvent(), Play(), PlayThread(), SetExternalFrame(), SetIdleImage(), and Stop().

m_refresh_pending

std::atomic_bool wxMediaCtrl3::m_refresh_pending {false}

private

{false};

Referenced by PlayFfmpeg().

m_state

wxMediaState wxMediaCtrl3::m_state = wxMEDIASTATE_STOPPED

private

Referenced by GetState(), NotifyStopped(), and Play().

m_thread

std::thread wxMediaCtrl3::m_thread

private

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

m_url

std::shared_ptr<wxURI> wxMediaCtrl3::m_url

private

Referenced by ~wxMediaCtrl3(), BeginExternalStream(), EndExternalStream(), Load(), PlayFfmpeg(), PlayThread(), SetIdleImage(), and Stop().

m_video_size

wxSize wxMediaCtrl3::m_video_size = wxDefaultSize

private

Referenced by BeginExternalStream(), DoSetSize(), EndExternalStream(), GetVideoSize(), Load(), PlayFfmpeg(), PlayThread(), and SetExternalFrame().

---

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

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