Discussion :

[geek-59600]

Bonsoir,

Depuis hier, j'essai de réaliser un screenshot de mon écran + affichage dans une fenêtre.

Je suis arrivé à faire une code fonctionnel mais d'une lenteur affligeante pour une API bas niveau.

Voici le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <stdlib.h> 
#include <stdio.h>
 
#include <X11/Xlib.h>
#include <X11/Xutil.h>
 
#include <time.h>
 
#define BLACK 	XBlackPixel(display,screen)
#define WHITE 	XWhitePixel(display,screen)
#define ROOT  	XDefaultRootWindow(display)
#define HEIGHT	DisplayHeight(display,screen)
#define WIDTH		DisplayWidth(display,screen)
 
int main()
	{
		sleep(3);
		Display*					display;
		Window						win2;
		XImage*						img;
		XEvent						ev;
		GC								gc;
		int           		screen;		
 
		display = XOpenDisplay(NULL);
		if (display == NULL)
			{
				printf ("!Open Display \n");
				exit -1;
			}
 
		screen = *(int*)DefaultScreenOfDisplay(display);
		gc=DefaultGC(display,screen);		
 
		printf ("Debut GET @ %ld \n",time(NULL));
		img = XGetImage(display,ROOT,0,0,WIDTH,HEIGHT,AllPlanes,XYPixmap);		
		printf ("Fin GET @ %ld \n",time(NULL));
 
		win2 = XCreateSimpleWindow(display,ROOT,0,0,WIDTH,HEIGHT,0,BLACK,WHITE);
		XSelectInput(display,win2,ExposureMask);
		XMapWindow(display,win2);
 
		while(1)
			{
				XNextEvent(display,&ev);
					if (ev.type == Expose)
						break;
			}
 
		printf ("Debut Put @ %ld \n",time(NULL));
		XPutImage(display,win2,gc,img,0,0,0,0,WIDTH,HEIGHT);	
		printf ("FIN Put @ %ld \n",time(NULL));
 
 
		XDestroyImage(img);
		XDestroyWindow(display,win2);
		XCloseDisplay(display);
		return 0;
	}

Le sleep(3) me laisse le temps de réduire la console.
Aprés soustraction des timestamps, j'obtient 3 ou 4 secondes pour XGetImage() et 8 pour XPutImage().

J'ai essayé de compiler avec l'option optimisation de gcc mais ce ne change rien.

Auriez vous une idée de la cause de cette lenteur, je sais que mon pc n'est pas de dernière jeunesse, Intel Celeron @ 2Ghz + 2Go de ram le tout tournant sur ubuntu 10.10 ?

Merci d'avance.
Bonne soirée.

[souviron34]

euh....


Plusieurs choses..

• D'abord tu utilises des printf, qui ne sont pas synchrones...
  
  Pour avoir une bonne synchronicité, utilise fprintf(stderr..)
  
  
• Pourquoi ne pas avoir déclaré screen comme un type Screen ??
  
  
• c'est int main (void) au minimum
  
  
• Pour évaluer le temps il faut se servir de clock()... (éventuellement de ma routine équivalente en temps absolu dans la section C->Sources->Gestion du temps)

Ensuite tu nous diras réellement ce qu'il en est....




Mais comme X est asynchrone (il gère des queues), les délais affichés ne sont pas les délais réels..

Pour voir le vrai temps mis, il faut mettre X en synchrone, via

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
XSynchronize (dpy, True);
XSync (dpy, .., False) ;
 
start = clock();
....
end = clock()
fprintf (stderr, "Temps",end-start);
 
XSynchronize (dpy, False);

[geek-59600]

Je reconnais que j'ai codé ca un peu à la barbare, j'ai modifié un peu et voici ce que j'ai fais.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <stdlib.h> 
#include <stdio.h>
 
#include <X11/Xlib.h>
#include <X11/Xutil.h>
 
#include <time.h>
 
#define BLACK 	XBlackPixel(display,*(int*)screen)
#define WHITE 	XWhitePixel(display,*(int*)screen)
#define ROOT  	XDefaultRootWindow(display)
#define HEIGHT	DisplayHeight(display,*(int*)screen)
#define WIDTH		DisplayWidth(display,*(int*)screen)
 
int main(void)
	{
		sleep(3);
		Display*					display;
		Window						win2;
		XImage*						img;
		XEvent						ev;
		GC								gc;
		Screen*        		screen;	
		clock_t						t1,t2,t3,t4;
 
		display = XOpenDisplay(NULL);
		if (display == NULL)
			{
				printf ("!Open Display \n");
				exit -1;
			}
 
		XSynchronize (display, True);
		XSync (display, False);
		screen = DefaultScreenOfDisplay(display);
		gc=DefaultGC(display,*(int*)screen);		
		t1 = clock();
		img = XGetImage(display,ROOT,0,0,WIDTH,HEIGHT,AllPlanes,XYPixmap);		
		t2 = clock();
		win2 = XCreateSimpleWindow(display,ROOT,0,0,WIDTH,HEIGHT,0,BLACK,WHITE);
		XSelectInput(display,win2,ExposureMask);
		XMapWindow(display,win2);
 
		while(1)
			{
				XNextEvent(display,&ev);
					if (ev.type == Expose)
						break;
			}
		t3 = clock();
		XPutImage(display,win2,gc,img,0,0,0,0,WIDTH,HEIGHT);	
		t4 = clock();
 
		printf ("GET : %f | PUT : %f \n",(t2-t1)/(double)CLOCKS_PER_SEC, (t4-t3)/(double)CLOCKS_PER_SEC);
		XSynchronize (display, False);
		XDestroyImage(img);
		XDestroyWindow(display,win2);
		XCloseDisplay(display);
		return 0;
	}

J'utilise toujours printf mais bon sachant que les valeurs sont récupérées au bon moment ca devrait ne pas changer le resultat j'imagine.

Voici la sortie :

GET : 0.000000 | PUT : 0.010000

Je trouve que pour le PUT c'est "léger" en chronométrant (via mon téléphone) l'affichage j'obtient +/- 8 secondes :s

Je n'y comprends plus rien