1 /*
2 * Copyright (C) 2019 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 #define LOG_TAG "GCH_HidlUtils"
18 //#define LOG_NDEBUG 0
19 #include <log/log.h>
20 #include <regex>
21
22 #include "hidl_camera_device.h"
23 #include "hidl_camera_provider.h"
24 #include "hidl_utils.h"
25
26 namespace android {
27 namespace hardware {
28 namespace camera {
29 namespace implementation {
30 namespace hidl_utils {
31
32 using ::android::hardware::camera::device::V3_2::ErrorCode;
33 using ::android::hardware::camera::device::V3_2::ErrorMsg;
34 using ::android::hardware::camera::device::V3_2::MsgType;
35 using ::android::hardware::camera::device::V3_2::ShutterMsg;
36 using ::android::hardware::camera::device::V3_5::implementation::HidlCameraDevice;
37 using ::android::hardware::camera::provider::V2_6::implementation::HidlCameraProvider;
38
ConvertToHidlVendorTagType(google_camera_hal::CameraMetadataType hal_type,CameraMetadataType * hidl_type)39 status_t ConvertToHidlVendorTagType(
40 google_camera_hal::CameraMetadataType hal_type,
41 CameraMetadataType* hidl_type) {
42 if (hidl_type == nullptr) {
43 ALOGE("%s: hidl_type is nullptr.", __FUNCTION__);
44 return BAD_VALUE;
45 }
46
47 switch (hal_type) {
48 case google_camera_hal::CameraMetadataType::kByte:
49 *hidl_type = CameraMetadataType::BYTE;
50 break;
51 case google_camera_hal::CameraMetadataType::kInt32:
52 *hidl_type = CameraMetadataType::INT32;
53 break;
54 case google_camera_hal::CameraMetadataType::kFloat:
55 *hidl_type = CameraMetadataType::FLOAT;
56 break;
57 case google_camera_hal::CameraMetadataType::kInt64:
58 *hidl_type = CameraMetadataType::INT64;
59 break;
60 case google_camera_hal::CameraMetadataType::kDouble:
61 *hidl_type = CameraMetadataType::DOUBLE;
62 break;
63 case google_camera_hal::CameraMetadataType::kRational:
64 *hidl_type = CameraMetadataType::RATIONAL;
65 break;
66 default:
67 ALOGE("%s: Unknown google_camera_hal::CameraMetadataType: %u",
68 __FUNCTION__, hal_type);
69 return BAD_VALUE;
70 }
71
72 return OK;
73 }
74
ConvertToHidlResourceCost(const google_camera_hal::CameraResourceCost & hal_cost,CameraResourceCost * hidl_cost)75 status_t ConvertToHidlResourceCost(
76 const google_camera_hal::CameraResourceCost& hal_cost,
77 CameraResourceCost* hidl_cost) {
78 if (hidl_cost == nullptr) {
79 ALOGE("%s: hidl_cost is nullptr.", __FUNCTION__);
80 return BAD_VALUE;
81 }
82
83 hidl_cost->resourceCost = hal_cost.resource_cost;
84 hidl_cost->conflictingDevices.resize(hal_cost.conflicting_devices.size());
85
86 for (uint32_t i = 0; i < hal_cost.conflicting_devices.size(); i++) {
87 hidl_cost->conflictingDevices[i] =
88 "device@" + HidlCameraDevice::kDeviceVersion + "/" +
89 HidlCameraProvider::kProviderName + "/" +
90 std::to_string(hal_cost.conflicting_devices[i]);
91 }
92
93 return OK;
94 }
95
ConvertToHidlVendorTagSections(const std::vector<google_camera_hal::VendorTagSection> & hal_sections,hidl_vec<VendorTagSection> * hidl_sections)96 status_t ConvertToHidlVendorTagSections(
97 const std::vector<google_camera_hal::VendorTagSection>& hal_sections,
98 hidl_vec<VendorTagSection>* hidl_sections) {
99 if (hidl_sections == nullptr) {
100 ALOGE("%s: hidl_sections is nullptr.", __FUNCTION__);
101 return BAD_VALUE;
102 }
103
104 hidl_sections->resize(hal_sections.size());
105 for (uint32_t i = 0; i < hal_sections.size(); i++) {
106 (*hidl_sections)[i].sectionName = hal_sections[i].section_name;
107 (*hidl_sections)[i].tags.resize(hal_sections[i].tags.size());
108
109 for (uint32_t j = 0; j < hal_sections[i].tags.size(); j++) {
110 (*hidl_sections)[i].tags[j].tagId = hal_sections[i].tags[j].tag_id;
111 (*hidl_sections)[i].tags[j].tagName = hal_sections[i].tags[j].tag_name;
112 status_t res =
113 ConvertToHidlVendorTagType(hal_sections[i].tags[j].tag_type,
114 &(*hidl_sections)[i].tags[j].tagType);
115 if (res != OK) {
116 ALOGE("%s: Converting to hidl vendor tag type failed. ", __FUNCTION__);
117 return res;
118 }
119 }
120 }
121
122 return OK;
123 }
124
ConvertToHidlStatus(status_t hal_status)125 Status ConvertToHidlStatus(status_t hal_status) {
126 switch (hal_status) {
127 case OK:
128 return Status::OK;
129 case BAD_VALUE:
130 return Status::ILLEGAL_ARGUMENT;
131 case -EBUSY:
132 return Status::CAMERA_IN_USE;
133 case -EUSERS:
134 return Status::MAX_CAMERAS_IN_USE;
135 case UNKNOWN_TRANSACTION:
136 return Status::METHOD_NOT_SUPPORTED;
137 case INVALID_OPERATION:
138 return Status::OPERATION_NOT_SUPPORTED;
139 case DEAD_OBJECT:
140 return Status::CAMERA_DISCONNECTED;
141 default:
142 return Status::INTERNAL_ERROR;
143 }
144 }
145
ConvertToHalTemplateType(RequestTemplate hidl_template,google_camera_hal::RequestTemplate * hal_template)146 status_t ConvertToHalTemplateType(
147 RequestTemplate hidl_template,
148 google_camera_hal::RequestTemplate* hal_template) {
149 if (hal_template == nullptr) {
150 ALOGE("%s: hal_template is nullptr.", __FUNCTION__);
151 return BAD_VALUE;
152 }
153
154 switch (hidl_template) {
155 case RequestTemplate::PREVIEW:
156 *hal_template = google_camera_hal::RequestTemplate::kPreview;
157 break;
158 case RequestTemplate::STILL_CAPTURE:
159 *hal_template = google_camera_hal::RequestTemplate::kStillCapture;
160 break;
161 case RequestTemplate::VIDEO_RECORD:
162 *hal_template = google_camera_hal::RequestTemplate::kVideoRecord;
163 break;
164 case RequestTemplate::VIDEO_SNAPSHOT:
165 *hal_template = google_camera_hal::RequestTemplate::kVideoSnapshot;
166 break;
167 case RequestTemplate::ZERO_SHUTTER_LAG:
168 *hal_template = google_camera_hal::RequestTemplate::kZeroShutterLag;
169 break;
170 case RequestTemplate::MANUAL:
171 *hal_template = google_camera_hal::RequestTemplate::kManual;
172 break;
173 default:
174 ALOGE("%s: Unknown HIDL RequestTemplate: %u", __FUNCTION__,
175 hidl_template);
176 return BAD_VALUE;
177 }
178
179 return OK;
180 }
181
ConvertToHidlHalStreamConfig(const std::vector<google_camera_hal::HalStream> & hal_configured_streams,HalStreamConfiguration * hidl_hal_stream_config)182 status_t ConvertToHidlHalStreamConfig(
183 const std::vector<google_camera_hal::HalStream>& hal_configured_streams,
184 HalStreamConfiguration* hidl_hal_stream_config) {
185 if (hidl_hal_stream_config == nullptr) {
186 ALOGE("%s: hidl_hal_stream_config is nullptr.", __FUNCTION__);
187 return BAD_VALUE;
188 }
189
190 hidl_hal_stream_config->streams.resize(hal_configured_streams.size());
191
192 for (uint32_t i = 0; i < hal_configured_streams.size(); i++) {
193 if (hal_configured_streams[i].is_physical_camera_stream) {
194 hidl_hal_stream_config->streams[i].physicalCameraId =
195 std::to_string(hal_configured_streams[i].physical_camera_id);
196 }
197
198 hidl_hal_stream_config->streams[i].v3_3.overrideDataSpace =
199 hal_configured_streams[i].override_data_space;
200
201 hidl_hal_stream_config->streams[i].v3_3.v3_2.id =
202 hal_configured_streams[i].id;
203
204 hidl_hal_stream_config->streams[i].v3_3.v3_2.overrideFormat =
205 (::android::hardware::graphics::common::V1_0::PixelFormat)
206 hal_configured_streams[i]
207 .override_format;
208
209 hidl_hal_stream_config->streams[i].v3_3.v3_2.producerUsage =
210 hal_configured_streams[i].producer_usage;
211
212 hidl_hal_stream_config->streams[i].v3_3.v3_2.consumerUsage =
213 hal_configured_streams[i].consumer_usage;
214
215 hidl_hal_stream_config->streams[i].v3_3.v3_2.maxBuffers =
216 hal_configured_streams[i].max_buffers;
217 }
218
219 return OK;
220 }
221
WriteToResultMetadataQueue(camera_metadata_t * metadata,MessageQueue<uint8_t,kSynchronizedReadWrite> * result_metadata_queue)222 status_t WriteToResultMetadataQueue(
223 camera_metadata_t* metadata,
224 MessageQueue<uint8_t, kSynchronizedReadWrite>* result_metadata_queue) {
225 if (result_metadata_queue == nullptr) {
226 return BAD_VALUE;
227 }
228
229 if (result_metadata_queue->availableToWrite() <= 0) {
230 ALOGW("%s: result_metadata_queue is not available to write", __FUNCTION__);
231 return BAD_VALUE;
232 }
233
234 uint32_t size = get_camera_metadata_size(metadata);
235 bool success = result_metadata_queue->write(
236 reinterpret_cast<const uint8_t*>(metadata), size);
237 if (!success) {
238 ALOGW("%s: Writing to result metadata queue failed. (size=%u)",
239 __FUNCTION__, size);
240 return INVALID_OPERATION;
241 }
242
243 return OK;
244 }
245
246 // Try writing result metadata to result metadata queue. If failed, return
247 // the metadata to the caller in out_hal_metadata.
TryWritingToResultMetadataQueue(std::unique_ptr<google_camera_hal::HalCameraMetadata> hal_metadata,MessageQueue<uint8_t,kSynchronizedReadWrite> * result_metadata_queue,uint64_t * fmq_result_size,std::unique_ptr<google_camera_hal::HalCameraMetadata> * out_hal_metadata)248 status_t TryWritingToResultMetadataQueue(
249 std::unique_ptr<google_camera_hal::HalCameraMetadata> hal_metadata,
250 MessageQueue<uint8_t, kSynchronizedReadWrite>* result_metadata_queue,
251 uint64_t* fmq_result_size,
252 std::unique_ptr<google_camera_hal::HalCameraMetadata>* out_hal_metadata) {
253 if (out_hal_metadata == nullptr) {
254 ALOGE("%s: out_hal_metadata is nullptr.", __FUNCTION__);
255 return BAD_VALUE;
256 }
257
258 *out_hal_metadata = std::move(hal_metadata);
259
260 if (fmq_result_size == nullptr) {
261 ALOGE("%s: fmq_result_size is nullptr", __FUNCTION__);
262 return BAD_VALUE;
263 }
264
265 *fmq_result_size = 0;
266 if (*out_hal_metadata == nullptr) {
267 return OK;
268 }
269
270 camera_metadata_t* metadata = (*out_hal_metadata)->ReleaseCameraMetadata();
271 // Temporarily use the raw metadata to write to metadata queue.
272 status_t res = WriteToResultMetadataQueue(metadata, result_metadata_queue);
273 *out_hal_metadata = google_camera_hal::HalCameraMetadata::Create(metadata);
274
275 if (res != OK) {
276 ALOGW("%s: Writing to result metadata queue failed: %s(%d)", __FUNCTION__,
277 strerror(-res), res);
278 return res;
279 }
280
281 *fmq_result_size = (*out_hal_metadata)->GetCameraMetadataSize();
282 *out_hal_metadata = nullptr;
283 return OK;
284 }
285
ConverToHidlResultMetadata(MessageQueue<uint8_t,kSynchronizedReadWrite> * result_metadata_queue,std::unique_ptr<google_camera_hal::HalCameraMetadata> hal_metadata,CameraMetadata * hidl_metadata,uint64_t * fmq_result_size)286 status_t ConverToHidlResultMetadata(
287 MessageQueue<uint8_t, kSynchronizedReadWrite>* result_metadata_queue,
288 std::unique_ptr<google_camera_hal::HalCameraMetadata> hal_metadata,
289 CameraMetadata* hidl_metadata, uint64_t* fmq_result_size) {
290 if (TryWritingToResultMetadataQueue(std::move(hal_metadata),
291 result_metadata_queue, fmq_result_size,
292 &hal_metadata) == OK) {
293 return OK;
294 }
295
296 // If writing to metadata queue failed, attach the metadata to hidl_metadata.
297 if (hidl_metadata == nullptr) {
298 ALOGE("%s: hidl_metadata is nullptr", __FUNCTION__);
299 return BAD_VALUE;
300 }
301
302 uint32_t metadata_size = hal_metadata->GetCameraMetadataSize();
303 hidl_metadata->setToExternal(
304 reinterpret_cast<uint8_t*>(hal_metadata->ReleaseCameraMetadata()),
305 metadata_size, /*shouldOwn=*/true);
306
307 return OK;
308 }
309
ConvertToHidlBufferStatus(google_camera_hal::BufferStatus hal_status,BufferStatus * hidl_status)310 status_t ConvertToHidlBufferStatus(google_camera_hal::BufferStatus hal_status,
311 BufferStatus* hidl_status) {
312 if (hidl_status == nullptr) {
313 ALOGE("%s: hidl_status is nullptr.", __FUNCTION__);
314 return BAD_VALUE;
315 }
316
317 switch (hal_status) {
318 case google_camera_hal::BufferStatus::kOk:
319 *hidl_status = BufferStatus::OK;
320 break;
321 case google_camera_hal::BufferStatus::kError:
322 *hidl_status = BufferStatus::ERROR;
323 break;
324 default:
325 ALOGE("%s: Unknown HAL buffer status: %u", __FUNCTION__, hal_status);
326 return BAD_VALUE;
327 }
328
329 return OK;
330 }
331
ConvertToHidlStreamBuffer(const google_camera_hal::StreamBuffer & hal_buffer,StreamBuffer * hidl_buffer)332 status_t ConvertToHidlStreamBuffer(
333 const google_camera_hal::StreamBuffer& hal_buffer,
334 StreamBuffer* hidl_buffer) {
335 if (hidl_buffer == nullptr) {
336 ALOGE("%s: hidl_buffer is nullptr", __FUNCTION__);
337 return BAD_VALUE;
338 }
339
340 hidl_buffer->streamId = hal_buffer.stream_id;
341 hidl_buffer->bufferId = hal_buffer.buffer_id;
342 hidl_buffer->buffer = nullptr;
343
344 status_t res =
345 ConvertToHidlBufferStatus(hal_buffer.status, &hidl_buffer->status);
346 if (res != OK) {
347 ALOGE("%s: Converting to HIDL buffer status failed: %s(%d)", __FUNCTION__,
348 strerror(-res), res);
349 return res;
350 }
351
352 hidl_buffer->acquireFence = nullptr;
353 hidl_buffer->releaseFence = hal_buffer.release_fence;
354 return OK;
355 }
356
ConvertToHidlCaptureResult_V3_2(MessageQueue<uint8_t,kSynchronizedReadWrite> * result_metadata_queue,google_camera_hal::CaptureResult * hal_result,device::V3_2::CaptureResult * hidl_result)357 status_t ConvertToHidlCaptureResult_V3_2(
358 MessageQueue<uint8_t, kSynchronizedReadWrite>* result_metadata_queue,
359 google_camera_hal::CaptureResult* hal_result,
360 device::V3_2::CaptureResult* hidl_result) {
361 if (hidl_result == nullptr) {
362 ALOGE("%s: hidl_result is nullptr.", __FUNCTION__);
363 return BAD_VALUE;
364 }
365
366 if (hal_result == nullptr) {
367 ALOGE("%s: hal_result is nullptr.", __FUNCTION__);
368 return BAD_VALUE;
369 }
370
371 hidl_result->frameNumber = hal_result->frame_number;
372
373 status_t res = ConverToHidlResultMetadata(
374 result_metadata_queue, std::move(hal_result->result_metadata),
375 &hidl_result->result, &hidl_result->fmqResultSize);
376 if (res != OK) {
377 ALOGE("%s: Converting to HIDL result metadata failed: %s(%d).",
378 __FUNCTION__, strerror(-res), res);
379 return res;
380 }
381
382 hidl_result->outputBuffers.resize(hal_result->output_buffers.size());
383 for (uint32_t i = 0; i < hidl_result->outputBuffers.size(); i++) {
384 res = ConvertToHidlStreamBuffer(hal_result->output_buffers[i],
385 &hidl_result->outputBuffers[i]);
386 if (res != OK) {
387 ALOGE("%s: Converting to HIDL output stream buffer failed: %s(%d)",
388 __FUNCTION__, strerror(-res), res);
389 return res;
390 }
391 }
392
393 uint32_t num_input_buffers = hal_result->input_buffers.size();
394 if (num_input_buffers > 0) {
395 if (num_input_buffers > 1) {
396 ALOGW("%s: HAL result should not have more than 1 input buffer. (=%u)",
397 __FUNCTION__, num_input_buffers);
398 }
399
400 res = ConvertToHidlStreamBuffer(hal_result->input_buffers[0],
401 &hidl_result->inputBuffer);
402 if (res != OK) {
403 ALOGE("%s: Converting to HIDL input stream buffer failed: %s(%d)",
404 __FUNCTION__, strerror(-res), res);
405 return res;
406 }
407 } else {
408 hidl_result->inputBuffer.streamId = -1;
409 }
410
411 hidl_result->partialResult = hal_result->partial_result;
412 return OK;
413 }
414
ConvertToHidlCaptureResult(MessageQueue<uint8_t,kSynchronizedReadWrite> * result_metadata_queue,std::unique_ptr<google_camera_hal::CaptureResult> hal_result,CaptureResult * hidl_result)415 status_t ConvertToHidlCaptureResult(
416 MessageQueue<uint8_t, kSynchronizedReadWrite>* result_metadata_queue,
417 std::unique_ptr<google_camera_hal::CaptureResult> hal_result,
418 CaptureResult* hidl_result) {
419 if (hidl_result == nullptr) {
420 ALOGE("%s: hidl_result is nullptr.", __FUNCTION__);
421 return BAD_VALUE;
422 }
423
424 if (hal_result == nullptr) {
425 ALOGE("%s: hal_result is nullptr.", __FUNCTION__);
426 return BAD_VALUE;
427 }
428
429 status_t res = ConvertToHidlCaptureResult_V3_2(
430 result_metadata_queue, hal_result.get(), &hidl_result->v3_2);
431 if (res != OK) {
432 ALOGE("%s: Converting to V3.2 HIDL result failed: %s(%d).", __FUNCTION__,
433 strerror(-res), res);
434 return res;
435 }
436
437 uint32_t num_physical_metadata = hal_result->physical_metadata.size();
438 hidl_result->physicalCameraMetadata.resize(num_physical_metadata);
439
440 for (uint32_t i = 0; i < num_physical_metadata; i++) {
441 hidl_result->physicalCameraMetadata[i].physicalCameraId =
442 std::to_string(hal_result->physical_metadata[i].physical_camera_id);
443
444 res = ConverToHidlResultMetadata(
445 result_metadata_queue,
446 std::move(hal_result->physical_metadata[i].metadata),
447 &hidl_result->physicalCameraMetadata[i].metadata,
448 &hidl_result->physicalCameraMetadata[i].fmqMetadataSize);
449 if (res != OK) {
450 ALOGE("%s: Converting to HIDL physical metadata failed: %s(%d).",
451 __FUNCTION__, strerror(-res), res);
452 return res;
453 }
454 }
455
456 return OK;
457 }
458
ConvertToHidlErrorMessage(const google_camera_hal::ErrorMessage & hal_error,ErrorMsg * hidl_error)459 status_t ConvertToHidlErrorMessage(
460 const google_camera_hal::ErrorMessage& hal_error, ErrorMsg* hidl_error) {
461 if (hidl_error == nullptr) {
462 ALOGE("%s: hidl_error is nullptr.", __FUNCTION__);
463 return BAD_VALUE;
464 }
465
466 hidl_error->frameNumber = hal_error.frame_number;
467 hidl_error->errorStreamId = hal_error.error_stream_id;
468
469 switch (hal_error.error_code) {
470 case google_camera_hal::ErrorCode::kErrorDevice:
471 hidl_error->errorCode = ErrorCode::ERROR_DEVICE;
472 break;
473 case google_camera_hal::ErrorCode::kErrorRequest:
474 hidl_error->errorCode = ErrorCode::ERROR_REQUEST;
475 break;
476 case google_camera_hal::ErrorCode::kErrorResult:
477 hidl_error->errorCode = ErrorCode::ERROR_RESULT;
478 break;
479 case google_camera_hal::ErrorCode::kErrorBuffer:
480 hidl_error->errorCode = ErrorCode::ERROR_BUFFER;
481 break;
482 default:
483 ALOGE("%s: Unknown error code: %u", __FUNCTION__, hal_error.error_code);
484 return BAD_VALUE;
485 }
486
487 return OK;
488 }
489
ConvertToHidlShutterMessage(const google_camera_hal::ShutterMessage & hal_shutter,ShutterMsg * hidl_shutter)490 status_t ConvertToHidlShutterMessage(
491 const google_camera_hal::ShutterMessage& hal_shutter,
492 ShutterMsg* hidl_shutter) {
493 if (hidl_shutter == nullptr) {
494 ALOGE("%s: hidl_shutter is nullptr.", __FUNCTION__);
495 return BAD_VALUE;
496 }
497
498 hidl_shutter->frameNumber = hal_shutter.frame_number;
499 hidl_shutter->timestamp = hal_shutter.timestamp_ns;
500 return OK;
501 }
502
ConverToHidlNotifyMessage(const google_camera_hal::NotifyMessage & hal_message,NotifyMsg * hidl_message)503 status_t ConverToHidlNotifyMessage(
504 const google_camera_hal::NotifyMessage& hal_message,
505 NotifyMsg* hidl_message) {
506 if (hidl_message == nullptr) {
507 ALOGE("%s: hidl_message is nullptr.", __FUNCTION__);
508 return BAD_VALUE;
509 }
510
511 status_t res;
512 switch (hal_message.type) {
513 case google_camera_hal::MessageType::kError:
514 hidl_message->type = MsgType::ERROR;
515 res = ConvertToHidlErrorMessage(hal_message.message.error,
516 &hidl_message->msg.error);
517 if (res != OK) {
518 ALOGE("%s: Converting to HIDL error message failed: %s(%d)",
519 __FUNCTION__, strerror(-res), res);
520 return res;
521 }
522 break;
523 case google_camera_hal::MessageType::kShutter:
524 hidl_message->type = MsgType::SHUTTER;
525 res = ConvertToHidlShutterMessage(hal_message.message.shutter,
526 &hidl_message->msg.shutter);
527 if (res != OK) {
528 ALOGE("%s: Converting to HIDL shutter message failed: %s(%d)",
529 __FUNCTION__, strerror(-res), res);
530 return res;
531 }
532 break;
533 default:
534 ALOGE("%s: Unknown message type: %u", __FUNCTION__, hal_message.type);
535 return BAD_VALUE;
536 }
537
538 return OK;
539 }
540
ConvertToHidlCameraDeviceStatus(google_camera_hal::CameraDeviceStatus hal_camera_device_status,CameraDeviceStatus * hidl_camera_device_status)541 status_t ConvertToHidlCameraDeviceStatus(
542 google_camera_hal::CameraDeviceStatus hal_camera_device_status,
543 CameraDeviceStatus* hidl_camera_device_status) {
544 if (hidl_camera_device_status == nullptr) {
545 ALOGE("%s: hidl_camera_device_status is nullptr.", __FUNCTION__);
546 return BAD_VALUE;
547 }
548
549 switch (hal_camera_device_status) {
550 case google_camera_hal::CameraDeviceStatus::kNotPresent:
551 *hidl_camera_device_status = CameraDeviceStatus::NOT_PRESENT;
552 break;
553 case google_camera_hal::CameraDeviceStatus::kPresent:
554 *hidl_camera_device_status = CameraDeviceStatus::PRESENT;
555 break;
556 case google_camera_hal::CameraDeviceStatus::kEnumerating:
557 *hidl_camera_device_status = CameraDeviceStatus::ENUMERATING;
558 break;
559 default:
560 ALOGE("%s: Unknown HAL camera device status: %u", __FUNCTION__,
561 hal_camera_device_status);
562 return BAD_VALUE;
563 }
564
565 return OK;
566 }
567
ConvertToHidlTorchModeStatus(google_camera_hal::TorchModeStatus hal_torch_status,TorchModeStatus * hidl_torch_status)568 status_t ConvertToHidlTorchModeStatus(
569 google_camera_hal::TorchModeStatus hal_torch_status,
570 TorchModeStatus* hidl_torch_status) {
571 if (hidl_torch_status == nullptr) {
572 ALOGE("%s: hidl_torch_status is nullptr.", __FUNCTION__);
573 return BAD_VALUE;
574 }
575
576 switch (hal_torch_status) {
577 case google_camera_hal::TorchModeStatus::kNotAvailable:
578 *hidl_torch_status = TorchModeStatus::NOT_AVAILABLE;
579 break;
580 case google_camera_hal::TorchModeStatus::kAvailableOff:
581 *hidl_torch_status = TorchModeStatus::AVAILABLE_OFF;
582 break;
583 case google_camera_hal::TorchModeStatus::kAvailableOn:
584 *hidl_torch_status = TorchModeStatus::AVAILABLE_ON;
585 break;
586 default:
587 ALOGE("%s: Unknown HAL torch mode status: %u", __FUNCTION__,
588 hal_torch_status);
589 return BAD_VALUE;
590 }
591
592 return OK;
593 }
594
ConvertToHidlBufferRequest(const std::vector<google_camera_hal::BufferRequest> & hal_buffer_requests,hidl_vec<BufferRequest> * hidl_buffer_requests)595 status_t ConvertToHidlBufferRequest(
596 const std::vector<google_camera_hal::BufferRequest>& hal_buffer_requests,
597 hidl_vec<BufferRequest>* hidl_buffer_requests) {
598 if (hidl_buffer_requests == nullptr) {
599 ALOGE("%s: hidl_buffer_request is nullptr.", __FUNCTION__);
600 return BAD_VALUE;
601 }
602
603 hidl_buffer_requests->resize(hal_buffer_requests.size());
604 for (uint32_t i = 0; i < hal_buffer_requests.size(); i++) {
605 (*hidl_buffer_requests)[i].streamId = hal_buffer_requests[i].stream_id;
606 (*hidl_buffer_requests)[i].numBuffersRequested =
607 hal_buffer_requests[i].num_buffers_requested;
608 }
609 return OK;
610 }
611
ConvertToHalBufferStatus(BufferStatus hidl_status,google_camera_hal::BufferStatus * hal_status)612 status_t ConvertToHalBufferStatus(BufferStatus hidl_status,
613 google_camera_hal::BufferStatus* hal_status) {
614 if (hal_status == nullptr) {
615 ALOGE("%s: hal_status is nullptr.", __FUNCTION__);
616 return BAD_VALUE;
617 }
618
619 switch (hidl_status) {
620 case BufferStatus::OK:
621 *hal_status = google_camera_hal::BufferStatus::kOk;
622 break;
623 case BufferStatus::ERROR:
624 *hal_status = google_camera_hal::BufferStatus::kError;
625 break;
626 default:
627 ALOGE("%s: Unknown HIDL buffer status: %u", __FUNCTION__, hidl_status);
628 return BAD_VALUE;
629 }
630
631 return OK;
632 }
633
ConvertToHalStreamBuffer(const StreamBuffer & hidl_buffer,google_camera_hal::StreamBuffer * hal_buffer)634 status_t ConvertToHalStreamBuffer(const StreamBuffer& hidl_buffer,
635 google_camera_hal::StreamBuffer* hal_buffer) {
636 if (hal_buffer == nullptr) {
637 ALOGE("%s: hal_buffer is nullptr.", __FUNCTION__);
638 return BAD_VALUE;
639 }
640
641 hal_buffer->stream_id = hidl_buffer.streamId;
642 hal_buffer->buffer_id = hidl_buffer.bufferId;
643 hal_buffer->buffer = hidl_buffer.buffer.getNativeHandle();
644
645 status_t res =
646 ConvertToHalBufferStatus(hidl_buffer.status, &hal_buffer->status);
647 if (res != OK) {
648 ALOGE("%s: Converting to HAL buffer status failed: %s(%d)", __FUNCTION__,
649 strerror(-res), res);
650 return res;
651 }
652
653 hal_buffer->acquire_fence = hidl_buffer.acquireFence.getNativeHandle();
654 hal_buffer->release_fence = hidl_buffer.releaseFence.getNativeHandle();
655
656 return OK;
657 }
658
ConvertToHalMetadata(uint32_t message_queue_setting_size,MessageQueue<uint8_t,kSynchronizedReadWrite> * request_metadata_queue,const CameraMetadata & request_settings,std::unique_ptr<google_camera_hal::HalCameraMetadata> * hal_metadata)659 status_t ConvertToHalMetadata(
660 uint32_t message_queue_setting_size,
661 MessageQueue<uint8_t, kSynchronizedReadWrite>* request_metadata_queue,
662 const CameraMetadata& request_settings,
663 std::unique_ptr<google_camera_hal::HalCameraMetadata>* hal_metadata) {
664 if (hal_metadata == nullptr) {
665 ALOGE("%s: hal_metadata is nullptr.", __FUNCTION__);
666 return BAD_VALUE;
667 }
668
669 const camera_metadata_t* metadata = nullptr;
670 CameraMetadata metadata_queue_settings;
671
672 if (message_queue_setting_size == 0) {
673 // Use the settings in the request.
674 if (request_settings.size() != 0) {
675 metadata =
676 reinterpret_cast<const camera_metadata_t*>(request_settings.data());
677 }
678 } else {
679 // Read the settings from request metadata queue.
680 if (request_metadata_queue == nullptr) {
681 ALOGE("%s: request_metadata_queue is nullptr", __FUNCTION__);
682 return BAD_VALUE;
683 }
684
685 metadata_queue_settings.resize(message_queue_setting_size);
686 bool success = request_metadata_queue->read(metadata_queue_settings.data(),
687 message_queue_setting_size);
688 if (!success) {
689 ALOGE("%s: Failed to read from request metadata queue.", __FUNCTION__);
690 return BAD_VALUE;
691 }
692
693 metadata = reinterpret_cast<const camera_metadata_t*>(
694 metadata_queue_settings.data());
695 }
696
697 if (metadata == nullptr) {
698 *hal_metadata = nullptr;
699 return OK;
700 }
701
702 *hal_metadata = google_camera_hal::HalCameraMetadata::Clone(metadata);
703 return OK;
704 }
705
ConvertToHalCaptureRequest(const CaptureRequest & hidl_request,MessageQueue<uint8_t,kSynchronizedReadWrite> * request_metadata_queue,google_camera_hal::CaptureRequest * hal_request)706 status_t ConvertToHalCaptureRequest(
707 const CaptureRequest& hidl_request,
708 MessageQueue<uint8_t, kSynchronizedReadWrite>* request_metadata_queue,
709 google_camera_hal::CaptureRequest* hal_request) {
710 if (hal_request == nullptr) {
711 ALOGE("%s: hal_request is nullptr.", __FUNCTION__);
712 return BAD_VALUE;
713 }
714
715 hal_request->frame_number = hidl_request.v3_2.frameNumber;
716
717 status_t res = ConvertToHalMetadata(
718 hidl_request.v3_2.fmqSettingsSize, request_metadata_queue,
719 hidl_request.v3_2.settings, &hal_request->settings);
720 if (res != OK) {
721 ALOGE("%s: Converting metadata failed: %s(%d)", __FUNCTION__,
722 strerror(-res), res);
723 return res;
724 }
725
726 google_camera_hal::StreamBuffer hal_buffer = {};
727 if (hidl_request.v3_2.inputBuffer.buffer != nullptr) {
728 res = ConvertToHalStreamBuffer(hidl_request.v3_2.inputBuffer, &hal_buffer);
729 if (res != OK) {
730 ALOGE("%s: Converting hal stream buffer failed: %s(%d)", __FUNCTION__,
731 strerror(-res), res);
732 return res;
733 }
734
735 hal_request->input_buffers.push_back(hal_buffer);
736 }
737
738 for (auto& buffer : hidl_request.v3_2.outputBuffers) {
739 hal_buffer = {};
740 status_t res = ConvertToHalStreamBuffer(buffer, &hal_buffer);
741 if (res != OK) {
742 ALOGE("%s: Converting hal stream buffer failed: %s(%d)", __FUNCTION__,
743 strerror(-res), res);
744 return res;
745 }
746
747 hal_request->output_buffers.push_back(hal_buffer);
748 }
749
750 for (auto hidl_physical_settings : hidl_request.physicalCameraSettings) {
751 std::unique_ptr<google_camera_hal::HalCameraMetadata> hal_physical_settings;
752 res = ConvertToHalMetadata(
753 hidl_physical_settings.fmqSettingsSize, request_metadata_queue,
754 hidl_physical_settings.settings, &hal_physical_settings);
755 if (res != OK) {
756 ALOGE("%s: Converting to HAL metadata failed: %s(%d)", __FUNCTION__,
757 strerror(-res), res);
758 return res;
759 }
760
761 uint32_t camera_id = std::stoul(hidl_physical_settings.physicalCameraId);
762 hal_request->physical_camera_settings.emplace(
763 camera_id, std::move(hal_physical_settings));
764 }
765
766 return OK;
767 }
768
ConvertToHalBufferCaches(const hidl_vec<BufferCache> & hidl_buffer_caches,std::vector<google_camera_hal::BufferCache> * hal_buffer_caches)769 status_t ConvertToHalBufferCaches(
770 const hidl_vec<BufferCache>& hidl_buffer_caches,
771 std::vector<google_camera_hal::BufferCache>* hal_buffer_caches) {
772 if (hal_buffer_caches == nullptr) {
773 ALOGE("%s: hal_buffer_caches is nullptr.", __FUNCTION__);
774 return BAD_VALUE;
775 }
776
777 for (auto hidl_cache : hidl_buffer_caches) {
778 google_camera_hal::BufferCache hal_cache;
779 hal_cache.stream_id = hidl_cache.streamId;
780 hal_cache.buffer_id = hidl_cache.bufferId;
781
782 hal_buffer_caches->push_back(hal_cache);
783 }
784
785 return OK;
786 }
787
ConvertToHalStreamConfigurationMode(StreamConfigurationMode hidl_mode,google_camera_hal::StreamConfigurationMode * hal_mode)788 status_t ConvertToHalStreamConfigurationMode(
789 StreamConfigurationMode hidl_mode,
790 google_camera_hal::StreamConfigurationMode* hal_mode) {
791 if (hal_mode == nullptr) {
792 ALOGE("%s: hal_mode is nullptr.", __FUNCTION__);
793 return BAD_VALUE;
794 }
795
796 switch (hidl_mode) {
797 case StreamConfigurationMode::NORMAL_MODE:
798 *hal_mode = google_camera_hal::StreamConfigurationMode::kNormal;
799 break;
800 case StreamConfigurationMode::CONSTRAINED_HIGH_SPEED_MODE:
801 *hal_mode =
802 google_camera_hal::StreamConfigurationMode::kConstrainedHighSpeed;
803 break;
804 default:
805 ALOGE("%s: Unknown configuration mode %u", __FUNCTION__, hidl_mode);
806 return BAD_VALUE;
807 }
808
809 return OK;
810 }
811
ConverToHalStreamConfig(const StreamConfiguration & hidl_stream_config,google_camera_hal::StreamConfiguration * hal_stream_config)812 status_t ConverToHalStreamConfig(
813 const StreamConfiguration& hidl_stream_config,
814 google_camera_hal::StreamConfiguration* hal_stream_config) {
815 if (hal_stream_config == nullptr) {
816 ALOGE("%s: hal_stream_config is nullptr.", __FUNCTION__);
817 return BAD_VALUE;
818 }
819
820 status_t res;
821
822 for (auto hidl_stream : hidl_stream_config.v3_4.streams) {
823 google_camera_hal::Stream hal_stream;
824 res = ConvertToHalStream(hidl_stream, &hal_stream);
825 if (res != OK) {
826 ALOGE("%s: Converting to HAL stream failed: %s(%d)", __FUNCTION__,
827 strerror(-res), res);
828 return res;
829 }
830
831 hal_stream_config->streams.push_back(hal_stream);
832 }
833
834 res = ConvertToHalStreamConfigurationMode(
835 hidl_stream_config.v3_4.operationMode, &hal_stream_config->operation_mode);
836 if (res != OK) {
837 ALOGE("%s: Converting to HAL opeation mode failed: %s(%d)", __FUNCTION__,
838 strerror(-res), res);
839 return res;
840 }
841
842 res = ConvertToHalMetadata(0, nullptr, hidl_stream_config.v3_4.sessionParams,
843 &hal_stream_config->session_params);
844 if (res != OK) {
845 ALOGE("%s: Converting to HAL metadata failed: %s(%d)", __FUNCTION__,
846 strerror(-res), res);
847 return res;
848 }
849
850 hal_stream_config->stream_config_counter =
851 hidl_stream_config.streamConfigCounter;
852
853 return OK;
854 }
855
ConverToHalStreamConfig(const device::V3_4::StreamConfiguration & hidl_stream_config,google_camera_hal::StreamConfiguration * hal_stream_config)856 status_t ConverToHalStreamConfig(
857 const device::V3_4::StreamConfiguration& hidl_stream_config,
858 google_camera_hal::StreamConfiguration* hal_stream_config) {
859 if (hal_stream_config == nullptr) {
860 ALOGE("%s: hal_stream_config is nullptr.", __FUNCTION__);
861 return BAD_VALUE;
862 }
863
864 status_t res;
865 for (auto hidl_stream : hidl_stream_config.streams) {
866 google_camera_hal::Stream hal_stream;
867 res = ConvertToHalStream(hidl_stream, &hal_stream);
868 if (res != OK) {
869 ALOGE("%s: Converting to HAL stream failed: %s(%d)", __FUNCTION__,
870 strerror(-res), res);
871 return res;
872 }
873 hal_stream_config->streams.push_back(hal_stream);
874 }
875
876 res = ConvertToHalStreamConfigurationMode(hidl_stream_config.operationMode,
877 &hal_stream_config->operation_mode);
878 if (res != OK) {
879 ALOGE("%s: Converting to HAL opeation mode failed: %s(%d)", __FUNCTION__,
880 strerror(-res), res);
881 return res;
882 }
883
884 res = ConvertToHalMetadata(0, nullptr, hidl_stream_config.sessionParams,
885 &hal_stream_config->session_params);
886 if (res != OK) {
887 ALOGE("%s: Converting to HAL metadata failed: %s(%d)", __FUNCTION__,
888 strerror(-res), res);
889 return res;
890 }
891
892 return OK;
893 }
894
ConvertToHalStreamType(StreamType hidl_stream_type,google_camera_hal::StreamType * hal_stream_type)895 status_t ConvertToHalStreamType(StreamType hidl_stream_type,
896 google_camera_hal::StreamType* hal_stream_type) {
897 if (hal_stream_type == nullptr) {
898 ALOGE("%s: hal_stream_type is nullptr.", __FUNCTION__);
899 return BAD_VALUE;
900 }
901
902 switch (hidl_stream_type) {
903 case StreamType::OUTPUT:
904 *hal_stream_type = google_camera_hal::StreamType::kOutput;
905 break;
906 case StreamType::INPUT:
907 *hal_stream_type = google_camera_hal::StreamType::kInput;
908 break;
909 default:
910 ALOGE("%s: Unknown stream type: %u", __FUNCTION__, hidl_stream_type);
911 return BAD_VALUE;
912 }
913
914 return OK;
915 }
916
ConvertToHalStreamRotation(StreamRotation hidl_stream_rotation,google_camera_hal::StreamRotation * hal_stream_rotation)917 status_t ConvertToHalStreamRotation(
918 StreamRotation hidl_stream_rotation,
919 google_camera_hal::StreamRotation* hal_stream_rotation) {
920 if (hal_stream_rotation == nullptr) {
921 ALOGE("%s: hal_stream_rotation is nullptr.", __FUNCTION__);
922 return BAD_VALUE;
923 }
924
925 switch (hidl_stream_rotation) {
926 case StreamRotation::ROTATION_0:
927 *hal_stream_rotation = google_camera_hal::StreamRotation::kRotation0;
928 break;
929 case StreamRotation::ROTATION_90:
930 *hal_stream_rotation = google_camera_hal::StreamRotation::kRotation90;
931 break;
932 case StreamRotation::ROTATION_180:
933 *hal_stream_rotation = google_camera_hal::StreamRotation::kRotation180;
934 break;
935 case StreamRotation::ROTATION_270:
936 *hal_stream_rotation = google_camera_hal::StreamRotation::kRotation270;
937 break;
938 default:
939 ALOGE("%s: Unknown stream rotation: %u", __FUNCTION__,
940 hidl_stream_rotation);
941 return BAD_VALUE;
942 }
943
944 return OK;
945 }
946
ConvertToHalStream(const Stream & hidl_stream,google_camera_hal::Stream * hal_stream)947 status_t ConvertToHalStream(const Stream& hidl_stream,
948 google_camera_hal::Stream* hal_stream) {
949 if (hal_stream == nullptr) {
950 ALOGE("%s: hal_stream is nullptr.", __FUNCTION__);
951 return BAD_VALUE;
952 }
953
954 *hal_stream = {};
955
956 hal_stream->id = hidl_stream.v3_2.id;
957
958 status_t res = ConvertToHalStreamType(hidl_stream.v3_2.streamType,
959 &hal_stream->stream_type);
960 if (res != OK) {
961 ALOGE("%s: Converting to HAL stream type failed: %s(%d)", __FUNCTION__,
962 strerror(-res), res);
963 return res;
964 }
965
966 hal_stream->width = hidl_stream.v3_2.width;
967 hal_stream->height = hidl_stream.v3_2.height;
968 hal_stream->format = (android_pixel_format_t)hidl_stream.v3_2.format;
969 hal_stream->usage = (uint64_t)hidl_stream.v3_2.usage;
970 hal_stream->data_space = (android_dataspace_t)hidl_stream.v3_2.dataSpace;
971
972 res = ConvertToHalStreamRotation(hidl_stream.v3_2.rotation,
973 &hal_stream->rotation);
974 if (res != OK) {
975 ALOGE("%s: Converting to HAL stream rotation failed: %s(%d)", __FUNCTION__,
976 strerror(-res), res);
977 return res;
978 }
979
980 if (hidl_stream.physicalCameraId.empty()) {
981 hal_stream->is_physical_camera_stream = false;
982 } else {
983 hal_stream->is_physical_camera_stream = true;
984 hal_stream->physical_camera_id = std::stoul(hidl_stream.physicalCameraId);
985 }
986
987 hal_stream->buffer_size = hidl_stream.bufferSize;
988
989 return OK;
990 }
991
ConvertToHalTorchMode(TorchMode hidl_torch_mode,google_camera_hal::TorchMode * hal_torch_mode)992 status_t ConvertToHalTorchMode(TorchMode hidl_torch_mode,
993 google_camera_hal::TorchMode* hal_torch_mode) {
994 if (hal_torch_mode == nullptr) {
995 ALOGE("%s: hal_torch_mode is nullptr.", __FUNCTION__);
996 return BAD_VALUE;
997 }
998
999 switch (hidl_torch_mode) {
1000 case TorchMode::ON:
1001 *hal_torch_mode = google_camera_hal::TorchMode::kOn;
1002 break;
1003 case TorchMode::OFF:
1004 *hal_torch_mode = google_camera_hal::TorchMode::kOff;
1005 break;
1006 default:
1007 ALOGE("%s: Unknown torch mode: %u", __FUNCTION__, hidl_torch_mode);
1008 return BAD_VALUE;
1009 }
1010
1011 return OK;
1012 }
1013
ConvertToHalBufferRequestStatus(const BufferRequestStatus & hidl_buffer_request_status,google_camera_hal::BufferRequestStatus * hal_buffer_request_status)1014 status_t ConvertToHalBufferRequestStatus(
1015 const BufferRequestStatus& hidl_buffer_request_status,
1016 google_camera_hal::BufferRequestStatus* hal_buffer_request_status) {
1017 if (hal_buffer_request_status == nullptr) {
1018 ALOGE("%s: hal_buffer_request_status is nullptr.", __FUNCTION__);
1019 return BAD_VALUE;
1020 }
1021
1022 switch (hidl_buffer_request_status) {
1023 case BufferRequestStatus::OK:
1024 *hal_buffer_request_status = google_camera_hal::BufferRequestStatus::kOk;
1025 break;
1026 case BufferRequestStatus::FAILED_PARTIAL:
1027 *hal_buffer_request_status =
1028 google_camera_hal::BufferRequestStatus::kFailedPartial;
1029 break;
1030 case BufferRequestStatus::FAILED_CONFIGURING:
1031 *hal_buffer_request_status =
1032 google_camera_hal::BufferRequestStatus::kFailedConfiguring;
1033 break;
1034 case BufferRequestStatus::FAILED_ILLEGAL_ARGUMENTS:
1035 *hal_buffer_request_status =
1036 google_camera_hal::BufferRequestStatus::kFailedIllegalArgs;
1037 break;
1038 case BufferRequestStatus::FAILED_UNKNOWN:
1039 *hal_buffer_request_status =
1040 google_camera_hal::BufferRequestStatus::kFailedUnknown;
1041 break;
1042 default:
1043 ALOGE("%s: Failed unknown buffer request error code %d", __FUNCTION__,
1044 hidl_buffer_request_status);
1045 return BAD_VALUE;
1046 }
1047
1048 return OK;
1049 }
1050
ConvertToHalBufferReturnStatus(const StreamBufferRet & hidl_stream_buffer_return,google_camera_hal::BufferReturn * hal_buffer_return)1051 status_t ConvertToHalBufferReturnStatus(
1052 const StreamBufferRet& hidl_stream_buffer_return,
1053 google_camera_hal::BufferReturn* hal_buffer_return) {
1054 if (hal_buffer_return == nullptr) {
1055 ALOGE("%s: hal_buffer_return is nullptr.", __FUNCTION__);
1056 return BAD_VALUE;
1057 }
1058
1059 if (hidl_stream_buffer_return.val.getDiscriminator() ==
1060 StreamBuffersVal::hidl_discriminator::error) {
1061 switch (hidl_stream_buffer_return.val.error()) {
1062 case StreamBufferRequestError::NO_BUFFER_AVAILABLE:
1063 hal_buffer_return->val.error =
1064 google_camera_hal::StreamBufferRequestError::kNoBufferAvailable;
1065 break;
1066 case StreamBufferRequestError::MAX_BUFFER_EXCEEDED:
1067 hal_buffer_return->val.error =
1068 google_camera_hal::StreamBufferRequestError::kMaxBufferExceeded;
1069 break;
1070 case StreamBufferRequestError::STREAM_DISCONNECTED:
1071 hal_buffer_return->val.error =
1072 google_camera_hal::StreamBufferRequestError::kStreamDisconnected;
1073 break;
1074 case StreamBufferRequestError::UNKNOWN_ERROR:
1075 hal_buffer_return->val.error =
1076 google_camera_hal::StreamBufferRequestError::kUnknownError;
1077 break;
1078 default:
1079 ALOGE("%s: Unknown StreamBufferRequestError %d", __FUNCTION__,
1080 hidl_stream_buffer_return.val.error());
1081 return BAD_VALUE;
1082 }
1083 } else {
1084 hal_buffer_return->val.error =
1085 google_camera_hal::StreamBufferRequestError::kOk;
1086 }
1087
1088 return OK;
1089 }
1090 } // namespace hidl_utils
1091 } // namespace implementation
1092 } // namespace camera
1093 } // namespace hardware
1094 } // namespace android
1095