### PlayBin Media Player Example

Source: https://context7.com/gnome/gstreamermm/llms.txt

This C++ code snippet demonstrates how to use Gst::PlayBin to play a media file or URI. It includes setting up the main loop, handling bus messages for playback events, and managing the playback state. Ensure GStreamer and GStreamerMM are installed.

```cpp
#include <gstreamermm.h>
#include <gstreamermm/playbin.h>
#include <glibmm/main.h>
#include <glibmm/convert.h>
#include <iostream>

Glib::RefPtr<Glib::MainLoop> mainloop;

bool on_bus_message(const Glib::RefPtr<Gst::Bus>&,
                    const Glib::RefPtr<Gst::Message>& message)
{
    switch (message->get_message_type()) {
        case Gst::MESSAGE_EOS:
            std::cout << "End of stream" << std::endl;
            mainloop->quit();
            return false;
        case Gst::MESSAGE_ERROR: {
            auto error_msg =
                Glib::RefPtr<Gst::MessageError>::cast_static(message);
            if (error_msg) {
                std::cerr << "Error: " << error_msg->parse_error().what()
                          << std::endl;
            }
            mainloop->quit();
            return false;
        }
        default:
            break;
    }
    return true;
}

int main(int argc, char* argv[])
{
    Gst::init(argc, argv);

    if (argc < 2) {
        std::cout << "Usage: " << argv[0] << " <media file or URI>" << std::endl;
        return 1;
    }

    // Create playbin element
#ifndef GSTREAMERMM_DISABLE_DEPRECATED
    Glib::RefPtr<Gst::PlayBin> playbin = Gst::PlayBin::create();
#else
    Glib::RefPtr<Gst::Element> playbin =
        Gst::ElementFactory::create_element("playbin");
#endif

    if (!playbin) {
        std::cerr << "Could not create playbin element" << std::endl;
        return 1;
    }

    // Convert filename to URI if needed
    Glib::ustring uri;
    if (gst_uri_is_valid(argv[1])) {
        uri = argv[1];
    } else {
        uri = Glib::filename_to_uri(argv[1]);
    }

    // Set the URI property
    playbin->set_property("uri", uri);

    // Create main loop and setup bus watch
    mainloop = Glib::MainLoop::create();
    Glib::RefPtr<Gst::Bus> bus = playbin->get_bus();
    bus->add_watch(sigc::ptr_fun(&on_bus_message));

    // Start playback
    std::cout << "Playing: " << uri << std::endl;
    playbin->set_state(Gst::STATE_PLAYING);
    mainloop->run();

    // Cleanup
    playbin->set_state(Gst::STATE_NULL);
    return 0;
}
```

--------------------------------

### TypeFind Media Detection Example

Source: https://context7.com/gnome/gstreamermm/llms.txt

Use the typefind element to identify media types by examining stream content. Connect to the 'have-type' signal to receive media type information. This example demonstrates setting up a pipeline with filesrc, typefind, and fakesink.

```cpp
#include <gstreamermm.h>
#include <glibmm/main.h>
#include <iostream>

Glib::RefPtr<Glib::MainLoop> mainloop;
bool have_type = false;

void on_typefind_have_type(guint probability,
                           const Glib::RefPtr<Gst::Caps>& caps)
{
    have_type = true;

    std::cout << "Type found with probability: " << probability << std::endl;

    if (!caps || !caps->size()) {
        std::cerr << "Invalid caps" << std::endl;
        return;
    }

    Gst::Structure structure = caps->get_structure(0);
    std::cout << "MIME type: " << structure.get_name() << std::endl;

    // Iterate through structure fields
    structure.foreach([](const Glib::QueryQuark& id,
                         const Glib::ValueBase& value) {
        gchar* str_value = g_strdup_value_contents(value.gobj());
        std::cout << "  " << Glib::ustring(id) << " = " << str_value << std::endl;
        g_free(str_value);
        return true;
    });

    if (mainloop) {
        mainloop->quit();
    }
}

int main(int argc, char* argv[])
{
    Gst::init(argc, argv);

    if (argc < 2) {
        std::cout << "Usage: " << argv[0] << " <filename>" << std::endl;
        return 1;
    }

    Glib::RefPtr<Gst::Pipeline> pipeline = Gst::Pipeline::create("typefind");

#ifndef GSTREAMERMM_DISABLE_DEPRECATED
    Glib::RefPtr<Gst::FileSrc> source = Gst::FileSrc::create();
    source->property_location() = std::string(argv[1]);
    Glib::RefPtr<Gst::FakeSink> sink = Gst::FakeSink::create();
    Glib::RefPtr<Gst::TypeFindElement> typefind = Gst::TypeFindElement::create();

    typefind->signal_have_type().connect(sigc::ptr_fun(&on_typefind_have_type));
#else
    Glib::RefPtr<Gst::Element> source =
        Gst::ElementFactory::create_element("filesrc");
    source->set_property("location", std::string(argv[1]));
    Glib::RefPtr<Gst::Element> sink =
        Gst::ElementFactory::create_element("fakesink");
    Glib::RefPtr<Gst::Element> typefind =
        Gst::ElementFactory::create_element("typefind");
#endif

    // Add and link elements
    pipeline->add(source)->add(typefind)->add(sink);
    source->link(typefind)->link(sink);

    // Run pipeline
    mainloop = Glib::MainLoop::create();
    pipeline->set_state(Gst::STATE_PLAYING);

    if (!have_type) {
        mainloop->run();
    }

    pipeline->set_state(Gst::STATE_NULL);
    return 0;
}

```

