| ★ CODING ★ ANTIBUG ★ STRUCTURE DE LA MÉMOIRE ÉCRAN DE L'AMSTRAD CPC PAR ANTIBUG ★ |
| Structure de la mémoire écran de l'Amstrad CPC par ANTIBUG | Coding Antibug |
Rappel sur les modes graphiques supportés par le CPC
1 - Structure de la mémoire La taille de la mémoire graphique, rappelons-le, fait 16 ko. Chaque ligne est entrelacée avec les autres et la largeur d'une ligne fait 80 caractères (octets).
2 - Calcul de l'adresse de base d'un pixel Comme vous avez pu le constater, pour passer de la ligne 0 à la ligne 1 on ajoute &800 à l'adresse de base et pour passer de la ligne 0 à la ligne 8 on ajoute &50. Les lignes sont regroupées par série de 8 lignes consécutives. A chaque nouvelle série de lignes on ajoute &50 à l'adresse vidéo, de base (&C000 dans notre exemple). Pourquoi &50 ? Tout simplement parce que la largeur de chaque ligne fait 80 octets (&50). La notion de « série de lignes » vient du fait que la mémoire vidéo est organisée ainsi. 2.1 Adresse de base d'une ligne vidéo Pour retrouver l'adresse de base d'une ligne ce n'est pas compliqué. Par exemple nous voulons retrouver l'adresse de la ligne 5 : [Adresse de base de la ligne] = &C000 + (&800 * 5) Dans le cas d'une ligne d'une série différente, il faudra prendre en compte le décalage de &50 dû au fait d'un changement de série ; pour cela ce n'est pas très compliqué, on sait que chaque série fait 8 lignes, de 0 à 7 pour la première série, de 8 à 15 pour la seconde, etc. Pour retrouver l'adresse de base de la ligne 12, par exemple, il faut d'abord savoir combien de série de lignes on a passé puis calculer le numéro de la ligne dans la série. Explication par le concret : [Numéro de la série de lignes] = (n° de ligne \ 8) [Numéro de la ligne dans la série] = (n° de ligne MOD 8) Ou, pour la ligne 21 : [Numéro de la série] = (21 \ 8) = 2 [Numéro de la ligne dans la série] = (21 MOD 8) = 5 Ce qui nous donne : Série 2 5ème ligne Maintenant pour calculer l'adresse de base de la ligne 21, on calcule son adresse de basse en fonction du n° de sa série puis on ajoute son décalage par rapport à l'adresse de la série, démonstration : [Adresse de base de la série] = [Adresse vidéo] + (n° de la série * &50) [Adresse de base de la ligne] = [Adresse de base de la série] + (&800 * n° de la ligne) Ce qui donne : [Adresse de base de la série] = &C000 + (2 * &50) = &C0A0 [Adresse de base de la ligne] = [Adresse de la série] + (&800 * 5) = &C0A0 + &2000 = &E0A0 2.2 Adresse d'un point aux coordonnées (X, Y) Pour retrouver l'adresse d'un point au coordonnées (X, Y) il suffit de prendre l'adresse de base de sa ligne vidéo Y et d'y ajouter son décalage X. Attention ! Le décalage en fonction de X dépend du mode graphique. ; - En mode 0 le décalage en fonction de X est égal à (X \ 2) car 2 pixels par octet. Exemple pour le point aux coordonnées (8, 21) en Mode 0 (16 couleurs): [Adresse de base du point] = [Adresse de base de la ligne 21] + [Valeur de X \ 2] = &E0A0 + (8 \ 2) = &E0A4 3 - Entrelacement des pixels 3.1 Entrelacement des pixels en Mode 0 On a vu qu'avec le mode graphique 0 (16 couleurs) on pouvait coder 2 pixels dans un octet car chaque pixel a une longueur de 4 bits et bien-sûr un octet 8 bits. On pourrait donc se dire dans les bits 7,6,5,4 je vais coder le premier pixel et dans les bits 3,2,1,0 le second … Mais c'est là qui y'a un blême ! Les deux pixels sont entrelacés !
Et oui ! La couleur du premier pixel est codée sur les bits 7,5,3,1 et celle du second pixel sur les bits 6,4,2,0. Voilà qui ne va pas arranger nos affaires ! Par de panique il y a toujours une solution … 3.2 Entrelacement des pixels en Mode 1 En ce qui concerne le mode 1, l'entrelacement de pixel est similaire à celui du Mode 0 à ceci près que chaque pixel n'est plus codé sur 4 bits mais 2 ; nous n'avons que 2 couleurs à coder.
3.3 Entrelacement des pixels en Mode 2 Pour le Mode 2 ce n'est pas compliqué, c'est le plus simple, chaque bit d'un octet correspond à 1 pixel, donc 8 pixels par octet. Et oui, codage de 2 couleurs seulement …
4 – Affichage d'un pixel 4.1 Affichage d'un pixel en Mode 0 On a vu dans les paragraphes précédents comment calculer l'adresse vidéo, de base d'un point. On a vu aussi comment étaient codés 2 pixels dans un octet. Maintenant nous allons voir comment afficher un pixel. Avant d'afficher quoi que ce soit il faut d'abord savoir ce que l'on veut faire … On veut afficher un point à l'écran avec une couleur bien spécifique. Le problème c'est que l'on ne peut pas directement mettre la valeur de la couleur du point dans l'octet associé à ce point ; vu que deux pixels sont codés dans un octet et que ces pixels sont entrelacés, si l'on modifie directement l'octet en question l'information sur la couleur des deux pixels existants sera modifiée et il va s'afficher n'importe quoi. Pour afficher correctement un pixel à l'écran réfléchissons aux différents problèmes que l'on va rencontrer : 1 - Savoir quels sont les bits du pixel à modifier en fonction de sa coordonnée.
Si X = 0 : Bit 0 de X = 0 (pair), correspondra donc au premier pixel à afficher Si X = 1 : Bit 0 de X = 1 (impair), correspondra donc au second pixel à afficher
Rappel sur le masque AND (en binaire): %1100 AND %1010 = %1000
Vous verrez rapidement l'intérêt d'une telle opération ...
Cette table va nous servir pour trouver la correspondance de chaque couleur à afficher. En effet, lorsque l'on voudra afficher un pixel avec la couleur15, on prendra la valeur associée 170 (%10101010) ; cette dernière étant près entrelacée il nous restera plus qu'à l'afficher. Avec toutes ces informations regardons maintenant toutes les étapes pour afficher un pixel : 1 – Calculer l'adresse du pixel en fonction des coordonnées (X, Y).
Affichage d'un pixel aux coordonnées (X = 0, Y = 0) avec la couleur 6. Les couleurs initiales des deux pixels de l'octet aux coordonnées (X, Y) avant modification sont 1 pour le premier pixel et 15 pour le second ; ce qui donnes en binaire, une fois les valeurs entrelacées : %01010111 (87)
1 – L'adresse de l'octet du pixel aux coordonnées (X = 0, Y = 0) est égal à &C000. [Couleur calculée] = [Couleur initiale] AND [Masque logique] = 87 AND 85 = %01010111 AND %01010101 = %01010101 = 85
Il nous reste plus qu'à coder la couleur du pixel à afficher (le premier pixel). Pour cela, nous allons appliquer un OU logique entre la valeur calculée de l'octet (celle précédemment calculée) et la valeur entrelacée, associée la couleur du premier pixel. [Nouvelle valeur de l'octet] = [Valeur modifiée] OR [Table correspondance(6)] = 85 OR 40 = %01010101 OR %00101000 = %01111101 = 125 Infos : Cet exemple ne permet d'encoder qu'un pixel pair. Pour les pixels impairs, les valeurs de la table de correspondance doivent être divisées par 2 (ou décalage d'1 bit vers la droite), un exemple sera traité après. 5 - Pour terminer, nous allons stocker la nouvelle valeur de l'octet à l'adresse du pixel … &C000 = 125 Exemple 2 – Codage d'un pixel impair: Affichage d'un pixel aux coordonnées (X = 1 Y = 0) avec la couleur 6. Comme dans l'exemple précédent, les couleurs initiales des deux pixels de l'octet aux coordonnées (X, Y) avant modification sont 1 pour le premier pixel et 15 pour le second ; ce qui donnes en binaire, une fois les valeurs entrelacées : %01010111 (87)
1 – L'adresse de l'octet du pixel aux coordonnées (X = 1, Y = 0) est égal à &C000.
Il nous reste plus qu'à coder la couleur du pixel à afficher (le second pixel). Pour cela, nous allons appliquer un OU logique entre la valeur calculée de l'octet (celle précédemment calculée) et la valeur entrelacée, associée la couleur du second pixel. [Nouvelle valeur de l'octet] = [Valeur modifiée] OR [Table correspondance(6) \ 2] = 2 OR (40 \ 2) = %00000010 OR %00010100 = %00010110 = 22 &C000 = 22 Et voilà celui-ci est allumé ! Enjoy !!! 4.2 Affichage d'un pixel en Mode 1 En mode graphique 1, chaque pixel est codé sur 2 bits, représentant ainsi une combinaison de 4 couleurs (de 0 à 3). Chaque octet contient 4 pixels, nous allons voir comment codé un pixel:
Les valeurs pré-calculées de la table vont correspondre à celles associées au premier pixel (pixel utilisant les bits 7 et 3 de l'octet), elles serviront de masques logiques pour afficher les couleurs. Pour calculer les valeurs des autres pixels, nous prendrons celles de la table et nous effectuerons un décalage binaire de celles-ci vers le bas (la droite). Contenu de la table de correspondance:
Comment savoir quel pixel traité dans l'octet ? Ce n'est pas compliqué ! Sachant que l'on a 4 pixels par octet, il suffit de regarder les 3 derniers bits de X pour savoir quel est le numéro du pixel concerné (sachant que leur numérotation va de 0 à 3). Exemple: Prenons un point aux coordonnées X = 13, Y = 0 et de couleur 2. Pour trouver l'octet concerné par l'affichage du pixel nous divisons X \ 4. [Octet concerné] = X \ 4 = 3 (4ème octet car leur numérotation commence à 0) Maintenant pour trouver quel est le pixel à afficher (dans l'octet), nous regardons les 3 derniers bits de la valeur de X. [Pixel concerné, dans l'octet] = X AND 3 = 1 (2ème pixel, la numérotation commence à 0) A ce stade, nous connaissons l'octet concerné par l'affichage du pixel et nous connaissons le numéro du pixel à afficher: octet 3, pixel 1. Calculons maintenant la valeur du masque logique qui va nous servir à modifier la couleur du pixel; nous allons utiliser la table de correspondance. Nous voulons afficher le pixel avec la couleur 2. Dans la table la valeur entrelacée liée à la couleur 2 est 128 (%10000000 en binaire). Nous savons que cette valeur est associée au 1er pixel (le pixel P0), nous allons donc recalculer cette valeur pour le second pixel; pour cela il suffit de décaler vers le bas cette valeur en fonction du numéro du pixel précédemment calculé : [Nouvelle valeur] = [Table correspondance(2)] \ (2 ^ [N° du pixel concerné, dans l'octet]) = 128 \ (2 ^ (13 AND 3)) = 128 \ (2 ^ 1) = 64 (%01000000 en binaire) Ici pour effectuer une rotation des bits vers le bas nous utilisons une division entière par 2. L'opération (2 ^ n) a pour effet d'élevé 2 à la puissance n pour savoir combien de rotation nous devons effectuer en fonction du numéro du pixel; bien-sûr, en assembleur il faudrait remplacer toute l'opération par une simple rotation de bits. Bilan : Nous avons le numéro de l'octet, le numéro du pixel et la valeur entrelacée de sa couleur; nous n'avons plus qu'à modifier sa couleur. Pour cela nous allons de nouveau utiliser un masque logique, masque qui va nous permettre de préserver les bits des pixels aux alentours, d'effacer l'ancienne couleur de notre pixel, puis d'appliquer sa nouvelle couleur. Ce masque correspond à la valeur 136 (%10001000) décalée vers le bas (la droite) d'autant de fois que le numéro du pixel : [Valeur du masque] = NOT (136 \ (2 ^ (X AND 3))) = NOT (%10001000 \ (2 ^ 1)) = NOT (%10001000 \ 2) = NOT (%01000100) = %01110111 Préservation des autres pixels : [Nouvelle valeur de l'octet] = [Ancienne valeur de l'octet] AND [Valeur du masque] L'opération logique ET permet de ne garder que les bits des valeurs source1 et source2 à 1. (voir plus haut) Nouvelle couleur appliquée : [Nouvelle valeur de l'octet] = [Nouvelle valeur de l'octet] OR [Nouvelle valeur entrelacée de la couleur] Ici le OU logique a pour but de n'allumer que les bits de la couleur entrelacée à 1. Pour terminer, stockons la nouvelle valeur de l'octet et allumons le pixel : &C003 = [Nouvelle valeur de l'octet] 4.3 Affichage d'un pixel en Mode 2 Pour l'affichage d'un pixel en Mode 2, l'opération est exactement la même qu'en Mode 1 à ceci près qu'en Mode 2 on code 8 pixels par octet et que chaque pixel est codé sur 2 bits et ne peut prendre que 2 couleurs (0 ou 1).
[Numéro de l'octet concerné] = X MOD 8 Sachant que l'on peut coder 8 pixels par octet et qu'un pixel ne peut prendre que la valeur 0 ou 1, le calcul du numéro du pixel peut être définit comme suit : [Numéro du pixel concerné]= X AND 7 Exemple :
Ce qui implique : Octet 0 Dans cet exemple nous pouvons voir que le pixel à allumer se trouve au 6ème bit, il va donc falloir préserver les bits des pixels restant pour ne pas affecter leur couleur. Pour cela nous allons calculer un premier masque logique. Nous partons du 7ème bit et nous allons décaler ce bit vers le bas (la droite) en fonction du numéro du pixel précédemment calculé, puis nous prendrons l'inverse de la valeur issue du calcul: [Masque logique 1] = NOT (128 \ (2 ^ (X AND 7))) = NOT (%10000000 \ (2 ^ (1 AND 7))) = NOT %01000000 = %10111111 Maintenant nous allons calculer le second masque qui va nous permettre de modifier la valeur de notre nouveau pixel. Comme pour les exemples précédents, nous allons utiliser une table de correspondances pour trouver la valeur entrelacée associée à la couleur à afficher. En Mode 2 la table de correspondances ne fait que 2 lignes car nous n'avons que 2 couleurs à coder (sur 1 bit, 0 ou 1). Vous me direz … une table pour coder 2 couleurs ? Il est vrai que celle-ci est facultative et qu'il y a d'autres moyens d'allumer un pixel ; nous allons quand même garder cet exemple.
[Masque logique 2] = [Table de correspondances(1)] \ (2 ^ (X AND 7)) = %10000000 \ (2 ^ (1 AND 7)) = %01000000 Il nous reste plus qu'à affecter la nouvelle valeur de notre pixel puis afficher le résultat : [Nouvelle valeur de l'octet] = ([Ancienne valeur de l'octet] AND [Masque 1]) OR [Masque 1] &C000 = [Nouvelle valeur de l'octet concerné] 5 – Partie code 5.1 Affichage d'un pixel en Mode 0 10 '****************************************** | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
 |
|
