• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 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 "metadata_output_impl.h"
17 #include "camera_error.h"
18 #include "camera_log.h"
19 
20 namespace OHOS {
21 namespace CameraStandard {
22 
23 thread_local sptr<MetadataOutput> CJMetadataOutput::sMetadataOutput_ = nullptr;
24 
OnMetadataObjectsAvailable(std::vector<sptr<MetadataObject>> metaObjects) const25 void CJMetadataOutputCallback::OnMetadataObjectsAvailable(std::vector<sptr<MetadataObject>> metaObjects) const
26 {
27     ExecuteCallback(metaObjects);
28 }
29 
OnError(const int32_t errorType) const30 void CJMetadataStateCallback::OnError(const int32_t errorType) const
31 {
32     ExecuteCallback(errorType);
33 }
34 
CJMetadataOutput()35 CJMetadataOutput::CJMetadataOutput()
36 {
37     metadataOutput_ = sMetadataOutput_;
38     sMetadataOutput_ = nullptr;
39 }
40 
CreateMetadataOutput(std::vector<MetadataObjectType> metadataObjectTypes)41 int32_t CJMetadataOutput::CreateMetadataOutput(std::vector<MetadataObjectType> metadataObjectTypes)
42 {
43     int retCode = CameraManager::GetInstance()->CreateMetadataOutput(sMetadataOutput_, metadataObjectTypes);
44     if (sMetadataOutput_ == nullptr) {
45         MEDIA_ERR_LOG("failed to create MetadataOutput");
46     }
47     return retCode;
48 }
49 
GetCameraOutput()50 sptr<CameraStandard::CaptureOutput> CJMetadataOutput::GetCameraOutput()
51 {
52     return metadataOutput_;
53 }
54 
Release()55 int32_t CJMetadataOutput::Release()
56 {
57     if (metadataOutput_ == nullptr) {
58         return CameraError::CAMERA_SERVICE_ERROR;
59     }
60     return metadataOutput_->Release();
61 }
62 
Start()63 int32_t CJMetadataOutput::Start()
64 {
65     if (metadataOutput_ == nullptr) {
66         return CameraError::CAMERA_SERVICE_ERROR;
67     }
68     return metadataOutput_->Start();
69 }
70 
Stop()71 int32_t CJMetadataOutput::Stop()
72 {
73     if (metadataOutput_ == nullptr) {
74         return CameraError::CAMERA_SERVICE_ERROR;
75     }
76     return metadataOutput_->Stop();
77 }
78 
OnMetadataObjectsAvailable(int64_t callbackId)79 void CJMetadataOutput::OnMetadataObjectsAvailable(int64_t callbackId)
80 {
81     if (metadataOutputCallback_ == nullptr) {
82         metadataOutputCallback_ = std::make_shared<CJMetadataOutputCallback>();
83         if (metadataOutputCallback_ == nullptr || metadataOutput_ == nullptr) {
84             return;
85         }
86         metadataOutput_->SetCallback(metadataOutputCallback_);
87     }
88     auto cFunc = reinterpret_cast<void (*)(CArrCJMetadataObject metaObjects)>(callbackId);
89     auto callback = [lambda = CJLambda::Create(cFunc)](std::vector<sptr<MetadataObject>> metaObjects) -> void {
90         auto res = MetadataObjectsToCArrCJMetadataObject(metaObjects);
91         lambda(res);
92         free(res.head);
93     };
94     auto callbackRef = std::make_shared<CallbackRef<std::vector<sptr<MetadataObject>>>>(callback, callbackId);
95     metadataOutputCallback_->SaveCallbackRef(callbackRef);
96 }
97 
OffMetadataObjectsAvailable(int64_t callbackId)98 void CJMetadataOutput::OffMetadataObjectsAvailable(int64_t callbackId)
99 {
100     if (metadataOutputCallback_ == nullptr) {
101         return;
102     }
103     metadataOutputCallback_->RemoveCallbackRef(callbackId);
104 }
105 
OffAllMetadataObjectsAvailable()106 void CJMetadataOutput::OffAllMetadataObjectsAvailable()
107 {
108     if (metadataOutputCallback_ == nullptr) {
109         return;
110     }
111     metadataOutputCallback_->RemoveAllCallbackRef();
112 }
113 
OnError(int64_t callbackId)114 void CJMetadataOutput::OnError(int64_t callbackId)
115 {
116     if (metadataStateCallback_ == nullptr) {
117         metadataStateCallback_ = std::make_shared<CJMetadataStateCallback>();
118         if (metadataStateCallback_ == nullptr || metadataOutput_ == nullptr) {
119             return;
120         }
121         metadataOutput_->SetCallback(metadataStateCallback_);
122     }
123     auto cFunc = reinterpret_cast<void (*)(const int32_t errorType)>(callbackId);
124     auto callback = [lambda = CJLambda::Create(cFunc)](const int32_t errorType) -> void { lambda(errorType); };
125     auto callbackRef = std::make_shared<CallbackRef<const int32_t>>(callback, callbackId);
126     metadataStateCallback_->SaveCallbackRef(callbackRef);
127 }
128 
OffError(int64_t callbackId)129 void CJMetadataOutput::OffError(int64_t callbackId)
130 {
131     if (metadataStateCallback_ == nullptr) {
132         return;
133     }
134     metadataStateCallback_->RemoveCallbackRef(callbackId);
135 }
136 
OffAllError()137 void CJMetadataOutput::OffAllError()
138 {
139     if (metadataStateCallback_ == nullptr) {
140         return;
141     }
142     metadataStateCallback_->RemoveAllCallbackRef();
143 }
144 
145 } // namespace CameraStandard
146 } // namespace OHOS