devbox
算法设计者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 超清大尺寸图片压缩转Base64中卡顿/速度优化问题整理（在子线程压缩Bitmap卡的主线程进度条走不动了。。。）_android drawbitmap bitmap过大导致慢

作者：算法设计者 | 2024-01-30 19:19:11

赞

踩

android drawbitmap bitmap过大导致慢

        最近遇到需求是前后端传输图片使用的是Base64，但是前端（Android 端）图片很大（尺寸很大4480 × 2520，质量也很大7-10M），需要压缩到一定尺寸（1280 × 960，当然还可以压得更小），然后传给后端，本来认为是一个简单的压缩，可是在子线程压缩过程中发现很卡，卡的主线程的进度条都走不动了，一开始用的模拟器测试的，以为模拟器性能比较差，可是换成手机测试，还是很卡，卡的主线程的进度条都走不动了。为了解决这个问题，请看以下步骤：

以下代码在项目里，项目地址：https://gitee.com/urasaki/RxJava2AndRetrofit2

1.先申请权限，关于如何申请权限请查看RxPermissions的使用（简单实用）_ErwinNakajima的博客-CSDN博客_rxpermissions

2.添加bitmap管理类。

  1. package com.phone.base64_and_file.manager;
  2.  
  3. import android.content.Context;
  4. import android.content.res.AssetManager;
  5. import android.graphics.Bitmap;
  6. import android.graphics.BitmapFactory;
  7. import android.graphics.Canvas;
  8. import android.graphics.ImageFormat;
  9. import android.graphics.LinearGradient;
  10. import android.graphics.Matrix;
  11. import android.graphics.Paint;
  12. import android.graphics.PorterDuff;
  13. import android.graphics.PorterDuffXfermode;
  14. import android.graphics.Rect;
  15. import android.graphics.RectF;
  16. import android.graphics.Shader;
  17. import android.graphics.YuvImage;
  18. import android.net.Uri;
  19. import android.text.TextUtils;
  20. import android.util.Base64;
  21. import android.util.Log;
  22.  
  23. import com.phone.common_library.manager.LogManager;
  24.  
  25. import java.io.BufferedInputStream;
  26. import java.io.BufferedOutputStream;
  27. import java.io.ByteArrayInputStream;
  28. import java.io.ByteArrayOutputStream;
  29. import java.io.File;
  30. import java.io.FileInputStream;
  31. import java.io.FileNotFoundException;
  32. import java.io.FileOutputStream;
  33. import java.io.IOException;
  34. import java.io.InputStream;
  35. import java.lang.ref.SoftReference;
  36. import java.nio.ByteBuffer;
  37. import java.text.DecimalFormat;
  38.  
  39. import id.zelory.compressor.Compressor;
  40.  
  41. public class BitmapManager {
  42.  
  43.     private static final String TAG = "BitmapManager";
  44.     /**
  45.      * 图像的旋转方向是0
  46.      */
  47.     public static final int ROTATE0 = 0;
  48.     /**
  49.      * 图像的旋转方向是90
  50.      */
  51.     public static final int ROTATE90 = 90;
  52.     /**
  53.      * 图像的旋转方向是180
  54.      */
  55.     public static final int ROTATE180 = 180;
  56.     /**
  57.      * 图像的旋转方向是270
  58.      */
  59.     public static final int ROTATE270 = 270;
  60.     /**
  61.      * 图像的旋转方向是360
  62.      */
  63.     public static final int ROTATE360 = 360;
  64.     /**
  65.      * 图片太大内存溢出后压缩的比例
  66.      */
  67.     public static final int PIC_COMPRESS_SIZE = 4;
  68.     /**
  69.      * 图像压缩边界
  70.      */
  71.     public static final int IMAGEBOUND = 128;
  72.     /**
  73.      * 图片显示最大边的像素
  74.      */
  75.     public static final int MAXLENTH = 1024;
  76.     /**
  77.      * Log switch
  78.      */
  79.     private static final boolean DEBUG = false;
  80.     /**
  81.      * 保存图片的质量：100
  82.      */
  83.     private static final int QUALITY = 100;
  84.     /**
  85.      * 默认的最大尺寸
  86.      */
  87.     private static final int DEFAULT_MAX_SIZE_CELL_NETWORK = 600;
  88.     /**
  89.      * 题编辑wifi环境下压缩的最大尺寸
  90.      */
  91.     private static final int QUESTION_MAX_SIZE_CELL_NETWORK = 1024;
  92.     /**
  93.      * 图片压缩的质量
  94.      */
  95.     private static final int QUESTION_IMAGE_JPG_QUALITY = 75;
  96.     /**
  97.      * 默认的图片压缩的质量
  98.      */
  99.     private static final int DEFAULT_IMAGE_JPG_QUALITY = 50;
  100.     /**
  101.      * 网络请求超时时间
  102.      */
  103.     private static final int CONNECTTIMEOUT = 3000;
  104.  
  105.     /**
  106.      * Private constructor to prohibit nonsense instance creation.
  107.      */
  108.     private BitmapManager() {
  109.     }
  110.  
  111.     /**
  112.      * 图片合成
  113.      *
  114.      * @param bitmap 位图1
  115.      * @param mark   位图2
  116.      * @return Bitmap
  117.      */
  118.     public static Bitmap createBitmap(Bitmap bitmap, Bitmap mark) {
  119.         int w = bitmap.getWidth();
  120.         int h = bitmap.getHeight();
  121.         int mW = mark.getWidth();
  122.         int mH = mark.getHeight();
  123.         Bitmap newbitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);// 创建一个长宽一样的位图
  124.  
  125.         Canvas cv = new Canvas(newbitmap);
  126.         cv.drawBitmap(bitmap, 0, 0, null);// 在 0，0坐标开始画入bitmap
  127.         cv.drawBitmap(mark, w - mW, h - mH, null);// 在右下角画入水印mark
  128.         cv.save();// 保存
  129.         cv.restore();// 存储
  130.         return newbitmap;
  131.     }
  132.  
  133.     /**
  134.      * 放大缩小图片
  135.      *
  136.      * @param bitmap 位图
  137.      * @param w      新的宽度
  138.      * @param h      新的高度
  139.      * @return Bitmap
  140.      */
  141.     public static Bitmap zoomBitmap(Bitmap bitmap, int w, int h) {
  142.         int width = bitmap.getWidth();
  143.         int height = bitmap.getHeight();
  144.         Matrix matrix = new Matrix();
  145.         float scaleWidht = ((float) w / width);
  146.         float scaleHeight = ((float) h / height);
  147.         matrix.postScale(scaleWidht, scaleHeight);
  148.         return Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, true);
  149.     }
  150.  
  151.     /**
  152.      * 旋转图片
  153.      *
  154.      * @param bitmap 要旋转的图片
  155.      * @param angle  旋转角度
  156.      * @return bitmap
  157.      */
  158.     public static Bitmap rotate(Bitmap bitmap, int angle) {
  159.         Matrix matrix = new Matrix();
  160.         matrix.postRotate(angle);
  161.         return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(),
  162.                 bitmap.getHeight(), matrix, true);
  163.     }
  164.  
  165.     /**
  166.      * 圆形图片
  167.      *
  168.      * @param source      位图
  169.      * @param strokeWidth 裁剪范围 0表示最大
  170.      * @param bl          是否需要描边
  171.      * @param bl          画笔粗细
  172.      * @param bl          颜色代码
  173.      * @return bitmap
  174.      */
  175.     public static Bitmap createCircleBitmap(Bitmap source, int strokeWidth, boolean bl, int edge, int color) {
  176.  
  177.         int diameter = source.getWidth() < source.getHeight() ? source.getWidth() : source.getHeight();
  178.         Bitmap target = Bitmap.createBitmap(diameter, diameter, Bitmap.Config.ARGB_8888);
  179.         Canvas canvas = new Canvas(target);//创建画布
  180.  
  181.         Paint paint = new Paint();
  182.         paint.setAntiAlias(true);
  183.         canvas.drawCircle(diameter / 2, diameter / 2, diameter / 2, paint);//绘制圆形
  184.         paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));//取相交裁剪
  185.         canvas.drawBitmap(source, strokeWidth, strokeWidth, paint);
  186.         if (bl) {
  187.             if (color == 0) color = 0xFFFEA248;//默认橘黄色
  188.             paint.setColor(color);
  189.             paint.setStyle(Paint.Style.STROKE);//描边
  190.             paint.setStrokeWidth(edge);
  191.             canvas.drawCircle(diameter / 2, diameter / 2, diameter / 2, paint);
  192.         }
  193.         return target;
  194.     }
  195.  
  196.     /**
  197.      * 圆角图片
  198.      *
  199.      * @param bitmap 位图
  200.      * @param rx     x方向上的圆角半径
  201.      * @param ry     y方向上的圆角半径
  202.      * @param bl     是否需要描边
  203.      * @param bl     画笔粗细
  204.      * @param bl     颜色代码
  205.      * @return bitmap
  206.      */
  207.     public static Bitmap createCornerBitmap(Bitmap bitmap, int rx, int ry, boolean bl, int edge, int color) {
  208.         Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
  209.         Canvas canvas = new Canvas(output);//创建画布
  210.  
  211.         Paint paint = new Paint();
  212.         paint.setAntiAlias(true);
  213.         Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
  214.         RectF rectF = new RectF(rect);
  215.         canvas.drawRoundRect(rectF, rx, ry, paint);//绘制圆角矩形
  216.         paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));//取相交裁剪
  217.         canvas.drawBitmap(bitmap, rect, rect, paint);
  218.         if (bl) {
  219.             if (color == 0) color = 0xFFFEA248;//默认橘黄色
  220.             paint.setColor(color);
  221.             paint.setColor(color);
  222.             paint.setStyle(Paint.Style.STROKE);//描边
  223.             paint.setStrokeWidth(edge);
  224.             canvas.drawRoundRect(rectF, rx, ry, paint);
  225.         }
  226.         return output;
  227.     }
  228.  
  229.     /**
  230.      * 按比例裁剪图片
  231.      *
  232.      * @param bitmap 位图
  233.      * @param wScale 裁剪宽 0~100%
  234.      * @param hScale 裁剪高 0~100%
  235.      * @return bitmap
  236.      */
  237.     public static Bitmap cropBitmap(Bitmap bitmap, float wScale, float hScale) {
  238.         int w = bitmap.getWidth();
  239.         int h = bitmap.getHeight();
  240.  
  241.         int wh = (int) (w * wScale);
  242.         int hw = (int) (h * hScale);
  243.  
  244.         int retX = (int) (w * (1 - wScale) / 2);
  245.         int retY = (int) (h * (1 - hScale) / 2);
  246.  
  247.         return Bitmap.createBitmap(bitmap, retX, retY, wh, hw, null, false);
  248.     }
  249.  
  250.     /**
  251.      * 获得带倒影的图片方法
  252.      *
  253.      * @param bitmap 位图
  254.      * @param region 倒影区域 0.1~1
  255.      * @return bitmap
  256.      */
  257.     public static Bitmap createReflectionBitmap(Bitmap bitmap, float region) {
  258.  
  259.         int width = bitmap.getWidth();
  260.         int height = bitmap.getHeight();
  261.         Matrix matrix = new Matrix();
  262.         matrix.preScale(1, -1);//镜像缩放
  263.         Bitmap reflectionBitmap = Bitmap.createBitmap(
  264.                 bitmap, 0
  265.                 , (int) (height * (1 - region))//从哪个点开始绘制
  266.                 , width
  267.                 , (int) (height * region)//绘制多高
  268.                 , matrix, false);
  269.  
  270.         Bitmap reflectionWithBitmap = Bitmap.createBitmap(width, height + (int) (height * region),
  271.                 Bitmap.Config.ARGB_8888);
  272.         Canvas canvas = new Canvas(reflectionWithBitmap);
  273.         canvas.drawBitmap(bitmap, 0, 0, null);
  274.         canvas.drawBitmap(reflectionBitmap, 0, height, null);
  275.  
  276.         LinearGradient shader = new LinearGradient(0, bitmap.getHeight(), 0,
  277.                 reflectionWithBitmap.getHeight()
  278.                 , 0x70ffffff, 0x00ffffff, Shader.TileMode.CLAMP);
  279.  
  280.         Paint paint = new Paint();
  281.         paint.setShader(shader);
  282.         paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));//取两层绘制交集。显示下层。
  283.         canvas.drawRect(0, height, width, reflectionWithBitmap.getHeight(), paint);
  284.         return reflectionWithBitmap;
  285.     }
  286.  
  287.     /**
  288.      * 图片质量压缩
  289.      *
  290.      * @param bitmap
  291.      * @param many   百分比
  292.      * @return
  293.      */
  294.     public static Bitmap compressBitmap(Bitmap bitmap, float many) {
  295.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  296.         bitmap.compress(Bitmap.CompressFormat.JPEG, (int) many * 100, baos);
  297.         ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
  298.         return BitmapFactory.decodeStream(isBm, null, null);
  299.     }
  300.  
  301.     /**
  302.      * 高级图片质量压缩
  303.      *
  304.      * @param bitmap  位图
  305.      * @param maxSize 压缩后的大小，单位kb
  306.      */
  307.     public static Bitmap imageZoom(Bitmap bitmap, double maxSize) {
  308.         // 将bitmap放至数组中，意在获得bitmap的大小（与实际读取的原文件要大）
  309.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  310.         // 格式、质量、输出流
  311.         bitmap.compress(Bitmap.CompressFormat.PNG, 70, baos);
  312.         byte[] b = baos.toByteArray();
  313.         // 将字节换成KB
  314.         double mid = b.length / 1024;
  315.         // 获取bitmap大小 是允许最大大小的多少倍
  316.         double i = mid / maxSize;
  317.         // 判断bitmap占用空间是否大于允许最大空间 如果大于则压缩 小于则不压缩
  318.         doRecycledIfNot(bitmap);
  319.         if (i > 1) {
  320.             // 缩放图片 此处用到平方根 将宽带和高度压缩掉对应的平方根倍
  321.             // （保持宽高不变，缩放后也达到了最大占用空间的大小）
  322.             return scaleWithWH(bitmap, bitmap.getWidth() / Math.sqrt(i),
  323.                     bitmap.getHeight() / Math.sqrt(i));
  324.         }
  325.         return null;
  326.     }
  327.  
  328.     /***
  329.      * 图片缩放
  330.      *@param bitmap 位图
  331.      * @param w 新的宽度
  332.      * @param h 新的高度
  333.      * @return Bitmap
  334.      */
  335.     public static Bitmap scaleWithWH(Bitmap bitmap, double w, double h) {
  336.         if (w == 0 || h == 0 || bitmap == null) {
  337.             return bitmap;
  338.         } else {
  339.             int width = bitmap.getWidth();
  340.             int height = bitmap.getHeight();
  341.  
  342.             Matrix matrix = new Matrix();
  343.             float scaleWidth = (float) (w / width);
  344.             float scaleHeight = (float) (h / height);
  345.  
  346.             matrix.postScale(scaleWidth, scaleHeight);
  347.             return Bitmap.createBitmap(bitmap, 0, 0, width, height,
  348.                     matrix, true);
  349.         }
  350.     }
  351.  
  352.     /**
  353.      * YUV视频流格式转bitmap
  354.      *
  355.      * @param data YUV视频流格式
  356.      * @return width 设置高度
  357.      */
  358.     public static Bitmap getBitmap(byte[] data, int width, int height) {
  359.         Bitmap bitmap;
  360.         YuvImage yuvimage = new YuvImage(data, ImageFormat.NV21, width, height, null);
  361.         //data是onPreviewFrame参数提供
  362.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  363.         yuvimage.compressToJpeg(new Rect(0, 0, yuvimage.getWidth(), yuvimage.getHeight()), 100, baos);//
  364.         // 80--JPG图片的质量[0-100],100最高
  365.         byte[] rawImage = baos.toByteArray();
  366.         BitmapFactory.Options options = new BitmapFactory.Options();
  367.         SoftReference<Bitmap> softRef = new SoftReference<Bitmap>(BitmapFactory.decodeByteArray(rawImage, 0, rawImage
  368.                 .length, options));
  369.         bitmap = softRef.get();
  370.         return bitmap;
  371.     }
  372.  
  373.     /**
  374.      * 图片资源文件转bitmap
  375.      *
  376.      * @param context
  377.      * @param resId
  378.      * @return bitmap
  379.      */
  380.     public static Bitmap getBitmapResources(Context context, int resId) {
  381.         return BitmapFactory.decodeResource(context.getResources(), resId);
  382.     }
  383.  
  384.     /**
  385.      * 将图片路径转Bitmap
  386.      *
  387.      * @return Bitmap
  388.      * @Param path 图片路径
  389.      */
  390.     public static Bitmap getBitmapPath(String path) {
  391.         return BitmapFactory.decodeFile(path);
  392.     }
  393.  
  394.     /**
  395.      * bitmap保存到指定路径
  396.      *
  397.      * @param path 图片的绝对路径
  398.      * @param bmp  位图
  399.      * @return bitmap
  400.      */
  401.     public static boolean saveFile(String path, Bitmap bmp) {
  402.         if (TextUtils.isEmpty(path) || bmp == null) return false;
  403.  
  404.         File file = new File(path);
  405.         if (file.exists()) {
  406.             file.delete();
  407.         } else {
  408.             File p = file.getParentFile();
  409.             if (!p.exists()) {
  410.                 p.mkdirs();
  411.             }
  412.             try {
  413.                 file.createNewFile();
  414.             } catch (IOException e) {
  415.                 e.printStackTrace();
  416.             }
  417.         }
  418.  
  419.         FileOutputStream fos = null;
  420.         BufferedOutputStream bos = null;
  421.         try {
  422.             fos = new FileOutputStream(file);
  423.             bos = new BufferedOutputStream(fos);
  424.             bmp.compress(Bitmap.CompressFormat.JPEG, 100, bos);
  425.             bos.flush();
  426.         } catch (IOException e) {
  427.             // TODO Auto-generated catch block
  428.             e.printStackTrace();
  429.         } finally {
  430.             if (bos != null) {
  431.                 try {
  432.                     bos.close();
  433.                 } catch (IOException e) {
  434.                     e.printStackTrace();
  435.                 }
  436.             }
  437.         }
  438.         return true;
  439.     }
  440.  
  441.     /**
  442.      * 回收一个未被回收的Bitmap
  443.      *
  444.      * @param bitmap
  445.      */
  446.     public static void doRecycledIfNot(Bitmap bitmap) {
  447.         if (!bitmap.isRecycled()) {
  448.             bitmap.recycle();
  449.         }
  450.     }
  451.  
  452.     /**
  453.      * 等比压缩图片
  454.      *
  455.      * @param resBitmap 原图
  456.      * @param desWidth  压缩后图片的宽度
  457.      * @param desHeight 压缩后图片的高度
  458.      * @return 压缩后的图片
  459.      */
  460.     public static Bitmap scaleImage(Bitmap resBitmap, int desWidth, int desHeight) {
  461.         int resWidth = resBitmap.getWidth();
  462.         int resHeight = resBitmap.getHeight();
  463.         if (resHeight > desHeight || resWidth > desWidth) {
  464.             // 计算出实际宽高和目标宽高的比率
  465.             final float heightRatio = (float) desHeight / (float) resHeight;
  466.             final float widthRatio = (float) desWidth / (float) resWidth;
  467.             float scale = heightRatio < widthRatio ? heightRatio : widthRatio;
  468.             LogManager.i(TAG, "scaleImage scale*****" + scale);
  469.             //開平方會有一點損失精度
  470.             float prescription = (float) Math.sqrt(scale);
  471.             //再次开平方
  472.             float prescription2 = (float) Math.sqrt(prescription);
  473. //            LogManager.i(TAG, "scaleImage prescription*****" + prescription);
  474.             LogManager.i(TAG, "scaleImage prescription2*****" + prescription2);
  475.             Bitmap bitmap = null;
  476.             //循環壓縮bitmap，防止一次壓縮bitmap卡頓問題（子線程把主線成卡頓了）
  477.             for (int i = 0; i < 4; i++) {
  478.                 if (bitmap != null) {
  479. //                    bitmap = scale(bitmap, prescription);
  480.                     bitmap = scale(bitmap, prescription2);
  481.                 } else {
  482. //                    bitmap = scale(resBitmap, prescription);
  483.                     bitmap = scale(resBitmap, prescription2);
  484.                 }
  485. //                LogManager.i(TAG, i + "scaleImage prescription*****" + prescription);
  486.                 LogManager.i(TAG, i + "scaleImage prescription2*****" + prescription2);
  487.             }
  488.             return bitmap;
  489.         }
  490.         return resBitmap;
  491.     }
  492.  
  493.     /**
  494.      * 等比压缩图片
  495.      *
  496.      * @param bitmap 原图
  497.      * @param scale  压缩因子
  498.      * @return 压缩后的图片
  499.      */
  500.     private static Bitmap scale(Bitmap bitmap, float scale) {
  501.         Matrix matrix = new Matrix();
  502.         matrix.postScale(scale, scale);
  503.         return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
  504.     }
  505.  
  506.     /**
  507.      * 尺寸缩放
  508.      *
  509.      * @param bitmap bitmap
  510.      * @param w      width
  511.      * @param h      height
  512.      * @return scaleBitmap
  513.      */
  514.     public static Bitmap scale(Bitmap bitmap, int w, int h) {
  515.         if (bitmap == null) {
  516.             return null;
  517.         }
  518.         int width = bitmap.getWidth();
  519.         int height = bitmap.getHeight();
  520.         Matrix matrix = new Matrix();
  521.         float scaleWidth = ((float) w / width);
  522.         float scaleHeight = ((float) h / height);
  523.         matrix.postScale(scaleWidth, scaleHeight);
  524.         return Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, true);
  525.  
  526.     }
  527.  
  528.     /**
  529.      * byte转Uri
  530.      *
  531.      * @param context
  532.      * @param data
  533.      * @return
  534.      */
  535.     public static Uri saveTakePictureImage(Context context, byte[] data) {
  536.         File file = context.getExternalFilesDir("file1");
  537.         file = new File(file.getAbsolutePath() + File.separator + System.currentTimeMillis() + ".jpg");
  538.         FileOutputStream fos = null;
  539.         try {
  540.             fos = new FileOutputStream(file);
  541.             fos.write(data);
  542.             fos.flush();
  543.         } catch (Exception e) {
  544.             e.printStackTrace();
  545.  
  546.             // 异常时删除保存失败的文件
  547.             try {
  548.                 if (file != null && file.exists() && file.isFile()) {
  549.                     file.delete();
  550.                 }
  551.             } catch (Exception ex) {
  552.                 ex.printStackTrace();
  553.             }
  554.  
  555.             return null;
  556.         } finally {
  557.             if (fos != null) {
  558.                 try {
  559.                     fos.close();
  560.                 } catch (IOException e) {
  561.                     e.printStackTrace();
  562.                 }
  563.             }
  564.         }
  565.         Log.e(TAG, file.getAbsolutePath());
  566.         return Uri.fromFile(file);
  567.     }
  568.  
  569.     /**
  570.      * byte转成bitmap
  571.      *
  572.      * @param data
  573.      * @param width
  574.      * @param height
  575.      * @return
  576.      */
  577.     public static Bitmap yuvToBitmap(byte[] data, int width, int height) {
  578.         int frameSize = width * height;
  579.         int[] rgba = new int[frameSize];
  580.  
  581.         for (int i = 0; i < height; i++) {
  582.             for (int j = 0; j < width; j++) {
  583.                 int y = (0xff & ((int) data[i * width + j]));
  584.                 int u = (0xff & ((int) data[frameSize + (i >> 1) * width + (j & ~1) + 0]));
  585.                 int v = (0xff & ((int) data[frameSize + (i >> 1) * width + (j & ~1) + 1]));
  586.                 y = y < 16 ? 16 : y;
  587.  
  588.                 int r = Math.round(1.164f * (y - 16) + 1.596f * (v - 128));
  589.                 int g = Math.round(1.164f * (y - 16) - 0.813f * (v - 128) - 0.391f * (u - 128));
  590.                 int b = Math.round(1.164f * (y - 16) + 2.018f * (u - 128));
  591.  
  592.                 r = r < 0 ? 0 : (r > 255 ? 255 : r);
  593.                 g = g < 0 ? 0 : (g > 255 ? 255 : g);
  594.                 b = b < 0 ? 0 : (b > 255 ? 255 : b);
  595.  
  596.                 rgba[i * width + j] = 0xff000000 + (b << 16) + (g << 8) + r;
  597.             }
  598.         }
  599.  
  600.         Bitmap bmp = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
  601.         bmp.setPixels(rgba, 0, width, 0, 0, width, height);
  602.         return bmp;
  603.     }
  604.  
  605.     /**
  606.      * byte转成bitmap
  607.      *
  608.      * @param depthBytes
  609.      * @param width
  610.      * @param height
  611.      * @return
  612.      */
  613.     public static Bitmap depthToBitmap(byte[] depthBytes, int width, int height) {
  614.         Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
  615.         int[] argbData = new int[width * height];
  616.         for (int i = 0; i < width * height; i++) {
  617.             argbData[i] = (((int) depthBytes[i * 2] + depthBytes[i * 2 + 1] * 256) / 10 & 0x000000ff)
  618.                     | ((((int) depthBytes[i * 2] + depthBytes[i * 2 + 1] * 256) / 10) & 0x000000ff) << 8
  619.                     | ((((int) depthBytes[i * 2] + depthBytes[i * 2 + 1] * 256) / 10) & 0x000000ff) << 16
  620.                     | 0xff000000;
  621.  
  622.         }
  623.         bitmap.setPixels(argbData, 0, width, 0, 0, width, height);
  624.         return bitmap;
  625.     }
  626.  
  627.     /**
  628.      * byte转bitmap
  629.      *
  630.      * @param bytes
  631.      * @param width
  632.      * @param height
  633.      * @return
  634.      */
  635.     public static Bitmap rGBToBitmap(byte[] bytes, int width, int height) {
  636.         // use Bitmap.Config.ARGB_8888 instead of type is OK
  637.         Bitmap stitchBmp = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
  638.         byte[] rgba = new byte[width * height * 4];
  639.         for (int i = 0; i < width * height; i++) {
  640.             byte b1 = bytes[i * 3 + 0];
  641.             byte b2 = bytes[i * 3 + 1];
  642.             byte b3 = bytes[i * 3 + 2];
  643.             // set value
  644.             rgba[i * 4 + 0] = b1;
  645.             rgba[i * 4 + 1] = b2;
  646.             rgba[i * 4 + 2] = b3;
  647.             rgba[i * 4 + 3] = (byte) 255;
  648.         }
  649.         stitchBmp.copyPixelsFromBuffer(ByteBuffer.wrap(rgba));
  650.         return stitchBmp;
  651.     }
  652.  
  653.     /**
  654.      * byte转bitmap
  655.      *
  656.      * @param bytes
  657.      * @param width
  658.      * @param height
  659.      * @return
  660.      */
  661.     public static Bitmap bGRToBitmap(byte[] bytes, int width, int height) {
  662.         // use Bitmap.Config.ARGB_8888 instead of type is OK
  663.         Bitmap stitchBmp = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
  664.         byte[] rgba = new byte[width * height * 4];
  665.         for (int i = 0; i < width * height; i++) {
  666.             byte b1 = bytes[i * 3 + 0];
  667.             byte b2 = bytes[i * 3 + 1];
  668.             byte b3 = bytes[i * 3 + 2];
  669.             // set value
  670.             rgba[i * 4 + 0] = b3;
  671.             rgba[i * 4 + 1] = b2;
  672.             rgba[i * 4 + 2] = b1;
  673.             rgba[i * 4 + 3] = (byte) 255;
  674.         }
  675.         stitchBmp.copyPixelsFromBuffer(ByteBuffer.wrap(rgba));
  676.         return stitchBmp;
  677.     }
  678.  
  679.     public static byte[] aRGBToR(byte[] bytes, int width, int height) {
  680.         byte[] IR = new byte[width * height];
  681.         for (int i = 0; i < width * height; i++) {
  682.             IR[i] = bytes[i * 4];
  683.         }
  684.         return IR;
  685.     }
  686.  
  687. //    /**
  688. //     * 百度人脸图片转换
  689. //     *
  690. //     * @param newInstance
  691. //     * @return
  692. //     */
  693. //    public static Bitmap getInstaceBmp(BDFaceImageInstance newInstance) {
  694. //        Bitmap transBmp = null;
  695. //        if (newInstance.imageType == BDFaceSDKCommon.BDFaceImageType.BDFACE_IMAGE_TYPE_RGBA) {
  696. //            transBmp = Bitmap.createBitmap(newInstance.width, newInstance.height, Bitmap.Config.ARGB_8888);
  697. //            transBmp.copyPixelsFromBuffer(ByteBuffer.wrap(newInstance.data));
  698. //        } else if (newInstance.imageType == BDFaceSDKCommon.BDFaceImageType.BDFACE_IMAGE_TYPE_BGR) {
  699. //            transBmp = BitmapManager.BGR2Bitmap(newInstance.data, newInstance.width, newInstance.height);
  700. //        } else if (newInstance.imageType == BDFaceSDKCommon.BDFaceImageType.BDFACE_IMAGE_TYPE_YUV_NV21) {
  701. //            transBmp = BitmapManager.yuv2Bitmap(newInstance.data, newInstance.width, newInstance.height);
  702. //        } else if (newInstance.imageType == BDFaceSDKCommon.BDFaceImageType.BDFACE_IMAGE_TYPE_GRAY) {
  703. //            transBmp = Depth2Bitmap(newInstance.data, newInstance.width, newInstance.height);
  704. //        }
  705. //        return transBmp;
  706. //    }
  707.  
  708.     /**
  709.      * 获取图片数据
  710.      *
  711.      * @param path
  712.      * @return
  713.      */
  714.     public static Bitmap getBitmap(String path) {
  715.         FileInputStream fis = null;
  716.         BufferedInputStream bis = null;
  717.         Bitmap bm = null;
  718.         try {
  719.             fis = new FileInputStream(path);
  720.             BitmapFactory.Options options = new BitmapFactory.Options();
  721. //            options.inSampleSize = 8;//图片的长宽都是原来的1/8
  722.             bis = new BufferedInputStream(fis);
  723.             bm = BitmapFactory.decodeStream(bis, null, options);
  724.         } catch (FileNotFoundException e) {
  725.             e.printStackTrace();
  726.         } finally {
  727.             try {
  728.                 bis.close();
  729.             } catch (IOException e) {
  730.                 e.printStackTrace();
  731.             }
  732.         }
  733.         return bm;
  734.     }
  735.  
  736.     /**
  737.      * @param bitmap
  738.      * @return
  739.      */
  740.     public static InputStream bitmapToInputStream(Bitmap bitmap) {
  741.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  742.         bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
  743.         ByteArrayInputStream byteArrInputStream = new ByteArrayInputStream(
  744.                 baos.toByteArray());
  745.  
  746.         return byteArrInputStream;
  747.     }
  748.  
  749.     /**
  750.      * 这个是把文件变成二进制流
  751.      *
  752.      * @param imagepath
  753.      * @return
  754.      * @throws Exception
  755.      */
  756.     public static byte[] readStream(String imagepath) {
  757.         FileInputStream fis = null;
  758.         BufferedInputStream bis = null;
  759.         ByteArrayOutputStream baos = null;
  760.         try {
  761.             fis = new FileInputStream(imagepath);
  762.             bis = new BufferedInputStream(fis);
  763.  
  764.             baos = new ByteArrayOutputStream();
  765.             byte[] buffer = new byte[1024];
  766.             int len = 0;
  767.             while (-1 != (len = bis.read(buffer))) {
  768.                 baos.write(buffer, 0, len);
  769.             }
  770.             //刷新此输出流并强制写出所有缓冲的输出字节
  771.             baos.flush();
  772.         } catch (IOException e) {
  773.             e.printStackTrace();
  774.         } finally {
  775.             try {
  776.                 if (bis != null) {
  777.                     bis.close();
  778.                 }
  779.                 if (baos != null) {
  780.                     baos.close();
  781.                 }
  782.             } catch (IOException e) {
  783.                 e.printStackTrace();
  784.             }
  785.         }
  786.         return baos.toByteArray();
  787.     }
  788.  
  789.     /**
  790.      * 将Bitmap转换成文件
  791.      * 保存文件
  792.      *
  793.      * @param bitmap
  794.      * @param fileName
  795.      * @throws IOException
  796.      */
  797.     public static File saveFile(Bitmap bitmap, String dirsPath, String fileName) {
  798.         File dirs = new File(dirsPath);
  799.         if (!dirs.exists()) {
  800.             dirs.mkdirs();
  801.         }
  802.         File captureFile = new File(dirs, fileName);
  803.         BufferedOutputStream bos = null;
  804.         try {
  805.             bos = new BufferedOutputStream(new FileOutputStream(captureFile));
  806.             //刷新此输出流并强制写出所有缓冲的输出字节
  807.             bos.flush();
  808.             bitmap.compress(Bitmap.CompressFormat.JPEG, 80, bos);
  809.         } catch (IOException e) {
  810.             e.printStackTrace();
  811.         } finally {
  812.             if (bos != null) {
  813.                 try {
  814.                     bos.close();
  815.                 } catch (IOException e) {
  816.                     e.printStackTrace();
  817.                 }
  818.             }
  819.         }
  820.  
  821.         return captureFile;
  822.     }
  823.  
  824.     /**
  825.      * 读取文件的大小
  826.      */
  828.     public static long getFileSize(File file) {
  829.         long size = 0;
  830.         if (file.exists()) {
  831.             FileInputStream fis = null;
  832.             BufferedInputStream bis = null;
  833.             try {
  834.                 fis = new FileInputStream(file);
  835.                 bis = new BufferedInputStream(fis);
  836.                 size = bis.available();
  837.             } catch (IOException e) {
  838.                 e.printStackTrace();
  839.             } finally {
  840.                 if (bis != null) {
  841.                     try {
  842.                         bis.close();
  843.                     } catch (IOException e) {
  844.                         e.printStackTrace();
  845.                     }
  846.                 }
  847.             }
  848.             return size;
  849.         }
  850.         return 0;
  851.     }
  852.  
  853.     /**
  854.      * 返回byte的数据大小对应的文本
  855.      *
  856.      * @param size
  857.      * @return
  858.      */
  859.     public static String getDataSize(long size) {
  860.         DecimalFormat formater = new DecimalFormat("####.00");
  861.         if (size < 1024) {
  862.             return size + "bytes";
  863.         } else if (size < 1024 * 1024) {
  864.             float kbsize = size / 1024f;
  865.             return formater.format(kbsize) + "KB";
  866.         } else if (size < 1024 * 1024 * 1024) {
  867.             float mbsize = size / 1024f / 1024f;
  868.             return formater.format(mbsize) + "MB";
  869.         } else if (size < 1024 * 1024 * 1024 * 1024) {
  870.             float gbsize = size / 1024f / 1024f / 1024f;
  871.             return formater.format(gbsize) + "GB";
  872.         } else {
  873.             return "size: error";
  874.         }
  875.     }
  876.  
  877.     /**
  878.      * 使用Compressor IO模式自定义压缩
  879.      *
  880.      * @param path .setMaxWidth(640).setMaxHeight(480)这两个数值越高，压缩力度越小，图片也不清晰
  881.      *             .setQuality(75)这个方法只是设置图片质量，并不影响压缩图片的大小KB
  882.      *             .setCompressFormat(Bitmap.CompressFormat.WEBP) WEBP图片格式是Google推出的 压缩强，质量 高，但是IOS不识别，需要把图片转为字节流然后转PNG格式
  883.      *             .setCompressFormat(Bitmap.CompressFormat.PNG)PNG格式的压缩，会导致图片变大，并耗过大的内 存，手机反应缓慢
  884.      *             .setCompressFormat(Bitmap.CompressFormat.JPEG)JPEG压缩；压缩速度比PNG快，质量一般，基本上属于1/10的压缩比例
  885.      */
  886.     public static File initCompressorIO(Context context, String path, String dirsPath) {
  887.         File dirs2 = new File(dirsPath);
  888.         if (!dirs2.exists()) {
  889.             dirs2.mkdirs();
  890.         }
  891.  
  892.         File file = null;
  893.         try {
  894.             file = new Compressor(context)
  895. //                    .setMaxWidth(1280)
  896. //                    .setMaxHeight(960)
  897.                     .setQuality(50)
  898.                     .setCompressFormat(Bitmap.CompressFormat.PNG)
  899.                     .setDestinationDirectoryPath(dirsPath)
  900.                     .compressToFile(new File(path));
  901.         } catch (IOException e) {
  902.             e.printStackTrace();
  903.         }
  904.         return file;
  905.     }
  906.  
  907.     public static File getAssetFile(Context context, String dirsPath, String assetFileName) {
  908.         AssetManager assetManager = context.getAssets();
  909.         File dirs = new File(dirsPath);
  910.         if (!dirs.exists()) {
  911.             dirs.mkdirs();
  912.         }
  913.         File file = new File(dirs, assetFileName);
  914.         if (!file.exists()) {
  915.             try {
  916.                 file.createNewFile();
  917.             } catch (IOException e) {
  918.                 e.printStackTrace();
  919.             }
  920.         }
  921.  
  922.         InputStream is = null;
  923.         BufferedInputStream bis = null;
  924.         FileOutputStream fos = null;
  925.         BufferedOutputStream bos = null;
  926.         try {
  927.             is = assetManager.open(assetFileName);
  928.             bis = new BufferedInputStream(is);
  929.             fos = new FileOutputStream(file);
  930.             bos = new BufferedOutputStream(fos);
  931.  
  932.             byte[] buffer = new byte[1024];
  933.             int len = 0;
  934.             while (-1 != (len = bis.read(buffer))) {
  935.                 bos.write(buffer, 0, len);
  936.             }
  937.             //刷新此输出流并强制写出所有缓冲的输出字节
  938.             bos.flush();
  939.         } catch (IOException e) {
  940.             e.printStackTrace();
  941.         } finally {
  942.             if (bis != null) {
  943.                 try {
  944.                     bis.close();
  945.                 } catch (IOException e) {
  946.                     e.printStackTrace();
  947.                 }
  948.             }
  949.             if (bos != null) {
  950.                 try {
  951.                     bos.close();
  952.                 } catch (IOException e) {
  953.                     e.printStackTrace();
  954.                 }
  955.             }
  956.         }
  957.  
  958.         return file;
  959.     }
  960.  
  961.     /**
  962.      * base64转bitmap
  963.      *
  964.      * @param base64String
  965.      * @return
  966.      */
  967.     public static Bitmap base64ToBitmap(String base64String) {
  968.         base64String = Uri.decode(base64String);
  969.         byte[] decode = Base64.decode(base64String, Base64.DEFAULT);
  970.         Bitmap bitmap = BitmapFactory.decodeByteArray(decode, 0, decode.length);
  971.         return bitmap;
  972.     }
  973.  
  974. }

