Wie zu komprimieren Bitmap als JPEG mit der geringsten Qualitätsverlust auf Android?

Nach einigen Untersuchungen fand ich die Schuldige: Skia ist YCbCr-Konvertierung. Repro, code für die Untersuchung und Lösungen können gefunden werden bei TWiStErRob/AndroidJPEG.

Entdeckung

Nach nicht immer eine positive Antwort auf diese Frage (weder aus http://b.android.com/206128) ich begann, tiefer zu Graben. Fand ich zahlreiche halb-informiert SO Antworten, das half mir enorm bei der Entdeckung bits und Stücke. Eine solche Antwort war https://stackoverflow.com/a/13055615/253468 das machte mir bewusst YuvImage wandelt ein YUV NV21 byte-array in eine JPEG-komprimierte byte-array:

YuvImage yuv = new YuvImage(yuvData, ImageFormat.NV21, width, height, null);
yuv.compressToJpeg(new Rect(0, 0, width, height), 100, jpeg);

Es gibt eine Menge von Freiheit geht in die Schaffung der YUV-Daten, die mit unterschiedlichen Konstanten und Präzision. Aus meine Frage, ist es klar, dass Android verwendet einen falschen Algorithmus.
Während der Wiedergabe, um mit den algorithmen und Konstanten, die ich online gefunden haben, bekam ich immer ein schlechtes image: entweder die Helligkeit verändert, oder hatte das gleiche banding-Probleme wie in der Frage.

, Tiefer zu Graben

YuvImage ist eigentlich nicht die beim Aufruf Bitmap.compress, hier ist der Stapel für Bitmap.compress:

• libjpeg/jpeg_write_scanlines(jcapistd.c:77)
• skia -/rgb2yuv_32 (SkImageDecoder_libjpeg.cpp:913)
• skia -/writer(=Write_32_YUV).write (SkImageDecoder_libjpeg.cpp:961)
  
  [WE_CONVERT_TO_YUV bedingungslos definiert]
• SkJPEGImageEncoder::onEncode(SkImageDecoder_libjpeg.cpp:1046)
• SkImageEncoder::encodeStream(SkImageEncoder.cpp:15)
• Bitmap_compress(Bitmap.cpp:383)
• Bitmap.nativeCompress(Bitmap.java:1573)
• Bitmap.compress(Bitmap.java:984)
• app.saveBitmapAsJPEG()

und der Stapel für die Verwendung YuvImage

• libjpeg/jpeg_write_raw_data(jcapistd.c:120)
• YuvToJpegEncoder::compress(YuvToJpegEncoder.cpp:71)
• YuvToJpegEncoder::encode(YuvToJpegEncoder.cpp:24)
• YuvImage_compressToJpeg(YuvToJpegEncoder.cpp:219)
• YuvImage.nativeCompressToJpeg(YuvImage.java:141)
• YuvImage.compressToJpeg(YuvImage.java:123)
• app.saveNV21AsJPEG()

Durch die Verwendung der Konstanten in rgb2yuv_32 von der Bitmap.compress flow ich war in der Lage, neu zu erstellen die gleichen banding-Effekt mit YuvImage, nicht eine Errungenschaft, nur eine Bestätigung, dass es tatsächlich die YUV-Konvertierung, die ist versaut. Ich doppelt überprüft, dass das problem nicht bei YuvImage aufrufen libjpeg: durch die Umwandlung der ARGB-Bitmap nach YUV und wieder zurück nach RGB, dann dumping die daraus resultierende pixel-blob als ein raw-Bild, das banding war schon da.

Während dies zu tun ich erkannte, dass die NV21/YUV420SP layout ist verlustbehaftet, wie es die Proben, die die Farbinformationen jedes 4. pixel, aber es hält den Wert (Helligkeit) der einzelnen pixel, was bedeutet, dass einige Farb-info ist verloren, aber die meisten der Informationen, die für die Augen der Menschen sind in der Helligkeit sowieso. Werfen Sie einen Blick auf die Beispiel auf wikipedia, die Cb-und Cr-Kanal macht kaum erkennbare Bilder, so lossy-sampling-es spielt keine Rolle, viel.

Lösung

So, an diesem Punkt wusste ich, dass libjpeg nicht die richtige Konvertierung, wenn es übergeben wird, werden die raw-Daten. Dies ist, wenn ich die NDK und integriert die neueste LibJPEG aus http://www.ijg.org. Ich war in der Lage zu bestätigen, dass in der Tat die übergabe der RGB-Daten aus der Bitmap-Pixel-array liefert das erwartete Ergebnis. Ich mag vermeiden Sie die Verwendung von einheitlichen Komponenten, wenn nicht absolut notwendig, so dass abgesehen von gehen für eine native Bibliothek kodiert, dass ein Bitmap-fand ich eine nette Abhilfe. Ich habe im Grunde genommen die rgb_ycc_convert Funktion von jcolor.c und schrieb es in Java das Skelett aus https://stackoverflow.com/a/13055615/253468. Die Tabelle ist nicht auf Geschwindigkeit optimiert, aber die Lesbarkeit einige Konstanten wurden aus Gründen der Kürze entfernt, finden Sie diese in libjpeg-code oder mein Beispiel-Projekt.

private static final int JSAMPLE_SIZE = 255 + 1;
private static final int CENTERJSAMPLE = 128;
private static final int SCALEBITS = 16;
private static final int CBCR_OFFSET = CENTERJSAMPLE << SCALEBITS;
private static final int ONE_HALF = 1 << (SCALEBITS - 1);

private static final int[] rgb_ycc_tab = new int[TABLE_SIZE];
static { //rgb_ycc_start
    for (int i = 0; i <= JSAMPLE_SIZE; i++) {
        rgb_ycc_tab[R_Y_OFFSET + i] = FIX(0.299) * i;
        rgb_ycc_tab[G_Y_OFFSET + i] = FIX(0.587) * i;
        rgb_ycc_tab[B_Y_OFFSET + i] = FIX(0.114) * i + ONE_HALF;
        rgb_ycc_tab[R_CB_OFFSET + i] = -FIX(0.168735892) * i;
        rgb_ycc_tab[G_CB_OFFSET + i] = -FIX(0.331264108) * i;
        rgb_ycc_tab[B_CB_OFFSET + i] = FIX(0.5) * i + CBCR_OFFSET + ONE_HALF - 1;
        rgb_ycc_tab[R_CR_OFFSET + i] = FIX(0.5) * i + CBCR_OFFSET + ONE_HALF - 1;
        rgb_ycc_tab[G_CR_OFFSET + i] = -FIX(0.418687589) * i;
        rgb_ycc_tab[B_CR_OFFSET + i] = -FIX(0.081312411) * i;
    }
}

static void rgb_ycc_convert(int[] argb, int width, int height, byte[] ycc) {
    int[] tab = LibJPEG.rgb_ycc_tab;
    final int frameSize = width * height;

    int yIndex = 0;
    int uvIndex = frameSize;
    int index = 0;
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int r = (argb[index] & 0x00ff0000) >> 16;
            int g = (argb[index] & 0x0000ff00) >> 8;
            int b = (argb[index] & 0x000000ff) >> 0;

            byte Y = (byte)((tab[r + R_Y_OFFSET] + tab[g + G_Y_OFFSET] + tab[b + B_Y_OFFSET]) >> SCALEBITS);
            byte Cb = (byte)((tab[r + R_CB_OFFSET] + tab[g + G_CB_OFFSET] + tab[b + B_CB_OFFSET]) >> SCALEBITS);
            byte Cr = (byte)((tab[r + R_CR_OFFSET] + tab[g + G_CR_OFFSET] + tab[b + B_CR_OFFSET]) >> SCALEBITS);

            ycc[yIndex++] = Y;
            if (y % 2 == 0 && index % 2 == 0) {
                ycc[uvIndex++] = Cr;
                ycc[uvIndex++] = Cb;
            }
            index++;
        }
    }
}

