PhotoConfirmationCapturedEventArgs.Frame Propiedad

Definición

Espacio de nombres:

Windows.Media.Capture

Obtiene el marco capturado.

public:
 property CapturedFrame ^ Frame { CapturedFrame ^ get(); };

CapturedFrame Frame();

public CapturedFrame Frame { get; }

var capturedFrame = photoConfirmationCapturedEventArgs.frame;

Public ReadOnly Property Frame As CapturedFrame

Valor de propiedad

CapturedFrame

Marco capturado.

Comentarios

Los datos devueltos en la propiedad Frame son datos de píxeles sin procesar. En otras palabras, no incluye un encabezado de formato de archivo de imagen. Por este motivo, no se puede pasar directamente la secuencia del fotograma capturado al método SetSourceAsync del mapa de bits. En su lugar, debe copiar los datos de píxeles manualmente en el búfer de píxeles del mapa de bits. Los fragmentos de código siguientes muestran cómo copiar los datos de la imagen y proporcionar una clase auxiliar que realiza la operación.

En primer lugar, debes habilitar la confirmación de fotos y enlazar el evento PhotoConfirmationCaptured .

private void EnablePhotoConfirmation()
{
    _mediaCapture.VideoDeviceController.PhotoConfirmationControl.Enabled = true;
    _mediaCapture.PhotoConfirmationCaptured += PhotoConfirmationCaptured;
}

void PhotoConfirmationCaptured(MediaCapture sender, PhotoConfirmationCapturedEventArgs args)
{
    using (ManualResetEventSlim evt = new ManualResetEventSlim(false))
    {
        CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
        {
            try
            {
                WriteableBitmap bmp = new WriteableBitmap(unchecked((int)args.Frame.Width), unchecked((int)args.Frame.Height));
                using (var istream = args.Frame.AsStream())
                using (var ostream = bmp.PixelBuffer.AsStream())
                {
                    await istream.CopyStreamToAsync(ostream);
                }
            }
            finally
            {
                evt.Set();
            }

        });

        evt.Wait();
    }

}

El siguiente fragmento de código muestra la clase auxiliar que define los métodos de extensión para copiar los datos de fotograma capturados en el flujo de datos de píxeles del mapa de bits que se puede escribir. La clase proporciona métodos y sobrecargas sincrónicos y asincrónicos que permiten especificar un tamaño de búfer de copia o usar un tamaño predeterminado.

public static class StreamEx
{
    public static void CopyStreamTo(this Stream inputStream, Stream outputStream)
    {
        inputStream.CopyStreamTo(outputStream, 4096);
    }

    public static void CopyStreamTo(this Stream inputStream, Stream outputStream, int bufferSize)
    {
        if (inputStream == null)
        {
            throw new ArgumentNullException("inputStream");
        }

        if (!inputStream.CanSeek)
        {
            throw new ArgumentException("Cannot seek in the input stream.", "inputStream");
        }

        if (!inputStream.CanRead)
        {
            throw new ArgumentException("Input stream is not readable.", "inputStream");
        }

        if (outputStream == null)
        {
            throw new ArgumentNullException("outputStream");
        }

        if (!outputStream.CanSeek)
        {
            throw new ArgumentException("Cannot seek in the output stream.", "outputStream");
        }

        if (!outputStream.CanWrite)
        {
            throw new ArgumentException("Output stream is not writeable.", "outputStream");
        }

        if (bufferSize <= 0)
        {
            throw new ArgumentOutOfRangeException("bufferSize", "Buffer size is equal to zero or negative.");
        }

        inputStream.Seek(0, SeekOrigin.Begin);
        outputStream.Seek(0, SeekOrigin.Begin);

        byte[] buffer = new byte[bufferSize];
        while (inputStream.Position < inputStream.Length)
        {
            int bytesRead = inputStream.Read(buffer, 0, buffer.Length);
            outputStream.Write(buffer, 0, bytesRead);
        }
    }

    public static Task CopyStreamToAsync(this Stream inputStream, Stream outputStream)
    {
        return Task.Run(() => CopyStreamTo(inputStream, outputStream));
    }

    public static Task CopyStreamToAsync(this Stream inputStream, Stream outputStream, int bufferSize)
    {
        return Task.Run(() => CopyStreamTo(inputStream, outputStream, bufferSize));
    }
}