Comment les ordinateurs affichent du texte et des graphiques bruts de bas niveau

Mon intérêt croissant pour les ordinateurs me pousse à poser des questions plus profondes, que nous ne semblons plus avoir à poser. D'après ce que je comprends, nos ordinateurs au démarrage sont en mode texte , dans lequel un caractère peut être affiché à l'aide de l'interruption logicielle 0x10quand AH=0x0e. Nous avons tous vu la célèbre police de démarrage qui a toujours la même apparence, quel que soit l'ordinateur en cours de démarrage.

Alors, comment se fait-il que les ordinateurs produisent des graphiques au niveau le plus bas, par exemple, en dessous du système d'exploitation? Et aussi, les graphismes ne sont sûrement pas restitués pixel par pixel à l’aide d’interruptions logicielles, car cela semble très lent?

Existe-t-il une norme définissant la production de base de sommets, polygones, polices, etc. (sous OpenGL, par exemple, que OpenGL pourrait utiliser)? Ce qui me fait demander, c'est pourquoi les systèmes d'exploitation peuvent souvent fonctionner sans les pilotes officiels installés; Comment font-ils cela?

Toutes mes excuses si mes hypothèses sont incorrectes. Je serais très reconnaissant pour l'élaboration de ces sujets!

C'est (en partie) le rôle du BIOS.

Le système de base des entrées-sorties de l'ordinateur est chargé de fournir une interface commune aux systèmes d'exploitation, malgré les différences existant entre les ordinateurs.

Cela dit, pour les graphiques en particulier, il existe différentes manières de dessiner à l'écran. Il existe des commandes TTY que vous pouvez envoyer au BIOS, mais ce n'est qu'en mode réel. Si vous voulez dessiner quelque chose en mode protégé, vous devez utiliser VGA pour dessiner des choses. Je ne peux pas l'expliquer mieux que OSDev, alors regardez ici pour plus d'informations - mais en gros, vous pouvez écrire dans la mémoire (la mémoire vidéo est mappée en mémoire) en partant de l'adresse 0xB8000pour dessiner des éléments à l'écran.

Si vous avez besoin d'une résolution supérieure à celle du VGA, vous devez utiliser les extensions du BIOS VESA. Je ne le connais pas bien, mais essayez de regarder le code source de GRUB pour plus d'informations.

Quelques références utiles:

• Code source GRUB :

  grub-core/video/i386/pc/vbe.c
  grub-core/video/i386/pc/vga.c
  

• OSDev Wiki (Dessin en mode protégé)

• Extensions du BIOS VESA

Si vous connaissez bien D - j’ai écrit il ya quelque temps un petit chargeur de démarrage capable d’écrire à l’écran (texte uniquement). Si cela vous intéresse, voici le code:

align(2) struct Cell { char ch; ubyte flags = 0x07; }

@property Cell[] vram()
{ return (cast(Cell*)0xB8000)[0 .. CONSOLE_WIDTH * CONSOLE_HEIGHT]; }

void putc(char c)
{
    if (isBochs) { _outp(0xE9, c); }  // Output to the Bochs terminal!

    bool isNewline = c == '\n';
    while (cursorPos + (isNewline ? 0 : 1) > vram.length)
    {
        for (short column = CONSOLE_WIDTH - 1; column >= 0; column--)
        {
            foreach (row; 0 .. CONSOLE_HEIGHT - 1)
            {
                uint cell = column + cast(uint)row * CONSOLE_WIDTH;
                vram[cell] = vram[cell + CONSOLE_WIDTH];
            }
            vram[column + (CONSOLE_HEIGHT - 1) * CONSOLE_WIDTH].ch = ' ';
        }
        cursorPos = cast(ushort)(cursorPos - CONSOLE_WIDTH);
    }
    if (isNewline)
        cursorPos = cast(ushort)
            ((1 + cursorPos / CONSOLE_WIDTH) * CONSOLE_WIDTH);
    else vram[cursorPos++].ch = c;
}

void putc(char c, ubyte attrib) { vram[cursorPos] = Cell(c, attrib); }

void memdump(void* pMem, size_t length)
{
    foreach (i; 0 .. length)
        putc((cast(char*)pMem)[i]);
}

void clear(char clear_to = '\0', ubyte attrib = DEFAULT_ATTRIBUTES)
{
    foreach (pos; 0 .. vram.length)
        vram[pos] = Cell(clear_to, attrib);
    cursorPos = 0;
}

@property ushort cursorPos()
{
    ushort result = 0;
    _outp(0x3D4, 14);
    result += _inp(0x3D5) << 8;
    _outp(0x3D4, 15);
    result += _inp(0x3D5);
    return result;
}

@property void cursorPos(ushort position)
{
    _outp(0x3D4, 14);
    _outp(0x3D5, (position >> 8) & 0xFF);
    _outp(0x3D4, 15);
    _outp(0x3D5, position & 0xFF);
}