3.把本地图片转化成bitmap。

  1. String dirsPath = Environment.getExternalStorageDirectory().getAbsolutePath()
  2.                 + File.separator + "Pictures";
  3.         String dirsPathCompressed = Environment.getExternalStorageDirectory().getAbsolutePath()
  4.                 + File.separator + "PicturesCompressed";
  5.         String dirsPathCompressedRecover = Environment.getExternalStorageDirectory().getAbsolutePath()
  6.                 + File.separator + "PicturesCompressedRecover";
  7.         Base64AndFileBean base64AndFileBean = new Base64AndFileBean();
  8.         base64AndFileBean.setDirsPath(dirsPath);
  9.         base64AndFileBean.setDirsPathCompressed(dirsPathCompressed);
  10.         base64AndFileBean.setDirsPathCompressedRecover(dirsPathCompressedRecover);
  11.  
  12. Bitmap bitmap = BitmapManager.getBitmap(base64AndFileBean.getFile().getAbsolutePath());
  13.                         LogManager.i(TAG, "bitmap mWidth*****" + bitmap.getWidth());
  14.                         LogManager.i(TAG, "bitmap mHeight*****" + bitmap.getHeight());
  15.                         base64AndFileBean.setBitmap(bitmap);

4.再压缩bitmap，循環壓縮bitmap（分成4次压缩了），防止一次壓縮bitmap卡頓問題，如果图片太大，就分成更多次压缩。

  1. Bitmap bitmapCompressed = BitmapManager.scaleImage(base64AndFileBean.getBitmap(), 1280, 960);
  2.                         LogManager.i(TAG, "bitmapCompressed mWidth*****" + bitmapCompressed.getWidth());
  3.                         LogManager.i(TAG, "bitmapCompressed mHeight*****" + bitmapCompressed.getHeight());
  4.                         base64AndFileBean.setBitmapCompressed(bitmapCompressed);

