X-Git-Url: https://gerrit.akraino.org/r/gitweb?a=blobdiff_plain;f=src%2Ftype3_AndroidCloud%2Fanbox-master%2Fandroid%2Fcamera%2FEmulatedFakeCamera2.h;fp=src%2Ftype3_AndroidCloud%2Fanbox-master%2Fandroid%2Fcamera%2FEmulatedFakeCamera2.h;h=64c8667aa8062ea7bc242f6368d32105c83b55c3;hb=e26c1ec581be598521517829adba8c8dd23a768f;hp=0000000000000000000000000000000000000000;hpb=6699c1aea74eeb0eb400e6299079f0c7576f716f;p=iec.git diff --git a/src/type3_AndroidCloud/anbox-master/android/camera/EmulatedFakeCamera2.h b/src/type3_AndroidCloud/anbox-master/android/camera/EmulatedFakeCamera2.h new file mode 100644 index 0000000..64c8667 --- /dev/null +++ b/src/type3_AndroidCloud/anbox-master/android/camera/EmulatedFakeCamera2.h @@ -0,0 +1,429 @@ +/* + * Copyright (C) 2012 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. + */ + +#ifndef HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H +#define HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H + +/* + * Contains declaration of a class EmulatedFakeCamera2 that encapsulates + * functionality of a fake camera that implements version 2 of the camera device + * interface. + */ + +#include "EmulatedCamera2.h" +#include "fake-pipeline2/Base.h" +#include "fake-pipeline2/Sensor.h" +#include "fake-pipeline2/JpegCompressor.h" +#include +#include +#include +#include + +namespace android { + +/* Encapsulates functionality of an advanced fake camera. This camera contains + * a simple simulation of a scene, sensor, and image processing pipeline. + */ +class EmulatedFakeCamera2 : public EmulatedCamera2 { +public: + /* Constructs EmulatedFakeCamera instance. */ + EmulatedFakeCamera2(int cameraId, bool facingBack, struct hw_module_t* module); + + /* Destructs EmulatedFakeCamera instance. */ + ~EmulatedFakeCamera2(); + + /**************************************************************************** + * EmulatedCamera2 virtual overrides. + ***************************************************************************/ + +public: + /* Initializes EmulatedFakeCamera2 instance. */ + status_t Initialize(); + + /**************************************************************************** + * Camera Module API and generic hardware device API implementation + ***************************************************************************/ +public: + + virtual status_t connectCamera(hw_device_t** device); + + virtual status_t plugCamera(); + virtual status_t unplugCamera(); + virtual camera_device_status_t getHotplugStatus(); + + virtual status_t closeCamera(); + + virtual status_t getCameraInfo(struct camera_info *info); + + /**************************************************************************** + * EmulatedCamera2 abstract API implementation. + ***************************************************************************/ +protected: + /** Request input queue */ + + virtual int requestQueueNotify(); + + /** Count of requests in flight */ + virtual int getInProgressCount(); + + /** Cancel all captures in flight */ + //virtual int flushCapturesInProgress(); + + /** Construct default request */ + virtual int constructDefaultRequest( + int request_template, + camera_metadata_t **request); + + virtual int allocateStream( + uint32_t width, + uint32_t height, + int format, + const camera2_stream_ops_t *stream_ops, + uint32_t *stream_id, + uint32_t *format_actual, + uint32_t *usage, + uint32_t *max_buffers); + + virtual int registerStreamBuffers( + uint32_t stream_id, + int num_buffers, + buffer_handle_t *buffers); + + virtual int releaseStream(uint32_t stream_id); + + // virtual int allocateReprocessStream( + // uint32_t width, + // uint32_t height, + // uint32_t format, + // const camera2_stream_ops_t *stream_ops, + // uint32_t *stream_id, + // uint32_t *format_actual, + // uint32_t *usage, + // uint32_t *max_buffers); + + virtual int allocateReprocessStreamFromStream( + uint32_t output_stream_id, + const camera2_stream_in_ops_t *stream_ops, + uint32_t *stream_id); + + virtual int releaseReprocessStream(uint32_t stream_id); + + virtual int triggerAction(uint32_t trigger_id, + int32_t ext1, + int32_t ext2); + + /** Debug methods */ + + virtual int dump(int fd); + +public: + /**************************************************************************** + * Utility methods called by configure/readout threads and pipeline + ***************************************************************************/ + + // Get information about a given stream. Will lock mMutex + const Stream &getStreamInfo(uint32_t streamId); + const ReprocessStream &getReprocessStreamInfo(uint32_t streamId); + + // Notifies rest of camera subsystem of serious error + void signalError(); + +private: + /**************************************************************************** + * Utility methods + ***************************************************************************/ + /** Construct static camera metadata, two-pass */ + status_t constructStaticInfo( + camera_metadata_t **info, + bool sizeRequest) const; + + /** Two-pass implementation of constructDefaultRequest */ + status_t constructDefaultRequest( + int request_template, + camera_metadata_t **request, + bool sizeRequest) const; + /** Helper function for constructDefaultRequest */ + static status_t addOrSize( camera_metadata_t *request, + bool sizeRequest, + size_t *entryCount, + size_t *dataCount, + uint32_t tag, + const void *entry_data, + size_t entry_count); + + /** Determine if the stream id is listed in any currently-in-flight + * requests. Assumes mMutex is locked */ + bool isStreamInUse(uint32_t streamId); + + /** Determine if the reprocess stream id is listed in any + * currently-in-flight requests. Assumes mMutex is locked */ + bool isReprocessStreamInUse(uint32_t streamId); + + /**************************************************************************** + * Pipeline controller threads + ***************************************************************************/ + + class ConfigureThread: public Thread { + public: + ConfigureThread(EmulatedFakeCamera2 *parent); + ~ConfigureThread(); + + status_t waitUntilRunning(); + status_t newRequestAvailable(); + status_t readyToRun(); + + bool isStreamInUse(uint32_t id); + int getInProgressCount(); + private: + EmulatedFakeCamera2 *mParent; + static const nsecs_t kWaitPerLoop = 10000000L; // 10 ms + + bool mRunning; + bool threadLoop(); + + bool setupCapture(); + bool setupReprocess(); + + bool configureNextCapture(); + bool configureNextReprocess(); + + bool getBuffers(); + + Mutex mInputMutex; // Protects mActive, mRequestCount + Condition mInputSignal; + bool mActive; // Whether we're waiting for input requests or actively + // working on them + size_t mRequestCount; + + camera_metadata_t *mRequest; + + Mutex mInternalsMutex; // Lock before accessing below members. + bool mWaitingForReadout; + bool mNextNeedsJpeg; + bool mNextIsCapture; + int32_t mNextFrameNumber; + int64_t mNextExposureTime; + int64_t mNextFrameDuration; + int32_t mNextSensitivity; + Buffers *mNextBuffers; + }; + + class ReadoutThread: public Thread, private JpegCompressor::JpegListener { + public: + ReadoutThread(EmulatedFakeCamera2 *parent); + ~ReadoutThread(); + + status_t readyToRun(); + + // Input + status_t waitUntilRunning(); + bool waitForReady(nsecs_t timeout); + void setNextOperation(bool isCapture, + camera_metadata_t *request, + Buffers *buffers); + bool isStreamInUse(uint32_t id); + int getInProgressCount(); + private: + EmulatedFakeCamera2 *mParent; + + bool mRunning; + bool threadLoop(); + + bool readyForNextCapture(); + status_t collectStatisticsMetadata(camera_metadata_t *frame); + + // Inputs + Mutex mInputMutex; // Protects mActive, mInFlightQueue, mRequestCount + Condition mInputSignal; + Condition mReadySignal; + + bool mActive; + + static const int kInFlightQueueSize = 4; + struct InFlightQueue { + bool isCapture; + camera_metadata_t *request; + Buffers *buffers; + } *mInFlightQueue; + + size_t mInFlightHead; + size_t mInFlightTail; + + size_t mRequestCount; + + // Internals + Mutex mInternalsMutex; + + bool mIsCapture; + camera_metadata_t *mRequest; + Buffers *mBuffers; + + // Jpeg completion listeners + void onJpegDone(const StreamBuffer &jpegBuffer, bool success); + void onJpegInputDone(const StreamBuffer &inputBuffer); + nsecs_t mJpegTimestamp; + }; + + // 3A management thread (auto-exposure, focus, white balance) + class ControlThread: public Thread { + public: + ControlThread(EmulatedFakeCamera2 *parent); + ~ControlThread(); + + status_t readyToRun(); + + status_t waitUntilRunning(); + + // Interpret request's control parameters and override + // capture settings as needed + status_t processRequest(camera_metadata_t *request); + + status_t triggerAction(uint32_t msgType, + int32_t ext1, int32_t ext2); + private: + ControlThread(const ControlThread &t); + ControlThread& operator=(const ControlThread &t); + + // Constants controlling fake 3A behavior + static const nsecs_t kControlCycleDelay; + static const nsecs_t kMinAfDuration; + static const nsecs_t kMaxAfDuration; + static const float kAfSuccessRate; + static const float kContinuousAfStartRate; + + static const float kAeScanStartRate; + static const nsecs_t kMinAeDuration; + static const nsecs_t kMaxAeDuration; + static const nsecs_t kMinPrecaptureAeDuration; + static const nsecs_t kMaxPrecaptureAeDuration; + + static const nsecs_t kNormalExposureTime; + static const nsecs_t kExposureJump; + static const nsecs_t kMinExposureTime; + + EmulatedFakeCamera2 *mParent; + + bool mRunning; + bool threadLoop(); + + Mutex mInputMutex; // Protects input methods + Condition mInputSignal; + + // Trigger notifications + bool mStartAf; + bool mCancelAf; + bool mStartPrecapture; + + // Latest state for 3A request fields + uint8_t mControlMode; + + uint8_t mEffectMode; + uint8_t mSceneMode; + + uint8_t mAfMode; + bool mAfModeChange; + + uint8_t mAwbMode; + uint8_t mAeMode; + + // Latest trigger IDs + int32_t mAfTriggerId; + int32_t mPrecaptureTriggerId; + + // Current state for 3A algorithms + uint8_t mAfState; + uint8_t mAeState; + uint8_t mAwbState; + bool mAeLock; + + // Current control parameters + nsecs_t mExposureTime; + + // Private to threadLoop and its utility methods + + nsecs_t mAfScanDuration; + nsecs_t mAeScanDuration; + bool mLockAfterPassiveScan; + + // Utility methods for AF + int processAfTrigger(uint8_t afMode, uint8_t afState); + int maybeStartAfScan(uint8_t afMode, uint8_t afState); + int updateAfScan(uint8_t afMode, uint8_t afState, nsecs_t *maxSleep); + void updateAfState(uint8_t newState, int32_t triggerId); + + // Utility methods for precapture trigger + int processPrecaptureTrigger(uint8_t aeMode, uint8_t aeState); + int maybeStartAeScan(uint8_t aeMode, bool aeLock, uint8_t aeState); + int updateAeScan(uint8_t aeMode, bool aeLock, uint8_t aeState, + nsecs_t *maxSleep); + void updateAeState(uint8_t newState, int32_t triggerId); + }; + + /**************************************************************************** + * Static configuration information + ***************************************************************************/ +private: + static const uint32_t kMaxRawStreamCount = 1; + static const uint32_t kMaxProcessedStreamCount = 3; + static const uint32_t kMaxJpegStreamCount = 1; + static const uint32_t kMaxReprocessStreamCount = 2; + static const uint32_t kMaxBufferCount = 4; + static const uint32_t kAvailableFormats[]; + static const uint32_t kAvailableRawSizes[]; + static const uint64_t kAvailableRawMinDurations[]; + static const uint32_t kAvailableProcessedSizesBack[]; + static const uint32_t kAvailableProcessedSizesFront[]; + static const uint64_t kAvailableProcessedMinDurations[]; + static const uint32_t kAvailableJpegSizesBack[]; + static const uint32_t kAvailableJpegSizesFront[]; + static const uint64_t kAvailableJpegMinDurations[]; + + /**************************************************************************** + * Data members. + ***************************************************************************/ + +protected: + /* Facing back (true) or front (false) switch. */ + bool mFacingBack; + +private: + bool mIsConnected; + + /** Stream manipulation */ + uint32_t mNextStreamId; + uint32_t mRawStreamCount; + uint32_t mProcessedStreamCount; + uint32_t mJpegStreamCount; + + uint32_t mNextReprocessStreamId; + uint32_t mReprocessStreamCount; + + KeyedVector mStreams; + KeyedVector mReprocessStreams; + + /** Simulated hardware interfaces */ + sp mSensor; + sp mJpegCompressor; + + /** Pipeline control threads */ + sp mConfigureThread; + sp mReadoutThread; + sp mControlThread; +}; + +}; /* namespace android */ + +#endif /* HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H */