### Basic GStreamer Pipeline Initialization and Playback

Source: https://github.com/vladkol/gstreamer-netcore/blob/master/README.md

This C# code snippet demonstrates initializing GStreamer, parsing a pipeline from a URI, setting it to play, and waiting for completion or errors. Ensure GStreamer and its plugins are installed and accessible.

```csharp
using System;
using Gst; 

namespace GstreamerSharp
{
	class Program
	{
		public static void Main (string[] args)
		{
			// Initialize Gstreamer
			Application.Init(ref args);

			// Build the pipeline
			var pipeline = Parse.Launch("playbin uri=http://download.blender.org/durian/trailer/sintel_trailer-1080p.mp4");

			// Start playing
		
pipeline.SetState(State.Playing);

			// Wait until error or EOS
			var bus = pipeline.Bus;
			var msg = bus.TimedPopFiltered (Constants.CLOCK_TIME_NONE, MessageType.Eos | MessageType.Error);

			// Free resources
		
pipeline.SetState (State.Null);
		}
	}
}
```

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

### Clone and Build gstreamer-netcore Project

Source: https://github.com/vladkol/gstreamer-netcore/blob/master/README.md

Use these commands to clone the repository recursively and build the project using the dotnet CLI. Ensure you have .NET Core 3.1 or later installed.

```bash
git clone https://github.com/vladkol/gstreamer-netcore --recurse
cd gstreamer-netcore
dotnet build
```

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

### Define Custom Pad Capabilities with PadTemplate

Source: https://context7.com/vladkol/gstreamer-netcore/llms.txt

Use PadTemplate to define the capabilities a pad can expose. This example shows how to create a sink pad template that accepts raw RGBA video and subscribes to the PadCreatedEvent.

```csharp
using Gst;

// Create a sink pad template accepting raw RGBA video
var caps     = Caps.FromString("video/x-raw,format=RGBA");
var template = new PadTemplate("sink_%u", PadDirection.Sink, PadPresence.Request, caps);

Console.WriteLine($"Template name : {template.NameTemplate}");
Console.WriteLine($"Direction     : {template.Direction}");
Console.WriteLine($"Presence      : {template.Presence}");
Console.WriteLine($"Caps          : {template.Caps}");

// Subscribe to pad-created signal to track dynamic pad instantiation
template.PadCreatedEvent += (sender, padArgs) =>
{
    Console.WriteLine($"New pad created from template: {padArgs.Args[0]}");
};
```

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

### Create Pipeline Element by Name

Source: https://context7.com/vladkol/gstreamer-netcore/llms.txt

Use ElementFactory.Make to instantiate GStreamer elements by their factory name. Properties can be set using the indexer. This example also shows attaching a custom AppSink for video output.

```csharp
using Gst;
using Gst.App;

Application.Init(ref args);

var pipeline = new Gst.Pipeline("mypipeline");
var playbin  = ElementFactory.Make("playbin", "playbin");

if (playbin == null)
    throw new Exception("Could not create playbin element. Is GStreamer installed?");

// Set element properties using the indexer
playbin["uri"] = "https://dash.akamaized.net/akamai/bbb_30fps/bbb_30fps.mpd";

// Attach a custom AppSink as the video output
var videoSink = new AppSink("videoSink");
videoSink["caps"] = Caps.FromString("video/x-raw,format=RGBA");
videoSink.Drop    = true;
videoSink.Sync    = true;
videoSink.Qos     = true;

playbin["video-sink"] = videoSink;
pipeline.Add(playbin);

pipeline.SetState(State.Playing);
```

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

### Initialize GStreamer and Playback Pipeline in Avalonia

Source: https://context7.com/vladkol/gstreamer-netcore/llms.txt

Initializes GStreamer and sets up a playback pipeline using playbin and AppSink. Configure AppSink for raw RGBA output and set playback URI. This is suitable for GUI applications needing to render video frames.

