L'intuition
La taille d'un fichier sur disque et la taille d'un bitmap décodé en mémoire semblent être le même nombre, juste à une échelle différente. Ils n'ont pourtant aucun rapport.
- Un bitmap décodé est une grille plate de pixels posée en RAM, sans aucune trace de la compression qui l'a produite.
- Son coût mémoire est une pure arithmétique :
largeur × hauteur × octets-par-pixel. Rien du fichier original n'entre dans cette formule. - C'est pourquoi un minuscule JPEG tout droit sorti d'un appareil photo de téléphone peut exploser en dizaines de mégaoctets une fois décodé, tandis qu'un énorme fichier peut se décoder en presque rien.
Mêmes pixels, nombre d'octets différent
La partie de la formule que vous contrôlez réellement, c'est le nombre
d'octets par pixel, via Bitmap.Config. Même image, mêmes dimensions,
configuration différente :
val width = 4000
val height = 3000
// ARGB_8888: 4 bytes/pixel, stored in memory as R, G, B, A (the name
// describes the int-packing order, not the raw byte order)
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, no alpha channel at all
val half = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565)
half.byteCount // 4000 * 3000 * 2 = 24,000,000 bytes ≈ 23 MBMême grille de pixels, mêmes dimensions, moitié moins de mémoire, parce que ce qui a changé c'est le nombre d'octets par pixel, pas le nombre de pixels. Chaque pixel est un groupe d'octets de taille fixe, stocké ligne par ligne dans un seul bloc de mémoire plat :
La taille du fichier et la mémoire décodée sont des nombres sans rapport
La taille compressée d'un fichier et le coût mémoire décodé de cette même image proviennent de deux étapes différentes du pipeline, et ils n'évoluent pas ensemble.
- La taille du fichier dépend du contenu. Une photo de bruit se compresse mal, un ciel uniforme se compresse à presque rien, et aucune des deux n'a de relation fixe avec les dimensions en pixels.
- La mémoire décodée ne dépend que des dimensions en pixels et du
nombre d'octets par pixel. Au moment où vous tenez un
Bitmap, la compression a disparu. Ce ne sont à nouveau que des nombres dans un tableau.
Si vous avez déjà rencontré une OutOfMemoryError qui n'avait aucun sens
vu la petite taille du fichier d'asset, voici pourquoi : un JPEG de 20 Ko
tout droit sorti d'un appareil photo de téléphone peut faire 4000 × 3000
pixels, ce qui se décode en 4000 × 3000 × 4 ≈ 46 Mo en ARGB_8888. Le
fichier faisait 20 Ko. Ce que vous tenez en RAM fait 46 Mo. La taille du
fichier n'a jamais été le nombre qui comptait, les dimensions en pixels,
si.
The fundamental
Un bitmap est un : un bloc de mémoire plat, , où
chaque pixel occupe le même nombre fixe d'octets. La mémoire totale est
déterministe, largeur × hauteur × octets-par-pixel, et elle est
entièrement découplée de la taille du fichier compressé qui l'a produite.
Le nombre d'octets par pixel est un compromis selon deux axes : combien de canaux vous conservez (alpha, RGB, ou simplement la luminance), et combien de bits par canal (8, 5/6, ou 16 bits en flottant). Réduisez l'un ou l'autre de ces axes et le buffer de pixels devient plus petit. La résolution de l'image, elle, n'a pas changé d'un pouce.
Ailleurs : même fondamental, framework différent
- iOS :
CGImage/UIImageadossé à unCGBitmapContext, où vous choisissezbitsPerComponentet unCGColorSpace. Un espace de couleurs en niveaux de gris sans alpha donne le même 1 octet/pixel queALPHA_8. - Web/Canvas :
ImageDataest toujours en RGBA à 4 octets/pixel, sans option native plus petite. Obtenir une économie en niveaux de gris signifie empaqueter unUint8ClampedArrayà 1 octet/pixel à la main et le dessiner vous-même. - PNG, sur disque plutôt qu'en mémoire : a des types de couleurs explicites pour la même idée : Vraies couleurs+Alpha (4 octets), Vraies couleurs (3 octets), Niveaux de gris (1 octet), Indexé/palette (1 octet plus une table de correspondance). Même compromis sur le nombre de canaux, simplement persisté plutôt que vivant en RAM.
- Textures GPU (OpenGL/Vulkan) : des formats comme
RGBA8,RGB565, etR8(un seul canal rouge/luminance) reflètentBitmap.Configpresque à l'identique.R8est l'équivalent en texture GPU deALPHA_8pour les niveaux de gris.
Là où ça coince vraiment
Décoder en pleine résolution quand vous n'avez besoin que d'une miniature gaspille exactement la mémoire contre laquelle l'intro mettait en garde
BitmapFactory.decodeFile()/decodeResource() décode aux dimensions
natives en pixels de l'image par défaut, quelle que soit la petitesse de
l'ImageView qui l'affichera. Charger une photo de 4000 × 3000 dans un
avatar de 120dp alloue tout de même le buffer ARGB_8888 complet
d'environ 46 Mo, puis en jette la plus grande partie dès que la vue le
redimensionne vers le bas.
Lisez d'abord les dimensions, sans aucune allocation de pixels, et passez
un inSampleSize calculé au vrai décodage :
val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
BitmapFactory.decodeFile(path, bounds) // outWidth/outHeight only, no pixel bytes allocated
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 divise les deux dimensions avant le décodage, donc la
mémoire chute avec le carré du facteur : inSampleSize = 4 transforme un
décodage de 46 Mo en environ 2,9 Mo. La formule de l'intro, largeur × hauteur × octets-par-pixel, n'a pas changé, elle tourne juste sur une
largeur et une hauteur plus petites.
Un bitmap recyclé plante à la prochaine lecture, pas à l'appel de recycle()
Les bibliothèques de chargement d'images et les caches personnalisés
peuvent appeler recycle() sur un Bitmap pour libérer sa mémoire
native immédiatement plutôt que d'attendre le GC. Le plantage ne se
produit pas à cet endroit, il se produit plus tard, dès que quelque chose
qui détient encore cette référence appelle getPixels() ou le dessine :
IllegalStateException: Can't call getPixels() on a recycled bitmap.
Vérifiez bitmap.isRecycled() avant de toucher un Bitmap qui a survécu
à une éviction de cache ou à une recréation après un changement de
configuration, plutôt que d'envelopper chaque accès aux pixels dans un
try/catch après coup.
Lire des pixels bruts avec une largeur de ligne erronée gauchit l'image en diagonale
Les plateformes peuvent aligner chaque ligne sur une limite de mémoire
pour des raisons d'efficacité matérielle, donc
est parfois plus grand que width * bytesPerPixel. Bitmap.getRowBytes()
renvoie la vraie valeur. Calculez votre propre width * bytesPerPixel à la
place et utilisez-le pour parcourir un buffer de pixels bruts, et l'image
ressort progressivement gauchie, parce que chaque ligne après la première
est décalée par un padding dont vous n'avez jamais tenu compte.
Un pixel rouge semi-transparent n'est pas stocké comme (255, 0, 0, 128)
Les bitmaps Android stockent les valeurs RVB déjà multipliées par l'alpha, ce qu'on appelle . Mélangez manuellement les octets de pixels sans en tenir compte, et les bords semi-transparents ressortent délavés ou assombris, parce que vous mettez à l'échelle une seconde fois des valeurs de couleur déjà mises à l'échelle.
getPixels() lève une exception sur un bitmap HARDWARE
Depuis Android 8, BitmapFactory peut décoder directement dans la mémoire
du GPU pour un affichage rapide. C'est excellent pour la mémoire, puisque
les pixels ne touchent jamais ni le tas Java ni le tas natif, mais cela
signifie aussi que vous ne pouvez pas appeler getPixels() ni dessiner
dedans avec un Canvas logiciel. Le code qui suppose que chaque Bitmap
est lisible casse la première fois qu'il en rencontre un.
Chacun de ces pièges, dimensionner le décodage, choisir une configuration, le pooling et le recyclage, c'est exactement ce qu'une bibliothèque de chargement d'images comme Coil ou Glide automatise. Elles ne contournent pas cette arithmétique, elles la calculent simplement pour vous derrière un request builder.
La mémoire d'un bitmap, c'est largeur × hauteur × octets-par-pixel,
point final. Rien dans le fichier qui l'a produit, ni dans le format dont
il est parti, ne change cette arithmétique une fois décodé.