Dès les débuts du PC IBM et de ses clones, le matériel de la carte graphique était très simple: un petit bloc de mémoire était dédié à une grille de cellules de caractères (80 x 25 caractères en mode standard), avec deux octets de mémoire pour chaque cellule. . Un octet a sélectionné le caractère et l’autre a sélectionné ses "attributs" - couleurs de premier plan et d’arrière-plan, plus contrôle des clignotements pour les adaptateurs de couleurs; gras, souligné, clignotant ou vidéo inversée pour les adaptateurs monochromes. Le matériel a recherché des pixels dans une table ROM de formes de caractères en fonction du contenu de la mémoire de caractères.

Afin d'offrir un certain degré d'indépendance matérielle, l'interface du BIOS à la mappe de caractères nécessitait l'exécution d'une interruption logicielle afin de définir une cellule de caractère unique à l'écran. C'était lent et inefficace. Cependant, la mémoire de caractères était également directement adressable par la CPU. Par conséquent, si vous saviez quel matériel était présent, vous pourriez écrire directement dans la mémoire. Quoi qu'il en soit, une fois défini, le caractère resterait à l'écran jusqu'à ce qu'il soit modifié, et la mémoire de caractères totale nécessaire pour travailler était de 4000 octets - environ la taille d'une seule texture 32x32 de couleur!

Dans les modes graphiques, la situation était similaire. chaque pixel à l'écran est associé à un emplacement particulier dans la mémoire. Il existait une interface BIOS avec pixel défini mais un travail très performant nécessitait une écriture directe dans la mémoire. Les normes ultérieures telles que VESA permettent au système d'effectuer quelques requêtes lentes basées sur le BIOS pour connaître la configuration de la mémoire du matériel, puis de travailler directement avec la mémoire. C’est ainsi qu’un système d’exploitation peut afficher des graphiques sans pilote spécialisé, bien que les systèmes d’exploitation modernes incluent également des pilotes de base pour le matériel de tous les principaux fabricants de GPU. Même la dernière carte NVidia prendra en charge plusieurs modes de compatibilité avec les versions antérieures, probablement jusqu’à IBM CGA.

Une différence importante entre les graphiques 3D et 2D est qu'en 2D, il n'est généralement pas nécessaire de redessiner l'écran entier à chaque image. En 3D, si la caméra bouge même un tout petit peu, chaque pixel de l'écran peut changer. en 2D, si vous ne faites pas défiler l'écran, la plupart de l'écran sera inchangé, et même si vous défilez, vous pouvez généralement effectuer une copie rapide de mémoire à mémoire au lieu de recomposer la scène entière. Il n’ya donc rien de tel que d’exécuter INT 10h pour chaque pixel, chaque image.

Source: je suis vraiment vieux

Au cours du démarrage, le BIOS du système recherche la carte vidéo. En particulier, il recherche le programme BIOS intégré de la carte vidéo et l'exécute. Ce BIOS se trouve normalement à l’emplacement C000h en mémoire. Le BIOS du système exécute le BIOS vidéo , qui initialise la carte vidéo.

Les niveaux ou modes vidéo / graphiques que le BIOS peut afficher en mode natif, sans système d'exploitation ou pilotes, dépendent principalement du BIOS vidéo lui-même.

Source / Plus d'infos ici - "Séquence de démarrage du système"

Nos ordinateurs, au démarrage, pour autant que je sache, sont en mode texte, dans lequel un caractère peut être affiché à l'aide de l'interruption logicielle 0x10 lorsque AH = 0x0e

Vous parlez des anciennes fonctions du BIOS. En fait, vous n'avez pas du tout besoin d'utiliser de telles fonctions. Vous les écrivez directement dans la mémoire vidéo.

comment diable les ordinateurs produisent-ils des graphiques au plus bas niveau, disons, en dessous du système d'exploitation?

Ceci doit absolument faire sur le fonctionnement du système d'exploitation. Quoi qu’il en soit, l’opération est la même au niveau matériel: la carte vidéo dispose d’une mémoire vidéo qui stocke (simplifie) la prochaine image à dessiner sur l’écran. Vous pouvez penser que chaque adresse est un octet qui représente un pixel (vous avez généralement besoin de plus d’un octet par pixel). Ensuite, le contrôleur vidéo se charge de traduire cela en un signal que le moniteur comprend.

Existe-t-il une norme définissant la production de base de sommets, polygones, polices, etc. (sous OpenGL, par exemple, que OpenGL pourrait utiliser)?

Autant que je sache, non. Il n'y a pas de normes concernant les représentations graphiques logiques.

Ce qui me fait demander, c'est pourquoi les systèmes d'exploitation peuvent souvent fonctionner sans les pilotes officiels installés; Comment font-ils cela?

Parce qu'il a des pilotes déjà fournis avec le système d'exploitation.