blob: 7b19ac01f2274a93bb5dbb51eb5cc01e4840cafa [file] [log] [blame]
/*
* Copyright (C) 2016 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 <inttypes.h>
//#define LOG_NDEBUG 0
#define LOG_TAG "NdkImageReader"
#include "NdkImagePriv.h"
#include "NdkImageReaderPriv.h"
#include <cutils/atomic.h>
#include <utils/Log.h>
#include <android_media_Utils.h>
#include <ui/PublicFormat.h>
#include <private/android/AHardwareBufferHelpers.h>
#include <grallocusage/GrallocUsageConversion.h>
#include <gui/bufferqueue/1.0/WGraphicBufferProducer.h>
using namespace android;
namespace {
// Get an ID that's unique within this process.
static int32_t createProcessUniqueId() {
static volatile int32_t globalCounter = 0;
return android_atomic_inc(&globalCounter);
}
}
const char* AImageReader::kCallbackFpKey = "Callback";
const char* AImageReader::kContextKey = "Context";
const char* AImageReader::kGraphicBufferKey = "GraphicBuffer";
static constexpr int kWindowHalTokenSizeMax = 256;
static media_status_t validateParameters(int32_t width, int32_t height, int32_t format,
uint64_t usage, int32_t maxImages,
/*out*/ AImageReader**& reader);
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
// AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN (0x6) is sufficient as it implies
// AHARDWAREBUFFER_USAGE_CPU_READ (0x2).
bool hasCpuUsage = usage & AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN;
switch (format) {
case AIMAGE_FORMAT_RGBA_8888:
case AIMAGE_FORMAT_RGBX_8888:
case AIMAGE_FORMAT_RGB_888:
case AIMAGE_FORMAT_RGB_565:
case AIMAGE_FORMAT_RGBA_FP16:
case AIMAGE_FORMAT_YUV_420_888:
case AIMAGE_FORMAT_JPEG:
case AIMAGE_FORMAT_RAW16:
case AIMAGE_FORMAT_RAW_DEPTH:
case AIMAGE_FORMAT_RAW_PRIVATE:
case AIMAGE_FORMAT_RAW10:
case AIMAGE_FORMAT_RAW12:
case AIMAGE_FORMAT_DEPTH16:
case AIMAGE_FORMAT_DEPTH_POINT_CLOUD:
case AIMAGE_FORMAT_Y8:
case AIMAGE_FORMAT_HEIC:
case AIMAGE_FORMAT_DEPTH_JPEG:
case AIMAGE_FORMAT_RAW_DEPTH10:
case HAL_PIXEL_FORMAT_YCBCR_P010:
return true;
case AIMAGE_FORMAT_PRIVATE:
// For private format, cpu usage is prohibited.
return !hasCpuUsage;
default:
return false;
}
}
int
AImageReader::getNumPlanesForFormat(int32_t format) {
switch (format) {
case AIMAGE_FORMAT_YUV_420_888:
case HAL_PIXEL_FORMAT_YCBCR_P010:
return 3;
case AIMAGE_FORMAT_RGBA_8888:
case AIMAGE_FORMAT_RGBX_8888:
case AIMAGE_FORMAT_RGB_888:
case AIMAGE_FORMAT_RGB_565:
case AIMAGE_FORMAT_RGBA_FP16:
case AIMAGE_FORMAT_JPEG:
case AIMAGE_FORMAT_RAW16:
case AIMAGE_FORMAT_RAW_DEPTH:
case AIMAGE_FORMAT_RAW_PRIVATE:
case AIMAGE_FORMAT_RAW10:
case AIMAGE_FORMAT_RAW12:
case AIMAGE_FORMAT_DEPTH16:
case AIMAGE_FORMAT_DEPTH_POINT_CLOUD:
case AIMAGE_FORMAT_Y8:
case AIMAGE_FORMAT_HEIC:
case AIMAGE_FORMAT_DEPTH_JPEG:
case AIMAGE_FORMAT_RAW_DEPTH10:
return 1;
case AIMAGE_FORMAT_PRIVATE:
return 0;
default:
return -1;
}
}
void
AImageReader::FrameListener::onFrameAvailable(const BufferItem& /*item*/) {
sp<AImageReader> reader = mReader.promote();
if (reader == nullptr) {
ALOGW("A frame is available after AImageReader closed!");
return; // reader has been closed
}
Mutex::Autolock _l(mLock);
if (mListener.onImageAvailable == nullptr) {
return; // No callback registered
}
sp<AMessage> msg = new AMessage(AImageReader::kWhatImageAvailable, reader->mHandler);
msg->setPointer(AImageReader::kCallbackFpKey, (void *) mListener.onImageAvailable);
msg->setPointer(AImageReader::kContextKey, mListener.context);
msg->post();
}
media_status_t
AImageReader::FrameListener::setImageListener(AImageReader_ImageListener* listener) {
Mutex::Autolock _l(mLock);
if (listener == nullptr) {
mListener.context = nullptr;
mListener.onImageAvailable = nullptr;
} else {
mListener = *listener;
}
return AMEDIA_OK;
}
void
AImageReader::BufferRemovedListener::onBufferFreed(const wp<GraphicBuffer>& graphicBuffer) {
sp<AImageReader> reader = mReader.promote();
if (reader == nullptr) {
ALOGW("A frame is available after AImageReader closed!");
return; // reader has been closed
}
Mutex::Autolock _l(mLock);
if (mListener.onBufferRemoved == nullptr) {
return; // No callback registered
}
sp<GraphicBuffer> gBuffer = graphicBuffer.promote();
if (gBuffer == nullptr) {
ALOGW("A buffer being freed has gone away!");
return; // buffer is already destroyed
}
sp<AMessage> msg = new AMessage(AImageReader::kWhatBufferRemoved, reader->mHandler);
msg->setPointer(
AImageReader::kCallbackFpKey, (void*) mListener.onBufferRemoved);
msg->setPointer(AImageReader::kContextKey, mListener.context);
msg->setObject(AImageReader::kGraphicBufferKey, gBuffer);
msg->post();
}
media_status_t
AImageReader::BufferRemovedListener::setBufferRemovedListener(
AImageReader_BufferRemovedListener* listener) {
Mutex::Autolock _l(mLock);
if (listener == nullptr) {
mListener.context = nullptr;
mListener.onBufferRemoved = nullptr;
} else {
mListener = *listener;
}
return AMEDIA_OK;
}
media_status_t
AImageReader::setImageListenerLocked(AImageReader_ImageListener* listener) {
return mFrameListener->setImageListener(listener);
}
media_status_t
AImageReader::setImageListener(AImageReader_ImageListener* listener) {
Mutex::Autolock _l(mLock);
return setImageListenerLocked(listener);
}
media_status_t
AImageReader::setBufferRemovedListenerLocked(AImageReader_BufferRemovedListener* listener) {
return mBufferRemovedListener->setBufferRemovedListener(listener);
}
media_status_t
AImageReader::setBufferRemovedListener(AImageReader_BufferRemovedListener* listener) {
Mutex::Autolock _l(mLock);
return setBufferRemovedListenerLocked(listener);
}
void AImageReader::CallbackHandler::onMessageReceived(
const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatBufferRemoved:
{
AImageReader_BufferRemovedCallback onBufferRemoved;
void* context;
bool found = msg->findPointer(kCallbackFpKey, (void**) &onBufferRemoved);
if (!found || onBufferRemoved == nullptr) {
ALOGE("%s: Cannot find onBufferRemoved callback fp!", __FUNCTION__);
return;
}
found = msg->findPointer(kContextKey, &context);
if (!found) {
ALOGE("%s: Cannot find callback context!", __FUNCTION__);
return;
}
sp<RefBase> bufferToFree;
found = msg->findObject(kGraphicBufferKey, &bufferToFree);
if (!found || bufferToFree == nullptr) {
ALOGE("%s: Cannot find the buffer to free!", __FUNCTION__);
return;
}
// TODO(jwcai) Someone from Android graphics team stating this should just be a
// static_cast.
AHardwareBuffer* outBuffer = reinterpret_cast<AHardwareBuffer*>(bufferToFree.get());
// At this point, bufferToFree holds the last reference to the GraphicBuffer owned by
// this AImageReader, and the reference will be gone once this function returns.
(*onBufferRemoved)(context, mReader, outBuffer);
break;
}
case kWhatImageAvailable:
{
AImageReader_ImageCallback onImageAvailable;
void* context;
bool found = msg->findPointer(kCallbackFpKey, (void**) &onImageAvailable);
if (!found || onImageAvailable == nullptr) {
ALOGE("%s: Cannot find onImageAvailable callback fp!", __FUNCTION__);
return;
}
found = msg->findPointer(kContextKey, &context);
if (!found) {
ALOGE("%s: Cannot find callback context!", __FUNCTION__);
return;
}
(*onImageAvailable)(context, mReader);
break;
}
default:
ALOGE("%s: unknown message type %d", __FUNCTION__, msg->what());
break;
}
}
AImageReader::AImageReader(int32_t width,
int32_t height,
int32_t format,
uint64_t usage,
int32_t maxImages,
uint32_t hardwareBufferFormat,
android_dataspace dataSpace)
: mWidth(width),
mHeight(height),
mFormat(format),
mUsage(usage),
mMaxImages(maxImages),
mNumPlanes(getNumPlanesForFormat(format)),
mHalFormat(hardwareBufferFormat),
mHalDataSpace(dataSpace),
mFrameListener(new FrameListener(this)),
mBufferRemovedListener(new BufferRemovedListener(this)) {}
AImageReader::~AImageReader() {
Mutex::Autolock _l(mLock);
LOG_FATAL_IF(mIsOpen, "AImageReader not closed before destruction");
}
media_status_t
AImageReader::init() {
mHalUsage = AHardwareBuffer_convertToGrallocUsageBits(mUsage);
sp<IGraphicBufferProducer> gbProducer;
sp<IGraphicBufferConsumer> gbConsumer;
BufferQueue::createBufferQueue(&gbProducer, &gbConsumer);
String8 consumerName = String8::format("ImageReader-%dx%df%xu%" PRIu64 "m%d-%d-%d",
mWidth, mHeight, mFormat, mUsage, mMaxImages, getpid(),
createProcessUniqueId());
mBufferItemConsumer =
new BufferItemConsumer(gbConsumer, mHalUsage, mMaxImages, /*controlledByApp*/ true);
if (mBufferItemConsumer == nullptr) {
ALOGE("Failed to allocate BufferItemConsumer");
return AMEDIA_ERROR_UNKNOWN;
}
mProducer = gbProducer;
mBufferItemConsumer->setName(consumerName);
mBufferItemConsumer->setFrameAvailableListener(mFrameListener);
mBufferItemConsumer->setBufferFreedListener(mBufferRemovedListener);
status_t res;
res = mBufferItemConsumer->setDefaultBufferSize(mWidth, mHeight);
if (res != OK) {
ALOGE("Failed to set BufferItemConsumer buffer size");
return AMEDIA_ERROR_UNKNOWN;
}
res = mBufferItemConsumer->setDefaultBufferFormat(mHalFormat);
if (res != OK) {
ALOGE("Failed to set BufferItemConsumer buffer format");
return AMEDIA_ERROR_UNKNOWN;
}
res = mBufferItemConsumer->setDefaultBufferDataSpace(mHalDataSpace);
if (res != OK) {
ALOGE("Failed to set BufferItemConsumer buffer dataSpace");
return AMEDIA_ERROR_UNKNOWN;
}
if (mUsage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT) {
gbConsumer->setConsumerIsProtected(true);
}
mSurface = new Surface(mProducer, /*controlledByApp*/true);
if (mSurface == nullptr) {
ALOGE("Failed to create surface");
return AMEDIA_ERROR_UNKNOWN;
}
mWindow = static_cast<ANativeWindow*>(mSurface.get());
for (int i = 0; i < mMaxImages; i++) {
BufferItem* buffer = new BufferItem;
mBuffers.push_back(buffer);
}
mCbLooper = new ALooper;
mCbLooper->setName(consumerName.c_str());
res = mCbLooper->start(
/*runOnCallingThread*/false,
/*canCallJava*/ true,
PRIORITY_DEFAULT);
if (res != OK) {
ALOGE("Failed to start the looper");
return AMEDIA_ERROR_UNKNOWN;
}
mHandler = new CallbackHandler(this);
mCbLooper->registerHandler(mHandler);
mIsOpen = true;
return AMEDIA_OK;
}
void AImageReader::close() {
Mutex::Autolock _l(mLock);
if (!mIsOpen) {
return;
}
mIsOpen = false;
AImageReader_ImageListener nullListener = {nullptr, nullptr};
setImageListenerLocked(&nullListener);
AImageReader_BufferRemovedListener nullBufferRemovedListener = {nullptr, nullptr};
setBufferRemovedListenerLocked(&nullBufferRemovedListener);
if (mCbLooper != nullptr) {
mCbLooper->unregisterHandler(mHandler->id());
mCbLooper->stop();
}
mCbLooper.clear();
mHandler.clear();
// Close all previously acquired images
for (auto it = mAcquiredImages.begin();
it != mAcquiredImages.end(); it++) {
AImage* image = *it;
Mutex::Autolock _l(image->mLock);
// Do not alter mAcquiredImages while we are iterating on it
releaseImageLocked(image, /*releaseFenceFd*/-1, /*clearCache*/false);
}
mAcquiredImages.clear();
// Delete Buffer Items
for (auto it = mBuffers.begin();
it != mBuffers.end(); it++) {
delete *it;
}
if (mBufferItemConsumer != nullptr) {
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
AImageReader::acquireImageLocked(/*out*/AImage** image, /*out*/int* acquireFenceFd) {
*image = nullptr;
BufferItem* buffer = getBufferItemLocked();
if (buffer == nullptr) {
ALOGW("Unable to acquire a lockedBuffer, very likely client tries to lock more than"
" maxImages buffers");
return AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED;
}
// When the output paramter fence is not NULL, we are acquiring the image asynchronously.
bool waitForFence = acquireFenceFd == nullptr;
status_t res = mBufferItemConsumer->acquireBuffer(buffer, 0, waitForFence);
if (res != NO_ERROR) {
returnBufferItemLocked(buffer);
if (res != BufferQueue::NO_BUFFER_AVAILABLE) {
if (res == INVALID_OPERATION) {
return AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED;
} else {
ALOGE("%s: Acquire image failed with some unknown error: %s (%d)",
__FUNCTION__, strerror(-res), res);
return AMEDIA_ERROR_UNKNOWN;
}
}
return AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE;
}
const int bufferWidth = getBufferWidth(buffer);
const int bufferHeight = getBufferHeight(buffer);
const int bufferFmt = buffer->mGraphicBuffer->getPixelFormat();
const int bufferUsage = buffer->mGraphicBuffer->getUsage();
const int readerWidth = mWidth;
const int readerHeight = mHeight;
const int readerFmt = mHalFormat;
const int readerUsage = mHalUsage;
// Check if the producer buffer configurations match what AImageReader configured. Add some
// extra checks for non-opaque formats.
if (!isFormatOpaque(readerFmt)) {
// Check if the left-top corner of the crop rect is origin, we currently assume this point
// is zero, will revisit this once this assumption turns out problematic.
Point lt = buffer->mCrop.leftTop();
if (lt.x != 0 || lt.y != 0) {
ALOGE("Crop left top corner [%d, %d] not at origin", lt.x, lt.y);
return AMEDIA_ERROR_UNKNOWN;
}
// Check if the producer buffer configurations match what ImageReader configured.
ALOGV_IF(readerWidth != bufferWidth || readerHeight != bufferHeight,
"%s: Buffer size: %dx%d, doesn't match AImageReader configured size: %dx%d",
__FUNCTION__, bufferWidth, bufferHeight, readerWidth, readerHeight);
// Check if the buffer usage is a super set of reader's usage bits, aka all usage bits that
// ImageReader requested has been supported from the producer side.
ALOGD_IF((readerUsage | bufferUsage) != bufferUsage,
"%s: Producer buffer usage: %x, doesn't cover all usage bits AImageReader "
"configured: %x",
__FUNCTION__, bufferUsage, readerUsage);
if (readerFmt != bufferFmt) {
if (readerFmt == HAL_PIXEL_FORMAT_YCbCr_420_888 && isPossiblyYUV(bufferFmt)) {
// Special casing for when producer switches to a format compatible with flexible
// YUV.
mHalFormat = bufferFmt;
ALOGD("%s: Overriding buffer format YUV_420_888 to 0x%x.", __FUNCTION__, bufferFmt);
} else {
// Return the buffer to the queue. No need to provide fence, as this buffer wasn't
// used anywhere yet.
mBufferItemConsumer->releaseBuffer(*buffer);
returnBufferItemLocked(buffer);
ALOGE("%s: Output buffer format: 0x%x, ImageReader configured format: 0x%x",
__FUNCTION__, bufferFmt, readerFmt);
return AMEDIA_ERROR_UNKNOWN;
}
}
}
if (mHalFormat == HAL_PIXEL_FORMAT_BLOB) {
*image = new AImage(this, mFormat, mUsage, buffer, buffer->mTimestamp,
readerWidth, readerHeight, mNumPlanes);
} else {
*image = new AImage(this, mFormat, mUsage, buffer, buffer->mTimestamp,
bufferWidth, bufferHeight, mNumPlanes);
}
mAcquiredImages.push_back(*image);
// When the output paramter fence is not NULL, we are acquiring the image asynchronously.
if (acquireFenceFd != nullptr) {
*acquireFenceFd = buffer->mFence->dup();
}
return AMEDIA_OK;
}
BufferItem*
AImageReader::getBufferItemLocked() {
if (mBuffers.empty()) {
return nullptr;
}
// Return a BufferItem pointer and remove it from the list
auto it = mBuffers.begin();
BufferItem* buffer = *it;
mBuffers.erase(it);
return buffer;
}
void
AImageReader::returnBufferItemLocked(BufferItem* buffer) {
mBuffers.push_back(buffer);
}
void
AImageReader::releaseImageLocked(AImage* image, int releaseFenceFd, bool clearCache) {
BufferItem* buffer = image->mBuffer;
if (buffer == nullptr) {
// This should not happen, but is not fatal
ALOGW("AImage %p has no buffer!", image);
return;
}
int unlockFenceFd = -1;
media_status_t ret = image->unlockImageIfLocked(&unlockFenceFd);
if (ret < 0) {
ALOGW("%s: AImage %p is cannot be unlocked.", __FUNCTION__, image);
return;
}
sp<Fence> unlockFence = unlockFenceFd > 0 ? new Fence(unlockFenceFd) : Fence::NO_FENCE;
sp<Fence> releaseFence = releaseFenceFd > 0 ? new Fence(releaseFenceFd) : Fence::NO_FENCE;
sp<Fence> bufferFence = Fence::merge("AImageReader", unlockFence, releaseFence);
mBufferItemConsumer->releaseBuffer(*buffer, bufferFence);
returnBufferItemLocked(buffer);
image->mBuffer = nullptr;
image->mLockedBuffer = nullptr;
image->mIsClosed = true;
if (!clearCache) {
return;
}
bool found = false;
// cleanup acquired image list
for (auto it = mAcquiredImages.begin();
it != mAcquiredImages.end(); it++) {
AImage* readerCopy = *it;
if (readerCopy == image) {
found = true;
mAcquiredImages.erase(it);
break;
}
}
if (!found) {
ALOGE("Error: AImage %p is not generated by AImageReader %p",
image, this);
}
}
// The LL-NDK API is now deprecated. New devices will no longer have the token
// manager service installed, so createHalToken will return false and this
// will return AMEDIA_ERROR_UNKNOWN on those devices.
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;
if (!buffer->mCrop.isEmpty()) {
return buffer->mCrop.getWidth();
}
return buffer->mGraphicBuffer->getWidth();
}
int
AImageReader::getBufferHeight(BufferItem* buffer) {
if (buffer == NULL) return -1;
if (!buffer->mCrop.isEmpty()) {
return buffer->mCrop.getHeight();
}
return buffer->mGraphicBuffer->getHeight();
}
media_status_t
AImageReader::acquireNextImage(/*out*/AImage** image, /*out*/int* acquireFenceFd) {
Mutex::Autolock _l(mLock);
return acquireImageLocked(image, acquireFenceFd);
}
media_status_t
AImageReader::acquireLatestImage(/*out*/AImage** image, /*out*/int* acquireFenceFd) {
if (image == nullptr) {
return AMEDIA_ERROR_INVALID_PARAMETER;
}
Mutex::Autolock _l(mLock);
*image = nullptr;
AImage* prevImage = nullptr;
AImage* nextImage = nullptr;
media_status_t ret = acquireImageLocked(&prevImage, acquireFenceFd);
if (prevImage == nullptr) {
return ret;
}
for (;;) {
ret = acquireImageLocked(&nextImage, acquireFenceFd);
if (nextImage == nullptr) {
*image = prevImage;
return AMEDIA_OK;
}
if (acquireFenceFd == nullptr) {
// No need for release fence here since the prevImage is unused and acquireImageLocked
// has already waited for acquired fence to be signaled.
prevImage->close();
} else {
// Use the acquire fence as release fence, so that producer can wait before trying to
// refill the buffer.
prevImage->close(*acquireFenceFd);
}
prevImage->free();
prevImage = nextImage;
nextImage = nullptr;
}
}
static
media_status_t validateParameters(int32_t width, int32_t height, int32_t format,
uint64_t usage, int32_t maxImages,
/*out*/ AImageReader**& reader) {
if (reader == nullptr) {
ALOGE("%s: reader argument is null", __FUNCTION__);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
if (width < 1 || height < 1) {
ALOGE("%s: image dimension must be positive: w:%d h:%d",
__FUNCTION__, width, height);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
if (maxImages < 1) {
ALOGE("%s: max outstanding image count must be at least 1 (%d)",
__FUNCTION__, maxImages);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
if (maxImages > BufferQueueDefs::NUM_BUFFER_SLOTS) {
ALOGE("%s: max outstanding image count (%d) cannot be larget than %d.",
__FUNCTION__, maxImages, BufferQueueDefs::NUM_BUFFER_SLOTS);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
if (!AImageReader::isSupportedFormatAndUsage(format, usage)) {
ALOGE("%s: format %d is not supported with usage 0x%" PRIx64 " by AImageReader",
__FUNCTION__, format, usage);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
return AMEDIA_OK;
}
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;
}
EXPORT
media_status_t AImageReader_new(
int32_t width, int32_t height, int32_t format, int32_t maxImages,
/*out*/AImageReader** reader) {
ALOGV("%s", __FUNCTION__);
return AImageReader_newWithUsage(
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_newWithDataSpace(
int32_t width, int32_t height, uint64_t usage, int32_t maxImages,
uint32_t hardwareBufferFormat, int32_t dataSpace,
/*out*/ AImageReader** reader) {
ALOGV("%s", __FUNCTION__);
android_dataspace halDataSpace = static_cast<android_dataspace>(dataSpace);
int32_t format = static_cast<int32_t>(
mapHalFormatDataspaceToPublicFormat(hardwareBufferFormat, halDataSpace));
return AImageReader_newWithUsage(width, height, format, usage, maxImages, reader);
}
EXPORT
media_status_t AImageReader_newWithUsage(
int32_t width, int32_t height, int32_t format, uint64_t usage,
int32_t maxImages, /*out*/ AImageReader** reader) {
ALOGV("%s", __FUNCTION__);
validateParameters(width, height, format, usage, maxImages, reader);
PublicFormat publicFormat = static_cast<PublicFormat>(format);
uint32_t halFormat = mapPublicFormatToHalFormat(publicFormat);
android_dataspace halDataSpace = mapPublicFormatToHalDataspace(publicFormat);
AImageReader* tmpReader = new AImageReader(
width, height, format, usage, maxImages, halFormat, halDataSpace);
if (tmpReader == nullptr) {
ALOGE("%s: AImageReader allocation failed", __FUNCTION__);
return AMEDIA_ERROR_UNKNOWN;
}
media_status_t ret = tmpReader->init();
if (ret != AMEDIA_OK) {
ALOGE("%s: AImageReader initialization failed!", __FUNCTION__);
delete tmpReader;
return ret;
}
*reader = tmpReader;
(*reader)->incStrong((void*) AImageReader_new);
return AMEDIA_OK;
}
EXPORT
void AImageReader_delete(AImageReader* reader) {
ALOGV("%s", __FUNCTION__);
if (reader != nullptr) {
reader->close();
reader->decStrong((void*) AImageReader_delete);
}
return;
}
EXPORT
media_status_t AImageReader_getWindow(AImageReader* reader, /*out*/ANativeWindow** window) {
ALOGV("%s", __FUNCTION__);
if (reader == nullptr || window == nullptr) {
ALOGE("%s: invalid argument. reader %p, window %p",
__FUNCTION__, reader, window);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
*window = reader->getWindow();
return AMEDIA_OK;
}
EXPORT
media_status_t AImageReader_getWidth(const AImageReader* reader, /*out*/int32_t* width) {
ALOGV("%s", __FUNCTION__);
if (reader == nullptr || width == nullptr) {
ALOGE("%s: invalid argument. reader %p, width %p",
__FUNCTION__, reader, width);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
*width = reader->getWidth();
return AMEDIA_OK;
}
EXPORT
media_status_t AImageReader_getHeight(const AImageReader* reader, /*out*/int32_t* height) {
ALOGV("%s", __FUNCTION__);
if (reader == nullptr || height == nullptr) {
ALOGE("%s: invalid argument. reader %p, height %p",
__FUNCTION__, reader, height);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
*height = reader->getHeight();
return AMEDIA_OK;
}
EXPORT
media_status_t AImageReader_getFormat(const AImageReader* reader, /*out*/int32_t* format) {
ALOGV("%s", __FUNCTION__);
if (reader == nullptr || format == nullptr) {
ALOGE("%s: invalid argument. reader %p, format %p",
__FUNCTION__, reader, format);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
*format = reader->getFormat();
return AMEDIA_OK;
}
EXPORT
media_status_t AImageReader_getMaxImages(const AImageReader* reader, /*out*/int32_t* maxImages) {
ALOGV("%s", __FUNCTION__);
if (reader == nullptr || maxImages == nullptr) {
ALOGE("%s: invalid argument. reader %p, maxImages %p",
__FUNCTION__, reader, maxImages);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
*maxImages = reader->getMaxImages();
return AMEDIA_OK;
}
EXPORT
media_status_t AImageReader_acquireNextImage(AImageReader* reader, /*out*/AImage** image) {
ALOGV("%s", __FUNCTION__);
return AImageReader_acquireNextImageAsync(reader, image, nullptr);
}
EXPORT
media_status_t AImageReader_acquireLatestImage(AImageReader* reader, /*out*/AImage** image) {
ALOGV("%s", __FUNCTION__);
return AImageReader_acquireLatestImageAsync(reader, image, nullptr);
}
EXPORT
media_status_t AImageReader_acquireNextImageAsync(
AImageReader* reader, /*out*/AImage** image, /*out*/int* acquireFenceFd) {
ALOGV("%s", __FUNCTION__);
if (reader == nullptr || image == nullptr) {
ALOGE("%s: invalid argument. reader %p, image %p",
__FUNCTION__, reader, image);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
return reader->acquireNextImage(image, acquireFenceFd);
}
EXPORT
media_status_t AImageReader_acquireLatestImageAsync(
AImageReader* reader, /*out*/AImage** image, /*out*/int* acquireFenceFd) {
ALOGV("%s", __FUNCTION__);
if (reader == nullptr || image == nullptr) {
ALOGE("%s: invalid argument. reader %p, image %p",
__FUNCTION__, reader, image);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
return reader->acquireLatestImage(image, acquireFenceFd);
}
EXPORT
media_status_t AImageReader_setImageListener(
AImageReader* reader, AImageReader_ImageListener* listener) {
ALOGV("%s", __FUNCTION__);
if (reader == nullptr) {
ALOGE("%s: invalid argument! reader %p", __FUNCTION__, reader);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
reader->setImageListener(listener);
return AMEDIA_OK;
}
EXPORT
media_status_t AImageReader_setBufferRemovedListener(
AImageReader* reader, AImageReader_BufferRemovedListener* listener) {
ALOGV("%s", __FUNCTION__);
if (reader == nullptr) {
ALOGE("%s: invalid argument! reader %p", __FUNCTION__, reader);
return AMEDIA_ERROR_INVALID_PARAMETER;
}
reader->setBufferRemovedListener(listener);
return AMEDIA_OK;
}