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