ImageHelper.cs

using SkiaSharp;
using RtspGStreamerLib;

namespace RtspGStreamerExample;

/// <summary>
/// Helper para conversão de VideoFrame para imagem usando SkiaSharp
/// Otimizado para ARM64 (Khadas VIM3) e multiplataforma
/// </summary>
public static class ImageHelper
{
    /// <summary>
    /// Converte VideoFrame (BGR) para SKBitmap
    /// IMPORTANTE: frame.Data está em formato BGR (3 bytes por pixel)
    /// </summary>
    public static SKBitmap VideoFrameToBitmap(VideoFrame frame)
    {
        // Criar bitmap com formato BGR (SkiaSharp suporta nativamente)
        var bitmap = new SKBitmap(frame.Width, frame.Height, SKColorType.Bgra8888, SKAlphaType.Opaque);

        // Obter ponteiro direto para os pixels (ZERO-COPY quando possível)
        IntPtr pixelsPtr = bitmap.GetPixels();

        // O frame.Data está em BGR (3 bytes), mas SKBitmap precisa de BGRA (4 bytes)
        // Vamos converter manualmente para máxima performance
        unsafe
        {
            byte* dst = (byte*)pixelsPtr;
            fixed (byte* src = frame.Data)
            {
                int srcIndex = 0;
                int dstIndex = 0;
                int totalPixels = frame.Width * frame.Height;

                // Loop otimizado - compilador vai vetorizar isso em ARM64
                for (int i = 0; i < totalPixels; i++)
                {
                    dst[dstIndex++] = src[srcIndex++]; // B
                    dst[dstIndex++] = src[srcIndex++]; // G
                    dst[dstIndex++] = src[srcIndex++]; // R
                    dst[dstIndex++] = 255;              // A (alpha = opaco)
                }
            }
        }

        return bitmap;
    }

    /// <summary>
    /// Salva VideoFrame como JPEG (alta performance)
    /// </summary>
    /// <param name="frame">Frame capturado</param>
    /// <param name="filePath">Caminho do arquivo (ex: "frame.jpg")</param>
    /// <param name="quality">Qualidade JPEG (0-100, padrão: 85)</param>
    public static void SaveAsJpeg(VideoFrame frame, string filePath, int quality = 85)
    {
        using var bitmap = VideoFrameToBitmap(frame);
        using var image = SKImage.FromBitmap(bitmap);
        using var data = image.Encode(SKEncodedImageFormat.Jpeg, quality);
        using var stream = File.OpenWrite(filePath);
        data.SaveTo(stream);
    }

    /// <summary>
    /// Salva VideoFrame como PNG (lossless)
    /// </summary>
    public static void SaveAsPng(VideoFrame frame, string filePath)
    {
        using var bitmap = VideoFrameToBitmap(frame);
        using var image = SKImage.FromBitmap(bitmap);
        using var data = image.Encode(SKEncodedImageFormat.Png, 100);
        using var stream = File.OpenWrite(filePath);
        data.SaveTo(stream);
    }

    /// <summary>
    /// Redimensiona frame mantendo aspect ratio
    /// Útil para reduzir processamento em detecção de objetos
    /// </summary>
    public static SKBitmap ResizeFrame(VideoFrame frame, int maxWidth, int maxHeight)
    {
        using var originalBitmap = VideoFrameToBitmap(frame);

        // Calcular novo tamanho mantendo aspect ratio
        float scale = Math.Min(
            (float)maxWidth / frame.Width,
            (float)maxHeight / frame.Height
        );

        int newWidth = (int)(frame.Width * scale);
        int newHeight = (int)(frame.Height * scale);

        // Resize com filtro de alta qualidade
        var resizedBitmap = originalBitmap.Resize(
            new SKImageInfo(newWidth, newHeight),
            SKFilterQuality.Medium // Medium é mais rápido que High, melhor que Low
        );

        return resizedBitmap;
    }

    /// <summary>
    /// Converte para escala de cinza (útil para detecção de movimento)
    /// MUITO MAIS RÁPIDO que processar BGR
    /// </summary>
    public static SKBitmap ToGrayscale(VideoFrame frame)
    {
        using var colorBitmap = VideoFrameToBitmap(frame);
        var grayBitmap = new SKBitmap(frame.Width, frame.Height, SKColorType.Gray8, SKAlphaType.Opaque);

        using var canvas = new SKCanvas(grayBitmap);
        using var paint = new SKPaint();

        // Aplicar filtro de escala de cinza
        paint.ColorFilter = SKColorFilter.CreateColorMatrix(new float[]
        {
            0.299f, 0.587f, 0.114f, 0, 0,  // R
            0.299f, 0.587f, 0.114f, 0, 0,  // G
            0.299f, 0.587f, 0.114f, 0, 0,  // B
            0,      0,      0,      1, 0   // A
        });

        canvas.DrawBitmap(colorBitmap, 0, 0, paint);
        return grayBitmap;
    }

    /// <summary>
    /// Desenha retângulos no frame (útil para mostrar detecções)
    /// </summary>
    public static void DrawRectangle(SKBitmap bitmap, int x, int y, int width, int height,
                                     SKColor color, int strokeWidth = 2)
    {
        using var canvas = new SKCanvas(bitmap);
        using var paint = new SKPaint
        {
            Style = SKPaintStyle.Stroke,
            Color = color,
            StrokeWidth = strokeWidth,
            IsAntialias = false // Desabilitar antialiasing para performance
        };

        canvas.DrawRect(x, y, width, height, paint);
    }

    /// <summary>
    /// Desenha texto no frame
    /// </summary>
    public static void DrawText(SKBitmap bitmap, string text, int x, int y,
                                SKColor color, float fontSize = 20)
    {
        using var canvas = new SKCanvas(bitmap);
        using var paint = new SKPaint
        {
            Color = color,
            TextSize = fontSize,
            IsAntialias = true,
            Typeface = SKTypeface.FromFamilyName("Arial")
        };

        canvas.DrawText(text, x, y, paint);
    }

    /// <summary>
    /// Extrai região de interesse (ROI) do frame
    /// Útil para processar apenas parte da imagem
    /// </summary>
    public static SKBitmap ExtractROI(VideoFrame frame, int x, int y, int width, int height)
    {
        using var fullBitmap = VideoFrameToBitmap(frame);

        var roi = new SKBitmap(width, height);
        var rect = new SKRect(x, y, x + width, y + height);
        var destRect = new SKRect(0, 0, width, height);

        using var canvas = new SKCanvas(roi);
        canvas.DrawBitmap(fullBitmap, rect, destRect);

        return roi;
    }

    /// <summary>
    /// Converte SKBitmap para byte[] BGR (para reprocessar com OpenCV, etc)
    /// </summary>
    public static byte[] BitmapToBGR(SKBitmap bitmap)
    {
        byte[] bgr = new byte[bitmap.Width * bitmap.Height * 3];

        unsafe
        {
            byte* src = (byte*)bitmap.GetPixels();
            fixed (byte* dst = bgr)
            {
                int srcIndex = 0;
                int dstIndex = 0;
                int totalPixels = bitmap.Width * bitmap.Height;

                for (int i = 0; i < totalPixels; i++)
                {
                    dst[dstIndex++] = src[srcIndex++]; // B
                    dst[dstIndex++] = src[srcIndex++]; // G
                    dst[dstIndex++] = src[srcIndex++]; // R
                    srcIndex++; // Pular alpha
                }
            }
        }

        return bgr;
    }
}