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