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 #include "av_trans_stream_data.h"
16 #include "dtbcollabmgr_log.h"
17
18 namespace OHOS {
19 namespace DistributedCollab {
20 namespace {
21 static constexpr int32_t RADIX = 10;
22 static const std::string TAG = "DSchedCollabAVTransStreamData";
23 }
24
StreamData()25 std::shared_ptr<AVTransDataBuffer> AVTransStreamData::StreamData()
26 {
27 return data_;
28 }
29
GetStreamDataExt() const30 const AVTransStreamDataExt& AVTransStreamData::GetStreamDataExt() const
31 {
32 return const_cast<const AVTransStreamDataExt&>(ext_);
33 }
34
SerializeStreamDataExt() const35 cJSON* AVTransStreamData::SerializeStreamDataExt() const
36 {
37 cJSON* root = cJSON_CreateObject();
38 WriteExtFlagToJson(root);
39 WriteExtIndexToJson(root);
40 switch (ext_.flag_) {
41 case AvCodecBufferFlag::AVCODEC_BUFFER_FLAG_PIXEL_MAP: {
42 WriteExtPixelMapPackOptionToJson(root);
43 return root;
44 }
45 case AvCodecBufferFlag::AVCODEC_BUFFER_FLAG_SURFACE_PARAM: {
46 WriteExtSurfaceParamToJson(root);
47 return root;
48 }
49 default: {
50 WriteExtPtsToJson(root);
51 WriteExtStartEncodeTToJson(root);
52 WriteExtFinishEncodeTToJson(root);
53 WriteExtSendEncodeTToJson(root);
54 return root;
55 }
56 }
57 }
58
WriteExtFlagToJson(cJSON * root) const59 inline void AVTransStreamData::WriteExtFlagToJson(cJSON* root) const
60 {
61 cJSON_AddNumberToObject(root, "flag", static_cast<uint32_t>(ext_.flag_));
62 }
63
WriteExtIndexToJson(cJSON * root) const64 inline void AVTransStreamData::WriteExtIndexToJson(cJSON* root) const
65 {
66 cJSON_AddNumberToObject(root, "index", ext_.index_);
67 }
68
WriteExtPtsToJson(cJSON * root) const69 inline void AVTransStreamData::WriteExtPtsToJson(cJSON* root) const
70 {
71 std::string ptsStr = std::to_string(ext_.pts_);
72 cJSON_AddStringToObject(root, "pts", ptsStr.c_str());
73 }
74
WriteExtStartEncodeTToJson(cJSON * root) const75 inline void AVTransStreamData::WriteExtStartEncodeTToJson(cJSON* root) const
76 {
77 std::string startEncodeTStr = std::to_string(ext_.startEncodeT_);
78 cJSON_AddStringToObject(root, "startEncodeT", startEncodeTStr.c_str());
79 }
80
WriteExtFinishEncodeTToJson(cJSON * root) const81 inline void AVTransStreamData::WriteExtFinishEncodeTToJson(cJSON* root) const
82 {
83 std::string finishEncodeTStr = std::to_string(ext_.finishEncodeT_);
84 cJSON_AddStringToObject(root, "finishEncodeT", finishEncodeTStr.c_str());
85 }
86
WriteExtSendEncodeTToJson(cJSON * root) const87 inline void AVTransStreamData::WriteExtSendEncodeTToJson(cJSON* root) const
88 {
89 std::string sendEncodeTStr = std::to_string(ext_.sendEncodeT_);
90 cJSON_AddStringToObject(root, "sendEncodeT", sendEncodeTStr.c_str());
91 }
92
WriteExtPixelMapPackOptionToJson(cJSON * root) const93 inline void AVTransStreamData::WriteExtPixelMapPackOptionToJson(cJSON* root) const
94 {
95 cJSON* pixelMapJson = cJSON_CreateObject();
96 cJSON_AddNumberToObject(pixelMapJson, "quality", ext_.pixelMapOption_.quality);
97 cJSON_AddNumberToObject(pixelMapJson, "width", ext_.pixelMapOption_.width);
98 cJSON_AddNumberToObject(pixelMapJson, "height", ext_.pixelMapOption_.height);
99 cJSON_AddItemToObject(root, "pixel_map", pixelMapJson);
100 }
101
WriteExtSurfaceParamToJson(cJSON * root) const102 inline void AVTransStreamData::WriteExtSurfaceParamToJson(cJSON* root) const
103 {
104 cJSON* surfaceParamJson = cJSON_CreateObject();
105 cJSON_AddNumberToObject(surfaceParamJson, "rotate", static_cast<uint32_t>(ext_.surfaceParam_.rotate));
106 cJSON_AddNumberToObject(surfaceParamJson, "filp", static_cast<uint32_t>(ext_.surfaceParam_.filp));
107 cJSON_AddItemToObject(root, "surface_param", surfaceParamJson);
108 }
109
DeserializeStreamDataExt(const char * data)110 int32_t AVTransStreamData::DeserializeStreamDataExt(const char* data)
111 {
112 if (data == nullptr) {
113 HILOGE("empty data");
114 return NULL_POINTER_ERROR;
115 }
116 cJSON* root = cJSON_Parse(data);
117 if (root == nullptr) {
118 HILOGE("parse recv data ext failed");
119 return PARSE_AV_TRANS_STREAM_EXT_FAILED;
120 }
121 DeserializeExtFromJson(root);
122 cJSON_Delete(root);
123 return ERR_OK;
124 }
125
DeserializeExtFromJson(const cJSON * root)126 void AVTransStreamData::DeserializeExtFromJson(const cJSON* root)
127 {
128 AVTransStreamDataExt& dataExt = ext_;
129 ReadExtFlagFromJson(dataExt, root);
130 ReadExtIndexFromJson(dataExt, root);
131 if (ext_.flag_ == AvCodecBufferFlag::AVCODEC_BUFFER_FLAG_PIXEL_MAP) {
132 return ReadExtPixelMapPackOptionToJson(dataExt, root);
133 }
134 if (ext_.flag_ == AvCodecBufferFlag::AVCODEC_BUFFER_FLAG_SURFACE_PARAM) {
135 return ReadExtSurfaceParamToJson(dataExt, root);
136 }
137 ReadExtPtsFromJson(dataExt, root);
138 ReadExtStartEncodeTFromJson(dataExt, root);
139 ReadExtFinishEncodeTFromJson(dataExt, root);
140 ReadExtSendEncodeTFromJson(dataExt, root);
141 }
142
ReadExtFlagFromJson(AVTransStreamDataExt & dataExt,const cJSON * root)143 inline void AVTransStreamData::ReadExtFlagFromJson(AVTransStreamDataExt& dataExt, const cJSON* root)
144 {
145 const cJSON* flagItem = cJSON_GetObjectItemCaseSensitive(root, "flag");
146 if (cJSON_IsNumber(flagItem)) {
147 dataExt.flag_ = static_cast<AvCodecBufferFlag>(flagItem->valueint);
148 }
149 }
150
ReadExtIndexFromJson(AVTransStreamDataExt & dataExt,const cJSON * root)151 inline void AVTransStreamData::ReadExtIndexFromJson(AVTransStreamDataExt& dataExt, const cJSON* root)
152 {
153 const cJSON* indexItem = cJSON_GetObjectItemCaseSensitive(root, "index");
154 if (cJSON_IsNumber(indexItem)) {
155 dataExt.index_ = static_cast<uint32_t>(indexItem->valueint);
156 }
157 }
158
ReadExtPtsFromJson(AVTransStreamDataExt & dataExt,const cJSON * root)159 inline void AVTransStreamData::ReadExtPtsFromJson(AVTransStreamDataExt& dataExt, const cJSON* root)
160 {
161 const cJSON* ptsItem = cJSON_GetObjectItemCaseSensitive(root, "pts");
162 if (cJSON_IsString(ptsItem) && ptsItem->valuestring != nullptr) {
163 dataExt.pts_ = std::strtoull(ptsItem->valuestring, nullptr, RADIX);
164 }
165 }
166
ReadExtStartEncodeTFromJson(AVTransStreamDataExt & dataExt,const cJSON * root)167 inline void AVTransStreamData::ReadExtStartEncodeTFromJson(AVTransStreamDataExt& dataExt, const cJSON* root)
168 {
169 const cJSON* startEncodeTItem = cJSON_GetObjectItemCaseSensitive(root, "startEncodeT");
170 if (cJSON_IsString(startEncodeTItem) && startEncodeTItem->valuestring != nullptr) {
171 dataExt.startEncodeT_ = std::strtoull(startEncodeTItem->valuestring, nullptr, RADIX);
172 }
173 }
174
ReadExtFinishEncodeTFromJson(AVTransStreamDataExt & dataExt,const cJSON * root)175 inline void AVTransStreamData::ReadExtFinishEncodeTFromJson(AVTransStreamDataExt& dataExt, const cJSON* root)
176 {
177 const cJSON* finishEncodeTItem = cJSON_GetObjectItemCaseSensitive(root, "finishEncodeT");
178 if (cJSON_IsString(finishEncodeTItem) && finishEncodeTItem->valuestring != nullptr) {
179 dataExt.finishEncodeT_ = std::strtoull(finishEncodeTItem->valuestring, nullptr, RADIX);
180 }
181 }
182
ReadExtSendEncodeTFromJson(AVTransStreamDataExt & dataExt,const cJSON * root)183 inline void AVTransStreamData::ReadExtSendEncodeTFromJson(AVTransStreamDataExt& dataExt, const cJSON* root)
184 {
185 const cJSON* sendEncodeTItem = cJSON_GetObjectItemCaseSensitive(root, "sendEncodeT");
186 if (cJSON_IsString(sendEncodeTItem) && sendEncodeTItem->valuestring != nullptr) {
187 dataExt.sendEncodeT_ = std::strtoull(sendEncodeTItem->valuestring, nullptr, RADIX);
188 }
189 }
190
ReadExtPixelMapPackOptionToJson(AVTransStreamDataExt & dataExt,const cJSON * root)191 void AVTransStreamData::ReadExtPixelMapPackOptionToJson(AVTransStreamDataExt& dataExt, const cJSON* root)
192 {
193 const cJSON* pixelMapJson = cJSON_GetObjectItemCaseSensitive(root, "pixel_map");
194 if (pixelMapJson) {
195 const cJSON* qualityItem = cJSON_GetObjectItemCaseSensitive(pixelMapJson, "quality");
196 if (cJSON_IsNumber(qualityItem)) {
197 ext_.pixelMapOption_.quality = static_cast<uint8_t>(cJSON_GetNumberValue(qualityItem));
198 }
199 const cJSON* widthItem = cJSON_GetObjectItemCaseSensitive(pixelMapJson, "width");
200 if (cJSON_IsNumber(widthItem)) {
201 dataExt.pixelMapOption_.width = static_cast<uint32_t>(cJSON_GetNumberValue(widthItem));
202 }
203 const cJSON* heightItem = cJSON_GetObjectItemCaseSensitive(pixelMapJson, "height");
204 if (cJSON_IsNumber(heightItem)) {
205 dataExt.pixelMapOption_.height = static_cast<uint32_t>(cJSON_GetNumberValue(heightItem));
206 }
207 }
208 }
209
ReadExtSurfaceParamToJson(AVTransStreamDataExt & dataExt,const cJSON * root)210 void AVTransStreamData::ReadExtSurfaceParamToJson(AVTransStreamDataExt& dataExt, const cJSON* root)
211 {
212 const cJSON* surfaceParamItem = cJSON_GetObjectItemCaseSensitive(root, "surface_param");
213 if (surfaceParamItem != nullptr && cJSON_IsObject(surfaceParamItem)) {
214 const cJSON* rotateItem = cJSON_GetObjectItemCaseSensitive(surfaceParamItem, "rotate");
215 if (cJSON_IsNumber(rotateItem)) {
216 dataExt.surfaceParam_.rotate = static_cast<SurfaceRotate>(rotateItem->valueint);
217 }
218
219 const cJSON* filpItem = cJSON_GetObjectItemCaseSensitive(surfaceParamItem, "filp");
220 if (cJSON_IsNumber(filpItem)) {
221 dataExt.surfaceParam_.filp = static_cast<SurfaceFilp>(filpItem->valueint);
222 }
223 }
224 }
225 } // namespace DistributedCollab
226 } // namespace OHOS
227