static byte[] compress(Bitmap bitmap) {
    int w = bitmap.getWidth();
    int h = bitmap.getHeight();
    int[] argb = new int[w * h];
    bitmap.getPixels(argb, 0, w, 0, 0, w, h);
    byte[] ycc = new byte[w * h * 3 / 2];
    rgb_ycc_convert(argb, w, h, ycc);
    argb = null; //let GC do its job
    ByteArrayOutputStream jpeg = new ByteArrayOutputStream();
    YuvImage yuvImage = new YuvImage(ycc, ImageFormat.NV21, w, h, null);
    yuvImage.compressToJpeg(new Rect(0, 0, w, h), quality, jpeg);
    return jpeg.toByteArray();
}

Der Magische Schlüssel zu sein scheint ONE_HALF - 1 der rest sieht schrecklich viel wie die Mathematik in Skia. Das ist eine gute Richtung für zukünftige Untersuchungen, aber für mich ist das oben genannte ist einfach genug, um eine gute Lösung für die Arbeit rund um Android builtin Skurrilität, wenn auch langsamer. Beachten Sie, dass diese Lösung nutzt die NV21 layout, das verliert 3/4 der Farb-info (von der Cr/Cb), aber dieser Verlust ist wesentlich kleiner als der Fehler durch Trennen der math. Beachten Sie auch, dass YuvImage keine Unterstützung für odd-sized Bilder, für weitere Infos siehe NV21-format und ungerade Bild-Dimensionen.

