实现Service和定时器
Matthew
2 years ago
parent
00433db12f
commit
9952fcbd8c
@ -1,20 +0,0 @@
|
|||||||
{
|
|
||||||
"version": 3,
|
|
||||||
"artifactType": {
|
|
||||||
"type": "APK",
|
|
||||||
"kind": "Directory"
|
|
||||||
},
|
|
||||||
"applicationId": "com.xinyingpower.microphoto",
|
|
||||||
"variantName": "release",
|
|
||||||
"elements": [
|
|
||||||
{
|
|
||||||
"type": "SINGLE",
|
|
||||||
"filters": [],
|
|
||||||
"attributes": [],
|
|
||||||
"versionCode": 1,
|
|
||||||
"versionName": "1.0",
|
|
||||||
"outputFile": "app-release.apk"
|
|
||||||
}
|
|
||||||
],
|
|
||||||
"elementType": "File"
|
|
||||||
}
|
|
||||||
@ -0,0 +1,196 @@
|
|||||||
|
#include "TerminalDevice.h"
|
||||||
|
/*
|
||||||
|
* 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.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define LOG_TAG "CameraTestHelpers"
|
||||||
|
|
||||||
|
#include "Camera.h"
|
||||||
|
|
||||||
|
#include <android/log.h>
|
||||||
|
|
||||||
|
#define ALOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
|
||||||
|
#define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
|
||||||
|
#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
|
||||||
|
|
||||||
|
CCamera::CCamera()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
CCamera::~CCamera()
|
||||||
|
{
|
||||||
|
closeCamera();
|
||||||
|
}
|
||||||
|
|
||||||
|
int CCamera::initCamera(ANativeWindow *imgReaderAnw) {
|
||||||
|
if (imgReaderAnw == nullptr) {
|
||||||
|
ALOGE("Cannot initialize camera before image reader get initialized.");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
mImgReaderAnw = imgReaderAnw;
|
||||||
|
mCameraManager = ACameraManager_create();
|
||||||
|
if (mCameraManager == nullptr) {
|
||||||
|
ALOGE("Failed to create ACameraManager.");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
int ret = ACameraManager_getCameraIdList(mCameraManager, &mCameraIdList);
|
||||||
|
if (ret != AMEDIA_OK) {
|
||||||
|
ALOGE("Failed to get cameraIdList: ret=%d", ret);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
if (mCameraIdList->numCameras < 1) {
|
||||||
|
ALOGW("Device has no NDK compatible camera.");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
ALOGI("Found %d camera(s).", mCameraIdList->numCameras);
|
||||||
|
|
||||||
|
// We always use the first camera.
|
||||||
|
mCameraId = mCameraIdList->cameraIds[0];
|
||||||
|
if (mCameraId == nullptr) {
|
||||||
|
ALOGE("Failed to get cameraId.");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = ACameraManager_openCamera(mCameraManager, mCameraId, &mDeviceCb,&mDevice);
|
||||||
|
if (ret != AMEDIA_OK || mDevice == nullptr) {
|
||||||
|
ALOGE("Failed to open camera, ret=%d, mDevice=%p.", ret, mDevice);
|
||||||
|
ret = ACAMERA_ERROR_INVALID_PARAMETER;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = ACameraManager_getCameraCharacteristics(mCameraManager, mCameraId,
|
||||||
|
&mCameraMetadata);
|
||||||
|
if (ret != ACAMERA_OK || mCameraMetadata == nullptr) {
|
||||||
|
ALOGE("Get camera %s characteristics failure. ret %d, metadata %p",
|
||||||
|
mCameraId, ret, mCameraMetadata);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!isCapabilitySupported(
|
||||||
|
ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE)) {
|
||||||
|
ALOGW("Camera does not support BACKWARD_COMPATIBLE.");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Create capture session
|
||||||
|
ret = ACaptureSessionOutputContainer_create(&mOutputs);
|
||||||
|
if (ret != AMEDIA_OK) {
|
||||||
|
ALOGE("ACaptureSessionOutputContainer_create failed, ret=%d", ret);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
ret = ACaptureSessionOutput_create(mImgReaderAnw, &mImgReaderOutput);
|
||||||
|
if (ret != AMEDIA_OK) {
|
||||||
|
ALOGE("ACaptureSessionOutput_create failed, ret=%d", ret);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
ret = ACaptureSessionOutputContainer_add(mOutputs, mImgReaderOutput);
|
||||||
|
if (ret != AMEDIA_OK) {
|
||||||
|
ALOGE("ACaptureSessionOutputContainer_add failed, ret=%d", ret);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
ret = ACameraDevice_createCaptureSession(mDevice, mOutputs, &mSessionCb,
|
||||||
|
&mSession);
|
||||||
|
if (ret != AMEDIA_OK) {
|
||||||
|
ALOGE("ACameraDevice_createCaptureSession failed, ret=%d", ret);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Create capture request
|
||||||
|
ret = ACameraDevice_createCaptureRequest(mDevice, TEMPLATE_RECORD,
|
||||||
|
&mCaptureRequest);
|
||||||
|
if (ret != AMEDIA_OK) {
|
||||||
|
ALOGE("ACameraDevice_createCaptureRequest failed, ret=%d", ret);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
ret = ACameraOutputTarget_create(mImgReaderAnw, &mReqImgReaderOutput);
|
||||||
|
if (ret != AMEDIA_OK) {
|
||||||
|
ALOGE("ACameraOutputTarget_create failed, ret=%d", ret);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
ret = ACaptureRequest_addTarget(mCaptureRequest, mReqImgReaderOutput);
|
||||||
|
if (ret != AMEDIA_OK) {
|
||||||
|
ALOGE("ACaptureRequest_addTarget failed, ret=%d", ret);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
mIsCameraReady = true;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool CCamera::isCapabilitySupported(
|
||||||
|
acamera_metadata_enum_android_request_available_capabilities_t cap) {
|
||||||
|
ACameraMetadata_const_entry entry;
|
||||||
|
ACameraMetadata_getConstEntry(mCameraMetadata,
|
||||||
|
ACAMERA_REQUEST_AVAILABLE_CAPABILITIES, &entry);
|
||||||
|
for (uint32_t i = 0; i < entry.count; i++) {
|
||||||
|
if (entry.data.u8[i] == cap) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
void CCamera::closeCamera() {
|
||||||
|
// Destroy capture request
|
||||||
|
if (mReqImgReaderOutput) {
|
||||||
|
ACameraOutputTarget_free(mReqImgReaderOutput);
|
||||||
|
mReqImgReaderOutput = nullptr;
|
||||||
|
}
|
||||||
|
if (mCaptureRequest) {
|
||||||
|
ACaptureRequest_free(mCaptureRequest);
|
||||||
|
mCaptureRequest = nullptr;
|
||||||
|
}
|
||||||
|
// Destroy capture session
|
||||||
|
if (mSession != nullptr) {
|
||||||
|
ACameraCaptureSession_close(mSession);
|
||||||
|
mSession = nullptr;
|
||||||
|
}
|
||||||
|
if (mImgReaderOutput) {
|
||||||
|
ACaptureSessionOutput_free(mImgReaderOutput);
|
||||||
|
mImgReaderOutput = nullptr;
|
||||||
|
}
|
||||||
|
if (mOutputs) {
|
||||||
|
ACaptureSessionOutputContainer_free(mOutputs);
|
||||||
|
mOutputs = nullptr;
|
||||||
|
}
|
||||||
|
// Destroy camera device
|
||||||
|
if (mDevice) {
|
||||||
|
ACameraDevice_close(mDevice);
|
||||||
|
mDevice = nullptr;
|
||||||
|
}
|
||||||
|
if (mCameraMetadata) {
|
||||||
|
ACameraMetadata_free(mCameraMetadata);
|
||||||
|
mCameraMetadata = nullptr;
|
||||||
|
}
|
||||||
|
// Destroy camera manager
|
||||||
|
if (mCameraIdList) {
|
||||||
|
ACameraManager_deleteCameraIdList(mCameraIdList);
|
||||||
|
mCameraIdList = nullptr;
|
||||||
|
}
|
||||||
|
if (mCameraManager) {
|
||||||
|
ACameraManager_delete(mCameraManager);
|
||||||
|
mCameraManager = nullptr;
|
||||||
|
}
|
||||||
|
mIsCameraReady = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
int CCamera::takePicture()
|
||||||
|
{
|
||||||
|
return ACameraCaptureSession_capture(mSession, nullptr, 1, &mCaptureRequest,
|
||||||
|
nullptr);
|
||||||
|
}
|
||||||
@ -0,0 +1,73 @@
|
|||||||
|
#ifndef __CAMERA_H__
|
||||||
|
#define __CAMERA_H__
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
// Must come before NdkCameraCaptureSession.h
|
||||||
|
#include <camera/NdkCaptureRequest.h>
|
||||||
|
|
||||||
|
#include <camera/NdkCameraCaptureSession.h>
|
||||||
|
#include <camera/NdkCameraDevice.h>
|
||||||
|
#include <camera/NdkCameraError.h>
|
||||||
|
#include <camera/NdkCameraManager.h>
|
||||||
|
#include <cstdlib>
|
||||||
|
#include <cstring>
|
||||||
|
#include <string>
|
||||||
|
#include <jni.h>
|
||||||
|
#include <media/NdkImage.h>
|
||||||
|
#include <media/NdkImageReader.h>
|
||||||
|
|
||||||
|
|
||||||
|
class CCamera
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
CCamera();
|
||||||
|
~CCamera();
|
||||||
|
|
||||||
|
int initCamera(ANativeWindow *imgReaderAnw);
|
||||||
|
bool isCapabilitySupported(acamera_metadata_enum_android_request_available_capabilities_t cap);
|
||||||
|
bool isCameraReady() { return mIsCameraReady; }
|
||||||
|
void closeCamera();
|
||||||
|
int takePicture();
|
||||||
|
|
||||||
|
static void onDeviceDisconnected(void * /*obj*/, ACameraDevice * /*device*/) {}
|
||||||
|
static void onDeviceError(void * /*obj*/, ACameraDevice * /*device*/,
|
||||||
|
int /*errorCode*/) {}
|
||||||
|
static void onSessionClosed(void * /*obj*/,
|
||||||
|
ACameraCaptureSession * /*session*/) {}
|
||||||
|
static void onSessionReady(void * /*obj*/,
|
||||||
|
ACameraCaptureSession * /*session*/) {}
|
||||||
|
static void onSessionActive(void * /*obj*/,
|
||||||
|
ACameraCaptureSession * /*session*/) {}
|
||||||
|
|
||||||
|
private:
|
||||||
|
ACameraDevice_StateCallbacks mDeviceCb{ this, onDeviceDisconnected,
|
||||||
|
onDeviceError };
|
||||||
|
ACameraCaptureSession_stateCallbacks mSessionCb{
|
||||||
|
this, onSessionClosed, onSessionReady, onSessionActive };
|
||||||
|
|
||||||
|
ANativeWindow *mImgReaderAnw{ nullptr }; // not owned by us.
|
||||||
|
|
||||||
|
// Camera manager
|
||||||
|
ACameraManager *mCameraManager{ nullptr };
|
||||||
|
ACameraIdList *mCameraIdList{ nullptr };
|
||||||
|
// Camera device
|
||||||
|
ACameraMetadata *mCameraMetadata{ nullptr };
|
||||||
|
ACameraDevice *mDevice{ nullptr };
|
||||||
|
// Capture session
|
||||||
|
ACaptureSessionOutputContainer *mOutputs{ nullptr };
|
||||||
|
ACaptureSessionOutput *mImgReaderOutput{ nullptr };
|
||||||
|
ACameraCaptureSession *mSession{ nullptr };
|
||||||
|
// Capture request
|
||||||
|
ACaptureRequest *mCaptureRequest{ nullptr };
|
||||||
|
ACameraOutputTarget *mReqImgReaderOutput{ nullptr };
|
||||||
|
|
||||||
|
bool mIsCameraReady{ false };
|
||||||
|
const char *mCameraId{ nullptr };
|
||||||
|
|
||||||
|
private:
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
#endif // __CAMERA_H__
|
||||||
@ -0,0 +1,278 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2015 Rockchip Electronics Co. LTD
|
||||||
|
*
|
||||||
|
* 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.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define MODULE_TAG "CameraReader"
|
||||||
|
|
||||||
|
// #include "mpp_log.h"
|
||||||
|
// #include "mpp_mem.h"
|
||||||
|
#include "Camera2Reader.h"
|
||||||
|
#include <dirent.h>
|
||||||
|
|
||||||
|
#include <iomanip>
|
||||||
|
#include <string>
|
||||||
|
#include <sstream>
|
||||||
|
|
||||||
|
Camera2Reader::Camera2Reader(const char *device, int bufcnt, int width, int height, int fmt)
|
||||||
|
: mBufcnt(bufcnt),
|
||||||
|
mWidth(width),
|
||||||
|
mHeight(height),
|
||||||
|
mFmt(fmt)
|
||||||
|
{
|
||||||
|
strcpy(mDevice, device);
|
||||||
|
}
|
||||||
|
Camera2Reader::Camera2Reader(int cameraId) : mCameraId(cameraId)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
int Camera2Reader::Init(const char *device, int bufcnt, int width, int height, int format)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Free a context to capture frames from <fname>.
|
||||||
|
// Returns NULL on error.
|
||||||
|
int Camera2Reader::Deinit()
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool Camera2Reader::Open(const char* path, const char* fileName)
|
||||||
|
{
|
||||||
|
mPath.assign(path);
|
||||||
|
mFileName.assign(fileName);
|
||||||
|
|
||||||
|
ACameraIdList *cameraIdList = NULL;
|
||||||
|
ACameraMetadata *cameraMetadata = NULL;
|
||||||
|
|
||||||
|
const char *selectedCameraId = NULL;
|
||||||
|
camera_status_t camera_status = ACAMERA_OK;
|
||||||
|
ACameraManager *cameraManager = ACameraManager_create();
|
||||||
|
|
||||||
|
camera_status = ACameraManager_getCameraIdList(cameraManager, &cameraIdList);
|
||||||
|
if (camera_status != ACAMERA_OK) {
|
||||||
|
LOGI("Failed to get camera id list (reason: %d)\n", camera_status);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (cameraIdList->numCameras < 1 ) {
|
||||||
|
LOGI("No camera device detected.\n");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (cameraIdList->numCameras <= mCameraId ) {
|
||||||
|
LOGI("No required camera device %d detected.\n", mCameraId);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
selectedCameraId = cameraIdList->cameraIds[mCameraId];
|
||||||
|
|
||||||
|
LOGI("Trying to open Camera2 (id: %s, num of camera : %d)\n", selectedCameraId,
|
||||||
|
cameraIdList->numCameras);
|
||||||
|
|
||||||
|
camera_status = ACameraManager_getCameraCharacteristics(cameraManager, selectedCameraId,
|
||||||
|
&cameraMetadata);
|
||||||
|
|
||||||
|
if (camera_status != ACAMERA_OK) {
|
||||||
|
LOGI("Failed to get camera meta data of ID:%s\n", selectedCameraId);
|
||||||
|
}
|
||||||
|
|
||||||
|
deviceStateCallbacks.onDisconnected = camera_device_on_disconnected;
|
||||||
|
deviceStateCallbacks.onError = camera_device_on_error;
|
||||||
|
|
||||||
|
camera_status = ACameraManager_openCamera(cameraManager, selectedCameraId,
|
||||||
|
&deviceStateCallbacks, &cameraDevice);
|
||||||
|
|
||||||
|
if (camera_status != ACAMERA_OK) {
|
||||||
|
LOGI("Failed to open camera device (id: %s)\n", selectedCameraId);
|
||||||
|
}
|
||||||
|
|
||||||
|
camera_status = ACameraDevice_createCaptureRequest(cameraDevice, TEMPLATE_PREVIEW,
|
||||||
|
&captureRequest);
|
||||||
|
|
||||||
|
if (camera_status != ACAMERA_OK) {
|
||||||
|
LOGI("Failed to create preview capture request (id: %s)\n", selectedCameraId);
|
||||||
|
}
|
||||||
|
|
||||||
|
ACaptureSessionOutputContainer_create(&captureSessionOutputContainer);
|
||||||
|
|
||||||
|
captureSessionStateCallbacks.onReady = capture_session_on_ready;
|
||||||
|
captureSessionStateCallbacks.onActive = capture_session_on_active;
|
||||||
|
captureSessionStateCallbacks.onClosed = capture_session_on_closed;
|
||||||
|
|
||||||
|
ACameraMetadata_free(cameraMetadata);
|
||||||
|
ACameraManager_deleteCameraIdList(cameraIdList);
|
||||||
|
ACameraManager_delete(cameraManager);
|
||||||
|
|
||||||
|
media_status_t status;
|
||||||
|
// status = AImageReader_new(1920, 1080, AIMAGE_FORMAT_YUV_420_888, 5, &mAImageReader);
|
||||||
|
status = AImageReader_new(1920, 1080, AIMAGE_FORMAT_JPEG, 5, &mAImageReader);
|
||||||
|
if (status != AMEDIA_OK)
|
||||||
|
{
|
||||||
|
LOGI("AImageReader_new error\n");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
AImageReader_ImageListener listener{
|
||||||
|
.context = this,
|
||||||
|
.onImageAvailable = OnImageCallback,
|
||||||
|
};
|
||||||
|
AImageReader_setImageListener(mAImageReader, &listener);
|
||||||
|
|
||||||
|
//ANativeWindow *mNativeWindow;
|
||||||
|
status = AImageReader_getWindow(mAImageReader, &theNativeWindow);
|
||||||
|
if (status != AMEDIA_OK)
|
||||||
|
{
|
||||||
|
LOGI("AImageReader_getWindow error\n");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOGI("Surface is prepared in %p.\n", theNativeWindow);
|
||||||
|
|
||||||
|
ACameraOutputTarget_create(theNativeWindow, &cameraOutputTarget);
|
||||||
|
ACaptureRequest_addTarget(captureRequest, cameraOutputTarget);
|
||||||
|
|
||||||
|
ACaptureSessionOutput_create(theNativeWindow, &sessionOutput);
|
||||||
|
ACaptureSessionOutputContainer_add(captureSessionOutputContainer, sessionOutput);
|
||||||
|
|
||||||
|
ACameraDevice_createCaptureSession(cameraDevice, captureSessionOutputContainer,
|
||||||
|
&captureSessionStateCallbacks, &captureSession);
|
||||||
|
|
||||||
|
// ACameraCaptureSession_setRepeatingRequest(captureSession, NULL, 1, &captureRequest, NULL);
|
||||||
|
ACameraCaptureSession_capture(captureSession, NULL, 1, &captureRequest, NULL);
|
||||||
|
LOGI("Surface is prepared in here.\n");
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
ACameraCaptureSession_stateCallbacks *Camera2Reader::GetSessionListener()
|
||||||
|
{
|
||||||
|
static ACameraCaptureSession_stateCallbacks sessionListener = {
|
||||||
|
.context = this,
|
||||||
|
.onClosed = Camera2Reader::capture_session_on_closed,
|
||||||
|
.onReady = Camera2Reader::capture_session_on_ready,
|
||||||
|
.onActive = Camera2Reader::capture_session_on_active,
|
||||||
|
};
|
||||||
|
return &sessionListener;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Camera2Reader::ImageCallback(AImageReader *reader)
|
||||||
|
{
|
||||||
|
int32_t format;
|
||||||
|
AImage *image = nullptr;
|
||||||
|
media_status_t status = AImageReader_acquireNextImage(reader, &image);
|
||||||
|
LOGI("ImageCallback\n");
|
||||||
|
if (status == AMEDIA_OK && image)
|
||||||
|
{
|
||||||
|
LOGI("ImageCallback\n");
|
||||||
|
AImage_delete(image);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
void Camera2Reader::OnImageCallback(void *ctx, AImageReader *reader)
|
||||||
|
{
|
||||||
|
Camera2Reader* pThis = reinterpret_cast<Camera2Reader*>(ctx);
|
||||||
|
AImage *image = nullptr;
|
||||||
|
media_status_t status = AImageReader_acquireNextImage(reader, &image);
|
||||||
|
if (status == AMEDIA_OK && image)
|
||||||
|
{
|
||||||
|
WriteFile(pThis, image, pThis->mPath);
|
||||||
|
// image.
|
||||||
|
AImage_delete(image);
|
||||||
|
pThis->Deinit();
|
||||||
|
delete pThis;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool Camera2Reader::readyToRun()
|
||||||
|
{
|
||||||
|
if (!Init(mDevice, mBufcnt, mWidth, mHeight, mFmt))
|
||||||
|
{
|
||||||
|
LOGI("Init false\n");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return Open("", "");
|
||||||
|
}
|
||||||
|
void Camera2Reader::start()
|
||||||
|
{
|
||||||
|
//run();
|
||||||
|
}
|
||||||
|
|
||||||
|
void Camera2Reader::stop()
|
||||||
|
{
|
||||||
|
//threadStop();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool Camera2Reader::threadLoop()
|
||||||
|
{
|
||||||
|
usleep(1000);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
Camera2Reader::~Camera2Reader()
|
||||||
|
{
|
||||||
|
LOGI("~CameraReader\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
void *Camera2Reader::readImage(int chn)
|
||||||
|
{
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void Camera2Reader::WriteFile(Camera2Reader* pThis, AImage *image, const std::string& path)
|
||||||
|
{
|
||||||
|
// static const char *kFileName = "capture";
|
||||||
|
int planeCount;
|
||||||
|
media_status_t status = AImage_getNumberOfPlanes(image, &planeCount);
|
||||||
|
|
||||||
|
LOGI("Info: getNumberOfPlanes() planeCount = %d", planeCount);
|
||||||
|
if (!(status == AMEDIA_OK && planeCount == 1))
|
||||||
|
{
|
||||||
|
LOGE("Error: getNumberOfPlanes() planeCount = %d", planeCount);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t *data = nullptr;
|
||||||
|
int len = 0;
|
||||||
|
AImage_getPlaneData(image, 0, &data, &len);
|
||||||
|
|
||||||
|
DIR *dir = opendir(path.c_str());
|
||||||
|
if (dir)
|
||||||
|
{
|
||||||
|
closedir(dir);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
std::string cmd = "mkdir -p ";
|
||||||
|
cmd += path;
|
||||||
|
system(cmd.c_str());
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string fileName = path + pThis->mFileName;
|
||||||
|
|
||||||
|
FILE *file = fopen(fileName.c_str(), "wb");
|
||||||
|
if (file && data && len)
|
||||||
|
{
|
||||||
|
fwrite(data, 1, len, file);
|
||||||
|
fclose(file);
|
||||||
|
|
||||||
|
LOGE("Capture: %s", fileName.c_str());
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (file)
|
||||||
|
fclose(file);
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,128 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2015 Rockchip Electronics Co. LTD
|
||||||
|
*
|
||||||
|
* 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.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __CAMERA2_READER_H__
|
||||||
|
#define __CAMERA2_READER_H__
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <time.h>
|
||||||
|
|
||||||
|
#include <camera/NdkCameraManager.h>
|
||||||
|
#include <camera/NdkCameraError.h>
|
||||||
|
#include <camera/NdkCameraDevice.h>
|
||||||
|
#include <camera/NdkCameraMetadataTags.h>
|
||||||
|
#include <media/NdkImageReader.h>
|
||||||
|
#include <android/log.h>
|
||||||
|
#define LOG_TAG "native-camera2-jni"
|
||||||
|
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
|
||||||
|
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
|
||||||
|
#define FMT_NUM_PLANES 1
|
||||||
|
|
||||||
|
// struct CameraParam
|
||||||
|
// {
|
||||||
|
// int id;
|
||||||
|
// const char *device;
|
||||||
|
// RK_U32 bufcnt;
|
||||||
|
// RK_U32 width;
|
||||||
|
// RK_U32 height;
|
||||||
|
// MppFrameFormat fmt;
|
||||||
|
// };
|
||||||
|
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
class Camera2Reader
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
AImageReader *mAImageReader;
|
||||||
|
ANativeWindow *theNativeWindow;
|
||||||
|
ACameraDevice *cameraDevice;
|
||||||
|
ACaptureRequest *captureRequest;
|
||||||
|
ACameraOutputTarget *cameraOutputTarget;
|
||||||
|
ACaptureSessionOutput *sessionOutput;
|
||||||
|
ACaptureSessionOutputContainer *captureSessionOutputContainer;
|
||||||
|
ACameraCaptureSession *captureSession;
|
||||||
|
|
||||||
|
ACameraDevice_StateCallbacks deviceStateCallbacks;
|
||||||
|
ACameraCaptureSession_stateCallbacks captureSessionStateCallbacks;
|
||||||
|
|
||||||
|
int sessionSequenceId;
|
||||||
|
|
||||||
|
int mCameraId = 0;
|
||||||
|
char mDevice[20];
|
||||||
|
int mBufcnt;
|
||||||
|
int mWidth;
|
||||||
|
int mHeight;
|
||||||
|
int mFmt;
|
||||||
|
|
||||||
|
std::string mPath;
|
||||||
|
std::string mFileName;
|
||||||
|
|
||||||
|
unsigned char *mYuv720p = NULL;
|
||||||
|
unsigned char *mYuv420i = NULL;
|
||||||
|
unsigned char *mArgb1080p = NULL;
|
||||||
|
// Create a new context to capture frames from <fname>. Returns NULL on error.
|
||||||
|
int Init(const char *device, int bufcnt, int width, int height, int fmt);
|
||||||
|
|
||||||
|
// Stop capturing and free a context.
|
||||||
|
int Deinit();
|
||||||
|
bool readyToRun();
|
||||||
|
bool threadLoop();
|
||||||
|
ACameraCaptureSession_stateCallbacks *GetSessionListener();
|
||||||
|
void ImageCallback(AImageReader *reader);
|
||||||
|
static void OnImageCallback(void *ctx, AImageReader *reader);
|
||||||
|
|
||||||
|
static void camera_device_on_disconnected(void *context, ACameraDevice *device)
|
||||||
|
{
|
||||||
|
LOGI("Camera(id: %s) is diconnected.\n", ACameraDevice_getId(device));
|
||||||
|
}
|
||||||
|
|
||||||
|
static void camera_device_on_error(void *context, ACameraDevice *device, int error)
|
||||||
|
{
|
||||||
|
LOGI("Error(code: %d) on Camera(id: %s).\n", error, ACameraDevice_getId(device));
|
||||||
|
}
|
||||||
|
|
||||||
|
static void capture_session_on_ready(void *context, ACameraCaptureSession *session)
|
||||||
|
{
|
||||||
|
LOGI("Session is ready. %p\n", session);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void capture_session_on_active(void *context, ACameraCaptureSession *session)
|
||||||
|
{
|
||||||
|
LOGI("Session is activated. %p\n", session);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void capture_session_on_closed(void *context, ACameraCaptureSession *session)
|
||||||
|
{
|
||||||
|
LOGI("Session is closed. %p\n", session);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void WriteFile(Camera2Reader* pThis, AImage *image, const std::string& path);
|
||||||
|
|
||||||
|
public:
|
||||||
|
bool Open(const char* path, const char* fileName);
|
||||||
|
Camera2Reader(const char *device, int bufcnt, int width, int height, int fmt);
|
||||||
|
Camera2Reader(int cameraId);
|
||||||
|
void *readImage(int chn);
|
||||||
|
// Camera2Reader &operator=(CameraParam *cameraParam);
|
||||||
|
~Camera2Reader();
|
||||||
|
void start();
|
||||||
|
void stop();
|
||||||
|
};
|
||||||
|
#endif /* __CAMERA_READER_H__ */
|
||||||
@ -0,0 +1,269 @@
|
|||||||
|
#include "TerminalDevice.h"
|
||||||
|
/*
|
||||||
|
* 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.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define LOG_TAG "CameraTestHelpers"
|
||||||
|
|
||||||
|
#include "PhoneDevice.h"
|
||||||
|
|
||||||
|
#include <android/log.h>
|
||||||
|
|
||||||
|
#define ALOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
|
||||||
|
#define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
|
||||||
|
#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
|
||||||
|
|
||||||
|
CPhoneDevice::CPhoneDevice()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
CPhoneDevice::~CPhoneDevice()
|
||||||
|
{
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
IDevice::timer_uid_t CPhoneDevice::registerTimer(unsigned int timerType, unsigned int timeout)
|
||||||
|
{
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool CPhoneDevice::unregisterTimer(IDevice::timer_uid_t uid)
|
||||||
|
{
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool CPhoneDevice::onTimeout(IDevice::timer_uid_t uid, unsigned int timerType, unsigned int times)
|
||||||
|
{
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
bool CPhoneDevice::TakePhoto(unsigned char channel, unsigned char preset, const string& path, bool photo)
|
||||||
|
{
|
||||||
|
int cameraId = (int)channel - 1;
|
||||||
|
|
||||||
|
ACameraIdList *cameraIdList = NULL;
|
||||||
|
ACameraMetadata *cameraMetadata = NULL;
|
||||||
|
|
||||||
|
const char *selectedCameraId = NULL;
|
||||||
|
camera_status_t camera_status = ACAMERA_OK;
|
||||||
|
ACameraManager *cameraManager = ACameraManager_create();
|
||||||
|
|
||||||
|
camera_status = ACameraManager_getCameraIdList(cameraManager, &cameraIdList);
|
||||||
|
if (camera_status != ACAMERA_OK) {
|
||||||
|
LOGI("Failed to get camera id list (reason: %d)\n", camera_status);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (cameraIdList->numCameras < 1 ) {
|
||||||
|
LOGI("No camera device detected.\n");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (cameraIdList->numCameras <= cameraId ) {
|
||||||
|
LOGI("No required camera device %d detected.\n", cameraId);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
selectedCameraId = cameraIdList->cameraIds[cameraId];
|
||||||
|
|
||||||
|
LOGI("Trying to open Camera2 (id: %s, num of camera : %d)\n", selectedCameraId,
|
||||||
|
cameraIdList->numCameras);
|
||||||
|
|
||||||
|
camera_status = ACameraManager_getCameraCharacteristics(cameraManager, selectedCameraId,
|
||||||
|
&cameraMetadata);
|
||||||
|
|
||||||
|
if (camera_status != ACAMERA_OK) {
|
||||||
|
LOGI("Failed to get camera meta data of ID:%s\n", selectedCameraId);
|
||||||
|
}
|
||||||
|
|
||||||
|
deviceStateCallbacks.onDisconnected = camera_device_on_disconnected;
|
||||||
|
deviceStateCallbacks.onError = camera_device_on_error;
|
||||||
|
|
||||||
|
camera_status = ACameraManager_openCamera(cameraManager, selectedCameraId,
|
||||||
|
&deviceStateCallbacks, &cameraDevice);
|
||||||
|
|
||||||
|
if (camera_status != ACAMERA_OK) {
|
||||||
|
LOGI("Failed to open camera device (id: %s)\n", selectedCameraId);
|
||||||
|
}
|
||||||
|
|
||||||
|
camera_status = ACameraDevice_createCaptureRequest(cameraDevice, TEMPLATE_PREVIEW,
|
||||||
|
&captureRequest);
|
||||||
|
|
||||||
|
if (camera_status != ACAMERA_OK) {
|
||||||
|
LOGI("Failed to create preview capture request (id: %s)\n", selectedCameraId);
|
||||||
|
}
|
||||||
|
|
||||||
|
ACaptureSessionOutputContainer_create(&captureSessionOutputContainer);
|
||||||
|
|
||||||
|
captureSessionStateCallbacks.onReady = capture_session_on_ready;
|
||||||
|
captureSessionStateCallbacks.onActive = capture_session_on_active;
|
||||||
|
captureSessionStateCallbacks.onClosed = capture_session_on_closed;
|
||||||
|
|
||||||
|
ACameraMetadata_free(cameraMetadata);
|
||||||
|
ACameraManager_deleteCameraIdList(cameraIdList);
|
||||||
|
ACameraManager_delete(cameraManager);
|
||||||
|
|
||||||
|
media_status_t status;
|
||||||
|
// status = AImageReader_new(1920, 1080, AIMAGE_FORMAT_YUV_420_888, 5, &mAImageReader);
|
||||||
|
status = AImageReader_new(1920, 1080, AIMAGE_FORMAT_JPEG, 5, &mAImageReader);
|
||||||
|
if (status != AMEDIA_OK)
|
||||||
|
{
|
||||||
|
LOGI("AImageReader_new error\n");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
AImageReader_ImageListener listener{
|
||||||
|
.context = this,
|
||||||
|
.onImageAvailable = OnImageCallback,
|
||||||
|
};
|
||||||
|
AImageReader_setImageListener(mAImageReader, &listener);
|
||||||
|
|
||||||
|
//ANativeWindow *mNativeWindow;
|
||||||
|
status = AImageReader_getWindow(mAImageReader, &theNativeWindow);
|
||||||
|
if (status != AMEDIA_OK)
|
||||||
|
{
|
||||||
|
LOGI("AImageReader_getWindow error\n");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOGI("Surface is prepared in %p.\n", theNativeWindow);
|
||||||
|
|
||||||
|
ACameraOutputTarget_create(theNativeWindow, &cameraOutputTarget);
|
||||||
|
ACaptureRequest_addTarget(captureRequest, cameraOutputTarget);
|
||||||
|
|
||||||
|
ACaptureSessionOutput_create(theNativeWindow, &sessionOutput);
|
||||||
|
ACaptureSessionOutputContainer_add(captureSessionOutputContainer, sessionOutput);
|
||||||
|
|
||||||
|
ACameraDevice_createCaptureSession(cameraDevice, captureSessionOutputContainer,
|
||||||
|
&captureSessionStateCallbacks, &captureSession);
|
||||||
|
|
||||||
|
// ACameraCaptureSession_setRepeatingRequest(captureSession, NULL, 1, &captureRequest, NULL);
|
||||||
|
ACameraCaptureSession_capture(captureSession, NULL, 1, &captureRequest, NULL);
|
||||||
|
LOGI("Surface is prepared in here.\n");
|
||||||
|
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
ACameraCaptureSession_stateCallbacks* CPhoneDevice::GetSessionListener()
|
||||||
|
{
|
||||||
|
static ACameraCaptureSession_stateCallbacks sessionListener = {
|
||||||
|
.context = this,
|
||||||
|
.onClosed = CPhoneDevice::capture_session_on_closed,
|
||||||
|
.onReady = CPhoneDevice::capture_session_on_ready,
|
||||||
|
.onActive = CPhoneDevice::capture_session_on_active,
|
||||||
|
};
|
||||||
|
return &sessionListener;
|
||||||
|
}
|
||||||
|
|
||||||
|
void CPhoneDevice::ImageCallback(AImageReader *reader)
|
||||||
|
{
|
||||||
|
int32_t format;
|
||||||
|
AImage *image = nullptr;
|
||||||
|
media_status_t status = AImageReader_acquireNextImage(reader, &image);
|
||||||
|
LOGI("ImageCallback\n");
|
||||||
|
if (status == AMEDIA_OK && image)
|
||||||
|
{
|
||||||
|
LOGI("ImageCallback\n");
|
||||||
|
AImage_delete(image);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
void CPhoneDevice::OnImageCallback(void *ctx, AImageReader *reader)
|
||||||
|
{
|
||||||
|
CPhoneDevice* pThis = reinterpret_cast<CPhoneDevice*>(ctx);
|
||||||
|
AImage *image = nullptr;
|
||||||
|
media_status_t status = AImageReader_acquireNextImage(reader, &image);
|
||||||
|
if (status == AMEDIA_OK && image)
|
||||||
|
{
|
||||||
|
WriteFile(pThis, image);
|
||||||
|
AImage_delete(image);
|
||||||
|
|
||||||
|
// delete pThis;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool CPhoneDevice::WriteFile(CPhoneDevice* pThis, AImage *image)
|
||||||
|
{
|
||||||
|
int planeCount = 0;
|
||||||
|
media_status_t status = AImage_getNumberOfPlanes(image, &planeCount);
|
||||||
|
|
||||||
|
LOGI("Info: getNumberOfPlanes() planeCount = %d", planeCount);
|
||||||
|
if (!(status == AMEDIA_OK && planeCount == 1))
|
||||||
|
{
|
||||||
|
LOGE("Error: getNumberOfPlanes() planeCount = %d", planeCount);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t *data = nullptr;
|
||||||
|
int len = 0;
|
||||||
|
AImage_getPlaneData(image, 0, &data, &len);
|
||||||
|
|
||||||
|
std::string path = pThis->GetFileName();
|
||||||
|
|
||||||
|
bool res = false;
|
||||||
|
FILE *file = fopen(path.c_str(), "wb");
|
||||||
|
if (file && data && len)
|
||||||
|
{
|
||||||
|
fwrite(data, 1, len, file);
|
||||||
|
fclose(file);
|
||||||
|
|
||||||
|
LOGE("Capture: %s", path.c_str());
|
||||||
|
res = true;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if (file)
|
||||||
|
fclose(file);
|
||||||
|
}
|
||||||
|
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string CPhoneDevice::GetFileName() const
|
||||||
|
{
|
||||||
|
return mPath;
|
||||||
|
}
|
||||||
|
|
||||||
|
void CPhoneDevice::camera_device_on_disconnected(void *context, ACameraDevice *device)
|
||||||
|
{
|
||||||
|
LOGI("Camera(id: %s) is diconnected.\n", ACameraDevice_getId(device));
|
||||||
|
CPhoneDevice* pThis = (CPhoneDevice*)context;
|
||||||
|
delete pThis;
|
||||||
|
}
|
||||||
|
|
||||||
|
void CPhoneDevice::camera_device_on_error(void *context, ACameraDevice *device, int error)
|
||||||
|
{
|
||||||
|
LOGI("Error(code: %d) on Camera(id: %s).\n", error, ACameraDevice_getId(device));
|
||||||
|
}
|
||||||
|
|
||||||
|
void CPhoneDevice::capture_session_on_ready(void *context, ACameraCaptureSession *session)
|
||||||
|
{
|
||||||
|
LOGI("Session is ready. %p\n", session);
|
||||||
|
}
|
||||||
|
|
||||||
|
void CPhoneDevice::capture_session_on_active(void *context, ACameraCaptureSession *session)
|
||||||
|
{
|
||||||
|
LOGI("Session is activated. %p\n", session);
|
||||||
|
}
|
||||||
|
|
||||||
|
void CPhoneDevice::capture_session_on_closed(void *context, ACameraCaptureSession *session)
|
||||||
|
{
|
||||||
|
LOGI("Session is closed. %p\n", session);
|
||||||
|
}
|
||||||
@ -0,0 +1,70 @@
|
|||||||
|
#ifndef __PHONE_DEVICE_H__
|
||||||
|
#define __PHONE_DEVICE_H__
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <time.h>
|
||||||
|
|
||||||
|
#include <camera/NdkCameraManager.h>
|
||||||
|
#include <camera/NdkCameraError.h>
|
||||||
|
#include <camera/NdkCameraDevice.h>
|
||||||
|
#include <camera/NdkCameraMetadataTags.h>
|
||||||
|
#include <media/NdkImageReader.h>
|
||||||
|
#include <android/log.h>
|
||||||
|
// #define LOG_TAG "native-camera2-jni"
|
||||||
|
#define PD_LOG_TAG "PhoneDev"
|
||||||
|
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,PD_LOG_TAG,__VA_ARGS__)
|
||||||
|
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,PD_LOG_TAG,__VA_ARGS__)
|
||||||
|
#include <Client/Device.h>
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
class CPhoneDevice : public IDevice
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
CPhoneDevice();
|
||||||
|
~CPhoneDevice();
|
||||||
|
|
||||||
|
virtual bool TakePhoto(unsigned char channel, unsigned char preset, const string& path, bool photo);
|
||||||
|
virtual timer_uid_t registerTimer(unsigned int timerType, unsigned int timeout);
|
||||||
|
virtual bool unregisterTimer(timer_uid_t uid);
|
||||||
|
virtual bool onTimeout(timer_uid_t uid, unsigned int timerType, unsigned int times);
|
||||||
|
|
||||||
|
protected:
|
||||||
|
|
||||||
|
ACameraCaptureSession_stateCallbacks *GetSessionListener();
|
||||||
|
std::string GetFileName() const;
|
||||||
|
|
||||||
|
static void camera_device_on_disconnected(void *context, ACameraDevice *device);
|
||||||
|
static void camera_device_on_error(void *context, ACameraDevice *device, int error);
|
||||||
|
static void capture_session_on_ready(void *context, ACameraCaptureSession *session);
|
||||||
|
static void capture_session_on_active(void *context, ACameraCaptureSession *session);
|
||||||
|
static void capture_session_on_closed(void *context, ACameraCaptureSession *session);
|
||||||
|
|
||||||
|
void ImageCallback(AImageReader *reader);
|
||||||
|
static void OnImageCallback(void *ctx, AImageReader *reader);
|
||||||
|
static bool WriteFile(CPhoneDevice* pThis, AImage *image);
|
||||||
|
|
||||||
|
protected:
|
||||||
|
|
||||||
|
std::string mPath;
|
||||||
|
|
||||||
|
AImageReader *mAImageReader;
|
||||||
|
ANativeWindow *theNativeWindow;
|
||||||
|
ACameraDevice *cameraDevice;
|
||||||
|
ACaptureRequest *captureRequest;
|
||||||
|
ACameraOutputTarget *cameraOutputTarget;
|
||||||
|
ACaptureSessionOutput *sessionOutput;
|
||||||
|
ACaptureSessionOutputContainer *captureSessionOutputContainer;
|
||||||
|
ACameraCaptureSession *captureSession;
|
||||||
|
|
||||||
|
ACameraDevice_StateCallbacks deviceStateCallbacks;
|
||||||
|
ACameraCaptureSession_stateCallbacks captureSessionStateCallbacks;
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
#endif // __PHONE_DEVICE_H__
|
||||||
@ -0,0 +1,170 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2017 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 "camera_engine.h"
|
||||||
|
#include "utils/native_debug.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* SampleEngine global object
|
||||||
|
*/
|
||||||
|
static CameraEngine* pEngineObj = nullptr;
|
||||||
|
CameraEngine* GetAppEngine(void) {
|
||||||
|
ASSERT(pEngineObj, "AppEngine has not initialized");
|
||||||
|
return pEngineObj;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Teamplate function for NativeActivity derived applications
|
||||||
|
* Create/Delete camera object with
|
||||||
|
* INIT_WINDOW/TERM_WINDOW command, ignoring other event.
|
||||||
|
*/
|
||||||
|
static void ProcessAndroidCmd(struct android_app* app, int32_t cmd) {
|
||||||
|
CameraEngine* engine = reinterpret_cast<CameraEngine*>(app->userData);
|
||||||
|
switch (cmd) {
|
||||||
|
case APP_CMD_INIT_WINDOW:
|
||||||
|
if (engine->AndroidApp()->window != NULL) {
|
||||||
|
engine->SaveNativeWinRes(ANativeWindow_getWidth(app->window),
|
||||||
|
ANativeWindow_getHeight(app->window),
|
||||||
|
ANativeWindow_getFormat(app->window));
|
||||||
|
engine->OnAppInitWindow();
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case APP_CMD_TERM_WINDOW:
|
||||||
|
engine->OnAppTermWindow();
|
||||||
|
ANativeWindow_setBuffersGeometry(
|
||||||
|
app->window, engine->GetSavedNativeWinWidth(),
|
||||||
|
engine->GetSavedNativeWinHeight(), engine->GetSavedNativeWinFormat());
|
||||||
|
break;
|
||||||
|
case APP_CMD_CONFIG_CHANGED:
|
||||||
|
engine->OnAppConfigChange();
|
||||||
|
break;
|
||||||
|
case APP_CMD_LOST_FOCUS:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
extern "C" void android_main(struct android_app* state) {
|
||||||
|
CameraEngine engine(state);
|
||||||
|
pEngineObj = &engine;
|
||||||
|
|
||||||
|
state->userData = reinterpret_cast<void*>(&engine);
|
||||||
|
state->onAppCmd = ProcessAndroidCmd;
|
||||||
|
|
||||||
|
// loop waiting for stuff to do.
|
||||||
|
while (1) {
|
||||||
|
// Read all pending events.
|
||||||
|
int events;
|
||||||
|
struct android_poll_source* source;
|
||||||
|
|
||||||
|
while (ALooper_pollAll(0, NULL, &events, (void**)&source) >= 0) {
|
||||||
|
// Process this event.
|
||||||
|
if (source != NULL) {
|
||||||
|
source->process(state, source);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check if we are exiting.
|
||||||
|
if (state->destroyRequested != 0) {
|
||||||
|
LOGI("CameraEngine thread destroy requested!");
|
||||||
|
engine.DeleteCamera();
|
||||||
|
pEngineObj = nullptr;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pEngineObj->DrawFrame();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Handle Android System APP_CMD_INIT_WINDOW message
|
||||||
|
* Request camera persmission from Java side
|
||||||
|
* Create camera object if camera has been granted
|
||||||
|
*/
|
||||||
|
void CameraEngine::OnAppInitWindow(void) {
|
||||||
|
if (!cameraGranted_) {
|
||||||
|
// Not permitted to use camera yet, ask(again) and defer other events
|
||||||
|
RequestCameraPermission();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
rotation_ = GetDisplayRotation();
|
||||||
|
|
||||||
|
CreateCamera();
|
||||||
|
ASSERT(camera_, "CameraCreation Failed");
|
||||||
|
|
||||||
|
EnableUI();
|
||||||
|
|
||||||
|
// NativeActivity end is ready to display, start pulling images
|
||||||
|
cameraReady_ = true;
|
||||||
|
camera_->StartPreview(true);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Handle APP_CMD_TEMR_WINDOW
|
||||||
|
*/
|
||||||
|
void CameraEngine::OnAppTermWindow(void) {
|
||||||
|
cameraReady_ = false;
|
||||||
|
DeleteCamera();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Handle APP_CMD_CONFIG_CHANGED
|
||||||
|
*/
|
||||||
|
void CameraEngine::OnAppConfigChange(void) {
|
||||||
|
int newRotation = GetDisplayRotation();
|
||||||
|
|
||||||
|
if (newRotation != rotation_) {
|
||||||
|
OnAppTermWindow();
|
||||||
|
|
||||||
|
rotation_ = newRotation;
|
||||||
|
OnAppInitWindow();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieve saved native window width.
|
||||||
|
* @return width of native window
|
||||||
|
*/
|
||||||
|
int32_t CameraEngine::GetSavedNativeWinWidth(void) {
|
||||||
|
return savedNativeWinRes_.width;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieve saved native window height.
|
||||||
|
* @return height of native window
|
||||||
|
*/
|
||||||
|
int32_t CameraEngine::GetSavedNativeWinHeight(void) {
|
||||||
|
return savedNativeWinRes_.height;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieve saved native window format
|
||||||
|
* @return format of native window
|
||||||
|
*/
|
||||||
|
int32_t CameraEngine::GetSavedNativeWinFormat(void) {
|
||||||
|
return savedNativeWinRes_.format;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Save original NativeWindow Resolution
|
||||||
|
* @param w width of native window in pixel
|
||||||
|
* @param h height of native window in pixel
|
||||||
|
* @param format
|
||||||
|
*/
|
||||||
|
void CameraEngine::SaveNativeWinRes(int32_t w, int32_t h, int32_t format) {
|
||||||
|
savedNativeWinRes_.width = w;
|
||||||
|
savedNativeWinRes_.height = h;
|
||||||
|
savedNativeWinRes_.format = format;
|
||||||
|
}
|
||||||
@ -0,0 +1,175 @@
|
|||||||
|
/**
|
||||||
|
* Copyright (C) 2017 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.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/** Description
|
||||||
|
* Demonstrate NDK Camera interface added to android-24
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "camera_engine.h"
|
||||||
|
|
||||||
|
#include <cstdio>
|
||||||
|
|
||||||
|
#include "utils/native_debug.h"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* constructor and destructor for main application class
|
||||||
|
* @param app native_app_glue environment
|
||||||
|
* @return none
|
||||||
|
*/
|
||||||
|
CameraEngine::CameraEngine(android_app* app)
|
||||||
|
: app_(app),
|
||||||
|
cameraGranted_(false),
|
||||||
|
rotation_(0),
|
||||||
|
cameraReady_(false),
|
||||||
|
camera_(nullptr),
|
||||||
|
yuvReader_(nullptr),
|
||||||
|
jpgReader_(nullptr) {
|
||||||
|
memset(&savedNativeWinRes_, 0, sizeof(savedNativeWinRes_));
|
||||||
|
}
|
||||||
|
|
||||||
|
CameraEngine::~CameraEngine() {
|
||||||
|
cameraReady_ = false;
|
||||||
|
DeleteCamera();
|
||||||
|
}
|
||||||
|
|
||||||
|
struct android_app* CameraEngine::AndroidApp(void) const {
|
||||||
|
return app_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Create a camera object for onboard BACK_FACING camera
|
||||||
|
*/
|
||||||
|
void CameraEngine::CreateCamera(void) {
|
||||||
|
// Camera needed to be requested at the run-time from Java SDK
|
||||||
|
// if Not granted, do nothing.
|
||||||
|
if (!cameraGranted_ || !app_->window) {
|
||||||
|
LOGW("Camera Sample requires Full Camera access");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
int32_t displayRotation = GetDisplayRotation();
|
||||||
|
rotation_ = displayRotation;
|
||||||
|
|
||||||
|
camera_ = new NDKCamera();
|
||||||
|
ASSERT(camera_, "Failed to Create CameraObject");
|
||||||
|
|
||||||
|
int32_t facing = 0, angle = 0, imageRotation = 0;
|
||||||
|
if (camera_->GetSensorOrientation(&facing, &angle)) {
|
||||||
|
if (facing == ACAMERA_LENS_FACING_FRONT) {
|
||||||
|
imageRotation = (angle + rotation_) % 360;
|
||||||
|
imageRotation = (360 - imageRotation) % 360;
|
||||||
|
} else {
|
||||||
|
imageRotation = (angle - rotation_ + 360) % 360;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
LOGI("Phone Rotation: %d, Present Rotation Angle: %d", rotation_,
|
||||||
|
imageRotation);
|
||||||
|
ImageFormat view{0, 0, 0}, capture{0, 0, 0};
|
||||||
|
camera_->MatchCaptureSizeRequest(app_->window, &view, &capture);
|
||||||
|
|
||||||
|
ASSERT(view.width && view.height, "Could not find supportable resolution");
|
||||||
|
|
||||||
|
// Request the necessary nativeWindow to OS
|
||||||
|
bool portraitNativeWindow =
|
||||||
|
(savedNativeWinRes_.width < savedNativeWinRes_.height);
|
||||||
|
ANativeWindow_setBuffersGeometry(
|
||||||
|
app_->window, portraitNativeWindow ? view.height : view.width,
|
||||||
|
portraitNativeWindow ? view.width : view.height, WINDOW_FORMAT_RGBA_8888);
|
||||||
|
|
||||||
|
yuvReader_ = new ImageReader(&view, AIMAGE_FORMAT_YUV_420_888);
|
||||||
|
yuvReader_->SetPresentRotation(imageRotation);
|
||||||
|
jpgReader_ = new ImageReader(&capture, AIMAGE_FORMAT_JPEG);
|
||||||
|
jpgReader_->SetPresentRotation(imageRotation);
|
||||||
|
jpgReader_->RegisterCallback(
|
||||||
|
this, [this](void* ctx, const char* str) -> void {
|
||||||
|
reinterpret_cast<CameraEngine*>(ctx)->OnPhotoTaken(str);
|
||||||
|
});
|
||||||
|
|
||||||
|
// now we could create session
|
||||||
|
camera_->CreateSession(yuvReader_->GetNativeWindow(),
|
||||||
|
jpgReader_->GetNativeWindow(), imageRotation);
|
||||||
|
}
|
||||||
|
|
||||||
|
void CameraEngine::DeleteCamera(void) {
|
||||||
|
cameraReady_ = false;
|
||||||
|
if (camera_) {
|
||||||
|
delete camera_;
|
||||||
|
camera_ = nullptr;
|
||||||
|
}
|
||||||
|
if (yuvReader_) {
|
||||||
|
delete yuvReader_;
|
||||||
|
yuvReader_ = nullptr;
|
||||||
|
}
|
||||||
|
if (jpgReader_) {
|
||||||
|
delete jpgReader_;
|
||||||
|
jpgReader_ = nullptr;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initiate a Camera Run-time usage request to Java side implementation
|
||||||
|
* [ The request result will be passed back in function
|
||||||
|
* notifyCameraPermission()]
|
||||||
|
*/
|
||||||
|
void CameraEngine::RequestCameraPermission() {
|
||||||
|
if (!app_) return;
|
||||||
|
|
||||||
|
JNIEnv* env;
|
||||||
|
ANativeActivity* activity = app_->activity;
|
||||||
|
activity->vm->GetEnv((void**)&env, JNI_VERSION_1_6);
|
||||||
|
|
||||||
|
activity->vm->AttachCurrentThread(&env, NULL);
|
||||||
|
|
||||||
|
jobject activityObj = env->NewGlobalRef(activity->clazz);
|
||||||
|
jclass clz = env->GetObjectClass(activityObj);
|
||||||
|
env->CallVoidMethod(activityObj,
|
||||||
|
env->GetMethodID(clz, "RequestCamera", "()V"));
|
||||||
|
env->DeleteGlobalRef(activityObj);
|
||||||
|
|
||||||
|
activity->vm->DetachCurrentThread();
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Process to user's sensitivity and exposure value change
|
||||||
|
* all values are represented in int64_t even exposure is just int32_t
|
||||||
|
* @param code ACAMERA_SENSOR_EXPOSURE_TIME or ACAMERA_SENSOR_SENSITIVITY
|
||||||
|
* @param val corresponding value from user
|
||||||
|
*/
|
||||||
|
void CameraEngine::OnCameraParameterChanged(int32_t code, int64_t val) {
|
||||||
|
camera_->UpdateCameraRequestParameter(code, val);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The main function rendering a frame. In our case, it is yuv to RGBA8888
|
||||||
|
* converter
|
||||||
|
*/
|
||||||
|
void CameraEngine::DrawFrame(void) {
|
||||||
|
if (!cameraReady_ || !yuvReader_) return;
|
||||||
|
AImage* image = yuvReader_->GetNextImage();
|
||||||
|
if (!image) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
ANativeWindow_acquire(app_->window);
|
||||||
|
ANativeWindow_Buffer buf;
|
||||||
|
if (ANativeWindow_lock(app_->window, &buf, nullptr) < 0) {
|
||||||
|
yuvReader_->DeleteImage(image);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
yuvReader_->DisplayImage(&buf, image);
|
||||||
|
ANativeWindow_unlockAndPost(app_->window);
|
||||||
|
ANativeWindow_release(app_->window);
|
||||||
|
}
|
||||||
@ -0,0 +1,81 @@
|
|||||||
|
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2017 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.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef __CAMERA_ENGINE_H__
|
||||||
|
#define __CAMERA_ENGINE_H__
|
||||||
|
|
||||||
|
#include <android/native_window.h>
|
||||||
|
#include <android_native_app_glue.h>
|
||||||
|
|
||||||
|
#include <functional>
|
||||||
|
#include <thread>
|
||||||
|
|
||||||
|
#include "camera_manager.h"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* basic CameraAppEngine
|
||||||
|
*/
|
||||||
|
class CameraEngine {
|
||||||
|
public:
|
||||||
|
explicit CameraEngine(android_app* app);
|
||||||
|
~CameraEngine();
|
||||||
|
|
||||||
|
// Interfaces to android application framework
|
||||||
|
struct android_app* AndroidApp(void) const;
|
||||||
|
void OnAppInitWindow(void);
|
||||||
|
void DrawFrame(void);
|
||||||
|
void OnAppConfigChange(void);
|
||||||
|
void OnAppTermWindow(void);
|
||||||
|
|
||||||
|
// Native Window handlers
|
||||||
|
int32_t GetSavedNativeWinWidth(void);
|
||||||
|
int32_t GetSavedNativeWinHeight(void);
|
||||||
|
int32_t GetSavedNativeWinFormat(void);
|
||||||
|
void SaveNativeWinRes(int32_t w, int32_t h, int32_t format);
|
||||||
|
|
||||||
|
// UI handlers
|
||||||
|
void RequestCameraPermission();
|
||||||
|
void OnCameraPermission(jboolean granted);
|
||||||
|
void EnableUI(void);
|
||||||
|
void OnTakePhoto(void);
|
||||||
|
void OnCameraParameterChanged(int32_t code, int64_t val);
|
||||||
|
|
||||||
|
// Manage NDKCamera Object
|
||||||
|
void CreateCamera(void);
|
||||||
|
void DeleteCamera(void);
|
||||||
|
|
||||||
|
private:
|
||||||
|
void OnPhotoTaken(const char* fileName);
|
||||||
|
int GetDisplayRotation(void);
|
||||||
|
|
||||||
|
struct android_app* app_;
|
||||||
|
ImageFormat savedNativeWinRes_;
|
||||||
|
bool cameraGranted_;
|
||||||
|
int rotation_;
|
||||||
|
volatile bool cameraReady_;
|
||||||
|
NDKCamera* camera_;
|
||||||
|
ImageReader* yuvReader_;
|
||||||
|
ImageReader* jpgReader_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* retrieve global singleton CameraEngine instance
|
||||||
|
* @return the only instance of CameraEngine in the app
|
||||||
|
*/
|
||||||
|
CameraEngine* GetAppEngine(void);
|
||||||
|
|
||||||
|
#endif // __CAMERA_ENGINE_H__
|
||||||
@ -0,0 +1,241 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2017 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 <camera/NdkCameraManager.h>
|
||||||
|
|
||||||
|
#include <cinttypes>
|
||||||
|
#include <queue>
|
||||||
|
#include <thread>
|
||||||
|
#include <utility>
|
||||||
|
|
||||||
|
#include "camera_manager.h"
|
||||||
|
#include "utils/camera_utils.h"
|
||||||
|
#include "utils/native_debug.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Camera Manager Listener object
|
||||||
|
*/
|
||||||
|
void OnCameraAvailable(void* ctx, const char* id) {
|
||||||
|
reinterpret_cast<NDKCamera*>(ctx)->OnCameraStatusChanged(id, true);
|
||||||
|
}
|
||||||
|
void OnCameraUnavailable(void* ctx, const char* id) {
|
||||||
|
reinterpret_cast<NDKCamera*>(ctx)->OnCameraStatusChanged(id, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* OnCameraStatusChanged()
|
||||||
|
* handles Callback from ACameraManager
|
||||||
|
*/
|
||||||
|
void NDKCamera::OnCameraStatusChanged(const char* id, bool available) {
|
||||||
|
if (valid_) {
|
||||||
|
cameras_[std::string(id)].available_ = available ? true : false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Construct a camera manager listener on the fly and return to caller
|
||||||
|
*
|
||||||
|
* @return ACameraManager_AvailabilityCallback
|
||||||
|
*/
|
||||||
|
ACameraManager_AvailabilityCallbacks* NDKCamera::GetManagerListener() {
|
||||||
|
static ACameraManager_AvailabilityCallbacks cameraMgrListener = {
|
||||||
|
.context = this,
|
||||||
|
.onCameraAvailable = ::OnCameraAvailable,
|
||||||
|
.onCameraUnavailable = ::OnCameraUnavailable,
|
||||||
|
};
|
||||||
|
return &cameraMgrListener;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* CameraDevice callbacks
|
||||||
|
*/
|
||||||
|
void OnDeviceStateChanges(void* ctx, ACameraDevice* dev) {
|
||||||
|
reinterpret_cast<NDKCamera*>(ctx)->OnDeviceState(dev);
|
||||||
|
}
|
||||||
|
|
||||||
|
void OnDeviceErrorChanges(void* ctx, ACameraDevice* dev, int err) {
|
||||||
|
reinterpret_cast<NDKCamera*>(ctx)->OnDeviceError(dev, err);
|
||||||
|
}
|
||||||
|
ACameraDevice_stateCallbacks* NDKCamera::GetDeviceListener() {
|
||||||
|
static ACameraDevice_stateCallbacks cameraDeviceListener = {
|
||||||
|
.context = this,
|
||||||
|
.onDisconnected = ::OnDeviceStateChanges,
|
||||||
|
.onError = ::OnDeviceErrorChanges,
|
||||||
|
};
|
||||||
|
return &cameraDeviceListener;
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Handle Camera DeviceStateChanges msg, notify device is disconnected
|
||||||
|
* simply close the camera
|
||||||
|
*/
|
||||||
|
void NDKCamera::OnDeviceState(ACameraDevice* dev) {
|
||||||
|
std::string id(ACameraDevice_getId(dev));
|
||||||
|
LOGW("device %s is disconnected", id.c_str());
|
||||||
|
|
||||||
|
cameras_[id].available_ = false;
|
||||||
|
ACameraDevice_close(cameras_[id].device_);
|
||||||
|
cameras_.erase(id);
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Handles Camera's deviceErrorChanges message, no action;
|
||||||
|
* mainly debugging purpose
|
||||||
|
*
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
void NDKCamera::OnDeviceError(ACameraDevice* dev, int err) {
|
||||||
|
std::string id(ACameraDevice_getId(dev));
|
||||||
|
|
||||||
|
LOGI("CameraDevice %s is in error %#x", id.c_str(), err);
|
||||||
|
PrintCameraDeviceError(err);
|
||||||
|
|
||||||
|
CameraId& cam = cameras_[id];
|
||||||
|
|
||||||
|
switch (err) {
|
||||||
|
case ERROR_CAMERA_IN_USE:
|
||||||
|
cam.available_ = false;
|
||||||
|
cam.owner_ = false;
|
||||||
|
break;
|
||||||
|
case ERROR_CAMERA_SERVICE:
|
||||||
|
case ERROR_CAMERA_DEVICE:
|
||||||
|
case ERROR_CAMERA_DISABLED:
|
||||||
|
case ERROR_MAX_CAMERAS_IN_USE:
|
||||||
|
cam.available_ = false;
|
||||||
|
cam.owner_ = false;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
LOGI("Unknown Camera Device Error: %#x", err);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// CaptureSession state callbacks
|
||||||
|
void OnSessionClosed(void* ctx, ACameraCaptureSession* ses) {
|
||||||
|
LOGW("session %p closed", ses);
|
||||||
|
reinterpret_cast<NDKCamera*>(ctx)->OnSessionState(
|
||||||
|
ses, CaptureSessionState::CLOSED);
|
||||||
|
}
|
||||||
|
void OnSessionReady(void* ctx, ACameraCaptureSession* ses) {
|
||||||
|
LOGW("session %p ready", ses);
|
||||||
|
reinterpret_cast<NDKCamera*>(ctx)->OnSessionState(ses,
|
||||||
|
CaptureSessionState::READY);
|
||||||
|
}
|
||||||
|
void OnSessionActive(void* ctx, ACameraCaptureSession* ses) {
|
||||||
|
LOGW("session %p active", ses);
|
||||||
|
reinterpret_cast<NDKCamera*>(ctx)->OnSessionState(
|
||||||
|
ses, CaptureSessionState::ACTIVE);
|
||||||
|
}
|
||||||
|
|
||||||
|
ACameraCaptureSession_stateCallbacks* NDKCamera::GetSessionListener() {
|
||||||
|
static ACameraCaptureSession_stateCallbacks sessionListener = {
|
||||||
|
.context = this,
|
||||||
|
.onClosed = ::OnSessionClosed,
|
||||||
|
.onReady = ::OnSessionReady,
|
||||||
|
.onActive = ::OnSessionActive,
|
||||||
|
};
|
||||||
|
return &sessionListener;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Handles capture session state changes.
|
||||||
|
* Update into internal session state.
|
||||||
|
*/
|
||||||
|
void NDKCamera::OnSessionState(ACameraCaptureSession* ses,
|
||||||
|
CaptureSessionState state) {
|
||||||
|
if (!ses || ses != captureSession_) {
|
||||||
|
LOGW("CaptureSession is %s", (ses ? "NOT our session" : "NULL"));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
ASSERT(state < CaptureSessionState::MAX_STATE, "Wrong state %d", state);
|
||||||
|
|
||||||
|
captureSessionState_ = state;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Capture callbacks, mostly information purpose
|
||||||
|
void SessionCaptureCallback_OnFailed(void* context,
|
||||||
|
ACameraCaptureSession* session,
|
||||||
|
ACaptureRequest* request,
|
||||||
|
ACameraCaptureFailure* failure) {
|
||||||
|
std::thread captureFailedThread(&NDKCamera::OnCaptureFailed,
|
||||||
|
static_cast<NDKCamera*>(context), session,
|
||||||
|
request, failure);
|
||||||
|
captureFailedThread.detach();
|
||||||
|
}
|
||||||
|
|
||||||
|
void SessionCaptureCallback_OnSequenceEnd(void* context,
|
||||||
|
ACameraCaptureSession* session,
|
||||||
|
int sequenceId, int64_t frameNumber) {
|
||||||
|
std::thread sequenceThread(&NDKCamera::OnCaptureSequenceEnd,
|
||||||
|
static_cast<NDKCamera*>(context), session,
|
||||||
|
sequenceId, frameNumber);
|
||||||
|
sequenceThread.detach();
|
||||||
|
}
|
||||||
|
void SessionCaptureCallback_OnSequenceAborted(void* context,
|
||||||
|
ACameraCaptureSession* session,
|
||||||
|
int sequenceId) {
|
||||||
|
std::thread sequenceThread(&NDKCamera::OnCaptureSequenceEnd,
|
||||||
|
static_cast<NDKCamera*>(context), session,
|
||||||
|
sequenceId, static_cast<int64_t>(-1));
|
||||||
|
sequenceThread.detach();
|
||||||
|
}
|
||||||
|
|
||||||
|
ACameraCaptureSession_captureCallbacks* NDKCamera::GetCaptureCallback() {
|
||||||
|
static ACameraCaptureSession_captureCallbacks captureListener{
|
||||||
|
.context = this,
|
||||||
|
.onCaptureStarted = nullptr,
|
||||||
|
.onCaptureProgressed = nullptr,
|
||||||
|
.onCaptureCompleted = nullptr,
|
||||||
|
.onCaptureFailed = SessionCaptureCallback_OnFailed,
|
||||||
|
.onCaptureSequenceCompleted = SessionCaptureCallback_OnSequenceEnd,
|
||||||
|
.onCaptureSequenceAborted = SessionCaptureCallback_OnSequenceAborted,
|
||||||
|
.onCaptureBufferLost = nullptr,
|
||||||
|
};
|
||||||
|
return &captureListener;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Process JPG capture SessionCaptureCallback_OnFailed event
|
||||||
|
* If this is current JPG capture session, simply resume preview
|
||||||
|
* @param session the capture session that failed
|
||||||
|
* @param request the capture request that failed
|
||||||
|
* @param failure for additional fail info.
|
||||||
|
*/
|
||||||
|
void NDKCamera::OnCaptureFailed(ACameraCaptureSession* session,
|
||||||
|
ACaptureRequest* request,
|
||||||
|
ACameraCaptureFailure* failure) {
|
||||||
|
if (valid_ && request == requests_[JPG_CAPTURE_REQUEST_IDX].request_) {
|
||||||
|
ASSERT(failure->sequenceId ==
|
||||||
|
requests_[JPG_CAPTURE_REQUEST_IDX].sessionSequenceId_,
|
||||||
|
"Error jpg sequence id")
|
||||||
|
StartPreview(true);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Process event from JPEG capture
|
||||||
|
* SessionCaptureCallback_OnSequenceEnd()
|
||||||
|
* SessionCaptureCallback_OnSequenceAborted()
|
||||||
|
*
|
||||||
|
* If this is jpg capture, turn back on preview after a catpure.
|
||||||
|
*/
|
||||||
|
void NDKCamera::OnCaptureSequenceEnd(ACameraCaptureSession* session,
|
||||||
|
int sequenceId, int64_t frameNumber) {
|
||||||
|
if (sequenceId != requests_[JPG_CAPTURE_REQUEST_IDX].sessionSequenceId_)
|
||||||
|
return;
|
||||||
|
|
||||||
|
// resume preview
|
||||||
|
CALL_SESSION(setRepeatingRequest(captureSession_, nullptr, 1,
|
||||||
|
&requests_[PREVIEW_REQUEST_IDX].request_,
|
||||||
|
nullptr));
|
||||||
|
}
|
||||||
@ -0,0 +1,490 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2017 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 "camera_manager.h"
|
||||||
|
|
||||||
|
#include <camera/NdkCameraManager.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
|
||||||
|
#include <cinttypes>
|
||||||
|
#include <queue>
|
||||||
|
#include <utility>
|
||||||
|
|
||||||
|
#include "utils/camera_utils.h"
|
||||||
|
#include "utils/native_debug.h"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Range of Camera Exposure Time:
|
||||||
|
* Camera's capability range have a very long range which may be disturbing
|
||||||
|
* on camera. For this sample purpose, clamp to a range showing visible
|
||||||
|
* video on preview: 100000ns ~ 250000000ns
|
||||||
|
*/
|
||||||
|
static const uint64_t kMinExposureTime = static_cast<uint64_t>(1000000);
|
||||||
|
static const uint64_t kMaxExposureTime = static_cast<uint64_t>(250000000);
|
||||||
|
|
||||||
|
NDKCamera::NDKCamera()
|
||||||
|
: cameraMgr_(nullptr),
|
||||||
|
activeCameraId_(""),
|
||||||
|
cameraFacing_(ACAMERA_LENS_FACING_BACK),
|
||||||
|
cameraOrientation_(0),
|
||||||
|
outputContainer_(nullptr),
|
||||||
|
captureSessionState_(CaptureSessionState::MAX_STATE),
|
||||||
|
exposureTime_(static_cast<int64_t>(0)) {
|
||||||
|
valid_ = false;
|
||||||
|
requests_.resize(CAPTURE_REQUEST_COUNT);
|
||||||
|
memset(requests_.data(), 0, requests_.size() * sizeof(requests_[0]));
|
||||||
|
cameras_.clear();
|
||||||
|
cameraMgr_ = ACameraManager_create();
|
||||||
|
ASSERT(cameraMgr_, "Failed to create cameraManager");
|
||||||
|
|
||||||
|
// Pick up a back-facing camera to preview
|
||||||
|
EnumerateCamera();
|
||||||
|
ASSERT(activeCameraId_.size(), "Unknown ActiveCameraIdx");
|
||||||
|
|
||||||
|
// Create back facing camera device
|
||||||
|
CALL_MGR(openCamera(cameraMgr_, activeCameraId_.c_str(), GetDeviceListener(),
|
||||||
|
&cameras_[activeCameraId_].device_));
|
||||||
|
|
||||||
|
CALL_MGR(registerAvailabilityCallback(cameraMgr_, GetManagerListener()));
|
||||||
|
|
||||||
|
// Initialize camera controls(exposure time and sensitivity), pick
|
||||||
|
// up value of 2% * range + min as starting value (just a number, no magic)
|
||||||
|
ACameraMetadata* metadataObj;
|
||||||
|
CALL_MGR(getCameraCharacteristics(cameraMgr_, activeCameraId_.c_str(),
|
||||||
|
&metadataObj));
|
||||||
|
ACameraMetadata_const_entry val = {
|
||||||
|
0,
|
||||||
|
};
|
||||||
|
camera_status_t status = ACameraMetadata_getConstEntry(
|
||||||
|
metadataObj, ACAMERA_SENSOR_INFO_EXPOSURE_TIME_RANGE, &val);
|
||||||
|
if (status == ACAMERA_OK) {
|
||||||
|
exposureRange_.min_ = val.data.i64[0];
|
||||||
|
if (exposureRange_.min_ < kMinExposureTime) {
|
||||||
|
exposureRange_.min_ = kMinExposureTime;
|
||||||
|
}
|
||||||
|
exposureRange_.max_ = val.data.i64[1];
|
||||||
|
if (exposureRange_.max_ > kMaxExposureTime) {
|
||||||
|
exposureRange_.max_ = kMaxExposureTime;
|
||||||
|
}
|
||||||
|
exposureTime_ = exposureRange_.value(2);
|
||||||
|
} else {
|
||||||
|
LOGW("Unsupported ACAMERA_SENSOR_INFO_EXPOSURE_TIME_RANGE");
|
||||||
|
exposureRange_.min_ = exposureRange_.max_ = 0l;
|
||||||
|
exposureTime_ = 0l;
|
||||||
|
}
|
||||||
|
status = ACameraMetadata_getConstEntry(
|
||||||
|
metadataObj, ACAMERA_SENSOR_INFO_SENSITIVITY_RANGE, &val);
|
||||||
|
|
||||||
|
if (status == ACAMERA_OK) {
|
||||||
|
sensitivityRange_.min_ = val.data.i32[0];
|
||||||
|
sensitivityRange_.max_ = val.data.i32[1];
|
||||||
|
|
||||||
|
sensitivity_ = sensitivityRange_.value(2);
|
||||||
|
} else {
|
||||||
|
LOGW("failed for ACAMERA_SENSOR_INFO_SENSITIVITY_RANGE");
|
||||||
|
sensitivityRange_.min_ = sensitivityRange_.max_ = 0;
|
||||||
|
sensitivity_ = 0;
|
||||||
|
}
|
||||||
|
valid_ = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A helper class to assist image size comparison, by comparing the absolute
|
||||||
|
* size
|
||||||
|
* regardless of the portrait or landscape mode.
|
||||||
|
*/
|
||||||
|
class DisplayDimension {
|
||||||
|
public:
|
||||||
|
DisplayDimension(int32_t w, int32_t h) : w_(w), h_(h), portrait_(false) {
|
||||||
|
if (h > w) {
|
||||||
|
// make it landscape
|
||||||
|
w_ = h;
|
||||||
|
h_ = w;
|
||||||
|
portrait_ = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
DisplayDimension(const DisplayDimension& other) {
|
||||||
|
w_ = other.w_;
|
||||||
|
h_ = other.h_;
|
||||||
|
portrait_ = other.portrait_;
|
||||||
|
}
|
||||||
|
|
||||||
|
DisplayDimension(void) {
|
||||||
|
w_ = 0;
|
||||||
|
h_ = 0;
|
||||||
|
portrait_ = false;
|
||||||
|
}
|
||||||
|
DisplayDimension& operator=(const DisplayDimension& other) {
|
||||||
|
w_ = other.w_;
|
||||||
|
h_ = other.h_;
|
||||||
|
portrait_ = other.portrait_;
|
||||||
|
|
||||||
|
return (*this);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IsSameRatio(DisplayDimension& other) {
|
||||||
|
return (w_ * other.h_ == h_ * other.w_);
|
||||||
|
}
|
||||||
|
bool operator>(DisplayDimension& other) {
|
||||||
|
return (w_ >= other.w_ & h_ >= other.h_);
|
||||||
|
}
|
||||||
|
bool operator==(DisplayDimension& other) {
|
||||||
|
return (w_ == other.w_ && h_ == other.h_ && portrait_ == other.portrait_);
|
||||||
|
}
|
||||||
|
DisplayDimension operator-(DisplayDimension& other) {
|
||||||
|
DisplayDimension delta(w_ - other.w_, h_ - other.h_);
|
||||||
|
return delta;
|
||||||
|
}
|
||||||
|
void Flip(void) { portrait_ = !portrait_; }
|
||||||
|
bool IsPortrait(void) { return portrait_; }
|
||||||
|
int32_t width(void) { return w_; }
|
||||||
|
int32_t height(void) { return h_; }
|
||||||
|
int32_t org_width(void) { return (portrait_ ? h_ : w_); }
|
||||||
|
int32_t org_height(void) { return (portrait_ ? w_ : h_); }
|
||||||
|
|
||||||
|
private:
|
||||||
|
int32_t w_, h_;
|
||||||
|
bool portrait_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Find a compatible camera modes:
|
||||||
|
* 1) the same aspect ration as the native display window, which should be a
|
||||||
|
* rotated version of the physical device
|
||||||
|
* 2) the smallest resolution in the camera mode list
|
||||||
|
* This is to minimize the later color space conversion workload.
|
||||||
|
*/
|
||||||
|
bool NDKCamera::MatchCaptureSizeRequest(ANativeWindow* display,
|
||||||
|
ImageFormat* resView,
|
||||||
|
ImageFormat* resCap) {
|
||||||
|
DisplayDimension disp(ANativeWindow_getWidth(display),
|
||||||
|
ANativeWindow_getHeight(display));
|
||||||
|
if (cameraOrientation_ == 90 || cameraOrientation_ == 270) {
|
||||||
|
disp.Flip();
|
||||||
|
}
|
||||||
|
|
||||||
|
ACameraMetadata* metadata;
|
||||||
|
CALL_MGR(
|
||||||
|
getCameraCharacteristics(cameraMgr_, activeCameraId_.c_str(), &metadata));
|
||||||
|
ACameraMetadata_const_entry entry;
|
||||||
|
CALL_METADATA(getConstEntry(
|
||||||
|
metadata, ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, &entry));
|
||||||
|
// format of the data: format, width, height, input?, type int32
|
||||||
|
bool foundIt = false;
|
||||||
|
DisplayDimension foundRes(4000, 4000);
|
||||||
|
DisplayDimension maxJPG(0, 0);
|
||||||
|
|
||||||
|
for (int i = 0; i < entry.count; i += 4) {
|
||||||
|
int32_t input = entry.data.i32[i + 3];
|
||||||
|
int32_t format = entry.data.i32[i + 0];
|
||||||
|
if (input) continue;
|
||||||
|
|
||||||
|
if (format == AIMAGE_FORMAT_YUV_420_888 || format == AIMAGE_FORMAT_JPEG) {
|
||||||
|
DisplayDimension res(entry.data.i32[i + 1], entry.data.i32[i + 2]);
|
||||||
|
if (!disp.IsSameRatio(res)) continue;
|
||||||
|
if (format == AIMAGE_FORMAT_YUV_420_888 && foundRes > res) {
|
||||||
|
foundIt = true;
|
||||||
|
foundRes = res;
|
||||||
|
} else if (format == AIMAGE_FORMAT_JPEG && res > maxJPG) {
|
||||||
|
maxJPG = res;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (foundIt) {
|
||||||
|
resView->width = foundRes.org_width();
|
||||||
|
resView->height = foundRes.org_height();
|
||||||
|
resCap->width = maxJPG.org_width();
|
||||||
|
resCap->height = maxJPG.org_height();
|
||||||
|
} else {
|
||||||
|
LOGW("Did not find any compatible camera resolution, taking 640x480");
|
||||||
|
if (disp.IsPortrait()) {
|
||||||
|
resView->width = 480;
|
||||||
|
resView->height = 640;
|
||||||
|
} else {
|
||||||
|
resView->width = 640;
|
||||||
|
resView->height = 480;
|
||||||
|
}
|
||||||
|
*resCap = *resView;
|
||||||
|
}
|
||||||
|
resView->format = AIMAGE_FORMAT_YUV_420_888;
|
||||||
|
resCap->format = AIMAGE_FORMAT_JPEG;
|
||||||
|
return foundIt;
|
||||||
|
}
|
||||||
|
|
||||||
|
void NDKCamera::CreateSession(ANativeWindow* previewWindow,
|
||||||
|
ANativeWindow* jpgWindow, int32_t imageRotation) {
|
||||||
|
// Create output from this app's ANativeWindow, and add into output container
|
||||||
|
requests_[PREVIEW_REQUEST_IDX].outputNativeWindow_ = previewWindow;
|
||||||
|
requests_[PREVIEW_REQUEST_IDX].template_ = TEMPLATE_PREVIEW;
|
||||||
|
requests_[JPG_CAPTURE_REQUEST_IDX].outputNativeWindow_ = jpgWindow;
|
||||||
|
requests_[JPG_CAPTURE_REQUEST_IDX].template_ = TEMPLATE_STILL_CAPTURE;
|
||||||
|
|
||||||
|
CALL_CONTAINER(create(&outputContainer_));
|
||||||
|
for (auto& req : requests_) {
|
||||||
|
ANativeWindow_acquire(req.outputNativeWindow_);
|
||||||
|
CALL_OUTPUT(create(req.outputNativeWindow_, &req.sessionOutput_));
|
||||||
|
CALL_CONTAINER(add(outputContainer_, req.sessionOutput_));
|
||||||
|
CALL_TARGET(create(req.outputNativeWindow_, &req.target_));
|
||||||
|
CALL_DEV(createCaptureRequest(cameras_[activeCameraId_].device_,
|
||||||
|
req.template_, &req.request_));
|
||||||
|
CALL_REQUEST(addTarget(req.request_, req.target_));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Create a capture session for the given preview request
|
||||||
|
captureSessionState_ = CaptureSessionState::READY;
|
||||||
|
CALL_DEV(createCaptureSession(cameras_[activeCameraId_].device_,
|
||||||
|
outputContainer_, GetSessionListener(),
|
||||||
|
&captureSession_));
|
||||||
|
|
||||||
|
ACaptureRequest_setEntry_i32(requests_[JPG_CAPTURE_REQUEST_IDX].request_,
|
||||||
|
ACAMERA_JPEG_ORIENTATION, 1, &imageRotation);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Only preview request is in manual mode, JPG is always in Auto mode
|
||||||
|
* JPG capture mode could also be switch into manual mode and control
|
||||||
|
* the capture parameters, this sample leaves JPG capture to be auto mode
|
||||||
|
* (auto control has better effect than author's manual control)
|
||||||
|
*/
|
||||||
|
uint8_t aeModeOff = ACAMERA_CONTROL_AE_MODE_OFF;
|
||||||
|
CALL_REQUEST(setEntry_u8(requests_[PREVIEW_REQUEST_IDX].request_,
|
||||||
|
ACAMERA_CONTROL_AE_MODE, 1, &aeModeOff));
|
||||||
|
CALL_REQUEST(setEntry_i32(requests_[PREVIEW_REQUEST_IDX].request_,
|
||||||
|
ACAMERA_SENSOR_SENSITIVITY, 1, &sensitivity_));
|
||||||
|
CALL_REQUEST(setEntry_i64(requests_[PREVIEW_REQUEST_IDX].request_,
|
||||||
|
ACAMERA_SENSOR_EXPOSURE_TIME, 1, &exposureTime_));
|
||||||
|
}
|
||||||
|
|
||||||
|
NDKCamera::~NDKCamera() {
|
||||||
|
valid_ = false;
|
||||||
|
// stop session if it is on:
|
||||||
|
if (captureSessionState_ == CaptureSessionState::ACTIVE) {
|
||||||
|
ACameraCaptureSession_stopRepeating(captureSession_);
|
||||||
|
}
|
||||||
|
ACameraCaptureSession_close(captureSession_);
|
||||||
|
|
||||||
|
for (auto& req : requests_) {
|
||||||
|
CALL_REQUEST(removeTarget(req.request_, req.target_));
|
||||||
|
ACaptureRequest_free(req.request_);
|
||||||
|
ACameraOutputTarget_free(req.target_);
|
||||||
|
|
||||||
|
CALL_CONTAINER(remove(outputContainer_, req.sessionOutput_));
|
||||||
|
ACaptureSessionOutput_free(req.sessionOutput_);
|
||||||
|
|
||||||
|
ANativeWindow_release(req.outputNativeWindow_);
|
||||||
|
}
|
||||||
|
|
||||||
|
requests_.resize(0);
|
||||||
|
ACaptureSessionOutputContainer_free(outputContainer_);
|
||||||
|
|
||||||
|
for (auto& cam : cameras_) {
|
||||||
|
if (cam.second.device_) {
|
||||||
|
CALL_DEV(close(cam.second.device_));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
cameras_.clear();
|
||||||
|
if (cameraMgr_) {
|
||||||
|
CALL_MGR(unregisterAvailabilityCallback(cameraMgr_, GetManagerListener()));
|
||||||
|
ACameraManager_delete(cameraMgr_);
|
||||||
|
cameraMgr_ = nullptr;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* EnumerateCamera()
|
||||||
|
* Loop through cameras on the system, pick up
|
||||||
|
* 1) back facing one if available
|
||||||
|
* 2) otherwise pick the first one reported to us
|
||||||
|
*/
|
||||||
|
void NDKCamera::EnumerateCamera() {
|
||||||
|
ACameraIdList* cameraIds = nullptr;
|
||||||
|
CALL_MGR(getCameraIdList(cameraMgr_, &cameraIds));
|
||||||
|
|
||||||
|
for (int i = 0; i < cameraIds->numCameras; ++i) {
|
||||||
|
const char* id = cameraIds->cameraIds[i];
|
||||||
|
|
||||||
|
ACameraMetadata* metadataObj;
|
||||||
|
CALL_MGR(getCameraCharacteristics(cameraMgr_, id, &metadataObj));
|
||||||
|
|
||||||
|
int32_t count = 0;
|
||||||
|
const uint32_t* tags = nullptr;
|
||||||
|
ACameraMetadata_getAllTags(metadataObj, &count, &tags);
|
||||||
|
for (int tagIdx = 0; tagIdx < count; ++tagIdx) {
|
||||||
|
if (ACAMERA_LENS_FACING == tags[tagIdx]) {
|
||||||
|
ACameraMetadata_const_entry lensInfo = {
|
||||||
|
0,
|
||||||
|
};
|
||||||
|
CALL_METADATA(getConstEntry(metadataObj, tags[tagIdx], &lensInfo));
|
||||||
|
CameraId cam(id);
|
||||||
|
cam.facing_ = static_cast<acamera_metadata_enum_android_lens_facing_t>(
|
||||||
|
lensInfo.data.u8[0]);
|
||||||
|
cam.owner_ = false;
|
||||||
|
cam.device_ = nullptr;
|
||||||
|
cameras_[cam.id_] = cam;
|
||||||
|
if (cam.facing_ == ACAMERA_LENS_FACING_BACK) {
|
||||||
|
activeCameraId_ = cam.id_;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ACameraMetadata_free(metadataObj);
|
||||||
|
}
|
||||||
|
|
||||||
|
ASSERT(cameras_.size(), "No Camera Available on the device");
|
||||||
|
if (activeCameraId_.length() == 0) {
|
||||||
|
// if no back facing camera found, pick up the first one to use...
|
||||||
|
activeCameraId_ = cameras_.begin()->second.id_;
|
||||||
|
}
|
||||||
|
// activeCameraId_ = cameras_.rbegin()->second.id_;
|
||||||
|
|
||||||
|
ACameraManager_deleteCameraIdList(cameraIds);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* GetSensorOrientation()
|
||||||
|
* Retrieve current sensor orientation regarding to the phone device
|
||||||
|
* orientation
|
||||||
|
* SensorOrientation is NOT settable.
|
||||||
|
*/
|
||||||
|
bool NDKCamera::GetSensorOrientation(int32_t* facing, int32_t* angle) {
|
||||||
|
if (!cameraMgr_) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
ACameraMetadata* metadataObj;
|
||||||
|
ACameraMetadata_const_entry face, orientation;
|
||||||
|
CALL_MGR(getCameraCharacteristics(cameraMgr_, activeCameraId_.c_str(),
|
||||||
|
&metadataObj));
|
||||||
|
CALL_METADATA(getConstEntry(metadataObj, ACAMERA_LENS_FACING, &face));
|
||||||
|
cameraFacing_ = static_cast<int32_t>(face.data.u8[0]);
|
||||||
|
|
||||||
|
CALL_METADATA(
|
||||||
|
getConstEntry(metadataObj, ACAMERA_SENSOR_ORIENTATION, &orientation));
|
||||||
|
|
||||||
|
LOGI("====Current SENSOR_ORIENTATION: %8d", orientation.data.i32[0]);
|
||||||
|
|
||||||
|
ACameraMetadata_free(metadataObj);
|
||||||
|
cameraOrientation_ = orientation.data.i32[0];
|
||||||
|
|
||||||
|
if (facing) *facing = cameraFacing_;
|
||||||
|
if (angle) *angle = cameraOrientation_;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* StartPreview()
|
||||||
|
* Toggle preview start/stop
|
||||||
|
*/
|
||||||
|
void NDKCamera::StartPreview(bool start) {
|
||||||
|
if (start) {
|
||||||
|
CALL_SESSION(setRepeatingRequest(captureSession_, nullptr, 1,
|
||||||
|
&requests_[PREVIEW_REQUEST_IDX].request_,
|
||||||
|
nullptr));
|
||||||
|
} else if (!start && captureSessionState_ == CaptureSessionState::ACTIVE) {
|
||||||
|
ACameraCaptureSession_stopRepeating(captureSession_);
|
||||||
|
} else {
|
||||||
|
ASSERT(false, "Conflict states(%s, %d)", (start ? "true" : "false"),
|
||||||
|
captureSessionState_);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Capture one jpg photo into
|
||||||
|
* /sdcard/DCIM/Camera
|
||||||
|
* refer to WriteFile() for details
|
||||||
|
*/
|
||||||
|
bool NDKCamera::TakePhoto(void) {
|
||||||
|
if (captureSessionState_ == CaptureSessionState::ACTIVE) {
|
||||||
|
ACameraCaptureSession_stopRepeating(captureSession_);
|
||||||
|
}
|
||||||
|
|
||||||
|
CALL_SESSION(capture(captureSession_, GetCaptureCallback(), 1,
|
||||||
|
&requests_[JPG_CAPTURE_REQUEST_IDX].request_,
|
||||||
|
&requests_[JPG_CAPTURE_REQUEST_IDX].sessionSequenceId_));
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void NDKCamera::UpdateCameraRequestParameter(int32_t code, int64_t val) {
|
||||||
|
ACaptureRequest* request = requests_[PREVIEW_REQUEST_IDX].request_;
|
||||||
|
switch (code) {
|
||||||
|
case ACAMERA_SENSOR_EXPOSURE_TIME:
|
||||||
|
if (exposureRange_.Supported()) {
|
||||||
|
exposureTime_ = val;
|
||||||
|
CALL_REQUEST(setEntry_i64(request, ACAMERA_SENSOR_EXPOSURE_TIME, 1,
|
||||||
|
&exposureTime_));
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case ACAMERA_SENSOR_SENSITIVITY:
|
||||||
|
if (sensitivityRange_.Supported()) {
|
||||||
|
sensitivity_ = val;
|
||||||
|
CALL_REQUEST(setEntry_i32(request, ACAMERA_SENSOR_SENSITIVITY, 1,
|
||||||
|
&sensitivity_));
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
ASSERT(false, "==ERROR==: error code for CameraParameterChange: %d",
|
||||||
|
code);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t aeModeOff = ACAMERA_CONTROL_AE_MODE_OFF;
|
||||||
|
CALL_REQUEST(setEntry_u8(request, ACAMERA_CONTROL_AE_MODE, 1, &aeModeOff));
|
||||||
|
CALL_SESSION(
|
||||||
|
setRepeatingRequest(captureSession_, nullptr, 1, &request,
|
||||||
|
&requests_[PREVIEW_REQUEST_IDX].sessionSequenceId_));
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieve Camera Exposure adjustable range.
|
||||||
|
*
|
||||||
|
* @param min Camera minimium exposure time in nanoseconds
|
||||||
|
* @param max Camera maximum exposure tiem in nanoseconds
|
||||||
|
*
|
||||||
|
* @return true min and max are loaded with the camera's exposure values
|
||||||
|
* false camera has not initialized, no value available
|
||||||
|
*/
|
||||||
|
bool NDKCamera::GetExposureRange(int64_t* min, int64_t* max, int64_t* curVal) {
|
||||||
|
if (!exposureRange_.Supported() || !exposureTime_ || !min || !max ||
|
||||||
|
!curVal) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
*min = exposureRange_.min_;
|
||||||
|
*max = exposureRange_.max_;
|
||||||
|
*curVal = exposureTime_;
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieve Camera sensitivity range.
|
||||||
|
*
|
||||||
|
* @param min Camera minimium sensitivity
|
||||||
|
* @param max Camera maximum sensitivity
|
||||||
|
*
|
||||||
|
* @return true min and max are loaded with the camera's sensitivity values
|
||||||
|
* false camera has not initialized, no value available
|
||||||
|
*/
|
||||||
|
bool NDKCamera::GetSensitivityRange(int64_t* min, int64_t* max,
|
||||||
|
int64_t* curVal) {
|
||||||
|
if (!sensitivityRange_.Supported() || !sensitivity_ || !min || !max ||
|
||||||
|
!curVal) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
*min = static_cast<int64_t>(sensitivityRange_.min_);
|
||||||
|
*max = static_cast<int64_t>(sensitivityRange_.max_);
|
||||||
|
*curVal = sensitivity_;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
@ -0,0 +1,139 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2017 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.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CAMERA_NATIVE_CAMERA_H
|
||||||
|
#define CAMERA_NATIVE_CAMERA_H
|
||||||
|
#include <camera/NdkCameraDevice.h>
|
||||||
|
#include <camera/NdkCameraError.h>
|
||||||
|
#include <camera/NdkCameraManager.h>
|
||||||
|
#include <camera/NdkCameraMetadataTags.h>
|
||||||
|
|
||||||
|
#include <map>
|
||||||
|
#include <string>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
#include "image_reader.h"
|
||||||
|
|
||||||
|
enum class CaptureSessionState : int32_t {
|
||||||
|
READY = 0, // session is ready
|
||||||
|
ACTIVE, // session is busy
|
||||||
|
CLOSED, // session is closed(by itself or a new session evicts)
|
||||||
|
MAX_STATE
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
class RangeValue {
|
||||||
|
public:
|
||||||
|
T min_, max_;
|
||||||
|
/**
|
||||||
|
* return absolute value from relative value
|
||||||
|
* value: in percent (50 for 50%)
|
||||||
|
*/
|
||||||
|
T value(int percent) {
|
||||||
|
return static_cast<T>(min_ + (max_ - min_) * percent / 100);
|
||||||
|
}
|
||||||
|
RangeValue() { min_ = max_ = static_cast<T>(0); }
|
||||||
|
|
||||||
|
bool Supported(void) const { return (min_ != max_); }
|
||||||
|
};
|
||||||
|
|
||||||
|
enum PREVIEW_INDICES {
|
||||||
|
PREVIEW_REQUEST_IDX = 0,
|
||||||
|
JPG_CAPTURE_REQUEST_IDX,
|
||||||
|
CAPTURE_REQUEST_COUNT,
|
||||||
|
};
|
||||||
|
|
||||||
|
struct CaptureRequestInfo {
|
||||||
|
ANativeWindow* outputNativeWindow_;
|
||||||
|
ACaptureSessionOutput* sessionOutput_;
|
||||||
|
ACameraOutputTarget* target_;
|
||||||
|
ACaptureRequest* request_;
|
||||||
|
ACameraDevice_request_template template_;
|
||||||
|
int sessionSequenceId_;
|
||||||
|
};
|
||||||
|
|
||||||
|
class CameraId;
|
||||||
|
class NDKCamera {
|
||||||
|
private:
|
||||||
|
ACameraManager* cameraMgr_;
|
||||||
|
std::map<std::string, CameraId> cameras_;
|
||||||
|
std::string activeCameraId_;
|
||||||
|
uint32_t cameraFacing_;
|
||||||
|
uint32_t cameraOrientation_;
|
||||||
|
|
||||||
|
std::vector<CaptureRequestInfo> requests_;
|
||||||
|
|
||||||
|
ACaptureSessionOutputContainer* outputContainer_;
|
||||||
|
ACameraCaptureSession* captureSession_;
|
||||||
|
CaptureSessionState captureSessionState_;
|
||||||
|
|
||||||
|
// set up exposure control
|
||||||
|
int64_t exposureTime_;
|
||||||
|
RangeValue<int64_t> exposureRange_;
|
||||||
|
int32_t sensitivity_;
|
||||||
|
RangeValue<int32_t> sensitivityRange_;
|
||||||
|
volatile bool valid_;
|
||||||
|
|
||||||
|
ACameraManager_AvailabilityCallbacks* GetManagerListener();
|
||||||
|
ACameraDevice_stateCallbacks* GetDeviceListener();
|
||||||
|
ACameraCaptureSession_stateCallbacks* GetSessionListener();
|
||||||
|
ACameraCaptureSession_captureCallbacks* GetCaptureCallback();
|
||||||
|
|
||||||
|
public:
|
||||||
|
NDKCamera();
|
||||||
|
~NDKCamera();
|
||||||
|
void EnumerateCamera(void);
|
||||||
|
bool MatchCaptureSizeRequest(ANativeWindow* display, ImageFormat* view,
|
||||||
|
ImageFormat* capture);
|
||||||
|
void CreateSession(ANativeWindow* previewWindow, ANativeWindow* jpgWindow,
|
||||||
|
int32_t imageRotation);
|
||||||
|
bool GetSensorOrientation(int32_t* facing, int32_t* angle);
|
||||||
|
void OnCameraStatusChanged(const char* id, bool available);
|
||||||
|
void OnDeviceState(ACameraDevice* dev);
|
||||||
|
void OnDeviceError(ACameraDevice* dev, int err);
|
||||||
|
void OnSessionState(ACameraCaptureSession* ses, CaptureSessionState state);
|
||||||
|
void OnCaptureSequenceEnd(ACameraCaptureSession* session, int sequenceId,
|
||||||
|
int64_t frameNumber);
|
||||||
|
void OnCaptureFailed(ACameraCaptureSession* session, ACaptureRequest* request,
|
||||||
|
ACameraCaptureFailure* failure);
|
||||||
|
void StartPreview(bool start);
|
||||||
|
bool TakePhoto(void);
|
||||||
|
bool GetExposureRange(int64_t* min, int64_t* max, int64_t* curVal);
|
||||||
|
bool GetSensitivityRange(int64_t* min, int64_t* max, int64_t* curVal);
|
||||||
|
|
||||||
|
void UpdateCameraRequestParameter(int32_t code, int64_t val);
|
||||||
|
};
|
||||||
|
|
||||||
|
// helper classes to hold enumerated camera
|
||||||
|
class CameraId {
|
||||||
|
public:
|
||||||
|
ACameraDevice* device_;
|
||||||
|
std::string id_;
|
||||||
|
acamera_metadata_enum_android_lens_facing_t facing_;
|
||||||
|
bool available_; // free to use ( no other apps are using
|
||||||
|
bool owner_; // we are the owner of the camera
|
||||||
|
explicit CameraId(const char* id)
|
||||||
|
: device_(nullptr),
|
||||||
|
facing_(ACAMERA_LENS_FACING_FRONT),
|
||||||
|
available_(false),
|
||||||
|
owner_(false) {
|
||||||
|
id_ = id;
|
||||||
|
}
|
||||||
|
|
||||||
|
explicit CameraId(void) { CameraId(""); }
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // CAMERA_NATIVE_CAMERA_H
|
||||||
@ -0,0 +1,156 @@
|
|||||||
|
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2017 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 <utils/native_debug.h>
|
||||||
|
|
||||||
|
#include "camera_engine.h"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieve current rotation from Java side
|
||||||
|
*
|
||||||
|
* @return current rotation angle
|
||||||
|
*/
|
||||||
|
int CameraEngine::GetDisplayRotation() {
|
||||||
|
ASSERT(app_, "Application is not initialized");
|
||||||
|
|
||||||
|
JNIEnv *env;
|
||||||
|
ANativeActivity *activity = app_->activity;
|
||||||
|
activity->vm->GetEnv((void **)&env, JNI_VERSION_1_6);
|
||||||
|
|
||||||
|
activity->vm->AttachCurrentThread(&env, NULL);
|
||||||
|
|
||||||
|
jobject activityObj = env->NewGlobalRef(activity->clazz);
|
||||||
|
jclass clz = env->GetObjectClass(activityObj);
|
||||||
|
jint newOrientation = env->CallIntMethod(
|
||||||
|
activityObj, env->GetMethodID(clz, "getRotationDegree", "()I"));
|
||||||
|
env->DeleteGlobalRef(activityObj);
|
||||||
|
|
||||||
|
activity->vm->DetachCurrentThread();
|
||||||
|
return newOrientation;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializate UI on Java side. The 2 seekBars' values are passed in
|
||||||
|
* array in the tuple of ( min, max, curVal )
|
||||||
|
* 0: exposure min
|
||||||
|
* 1: exposure max
|
||||||
|
* 2: exposure val
|
||||||
|
* 3: sensitivity min
|
||||||
|
* 4: sensitivity max
|
||||||
|
* 5: sensitivity val
|
||||||
|
*/
|
||||||
|
const int kInitDataLen = 6;
|
||||||
|
void CameraEngine::EnableUI(void) {
|
||||||
|
JNIEnv *jni;
|
||||||
|
app_->activity->vm->AttachCurrentThread(&jni, NULL);
|
||||||
|
int64_t range[3];
|
||||||
|
|
||||||
|
// Default class retrieval
|
||||||
|
jclass clazz = jni->GetObjectClass(app_->activity->clazz);
|
||||||
|
jmethodID methodID = jni->GetMethodID(clazz, "EnableUI", "([J)V");
|
||||||
|
jlongArray initData = jni->NewLongArray(kInitDataLen);
|
||||||
|
|
||||||
|
ASSERT(initData && methodID, "JavaUI interface Object failed(%p, %p)",
|
||||||
|
methodID, initData);
|
||||||
|
|
||||||
|
if (!camera_->GetExposureRange(&range[0], &range[1], &range[2])) {
|
||||||
|
memset(range, 0, sizeof(int64_t) * 3);
|
||||||
|
}
|
||||||
|
|
||||||
|
jni->SetLongArrayRegion(initData, 0, 3, range);
|
||||||
|
|
||||||
|
if (!camera_->GetSensitivityRange(&range[0], &range[1], &range[2])) {
|
||||||
|
memset(range, 0, sizeof(int64_t) * 3);
|
||||||
|
}
|
||||||
|
jni->SetLongArrayRegion(initData, 3, 3, range);
|
||||||
|
jni->CallVoidMethod(app_->activity->clazz, methodID, initData);
|
||||||
|
app_->activity->vm->DetachCurrentThread();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Handles UI request to take a photo into
|
||||||
|
* /sdcard/DCIM/Camera
|
||||||
|
*/
|
||||||
|
void CameraEngine::OnTakePhoto() {
|
||||||
|
if (camera_) {
|
||||||
|
camera_->TakePhoto();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void CameraEngine::OnPhotoTaken(const char *fileName) {
|
||||||
|
JNIEnv *jni;
|
||||||
|
app_->activity->vm->AttachCurrentThread(&jni, NULL);
|
||||||
|
|
||||||
|
// Default class retrieval
|
||||||
|
jclass clazz = jni->GetObjectClass(app_->activity->clazz);
|
||||||
|
jmethodID methodID =
|
||||||
|
jni->GetMethodID(clazz, "OnPhotoTaken", "(Ljava/lang/String;)V");
|
||||||
|
jstring javaName = jni->NewStringUTF(fileName);
|
||||||
|
|
||||||
|
jni->CallVoidMethod(app_->activity->clazz, methodID, javaName);
|
||||||
|
app_->activity->vm->DetachCurrentThread();
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* Process user camera and disk writing permission
|
||||||
|
* Resume application initialization after user granted camera and disk usage
|
||||||
|
* If user denied permission, do nothing: no camera
|
||||||
|
*
|
||||||
|
* @param granted user's authorization for camera and disk usage.
|
||||||
|
* @return none
|
||||||
|
*/
|
||||||
|
void CameraEngine::OnCameraPermission(jboolean granted) {
|
||||||
|
cameraGranted_ = (granted != JNI_FALSE);
|
||||||
|
|
||||||
|
if (cameraGranted_) {
|
||||||
|
OnAppInitWindow();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A couple UI handles ( from UI )
|
||||||
|
* user camera and disk permission
|
||||||
|
* exposure and sensitivity SeekBars
|
||||||
|
* takePhoto button
|
||||||
|
*/
|
||||||
|
extern "C" JNIEXPORT void JNICALL
|
||||||
|
Java_com_sample_camera_basic_CameraActivity_notifyCameraPermission(
|
||||||
|
JNIEnv *env, jclass type, jboolean permission) {
|
||||||
|
std::thread permissionHandler(&CameraEngine::OnCameraPermission,
|
||||||
|
GetAppEngine(), permission);
|
||||||
|
permissionHandler.detach();
|
||||||
|
}
|
||||||
|
|
||||||
|
extern "C" JNIEXPORT void JNICALL
|
||||||
|
Java_com_sample_camera_basic_CameraActivity_TakePhoto(JNIEnv *env,
|
||||||
|
jclass type) {
|
||||||
|
std::thread takePhotoHandler(&CameraEngine::OnTakePhoto, GetAppEngine());
|
||||||
|
takePhotoHandler.detach();
|
||||||
|
}
|
||||||
|
|
||||||
|
extern "C" JNIEXPORT void JNICALL
|
||||||
|
Java_com_sample_camera_basic_CameraActivity_OnExposureChanged(
|
||||||
|
JNIEnv *env, jobject instance, jlong exposurePercent) {
|
||||||
|
GetAppEngine()->OnCameraParameterChanged(ACAMERA_SENSOR_EXPOSURE_TIME,
|
||||||
|
exposurePercent);
|
||||||
|
}
|
||||||
|
|
||||||
|
extern "C" JNIEXPORT void JNICALL
|
||||||
|
Java_com_sample_camera_basic_CameraActivity_OnSensitivityChanged(
|
||||||
|
JNIEnv *env, jobject instance, jlong sensitivity) {
|
||||||
|
GetAppEngine()->OnCameraParameterChanged(ACAMERA_SENSOR_SENSITIVITY,
|
||||||
|
sensitivity);
|
||||||
|
}
|
||||||
@ -0,0 +1,459 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2017 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 "image_reader.h"
|
||||||
|
|
||||||
|
#include <dirent.h>
|
||||||
|
|
||||||
|
#include <cstdlib>
|
||||||
|
#include <ctime>
|
||||||
|
#include <functional>
|
||||||
|
#include <string>
|
||||||
|
#include <thread>
|
||||||
|
|
||||||
|
#include "utils/native_debug.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
* For JPEG capture, captured files are saved under
|
||||||
|
* DirName
|
||||||
|
* File names are incrementally appended an index number as
|
||||||
|
* capture0.jpg, capture1.jpg, capture2.jpg
|
||||||
|
*/
|
||||||
|
static const char *kDirName = "/sdcard/DCIM/Camera/";
|
||||||
|
static const char *kFileName = "capture";
|
||||||
|
|
||||||
|
/**
|
||||||
|
* MAX_BUF_COUNT:
|
||||||
|
* Max buffers in this ImageReader.
|
||||||
|
*/
|
||||||
|
#define MAX_BUF_COUNT 4
|
||||||
|
|
||||||
|
/**
|
||||||
|
* ImageReader listener: called by AImageReader for every frame captured
|
||||||
|
* We pass the event to ImageReader class, so it could do some housekeeping
|
||||||
|
* about
|
||||||
|
* the loaded queue. For example, we could keep a counter to track how many
|
||||||
|
* buffers are full and idle in the queue. If camera almost has no buffer to
|
||||||
|
* capture
|
||||||
|
* we could release ( skip ) some frames by AImageReader_getNextImage() and
|
||||||
|
* AImageReader_delete().
|
||||||
|
*/
|
||||||
|
void OnImageCallback(void *ctx, AImageReader *reader) {
|
||||||
|
reinterpret_cast<ImageReader *>(ctx)->ImageCallback(reader);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Constructor
|
||||||
|
*/
|
||||||
|
ImageReader::ImageReader(ImageFormat *res, enum AIMAGE_FORMATS format)
|
||||||
|
: presentRotation_(0), reader_(nullptr) {
|
||||||
|
callback_ = nullptr;
|
||||||
|
callbackCtx_ = nullptr;
|
||||||
|
|
||||||
|
media_status_t status = AImageReader_new(res->width, res->height, format,
|
||||||
|
MAX_BUF_COUNT, &reader_);
|
||||||
|
ASSERT(reader_ && status == AMEDIA_OK, "Failed to create AImageReader");
|
||||||
|
|
||||||
|
AImageReader_ImageListener listener{
|
||||||
|
.context = this,
|
||||||
|
.onImageAvailable = OnImageCallback,
|
||||||
|
};
|
||||||
|
AImageReader_setImageListener(reader_, &listener);
|
||||||
|
}
|
||||||
|
|
||||||
|
ImageReader::~ImageReader() {
|
||||||
|
ASSERT(reader_, "NULL Pointer to %s", __FUNCTION__);
|
||||||
|
AImageReader_delete(reader_);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ImageReader::RegisterCallback(
|
||||||
|
void *ctx, std::function<void(void *ctx, const char *fileName)> func) {
|
||||||
|
callbackCtx_ = ctx;
|
||||||
|
callback_ = func;
|
||||||
|
}
|
||||||
|
|
||||||
|
void ImageReader::ImageCallback(AImageReader *reader) {
|
||||||
|
int32_t format;
|
||||||
|
media_status_t status = AImageReader_getFormat(reader, &format);
|
||||||
|
ASSERT(status == AMEDIA_OK, "Failed to get the media format");
|
||||||
|
if (format == AIMAGE_FORMAT_JPEG) {
|
||||||
|
AImage *image = nullptr;
|
||||||
|
media_status_t status = AImageReader_acquireNextImage(reader, &image);
|
||||||
|
ASSERT(status == AMEDIA_OK && image, "Image is not available");
|
||||||
|
|
||||||
|
// Create a thread and write out the jpeg files
|
||||||
|
std::thread writeFileHandler(&ImageReader::WriteFile, this, image);
|
||||||
|
writeFileHandler.detach();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ANativeWindow *ImageReader::GetNativeWindow(void) {
|
||||||
|
if (!reader_) return nullptr;
|
||||||
|
ANativeWindow *nativeWindow;
|
||||||
|
media_status_t status = AImageReader_getWindow(reader_, &nativeWindow);
|
||||||
|
ASSERT(status == AMEDIA_OK, "Could not get ANativeWindow");
|
||||||
|
|
||||||
|
return nativeWindow;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* GetNextImage()
|
||||||
|
* Retrieve the next image in ImageReader's bufferQueue, NOT the last image so
|
||||||
|
* no image is skipped. Recommended for batch/background processing.
|
||||||
|
*/
|
||||||
|
AImage *ImageReader::GetNextImage(void) {
|
||||||
|
AImage *image;
|
||||||
|
media_status_t status = AImageReader_acquireNextImage(reader_, &image);
|
||||||
|
if (status != AMEDIA_OK) {
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
return image;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* GetLatestImage()
|
||||||
|
* Retrieve the last image in ImageReader's bufferQueue, deleting images in
|
||||||
|
* in front of it on the queue. Recommended for real-time processing.
|
||||||
|
*/
|
||||||
|
AImage *ImageReader::GetLatestImage(void) {
|
||||||
|
AImage *image;
|
||||||
|
media_status_t status = AImageReader_acquireLatestImage(reader_, &image);
|
||||||
|
if (status != AMEDIA_OK) {
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
return image;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Delete Image
|
||||||
|
* @param image {@link AImage} instance to be deleted
|
||||||
|
*/
|
||||||
|
void ImageReader::DeleteImage(AImage *image) {
|
||||||
|
if (image) AImage_delete(image);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Helper function for YUV_420 to RGB conversion. Courtesy of Tensorflow
|
||||||
|
* ImageClassifier Sample:
|
||||||
|
* https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/android/jni/yuv2rgb.cc
|
||||||
|
* The difference is that here we have to swap UV plane when calling it.
|
||||||
|
*/
|
||||||
|
#ifndef MAX
|
||||||
|
#define MAX(a, b) \
|
||||||
|
({ \
|
||||||
|
__typeof__(a) _a = (a); \
|
||||||
|
__typeof__(b) _b = (b); \
|
||||||
|
_a > _b ? _a : _b; \
|
||||||
|
})
|
||||||
|
#define MIN(a, b) \
|
||||||
|
({ \
|
||||||
|
__typeof__(a) _a = (a); \
|
||||||
|
__typeof__(b) _b = (b); \
|
||||||
|
_a < _b ? _a : _b; \
|
||||||
|
})
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// This value is 2 ^ 18 - 1, and is used to clamp the RGB values before their
|
||||||
|
// ranges
|
||||||
|
// are normalized to eight bits.
|
||||||
|
static const int kMaxChannelValue = 262143;
|
||||||
|
|
||||||
|
static inline uint32_t YUV2RGB(int nY, int nU, int nV) {
|
||||||
|
nY -= 16;
|
||||||
|
nU -= 128;
|
||||||
|
nV -= 128;
|
||||||
|
if (nY < 0) nY = 0;
|
||||||
|
|
||||||
|
// This is the floating point equivalent. We do the conversion in integer
|
||||||
|
// because some Android devices do not have floating point in hardware.
|
||||||
|
// nR = (int)(1.164 * nY + 1.596 * nV);
|
||||||
|
// nG = (int)(1.164 * nY - 0.813 * nV - 0.391 * nU);
|
||||||
|
// nB = (int)(1.164 * nY + 2.018 * nU);
|
||||||
|
|
||||||
|
int nR = (int)(1192 * nY + 1634 * nV);
|
||||||
|
int nG = (int)(1192 * nY - 833 * nV - 400 * nU);
|
||||||
|
int nB = (int)(1192 * nY + 2066 * nU);
|
||||||
|
|
||||||
|
nR = MIN(kMaxChannelValue, MAX(0, nR));
|
||||||
|
nG = MIN(kMaxChannelValue, MAX(0, nG));
|
||||||
|
nB = MIN(kMaxChannelValue, MAX(0, nB));
|
||||||
|
|
||||||
|
nR = (nR >> 10) & 0xff;
|
||||||
|
nG = (nG >> 10) & 0xff;
|
||||||
|
nB = (nB >> 10) & 0xff;
|
||||||
|
|
||||||
|
return 0xff000000 | (nR << 16) | (nG << 8) | nB;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Convert yuv image inside AImage into ANativeWindow_Buffer
|
||||||
|
* ANativeWindow_Buffer format is guaranteed to be
|
||||||
|
* WINDOW_FORMAT_RGBX_8888
|
||||||
|
* WINDOW_FORMAT_RGBA_8888
|
||||||
|
* @param buf a {@link ANativeWindow_Buffer } instance, destination of
|
||||||
|
* image conversion
|
||||||
|
* @param image a {@link AImage} instance, source of image conversion.
|
||||||
|
* it will be deleted via {@link AImage_delete}
|
||||||
|
*/
|
||||||
|
bool ImageReader::DisplayImage(ANativeWindow_Buffer *buf, AImage *image) {
|
||||||
|
ASSERT(buf->format == WINDOW_FORMAT_RGBX_8888 ||
|
||||||
|
buf->format == WINDOW_FORMAT_RGBA_8888,
|
||||||
|
"Not supported buffer format");
|
||||||
|
|
||||||
|
int32_t srcFormat = -1;
|
||||||
|
AImage_getFormat(image, &srcFormat);
|
||||||
|
ASSERT(AIMAGE_FORMAT_YUV_420_888 == srcFormat, "Failed to get format");
|
||||||
|
int32_t srcPlanes = 0;
|
||||||
|
AImage_getNumberOfPlanes(image, &srcPlanes);
|
||||||
|
ASSERT(srcPlanes == 3, "Is not 3 planes");
|
||||||
|
|
||||||
|
switch (presentRotation_) {
|
||||||
|
case 0:
|
||||||
|
PresentImage(buf, image);
|
||||||
|
break;
|
||||||
|
case 90:
|
||||||
|
PresentImage90(buf, image);
|
||||||
|
break;
|
||||||
|
case 180:
|
||||||
|
PresentImage180(buf, image);
|
||||||
|
break;
|
||||||
|
case 270:
|
||||||
|
PresentImage270(buf, image);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
ASSERT(0, "NOT recognized display rotation: %d", presentRotation_);
|
||||||
|
}
|
||||||
|
|
||||||
|
AImage_delete(image);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* PresentImage()
|
||||||
|
* Converting yuv to RGB
|
||||||
|
* No rotation: (x,y) --> (x, y)
|
||||||
|
* Refer to:
|
||||||
|
* https://mathbits.com/MathBits/TISection/Geometry/Transformations2.htm
|
||||||
|
*/
|
||||||
|
void ImageReader::PresentImage(ANativeWindow_Buffer *buf, AImage *image) {
|
||||||
|
AImageCropRect srcRect;
|
||||||
|
AImage_getCropRect(image, &srcRect);
|
||||||
|
|
||||||
|
int32_t yStride, uvStride;
|
||||||
|
uint8_t *yPixel, *uPixel, *vPixel;
|
||||||
|
int32_t yLen, uLen, vLen;
|
||||||
|
AImage_getPlaneRowStride(image, 0, &yStride);
|
||||||
|
AImage_getPlaneRowStride(image, 1, &uvStride);
|
||||||
|
AImage_getPlaneData(image, 0, &yPixel, &yLen);
|
||||||
|
AImage_getPlaneData(image, 1, &vPixel, &vLen);
|
||||||
|
AImage_getPlaneData(image, 2, &uPixel, &uLen);
|
||||||
|
int32_t uvPixelStride;
|
||||||
|
AImage_getPlanePixelStride(image, 1, &uvPixelStride);
|
||||||
|
|
||||||
|
int32_t height = MIN(buf->height, (srcRect.bottom - srcRect.top));
|
||||||
|
int32_t width = MIN(buf->width, (srcRect.right - srcRect.left));
|
||||||
|
|
||||||
|
uint32_t *out = static_cast<uint32_t *>(buf->bits);
|
||||||
|
for (int32_t y = 0; y < height; y++) {
|
||||||
|
const uint8_t *pY = yPixel + yStride * (y + srcRect.top) + srcRect.left;
|
||||||
|
|
||||||
|
int32_t uv_row_start = uvStride * ((y + srcRect.top) >> 1);
|
||||||
|
const uint8_t *pU = uPixel + uv_row_start + (srcRect.left >> 1);
|
||||||
|
const uint8_t *pV = vPixel + uv_row_start + (srcRect.left >> 1);
|
||||||
|
|
||||||
|
for (int32_t x = 0; x < width; x++) {
|
||||||
|
const int32_t uv_offset = (x >> 1) * uvPixelStride;
|
||||||
|
out[x] = YUV2RGB(pY[x], pU[uv_offset], pV[uv_offset]);
|
||||||
|
}
|
||||||
|
out += buf->stride;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* PresentImage90()
|
||||||
|
* Converting YUV to RGB
|
||||||
|
* Rotation image anti-clockwise 90 degree -- (x, y) --> (-y, x)
|
||||||
|
*/
|
||||||
|
void ImageReader::PresentImage90(ANativeWindow_Buffer *buf, AImage *image) {
|
||||||
|
AImageCropRect srcRect;
|
||||||
|
AImage_getCropRect(image, &srcRect);
|
||||||
|
|
||||||
|
int32_t yStride, uvStride;
|
||||||
|
uint8_t *yPixel, *uPixel, *vPixel;
|
||||||
|
int32_t yLen, uLen, vLen;
|
||||||
|
AImage_getPlaneRowStride(image, 0, &yStride);
|
||||||
|
AImage_getPlaneRowStride(image, 1, &uvStride);
|
||||||
|
AImage_getPlaneData(image, 0, &yPixel, &yLen);
|
||||||
|
AImage_getPlaneData(image, 1, &vPixel, &vLen);
|
||||||
|
AImage_getPlaneData(image, 2, &uPixel, &uLen);
|
||||||
|
int32_t uvPixelStride;
|
||||||
|
AImage_getPlanePixelStride(image, 1, &uvPixelStride);
|
||||||
|
|
||||||
|
int32_t height = MIN(buf->width, (srcRect.bottom - srcRect.top));
|
||||||
|
int32_t width = MIN(buf->height, (srcRect.right - srcRect.left));
|
||||||
|
|
||||||
|
uint32_t *out = static_cast<uint32_t *>(buf->bits);
|
||||||
|
out += height - 1;
|
||||||
|
for (int32_t y = 0; y < height; y++) {
|
||||||
|
const uint8_t *pY = yPixel + yStride * (y + srcRect.top) + srcRect.left;
|
||||||
|
|
||||||
|
int32_t uv_row_start = uvStride * ((y + srcRect.top) >> 1);
|
||||||
|
const uint8_t *pU = uPixel + uv_row_start + (srcRect.left >> 1);
|
||||||
|
const uint8_t *pV = vPixel + uv_row_start + (srcRect.left >> 1);
|
||||||
|
|
||||||
|
for (int32_t x = 0; x < width; x++) {
|
||||||
|
const int32_t uv_offset = (x >> 1) * uvPixelStride;
|
||||||
|
// [x, y]--> [-y, x]
|
||||||
|
out[x * buf->stride] = YUV2RGB(pY[x], pU[uv_offset], pV[uv_offset]);
|
||||||
|
}
|
||||||
|
out -= 1; // move to the next column
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* PresentImage180()
|
||||||
|
* Converting yuv to RGB
|
||||||
|
* Rotate image 180 degree: (x, y) --> (-x, -y)
|
||||||
|
*/
|
||||||
|
void ImageReader::PresentImage180(ANativeWindow_Buffer *buf, AImage *image) {
|
||||||
|
AImageCropRect srcRect;
|
||||||
|
AImage_getCropRect(image, &srcRect);
|
||||||
|
|
||||||
|
int32_t yStride, uvStride;
|
||||||
|
uint8_t *yPixel, *uPixel, *vPixel;
|
||||||
|
int32_t yLen, uLen, vLen;
|
||||||
|
AImage_getPlaneRowStride(image, 0, &yStride);
|
||||||
|
AImage_getPlaneRowStride(image, 1, &uvStride);
|
||||||
|
AImage_getPlaneData(image, 0, &yPixel, &yLen);
|
||||||
|
AImage_getPlaneData(image, 1, &vPixel, &vLen);
|
||||||
|
AImage_getPlaneData(image, 2, &uPixel, &uLen);
|
||||||
|
int32_t uvPixelStride;
|
||||||
|
AImage_getPlanePixelStride(image, 1, &uvPixelStride);
|
||||||
|
|
||||||
|
int32_t height = MIN(buf->height, (srcRect.bottom - srcRect.top));
|
||||||
|
int32_t width = MIN(buf->width, (srcRect.right - srcRect.left));
|
||||||
|
|
||||||
|
uint32_t *out = static_cast<uint32_t *>(buf->bits);
|
||||||
|
out += (height - 1) * buf->stride;
|
||||||
|
for (int32_t y = 0; y < height; y++) {
|
||||||
|
const uint8_t *pY = yPixel + yStride * (y + srcRect.top) + srcRect.left;
|
||||||
|
|
||||||
|
int32_t uv_row_start = uvStride * ((y + srcRect.top) >> 1);
|
||||||
|
const uint8_t *pU = uPixel + uv_row_start + (srcRect.left >> 1);
|
||||||
|
const uint8_t *pV = vPixel + uv_row_start + (srcRect.left >> 1);
|
||||||
|
|
||||||
|
for (int32_t x = 0; x < width; x++) {
|
||||||
|
const int32_t uv_offset = (x >> 1) * uvPixelStride;
|
||||||
|
// mirror image since we are using front camera
|
||||||
|
out[width - 1 - x] = YUV2RGB(pY[x], pU[uv_offset], pV[uv_offset]);
|
||||||
|
// out[x] = YUV2RGB(pY[x], pU[uv_offset], pV[uv_offset]);
|
||||||
|
}
|
||||||
|
out -= buf->stride;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* PresentImage270()
|
||||||
|
* Converting image from YUV to RGB
|
||||||
|
* Rotate Image counter-clockwise 270 degree: (x, y) --> (y, x)
|
||||||
|
*/
|
||||||
|
void ImageReader::PresentImage270(ANativeWindow_Buffer *buf, AImage *image) {
|
||||||
|
AImageCropRect srcRect;
|
||||||
|
AImage_getCropRect(image, &srcRect);
|
||||||
|
|
||||||
|
int32_t yStride, uvStride;
|
||||||
|
uint8_t *yPixel, *uPixel, *vPixel;
|
||||||
|
int32_t yLen, uLen, vLen;
|
||||||
|
AImage_getPlaneRowStride(image, 0, &yStride);
|
||||||
|
AImage_getPlaneRowStride(image, 1, &uvStride);
|
||||||
|
AImage_getPlaneData(image, 0, &yPixel, &yLen);
|
||||||
|
AImage_getPlaneData(image, 1, &vPixel, &vLen);
|
||||||
|
AImage_getPlaneData(image, 2, &uPixel, &uLen);
|
||||||
|
int32_t uvPixelStride;
|
||||||
|
AImage_getPlanePixelStride(image, 1, &uvPixelStride);
|
||||||
|
|
||||||
|
int32_t height = MIN(buf->width, (srcRect.bottom - srcRect.top));
|
||||||
|
int32_t width = MIN(buf->height, (srcRect.right - srcRect.left));
|
||||||
|
|
||||||
|
uint32_t *out = static_cast<uint32_t *>(buf->bits);
|
||||||
|
for (int32_t y = 0; y < height; y++) {
|
||||||
|
const uint8_t *pY = yPixel + yStride * (y + srcRect.top) + srcRect.left;
|
||||||
|
|
||||||
|
int32_t uv_row_start = uvStride * ((y + srcRect.top) >> 1);
|
||||||
|
const uint8_t *pU = uPixel + uv_row_start + (srcRect.left >> 1);
|
||||||
|
const uint8_t *pV = vPixel + uv_row_start + (srcRect.left >> 1);
|
||||||
|
|
||||||
|
for (int32_t x = 0; x < width; x++) {
|
||||||
|
const int32_t uv_offset = (x >> 1) * uvPixelStride;
|
||||||
|
out[(width - 1 - x) * buf->stride] =
|
||||||
|
YUV2RGB(pY[x], pU[uv_offset], pV[uv_offset]);
|
||||||
|
}
|
||||||
|
out += 1; // move to the next column
|
||||||
|
}
|
||||||
|
}
|
||||||
|
void ImageReader::SetPresentRotation(int32_t angle) {
|
||||||
|
presentRotation_ = angle;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Write out jpeg files to kDirName directory
|
||||||
|
* @param image point capture jpg image
|
||||||
|
*/
|
||||||
|
void ImageReader::WriteFile(AImage *image) {
|
||||||
|
int planeCount;
|
||||||
|
media_status_t status = AImage_getNumberOfPlanes(image, &planeCount);
|
||||||
|
ASSERT(status == AMEDIA_OK && planeCount == 1,
|
||||||
|
"Error: getNumberOfPlanes() planeCount = %d", planeCount);
|
||||||
|
uint8_t *data = nullptr;
|
||||||
|
int len = 0;
|
||||||
|
AImage_getPlaneData(image, 0, &data, &len);
|
||||||
|
|
||||||
|
DIR *dir = opendir(kDirName);
|
||||||
|
if (dir) {
|
||||||
|
closedir(dir);
|
||||||
|
} else {
|
||||||
|
std::string cmd = "mkdir -p ";
|
||||||
|
cmd += kDirName;
|
||||||
|
system(cmd.c_str());
|
||||||
|
}
|
||||||
|
|
||||||
|
struct timespec ts {
|
||||||
|
0, 0
|
||||||
|
};
|
||||||
|
clock_gettime(CLOCK_REALTIME, &ts);
|
||||||
|
struct tm localTime;
|
||||||
|
localtime_r(&ts.tv_sec, &localTime);
|
||||||
|
|
||||||
|
std::string fileName = kDirName;
|
||||||
|
std::string dash("-");
|
||||||
|
fileName += kFileName + std::to_string(localTime.tm_mon) +
|
||||||
|
std::to_string(localTime.tm_mday) + dash +
|
||||||
|
std::to_string(localTime.tm_hour) +
|
||||||
|
std::to_string(localTime.tm_min) +
|
||||||
|
std::to_string(localTime.tm_sec) + ".jpg";
|
||||||
|
FILE *file = fopen(fileName.c_str(), "wb");
|
||||||
|
if (file && data && len) {
|
||||||
|
fwrite(data, 1, len, file);
|
||||||
|
fclose(file);
|
||||||
|
|
||||||
|
if (callback_) {
|
||||||
|
callback_(callbackCtx_, fileName.c_str());
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if (file) fclose(file);
|
||||||
|
}
|
||||||
|
AImage_delete(image);
|
||||||
|
}
|
||||||
@ -0,0 +1,117 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2017 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.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef CAMERA_IMAGE_READER_H
|
||||||
|
#define CAMERA_IMAGE_READER_H
|
||||||
|
#include <media/NdkImageReader.h>
|
||||||
|
|
||||||
|
#include <functional>
|
||||||
|
/*
|
||||||
|
* ImageFormat:
|
||||||
|
* A Data Structure to communicate resolution between camera and ImageReader
|
||||||
|
*/
|
||||||
|
struct ImageFormat {
|
||||||
|
int32_t width;
|
||||||
|
int32_t height;
|
||||||
|
|
||||||
|
int32_t format; // Through out this demo, the format is fixed to
|
||||||
|
// YUV_420 format
|
||||||
|
};
|
||||||
|
|
||||||
|
class ImageReader {
|
||||||
|
public:
|
||||||
|
/**
|
||||||
|
* Ctor and Dtor()
|
||||||
|
*/
|
||||||
|
explicit ImageReader(ImageFormat* res, enum AIMAGE_FORMATS format);
|
||||||
|
|
||||||
|
~ImageReader();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Report cached ANativeWindow, which was used to create camera's capture
|
||||||
|
* session output.
|
||||||
|
*/
|
||||||
|
ANativeWindow* GetNativeWindow(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieve Image on the top of Reader's queue
|
||||||
|
*/
|
||||||
|
AImage* GetNextImage(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Retrieve Image on the back of Reader's queue, dropping older images
|
||||||
|
*/
|
||||||
|
AImage* GetLatestImage(void);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Delete Image
|
||||||
|
* @param image {@link AImage} instance to be deleted
|
||||||
|
*/
|
||||||
|
void DeleteImage(AImage* image);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* AImageReader callback handler. Called by AImageReader when a frame is
|
||||||
|
* captured
|
||||||
|
* (Internal function, not to be called by clients)
|
||||||
|
*/
|
||||||
|
void ImageCallback(AImageReader* reader);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* DisplayImage()
|
||||||
|
* Present camera image to the given display buffer. Avaliable image is
|
||||||
|
* converted
|
||||||
|
* to display buffer format. Supported display format:
|
||||||
|
* WINDOW_FORMAT_RGBX_8888
|
||||||
|
* WINDOW_FORMAT_RGBA_8888
|
||||||
|
* @param buf {@link ANativeWindow_Buffer} for image to display to.
|
||||||
|
* @param image a {@link AImage} instance, source of image conversion.
|
||||||
|
* it will be deleted via {@link AImage_delete}
|
||||||
|
* @return true on success, false on failure
|
||||||
|
*/
|
||||||
|
bool DisplayImage(ANativeWindow_Buffer* buf, AImage* image);
|
||||||
|
/**
|
||||||
|
* Configure the rotation angle necessary to apply to
|
||||||
|
* Camera image when presenting: all rotations should be accumulated:
|
||||||
|
* CameraSensorOrientation + Android Device Native Orientation +
|
||||||
|
* Human Rotation (rotated degree related to Phone native orientation
|
||||||
|
*/
|
||||||
|
void SetPresentRotation(int32_t angle);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* regsiter a callback function for client to be notified that jpeg already
|
||||||
|
* written out.
|
||||||
|
* @param ctx is client context when callback is invoked
|
||||||
|
* @param callback is the actual callback function
|
||||||
|
*/
|
||||||
|
void RegisterCallback(void* ctx,
|
||||||
|
std::function<void(void* ctx, const char* fileName)>);
|
||||||
|
|
||||||
|
private:
|
||||||
|
int32_t presentRotation_;
|
||||||
|
AImageReader* reader_;
|
||||||
|
|
||||||
|
std::function<void(void* ctx, const char* fileName)> callback_;
|
||||||
|
void* callbackCtx_;
|
||||||
|
|
||||||
|
void PresentImage(ANativeWindow_Buffer* buf, AImage* image);
|
||||||
|
void PresentImage90(ANativeWindow_Buffer* buf, AImage* image);
|
||||||
|
void PresentImage180(ANativeWindow_Buffer* buf, AImage* image);
|
||||||
|
void PresentImage270(ANativeWindow_Buffer* buf, AImage* image);
|
||||||
|
|
||||||
|
void WriteFile(AImage* image);
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // CAMERA_IMAGE_READER_H
|
||||||
@ -0,0 +1,459 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2017 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 "camera_utils.h"
|
||||||
|
|
||||||
|
#include <camera/NdkCameraManager.h>
|
||||||
|
#include <media/NdkImage.h>
|
||||||
|
|
||||||
|
#include <cinttypes>
|
||||||
|
#include <string>
|
||||||
|
#include <typeinfo>
|
||||||
|
#include <utility>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
#include "utils/native_debug.h"
|
||||||
|
|
||||||
|
#define UKNOWN_TAG "UNKNOW_TAG"
|
||||||
|
#define MAKE_PAIR(val) std::make_pair(val, #val)
|
||||||
|
template <typename T>
|
||||||
|
const char* GetPairStr(T key, std::vector<std::pair<T, const char*>>& store) {
|
||||||
|
typedef typename std::vector<std::pair<T, const char*>>::iterator iterator;
|
||||||
|
for (iterator it = store.begin(); it != store.end(); ++it) {
|
||||||
|
if (it->first == key) {
|
||||||
|
return it->second;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
LOGW("(%#08x) : UNKNOWN_TAG for %s", key, typeid(store[0].first).name());
|
||||||
|
return UKNOWN_TAG;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* camera_status_t error translation
|
||||||
|
*/
|
||||||
|
using ERROR_PAIR = std::pair<camera_status_t, const char*>;
|
||||||
|
static std::vector<ERROR_PAIR> errorInfo{
|
||||||
|
MAKE_PAIR(ACAMERA_OK),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_UNKNOWN),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_INVALID_PARAMETER),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_CAMERA_DISCONNECTED),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_NOT_ENOUGH_MEMORY),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_METADATA_NOT_FOUND),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_CAMERA_DEVICE),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_CAMERA_SERVICE),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_SESSION_CLOSED),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_INVALID_OPERATION),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_STREAM_CONFIGURE_FAIL),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_CAMERA_IN_USE),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_MAX_CAMERA_IN_USE),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_CAMERA_DISABLED),
|
||||||
|
MAKE_PAIR(ACAMERA_ERROR_PERMISSION_DENIED),
|
||||||
|
};
|
||||||
|
const char* GetErrorStr(camera_status_t err) {
|
||||||
|
return GetPairStr<camera_status_t>(err, errorInfo);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* camera_metadata_tag_t translation. Useful to look at available tags
|
||||||
|
* on the underneath platform
|
||||||
|
*/
|
||||||
|
using TAG_PAIR = std::pair<acamera_metadata_tag_t, const char*>;
|
||||||
|
static std::vector<TAG_PAIR> tagInfo{
|
||||||
|
MAKE_PAIR(ACAMERA_COLOR_CORRECTION_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_COLOR_CORRECTION_TRANSFORM),
|
||||||
|
MAKE_PAIR(ACAMERA_COLOR_CORRECTION_GAINS),
|
||||||
|
MAKE_PAIR(ACAMERA_COLOR_CORRECTION_ABERRATION_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_COLOR_CORRECTION_END),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_ANTIBANDING_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_EXPOSURE_COMPENSATION),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_LOCK),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_REGIONS),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_TARGET_FPS_RANGE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_PRECAPTURE_TRIGGER),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AF_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AF_REGIONS),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AF_TRIGGER),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AWB_LOCK),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AWB_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AWB_REGIONS),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_CAPTURE_INTENT),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_EFFECT_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_SCENE_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_AVAILABLE_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_COMPENSATION_RANGE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_COMPENSATION_STEP),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AF_AVAILABLE_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AVAILABLE_EFFECTS),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AVAILABLE_SCENE_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AWB_AVAILABLE_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_MAX_REGIONS),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_STATE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AF_STATE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AWB_STATE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AE_LOCK_AVAILABLE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AWB_LOCK_AVAILABLE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_AVAILABLE_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_POST_RAW_SENSITIVITY_BOOST_RANGE),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_POST_RAW_SENSITIVITY_BOOST),
|
||||||
|
MAKE_PAIR(ACAMERA_CONTROL_END),
|
||||||
|
MAKE_PAIR(ACAMERA_EDGE_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_EDGE_AVAILABLE_EDGE_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_EDGE_END),
|
||||||
|
MAKE_PAIR(ACAMERA_FLASH_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_FLASH_STATE),
|
||||||
|
MAKE_PAIR(ACAMERA_FLASH_END),
|
||||||
|
MAKE_PAIR(ACAMERA_FLASH_INFO_AVAILABLE),
|
||||||
|
MAKE_PAIR(ACAMERA_FLASH_INFO_END),
|
||||||
|
MAKE_PAIR(ACAMERA_HOT_PIXEL_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_HOT_PIXEL_END),
|
||||||
|
MAKE_PAIR(ACAMERA_JPEG_GPS_COORDINATES),
|
||||||
|
MAKE_PAIR(ACAMERA_JPEG_GPS_PROCESSING_METHOD),
|
||||||
|
MAKE_PAIR(ACAMERA_JPEG_GPS_TIMESTAMP),
|
||||||
|
MAKE_PAIR(ACAMERA_JPEG_ORIENTATION),
|
||||||
|
MAKE_PAIR(ACAMERA_JPEG_QUALITY),
|
||||||
|
MAKE_PAIR(ACAMERA_JPEG_THUMBNAIL_QUALITY),
|
||||||
|
MAKE_PAIR(ACAMERA_JPEG_THUMBNAIL_SIZE),
|
||||||
|
MAKE_PAIR(ACAMERA_JPEG_AVAILABLE_THUMBNAIL_SIZES),
|
||||||
|
MAKE_PAIR(ACAMERA_JPEG_END),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_APERTURE),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_FILTER_DENSITY),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_FOCAL_LENGTH),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_FOCUS_DISTANCE),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_OPTICAL_STABILIZATION_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_FACING),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_POSE_ROTATION),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_POSE_TRANSLATION),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_FOCUS_RANGE),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_STATE),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_INTRINSIC_CALIBRATION),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_RADIAL_DISTORTION),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_END),
|
||||||
|
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_INFO_AVAILABLE_APERTURES),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_INFO_AVAILABLE_FILTER_DENSITIES),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_INFO_AVAILABLE_FOCAL_LENGTHS),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_INFO_HYPERFOCAL_DISTANCE),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_INFO_MINIMUM_FOCUS_DISTANCE),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_INFO_SHADING_MAP_SIZE),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_INFO_FOCUS_DISTANCE_CALIBRATION),
|
||||||
|
MAKE_PAIR(ACAMERA_LENS_INFO_END),
|
||||||
|
|
||||||
|
MAKE_PAIR(ACAMERA_NOISE_REDUCTION_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_NOISE_REDUCTION_END),
|
||||||
|
|
||||||
|
MAKE_PAIR(ACAMERA_REQUEST_MAX_NUM_OUTPUT_STREAMS),
|
||||||
|
MAKE_PAIR(ACAMERA_REQUEST_PIPELINE_DEPTH),
|
||||||
|
MAKE_PAIR(ACAMERA_REQUEST_PIPELINE_MAX_DEPTH),
|
||||||
|
MAKE_PAIR(ACAMERA_REQUEST_PARTIAL_RESULT_COUNT),
|
||||||
|
MAKE_PAIR(ACAMERA_REQUEST_AVAILABLE_CAPABILITIES),
|
||||||
|
MAKE_PAIR(ACAMERA_REQUEST_AVAILABLE_REQUEST_KEYS),
|
||||||
|
MAKE_PAIR(ACAMERA_REQUEST_AVAILABLE_RESULT_KEYS),
|
||||||
|
MAKE_PAIR(ACAMERA_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS),
|
||||||
|
MAKE_PAIR(ACAMERA_REQUEST_END),
|
||||||
|
|
||||||
|
MAKE_PAIR(ACAMERA_SCALER_CROP_REGION),
|
||||||
|
MAKE_PAIR(ACAMERA_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM),
|
||||||
|
MAKE_PAIR(ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS),
|
||||||
|
MAKE_PAIR(ACAMERA_SCALER_AVAILABLE_MIN_FRAME_DURATIONS),
|
||||||
|
MAKE_PAIR(ACAMERA_SCALER_AVAILABLE_STALL_DURATIONS),
|
||||||
|
MAKE_PAIR(ACAMERA_SCALER_CROPPING_TYPE),
|
||||||
|
MAKE_PAIR(ACAMERA_SCALER_END),
|
||||||
|
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_EXPOSURE_TIME),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_FRAME_DURATION),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_SENSITIVITY),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_REFERENCE_ILLUMINANT1),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_REFERENCE_ILLUMINANT2),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_CALIBRATION_TRANSFORM1),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_CALIBRATION_TRANSFORM2),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_COLOR_TRANSFORM1),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_COLOR_TRANSFORM2),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_FORWARD_MATRIX1),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_FORWARD_MATRIX2),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_BLACK_LEVEL_PATTERN),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_MAX_ANALOG_SENSITIVITY),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_ORIENTATION),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_TIMESTAMP),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_NEUTRAL_COLOR_POINT),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_NOISE_PROFILE),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_GREEN_SPLIT),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_TEST_PATTERN_DATA),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_TEST_PATTERN_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_AVAILABLE_TEST_PATTERN_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_ROLLING_SHUTTER_SKEW),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_OPTICAL_BLACK_REGIONS),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_DYNAMIC_BLACK_LEVEL),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_DYNAMIC_WHITE_LEVEL),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_END),
|
||||||
|
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_INFO_ACTIVE_ARRAY_SIZE),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_INFO_SENSITIVITY_RANGE),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_INFO_EXPOSURE_TIME_RANGE),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_INFO_MAX_FRAME_DURATION),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_INFO_PHYSICAL_SIZE),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_INFO_PIXEL_ARRAY_SIZE),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_INFO_WHITE_LEVEL),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_INFO_TIMESTAMP_SOURCE),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_INFO_LENS_SHADING_APPLIED),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE),
|
||||||
|
MAKE_PAIR(ACAMERA_SENSOR_INFO_END),
|
||||||
|
|
||||||
|
MAKE_PAIR(ACAMERA_SHADING_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_SHADING_AVAILABLE_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_SHADING_END),
|
||||||
|
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_FACE_DETECT_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_HOT_PIXEL_MAP_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_FACE_IDS),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_FACE_LANDMARKS),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_FACE_RECTANGLES),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_FACE_SCORES),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_LENS_SHADING_MAP),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_SCENE_FLICKER),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_HOT_PIXEL_MAP),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_LENS_SHADING_MAP_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_END),
|
||||||
|
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_INFO_MAX_FACE_COUNT),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_STATISTICS_INFO_END),
|
||||||
|
|
||||||
|
MAKE_PAIR(ACAMERA_TONEMAP_CURVE_BLUE),
|
||||||
|
MAKE_PAIR(ACAMERA_TONEMAP_CURVE_GREEN),
|
||||||
|
MAKE_PAIR(ACAMERA_TONEMAP_CURVE_RED),
|
||||||
|
MAKE_PAIR(ACAMERA_TONEMAP_MODE),
|
||||||
|
MAKE_PAIR(ACAMERA_TONEMAP_MAX_CURVE_POINTS),
|
||||||
|
MAKE_PAIR(ACAMERA_TONEMAP_AVAILABLE_TONE_MAP_MODES),
|
||||||
|
MAKE_PAIR(ACAMERA_TONEMAP_GAMMA),
|
||||||
|
MAKE_PAIR(ACAMERA_TONEMAP_PRESET_CURVE),
|
||||||
|
MAKE_PAIR(ACAMERA_TONEMAP_END),
|
||||||
|
|
||||||
|
MAKE_PAIR(ACAMERA_INFO_SUPPORTED_HARDWARE_LEVEL),
|
||||||
|
MAKE_PAIR(ACAMERA_INFO_END),
|
||||||
|
MAKE_PAIR(ACAMERA_BLACK_LEVEL_LOCK),
|
||||||
|
MAKE_PAIR(ACAMERA_BLACK_LEVEL_END),
|
||||||
|
MAKE_PAIR(ACAMERA_SYNC_FRAME_NUMBER),
|
||||||
|
MAKE_PAIR(ACAMERA_SYNC_MAX_LATENCY),
|
||||||
|
MAKE_PAIR(ACAMERA_SYNC_END),
|
||||||
|
MAKE_PAIR(ACAMERA_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS),
|
||||||
|
|
||||||
|
MAKE_PAIR(ACAMERA_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS),
|
||||||
|
MAKE_PAIR(ACAMERA_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS),
|
||||||
|
MAKE_PAIR(ACAMERA_DEPTH_DEPTH_IS_EXCLUSIVE),
|
||||||
|
MAKE_PAIR(ACAMERA_DEPTH_END),
|
||||||
|
};
|
||||||
|
const char* GetTagStr(acamera_metadata_tag_t tag) {
|
||||||
|
return GetPairStr<acamera_metadata_tag_t>(tag, tagInfo);
|
||||||
|
}
|
||||||
|
|
||||||
|
using FORMAT_PAIR = std::pair<int, const char*>;
|
||||||
|
static std::vector<FORMAT_PAIR> formatInfo{
|
||||||
|
MAKE_PAIR(AIMAGE_FORMAT_YUV_420_888),
|
||||||
|
MAKE_PAIR(AIMAGE_FORMAT_JPEG),
|
||||||
|
MAKE_PAIR(AIMAGE_FORMAT_RAW16),
|
||||||
|
MAKE_PAIR(AIMAGE_FORMAT_RAW_PRIVATE),
|
||||||
|
MAKE_PAIR(AIMAGE_FORMAT_RAW10),
|
||||||
|
MAKE_PAIR(AIMAGE_FORMAT_RAW12),
|
||||||
|
MAKE_PAIR(AIMAGE_FORMAT_DEPTH16),
|
||||||
|
MAKE_PAIR(AIMAGE_FORMAT_DEPTH_POINT_CLOUD),
|
||||||
|
MAKE_PAIR(AIMAGE_FORMAT_PRIVATE),
|
||||||
|
};
|
||||||
|
const char* GetFormatStr(int fmt) { return GetPairStr<int>(fmt, formatInfo); }
|
||||||
|
|
||||||
|
void PrintMetadataTags(int32_t entries, const uint32_t* pTags) {
|
||||||
|
LOGI("MetadataTag (start):");
|
||||||
|
for (int32_t idx = 0; idx < entries; ++idx) {
|
||||||
|
const char* name =
|
||||||
|
GetTagStr(static_cast<acamera_metadata_tag_t>(pTags[idx]));
|
||||||
|
LOGI("(%#08x) : %s", pTags[idx], name);
|
||||||
|
}
|
||||||
|
LOGI("MetadataTag (end)");
|
||||||
|
}
|
||||||
|
|
||||||
|
void PrintLensFacing(ACameraMetadata_const_entry& lens) {
|
||||||
|
ASSERT(lens.tag == ACAMERA_LENS_FACING, "Wrong tag(%#x) of %s to %s",
|
||||||
|
lens.tag, GetTagStr((acamera_metadata_tag_t)lens.tag), __FUNCTION__);
|
||||||
|
LOGI("LensFacing: tag(%#x), type(%d), count(%d), val(%#x)", lens.tag,
|
||||||
|
lens.type, lens.count, lens.data.u8[0]);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Stream_Configuration is in format of:
|
||||||
|
* format, width, height, input?
|
||||||
|
* ACAMERA_TYPE_INT32 type
|
||||||
|
*/
|
||||||
|
void PrintStreamConfigurations(ACameraMetadata_const_entry& val) {
|
||||||
|
#define MODE_LABLE "ModeInfo:"
|
||||||
|
const char* tagName = GetTagStr(static_cast<acamera_metadata_tag_t>(val.tag));
|
||||||
|
ASSERT(!(val.count & 0x3), "STREAM_CONFIGURATION (%d) should multiple of 4",
|
||||||
|
val.count);
|
||||||
|
ASSERT(val.type == ACAMERA_TYPE_INT32,
|
||||||
|
"STREAM_CONFIGURATION TYPE(%d) is not ACAMERA_TYPE_INT32(1)",
|
||||||
|
val.type);
|
||||||
|
LOGI("%s -- %s:", tagName, MODE_LABLE);
|
||||||
|
for (uint32_t i = 0; i < val.count; i += 4) {
|
||||||
|
LOGI("%s: %08d x %08d %s", GetFormatStr(val.data.i32[i]),
|
||||||
|
val.data.i32[i + 1], val.data.i32[i + 2],
|
||||||
|
val.data.i32[i + 3] ? "INPUT" : "OUTPUT");
|
||||||
|
}
|
||||||
|
#undef MODE_LABLE
|
||||||
|
}
|
||||||
|
void PrintTagVal(const char* printLabel, ACameraMetadata_const_entry& val) {
|
||||||
|
if (val.tag == ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS) {
|
||||||
|
PrintStreamConfigurations(val);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
const char* name = GetTagStr(static_cast<acamera_metadata_tag_t>(val.tag));
|
||||||
|
for (uint32_t i = 0; i < val.count; ++i) {
|
||||||
|
switch (val.type) {
|
||||||
|
case ACAMERA_TYPE_INT32:
|
||||||
|
LOGI("%s %s: %08d", printLabel, name, val.data.i32[i]);
|
||||||
|
break;
|
||||||
|
case ACAMERA_TYPE_BYTE:
|
||||||
|
LOGI("%s %s: %#02x", printLabel, name, val.data.u8[i]);
|
||||||
|
break;
|
||||||
|
case ACAMERA_TYPE_INT64:
|
||||||
|
LOGI("%s %s: %" PRIu64, printLabel, name, (int64_t)val.data.i64[i]);
|
||||||
|
break;
|
||||||
|
case ACAMERA_TYPE_FLOAT:
|
||||||
|
LOGI("%s %s: %f", printLabel, name, val.data.f[i]);
|
||||||
|
break;
|
||||||
|
case ACAMERA_TYPE_DOUBLE:
|
||||||
|
LOGI("%s %s: %" PRIx64, printLabel, name, val.data.i64[i]);
|
||||||
|
break;
|
||||||
|
case ACAMERA_TYPE_RATIONAL:
|
||||||
|
LOGI("%s %s: %08x, %08x", printLabel, name, val.data.r[i].numerator,
|
||||||
|
val.data.r[i].denominator);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
ASSERT(false, "Unknown tag value type: %d", val.type);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* PrintCamera():
|
||||||
|
* Enumerate existing camera and its metadata.
|
||||||
|
*/
|
||||||
|
void PrintCameras(ACameraManager* cmrMgr) {
|
||||||
|
if (!cmrMgr) return;
|
||||||
|
|
||||||
|
ACameraIdList* cameraIds = nullptr;
|
||||||
|
camera_status_t status = ACameraManager_getCameraIdList(cmrMgr, &cameraIds);
|
||||||
|
LOGI("camera Status = %d, %s", status, GetErrorStr(status));
|
||||||
|
|
||||||
|
for (int i = 0; i < cameraIds->numCameras; ++i) {
|
||||||
|
const char* id = cameraIds->cameraIds[i];
|
||||||
|
LOGI("=====cameraId = %d, cameraName = %s=====", i, id);
|
||||||
|
ACameraMetadata* metadataObj;
|
||||||
|
CALL_MGR(getCameraCharacteristics(cmrMgr, id, &metadataObj));
|
||||||
|
|
||||||
|
int32_t count = 0;
|
||||||
|
const uint32_t* tags = nullptr;
|
||||||
|
ACameraMetadata_getAllTags(metadataObj, &count, &tags);
|
||||||
|
|
||||||
|
for (int tagIdx = 0; tagIdx < count; ++tagIdx) {
|
||||||
|
ACameraMetadata_const_entry val = {
|
||||||
|
0,
|
||||||
|
};
|
||||||
|
camera_status_t status =
|
||||||
|
ACameraMetadata_getConstEntry(metadataObj, tags[tagIdx], &val);
|
||||||
|
if (status != ACAMERA_OK) {
|
||||||
|
LOGW("Unsupported Tag: %s",
|
||||||
|
GetTagStr(static_cast<acamera_metadata_tag_t>(tags[tagIdx])));
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
PrintTagVal("Camera Tag:", val);
|
||||||
|
|
||||||
|
if (ACAMERA_LENS_FACING == tags[tagIdx]) {
|
||||||
|
PrintLensFacing(val);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ACameraMetadata_free(metadataObj);
|
||||||
|
}
|
||||||
|
|
||||||
|
ACameraManager_deleteCameraIdList(cameraIds);
|
||||||
|
}
|
||||||
|
|
||||||
|
void PrintRequestMetadata(ACaptureRequest* req) {
|
||||||
|
if (!req) return;
|
||||||
|
int32_t count;
|
||||||
|
const uint32_t* tags;
|
||||||
|
CALL_REQUEST(getAllTags(req, &count, &tags));
|
||||||
|
for (int32_t idx = 0; idx < count; ++idx) {
|
||||||
|
ACameraMetadata_const_entry val;
|
||||||
|
CALL_REQUEST(getConstEntry(req, tags[idx], &val));
|
||||||
|
const char* name =
|
||||||
|
GetTagStr(static_cast<acamera_metadata_tag_t>(tags[idx]));
|
||||||
|
|
||||||
|
for (uint32_t i = 0; i < val.count; ++i) {
|
||||||
|
switch (val.type) {
|
||||||
|
case ACAMERA_TYPE_INT32:
|
||||||
|
LOGI("Capture Tag %s: %08d", name, val.data.i32[i]);
|
||||||
|
break;
|
||||||
|
case ACAMERA_TYPE_BYTE:
|
||||||
|
LOGI("Capture Tag %s: %#08x", name, val.data.u8[i]);
|
||||||
|
break;
|
||||||
|
case ACAMERA_TYPE_INT64:
|
||||||
|
LOGI("Capture Tag %s: %" PRIu64, name, (int64_t)val.data.i64[i]);
|
||||||
|
break;
|
||||||
|
case ACAMERA_TYPE_FLOAT:
|
||||||
|
LOGI("Capture Tag %s: %f", name, val.data.f[i]);
|
||||||
|
break;
|
||||||
|
case ACAMERA_TYPE_DOUBLE:
|
||||||
|
LOGI("Capture Tag %s: %" PRIx64, name, val.data.i64[i]);
|
||||||
|
break;
|
||||||
|
case ACAMERA_TYPE_RATIONAL:
|
||||||
|
LOGI("Capture Tag %s: %08x, %08x", name, val.data.r[i].numerator,
|
||||||
|
val.data.r[i].denominator);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
ASSERT(false, "Unknown tag value type: %d", val.type);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* CameraDevice error state translation, used in
|
||||||
|
* ACameraDevice_ErrorStateCallback
|
||||||
|
*/
|
||||||
|
using DEV_ERROR_PAIR = std::pair<int, const char*>;
|
||||||
|
static std::vector<DEV_ERROR_PAIR> devErrors{
|
||||||
|
MAKE_PAIR(ERROR_CAMERA_IN_USE), MAKE_PAIR(ERROR_MAX_CAMERAS_IN_USE),
|
||||||
|
MAKE_PAIR(ERROR_CAMERA_DISABLED), MAKE_PAIR(ERROR_CAMERA_DEVICE),
|
||||||
|
MAKE_PAIR(ERROR_CAMERA_SERVICE),
|
||||||
|
};
|
||||||
|
|
||||||
|
const char* GetCameraDeviceErrorStr(int err) {
|
||||||
|
return GetPairStr<int>(err, devErrors);
|
||||||
|
}
|
||||||
|
void PrintCameraDeviceError(int err) {
|
||||||
|
LOGI("CameraDeviceError(%#x): %s", err, GetCameraDeviceErrorStr(err));
|
||||||
|
}
|
||||||
@ -0,0 +1,52 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2017 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.
|
||||||
|
*/
|
||||||
|
#ifndef __CAMERA_CAMERA_UTILS_H__
|
||||||
|
#define __CAMERA_CAMERA_UTILS_H__
|
||||||
|
|
||||||
|
#include <camera/NdkCameraError.h>
|
||||||
|
#include <camera/NdkCameraManager.h>
|
||||||
|
|
||||||
|
/*
|
||||||
|
* A set of macros to call into Camera APIs. The API is grouped with a few
|
||||||
|
* objects, with object name as the prefix of function names.
|
||||||
|
*/
|
||||||
|
#define CALL_CAMERA(func) \
|
||||||
|
{ \
|
||||||
|
camera_status_t status = func; \
|
||||||
|
ASSERT(status == ACAMERA_OK, "%s call failed with code: %#x, %s", \
|
||||||
|
__FUNCTION__, status, GetErrorStr(status)); \
|
||||||
|
}
|
||||||
|
#define CALL_MGR(func) CALL_CAMERA(ACameraManager_##func)
|
||||||
|
#define CALL_DEV(func) CALL_CAMERA(ACameraDevice_##func)
|
||||||
|
#define CALL_METADATA(func) CALL_CAMERA(ACameraMetadata_##func)
|
||||||
|
#define CALL_CONTAINER(func) CALL_CAMERA(ACaptureSessionOutputContainer_##func)
|
||||||
|
#define CALL_OUTPUT(func) CALL_CAMERA(ACaptureSessionOutput_##func)
|
||||||
|
#define CALL_TARGET(func) CALL_CAMERA(ACameraOutputTarget_##func)
|
||||||
|
#define CALL_REQUEST(func) CALL_CAMERA(ACaptureRequest_##func)
|
||||||
|
#define CALL_SESSION(func) CALL_CAMERA(ACameraCaptureSession_##func)
|
||||||
|
|
||||||
|
/*
|
||||||
|
* A few debugging functions for error code strings etc
|
||||||
|
*/
|
||||||
|
const char* GetErrorStr(camera_status_t err);
|
||||||
|
const char* GetTagStr(acamera_metadata_tag_t tag);
|
||||||
|
void PrintMetadataTags(int32_t entries, const uint32_t* pTags);
|
||||||
|
void PrintLensFacing(ACameraMetadata_const_entry& lensData);
|
||||||
|
void PrintCameras(ACameraManager* cameraMgr);
|
||||||
|
void PrintCameraDeviceError(int err);
|
||||||
|
|
||||||
|
void PrintRequestMetadata(ACaptureRequest* req);
|
||||||
|
#endif // __CAMERA_CAMERA_UTILS_H__
|
||||||
@ -0,0 +1,10 @@
|
|||||||
|
#include <android/log.h>
|
||||||
|
|
||||||
|
#define LOG_TAG "CAMERA-SAMPLE"
|
||||||
|
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
|
||||||
|
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
|
||||||
|
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
|
||||||
|
#define ASSERT(cond, fmt, ...) \
|
||||||
|
if (!(cond)) { \
|
||||||
|
__android_log_assert(#cond, LOG_TAG, fmt, ##__VA_ARGS__); \
|
||||||
|
}
|
||||||
@ -0,0 +1,217 @@
|
|||||||
|
package com.xinyingpower.microphoto;
|
||||||
|
|
||||||
|
import android.app.Service;
|
||||||
|
import android.content.Context;
|
||||||
|
import android.content.Intent;
|
||||||
|
import android.graphics.PixelFormat;
|
||||||
|
import android.graphics.Rect;
|
||||||
|
import android.os.Build;
|
||||||
|
import android.os.IBinder;
|
||||||
|
import android.text.Editable;
|
||||||
|
import android.text.TextWatcher;
|
||||||
|
import android.util.DisplayMetrics;
|
||||||
|
import android.view.Gravity;
|
||||||
|
import android.view.LayoutInflater;
|
||||||
|
import android.view.MotionEvent;
|
||||||
|
import android.view.View;
|
||||||
|
import android.view.WindowManager;
|
||||||
|
import android.view.inputmethod.InputMethodManager;
|
||||||
|
import android.widget.Button;
|
||||||
|
import android.widget.EditText;
|
||||||
|
import android.widget.TextView;
|
||||||
|
|
||||||
|
public class FloatingWindow extends Service {
|
||||||
|
|
||||||
|
private Context mContext;
|
||||||
|
private WindowManager mWindowManager;
|
||||||
|
private View mView;
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public IBinder onBind(Intent intent) {
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onCreate() {
|
||||||
|
super.onCreate();
|
||||||
|
mContext = this;
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public int onStartCommand(Intent intent, int flags, int startId) {
|
||||||
|
mWindowManager = (WindowManager) getSystemService(WINDOW_SERVICE);
|
||||||
|
|
||||||
|
allAboutLayout(intent);
|
||||||
|
moveView();
|
||||||
|
|
||||||
|
return super.onStartCommand(intent, flags, startId);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onDestroy() {
|
||||||
|
|
||||||
|
if (mView != null) {
|
||||||
|
mWindowManager.removeView(mView);
|
||||||
|
}
|
||||||
|
super.onDestroy();
|
||||||
|
}
|
||||||
|
|
||||||
|
WindowManager.LayoutParams mWindowsParams;
|
||||||
|
private void moveView() {
|
||||||
|
DisplayMetrics metrics = mContext.getResources().getDisplayMetrics();
|
||||||
|
int width = (int) (metrics.widthPixels * 1f);
|
||||||
|
int height = (int) (metrics.heightPixels * 1f);
|
||||||
|
|
||||||
|
mWindowsParams = new WindowManager.LayoutParams(
|
||||||
|
width,//WindowManager.LayoutParams.WRAP_CONTENT,
|
||||||
|
height,//WindowManager.LayoutParams.WRAP_CONTENT,
|
||||||
|
//WindowManager.LayoutParams.TYPE_SYSTEM_ALERT,
|
||||||
|
|
||||||
|
(Build.VERSION.SDK_INT <= 25) ? WindowManager.LayoutParams.TYPE_PHONE : WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
|
||||||
|
,
|
||||||
|
|
||||||
|
//WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL,
|
||||||
|
WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
|
||||||
|
| WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN // Not displaying keyboard on bg activity's EditText
|
||||||
|
| WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
|
||||||
|
| WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
|
||||||
|
| WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
|
||||||
|
| WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON,
|
||||||
|
//WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE, //Not work with EditText on keyboard
|
||||||
|
PixelFormat.TRANSLUCENT);
|
||||||
|
|
||||||
|
|
||||||
|
mWindowsParams.gravity = Gravity.TOP | Gravity.LEFT;
|
||||||
|
//params.x = 0;
|
||||||
|
mWindowsParams.y = 100;
|
||||||
|
mWindowManager.addView(mView, mWindowsParams);
|
||||||
|
|
||||||
|
mView.setOnTouchListener(new View.OnTouchListener() {
|
||||||
|
private int initialX;
|
||||||
|
private int initialY;
|
||||||
|
private float initialTouchX;
|
||||||
|
private float initialTouchY;
|
||||||
|
|
||||||
|
long startTime = System.currentTimeMillis();
|
||||||
|
@Override
|
||||||
|
public boolean onTouch(View v, MotionEvent event) {
|
||||||
|
if (System.currentTimeMillis() - startTime <= 300) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (isViewInBounds(mView, (int) (event.getRawX()), (int) (event.getRawY()))) {
|
||||||
|
editTextReceiveFocus();
|
||||||
|
} else {
|
||||||
|
editTextDontReceiveFocus();
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (event.getAction()) {
|
||||||
|
case MotionEvent.ACTION_DOWN:
|
||||||
|
initialX = mWindowsParams.x;
|
||||||
|
initialY = mWindowsParams.y;
|
||||||
|
initialTouchX = event.getRawX();
|
||||||
|
initialTouchY = event.getRawY();
|
||||||
|
break;
|
||||||
|
case MotionEvent.ACTION_UP:
|
||||||
|
break;
|
||||||
|
case MotionEvent.ACTION_MOVE:
|
||||||
|
mWindowsParams.x = initialX + (int) (event.getRawX() - initialTouchX);
|
||||||
|
mWindowsParams.y = initialY + (int) (event.getRawY() - initialTouchY);
|
||||||
|
mWindowManager.updateViewLayout(mView, mWindowsParams);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean isViewInBounds(View view, int x, int y) {
|
||||||
|
Rect outRect = new Rect();
|
||||||
|
int[] location = new int[2];
|
||||||
|
view.getDrawingRect(outRect);
|
||||||
|
view.getLocationOnScreen(location);
|
||||||
|
outRect.offset(location[0], location[1]);
|
||||||
|
return outRect.contains(x, y);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void editTextReceiveFocus() {
|
||||||
|
if (!wasInFocus) {
|
||||||
|
mWindowsParams.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL | WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;
|
||||||
|
mWindowManager.updateViewLayout(mView, mWindowsParams);
|
||||||
|
wasInFocus = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private void editTextDontReceiveFocus() {
|
||||||
|
if (wasInFocus) {
|
||||||
|
mWindowsParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;
|
||||||
|
mWindowManager.updateViewLayout(mView, mWindowsParams);
|
||||||
|
wasInFocus = false;
|
||||||
|
hideKeyboard(mContext, edt1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private boolean wasInFocus = true;
|
||||||
|
private EditText edt1;
|
||||||
|
private void allAboutLayout(Intent intent) {
|
||||||
|
|
||||||
|
LayoutInflater layoutInflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
|
||||||
|
mView = layoutInflater.inflate(R.layout.ovelay_window, null);
|
||||||
|
|
||||||
|
edt1 = (EditText) mView.findViewById(R.id.edt1);
|
||||||
|
final TextView tvValue = (TextView) mView.findViewById(R.id.tvValue);
|
||||||
|
Button btnClose = (Button) mView.findViewById(R.id.btnClose);
|
||||||
|
|
||||||
|
edt1.setOnClickListener(new View.OnClickListener() {
|
||||||
|
@Override
|
||||||
|
public void onClick(View v) {
|
||||||
|
mWindowsParams.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL | WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;
|
||||||
|
mWindowsParams.softInputMode = WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE;
|
||||||
|
mWindowManager.updateViewLayout(mView, mWindowsParams);
|
||||||
|
wasInFocus = true;
|
||||||
|
showSoftKeyboard(v);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
edt1.addTextChangedListener(new TextWatcher() {
|
||||||
|
@Override
|
||||||
|
public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
|
||||||
|
tvValue.setText(edt1.getText());
|
||||||
|
}
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void afterTextChanged(Editable editable) {
|
||||||
|
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
btnClose.setOnClickListener(new View.OnClickListener() {
|
||||||
|
@Override
|
||||||
|
public void onClick(View view) {
|
||||||
|
stopSelf();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
private void hideKeyboard(Context context, View view) {
|
||||||
|
if (view != null) {
|
||||||
|
InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
|
||||||
|
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public void showSoftKeyboard(View view) {
|
||||||
|
if (view.requestFocus()) {
|
||||||
|
InputMethodManager imm = (InputMethodManager)
|
||||||
|
getSystemService(Context.INPUT_METHOD_SERVICE);
|
||||||
|
imm.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
@ -0,0 +1,84 @@
|
|||||||
|
package com.xinyingpower.microphoto;
|
||||||
|
|
||||||
|
import android.content.BroadcastReceiver;
|
||||||
|
import android.content.Context;
|
||||||
|
import android.content.Intent;
|
||||||
|
import android.content.IntentFilter;
|
||||||
|
import android.os.Build;
|
||||||
|
import android.util.Log;
|
||||||
|
import android.widget.Toast;
|
||||||
|
|
||||||
|
public class ScreenActionReceiver extends BroadcastReceiver {
|
||||||
|
|
||||||
|
private String TAG = "ScreenActionReceiver";
|
||||||
|
|
||||||
|
@Override
|
||||||
|
public void onReceive(Context context, Intent intent) {
|
||||||
|
|
||||||
|
|
||||||
|
//LOG
|
||||||
|
StringBuilder sb = new StringBuilder();
|
||||||
|
sb.append("Action: " + intent.getAction() + "\n");
|
||||||
|
sb.append("URI: " + intent.toUri(Intent.URI_INTENT_SCHEME).toString() + "\n");
|
||||||
|
String log = sb.toString();
|
||||||
|
Log.d(TAG, log);
|
||||||
|
Toast.makeText(context, log, Toast.LENGTH_LONG).show();
|
||||||
|
|
||||||
|
String action = intent.getAction();
|
||||||
|
|
||||||
|
if(Intent.ACTION_SCREEN_ON.equals(action))
|
||||||
|
{
|
||||||
|
Log.d(TAG, "screen is on...");
|
||||||
|
Toast.makeText(context,"screen ON",Toast.LENGTH_LONG);
|
||||||
|
|
||||||
|
//Run the locker
|
||||||
|
|
||||||
|
context.startService(new Intent(context, FloatingWindow.class));
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
else if(Intent.ACTION_SCREEN_OFF.equals(action))
|
||||||
|
{
|
||||||
|
Log.d(TAG, "screen is off...");
|
||||||
|
Toast.makeText(context,"screen OFF",Toast.LENGTH_LONG);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
else if(Intent.ACTION_USER_PRESENT.equals(action))
|
||||||
|
{
|
||||||
|
Log.d(TAG, "screen is unlock...");
|
||||||
|
Toast.makeText(context,"screen UNLOCK",Toast.LENGTH_LONG);
|
||||||
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
||||||
|
context.startForegroundService(new Intent(context, FloatingWindow.class));
|
||||||
|
} else {
|
||||||
|
context.startService(new Intent(context, FloatingWindow.class));
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
else if(Intent.ACTION_BOOT_COMPLETED.equals(action)){
|
||||||
|
Log.d(TAG, "boot completed...");
|
||||||
|
Toast.makeText(context,"BOOTED..",Toast.LENGTH_LONG);
|
||||||
|
//Run the locker
|
||||||
|
/* Intent i = new Intent(context, FloatingWindow.class);
|
||||||
|
context.startService(i);
|
||||||
|
|
||||||
|
*/
|
||||||
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
||||||
|
context.startForegroundService(new Intent(context, FloatingWindow.class));
|
||||||
|
} else {
|
||||||
|
context.startService(new Intent(context, FloatingWindow.class));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
public IntentFilter getFilter(){
|
||||||
|
final IntentFilter filter = new IntentFilter();
|
||||||
|
filter.addAction(Intent.ACTION_SCREEN_OFF);
|
||||||
|
filter.addAction(Intent.ACTION_SCREEN_ON);
|
||||||
|
return filter;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
@ -0,0 +1,36 @@
|
|||||||
|
<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
|
||||||
|
android:layout_width="match_parent"
|
||||||
|
android:layout_height="wrap_content"
|
||||||
|
android:gravity="center"
|
||||||
|
android:orientation="horizontal"
|
||||||
|
android:weightSum="4">
|
||||||
|
|
||||||
|
<LinearLayout
|
||||||
|
android:layout_width="0dp"
|
||||||
|
android:layout_height="wrap_content"
|
||||||
|
android:layout_weight="3"
|
||||||
|
android:gravity="center">
|
||||||
|
|
||||||
|
<TextView
|
||||||
|
android:id="@+id/tv_state"
|
||||||
|
android:layout_width="wrap_content"
|
||||||
|
android:layout_height="wrap_content"
|
||||||
|
android:text="STATES"
|
||||||
|
android:textSize="16sp" />
|
||||||
|
</LinearLayout>
|
||||||
|
|
||||||
|
<LinearLayout
|
||||||
|
android:layout_width="0dp"
|
||||||
|
android:layout_height="wrap_content"
|
||||||
|
android:layout_weight="1"
|
||||||
|
android:gravity="center">
|
||||||
|
|
||||||
|
<Button
|
||||||
|
android:id="@+id/btn_stop"
|
||||||
|
android:layout_width="wrap_content"
|
||||||
|
android:layout_height="wrap_content"
|
||||||
|
android:text="STOP"
|
||||||
|
android:textSize="13sp" />
|
||||||
|
</LinearLayout>
|
||||||
|
</LinearLayout>
|
||||||
@ -0,0 +1,34 @@
|
|||||||
|
<?xml version="1.0" encoding="utf-8"?>
|
||||||
|
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
|
||||||
|
xmlns:tools="http://schemas.android.com/tools"
|
||||||
|
android:id="@+id/activity_main"
|
||||||
|
android:layout_width="match_parent"
|
||||||
|
android:layout_height="match_parent"
|
||||||
|
android:paddingBottom="@dimen/activity_vertical_margin"
|
||||||
|
android:paddingLeft="@dimen/activity_horizontal_margin"
|
||||||
|
android:paddingRight="@dimen/activity_horizontal_margin"
|
||||||
|
android:paddingTop="@dimen/activity_vertical_margin"
|
||||||
|
android:background="#548F32"
|
||||||
|
tools:context=".MainActivity">
|
||||||
|
|
||||||
|
<EditText
|
||||||
|
android:id="@+id/edt1"
|
||||||
|
android:hint="Type here"
|
||||||
|
android:layout_toLeftOf="@+id/btnClose"
|
||||||
|
android:layout_width="match_parent"
|
||||||
|
android:layout_height="wrap_content" />
|
||||||
|
<Button
|
||||||
|
android:layout_width="wrap_content"
|
||||||
|
android:layout_height="wrap_content"
|
||||||
|
android:text="Close"
|
||||||
|
android:layout_alignParentRight="true"
|
||||||
|
android:id="@+id/btnClose"
|
||||||
|
/>
|
||||||
|
<TextView
|
||||||
|
android:id="@+id/tvValue"
|
||||||
|
android:layout_below="@+id/edt1"
|
||||||
|
android:layout_width="wrap_content"
|
||||||
|
android:layout_height="wrap_content"
|
||||||
|
android:text="" />
|
||||||
|
|
||||||
|
</RelativeLayout>
|
||||||
@ -0,0 +1,5 @@
|
|||||||
|
<resources>
|
||||||
|
<!-- Default screen margins, per the Android Design guidelines. -->
|
||||||
|
<dimen name="activity_horizontal_margin">16dp</dimen>
|
||||||
|
<dimen name="activity_vertical_margin">16dp</dimen>
|
||||||
|
</resources>
|
||||||
@ -1,3 +1,4 @@
|
|||||||
<resources>
|
<resources>
|
||||||
<string name="app_name">MicroPhoto</string>
|
<string name="app_name">MicroPhoto</string>
|
||||||
|
<string name="text_name_notification">Notification Name</string>
|
||||||
</resources>
|
</resources>
|
||||||
Loading…
Reference in New Issue