BitMap内存占用

小灰灰 2023-07-01 08:45 4阅读 0赞

BitMap加载后，占用内存大小：

width \* height \*每个像素占的字节数

代码中获取bitmap占用内存大小的计算：

public final int getByteCount() @Bitmap.java{
        return getRowBytes() * getHeight();
    }

其中的getRowBytes()调用的是native方法，具体在android源码中就是SkBitmap.cpp中的实现。

SkBitmap.h    
    /** Returns row bytes, the interval from one pixel row to the next. Row bytes
            is at least as large as width() * info().bytesPerPixel().
    
            Returns zero if colorType() is kUnknown_SkColorType, or if row bytes supplied to
            setInfo() is not large enough to hold a row of pixels.
    
            @return  byte length of pixel row
        */
        size_t rowBytes() const { return fPixmap.rowBytes(); }

常见的颜色类型kRGB\_565\_SkColorType，一个像素占2个字节，

kRGBA\_8888\_SkColorType 一个像素占4个字节。

占用内存跟容器格式也就是文件后缀名没有关系，但是跟文件放在drawable的那个目录有关系，前提同一张图片，同时只在一个drawable目录存在。

一张477\*550的图片，放在drawable-xhdpi中，

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbjIwMDQ0MTQwNDEw_size_16_color_FFFFFF_t_70][]

如代码：

public void decodeBitmap() {
            Bitmap jpgFile = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.pngfile);
            Log.d(TAG,"jpgfile,width="+jpgFile.getWidth()+",jpgfile,height="+jpgFile.getHeight()
                +",jpgfile,byteCount="+jpgFile.getByteCount()+",,,="+jpgFile.getDensity());
    
            Bitmap bmpFile = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.bmpfile);
            Log.d(TAG,"pngfile,width="+bmpFile.getWidth()+",pngfile,height="+bmpFile.getHeight()
                    +",pngfile,byteCount="+bmpFile.getByteCount());
    
            Bitmap pngFile = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.jpgfile);
            Log.d(TAG,"pngfile,width="+pngFile.getWidth()+",pngfile,height="+pngFile.getHeight()
                    +",pngfile,byteCount="+pngFile.getByteCount()+",,,="+pngFile.getDensity());
        }

![20200120150157490.PNG][]

/\*output\*/

2020-01-02 09:18:10.967 9850-9850/? D/com.jlq.mainthreaddemo.DecodeBitmap: jpgfile,width=477,jpgfile,height=550,jpgfile,byteCount=1049400,,,=320
    2020-01-02 09:18:10.986 9850-9850/? D/com.jlq.mainthreaddemo.DecodeBitmap: pngfile,width=477,pngfile,height=550,pngfile,byteCount=1049400
    2020-01-02 09:18:11.000 9850-9850/? D/com.jlq.mainthreaddemo.DecodeBitmap: pngfile,width=477,pngfile,height=550,pngfile,byteCount=1049400,,,=320

把那三张图片放在drawable-xxhdpi中，会缩小图片

![20200120150417240.PNG][]

/\*output\*/

2020-01-02 09:31:07.659 10130-10130/? D/com.jlq.mainthreaddemo.DecodeBitmap: jpgfile,width=318,jpgfile,height=367,jpgfile,byteCount=466824,,,=320
    2020-01-02 09:31:07.680 10130-10130/? D/com.jlq.mainthreaddemo.DecodeBitmap: pngfile,width=318,pngfile,height=367,pngfile,byteCount=466824
    2020-01-02 09:31:07.696 10130-10130/? D/com.jlq.mainthreaddemo.DecodeBitmap: pngfile,width=318,pngfile,height=367,pngfile,byteCount=466824,,,=320

放在drawable-hdpi中，会放大图片。

![20200120150654745.PNG][]

/\*output\*/

2020-01-02 09:35:23.787 10252-10252/com.jlq.mainthreaddemo D/com.jlq.mainthreaddemo.DecodeBitmap: jpgfile,width=636,jpgfile,height=733,jpgfile,byteCount=1864752,,,=320
    2020-01-02 09:35:23.821 10252-10252/com.jlq.mainthreaddemo D/com.jlq.mainthreaddemo.DecodeBitmap: pngfile,width=636,pngfile,height=733,pngfile,byteCount=1864752
    2020-01-02 09:35:23.850 10252-10252/com.jlq.mainthreaddemo D/com.jlq.mainthreaddemo.DecodeBitmap: pngfile,width=636,pngfile,height=733,pngfile,byteCount=1864752,,,=320

