New Audio recording

src/Audio.cpp

@@ -0,0 +1,368 @@
+/*
+ * This file is part of vimix - video live mixer
+ *
+ * **Copyright** (C) 2019-2023 Bruno Herbelin <bruno.herbelin@gmail.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, see <https://www.gnu.org/licenses/>.
+**/
+
+#include <thread>
+#include <algorithm>
+
+#include <gst/pbutils/gstdiscoverer.h>
+#include <gst/pbutils/pbutils.h>
+#include <gst/gst.h>
+
+#include "Settings.h"
+#include "Log.h"
+
+#include "Audio.h"
+
+#ifndef NDEBUG
+//#define AUDIO_DEBUG
+#endif
+
+Audio::Audio(): monitor_(nullptr), monitor_initialized_(false)
+{
+    std::thread(launchMonitoring, this).detach();
+}
+
+void Audio::launchMonitoring(Audio *d)
+{
+    // gstreamer monitoring of devices
+    d->monitor_ = gst_device_monitor_new ();
+    gst_device_monitor_set_show_all_devices(d->monitor_, true);
+
+    // watching all video stream sources
+    GstCaps *caps = gst_caps_new_empty_simple ("audio/x-raw");
+    gst_device_monitor_add_filter (d->monitor_, "Audio/Source", caps);
+    gst_caps_unref (caps);
+
+    // Add configs for already plugged devices
+    GList *devices = gst_device_monitor_get_devices(d->monitor_);
+    GList *tmp;
+    for (tmp = devices; tmp ; tmp = tmp->next ) {
+        GstDevice *device = (GstDevice *) tmp->data;
+        d->add(device);
+        gst_object_unref (device);
+    }
+    g_list_free(devices);
+
+    // monitor is initialized
+    d->monitor_initialized_ = true;
+    d->monitor_initialization_.notify_all();
+
+    // create a local g_main_context to launch monitoring in this thread
+    GMainContext *_gcontext_device = g_main_context_new();
+    g_main_context_acquire(_gcontext_device);
+
+    // temporarily push as default the default g_main_context for add_watch
+    g_main_context_push_thread_default(_gcontext_device);
+
+    // add a bus watch on the device monitoring using the main loop we created
+    GstBus *bus = gst_device_monitor_get_bus (d->monitor_);
+    gst_bus_add_watch (bus, callback_audio_monitor, NULL);
+    gst_object_unref (bus);
+
+    //    gst_device_monitor_set_show_all_devices(d->monitor_, false);
+    if ( !gst_device_monitor_start (d->monitor_) )
+        Log::Info("Audio discovery failed.");
+
+    // restore g_main_context
+    g_main_context_pop_thread_default(_gcontext_device);
+
+    // start main loop for this context (blocking infinitely)
+    g_main_loop_run( g_main_loop_new (_gcontext_device, true) );
+}
+
+void Audio::initialize()
+{
+    // instanciate and wait for monitor initialization if not already initialized
+    std::mutex mtx;
+    std::unique_lock<std::mutex> lck(mtx);
+    Audio::manager().monitor_initialization_.wait(lck, Audio::_initialized);
+}
+
+bool Audio::_initialized()
+{
+    return Audio::manager().monitor_initialized_;
+}
+
+gboolean
+Audio::callback_audio_monitor (GstBus *, GstMessage * message, gpointer )
+{
+    GstDevice *device;
+
+    switch (GST_MESSAGE_TYPE (message)) {
+    case GST_MESSAGE_DEVICE_ADDED:
+    {
+        gst_message_parse_device_added (message, &device);
+        manager().add(device);
+        gst_object_unref (device);
+
+    }
+    break;
+    case GST_MESSAGE_DEVICE_REMOVED:
+    {
+        gst_message_parse_device_removed (message, &device);
+        manager().remove(device);
+        gst_object_unref (device);
+    }
+    break;
+    default:
+        break;
+    }
+
+    return G_SOURCE_CONTINUE;
+}
+
+int Audio::numDevices()
+{
+    access_.lock();
+    int ret = handles_.size();
+    access_.unlock();
+
+    return ret;
+}
+
+struct hasAudioName
+{
+    inline bool operator()(const AudioHandle &elem) const {
+        return (elem.name.compare(_name) == 0);
+    }
+    explicit hasAudioName(const std::string &name) : _name(name) { }
+private:
+    std::string _name;
+};
+
+bool Audio::exists(const std::string &device)
+{
+    access_.lock();
+    auto h = std::find_if(handles_.cbegin(), handles_.cend(), hasAudioName(device));
+    bool ret = (h != handles_.cend());
+    access_.unlock();
+
+    return ret;
+}
+
+int  Audio::index(const std::string &device)
+{
+    int i = -1;
+
+    access_.lock();
+    auto h = std::find_if(handles_.cbegin(), handles_.cend(), hasAudioName(device));
+    if (h != handles_.cend())
+        i = std::distance(handles_.cbegin(), h);
+    access_.unlock();
+
+    return i;
+}
+
+std::string Audio::name(int index)
+{
+    std::string ret = "";
+
+    access_.lock();
+    if (index > -1 && index < (int) handles_.size())
+        ret = handles_[index].name;
+    access_.unlock();
+
+    return ret;
+}
+
+bool Audio::is_monitor(int index)
+{
+    bool ret = false;
+
+    access_.lock();
+    if (index > -1 && index < (int) handles_.size())
+        ret = handles_[index].is_monitor;
+    access_.unlock();
+
+    return ret;
+}
+
+std::string Audio::pipeline(int index)
+{
+    std::string ret = "";
+
+    access_.lock();
+    if (index > -1 && index < (int) handles_.size())
+        ret = handles_[index].pipeline;
+    access_.unlock();
+
+    return ret;
+}
+
+
+// copied from gst-inspect-1.0. perfect for identifying devices
+// https://github.com/freedesktop/gstreamer-gst-plugins-base/blob/master/tools/gst-device-monitor.c
+static gchar *get_launch_line(::GstDevice *device)
+{
+    static const char *const ignored_propnames[] = { "name", "parent", "direction", "template", "caps", nullptr };
+    GString *                launch_line;
+    GstElement *             element;
+    GstElement *             pureelement;
+    GParamSpec **            properties, *property;
+    GValue                   value  = G_VALUE_INIT;
+    GValue                   pvalue = G_VALUE_INIT;
+    guint                    i, number_of_properties;
+    GstElementFactory *      factory;
+
+    element = gst_device_create_element(device, nullptr);
+
+    if (!element)
+        return nullptr;
+
+    factory = gst_element_get_factory(element);
+    if (!factory) {
+        gst_object_unref(element);
+        return nullptr;
+    }
+
+    if (!gst_plugin_feature_get_name(factory)) {
+        gst_object_unref(element);
+        return nullptr;
+    }
+
+    launch_line = g_string_new(gst_plugin_feature_get_name(factory));
+
+    pureelement = gst_element_factory_create(factory, nullptr);
+
+    /* get paramspecs and show non-default properties */
+    properties = g_object_class_list_properties(G_OBJECT_GET_CLASS(element), &number_of_properties);
+    if (properties) {
+        for (i = 0; i < number_of_properties; i++) {
+            gint     j;
+            gboolean ignore = FALSE;
+            property        = properties[i];
+
+            /* skip some properties */
+            if ((property->flags & G_PARAM_READWRITE) != G_PARAM_READWRITE)
+                continue;
+
+            for (j = 0; ignored_propnames[j]; j++)
+                if (!g_strcmp0(ignored_propnames[j], property->name))
+                    ignore = TRUE;
+
+            if (ignore)
+                continue;
+
+            /* Can't use _param_value_defaults () because sub-classes modify the
+             * values already.
+             */
+
+            g_value_init(&value, property->value_type);
+            g_value_init(&pvalue, property->value_type);
+            g_object_get_property(G_OBJECT(element), property->name, &value);
+            g_object_get_property(G_OBJECT(pureelement), property->name, &pvalue);
+            if (gst_value_compare(&value, &pvalue) != GST_VALUE_EQUAL) {
+                gchar *valuestr = gst_value_serialize(&value);
+
+                if (!valuestr) {
+                    GST_WARNING("Could not serialize property %s:%s", GST_OBJECT_NAME(element), property->name);
+                    g_free(valuestr);
+                    goto next;
+                }
+
+                g_string_append_printf(launch_line, " %s=%s", property->name, valuestr);
+                g_free(valuestr);
+            }
+
+        next:
+            g_value_unset(&value);
+            g_value_unset(&pvalue);
+        }
+        g_free(properties);
+    }
+
+    gst_object_unref(element);
+    gst_object_unref(pureelement);
+
+    return g_string_free(launch_line, FALSE);
+}
+
+
+void Audio::add(GstDevice *device)
+{
+    if (device==nullptr)
+        return;
+
+    gchar *device_name = gst_device_get_display_name (device);
+
+    // lock before change
+    access_.lock();
+
+    // if device with this name is not already listed
+    auto handle = std::find_if(handles_.cbegin(), handles_.cend(), hasAudioName(device_name) );
+    if ( handle == handles_.cend() ) {
+
+        gchar *ll = get_launch_line(device);
+
+        // add if valid pipeline
+        if (ll)
+        {
+            AudioHandle dev;
+            dev.name = device_name;
+            dev.pipeline = std::string(ll);
+            dev.is_monitor = dev.pipeline.compare( dev.pipeline.size()-7, 7, "monitor") == 0;
+
+#ifdef AUDIO_DEBUG
+            GstStructure *stru = gst_device_get_properties(device);
+            g_print("\nName: '%s'\nProperties: %s", device_name, gst_structure_to_string(stru) );
+            g_print("\nPipeline: %s\n", dev.pipeline.c_str());
+#endif
+            handles_.push_back(dev);
+            Log::Info("Audio device '%s' is plugged-in.", device_name);
+        }
+
+    }
+
+    // unlock access
+    access_.unlock();
+
+    g_free (device_name);
+}
+
+void Audio::remove(GstDevice *device)
+{
+    if (device==nullptr)
+        return;
+
+    std::string devicename = gst_device_get_display_name (device);
+
+    // lock before change
+    access_.lock();
+
+    // if a device with this name is listed
+    auto handle = std::find_if(handles_.cbegin(), handles_.cend(), hasAudioName(devicename) );
+    if ( handle != handles_.cend() ) {
+
+        // inform the user
+        Log::Info("Audio device '%s' unplugged.", devicename.c_str());
+
+        // Warning if the audio device used for recording is unplugged
+        if (Settings::application.record.audio_device.compare(devicename) == 0) {
+            Log::Warning("Audio device for recording was unplugged.");
+            // reset settings
+            Settings::application.record.audio_device = "";
+        }
+
+        // remove the handle
+        handles_.erase(handle);
+    }
+
+    // unlock access
+    access_.unlock();
+}