SENSAndroidCamera Class Reference

#include <SENSAndroidCamera.h>

Inheritance diagram for SENSAndroidCamera:

Public Member Functions
	SENSAndroidCamera ()
	~SENSAndroidCamera ()
const SENSCameraConfig &	start (std::string deviceId, const SENSCameraStreamConfig &streamConfig, bool provideIntrinsics=true) override
void	stop () override
	Stop a started camera device. More...
const SENSCaptureProps &	captureProperties () override
	Get SENSCaptureProps which contains necessary information about all available camera devices and their capabilities. More...
void	onDeviceDisconnected (ACameraDevice *dev)
void	onDeviceError (ACameraDevice *dev, int err)
void	onCameraStatusChanged (const char *id, bool available)
void	onSessionState (ACameraCaptureSession *ses, CaptureSessionState state)
void	imageCallback (AImageReader *reader)
Public Member Functions inherited from SENSBaseCamera
SENSFrameBasePtr	latestFrame () override
	Get the latest captured frame. If no frame was captured the frame will be empty (null). More...
const SENSCameraConfig &	config () const override
	defines how the camera was configured during start More...
void	registerListener (SENSCameraListener *listener) override
void	unregisterListener (SENSCameraListener *listener) override
bool	started () const override
bool	permissionGranted () const override
void	setPermissionGranted () override
Public Member Functions inherited from SENSCamera
virtual	~SENSCamera ()

Private Member Functions
void	openCamera ()
void	createCaptureSession ()

Static Private Member Functions
static cv::Mat	convertToYuv (AImage *image)

Private Attributes
ACameraManager_AvailabilityCallbacks	_cameraManagerAvailabilityCallbacks
ACameraManager *	_cameraManager = nullptr
ACameraDevice *	_cameraDevice = nullptr
AImageReader *	_imageReader = nullptr
ANativeWindow *	_surface = nullptr
ACaptureSessionOutput *	_captureSessionOutput = nullptr
ACaptureSessionOutputContainer *	_captureSessionOutputContainer = nullptr
ACameraOutputTarget *	_cameraOutputTarget = nullptr
ACaptureRequest *	_captureRequest = nullptr
ACameraCaptureSession *	_captureSession = nullptr
CaptureSessionState	_captureSessionState = CaptureSessionState::MAX_STATE
std::condition_variable	_captureSessionStateCV
std::mutex	_captureSessionStateMutex
std::map< std::string, bool >	_cameraAvailability
std::mutex	_cameraAvailabilityMutex
std::condition_variable	_openCameraCV
std::atomic< bool >	_cameraDeviceOpened {false}
cv::Size	_captureSize

Additional Inherited Members
Protected Member Functions inherited from SENSBaseCamera
void	updateFrame (cv::Mat bgrImg, cv::Mat intrinsics, int width, int height, bool intrinsicsChanged)
void	processStart ()
	call from start function to do startup preprocessing More...
Protected Attributes inherited from SENSBaseCamera
SENSCaptureProps	_captureProperties
std::atomic< bool >	_started {false}
	flags if camera was started More...
SENSCameraConfig	_config
	indicates what is currently running More...
std::atomic< bool >	_permissionGranted {false}
std::vector< SENSCameraListener * >	_listeners
std::mutex	_listenerMutex
SENSFrameBasePtr	_frame
	current frame More...
std::mutex	_frameMutex

Detailed Description

Definition at line 32 of file SENSAndroidCamera.h.

Constructor & Destructor Documentation

SENSAndroidCamera()

SENSAndroidCamera::SENSAndroidCamera

(

)

Definition at line 74 of file SENSAndroidCamera.cpp.

  : _cameraDeviceOpened(false)
{
    LOG_NDKCAM_INFO("Camera instantiated");
}

~SENSAndroidCamera()

SENSAndroidCamera::~SENSAndroidCamera

(

)

Definition at line 80 of file SENSAndroidCamera.cpp.

{
    //stop();
    LOG_NDKCAM_INFO("~SENSAndroidCamera: Camera destructor finished");
}

Member Function Documentation

captureProperties()

const SENSCaptureProps & SENSAndroidCamera::captureProperties ( )

overridevirtual

Get SENSCaptureProps which contains necessary information about all available camera devices and their capabilities.

Implements SENSCamera.

Definition at line 652 of file SENSAndroidCamera.cpp.