--------------------------------

### Create and Configure a GStreamer Pipeline

Source: https://context7.com/gnome/gstreamermm/llms.txt

Demonstrates creating a GStreamer pipeline, adding video test source and auto video sink elements, setting properties, linking them, and accessing the bus and clock. Ensure GStreamer and GStreamerMM are installed.

```cpp
#include <gstreamermm.h>
#include <iostream>

int main(int argc, char* argv[])
{
    Gst::init(argc, argv);

    // Create a named pipeline
    Glib::RefPtr<Gst::Pipeline> pipeline = Gst::Pipeline::create("my-pipeline");

    // Create elements
    Glib::RefPtr<Gst::Element> source =
        Gst::ElementFactory::create_element("videotestsrc", "source");
    Glib::RefPtr<Gst::Element> sink =
        Gst::ElementFactory::create_element("autovideosink", "sink");

    if (!pipeline || !source || !sink) {
        std::cerr << "Failed to create elements" << std::endl;
        return 1;
    }

    // Set element properties
    source->set_property("pattern", 0);  // SMPTE test pattern

    // Add elements to pipeline
    try {
        pipeline->add(source)->add(sink);
    } catch (const std::runtime_error& ex) {
        std::cerr << "Exception while adding: " << ex.what() << std::endl;
        return 1;
    }

    // Link elements together
    try {
        source->link(sink);
    } catch (const std::runtime_error& ex) {
        std::cerr << "Exception while linking: " << ex.what() << std::endl;
        return 1;
    }

    // Get the pipeline's bus for message handling
    Glib::RefPtr<Gst::Bus> bus = pipeline->get_bus();

    // Get/set pipeline clock
    Glib::RefPtr<Gst::Clock> clock = pipeline->get_clock();

    return 0;
}

```

--------------------------------

### GStreamerMM Tee Example with Request Pads

Source: https://context7.com/gnome/gstreamermm/llms.txt

This C++ code demonstrates using the tee element to split an audio and video stream from a file source. It utilizes request pads to dynamically create output pads for the tee element and links them to separate audio and video processing chains. Ensure you have GStreamer and GStreamerMM libraries installed.

