| /* |
| * 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 <utils/Condition.h> |
| #include <utils/KeyedVector.h> |
| #include <utils/String8.h> |
| #include <utils/String16.h> |
| |
| 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); |
| |
| /** Custom tag definitions */ |
| virtual const char* getVendorSectionName(uint32_t tag); |
| virtual const char* getVendorTagName(uint32_t tag); |
| virtual int getVendorTagType(uint32_t tag); |
| |
| /** 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<uint32_t, Stream> mStreams; |
| KeyedVector<uint32_t, ReprocessStream> mReprocessStreams; |
| |
| /** Simulated hardware interfaces */ |
| sp<Sensor> mSensor; |
| sp<JpegCompressor> mJpegCompressor; |
| |
| /** Pipeline control threads */ |
| sp<ConfigureThread> mConfigureThread; |
| sp<ReadoutThread> mReadoutThread; |
| sp<ControlThread> mControlThread; |
| }; |
| |
| }; /* namespace android */ |
| |
| #endif /* HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H */ |
