如何在Android上以最小的质量损失将位图压缩为JPEG？

u7up0aaq  于 2023-06-27  发布在  Android
关注(0)|答案(3)|浏览(133)
  • 这不是一个简单的问题，请仔细阅读！*

我想处理JPEG文件并将其再次保存为JPEG。问题是，即使没有操纵，也会有明显的（可见的）质量损失。问题：我缺少什么选项或API来重新压缩JPEG而不损失质量（我知道这不完全可能，但我认为我下面描述的是不可接受的伪像水平，特别是质量=100）。

控制

我从文件中将其作为Bitmap加载：

  1. BitmapFactory.Options options = new BitmapFactory.Options();
  2. // explicitly state everything so the configuration is clear
  3. options.inPreferredConfig = Config.ARGB_8888;
  4. options.inDither = false; // shouldn't be used anyway since 8888 can store HQ pixels
  5. options.inScaled = false;
  6. options.inPremultiplied = false; // no alpha, but disable explicitly
  7. options.inSampleSize = 1; // make sure pixels are 1:1
  8. options.inPreferQualityOverSpeed = true; // doesn't make a difference
  9. // I'm loading the highest possible quality without any scaling/sizing/manipulation
  10. Bitmap bitmap = BitmapFactory.decodeFile("/sdcard/image.jpg", options);

现在，为了有一个控制图像进行比较，让我们将普通位图字节保存为PNG：

  1. bitmap.compress(PNG, 100/*ignored*/, new FileOutputStream("/sdcard/image.png"));

***我将此图像与计算机上的原始JPEG图像进行了比较，没有视觉差异。

我还保存了来自getPixels的原始int[]，并将其作为原始ARGB文件加载到我的计算机上：与原始JPEG没有视觉差异，也没有从Bitmap保存的PNG。
我检查了位图的尺寸和配置，它们与源图像和输入选项匹配：它被解码为ARGB_8888，正如预期的那样。

  • 以上控制检查证明内存位图中的像素正确。*

问题

我想有JPEG文件作为结果，所以上述PNG和RAW方法将不起作用，让我们尝试保存为JPEG 100%第一：

  1. // 100% still expected lossy, but not this amount of artifacts
  2. bitmap.compress(JPEG, 100, new FileOutputStream("/sdcard/image.jpg"));
  • 我不确定它的度量是百分比，但它更容易阅读和讨论，所以我会使用它。*

我知道100%质量的JPEG仍然是有损的，但它不应该在视觉上如此有损，以至于从远处就可以看到。这是同一个源的两个100%压缩的比较。
在单独的选项卡中打开它们，在它们之间来回点击，看看我的意思。使用Gimp制作差异图像：底层为原始，中间层以“谷物提取物”模式重新压缩，顶层以“价值”模式全白色以增强不良。

  • 下面的图片被上传到Imgur，它也压缩了文件，但由于所有的图片都被压缩了，所以原始的不需要的伪影仍然可见，就像我打开原始文件时看到的那样。

原始[560 k]：x1c 0d1x Imgur与原始图像的差异（与问题无关，只是为了表明上传图像时不会导致任何 * 额外 * 伪影）：

IrfanView 100% [728 k]（视觉上与原始图像相同）：

IrfanView 100%与原始版本的差异（几乎没有任何差异）

Android 100% [942 k]：x1c4d 1x Android 100%的差异，以原来的（着色，带，涂抹）

在IrfanView中，我必须低于50% [50 k]才能看到远程类似的效果。IrfanView中的70% [100 k]没有明显的差异，但大小是Android的9分之一。

后台

我创建了一个应用程序，从相机API拍摄照片，该图像为byte[]，是一个编码的JPEG斑点。我通过OutputStream.write(byte[])方法保存了这个文件，这是我的原始源文件。decodeByteArray(data, 0, data.length, options)解码与从文件阅读相同的像素，使用Bitmap.sameAs进行测试，因此与问题无关。
我正在使用我的三星Galaxy S4与Android 4.4.2来测试。编辑：在进一步调查的同时，我还尝试了Android 6. 0和N预览模拟器，它们重现了同样的问题。

android

3条答案

按热度按时间
o0lyfsai

o0lyfsai1#

经过一番调查，我找到了罪魁祸首：Skia的YCbCr转换。复制，调查和解决方案的代码可以在TWiStErRob/AndroidJPEG找到。