```cpp
#include <gstreamermm.h>
#include <glibmm/main.h>
#include <iostream>

Glib::RefPtr<Glib::MainLoop> mainloop;

int main(int argc, char* argv[])
{
    Gst::init(argc, argv);

    if (argc < 2) {
        std::cout << "Usage: " << argv[0] << " <audio file>" << std::endl;
        return 1;
    }

    Glib::RefPtr<Gst::Pipeline> pipeline = Gst::Pipeline::create("tee-example");

    // Create elements
    Glib::RefPtr<Gst::Element> source = 
        Gst::ElementFactory::create_element("filesrc");
    Glib::RefPtr<Gst::Element> decoder = 
        Gst::ElementFactory::create_element("decodebin");
    Glib::RefPtr<Gst::Element> tee = 
        Gst::ElementFactory::create_element("tee");
    Glib::RefPtr<Gst::Element> audio_queue = 
        Gst::ElementFactory::create_element("queue");
    Glib::RefPtr<Gst::Element> video_queue = 
        Gst::ElementFactory::create_element("queue");
    Glib::RefPtr<Gst::Element> audio_convert = 
        Gst::ElementFactory::create_element("audioconvert");
    Glib::RefPtr<Gst::Element> audio_sink = 
        Gst::ElementFactory::create_element("autoaudiosink");
    Glib::RefPtr<Gst::Element> visualizer = 
        Gst::ElementFactory::create_element("goom");
    Glib::RefPtr<Gst::Element> video_convert = 
        Gst::ElementFactory::create_element("videoconvert");
    Glib::RefPtr<Gst::Element> video_sink = 
        Gst::ElementFactory::create_element("autovideosink");

    source->set_property<Glib::ustring>("location", argv[1]);

    // Add all elements
    pipeline->add(source)->add(decoder)->add(tee)
            ->add(audio_queue)->add(video_queue)
            ->add(audio_convert)->add(visualizer)
            ->add(video_convert)->add(audio_sink)->add(video_sink);

    // Get tee's pad template and request pads
    Glib::RefPtr<Gst::PadTemplate> tee_src_tpl = tee->get_pad_template("src_%u");

    // Request first tee output pad and link to audio queue
    Glib::RefPtr<Gst::Pad> tee_audio_pad = tee->request_pad(tee_src_tpl);
    if (tee_audio_pad->link(audio_queue->get_static_pad("sink")) != Gst::PAD_LINK_OK) {
        std::cerr << "Cannot link tee to audio queue" << std::endl;
        return 1;
    }

    // Request second tee output pad and link to video queue
    Glib::RefPtr<Gst::Pad> tee_video_pad = tee->request_pad(tee_src_tpl);
    if (tee_video_pad->link(video_queue->get_static_pad("sink")) != Gst::PAD_LINK_OK) {
        std::cerr << "Cannot link tee to video queue" << std::endl;
        return 1;
    }

    // Link static pads
    source->link(decoder);
    audio_queue->link(audio_convert)->link(audio_sink);
    video_queue->link(visualizer)->link(video_convert)->link(video_sink);

    // Handle decoder's dynamic pads
    decoder->signal_pad_added().connect(
        [tee](const Glib::RefPtr<Gst::Pad>& pad) {
            Glib::RefPtr<Gst::Caps> caps = pad->get_current_caps();
            std::string media_type = caps->get_structure(0).get_name();

            if (media_type.find("audio") == 0) {
                pad->link(tee->get_static_pad("sink"));
            }
        }
    );

    // Bus message handling
    pipeline->get_bus()->add_watch(
        [](const Glib::RefPtr<Gst::Bus>&, 
           const Glib::RefPtr<Gst::Message>& msg) {
            if (msg->get_message_type() == Gst::MESSAGE_ERROR ||
                msg->get_message_type() == Gst::MESSAGE_EOS) {
                mainloop->quit();
            }
            return true;
        }
    );

    mainloop = Glib::MainLoop::create();
    pipeline->set_state(Gst::STATE_PLAYING);
    mainloop->run();
    pipeline->set_state(Gst::STATE_NULL);

    return 0;
}

```

--------------------------------

### Handle Dynamic Pads with `signal_pad_added`

Source: https://context7.com/gnome/gstreamermm/llms.txt

Connect to the `signal_pad_added` signal to link dynamically created pads, typically from elements like `decodebin`. This example demonstrates linking a `videotestsrc` to a `decodebin` and then linking the `decodebin`'s dynamic output pad to an `autovideosink`.

