camera/CameraRotator.h

/*
 * Copyright (C) 2021 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.
 */


#pragma once

#include "fake-pipeline2/Base.h"
#include "EmulatedFakeRotatingCameraDevice.h"

#include <ui/GraphicBufferAllocator.h>
#include <ui/GraphicBufferMapper.h>
#include <utils/Mutex.h>
#include <utils/Thread.h>
#include <utils/Timers.h>

namespace android {

class CameraRotator : private Thread, public virtual RefBase {
public:
    CameraRotator(int w, int h);
    ~CameraRotator();


    status_t startUp();
    status_t shutDown();


    void setExposureTime(uint64_t ns);
    void setFrameDuration(uint64_t ns);
    void setSensitivity(uint32_t gain);

    /*
     * Each Buffer in "buffers" must be at least stride*height*2 bytes in size.
     */
    void setDestinationBuffers(Buffers *buffers);
    /*
     * To simplify tracking the sensor's current frame.
     */
    void setFrameNumber(uint32_t frameNumber);

    /*
     * Synchronizing with sensor operation (vertical sync).
     */

    /*
     * Wait until the sensor outputs its next vertical sync signal, meaning it
     * is starting readout of its latest frame of data.
     *
     * Returns:
     *     true if vertical sync is signaled; false if the wait timed out.
     */
    bool waitForVSync(nsecs_t reltime);

    /*
     * Wait until a new frame has been read out, and then return the time
     * capture started. May return immediately if a new frame has been pushed
     * since the last wait for a new frame.
     *
     * Returns:
     *     true if new frame is returned; false if timed out.
     */
    bool waitForNewFrame(nsecs_t reltime, nsecs_t *captureTime);

    /*
     * Interrupt event servicing from the sensor. Only triggers for sensor
     * cycles that have valid buffers to write to.
     */
    struct CameraRotatorListener {
        enum Event {
            EXPOSURE_START,
        };

        virtual void onCameraRotatorEvent(uint32_t frameNumber, Event e,
                nsecs_t timestamp) = 0;
        virtual ~CameraRotatorListener();
    };

    void setCameraRotatorListener(CameraRotatorListener *listener);

    /*
     * Static Sensor Characteristics
     */
    const uint32_t mWidth, mHeight;
    const uint32_t mActiveArray[4];

    static const nsecs_t kExposureTimeRange[2];
    static const nsecs_t kFrameDurationRange[2];
    static const nsecs_t kMinVerticalBlank;

    static const int32_t kSensitivityRange[2];
    static const uint32_t kDefaultSensitivity;

    static const char kHostCameraVerString[];

  private:
    int32_t mLastRequestWidth, mLastRequestHeight;

    /*
     * Defines possible states of the emulated camera device object.
     */
    enum EmulatedCameraDeviceState {
        // Object has been constructed.
        ECDS_CONSTRUCTED,
        // Object has been initialized.
        ECDS_INITIALIZED,
        // Object has been connected to the physical device.
        ECDS_CONNECTED,
        // Camera device has been started.
        ECDS_STARTED,
    };
    // Object state.
    EmulatedCameraDeviceState mState;

    const char *mDeviceName;
    GraphicBufferAllocator* mGBA;
    GraphicBufferMapper*    mGBM;

    // Always lock before accessing control parameters.
    Mutex mControlMutex;
    /*
     * Control Parameters
     */
    Condition mVSync;
    bool mGotVSync;
    uint64_t mFrameDuration;
    Buffers *mNextBuffers;
    uint32_t mFrameNumber;

    // Always lock before accessing readout variables.
    Mutex mReadoutMutex;
    /*
     * Readout Variables
     */
    Condition mReadoutAvailable;
    Condition mReadoutComplete;
    Buffers *mCapturedBuffers;
    nsecs_t mCaptureTime;
    CameraRotatorListener *mListener;

    // Time of sensor startup (used for simulation zero-time point).
    nsecs_t mStartupTime;
    int32_t mHostCameraVer;
    bool mIsMinigbm;

  private:
    /*
     * Inherited Thread Virtual Overrides
     */
    virtual status_t readyToRun() override;
    /*
     * CameraRotator capture operation main loop.
     */
    virtual bool threadLoop() override;

    /*
     * Members only used by the processing thread.
     */
    nsecs_t mNextCaptureTime;
    Buffers *mNextCapturedBuffers;

    void captureRGBA(uint32_t width, uint32_t height, uint32_t stride,
                     int64_t *timestamp, buffer_handle_t* handle);
    void captureYU12(uint32_t width, uint32_t height, uint32_t stride,
                     int64_t *timestamp, buffer_handle_t* handle);
    void captureRGBA(uint8_t *img, uint32_t width, uint32_t height,
                     uint32_t stride, int64_t *timestamp);
    void captureYU12(uint8_t *img, uint32_t width, uint32_t height,
                     uint32_t stride, int64_t *timestamp);
    void captureRGB(uint8_t *img, uint32_t width, uint32_t height,
                    uint32_t stride, int64_t *timestamp);

private:

    EmulatedFakeRotatingCameraDevice    mRender;

    status_t queryStart(uint32_t pixel_format, int width, int height);

    status_t queryStart();

    status_t queryStop();

    status_t queryFrame(void* vframe,
                        void* pframe,
                        size_t vframe_size,
                        size_t pframe_size,
                        float r_scale,
                        float g_scale,
                        float b_scale,
                        float exposure_comp,
                        int64_t* frame_time);


    status_t queryFrame(int wdith,
                        int height,
                        uint32_t pixel_format,
                        uint64_t offset,
                        float r_scale,
                        float g_scale,
                        float b_scale,
                        float exposure_comp,
                        int64_t* frame_time);

};

};  // end of namespace android