blob: 2c8530d4daebca62828237e01a79cacdd4830283 [file] [log] [blame]
Leon Scroggins III671cce22018-01-14 16:52:17 -05001/*
2 * Copyright (C) 2018 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
Leon Scroggins III671cce22018-01-14 16:52:17 -050017#include <SkAndroidCodec.h>
18#include <SkAnimatedImage.h>
19#include <SkColorFilter.h>
Kevin Lubick1175dc02022-02-28 12:41:27 -050020#include <SkEncodedImageFormat.h>
Leon Scroggins III671cce22018-01-14 16:52:17 -050021#include <SkPicture.h>
22#include <SkPictureRecorder.h>
Kevin Lubick1175dc02022-02-28 12:41:27 -050023#include <SkRect.h>
24#include <SkRefCnt.h>
Leon Scroggins III5b7f4262018-01-26 11:03:54 -050025#include <hwui/AnimatedImageDrawable.h>
26#include <hwui/Canvas.h>
Nader Jawadf0ea9e12023-05-02 15:18:00 -070027#include <hwui/ImageDecoder.h>
Jerome Gaillard01f8f4f2024-03-19 14:24:35 +000028#ifdef __ANDROID__
Leon Scroggins IIIbeaf5d92018-01-26 11:03:54 -050029#include <utils/Looper.h>
Jerome Gaillarddd37c982024-04-08 15:02:33 +010030#else
31#include "utils/MessageHandler.h"
Jerome Gaillard01f8f4f2024-03-19 14:24:35 +000032#endif
Leon Scroggins III671cce22018-01-14 16:52:17 -050033
Nader Jawadf0ea9e12023-05-02 15:18:00 -070034#include "ColorFilter.h"
35#include "GraphicsJNI.h"
36#include "ImageDecoder.h"
37#include "Utils.h"
38
Leon Scroggins III671cce22018-01-14 16:52:17 -050039using namespace android;
40
John Reck3998a012021-07-28 11:04:30 -040041static jclass gAnimatedImageDrawableClass;
42static jmethodID gAnimatedImageDrawable_callOnAnimationEndMethodID;
Leon Scroggins III671cce22018-01-14 16:52:17 -050043
44// Note: jpostProcess holds a handle to the ImageDecoder.
45static jlong AnimatedImageDrawable_nCreate(JNIEnv* env, jobject /*clazz*/,
46 jlong nativeImageDecoder, jobject jpostProcess,
Leon Scroggins IIIeac14232019-02-04 10:30:22 -050047 jint width, jint height, jlong colorSpaceHandle,
48 jboolean extended, jobject jsubset) {
Leon Scroggins III671cce22018-01-14 16:52:17 -050049 if (nativeImageDecoder == 0) {
50 doThrowIOE(env, "Cannot create AnimatedImageDrawable from null!");
51 return 0;
52 }
53
54 auto* imageDecoder = reinterpret_cast<ImageDecoder*>(nativeImageDecoder);
Leon Scroggins III671cce22018-01-14 16:52:17 -050055 SkIRect subset;
56 if (jsubset) {
57 GraphicsJNI::jrect_to_irect(env, jsubset, &subset);
58 } else {
59 subset = SkIRect::MakeWH(width, height);
60 }
61
Leon Scroggins IIIeb3b38e2018-03-20 11:11:13 -040062 bool hasRestoreFrame = false;
Leon Scroggins IIIeac14232019-02-04 10:30:22 -050063 if (imageDecoder->mCodec->getEncodedFormat() != SkEncodedImageFormat::kWEBP) {
Leon Scroggins IIIeb3b38e2018-03-20 11:11:13 -040064 const int frameCount = imageDecoder->mCodec->codec()->getFrameCount();
65 for (int i = 0; i < frameCount; ++i) {
66 SkCodec::FrameInfo frameInfo;
67 if (!imageDecoder->mCodec->codec()->getFrameInfo(i, &frameInfo)) {
68 doThrowIOE(env, "Failed to read frame info!");
69 return 0;
70 }
71 if (frameInfo.fDisposalMethod == SkCodecAnimation::DisposalMethod::kRestorePrevious) {
72 hasRestoreFrame = true;
73 break;
74 }
75 }
76 }
77
Leon Scroggins IIIeac14232019-02-04 10:30:22 -050078 auto info = imageDecoder->mCodec->getInfo().makeWH(width, height)
79 .makeColorSpace(GraphicsJNI::getNativeColorSpace(colorSpaceHandle));
80 if (extended) {
81 info = info.makeColorType(kRGBA_F16_SkColorType);
82 }
83
Leon Scroggins IIIeb3b38e2018-03-20 11:11:13 -040084 size_t bytesUsed = info.computeMinByteSize();
85 // SkAnimatedImage has one SkBitmap for decoding, plus an extra one if there is a
86 // kRestorePrevious frame. AnimatedImageDrawable has two SkPictures storing the current
87 // frame and the next frame. (The former assumes that the image is animated, and the
88 // latter assumes that it is drawn to a hardware canvas.)
89 bytesUsed *= hasRestoreFrame ? 4 : 3;
Leon Scroggins III671cce22018-01-14 16:52:17 -050090 sk_sp<SkPicture> picture;
91 if (jpostProcess) {
92 SkRect bounds = SkRect::MakeWH(subset.width(), subset.height());
93
94 SkPictureRecorder recorder;
95 SkCanvas* skcanvas = recorder.beginRecording(bounds);
96 std::unique_ptr<Canvas> canvas(Canvas::create_canvas(skcanvas));
Leon Scroggins IIIe5de9aa2018-01-10 20:56:51 -050097 postProcessAndRelease(env, jpostProcess, std::move(canvas));
Leon Scroggins III671cce22018-01-14 16:52:17 -050098 if (env->ExceptionCheck()) {
99 return 0;
100 }
101 picture = recorder.finishRecordingAsPicture();
Leon Scroggins IIIeb3b38e2018-03-20 11:11:13 -0400102 bytesUsed += picture->approximateBytesUsed();
Leon Scroggins III671cce22018-01-14 16:52:17 -0500103 }
104
John Reck2be87bb2023-04-05 17:33:00 -0400105 SkEncodedImageFormat format = imageDecoder->mCodec->getEncodedFormat();
Derek Sollenberger2d142132018-01-22 10:25:26 -0500106 sk_sp<SkAnimatedImage> animatedImg = SkAnimatedImage::Make(std::move(imageDecoder->mCodec),
Leon Scroggins IIIeac14232019-02-04 10:30:22 -0500107 info, subset,
Derek Sollenberger2d142132018-01-22 10:25:26 -0500108 std::move(picture));
109 if (!animatedImg) {
Leon Scroggins III671cce22018-01-14 16:52:17 -0500110 doThrowIOE(env, "Failed to create drawable");
111 return 0;
112 }
Leon Scroggins III671cce22018-01-14 16:52:17 -0500113
Leon Scroggins IIIeb3b38e2018-03-20 11:11:13 -0400114 bytesUsed += sizeof(animatedImg.get());
115
John Reck2be87bb2023-04-05 17:33:00 -0400116 sk_sp<AnimatedImageDrawable> drawable(
117 new AnimatedImageDrawable(std::move(animatedImg), bytesUsed, format));
Leon Scroggins III671cce22018-01-14 16:52:17 -0500118 return reinterpret_cast<jlong>(drawable.release());
119}
120
121static void AnimatedImageDrawable_destruct(AnimatedImageDrawable* drawable) {
Derek Sollenberger2d142132018-01-22 10:25:26 -0500122 SkSafeUnref(drawable);
Leon Scroggins III671cce22018-01-14 16:52:17 -0500123}
124
125static jlong AnimatedImageDrawable_nGetNativeFinalizer(JNIEnv* /*env*/, jobject /*clazz*/) {
126 return static_cast<jlong>(reinterpret_cast<uintptr_t>(&AnimatedImageDrawable_destruct));
127}
128
Leon Scroggins III5b7f4262018-01-26 11:03:54 -0500129// Java's FINISHED relies on this being -1
130static_assert(SkAnimatedImage::kFinished == -1);
131
Leon Scroggins III671cce22018-01-14 16:52:17 -0500132static jlong AnimatedImageDrawable_nDraw(JNIEnv* env, jobject /*clazz*/, jlong nativePtr,
Derek Sollenberger2d142132018-01-22 10:25:26 -0500133 jlong canvasPtr) {
Leon Scroggins III671cce22018-01-14 16:52:17 -0500134 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
Leon Scroggins III671cce22018-01-14 16:52:17 -0500135 auto* canvas = reinterpret_cast<Canvas*>(canvasPtr);
Derek Sollenberger2d142132018-01-22 10:25:26 -0500136 return (jlong) canvas->drawAnimatedImage(drawable);
Leon Scroggins III671cce22018-01-14 16:52:17 -0500137}
138
139static void AnimatedImageDrawable_nSetAlpha(JNIEnv* env, jobject /*clazz*/, jlong nativePtr,
140 jint alpha) {
141 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
Derek Sollenberger2d142132018-01-22 10:25:26 -0500142 drawable->setStagingAlpha(alpha);
Leon Scroggins III671cce22018-01-14 16:52:17 -0500143}
144
145static jlong AnimatedImageDrawable_nGetAlpha(JNIEnv* env, jobject /*clazz*/, jlong nativePtr) {
146 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
Derek Sollenberger2d142132018-01-22 10:25:26 -0500147 return drawable->getStagingAlpha();
Leon Scroggins III671cce22018-01-14 16:52:17 -0500148}
149
150static void AnimatedImageDrawable_nSetColorFilter(JNIEnv* env, jobject /*clazz*/, jlong nativePtr,
151 jlong nativeFilter) {
152 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
Nader Jawadf0ea9e12023-05-02 15:18:00 -0700153 auto filter = uirenderer::ColorFilter::fromJava(nativeFilter);
154 auto skColorFilter = filter != nullptr ? filter->getInstance() : sk_sp<SkColorFilter>();
155 drawable->setStagingColorFilter(skColorFilter);
Leon Scroggins III671cce22018-01-14 16:52:17 -0500156}
157
158static jboolean AnimatedImageDrawable_nIsRunning(JNIEnv* env, jobject /*clazz*/, jlong nativePtr) {
159 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
Derek Sollenberger2d142132018-01-22 10:25:26 -0500160 return drawable->isRunning();
Leon Scroggins III671cce22018-01-14 16:52:17 -0500161}
162
Leon Scroggins III057c91a2018-01-24 13:02:16 -0500163static jboolean AnimatedImageDrawable_nStart(JNIEnv* env, jobject /*clazz*/, jlong nativePtr) {
Leon Scroggins III671cce22018-01-14 16:52:17 -0500164 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
Leon Scroggins III057c91a2018-01-24 13:02:16 -0500165 return drawable->start();
Leon Scroggins III671cce22018-01-14 16:52:17 -0500166}
167
Leon Scroggins IIIbeaf5d92018-01-26 11:03:54 -0500168static jboolean AnimatedImageDrawable_nStop(JNIEnv* env, jobject /*clazz*/, jlong nativePtr) {
Leon Scroggins III671cce22018-01-14 16:52:17 -0500169 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
Leon Scroggins IIIbeaf5d92018-01-26 11:03:54 -0500170 return drawable->stop();
Leon Scroggins III671cce22018-01-14 16:52:17 -0500171}
172
Leon Scroggins III127d31a2018-01-19 12:29:47 -0500173// Java's LOOP_INFINITE relies on this being the same.
174static_assert(SkCodec::kRepetitionCountInfinite == -1);
175
Leon Scroggins III6de55b82018-02-23 16:11:37 -0500176static jint AnimatedImageDrawable_nGetRepeatCount(JNIEnv* env, jobject /*clazz*/, jlong nativePtr) {
Leon Scroggins III1474b782018-02-23 09:38:12 -0500177 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
178 return drawable->getRepetitionCount();
179}
180
Leon Scroggins III6de55b82018-02-23 16:11:37 -0500181static void AnimatedImageDrawable_nSetRepeatCount(JNIEnv* env, jobject /*clazz*/, jlong nativePtr,
182 jint loopCount) {
Leon Scroggins III127d31a2018-01-19 12:29:47 -0500183 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
184 drawable->setRepetitionCount(loopCount);
185}
186
Leon Scroggins IIIbeaf5d92018-01-26 11:03:54 -0500187class InvokeListener : public MessageHandler {
Leon Scroggins III127d31a2018-01-19 12:29:47 -0500188public:
Leon Scroggins IIIbeaf5d92018-01-26 11:03:54 -0500189 InvokeListener(JNIEnv* env, jobject javaObject) {
Leon Scroggins III127d31a2018-01-19 12:29:47 -0500190 LOG_ALWAYS_FATAL_IF(env->GetJavaVM(&mJvm) != JNI_OK);
John Reck3998a012021-07-28 11:04:30 -0400191 mCallbackRef = env->NewGlobalRef(javaObject);
Leon Scroggins III127d31a2018-01-19 12:29:47 -0500192 }
193
Leon Scroggins IIIbeaf5d92018-01-26 11:03:54 -0500194 ~InvokeListener() override {
Leon Scroggins IIIf97b29d22020-04-06 12:01:01 -0400195 auto* env = requireEnv(mJvm);
John Reck3998a012021-07-28 11:04:30 -0400196 env->DeleteGlobalRef(mCallbackRef);
Leon Scroggins III127d31a2018-01-19 12:29:47 -0500197 }
198
Leon Scroggins IIIbeaf5d92018-01-26 11:03:54 -0500199 virtual void handleMessage(const Message&) override {
Leon Scroggins III127d31a2018-01-19 12:29:47 -0500200 auto* env = get_env_or_die(mJvm);
John Reck3998a012021-07-28 11:04:30 -0400201 env->CallStaticVoidMethod(gAnimatedImageDrawableClass,
202 gAnimatedImageDrawable_callOnAnimationEndMethodID, mCallbackRef);
Leon Scroggins III127d31a2018-01-19 12:29:47 -0500203 }
204
205private:
206 JavaVM* mJvm;
John Reck3998a012021-07-28 11:04:30 -0400207 jobject mCallbackRef;
Leon Scroggins IIIbeaf5d92018-01-26 11:03:54 -0500208};
209
210class JniAnimationEndListener : public OnAnimationEndListener {
Jerome Gaillard01f8f4f2024-03-19 14:24:35 +0000211#ifdef __ANDROID__
Leon Scroggins IIIbeaf5d92018-01-26 11:03:54 -0500212public:
213 JniAnimationEndListener(sp<Looper>&& looper, JNIEnv* env, jobject javaObject) {
214 mListener = new InvokeListener(env, javaObject);
215 mLooper = std::move(looper);
216 }
217
218 void onAnimationEnd() override { mLooper->sendMessage(mListener, 0); }
219
220private:
221 sp<InvokeListener> mListener;
222 sp<Looper> mLooper;
Jerome Gaillard01f8f4f2024-03-19 14:24:35 +0000223#else
224public:
225 JniAnimationEndListener(JNIEnv* env, jobject javaObject) {
226 mListener = new InvokeListener(env, javaObject);
227 }
228
229 void onAnimationEnd() override { mListener->handleMessage(0); }
230
231private:
232 sp<InvokeListener> mListener;
233#endif
Leon Scroggins III127d31a2018-01-19 12:29:47 -0500234};
235
236static void AnimatedImageDrawable_nSetOnAnimationEndListener(JNIEnv* env, jobject /*clazz*/,
237 jlong nativePtr, jobject jdrawable) {
238 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
Leon Scroggins IIIbeaf5d92018-01-26 11:03:54 -0500239 if (!jdrawable) {
240 drawable->setOnAnimationEndListener(nullptr);
241 } else {
Jerome Gaillard01f8f4f2024-03-19 14:24:35 +0000242#ifdef __ANDROID__
Leon Scroggins IIIbeaf5d92018-01-26 11:03:54 -0500243 sp<Looper> looper = Looper::getForThread();
244 if (!looper.get()) {
245 doThrowISE(env,
246 "Must set AnimatedImageDrawable's AnimationCallback on a thread with a "
247 "looper!");
248 return;
249 }
250
251 drawable->setOnAnimationEndListener(
252 std::make_unique<JniAnimationEndListener>(std::move(looper), env, jdrawable));
Jerome Gaillard01f8f4f2024-03-19 14:24:35 +0000253#else
254 drawable->setOnAnimationEndListener(
255 std::make_unique<JniAnimationEndListener>(env, jdrawable));
256#endif
Leon Scroggins IIIbeaf5d92018-01-26 11:03:54 -0500257 }
Leon Scroggins III127d31a2018-01-19 12:29:47 -0500258}
259
Leon Scroggins IIIeb3b38e2018-03-20 11:11:13 -0400260static jlong AnimatedImageDrawable_nNativeByteSize(JNIEnv* env, jobject /*clazz*/, jlong nativePtr) {
Leon Scroggins III671cce22018-01-14 16:52:17 -0500261 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
Leon Scroggins IIIeb3b38e2018-03-20 11:11:13 -0400262 return drawable->byteSize();
Leon Scroggins III671cce22018-01-14 16:52:17 -0500263}
264
Leon Scroggins III5e8447f2018-03-05 14:22:51 -0500265static void AnimatedImageDrawable_nSetMirrored(JNIEnv* env, jobject /*clazz*/, jlong nativePtr,
266 jboolean mirrored) {
267 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
268 drawable->setStagingMirrored(mirrored);
269}
270
Leon Scroggins IIIbe969ef2021-01-20 15:28:39 -0500271static void AnimatedImageDrawable_nSetBounds(JNIEnv* env, jobject /*clazz*/, jlong nativePtr,
272 jobject jrect) {
273 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
274 SkRect rect;
275 GraphicsJNI::jrect_to_rect(env, jrect, &rect);
276 drawable->setStagingBounds(rect);
277}
278
Daniel Dilanae7c8352024-10-14 19:46:40 +0000279static jboolean AnimatedImageDrawable_nSetFilterBitmap(JNIEnv* env, jobject /*clazz*/,
280 jlong nativePtr, jboolean filterBitmap) {
281 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
282 return drawable->setFilterBitmap(filterBitmap);
283}
284
285static jboolean AnimatedImageDrawable_nGetFilterBitmap(JNIEnv* env, jobject /*clazz*/,
286 jlong nativePtr) {
287 auto* drawable = reinterpret_cast<AnimatedImageDrawable*>(nativePtr);
288 return drawable->getFilterBitmap();
289}
290
Leon Scroggins III671cce22018-01-14 16:52:17 -0500291static const JNINativeMethod gAnimatedImageDrawableMethods[] = {
John Reck3998a012021-07-28 11:04:30 -0400292 {"nCreate", "(JLandroid/graphics/ImageDecoder;IIJZLandroid/graphics/Rect;)J",
293 (void*)AnimatedImageDrawable_nCreate},
294 {"nGetNativeFinalizer", "()J", (void*)AnimatedImageDrawable_nGetNativeFinalizer},
295 {"nDraw", "(JJ)J", (void*)AnimatedImageDrawable_nDraw},
296 {"nSetAlpha", "(JI)V", (void*)AnimatedImageDrawable_nSetAlpha},
297 {"nGetAlpha", "(J)I", (void*)AnimatedImageDrawable_nGetAlpha},
298 {"nSetColorFilter", "(JJ)V", (void*)AnimatedImageDrawable_nSetColorFilter},
299 {"nIsRunning", "(J)Z", (void*)AnimatedImageDrawable_nIsRunning},
300 {"nStart", "(J)Z", (void*)AnimatedImageDrawable_nStart},
301 {"nStop", "(J)Z", (void*)AnimatedImageDrawable_nStop},
302 {"nGetRepeatCount", "(J)I", (void*)AnimatedImageDrawable_nGetRepeatCount},
303 {"nSetRepeatCount", "(JI)V", (void*)AnimatedImageDrawable_nSetRepeatCount},
304 {"nSetOnAnimationEndListener", "(JLjava/lang/ref/WeakReference;)V",
305 (void*)AnimatedImageDrawable_nSetOnAnimationEndListener},
306 {"nNativeByteSize", "(J)J", (void*)AnimatedImageDrawable_nNativeByteSize},
307 {"nSetMirrored", "(JZ)V", (void*)AnimatedImageDrawable_nSetMirrored},
308 {"nSetBounds", "(JLandroid/graphics/Rect;)V", (void*)AnimatedImageDrawable_nSetBounds},
Daniel Dilanae7c8352024-10-14 19:46:40 +0000309 {"nSetFilterBitmap", "(JZ)Z", (void*)AnimatedImageDrawable_nSetFilterBitmap},
310 {"nGetFilterBitmap", "(J)Z", (void*)AnimatedImageDrawable_nGetFilterBitmap},
Leon Scroggins III671cce22018-01-14 16:52:17 -0500311};
312
313int register_android_graphics_drawable_AnimatedImageDrawable(JNIEnv* env) {
John Reck3998a012021-07-28 11:04:30 -0400314 gAnimatedImageDrawableClass = reinterpret_cast<jclass>(env->NewGlobalRef(
315 FindClassOrDie(env, "android/graphics/drawable/AnimatedImageDrawable")));
316 gAnimatedImageDrawable_callOnAnimationEndMethodID =
317 GetStaticMethodIDOrDie(env, gAnimatedImageDrawableClass, "callOnAnimationEnd",
318 "(Ljava/lang/ref/WeakReference;)V");
Leon Scroggins III127d31a2018-01-19 12:29:47 -0500319
Leon Scroggins III671cce22018-01-14 16:52:17 -0500320 return android::RegisterMethodsOrDie(env, "android/graphics/drawable/AnimatedImageDrawable",
321 gAnimatedImageDrawableMethods, NELEM(gAnimatedImageDrawableMethods));
322}
323