Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Dossier : Comment sont affichées les images d'un Amiga PAL sur un moniteur ?
(Article écrit par Nori - mars 2023)
|
|
Quoi ?
Ce petit article a pour but d'expliquer dans les grandes lignes la manière dont les moniteurs affichent
les images envoyées par l'Amiga. Il concerne les Amiga et moniteurs de type PAL. L'autre norme, appelée NTSC,
ne sera pas étudiée bien que le principe reste le même.
Pour qui ?
Cet article est destiné aux débutants.
Pourquoi ?
A quoi sert cet article me direz-vous ? Eh bien, je distingue deux raisons :
- La première est que connaître, même de manière générale, la façon dont est affichée une image vous
permettra de mieux comprendre comment l'Amiga répartit les temps d'exécution entre les différents composants
(microprocesseur 68000, coprocesseurs divers tels affichage, Blitter, Copper, lutins, etc.).
- La seconde est que lorsque vous atteindrez un niveau de programmation plus avancé (quel que soit le
langage), vous aurez besoin de ces notions pour pouvoir mieux appréhender les problèmes pour rendre un
affichage fluide des différents objets à l'écran (dans un jeu, démo ou autre).
Le principe
Bon, par quoi allons-nous débuter ? Eh bien, par le commencement.
Les premiers cinéastes ont remarqué qu'une vitesse de défilement des images de la pellicule entre 10 et 20
images par seconde suffisait à rendre un film tout juste acceptable pour le spectateur.
La norme fut ramenée à peu près à 25 images par seconde pour un confort augmenté (moins de scintillement).
Les téléviseurs ont repris ce principe mais en doublant la fréquence d'affichage (on passe de 25 à 50 Hz).
Les images sont affichées 50 fois par seconde, une seule image affichée durant 1/50e de seconde est appelée
"trame".
Une image complète de téléviseur est constituée de 625 lignes horizontales. Par contre, à l'époque, il
n'existait pas de solution technique bon marché pour afficher une image avec autant de lignes à une
fréquence si élevée. La bande passante est explosée. Les techniciens ont proposé une solution simple :
couper la poire en deux.
Concrètement, cela consiste à diviser verticalement l'image en deux. On affiche une ligne sur deux de la
même image à la suite. Le premier passage affiche les lignes impaires et le second les paires. Les deux
demi-images sont affichées suffisamment rapidement pour que notre cerveau "fusionne" ces deux demi-images
pour n'en faire qu'une.
La fréquence d'affichage réelle d'une image complète est donc de 25 Hz et horizontalement, on a 25x625,
ce qui fait approximativement 15 kHz.
Un moniteur CRT ou une vieille télé affiche une image de la sorte. A l'arrière de la télé part un faisceau
à électrons qui vient percuter un tube cathodique pour former un point lumineux sur la surface visible
de ce tube cathodique. Le faisceau à électrons balaye toute la surface de gauche à droite et de haut en bas,
ligne par ligne jusqu'à arriver en bas. Plus précisément, le faisceau balaye de gauche à droite, une fois
arrivé à l'extrémité droite de l'écran, il s'éteint puis revient rapidement à gauche (on appelle ce moment
le temps mort horizontal ou "horizontal blank" en anglais) mais en même temps il descend d'une ligne, se rallume et repart de plus belle, pour finalement arriver en bas à droite de l'écran. Le faisceau s'éteint et remonte dans le coin supérieur gauche (on appelle ce moment le temps mort vertical, ou la fameuse VBL) pour réafficher une nouvelle image. Ainsi de suite, 50 fois par seconde.
Il est à noter, qu'en réalité, il n'y a qu'un seul point qui est constamment affiché sur l'écran (hors temps mort),
balayant tout l'écran pour donner l'illusion de l'affichage d'une image.
Du concret
Vous voulez voir concrètement comment cela se passe ? Allez jeter un oeil ou deux à cette vidéo très
bien faite (l'auteur est The Slow Mo Guys) :
www.youtube.com/watch?v=3BJU2drrtCM.
Revenons à nos moutons. La première image affiche les lignes impaires durant 1/50e de seconde, la seconde
moitié affiche la même image, mais cette fois-ci les lignes paires durant 1/50e de seconde, ce qui prend
donc 1/25e de seconde pour afficher une image complète.
Note : si les deux trames sont différentes, on obtient une image plus fine verticalement mais qui
scintille fortement, c'est sur ce principe exact qu'est basé le mode graphique entrelacé ("interlace").
Demi-image lignes impaires
Demi-image lignes paires
Image complète tel que l'oeil la perçoit
Vous me direz, ça me fait une belle jambe de savoir ça, en quoi cela va m'aider à atteindre la sagesse qui
mène vers la maîtrise de la programmation Amiga ?
Eh bien, ce qui est intéressant, c'est que l'Amiga se synchronise sur ce système d'affichage. Dans le
cas contraire, ce serait un joyeux bordel.
Durant l'affichage d'une ligne, l'Amiga fait beaucoup de choses. Il rafraîchit la mémoire Chip, affiche
une ligne d'un lutin (s'il y en a un qui traverse cette ligne), affiche la ligne de l'écran (ça prend du
temps et même beaucoup), génère du son, le 68000 exécute ses instructions. Entre autres.
Sur une configuration sans réelle mémoire Fast, l'Amiga divise le temps que le faisceau à électrons met pour
afficher une ligne en 225 parties égales appelées cycles (en réalité, il y a très exactement 227,5 cycles par
ligne mais je n'ai cité que ceux hors temps mort horizontal). Les cycles impairs sont réservés aux DMA
(on expliquera plus en détails ce que sont les DMA dans un prochain article), le 68000 ne peut accéder
au bus que durant les cycles pairs. Pour faire simple, un bus est une espèce de réseau d'autoroutes
qui permet le transport des données entre les différents organes de la machine. Et encore, les cycles
pairs peuvent parfois être pris par un DMA, laissant le 68000 attendre encore plus longtemps.
Cette architecture peut paraître restrictive et compliquée (elle divise quand même par deux la vitesse du
processeur principal), mais elle est nécessaire car les coprocesseurs ont eux aussi besoin d'accéder au bus.
Verticalement, c'est aussi intéressant de connaître comment est affichée l'image sur Amiga.
Admettons que vous programmiez un jeu avec des objets graphiques qui bougent à l'écran. Si vous modifiez
ces images pendant que le faisceau à électrons passe sur cet objet, vous aurez un effet disgracieux qui se
matérialise par une espèce de déchirement de ces dits objets.
Il existe plusieurs méthodes pour palier à ça :
- La première est de ne redessiner ces objets que durant le temps mort vertical. Faisable, mais limité par le
nombre d'objets. Car s'il y en a trop, l'Amiga n'aura pas le temps de tous les afficher durant le temps mort
vertical.
- Deuxième méthode (celle utilisée par le programmeur du jeu Battle
Squadron, entre autres), on attend que le faisceau à électron soit juste en dessous de l'objet et on peut le
redessiner à ce moment.
- Troisième méthode, on effectue toutes les opérations graphiques dans une zone mémoire tampon en mémoire Chip
(une sorte de deuxième écran caché), puis on rend visible cette zone mémoire tampon lorsque toutes les opérations
sont finies et au moment du temps mort vertical (pour être plus exact, on indique à l'Amiga que désormais cette
zone tampon est l'écran visible). Cette troisième méthode est la plus utilisée par les programmeurs en assembleur.
Livres et liens
Pour compléter et approfondir vos connaissances dans ce domaine, voici quelques conseils de lecture :
- La Bible de l'Amiga © Micro Application (attention, il y a quelques erreurs dans certains articles).
- Amiga Hardware Manual Reference © Commodore.
- Stash of Code.
Eh bien, je crois que nous avons fini pour aujourd'hui. La prochaine fois, nous nous attaquerons à un
autre sujet : la programmation en assembleur d'un simple effet dégradé au Copper qui se déplace verticalement
(avec rotations des couleurs).
|
