1 /* 2 * Copyright (C) 2016 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 #ifndef _NDK_IMAGE_READER_PRIV_H 18 #define _NDK_IMAGE_READER_PRIV_H 19 20 #include <inttypes.h> 21 22 #include <media/NdkImageReader.h> 23 #include <media-vndk/VndkImageReader.h> 24 25 #include <utils/List.h> 26 #include <utils/Mutex.h> 27 #include <utils/StrongPointer.h> 28 29 #include <com_android_graphics_libgui_flags.h> 30 #include <gui/BufferItem.h> 31 #include <gui/BufferItemConsumer.h> 32 #include <gui/Surface.h> 33 34 #include <media/stagefright/foundation/ALooper.h> 35 #include <media/stagefright/foundation/AHandler.h> 36 #include <media/stagefright/foundation/AMessage.h> 37 38 using namespace android; 39 40 namespace { 41 enum { 42 IMAGE_READER_MAX_NUM_PLANES = 3, 43 }; 44 45 enum { 46 ACQUIRE_SUCCESS = 0, 47 ACQUIRE_NO_BUFFERS = 1, 48 ACQUIRE_MAX_IMAGES = 2, 49 }; 50 } 51 52 struct AImageReader : public RefBase { 53 public: 54 static bool isSupportedFormatAndUsage(int32_t format, uint64_t usage0); 55 static int getNumPlanesForFormat(int32_t format); 56 57 AImageReader(int32_t width, 58 int32_t height, 59 int32_t format, 60 uint64_t usage, 61 int32_t maxImages, 62 uint32_t hardwareBufferFormat, 63 android_dataspace dataSpace); 64 ~AImageReader(); 65 66 // Initialize AImageReader, uninitialized or failed to initialize AImageReader 67 // should never be passed to application 68 media_status_t init(); 69 70 media_status_t setImageListener(AImageReader_ImageListener* listener); 71 media_status_t setBufferRemovedListener(AImageReader_BufferRemovedListener* listener); 72 media_status_t setUsage(uint64_t usage); 73 74 media_status_t acquireNextImage(/*out*/AImage** image, /*out*/int* fenceFd); 75 media_status_t acquireLatestImage(/*out*/AImage** image, /*out*/int* fenceFd); 76 77 media_status_t getWindowNativeHandle(/*out*/native_handle_t **handle); 78 getWindowAImageReader79 ANativeWindow* getWindow() const { return mWindow.get(); }; getWidthAImageReader80 int32_t getWidth() const { return mWidth; }; getHeightAImageReader81 int32_t getHeight() const { return mHeight; }; getFormatAImageReader82 int32_t getFormat() const { return mFormat; }; getMaxImagesAImageReader83 int32_t getMaxImages() const { return mMaxImages; }; 84 void close(); 85 86 private: 87 friend struct AImage; // for grabing reader lock 88 89 BufferItem* getBufferItemLocked(); 90 void returnBufferItemLocked(BufferItem* buffer); 91 92 // Called by AImageReader_acquireXXX to acquire a Buffer and setup AImage. 93 media_status_t acquireImageLocked(/*out*/AImage** image, /*out*/int* fenceFd); 94 95 // Called by AImage/~AImageReader to close image. Caller is responsible to grab AImage::mLock 96 void releaseImageLocked(AImage* image, int releaseFenceFd, bool clearCache = true); 97 98 static int getBufferWidth(BufferItem* buffer); 99 static int getBufferHeight(BufferItem* buffer); 100 101 media_status_t setImageListenerLocked(AImageReader_ImageListener* listener); 102 media_status_t setBufferRemovedListenerLocked(AImageReader_BufferRemovedListener* listener); 103 104 // definition of handler and message 105 enum { 106 kWhatBufferRemoved, 107 kWhatImageAvailable, 108 }; 109 static const char* kCallbackFpKey; 110 static const char* kContextKey; 111 static const char* kGraphicBufferKey; 112 class CallbackHandler : public AHandler { 113 public: CallbackHandlerAImageReader114 CallbackHandler(AImageReader* reader) : mReader(reader) {} 115 void onMessageReceived(const sp<AMessage> &msg) override; 116 private: 117 AImageReader* mReader; 118 }; 119 sp<CallbackHandler> mHandler; 120 sp<ALooper> mCbLooper; // Looper thread where callbacks actually happen on 121 List<BufferItem*> mBuffers; 122 123 const int32_t mWidth; 124 const int32_t mHeight; 125 int32_t mFormat; 126 uint64_t mUsage; // AHARDWAREBUFFER_USAGE_* flags. 127 const int32_t mMaxImages; 128 129 // TODO(jwcai) Seems completely unused in AImageReader class. 130 const int32_t mNumPlanes; 131 132 uint32_t mHalFormat = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM; 133 android_dataspace mHalDataSpace = HAL_DATASPACE_UNKNOWN; 134 135 struct FrameListener : public ConsumerBase::FrameAvailableListener { 136 public: FrameListenerAImageReader::FrameListener137 explicit FrameListener(AImageReader* parent) : mReader(parent) {} 138 139 void onFrameAvailable(const BufferItem& item) override; 140 141 media_status_t setImageListener(AImageReader_ImageListener* listener); 142 143 private: 144 AImageReader_ImageListener mListener = {nullptr, nullptr}; 145 const wp<AImageReader> mReader; 146 Mutex mLock; 147 }; 148 sp<FrameListener> mFrameListener; 149 150 struct BufferRemovedListener : public BufferItemConsumer::BufferFreedListener { 151 public: BufferRemovedListenerAImageReader::BufferRemovedListener152 explicit BufferRemovedListener(AImageReader* parent) : mReader(parent) {} 153 154 void onBufferFreed(const wp<GraphicBuffer>& graphicBuffer) override; 155 156 media_status_t setBufferRemovedListener(AImageReader_BufferRemovedListener* listener); 157 158 private: 159 AImageReader_BufferRemovedListener mListener = {nullptr, nullptr}; 160 const wp<AImageReader> mReader; 161 Mutex mLock; 162 }; 163 sp<BufferRemovedListener> mBufferRemovedListener; 164 165 uint64_t mHalUsage; 166 167 #if !COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ) 168 sp<IGraphicBufferProducer> mProducer; 169 #endif // !COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ) 170 sp<Surface> mSurface; 171 sp<BufferItemConsumer> mBufferItemConsumer; 172 sp<ANativeWindow> mWindow; 173 native_handle_t* mWindowHandle = nullptr; 174 175 List<AImage*> mAcquiredImages; 176 bool mIsOpen = false; 177 178 Mutex mLock; 179 }; 180 181 #endif // _NDK_IMAGE_READER_PRIV_H 182