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 …

Le premier pixel se trouve au bit 7, etc. Rien à ajouter.
 

    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.
    2 - Lors de l’affichage d’un pixel, ne pas modifier la couleur du pixel voisin.
    3 - Encoder le numéro de la couleur du pixel à afficher pour contourner le 
         problème de l’entrelacement.
 

1 – En effet, sachant que sont codés deux pixels dans un octet il faut savoir quel pixel correspond à telle série de bits ? Pour cela il suffit de regarder si sa coordonnées X un pair ou impair. Imaginons que X soit égal à 12, en binaire on a %1100, le bit 0 étant égal à zéro il s’agit d’un nombre pair. Réciproquement pour codé la valeur 13, en binaire on a %1101 le bit 0 égal 1 donc le chiffre à codé est impair. Exemple dans notre cas :

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
 

2 - Pour ne pas modifier la couleur du pixel voisin on va utiliser un masque binaire ; ce masque va nous permettre préserver sa couleur et supprimer celle du pixel à modifier. Un second masque sera appliqué pour modifier la couleur du nouveau pixel.

Rappel sur le masque AND (en binaire):
 

                    %1100 AND %1010 = %1000

    Vous verrez rapidement l’intérêt d’une telle opération ...
 

3 – Pour contourner le problème de l’entrelacement des pixels, nous allons passer par une table de correspondance entre la couleur à afficher et la valeur réelle à stocker en mémoire. Sachant que les couleurs de nos deux pixels sont entrelacées, passons d’abord en revu les différentes valeurs possibles pour les couleurs du 1er pixel.
 

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).
    2 – Regarder quel pixel doit être allumé (pair ou impaire).
    3 – Récupérer la valeur de l’octet se trouvant à l’adresse du pixel.
    4 – Appliquer les filtres logiques.
    5 – Stockage de la nouvelle valeur de l’octet à l’adresse du pixel.


 

Exemple 1 – Codage d’un pixel pair:

    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.
2 – Le pixel est un pixel pair car X = 0 (bit 0 de X = 0)
3 – La couleur initiale de l’octet se trouvant à l’adresse &C000 est égal à %01010111
4 – Nous allons maintenant éteindre le premier pixel en appliquant un filtre logique :
 

        [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.
2 – Le pixel est un pixel impair car X = 1 (bit 0 de X = 1)
3 – La couleur initiale de l’octet se trouvant à l’adresse &C000 est égal à %01010111
4 – Nous allons maintenant éteindre le second pixel en appliquant un filtre logique :
 
 

        [Couleur calculée]  = [Couleur initiale] AND [Masque logique]
                            = 87 AND 170
                            = %01010111 AND %10101010
                            = %00000010
                            = 2

    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 !!!
 

    Nous avons vu précédemment comment calculé l'adresse de base d'une ligne et d'un pixel à partir d'un système de coordonnées (X, Y). Nous allons étudier maintenant comment traiter un pixel en particulier. Nous avons vu que pour afficher un pixel en mode 16 couleurs (Mode 0) les bits de chacune des couleurs devaient être entrelacés et qu'il nous fallait une table de correspondance (couleurs d'origine => valeurs après entrelacement). Pour l'affichage de pixels en Mode 1 c'est identique, nous allons devoir utiliser une table de correspondance; celle-ci sera plus petite car nous n'avons que 4 couleurs à coder et pas 16.

    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)

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

        [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. 
    Donc d'appliquer la nouvelle couleur.

Pour terminer, stockons la nouvelle valeur de l'octet et allumons le pixel :
 

                        &C003 = [Nouvelle valeur de l'octet]

    Pour calculer le numéro de l'octet nous allons effectuer une division modulo 8 à partir de la valeur de X :
 

        [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 :
 

    Nous voulons allumer un pixel se trouvant aux coordonnées (X = 1, Y = 0) et de couleur 1. Il va nous falloir calculer 2 masques logiques, l'un pour préserver les pixels aux alentours tout en effaçant la valeur de notre ancien pixel, l'autre pour pouvoir allumer la nouvelle valeur de notre pixel.

        [Numéro de l'octet concerné] = X MOD 8
                                     = 0

        [Numéro du pixel concerné]   = X AND 7
                                     = 1

Ce qui implique :

    Octet 0
    Pixel 1 (bit 6)

    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é]