```cpp
#include <gstreamermm.h>
#include <glibmm/main.h>
#include <iostream>

int main(int argc, char* argv[])
{
    Gst::init(argc, argv);

    Glib::RefPtr<Glib::MainLoop> main_loop = Glib::MainLoop::create();
    Glib::RefPtr<Gst::Pipeline> pipeline = Gst::Pipeline::create("dynamic-pipeline");

    // Create elements
    Glib::RefPtr<Gst::Element> source =
        Gst::ElementFactory::create_element("videotestsrc", "source");
    Glib::RefPtr<Gst::Element> decodebin =
        Gst::ElementFactory::create_element("decodebin", "decoder");
    Glib::RefPtr<Gst::Element> sink =
        Gst::ElementFactory::create_element("autovideosink", "videosink");

    // Add elements to pipeline
    pipeline->add(source)->add(decodebin)->add(sink);

    // Link source to decodebin (sink has dynamic pads)
    source->link(decodebin);
    // Note: Cannot link decodebin to sink yet - no src pad exists

    // Handle bus messages
    pipeline->get_bus()->add_watch(
        [main_loop](const Glib::RefPtr<Gst::Bus>&,
                    const Glib::RefPtr<Gst::Message>& message) {
            if (message->get_message_type() == Gst::MESSAGE_EOS ||
                message->get_message_type() == Gst::MESSAGE_ERROR) {
                main_loop->quit();
            }
            return true;
        }
    );

    // Connect to pad-added signal for dynamic linking
    decodebin->signal_pad_added().connect(
        [decodebin, sink](const Glib::RefPtr<Gst::Pad>& pad) {
            std::cout << "New pad added: " << pad->get_name() << std::endl;

            // Get the sink pad of our sink element
            Glib::RefPtr<Gst::Pad> sink_pad = sink->get_static_pad("sink");

            // Link the new pad to the sink
            Gst::PadLinkReturn ret = pad->link(sink_pad);

            if (ret != Gst::PAD_LINK_OK) {
                std::cout << "Cannot link pads. Error: " << ret << std::endl;
            } else {
                std::cout << "Pads linked successfully!" << std::endl;
            }
        }
    );

    // Start playing
    pipeline->set_state(Gst::STATE_PLAYING);
    main_loop->run();
    pipeline->set_state(Gst::STATE_NULL);

    return 0;
}

```

--------------------------------

### Compile gstreamermm Application with pkg-config

Source: https://context7.com/gnome/gstreamermm/llms.txt

Use pkg-config to get compiler and linker flags for gstreamermm. This is the basic command for compiling a C++ program with gstreamermm.

```bash
g++ program.cc -o program `pkg-config --cflags --libs gstreamermm-1.0`
```

```bash
g++ -std=c++11 program.cc -o program `pkg-config --cflags --libs gstreamermm-1.0`
```

--------------------------------

### Pad Probe for Data Monitoring

Source: https://context7.com/gnome/gstreamermm/llms.txt

Pad probes allow interception and monitoring of data flowing through pads. Use `add_probe()` to attach a callback that receives buffer or event notifications. This example demonstrates adding a probe to a fakesink's sink pad.

```cpp
#include <gstreamermm.h>
#include <glibmm/main.h>
#include <iostream>

Glib::RefPtr<Glib::MainLoop> mainloop;
gulong probe_id = 0;

Gst::PadProbeReturn on_pad_probe(const Glib::RefPtr<Gst::Pad>& pad,
                                  const Gst::PadProbeInfo& info)
{
    std::cout << "Data received on pad: " << pad->get_name() << std::endl;

    // Remove probe after first data (optional)
    if (probe_id) {
        std::cout << "Removing probe ID: " << probe_id << std::endl;
        pad->remove_probe(probe_id);
        probe_id = 0;
    }

    return Gst::PAD_PROBE_OK;  // Continue processing
    // return Gst::PAD_PROBE_DROP;  // Drop the data
    // return Gst::PAD_PROBE_REMOVE;  // Remove the probe
}

int main(int argc, char* argv[])
{
    Gst::init(argc, argv);

    Glib::RefPtr<Gst::Pipeline> pipeline = Gst::Pipeline::create("probe-test");

    Glib::RefPtr<Gst::Element> source =
        Gst::ElementFactory::create_element("videotestsrc");
    Glib::RefPtr<Gst::Element> sink =
        Gst::ElementFactory::create_element("fakesink");

    source->set_property("num-buffers", 10);

    pipeline->add(source)->add(sink);
    source->link(sink);

    // Add probe to sink pad
    Glib::RefPtr<Gst::Pad> sink_pad = sink->get_static_pad("sink");

    // Probe for downstream data (buffers)
    probe_id = sink_pad->add_probe(
        Gst::PAD_PROBE_TYPE_DATA_DOWNSTREAM,
        sigc::ptr_fun(&on_pad_probe)
    );

    std::cout << "Added probe with ID: " << probe_id << std::endl;

    // Bus handling
    pipeline->get_bus()->add_watch(
        [](const Glib::RefPtr<Gst::Bus>&,
           const Glib::RefPtr<Gst::Message>& msg) {
            if (msg->get_message_type() == Gst::MESSAGE_EOS) {
                std::cout << "EOS received" << std::endl;
                mainloop->quit();
            } else if (msg->get_message_type() == Gst::MESSAGE_ERROR) {
                mainloop->quit();
            }
            return true;
        }
    );

    mainloop = Glib::MainLoop::create();
    pipeline->set_state(Gst::STATE_PLAYING);
    mainloop->run();
    pipeline->set_state(Gst::STATE_NULL);

    return 0;
}

```

