Capturer son écran avec l'API Win32 dans un fichier bmp

Hoy !
C'est la rentrée depuis maintenant deux semaines, et je n'ai plus vraiment la motivation pour m'attaquer à des sujets intéressants et qui ont besoin de beaucoup de pré-requis (qu'Ivanlef0u me pardonne, car je n'oublie pas ma mission sur CsrCallServer...).

Ce matin, m'ennuyant, j'ai mis une heure à me documenter sur les API Win32 pour réaliser un petit programme qui va balayer l'écran pour y enregistrer chaque pixel - de façon ordonnée, hein - dans un fichier bitmap.

Déjà, il faut savoir que le format bitmap est propre à Microsoft, mais cela n'empêche pas qu'il soit documenté et simple à comprendre. J'avais, par ailleurs, rédigé un document un peu bidon sur ce que j'en savais : http://venom630.free.fr/geo/divers/doc_bmp.txt.

Si on se sert de ça comme support à la compréhension du format, on élabore notre structure C sans broncher :

typedef struct {
DWORD dwSize;
WORD wRes1;
WORD wRes2;
DWORD dwOffset;
DWORD dwHeaderSize;
DWORD dwWidth;
DWORD dwHeight;
WORD wFoo;
WORD wBitsPerPixels;
DWORD dwCompressed;
DWORD dwBytesPerPixels;
DWORD dwBitsPerMetterOnWidth;
DWORD dwBitsPerMetterOnHeigt;
DWORD dwNumberOfColors;
DWORD dwImportantColors;
} BMPHDR, *PBMPHDR;

Il existe peut-être une structure déjà existante fournie par microsoft, mais je ne voulais pas chercher sur le net sachant que je serais allé bien plus vite en faisant ma propre structure.

Pour les déroutés : DWORD et WORD correspondent respectivement à des tailles de données sur 4 et 2 octets. Les préfixes dw et w correspondent à "double word" et "word", pour rendre le nom des champs plus logiques.

A noter que je n'ai pas mis le champ "mot magique" dans la structure, car celui-ci fait 2 octets, et si on le rajoute, la structure ne sera plus alignée sur 4 octets. C'est plutôt gênant quand on veut écrire/lire une structure en un coup. De plus, la mot magique est toujours égal à 'BM', soit 0x4244.

Enfin, on passe à la partie la plus intéressante : les fonctions fournies par l'API Win32 pour faire joujou.

Tout d'abord, il faut récupérer la résolution de l'écran. C'est faisable via la fonction GetSystemMetrics() : http://msdn.microsoft.com/en-us/library/ms724385%28VS.85%29.aspx.

Ces fonctions retournent respectivement la longueur et la largeur de l'écran :

#include <windows.h>
GetSystemMetrics(SM_CXSCREEN);
GetSystemMetrics(SM_CYSCREEN);

Ensuite, on a besoin d'avoir un "handle" sur la totalité de la surface de l'écran. Pour cela, on utilise la fonction GetDC() ("Get Device Context") : http://msdn.microsoft.com/en-us/library/dd144871%28VS.85%29.aspx. Si l'argument de la fonction est égal à NULL, le handle retourné concerne la fenêtre entière. Si on fourni, par contre, un argument handle de type "HWND", on aura un "handle" sur une fenêtre.

Avec cet handle sur l'écran, on peut utiliser la fonction magique GetPixel() fournie par la bibliothèque GDI32. GetPixel() : http://msdn.microsoft.com/en-us/library/dd144909%28VS.85%29.aspx.

Cette fonction, comme vous pouvez le voir, utilise trois arguments :
- le premier est le handle de notre "device context" ;
- le second correspond à l'abscisse du pixel ;
- le troisième correspond à son ordonnée.

Avec cette fonction, on va donc pouvoir lire chaque pixel à l'écran. Effectivement, on fera une double boucle for pour balayer chaque ligne et récupérer chaque valeur de pixel. Par ailleurs, GetPixel() retourne la valeur "RVB" du pixel. Et dans un fichier bitmap, un pixel est écrit sur trois octets : le premier correspond au taux de bleu, le second au taux de vert et le dernier au taux de rouge.

