Gérer affichage pixel par pixel

**Belinformatic** · 16/04/2012, 12h39

Bonjour à tous,

Connaissez-vous un moyen de gérer l’affichage des pixels de manière très poussée ?

Peut-on imaginer, par exemple :
- d’abord l’affichage des colonnes de pixels 1 à 10
- puis l’affichage des colonnes de pixels 21 à 30
- puis l’affichage des colonnes de pixels 11 à 20
- puis l’affichage des colonnes de pixels 31 à 40
- etc.

Merci d’avance pour vos idées.

zoé

**Obsidian** · 16/04/2012, 12h53

Bonjour,

Dans quel contexte et avec quel langage ?
Que comptes-tu faire exactement ?

**frp31** · 16/04/2012, 14h13

le plus évident est de piloter directement la carte vidéo, en assembleur avec les interruptions matérielles, mais c'est devenu impossible par la complexité des cartes modernes.

tu peux par contre tjrs écrire bitàbit ou pixel/pixel (3 "binary-words" donc (RGB)) dans la plage d'adressage de la mémoire vidéo de la "page-vidéo" que tu veux gérer.

ou encore plus simple avec un langage évolué, dans un espace sécurisé (dans une appli, donc limité à la fenêtre de celle ci), avec des fonctions du langages tout simplement...

bref plus on évolue plus c'est abstrait et donc plus on s'éloigne du matériel donc c'est plus simple à faire et à comprendre, mais du coup on est prisonnier des limites du langages et la fenêtre de l'application qu'on écrit.

**Belinformatic** · 16/04/2012, 14h39

Merci de vos réponses.

L'idée, ça serait de faire ça en dehors de toute application.
Que ce soit Linux (Ubuntu si possible) qui gère cet affichage personnalisé.
Pour que quelque soit l'application qui est lancée, l'affichage des pixels soit réorganisé comme je l'entends.

J'avais pensé à faire ça avec Xorg, mais j'ai l'impression que ça ne permet pas ce genre de configuration.

@frp31
Comment fait-on pour écrire dans la plage d'adressage de la mémoire vidéo d'une page vidéo ???
Y a-t-il une application pour gérer ça ? Un langage particulier sûrement ?

**frp31** · 16/04/2012, 15h17

Envoyé par Belinformatic

Merci de vos réponses.

@frp31
Comment fait-on pour écrire dans la plage d'adressage de la mémoire vidéo d'une page vidéo ???
Y a-t-il une application pour gérer ça ? Un langage particulier sûrement ?

bha deux solution attaquer directement le matériel en assembleur donc mais attention pas avec les interruptions systèmes (0x80) mais matérielles donc spécifiques à chaque famille de processeurs graphiques, ou sinon en langage évolué en C, il y a des fonctions pour faire ça via les interruptions systèmes pour ne pas subir les spécifications matérielles des constructeurs mais c'est bien sur plus lent..

les basses résolutions elle est à l'adresse 0x000A0000
pour les grandes résolutions cela dépend de ta carte
l'adresse... En général, la mémoire video est mappée dans les plages supérieures en mémoires (genre 0xE0000000). S'il y en a plusieurs, il faut donc les essayer.

ça pour ecran CRT surtout :
Pour gérer le balayage, et les résolutions, il faut communiquer avec ta carte (ports I/O). Certains standard on été établis pour cela par le passé. En conséquence les numéros de port et certaines interruptions logicielles comme l'int 10h (int du BIOS) sont les mêmes quelque soit la carte.

Sinon avec VESA, tu peux avoir accès aux hautes résolutions. C'est un standard. Cherche VBE2 ou VBE3 sur le net.

etc...etc... après c'est pas assez simple pour pouvoir te donner un exemple complet comme ça en quelques lignes...

http://www.cin.ufpe.br/~if817/arquiv...tut/index.html
http://asm.sourceforge.net/articles/....html#Syscalls

mais bon ça fait des plombes que j'ai plus fait de programmation alors.... te faire un exemple....

**frp31** · 16/04/2012, 18h18

J'ai retrouvé un exemple en assembler imbriqué dans du pascal

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
Procedure PutPixel (x,y,col:word);assembler;
asm
mov ax,0a000h {charge segment} 
mov es,ax
mov cx,x
and cx,3 {plan d ecriture (page)}
mov ax,1
shl ax,cl
mov ah,al 
mov dx,03c4h { registre 2 - write plane mask}
mov al, 2
out dx,ax
 
mov ax,80 { offset = Y*80+X/4}
mul y
mov di,ax
mov ax,x
shr ax,2
add di,ax {charge l offset}
mov al,byte ptr  col {charge la couleur}
mov es:[di],al {appel processeur de carte graphique : dessine pixel}
end;

code applicable pour toute carte VGA VESA

Issue de "Le meilleur de la programmation 3D" chez micro application
ISBN : 2-7329-*0719-X
1996

**Belinformatic** · 17/04/2012, 13h00

Je te remercie beaucoup, frp31, pour cette piste que tu me proposes.

