Comment prendre une capture d'écran de bureau rapide avec Java sous Windows (FFMPEG, etc.)?

Vous devrez utiliser JNI ou JNA pour appeler une combinaison de CreateCompatibleBitmap, XGetImage, DirectX ou OpenGL pour saisir une capture d'écran, puis copier des données bitmap brutes vers Java. Mon profilage a montré une vitesse d'environ 400% sur la classe de robots lors de l'accès aux données BitMap brutes sur X11. Je n'ai pas testé d'autres plates-formes pour le moment. Un code très précoce est disponible ici mais je n'ai pas eu beaucoup de temps pour y travailler récemment.

Utilisation de la classe de robots intégrée forte> est une voie plus facile que d'autres bibliothèques Java et devrait probablement correspondre à vos besoins.

Si vous avez besoin d'une vidéo lisse avec> = 30FPS (plus de 30 captures d'écran par Deuxièmement), vous devriez d'abord essayer les robots approche plus les améliorations de performance en utilisant stockage asynchrone des captures d'écran strong>. p>

Si cela ne fonctionne pas pour vous, essayez d'utiliser JNA strong> et c'est (même s'il est plus complexe) presque garanti de travailler pour la capture d'écran lisse. P>

approche avec des robots h2>

La classe des robots est en effet capable de faire ce que vous Vous voulez, la plupart des approches de capture d'écran avec des robots ont le problème, est la épargne forte> des captures d'écran. Une approche pourrait ressembler à celle-là: boucle sur la méthode CapturesCreen (), saisissant l'écran dans un bufferedimage, convertissez-la en une matrice d'octet et enregistrez-la avec un écrivain de fichier asynchrone à un fichier cible après avoir ajouté la référence future de votre image à la ArrayList Pour pouvoir continuer tout en stockant les données d'image. P>

import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferInt;
import java.awt.image.DataBufferUShort;
import java.awt.image.DirectColorModel;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;

import com.sun.jna.Native;
import com.sun.jna.platform.win32.W32API;
import com.sun.jna.win32.W32APIOptions;

public class JNAScreenShot
{

    public static BufferedImage getScreenshot(Rectangle bounds)
    {
        W32API.HDC windowDC = GDI.GetDC(USER.GetDesktopWindow());
        W32API.HBITMAP outputBitmap = GDI.CreateCompatibleBitmap(windowDC, bounds.width, bounds.height);
        try
        {
            W32API.HDC blitDC = GDI.CreateCompatibleDC(windowDC);
            try
            {
                W32API.HANDLE oldBitmap = GDI.SelectObject(blitDC, outputBitmap);
                try
                {
                    GDI.BitBlt(blitDC, 0, 0, bounds.width, bounds.height, windowDC, bounds.x, bounds.y, GDI32.SRCCOPY);
                }
                finally
                {
                    GDI.SelectObject(blitDC, oldBitmap);
                }
                GDI32.BITMAPINFO bi = new GDI32.BITMAPINFO(40);
                bi.bmiHeader.biSize = 40;
                boolean ok = GDI.GetDIBits(blitDC, outputBitmap, 0, bounds.height, (byte[]) null, bi, GDI32.DIB_RGB_COLORS);
                if (ok)
                {
                    GDI32.BITMAPINFOHEADER bih = bi.bmiHeader;
                    bih.biHeight = -Math.abs(bih.biHeight);
                    bi.bmiHeader.biCompression = 0;
                    return bufferedImageFromBitmap(blitDC, outputBitmap, bi);
                }
                else
                {
                    return null;
                }
            }
            finally
            {
                GDI.DeleteObject(blitDC);
            }
        }
        finally
        {
            GDI.DeleteObject(outputBitmap);
        }
    }

    private static BufferedImage bufferedImageFromBitmap(GDI32.HDC blitDC, GDI32.HBITMAP outputBitmap, GDI32.BITMAPINFO bi)
    {
        GDI32.BITMAPINFOHEADER bih = bi.bmiHeader;
        int height = Math.abs(bih.biHeight);
        final ColorModel cm;
        final DataBuffer buffer;
        final WritableRaster raster;
        int strideBits = (bih.biWidth * bih.biBitCount);
        int strideBytesAligned = (((strideBits - 1) | 0x1F) + 1) >> 3;
        final int strideElementsAligned;
        switch (bih.biBitCount)
        {
            case 16:
                strideElementsAligned = strideBytesAligned / 2;
                cm = new DirectColorModel(16, 0x7C00, 0x3E0, 0x1F);
                buffer = new DataBufferUShort(strideElementsAligned * height);
                raster = Raster.createPackedRaster(buffer, bih.biWidth, height, strideElementsAligned, ((DirectColorModel) cm).getMasks(), null);
                break;
            case 32:
                strideElementsAligned = strideBytesAligned / 4;
                cm = new DirectColorModel(32, 0xFF0000, 0xFF00, 0xFF);
                buffer = new DataBufferInt(strideElementsAligned * height);
                raster = Raster.createPackedRaster(buffer, bih.biWidth, height, strideElementsAligned, ((DirectColorModel) cm).getMasks(), null);
                break;
            default:
                throw new IllegalArgumentException("Unsupported bit count: " + bih.biBitCount);
        }
        final boolean ok;
        switch (buffer.getDataType())
        {
            case DataBuffer.TYPE_INT:
            {
                int[] pixels = ((DataBufferInt) buffer).getData();
                ok = GDI.GetDIBits(blitDC, outputBitmap, 0, raster.getHeight(), pixels, bi, 0);
            }
                break;
            case DataBuffer.TYPE_USHORT:
            {
                short[] pixels = ((DataBufferUShort) buffer).getData();
                ok = GDI.GetDIBits(blitDC, outputBitmap, 0, raster.getHeight(), pixels, bi, 0);
            }
                break;
            default:
                throw new AssertionError("Unexpected buffer element type: " + buffer.getDataType());
        }
        if (ok)
        {
            return new BufferedImage(cm, raster, false, null);
        }
        else
        {
            return null;
        }
    }

    private static final User32 USER = User32.INSTANCE;

    private static final GDI32 GDI = GDI32.INSTANCE;

}

interface GDI32 extends com.sun.jna.platform.win32.GDI32
{
    GDI32 INSTANCE = (GDI32) Native.loadLibrary(GDI32.class);

    boolean BitBlt(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HDC hdcSrc, int nXSrc, int nYSrc, int dwRop);

    HDC GetDC(HWND hWnd);

    boolean GetDIBits(HDC dc, HBITMAP bmp, int startScan, int scanLines, byte[] pixels, BITMAPINFO bi, int usage);

    boolean GetDIBits(HDC dc, HBITMAP bmp, int startScan, int scanLines, short[] pixels, BITMAPINFO bi, int usage);

    boolean GetDIBits(HDC dc, HBITMAP bmp, int startScan, int scanLines, int[] pixels, BITMAPINFO bi, int usage);

    int SRCCOPY = 0xCC0020;
}

interface User32 extends com.sun.jna.platform.win32.User32
{
    User32 INSTANCE = (User32) Native.loadLibrary(User32.class, W32APIOptions.UNICODE_OPTIONS);

    HWND GetDesktopWindow();
}

connaissez-vous Xuggler? Il utilise FFMPEG pour le codage et le décodage. J'ai appris à le savoir il y a quelques mois lorsque je devais extraire des cadres d'une vidéo et cela fonctionnait bien.

sur le site officiel, vous pouvez trouver quelques exemples, y compris celui appelé "capturesCreentofile.java". Pour plus d'informations, suivez ces liens:

http://www.xuggle.com/xuggler/

https://github.com/ ArtClarke / Xugue-Xuggler / Tree / Master / SRC / com / Xugier / Xuggler / Démos

Selon l'officiel Documentation FFMPEG Vous devriez être capable de le garder jolie plate-forme croisée Si vous effectuez le paramètre fichier transmis au ffmpegframegrabber (qui est vraiment un paramètre transmis comme le -i < / Code> Option à FFMPEG) Adhérer au formats différents chaque périphérique s'attend à ce que .

IE:

pour Windows: dshow attend -i vidéo = "enregistreur-capture d'écran"

pour OSX: AVFoundation attend -I "":

et pour Linux: x11grab attend -I: + , . .

Donc, simplement passer ces valeurs (arguments à -i ) au constructeur et régler le format (via setformat ) devrait donc faire le tour.