--------------------------------

### Ogg/Vorbis Audio Player Pipeline

Source: https://context7.com/gnome/gstreamermm/llms.txt

Builds and runs an Ogg/Vorbis audio player. Handles dynamic pad creation from 'oggdemux' and links it to 'vorbisdec'. Requires an Ogg/Vorbis file as a command-line argument.

```cpp
#include <gstreamermm.h>
#include <glibmm/main.h>
#include <iostream>
#include <iomanip>

Glib::RefPtr<Glib::MainLoop> mainloop;
Glib::RefPtr<Gst::Pipeline> pipeline;
Glib::RefPtr<Gst::Element> decoder;

bool on_timeout()
{
    gint64 pos = 0, len = 0;

    if (pipeline->query_position(Gst::FORMAT_TIME, pos) &&
        pipeline->query_duration(Gst::FORMAT_TIME, len)) {
        std::cout << "Position: " << std::setfill('0')
                  << std::setw(2) << Gst::get_hours(pos) << ":"
                  << std::setw(2) << Gst::get_minutes(pos) << ":"
                  << std::setw(2) << Gst::get_seconds(pos)
                  << " / "
                  << std::setw(2) << Gst::get_hours(len) << ":"
                  << std::setw(2) << Gst::get_minutes(len) << ":"
                  << std::setw(2) << Gst::get_seconds(len) << "\r" << std::flush;
    }
    return true;
}

bool on_bus_message(const Glib::RefPtr<Gst::Bus>&, 
                    const Glib::RefPtr<Gst::Message>& message)
{
    switch (message->get_message_type()) {
        case Gst::MESSAGE_EOS:
            std::cout << std::endl << "End of stream" << std::endl;
            mainloop->quit();
            return false;
        case Gst::MESSAGE_ERROR: {
            auto error = Glib::RefPtr<Gst::MessageError>::cast_static(message);
            std::cerr << "Error: " << error->parse_error().what() << std::endl;
            mainloop->quit();
            return false;
        }
        default:
            break;
    }
    return true;
}

void on_parser_pad_added(const Glib::RefPtr<Gst::Pad>& new_pad)
{
    std::cout << "Dynamic pad created, linking parser to decoder" << std::endl;
    Glib::RefPtr<Gst::Pad> sink_pad = decoder->get_static_pad("sink");

    Gst::PadLinkReturn ret = new_pad->link(sink_pad);
    if (ret != Gst::PAD_LINK_OK && ret != Gst::PAD_LINK_WAS_LINKED) {
        std::cerr << "Linking failed" << std::endl;
    }
}

int main(int argc, char* argv[])
{
    Gst::init(argc, argv);

    if (argc < 2) {
        std::cout << "Usage: " << argv[0] << " <Ogg/Vorbis file>" << std::endl;
        return 1;
    }

    mainloop = Glib::MainLoop::create();
    pipeline = Gst::Pipeline::create("audio-player");

    // Create elements
    Glib::RefPtr<Gst::Element> source =
        Gst::ElementFactory::create_element("filesrc");
    Glib::RefPtr<Gst::Element> parser =
        Gst::ElementFactory::create_element("oggdemux");
    decoder = Gst::ElementFactory::create_element("vorbisdec");
    Glib::RefPtr<Gst::Element> conv =
        Gst::ElementFactory::create_element("audioconvert");
    Glib::RefPtr<Gst::Element> sink = 
        Gst::ElementFactory::create_element("autoaudiosink");

    if (!source || !parser || !decoder || !conv || !sink) {
        std::cerr << "Failed to create elements" << std::endl;
        return 1;
    }

    // Set input file
    source->set_property("location", std::string(argv[1]));

    // Setup bus watch
    pipeline->get_bus()->add_watch(sigc::ptr_fun(&on_bus_message));

    // Add elements to pipeline
    pipeline->add(source)->add(parser)->add(decoder)->add(conv)->add(sink);

    // Link elements (parser uses dynamic pads)
    source->link(parser);
    parser->signal_pad_added().connect(sigc::ptr_fun(&on_parser_pad_added));
    decoder->link(conv)->link(sink);

    // Setup position display timer
    Glib::signal_timeout().connect(sigc::ptr_fun(&on_timeout), 200);

    // Start playback
    std::cout << "Playing..." << std::endl;
    pipeline->set_state(Gst::STATE_PLAYING);
    mainloop->run();

    pipeline->set_state(Gst::STATE_NULL);
    return 0;
}

```