```csharp
// In MainWindow initialization (Avalonia)
Gst.Application.Init();
GtkSharp.GstreamerSharp.ObjectManager.Initialize();

var pipeline  = new Gst.Pipeline("playback");
var playbin   = ElementFactory.Make("playbin", "playbin");
var videoSink = new AppSink("videoSink");

videoSink["caps"]          = Caps.FromString("video/x-raw,format=RGBA");
videoSink.Drop             = true;
videoSink.Sync             = true;
videoSink.Qos              = true;
videoSink.MaxBuffers       = 1;
videoSink.MaxLateness      = (1000 / 30) * 1_000_000L; // target ≥30 fps
videoSink.EnableLastSample = false;

playbin["video-sink"] = videoSink;
pipeline.Add(playbin);

// On render timer tick (up to 100 fps):
var sample = videoSink.TryPullSample(0); // non-blocking pull
if (sample != null)
{
    sample.Caps[0].GetInt("width",  out int width);
    sample.Caps[0].GetInt("height", out int height);

    using var buffer = sample.Buffer;
    MapInfo map;
    if (buffer.Map(out map, MapFlags.Read))
    {
        // GstFrameRenderer.UpdateImage copies raw bytes into a WriteableBitmap
        // map.CopyTo(bitmapLock.Address, bitmapLock.RowBytes * height)
        frameRenderer.UpdateImage(ref map, width, height);
        buffer.Unmap(map);
    }
    sample.Dispose();
}

// Start playback
playbin["uri"] = "file:///home/user/movie.mp4";
pipeline.SetState(State.Playing);
```

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

### Create a new .NET Core Console Project

Source: https://github.com/vladkol/gstreamer-netcore/blob/master/README.md

Use this command to create a new console application project for .NET Core.

```bash
dotnet new console
```

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

### Complex Multi-Branch Pipeline for Simultaneous Playback and Raw Sample Access

Source: https://context7.com/vladkol/gstreamer-netcore/llms.txt

Builds a pipeline with uridecodebin, tee elements, auto sinks for playback, and AppSink nodes for capturing raw audio (F32LE PCM) and video (RGBA) samples. Ensure GStreamer and GStreamer-Sharp are initialized.

```csharp
using Gst;
using Gst.App;

Application.Init(ref args);
GtkSharp.GstreamerSharp.ObjectManager.Initialize();

string source = "https://dash.akamaized.net/akamai/bbb_30fps/bbb_30fps.mpd";

var pipeline = Parse.Launch(
    $"uridecodebin uri=\"{source}\" name=dmux " +

    // --- Audio branch ---
    "dmux. ! queue ! audioconvert ! audio/x-raw,format=F32LE " +
        "! tee name=audioTee " +
            "audioTee. ! queue ! autoaudiosink " +           // live audio playback
            "audioTee. ! queue ! appsink name=audioSink " +  // raw PCM samples

    // --- Video branch (GPU color conversion) ---
    "dmux. ! queue ! videoconvert " +
        "! glupload ! glcolorconvert " +
        "! video/x-raw(memory:GLMemory),texture-target=2D,format=(string)RGBA ! gldownload " +
        "! tee name=videoTee " +
            "videoTee. ! queue ! autovideosink " +            // live video playback
            "videoTee. ! queue ! appsink name=videoSink");

// Wire up AppSink callbacks
var videoSink = ((Gst.Pipeline)pipeline).GetChildByName("videoSink") as AppSink;
videoSink.EmitSignals = true;
videoSink.Drop = true; videoSink.Sync = true; videoSink.Qos = true;
videoSink.NewSample += (sender, _) =>
{
    var sample = ((AppSink)sender).PullSample();
    if (sample == null) return;
    var cap = sample.Caps[0];
    cap.GetInt("width", out int w); cap.GetInt("height", out int h);
    MapInfo map;
    if (sample.Buffer.Map(out map, MapFlags.Read))
    {
        Console.WriteLine($"Video frame: {w}x{h}, {map.Size} bytes (RGBA)");
        sample.Buffer.Unmap(map);
    }
    sample.Dispose();
};

var audioSink = ((Gst.Pipeline)pipeline).GetChildByName("audioSink") as AppSink;
audioSink.EmitSignals = true;
audioSink.Drop = true; audioSink.Sync = true; audioSink.Qos = true;
audioSink.NewSample += (sender, _) =>
{
    var sample = ((AppSink)sender).PullSample();
    if (sample == null) return;
    sample.Caps[0].GetInt("rate", out int rate);
    sample.Caps[0].GetInt("channels", out int channels);
    MapInfo map;
    if (sample.Buffer.Map(out map, MapFlags.Read))
    {
        float[] pcm = new float[map.Size / sizeof(float)];
        System.Buffer.BlockCopy(map.Data, 0, pcm, 0, pcm.Length * sizeof(float));
        Console.WriteLine($"Audio chunk: {pcm.Length} F32LE samples @ {rate}Hz, {channels}ch");
        sample.Buffer.Unmap(map);
    }
    sample.Dispose();
};

var mainLoop = new GLib.MainLoop();
pipeline.Bus.AddSignalWatch();
pipeline.Bus.Message += (_, a) =>
{
    if (a.Message.Type == MessageType.Error)
    {
        a.Message.ParseError(out GLib.GException err, out string dbg);
        Console.WriteLine($"Error: {err.Message} | {dbg}");
        mainLoop.Quit();
    }
    else if (a.Message.Type == MessageType.Eos)
    {
        Console.WriteLine("EOS reached.");
        mainLoop.Quit();
    }
};

pipeline.SetState(State.Playing);
mainLoop.Run();
pipeline.SetState(State.Null);
```

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

