You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
292 lines
8.9 KiB
C++
292 lines
8.9 KiB
C++
// Tencent is pleased to support the open source community by making ncnn available.
|
|
//
|
|
// Copyright (C) 2021 THL A29 Limited, a Tencent company. All rights reserved.
|
|
//
|
|
// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
|
|
// in compliance with the License. You may obtain a copy of the License at
|
|
//
|
|
// https://opensource.org/licenses/BSD-3-Clause
|
|
//
|
|
// 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 NDKCAMERA_H
|
|
#define NDKCAMERA_H
|
|
|
|
#include <camera/NdkCameraDevice.h>
|
|
#include <camera/NdkCameraManager.h>
|
|
#include <camera/NdkCameraMetadata.h>
|
|
#include <media/NdkImageReader.h>
|
|
|
|
#include <opencv2/core/core.hpp>
|
|
#include "Camera2Helper.h"
|
|
#include <mutex>
|
|
#include <set>
|
|
|
|
/**
|
|
* 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);
|
|
|
|
#define WAIT_AE_LOCKED 1
|
|
#define WAIT_AWB_LOCKED 2
|
|
#define WAIT_AF_LOCKED 4
|
|
|
|
#define PREVIEW_REQUEST_IDX 0
|
|
|
|
class CameraManager
|
|
{
|
|
public:
|
|
CameraManager()
|
|
{
|
|
camera_manager = NULL;
|
|
}
|
|
|
|
void Create()
|
|
{
|
|
camera_manager = ACameraManager_create();
|
|
}
|
|
|
|
operator ACameraManager* ()
|
|
{
|
|
return camera_manager;
|
|
}
|
|
~CameraManager()
|
|
{
|
|
if (camera_manager != NULL)
|
|
{
|
|
ACameraManager_delete(camera_manager);
|
|
camera_manager = NULL;
|
|
}
|
|
}
|
|
|
|
private:
|
|
ACameraManager* camera_manager;
|
|
};
|
|
|
|
class NdkCamera
|
|
{
|
|
public:
|
|
|
|
struct CAMERA_PARAMS {
|
|
unsigned int sceneMode : 5;
|
|
unsigned int autoFocus : 1;
|
|
unsigned int autoExposure : 1;
|
|
unsigned int orientation:3;
|
|
unsigned int zoom : 1;
|
|
unsigned int wait3ALocked : 3;
|
|
unsigned int burstRawCapture : 2;
|
|
unsigned int customHdr : 1;
|
|
unsigned int hdrStep : 3;
|
|
unsigned int reserved : 12;
|
|
int64_t exposureTime;
|
|
unsigned int sensitivity;
|
|
int compensation;
|
|
float zoomRatio;
|
|
uint8_t requestTemplate;
|
|
uint8_t awbMode;
|
|
uint8_t burstCaptures;
|
|
unsigned short focusTimeout; // milli-seconds 65535
|
|
};
|
|
|
|
struct CAPTURE_RESULT
|
|
{
|
|
uint8_t autoFocus;
|
|
uint8_t autoExposure;
|
|
uint8_t afState;
|
|
uint8_t aeState;
|
|
uint8_t awbState;
|
|
int64_t exposureTime;
|
|
float FocusDistance;
|
|
int32_t sensitivity;
|
|
int32_t compensation;
|
|
uint8_t sceneMode;
|
|
uint8_t awbMode;
|
|
uint16_t avgY;
|
|
float zoomRatio;
|
|
uint64_t duration;
|
|
int64_t frameDuration;
|
|
|
|
uint8_t awbLockSetted : 1;
|
|
uint8_t aeLockSetted : 1;
|
|
uint8_t afLockSetted : 1;
|
|
};
|
|
|
|
struct CaptureRequest
|
|
{
|
|
/* For image capture */
|
|
NdkCamera* pThis;
|
|
AImageReader* imageReader;
|
|
ANativeWindow* imageWindow;
|
|
ACameraOutputTarget* imageTarget;
|
|
|
|
ACaptureSessionOutput* sessionOutput;
|
|
|
|
ACaptureRequest* request;
|
|
ACameraDevice_request_template templateId;
|
|
int sessionSequenceId;
|
|
};
|
|
|
|
struct CaptureResult
|
|
{
|
|
ACameraMetadata* result;
|
|
AImage* image;
|
|
int sequenceId;
|
|
};
|
|
|
|
NdkCamera(int32_t width, int32_t height, const CAMERA_PARAMS& params);
|
|
virtual ~NdkCamera();
|
|
|
|
// facing 0=front 1=back
|
|
int open(const std::string& cameraId);
|
|
void close();
|
|
|
|
int selfTest(const std::string& cameraId, int32_t& maxResolutionX, int32_t& maxResolutionY);
|
|
static void writeJpegFile(AImage *image, const char* path);
|
|
static void writeRawFile(AImage *image, ACameraMetadata* characteristics, ACameraMetadata* result, const char* path);
|
|
|
|
void onAvailabilityCallback(const char* cameraId);
|
|
void onUnavailabilityCallback(const char* cameraId);
|
|
virtual void onImageAvailable(AImageReader* reader);
|
|
virtual int32_t getOutputFormat() const;
|
|
virtual int32_t getBurstCaptures() const;
|
|
|
|
void CreateSession(ANativeWindow* previewWindow, ANativeWindow* jpgWindow, bool manaulPreview, int32_t imageRotation, int32_t width, int32_t height);
|
|
void CreateSession(ANativeWindow* previewWindow);
|
|
|
|
CaptureRequest* CreateRequest(bool isPreviewRequest);
|
|
void DestroyRequest(CaptureRequest* request);
|
|
|
|
void DestroySession();
|
|
|
|
virtual bool on_image(cv::Mat rgb);
|
|
virtual void on_error(const std::string& msg);
|
|
virtual void on_image(const unsigned char* nv21, int nv21_width, int nv21_height);
|
|
virtual void onDisconnected(ACameraDevice* device);
|
|
|
|
virtual bool onOneCapture(std::shared_ptr<ACameraMetadata> characteristics, std::shared_ptr<ACameraMetadata> result, uint32_t ldr, uint32_t duration, cv::Mat rgb);
|
|
virtual bool onBurstCapture(std::shared_ptr<ACameraMetadata> characteristics, std::vector<std::shared_ptr<ACameraMetadata> >& results, uint32_t ldr, uint32_t duration, std::vector<std::vector<uint8_t> >& frames);
|
|
virtual bool onBurstCapture(std::shared_ptr<ACameraMetadata> characteristics, std::vector<std::shared_ptr<ACameraMetadata> >& results, uint32_t ldr, uint32_t duration, std::vector<std::shared_ptr<AImage> >& frames);
|
|
|
|
void onCaptureProgressed(ACameraCaptureSession* session, ACaptureRequest* request, const ACameraMetadata* result);
|
|
void onCaptureCompleted(ACameraCaptureSession* session, ACaptureRequest* request, const ACameraMetadata* result);
|
|
void onCaptureFailed(ACameraCaptureSession* session, ACaptureRequest* request, ACameraCaptureFailure* failure);
|
|
void onSessionReady(ACameraCaptureSession *session);
|
|
void onError(ACameraDevice* device, int error);
|
|
|
|
void CopyPreviewRequest(ACaptureRequest* request, const ACameraMetadata* previewResult);
|
|
|
|
void FireBurstCapture();
|
|
|
|
uint32_t GetLdr() const
|
|
{
|
|
return mFinalLdr;
|
|
}
|
|
|
|
bool HasFatalError() const
|
|
{
|
|
return m_fatalError;
|
|
}
|
|
|
|
bool IsCameraAvailable(const std::string& cameraId);
|
|
|
|
static bool convertAImageToNv21(AImage* image, uint8_t** nv21, int32_t& width, int32_t& height);
|
|
static void EnumCameraResult(ACameraMetadata* result, CAPTURE_RESULT& captureResult);
|
|
|
|
protected:
|
|
std::mutex m_locker;
|
|
std::set<std::string> m_availableCameras;
|
|
|
|
CAMERA_PARAMS m_params;
|
|
DisplayDimension foundRes;
|
|
int camera_facing;
|
|
int camera_orientation;
|
|
bool m_firstFrame;
|
|
bool m_photoTaken;
|
|
int32_t mWidth;
|
|
int32_t mHeight;
|
|
std::string mCameraId;
|
|
|
|
int64_t maxFrameDuration;
|
|
bool sceneModeSupported;
|
|
bool afSupported;
|
|
uint8_t awbMode;
|
|
bool aeLockAvailable;
|
|
bool awbLockAvailable;
|
|
bool m_fatalError;
|
|
|
|
uint64_t numberOfPrecaptures;
|
|
unsigned long long m_precaptureStartTime;
|
|
bool lightDetected;
|
|
|
|
// int64_t exposureTime_;
|
|
RangeValue<int64_t> exposureRange;
|
|
// int32_t sensitivity_;
|
|
RangeValue<int32_t> sensitivityRange;
|
|
RangeValue<int32_t> aeCompensationRange;
|
|
ACameraMetadata_rational aeCompensationStep;
|
|
int32_t activeArraySize[2];
|
|
int32_t maxRegions[3];
|
|
|
|
bool mCaptureTriggered;
|
|
bool mFocusTriggered;
|
|
|
|
CAPTURE_RESULT mResult;
|
|
unsigned long long m_startTime;
|
|
|
|
protected:
|
|
|
|
ACameraManager_AvailabilityCallbacks camera_manager_cb;
|
|
|
|
CameraManager camera_manager;
|
|
ACameraDevice* camera_device;
|
|
|
|
ACaptureSessionOutputContainer* capture_session_output_container;
|
|
|
|
AImageReader* mPreviewImageReader;
|
|
ANativeWindow* mPreviewImageWindow;
|
|
ACameraOutputTarget* mPreviewOutputTarget;
|
|
ACaptureSessionOutput* mPreviewSessionOutput;
|
|
|
|
AImageReader* mImageReader;
|
|
ANativeWindow* mImageWindow;
|
|
ACameraOutputTarget* mOutputTarget;
|
|
ACaptureSessionOutput* mSessionOutput;
|
|
|
|
AImageReader* mImageReader2;
|
|
ANativeWindow* mImageWindow2;
|
|
ACameraOutputTarget* mOutputTarget2;
|
|
ACaptureSessionOutput* mSessionOutput2;
|
|
|
|
std::shared_ptr<ACameraMetadata> mCharacteristics;
|
|
std::vector<CaptureRequest*> mCaptureRequests;
|
|
|
|
std::shared_ptr<ACameraMetadata> mPreviewResults;
|
|
std::vector<std::shared_ptr<ACameraMetadata> > mCaptureResults;
|
|
uint32_t mLdr;
|
|
uint32_t mFinalLdr;
|
|
uint32_t mFinalBurstCaptures;
|
|
int32_t mFinalOutputFormat;
|
|
std::vector<std::shared_ptr<AImage> > mCaptureFrames;
|
|
|
|
cv::Mat mOneFrame;
|
|
std::vector<std::vector<uint8_t> > mRawFrames;
|
|
|
|
ACameraCaptureSession* capture_session;
|
|
|
|
// AImageReader* image_reader;
|
|
// ANativeWindow* image_reader_surface;
|
|
// ACameraOutputTarget* image_reader_target;
|
|
// ACaptureRequest* capture_request;
|
|
// ACaptureSessionOutput* capture_session_output;
|
|
|
|
};
|
|
|
|
#endif // NDKCAMERA_H
|