Malheureusement, je t'avoue que pour moi, tout cela est très nouveau... Je vais dons étudier ça de près et voir si ça peut me convenir.

Juste une précision : ce code en assembleur, comment s'en sert-on ? Faut-il simplement l'exécuter au démarrage d'Ubuntu ?

**frp31** · 17/04/2012, 13h09

Envoyé par Belinformatic

Je te remercie beaucoup, frp31, pour cette piste que tu me proposes.

Malheureusement, je t'avoue que pour moi, tout cela est très nouveau... Je vais dons étudier ça de près et voir si ça peut me convenir.

Juste une précision : ce code en assembleur, comment s'en sert-on ? Faut-il simplement l'exécuter au démarrage d'Ubuntu ?

non là il est par exemple intégré comme une fonction dans un programme en PASCAL dans cet exemple.

donc si tu veux t'en servir au boot pour faire une petite animation ou pour dessiner tu peux créer une librairie en C, et lancer un petit programme qui l'appelle N fois, pour dessiner N pixels, et ce programme tu le lances dans les programmes de démarrage
ou tu ecris un MBR perso qui se substitue à grub et qui l'integre.

**Belinformatic** · 17/04/2012, 17h49

Merci pour ces précisions, ça devient un peu plus clair.

Mais le code que tu donnes en exemple, définit la couleur de chaque pixel, non ? Est-ce qu'il est également possible de changer l'ordre des pixels ?

Sinon, n'existe-t-il pas de moyen plus simple que de travailler directement dans la mémoire vidéo ? J'espérais qu'il existerait sous Linux un utilitaire qui puisse gérer l'afichage de façon très précise... Pas d'idée à ce niveau-là ?

**Obsidian** · 17/04/2012, 18h43

Bonjour,

Envoyé par Belinformatic

Sinon, n'existe-t-il pas de moyen plus simple que de travailler directement dans la mémoire vidéo ? J'espérais qu'il existerait sous Linux un utilitaire qui puisse gérer l'afichage de façon très précise... Pas d'idée à ce niveau-là ?

Encore une fois, si nos réponses sont imprécises, c'est parce que tes questions sont imprécises. Que cherches-tu à faire au final ?

Des utilitaires pour gérer l'affichage en long et en large, il en existe bien sûr, mais à tous les niveaux de programmation et d'exécution et pour des usages adaptés à chaque cas. Par exemple :

Tu travailles en mode graphique, donc avec X-Window (qui est le serveur graphique qui te permet — entre autre — d'utiliser le système de fenêtres). Si tu utilises la X-lib directement, tu as des primitives telles que XDrawPoint() qui te demandent ton serveur X, la fenêtre dans laquelle tu veux dessiner (ou l'écran entier) et les coordonnées x et y du pixel que tu veux allumer. De là, tu peux les traiter colonne par colonne si tu as envie (attention, c'est assez lent) ;
Si tu veux faire une application un peu plus bas niveau, comme du temps où on travaillait en mono-tâche pour faire facilement un petit jeu vidéo, par exemple, tu as la SDL. Après lui avoir demandé en bonne et due forme de t'allouer un buffer, elle te renverra un pointeur qui te permettra d'écrire directement dans la mémoire. Ce sera transparent pour toi mais, en réalité, chacun de tes accès sera contrôlé pour être envoyé au bon endroit sur l'écran (parce qu'en général, tu écris dans une fenêtre qui, elle-même, n'occupe qu'une position spécifique à l'écran) ;
Si tu demandes comment est, en soi, géré l'affichage vidéo d'un ordinateur, alors comme on te l'a dit, il s'agit d'un automate indépendant du micro-processeur, qui balaie la mémoire linéairement et qui, pour chaque groupe d'octet rencontré, traduit celui-ci en un pixel de couleur donnée.

Si tu veux approfondir encore, tu peux généralement, mais pas toujours, demander à ta carte vidéo de scanner la mémoire à partir d'un endroit particulier plutôt que recopier la zone à afficher au bon endroit. Mais ce n'est valable qu'à partir du moment où tu travailles en plein écran et qu'une seule et même application l'accapare en entier, ce qui n'est pour ainsi dire plus le cas aujourd'hui, sauf jeux vidéos et visionnages de films.

Certains ordinateurs tel que l'Amiga des années 1990 (1987 pour l'Amiga 500) était doté d'un processeur d'affichage graphique programmable appelée « Copper », rudimentaire mais très versatile et qui était synchronisé avec le balayage des écrans à tube cathodique de l'époque. On pouvait écrire une copperlist qui permettait de gérer l'affichage proprement dit de façon évoluée sans intervention du micro-processeur. Cela dit, ça ne permettait de ne travailler au mieux qu'au niveau de la ligne, ou d'une partie d'une ligne. Pas au niveau du pixel et, dans tous les cas, ça ne disait pas au hardware quels pixels de l'écran il fallait afficher en premier (il était toujours rafraîchi de haut en bas), mais où, en mémoire, aller chercher les informations qui correspondait à chacun d'eux, ce qui était déjà beaucoup.

Maintenant, dis-nous où tu veux en venir.