Comment savoir une image Bitmap taille de InputStream avant la création de l'image Bitmap?

J'ai besoin de redimensionner une image avant de la créer et je veux le faire uniquement si elle est supérieure à 1024 KB (par exemple).

En procédant ainsi je peux l'échelle de l'image mais j'ai seulement besoin de l'échelle, ceux qui sont plus grand que la taille donnée.

Bitmap bmImg = null;
InputStream is = url.openStream();
BitmapFactory.Options opts = new BitmapFactory.Options();
opts.inSampleSize = 10;
bmImg = BitmapFactory.decodeStream(is,null,opts);

Comment puis-je obtenir la taille de l'image? (Je suis heureux de savoir la quantité d'octets, et non pas la taille après la décompression).

Edit:

J'essaie ceci:

BitmapFactory.Options opts = new BitmapFactory.Options();
opts.inJustDecodeBounds = true;
Bitmap bmImg=BitmapFactory.decodeStream(is,null,opts);
Log.e("optwidth",opts.outWidth+"");
Bitmap bmImg1 = BitmapFactory.decodeStream(is);

La première fois que j'utilise l'InputStream (est) pour le décoder avec la "inJustDecodeBounds" fonctionne très bien et je peux obtenir des dimensions de l'image Bitmap.
Le problème est que la deuxième fois que je l'utilise pour en mesure de décoder l'image, aucune image n'est affichée.

Ce que je fais mal?

OriginalL'auteur sergi | 2011-01-08

  1. 5

    Je suis un noob donc je ne peux pas commenter sur monkjack de répondre directement. La raison, sa réponse est si lent, c'est que c'est la copie d'un octet à la fois. À l'aide d'un tampon de même 1K de manière significative à améliorer les performances.

    InputStream in = getContentResolver().openInputStream(docUri);

ByteArrayOutputStream bos = new ByteArrayOutputStream();
int i;
byte[] buffer = new byte[1024];
while ((i = in.read(buffer)) != -1) {
    bos.write(buffer);
}
byte[] docbuffer = bos.toByteArray();
    vous devez accepter cette réponse
    Cela ne fonctionnera pas si l'objectif de réduction est de prévenir les OutOfMemoryException.

    OriginalL'auteur Scott Roberts

  2. 2

    Si vous connaissez le format du fichier que vous pourriez être en mesure de lire l'en-tête du fichier. Habituellement l'en-tête contient la taille et le format de l'image. Et heureusement pour vous, c'est toujours les premiers octets du fichier.

    Il pourrait ne pas être possible pour certains types.

    PNG, JPEG, BMP, TGA

    Viens de lire sur l'en-tête et le fichier que vous pourriez avoir à deviner la largeur d'abord. Par exemple, le format PNG ne semble pas inclure largeur/hauteur, mais vous devriez être capable de lire de la largeur et de deviner une hauteur avec la taille de pixel /ratio.

    Edit: My bad, je pensais que tu voulais échelle à l'aide de la dimension... Ouais ContentLenght devrait aider, mais parfois, il sera de retour 0 si le serveur n'a pas mis la bonne dimension dans l'en-tête http. Dans ce cas, vous devez savoir le retour de la taille. Mais de toute façon, vous pouvez économiser de l'objet bytearray et une fois que tout est chargé, il suffit de cocher la longueur du tableau. si c'est plus grand que 1024 kb redimensionner l'image. Et de les enregistrer ou de faire ce que vous voulez avec elle.

    OriginalL'auteur Loïc Faure-Lacroix

  3. 2

    Vous pouvez envelopper is avec un new BufferedInputStream(is); et l'utilisation de la mark(int readlimit) et reset() méthodes de re-lire le flux. Vous aurez besoin de décider ce que pour définir readlimit pour lui permettre de lire l'intégralité de l'en-tête, les liens fournis par Loïc devrait aider ici.

    BufferedInputStream bis = new BufferedInputStream(is);
bis.mark(1024 * 1024);
BitmapFactory.Options opts = new BitmapFactory.Options();
opts.inJustDecodeBounds = true;
Bitmap bmImg=BitmapFactory.decodeStream(bis,null,opts);
Log.e("optwidth",opts.outWidth+"");
bis.reset();
Bitmap bmImg1 = BitmapFactory.decodeStream(bis);

    J'ai laissé de côté approprié de gestion des erreurs pour la reset() méthode, qu'il va jeter un IOException si vous avez lu plus de readlimit octets dans le flux.

    Je vais essayer cela et je suis arriver dans certaines images aléatoires: java.io.IOException: la Marque a été invalidé-je obtenir en images de 75 KO, 120 KO et pas dans les images de 45KB ou 700KB..
    le paramètre readLimit doit être égale à la bis.disponible (le), de sorte que la marque n'est pas invalidé, tandis que les flux était en train de lire pour la première décoder.

    OriginalL'auteur Adam Bryzak

  4. 2

    Si vous êtes en train d'essayer d'empêcher dépassement de mémoire ou autre chose...

    vous pouvez créer une zone tampon avec vos données d'image, 

    BitmapFactory.Options buffer = new BitmapFactory.Options();
