Glide源码解析04-decode

痛定思痛。 2023-10-17 13:07 87阅读 0赞

## Glide源码解析04-decode ##

承接上文的EngineRunnable\#run()，内部会调用EngineRunnable\#decode()来解析数据，我们来分析下。

##### 4.0 EngineRunnable\#decode() #####

decode方法中会进行是否从缓存中解析图片，如果从而调用不同的处理逻辑，这里我们只看decodeFromSource。

private Resource<?> decode() throws Exception {
    
        //是否从缓存中decode图片
        if (isDecodingFromCache()) {
            return decodeFromCache();
        } else {
            return decodeFromSource();
        }
    }

##### 4.1 decodeFromSource #####

首先会解码Resource对象，然后将`Resource<T>`对象转化为`Resource<Z>`对象，方便后面统一使用

class DecodeJob<A, T, Z> {
        ...
        public Resource<Z> decodeFromSource() throws Exception {
            //3.13 解码Resource对象
            Resource<T> decoded = decodeSource();
            //3.14 将Resource<T>对象转化为Resource<Z>对象
            return transformEncodeAndTranscode(decoded);
        }
    
        private Resource<T> decodeSource() throws Exception {
            Resource<T> decoded = null;
            try {
                long startTime = LogTime.getLogTime();
                final A data = fetcher.loadData(priority);
                if (Log.isLoggable(TAG, Log.VERBOSE)) {
                    logWithTimeAndKey("Fetched data", startTime);
                }
                if (isCancelled) {
                    return null;
                }
                decoded = decodeFromSourceData(data);
            } finally {
                fetcher.cleanup();
            }
            return decoded;
        }
        ...
    }

##### 4.2 decodeSource \#\#\#\# #####

此处，会调用fetcher.loadData加载数据，fetcher有很多种，比如从网络加载的HttpUrlFetcher(基于HttpUrlConnection)，从asset中加载的AssetPathFetcher等等

private Resource<T> decodeSource() throws Exception {
        Resource<T> decoded = null;
        try {
            long startTime = LogTime.getLogTime();
            final A data = fetcher.loadData(priority);
    
            if (isCancelled) {
                return null;
            }
            //进行解码
            decoded = decodeFromSourceData(data);
        } finally {
            fetcher.cleanup();
        }
        return decoded;
    }
    
    private Resource<T> decodeFromSourceData(A data) throws IOException {
        final Resource<T> decoded;
        if (diskCacheStrategy.cacheSource()) {
            decoded = cacheAndDecodeSourceData(data);
        } else {
            long startTime = LogTime.getLogTime();
            //loadProvider是刚才在onSizeReady()中的FixedLoadProvider
            //getSourceDecoder是GifBitmapWrapperResourceDecoder
            //在此处真正进行解码
            decoded = loadProvider.getSourceDecoder().decode(data, width, height);
            if (Log.isLoggable(TAG, Log.VERBOSE)) {
                logWithTimeAndKey("Decoded from source", startTime);
            }
        }
        return decoded;
    }

##### 4.3 loadProvider.getSourceDecoder().decode #####

经过一系列的方法，最终会调用Downsampler\#decode，对服务器返回的InputStream的读取，以及对图片的加载全都在这里了，包括对图片的压缩，甚至还有旋转、圆角等逻辑处理。

public abstract class Downsampler implements BitmapDecoder<InputStream> {
    
        public Bitmap decode(InputStream is, BitmapPool pool, int outWidth, int outHeight, DecodeFormat decodeFormat) {
            final ByteArrayPool byteArrayPool = ByteArrayPool.get();
            final byte[] bytesForOptions = byteArrayPool.getBytes();
            final byte[] bytesForStream = byteArrayPool.getBytes();
            final BitmapFactory.Options options = getDefaultOptions();
    
            // Use to fix the mark limit to avoid allocating buffers that fit entire images.
            RecyclableBufferedInputStream bufferedStream = new RecyclableBufferedInputStream(
                    is, bytesForStream);
            // Use to retrieve exceptions thrown while reading.
            // TODO(#126): when the framework no longer returns partially decoded Bitmaps or provides a way to determine
            // if a Bitmap is partially decoded, consider removing.
            ExceptionCatchingInputStream exceptionStream =
                    ExceptionCatchingInputStream.obtain(bufferedStream);
            // Use to read data.
            // Ensures that we can always reset after reading an image header so that we can still attempt to decode the
            // full image even when the header decode fails and/or overflows our read buffer. See #283.
            MarkEnforcingInputStream invalidatingStream = new MarkEnforcingInputStream(exceptionStream);
            try {
                exceptionStream.mark(MARK_POSITION);
                int orientation = 0;
                try {
                    orientation = new ImageHeaderParser(exceptionStream).getOrientation();
                } catch (IOException e) {
                    if (Log.isLoggable(TAG, Log.WARN)) {
                        Log.w(TAG, "Cannot determine the image orientation from header", e);
                    }
                } finally {
                    try {
                        exceptionStream.reset();
                    } catch (IOException e) {
                        if (Log.isLoggable(TAG, Log.WARN)) {
                            Log.w(TAG, "Cannot reset the input stream", e);
                        }
                    }
                }
    
                options.inTempStorage = bytesForOptions;
    
                final int[] inDimens = getDimensions(invalidatingStream, bufferedStream, options);
                final int inWidth = inDimens[0];
                final int inHeight = inDimens[1];
    
                final int degreesToRotate = TransformationUtils.getExifOrientationDegrees(orientation);
                final int sampleSize = getRoundedSampleSize(degreesToRotate, inWidth, inHeight, outWidth, outHeight);
    
                final Bitmap downsampled =
                        downsampleWithSize(invalidatingStream, bufferedStream, options, pool, inWidth, inHeight, sampleSize,
                                decodeFormat);
    
                // BitmapFactory swallows exceptions during decodes and in some cases when inBitmap is non null, may catch
                // and log a stack trace but still return a non null bitmap. To avoid displaying partially decoded bitmaps,
                // we catch exceptions reading from the stream in our ExceptionCatchingInputStream and throw them here.
                final Exception streamException = exceptionStream.getException();
                if (streamException != null) {
                    throw new RuntimeException(streamException);
                }
    
                Bitmap rotated = null;
                if (downsampled != null) {
                    rotated = TransformationUtils.rotateImageExif(downsampled, pool, orientation);
    
                    if (!downsampled.equals(rotated) && !pool.put(downsampled)) {
                        downsampled.recycle();
                    }
                }
    
                return rotated;
            } finally {
                byteArrayPool.releaseBytes(bytesForOptions);
                byteArrayPool.releaseBytes(bytesForStream);
                exceptionStream.release();
                releaseOptions(options);
            }
        }
    }

#### 更多 ####

[Glide源码解析01-with][Glide_01-with]  
[Glide源码解析02-load][Glide_02-load]  
[Glide源码解析03-into][Glide_03-into]  
[ Glide源码解析04-decode][Glide_04-decode]  
[Glide源码解析05-onLoadComplete][Glide_05-onLoadComplete]  
[Glide源码解析06-Glide流程图][Glide_06-Glide]

[Glide_01-with]: http://blog.csdn.net/ethanco/article/details/71977252
[Glide_02-load]: http://blog.csdn.net/ethanco/article/details/71983310
[Glide_03-into]: http://blog.csdn.net/ethanco/article/details/72085582
[Glide_04-decode]: http://blog.csdn.net/ethanco/article/details/72085588
[Glide_05-onLoadComplete]: http://blog.csdn.net/ethanco/article/details/72085605
[Glide_06-Glide]: http://blog.csdn.net/ethanco/article/details/72085606