On peut donc imaginer une structure tenant sur trois octets :

typedef struct {
char bBlue, bGreen, bRed;
} PIXEL, *PPIXEL;

Enfin, pour ma part, j'ai enregistré les pixels "à la volée" dans le fichier, et j'ai utilisé la bibliothèque standard du C pour ouvrir mon bitmap et y déposer les pixels.

Pour résumer, voici le code que je suis parvenu à élaborer :

#include <windows.h>
#include <stdio.h>

size_t GetSizeFromDim(int x, int y);

typedef struct {
DWORD dwSize;
WORD wRes1;
WORD wRes2;
DWORD dwOffset;
DWORD dwHeaderSize;
DWORD dwWidth;
DWORD dwHeight;
WORD wFoo;
WORD wBitsPerPixels;
DWORD dwCompressed;
DWORD dwBytesPerPixels;
DWORD dwBitsPerMetterOnWidth;
DWORD dwBitsPerMetterOnHeigt;
DWORD dwNumberOfColors;
DWORD dwImportantColors;
} BMPHDR, *PBMPHDR;

typedef struct {
char bBlue, bGreen, bRed;
} PIXEL, *PPIXEL;


int main(int argc, char **argv) {

BMPHDR Hdr;
Hdr.dwSize = GetSizeFromDim(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
Hdr.wRes1 = 0x0000;
Hdr.wRes2 = 0x0000;
Hdr.dwOffset = 0x00000036;
Hdr.dwHeaderSize = 0x00000028;
Hdr.dwWidth = (DWORD)GetSystemMetrics(SM_CXSCREEN);
Hdr.dwHeight = (DWORD)GetSystemMetrics(SM_CYSCREEN);
Hdr.wFoo = 0x0001;
Hdr.wBitsPerPixels = 0x0018;
Hdr.dwCompressed = 0;
Hdr.dwBytesPerPixels = 0x00000004;
Hdr.dwBitsPerMetterOnWidth = 0;
Hdr.dwBitsPerMetterOnHeigt = 0;
Hdr.dwNumberOfColors = 0;
Hdr.dwImportantColors = 0;

WORD Sign = 0x4d42;

// Fichier de sortie
FILE *fout = fopen("foo.bmp","wb");
fwrite(&Sign, sizeof(WORD), 1, fout);
fwrite(&Hdr, sizeof(BMPHDR), 1, fout);



// Récupération du handle de l'écran
HDC ecran = GetDC(NULL);

// Lecture des pixels et enregistrement !
COLORREF Color;
PIXEL Pixel;
int i, j, k;

char bourrage = 0;

for(j = Hdr.dwHeight - 1; j >= 0; j--) {

// Un bmp part du bas, donc on lira les pixels à partir du bas
for(i = 0; i < Hdr.dwWidth; i++) {
Color = GetPixel(ecran, i, j);
Pixel.bBlue = GetBValue(Color);
Pixel.bGreen = GetGValue(Color);
Pixel.bRed = GetRValue(Color);

// Ecriture du pixel
fwrite(&Pixel, sizeof(PIXEL), 1, fout);
}
// On bourre
for(k = 0; k < (i % 4); k++)
fwrite(&bourrage, sizeof(char), 1, fout);
}

fclose(fout);

return 0;
}

size_t GetSizeFromDim(int x, int y) {
return sizeof(BMPHDR) + ((x*3 + (x%4))*y);
}

Vous trouverez la source propre et colorée à cette adresse : http://venom630.free.fr/geo/tools/GetSystemMetric_c.html.

Conclusion

J'avoue avoir été pressé dans mes explications. Mais je me suis dit que ça pouvait en intéresser plus de savoir comment pouvait fonctionner la capture d'écran sous Windows. Après, j'ignore si le code marche sous Vista ou s'il est véritablement portable. Mais une fois que vous comprenez l'algorithme, vous pouvez aisément faire votre propre code valide.

J'oubliais de préciser : pendant la compilation, n'oubliez pas de lier la lib gdi, sinon le compilateur vous dira qu'il ne trouve aucune référence à GetPixel() lors de l'édition de lien.

A la revoyure !

Geo