{
    if (_captureProperties.size() == 0)
    {
        ACameraManager* cameraManager = ACameraManager_create();
        if (!cameraManager)
            throw SENSException(SENSType::CAM, "Could not instantiate camera manager!", __LINE__, __FILE__);
 
        ACameraIdList* cameraIds = nullptr;
        if (ACameraManager_getCameraIdList(cameraManager, &cameraIds) != ACAMERA_OK)
            throw SENSException(SENSType::CAM, "Could not retrieve camera list!", __LINE__, __FILE__);
 
        for (int i = 0; i < cameraIds->numCameras; ++i)
        {
            std::string cameraId = cameraIds->cameraIds[i];
 
            ACameraMetadata* camCharacteristics;
            ACameraManager_getCameraCharacteristics(cameraManager, cameraId.c_str(), &camCharacteristics);
 
            int32_t         numEntries = 0; //will be filled by getAllTags with number of entries
            const uint32_t* tags       = nullptr;
            ACameraMetadata_getAllTags(camCharacteristics, &numEntries, &tags);
 
            std::vector<float> focalLengthsMM;
            cv::Size2f         physicalSensorSizeMM;
            SENSCameraFacing   facing = SENSCameraFacing::UNKNOWN;
 
            //make a first loop to estimate physical sensor parameters
            for (int tagIdx = 0; tagIdx < numEntries; ++tagIdx)
            {
                ACameraMetadata_const_entry lensInfo = {0};
                //first check that ACAMERA_LENS_FACING is contained at all
                if (tags[tagIdx] == ACAMERA_LENS_FACING)
                {
                    ACameraMetadata_getConstEntry(camCharacteristics, tags[tagIdx], &lensInfo);
                    acamera_metadata_enum_android_lens_facing_t androidFacing = static_cast<acamera_metadata_enum_android_lens_facing_t>(lensInfo.data.u8[0]);
                    if (androidFacing == ACAMERA_LENS_FACING_BACK)
                        facing = SENSCameraFacing::BACK;
                    else if (androidFacing == ACAMERA_LENS_FACING_FRONT)
                        facing = SENSCameraFacing::FRONT;
                    else //if (androidFacing == ACAMERA_LENS_FACING_EXTERNAL)
                        facing = SENSCameraFacing::EXTERNAL;
                }
                else if (tags[tagIdx] == ACAMERA_LENS_INFO_AVAILABLE_FOCAL_LENGTHS)
                {
                    if (ACameraMetadata_getConstEntry(camCharacteristics, tags[tagIdx], &lensInfo) ==
                        ACAMERA_OK)
                    {
                        for (int i = 0; i < lensInfo.count; ++i)
                        {
                            //characteristics.focalLenghtsMM.push_back(lensInfo.data.f[i]);
                            focalLengthsMM.push_back(lensInfo.data.f[i]);
                        }
                    }
                }
                else if (tags[tagIdx] == ACAMERA_SENSOR_INFO_PHYSICAL_SIZE)
                {
                    if (ACameraMetadata_getConstEntry(camCharacteristics, tags[tagIdx], &lensInfo) == ACAMERA_OK)
                    {
                        //characteristics.physicalSensorSizeMM.width = lensInfo.data.f[0];
                        //characteristics.physicalSensorSizeMM.height = lensInfo.data.f[1];
 
                        physicalSensorSizeMM.width  = lensInfo.data.f[0];
                        physicalSensorSizeMM.height = lensInfo.data.f[1];
                    }
                }
            }
 
            //todo: if we have more than one focal length, what do we do?
            //if we have more than one focal length, we select the first one..
 
            SENSCameraDeviceProps characteristics(cameraId, facing);
 
            //in the second loop we use the physical sensor parameters to specify a focal length in pixel for every stream config
            for (int tagIdx = 0; tagIdx < numEntries; ++tagIdx)
            {
                if (tags[tagIdx] == ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS)
                {
                    ACameraMetadata_const_entry lensInfo = {0};
                    if (ACameraMetadata_getConstEntry(camCharacteristics, tags[tagIdx], &lensInfo) == ACAMERA_OK)
                    {
                        if (lensInfo.count & 0x3)
                            throw SENSException(SENSType::CAM,
                                                "STREAM_CONFIGURATION (%d) should multiple of 4",
                                                __LINE__,
                                                __FILE__);
 
                        if (lensInfo.type != ACAMERA_TYPE_INT32)
                            throw SENSException(SENSType::CAM,
                                                "STREAM_CONFIGURATION TYPE(%d) is not ACAMERA_TYPE_INT32(1)",
                                                __LINE__,
                                                __FILE__);
 
                        int width = 0, height = 0;
                        for (uint32_t i = 0; i < lensInfo.count; i += 4)
                        {
                            //example for content interpretation:
                            //std::string direction         = lensInfo.data.i32[i + 3] ? "INPUT" : "OUTPUT";
                            //std::string format            = GetFormatStr(lensInfo.data.i32[i]);
 
                            //OUTPUT format and AIMAGE_FORMAT_YUV_420_888 image format
                            if (!lensInfo.data.i32[i + 3] && lensInfo.data.i32[i] == AIMAGE_FORMAT_YUV_420_888)
                            {
                                width  = lensInfo.data.i32[i + 1];
                                height = lensInfo.data.i32[i + 2];
 
                                float focalLengthPix = -1.f;
                                if (focalLengthsMM.size() && physicalSensorSizeMM.width > 0 && physicalSensorSizeMM.height > 0)
                                {
                                    //we assume the image is cropped at one side only. we compare the sensor aspect ratio
                                    //with the image aspect ratio and use the uncropped length to estimate a focal length in pixel that fits to this stream configuration size
                                    if ((float)physicalSensorSizeMM.width / (float)physicalSensorSizeMM.height > (float)width / (float)height)
                                        focalLengthPix = focalLengthsMM.front() / physicalSensorSizeMM.height * (float)height;
                                    else
                                        focalLengthPix = focalLengthsMM.front() / physicalSensorSizeMM.width * (float)width;
                                }
 
                                if (!characteristics.contains({width, height}))
                                    characteristics.add(width, height, focalLengthPix);
                            }
                        }
                    }
                }
            }
            ACameraMetadata_free(camCharacteristics);
            _captureProperties.push_back(characteristics);
        }
 
        ACameraManager_deleteCameraIdList(cameraIds);
        ACameraManager_delete(cameraManager);
    }
 
    return _captureProperties;
}

