Links
Android Sites
Language
Results
Loading...
1
/*
2
* Copyright (C) 2014 The Android Open Source Project
3
*
4
* Licensed under the Apache License, Version 2.0 (the "License");
5
* you may not use this file except in compliance with the License.
6
* You may obtain a copy of the License at
7
*
8
* http://www.apache.org/licenses/LICENSE-2.0
9
*
10
* Unless required by applicable law or agreed to in writing, software
11
* distributed under the License is distributed on an "AS IS" BASIS,
12
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
* See the License for the specific language governing permissions and
14
* limitations under the License.
15
*/
16
17
package com.example.android.basicrenderscript;
18
19
import android.app.Activity;
20
import android.graphics.Bitmap;
21
import android.graphics.BitmapFactory;
22
import android.os.AsyncTask;
23
import android.os.Bundle;
24
import android.widget.ImageView;
25
import android.widget.SeekBar;
26
import android.widget.SeekBar.OnSeekBarChangeListener;
27
import android.support.v8.renderscript.*;
28
29
public class MainActivity extends Activity {
30
/* Number of bitmaps that is used for renderScript thread and UI thread synchronization.
31
Ideally, this can be reduced to 2, however in some devices, 2 buffers still showing tierings on UI.
32
Investigating a root cause.
33
*/
34
private final int NUM_BITMAPS = 3;
35
private int mCurrentBitmap = 0;
36
private Bitmap mBitmapIn;
37
private Bitmap[] mBitmapsOut;
38
private ImageView mImageView;
39
40
private RenderScript mRS;
41
private Allocation mInAllocation;
42
private Allocation[] mOutAllocations;
43
private ScriptC_saturation mScript;
44
45
@Override
46
protected void onCreate(Bundle savedInstanceState) {
47
super.onCreate(savedInstanceState);
48
49
setContentView(R.layout.main_layout);
50
51
/*
52
* Initialize UI
53
*/
54
mBitmapIn = loadBitmap(R.drawable.data);
55
mBitmapsOut = new Bitmap[NUM_BITMAPS];
56
for (int i = 0; i < NUM_BITMAPS; ++i) {
57
mBitmapsOut[i] = Bitmap.createBitmap(mBitmapIn.getWidth(),
58
mBitmapIn.getHeight(), mBitmapIn.getConfig());
59
}
60
61
mImageView = (ImageView) findViewById(R.id.imageView);
62
mImageView.setImageBitmap(mBitmapsOut[mCurrentBitmap]);
63
mCurrentBitmap += (mCurrentBitmap + 1) % NUM_BITMAPS;
64
65
SeekBar seekbar = (SeekBar) findViewById(R.id.seekBar1);
66
seekbar.setProgress(50);
67
seekbar.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
68
public void onProgressChanged(SeekBar seekBar, int progress,
69
boolean fromUser) {
70
float max = 2.0f;
71
float min = 0.0f;
72
float f = (float) ((max - min) * (progress / 100.0) + min);
73
updateImage(f);
74
}
75
76
@Override
77
public void onStartTrackingTouch(SeekBar seekBar) {
78
}
79
80
@Override
81
public void onStopTrackingTouch(SeekBar seekBar) {
82
}
83
});
84
85
/*
86
* Create renderScript
87
*/
88
createScript();
89
90
/*
91
* Invoke renderScript kernel and update imageView
92
*/
93
updateImage(1.0f);
94
}
95
96
/*
97
* Initialize RenderScript
98
* In the sample, it creates RenderScript kernel that performs saturation manipulation.
99
*/
100
private void createScript() {
101
//Initialize RS
102
mRS = RenderScript.create(this);
103
104
//Allocate buffers
105
mInAllocation = Allocation.createFromBitmap(mRS, mBitmapIn);
106
mOutAllocations = new Allocation[NUM_BITMAPS];
107
for (int i = 0; i < NUM_BITMAPS; ++i) {
108
mOutAllocations[i] = Allocation.createFromBitmap(mRS, mBitmapsOut[i]);
109
}
110
111
//Load script
112
mScript = new ScriptC_saturation(mRS);
113
}
114
115
/*
116
* In the AsyncTask, it invokes RenderScript intrinsics to do a filtering.
117
* After the filtering is done, an operation blocks at Allication.copyTo() in AsyncTask thread.
118
* Once all operation is finished at onPostExecute() in UI thread, it can invalidate and update ImageView UI.
119
*/
120
private class RenderScriptTask extends AsyncTask<Float, Integer, Integer> {
121
Boolean issued = false;
122
123
protected Integer doInBackground(Float... values) {
124
int index = -1;
125
if (isCancelled() == false) {
126
issued = true;
127
index = mCurrentBitmap;
128
129
/*
130
* Set global variable in RS
131
*/
132
mScript.set_saturationValue(values[0]);
133
134
/*
135
* Invoke saturation filter kernel
136
*/
137
mScript.forEach_saturation(mInAllocation, mOutAllocations[index]);
138
139
/*
140
* Copy to bitmap and invalidate image view
141
*/
142
mOutAllocations[index].copyTo(mBitmapsOut[index]);
143
mCurrentBitmap = (mCurrentBitmap + 1) % NUM_BITMAPS;
144
}
145
return index;
146
}
147
148
void updateView(Integer result) {
149
if (result != -1) {
150
// Request UI update
151
mImageView.setImageBitmap(mBitmapsOut[result]);
152
mImageView.invalidate();
153
}
154
}
155
156
protected void onPostExecute(Integer result) {
157
updateView(result);
158
}
159
160
protected void onCancelled(Integer result) {
161
if (issued) {
162
updateView(result);
163
}
164
}
165
}
166
167
RenderScriptTask currentTask = null;
168
169
/*
170
Invoke AsynchTask and cancel previous task.
171
When AsyncTasks are piled up (typically in slow device with heavy kernel),
172
Only the latest (and already started) task invokes RenderScript operation.
173
*/
174
private void updateImage(final float f) {
175
if (currentTask != null)
176
currentTask.cancel(false);
177
currentTask = new RenderScriptTask();
178
currentTask.execute(f);
179
}
180
181
/*
182
Helper to load Bitmap from resource
183
*/
184
private Bitmap loadBitmap(int resource) {
185
final BitmapFactory.Options options = new BitmapFactory.Options();
186
options.inPreferredConfig = Bitmap.Config.ARGB_8888;
187
return BitmapFactory.decodeResource(getResources(), resource, options);
188
}
189
190
}