### Using a Custom Frame Processor

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Example of opening a capture device with a custom frame processor and processing the captured frames.

```csharp
var devices = new CaptureDevices();
var descriptor0 = devices.EnumerateDevices().ElementAt(0);

// Open by specifying our frame processor.
using var device = await descriptor0.OpenWitFrameProcessorAsync(
  descriptor0.Characteristics[0],
  TranscodeFormats.Auto,
  new CoolFrameProcessor(buffer =>   // Using our frame processor.
  {
    // Captured pixel buffer is passed.
    var image = buffer.ReferImage();

    // Perform decode.
    var bitmap = Bitmap.FromStream(image.AsStream());

    // ...
  }));

await device.StartAsync();

// ...
```

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

### Capture Video Frames with Callback

Source: https://github.com/kekyo/flashcap/blob/main/README.md

This code demonstrates how to open a capture device, specify video characteristics, and process captured frames using a callback function. The captured image data can be extracted as a byte array and used to create a bitmap. Remember to start and stop the device processing.

```csharp
// Open a device with a video characteristics:
var descriptor0 = devices.EnumerateDescriptors().ElementAt(0);

using var device = await descriptor0.OpenAsync(
    descriptor0.Characteristics[0],
    async bufferScope =>
    {
        // Captured into a pixel buffer from an argument.

        // Get image data (Maybe DIB/JPEG/PNG):
        byte[] image = bufferScope.Buffer.ExtractImage();

        // Anything use of it...
        var ms = new MemoryStream(image);
        var bitmap = Bitmap.FromStream(ms);

        // ...
    });

// Start processing:
await device.StartAsync();

// ...

// Stop processing:
await device.StopAsync();
```

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

### Enumerate Capture Devices and Video Characteristics

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Use this snippet to list available capture devices and their supported video formats (resolution, codec, frame rate). Ensure the FlashCap NuGet package is installed.

```csharp
using FlashCap;

// Capture device enumeration:
var devices = new CaptureDevices();

foreach (var descriptor in devices.EnumerateDescriptors())
{
    // "Logicool Webcam C930e: DirectShow device, Characteristics=34"
    // "Default: VideoForWindows default, Characteristics=1"
    Console.WriteLine(descriptor);

    foreach (var characteristics in descriptor.Characteristics)
    {
        // "1920x1080 [JPEG, 30fps]"
        // "640x480 [YUYV, 60fps]"
        Console.WriteLine(characteristics);
    }
}
```

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

### Capture Video Frames with Rx.NET Observable

Source: https://github.com/kekyo/flashcap/blob/main/README.md

This snippet shows how to use FlashCap with Rx.NET to capture video frames. It converts a capture device into an observable sequence, allowing you to subscribe to frame capture events and process them asynchronously. Ensure you start and stop the observable device.

```csharp
// Get a observable with a video characteristics:
var descriptor0 = devices.EnumerateDescriptors().ElementAt(0);

using var deviceObservable = await descriptor0.AsObservableAsync(
    descriptor0.Characteristics[0]);

// Subscribe the device.
deviceObservable.Subscribe(bufferScope =>
{
    // Captured into a pixel buffer from an argument.

    // Get image data (Maybe DIB/JPEG/PNG):
    byte[] image = bufferScope.Buffer.ExtractImage();

    // Anything use of it...
    var ms = new MemoryStream(image);
    var bitmap = Bitmap.FromStream(ms);

    // ...
});

// Start processing:
await deviceObservable.StartAsync();
```

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

### Configure Callback Handler Trigger in FlashCap

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Specify the trigger for invoking the handler using isScattering and maxQueuingFrames. This example sets scattering to true and allows up to 10 queuing frames.

```csharp
// Specifies the trigger for invoking the handler:
using var device = await descriptor0.OpenAsync(
  descriptor0.Characteristics[0],
  TranscodeFormats.Auto,
  true,   // Specifying the invoking trigger (true: Scattering)
  10,     // Maximum number of queuing frames
  async buferScope =>
  {
      // ...
  });

// ...
```

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

### Safest Image Copy with CopyImage()

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Demonstrates using CopyImage() to get a byte array of the frame data. This method ensures data safety for out-of-scope references but results in at least two copies.

```csharp
using var device = await descriptor0.OpenAsync(
  descriptor0.Characteristics[0],
  async bufferScope =>  // <-- `PixelBufferScope` (already copied once at this point)
  {
    // This is where the second copy occurs.
    byte[] image = bufferScope.Buffer.CopyImage();

    // Convert to Stream.
    var ms = new MemoryStream(image);
    // Consequently, a third copy occurs here.
    var bitmap = Bitmap.FromStream(ms);

    // ...
  });
```

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

### Using a Custom Buffer Pool with CaptureDevices

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Instantiate a custom BufferPool implementation and pass it to the CaptureDevices constructor. This allows FlashCap to use your custom pooling strategy for all enumerated devices.

```csharp
// Create and use a buffer pooling instance.
var bufferPool = new FakeBufferPool();

var devices = new CaptureDevices(bufferPool);

// ...

```

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