convertToYuv()

cv::Mat SENSAndroidCamera::convertToYuv ( AImage *  image )

staticprivate

Definition at line 464 of file SENSAndroidCamera.cpp.

{
    int32_t height, width, rowStrideY;
    AImage_getHeight(image, &height);
    AImage_getWidth(image, &width);
    AImage_getPlaneRowStride(image, 0, &rowStrideY);
 
    //pointers to yuv data planes and length of yuv data planes in byte
    uint8_t *yPixel, /* *uPixel,*/ *vPixel;
    int32_t  yLen, /*uLen,*/ vLen;
    AImage_getPlaneData(image, 0, &yPixel, &yLen);
    //AImage_getPlaneData(image, 1, &uPixel, &uLen);
    AImage_getPlaneData(image, 2, &vPixel, &vLen);
 
    //Attention: There may be additional padding at the end of every line, in this case width is not equal to rowStrideY.
    //As this padding is not contained at the end of the Y-block, yLen can be calculated as follows:
    // yLen = rowStrideY * height - (rowStrideY - width)
    //But when copying the UV-block we have to "insert" the additional padding at the end of the Y-block
    //in the new yuv image!
    //(https://stackoverflow.com/questions/40030533/android-camera2-preview-output-sizes)
    //(https://stackoverflow.com/questions/52726002/camera2-captured-picture-conversion-from-yuv-420-888-to-nv21/52740776#52740776)
 
    //copy image data to yuv image: we use the rowStrideY to define the maximum data block width including potential padding
    cv::Mat yuv(height + (height / 2), rowStrideY, CV_8UC1);
    memcpy(yuv.data, yPixel, yLen);
    //The interleaved uv data starts with v pixels, you can inspect this by comparing uPixel and vPixel adresses,
    //which is one byte lower. So the order is V/U: NV12: YYYYUV NV21: YYYYVU
    // This is also described like this in wikipedia in section https://en.wikipedia.org/wiki/YUV#Y%E2%80%B2UV420sp_(NV21)_to_RGB_conversion_(Android)
    // U follows V in the interleaved block (in contradiction to what is shown in the drawing explaining yuv in wikipedia).
    // As both planes have the same length, but one starts one byte lower, we have to copy one
    //additional byte to get all the data (see vLen+1).
    //We do not have to additionally copy the v plane. The u plane contains the interleaved u and v data!
    memcpy(yuv.data + yLen + (rowStrideY - width), vPixel, vLen + 1);
 
    //If there is line padding we get rid of it now by defining a sub region of interest in the target image size
    if (rowStrideY > width)
    {
        cv::Rect roi(0, 0, width, yuv.rows);
        cv::Mat  roiYuv = yuv(roi);
        return roiYuv;
    }
    else
        return yuv;
}