发现

在这个问题上没有得到积极的回应（也没有来自http://b.android.com/206128-> https://issuetracker.google.com/issues/37092486）之后，我开始深入挖掘。我发现了许多半真半假的SO答案，这些答案极大地帮助我发现了点点滴滴。一个这样的答案是https://stackoverflow.com/a/13055615/253468，这让我意识到YuvImage可以将YUV NV 21字节数组转换为JPEG压缩字节数组：

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

创建YUV数据有很大的自由度，具有不同的常数和精度。从我的问题很明显，Android使用了一个不正确的算法。在玩我在网上找到的算法和常量时，我总是得到一个不好的形象：亮度改变或具有与问题中相同的条带问题。

深入挖掘

调用Bitmap.compress时实际上没有使用YuvImage，下面是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无条件定义]

  • 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（）

以及使用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（）

通过使用来自Bitmap.compress流的rgb2yuv_32中的常数，我能够使用YuvImage重新创建相同的条带效果，这不是一项成就，只是确认它确实是YUV转换搞砸了。我仔细检查了问题不是在YuvImage调用libjpeg期间：通过将Bitmap的ARGB转换为YUV，再转换回RGB，然后将得到的像素斑点作为原始图像转储，条带已经存在。
在这样做的时候，我意识到NV 21/YUV 420 SP布局是有损耗的，因为它每4个像素采样一次颜色信息，但它保留了每个像素的值（亮度），这意味着一些颜色信息丢失了，但人们眼睛的大部分信息都在亮度中。看看wikipedia上的example，Cb和Cr通道几乎无法识别图像，因此有损采样并不重要。

解决方案

所以，在这一点上，我知道libjpeg在传递正确的原始数据时会进行正确的转换。这是我设置NDK并集成来自http://www.ijg.org的最新LibJPEG的时候。我可以确认，从位图的像素数组传递RGB数据确实会产生预期的结果。我喜欢避免在非绝对必要的情况下使用本机组件，所以除了使用编码位图的本机库之外，我发现了一个整洁的解决方案。实际上，我从jcolor.c中提取了rgb_ycc_convert函数，并使用https://stackoverflow.com/a/13055615/253468的框架在Java中重写了它。下面的代码并不是为了速度而优化的，但是为了可读性，为了简洁，一些常量被删除了，你可以在libjpeg代码或我的示例项目中找到它们。

  1. private static final int JSAMPLE_SIZE = 255 + 1;
  2. private static final int CENTERJSAMPLE = 128;
  3. private static final int SCALEBITS = 16;
  4. private static final int CBCR_OFFSET = CENTERJSAMPLE << SCALEBITS;
  5. private static final int ONE_HALF = 1 << (SCALEBITS - 1);
  7. private static final int[] rgb_ycc_tab = new int[TABLE_SIZE];
  8. static { // rgb_ycc_start
  9.     for (int i = 0; i <= JSAMPLE_SIZE; i++) {
  10.         rgb_ycc_tab[R_Y_OFFSET + i] = FIX(0.299) * i;
  11.         rgb_ycc_tab[G_Y_OFFSET + i] = FIX(0.587) * i;
  12.         rgb_ycc_tab[B_Y_OFFSET + i] = FIX(0.114) * i + ONE_HALF;
  13.         rgb_ycc_tab[R_CB_OFFSET + i] = -FIX(0.168735892) * i;
  14.         rgb_ycc_tab[G_CB_OFFSET + i] = -FIX(0.331264108) * i;
  15.         rgb_ycc_tab[B_CB_OFFSET + i] = FIX(0.5) * i + CBCR_OFFSET + ONE_HALF - 1;
  16.         rgb_ycc_tab[R_CR_OFFSET + i] = FIX(0.5) * i + CBCR_OFFSET + ONE_HALF - 1;
  17.         rgb_ycc_tab[G_CR_OFFSET + i] = -FIX(0.418687589) * i;
  18.         rgb_ycc_tab[B_CR_OFFSET + i] = -FIX(0.081312411) * i;
  19.     }
  20. }
  22. static void rgb_ycc_convert(int[] argb, int width, int height, byte[] ycc) {
  23.     int[] tab = LibJPEG.rgb_ycc_tab;
  24.     final int frameSize = width * height;
  26.     int yIndex = 0;
  27.     int uvIndex = frameSize;
  28.     int index = 0;
  29.     for (int y = 0; y < height; y++) {
  30.         for (int x = 0; x < width; x++) {
  31.             int r = (argb[index] & 0x00ff0000) >> 16;
  32.             int g = (argb[index] & 0x0000ff00) >> 8;
  33.             int b = (argb[index] & 0x000000ff) >> 0;
  35.             byte Y = (byte)((tab[r + R_Y_OFFSET] + tab[g + G_Y_OFFSET] + tab[b + B_Y_OFFSET]) >> SCALEBITS);
  36.             byte Cb = (byte)((tab[r + R_CB_OFFSET] + tab[g + G_CB_OFFSET] + tab[b + B_CB_OFFSET]) >> SCALEBITS);
  37.             byte Cr = (byte)((tab[r + R_CR_OFFSET] + tab[g + G_CR_OFFSET] + tab[b + B_CR_OFFSET]) >> SCALEBITS);
  39.             ycc[yIndex++] = Y;
  40.             if (y % 2 == 0 && index % 2 == 0) {
  41.                 ycc[uvIndex++] = Cr;
  42.                 ycc[uvIndex++] = Cb;
  43.             }
  44.             index++;
  45.         }
  46.     }
  47. }
  49. static byte[] compress(Bitmap bitmap) {
  50.     int w = bitmap.getWidth();
  51.     int h = bitmap.getHeight();
  52.     int[] argb = new int[w * h];
  53.     bitmap.getPixels(argb, 0, w, 0, 0, w, h);
  54.     byte[] ycc = new byte[w * h * 3 / 2];
  55.     rgb_ycc_convert(argb, w, h, ycc);
  56.     argb = null; // let GC do its job
  57.     ByteArrayOutputStream jpeg = new ByteArrayOutputStream();
  58.     YuvImage yuvImage = new YuvImage(ycc, ImageFormat.NV21, w, h, null);
  59.     yuvImage.compressToJpeg(new Rect(0, 0, w, h), quality, jpeg);
  60.     return jpeg.toByteArray();
  61. }

