Suavizador de quadros

O buffer de quadros ou memória de imagem ( quadro inglês - imagem única, buffer - armazenamento intermediário) faz parte da memória gráfica dos computadores e corresponde a uma cópia digital da imagem do monitor . Isso significa que cada pixel da tela pode ser atribuído a uma área específica do buffer de quadros que contém seu valor de cor traduzido digitalmente. Desde a década de 1990, o framebuffer tem sido localizado principalmente na placa de vídeo .

Requisitos de memória

O tamanho mínimo necessário do buffer de quadros depende de dois fatores: a profundidade de cor usada (mais precisamente: formato de pixel) e a resolução da imagem usada .

Profundidade de cor

A profundidade de cor do buffer de quadro define o número máximo de cores ou nuances de cores exibidas na tela ao mesmo tempo. Na área de computadores compatíveis com IBM PC , os tamanhos fornecidos na lista a seguir eram e são comuns. Os formatos de pixel especificados indicam quantos bits por pixel são atribuídos aos canais de cores individuais (vermelho, verde, azul, canal alfa ) - essa informação está faltando para modos de cor que usam cores indexadas (paletas) porque não faz nenhum sentido.

• 1 bit por pixel, duas cores (geralmente claro e escuro em um monitor monocromático )
  • MDA
• 2 bits por pixel, quatro cores
  • CGA : paleta com 4 cores de 16 possíveis
• 4 bits por pixel, 16 cores
  • EGA : Paleta com 16 cores de 64 possíveis
• 8 bits por pixel, 256 cores
  • VGA : Paleta com 256 cores de 262144 possíveis
• 15 bits por pixel, 32.768 cores
  • Cor real : formato de pixel 5-5-5, ou seja, H. 5 bits por canal de cor (ou seja, 32 níveis de intensidade por canal)
• 16 bits por pixel, 65536 cores
  • High Color : formato de pixel 5-6-5, ou seja, H. 5 bits para vermelho e azul (32 níveis de intensidade) e 6 bits para verde (64 níveis de intensidade)
  • alternativamente também 4-4-4-4, ou seja, H. 4 bits por canal de cor (16 níveis de intensidade), em que os últimos quatro bits não são usados ​​ou são usados ​​como um canal alfa (consulte true color de 32 bits)
• 24 bits por pixel: 16777216 cores
  • True Color : formato de pixel 8-8-8, ou seja, H. 8 bits por canal de cor (256 níveis de intensidade)
• 32 bits por pixel
  • True Color: formato de pixel 8-8-8-8, ou seja, H. 8 bits por canal de cor (256 níveis de intensidade)
  • Os 8 bits que foram adicionados à true color de 24 bits normalmente não são usados; Em computadores com arquitetura de 32 bits, no entanto, o processamento de valores de 32 bits é mais eficiente do que os de 24 bits, porque isso corresponde exatamente ao comprimento da palavra do processador, razão pela qual buffers de quadro true-color principalmente apesar do requisito de memória 33% maior Use profundidade de cor de 32 bits.

Com hardware gráfico que funciona com bitplanes (por exemplo, Amiga ), 3, 5, 6 e 7 bits por pixel com 8, 32, 64 ou 128 cores correspondentes também são comuns para cores indexadas.

Na computação gráfica 3D, buffers de quadro com maior precisão também são usados. Lá, a determinação da cor de um pixel geralmente requer várias etapas de cálculo, em que erros de arredondamento podem ocorrer com cada resultado intermediário , que são rapidamente visíveis em formatos de buffer de quadro convencionais e têm um efeito perturbador.

Com esses formatos mais precisos, os valores do canal de cor são interpretados como valores de vírgula em uma escala de 0,0 a 1,0, de modo que o manuseio é simplificado ao usar vários formatos de pixel.

• FX8
  • Ponto fixo de 8 bits por canal de cor , portanto, 256 gradações de cor escalonadas linearmente
  • idêntico aos 32 bits por pixel acima. Se você pegar os 256 valores diferentes por canal de cor como um número inteiro entre 0 e 255 ou como um valor de ponto fixo entre 0,0 e 1,0 é apenas uma questão de interpretação.${\ displaystyle \ left ({\ frac {\ text {value}} {255}} \ right)}$
  • contraste máximo de 255: 1, portanto, adequado para renderização de baixa faixa dinâmica (LDR), como pode ser exibido por telas normais de todos os tipos
• FX12
  • Ponto fixo de 12 bits por canal de cor, portanto, 4096 gradações de cor escalonadas linearmente
  • maior precisão do que FX8
  • contraste máximo 4095: 1, adequado para renderização de baixo alcance dinâmico (LDR)
• FX16
  • Ponto fixo de 16 bits por canal de cor, portanto, 65536 gradações de cor escalonadas linearmente
  • maior precisão do que FX12
  • contraste máximo 65535: 1, adequado para renderização de intervalo dinâmico médio (MDR)