createCaptureSession()

void SENSAndroidCamera::createCaptureSession ( )

private

Definition at line 324 of file SENSAndroidCamera.cpp.

{
    //Get the pointer to a surface from the image reader (Surface from java is like nativeWindow in ndk)
    AImageReader_getWindow(_imageReader, &_surface);
 
    // Avoid surface to be deleted
    ANativeWindow_acquire(_surface);
    //create a capture session and provide the surfaces to it
    ACaptureSessionOutput_create(_surface, &_captureSessionOutput);
    //create an output container for capture session and add it to the session
    ACaptureSessionOutputContainer_create(&_captureSessionOutputContainer);
    ACaptureSessionOutputContainer_add(_captureSessionOutputContainer, _captureSessionOutput);
 
    ACameraOutputTarget_create(_surface, &_cameraOutputTarget);
    ACameraDevice_createCaptureRequest(_cameraDevice, TEMPLATE_PREVIEW, &_captureRequest);
 
    ACaptureRequest_addTarget(_captureRequest, _cameraOutputTarget);
 
    _captureSessionState = CaptureSessionState::READY;
 
    ACameraCaptureSession_stateCallbacks captureSessionStateCallbacks = {
      .context  = this,
      .onActive = ::onSessionActive,
      .onReady  = ::onSessionReady,
      .onClosed = ::onSessionClosed};
    camera_status_t captureSessionStatus = ACameraDevice_createCaptureSession(_cameraDevice,
                                                                              _captureSessionOutputContainer,
                                                                              &captureSessionStateCallbacks,
                                                                              &_captureSession);
    if (captureSessionStatus != AMEDIA_OK)
    {
        LOG_NDKCAM_WARN("Creating capture session failed!");
    }
    //throw SENSException(SENSType::CAM, "Could not create capture session!", __LINE__, __FILE__);
 
    //adjust capture request properties:
 
    //auto focus mode
    if (_config.focusMode == SENSCameraFocusMode::FIXED_INFINITY_FOCUS)
    {
        uint8_t afMode = ACAMERA_CONTROL_AF_MODE_OFF;
        ACaptureRequest_setEntry_u8(_captureRequest, ACAMERA_CONTROL_AF_MODE, 1, &afMode);
        float focusDistance = 0.0f;
        ACaptureRequest_setEntry_float(_captureRequest, ACAMERA_LENS_FOCUS_DISTANCE, 1, &focusDistance);
    }
    else
    {
        uint8_t afMode = ACAMERA_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
        ACaptureRequest_setEntry_u8(_captureRequest, ACAMERA_CONTROL_AF_MODE, 1, &afMode);
    }
 
    //digital video stabilization (software) -> turn off by default (for now)
    {
        uint8_t mode = ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
        ACaptureRequest_setEntry_u8(_captureRequest, ACAMERA_CONTROL_VIDEO_STABILIZATION_MODE, 1, &mode);
    }
    //optical video stabilization (hardware)
    {
        uint8_t mode = ACAMERA_LENS_OPTICAL_STABILIZATION_MODE_OFF;
        ACaptureRequest_setEntry_u8(_captureRequest, ACAMERA_LENS_OPTICAL_STABILIZATION_MODE, 1, &mode);
    }
 
    //install repeating request
    ACameraCaptureSession_setRepeatingRequest(_captureSession, nullptr, 1, &_captureRequest, nullptr);
}

imageCallback()

void SENSAndroidCamera::imageCallback

(

AImageReader *

reader

)

Definition at line 509 of file SENSAndroidCamera.cpp.

{
    AImage*        image  = nullptr;
    media_status_t status = AImageReader_acquireLatestImage(reader, &image);
    if (status == AMEDIA_OK && image)
    {
        cv::Mat yuv = convertToYuv(image);
 
        AImage_delete(image);
 
        cv::Mat      bgr;
        HighResTimer t;
        cv::cvtColor(yuv, bgr, cv::COLOR_YUV2BGR_NV21, 3);
        SENS_DEBUG("SENSAndroidCamera: time for yuv conversion: %f ms", t.elapsedTimeInMilliSec());
 
        updateFrame(bgr, cv::Mat(), false, bgr.cols, bgr.rows);
    }
}

onCameraStatusChanged()

void SENSAndroidCamera::onCameraStatusChanged	(	const char *	id,
		bool	available
	)

OnCameraStatusChanged() handles Callback from ACameraManager

Definition at line 596 of file SENSAndroidCamera.cpp.