buffer.inJustDecodeBounds = true;
BitmapFactory.decodeByteArray(photo, 0, photo.length, buffer);

    Alors vous pouvez obtenir la taille à l'aide de la mémoire tampon.outHeight, tampon.outWidth..

    Si vous souhaitez mettre à l'échelle, il suffit d'utiliser de la mémoire tampon.isSampleSize mais j'ai remarqué que vous êtes de la configuration d'un "10" de la valeur... qui je pense est faux... sampleSize devriez obtenir un 2^ valeur .. comme 2,4,8,16 etc.

    Enfin, après vous êtes sampleSize de configuration, vous pouvez créer l'image bitmap, comme toujours.

    Bitmap bmp = BitmapFactory.decodeByteArray(photo, 0, photo.length, buffer);

    de l'espoir pour vous aider!

    PS: SQS MON ANGLAIS =(!!!

    OriginalL'auteur Sergio A.

  5. 0

    Vous ne pouvez pas obtenir la taille à partir d'un flux de par sa définition. Si vous le souhaitez, vous pouvez charger le flux dans un tableau d'octets, obtenir le nombre d'octets à partir de cela. Vous pouvez également utiliser le BitmapFactory pour décoder un tableau d'octets directement, de sorte que ça va marcher très bien.

    InputStream in = ...
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int i;
while ((i = in.read()) != -1) {
    bos.write(i);
}
byte[] byteArray = bos.toByteArray();
if (byteArray.length > SOME_VALUE) { 
    //do things here
}
BitmapFactory.decodeByteArray(byteArray, 0, byteArray.length);
    Cela fonctionne réellement, mais c'est de façon plus lente.

    OriginalL'auteur monkjack

  6. 0

    La plupart des flux sont consommés, lorsque vous lisez à partir d'eux. Dans le 2ème bloc de code, vous consommez le ruisseau la première fois en tant que bitmap. Lorsque vous appelez decodeString un deuxième temps, le flux est "vide" (si seulement dans le sens que toutes les données ont déjà été lues).

    La meilleure réponse sera probablement monkjack, mais peut-être avec juste un peu de code supplémentaire pour vous assurer que vous ne sont pas de la lecture d'un gigantesque fichier dans la mémoire. Je recommande juste de vérifier que vous êtes en streaming dans une mémoire tampon de taille (c'est à dire stop à 10 MO); je ne suis pas sûr de savoir comment bien Android va gérer un souvenir d'exception.

    Le problème est que monkjack la solution est d'autant plus faible. Android juste se bloque lorsque je tente d'allouer une trop grande image.

    OriginalL'auteur NBJack

  7. 0

    Si vous êtes à la réduction d'échelle pour éviter OutOfMemoryException comme moi, cette solution peut fonctionner mieux pour vous (en fonction des réponses fournies ici):

    //<initialize stream>

//figure out number of bytes in stream
byte[] bytes = new byte[1024];
int i;
int byteCount = 0;
while ((i = stream.read(bytes)) != -1) {
    byteCount += i;
}

//<reset stream>

Bitmap bmImg;

//downsample if necessary
if (byteCount > MAX_SIZE) {
    //scale down photo if too large
    BitmapFactory.Options options = new BitmapFactory.Options();
    //scale to nearest power of 2 - faster
    options.inSampleSize = (int)Math.pow(2, (int)(Math.log10(Math.sqrt((double)byteCount / MAX_SIZE)) / Math.log10(2) + 1)); //2 ^ (log2(lengthRatio)+1)
    options.inPreferredConfig = Bitmap.Config.ARGB_8888;
    bmImg = BitmapFactory.decodeStream(stream, null, options);
}
else {
    bmImg = BitmapFactory.decodeStream(stream);
}

    J'ai évité l'utilisation de mark(int) et reset() parce que dans mon cas il n'y a pas de limite supérieure à la taille du cours d'eau. Donc comment faire pour réinitialiser le flux dépend de votre mise en œuvre. Mon stream a été spécifié par un Uri, donc j'ai simplement utilisé:

    stream.close();
stream = this.getContentResolver().openInputStream(uri); //where this is an Activity

    pour réinitialiser le flux.

    OriginalL'auteur Ken

  8. 0

    Vérifier logcat, si vous avez une erreur qui dit que "Bitmap too large to be uploaded into a texture" alors vous devez faire ce qui suit. Ma réponse est similaire à @Sergio A. mais vous pouvez utiliser BitmapFactory.decodeStream directement au lieu de decodeByteArray.

    final BitmapFactory.options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;

//Pass in a Rect if you want to know the padding.
BitmapFactory.decodeStream(inputStream,null,options);

    Cela permet d'obtenir juste la taille de l'image (pas la totalité de l'image elle-même). Vous pouvez isoler la largeur et la hauteur en utilisant le code suivant.

    final int height = options.outHeight;
final int width = options.outWidth;

    Vous pouvez utiliser ces valeurs (avec votre largeur et la hauteur désirées - le plus probable en fonction de l'imageView ou de l'écran) pour calculer options.inSampleSize. Je ne vais pas aller dans la façon de le faire, mais Google a fourni un tutoriel ici.

    Espère que cela aide 🙂

    OriginalL'auteur sotrh

  9. -2

    Vous ne pouvez pas obtenir la taille d'une image bitmap, il n'est tout simplement pas un construit en. Vous pouvez toutefois obtenir la taille du contenu (un fichier), qui est ce que vous aurez probablement besoin de le faire. Quelque chose comme cela devrait fonctionner.

    int file_size = url.getContentLength();
    l'url est de quel type? Je ne trouve pas cette méthode en java.net.URL
    Cet utilisateur est en réalité référence à URLConnection voir ici. Mais cette méthode n'est vraiment pas recommandé.. il s'appuie sur le serveur fournissant un Contenu valide en-tête de Longueur (et cet en-tête peut être trompeur si les données sont compressées par exemple).

    OriginalL'auteur user432209