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
|
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.photos.data;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.BitmapFactory;
import android.util.Log;
import com.android.gallery3d.R;
import com.android.gallery3d.common.BitmapUtils;
import com.android.gallery3d.data.DecodeUtils;
import com.android.gallery3d.data.MediaItem;
import com.android.gallery3d.util.ThreadPool.CancelListener;
import com.android.gallery3d.util.ThreadPool.JobContext;
import com.android.photos.data.MediaRetriever.MediaSize;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class MediaCacheUtils {
private static final String TAG = MediaCacheUtils.class.getSimpleName();
private static int QUALITY = 80;
private static final JobContext sJobStub = new JobContext() {
@Override
public boolean isCancelled() {
return false;
}
@Override
public void setCancelListener(CancelListener listener) {
}
@Override
public boolean setMode(int mode) {
return true;
}
};
private static int mTargetThumbnailSize;
private static int mTargetPreviewSize;
public static void initialize(Context context) {
Resources resources = context.getResources();
mTargetThumbnailSize = resources.getDimensionPixelSize(R.dimen.size_thumbnail);
mTargetPreviewSize = resources.getDimensionPixelSize(R.dimen.size_preview);
}
public static int getTargetSize(MediaSize size) {
return (size == MediaSize.Thumbnail) ? mTargetThumbnailSize : mTargetPreviewSize;
}
public static boolean downsample(File inBitmap, MediaSize targetSize, File outBitmap) {
if (MediaSize.Original == targetSize) {
return false; // MediaCache should use the local path for this.
}
int size = getTargetSize(targetSize);
BitmapFactory.Options options = new BitmapFactory.Options();
options.inPreferredConfig = Bitmap.Config.ARGB_8888;
// TODO: remove unnecessary job context from DecodeUtils.
Bitmap bitmap = DecodeUtils.decodeThumbnail(sJobStub, inBitmap.getPath(), options, size,
MediaItem.TYPE_THUMBNAIL);
boolean success = (bitmap != null);
if (success) {
success = writeAndRecycle(bitmap, outBitmap);
}
return success;
}
public static boolean downsample(Bitmap inBitmap, MediaSize size, File outBitmap) {
if (MediaSize.Original == size) {
return false; // MediaCache should use the local path for this.
}
int targetSize = getTargetSize(size);
boolean success;
if (!needsDownsample(inBitmap, size)) {
success = writeAndRecycle(inBitmap, outBitmap);
} else {
float maxDimension = Math.max(inBitmap.getWidth(), inBitmap.getHeight());
float scale = targetSize / maxDimension;
int targetWidth = Math.round(scale * inBitmap.getWidth());
int targetHeight = Math.round(scale * inBitmap.getHeight());
Bitmap scaled = Bitmap.createScaledBitmap(inBitmap, targetWidth, targetHeight, false);
success = writeAndRecycle(scaled, outBitmap);
inBitmap.recycle();
}
return success;
}
public static boolean extractImageFromVideo(File inVideo, File outBitmap) {
Bitmap bitmap = BitmapUtils.createVideoThumbnail(inVideo.getPath());
return writeAndRecycle(bitmap, outBitmap);
}
public static boolean needsDownsample(Bitmap bitmap, MediaSize size) {
if (size == MediaSize.Original) {
return false;
}
int targetSize = getTargetSize(size);
int maxDimension = Math.max(bitmap.getWidth(), bitmap.getHeight());
return maxDimension > (targetSize * 4 / 3);
}
public static boolean writeAndRecycle(Bitmap bitmap, File outBitmap) {
boolean success = writeToFile(bitmap, outBitmap);
bitmap.recycle();
return success;
}
public static boolean writeToFile(Bitmap bitmap, File outBitmap) {
boolean success = false;
try {
FileOutputStream out = new FileOutputStream(outBitmap);
success = bitmap.compress(CompressFormat.JPEG, QUALITY, out);
out.close();
} catch (IOException e) {
Log.w(TAG, "Couldn't write bitmap to cache", e);
// success is already false
}
return success;
}
}
|
