Fundamentos de Memória & Ponteiros (Unsafe Pointers)

Para compreender o processamento de imagens em alta velocidade, precisamos entender como o computador organiza uma imagem dentro da memória RAM.

---

1. O que é uma Imagem Digital na Memória RAM?

A Analogia do Mosaico de Azulejos:

Imagine uma parede inteira coberta por milhares de quadradinhos coloridos (pixels). Se você olhar de muito perto, verá apenas quadradinhos individuais. Se der 10 passos para trás, seus olhos juntam todos os pontinhos e enxergam uma fotografia nítida.

Na memória RAM do computador, essa grade não é armazenada como uma tabela 2D, mas sim como uma fita contínua de números (um vetor 1D):

Memoria Linear Contínua (1D):
[Pixel 0,0][Pixel 1,0][Pixel 2,0] ... [Pixel 511,0] | [Pixel 0,1][Pixel 1,1] ...

---

2. Estrutura do Formato de Pixel Bgra32

Neste projeto, cada pixel ocupa exatamente 32 bits (4 bytes) na ordem nativa das placas de vídeo Windows (BGRA):

+---------------+---------------+---------------+---------------+
| Byte 0: Blue  | Byte 1: Green | Byte 2: Red   | Byte 3: Alpha |
+---------------+---------------+---------------+---------------+
  (Azul: 0-255)   (Verde: 0-255)  (Verm: 0-255)   (Opac: 0-255)

• Byte 0 (B): Componente Azul (Blue), variando de 0 a 255.
• Byte 1 (G): Componente Verde (Green), variando de 0 a 255.
• Byte 2 (R): Componente Vermelho (Red), variando de 0 a 255.
• Byte 3 (A): Canal Alfa (Alpha - Opacidade), onde 0 é transparente e 255 é 100% opaco.

---

3. O Conceito Fundamental de Stride

A Analogia do Caderno Pautado:

Imagine um caderno com linhas horizontais. O Stride é a largura total em bytes de uma linha inteira do caderno.

$$\text{Stride} = \text{Largura} \times 4$$

Para uma imagem de $512\text{ pixels}$ de largura:

$$\text{Stride} = 512 \times 4 = 2048\text{ bytes por linha}$$

Cálculo do Endereço de Memória do Pixel $(x, y)$:

Para localizar exatamente o byte inicial de qualquer pixel na coluna $x$ e linha $y$:

$$\text{Deslocamento}(x, y) = (y \times \text{Stride}) + (x \times 4)$$ $$\text{Endereço na RAM}(x, y) = \text{PonteiroBase} + \text{Deslocamento}(x, y)$$

---

4. Por que o GetPixel / SetPixel Clássico é Lento?

Em bibliotecas antigas (como System.Drawing.Bitmap), o código tradicional costuma ser escrito assim:

// Abordagem lenta tradicional:
for (int y = 0; y < height; y++)
{
    for (int x = 0; x < width; x++)
    {
        Color cor = bmp.GetPixel(x, y); // Lento!
        Color novaCor = Transformar(cor);
        bmp.SetPixel(x, y, novaCor);    // Lento!
    }
}

A cada chamada de GetPixel, o sistema operacional executa validações repetitivas de limites e chamadas intermediárias. Para uma imagem de $512 \times 512$ pixels ($262.144\text{ pixels}$), isso demora mais de $200\text{ ms}$ (apenas 5 quadros por segundo).

---

5. A Solução: Ponteiros Não Gerenciados (unsafe byte*)

Com blocos unsafe, acessamos a memória diretamente sem camadas intermediárias:

// Abordagem de alto desempenho (usada no CGPDI.StudyLab):
unsafe
{
    byte* basePtr = bmp.BackBuffer;

    byte* pixelPtr = basePtr + (y * stride) + (x * 4);
    byte azul     = pixelPtr[0];
    byte verde    = pixelPtr[1];
    byte vermelho = pixelPtr[2];
    byte alfa     = pixelPtr[3];
}

Com essa técnica combinada com Parallel.For, o mesmo cálculo é concluído em $0.8\text{ ms}$ (mais de 1000 FPS).

---

📚 Referências Oficiais Microsoft Learn

Aprofunde seus conhecimentos na documentação oficial da Microsoft sobre memória e ponteiros no .NET:

• Tipos de ponteiro e código não seguro (unsafe) no C# — Sintaxe de fixed, stackalloc e aritmética de ponteiros.
• Gerenciamento de Memória e Coleta de Lixo (GC) no .NET — Como funciona o Heap gerenciado e por que fixamos buffers na memória.
• Paralelismo de Dados com Parallel.For — Utilização da Task Parallel Library (TPL) para distribuição de carga em múltiplos núcleos de CPU.

---

👉 Próximo Passo: Analise o código completo da classe DirectBitmap.cs.