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(wp<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 camera3_stream_rotation_t rotation, int *id, const String8& physicalCameraId, 47 std::vector<int> *surfaceIds, int streamSetId, bool isShared); 48 49 status_t deleteStream(); 50 51 // Create and register all internal camera streams. 52 virtual status_t createInternalStreams(const std::vector<sp<Surface>>& consumers, 53 bool hasDeferredConsumer, uint32_t width, uint32_t height, int format, 54 camera3_stream_rotation_t rotation, int *id, const String8& physicalCameraId, 55 std::vector<int> *surfaceIds, int streamSetId, bool isShared) = 0; 56 57 // Release all internal streams and corresponding resources. 58 virtual status_t deleteInternalStreams() = 0; 59 60 // Stream configuration completed. 61 virtual status_t configureStream() = 0; 62 63 // Insert the internal composite stream id in the user capture request. 64 virtual status_t insertGbp(SurfaceMap* /*out*/outSurfaceMap, 65 Vector<int32_t>* /*out*/outputStreamIds, int32_t* /*out*/currentStreamId) = 0; 66 67 // Return composite stream id. 68 virtual int getStreamId() = 0; 69 70 // Notify when shutter notify is triggered onShutter(const CaptureResultExtras &,nsecs_t)71 virtual void onShutter(const CaptureResultExtras& /*resultExtras*/, nsecs_t /*timestamp*/) {} 72 73 void onResultAvailable(const CaptureResult& result); 74 bool onError(int32_t errorCode, const CaptureResultExtras& resultExtras); 75 76 // Camera3StreamBufferListener implementation onBufferAcquired(const BufferInfo &)77 void onBufferAcquired(const BufferInfo& /*bufferInfo*/) override { /*Empty for now */ } 78 void onBufferReleased(const BufferInfo& bufferInfo) override; 79 void onBufferRequestForFrameNumber(uint64_t frameNumber, int streamId, 80 const CameraMetadata& settings) override; 81 82 protected: 83 struct ProducerListener : public BnProducerListener { 84 // ProducerListener impementation onBufferReleasedProducerListener85 void onBufferReleased() override { /*No impl. for now*/ }; 86 }; 87 88 status_t registerCompositeStreamListener(int32_t streamId); 89 void eraseResult(int64_t frameNumber); 90 void flagAnErrorFrameNumber(int64_t frameNumber); 91 void notifyError(int64_t frameNumber); 92 93 // Subclasses should check for buffer errors from internal streams and return 'true' in 94 // case the error notification should remain within camera service. 95 virtual bool onStreamBufferError(const CaptureResultExtras& resultExtras) = 0; 96 97 // Subclasses can decide how to handle result errors depending on whether or not the 98 // internal processing needs result data. 99 virtual void onResultError(const CaptureResultExtras& resultExtras) = 0; 100 101 // Device and/or service is in unrecoverable error state. 102 // Composite streams should behave accordingly. 103 void enableErrorState(); 104 105 wp<CameraDeviceBase> mDevice; 106 wp<hardware::camera2::ICameraDeviceCallbacks> mRemoteCallback; 107 108 mutable Mutex mMutex; 109 Condition mInputReadyCondition; 110 int32_t mNumPartialResults; 111 bool mErrorState; 112 113 // Frame number to capture result map of partial pending request results. 114 std::unordered_map<uint64_t, CameraMetadata> mPendingCaptureResults; 115 116 // Timestamp to capture (frame number, result) map of completed pending request results. 117 std::unordered_map<int64_t, std::tuple<int64_t, CameraMetadata>> mCaptureResults; 118 119 // Frame number to timestamp map 120 std::unordered_map<int64_t, int64_t> mFrameNumberMap; 121 122 // Keeps a set buffer/result frame numbers for any errors detected during processing. 123 std::set<int64_t> mErrorFrameNumbers; 124 125 }; 126 127 }; //namespace camera3 128 }; //namespace android 129 130 #endif 131