Recomposed
Canvas

Fundamentos de Bitmap: Buffers de Pixel, Layout de Bytes e Por Que o Tamanho do Arquivo Engana

Oct 16, 2026 · 5 min read

Fundamentos de Bitmap: Buffers de Pixel, Layout de Bytes e Por Que o Tamanho do Arquivo Engana

A intuição

O tamanho de um arquivo em disco e o tamanho de um bitmap decodificado na memória parecem ser o mesmo número, só em escalas diferentes. Eles não têm relação alguma.

  • Um bitmap decodificado é uma grade plana de pixels sentada na RAM, sem nenhuma memória da compressão que o gerou.
  • Seu custo de memória é pura aritmética: largura × altura × bytes-por-pixel. Nada do arquivo original entra nessa fórmula.
  • É por isso que um JPEG minúsculo direto da câmera de um celular pode se transformar em dezenas de megabytes depois de decodificado, enquanto um arquivo enorme pode decodificar para quase nada.

Mesmos pixels, contagem de bytes diferente

A parte da fórmula que você realmente controla é bytes-por-pixel, via Bitmap.Config. Mesma imagem, mesmas dimensões, configuração diferente:

val width = 4000
val height = 3000
 
// ARGB_8888: 4 bytes/pixel, armazenado na memória como R, G, B, A (o nome
// descreve a ordem de empacotamento do int, não a ordem bruta dos bytes)
val full = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
full.byteCount // 4000 * 3000 * 4 = 48,000,000 bytes ≈ 46 MB
 
// RGB_565: 2 bytes/pixel, sem canal alfa nenhum
val half = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565)
half.byteCount // 4000 * 3000 * 2 = 24,000,000 bytes ≈ 23 MB

Mesma grade de pixels, mesmas dimensões, metade da memória, porque o que mudou foi bytes-por-pixel, não a contagem de pixels. Cada pixel é um grupo de tamanho fixo de bytes, armazenado linha por linha em um único bloco plano de memória:

FIG. 01
ARGB_8888: quatro bytes codificam um pixel, em ordem de memória

Tamanho do arquivo e memória decodificada são números não relacionados

O tamanho comprimido de um arquivo e o custo de memória decodificada dessa mesma imagem vêm de dois estágios diferentes do pipeline, e eles não escalam juntos.

FIG. 02
A decodificação quebra o vínculo entre tamanho do arquivo e memória
  • Tamanho do arquivo depende do conteúdo. Uma foto de ruído comprime mal, um céu em branco comprime para quase nada, e nenhum dos dois tem uma relação fixa com as dimensões em pixels.
  • Memória decodificada depende apenas das dimensões em pixels e de bytes-por-pixel. No momento em que você está segurando um Bitmap, a compressão já desapareceu. São só números em um array de novo.

Se você já bateu em um OutOfMemoryError que não fazia sentido dado o quão pequeno era o arquivo do asset, é por isso: um JPEG de 20KB direto da câmera de um celular pode ter 4000 × 3000 pixels, o que decodifica para 4000 × 3000 × 4 ≈ 46 MB em ARGB_8888. O arquivo tinha 20KB. A coisa que você está segurando na RAM tem 46MB. O tamanho do arquivo nunca foi o número que importava, as dimensões em pixels sim.

O fundamento

Um bitmap é um : um bloco plano de memória onde cada pixel ocupa o mesmo número fixo de bytes. A memória total é determinística, largura × altura × bytes-por-pixel, e está totalmente desacoplada do tamanho do arquivo comprimido que a gerou.

Bytes-por-pixel é um trade-off ao longo de dois eixos: quantos canais você mantém (alfa, RGB, ou só luminância), e quantos bits por canal (8, 5/6, ou float de 16 bits). Reduza qualquer um dos eixos e o buffer de pixel fica menor. A resolução da imagem não mudou em nada.

Em outros lugares: mesmo fundamento, framework diferente

  • iOS: CGImage/UIImage apoiado por um CGBitmapContext, onde você escolhe bitsPerComponent e um CGColorSpace. Um colorspace em escala de cinza sem alfa dá o mesmo 1 byte/pixel que ALPHA_8.
  • Web/Canvas: ImageData é sempre RGBA a 4 bytes/pixel, sem nenhuma opção nativa menor. Conseguir uma economia em escala de cinza significa empacotar um Uint8ClampedArray manualmente a 1 byte/pixel e desenhá-lo você mesmo.
  • PNG, em disco em vez de em memória: tem tipos de cor explícitos para a mesma ideia: Truecolor+Alpha (4 bytes), Truecolor (3 bytes), Grayscale (1 byte), Indexed/palette (1 byte mais uma tabela de consulta). Mesmo trade-off de contagem de canais, só que persistido em vez de vivo na RAM.
  • Texturas de GPU (OpenGL/Vulkan): formatos como RGBA8, RGB565, e R8 (um único canal vermelho/luminância) espelham Bitmap.Config quase um para um. R8 é o equivalente em textura de GPU de ALPHA_8 para escala de cinza.

