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 MBMesma 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:
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.
- 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/UIImageapoiado por umCGBitmapContext, onde você escolhebitsPerComponente umCGColorSpace. Um colorspace em escala de cinza sem alfa dá o mesmo 1 byte/pixel queALPHA_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 umUint8ClampedArraymanualmente 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, eR8(um único canal vermelho/luminância) espelhamBitmap.Configquase um para um.R8é o equivalente em textura de GPU deALPHA_8para 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.