• FP16
  • Ponto flutuante de 16 bits por canal de cor (dos quais expoente de 5 bits e mantissa de 10 bits ), portanto, 32768 gradações de cores escaladas exponencialmente
  • Em comparação com o FX16, a escala exponencial permite uma resolução muito mais precisa para valores pequenos, mas é menos precisa para valores maiores.
  • contraste máximo aprox. , adequado para renderização de alta faixa dinâmica (HDR) .${\ displaystyle 10 ^ {12}: 1}$
• FP24
  • Ponto flutuante de 24 bits por canal de cor (incluindo expoente de 7 bits e mantissa de 16 bits), portanto, mais de 8 milhões de gradações de cores escaladas exponencialmente
  • maior precisão do que FP16, portanto, muito adequado para renderização HDR
• FP32
  • Ponto flutuante de 32 bits por canal de cor (dos quais expoente de 8 bits e mantissa de 23 bits), portanto, mais de 2 bilhões de gradações de cor escaladas exponencialmente
  • precisão ainda maior do que FP24

Resolução de imagem

A resolução da imagem indica em quantos pixels o framebuffer consiste. Normalmente, você especifica o número horizontal e vertical de pixels, o que significa que também pode calcular a proporção da imagem diretamente; 4: 3, 5: 4 e 16:10 são comuns aqui.

Exemplos

• Modo de texto (por exemplo, ao inicializar um PC compatível com IBM com BIOS )
  Para um console com 80 × 25 caracteres, cada caractere e sua cor sendo salvos com 8 bits cada (ou seja, um total de 16 bits), o buffer de quadro ocupa 80 × 25 × 16 = 32000 bits = 4 KB.
• Buffers de quadro EFI em PCs modernos com Interface de Firmware Extensível Unificada (UEFI)
  Com EFI 1.x, o Adaptador Gráfico Universal (UGA) era um driver EFI independente de hardware disponível para usar um buffer de quadro de vídeo simples. Ele foi substituído pelo UEFI 2.x pelo Graphics Output Protocol (GOP), que agora também pode usar o modo de texto independentemente da placa de vídeo. Ambos UGA e GOP substituem completamente o BIOS de vídeo (VBIOS para breve, apenas em PCs com BIOS) - as funções VBIOS não podem mais ser usadas pelo driver gráfico, de modo que alguns drivers gráficos de PC mais antigos em (U) EFI não funcionam com hardware idêntico, mas com CSM ativado (a emulação de BIOS de EFI ou UEFI). Os sistemas operacionais e drivers de dispositivo devem, portanto, usar EFI-UGA ou -GOP para poder usar o modo de texto (com GOP) ou vídeo e outras funções de buffer de quadro de firmware. No Linux existe comefifbum driver gráfico framebuffer genérico que funciona em todos os PCs EFI e, portanto, também independente da placa gráfica específica. O Windows e o macOS também usam o buffer de quadros EFI, mas como ele só está disponível sem aceleração gráfica, só está disponível em modo restrito.
• Modo gráfico (por exemplo, no Windows ou no sistema X Window no Linux)
  Com uma resolução de tela de 1024 × 768 pixels e uma profundidade de cor de 24 bits, o buffer de quadro ocupa 1024 × 768 × 24 = 18874368 bits = 2,25 MiB .

No caso do TrueColor, a visão geral leva em consideração que os dados são armazenados internamente com 24 bits.

Melhorias

Devido a inadequações na continuidade da sequência de imagens e para aumentar ainda mais a qualidade geral da exibição, o conceito de buffer de quadros foi revisado ao longo do tempo. Um framebuffer nos sistemas atuais corresponde a vários buffers.

• No buffer duplo ( buffer duplo ) do buffer de quadros em duas regiões ( buffer frontal e buffer traseiro ) dividido.
• No buffer triplo ( buffer triplo ) do buffer de quadro é (1 em três áreas do buffer frontal e 2 BackBuffer dividido).

Framebuffer do Linux

Captura de tela de inicialização do Knoppix

O Linux Framebuffer Device ( fbdev para abreviar ) é uma camada de abstração independente de hardware no Linux para exibir gráficos no console ou com um X-Window (xf86_fbdev). O dispositivo framebuffer não depende de bibliotecas específicas do sistema, como SVGALib ou o X Window System e, portanto, é uma alternativa de economia de recursos para o servidor X difundido no qual a maioria das interfaces gráficas para Linux são baseadas hoje. Ele foi incluído no kernel padrão para todas as plataformas desde o kernel Linux versão 2.1.107.

Originalmente, foi implementado para Linux68k a fim de emular um modo de texto em sistemas correspondentes (Amiga, Atari, Macintosh) com uma baixa aceleração de hardware e só foi estendido posteriormente para a plataforma compatível com IBM-PC.