5.再把压缩后的bitmap保存到本地。

  1. File fileCompressed = BitmapManager.saveFile(base64AndFileBean.getBitmapCompressed(), base64AndFileBean.getDirsPathCompressed(), "picture_large_compressed.png");
  2.                         base64AndFileBean.setFileCompressed(fileCompressed);
  3.                         LogManager.i(TAG, "base64AndFileBean.getFileCompressed().getPath()*****" + base64AndFileBean.getFileCompressed().getPath());
  4.                         LogManager.i(TAG, "base64AndFileBean.getFileCompressed().getAbsolutePath()*****" + base64AndFileBean.getFileCompressed().getAbsolutePath());

6.最后把File转成Base64。

  1. String base64Str = null;
  2.                         if (base64AndFileBean.getFileCompressed().exists()) {
  3.                             base64Str = Base64AndFileManager.fileToBase64(base64AndFileBean.getFileCompressed());
  4. //                base64Str = Base64AndFileManager.fileToBase64Test(file);
  5. //                    base64Str = Base64AndFileManager.fileToBase64Second(file);
  6.                             base64AndFileBean.setBase64Str(base64Str);
  7.                         }
  8.                         if (!TextUtils.isEmpty(base64Str)) {
  9.                             String fileName = "base64Str.txt";
  10.                             String txtFilePath = FileManager.writeStrToTextFile(base64Str, base64AndFileBean.getDirsPathCompressed(), fileName);
  11.                             base64AndFileBean.setTxtFilePath(txtFilePath);
  12.                             base64AndFileBean.setBase64StrList(Base64AndFileManager.getBase64StrList(txtFilePath));
  13. //                base64Str = "";
  14. //                StringBuilder stringBuilder = new StringBuilder();
  15. //                for (int i = 0; i < base64StrList.size(); i++) {
  16. //                    stringBuilder.append(base64StrList.get(i));
  17. //                }
  18. //                base64Str = stringBuilder.toString();
  19.  
  20. //                    //把字符串的最後一個打印出來，然後看看和RecyclerView顯示的最後一個字符串是否一致
  21. //                    LogManager.i(TAG, "base64StrList******" + base64StrList.get(base64StrList.size() - 1));
  22.                         }

以上是我总结的超清大尺寸图片压缩转Base64速度优化问题，重点在第3点，循環壓縮bitmap（分成4次压缩了），防止一次壓縮bitmap卡頓問題，如果图片太大，就分成更多次压缩。

如对此有疑问，请联系qq1164688204。

推荐Android开源项目

项目功能介绍：RxJava2和Retrofit2项目，添加自动管理token功能，添加RxJava2生命周期管理，使用App架构设计是MVP模式和MVVM模式，同时使用组件化，部分代码使用Kotlin，此项目持续维护中。

项目地址：https://gitee.com/urasaki/RxJava2AndRetrofit2

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/48412
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号