获取当前设备的屏幕密度：

public void getDisplayMetrics() {
            DisplayMetrics dm = mContext.getResources().getDisplayMetrics();
            mDensity = dm.density;
            mDensityDpi = dm.densityDpi;
            TypedValue tv = new TypedValue();
            Log.d(TAG,"mDensity="+mDensity+",mDensityDpi="+mDensityDpi);
        }

2020-01-02 09:35:23.747 10252-10252/com.jlq.mainthreaddemo D/com.jlq.mainthreaddemo.DecodeBitmap: mDensity=2.0,mDensityDpi=320

跟当前设备匹配的资源目录是drawable-xhdpi，对应屏幕密度是320dpi。

设备常用的屏幕密度：

*  ldpi（低）: ~120 dpi 3
 *  mdpi（中）：120~160dpi
 *  hdpi（高）：160~240dpi
 *  xhdpi（超高）：240~320dpi
 *  xxhdpi（超超高）：320~480dpi
 *  xxxhdpi（超超超高）：480~640dpi

通过上面的测试，图片放的位置如果跟当前的屏幕密度不一致，会对图片做缩放。具体的缩放算法：

实际加载后的图片尺寸 = （原图片的尺寸 \* 目标设备的屏幕密度） / 图片放置目录的dpi等级。

依据这个公式可以算出，在把图片放置在drawable-xxhdpi中时，实际的图片宽度 = （477（原图宽度）\* 320（屏幕密度））/480 (xxhdpi的等级) 。结果是318，跟代码输入是一致的。

下面分析下具体代码实现是不是这样的。

第一步，从decodeResource开始看起，

//仅关心跟图片缩放相关代码   
     public static Bitmap decodeResource(Resources res, int id, Options opts) @BitmapFactory.java{
            validate(opts);
            Bitmap bm = null;
            InputStream is = null; 
            
            try {
                final TypedValue value = new TypedValue();
                //从文件读取图片，转成输入流，这里会解析图片放置目录的dpi等级，并以出参value返回
                is = res.openRawResource(id, value);
                //根据解析出的图片目录的dpi等级，及设备密度，做缩放
                bm = decodeResourceStream(res, value, is, null, opts);
            } 
            return bm;
        }

第二步，跟踪openRawResource的执行，跳过参数透传，看AssetManager.java中的实现。

//从参数 TypedValue outValue的名字有out前缀，可以看出，这是一个出参，也就是说BitmapFactory中创建
    //的TypedValue对象，只是一个空壳，里面的实际参数值，会在接下来的解析中去填充。
        boolean getResourceValue(@AnyRes int resId, int densityDpi, @NonNull TypedValue outValue,
                boolean resolveRefs)@AssetManager.java {
            synchronized (this) {
                final int cookie = nativeGetResourceValue(
                        mObject, resId, (short) densityDpi, outValue, resolveRefs);
    
                // Convert the changing configurations flags populated by native code.
                outValue.changingConfigurations = ActivityInfo.activityInfoConfigNativeToJava(
                        outValue.changingConfigurations);
    
                if (outValue.type == TypedValue.TYPE_STRING) {
                    outValue.string = mApkAssets[cookie - 1].getStringFromPool(outValue.data);
                }
                return true;
            }
        }

调到jni层

//解析资源是通过AssetManager2来执行的
    static jint NativeGetResourceValue(JNIEnv* env, jclass /*clazz*/, jlong ptr, jint resid,
                                       jshort density, jobject typed_value,
                                       jboolean resolve_references) @android_util_AssetManager.cpp{
      ScopedLock<AssetManager2> assetmanager(AssetManagerFromLong(ptr));
      Res_value value;
      ResTable_config selected_config;
      uint32_t flags;
      ApkAssetsCookie cookie =
          assetmanager->GetResource(static_cast<uint32_t>(resid), false /*may_be_bag*/,
                                    static_cast<uint16_t>(density), &value, &selected_config, &flags);
    
      }