Onde isso realmente pega as pessoas

Decodificar em resolução total quando você só precisa de uma miniatura desperdiça exatamente a memória contra a qual a introdução alertou

BitmapFactory.decodeFile()/decodeResource() decodifica nas dimensões nativas em pixels da imagem por padrão, não importa quão pequena seja a ImageView que vai exibi-la. Carregar uma foto de 4000 × 3000 em um avatar de 120dp ainda aloca o buffer ARGB_8888 completo de ~46MB, e depois descarta a maior parte dele no momento em que a view a reduz.

Leia as dimensões primeiro, sem nenhuma alocação de pixel, e passe um inSampleSize calculado para a decodificação real:

val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
BitmapFactory.decodeFile(path, bounds) // apenas outWidth/outHeight, nenhum byte de pixel é alocado
 
var sampleSize = 1
while (bounds.outWidth / (sampleSize * 2) >= reqWidth &&
    bounds.outHeight / (sampleSize * 2) >= reqHeight) {
    sampleSize *= 2
}
 
val decoded = BitmapFactory.decodeFile(path, BitmapFactory.Options().apply {
    inSampleSize = sampleSize
})

inSampleSize divide as duas dimensões antes da decodificação, então a memória cai com o quadrado do fator: inSampleSize = 4 transforma uma decodificação de 46MB em cerca de 2,9MB. A fórmula da introdução, largura × altura × bytes-por-pixel, não mudou, ela só está rodando contra uma largura e altura menores.

Um bitmap reciclado quebra na próxima leitura, não na chamada de recycle()

Bibliotecas de carregamento de imagem e caches customizados podem chamar recycle() em um Bitmap para liberar sua memória nativa imediatamente, em vez de esperar o GC. O crash não acontece ali, ele acontece depois, sempre que algo que ainda guarda essa referência chama getPixels() ou desenha com ela: IllegalStateException: Can't call getPixels() on a recycled bitmap.

Verifique bitmap.isRecycled() antes de tocar em um Bitmap que sobreviveu a uma remoção de cache ou a uma recriação por mudança de configuração, em vez de envolver cada acesso a pixel em um try/catch depois do fato.

Ler pixels brutos com a largura de linha errada distorce a imagem na diagonal

Plataformas podem preencher cada linha até um limite de alinhamento por eficiência de hardware, então o às vezes é maior que width * bytesPerPixel. Bitmap.getRowBytes() retorna o valor real. Calcule seu próprio width * bytesPerPixel em vez disso e use-o para percorrer um buffer de pixel bruto, e a imagem sai progressivamente distorcida, porque cada linha depois da primeira é deslocada pelo preenchimento que você nunca considerou.

Um pixel vermelho semitransparente não é armazenado como (255, 0, 0, 128)

Bitmaps do Android armazenam valores RGB já multiplicados pelo alfa, chamado de . Misture bytes de pixel manualmente sem considerar isso e as bordas semitransparentes saem desbotadas ou escurecidas, porque você está escalando valores de cor já escalados uma segunda vez.

getPixels() lança uma exceção em um bitmap HARDWARE

Desde o Android 8, o BitmapFactory pode decodificar direto na memória da GPU para exibição rápida. Isso é ótimo para memória, já que os pixels nunca tocam o heap Java ou nativo, mas também significa que você não pode chamar getPixels() ou desenhar nele com um Canvas de software. Código que assume que todo Bitmap é legível quebra na primeira vez que encontra um desses.

Cada uma dessas pegadinhas, dimensionar a decodificação, escolher uma config, pooling e reciclagem, é exatamente o que uma biblioteca de carregamento de imagem como Coil ou Glide automatiza. Elas não contornam essa aritmética, só a calculam para você por trás de um request builder.

A memória de um bitmap é largura × altura × bytes-por-pixel, ponto final. Nada sobre o arquivo que o gerou, ou o formato em que começou, muda essa aritmética depois que ele é decodificado.

Keep reading

Related reads

Receba novos posts no seu e-mail