--------------------------------

### Manage Elements within a GStreamer Bin

Source: https://context7.com/gnome/gstreamermm/llms.txt

Illustrates creating a GStreamer bin, adding and removing elements, retrieving elements by name, connecting to signals, and iterating through bin contents. This is useful for organizing and controlling groups of elements.

```cpp
#include <gstreamermm.h>
#include <iostream>

int main(int argc, char* argv[])
{
    Gst::init(argc, argv);

    // Create elements
    Glib::RefPtr<Gst::Element> fakesrc =
        Gst::ElementFactory::create_element("fakesrc", "source");
    Glib::RefPtr<Gst::Element> fakesink =
        Gst::ElementFactory::create_element("fakesink", "sink");

    // Create empty bin
    Glib::RefPtr<Gst::Bin> bin = Gst::Bin::create("my-bin");

    // Add elements to bin (chainable)
    try {
        bin->add(fakesrc)->add(fakesink);
    } catch (const std::runtime_error& ex) {
        std::cerr << "Exception while adding: " << ex.what() << std::endl;
        return 1;
    }

    // Get element by name
    Glib::RefPtr<Gst::Element> element = bin->get_element("source");

    // Connect to element-removed signal
    bin->signal_element_removed().connect(
        [](const Glib::RefPtr<Gst::Element>& removed) {
            std::cout << "Element '" << removed->get_name()
                      << "' was removed" << std::endl;
        }
    );

    // Remove element from bin
    bin->remove(fakesink);

    // Iterate through elements in a bin
    Gst::Iterator<Gst::Element> it = bin->iterate_elements();
    while (it.next()) {
        std::cout << "Element: " << it->get_name() << std::endl;
    }

    // Cast playbin element to Bin and iterate
    Glib::RefPtr<Gst::Element> playbin =
        Gst::ElementFactory::create_element("playbin");
    Glib::RefPtr<Gst::Bin> playbin_bin =
        Glib::RefPtr<Gst::Bin>::cast_static(playbin);

    if (playbin_bin) {
        Gst::Iterator<Gst::Element> recursive_it = playbin_bin->iterate_recurse();
        while (recursive_it.next()) {
            std::cout << " * " << recursive_it->get_name() << std::endl;
        }
    }

    return 0;
}

```

--------------------------------

### Create GStreamer Elements with ElementFactory

Source: https://context7.com/gnome/gstreamermm/llms.txt

Demonstrates creating GStreamer elements using `Gst::ElementFactory`. You can create elements directly by name or find the factory first to access metadata and then create the element. This also shows how to list available elements of a specific type.

```cpp
#include <gstreamermm.h>
#include <iostream>

int main(int argc, char* argv[])
{
    Gst::init(argc, argv);

    // Method 1: Create element directly with ElementFactory
    Glib::RefPtr<Gst::Element> fakesrc =
        Gst::ElementFactory::create_element("fakesrc", "source");

    if (!fakesrc) {
        std::cerr << "Failed to create element 'fakesrc'" << std::endl;
        return 1;
    }

    // Method 2: Find factory first, then create element
    Glib::RefPtr<Gst::ElementFactory> factory =
        Gst::ElementFactory::find("fakesrc");

    if (factory) {
        // Get element metadata
        std::cout << "Author: "
                  << factory->get_metadata(GST_ELEMENT_METADATA_AUTHOR)
                  << std::endl;

        // Create element from factory
        Glib::RefPtr<Gst::Element> element = factory->create("my-source");
    }

    // Get list of all primary demuxers in the system
    std::cout << "Available demuxers:" << std::endl;
    for (auto& factory : Gst::ElementFactory::get_elements(
            Gst::ELEMENT_FACTORY_TYPE_DEMUXER, Gst::RANK_PRIMARY)) {
        std::cout << " * " << factory->get_name() << std::endl;
    }

    return 0;
}
```

