TermApp/app/src/main/cpp/camera2/ndkcamera.h

// 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 reserved : 18;
        int64_t exposureTime;
        unsigned int sensitivity;
        int compensation;
        float zoomRatio;
        uint8_t requestTemplate;
        uint8_t awbMode;
        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, int burstCaptures = 1);
    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);
    void writeJpegFile(AImage *image, const char* path);
    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;

    void CreateSession(ANativeWindow* previewWindow, ANativeWindow* jpgWindow, bool manaulPreview, int32_t imageRotation, int32_t width, int32_t height);
    void CreateSession(ANativeWindow* previewWindow);

    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 onBurstCapture(std::shared_ptr<ACameraMetadata> characteristics, const std::vector<std::shared_ptr<ACameraMetadata> >& results, const 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);

    const CAPTURE_RESULT& getCaptureResult() const
    {
        return mFinalResult;
    }

    bool IsCameraAvailable(const std::string& cameraId);

    static bool convertAImageToNv21(AImage* image, uint8_t** nv21, int32_t& width, int32_t& height);

protected:
    std::mutex m_locker;
    std::set<std::string> m_availableCameras;

    std::atomic<uint32_t> mFrameNumber;


protected:
    CAMERA_PARAMS m_params;
    int mBurstCaptures;
    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;

    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;

    CAPTURE_RESULT mResult;
    CAPTURE_RESULT mFinalResult;
    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;

    AImageReader* mImageReader;
    ANativeWindow* mImageWindow;
    ACameraOutputTarget* mOutputTarget;

    std::shared_ptr<ACameraMetadata> mCharacteristics;
    std::vector<CaptureRequest*> mCaptureRequests;

    std::vector<std::shared_ptr<ACameraMetadata> > mCaptureResults;
    std::vector<std::shared_ptr<AImage> > mCaptureFrames;

    ACameraCaptureSession* capture_session;

    // AImageReader* image_reader;
    // ANativeWindow* image_reader_surface;
    // ACameraOutputTarget* image_reader_target;
    // ACaptureRequest* capture_request;
    // ACaptureSessionOutput* capture_session_output;

};

#endif // NDKCAMERA_H