1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
package com.bumptech.glide.load.resource.gif;
import android.content.Context;
import android.graphics.Bitmap;
import android.util.Log;
import com.bumptech.glide.Glide;
import com.bumptech.glide.gifdecoder.GifDecoder;
import com.bumptech.glide.gifdecoder.GifHeader;
import com.bumptech.glide.gifdecoder.GifHeaderParser;
import com.bumptech.glide.load.ResourceDecoder;
import com.bumptech.glide.load.Transformation;
import com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool;
import com.bumptech.glide.load.resource.UnitTransformation;
import com.bumptech.glide.util.Util;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Queue;
/**
* An {@link com.bumptech.glide.load.ResourceDecoder} that decodes
* {@link com.bumptech.glide.load.resource.gif.GifDrawable} from {@link java.io.InputStream} data.
*/
public class GifResourceDecoder implements ResourceDecoder<InputStream, GifDrawable> {
private static final String TAG = "GifResourceDecoder";
private static final GifHeaderParserPool PARSER_POOL = new GifHeaderParserPool();
private static final GifDecoderPool DECODER_POOL = new GifDecoderPool();
private final Context context;
private final GifHeaderParserPool parserPool;
private final BitmapPool bitmapPool;
private final GifDecoderPool decoderPool;
private final GifBitmapProvider provider;
public GifResourceDecoder(Context context) {
this(context, Glide.get(context).getBitmapPool());
}
public GifResourceDecoder(Context context, BitmapPool bitmapPool) {
this(context, bitmapPool, PARSER_POOL, DECODER_POOL);
}
// Visible for testing.
GifResourceDecoder(Context context, BitmapPool bitmapPool, GifHeaderParserPool parserPool,
GifDecoderPool decoderPool) {
this.context = context;
this.bitmapPool = bitmapPool;
this.decoderPool = decoderPool;
this.provider = new GifBitmapProvider(bitmapPool);
this.parserPool = parserPool;
}
@Override
public GifDrawableResource decode(InputStream source, int width, int height) {
byte[] data = inputStreamToBytes(source);
final GifHeaderParser parser = parserPool.obtain(data);
final GifDecoder decoder = decoderPool.obtain(provider);
try {
return decode(data, width, height, parser, decoder);
} finally {
parserPool.release(parser);
decoderPool.release(decoder);
}
}
private GifDrawableResource decode(byte[] data, int width, int height, GifHeaderParser parser, GifDecoder decoder) {
final GifHeader header = parser.parseHeader();
if (header.getNumFrames() <= 0 || header.getStatus() != GifDecoder.STATUS_OK) {
// If we couldn't decode the GIF, we will end up with a frame count of 0.
return null;
}
Bitmap firstFrame = decodeFirstFrame(decoder, header, data);
if (firstFrame == null) {
return null;
}
Transformation<Bitmap> unitTransformation = UnitTransformation.get();
GifDrawable gifDrawable = new GifDrawable(context, provider, bitmapPool, unitTransformation, width, height,
header, data, firstFrame);
return new GifDrawableResource(gifDrawable);
}
private Bitmap decodeFirstFrame(GifDecoder decoder, GifHeader header, byte[] data) {
decoder.setData(header, data);
decoder.advance();
return decoder.getNextFrame();
}
@Override
public String getId() {
return "";
}
private static byte[] inputStreamToBytes(InputStream is) {
final int bufferSize = 16384;
ByteArrayOutputStream buffer = new ByteArrayOutputStream(bufferSize);
try {
int nRead;
byte[] data = new byte[bufferSize];
while ((nRead = is.read(data)) != -1) {
buffer.write(data, 0, nRead);
}
buffer.flush();
} catch (IOException e) {
Log.w(TAG, "Error reading data from stream", e);
}
//TODO the returned byte[] may be partial if an IOException was thrown from read
return buffer.toByteArray();
}
// Visible for testing.
static class GifDecoderPool {
private final Queue<GifDecoder> pool = Util.createQueue(0);
public synchronized GifDecoder obtain(GifDecoder.BitmapProvider bitmapProvider) {
GifDecoder result = pool.poll();
if (result == null) {
result = new GifDecoder(bitmapProvider);
}
return result;
}
public synchronized void release(GifDecoder decoder) {
decoder.clear();
pool.offer(decoder);
}
}
// Visible for testing.
static class GifHeaderParserPool {
private final Queue<GifHeaderParser> pool = Util.createQueue(0);
public synchronized GifHeaderParser obtain(byte[] data) {
GifHeaderParser result = pool.poll();
if (result == null) {
result = new GifHeaderParser();
}
return result.setData(data);
}
public synchronized void release(GifHeaderParser parser) {
parser.clear();
pool.offer(parser);
}
}
}
|