--------------------------------

### Initialize gstreamermm

Source: https://context7.com/gnome/gstreamermm/llms.txt

Initializes the gstreamermm library, optionally parsing command line arguments. It's essential to call this before using any gstreamermm functionality. You can also check the GStreamer version after initialization.

```cpp
#include <gstreamermm.h>
#include <iostream>

int main(int argc, char* argv[])
{
    // Initialize gstreamermm with command line parsing
    Gst::init(argc, argv);

    // Check GStreamer version
    guint major, minor, micro, nano;
    Gst::version(major, minor, micro, nano);
    std::cout << "GStreamer version: " << major << "." << minor
              << "." << micro << "." << nano << std::endl;

    // Alternatively, use init_check for graceful error handling
    // try {
    //     if (!Gst::init_check(argc, argv)) {
    //         std::cerr << "Failed to initialize GStreamer" << std::endl;
    //         return 1;
    //     }
    // } catch (const Glib::Error& ex) {
    //     std::cerr << "Error: " << ex.what() << std::endl;
    //     return 1;
    // }

    // Simple init without command line parsing
    // Gst::init();

    return 0;
}
```

--------------------------------

### Link GStreamer Elements in C++

Source: https://context7.com/gnome/gstreamermm/llms.txt

Demonstrates chaining elements for data flow using `link()` or specific pad connections with `link_pads()`. Elements must be added to the pipeline before linking.

```cpp
#include <gstreamermm.h>
#include <iostream>

int main(int argc, char* argv[])
{
    Gst::init(argc, argv);

    // Create pipeline and elements
    Glib::RefPtr<Gst::Pipeline> pipeline = Gst::Pipeline::create("my-pipeline");
    Glib::RefPtr<Gst::Element> source =
        Gst::ElementFactory::create_element("fakesrc");
    Glib::RefPtr<Gst::Element> filter =
        Gst::ElementFactory::create_element("identity");
    Glib::RefPtr<Gst::Element> sink =
        Gst::ElementFactory::create_element("fakesink");

    // Add elements to pipeline first (required before linking)
    try {
        pipeline->add(source)->add(filter)->add(sink);
    } catch (const std::runtime_error& ex) {
        std::cerr << "Exception while adding: " << ex.what() << std::endl;
        return 1;
    }

    // Method 1: Chain linking (returns dest element for further linking)
    try {
        source->link(filter)->link(sink);
    } catch (const std::runtime_error& ex) {
        std::cerr << "Exception while linking: " << ex.what() << std::endl;
        return 1;
    }

    // Method 2: Link specific pads by name
    // source->link_pads("src", filter, "sink");

    // Method 3: Link with caps filter
    // Glib::RefPtr<Gst::Caps> caps = Gst::Caps::create_simple(
    //     "video/x-raw", "width", 640, "height", 480);
    // source->link(filter, caps);

    // Unlink elements
    source->unlink(filter);

    return 0;
}

```

--------------------------------

### Manage GStreamer Element States

Source: https://context7.com/gnome/gstreamermm/llms.txt

Use `set_state()` to change an element's state and `get_state()` to query its current and pending states. Handles different return values indicating success, asynchronous operation, no preroll, or failure.

```cpp
#include <gstreamermm.h>
#include <iostream>

int main(int argc, char* argv[])
{
    Gst::init(argc, argv);

    Glib::RefPtr<Gst::Pipeline> pipeline = Gst::Pipeline::create("test");
    Glib::RefPtr<Gst::Element> source =
        Gst::ElementFactory::create_element("videotestsrc");
    Glib::RefPtr<Gst::Element> sink =
        Gst::ElementFactory::create_element("fakesink");

    pipeline->add(source)->add(sink);
    source->link(sink);

    // Set pipeline to PLAYING state
    Gst::StateChangeReturn ret = pipeline->set_state(Gst::STATE_PLAYING);

    switch (ret) {
        case Gst::STATE_CHANGE_SUCCESS:
            std::cout << "State change successful" << std::endl;
            break;
        case Gst::STATE_CHANGE_ASYNC:
            std::cout << "State change in progress..." << std::endl;
            break;
        case Gst::STATE_CHANGE_NO_PREROLL:
            std::cout << "Live source, no preroll" << std::endl;
            break;
        case Gst::STATE_CHANGE_FAILURE:
            std::cerr << "State change failed" << std::endl;
            return 1;
    }

    // Query current state with timeout (in nanoseconds)
    Gst::State state, pending;
    ret = pipeline->get_state(state, pending, Gst::CLOCK_TIME_NONE);
    std::cout << "Current state: " << Gst::Enums::get_name(state) << std::endl;
    std::cout << "Pending state: " << Gst::Enums::get_name(pending) << std::endl;

    // Pause the pipeline
    pipeline->set_state(Gst::STATE_PAUSED);

    // Stop the pipeline (cleanup)
    pipeline->set_state(Gst::STATE_NULL);

    return 0;
}

```