### Display Camera Device Property Page

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Illustrates how to open a camera device and display its property page if supported. Requires a valid window handle for the parent window, and currently only works for DirectShow devices.

```csharp
using var device = await descriptor.OpenAsync(
    characteristics,
    async bufferScope =>
    {
        // ...
    });

// if the camera device supports property pages
if (device.HasPropertyPage)
{
    // Get parent window handle from Avalonia window
    if (this.window.TryGetPlatformHandle()?.Handle is { } handle)
    {
        // show the camera device's property page
        await device.ShowPropertyPageAsync(handle);
    }
}
```

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

### Take a Single Image with FlashCap

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Demonstrates how to capture a single image from a camera device and save it to a file. Ensure you have enumerated descriptors and selected characteristics beforehand.

```csharp
// Take only one image, given the image characteristics:
var descriptor0 = devices.EnumerateDescriptors().ElementAt(0);

byte[] imageData = await descriptor0.TakeOneShotAsync(
    descriptor0.Characteristics[0]);

// Save to file
await File.WriteAllBytesAsync("oneshot", imageData);
```

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

### Fast Image Reference with ReferImage()

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Demonstrates using ReferImage() for fast access to image data with minimal copying, returning an ArraySegment<byte>. Out-of-scope references are dangerous, and the data is not directly usable as a byte array.

```csharp
using var device = await descriptor0.OpenAsync(
  descriptor0.Characteristics[0],
  async bufferScope =>  // <-- `PixelBufferScope` (already copied once at this point)
  {
    // Basically no copying occurs here.
    ArraySegment<byte> image =
      bufferScope.Buffer.ReferImage();

    // Convert to Stream.
    var ms = new MemoryStream(
      image.Array, image.Offset, image.Count);
    // Decode (Second copy)
    var bitmap = Bitmap.LoadFrom(ms);

    // ...
  });
```

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

### Add Platform Branch to V4L2 Interop

Source: https://github.com/kekyo/flashcap/blob/main/README.md

This code snippet shows how to extend the NativeMethods_V4L2.cs file to include a new platform branch in the type initializer's switch statement. This is necessary when porting FlashCap to a new architecture.

```csharp
switch (buf.machine)
{
    case "x86_64":
    case "amd64":
    case "i686":
    case "i586":
    case "i486":
    case "i386":
        Interop = IntPtr.Size == 8 ?
            new NativeMethods_V4L2_Interop_x86_64() :
            new NativeMethods_V4L2_Interop_i686();
        break;
    case "aarch64":
    case "armv9l":
    case "armv8l":
    case "armv7l":
    case "armv6l":
        Interop = IntPtr.Size == 8 ?
            new NativeMethods_V4L2_Interop_aarch64() :
            new NativeMethods_V4L2_Interop_armv7l();
        break;
    case "mips":
    case "mipsel":
        Interop = new NativeMethods_V4L2_Interop_mips();
        break;
    case "loongarch64":
        Interop = new NativeMethods_V4L2_Interop_loongarch64();
        break;

    // (Insert your cool platform ported interop...)

    default:
        throw new InvalidOperationException(
            $"FlashCap: Architecture '{buf.machine}' is not supported.");
}
```

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

### Image Copy with ExtractImage()

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Shows using ExtractImage() which may avoid a second copy in some cases. However, the data's validity period is short, making out-of-scope references dangerous.

```csharp
using var device = await descriptor0.OpenAsync(
  descriptor0.Characteristics[0],
  async bufferScope =>  // <-- `PixelBufferScope` (already copied once at this point)
  {
    // This is where the second copy (may) occur.
    byte[] image = bufferScope.Buffer.ExtractImage();

    // Convert to Stream.
    var ms = new MemoryStream(image);
    // Decode. Consequently, a second or third copy occurs here.
    var bitmap = Bitmap.FromStream(ms);

    // ...
  });
```

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

### BufferPool Base Class Definition

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Defines the abstract base class for buffer pooling in FlashCap. Implement Rent to provide a buffer and Return to reclaim it.

```csharp
// Base class for buffer pooling.
public abstract class BufferPool
{
  protected BufferPool()
  { /* ... */ }

  // Get the buffer.
  public abstract byte[] Rent(int minimumSize);

  // Release the buffer.
  public abstract void Return(byte[] buffer);
}
```

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

### Exclude Unsupported Pixel Formats

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Shows how to filter camera characteristics to exclude formats that FlashCap does not support, identified by PixelFormats.Unknown. This ensures compatibility before opening a device.

```csharp
// Select a device:
var descriptor0 = devices.EnumerateDescriptors().ElementAt(0);

// Exclude unsupported formats:
var characteristics = descriptor0.Characteristics.
    Where(c => c.PixelFormat ! = PixelFormats.Unknown).
    ToArray();
```

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

### FakeBufferPool Implementation

Source: https://github.com/kekyo/flashcap/blob/main/README.md

A simple, non-pooling implementation of BufferPool that always creates new byte arrays. Useful for testing or scenarios where buffer pooling is not strictly necessary.