先用锁装饰了AAssetManager，实际完成解析的还是AAssetManager2中的实现，也就是AssetManager2.cpp中的

ApkAssetsCookie AssetManager2::GetResource(uint32_t resid, bool may_be_bag,
                                               uint16_t density_override, Res_value* out_value,
                                               ResTable_config* out_selected_config,
                                               uint32_t* out_flags) const {}

ApkAssetsCookie AssetManager2::FindEntry(uint32_t resid, uint16_t density_override,
                                             bool /*stop_at_first_match*/,
                                             FindEntryResult* out_entry) const {}

其中的结构体，ResTable\_config，对应了资源的类别。

对资源的解析，需要后续在做补充。。。

解析的图片所在目录的dpi等级，会作用到BitmapFactory.Options中，

public static Bitmap decodeResourceStream(@Nullable Resources res, @Nullable TypedValue value,
                @Nullable InputStream is, @Nullable Rect pad, @Nullable Options opts) {
            validate(opts);
            if (opts == null) {
                opts = new Options();
            }
    
            if (opts.inDensity == 0 && value != null) {
    //这里value.density的值，会随着图片放置的目录变化，如log打印
                final int density = value.density;
    			Log.e("BitmapFactory", "decodeResourceStream:" + value.density);
                if (density == TypedValue.DENSITY_DEFAULT) {
                    opts.inDensity = DisplayMetrics.DENSITY_DEFAULT;
                } else if (density != TypedValue.DENSITY_NONE) {
                    opts.inDensity = density;
                }
            }
            
            if (opts.inTargetDensity == 0 && res != null) {
                opts.inTargetDensity = res.getDisplayMetrics().densityDpi;
            }
            
            return decodeStream(is, pad, opts);
        }

把图片分别放在hdpi,xxhdpi时：

2020-01-20 16:59:45.739 3723-3723/com.jlq.mainthreaddemo E/BitmapFactory: decodeResourceStream:240
    
    2020-01-20 17:00:33.697 3806-3806/? E/BitmapFactory: decodeResourceStream:480

第三步，把元数据转成流后，接下来就是从流解码成bitmap，并做缩放。

具体从BitmapFactory.java开始

public static Bitmap decodeResourceStream(@Nullable Resources res, @Nullable TypedValue value,
                @Nullable InputStream is, @Nullable Rect pad, @Nullable Options opts) {}

转到native代码；

static jobject nativeDecodeStream(JNIEnv* env, jobject clazz, jobject is, jbyteArray storage,
            jobject padding, jobject options)@BitmapFactory.cpp {}

static jobject doDecode(JNIEnv* env, std::unique_ptr<SkStreamRewindable> stream,
                            jobject padding, jobject options) @BitmapFactory.cpp{
     // Update with options supplied by the client.
        if (options != NULL) {
            sampleSize = env->GetIntField(options, gOptions_sampleSizeFieldID);
            // Correct a non-positive sampleSize.  sampleSize defaults to zero within the
            // options object, which is strange.
            if (sampleSize <= 0) {
                sampleSize = 1;
            }
    
            if (env->GetBooleanField(options, gOptions_scaledFieldID)) {
                const int density = env->GetIntField(options, gOptions_densityFieldID);
                const int targetDensity = env->GetIntField(options, gOptions_targetDensityFieldID);
                const int screenDensity = env->GetIntField(options, gOptions_screenDensityFieldID);
                if (density != 0 && targetDensity != 0 && density != screenDensity) {
    //这里计算出缩放因子
                    scale = (float) targetDensity / density;
                }
            }
        }
        
    //对图片做缩放
        // Scale is necessary due to density differences.
        if (scale != 1.0f) {
            willScale = true;
            scaledWidth = static_cast<int>(scaledWidth * scale + 0.5f);
            scaledHeight = static_cast<int>(scaledHeight * scale + 0.5f);
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbjIwMDQ0MTQwNDEw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200120145444737.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbjIwMDQ0MTQwNDEw,size_16,color_FFFFFF,t_70
[20200120150157490.PNG]: https://img-blog.csdnimg.cn/20200120150157490.PNG
[20200120150417240.PNG]: https://img-blog.csdnimg.cn/20200120150417240.PNG
[20200120150654745.PNG]: https://img-blog.csdnimg.cn/20200120150654745.PNG