{
    LOG_NDKCAM_INFO("onCameraStatusChanged: id: %s available: %s ", id, available ? "true" : "false");
    {
        std::lock_guard<std::mutex> lock(_cameraAvailabilityMutex);
        _cameraAvailability[std::string(id)] = available;
    }
    _openCameraCV.notify_one();
}

onDeviceDisconnected()

void SENSAndroidCamera::onDeviceDisconnected

(

ACameraDevice *

dev

)

Handle Camera DeviceStateChanges msg, notify device is disconnected simply close the camera

Definition at line 532 of file SENSAndroidCamera.cpp.

{
    if (dev == _cameraDevice)
    {
        std::string id(ACameraDevice_getId(dev));
        LOG_NDKCAM_WARN("device %s is disconnected", id.c_str());
 
        {
            std::lock_guard<std::mutex> lock(_cameraAvailabilityMutex);
            _cameraAvailability[id] = false;
        }
 
        _cameraDeviceOpened = false;
        ACameraDevice_close(_cameraDevice);
        _cameraDevice = nullptr;
    }
}

onDeviceError()

void SENSAndroidCamera::onDeviceError	(	ACameraDevice *	dev,
		int	err
	)

Handles Camera's deviceErrorChanges message, no action; mainly debugging purpose

Definition at line 555 of file SENSAndroidCamera.cpp.

{
    if (dev == _cameraDevice)
    {
        std::string errStr;
        switch (err)
        {
            case ERROR_CAMERA_IN_USE:
                errStr = "ERROR_CAMERA_IN_USE";
                break;
            case ERROR_CAMERA_SERVICE:
                errStr = "ERROR_CAMERA_SERVICE";
                break;
            case ERROR_CAMERA_DEVICE:
                errStr = "ERROR_CAMERA_DEVICE";
                break;
            case ERROR_CAMERA_DISABLED:
                errStr = "ERROR_CAMERA_DISABLED";
                break;
            case ERROR_MAX_CAMERAS_IN_USE:
                errStr = "ERROR_MAX_CAMERAS_IN_USE";
                break;
            default:
                errStr = "Unknown Error";
        }
 
        std::string id(ACameraDevice_getId(dev));
        {
            std::lock_guard<std::mutex> lock(_cameraAvailabilityMutex);
            _cameraAvailability[id] = false;
        }
        _cameraDeviceOpened = false;
 
        LOG_NDKCAM_INFO("CameraDevice %s is in error %s", id.c_str(), errStr.c_str());
    }
}

onSessionState()

void SENSAndroidCamera::onSessionState	(	ACameraCaptureSession *	ses,
		CaptureSessionState	state
	)

Handles capture session state changes. Update into internal session state.

Definition at line 623 of file SENSAndroidCamera.cpp.

{
    if (!_captureSession)
        LOG_NDKCAM_WARN("onSessionState: CaptureSession is NULL");
 
    if (state >= CaptureSessionState::MAX_STATE)
    {
        throw SENSException(SENSType::CAM, "Wrong state " + std::to_string((int)state), __LINE__, __FILE__);
    }
 
    LOG_NDKCAM_WARN("onSessionState: CaptureSession state: %s", getPrintableState(state).c_str());
 
    {
        std::lock_guard<std::mutex> lock(_captureSessionStateMutex);
        _captureSessionState = state;
 
        if (_captureSessionState == CaptureSessionState::ACTIVE)
        {
            _started = true;
        }
        else
        {
            _started = false;
        }
    }
    _captureSessionStateCV.notify_one();
}

openCamera()

void SENSAndroidCamera::openCamera ( )

private

Definition at line 102 of file SENSAndroidCamera.cpp.

