// This file is part of OpenCV project. // It is subject to the license terms in the LICENSE file found in the top-level directory // of this distribution and at http://opencv.org/license.html // Contributed by Giles Payne #include "precomp.hpp" #include #include #include #include #include #include #include #include #include #include #include using namespace cv; #define TAG "NativeCamera" #define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, TAG, __VA_ARGS__) #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__) #define LOGW(...) __android_log_print(ANDROID_LOG_WARN, TAG, __VA_ARGS__) #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__) #define MAX_BUF_COUNT 4 #define COLOR_FormatUnknown -1 #define COLOR_FormatYUV420Planar 19 #define COLOR_FormatYUV420SemiPlanar 21 #define FOURCC_BGR CV_FOURCC_MACRO('B','G','R','3') #define FOURCC_RGB CV_FOURCC_MACRO('R','G','B','3') #define FOURCC_BGRA CV_FOURCC_MACRO('B','G','R','4') #define FOURCC_RGBA CV_FOURCC_MACRO('R','G','B','4') #define FOURCC_GRAY CV_FOURCC_MACRO('G','R','E','Y') #define FOURCC_NV21 CV_FOURCC_MACRO('N','V','2','1') #define FOURCC_YV12 CV_FOURCC_MACRO('Y','V','1','2') #define FOURCC_UNKNOWN 0xFFFFFFFF template struct RangeValue { T min, max; RangeValue(T minv = 0, T maxv = 0) : min(minv), max(maxv) {} bool isValid() const { return (min != max); } T percentage(int percent) const { return static_cast(min + ((max - min) * percent) / 100); } T clamp( T value ) const { return (value > max) ? max : ((value < min) ? min : value); } }; template using AObjPtr = std::unique_ptr>; enum class CaptureSessionState { INITIALIZING, // session is ready READY, // session is ready ACTIVE, // session is busy CLOSED // session was closed }; #define CAPTURE_TIMEOUT_SECONDS 2 #define CAPTURE_POLL_INTERVAL_MS 5 /** * 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 RangeValue exposureTimeLimits = { 1000000, 250000000 }; static double elapsedTimeFrom(std::chrono::time_point start) { return std::chrono::duration(std::chrono::system_clock::now() - start).count(); } class AndroidCameraCapture : public IVideoCapture { int deviceIndex; AObjPtr cameraManager { nullptr, ACameraManager_delete }; AObjPtr cameraDevice { nullptr, ACameraDevice_close }; AObjPtr imageReader { nullptr, AImageReader_delete }; AObjPtr outputContainer { nullptr, ACaptureSessionOutputContainer_free }; AObjPtr sessionOutput { nullptr, ACaptureSessionOutput_free }; AObjPtr nativeWindow { nullptr, ANativeWindow_release }; AObjPtr outputTarget { nullptr, ACameraOutputTarget_free }; AObjPtr captureRequest { nullptr, ACaptureRequest_free }; AObjPtr captureSession { nullptr, ACameraCaptureSession_close }; CaptureSessionState sessionState = CaptureSessionState::INITIALIZING; int32_t frameWidth = 0; int32_t frameStride = 0; int32_t frameHeight = 0; int32_t colorFormat = COLOR_FormatUnknown; std::vector buffer; bool sessionOutputAdded = false; bool targetAdded = false; // properties uint32_t fourCC = FOURCC_UNKNOWN; int32_t desiredWidth = 640; int32_t desiredHeight = 480; enum SetupState { setupDone = 0, setupWidth = 0x01, setupHeight = 0x02 } widthHeightState = setupDone; uint8_t flashMode = ACAMERA_FLASH_MODE_OFF; uint8_t aeMode = ACAMERA_CONTROL_AE_MODE_ON; int64_t exposureTime = 0; RangeValue exposureRange; int32_t sensitivity = 0; RangeValue sensitivityRange; float zoomRatio = 1.0f; RangeValue zoomRange; ACameraDevice_stateCallbacks deviceCallbacks = {}; ACameraCaptureSession_stateCallbacks sessionCallbacks = {}; ACameraCaptureSession_captureCallbacks captureCallbacks = {}; static void OnDeviceDisconnect(void* ctx, ACameraDevice* dev); static void OnDeviceError(void* ctx, ACameraDevice* dev, int err); static void OnSessionClosed(void* context, ACameraCaptureSession* session); static void OnSessionReady(void* context, ACameraCaptureSession* session); static void OnSessionActive(void* context, ACameraCaptureSession* session); static void OnCaptureCompleted(void* context, ACameraCaptureSession* session, ACaptureRequest* request, const ACameraMetadata* result); static void OnCaptureFailed(void* context, ACameraCaptureSession* session, ACaptureRequest* request, ACameraCaptureFailure* failure); // for synchronization with NDK capture callback bool waitingCapture = false; bool captureSuccess = false; std::mutex mtx; std::condition_variable condition; public: AndroidCameraCapture(int index, const VideoCaptureParameters& params) : deviceIndex(index) { deviceCallbacks.context = this; deviceCallbacks.onError = OnDeviceError; deviceCallbacks.onDisconnected = OnDeviceDisconnect, sessionCallbacks.context = this; sessionCallbacks.onReady = OnSessionReady; sessionCallbacks.onActive = OnSessionActive; sessionCallbacks.onClosed = OnSessionClosed; captureCallbacks.context = this; captureCallbacks.onCaptureCompleted = OnCaptureCompleted; captureCallbacks.onCaptureFailed = OnCaptureFailed; desiredWidth = params.get(CAP_PROP_FRAME_WIDTH, desiredWidth); desiredHeight = params.get(CAP_PROP_FRAME_HEIGHT, desiredHeight); static const struct { int propId; uint32_t defaultValue; } items[] = { { CAP_PROP_AUTO_EXPOSURE, 1 }, { CAP_PROP_FOURCC, FOURCC_UNKNOWN }, { CAP_PROP_ANDROID_DEVICE_TORCH, 0 } }; for (auto it = std::begin(items); it != std::end(items); ++it) { setProperty(it->propId, params.get(it->propId, it->defaultValue)); } } ~AndroidCameraCapture() { cleanUp(); } bool isOpened() const CV_OVERRIDE { return imageReader && captureSession; } int getCaptureDomain() CV_OVERRIDE { return CAP_ANDROID; } bool grabFrame() CV_OVERRIDE { AImage* img; { std::unique_lock lock(mtx); media_status_t mStatus = AImageReader_acquireLatestImage(imageReader.get(), &img); if (mStatus != AMEDIA_OK) { if (mStatus == AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE) { // this error is not fatal - we just need to wait for a buffer to become available LOGW("No Buffer Available error occurred - waiting for callback"); waitingCapture = true; captureSuccess = false; auto start = std::chrono::system_clock::now(); bool captured = condition.wait_for(lock, std::chrono::seconds( CAPTURE_TIMEOUT_SECONDS), [this]{ return captureSuccess; }); waitingCapture = false; if (captured) { mStatus = AImageReader_acquireLatestImage(imageReader.get(), &img); // even though an image has been captured we may not be able to acquire it // straight away so we poll every 10ms while (mStatus == AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE && elapsedTimeFrom(start) < CAPTURE_TIMEOUT_SECONDS) { std::this_thread::sleep_for(std::chrono::milliseconds(CAPTURE_POLL_INTERVAL_MS)); mStatus = AImageReader_acquireLatestImage(imageReader.get(), &img); } if (mStatus != AMEDIA_OK) { LOGE("Acquire image failed with error code: %d", mStatus); if (elapsedTimeFrom(start) >= CAPTURE_TIMEOUT_SECONDS) { LOGE("Image acquisition timed out"); } return false; } } else { LOGE("Capture failed or callback timed out"); return false; } } else { LOGE("Acquire image failed with error code: %d", mStatus); return false; } } } AObjPtr image(img, AImage_delete); int32_t srcFormat = -1; AImage_getFormat(image.get(), &srcFormat); if (srcFormat != AIMAGE_FORMAT_YUV_420_888) { LOGE("Incorrect image format"); return false; } int32_t srcPlanes = 0; AImage_getNumberOfPlanes(image.get(), &srcPlanes); if (srcPlanes != 3) { LOGE("Incorrect number of planes in image data"); return false; } int32_t yStride, uvStride; uint8_t *yPixel, *uPixel, *vPixel; int32_t yLen, uLen, vLen; int32_t uvPixelStride; AImage_getPlaneRowStride(image.get(), 0, &yStride); AImage_getPlaneRowStride(image.get(), 1, &uvStride); AImage_getPlaneData(image.get(), 0, &yPixel, &yLen); AImage_getPlaneData(image.get(), 1, &uPixel, &uLen); AImage_getPlaneData(image.get(), 2, &vPixel, &vLen); AImage_getPlanePixelStride(image.get(), 1, &uvPixelStride); int32_t yBufferLen = yLen; if ( (uvPixelStride == 2) && (uPixel == vPixel + 1) && (yLen == (yStride * (frameHeight - 1)) + frameWidth) && (uLen == (uvStride * ((frameHeight / 2) - 1)) + frameWidth - 1) && (uvStride == yStride) && (vLen == uLen) ) { frameStride = yStride; yBufferLen = frameStride * frameHeight; colorFormat = COLOR_FormatYUV420SemiPlanar; if (fourCC == FOURCC_UNKNOWN) { fourCC = FOURCC_NV21; } } else if ( (uvPixelStride == 1) && (uPixel == vPixel + vLen) && (yLen == frameWidth * frameHeight) && (uLen == yLen / 4) && (vLen == uLen) ) { colorFormat = COLOR_FormatYUV420Planar; if (fourCC == FOURCC_UNKNOWN) { fourCC = FOURCC_YV12; } } else { colorFormat = COLOR_FormatUnknown; fourCC = FOURCC_UNKNOWN; LOGE("Unsupported format"); return false; } buffer.clear(); buffer.insert(buffer.end(), yPixel, yPixel + yBufferLen); buffer.insert(buffer.end(), vPixel, vPixel + yBufferLen / 2); return true; } bool retrieveFrame(int, OutputArray out) CV_OVERRIDE { if (buffer.empty()) { return false; } if (colorFormat == COLOR_FormatYUV420Planar) { const Mat yuv(frameHeight + frameHeight/2, frameWidth, CV_8UC1, buffer.data()); switch (fourCC) { case FOURCC_BGRA: cvtColor(yuv, out, COLOR_YUV2BGRA_YV12); break; case FOURCC_RGBA: cvtColor(yuv, out, COLOR_YUV2RGBA_YV12); break; case FOURCC_BGR: cvtColor(yuv, out, COLOR_YUV2BGR_YV12); break; case FOURCC_RGB: cvtColor(yuv, out, COLOR_YUV2RGB_YV12); break; case FOURCC_GRAY: cvtColor(yuv, out, COLOR_YUV2GRAY_YV12); break; case FOURCC_YV12: yuv.copyTo(out); break; default: LOGE("Unexpected FOURCC value: %d", fourCC); return false; } } else if (colorFormat == COLOR_FormatYUV420SemiPlanar) { const Mat yuv(frameHeight + frameHeight/2, frameWidth, CV_8UC1, buffer.data(), frameStride); switch (fourCC) { case FOURCC_BGRA: cvtColor(yuv, out, COLOR_YUV2BGRA_NV21); break; case FOURCC_RGBA: cvtColor(yuv, out, COLOR_YUV2RGBA_NV21); break; case FOURCC_BGR: cvtColor(yuv, out, COLOR_YUV2BGR_NV21); break; case FOURCC_RGB: cvtColor(yuv, out, COLOR_YUV2RGB_NV21); break; case FOURCC_GRAY: cvtColor(yuv, out, COLOR_YUV2GRAY_NV21); break; case FOURCC_NV21: yuv.copyTo(out); break; default: LOGE("Unexpected FOURCC value: %d", fourCC); return false; } } else { LOGE("Unsupported video format: %d", colorFormat); return false; } return true; } double getProperty(int property_id) const CV_OVERRIDE { switch (property_id) { case CAP_PROP_FRAME_WIDTH: return isOpened() ? frameWidth : desiredWidth; case CAP_PROP_FRAME_HEIGHT: return isOpened() ? frameHeight : desiredHeight; case CAP_PROP_AUTO_EXPOSURE: return (aeMode == ACAMERA_CONTROL_AE_MODE_ON) ? 1 : 0; case CAP_PROP_EXPOSURE: return exposureTime; case CAP_PROP_ISO_SPEED: return sensitivity; case CAP_PROP_FOURCC: return fourCC; case CAP_PROP_ANDROID_DEVICE_TORCH: return (flashMode == ACAMERA_FLASH_MODE_TORCH) ? 1 : 0; case CAP_PROP_ZOOM: return zoomRange.isValid() ? zoomRatio : -1; default: break; } // unknown parameter or value not available return -1; } bool setProperty(int property_id, double value) CV_OVERRIDE { switch (property_id) { case CAP_PROP_FRAME_WIDTH: desiredWidth = static_cast(value); setWidthHeight(setupWidth); return true; case CAP_PROP_FRAME_HEIGHT: desiredHeight = static_cast(value); setWidthHeight(setupHeight); return true; case CAP_PROP_FOURCC: { uint32_t newFourCC = cvRound(value); if (fourCC == newFourCC) { return true; } else { switch (newFourCC) { case FOURCC_BGR: case FOURCC_RGB: case FOURCC_BGRA: case FOURCC_RGBA: case FOURCC_GRAY: fourCC = newFourCC; return true; case FOURCC_YV12: if (colorFormat == COLOR_FormatYUV420Planar) { fourCC = newFourCC; return true; } else { LOGE("Unsupported FOURCC conversion COLOR_FormatYUV420SemiPlanar" " -> COLOR_FormatYUV420Planar"); return false; } case FOURCC_NV21: if (colorFormat == COLOR_FormatYUV420SemiPlanar) { fourCC = newFourCC; return true; } else { LOGE("Unsupported FOURCC conversion COLOR_FormatYUV420Planar" " -> COLOR_FormatYUV420SemiPlanar"); return false; } default: LOGE("Unsupported FOURCC value: %d\n", fourCC); return false; } } } case CAP_PROP_AUTO_EXPOSURE: aeMode = (value != 0) ? ACAMERA_CONTROL_AE_MODE_ON : ACAMERA_CONTROL_AE_MODE_OFF; if (isOpened()) { return submitRequest(ACaptureRequest_setEntry_u8, ACAMERA_CONTROL_AE_MODE, aeMode); } return true; case CAP_PROP_EXPOSURE: if (isOpened() && exposureRange.isValid()) { exposureTime = exposureRange.clamp(static_cast(value)); LOGI("Setting CAP_PROP_EXPOSURE will have no effect unless CAP_PROP_AUTO_EXPOSURE is off"); return submitRequest(ACaptureRequest_setEntry_i64, ACAMERA_SENSOR_EXPOSURE_TIME, exposureTime); } return false; case CAP_PROP_ISO_SPEED: if (isOpened() && sensitivityRange.isValid()) { sensitivity = sensitivityRange.clamp(static_cast(value)); LOGI("Setting CAP_PROP_ISO_SPEED will have no effect unless CAP_PROP_AUTO_EXPOSURE is off"); return submitRequest(ACaptureRequest_setEntry_i32, ACAMERA_SENSOR_SENSITIVITY, sensitivity); } return false; case CAP_PROP_ZOOM: if (isOpened() && zoomRange.isValid()) { zoomRatio = zoomRange.clamp(static_cast(value)); return submitRequest(ACaptureRequest_setEntry_float, ACAMERA_CONTROL_ZOOM_RATIO, zoomRatio); } return true; case CAP_PROP_ANDROID_DEVICE_TORCH: flashMode = (value != 0) ? ACAMERA_FLASH_MODE_TORCH : ACAMERA_FLASH_MODE_OFF; if (isOpened()) { return submitRequest(ACaptureRequest_setEntry_u8, ACAMERA_FLASH_MODE, flashMode); } return true; default: break; } return false; } bool initCapture() { cameraManager.reset(ACameraManager_create()); if (!cameraManager) { LOGE("Cannot create camera manager!"); return false; } ACameraIdList* cameraIds; camera_status_t cStatus = ACameraManager_getCameraIdList(cameraManager.get(), &cameraIds); if (cStatus != ACAMERA_OK) { LOGE("Get camera list failed with error code: %d", cStatus); return false; } AObjPtr cameraIdList(cameraIds, ACameraManager_deleteCameraIdList); if (deviceIndex < 0 || deviceIndex >= cameraIds->numCameras) { LOGE("Camera index out of range %d (Number of cameras: %d)", deviceIndex, cameraIds->numCameras); return false; } const char *cameraId = cameraIdList.get()->cameraIds[deviceIndex]; ACameraDevice* camera; cStatus = ACameraManager_openCamera(cameraManager.get(), cameraId, &deviceCallbacks, &camera); if (cStatus != ACAMERA_OK) { LOGE("Open camera failed with error code: %d", cStatus); return false; } cameraDevice.reset(camera); ACameraMetadata* metadata; cStatus = ACameraManager_getCameraCharacteristics(cameraManager.get(), cameraId, &metadata); if (cStatus != ACAMERA_OK) { LOGE("Get camera characteristics failed with error code: %d", cStatus); return false; } AObjPtr cameraMetadata(metadata, ACameraMetadata_free); getPropertyRanges(cameraMetadata.get()); int32_t bestMatchWidth = 0, bestMatchHeight = 0; findResolutionMatch(cameraMetadata.get(), bestMatchWidth, bestMatchHeight); LOGI("Best resolution match: %dx%d", bestMatchWidth, bestMatchHeight); AImageReader* reader; media_status_t mStatus = AImageReader_new(bestMatchWidth, bestMatchHeight, AIMAGE_FORMAT_YUV_420_888, MAX_BUF_COUNT, &reader); if (mStatus != AMEDIA_OK) { LOGE("ImageReader creation failed with error code: %d", mStatus); return false; } frameWidth = bestMatchWidth; frameHeight = bestMatchHeight; imageReader.reset(reader); ANativeWindow* window; mStatus = AImageReader_getWindow(imageReader.get(), &window); if (mStatus != AMEDIA_OK) { LOGE("Could not get ANativeWindow: %d", mStatus); return false; } nativeWindow.reset(window); ANativeWindow_acquire(nativeWindow.get()); ACaptureSessionOutputContainer* container; cStatus = ACaptureSessionOutputContainer_create(&container); if (cStatus != ACAMERA_OK) { LOGE("CaptureSessionOutputContainer creation failed with error code: %d", cStatus); return false; } outputContainer.reset(container); ACaptureSessionOutput* output; cStatus = ACaptureSessionOutput_create(nativeWindow.get(), &output); if (cStatus != ACAMERA_OK) { LOGE("CaptureSessionOutput creation failed with error code: %d", cStatus); return false; } sessionOutput.reset(output); cStatus = ACaptureSessionOutputContainer_add(outputContainer.get(), sessionOutput.get()); if (cStatus != ACAMERA_OK) { LOGE("CaptureSessionOutput Container add failed with error code: %d", cStatus); return false; } sessionOutputAdded = true; ACameraOutputTarget* target; cStatus = ACameraOutputTarget_create(nativeWindow.get(), &target); if (cStatus != ACAMERA_OK) { LOGE("CameraOutputTarget creation failed with error code: %d", cStatus); return false; } outputTarget.reset(target); ACaptureRequest* request; cStatus = ACameraDevice_createCaptureRequest(cameraDevice.get(), TEMPLATE_PREVIEW, &request); if (cStatus != ACAMERA_OK) { LOGE("CaptureRequest creation failed with error code: %d", cStatus); return false; } captureRequest.reset(request); cStatus = ACaptureRequest_addTarget(captureRequest.get(), outputTarget.get()); if (cStatus != ACAMERA_OK) { LOGE("Add target to CaptureRequest failed with error code: %d", cStatus); return false; } targetAdded = true; ACameraCaptureSession* session; cStatus = ACameraDevice_createCaptureSession(cameraDevice.get(), outputContainer.get(), &sessionCallbacks, &session); if (cStatus != ACAMERA_OK) { LOGE("CaptureSession creation failed with error code: %d", cStatus); return false; } captureSession.reset(session); ACaptureRequest_setEntry_u8(captureRequest.get(), ACAMERA_CONTROL_AE_MODE, 1, &aeMode); if (aeMode != ACAMERA_CONTROL_AE_MODE_ON) { ACaptureRequest_setEntry_i32(captureRequest.get(), ACAMERA_SENSOR_SENSITIVITY, 1, &sensitivity); ACaptureRequest_setEntry_i64(captureRequest.get(), ACAMERA_SENSOR_EXPOSURE_TIME, 1, &exposureTime); } if (zoomRange.isValid()) { ACaptureRequest_setEntry_float(captureRequest.get(), ACAMERA_CONTROL_ZOOM_RATIO, 1, &zoomRatio); } ACaptureRequest_setEntry_u8(captureRequest.get(), ACAMERA_FLASH_MODE, 1, &flashMode); cStatus = ACameraCaptureSession_setRepeatingRequest(captureSession.get(), &captureCallbacks, 1, &request, nullptr); if (cStatus != ACAMERA_OK) { LOGE("CameraCaptureSession set repeating request failed with error code: %d", cStatus); return false; } return true; } private: void getPropertyRanges(const ACameraMetadata* metadata) { camera_status_t cStatus; ACameraMetadata_const_entry val; cStatus = ACameraMetadata_getConstEntry(metadata, ACAMERA_SENSOR_INFO_EXPOSURE_TIME_RANGE, &val); if (cStatus == ACAMERA_OK) { exposureRange.min = exposureTimeLimits.clamp(val.data.i64[0]); exposureRange.max = exposureTimeLimits.clamp(val.data.i64[1]); exposureTime = exposureRange.percentage(2); } else { LOGW("Unsupported ACAMERA_SENSOR_INFO_EXPOSURE_TIME_RANGE"); exposureRange.min = exposureRange.max = 0; exposureTime = 0; } cStatus = ACameraMetadata_getConstEntry(metadata, ACAMERA_SENSOR_INFO_SENSITIVITY_RANGE, &val); if (cStatus == ACAMERA_OK){ sensitivityRange.min = val.data.i32[0]; sensitivityRange.max = val.data.i32[1]; sensitivity = sensitivityRange.percentage(2); } else { LOGW("Unsupported ACAMERA_SENSOR_INFO_SENSITIVITY_RANGE"); sensitivityRange.min = sensitivityRange.max = 0; sensitivity = 0; } cStatus = ACameraMetadata_getConstEntry(metadata, ACAMERA_CONTROL_ZOOM_RATIO_RANGE, &val); if (cStatus == ACAMERA_OK){ zoomRange.min = val.data.f[0]; zoomRange.max = val.data.f[1]; zoomRatio = zoomRange.clamp(zoomRatio); } else { LOGW("Unsupported ACAMERA_CONTROL_ZOOM_RATIO_RANGE"); zoomRange.min = zoomRange.max = 0; zoomRatio = 1.0f; } } // calculate a score based on how well the width and height match the desired width and height // basically draw the 2 rectangle on top of each other and take the ratio of the non-overlapping // area to the overlapping area double getScore(int32_t width, int32_t height) const { double area1 = width * height; double area2 = desiredWidth * desiredHeight; if ((width < desiredWidth) == (height < desiredHeight)) { return (width < desiredWidth) ? (area2 - area1)/area1 : (area1 - area2)/area2; } else { int32_t overlappedWidth = std::min(width, desiredWidth); int32_t overlappedHeight = std::min(height, desiredHeight); double overlappedArea = overlappedWidth * overlappedHeight; return (area1 + area2 - overlappedArea)/overlappedArea; } } void findResolutionMatch(const ACameraMetadata* metadata, int32_t &bestMatchWidth, int32_t &bestMatchHeight) const { ACameraMetadata_const_entry entry = {}; ACameraMetadata_getConstEntry(metadata, ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, &entry); double bestScore = std::numeric_limits::max(); for (uint32_t 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 && format == AIMAGE_FORMAT_YUV_420_888) { int32_t width = entry.data.i32[i + 1]; int32_t height = entry.data.i32[i + 2]; if (width == desiredWidth && height == desiredHeight) { bestMatchWidth = width; bestMatchHeight = height; return; } double score = getScore(width, height); if (score < bestScore) { bestMatchWidth = width; bestMatchHeight = height; bestScore = score; } } } } void setWidthHeight(SetupState newState) { if ((widthHeightState | newState) == (setupWidth | setupHeight)) { cleanUp(); initCapture(); newState = setupDone; } widthHeightState = newState; } void cleanUp() { if (sessionState == CaptureSessionState::ACTIVE) { ACameraCaptureSession_stopRepeating(captureSession.get()); } captureSession.reset(); if (targetAdded) { ACaptureRequest_removeTarget(captureRequest.get(), outputTarget.get()); targetAdded = false; } captureRequest.reset(); outputTarget.reset(); if (sessionOutputAdded) { ACaptureSessionOutputContainer_remove(outputContainer.get(), sessionOutput.get()); sessionOutputAdded = false; } sessionOutput.reset(); nativeWindow.reset(); outputContainer.reset(); cameraDevice.reset(); cameraManager.reset(); imageReader.reset(); } template bool submitRequest(FuncT setFn, uint32_t tag, const T &data) { ACaptureRequest *request = captureRequest.get(); return request && setFn(request, tag, 1, &data) == ACAMERA_OK && ACameraCaptureSession_setRepeatingRequest(captureSession.get(), &captureCallbacks, 1, &request, nullptr) == ACAMERA_OK; } }; /******************************** Device management *******************************/ void AndroidCameraCapture::OnDeviceDisconnect(void* /* ctx */, ACameraDevice* dev) { const char *id = ACameraDevice_getId(dev); LOGW("Device %s disconnected", id ? id : ""); } void AndroidCameraCapture::OnDeviceError(void* /* ctx */, ACameraDevice* dev, int err) { const char *id = ACameraDevice_getId(dev); LOGI("Camera Device Error: %#x, Device %s", err, id ? id : ""); switch (err) { case ERROR_CAMERA_IN_USE: LOGI("Camera in use"); break; case ERROR_CAMERA_SERVICE: LOGI("Fatal Error occurred in Camera Service"); break; case ERROR_CAMERA_DEVICE: LOGI("Fatal Error occurred in Camera Device"); break; case ERROR_CAMERA_DISABLED: LOGI("Camera disabled"); break; case ERROR_MAX_CAMERAS_IN_USE: LOGI("System limit for maximum concurrent cameras used was exceeded"); break; default: LOGI("Unknown Camera Device Error: %#x", err); } } /******************************** Session management *******************************/ void AndroidCameraCapture::OnSessionClosed(void* context, ACameraCaptureSession* session) { if (context == nullptr) return; LOGW("session %p closed", session); static_cast(context)->sessionState = CaptureSessionState::CLOSED; } void AndroidCameraCapture::OnSessionReady(void* context, ACameraCaptureSession* session) { if (context == nullptr) return; LOGW("session %p ready", session); static_cast(context)->sessionState = CaptureSessionState::READY; } void AndroidCameraCapture::OnSessionActive(void* context, ACameraCaptureSession* session) { if (context == nullptr) return; LOGW("session %p active", session); static_cast(context)->sessionState = CaptureSessionState::ACTIVE; } void AndroidCameraCapture::OnCaptureCompleted(void* context, ACameraCaptureSession* session, ACaptureRequest* /* request */, const ACameraMetadata* /* result */) { if (context == nullptr) return; LOGV("session %p capture completed", session); AndroidCameraCapture* cameraCapture = static_cast(context); std::unique_lock lock(cameraCapture->mtx); if (cameraCapture->waitingCapture) { cameraCapture->waitingCapture = false; cameraCapture->captureSuccess = true; cameraCapture->condition.notify_one(); } } void AndroidCameraCapture::OnCaptureFailed(void* context, ACameraCaptureSession* session, ACaptureRequest* /* request */, ACameraCaptureFailure* /* failure */) { if (context == nullptr) return; LOGV("session %p capture failed", session); AndroidCameraCapture* cameraCapture = static_cast(context); std::unique_lock lock(cameraCapture->mtx); if (cameraCapture->waitingCapture) { cameraCapture->waitingCapture = false; cameraCapture->captureSuccess = false; cameraCapture->condition.notify_one(); } } /****************** Implementation of interface functions ********************/ Ptr cv::createAndroidCapture_cam(int index, const VideoCaptureParameters& params) { Ptr res = makePtr(index, params); if (res && res->initCapture()) return res; return Ptr(); }