1 /* 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 17 #pragma once 18 19 #include <android-base/unique_fd.h> 20 #include <system/window.h> 21 #include <apex/window.h> 22 #include <utils/Errors.h> 23 #include <utils/Macros.h> 24 #include <utils/NdkUtils.h> 25 #include <utils/StrongPointer.h> 26 27 #include <memory> 28 #include <mutex> 29 30 namespace android::uirenderer::renderthread { 31 32 class ReliableSurface { 33 PREVENT_COPY_AND_ASSIGN(ReliableSurface); 34 35 public: 36 ReliableSurface(ANativeWindow* window); 37 ~ReliableSurface(); 38 39 // Performs initialization that is not safe to do in the constructor. 40 // For instance, registering ANativeWindow interceptors with ReliableSurface 41 // passed as the data pointer is not safe. 42 void init(); 43 getNativeWindow()44 ANativeWindow* getNativeWindow() { return mWindow; } 45 46 int reserveNext(); 47 getAndClearError()48 int getAndClearError() { 49 int ret = mBufferQueueState; 50 mBufferQueueState = OK; 51 return ret; 52 } 53 didSetExtraBuffers()54 bool didSetExtraBuffers() const { 55 std::lock_guard _lock{mMutex}; 56 return mDidSetExtraBuffers; 57 } 58 59 private: 60 ANativeWindow* mWindow; 61 62 mutable std::mutex mMutex; 63 64 uint64_t mUsage = AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER; 65 AHardwareBuffer_Format mFormat = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM; 66 UniqueAHardwareBuffer mScratchBuffer; 67 ANativeWindowBuffer* mReservedBuffer = nullptr; 68 base::unique_fd mReservedFenceFd; 69 bool mHasDequeuedBuffer = false; 70 int mBufferQueueState = OK; 71 size_t mExpectedBufferCount = 0; 72 bool mDidSetExtraBuffers = false; 73 74 bool isFallbackBuffer(const ANativeWindowBuffer* windowBuffer) const; 75 ANativeWindowBuffer* acquireFallbackBuffer(int error); 76 void clearReservedBuffer(); 77 78 // ANativeWindow hooks. When an ANativeWindow_* method is called on the 79 // underlying ANativeWindow, these methods will intercept the original call. 80 // For example, an EGL driver would call into these hooks instead of the 81 // original methods. 82 static int hook_cancelBuffer(ANativeWindow* window, ANativeWindow_cancelBufferFn cancelBuffer, 83 void* data, ANativeWindowBuffer* buffer, int fenceFd); 84 static int hook_dequeueBuffer(ANativeWindow* window, 85 ANativeWindow_dequeueBufferFn dequeueBuffer, void* data, 86 ANativeWindowBuffer** buffer, int* fenceFd); 87 static int hook_queueBuffer(ANativeWindow* window, ANativeWindow_queueBufferFn queueBuffer, 88 void* data, ANativeWindowBuffer* buffer, int fenceFd); 89 90 static int hook_perform(ANativeWindow* window, ANativeWindow_performFn perform, void* data, 91 int operation, va_list args); 92 static int hook_query(const ANativeWindow* window, ANativeWindow_queryFn query, void* data, 93 int what, int* value); 94 }; 95 96 }; // namespace android::uirenderer::renderthread 97