X-Git-Url: https://gerrit.akraino.org/r/gitweb?a=blobdiff_plain;f=src%2Ftype3_AndroidCloud%2Fanbox-master%2Fandroid%2Fcamera%2FEmulatedFakeCamera3.h;fp=src%2Ftype3_AndroidCloud%2Fanbox-master%2Fandroid%2Fcamera%2FEmulatedFakeCamera3.h;h=4835009961f06d304696d7c69d115a89ae4621c4;hb=e26c1ec581be598521517829adba8c8dd23a768f;hp=0000000000000000000000000000000000000000;hpb=6699c1aea74eeb0eb400e6299079f0c7576f716f;p=iec.git diff --git a/src/type3_AndroidCloud/anbox-master/android/camera/EmulatedFakeCamera3.h b/src/type3_AndroidCloud/anbox-master/android/camera/EmulatedFakeCamera3.h new file mode 100644 index 0000000..4835009 --- /dev/null +++ b/src/type3_AndroidCloud/anbox-master/android/camera/EmulatedFakeCamera3.h @@ -0,0 +1,289 @@ +/* + * Copyright (C) 2013 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_CAMERA3_H +#define HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA3_H + +/** + * Contains declaration of a class EmulatedCamera that encapsulates + * functionality of a fake camera that implements version 3 of the camera device + * interace. + */ + +#include "EmulatedCamera3.h" +#include "fake-pipeline2/Base.h" +#include "fake-pipeline2/Sensor.h" +#include "fake-pipeline2/JpegCompressor.h" +#include +#include +#include +#include + +namespace android { + +/** + * Encapsulates functionality for a v3 HAL camera which produces synthetic data. + * + * Note that EmulatedCameraFactory instantiates an object of this class just + * once, when EmulatedCameraFactory instance gets constructed. Connection to / + * disconnection from the actual camera device is handled by calls to + * connectDevice(), and closeCamera() methods of this class that are invoked in + * response to hw_module_methods_t::open, and camera_device::close callbacks. + */ +class EmulatedFakeCamera3 : public EmulatedCamera3, + private Sensor::SensorListener { +public: + + EmulatedFakeCamera3(int cameraId, bool facingBack, + struct hw_module_t* module); + + virtual ~EmulatedFakeCamera3(); + + /**************************************************************************** + * EmulatedCamera3 virtual overrides + ***************************************************************************/ + +public: + + virtual status_t Initialize(); + + /**************************************************************************** + * Camera module API and generic hardware device API implementation + ***************************************************************************/ + +public: + virtual status_t connectCamera(hw_device_t** device); + + virtual status_t closeCamera(); + + virtual status_t getCameraInfo(struct camera_info *info); + + /**************************************************************************** + * EmulatedCamera3 abstract API implementation + ***************************************************************************/ + +protected: + + virtual status_t configureStreams( + camera3_stream_configuration *streamList); + + virtual status_t registerStreamBuffers( + const camera3_stream_buffer_set *bufferSet) ; + + virtual const camera_metadata_t* constructDefaultRequestSettings( + int type); + + virtual status_t processCaptureRequest(camera3_capture_request *request); + + virtual status_t flush(); + + /** Debug methods */ + + virtual void dump(int fd); + +private: + + /** + * Get the requested capability set for this camera + */ + status_t getCameraCapabilities(); + + bool hasCapability(AvailableCapabilities cap); + + /** + * Build the static info metadata buffer for this device + */ + status_t constructStaticInfo(); + + /** + * Run the fake 3A algorithms as needed. May override/modify settings + * values. + */ + status_t process3A(CameraMetadata &settings); + + status_t doFakeAE(CameraMetadata &settings); + status_t doFakeAF(CameraMetadata &settings); + status_t doFakeAWB(CameraMetadata &settings); + void update3A(CameraMetadata &settings); + + /** Signal from readout thread that it doesn't have anything to do */ + void signalReadoutIdle(); + + /** Handle interrupt events from the sensor */ + void onSensorEvent(uint32_t frameNumber, Event e, nsecs_t timestamp); + + /**************************************************************************** + * 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; + // We need a positive stream ID to distinguish external buffers from + // sensor-generated buffers which use a nonpositive ID. Otherwise, HAL3 has + // no concept of a stream id. + static const uint32_t kGenericStreamId = 1; + static const int32_t kAvailableFormats[]; + + static const int64_t kSyncWaitTimeout = 10000000; // 10 ms + static const int32_t kMaxSyncTimeoutCount = 1000; // 1000 kSyncWaitTimeouts + static const uint32_t kFenceTimeoutMs = 2000; // 2 s + + /**************************************************************************** + * Data members. + ***************************************************************************/ + + /* HAL interface serialization lock. */ + Mutex mLock; + + /* Facing back (true) or front (false) switch. */ + bool mFacingBack; + + SortedVector mCapabilities; + + /** + * Cache for default templates. Once one is requested, the pointer must be + * valid at least until close() is called on the device + */ + camera_metadata_t *mDefaultTemplates[CAMERA3_TEMPLATE_COUNT]; + + /** + * Private stream information, stored in camera3_stream_t->priv. + */ + struct PrivateStreamInfo { + bool alive; + }; + + // Shortcut to the input stream + camera3_stream_t* mInputStream; + + typedef List StreamList; + typedef List::iterator StreamIterator; + typedef Vector HalBufferVector; + + // All streams, including input stream + StreamList mStreams; + + // Cached settings from latest submitted request + CameraMetadata mPrevSettings; + + /** Fake hardware interfaces */ + sp mSensor; + sp mJpegCompressor; + friend class JpegCompressor; + + /** Processing thread for sending out results */ + + class ReadoutThread : public Thread, private JpegCompressor::JpegListener { + public: + ReadoutThread(EmulatedFakeCamera3 *parent); + ~ReadoutThread(); + + struct Request { + uint32_t frameNumber; + CameraMetadata settings; + HalBufferVector *buffers; + Buffers *sensorBuffers; + }; + + /** + * Interface to parent class + */ + + // Place request in the in-flight queue to wait for sensor capture + void queueCaptureRequest(const Request &r); + + // Test if the readout thread is idle (no in-flight requests, not + // currently reading out anything + bool isIdle(); + + // Wait until isIdle is true + status_t waitForReadout(); + + private: + static const nsecs_t kWaitPerLoop = 10000000L; // 10 ms + static const nsecs_t kMaxWaitLoops = 1000; + static const size_t kMaxQueueSize = 2; + + EmulatedFakeCamera3 *mParent; + Mutex mLock; + + List mInFlightQueue; + Condition mInFlightSignal; + bool mThreadActive; + + virtual bool threadLoop(); + + // Only accessed by threadLoop + + Request mCurrentRequest; + + // Jpeg completion callbacks + + Mutex mJpegLock; + bool mJpegWaiting; + camera3_stream_buffer mJpegHalBuffer; + uint32_t mJpegFrameNumber; + virtual void onJpegDone(const StreamBuffer &jpegBuffer, bool success); + virtual void onJpegInputDone(const StreamBuffer &inputBuffer); + }; + + sp mReadoutThread; + + /** Fake 3A constants */ + + static const nsecs_t kNormalExposureTime; + static const nsecs_t kFacePriorityExposureTime; + static const int kNormalSensitivity; + static const int kFacePrioritySensitivity; + // Rate of converging AE to new target value, as fraction of difference between + // current and target value. + static const float kExposureTrackRate; + // Minimum duration for precapture state. May be longer if slow to converge + // to target exposure + static const int kPrecaptureMinFrames; + // How often to restart AE 'scanning' + static const int kStableAeMaxFrames; + // Maximum stop below 'normal' exposure time that we'll wander to while + // pretending to converge AE. In powers of 2. (-2 == 1/4 as bright) + static const float kExposureWanderMin; + // Maximum stop above 'normal' exposure time that we'll wander to while + // pretending to converge AE. In powers of 2. (2 == 4x as bright) + static const float kExposureWanderMax; + + /** Fake 3A state */ + + uint8_t mControlMode; + bool mFacePriority; + uint8_t mAeState; + uint8_t mAfState; + uint8_t mAwbState; + uint8_t mAeMode; + uint8_t mAfMode; + uint8_t mAwbMode; + + int mAeCounter; + nsecs_t mAeCurrentExposureTime; + nsecs_t mAeTargetExposureTime; + int mAeCurrentSensitivity; + +}; + +} // namespace android + +#endif // HW_EMULATOR_CAMERA_EMULATED_CAMERA3_H