```csharp
public sealed class FakeBufferPool : BufferPool
{
    public override byte[] Rent(int minimumSize) =>
        // Always generate a buffer.
        new byte[minimumSize];

    public override void Return(byte[] buffer)
    {
        // (Unfollow the `buffer` reference and let the GC collect it.)
    }
}
```

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

### Custom Frame Processor Implementation

Source: https://github.com/kekyo/flashcap/blob/main/README.md

A typical implementation of a custom frame processor that captures pixel data and invokes a delegate.

```csharp
public sealed class CoolFrameProcessor : FrameProcessor
{
  private readonly Action<PixelBuffer> action;

  // Hold a delegate to run once captured.
  public CoolFrameProcessor(Action<PixelBuffer> action) =>
    this.action = action;

  // Called when a frame is arrived.
  public override void OnFrameArrived(
    CaptureDevice captureDevice,
    IntPtr pData, int size, long timestampMicroseconds, long frameIndex)
  {
    // Get a pixel buffer.
    var buffer = base.GetPixelBuffer();

    // Perform capture.
    // Image data is stored in pixel buffer. (First copy occurs.)
    base.Capture(
      captureDevice,
      pData, size,
      timestampMicroseconds, frameIndex,
      buffer);

    // Invoke a delegate.
    this.action(buffer);

    // Return the pixel buffer (optional, will reuse allocated buffer)
    base.ReleasePixelBuffer(buffer);
  }
}
```

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

### Save Image Data Directly to File

Source: https://github.com/kekyo/flashcap/blob/main/README.md

This C# snippet demonstrates saving image data directly to a file without decoding. It opens a device, accesses the image buffer, and writes it to a file based on the pixel format. Copying is minimized within the buffer scope.

```csharp
using var device = await descriptor0.OpenAsync(
  descriptor0.Characteristics[0],
  async bufferScope =>  // <-- `PixelBufferScope` (already copied once at this point)
  {
    // Basically no copying occurs here.
    ArraySegment<byte> image = bufferScope.Buffer.ReferImage();

    // Output image data directly to a file.
    using var fs = File.Create(
      descriptor0.Characteristics[0].PixelFormat switch
      {
        PixelFormats.JPEG => "output.jpg",
        PixelFormats.PNG => "output.png",
        _ => "output.bmp",
      });
    await fs.WriteAsync(image.Array, image.Offset, image.Count);
    await fs.FlushAsync();
  });
```

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

### Disable Transcoding in FlashCap

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Open a device with transcoding disabled to handle YUV formats as raw data. This ensures copying occurs only once.

```csharp
using var device = await descriptor0.OpenAsync(
  descriptor0.Characteristics[0],
  TranscodeFormats.DoNotTranscode,   // Do not transcode.
  async buferScope =>
  {
      // ...
  });

// ...
```

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

### Projecting Image Data from Pixel Buffer

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Use the Select operator to immediately project image data from a pixel buffer. This is useful for ensuring image data is extracted before the buffer expires, especially when using reactive extensions.

```csharp
deviceObservable.
    // Immediately projection
    Select(bufferScope =>
        Bitmap.FromStream(bufferScope.Buffer.ReferImage().AsStream())).
    // Do whatever you want after that...
    // ...
```

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

### FlashCap FrameProcessor Base Class

Source: https://github.com/kekyo/flashcap/blob/main/README.md

The abstract base class for custom frame processors. You must implement the OnFrameArrived method.

```csharp
public abstract class FrameProcessor : IDisposable
{
  // Implement if necessary.
  public virtual void Dispose()
  {
  }

  // Get a pixel buffer.
  protected PixelBuffer GetPixelBuffer()
  {
    /* ... */
  }

  // Return the pixel buffer.
  public void ReleasePixelBuffer(PixelBuffer buffer)
  {
    /* ... */
  }

  // Perform capture using the device.
  protected void Capture(
    CaptureDevice captureDevice,
    IntPtr pData, int size,
    long timestampMicroseconds, long frameIndex,
    PixelBuffer buffer)
  {
    /* ... */
  }

  // Called when a frame is arrived.
  public abstract void OnFrameArrived(
    CaptureDevice captureDevice,
    IntPtr pData, int size, long timestampMicroseconds, long frameIndex);
}
```

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

### Saving Image Data Outside Callback Scope

Source: https://github.com/kekyo/flashcap/blob/main/README.md

Illustrates saving image data to a variable outside the callback scope using CopyImage(). Using ExtractImage() here is dangerous due to the short validity of the data.

```csharp
// Stores image data outside the scope of the callback.
byte[]? image = null;

using var device = await descriptor0.OpenAsync(
  descriptor0.Characteristics[0],
  bufferScope =>  // <-- `PixelBufferScope` (already copied once at this point)
  {
    // Save out of scope. (second copy)
    image = bufferScope.Buffer.CopyImage();
    //image = bufferScope.ExtractImage();  // DANGER!!!
  });

// Use outside of scope.
var ms = new MemoryStream(image);
// Decode (Third copy)
var bitmap = Bitmap.FromStream(ms);
```

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