InformationsquelleAutor TWiStErRob

Unten ist mein Code:

public static String compressImage(Context context, String imagePath)
{

    final float maxHeight = 1024.0f;
    final float maxWidth = 1024.0f;
    Bitmap scaledBitmap = null;
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    Bitmap bmp = BitmapFactory.decodeFile(imagePath, options);
    int actualHeight = options.outHeight;
    int actualWidth = options.outWidth;
    float imgRatio = (float) actualWidth / (float) actualHeight;
    float maxRatio = maxWidth / maxHeight;
    if (actualHeight > maxHeight || actualWidth > maxWidth) {
        if (imgRatio < maxRatio) {
            imgRatio = maxHeight / actualHeight;
            actualWidth = (int) (imgRatio * actualWidth);
            actualHeight = (int) maxHeight;
        } else if (imgRatio > maxRatio) {
            imgRatio = maxWidth / actualWidth;
            actualHeight = (int) (imgRatio * actualHeight);
            actualWidth = (int) maxWidth;
        } else {
            actualHeight = (int) maxHeight;
            actualWidth = (int) maxWidth;
        }
    }
    options.inSampleSize = calculateInSampleSize(options, actualWidth, actualHeight);
    options.inJustDecodeBounds = false;
    options.inDither = false;
    options.inPurgeable = true;
    options.inInputShareable = true;
    options.inTempStorage = new byte[16 * 1024];
    try {
        bmp = BitmapFactory.decodeFile(imagePath, options);
    } catch (OutOfMemoryError exception) {
        exception.printStackTrace();
    }
    try {
        scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.RGB_565);
    } catch (OutOfMemoryError exception) {
        exception.printStackTrace();
    }
    float ratioX = actualWidth / (float) options.outWidth;
    float ratioY = actualHeight / (float) options.outHeight;
    float middleX = actualWidth / 2.0f;
    float middleY = actualHeight / 2.0f;
    Matrix scaleMatrix = new Matrix();
    scaleMatrix.setScale(ratioX, ratioY, middleX, middleY);
    assert scaledBitmap != null;
    Canvas canvas = new Canvas(scaledBitmap);
    canvas.setMatrix(scaleMatrix);
    canvas.drawBitmap(bmp, middleX - bmp.getWidth() / 2, middleY - bmp.getHeight() / 2, new Paint(Paint.FILTER_BITMAP_FLAG));
    if (bmp != null) {
        bmp.recycle();
    }
    ExifInterface exif;
    try {
        exif = new ExifInterface(imagePath);
        int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 0);
        Matrix matrix = new Matrix();
        if (orientation == 6) {
            matrix.postRotate(90);
        } else if (orientation == 3) {
            matrix.postRotate(180);
        } else if (orientation == 8) {
            matrix.postRotate(270);
        }
        scaledBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);
    } catch (IOException e) {
        e.printStackTrace();
    }
    FileOutputStream out = null;
    String filepath = getFilename(context);
    try {
        out = new FileOutputStream(filepath);
        scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 80, out);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }
    return filepath;
}

public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
    final int height = options.outHeight;
    final int width = options.outWidth;
    int inSampleSize = 1;
    if (height > reqHeight || width > reqWidth) {
        final int heightRatio = Math.round((float) height / (float) reqHeight);
        final int widthRatio = Math.round((float) width / (float) reqWidth);
        inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
    }
    final float totalPixels = width * height;
    final float totalReqPixelsCap = reqWidth * reqHeight * 2;
    while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
        inSampleSize++;
    }
    return inSampleSize;
}


public static String getFilename(Context context) {
    File mediaStorageDir = new File(Environment.getExternalStorageDirectory()
            + "/Android/data/"
            + context.getApplicationContext().getPackageName()
            + "/Files/Compressed");

    if (!mediaStorageDir.exists()) {
        mediaStorageDir.mkdirs();
    }
    String mImageName = "IMG_" + String.valueOf(System.currentTimeMillis()) + ".jpg";
    return (mediaStorageDir.getAbsolutePath() + "/" + mImageName);
}

InformationsquelleAutor Er. Praful Parmar