1 /*
2  * Copyright (c) 2021 - 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 "utils_data_stub.h"
17 
18 static constexpr uint32_t MAX_SUPPORTED_TAGS = 1000;
19 static constexpr uint32_t MAX_SUPPORTED_ITEMS = 1000;
20 static constexpr uint32_t MAX_ITEM_CAPACITY = (1000 * 10);
21 static constexpr uint32_t MAX_DATA_CAPACITY = (1000 * 10 * 10);
22 
23 namespace OHOS::Camera {
WriteMetadataDataToVec(const camera_metadata_item_t & entry,std::vector<uint8_t> & cameraAbility)24 bool UtilsDataStub::WriteMetadataDataToVec(const camera_metadata_item_t &entry, std::vector<uint8_t> &cameraAbility)
25 {
26     if (entry.data_type == META_TYPE_BYTE) {
27         for (size_t i = 0; i < entry.count; i++) {
28             WriteData<int8_t>(*(entry.data.u8 + i), cameraAbility);
29         }
30     } else if (entry.data_type == META_TYPE_INT32) {
31         for (size_t i = 0; i < entry.count; i++) {
32             WriteData<int32_t>(*(entry.data.i32 + i), cameraAbility);
33         }
34     } else if (entry.data_type == META_TYPE_FLOAT) {
35         for (size_t i = 0; i < entry.count; i++) {
36             WriteData<float>(*(entry.data.f + i), cameraAbility);
37         }
38     } else if (entry.data_type == META_TYPE_INT64) {
39         for (size_t i = 0; i < entry.count; i++) {
40             WriteData<int64_t>(*(entry.data.i64 + i), cameraAbility);
41         }
42     } else if (entry.data_type == META_TYPE_DOUBLE) {
43         for (size_t i = 0; i < entry.count; i++) {
44             WriteData<double>(*(entry.data.d + i), cameraAbility);
45         }
46     } else if (entry.data_type == META_TYPE_RATIONAL) {
47         for (size_t i = 0; i < entry.count; i++) {
48             WriteData<int32_t>((*(entry.data.r + i)).numerator, cameraAbility);
49             WriteData<int32_t>((*(entry.data.r + i)).denominator, cameraAbility);
50         }
51     }
52 
53     return true;
54 }
55 
ConvertMetadataToVec(const std::shared_ptr<CameraMetadata> & metadata,std::vector<uint8_t> & cameraAbility)56 bool UtilsDataStub::ConvertMetadataToVec(const std::shared_ptr<CameraMetadata> &metadata,
57     std::vector<uint8_t> &cameraAbility)
58 {
59     if (metadata == nullptr) {
60         return false;
61     }
62 
63     bool bRet = true;
64     uint32_t tagCount = 0;
65     common_metadata_header_t *meta = metadata->get();
66     if (meta != nullptr) {
67         tagCount = GetCameraMetadataItemCount(meta);
68         WriteData<uint32_t>(tagCount, cameraAbility);
69         WriteData<uint32_t>(GetCameraMetadataItemCapacity(meta), cameraAbility);
70         WriteData<uint32_t>(GetCameraMetadataDataSize(meta), cameraAbility);
71         for (uint32_t i = 0; i < tagCount; i++) {
72             camera_metadata_item_t item;
73             int ret = GetCameraMetadataItem(meta, i, &item);
74             if (ret != CAM_META_SUCCESS) {
75                 return false;
76             }
77 
78             WriteData<uint32_t>(item.index, cameraAbility);
79             WriteData<uint32_t>(item.item, cameraAbility);
80             WriteData<uint32_t>(item.data_type, cameraAbility);
81             WriteData<uint32_t>(item.count, cameraAbility);
82 
83             bRet = WriteMetadataDataToVec(item, cameraAbility);
84         }
85     } else {
86         cameraAbility.push_back(tagCount);
87     }
88 
89     return bRet;
90 }
91 
EncodeCameraMetadata(const std::shared_ptr<CameraMetadata> & metadata,MessageParcel & data)92 bool UtilsDataStub::EncodeCameraMetadata(const std::shared_ptr<CameraMetadata> &metadata,
93     MessageParcel &data)
94 {
95     if (metadata == nullptr) {
96         return false;
97     }
98 
99     bool bRet = true;
100     uint32_t tagCount = 0;
101     common_metadata_header_t *meta = metadata->get();
102     if (meta != nullptr) {
103         tagCount = Camera::GetCameraMetadataItemCount(meta);
104         bRet = (bRet && data.WriteInt32(static_cast<int32_t>(tagCount)));
105         camera_metadata_item_entry_t *item = Camera::GetMetadataItems(meta);
106         for (uint32_t i = 0; i < tagCount; i++, item++) {
107             camera_metadata_item_t entry;
108             int ret = FindCameraMetadataItem(meta, item->item, &entry);
109             if (ret == -ENOENT) {
110                 return false;
111             }
112 
113             bRet = (bRet && data.WriteUint32(static_cast<uint32_t>(entry.index)));
114             bRet = (bRet && data.WriteUint32(entry.item));
115             bRet = (bRet && data.WriteUint8(static_cast<uint8_t>(entry.data_type)));
116             bRet = (bRet && data.WriteUint32(static_cast<uint32_t>(entry.count)));
117             bRet = (bRet && UtilsDataStub::WriteMetadata(entry, data));
118         }
119     } else {
120         bRet = data.WriteInt32(tagCount);
121     }
122     return bRet;
123 }
124 
ReadMetadataDataFromVec(int32_t & index,camera_metadata_item_t & entry,const std::vector<uint8_t> & cameraAbility)125 bool UtilsDataStub::ReadMetadataDataFromVec(int32_t &index, camera_metadata_item_t &entry,
126     const std::vector<uint8_t> &cameraAbility)
127 {
128     if (entry.data_type == META_TYPE_BYTE) {
129         entry.data.u8 = new(std::nothrow) uint8_t[entry.count];
130         if (entry.data.u8 != nullptr) {
131             for (size_t i = 0; i < entry.count; i++) {
132                 ReadData<uint8_t>(entry.data.u8[i], index, cameraAbility);
133             }
134         }
135     } else if (entry.data_type == META_TYPE_INT32) {
136         entry.data.i32 = new(std::nothrow) int32_t[entry.count];
137         if (entry.data.i32 != nullptr) {
138             for (size_t i = 0; i < entry.count; i++) {
139                 ReadData<int32_t>(entry.data.i32[i], index, cameraAbility);
140             }
141         }
142     } else if (entry.data_type == META_TYPE_FLOAT) {
143         entry.data.f = new(std::nothrow) float[entry.count];
144         if (entry.data.f != nullptr) {
145             for (size_t i = 0; i < entry.count; i++) {
146                 ReadData<float>(entry.data.f[i], index, cameraAbility);
147             }
148         }
149     } else if (entry.data_type == META_TYPE_INT64) {
150         entry.data.i64 = new(std::nothrow) int64_t[entry.count];
151         if (entry.data.i64 != nullptr) {
152             for (size_t i = 0; i < entry.count; i++) {
153                 ReadData<int64_t>(entry.data.i64[i], index, cameraAbility);
154             }
155         }
156     } else if (entry.data_type == META_TYPE_DOUBLE) {
157         entry.data.d = new(std::nothrow) double[entry.count];
158         if (entry.data.d != nullptr) {
159             for (size_t i = 0; i < entry.count; i++) {
160                 ReadData<double>(entry.data.d[i], index, cameraAbility);
161             }
162         }
163     } else if (entry.data_type == META_TYPE_RATIONAL) {
164         entry.data.r = new(std::nothrow) camera_rational_t[entry.count];
165         if (entry.data.r != nullptr) {
166             for (size_t i = 0; i < entry.count; i++) {
167                 ReadData<int32_t>(entry.data.r[i].numerator, index, cameraAbility);
168                 ReadData<int32_t>(entry.data.r[i].denominator, index, cameraAbility);
169             }
170         }
171     }
172 
173     return true;
174 }
175 
ConvertVecToMetadata(const std::vector<uint8_t> & cameraAbility,std::shared_ptr<CameraMetadata> & metadata)176 void UtilsDataStub::ConvertVecToMetadata(const std::vector<uint8_t> &cameraAbility,
177     std::shared_ptr<CameraMetadata> &metadata)
178 {
179     int32_t index = 0;
180     uint32_t tagCount = 0;
181     uint32_t itemCapacity = 0;
182     uint32_t dataCapacity = 0;
183 
184     ReadData<uint32_t>(tagCount, index, cameraAbility);
185     if (tagCount > MAX_SUPPORTED_TAGS) {
186         tagCount = MAX_SUPPORTED_TAGS;
187         METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata tagCount is more than supported value");
188     }
189     ReadData<uint32_t>(itemCapacity, index, cameraAbility);
190     if (itemCapacity > MAX_ITEM_CAPACITY) {
191         itemCapacity = MAX_ITEM_CAPACITY;
192         METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata itemCapacity is more than supported value");
193     }
194     ReadData<uint32_t>(dataCapacity, index, cameraAbility);
195     if (dataCapacity > MAX_DATA_CAPACITY) {
196         dataCapacity = MAX_DATA_CAPACITY;
197         METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata dataCapacity is more than supported value");
198     }
199 
200     std::vector<camera_metadata_item_t> items;
201     for (int32_t i = 0; i < tagCount; i++) {
202         camera_metadata_item_t item;
203         ReadData<uint32_t>(item.index, index, cameraAbility);
204         ReadData<uint32_t>(item.item, index, cameraAbility);
205         ReadData<uint32_t>(item.data_type, index, cameraAbility);
206         ReadData<uint32_t>(item.count, index, cameraAbility);
207         if (item.count > MAX_SUPPORTED_ITEMS) {
208             item.count = MAX_SUPPORTED_ITEMS;
209             METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata item.count is more than supported value");
210         }
211         ReadMetadataDataFromVec(index, item, cameraAbility);
212         items.push_back(item);
213     }
214 
215     metadata = std::make_shared<CameraMetadata>(itemCapacity, dataCapacity);
216     CHECK_IF_PTR_NULL_RETURN_VOID(metadata);
217     common_metadata_header_t *meta = metadata->get();
218     for (auto &item_ : items) {
219         void *buffer = nullptr;
220         MetadataUtils::ItemDataToBuffer(item_, &buffer);
221         (void)AddCameraMetadataItem(meta, item_.item, buffer, item_.count);
222         MetadataUtils::FreeMetadataBuffer(item_);
223     }
224 }
225 
DecodeCameraMetadata(MessageParcel & data,std::shared_ptr<CameraMetadata> & metadata)226 void UtilsDataStub::DecodeCameraMetadata(MessageParcel &data, std::shared_ptr<CameraMetadata> &metadata)
227 {
228     int32_t tagCount = data.ReadInt32();
229     if (tagCount <= 0) {
230         return;
231     }
232 
233     if (tagCount > MAX_SUPPORTED_TAGS) {
234         tagCount = MAX_SUPPORTED_TAGS;
235         METADATA_ERR_LOG("MetadataUtils::DecodeCameraMetadata tagCount is more than supported value");
236     }
237 
238     int32_t metadataSize = 0;
239     std::vector<camera_metadata_item_t> entrys;
240     for (int32_t i = 0; i < tagCount; i++) {
241         camera_metadata_item_t entry;
242         entry.index = static_cast<size_t>(data.ReadUint32());
243         entry.item = static_cast<uint32_t>(data.ReadUint32());
244         entry.data_type = static_cast<uint8_t>(data.ReadUint8());
245         entry.count = static_cast<size_t>(data.ReadUint32());
246         ReadMetadata(entry, data);
247         metadataSize++;
248 
249         entrys.push_back(entry);
250     }
251 
252     metadata = std::make_shared<CameraMetadata>(tagCount, metadataSize);
253     CHECK_IF_PTR_NULL_RETURN_VOID(metadata);
254     common_metadata_header_t *meta = metadata->get();
255     for (auto &entry : entrys) {
256         void *buffer = nullptr;
257         UtilsDataStub::EntryDataToBuffer(entry, &buffer);
258         if (buffer != nullptr) {
259             (void)Camera::AddCameraMetadataItem(meta, entry.item, buffer, entry.count);
260         }
261         MetadataUtils::FreeMetadataBuffer(entry);
262     }
263 }
264 
EncodeStreamInfo(const std::shared_ptr<StreamInfo> & pInfo,MessageParcel & parcel)265 bool UtilsDataStub::EncodeStreamInfo(const std::shared_ptr<StreamInfo> &pInfo, MessageParcel &parcel)
266 {
267     bool bRet = true;
268     bRet = (bRet && parcel.WriteInt32(static_cast<int32_t>(pInfo->streamId_)));
269     bRet = (bRet && parcel.WriteInt32(static_cast<int32_t>(pInfo->width_)));
270     bRet = (bRet && parcel.WriteInt32(static_cast<int32_t>(pInfo->height_)));
271     bRet = (bRet && parcel.WriteInt32(static_cast<int32_t>(pInfo->format_)));
272     bRet = (bRet && parcel.WriteInt32(pInfo->intent_));
273     bRet = (bRet && parcel.WriteBool(pInfo->tunneledMode_));
274     bool bufferQueueFlag = (pInfo->bufferQueue_->producer_ != nullptr) ? true : false;
275     bRet = (bRet && parcel.WriteBool(bufferQueueFlag));
276     if (bufferQueueFlag) {
277         bRet = (bRet && parcel.WriteRemoteObject(pInfo->bufferQueue_->producer_->AsObject()));
278     }
279     bRet = (bRet && parcel.WriteInt32(static_cast<int32_t>(pInfo->minFrameDuration_)));
280     bRet = (bRet && parcel.WriteInt32(pInfo->encodeType_));
281     return bRet;
282 }
283 
DecodeStreamInfo(MessageParcel & parcel,std::shared_ptr<StreamInfo> & pInfo)284 void UtilsDataStub::DecodeStreamInfo(MessageParcel &parcel, std::shared_ptr<StreamInfo> &pInfo)
285 {
286     pInfo->streamId_ = static_cast<int>(parcel.ReadInt32());
287     pInfo->width_ = static_cast<int>(parcel.ReadInt32());
288     pInfo->height_ = static_cast<int>(parcel.ReadInt32());
289     pInfo->format_ = static_cast<int>(parcel.ReadInt32());
290     pInfo->intent_ = static_cast<StreamIntent>(parcel.ReadInt32());
291     pInfo->tunneledMode_ = parcel.ReadBool();
292     bool bufferQueueFlag = parcel.ReadBool();
293     if (bufferQueueFlag) {
294         sptr<IRemoteObject> remoteBufferProducer = parcel.ReadRemoteObject();
295         pInfo->bufferQueue_->producer_ = OHOS::iface_cast<OHOS::IBufferProducer>(remoteBufferProducer);
296     }
297     pInfo->minFrameDuration_ = static_cast<int>(parcel.ReadInt32());
298     pInfo->encodeType_ = static_cast<EncodeType>(parcel.ReadInt32());
299 }
300 
GetDataSize(uint8_t type)301 int32_t UtilsDataStub::GetDataSize(uint8_t type)
302 {
303     int32_t size = 0;
304     if (type == META_TYPE_BYTE) {
305         size = sizeof(uint8_t);
306     } else if (type == META_TYPE_INT32) {
307         size = sizeof(int32_t);
308     } else if (type == META_TYPE_FLOAT) {
309         size = sizeof(float);
310     } else if (type == META_TYPE_INT64) {
311         size = sizeof(int64_t);
312     } else if (type == META_TYPE_DOUBLE) {
313         size = sizeof(double);
314     } else if (type == META_TYPE_RATIONAL) {
315         size = sizeof(camera_rational_t);
316     } else {
317         size = 0;
318     }
319     return size;
320 }
321 
WriteMetadata(const camera_metadata_item_t & entry,MessageParcel & data)322 bool UtilsDataStub::WriteMetadata(const camera_metadata_item_t &entry, MessageParcel &data)
323 {
324     if (entry.data_type == META_TYPE_BYTE) {
325         std::vector<uint8_t> buffers;
326         for (size_t i = 0; i < entry.count; i++) {
327             buffers.push_back(*(entry.data.u8 + i));
328         }
329         data.WriteUInt8Vector(buffers);
330     } else if (entry.data_type == META_TYPE_INT32) {
331         std::vector<int32_t> buffers;
332         for (size_t i = 0; i < entry.count; i++) {
333             buffers.push_back(*(entry.data.i32 + i));
334         }
335         data.WriteInt32Vector(buffers);
336     } else if (entry.data_type == META_TYPE_FLOAT) {
337         std::vector<float> buffers;
338         for (size_t i = 0; i < entry.count; i++) {
339             buffers.push_back(*(entry.data.f + i));
340         }
341         data.WriteFloatVector(buffers);
342     } else if (entry.data_type == META_TYPE_INT64) {
343         std::vector<int64_t> buffers;
344         for (size_t i = 0; i < entry.count; i++) {
345             buffers.push_back(*(entry.data.i64 + i));
346         }
347         data.WriteInt64Vector(buffers);
348     } else if (entry.data_type == META_TYPE_DOUBLE) {
349         std::vector<double> buffers;
350         for (size_t i = 0; i < entry.count; i++) {
351             buffers.push_back(*(entry.data.d + i));
352         }
353         data.WriteDoubleVector(buffers);
354     } else if (entry.data_type == META_TYPE_RATIONAL) {
355         std::vector<int32_t> buffers;
356         for (size_t i = 0; i < entry.count; i++) {
357             buffers.push_back((*(entry.data.r + i)).numerator);
358             buffers.push_back((*(entry.data.r + i)).denominator);
359         }
360         data.WriteInt32Vector(buffers);
361     }
362 
363     return true;
364 }
365 
ReadMetadataUInt8(camera_metadata_item_t & entry,MessageParcel & data)366 static void ReadMetadataUInt8(camera_metadata_item_t &entry, MessageParcel &data)
367 {
368     std::vector<uint8_t> buffers;
369     data.ReadUInt8Vector(&buffers);
370     entry.data.u8 = new(std::nothrow) uint8_t[entry.count];
371     if (entry.data.u8 != nullptr) {
372         for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
373             entry.data.u8[i] = buffers.at(i);
374         }
375     }
376 }
377 
ReadMetadataInt32(camera_metadata_item_t & entry,MessageParcel & data)378 static void ReadMetadataInt32(camera_metadata_item_t &entry, MessageParcel &data)
379 {
380     std::vector<int32_t> buffers;
381     data.ReadInt32Vector(&buffers);
382     entry.data.i32 = new(std::nothrow) int32_t[entry.count];
383     if (entry.data.i32 != nullptr) {
384         for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
385             entry.data.i32[i] = buffers.at(i);
386         }
387     }
388 }
389 
ReadMetadataUInt32(camera_metadata_item_t & entry,MessageParcel & data)390 static void ReadMetadataUInt32(camera_metadata_item_t &entry, MessageParcel &data)
391 {
392     std::vector<uint32_t> buffers;
393     data.ReadUInt32Vector(&buffers);
394     entry.data.ui32 = new(std::nothrow) uint32_t[entry.count];
395     if (entry.data.ui32 != nullptr) {
396         for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
397             entry.data.ui32[i] = buffers.at(i);
398         }
399     }
400 }
401 
ReadMetadataFloat(camera_metadata_item_t & entry,MessageParcel & data)402 static void ReadMetadataFloat(camera_metadata_item_t &entry, MessageParcel &data)
403 {
404     std::vector<float> buffers;
405     data.ReadFloatVector(&buffers);
406     entry.data.f = new(std::nothrow) float[entry.count];
407     if (entry.data.f != nullptr) {
408         for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
409             entry.data.f[i] = buffers.at(i);
410         }
411     }
412 }
413 
ReadMetadataInt64(camera_metadata_item_t & entry,MessageParcel & data)414 static void ReadMetadataInt64(camera_metadata_item_t &entry, MessageParcel &data)
415 {
416     std::vector<int64_t> buffers;
417     data.ReadInt64Vector(&buffers);
418     entry.data.i64 = new(std::nothrow) int64_t[entry.count];
419     if (entry.data.i64 != nullptr) {
420         for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
421             entry.data.i64[i] = buffers.at(i);
422         }
423     }
424 }
425 
ReadMetadataDouble(camera_metadata_item_t & entry,MessageParcel & data)426 static void ReadMetadataDouble(camera_metadata_item_t &entry, MessageParcel &data)
427 {
428     std::vector<double> buffers;
429     data.ReadDoubleVector(&buffers);
430     entry.data.d = new(std::nothrow) double[entry.count];
431     if (entry.data.d != nullptr) {
432         for (size_t i = 0; i < entry.count && i < buffers.size(); i++) {
433             entry.data.d[i] = buffers.at(i);
434         }
435     }
436 }
437 
ReadMetadataRational(camera_metadata_item_t & entry,MessageParcel & data)438 static void ReadMetadataRational(camera_metadata_item_t &entry, MessageParcel &data)
439 {
440     std::vector<int32_t> buffers;
441     data.ReadInt32Vector(&buffers);
442     entry.data.r = new(std::nothrow) camera_rational_t[entry.count];
443     if (entry.data.r != nullptr) {
444         for (size_t i = 0, j = 0;
445             i < entry.count && j < static_cast<size_t>(buffers.size() - 1);
446             i++, j += 2) { // 2:Take two elements from the buffer vector container
447             entry.data.r[i].numerator = buffers.at(j);
448             entry.data.r[i].denominator = buffers.at(j + 1);
449         }
450     }
451 }
ReadMetadata(camera_metadata_item_t & entry,MessageParcel & data)452 bool UtilsDataStub::ReadMetadata(camera_metadata_item_t &entry, MessageParcel &data)
453 {
454     switch (entry.data_type) {
455         case META_TYPE_BYTE:
456             ReadMetadataUInt8(entry, data);
457             break;
458         case META_TYPE_INT32:
459             ReadMetadataInt32(entry, data);
460             break;
461         case META_TYPE_UINT32:
462             ReadMetadataUInt32(entry, data);
463             break;
464         case META_TYPE_FLOAT:
465             ReadMetadataFloat(entry, data);
466             break;
467         case META_TYPE_INT64:
468             ReadMetadataInt64(entry, data);
469             break;
470         case META_TYPE_DOUBLE:
471             ReadMetadataDouble(entry, data);
472             break;
473         case META_TYPE_RATIONAL:
474             ReadMetadataRational(entry, data);
475             break;
476     }
477     return true;
478 }
479 
EntryDataToBuffer(const camera_metadata_item_t & entry,void ** buffer)480 void UtilsDataStub::EntryDataToBuffer(const camera_metadata_item_t &entry, void **buffer)
481 {
482     if (entry.data_type == META_TYPE_BYTE) {
483         *buffer = static_cast<void*>(entry.data.u8);
484     } else if (entry.data_type == META_TYPE_INT32) {
485         *buffer = static_cast<void*>(entry.data.i32);
486     } else if (entry.data_type == META_TYPE_FLOAT) {
487         *buffer = static_cast<void*>(entry.data.f);
488     } else if (entry.data_type == META_TYPE_INT64) {
489         *buffer = static_cast<void*>(entry.data.i64);
490     } else if (entry.data_type == META_TYPE_DOUBLE) {
491         *buffer = static_cast<void*>(entry.data.d);
492     } else if (entry.data_type == META_TYPE_RATIONAL) {
493         *buffer = static_cast<void*>(entry.data.r);
494     }
495 }
496 }
497