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_HidlCameraDeviceSession"
18 #define ATRACE_TAG ATRACE_TAG_CAMERA
19 //#define LOG_NDEBUG 0
20 #include "hidl_camera_device_session.h"
21 
22 #include <cutils/properties.h>
23 #include <cutils/trace.h>
24 #include <log/log.h>
25 #include <malloc.h>
26 #include <utils/Trace.h>
27 
28 #include "hidl_profiler.h"
29 #include "hidl_utils.h"
30 
31 namespace android {
32 namespace hardware {
33 namespace camera {
34 namespace device {
35 namespace V3_7 {
36 namespace implementation {
37 
38 namespace hidl_utils = ::android::hardware::camera::implementation::hidl_utils;
39 
40 using ::android::hardware::camera::device::V3_2::NotifyMsg;
41 using ::android::hardware::camera::device::V3_2::StreamBuffer;
42 using ::android::hardware::camera::device::V3_4::CaptureResult;
43 using ::android::hardware::camera::device::V3_5::BufferRequest;
44 using ::android::hardware::camera::device::V3_5::BufferRequestStatus;
45 using ::android::hardware::camera::device::V3_5::StreamBufferRet;
46 using ::android::hardware::camera::device::V3_5::StreamBuffersVal;
47 using ::android::hardware::camera::device::V3_6::HalStreamConfiguration;
48 using ::android::hardware::thermal::V1_0::ThermalStatus;
49 using ::android::hardware::thermal::V1_0::ThermalStatusCode;
50 using ::android::hardware::thermal::V2_0::Temperature;
51 using ::android::hardware::thermal::V2_0::TemperatureType;
52 
Create(const sp<V3_2::ICameraDeviceCallback> & callback,std::unique_ptr<google_camera_hal::CameraDeviceSession> device_session,std::shared_ptr<HidlProfiler> hidl_profiler)53 std::unique_ptr<HidlCameraDeviceSession> HidlCameraDeviceSession::Create(
54     const sp<V3_2::ICameraDeviceCallback>& callback,
55     std::unique_ptr<google_camera_hal::CameraDeviceSession> device_session,
56     std::shared_ptr<HidlProfiler> hidl_profiler) {
57   ATRACE_NAME("HidlCameraDeviceSession::Create");
58   auto session =
59       std::unique_ptr<HidlCameraDeviceSession>(new HidlCameraDeviceSession());
60   if (session == nullptr) {
61     ALOGE("%s: Cannot create a HidlCameraDeviceSession.", __FUNCTION__);
62     return nullptr;
63   }
64 
65   status_t res =
66       session->Initialize(callback, std::move(device_session), hidl_profiler);
67   if (res != OK) {
68     ALOGE("%s: Initializing HidlCameraDeviceSession failed: %s(%d)",
69           __FUNCTION__, strerror(-res), res);
70     return nullptr;
71   }
72 
73   return session;
74 }
75 
~HidlCameraDeviceSession()76 HidlCameraDeviceSession::~HidlCameraDeviceSession() {
77   ATRACE_NAME("HidlCameraDeviceSession::~HidlCameraDeviceSession");
78   close();
79   // camera's closing, so flush any unused malloc pages
80   mallopt(M_PURGE, 0);
81 }
82 
ProcessCaptureResult(std::unique_ptr<google_camera_hal::CaptureResult> hal_result)83 void HidlCameraDeviceSession::ProcessCaptureResult(
84     std::unique_ptr<google_camera_hal::CaptureResult> hal_result) {
85   std::shared_lock lock(hidl_device_callback_lock_);
86   if (hidl_device_callback_ == nullptr) {
87     ALOGE("%s: hidl_device_callback_ is nullptr", __FUNCTION__);
88     return;
89   }
90 
91   {
92     std::lock_guard<std::mutex> pending_lock(pending_first_frame_buffers_mutex_);
93     if (!hal_result->output_buffers.empty() &&
94         num_pending_first_frame_buffers_ > 0 &&
95         first_request_frame_number_ == hal_result->frame_number) {
96       num_pending_first_frame_buffers_ -= hal_result->output_buffers.size();
97       if (num_pending_first_frame_buffers_ == 0) {
98         ALOGI("%s: First frame done", __FUNCTION__);
99         hidl_profiler_->FirstFrameEnd();
100         ATRACE_ASYNC_END("first_frame", 0);
101         ATRACE_ASYNC_END("switch_mode", 0);
102       }
103     }
104   }
105   for (auto& buffer : hal_result->output_buffers) {
106     hidl_profiler_->ProfileFrameRate("Stream " +
107                                      std::to_string(buffer.stream_id));
108   }
109 
110   hidl_vec<CaptureResult> hidl_results(1);
111   status_t res = hidl_utils::ConvertToHidlCaptureResult(
112       result_metadata_queue_.get(), std::move(hal_result), &hidl_results[0]);
113   if (res != OK) {
114     ALOGE("%s: Converting to HIDL result failed: %s(%d)", __FUNCTION__,
115           strerror(-res), res);
116     return;
117   }
118 
119   auto hidl_res = hidl_device_callback_->processCaptureResult_3_4(hidl_results);
120   if (!hidl_res.isOk()) {
121     ALOGE("%s: processCaptureResult transaction failed: %s.", __FUNCTION__,
122           hidl_res.description().c_str());
123     return;
124   }
125 }
126 
NotifyHalMessage(const google_camera_hal::NotifyMessage & hal_message)127 void HidlCameraDeviceSession::NotifyHalMessage(
128     const google_camera_hal::NotifyMessage& hal_message) {
129   std::shared_lock lock(hidl_device_callback_lock_);
130   if (hidl_device_callback_ == nullptr) {
131     ALOGE("%s: hidl_device_callback_ is nullptr", __FUNCTION__);
132     return;
133   }
134 
135   hidl_vec<NotifyMsg> hidl_messages(1);
136   status_t res =
137       hidl_utils::ConverToHidlNotifyMessage(hal_message, &hidl_messages[0]);
138   if (res != OK) {
139     ALOGE("%s: Converting to HIDL message failed: %s(%d)", __FUNCTION__,
140           strerror(-res), res);
141     return;
142   }
143 
144   auto hidl_res = hidl_device_callback_->notify(hidl_messages);
145   if (!hidl_res.isOk()) {
146     ALOGE("%s: notify transaction failed: %s.", __FUNCTION__,
147           hidl_res.description().c_str());
148     return;
149   }
150 }
151 
152 google_camera_hal::BufferRequestStatus
RequestStreamBuffers(const std::vector<google_camera_hal::BufferRequest> & hal_buffer_requests,std::vector<google_camera_hal::BufferReturn> * hal_buffer_returns)153 HidlCameraDeviceSession::RequestStreamBuffers(
154     const std::vector<google_camera_hal::BufferRequest>& hal_buffer_requests,
155     std::vector<google_camera_hal::BufferReturn>* hal_buffer_returns) {
156   std::shared_lock lock(hidl_device_callback_lock_);
157   if (hidl_device_callback_ == nullptr) {
158     ALOGE("%s: hidl_device_callback_ is nullptr", __FUNCTION__);
159     return google_camera_hal::BufferRequestStatus::kFailedUnknown;
160   }
161 
162   if (hal_buffer_returns == nullptr) {
163     ALOGE("%s: hal_buffer_returns is nullptr", __FUNCTION__);
164     return google_camera_hal::BufferRequestStatus::kFailedUnknown;
165   }
166 
167   hidl_vec<BufferRequest> hidl_buffer_requests;
168   status_t res = hidl_utils::ConvertToHidlBufferRequest(hal_buffer_requests,
169                                                         &hidl_buffer_requests);
170   if (res != OK) {
171     ALOGE("%s: Converting to Hidl buffer request failed: %s(%d)", __FUNCTION__,
172           strerror(-res), res);
173     return google_camera_hal::BufferRequestStatus::kFailedUnknown;
174   }
175 
176   BufferRequestStatus hidl_status;
177   hidl_vec<StreamBufferRet> stream_buffer_returns;
178   auto cb_status = hidl_device_callback_->requestStreamBuffers(
179       hidl_buffer_requests, [&hidl_status, &stream_buffer_returns](
180                                 BufferRequestStatus status_ret,
181                                 const hidl_vec<StreamBufferRet>& buffer_ret) {
182         hidl_status = status_ret;
183         stream_buffer_returns = std::move(buffer_ret);
184       });
185   if (!cb_status.isOk()) {
186     ALOGE("%s: Transaction request stream buffers error: %s", __FUNCTION__,
187           cb_status.description().c_str());
188     return google_camera_hal::BufferRequestStatus::kFailedUnknown;
189   }
190 
191   google_camera_hal::BufferRequestStatus hal_buffer_request_status;
192   res = hidl_utils::ConvertToHalBufferRequestStatus(hidl_status,
193                                                     &hal_buffer_request_status);
194   if (res != OK) {
195     ALOGE("%s: Converting to Hal buffer request status failed: %s(%d)",
196           __FUNCTION__, strerror(-res), res);
197     return google_camera_hal::BufferRequestStatus::kFailedUnknown;
198   }
199 
200   hal_buffer_returns->clear();
201   // Converting HIDL stream buffer returns to HAL stream buffer returns.
202   for (auto& stream_buffer_return : stream_buffer_returns) {
203     google_camera_hal::BufferReturn hal_buffer_return;
204     res = hidl_utils::ConvertToHalBufferReturnStatus(stream_buffer_return,
205                                                      &hal_buffer_return);
206     if (res != OK) {
207       ALOGE("%s: Converting to Hal buffer return status failed: %s(%d)",
208             __FUNCTION__, strerror(-res), res);
209       return google_camera_hal::BufferRequestStatus::kFailedUnknown;
210     }
211 
212     if (stream_buffer_return.val.getDiscriminator() ==
213         V3_5::StreamBuffersVal::hidl_discriminator::buffers) {
214       const hidl_vec<StreamBuffer>& hidl_buffers =
215           stream_buffer_return.val.buffers();
216       for (auto& hidl_buffer : hidl_buffers) {
217         google_camera_hal::StreamBuffer hal_buffer = {};
218         hidl_utils::ConvertToHalStreamBuffer(hidl_buffer, &hal_buffer);
219         if (res != OK) {
220           ALOGE("%s: Converting to Hal stream buffer failed: %s(%d)",
221                 __FUNCTION__, strerror(-res), res);
222           return google_camera_hal::BufferRequestStatus::kFailedUnknown;
223         }
224 
225         if (hidl_buffer.acquireFence.getNativeHandle() != nullptr) {
226           hal_buffer.acquire_fence =
227               native_handle_clone(hidl_buffer.acquireFence.getNativeHandle());
228           if (hal_buffer.acquire_fence == nullptr) {
229             ALOGE("%s: Cloning Hal stream buffer acquire fence failed",
230                   __FUNCTION__);
231           }
232         }
233 
234         hal_buffer.release_fence = nullptr;
235         // If buffer handle is not null, we need to import buffer handle and
236         // return to the caller.
237         if (hidl_buffer.buffer.getNativeHandle() != nullptr) {
238           if (buffer_mapper_v4_ != nullptr) {
239             hal_buffer.buffer = ImportBufferHandle<
240                 android::hardware::graphics::mapper::V4_0::IMapper,
241                 android::hardware::graphics::mapper::V4_0::Error>(
242                 buffer_mapper_v4_, hidl_buffer.buffer);
243           } else if (buffer_mapper_v3_ != nullptr) {
244             hal_buffer.buffer = ImportBufferHandle<
245                 android::hardware::graphics::mapper::V3_0::IMapper,
246                 android::hardware::graphics::mapper::V3_0::Error>(
247                 buffer_mapper_v3_, hidl_buffer.buffer);
248           } else {
249             hal_buffer.buffer = ImportBufferHandle<
250                 android::hardware::graphics::mapper::V2_0::IMapper,
251                 android::hardware::graphics::mapper::V2_0::Error>(
252                 buffer_mapper_v2_, hidl_buffer.buffer);
253           }
254         }
255 
256         hal_buffer_return.val.buffers.push_back(hal_buffer);
257       }
258     }
259 
260     hal_buffer_returns->push_back(hal_buffer_return);
261   }
262 
263   return hal_buffer_request_status;
264 }
265 
266 template <class T, class U>
ImportBufferHandle(const sp<T> buffer_mapper_,const hidl_handle & buffer_hidl_handle)267 buffer_handle_t HidlCameraDeviceSession::ImportBufferHandle(
268     const sp<T> buffer_mapper_, const hidl_handle& buffer_hidl_handle) {
269   U mapper_error;
270   buffer_handle_t imported_buffer_handle;
271 
272   auto hidl_res = buffer_mapper_->importBuffer(
273       buffer_hidl_handle, [&](const auto& error, const auto& buffer_handle) {
274         mapper_error = error;
275         imported_buffer_handle = static_cast<buffer_handle_t>(buffer_handle);
276       });
277   if (!hidl_res.isOk() || mapper_error != U::NONE) {
278     ALOGE("%s: Importing buffer failed: %s, mapper error %u", __FUNCTION__,
279           hidl_res.description().c_str(), mapper_error);
280     return nullptr;
281   }
282 
283   return imported_buffer_handle;
284 }
285 
ReturnStreamBuffers(const std::vector<google_camera_hal::StreamBuffer> & return_hal_buffers)286 void HidlCameraDeviceSession::ReturnStreamBuffers(
287     const std::vector<google_camera_hal::StreamBuffer>& return_hal_buffers) {
288   std::shared_lock lock(hidl_device_callback_lock_);
289   if (hidl_device_callback_ == nullptr) {
290     ALOGE("%s: hidl_device_callback_ is nullptr", __FUNCTION__);
291     return;
292   }
293 
294   status_t res = OK;
295   hidl_vec<StreamBuffer> hidl_return_buffers;
296   hidl_return_buffers.resize(return_hal_buffers.size());
297   for (uint32_t i = 0; i < return_hal_buffers.size(); i++) {
298     res = hidl_utils::ConvertToHidlStreamBuffer(return_hal_buffers[i],
299                                                 &hidl_return_buffers[i]);
300     if (res != OK) {
301       ALOGE("%s: Converting to Hidl stream buffer failed: %s(%d)", __FUNCTION__,
302             strerror(-res), res);
303       return;
304     }
305   }
306 
307   auto hidl_res =
308       hidl_device_callback_->returnStreamBuffers(hidl_return_buffers);
309   if (!hidl_res.isOk()) {
310     ALOGE("%s: return stream buffers transaction failed: %s.", __FUNCTION__,
311           hidl_res.description().c_str());
312     return;
313   }
314 }
315 
InitializeBufferMapper()316 status_t HidlCameraDeviceSession::InitializeBufferMapper() {
317   buffer_mapper_v4_ =
318       android::hardware::graphics::mapper::V4_0::IMapper::getService();
319   if (buffer_mapper_v4_ != nullptr) {
320     return OK;
321   }
322 
323   buffer_mapper_v3_ =
324       android::hardware::graphics::mapper::V3_0::IMapper::getService();
325   if (buffer_mapper_v3_ != nullptr) {
326     return OK;
327   }
328 
329   buffer_mapper_v2_ =
330       android::hardware::graphics::mapper::V2_0::IMapper::getService();
331   if (buffer_mapper_v2_ != nullptr) {
332     return OK;
333   }
334 
335   ALOGE("%s: Getting buffer mapper failed.", __FUNCTION__);
336   return UNKNOWN_ERROR;
337 }
338 
Initialize(const sp<V3_2::ICameraDeviceCallback> & callback,std::unique_ptr<google_camera_hal::CameraDeviceSession> device_session,std::shared_ptr<HidlProfiler> hidl_profiler)339 status_t HidlCameraDeviceSession::Initialize(
340     const sp<V3_2::ICameraDeviceCallback>& callback,
341     std::unique_ptr<google_camera_hal::CameraDeviceSession> device_session,
342     std::shared_ptr<HidlProfiler> hidl_profiler) {
343   ATRACE_NAME("HidlCameraDeviceSession::Initialize");
344   if (device_session == nullptr) {
345     ALOGE("%s: device_session is nullptr.", __FUNCTION__);
346     return BAD_VALUE;
347   }
348 
349   if (hidl_profiler == nullptr) {
350     ALOGE("%s: hidl_profiler is nullptr.", __FUNCTION__);
351     return BAD_VALUE;
352   }
353 
354   status_t res = CreateMetadataQueue(&request_metadata_queue_,
355                                      kRequestMetadataQueueSizeBytes,
356                                      "ro.vendor.camera.req.fmq.size");
357   if (res != OK) {
358     ALOGE("%s: Creating request metadata queue failed: %s(%d)", __FUNCTION__,
359           strerror(-res), res);
360     return res;
361   }
362 
363   res = CreateMetadataQueue(&result_metadata_queue_,
364                             kResultMetadataQueueSizeBytes,
365                             "ro.vendor.camera.res.fmq.size");
366   if (res != OK) {
367     ALOGE("%s: Creating result metadata queue failed: %s(%d)", __FUNCTION__,
368           strerror(-res), res);
369     return res;
370   }
371 
372   // Cast V3.2 callback to V3.5
373   auto cast_res = ICameraDeviceCallback::castFrom(callback);
374   if (!cast_res.isOk()) {
375     ALOGE("%s: Cannot convert to V3.5 device callback.", __FUNCTION__);
376     return UNKNOWN_ERROR;
377   }
378 
379   // Initialize buffer mapper
380   res = InitializeBufferMapper();
381   if (res != OK) {
382     ALOGE("%s: Initialize buffer mapper failed: %s(%d)", __FUNCTION__,
383           strerror(-res), res);
384     return res;
385   }
386 
387   thermal_ = android::hardware::thermal::V2_0::IThermal::getService();
388   if (thermal_ == nullptr) {
389     ALOGE("%s: Getting thermal failed.", __FUNCTION__);
390     // Continue without getting thermal information.
391   }
392 
393   hidl_device_callback_ = cast_res;
394   device_session_ = std::move(device_session);
395   hidl_profiler_ = hidl_profiler;
396 
397   SetSessionCallbacks();
398   return OK;
399 }
400 
SetSessionCallbacks()401 void HidlCameraDeviceSession::SetSessionCallbacks() {
402   google_camera_hal::CameraDeviceSessionCallback session_callback = {
403       .process_capture_result = google_camera_hal::ProcessCaptureResultFunc(
404           [this](std::unique_ptr<google_camera_hal::CaptureResult> result) {
405             ProcessCaptureResult(std::move(result));
406           }),
407       .notify = google_camera_hal::NotifyFunc(
408           [this](const google_camera_hal::NotifyMessage& message) {
409             NotifyHalMessage(message);
410           }),
411       .request_stream_buffers = google_camera_hal::RequestStreamBuffersFunc(
412           [this](
413               const std::vector<google_camera_hal::BufferRequest>&
414                   hal_buffer_requests,
415               std::vector<google_camera_hal::BufferReturn>* hal_buffer_returns) {
416             return RequestStreamBuffers(hal_buffer_requests, hal_buffer_returns);
417           }),
418       .return_stream_buffers = google_camera_hal::ReturnStreamBuffersFunc(
419           [this](const std::vector<google_camera_hal::StreamBuffer>&
420                      return_hal_buffers) {
421             ReturnStreamBuffers(return_hal_buffers);
422           }),
423   };
424 
425   google_camera_hal::ThermalCallback thermal_callback = {
426       .register_thermal_changed_callback =
427           google_camera_hal::RegisterThermalChangedCallbackFunc(
428               [this](google_camera_hal::NotifyThrottlingFunc notify_throttling,
429                      bool filter_type, google_camera_hal::TemperatureType type) {
430                 return RegisterThermalChangedCallback(notify_throttling,
431                                                       filter_type, type);
432               }),
433       .unregister_thermal_changed_callback =
434           google_camera_hal::UnregisterThermalChangedCallbackFunc(
435               [this]() { UnregisterThermalChangedCallback(); }),
436   };
437 
438   device_session_->SetSessionCallback(session_callback, thermal_callback);
439 }
440 
RegisterThermalChangedCallback(google_camera_hal::NotifyThrottlingFunc notify_throttling,bool filter_type,google_camera_hal::TemperatureType type)441 status_t HidlCameraDeviceSession::RegisterThermalChangedCallback(
442     google_camera_hal::NotifyThrottlingFunc notify_throttling, bool filter_type,
443     google_camera_hal::TemperatureType type) {
444   std::lock_guard<std::mutex> lock(hidl_thermal_mutex_);
445   if (thermal_ == nullptr) {
446     ALOGE("%s: thermal was not initialized.", __FUNCTION__);
447     return NO_INIT;
448   }
449 
450   if (thermal_changed_callback_ != nullptr) {
451     ALOGE("%s: thermal changed callback is already registered.", __FUNCTION__);
452     return ALREADY_EXISTS;
453   }
454 
455   TemperatureType hidl_type;
456   status_t res =
457       hidl_thermal_utils::ConvertToHidlTemperatureType(type, &hidl_type);
458   if (res != OK) {
459     ALOGE("%s: Converting to HIDL type failed: %s(%d)", __FUNCTION__,
460           strerror(-res), res);
461     return res;
462   }
463 
464   std::unique_ptr<hidl_thermal_utils::HidlThermalChangedCallback> callback =
465       hidl_thermal_utils::HidlThermalChangedCallback::Create(notify_throttling);
466   thermal_changed_callback_ = callback.release();
467   ThermalStatus thermal_status;
468   auto hidl_res = thermal_->registerThermalChangedCallback(
469       thermal_changed_callback_, filter_type, hidl_type,
470       [&](ThermalStatus status) { thermal_status = status; });
471   if (!hidl_res.isOk() || thermal_status.code != ThermalStatusCode::SUCCESS) {
472     thermal_changed_callback_ = nullptr;
473     return UNKNOWN_ERROR;
474   }
475 
476   return OK;
477 }
478 
UnregisterThermalChangedCallback()479 void HidlCameraDeviceSession::UnregisterThermalChangedCallback() {
480   std::lock_guard<std::mutex> lock(hidl_thermal_mutex_);
481   if (thermal_changed_callback_ == nullptr) {
482     // no-op if no thermal changed callback is registered.
483     return;
484   }
485 
486   if (thermal_ == nullptr) {
487     ALOGE("%s: thermal was not initialized.", __FUNCTION__);
488     return;
489   }
490 
491   ThermalStatus thermal_status;
492   auto hidl_res = thermal_->unregisterThermalChangedCallback(
493       thermal_changed_callback_,
494       [&](ThermalStatus status) { thermal_status = status; });
495   if (!hidl_res.isOk() || thermal_status.code != ThermalStatusCode::SUCCESS) {
496     ALOGW("%s: Unregstering thermal callback failed: %s", __FUNCTION__,
497           thermal_status.debugMessage.c_str());
498   }
499 
500   thermal_changed_callback_ = nullptr;
501 }
502 
CreateMetadataQueue(std::unique_ptr<MetadataQueue> * metadata_queue,uint32_t default_size_bytes,const char * override_size_property)503 status_t HidlCameraDeviceSession::CreateMetadataQueue(
504     std::unique_ptr<MetadataQueue>* metadata_queue, uint32_t default_size_bytes,
505     const char* override_size_property) {
506   if (metadata_queue == nullptr) {
507     ALOGE("%s: metadata_queue is nullptr", __FUNCTION__);
508     return BAD_VALUE;
509   }
510 
511   int32_t size = default_size_bytes;
512   if (override_size_property != nullptr) {
513     // Try to read the override size from the system property.
514     size = property_get_int32(override_size_property, default_size_bytes);
515     ALOGV("%s: request metadata queue size overridden to %d", __FUNCTION__,
516           size);
517   }
518 
519   *metadata_queue = std::make_unique<MetadataQueue>(
520       static_cast<size_t>(size), /*configureEventFlagWord=*/false);
521   if (!(*metadata_queue)->isValid()) {
522     ALOGE("%s: Creating metadata queue (size %d) failed.", __FUNCTION__, size);
523     return NO_INIT;
524   }
525 
526   return OK;
527 }
528 
constructDefaultRequestSettings(RequestTemplate type,ICameraDeviceSession::constructDefaultRequestSettings_cb _hidl_cb)529 Return<void> HidlCameraDeviceSession::constructDefaultRequestSettings(
530     RequestTemplate type,
531     ICameraDeviceSession::constructDefaultRequestSettings_cb _hidl_cb) {
532   ATRACE_NAME("HidlCameraDeviceSession::constructDefaultRequestSettings");
533   V3_2::CameraMetadata hidl_metadata;
534 
535   if (device_session_ == nullptr) {
536     _hidl_cb(Status::INTERNAL_ERROR, hidl_metadata);
537     return Void();
538   }
539 
540   google_camera_hal::RequestTemplate hal_type;
541   status_t res = hidl_utils::ConvertToHalTemplateType(type, &hal_type);
542   if (res != OK) {
543     _hidl_cb(Status::ILLEGAL_ARGUMENT, hidl_metadata);
544     return Void();
545   }
546 
547   std::unique_ptr<google_camera_hal::HalCameraMetadata> settings = nullptr;
548   res = device_session_->ConstructDefaultRequestSettings(hal_type, &settings);
549   if (res != OK) {
550     _hidl_cb(hidl_utils::ConvertToHidlStatus(res), hidl_metadata);
551     return Void();
552   }
553 
554   uint32_t metadata_size = settings->GetCameraMetadataSize();
555   hidl_metadata.setToExternal((uint8_t*)settings->ReleaseCameraMetadata(),
556                               metadata_size, /*shouldOwn=*/true);
557   _hidl_cb(Status::OK, hidl_metadata);
558 
559   return Void();
560 }
561 
configureStreams_3_7(const StreamConfiguration & requestedConfiguration,ICameraDeviceSession::configureStreams_3_6_cb _hidl_cb)562 Return<void> HidlCameraDeviceSession::configureStreams_3_7(
563     const StreamConfiguration& requestedConfiguration,
564     ICameraDeviceSession::configureStreams_3_6_cb _hidl_cb) {
565   ATRACE_NAME("HidlCameraDeviceSession::configureStreams_3_7");
566   HalStreamConfiguration hidl_hal_configs;
567   if (device_session_ == nullptr) {
568     _hidl_cb(Status::ILLEGAL_ARGUMENT, hidl_hal_configs);
569     return Void();
570   }
571 
572   auto profiler = hidl_profiler_->MakeScopedProfiler(
573       HidlProfiler::ScopedType::kConfigureStream);
574 
575   first_frame_requested_ = false;
576   num_pending_first_frame_buffers_ = 0;
577 
578   google_camera_hal::StreamConfiguration hal_stream_config;
579   status_t res = hidl_utils::ConverToHalStreamConfig(requestedConfiguration,
580                                                      &hal_stream_config);
581   if (res != OK) {
582     _hidl_cb(Status::ILLEGAL_ARGUMENT, hidl_hal_configs);
583     return Void();
584   }
585 
586   std::vector<google_camera_hal::HalStream> hal_configured_streams;
587   res = device_session_->ConfigureStreams(hal_stream_config,
588                                           &hal_configured_streams);
589   if (res != OK) {
590     ALOGE("%s: Configuring streams failed: %s(%d)", __FUNCTION__,
591           strerror(-res), res);
592     _hidl_cb(hidl_utils::ConvertToHidlStatus(res), hidl_hal_configs);
593     return Void();
594   }
595 
596   res = hidl_utils::ConvertToHidlHalStreamConfig(hal_configured_streams,
597                                                  &hidl_hal_configs);
598   _hidl_cb(hidl_utils::ConvertToHidlStatus(res), hidl_hal_configs);
599 
600   return Void();
601 }
602 
getCaptureRequestMetadataQueue(ICameraDeviceSession::getCaptureRequestMetadataQueue_cb _hidl_cb)603 Return<void> HidlCameraDeviceSession::getCaptureRequestMetadataQueue(
604     ICameraDeviceSession::getCaptureRequestMetadataQueue_cb _hidl_cb) {
605   _hidl_cb(*request_metadata_queue_->getDesc());
606   return Void();
607 }
608 
getCaptureResultMetadataQueue(ICameraDeviceSession::getCaptureResultMetadataQueue_cb _hidl_cb)609 Return<void> HidlCameraDeviceSession::getCaptureResultMetadataQueue(
610     ICameraDeviceSession::getCaptureResultMetadataQueue_cb _hidl_cb) {
611   _hidl_cb(*result_metadata_queue_->getDesc());
612   return Void();
613 }
614 
processCaptureRequest_3_7(const hidl_vec<CaptureRequest> & requests,const hidl_vec<BufferCache> & cachesToRemove,processCaptureRequest_3_7_cb _hidl_cb)615 Return<void> HidlCameraDeviceSession::processCaptureRequest_3_7(
616     const hidl_vec<CaptureRequest>& requests,
617     const hidl_vec<BufferCache>& cachesToRemove,
618     processCaptureRequest_3_7_cb _hidl_cb) {
619   if (device_session_ == nullptr) {
620     _hidl_cb(Status::ILLEGAL_ARGUMENT, 0);
621     return Void();
622   }
623 
624   bool profile_first_request = false;
625   if (!first_frame_requested_) {
626     first_frame_requested_ = true;
627     profile_first_request = true;
628     ATRACE_BEGIN("HidlCameraDeviceSession::FirstRequest");
629     num_pending_first_frame_buffers_ =
630         requests[0].v3_4.v3_2.outputBuffers.size();
631     first_request_frame_number_ = requests[0].v3_4.v3_2.frameNumber;
632     hidl_profiler_->FirstFrameStart();
633     ATRACE_ASYNC_BEGIN("first_frame", 0);
634   }
635 
636   std::vector<google_camera_hal::BufferCache> hal_buffer_caches;
637 
638   status_t res =
639       hidl_utils::ConvertToHalBufferCaches(cachesToRemove, &hal_buffer_caches);
640   if (res != OK) {
641     _hidl_cb(Status::ILLEGAL_ARGUMENT, 0);
642     if (profile_first_request) {
643       ATRACE_END();
644     }
645     return Void();
646   }
647 
648   device_session_->RemoveBufferCache(hal_buffer_caches);
649 
650   // Converting HIDL requests to HAL requests.
651   std::vector<google_camera_hal::CaptureRequest> hal_requests;
652   for (auto& request : requests) {
653     google_camera_hal::CaptureRequest hal_request = {};
654     res = hidl_utils::ConvertToHalCaptureRequest(
655         request, request_metadata_queue_.get(), &hal_request);
656     if (res != OK) {
657       ALOGE("%s: Converting to HAL capture request failed: %s(%d)",
658             __FUNCTION__, strerror(-res), res);
659       _hidl_cb(hidl_utils::ConvertToHidlStatus(res), 0);
660       if (profile_first_request) {
661         ATRACE_END();
662       }
663       return Void();
664     }
665 
666     hal_requests.push_back(std::move(hal_request));
667   }
668 
669   uint32_t num_processed_requests = 0;
670   res = device_session_->ProcessCaptureRequest(hal_requests,
671                                                &num_processed_requests);
672   if (res != OK) {
673     ALOGE(
674         "%s: Processing capture request failed: %s(%d). Only processed %u"
675         " out of %zu.",
676         __FUNCTION__, strerror(-res), res, num_processed_requests,
677         hal_requests.size());
678   }
679 
680   _hidl_cb(hidl_utils::ConvertToHidlStatus(res), num_processed_requests);
681   if (profile_first_request) {
682     ATRACE_END();
683   }
684   return Void();
685 }
686 
signalStreamFlush(const hidl_vec<int32_t> &,uint32_t)687 Return<void> HidlCameraDeviceSession::signalStreamFlush(
688     const hidl_vec<int32_t>& /*streamIds*/, uint32_t /*streamConfigCounter*/) {
689   // TODO(b/143902312): Implement this.
690   return Void();
691 }
692 
flush()693 Return<Status> HidlCameraDeviceSession::flush() {
694   ATRACE_NAME("HidlCameraDeviceSession::flush");
695   ATRACE_ASYNC_BEGIN("switch_mode", 0);
696   if (device_session_ == nullptr) {
697     return Status::INTERNAL_ERROR;
698   }
699 
700   hidl_profiler_->SetLatencyProfiler(device_session_->GetProfiler(
701       hidl_profiler_->GetCameraId(), hidl_profiler_->GetLatencyFlag()));
702   hidl_profiler_->SetFpsProfiler(device_session_->GetProfiler(
703       hidl_profiler_->GetCameraId(), hidl_profiler_->GetFpsFlag()));
704   auto profiler =
705       hidl_profiler_->MakeScopedProfiler(HidlProfiler::ScopedType::kFlush);
706 
707   status_t res = device_session_->Flush();
708   if (res != OK) {
709     ALOGE("%s: Flushing device failed: %s(%d).", __FUNCTION__, strerror(-res),
710           res);
711     return Status::INTERNAL_ERROR;
712   }
713 
714   return Status::OK;
715 }
716 
close()717 Return<void> HidlCameraDeviceSession::close() {
718   ATRACE_NAME("HidlCameraDeviceSession::close");
719   if (device_session_ != nullptr) {
720     auto profiler =
721         hidl_profiler_->MakeScopedProfiler(HidlProfiler::ScopedType::kClose);
722     device_session_ = nullptr;
723   }
724   return Void();
725 }
726 
isReconfigurationRequired(const V3_2::CameraMetadata & oldSessionParams,const V3_2::CameraMetadata & newSessionParams,ICameraDeviceSession::isReconfigurationRequired_cb _hidl_cb)727 Return<void> HidlCameraDeviceSession::isReconfigurationRequired(
728     const V3_2::CameraMetadata& oldSessionParams,
729     const V3_2::CameraMetadata& newSessionParams,
730     ICameraDeviceSession::isReconfigurationRequired_cb _hidl_cb) {
731   ATRACE_NAME("HidlCameraDeviceSession::isReconfigurationRequired");
732   std::unique_ptr<google_camera_hal::HalCameraMetadata> old_hal_session_metadata;
733   status_t res = hidl_utils::ConvertToHalMetadata(0, nullptr, oldSessionParams,
734                                                   &old_hal_session_metadata);
735   if (res != OK) {
736     ALOGE("%s: Converting to old session metadata failed: %s(%d)", __FUNCTION__,
737           strerror(-res), res);
738     _hidl_cb(Status::INTERNAL_ERROR, true);
739     return Void();
740   }
741 
742   std::unique_ptr<google_camera_hal::HalCameraMetadata> new_hal_session_metadata;
743   res = hidl_utils::ConvertToHalMetadata(0, nullptr, newSessionParams,
744                                          &new_hal_session_metadata);
745   if (res != OK) {
746     ALOGE("%s: Converting to new session metadata failed: %s(%d)", __FUNCTION__,
747           strerror(-res), res);
748     _hidl_cb(Status::INTERNAL_ERROR, true);
749     return Void();
750   }
751 
752   bool reconfiguration_required = true;
753   res = device_session_->IsReconfigurationRequired(
754       old_hal_session_metadata.get(), new_hal_session_metadata.get(),
755       &reconfiguration_required);
756 
757   if (res != OK) {
758     ALOGE("%s: IsReconfigurationRequired failed: %s(%d)", __FUNCTION__,
759           strerror(-res), res);
760     _hidl_cb(Status::INTERNAL_ERROR, true);
761     return Void();
762   }
763 
764   _hidl_cb(Status::OK, reconfiguration_required);
765   return Void();
766 }
767 
configureStreams(const V3_2::StreamConfiguration &,configureStreams_cb _hidl_cb)768 Return<void> HidlCameraDeviceSession::configureStreams(
769     const V3_2::StreamConfiguration&, configureStreams_cb _hidl_cb) {
770   _hidl_cb(Status::ILLEGAL_ARGUMENT, V3_2::HalStreamConfiguration());
771   return Void();
772 }
configureStreams_3_3(const V3_2::StreamConfiguration &,configureStreams_3_3_cb _hidl_cb)773 Return<void> HidlCameraDeviceSession::configureStreams_3_3(
774     const V3_2::StreamConfiguration&, configureStreams_3_3_cb _hidl_cb) {
775   _hidl_cb(Status::ILLEGAL_ARGUMENT, V3_3::HalStreamConfiguration());
776   return Void();
777 }
configureStreams_3_4(const V3_4::StreamConfiguration &,configureStreams_3_4_cb _hidl_cb)778 Return<void> HidlCameraDeviceSession::configureStreams_3_4(
779     const V3_4::StreamConfiguration&, configureStreams_3_4_cb _hidl_cb) {
780   _hidl_cb(Status::ILLEGAL_ARGUMENT, V3_4::HalStreamConfiguration());
781   return Void();
782 }
783 
configureStreams_3_5(const V3_5::StreamConfiguration & requestedConfiguration,configureStreams_3_5_cb _hidl_cb)784 Return<void> HidlCameraDeviceSession::configureStreams_3_5(
785     const V3_5::StreamConfiguration& requestedConfiguration,
786     configureStreams_3_5_cb _hidl_cb) {
787   configureStreams_3_6(
788       requestedConfiguration,
789       [_hidl_cb](Status s, device::V3_6::HalStreamConfiguration halConfig) {
790         V3_4::HalStreamConfiguration halConfig3_4;
791         halConfig3_4.streams.resize(halConfig.streams.size());
792         for (size_t i = 0; i < halConfig.streams.size(); i++) {
793           halConfig3_4.streams[i] = halConfig.streams[i].v3_4;
794         }
795         _hidl_cb(s, halConfig3_4);
796       });
797 
798   return Void();
799 }
800 
configureStreams_3_6(const V3_5::StreamConfiguration & requestedConfiguration,configureStreams_3_6_cb _hidl_cb)801 Return<void> HidlCameraDeviceSession::configureStreams_3_6(
802     const V3_5::StreamConfiguration& requestedConfiguration,
803     configureStreams_3_6_cb _hidl_cb) {
804   StreamConfiguration requestedConfiguration3_7;
805   requestedConfiguration3_7.streams.resize(
806       requestedConfiguration.v3_4.streams.size());
807   for (size_t i = 0; i < requestedConfiguration.v3_4.streams.size(); i++) {
808     requestedConfiguration3_7.streams[i].v3_4 =
809         requestedConfiguration.v3_4.streams[i];
810     requestedConfiguration3_7.streams[i].groupId = -1;
811   }
812   requestedConfiguration3_7.operationMode =
813       requestedConfiguration.v3_4.operationMode;
814   requestedConfiguration3_7.sessionParams =
815       requestedConfiguration.v3_4.sessionParams;
816   requestedConfiguration3_7.streamConfigCounter =
817       requestedConfiguration.streamConfigCounter;
818   requestedConfiguration3_7.multiResolutionInputImage = false;
819 
820   configureStreams_3_7(requestedConfiguration3_7, _hidl_cb);
821   return Void();
822 }
823 
switchToOffline(const hidl_vec<int32_t> &,switchToOffline_cb _hidl_cb)824 Return<void> HidlCameraDeviceSession::switchToOffline(
825     const hidl_vec<int32_t>&, switchToOffline_cb _hidl_cb) {
826   _hidl_cb(Status::ILLEGAL_ARGUMENT, V3_6::CameraOfflineSessionInfo(), nullptr);
827   return Void();
828 }
829 
processCaptureRequest(const hidl_vec<V3_2::CaptureRequest> & requests,const hidl_vec<BufferCache> & cachesToRemove,processCaptureRequest_cb _hidl_cb)830 Return<void> HidlCameraDeviceSession::processCaptureRequest(
831     const hidl_vec<V3_2::CaptureRequest>& requests,
832     const hidl_vec<BufferCache>& cachesToRemove,
833     processCaptureRequest_cb _hidl_cb) {
834   hidl_vec<V3_4::CaptureRequest> requests_3_4;
835   requests_3_4.resize(requests.size());
836   for (uint32_t i = 0; i < requests_3_4.size(); i++) {
837     requests_3_4[i].v3_2 = requests[i];
838   }
839 
840   return processCaptureRequest_3_4(requests_3_4, cachesToRemove, _hidl_cb);
841 }
842 
processCaptureRequest_3_4(const hidl_vec<V3_4::CaptureRequest> & requests,const hidl_vec<BufferCache> & cachesToRemove,processCaptureRequest_cb _hidl_cb)843 Return<void> HidlCameraDeviceSession::processCaptureRequest_3_4(
844     const hidl_vec<V3_4::CaptureRequest>& requests,
845     const hidl_vec<BufferCache>& cachesToRemove,
846     processCaptureRequest_cb _hidl_cb) {
847   hidl_vec<V3_7::CaptureRequest> requests_3_7;
848   requests_3_7.resize(requests.size());
849   for (uint32_t i = 0; i < requests_3_7.size(); i++) {
850     requests_3_7[i].v3_4 = requests[i];
851   }
852 
853   return processCaptureRequest_3_7(requests_3_7, cachesToRemove, _hidl_cb);
854 }
855 
856 }  // namespace implementation
857 }  // namespace V3_7
858 }  // namespace device
859 }  // namespace camera
860 }  // namespace hardware
861 }  // namespace android
862