神奇的钥匙似乎是ONE_HALF - 1，其余的看起来很像Skia中的数学。这是未来研究的一个很好的方向，但对我来说，上面的方法足够简单，可以作为解决Android内置怪异问题的好方法，尽管速度较慢。**请注意，此解决方案使用NV 21布局，丢失了3/4的颜色信息（来自Cr/Cb），但这种损失比Skia的数学产生的误差要小得多。**还请注意，YuvImage不支持奇数大小的图像，有关更多信息，请参阅NV21 format and odd image dimensions。

展开查看全部
赞(0）分享  回复(0）举报  2023-06-27
yc0p9oo0

yc0p9oo02#

请使用以下方法：

  1. public String convertBitmaptoSmallerSizetoString(String image){
  2.     File imageFile = new File(image);
  3.     Bitmap bitmap = BitmapFactory.decodeFile(imageFile.getAbsolutePath());
  4.     int nh = (int) (bitmap.getHeight() * (512.0 / bitmap.getWidth()));
  5.     Bitmap scaled = Bitmap.createScaledBitmap(bitmap, 512, nh, true);
  6.     ByteArrayOutputStream stream = new ByteArrayOutputStream();
  7.     scaled.compress(Bitmap.CompressFormat.PNG, 90, stream);
  8.     byte[] imageByte = stream.toByteArray();
  9.     String img_str = Base64.encodeToString(imageByte, Base64.NO_WRAP);
  10.     return img_str;
  11. }
赞(0）分享  回复(0）举报  2023-06-27
drnojrws

drnojrws3#

下面是我的代码：

  1. public static String compressImage(Context context, String imagePath)
  2. {
  4.     final float maxHeight = 1024.0f;
  5.     final float maxWidth = 1024.0f;
  6.     Bitmap scaledBitmap = null;
  7.     BitmapFactory.Options options = new BitmapFactory.Options();
  8.     options.inJustDecodeBounds = true;
  9.     Bitmap bmp = BitmapFactory.decodeFile(imagePath, options);
  10.     int actualHeight = options.outHeight;
  11.     int actualWidth = options.outWidth;
  12.     float imgRatio = (float) actualWidth / (float) actualHeight;
  13.     float maxRatio = maxWidth / maxHeight;
  14.     if (actualHeight > maxHeight || actualWidth > maxWidth) {
  15.         if (imgRatio < maxRatio) {
  16.             imgRatio = maxHeight / actualHeight;
  17.             actualWidth = (int) (imgRatio * actualWidth);
  18.             actualHeight = (int) maxHeight;
  19.         } else if (imgRatio > maxRatio) {
  20.             imgRatio = maxWidth / actualWidth;
  21.             actualHeight = (int) (imgRatio * actualHeight);
  22.             actualWidth = (int) maxWidth;
  23.         } else {
  24.             actualHeight = (int) maxHeight;
  25.             actualWidth = (int) maxWidth;
  26.         }
  27.     }
  28.     options.inSampleSize = calculateInSampleSize(options, actualWidth, actualHeight);
  29.     options.inJustDecodeBounds = false;
  30.     options.inDither = false;
  31.     options.inPurgeable = true;
  32.     options.inInputShareable = true;
  33.     options.inTempStorage = new byte[16 * 1024];
  34.     try {
  35.         bmp = BitmapFactory.decodeFile(imagePath, options);
  36.     } catch (OutOfMemoryError exception) {
  37.         exception.printStackTrace();
  38.     }
  39.     try {
  40.         scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.RGB_565);
  41.     } catch (OutOfMemoryError exception) {
  42.         exception.printStackTrace();
  43.     }
  44.     float ratioX = actualWidth / (float) options.outWidth;
  45.     float ratioY = actualHeight / (float) options.outHeight;
  46.     float middleX = actualWidth / 2.0f;
  47.     float middleY = actualHeight / 2.0f;
  48.     Matrix scaleMatrix = new Matrix();
  49.     scaleMatrix.setScale(ratioX, ratioY, middleX, middleY);
  50.     assert scaledBitmap != null;
  51.     Canvas canvas = new Canvas(scaledBitmap);
  52.     canvas.setMatrix(scaleMatrix);
  53.     canvas.drawBitmap(bmp, middleX - bmp.getWidth() / 2, middleY - bmp.getHeight() / 2, new Paint(Paint.FILTER_BITMAP_FLAG));
  54.     if (bmp != null) {
  55.         bmp.recycle();
  56.     }
  57.     ExifInterface exif;
  58.     try {
  59.         exif = new ExifInterface(imagePath);
  60.         int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 0);
  61.         Matrix matrix = new Matrix();
  62.         if (orientation == 6) {
  63.             matrix.postRotate(90);
  64.         } else if (orientation == 3) {
  65.             matrix.postRotate(180);
  66.         } else if (orientation == 8) {
  67.             matrix.postRotate(270);
  68.         }
  69.         scaledBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);
  70.     } catch (IOException e) {
  71.         e.printStackTrace();
  72.     }
  73.     FileOutputStream out = null;
  74.     String filepath = getFilename(context);
  75.     try {
  76.         out = new FileOutputStream(filepath);
  77.         scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 80, out);
  78.     } catch (FileNotFoundException e) {
  79.         e.printStackTrace();
  80.     }
  81.     return filepath;
  82. }
  84. public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
  85.     final int height = options.outHeight;
  86.     final int width = options.outWidth;
  87.     int inSampleSize = 1;
  88.     if (height > reqHeight || width > reqWidth) {
  89.         final int heightRatio = Math.round((float) height / (float) reqHeight);
  90.         final int widthRatio = Math.round((float) width / (float) reqWidth);
  91.         inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
  92.     }
  93.     final float totalPixels = width * height;
  94.     final float totalReqPixelsCap = reqWidth * reqHeight * 2;
  95.     while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
  96.         inSampleSize++;
  97.     }
  98.     return inSampleSize;
  99. }
  101. public static String getFilename(Context context) {
  102.     File mediaStorageDir = new File(Environment.getExternalStorageDirectory()
  103.             + "/Android/data/"
  104.             + context.getApplicationContext().getPackageName()
  105.             + "/Files/Compressed");
  107.     if (!mediaStorageDir.exists()) {
  108.         mediaStorageDir.mkdirs();
  109.     }
  110.     String mImageName = "IMG_" + String.valueOf(System.currentTimeMillis()) + ".jpg";
  111.     return (mediaStorageDir.getAbsolutePath() + "/" + mImageName);
  112. }
展开查看全部
赞(0）分享  回复(0）举报  2023-06-27
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com