Bitmap taille en octets après le décodage?

Comment puis-je déterminer/calculer la taille en octets d'une image bitmap (après décodage avec BitmapFactory)?
J'ai besoin de savoir combien d'espace mémoire qu'elle occupe, parce que je suis en train de faire de la mémoire cache et de la gestion de mon application. (la taille du fichier n'est pas suffisant, car ce sont des jpg/png)

Merci pour toutes les solutions!

Mise à jour: getRowBytes * getHeight pourrait faire l'affaire.. je vais la mettre en œuvre cette manière jusqu'à ce que quelqu'un arrive avec quelque chose contre elle.

InformationsquelleAutor user289463 | 2010-03-09

android bitmap

113

getRowBytes() * getHeight() semble bien fonctionner pour moi.

Mise à jour de mon ~2 ans réponse:
Depuis l'API de niveau 12 image a une façon directe à la requête de la taille en octets:
http://developer.android.com/reference/android/graphics/Bitmap.html#getByteCount%28%29

----Exemple de code
```
    @TargetApi(Build.VERSION_CODES.HONEYCOMB_MR1)
    protected int sizeOf(Bitmap data) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR1) {
            return data.getRowBytes() * data.getHeight();
        } else {
            return data.getByteCount();
        }
    }
```
- Essayé comme ceci: original = BitmapFactory.decodeStream(getAssets().open("hd.jpg")); sizeOf(original); ByteArrayOutputStream out = new ByteArrayOutputStream(); original.compresser(Bitmap.CompressFormat.WEBP, 50, out); Bitmap décodé = BitmapFactory.decodeStream(nouveau ByteArrayInputStream(en dehors.toByteArray())); sizeOf(décodé); Lorsque je debug à l'intérieur de votre méthode, j'obtiens le même nombre d'octets, même lorsque la deuxième image est compressée! Tous les commentaires?
- Une image Bitmap contient toujours l'image non compressée. La Compression n'est utilisée pour réduire une image pour sauvegarder un fichier.
- le temps de mettre à jour et ajouter le kitkat méthode de getAllocationByteCount(). Voir developer.android.com/reference/android/graphics/...
- j'ai une image, mais si je le lance en deux image, puis dans les deux appareil je m obtenir la taille d'image différente de raison d'être? par exemple, dans Galaxy S Duos donne 656 KO et en MOTO G dispositif de retour 1136 KO
- Votre samsung dispose d'un hdpi écran et la moto un xhdpi, de sorte qu'il charge les ressources de différentes tailles sur ces modèles. Découvrez le display de google densitiy seau doc.
- excellente réponse
- Je suis d'allocation nombre d'octets 3145728 à l'aide de BitmapCompat.getAllocationByteCount(scaledBitmap). Mais la taille réelle est 207kB. Ce que je fais mal?
InformationsquelleAutor user289463
41

Il est donc préférable d'utiliser la bibliothèque de prise en charge:
```
int bitmapByteCount=BitmapCompat.getAllocationByteCount(bitmap)
```
Mais si vous avez le projet Android pour utiliser au moins minSdk de 19 (kitkat, sens 4.4), vous pouvez simplement utiliser bitmap.getAllocationByteCount() .
- Belle prise! Merci
- Je suis d'allocation nombre d'octets 3145728 à l'aide de BitmapCompat.getAllocationByteCount(scaledBitmap). Mais la taille réelle est 207kB. Ce que je fais mal?
- Taille réelle de ce à quoi? Si tu parles de la taille du fichier, il est logique, car le fichier est compressé. Personne ne ces jours-ci permettra de mettre l'image dans un fichier sans l'enregistrer en JPG, PNG, WEBP. Les fichiers ne sont pas censés prendre la même taille que l'image décodée. L'estimation de nombre d'octets pour chaque image est width*height*bytesPerPixel , où bytesPerPixel est généralement de 4 ou 2. Cela signifie que si vous avez un 1000x1000 de l'image, il peut prendre 4*1000*1000= 4 000 000 d'octets, sens ~4 MO.
- J'ai une image dans ma onactivityResult et je veux vérifier la taille de l'image et de vérifier si la taille est supérieure à 5 mo ou pas et puis de l'envoyer à mon serveur si moins de 5 mo sinon demande à l'utilisateur de prendre une nouvelle photo.
- Vous envoyez un fichier image sur le serveur. C'est généralement JPEG,PNG, WEBP... Tous ceux qui prennent généralement moins de 5 mo d'espace de stockage, car ils sont compressés. Ils ont aussi presque toujours de prendre moins d'espace de stockage que l'image bitmap prend dans la mémoire. Il suffit de vérifier la taille du fichier après que vous avez créé à l'aide de file.length : developer.android.com/reference/java/io/File.html#length() . Il n'a rien à voir avec l'image bitmap. La résolution de l'image bitmap peut être énorme ou petit. De quoi vous parlez c'est le fichier lui-même.
- Merci @androiddeveloper pour obtenir des éclaircissements.
- Si vous avez plus de questions à ce sujet, vous êtes libre de demander 🙂
- J'ai sur Android d'autres questions. Pouvez-vous m'aider?
- Bien sûr, poser une nouvelle question ici, au lieu d'un commentaire, et je vais voir ce que je peux faire. Si vous avez un rapport de bug sur Android ou suggestion, vous pouvez écrire ici: issuetracker.google.com/issues
InformationsquelleAutor android developer
21

Ici est la 2014 version qui utilise KitKat est getAllocationByteCount() et est écrit de telle sorte que le compilateur comprend la version logique (donc @TargetApi n'est pas nécessaire)
```
/**
 * returns the bytesize of the give bitmap
 */
public static int byteSizeOf(Bitmap bitmap) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        return bitmap.getAllocationByteCount();
    } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1) {
        return bitmap.getByteCount();
    } else {
        return bitmap.getRowBytes() * bitmap.getHeight();
    }
}
```
À noter que le résultat de getAllocationByteCount() peut être plus grand que le résultat de getByteCount() si une image bitmap est réutilisé pour décoder d'autres images de plus petite taille, ou par reconfiguration manuelle.
- Oui, Picasso également utiliser cette fonction pour calculer la taille du bitmap.
- Je suis d'allocation nombre d'octets 3145728 à l'aide de BitmapCompat.getAllocationByteCount(scaledBitmap). Mais la taille réelle est 207kB. Ce que je fais mal?
InformationsquelleAutor patrickf
5
```
public static int sizeOf(Bitmap data) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR1) {
        return data.getRowBytes() * data.getHeight();
    } else if (Build.VERSION.SDK_INT<Build.VERSION_CODES.KITKAT){
        return data.getByteCount();
    } else{
        return data.getAllocationByteCount();
    }
}
```
La seule différence avec @user289463 réponse, est l'utilisation de getAllocationByteCount() pour KitKat et versions supérieures.
- Je suis d'allocation nombre d'octets 3145728 à l'aide de BitmapCompat.getAllocationByteCount(scaledBitmap). Mais la taille réelle est 207kB. Ce que je fais mal?
- Que 207kB valeur est la taille du fichier compressé quand il est stocké sur le disque. Lorsqu'il est chargé dans la mémoire, il est décompressé et utilise le nombre d'octets que vous obtenez à partir de la fonction.
InformationsquelleAutor ahmed_khan_89

Vous devez vous connecter pour publier un commentaire.