1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <algorithm>
17 #include <iterator>
18 #include "stream_operator_service.h"
19 #include "stream_operator_service_callback.h"
20 #include "camera_service_type_converter.h"
21 #include "camera_hal_hisysevent.h"
22
23 namespace OHOS::Camera {
24
StreamOperatorService(OHOS::sptr<IStreamOperatorVdi> streamOperatorVdi)25 StreamOperatorService::StreamOperatorService(OHOS::sptr<IStreamOperatorVdi> streamOperatorVdi)
26 : streamOperatorVdi_(streamOperatorVdi)
27 {
28 CAMERA_LOGD("ctor, instance");
29 }
30
~StreamOperatorService()31 StreamOperatorService::~StreamOperatorService()
32 {
33 CAMERA_LOGD("dtor, instance");
34 }
35
IsStreamsSupported(OperationMode mode,const std::vector<uint8_t> & modeSetting,const std::vector<StreamInfo> & infos,StreamSupportType & type)36 int32_t StreamOperatorService::IsStreamsSupported(OperationMode mode, const std::vector<uint8_t> &modeSetting,
37 const std::vector<StreamInfo> &infos, StreamSupportType &type)
38 {
39 CameraHalHicollie cameraHalHicollie("CameraHost:IsStreamsSupported");
40 CHECK_IF_PTR_NULL_RETURN_VALUE(streamOperatorVdi_, OHOS::HDI::Camera::V1_0::INVALID_ARGUMENT);
41 std::vector<VdiStreamInfo> vdiInfos;
42 for (auto info : infos) {
43 VdiStreamInfo vdiInfo;
44 ConvertStreamInfoHdiToVdi(info, vdiInfo);
45 vdiInfos.push_back(vdiInfo);
46 }
47 VdiStreamSupportType vdiType = static_cast<VdiStreamSupportType>(type);
48 int32_t ret = streamOperatorVdi_->IsStreamsSupported(static_cast<VdiOperationMode>(mode),
49 modeSetting, vdiInfos, vdiType);
50 type = static_cast<StreamSupportType>(vdiType);
51 return ret;
52 }
53
CreateStreams(const std::vector<StreamInfo> & streamInfos)54 int32_t StreamOperatorService::CreateStreams(const std::vector<StreamInfo> &streamInfos)
55 {
56 CameraHalHicollie cameraHalHicollie("CameraHost:CreateStreams");
57 CHECK_IF_PTR_NULL_RETURN_VALUE(streamOperatorVdi_, OHOS::HDI::Camera::V1_0::INVALID_ARGUMENT);
58 std::vector<VdiStreamInfo> vdiStreamInfos;
59 for (auto info : streamInfos) {
60 VdiStreamInfo vdiInfo;
61 ConvertStreamInfoHdiToVdi(info, vdiInfo);
62 vdiStreamInfos.push_back(vdiInfo);
63 }
64 return streamOperatorVdi_->CreateStreams(vdiStreamInfos);
65 }
66
ReleaseStreams(const std::vector<int32_t> & streamIds)67 int32_t StreamOperatorService::ReleaseStreams(const std::vector<int32_t> &streamIds)
68 {
69 CameraHalHicollie cameraHalHicollie("CameraHost:ReleaseStreams");
70 CHECK_IF_PTR_NULL_RETURN_VALUE(streamOperatorVdi_, OHOS::HDI::Camera::V1_0::INVALID_ARGUMENT);
71 return streamOperatorVdi_->ReleaseStreams(streamIds);
72 }
73
CommitStreams(OperationMode mode,const std::vector<uint8_t> & modeSetting)74 int32_t StreamOperatorService::CommitStreams(OperationMode mode, const std::vector<uint8_t> &modeSetting)
75 {
76 CameraHalHicollie cameraHalHicollie("CameraHost:CommitStreams");
77 CHECK_IF_PTR_NULL_RETURN_VALUE(streamOperatorVdi_, OHOS::HDI::Camera::V1_0::INVALID_ARGUMENT);
78 return streamOperatorVdi_->CommitStreams(static_cast<VdiOperationMode>(mode), modeSetting);
79 }
80
GetStreamAttributes(std::vector<StreamAttribute> & attributes)81 int32_t StreamOperatorService::GetStreamAttributes(std::vector<StreamAttribute> &attributes)
82 {
83 CameraHalHicollie cameraHalHicollie("CameraHost:GetStreamAttributes");
84 CHECK_IF_PTR_NULL_RETURN_VALUE(streamOperatorVdi_, OHOS::HDI::Camera::V1_0::INVALID_ARGUMENT);
85 std::vector<VdiStreamAttribute> vdiAttributes;
86 for (auto attribute : attributes) {
87 VdiStreamAttribute vdiAttribute;
88 ConvertStreamAttributeHdiToVdi(attribute, vdiAttribute);
89 vdiAttributes.push_back(vdiAttribute);
90 }
91 int32_t ret = streamOperatorVdi_->GetStreamAttributes(vdiAttributes);
92 std::vector<StreamAttribute>().swap(attributes);
93 for (auto attribute : vdiAttributes) {
94 StreamAttribute hdiAttribute;
95 ConvertStreamAttributeVdiToHdi(attribute, hdiAttribute);
96 attributes.push_back(hdiAttribute);
97 }
98 return ret;
99 }
100
AttachBufferQueue(int32_t streamId,const sptr<BufferProducerSequenceable> & bufferProducer)101 int32_t StreamOperatorService::AttachBufferQueue(int32_t streamId,
102 const sptr<BufferProducerSequenceable> &bufferProducer)
103 {
104 CameraHalHicollie cameraHalHicollie("CameraHost:AttachBufferQueue");
105 CHECK_IF_PTR_NULL_RETURN_VALUE(streamOperatorVdi_, OHOS::HDI::Camera::V1_0::INVALID_ARGUMENT);
106 return streamOperatorVdi_->AttachBufferQueue(streamId, bufferProducer);
107 }
108
DetachBufferQueue(int32_t streamId)109 int32_t StreamOperatorService::DetachBufferQueue(int32_t streamId)
110 {
111 CameraHalHicollie cameraHalHicollie("CameraHost:DetachBufferQueue");
112 CHECK_IF_PTR_NULL_RETURN_VALUE(streamOperatorVdi_, OHOS::HDI::Camera::V1_0::INVALID_ARGUMENT);
113 return streamOperatorVdi_->DetachBufferQueue(streamId);
114 }
115
Capture(int32_t captureId,const CaptureInfo & info,bool isStreaming)116 int32_t StreamOperatorService::Capture(int32_t captureId, const CaptureInfo &info, bool isStreaming)
117 {
118 CameraHalHicollie cameraHalHicollie("CameraHost:Capture");
119 CAMERAHALPERFSYSEVENT(TIME_FOR_CAPTURE);
120 CHECK_IF_PTR_NULL_RETURN_VALUE(streamOperatorVdi_, OHOS::HDI::Camera::V1_0::INVALID_ARGUMENT);
121 VdiCaptureInfo vdiInfo;
122 ConvertCaptureInfoHdiToVdi(info, vdiInfo);
123 return streamOperatorVdi_->Capture(captureId, vdiInfo, isStreaming);
124 }
125
CancelCapture(int32_t captureId)126 int32_t StreamOperatorService::CancelCapture(int32_t captureId)
127 {
128 CameraHalHicollie cameraHalHicollie("CameraHost:CancelCapture");
129 CHECK_IF_PTR_NULL_RETURN_VALUE(streamOperatorVdi_, OHOS::HDI::Camera::V1_0::INVALID_ARGUMENT);
130 return streamOperatorVdi_->CancelCapture(captureId);
131 }
132
ChangeToOfflineStream(const std::vector<int32_t> & streamIds,const sptr<IStreamOperatorCallback> & callbackObj,sptr<IOfflineStreamOperator> & offlineOperator)133 int32_t StreamOperatorService::ChangeToOfflineStream(const std::vector<int32_t> &streamIds,
134 const sptr<IStreamOperatorCallback> &callbackObj, sptr<IOfflineStreamOperator> &offlineOperator)
135 {
136 OHOS::sptr<IOfflineStreamOperatorVdi> offlineOperatorVdi = nullptr;
137 CHECK_IF_PTR_NULL_RETURN_VALUE(streamOperatorVdi_, OHOS::HDI::Camera::V1_0::INVALID_ARGUMENT);
138 OHOS::sptr<IStreamOperatorVdiCallback> vdiCallbackObj = new StreamOperatorServiceCallback(callbackObj);
139 if (vdiCallbackObj == nullptr) {
140 CAMERA_LOGE("Change to offline stream error, vdiCallbackObj is nullptr");
141 return OHOS::HDI::Camera::V1_0::INSUFFICIENT_RESOURCES;
142 }
143 int32_t ret = streamOperatorVdi_->ChangeToOfflineStream(streamIds, vdiCallbackObj, offlineOperatorVdi);
144 if (ret != OHOS::HDI::Camera::V1_0::NO_ERROR) {
145 CAMERA_LOGE("Change to offline stream error, ret=%{public}d", ret);
146 return ret;
147 }
148 if (offlineOperatorVdi == nullptr) {
149 CAMERA_LOGE("Change to offline stream error, offlineOperatorVdi is nullptr");
150 return OHOS::HDI::Camera::V1_0::INSUFFICIENT_RESOURCES;
151 }
152 offlineOperator = new OfflineStreamOperatorService(offlineOperatorVdi);
153 if (offlineOperator == nullptr) {
154 CAMERA_LOGE("Change to offline stream error, offlineOperator is nullptr");
155 return OHOS::HDI::Camera::V1_0::INSUFFICIENT_RESOURCES;
156 }
157
158 return OHOS::HDI::Camera::V1_0::NO_ERROR;
159 }
160 } // end namespace OHOS::Camera
161