Recomposed
Canvas

Fondamentaux du bitmap : buffers de pixels, octets, et pourquoi la taille du fichier ne dit rien

Oct 16, 2026 · 5 min read

Fondamentaux du bitmap : buffers de pixels, octets, et pourquoi la taille du fichier ne dit rien

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 MB

Mê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 :

FIG. 01
ARGB_8888: four bytes encode one pixel, in memory order

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.

FIG. 02
Decode breaks the link between file size and memory
  • 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/UIImage adossé à un CGBitmapContext, où vous choisissez bitsPerComponent et un CGColorSpace. Un espace de couleurs en niveaux de gris sans alpha donne le même 1 octet/pixel que ALPHA_8.
  • Web/Canvas : ImageData est toujours en RGBA à 4 octets/pixel, sans option native plus petite. Obtenir une économie en niveaux de gris signifie empaqueter un Uint8ClampedArray à 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, et R8 (un seul canal rouge/luminance) reflètent Bitmap.Config presque à l'identique. R8 est l'équivalent en texture GPU de ALPHA_8 pour 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é.

Keep reading

Related reads

Recevez les nouveaux articles par e-mail