Skip to content
Snippets Groups Projects
Select Git revision
  • 987811a540769ca54d8e8752d8fa29b23a7da264
  • master default protected
  • release/202005
  • release/202001
  • release/201912
  • release/201911
  • release/releaseWindowsTestOne
  • release/releaseTest
  • release/releaseWindowsTest
  • release/windowsReleaseTest
  • release/201910
  • release/qt/201910
  • release/windows-test/201910
  • release/201908
  • release/201906
  • release/201905
  • release/201904
  • release/201903
  • release/201902
  • release/201901
  • release/201812
  • 1.0.0
  • 0.3.0
  • 0.2.1
  • 0.2.0
  • 0.1.0
26 results

lrc.cpp

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    mediasettingsview.cpp 22.13 KiB
    /*
     *  Copyright (C) 2015-2019 Savoir-faire Linux Inc.
     *  Author: Stepan Salenikovich <stepan.salenikovich@savoirfairelinux.com>
     *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
     *
     *  This program is free software; you can redistribute it and/or modify
     *  it under the terms of the GNU General Public License as published by
     *  the Free Software Foundation; either version 3 of the License, or
     *  (at your option) any later version.
     *
     *  This program is distributed in the hope that it will be useful,
     *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     *  GNU General Public License for more details.
     *
     *  You should have received a copy of the GNU General Public License
     *  along with this program; if not, write to the Free Software
     *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
     */
    
    #include "mediasettingsview.h"
    
    #include <gtk/gtk.h>
    #include <string>
    
    // LRC
    #include <api/avmodel.h>
    #include <api/newvideo.h>
    
    #include "video/video_widget.h"
    
    namespace { namespace details
    {
    class CppImpl;
    }}
    
    struct _MediaSettingsView
    {
        GtkScrolledWindow parent;
    };
    
    struct _MediaSettingsViewClass
    {
        GtkScrolledWindowClass parent_class;
    };
    
    typedef struct _MediaSettingsViewPrivate MediaSettingsViewPrivate;
    
    struct _MediaSettingsViewPrivate
    {
        GtkWidget *vbox_main;
    
        /* audio settings */
        GtkWidget *combobox_manager;
        GtkWidget *combobox_ringtone;
        GtkWidget *combobox_output;
        GtkWidget *combobox_input;
        GtkWidget *levelbar_input;
    
        /* camera settings */
        GtkWidget *combobox_device;
        GtkWidget *combobox_channel;
        GtkWidget *combobox_resolution;
        GtkWidget *combobox_framerate;
        GtkWidget *video_widget;
    
        /* this is used to keep track of the state of the preview when the settings
         * are opened; if a call is in progress, then the preview should already be
         * started and we don't want to stop it when the settings are closed, in this
         * case */
        gboolean video_started_by_settings;
    
        QMetaObject::Connection local_renderer_connection;
        QMetaObject::Connection device_event_connection;
        QMetaObject::Connection audio_meter_connection;
    
        /* hardware accel settings */
        GtkWidget *checkbutton_hardware_acceleration;
    
        details::CppImpl* cpp; ///< Non-UI and C++ only code
    };
    
    G_DEFINE_TYPE_WITH_PRIVATE(MediaSettingsView, media_settings_view, GTK_TYPE_SCROLLED_WINDOW);
    
    #define MEDIA_SETTINGS_VIEW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), MEDIA_SETTINGS_VIEW_TYPE, MediaSettingsViewPrivate))
    
    namespace { namespace details
    {
    
    class CppImpl
    {
    public:
        explicit CppImpl(MediaSettingsView& widget, lrc::api::AVModel& avModel);
    
        void drawAudioDevices();
        void drawFramerates();
        void drawResolutions();
        void drawChannels();
        void drawVideoDevices();
    
        lrc::api::AVModel* avModel_ = nullptr;
        MediaSettingsView* self = nullptr; // The GTK widget itself
        MediaSettingsViewPrivate* widgets = nullptr;
    };
    
    CppImpl::CppImpl(MediaSettingsView& widget, lrc::api::AVModel& avModel)
    : self {&widget}
    , widgets {MEDIA_SETTINGS_VIEW_GET_PRIVATE(&widget)}
    , avModel_(&avModel)
    {
        gtk_toggle_button_set_active(
            GTK_TOGGLE_BUTTON(widgets->checkbutton_hardware_acceleration),
            avModel_->getHardwareAcceleration());
    
        auto activeIdx = 0;
        auto currentManager = avModel_->getAudioManager();
        auto i = 0;
        for (const auto& manager : avModel_->getSupportedAudioManagers()) {
            if (manager == currentManager) {
                activeIdx = i;
            }
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets->combobox_manager), nullptr, manager.c_str());
            i++;
        }
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->combobox_manager), activeIdx);
        drawAudioDevices();
        drawVideoDevices();
    
        gtk_level_bar_set_value(GTK_LEVEL_BAR(widgets->levelbar_input), 0.0);
    }
    
    void
    CppImpl::drawAudioDevices()
    {
        if (!avModel_) {
            g_warning("AVModel not initialized yet");
            return;
        }
        auto activeOutput = 0, activeRingtone = 0;
        auto currentOutput = avModel_->getOutputDevice();
        auto currentRingtone = avModel_->getRingtoneDevice();
        auto i = 0;
        gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->combobox_ringtone));
        gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->combobox_output));
        for (const auto& output : avModel_->getAudioOutputDevices()) {
            if (output == currentOutput) {
                activeOutput = i;
            }
            if (output == currentRingtone) {
                activeRingtone = i;
            }
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets->combobox_ringtone), nullptr, output.c_str());
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets->combobox_output), nullptr, output.c_str());
            i++;
        }
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->combobox_ringtone), activeRingtone);
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->combobox_output), activeOutput);
    
        auto activeInput = 0;
        auto currentInput = avModel_->getInputDevice();
        i = 0;
        gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->combobox_input));
        for (const auto& input : avModel_->getAudioInputDevices()) {
            if (input == currentInput) {
                activeInput = i;
            }
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets->combobox_input), nullptr, input.c_str());
            i++;
        }
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->combobox_input), activeInput);
    }
    
    void
    CppImpl::drawFramerates()
    {
        if (!avModel_) {
            g_warning("AVModel not initialized yet");
            return;
        }
        using namespace lrc::api;
        auto active = 0;
        auto currentDevice = avModel_->getDefaultDeviceName();
        auto deviceCaps = avModel_->getDeviceCapabilities(currentDevice);
        std::string currentChannel = "", currentRes = "", currentRate = "";
        int currentResIndex;
        try {
            auto deviceSettings = avModel_->getDeviceSettings(currentDevice);
            currentChannel = deviceSettings.channel;
            currentRes = deviceSettings.size;
            currentRate = std::to_string(deviceSettings.rate);
            auto resRates = deviceCaps.at(currentChannel);
            auto it = std::find_if(resRates.begin(), resRates.end(),
                [&currentRes](const std::pair<video::Resolution, video::FrameratesList>& element) {
                    return element.first == currentRes;
                });
            if (it == resRates.end()) {
                throw std::out_of_range("Can't find resolution");
            }
            currentResIndex = std::distance(resRates.begin(), it);
        } catch (const std::out_of_range&) {
            g_warning("drawFramerates out_of_range exception");
            return;
        }
        auto rates = deviceCaps.at(currentChannel).at(currentResIndex).second;
        auto i = 0;
        gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->combobox_framerate));
        for (const auto& rate : rates) {
            auto rateStr = std::to_string(static_cast<uint8_t>(rate));
            if (rateStr == currentRate) {
                active = i;
            }
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets->combobox_framerate), nullptr, rateStr.c_str());
            i++;
        }
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->combobox_framerate), active);
    }
    
    void
    CppImpl::drawResolutions()
    {
        if (!avModel_) {
            g_warning("AVModel not initialized yet");
            return;
        }
        auto active = 0;
        auto currentDevice = avModel_->getDefaultDeviceName();
        std::string currentChannel = "", currentRes = "";
        try {
            currentChannel = avModel_->getDeviceSettings(currentDevice).channel;
            currentRes = avModel_->getDeviceSettings(currentDevice).size;
        } catch (const std::out_of_range&) {
            g_warning("drawResolutions out_of_range exception");
            return;
        }
        auto resToRates = avModel_->getDeviceCapabilities(currentDevice).at(currentChannel);
        auto i = 0;
        gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->combobox_resolution));
        for (const auto& item : resToRates) {
            if (item.first == currentRes) {
                active = i;
            }
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets->combobox_resolution), nullptr, item.first.c_str());
            i++;
        }
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->combobox_resolution), active);
        drawFramerates();
    }
    
    void
    CppImpl::drawChannels()
    {
        if (!avModel_) {
            g_warning("AVModel not initialized yet");
            return;
        }
        auto active = 0;
        auto currentDevice = avModel_->getDefaultDeviceName();
        std::string currentChannel = "";
        try {
            currentChannel = avModel_->getDeviceSettings(currentDevice).channel;
        } catch (const std::out_of_range&) {
            g_warning("drawChannels out_of_range exception");
            return;
        }
        auto i = 0;
        gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->combobox_channel));
        for (const auto& capabilites : avModel_->getDeviceCapabilities(currentDevice)) {
            if (capabilites.first == currentChannel) {
                active = i;
            }
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets->combobox_channel), nullptr, capabilites.first.c_str());
            i++;
        }
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->combobox_channel), active);
        drawResolutions();
    }
    
    void
    CppImpl::drawVideoDevices()
    {
        if (!avModel_) {
            g_warning("AVModel not initialized yet");
            return;
        }
        auto active = 0;
        auto current = avModel_->getDefaultDeviceName();
        if (current == "") {
            // Avoid to draw devices if no camera is selected
            return;
        }
        auto i = 0;
        gtk_combo_box_text_remove_all(GTK_COMBO_BOX_TEXT(widgets->combobox_device));
        for (const auto& device : avModel_->getDevices()) {
            if (device == current) {
                active = i;
            }
            gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(widgets->combobox_device), nullptr, device.c_str());
            i++;
        }
        gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->combobox_device), active);
        drawChannels();
    }
    
    }} // namespace details
    
    
    
    static void
    media_settings_view_dispose(GObject *object)
    {
        MediaSettingsView *view = MEDIA_SETTINGS_VIEW(object);
        MediaSettingsViewPrivate *priv = MEDIA_SETTINGS_VIEW_GET_PRIVATE(view);
    
        /* make sure to stop the preview if this view is getting destroyed */
        if (priv->video_started_by_settings) {
            priv->cpp->avModel_->stopPreview();
            priv->video_started_by_settings = FALSE;
        }
    
        QObject::disconnect(priv->local_renderer_connection);
        QObject::disconnect(priv->device_event_connection);
        QObject::disconnect(priv->audio_meter_connection);
    
        G_OBJECT_CLASS(media_settings_view_parent_class)->dispose(object);
    }
    
    static void
    hardware_acceleration_toggled(GtkToggleButton *toggle_button, MediaSettingsView *self)
    {
        g_return_if_fail(IS_MEDIA_SETTINGS_VIEW(self));
        MediaSettingsViewPrivate *priv = MEDIA_SETTINGS_VIEW_GET_PRIVATE(self);
        gboolean hardware_acceleration = gtk_toggle_button_get_active(toggle_button);
        priv->cpp->avModel_->setHardwareAcceleration(hardware_acceleration);
    }
    
    static void
    set_audio_manager(MediaSettingsView* self)
    {
        g_return_if_fail(IS_MEDIA_SETTINGS_VIEW(self));
        MediaSettingsViewPrivate *priv = MEDIA_SETTINGS_VIEW_GET_PRIVATE(self);
        auto* audio_manager = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(priv->combobox_manager));
        if (audio_manager) {
            priv->cpp->avModel_->setAudioManager(audio_manager);
            priv->cpp->drawAudioDevices();
        }
    }
    
    static void
    set_ringtone_device(MediaSettingsView* self)
    {
        g_return_if_fail(IS_MEDIA_SETTINGS_VIEW(self));
        MediaSettingsViewPrivate *priv = MEDIA_SETTINGS_VIEW_GET_PRIVATE(self);
        auto* ringtone_device = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(priv->combobox_ringtone));
        if (ringtone_device) {
            priv->cpp->avModel_->setRingtoneDevice(ringtone_device);
        }
    }
    
    static void
    set_output_device(MediaSettingsView* self)
    {
        g_return_if_fail(IS_MEDIA_SETTINGS_VIEW(self));
        MediaSettingsViewPrivate *priv = MEDIA_SETTINGS_VIEW_GET_PRIVATE(self);
        auto* output_device = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(priv->combobox_output));
        if (output_device) {
            priv->cpp->avModel_->setOutputDevice(output_device);
        }
    }
    
    static void
    set_input_device(MediaSettingsView* self)
    {
        g_return_if_fail(IS_MEDIA_SETTINGS_VIEW(self));
        MediaSettingsViewPrivate *priv = MEDIA_SETTINGS_VIEW_GET_PRIVATE(self);
        auto* input_device = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(priv->combobox_input));
        if (input_device) {
            priv->cpp->avModel_->setInputDevice(input_device);
        }
    }
    
    static void
    set_video_device(MediaSettingsView* self)
    {
        g_return_if_fail(IS_MEDIA_SETTINGS_VIEW(self));
        MediaSettingsViewPrivate *priv = MEDIA_SETTINGS_VIEW_GET_PRIVATE(self);
        auto* video_device = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(priv->combobox_device));
        if (video_device) {
            auto currentDevice = priv->cpp->avModel_->getDefaultDeviceName();
            if (currentDevice == video_device) return;
            priv->cpp->avModel_->setDefaultDevice(video_device);
            try {
                auto settings = priv->cpp->avModel_->getDeviceSettings(currentDevice);
                priv->cpp->avModel_->setDeviceSettings(settings);
            } catch (const std::out_of_range&) {
                g_warning("set_resolution out_of_range exception");
            }
            priv->cpp->drawVideoDevices();
        }
    }
    
    static void
    set_channel(MediaSettingsView* self)
    {
        g_return_if_fail(IS_MEDIA_SETTINGS_VIEW(self));
        MediaSettingsViewPrivate *priv = MEDIA_SETTINGS_VIEW_GET_PRIVATE(self);
        auto* video_channel = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(priv->combobox_channel));
        if (video_channel) {
            auto currentDevice = priv->cpp->avModel_->getDefaultDeviceName();
            try {
                auto settings = priv->cpp->avModel_->getDeviceSettings(currentDevice);
                if (settings.channel == video_channel) return;
                settings.channel = video_channel;
                priv->cpp->avModel_->setDeviceSettings(settings);
            } catch (const std::out_of_range&) {
                g_warning("set_channel out_of_range exception");
                return;
            }
            priv->cpp->drawChannels();
        }
    }
    
    static void
    set_resolution(MediaSettingsView* self)
    {
        g_return_if_fail(IS_MEDIA_SETTINGS_VIEW(self));
        MediaSettingsViewPrivate *priv = MEDIA_SETTINGS_VIEW_GET_PRIVATE(self);
        auto* video_resolution = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(priv->combobox_resolution));
        if (video_resolution) {
            auto currentDevice = priv->cpp->avModel_->getDefaultDeviceName();
            try {
                auto settings = priv->cpp->avModel_->getDeviceSettings(currentDevice);
                if (settings.size == video_resolution) return;
                settings.size = video_resolution;
                priv->cpp->avModel_->setDeviceSettings(settings);
            } catch (const std::out_of_range&) {
                g_warning("set_resolution out_of_range exception");
                return;
            }
            priv->cpp->drawFramerates();
        }
    }
    
    static void
    set_framerate(MediaSettingsView* self)
    {
        g_return_if_fail(IS_MEDIA_SETTINGS_VIEW(self));
        MediaSettingsViewPrivate *priv = MEDIA_SETTINGS_VIEW_GET_PRIVATE(self);
        auto* video_framerate = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(priv->combobox_framerate));
        if (video_framerate) {
            auto currentDevice = priv->cpp->avModel_->getDefaultDeviceName();
            try {
                auto settings = priv->cpp->avModel_->getDeviceSettings(currentDevice);
                if (settings.rate == std::stoi(video_framerate)) return;
                settings.rate = std::stoi(video_framerate);
                priv->cpp->avModel_->setDeviceSettings(settings);
            } catch (...) {
                g_debug("Cannot convert framerate.");
            }
        }
    }
    
    static void
    media_settings_view_init(MediaSettingsView *view)
    {
        gtk_widget_init_template(GTK_WIDGET(view));
    }
    
    static void
    media_settings_view_class_init(MediaSettingsViewClass *klass)
    {
        G_OBJECT_CLASS(klass)->dispose = media_settings_view_dispose;
    
        gtk_widget_class_set_template_from_resource(GTK_WIDGET_CLASS (klass),
                                                    "/net/jami/JamiGnome/mediasettingsview.ui");
    
        gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), MediaSettingsView, vbox_main);
        gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), MediaSettingsView, combobox_manager);
        gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), MediaSettingsView, combobox_ringtone);
        gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), MediaSettingsView, combobox_output);
        gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), MediaSettingsView, combobox_input);
        gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), MediaSettingsView, combobox_device);
        gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), MediaSettingsView, combobox_channel);
        gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), MediaSettingsView, combobox_resolution);
        gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), MediaSettingsView, combobox_framerate);
        gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), MediaSettingsView, checkbutton_hardware_acceleration);
        gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), MediaSettingsView, levelbar_input);
    }
    
    GtkWidget *
    media_settings_view_new(lrc::api::AVModel& avModel)
    {
        auto self = g_object_new(MEDIA_SETTINGS_VIEW_TYPE, NULL);
        auto* priv = MEDIA_SETTINGS_VIEW_GET_PRIVATE(self);
        priv->cpp = new details::CppImpl(
            *(reinterpret_cast<MediaSettingsView*>(self)), avModel
        );
    
        // CppImpl ctor
        g_signal_connect(priv->checkbutton_hardware_acceleration, "toggled",
            G_CALLBACK(hardware_acceleration_toggled), self);
        g_signal_connect_swapped(priv->combobox_manager, "changed",
            G_CALLBACK(set_audio_manager), self);
        g_signal_connect_swapped(priv->combobox_ringtone, "changed",
            G_CALLBACK(set_ringtone_device), self);
        g_signal_connect_swapped(priv->combobox_output, "changed",
            G_CALLBACK(set_output_device), self);
        g_signal_connect_swapped(priv->combobox_input, "changed",
            G_CALLBACK(set_input_device), self);
        g_signal_connect_swapped(priv->combobox_device, "changed",
            G_CALLBACK(set_video_device), self);
        g_signal_connect_swapped(priv->combobox_channel, "changed",
            G_CALLBACK(set_channel), self);
        g_signal_connect_swapped(priv->combobox_resolution, "changed",
            G_CALLBACK(set_resolution), self);
        g_signal_connect_swapped(priv->combobox_framerate, "changed",
            G_CALLBACK(set_framerate), self);
        priv->audio_meter_connection = QObject::connect(
            &*priv->cpp->avModel_,
            &lrc::api::AVModel::audioMeter,
            [=](const std::string& id, float level) {
                if (id == "audiolayer_id")
                    gtk_level_bar_set_value(GTK_LEVEL_BAR(priv->levelbar_input), level);
            });
        return (GtkWidget *)self;
    }
    
    void
    media_settings_view_show_preview(MediaSettingsView *self, gboolean show_preview)
    {
        g_return_if_fail(IS_MEDIA_SETTINGS_VIEW(self));
        MediaSettingsViewPrivate *priv = MEDIA_SETTINGS_VIEW_GET_PRIVATE(self);
    
        /* if TRUE, create a VideoWidget, then check if the preview has already been
         * started (because a call was in progress); if not, then start it.
         * if FALSE, check if the preview was started by this function, if so
         * then stop the preview; then destroy the VideoWidget to make sure we don't
         * get useless frame updates */
    
        if (show_preview) {
            /* put video widget in */
            priv->video_widget = video_widget_new();
            gtk_widget_show_all(priv->video_widget);
            gtk_box_pack_start(GTK_BOX(priv->vbox_main), priv->video_widget, TRUE, TRUE, 0);
            // set minimum size for video so it doesn't shrink too much
            gtk_widget_set_size_request(priv->video_widget, 400, -1);
    
            try {
                const lrc::api::video::Renderer* previewRenderer =
                    &priv->cpp->avModel_->getRenderer(
                    lrc::api::video::PREVIEW_RENDERER_ID);
                priv->video_started_by_settings = previewRenderer->isRendering();
                if (priv->video_started_by_settings) {
                    video_widget_add_new_renderer(VIDEO_WIDGET(priv->video_widget),
                        priv->cpp->avModel_, previewRenderer, VIDEO_RENDERER_REMOTE);
                } else {
                    priv->video_started_by_settings = true;
                    priv->device_event_connection = QObject::connect(
                        &*priv->cpp->avModel_,
                        &lrc::api::AVModel::deviceEvent,
                        [=]() {
                            priv->cpp->drawVideoDevices();
                        });
                    priv->local_renderer_connection = QObject::connect(
                        &*priv->cpp->avModel_,
                        &lrc::api::AVModel::rendererStarted,
                        [=](const std::string& id) {
                            if (id != lrc::api::video::PREVIEW_RENDERER_ID)
                                return;
                            video_widget_add_new_renderer(
                                VIDEO_WIDGET(priv->video_widget),
                                priv->cpp->avModel_,
                                previewRenderer, VIDEO_RENDERER_REMOTE);
                        });
                    priv->cpp->avModel_->startPreview();
                }
            } catch (const std::out_of_range& e) {
                g_warning("Cannot start preview");
            }
            priv->cpp->avModel_->startAudioDevice();
            priv->cpp->avModel_->setAudioMeterState(true);
        } else {
            if (priv->video_started_by_settings) {
                priv->cpp->avModel_->stopPreview();
                QObject::disconnect(priv->local_renderer_connection);
                QObject::disconnect(priv->device_event_connection);
                priv->video_started_by_settings = FALSE;
            }
    
            if (priv->video_widget && IS_VIDEO_WIDGET(priv->video_widget))
                gtk_container_remove(GTK_CONTAINER(priv->vbox_main), priv->video_widget);
            priv->video_widget = NULL;
            priv->cpp->avModel_->setAudioMeterState(false);
            priv->cpp->avModel_->stopAudioDevice();
        }
    
    }