Android 高质量高压缩比图像压缩

港控/mmm° 2022-07-26 04:13 171阅读 0赞

一般Android项目都有从相册选取照片并上传到服务器的需求，但是不能对file文件直接上传，因为对于一些像素特别高的手机，拍出来的相片体积也会特别巨大，比如1300万的相机最大能达到9-10m，这样在上传之前就需要进行压缩，而压缩氛围图像大小的压缩和品质的压缩，在压缩过程中很有可能会出现OOM的情况，下面是一个图片压缩工具类，思路是先进行图像宽高的压缩，将比较大的图片压缩到1280\*1280的大小范围，以减少oom，然后进行品质的压缩，一般品质保持在70-100之间，肉眼几乎无法看出差别，而大小能够明显改善，压缩后大小范围在100k-200k之间，便于向服务器上传。宽高压缩和品质压缩各执行一遍，没有循环压缩，因为我发现一些循环压缩的方案往往导致图像质量显著下降，俗称照片糊了。

package com.example.administrator.jnidemo;
    
    
    import android.content.Context;
    import android.content.res.AssetFileDescriptor;
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.graphics.Matrix;
    import android.graphics.Rect;
    import android.os.Build;
    import android.util.Log;
    
    import java.io.File;
    import java.io.FileDescriptor;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    /**
     * Created by Administrator on 2016/4/6.
     */
    public class AlxBitMapUtils {
    
        /**
         * 传入一个bitmap，根据传入比例进行大小缩放
         * @param bitmap
         * @param widthRatio 宽度比例，缩小就比1小，放大就比1大
         * @param heightRatio
         * @return
         */
        public static Bitmap scaleBitmap(Bitmap bitmap, float widthRatio, float heightRatio) {
            Matrix matrix = new Matrix();
            matrix.postScale(widthRatio,heightRatio);
            return Bitmap.createBitmap(bitmap,0,0,bitmap.getWidth(),bitmap.getHeight(),matrix,true);
        }
    
        /**
         * 传入图片路径，根据图片进行压缩，仅压缩大小，不压缩质量
         * @param oriFile 源文件
         * @param targetFile 这个和 stream传一个就行
         * @param ifDel 是否需要在压缩完毕后删除原图
         */
        public static void compressImage(File oriFile, File targetFile, OutputStream stream,boolean ifDel) {
            if(oriFile ==null)return;
            Log.i("Alex","源图片为"+oriFile);
            Log.i("Alex","目标地址为"+targetFile);
            try {
                BitmapFactory.Options opts = new BitmapFactory.Options();
                opts.inJustDecodeBounds = true; // 不读取像素数组到内存中，仅读取图片的信息，非常重要
                BitmapFactory.decodeFile(oriFile.getAbsolutePath(), opts);//读取文件信息，存放到Options对象中
                // 从Options中获取图片的分辨率
                int imageHeight = opts.outHeight;
                int imageWidth = opts.outWidth;
                int longEdge = Math.max(imageHeight,imageWidth);//取出宽高中的长边
                int pixelCount = (imageWidth*imageHeight)>>20;//看看这张照片有多少百万像素
                Log.i("Alex","图片宽为"+imageWidth+"图片高为"+imageHeight+"图片像素数为"+pixelCount+"百万像素");
    
                long size = oriFile.length();
                Log.i("Alex","f.length 图片大小为"+(size)+" B");
                //走到这一步的时候，内存里还没有bitmap
                Bitmap bitmap = null;
                if(pixelCount > 4){//如果超过了4百万像素，那么就首先对大小进行压缩
                    float compressRatio = longEdge /1280f;
                    int compressRatioInt = Math.round(compressRatio);
                    if(compressRatioInt%2!=0 && compressRatioInt!=1)compressRatioInt++;//如果是奇数的话，就给弄成偶数
                    Log.i("Alex","长宽压缩比是"+compressRatio+" 偶数化后"+compressRatioInt);
                    //尺寸压缩
                    BitmapFactory.Options options = new BitmapFactory.Options();
                    //目标出来的大小1024*1024 1百万像素，100k左右
                    options.inSampleSize = Math.round(compressRatioInt);//注意，此处必须是偶数，根据计算好的比例进行压缩,如果长边没有超过1280*1.5，就不去压缩,否则就压缩成原来的一半
                    options.inJustDecodeBounds = false;//在decode file的时候，不仅读取图片的信息，还把像素数组到内存
                    options.inPreferredConfig = Bitmap.Config.RGB_565;//每个像素占四位，即R=5，G=6，B=5，没有透明度，那么一个像素点占5+6+5=16位
                    //现在开始将bitmap放入内存
                    bitmap = BitmapFactory.decodeFile(oriFile.getAbsolutePath(), options);//根据压缩比取出大小已经压缩好的bitmap
                    //此处会打印出存入内存的bitmap大小
                }else {//如果是长图或者长边短于1920的图，那么只进行质量压缩
                    // 现在开始将bitmap放入内存
                    bitmap = BitmapFactory.decodeFile(oriFile.getAbsolutePath());
                    //此处会打印出bitmap在内存中占得大小
                }
                if(targetFile!=null)compressMethodAndSave(bitmap, targetFile);
                if(stream!=null)compressBitmapToStream(bitmap,stream);
                if(ifDel) oriFile.delete();//是否要删除源文件
                System.gc();
            }catch (Exception e){
                Log.d("Alex",""+e.getMessage().toString());
            }
        }
    
        /**
         * 获取一个bitmap在内存中所占的大小
         * @param image
         * @return
         */
        private static int getSize(Bitmap image){
            int size=0;
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {    //API 19
                size = image.getAllocationByteCount();
            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1) {//API 12
                size = image.getByteCount();
            } else {
                size = image.getRowBytes() * image.getHeight();
            }
            return size;
        }
    
        /**
         * 根据传来的bitmap的大小计算一个质量压缩率，并且保存到指定路径中去，只压缩质量，不压缩大小
         * @param image
         * @param targetFile
         */
        public static void compressMethodAndSave(Bitmap image,File targetFile){
            try {
                OutputStream stream = new FileOutputStream(targetFile);
                int size = compressBitmapToStream(image,stream);
                if(size==0)return;
                long afterSize = targetFile.length();
                Log.i("Alex","压缩完后图片大小"+(afterSize>>10)+"KB 压缩率:::"+afterSize*100/size+"%");
            }catch (Exception e){
                Log.i("Alex","压缩图片出现异常",e);
            }
        }
    
        public static int compressBitmapToStream(Bitmap image,OutputStream stream){
            if(image==null || stream==null)return 0;
            try {
                Bitmap.CompressFormat format = Bitmap.CompressFormat.JPEG;
                int size = getSize(image);
                Log.i("Alex","存入内寸的bitmap大小是"+(size>>10)+" KB 宽度是"+image.getWidth()+" 高度是"+image.getHeight());
                int quality = getQuality(size);//根据图像的大小得到合适的有损压缩质量
                Log.i("Alex","目前适用的有损压缩率是"+quality);
                long startTime = System.currentTimeMillis();
                image.compress(format, quality, stream);//压缩文件并且输出
                if (image != null) {
                    image.recycle();//此处把bitmap从内存中移除
                    image = null;
                }
                Log.i("Alex","压缩图片并且存储的耗时"+(System.currentTimeMillis()-startTime));
                return size;
            }catch (Exception e){
                Log.i("Alex","压缩图片出现异常",e);
            }
            return 0;
        }
    
        /**
         * 根据图像的大小得到合适的有损压缩质量，因为此时传入的bitmap大小已经比较合适了，靠近1000*1000，所以根据其内存大小进行质量压缩
         * @param size
         * @return
         */
        private static int getQuality(int size){
            int mb=size>>20;//除以100万，也就是m
            int kb = size>>10;
            Log.i("Alex","准备按照图像大小计算压缩质量，大小是"+kb+"KB,兆数是"+mb);
            if(mb>70){
                return 17;
            }else if(mb>50){
                return 20;
            }else if(mb>40){
                return 25;
            }else if(mb>20){
                return 40;
            }else if(mb>10){
                return 60;
            }else if(mb>3){//目标压缩大小 100k，这里可根据实际情况来判断
                return 60;
            }else if(mb>=2){
                return 60;
            }else if(kb > 1500){
                return 70;
            }else if(kb > 1000){
                return 80;
            }else if(kb>500){
                return 85;
            }else if(kb>100){
                return 90;
            }
            else{
                return 100;
            }
        }
    
        /**
         * 从assets文件夹中根据文件名得到一个Bitmap
         * @param fileName
         * @return
         */
        public static Bitmap getDataFromAssets(Context context,String fileName){
            Log.i("Alex","准备从assets文件夹中读取文件"+fileName);
            try {
                //可以直接使用context.getResources().getAssets().open(fileName);得到一个InputStream再用BufferedInputStream通过缓冲区获得字符数组
                AssetFileDescriptor descriptor = context.getResources().getAssets().openFd(fileName);//此处获得文件描述之后可以得到FileInputStream，然后使用NIO得到Channel
                long fileSize = descriptor.getLength();
                Log.i("Alex","要读取的文件的长度是"+fileSize);//注意这个地方如果文件大小太大，在decodeStream需要设置参数进行裁剪
                Bitmap bitmap = BitmapFactory.decodeStream(context.getResources().getAssets().open(fileName));
    //            Bitmap bitmap = BitmapFactory.decodeFileDescriptor(fileDescriptor);//注意，AssetFileDescriptor只能用来获取文件的大小，不能用来获取inputStream，用FileDescriptor获取的输入流BitmapFactory.decodeStream不能识别
                if(bitmap==null)Log.i("Alex","decode bitmap失败");
                return bitmap;
            } catch (Exception e) {
                Log.i("Alex","读取文件出现异常",e);
                e.printStackTrace();
            }
            return null;
        }
    
        public static boolean copyFile(File sourceFile,File targetFile){
            //NIO中读取数据的步骤：1）从FileInputStream中得到Channel对象;2)创建一个buffer对象;3)从Channel中读数据到Buffer中;
            FileInputStream fin  = null;
            FileOutputStream fout = null;
            FileChannel fcin = null;
            FileChannel fcout = null;
            try {
                fin = new FileInputStream( sourceFile );
                fout = new FileOutputStream( targetFile );
                fcin = fin.getChannel();
                fcout =fout.getChannel();
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                int r = 0;
                while ((r = fcin.read(buffer))!=-1) {
                    buffer.clear();
                    buffer.flip();//反转一下，从写入状态变成读取状态
                    fcout.write(buffer);
                }
                return true;
            } catch (Exception e){
                Log.i("Alex","复制文件发生错误",e);
            }finally {
                if(fin!=null) try {
                    fin.close();
                    if(fout!=null)fout.close();
                    if(fcin!=null)fcin.close();
                    if(fcout!=null)fcout.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return false;
        }
    
    
    
    
    }

调用方法：这里是通过一个输出流获得一个字节数组准备上传

private byte[] getCompressedUploadPhotoBitmapByteArray(String filePath, int inSampleSize, int quality) {
                            byte[] bitmapDataByteArray = {};
                            if (!JDataUtils.isEmpty(filePath)) {
                                
                                File file = new File(filePath);
                                if (file.exists()) {
                                        ByteArrayOutputStream baos = null;
                                        try {
                                            baos = new ByteArrayOutputStream();//这个输出流好，输出到内存，然后可以直接转换成数组
                                            
                                            AlxBitmapUtils.compressImage(file,null,baos,false);//这一句是关键，在这里进行压缩
                                            bitmapDataByteArray = baos.toByteArray();
                                            Log.i("Alex","压缩完后的字符串数组是大小是"+(bitmapDataByteArray.length>>10)+" KB");
                                        } catch (Throwable throwable) {
                                            
                                        } finally {
                                            try {
                                                if (baos != null) {
                                                    baos.close();
                                                }
                                            } catch (Throwable throwable) {
                                                
                                            }
                                        }
    
                                } else {
                                    bitmapDataByteArray = null;
                                }
                            } else {
                                bitmapDataByteArray = null;
                            }
    
                            return bitmapDataByteArray;
                        }