### Create a new .NET Core Class Library

Source: https://github.com/vladkol/gstreamer-netcore/blob/master/README.md

If creating a class library, ensure it targets .NET Core 3.1 or later using this command.

```bash
dotnet new classlib -f netcoreapp3.1
```

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

### Initialize GStreamer Runtime

Source: https://context7.com/vladkol/gstreamer-netcore/llms.txt

Call Application.Init once before any other GStreamer API. This initializes the GStreamer runtime and bootstraps the native library mapper for automatic DLL resolution.

```csharp
using Gst;

class Program
{
    static void Main(string[] args)
    {
        // Initialize GStreamer (also triggers NativeLibMapper for .NET Core DLL resolution)
        Application.Init(ref args);

        // Now safe to use any Gst API
        var version = Gst.Version.String;
        Console.WriteLine($"GStreamer version: {version}");
    }
}
```

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

### Build Pipeline from String Description

Source: https://context7.com/vladkol/gstreamer-netcore/llms.txt

Use Parse.Launch to create a GStreamer pipeline from a description string, similar to gst-launch-1.0. Handles playback and error/EOS message processing.

```csharp
using Gst;

Application.Init(ref args);

// Launch a simple playbin pipeline for a remote DASH stream
var pipeline = Parse.Launch(
    "playbin uri=\"https://dash.akamaized.net/akamai/bbb_30fps/bbb_30fps.mpd\""
);

pipeline.SetState(State.Playing);

var bus = pipeline.Bus;
// Block until EOS or error
var msg = bus.TimedPopFiltered(Constants.CLOCK_TIME_NONE, MessageType.Eos | MessageType.Error);

if (msg.Type == MessageType.Error)
{
    msg.ParseError(out GLib.GException err, out string debug);
    Console.WriteLine($"Error: {err.Message} | Debug: {debug}");
}
else
{
    Console.WriteLine("Playback finished.");
}

pipeline.SetState(State.Null);
```

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

### Add GStreamer-Sharp NuGet Package

Source: https://github.com/vladkol/gstreamer-netcore/blob/master/README.md

Add the gstreamer-sharp-netcore NuGet package to your .NET Core application using this command.

```bash
dotnet add package gstreamer-sharp-netcore
```

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

### Zero-Copy Raw Buffer Transfer with MapInfo.CopyTo in C#

Source: https://context7.com/vladkol/gstreamer-netcore/llms.txt

The `MapInfo.CopyTo` extension method facilitates efficient, zero-copy transfer of GStreamer buffer data to a caller-supplied `IntPtr`. This is ideal for direct GPU uploads or shared-memory operations, avoiding managed heap allocations.

```csharp
using Gst;
using System.Runtime.InteropServices;

// Allocate unmanaged destination buffer
int frameBytes = width * height * 4; // RGBA
IntPtr dest = Marshal.AllocHGlobal(frameBytes);

try
{
    MapInfo map;
    if (gstBuffer.Map(out map, MapFlags.Read))
    {
        // Copies map.Size bytes from GStreamer native buffer to dest
        map.CopyTo(dest, frameBytes);
        gstBuffer.Unmap(map);
    }

    // dest now holds a raw RGBA frame — pass to GPU, write to file, etc.
}
finally
{
    Marshal.FreeHGlobal(dest);
}
```

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

### Extract Raw Video Frames with AppSink in C#