{
    //init camera manager
    if (!_cameraManager)
    {
        //init availability
        for (const SENSCameraDeviceProps& c : _captureProperties)
        {
            _cameraAvailability[c.deviceId()] = false;
        }
 
        LOG_NDKCAM_DEBUG("openCamera: Creating camera manager ...");
        _cameraManager = ACameraManager_create();
        if (!_cameraManager)
            throw SENSException(SENSType::CAM, "Could not instantiate camera manager!", __LINE__, __FILE__);
 
        //register callbacks
        _cameraManagerAvailabilityCallbacks = {
          .context             = this,
          .onCameraAvailable   = onCameraAvailable,
          .onCameraUnavailable = onCameraUnavailable,
        };
        ACameraManager_registerAvailabilityCallback(_cameraManager,
                                                    &_cameraManagerAvailabilityCallbacks);
 
        //Attention: if we never access the _cameraManager the onCameraStatusChanged never comes (seems to be an android bug)
        {
            ACameraIdList*  cameraIds = nullptr;
            camera_status_t status    = ACameraManager_getCameraIdList(_cameraManager, &cameraIds);
            ACameraManager_deleteCameraIdList(cameraIds);
            //PrintCameras(_cameraManager);
        }
        LOG_NDKCAM_DEBUG("openCamera: Camera manager created!");
    }
 
    //find current SENSCameraDeviceProps
    const SENSCameraDeviceProps* camProps = _captureProperties.camPropsForDeviceId(_config.deviceId);
 
    if (!_cameraDeviceOpened)
    {
        LOG_NDKCAM_DEBUG("openCamera: Camera device not open");
        auto condition = [&]
        {
            LOG_NDKCAM_DEBUG("openCamera: checking condition");
            return (_cameraAvailability[camProps->deviceId()]);
        };
        std::unique_lock<std::mutex> lock(_cameraAvailabilityMutex);
        //wait here before opening the required camera device until it is available
        _openCameraCV.wait(lock, condition);
 
        LOG_NDKCAM_DEBUG("openCamera: Opening camera ...");
        //open the so found camera with _characteristics.cameraId
        ACameraDevice_stateCallbacks cameraDeviceListener = {
          .context        = this,
          .onDisconnected = ::onDeviceDisconnected,
          .onError        = ::onDeviceErrorChanges,
        };
 
        camera_status_t cameraState;
        int             n    = 0;
        int             nMax = 10;
        while (n < nMax)
        {
            cameraState = ACameraManager_openCamera(_cameraManager,
                                                    camProps->deviceId().c_str(),
                                                    &cameraDeviceListener,
                                                    &_cameraDevice);
 
            if (cameraState == ACAMERA_OK)
                break;
            n++;
        }
 
        if (cameraState != ACAMERA_OK)
        {
            throw SENSException(SENSType::CAM, "Could not camera camera!", __LINE__, __FILE__);
        }
        else
        {
            _cameraDeviceOpened = true;
            LOG_NDKCAM_DEBUG("openCamera: Camera opened!");
        }
    }
    else
    {
        LOG_NDKCAM_DEBUG("openCamera: Camera device is already open");
    }
 
    const auto& streamConfig = _config.streamConfig;
    LOG_NDKCAM_INFO("openCamera: CaptureSize (%d, %d)", streamConfig.widthPix, streamConfig.heightPix);
 
    if (_imageReader && _captureSize != cv::Size(streamConfig.widthPix, streamConfig.heightPix))
    {
        LOG_NDKCAM_INFO("openCamera: ImageReader valid and captureSize does not fit");
        //stop repeating request and wait for stopped state
        if (_captureSession)
        {
            LOG_NDKCAM_DEBUG("openCamera: Stopping repeating request...");
            //if (_captureSessionState == CaptureSessionState::ACTIVE)
            //{
            ACameraCaptureSession_stopRepeating(_captureSession);
 
            auto condition = [&]
            {
                return (_captureSessionState != CaptureSessionState::ACTIVE);
            };
            std::unique_lock<std::mutex> lock(_captureSessionStateMutex);
            //wait here until capture session is stopped
            _captureSessionStateCV.wait(lock, condition);
            //}
            //else
            //    LOG_NDKCAM_WARN("CaptureSessionState NOT ACTIVE");
            LOG_NDKCAM_DEBUG("openCamera: Repeating request stopped!");
 
            //LOG_NDKCAM_DEBUG("stop: closing capture session...");
            //todo: it is recommended not to close before creating a new session
            //ACameraCaptureSession_close(_captureSession);
            //_captureSession = nullptr;
        }
 
        LOG_NDKCAM_DEBUG("openCamera: Free request stuff...");
        if (_captureRequest)
        {
            ACaptureRequest_removeTarget(_captureRequest, _cameraOutputTarget);
            ACaptureRequest_free(_captureRequest);
            _captureRequest = nullptr;
        }
 
        if (_captureSessionOutput)
        {
            ACaptureSessionOutputContainer_remove(_captureSessionOutputContainer,
                                                  _captureSessionOutput);
            ACaptureSessionOutput_free(_captureSessionOutput);
            _captureSessionOutput = nullptr;
        }
 
        if (_surface)
        {
            ANativeWindow_release(_surface);
            _surface = nullptr;
        }
 
        if (_captureSessionOutputContainer)
        {
            ACaptureSessionOutputContainer_free(_captureSessionOutputContainer);
            _captureSessionOutputContainer = nullptr;
        }
 
        if (_imageReader)
        {
            LOG_NDKCAM_DEBUG("openCamera: Deleting image reader...");
            AImageReader_delete(_imageReader);
            _imageReader = nullptr;
        }
    }
 
    if (_cameraDeviceOpened)
    {
        if (!_imageReader)
        {
            LOG_NDKCAM_INFO("openCamera: Creating image reader...");
 
            _captureSize = cv::Size(streamConfig.widthPix, streamConfig.heightPix);
 
            //create image reader with 2 surfaces (a surface is the like a ring buffer for images)
            if (AImageReader_new(streamConfig.widthPix, streamConfig.heightPix, AIMAGE_FORMAT_YUV_420_888, 2, &_imageReader) != AMEDIA_OK)
                throw SENSException(SENSType::CAM, "Could not create image reader!", __LINE__, __FILE__);
 
            //register onImageAvailable listener
            AImageReader_ImageListener listener{
              .context          = this,
              .onImageAvailable = onImageCallback,
            };
            AImageReader_setImageListener(_imageReader, &listener);
 
            createCaptureSession();
        }
    }
    else
    {
        //todo: throw something
    }
}

