Add an llndk api to get a native handle corresponding to ANativeWindow in AImageReader.
Since vendor modules sometimes might need to transfer ANativeWindow(specific to
AImageReader) over hidl to system processes, here, we introduce an llndk
function to convert the ANativeWindow owned by AImageReader into a
native_handle_t which may be transported over hwbinder.
We also introduce a platform only api to retrieve an HIDL
IGraphicBufferProducer from the handle received.
Bug: 110364143
Test: mm -j64
Test: AImageReaderWindowHandleTest
Change-Id: I5f2aec41d9c67c619413c02e48cd97933e3b2986
Signed-off-by: Jayant Chowdhary <jchowdhary@google.com>
diff --git a/media/libstagefright/bqhelper/Android.bp b/media/libstagefright/bqhelper/Android.bp
index 4f46be7..c647f5f 100644
--- a/media/libstagefright/bqhelper/Android.bp
+++ b/media/libstagefright/bqhelper/Android.bp
@@ -4,7 +4,7 @@
vndk: {
enabled: true,
},
-
+ double_loadable: true,
srcs: [
"Conversion.cpp",
"FrameDropper.cpp",
diff --git a/media/ndk/Android.bp b/media/ndk/Android.bp
index 05c8582..fc58583 100644
--- a/media/ndk/Android.bp
+++ b/media/ndk/Android.bp
@@ -57,7 +57,6 @@
cflags: [
"-fvisibility=hidden",
"-DEXPORT=__attribute__((visibility(\"default\")))",
-
"-Werror",
"-Wall",
],
@@ -67,6 +66,8 @@
],
shared_libs: [
+ "android.hardware.graphics.bufferqueue@1.0",
+ "android.hidl.token@1.0-utils",
"libbinder",
"libmedia",
"libmedia_omx",
@@ -75,12 +76,15 @@
"libmediaextractor",
"libstagefright",
"libstagefright_foundation",
+ "libstagefright_bufferqueue_helper",
"liblog",
"libutils",
"libcutils",
"libandroid",
"libandroid_runtime",
"libbinder",
+ "libhwbinder",
+ "libhidlbase",
"libgui",
"libui",
"libmedia2_jni_core",
@@ -99,7 +103,9 @@
llndk_library {
name: "libmediandk",
symbol_file: "libmediandk.map.txt",
- export_include_dirs: ["include"],
+ export_include_dirs: [
+ "include",
+ ],
}
cc_library {
@@ -143,3 +149,24 @@
},
},
}
+
+cc_test {
+ name: "AImageReaderWindowHandleTest",
+ srcs: ["tests/AImageReaderWindowHandleTest.cpp"],
+ shared_libs: [
+ "libbinder",
+ "libmediandk",
+ "libnativewindow",
+ "libgui",
+ "libutils",
+ "libui",
+ "libcutils",
+ "android.hardware.graphics.bufferqueue@1.0",
+ ],
+ cflags: [
+ "-D__ANDROID_VNDK__",
+ ],
+ include_dirs: [
+ "frameworks/av/media/ndk/",
+ ],
+}
diff --git a/media/ndk/NdkImageReader.cpp b/media/ndk/NdkImageReader.cpp
index be635ff..47b0780 100644
--- a/media/ndk/NdkImageReader.cpp
+++ b/media/ndk/NdkImageReader.cpp
@@ -28,6 +28,7 @@
#include <android_runtime/android_view_Surface.h>
#include <android_runtime/android_hardware_HardwareBuffer.h>
#include <grallocusage/GrallocUsageConversion.h>
+#include <media/stagefright/bqhelper/WGraphicBufferProducer.h>
using namespace android;
@@ -43,6 +44,10 @@
const char* AImageReader::kContextKey = "Context";
const char* AImageReader::kGraphicBufferKey = "GraphicBuffer";
+static constexpr int kWindowHalTokenSizeMax = 256;
+
+static native_handle_t *convertHalTokenToNativeHandle(const HalToken &halToken);
+
bool
AImageReader::isSupportedFormatAndUsage(int32_t format, uint64_t usage) {
// Check whether usage has either CPU_READ_OFTEN or CPU_READ set. Note that check against
@@ -363,6 +368,15 @@
mBufferItemConsumer->abandon();
mBufferItemConsumer->setFrameAvailableListener(nullptr);
}
+
+ if (mWindowHandle != nullptr) {
+ int size = mWindowHandle->data[0];
+ hidl_vec<uint8_t> halToken;
+ halToken.setToExternal(
+ reinterpret_cast<uint8_t *>(&mWindowHandle->data[1]), size);
+ deleteHalToken(halToken);
+ native_handle_delete(mWindowHandle);
+ }
}
media_status_t
@@ -522,6 +536,25 @@
}
}
+media_status_t AImageReader::getWindowNativeHandle(native_handle **handle) {
+ if (mWindowHandle != nullptr) {
+ *handle = mWindowHandle;
+ return AMEDIA_OK;
+ }
+ sp<HGraphicBufferProducer> hgbp =
+ new TWGraphicBufferProducer<HGraphicBufferProducer>(mProducer);
+ HalToken halToken;
+ if (!createHalToken(hgbp, &halToken)) {
+ return AMEDIA_ERROR_UNKNOWN;
+ }
+ mWindowHandle = convertHalTokenToNativeHandle(halToken);
+ if (!mWindowHandle) {
+ return AMEDIA_ERROR_UNKNOWN;
+ }
+ *handle = mWindowHandle;
+ return AMEDIA_OK;
+}
+
int
AImageReader::getBufferWidth(BufferItem* buffer) {
if (buffer == NULL) return -1;
@@ -585,6 +618,58 @@
}
}
+static native_handle_t *convertHalTokenToNativeHandle(
+ const HalToken &halToken) {
+ // We attempt to store halToken in the ints of the native_handle_t after its
+ // size. The first int stores the size of the token. We store this in an int
+ // to avoid alignment issues where size_t and int do not have the same
+ // alignment.
+ size_t nhDataByteSize = halToken.size();
+ if (nhDataByteSize > kWindowHalTokenSizeMax) {
+ // The size of the token isn't reasonable..
+ return nullptr;
+ }
+ size_t numInts = ceil(nhDataByteSize / sizeof(int)) + 1;
+
+ // We don't check for overflow, whether numInts can fit in an int, since we
+ // expect kWindowHalTokenSizeMax to be a reasonable limit.
+ // create a native_handle_t with 0 numFds and numInts number of ints.
+ native_handle_t *nh =
+ native_handle_create(0, numInts);
+ if (!nh) {
+ return nullptr;
+ }
+ // Store the size of the token in the first int.
+ nh->data[0] = nhDataByteSize;
+ memcpy(&(nh->data[1]), halToken.data(), nhDataByteSize);
+ return nh;
+}
+
+static sp<HGraphicBufferProducer> convertNativeHandleToHGBP (
+ const native_handle_t *handle) {
+ // Read the size of the halToken vec<uint8_t>
+ hidl_vec<uint8_t> halToken;
+ halToken.setToExternal(
+ reinterpret_cast<uint8_t *>(const_cast<int *>(&(handle->data[1]))),
+ handle->data[0]);
+ sp<HGraphicBufferProducer> hgbp =
+ HGraphicBufferProducer::castFrom(retrieveHalInterface(halToken));
+ return hgbp;
+}
+
+EXPORT
+sp<HGraphicBufferProducer> AImageReader_getHGBPFromHandle(
+ const native_handle_t *handle) {
+ if (handle == nullptr) {
+ return nullptr;
+ }
+ if (handle->numFds != 0 ||
+ handle->numInts < ceil(sizeof(size_t) / sizeof(int))) {
+ return nullptr;
+ }
+ return convertNativeHandleToHGBP(handle);
+}
+
EXPORT
media_status_t AImageReader_new(
int32_t width, int32_t height, int32_t format, int32_t maxImages,
@@ -594,6 +679,19 @@
width, height, format, AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN, maxImages, reader);
}
+extern "C" {
+
+EXPORT
+media_status_t AImageReader_getWindowNativeHandle(
+ AImageReader *reader, /*out*/native_handle_t **handle) {
+ if (reader == nullptr || handle == nullptr) {
+ return AMEDIA_ERROR_INVALID_PARAMETER;
+ }
+ return reader->getWindowNativeHandle(handle);
+}
+
+} //extern "C"
+
EXPORT
media_status_t AImageReader_newWithUsage(
int32_t width, int32_t height, int32_t format, uint64_t usage,
diff --git a/media/ndk/NdkImageReaderPriv.h b/media/ndk/NdkImageReaderPriv.h
index bed8a21..a9b54a8 100644
--- a/media/ndk/NdkImageReaderPriv.h
+++ b/media/ndk/NdkImageReaderPriv.h
@@ -69,6 +69,8 @@
media_status_t acquireNextImage(/*out*/AImage** image, /*out*/int* fenceFd);
media_status_t acquireLatestImage(/*out*/AImage** image, /*out*/int* fenceFd);
+ media_status_t getWindowNativeHandle(/*out*/native_handle_t **handle);
+
ANativeWindow* getWindow() const { return mWindow.get(); };
int32_t getWidth() const { return mWidth; };
int32_t getHeight() const { return mHeight; };
@@ -160,10 +162,17 @@
sp<Surface> mSurface;
sp<BufferItemConsumer> mBufferItemConsumer;
sp<ANativeWindow> mWindow;
+ native_handle_t* mWindowHandle = nullptr;
List<AImage*> mAcquiredImages;
Mutex mLock;
};
+// Retrieves HGraphicBufferProducer corresponding to the native_handle_t
+// provided. This method also deletes the HalToken corresponding to the
+// native_handle_t. Thus, if it is used twice in succession, the second call
+// returns nullptr;
+sp<HGraphicBufferProducer> AImageReader_getHGBPFromHandle(const native_handle_t *handle);
+
#endif // _NDK_IMAGE_READER_PRIV_H
diff --git a/media/ndk/include/media/NdkImageReader.h b/media/ndk/include/media/NdkImageReader.h
index 68de176..e5d863c 100644
--- a/media/ndk/include/media/NdkImageReader.h
+++ b/media/ndk/include/media/NdkImageReader.h
@@ -37,6 +37,9 @@
#define _NDK_IMAGE_READER_H
#include <sys/cdefs.h>
+#ifdef __ANDROID_VNDK__
+#include <cutils/native_handle.h>
+#endif
#include <android/native_window.h>
#include "NdkMediaError.h"
@@ -461,6 +464,23 @@
media_status_t AImageReader_setBufferRemovedListener(
AImageReader* reader, AImageReader_BufferRemovedListener* listener) __INTRODUCED_IN(26);
+#ifdef __ANDROID_VNDK__
+/*
+ * Get the native_handle_t corresponding to the ANativeWindow owned by the
+ * AImageReader provided.
+ *
+ * @param reader The image reader of interest.
+ * @param handle The output native_handle_t. This native handle is owned by
+ * this image reader.
+ *
+ * @return AMEDIA_OK if the method call succeeds.
+ * AMEDIA_ERROR_INVALID_PARAMETER if reader or handle are NULL.
+ * AMEDIA_ERROR_UNKNOWN if some other error is encountered.
+ */
+media_status_t AImageReader_getWindowNativeHandle(
+ AImageReader *reader, /* out */native_handle_t **handle);
+#endif
+
#endif /* __ANDROID_API__ >= 26 */
__END_DECLS
diff --git a/media/ndk/libmediandk.map.txt b/media/ndk/libmediandk.map.txt
index 224329a..bf4802d 100644
--- a/media/ndk/libmediandk.map.txt
+++ b/media/ndk/libmediandk.map.txt
@@ -4,6 +4,7 @@
AImageReader_acquireLatestImageAsync; # introduced=26
AImageReader_acquireNextImage; # introduced=24
AImageReader_acquireNextImageAsync; # introduced=26
+ AImageReader_getWindowNativeHandle; #vndk
AImageReader_delete; # introduced=24
AImageReader_getFormat; # introduced=24
AImageReader_getHeight; # introduced=24
diff --git a/media/ndk/tests/AImageReaderWindowHandleTest.cpp b/media/ndk/tests/AImageReaderWindowHandleTest.cpp
new file mode 100644
index 0000000..3b5e358
--- /dev/null
+++ b/media/ndk/tests/AImageReaderWindowHandleTest.cpp
@@ -0,0 +1,182 @@
+/*
+ * Copyright 2018 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.
+ */
+
+#include <gtest/gtest.h>
+#include <media/NdkImageReader.h>
+#include <media/NdkImage.h>
+#include <gui/IGraphicBufferProducer.h>
+#include <gui/bufferqueue/1.0/H2BGraphicBufferProducer.h>
+#include <NdkImageReaderPriv.h>
+#include <vndk/hardware_buffer.h>
+#include <memory>
+
+namespace android {
+
+using hardware::graphics::bufferqueue::V1_0::utils::H2BGraphicBufferProducer;
+typedef IGraphicBufferProducer::QueueBufferInput QueueBufferInput;
+typedef IGraphicBufferProducer::QueueBufferOutput QueueBufferOutput;
+
+static constexpr uint64_t kImageBufferUsage =
+ AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
+static constexpr int kImageWidth = 640;
+static constexpr int kImageHeight = 480;
+static constexpr int kImageFormat = AIMAGE_FORMAT_RGBA_8888;
+static constexpr int kMaxImages = 1;
+
+static constexpr int64_t kQueueBufferInputTimeStamp = 1384888611;
+static constexpr bool kQueueBufferInputIsAutoTimeStamp = false;
+static constexpr android_dataspace kQueueBufferInputDataspace = HAL_DATASPACE_UNKNOWN;
+static const Rect kQueueBufferInputRect = Rect(kImageWidth, kImageHeight);
+static constexpr int kQueueBufferInputScalingMode = 0;
+static constexpr int kQueueBufferInputTransform = 0;
+static const sp<Fence> kQueueBufferInputFence = Fence::NO_FENCE;
+
+static constexpr int kOnImageAvailableWaitUs = 100 * 1000;
+
+class AImageReaderWindowHandleTest : public ::testing::Test {
+ public:
+ void SetUp() override {
+ AImageReader_newWithUsage(kImageWidth, kImageHeight, kImageFormat,
+ kImageBufferUsage , kMaxImages, &imageReader_);
+ media_status_t ret = AMEDIA_ERROR_UNKNOWN;
+ ASSERT_NE(imageReader_, nullptr);
+ ret = AImageReader_setImageListener(imageReader_,
+ &imageReaderAvailableCb_);
+ ASSERT_EQ(ret, AMEDIA_OK);
+ ret = AImageReader_setBufferRemovedListener(imageReader_,
+ &imageReaderDetachedCb_);
+ ASSERT_EQ(ret, AMEDIA_OK);
+ }
+ void TearDown() override {
+ if (imageReader_) {
+ AImageReader_delete(imageReader_);
+ }
+ }
+
+ void HandleImageAvailable() {
+ AImage *outImage = nullptr;
+ media_status_t ret = AMEDIA_OK;
+ auto imageDeleter = [](AImage *img) { AImage_delete(img); };
+ std::unique_ptr<AImage, decltype(imageDeleter)> img(nullptr, imageDeleter);
+
+ // Test that the image can be acquired.
+ ret = AImageReader_acquireNextImage(imageReader_, &outImage);
+ ASSERT_EQ(ret, AMEDIA_OK);
+ img.reset(outImage);
+ ASSERT_NE(img, nullptr);
+
+ // Test that we can get a handle to the image's hardware buffer and a
+ // native handle to it.
+ AHardwareBuffer *hardwareBuffer = nullptr;
+ ret = AImage_getHardwareBuffer(img.get(), &hardwareBuffer);
+ ASSERT_EQ(ret, AMEDIA_OK);
+ ASSERT_NE(hardwareBuffer, nullptr);
+ const native_handle_t *nh = AHardwareBuffer_getNativeHandle(hardwareBuffer);
+ ASSERT_NE(nh, nullptr);
+ std::unique_lock<std::mutex> lock(imageAvailableMutex_);
+ imageAvailable_ = true;
+ imageCondVar_.notify_one();
+ }
+
+ static void onImageAvailable(void *context, AImageReader *reader) {
+ (void)reader;
+ AImageReaderWindowHandleTest *thisContext =
+ reinterpret_cast<AImageReaderWindowHandleTest *>(context);
+ thisContext->HandleImageAvailable();
+ }
+
+ static void onBufferRemoved(void *, AImageReader *, AHardwareBuffer *) {
+ }
+
+ AImageReader *imageReader_ = nullptr;
+ AImageReader_ImageListener imageReaderAvailableCb_{this, onImageAvailable};
+ AImageReader_BufferRemovedListener imageReaderDetachedCb_{this, onBufferRemoved};
+ std::mutex imageAvailableMutex_;
+ std::condition_variable imageCondVar_;
+ bool imageAvailable_ = false;
+};
+
+static void fillRGBA8Buffer(uint8_t* buf, int w, int h, int stride) {
+ const size_t PIXEL_SIZE = 4;
+ for (int x = 0; x < w; x++) {
+ for (int y = 0; y < h; y++) {
+ off_t offset = (y * stride + x) * PIXEL_SIZE;
+ for (int c = 0; c < 4; c++) {
+ int parityX = (x / (1 << (c+2))) & 1;
+ int parityY = (y / (1 << (c+2))) & 1;
+ buf[offset + c] = (parityX ^ parityY) ? 231 : 35;
+ }
+ }
+ }
+}
+
+TEST_F(AImageReaderWindowHandleTest, CreateWindowNativeHandle) {
+ // Check that we can create a native_handle_t corresponding to the
+ // AImageReader.
+ native_handle_t *nh = nullptr;
+ AImageReader_getWindowNativeHandle(imageReader_, &nh);
+ ASSERT_NE(nh, nullptr);
+
+ // Check that there are only ints in the handle.
+ ASSERT_EQ(nh->numFds, 0);
+ ASSERT_NE(nh->numInts, 0);
+
+ // Check that the HGBP can be retrieved from the handle.
+ sp<HGraphicBufferProducer> hgbp = AImageReader_getHGBPFromHandle(nh);
+ ASSERT_NE(hgbp, nullptr);
+ sp<IGraphicBufferProducer> igbp = new H2BGraphicBufferProducer(hgbp);
+ int dequeuedSlot = -1;
+ sp<Fence> dequeuedFence;
+ IGraphicBufferProducer::QueueBufferOutput output;
+ ASSERT_EQ(OK, igbp->connect(nullptr, NATIVE_WINDOW_API_CPU, false, &output));
+
+ // Test that we can dequeue a buffer.
+ ASSERT_EQ(OK,
+ ~IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION &
+ (igbp->dequeueBuffer(&dequeuedSlot, &dequeuedFence,
+ kImageWidth, kImageHeight,
+ kImageFormat, kImageBufferUsage,
+ nullptr, nullptr)));
+ EXPECT_LE(0, dequeuedSlot);
+ EXPECT_GT(BufferQueue::NUM_BUFFER_SLOTS, dequeuedSlot);
+
+ sp<GraphicBuffer> dequeuedBuffer;
+ igbp->requestBuffer(dequeuedSlot, &dequeuedBuffer);
+ uint8_t* img = nullptr;
+ ASSERT_EQ(NO_ERROR, dequeuedBuffer->lock(kImageBufferUsage, (void**)(&img)));
+
+ // Write in some dummy image data.
+ fillRGBA8Buffer(img, dequeuedBuffer->getWidth(), dequeuedBuffer->getHeight(),
+ dequeuedBuffer->getStride());
+ ASSERT_EQ(NO_ERROR, dequeuedBuffer->unlock());
+ QueueBufferInput queueBufferInput(kQueueBufferInputTimeStamp,
+ kQueueBufferInputIsAutoTimeStamp,
+ kQueueBufferInputDataspace,
+ kQueueBufferInputRect,
+ kQueueBufferInputScalingMode,
+ kQueueBufferInputTransform,
+ kQueueBufferInputFence);
+ QueueBufferOutput queueBufferOutput;
+ ASSERT_EQ(OK, igbp->queueBuffer(dequeuedSlot, queueBufferInput,
+ &queueBufferOutput));
+ // wait until the onImageAvailable callback is called, or timeout completes.
+ std::unique_lock<std::mutex> lock(imageAvailableMutex_);
+ imageCondVar_.wait_for(lock, std::chrono::microseconds(kOnImageAvailableWaitUs),
+ [this]{ return this->imageAvailable_;});
+ EXPECT_TRUE(imageAvailable_) << "Timed out waiting for image data to be handled!\n";
+}
+
+} // namespace android