1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
/*
* Copyright (C) 2019 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 HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_RGBIRD_RESULT_REQUEST_PROCESSOR_H_
#define HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_RGBIRD_RESULT_REQUEST_PROCESSOR_H_
#include <set>
#include "request_processor.h"
#include "result_processor.h"
#include "vendor_tag_defs.h"
namespace android {
namespace google_camera_hal {
// RgbirdResultRequestProcessor implements a ResultProcessor handling realtime
// capture results for a logical camera consisting of one RGB and two IR camera
// sensors.
class RgbirdResultRequestProcessor : public ResultProcessor,
public RequestProcessor {
public:
struct RgbirdResultRequestProcessorCreateData {
// camera id of the color sensor
uint32_t rgb_camera_id = 0;
// camera id of the NIR sensor used as source
uint32_t ir1_camera_id = 0;
// camera id of the NIR sensor used as target
uint32_t ir2_camera_id = 0;
// stream id of the internal raw stream for hdr+
int32_t rgb_raw_stream_id = -1;
// whether hdr+ is supported
bool is_hdrplus_supported = false;
// stream id of the internal yuv stream in case depth is configured
int32_t rgb_internal_yuv_stream_id = -1;
};
static std::unique_ptr<RgbirdResultRequestProcessor> Create(
const RgbirdResultRequestProcessorCreateData& create_data);
virtual ~RgbirdResultRequestProcessor() = default;
// Override functions of ResultProcessor start.
void SetResultCallback(
ProcessCaptureResultFunc process_capture_result, NotifyFunc notify,
ProcessBatchCaptureResultFunc process_batch_capture_result) override;
status_t AddPendingRequests(
const std::vector<ProcessBlockRequest>& process_block_requests,
const CaptureRequest& remaining_session_request) override;
void ProcessResult(ProcessBlockResult block_result) override;
void Notify(const ProcessBlockNotifyMessage& block_message) override;
status_t FlushPendingRequests() override;
// Override functions of ResultProcessor end.
// Override functions of RequestProcessor start.
status_t ConfigureStreams(
InternalStreamManager* internal_stream_manager,
const StreamConfiguration& stream_config,
StreamConfiguration* process_block_stream_config) override;
status_t SetProcessBlock(std::unique_ptr<ProcessBlock> process_block) override;
status_t ProcessRequest(const CaptureRequest& request) override;
status_t Flush() override;
// Override functions of RequestProcessor end.
protected:
RgbirdResultRequestProcessor(
const RgbirdResultRequestProcessorCreateData& create_data);
private:
static constexpr int32_t kInvalidStreamId = -1;
static constexpr uint32_t kAutocalFrameNumber = 5;
static constexpr uint32_t kNumOfAutoCalInputBuffers = /*YUV+IR+IR*/ 3;
const uint32_t kRgbCameraId;
const uint32_t kIr1CameraId;
const uint32_t kIr2CameraId;
const int32_t kSyncWaitTime = 5000; // milliseconds
void ProcessResultForHdrplus(CaptureResult* result, bool* rgb_raw_output);
// Return the RGB internal YUV stream buffer if there is any and depth is
// configured
void TryReturnInternalBufferForDepth(CaptureResult* result,
bool* has_internal);
// Save face detect mode for HDR+
void SaveFdForHdrplus(const CaptureRequest& request);
// Handle face detect metadata from result for HDR+
status_t HandleFdResultForHdrplus(uint32_t frameNumber,
HalCameraMetadata* metadata);
// Save lens shading map mode for HDR+
void SaveLsForHdrplus(const CaptureRequest& request);
// Handle Lens shading metadata from result for HDR+
status_t HandleLsResultForHdrplus(uint32_t frameNumber,
HalCameraMetadata* metadata);
// TODO(b/127322570): update the following function after FLL sync verified
// Remove internal streams for depth lock
status_t ReturnInternalStreams(CaptureResult* result);
// Check fence status if need
status_t CheckFenceStatus(CaptureRequest* request);
// Check all metadata exist for Autocal
// Protected by depth_requests_mutex_
bool IsAutocalMetadataReadyLocked(const HalCameraMetadata& metadata);
// Prepare Depth Process Block request and try to submit that
status_t TrySubmitDepthProcessBlockRequest(
const ProcessBlockResult& block_result);
// Whether the internal yuv stream buffer needs to be passed to the depth
// process block.
bool IsAutocalRequest(uint32_t frame_number) const;
// Verify if all information is ready for a depth request for frame_number and
// submit the request to the process block if so.
status_t VerifyAndSubmitDepthRequest(uint32_t frame_number);
std::mutex callback_lock_;
// The following callbacks must be protected by callback_lock_.
ProcessCaptureResultFunc process_capture_result_;
NotifyFunc notify_;
std::mutex depth_process_block_lock_;
// Protected by depth_process_block_lock_.
std::unique_ptr<ProcessBlock> depth_process_block_;
// rgb_raw_stream_id_ is the stream ID of internal raw from RGB camera for HDR+
int32_t rgb_raw_stream_id_ = -1;
bool is_hdrplus_supported_ = false;
// Current face detect mode set by framework.
uint8_t current_face_detect_mode_ = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
std::mutex face_detect_lock_;
// Map from frame number to face detect mode requested for that frame by
// framework. And requested_face_detect_modes_ is protected by
// face_detect_lock_
std::unordered_map<uint32_t, uint8_t> requested_face_detect_modes_;
// Current lens shading map mode set by framework.
uint8_t current_lens_shading_map_mode_ =
ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF;
std::mutex lens_shading_lock_;
// Map from frame number to lens shading map mode requested for that frame
// by framework. And requested_lens_shading_map_modes_ is protected by
// lens_shading_lock_
std::unordered_map<uint32_t, uint8_t> requested_lens_shading_map_modes_;
// Internal stream manager
InternalStreamManager* internal_stream_manager_ = nullptr;
// TODO(b/128633958): remove this after FLL syncing is verified
bool force_internal_stream_ = false;
// Set of framework stream id
std::set<int32_t> framework_stream_id_set_;
std::mutex depth_requests_mutex_;
// Map from framework number to capture request for depth process block. If a
// request does not contain any depth buffer, it is not recorded in the map.
// Protected by depth_requests_mutex_
std::unordered_map<uint32_t, std::unique_ptr<CaptureRequest>> depth_requests_;
// Depth stream id if it is configured for the current session
int32_t depth_stream_id_ = -1;
// If a depth stream is configured, always configure an extra internal YUV
// stream to cover the case when there is no request for any stream from the
// RGB sensor.
int32_t rgb_internal_yuv_stream_id_ = -1;
// Whether RGB-IR auto-calibration is enabled. This affects how the internal
// YUV stream results are handled.
bool rgb_ir_auto_cal_enabled_ = false;
};
} // namespace google_camera_hal
} // namespace android
#endif // HARDWARE_GOOGLE_CAMERA_HAL_GOOGLE_CAMERA_HAL_RGBIRD_RESULT_REQUEST_PROCESSOR_H_
|
