1 /* 2 * Copyright (C) 2018 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_SERVERS_CAMERA_CAMERA3_COMPOSITE_STREAM_H 18 #define ANDROID_SERVERS_CAMERA_CAMERA3_COMPOSITE_STREAM_H 19 20 #include <set> 21 #include <unordered_map> 22 23 #include <android/hardware/camera2/ICameraDeviceCallbacks.h> 24 #include <camera/CameraMetadata.h> 25 #include <camera/camera2/OutputConfiguration.h> 26 #include <gui/IProducerListener.h> 27 #include "common/CameraDeviceBase.h" 28 #include "device3/Camera3StreamInterface.h" 29 30 namespace android { 31 32 class CameraDeviceClient; 33 class CameraMetadata; 34 class Surface; 35 36 namespace camera3 { 37 38 class CompositeStream : public camera3::Camera3StreamBufferListener { 39 40 public: 41 CompositeStream(sp<CameraDeviceBase> device, wp<hardware::camera2::ICameraDeviceCallbacks> cb); ~CompositeStream()42 virtual ~CompositeStream() {} 43 44 status_t createStream(const std::vector<sp<Surface>>& consumers, 45 bool hasDeferredConsumer, uint32_t width, uint32_t height, int format, 46 camera_stream_rotation_t rotation, int *id, const String8& physicalCameraId, 47 const std::unordered_set<int32_t> &sensorPixelModesUsed, 48 std::vector<int> *surfaceIds, 49 int streamSetId, bool isShared, bool isMultiResolution); 50 51 status_t deleteStream(); 52 53 // Switch to offline mode and release any online resources. 54 void switchToOffline(); 55 56 // Create and register all internal camera streams. 57 virtual status_t createInternalStreams(const std::vector<sp<Surface>>& consumers, 58 bool hasDeferredConsumer, uint32_t width, uint32_t height, int format, 59 camera_stream_rotation_t rotation, int *id, const String8& physicalCameraId, 60 const std::unordered_set<int32_t> &sensorPixelModesUsed, 61 std::vector<int> *surfaceIds, 62 int streamSetId, bool isShared) = 0; 63 64 // Release all internal streams and corresponding resources. 65 virtual status_t deleteInternalStreams() = 0; 66 67 // Stream configuration completed. 68 virtual status_t configureStream() = 0; 69 70 // Insert the internal composite stream id in the user capture request. 71 virtual status_t insertGbp(SurfaceMap* /*out*/outSurfaceMap, 72 Vector<int32_t>* /*out*/outputStreamIds, int32_t* /*out*/currentStreamId) = 0; 73 74 // Attach the internal composite stream ids. 75 virtual status_t insertCompositeStreamIds( 76 std::vector<int32_t>* compositeStreamIds /*out*/) = 0; 77 78 // Return composite stream id. 79 virtual int getStreamId() = 0; 80 81 // Notify when shutter notify is triggered onShutter(const CaptureResultExtras &,nsecs_t)82 virtual void onShutter(const CaptureResultExtras& /*resultExtras*/, nsecs_t /*timestamp*/) {} 83 84 void onResultAvailable(const CaptureResult& result); 85 bool onError(int32_t errorCode, const CaptureResultExtras& resultExtras); 86 87 // Camera3StreamBufferListener implementation onBufferAcquired(const BufferInfo &)88 void onBufferAcquired(const BufferInfo& /*bufferInfo*/) override { /*Empty for now */ } 89 void onBufferReleased(const BufferInfo& bufferInfo) override; 90 void onBufferRequestForFrameNumber(uint64_t frameNumber, int streamId, 91 const CameraMetadata& settings) override; 92 93 protected: 94 struct ProducerListener : public BnProducerListener { 95 // ProducerListener impementation onBufferReleasedProducerListener96 void onBufferReleased() override { /*No impl. for now*/ }; 97 }; 98 99 status_t registerCompositeStreamListener(int32_t streamId); 100 void eraseResult(int64_t frameNumber); 101 void flagAnErrorFrameNumber(int64_t frameNumber); 102 void notifyError(int64_t frameNumber, int32_t requestId); 103 104 // Subclasses should check for buffer errors from internal streams and return 'true' in 105 // case the error notification should remain within camera service. 106 virtual bool onStreamBufferError(const CaptureResultExtras& resultExtras) = 0; 107 108 // Subclasses can decide how to handle result errors depending on whether or not the 109 // internal processing needs result data. 110 virtual void onResultError(const CaptureResultExtras& resultExtras) = 0; 111 112 // Subclasses can decide how to handle request errors depending on whether 113 // or not the internal processing needs clean up. onRequestError(const CaptureResultExtras &)114 virtual void onRequestError(const CaptureResultExtras& /*resultExtras*/) {} 115 116 // Device and/or service is in unrecoverable error state. 117 // Composite streams should behave accordingly. 118 void enableErrorState(); 119 120 wp<CameraDeviceBase> mDevice; 121 wp<camera3::StatusTracker> mStatusTracker; 122 wp<hardware::camera2::ICameraDeviceCallbacks> mRemoteCallback; 123 124 mutable Mutex mMutex; 125 Condition mInputReadyCondition; 126 int32_t mNumPartialResults; 127 bool mErrorState; 128 129 // Frame number to capture result map of partial pending request results. 130 std::unordered_map<uint64_t, CameraMetadata> mPendingCaptureResults; 131 132 // Timestamp to capture (frame number, result) map of completed pending request results. 133 std::unordered_map<int64_t, std::tuple<int64_t, CameraMetadata>> mCaptureResults; 134 135 // Frame number to timestamp map 136 std::unordered_map<int64_t, int64_t> mFrameNumberMap; 137 138 // Keeps a set buffer/result frame numbers for any errors detected during processing. 139 std::set<int64_t> mErrorFrameNumbers; 140 141 }; 142 143 }; //namespace camera3 144 }; //namespace android 145 146 #endif 147