Source: https://context7.com/vladkol/gstreamer-netcore/llms.txt

Utilize `AppSink` to receive decoded media buffers directly. Subscribe to the `NewSample` event, pull samples, map buffers to access raw pixel data (e.g., RGBA), and process them.

```csharp
using Gst;
using Gst.App;

Application.Init(ref args);

var pipeline  = new Gst.Pipeline("raw-pipeline");
var playbin   = ElementFactory.Make("playbin", "playbin");
var videoSink = new AppSink("videoSink");

// Request RGBA frames
videoSink["caps"]  = Caps.FromString("video/x-raw,format=RGBA");
videoSink.EmitSignals = true;
videoSink.Drop     = true;
videoSink.Sync     = true;
videoSink.Qos      = true;

videoSink.NewSample += (sender, e) =>
{
    var sink   = (AppSink)sender;
    var sample = sink.PullSample();
    if (sample == null) return;

    var cap = sample.Caps[0];
    cap.GetInt("width",  out int width);
    cap.GetInt("height", out int height);
    cap.GetFraction("framerate", out int fpsNum, out int fpsDen);
    string fmt = cap.GetString("format"); // "RGBA"

    MapInfo map;
    if (sample.Buffer.Map(out map, MapFlags.Read))
    {
        // map.Data  — byte[] with raw RGBA pixels (width * height * 4 bytes)
        // map.DataPtr — IntPtr for unsafe/native interop
        // map.Size    — total byte count
        Console.WriteLine($"Frame {width}x{height} @ {fpsNum}/{fpsDen} fps, {map.Size} bytes");

        // Copy to unmanaged memory (e.g., for GPU upload):
        // map.CopyTo(unmanagedPtr, destinationSizeInBytes);

        sample.Buffer.Unmap(map);
    }
    sample.Dispose();
};

playbin["uri"]        = "https://dash.akamaized.net/akamai/bbb_30fps/bbb_30fps.mpd";
playbin["video-sink"] = videoSink;
pipeline.Add(playbin);

var mainLoop = new GLib.MainLoop();
pipeline.Bus.AddSignalWatch();
pipeline.Bus.Message += (_, a) =>
{
    if (a.Message.Type == MessageType.Eos || a.Message.Type == MessageType.Error)
        mainLoop.Quit();
};

pipeline.SetState(State.Playing);
mainLoop.Run();
pipeline.SetState(State.Null);
```

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

### Handle Pipeline Bus Messages in C#

Source: https://context7.com/vladkol/gstreamer-netcore/llms.txt

Use `AddSignalWatch` and the `Message` event on the pipeline's `Bus` to asynchronously receive and process pipeline events. This is suitable for event-loop-driven applications.

```csharp
using Gst;

Application.Init(ref args);
var pipeline = Parse.Launch("playbin uri=\"file:///home/user/video.mp4");
var mainLoop  = new GLib.MainLoop();

pipeline.Bus.AddSignalWatch();
pipeline.Bus.Message += (sender, msgArgs) =>
{
    switch (msgArgs.Message.Type)
    {
        case MessageType.StateChanged:
            msgArgs.Message.ParseStateChanged(out State old, out State next, out State pending);
            Console.WriteLine($"State: {old} -> {next} (pending: {pending})");
            break;

        case MessageType.Buffering:
            int pct = msgArgs.Message.ParseBuffering();
            Console.WriteLine($"Buffering: {pct}%");
            pipeline.SetState(pct < 100 ? State.Paused : State.Playing);
            break;

        case MessageType.DurationChanged:
            pipeline.QueryDuration(Format.Time, out long dur);
            Console.WriteLine($"Duration: {dur / Constants.SECOND}s");
            break;

        case MessageType.Tag:
            var tags = msgArgs.Message.ParseTag();
            Console.WriteLine($"Tags: {tags}");
            break;

        case MessageType.Error:
            msgArgs.Message.ParseError(out GLib.GException err, out string dbg);
            Console.WriteLine($"Error: {err.Message} ({dbg})");
            mainLoop.Quit();
            break;

        case MessageType.Eos:
            Console.WriteLine("End of stream.");
            mainLoop.Quit();
            break;
    }
};

pipeline.SetState(State.Playing);
mainLoop.Run();
pipeline.SetState(State.Null);
```

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