--------------------------------

### Integrate gstreamermm with Autoconf/Automake

Source: https://context7.com/gnome/gstreamermm/llms.txt

Add gstreamermm module checks to configure.ac and define compiler/linker flags in Makefile.am for projects using autoconf and automake.

```autoconf
# PKG_CHECK_MODULES([GSTREAMERMM], [gstreamermm-1.0])
```

```makefile
# program_CPPFLAGS = $(GSTREAMERMM_CFLAGS)
# program_LDADD = $(GSTREAMERMM_LIBS)
```

--------------------------------

### Handle GStreamer Bus Messages in C++

Source: https://context7.com/gnome/gstreamermm/llms.txt

Asynchronously process pipeline messages like errors, EOS, and state changes by adding a watch function to the Gst::Bus. The watch function should return `false` to stop processing messages.

```cpp
#include <gstreamermm.h>
#include <glibmm/main.h>
#include <iostream>

Glib::RefPtr<Glib::MainLoop> main_loop;

bool on_bus_message(const Glib::RefPtr<Gst::Bus>& bus,
                    const Glib::RefPtr<Gst::Message>& message)
{
    std::cout << "Message type: "
              << Gst::Enums::get_name(message->get_message_type()) << std::endl;

    if (message->get_source()) {
        std::cout << "Source: " << message->get_source()->get_name() << std::endl;
    }

    switch (message->get_message_type()) {
        case Gst::MESSAGE_ERROR: {
            auto error_msg =
                Glib::RefPtr<Gst::MessageError>::cast_static(message);
            std::cerr << "Error: " << error_msg->parse_error().what() << std::endl;
            std::cerr << "Debug: " << error_msg->parse_debug() << std::endl;
            main_loop->quit();
            return false;
        }
        case Gst::MESSAGE_EOS:
            std::cout << "End of stream"
                      << std::endl;
            main_loop->quit();
            return false;
        case Gst::MESSAGE_STATE_CHANGED: {
            auto state_msg =
                Glib::RefPtr<Gst::MessageStateChanged>::cast_static(message);
            std::cout << "State: "
                      << Gst::Enums::get_name(state_msg->parse_old_state())
                      << " -> "
                      << Gst::Enums::get_name(state_msg->parse_new_state())
                      << std::endl;
            break;
        }
        default:
            break;
    }
    return true;
}

int main(int argc, char* argv[])
{
    Gst::init(argc, argv);

    Glib::RefPtr<Gst::Pipeline> pipeline = Gst::Pipeline::create("test");
    Glib::RefPtr<Gst::Element> source =
        Gst::ElementFactory::create_element("videotestsrc");
    Glib::RefPtr<Gst::Element> sink =
        Gst::ElementFactory::create_element("autovideosink");

    pipeline->add(source)->add(sink);
    source->link(sink);

    // Get bus and add watch
    Glib::RefPtr<Gst::Bus> bus = pipeline->get_bus();
    bus->add_watch(sigc::ptr_fun(&on_bus_message));

    // Alternative: use lambda
    // bus->add_watch([](const Glib::RefPtr<Gst::Bus>&,
    //                   const Glib::RefPtr<Gst::Message>& msg) {
    //     if (msg->get_message_type() == Gst::MESSAGE_EOS) {
    //         main_loop->quit();
    //     }
    //     return true;
    // });

    pipeline->set_state(Gst::STATE_PLAYING);
    main_loop = Glib::MainLoop::create();
    main_loop->run();

    pipeline->set_state(Gst::STATE_NULL);
    return 0;
}

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.