Hoje em dia o framebuffer pode ser usado diretamente por diferentes programas como MPlayer e bibliotecas como GGI, SDL , GTK + e Qt Extended . O conceito de economia de recursos torna o uso particularmente interessante para sistemas embarcados.

Em particular, ele é usado por várias distribuições ( Ubuntu , openSUSE ) para habilitar a saída gráfica na forma de uma tela inicial durante a inicialização .

O driver de framebuffer VESA mais frequentemente usado (vesafb) é baseado em especificações uniformes de padrões de vídeo e, portanto, permite o acesso a placas gráficas independente do fabricante. Isso significa que uma implementação de código aberto também é possível. Além disso, vários fabricantes de chips gráficos ( Nvidia : rivafb, nvidiafb; AMD : radeonfb) trouxeram drivers proprietários para o mercado.

O dispositivo framebuffer tornou-se conhecido por sua capacidade de exibir um logotipo do Tux para o usuário durante o processo de carregamento do kernel do Linux . Para fazer isso, no entanto, ele deve primeiro estar contido no kernel e ativado especificando o parâmetro durante a próxima reinicialização pelo carregador de boot , que também carrega o sistema operacional na memória principal video.

O seguinte mostra dois exemplos em que um driver AMD é carregado com uma resolução de imagem de 1024 × 768 pixels, uma profundidade de cor de 8 bits por pixel e uma taxa de atualização de 76 Hz:

Exemplo de um arquivo de configuração LILO

# LILO configuration file
boot = /dev/sda1
# Linux bootable partition config begins
image = /vmlinuz
append = "video=atyfb:1024x768-8@76,font:SUN8x16"

Exemplo de arquivo de configuração GRUB

# GRUB configuration file
# For booting LINUX
title Linux
kernel (hd0, 0) /vmlinuz video=atyfb:1024x768-8@76,font:SUN8x16 root=/dev/hda1

Um módulo de kernel não precisa necessariamente ser escrito para acesso de hardware ao dispositivo de buffer de quadro. O aplicativo também tem a opção de /dev/fb*acessar o dispositivo no modo de usuário por meio do arquivo do dispositivo e gravá-lo na memória gráfica. O exemplo a seguir demonstra como a linguagem de programação C pode ser usada para escrever linearmente no buffer de quadros. Aqui, o valor hexadecimal 0x000000FF (binário: 0b00000000000000000000000011111111) é definido para cada pixel:

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/fb.h>
#include <unistd.h>
#include <stdio.h>

int main(int argc, char **argv) {
   int row, col, width, height, bitspp, bytespp;
   unsigned int *data;

   // Öffnen des Gerätes
   int fd = open("/dev/fb0", O_RDWR);

   // Informationen über den Framebuffer einholen
   struct fb_var_screeninfo screeninfo;
   ioctl(fd, FBIOGET_VSCREENINFO, &screeninfo);

   // Beende, wenn die Farbauflösung nicht 32 Bit pro Pixel entspricht
   bitspp = screeninfo.bits_per_pixel;
   if(bitspp != 32) {
     // Ausgabe der Fehlermeldung
     printf("Farbaufloesung = %i Bits pro Pixel\n", bitspp);
     printf("Bitte aendern Sie die Farbtiefe auf 32 Bits pro Pixel\n");
     close(fd);
     return 1; // Für den Programmabbruch geben wir einen Rückgabetyp != 0 aus.
   }

   width  = screeninfo.xres;
   height = screeninfo.yres;
   bytespp = bitspp/8; //Bytes pro Pixel berechnen

   // Überprüfen ob der Typ unsigned int die gleiche Byte-Grösse wie ein Pixel besitzt.
   // In unserem Fall 4 Byte (32 Bit), falls nicht wird das Programm beendet
   if(sizeof(unsigned int) != bytespp) {
      close(fd);
      return 1;
   }

   // Zeiger auf den Framebufferspeicher anfordern
   data = (unsigned int*) mmap(0, width * height * bytespp, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

   // In den Framebuffer-Speicher schreiben. Hier wird Pixel für Pixel auf
   // die Farbe 0x000000FF (Blau) gesetzt, da ein Pixel das AARRGGBB Format hat
   for(row = 0; row < height; row++)
     for(col = 0; col < width; col++)
        data[row * width + col] = 0xFF;

   // Zeiger wieder freigeben
   munmap(data, width * height * bytespp);

   // Gerät schließen
   close(fd);
   // Rückgabewert
   return 0;
}

Veja também

• DirectFB , Direct frame buffer, uma biblioteca de programas baseada no Linux frame buffer

Evidência individual

1. ↑ Edgar Hucek: O que é efifb? In: Arquivos do kernel do Linux. Recuperado em 25 de agosto de 2020 .