start()

const SENSCameraConfig & SENSAndroidCamera::start ( std::string  deviceId, const SENSCameraStreamConfig &  streamConfig, bool  provideIntrinsics = true  )

overridevirtual

Call this function to configure the camera if you exactly know, what device you want to open and with which stream configuration. You can find out these properties by using SENSCaptureProps object (see getCaptureProperties())

Parameters

deviceId	camera device id to start
streamConfig	SENSCameraStreamConfig from camera device. This defines the size of the image. The image is converted to BGR and assigned to SENSFrame::imgBGR.
provideIntrinsics	specifies if intrinsics estimation should be enabled. The estimated intrinsics are transferred with every SENSFrame as they may be different for every frame (e.g. on iOS). This value has different effects on different architectures.

Returns

the found configuration that is adjusted and used when SENSCamera::start() is called.

Implements SENSCamera.

Definition at line 286 of file SENSAndroidCamera.cpp.

{
    if (_started)
    {
        Utils::warnMsg("SENSWebCamera", "Call to start was ignored. Camera is currently running!", __LINE__, __FILE__);
        return _config;
    }
 
    //retrieve all camera characteristics
    if (_captureProperties.size() == 0)
        captureProperties();
 
    if (_captureProperties.size() == 0)
        throw SENSException(SENSType::CAM, "Could not retrieve camera properties!", __LINE__, __FILE__);
 
    if (!_captureProperties.containsDeviceId(deviceId))
        throw SENSException(SENSType::CAM, "DeviceId does not exist!", __LINE__, __FILE__);
 
    SENSCameraFacing             facing = SENSCameraFacing::UNKNOWN;
    const SENSCameraDeviceProps* props  = _captureProperties.camPropsForDeviceId(deviceId);
    if (props)
        facing = props->facing();
 
    //init config here
    _config = SENSCameraConfig(deviceId,
                               streamConfig,
                               facing,
                               SENSCameraFocusMode::UNKNOWN);
    processStart();
 
    openCamera();
 
    _started = true;
    return _config;
}

stop()

void SENSAndroidCamera::stop ( )

overridevirtual

Stop a started camera device.

Implements SENSCamera.

Definition at line 390 of file SENSAndroidCamera.cpp.

{
    if (_started)
    {
        if (_captureSession)
        {
            LOG_NDKCAM_DEBUG("stop: stopping repeating request...");
            if (_captureSessionState == CaptureSessionState::ACTIVE)
            {
                ACameraCaptureSession_stopRepeating(_captureSession);
            }
            else
                LOG_NDKCAM_WARN("stop: CaptureSessionState NOT ACTIVE");
 
            LOG_NDKCAM_DEBUG("stop: closing capture session...");
            //todo: it is recommended not to close before creating a new session
            ACameraCaptureSession_close(_captureSession);
            _captureSession = nullptr;
        }
 
        if (_captureRequest)
        {
            LOG_NDKCAM_DEBUG("stop: free request stuff...");
            ACaptureRequest_removeTarget(_captureRequest, _cameraOutputTarget);
            ACaptureRequest_free(_captureRequest);
            _captureRequest = nullptr;
        }
 
        if (_captureSessionOutput)
        {
            ACaptureSessionOutputContainer_remove(_captureSessionOutputContainer,
                                                  _captureSessionOutput);
            ACaptureSessionOutput_free(_captureSessionOutput);
            _captureSessionOutput = nullptr;
        }
 
        if (_surface)
        {
            ANativeWindow_release(_surface);
            _surface = nullptr;
        }
 
        if (_captureSessionOutputContainer)
        {
            ACaptureSessionOutputContainer_free(_captureSessionOutputContainer);
            _captureSessionOutputContainer = nullptr;
        }
 
        if (_cameraDevice)
        {
            LOG_NDKCAM_DEBUG("stop: closing camera...");
            ACameraDevice_close(_cameraDevice);
            _cameraDevice       = nullptr;
            _cameraDeviceOpened = false;
        }
 
        if (_cameraManager)
        {
            LOG_NDKCAM_DEBUG("stop: deleting camera manager...");
            ACameraManager_unregisterAvailabilityCallback(_cameraManager,
                                                          &_cameraManagerAvailabilityCallbacks);
            ACameraManager_delete(_cameraManager);
            _cameraManager = nullptr;
        }
 
        if (_imageReader)
        {
            LOG_NDKCAM_DEBUG("stop: free image reader...");
            AImageReader_delete(_imageReader);
            _imageReader = nullptr;
        }
    }
}

Member Data Documentation

_cameraAvailability

std::map<std::string, bool> SENSAndroidCamera::_cameraAvailability

private

Definition at line 78 of file SENSAndroidCamera.h.

_cameraAvailabilityMutex

std::mutex SENSAndroidCamera::_cameraAvailabilityMutex

private

Definition at line 79 of file SENSAndroidCamera.h.

_cameraDevice

ACameraDevice* SENSAndroidCamera::_cameraDevice = nullptr

private

Definition at line 63 of file SENSAndroidCamera.h.

_cameraDeviceOpened

std::atomic<bool> SENSAndroidCamera::_cameraDeviceOpened {false}

private

Definition at line 83 of file SENSAndroidCamera.h.

_cameraManager

ACameraManager* SENSAndroidCamera::_cameraManager = nullptr

private

Definition at line 62 of file SENSAndroidCamera.h.

_cameraManagerAvailabilityCallbacks

ACameraManager_AvailabilityCallbacks SENSAndroidCamera::_cameraManagerAvailabilityCallbacks

private

Definition at line 58 of file SENSAndroidCamera.h.

_cameraOutputTarget

ACameraOutputTarget* SENSAndroidCamera::_cameraOutputTarget = nullptr

private

Definition at line 68 of file SENSAndroidCamera.h.

_captureRequest

ACaptureRequest* SENSAndroidCamera::_captureRequest = nullptr

private

Definition at line 69 of file SENSAndroidCamera.h.

_captureSession

ACameraCaptureSession* SENSAndroidCamera::_captureSession = nullptr

private

Definition at line 70 of file SENSAndroidCamera.h.

_captureSessionOutput

ACaptureSessionOutput* SENSAndroidCamera::_captureSessionOutput = nullptr

private

Definition at line 66 of file SENSAndroidCamera.h.

_captureSessionOutputContainer

ACaptureSessionOutputContainer* SENSAndroidCamera::_captureSessionOutputContainer = nullptr

private

Definition at line 67 of file SENSAndroidCamera.h.

_captureSessionState

CaptureSessionState SENSAndroidCamera::_captureSessionState = CaptureSessionState::MAX_STATE

private

Definition at line 72 of file SENSAndroidCamera.h.

_captureSessionStateCV

std::condition_variable SENSAndroidCamera::_captureSessionStateCV

private

Definition at line 73 of file SENSAndroidCamera.h.

_captureSessionStateMutex

std::mutex SENSAndroidCamera::_captureSessionStateMutex

private

Definition at line 74 of file SENSAndroidCamera.h.

_captureSize

cv::Size SENSAndroidCamera::_captureSize

private

Definition at line 86 of file SENSAndroidCamera.h.

_imageReader

AImageReader* SENSAndroidCamera::_imageReader = nullptr

private

Definition at line 64 of file SENSAndroidCamera.h.

_openCameraCV

std::condition_variable SENSAndroidCamera::_openCameraCV

private

Definition at line 80 of file SENSAndroidCamera.h.

_surface

ANativeWindow* SENSAndroidCamera::_surface = nullptr

private

Definition at line 65 of file SENSAndroidCamera.h.

---

The documentation for this class was generated from the following files:

• SENSAndroidCamera.h
• SENSAndroidCamera.cpp