1 /*
2 * Copyright (c) 2021 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 "proxy_msgproc.h"
16 #include <hdf_log.h>
17
18 #ifdef __cplusplus
19 extern "C" {
20 #endif /* __cplusplus */
CodecProxyParseAlignment(struct HdfSBuf * reply,Alginment * alginment)21 int32_t CodecProxyParseAlignment(struct HdfSBuf *reply, Alginment *alginment)
22 {
23 if (reply == NULL || alginment == NULL) {
24 HDF_LOGE("%{public}s: params NULL!", __func__);
25 return HDF_ERR_INVALID_PARAM;
26 }
27 if (!HdfSbufReadInt32(reply, &alginment->widthAlginment)) {
28 HDF_LOGE("%{public}s: read widthAlginment failed!", __func__);
29 return HDF_FAILURE;
30 }
31 if (!HdfSbufReadInt32(reply, &alginment->heightAlginment)) {
32 HDF_LOGE("%{public}s: read heightAlginment failed!", __func__);
33 return HDF_FAILURE;
34 }
35 return HDF_SUCCESS;
36 }
37
CodecProxyParseRect(struct HdfSBuf * reply,Rect * rectangle)38 int32_t CodecProxyParseRect(struct HdfSBuf *reply, Rect *rectangle)
39 {
40 if (reply == NULL || rectangle == NULL) {
41 HDF_LOGE("%{public}s: params NULL!", __func__);
42 return HDF_ERR_INVALID_PARAM;
43 }
44 if (!HdfSbufReadInt32(reply, &rectangle->width)) {
45 HDF_LOGE("%{public}s: read width failed!", __func__);
46 return HDF_FAILURE;
47 }
48 if (!HdfSbufReadInt32(reply, &rectangle->height)) {
49 HDF_LOGE("%{public}s: read height failed!", __func__);
50 return HDF_FAILURE;
51 }
52 return HDF_SUCCESS;
53 }
54
CodecProxyParseArray(struct HdfSBuf * reply,ResizableArray * resArr)55 int32_t CodecProxyParseArray(struct HdfSBuf *reply, ResizableArray *resArr)
56 {
57 if (reply == NULL || resArr == NULL) {
58 HDF_LOGE("%{public}s: params NULL!", __func__);
59 return HDF_ERR_INVALID_PARAM;
60 }
61
62 if (!HdfSbufReadUint32(reply, &resArr->actualLen)) {
63 HDF_LOGE("%{public}s: read actualLen failed!", __func__);
64 return HDF_FAILURE;
65 }
66 for (uint32_t i = 0; i < resArr->actualLen; i++) {
67 if (!HdfSbufReadUint32(reply, &resArr->element[i])) {
68 HDF_LOGE("%{public}s: read element failed!", __func__);
69 return HDF_FAILURE;
70 }
71 }
72 return HDF_SUCCESS;
73 }
74
CodecProxyParseGottenCapbility(struct HdfSBuf * reply,CodecCapbility * cap)75 int32_t CodecProxyParseGottenCapbility(struct HdfSBuf *reply, CodecCapbility *cap)
76 {
77 if (reply == NULL || cap == NULL) {
78 return HDF_ERR_INVALID_PARAM;
79 }
80 if (!HdfSbufReadUint32(reply, (uint32_t*)&cap->mime)) {
81 return HDF_FAILURE;
82 }
83 if (!HdfSbufReadUint32(reply, (uint32_t*)&cap->type)) {
84 return HDF_FAILURE;
85 }
86 if (CodecProxyParseAlignment(reply, &cap->whAlignment) != HDF_SUCCESS) {
87 return HDF_FAILURE;
88 }
89 if (CodecProxyParseRect(reply, &cap->minSize) != HDF_SUCCESS) {
90 return HDF_FAILURE;
91 }
92 if (CodecProxyParseRect(reply, &cap->maxSize) != HDF_SUCCESS) {
93 return HDF_FAILURE;
94 }
95 if (!HdfSbufReadUint64(reply, &cap->minBitRate)) {
96 return HDF_FAILURE;
97 }
98 if (!HdfSbufReadUint64(reply, &cap->maxBitRate)) {
99 return HDF_FAILURE;
100 }
101 if (CodecProxyParseArray(reply, &cap->supportProfiles) != HDF_SUCCESS) {
102 return HDF_FAILURE;
103 }
104 if (CodecProxyParseArray(reply, &cap->supportLevels) != HDF_SUCCESS) {
105 return HDF_FAILURE;
106 }
107 if (CodecProxyParseArray(reply, &cap->supportPixelFormats) != HDF_SUCCESS) {
108 return HDF_FAILURE;
109 }
110 if (!HdfSbufReadUint32(reply, &cap->minInputBufferNum)) {
111 return HDF_FAILURE;
112 }
113 if (!HdfSbufReadUint32(reply, &cap->minOutputBufferNum)) {
114 return HDF_FAILURE;
115 }
116 if (!HdfSbufReadUint32(reply, &cap->allocateMask)) {
117 return HDF_FAILURE;
118 }
119 if (!HdfSbufReadUint32(reply, &cap->capsMask)) {
120 return HDF_FAILURE;
121 }
122
123 return HDF_SUCCESS;
124 }
125
CodecProxyPackParam(struct HdfSBuf * data,const Param * param)126 int32_t CodecProxyPackParam(struct HdfSBuf *data, const Param *param)
127 {
128 if (data == NULL || param == NULL) {
129 HDF_LOGE("%{public}s: params NULL!", __func__);
130 return HDF_ERR_INVALID_PARAM;
131 }
132 if (!HdfSbufWriteUint32(data, (uint32_t)param->key)) {
133 HDF_LOGE("%{public}s: Write key failed!", __func__);
134 return HDF_FAILURE;
135 }
136 if (!HdfSbufWriteUint32(data, (uint32_t)¶m->val)) {
137 HDF_LOGE("%{public}s: Write val failed!", __func__);
138 return HDF_FAILURE;
139 }
140 if (!HdfSbufWriteInt32(data, param->size)) {
141 HDF_LOGE("%{public}s: Write size failed!", __func__);
142 return HDF_FAILURE;
143 }
144 return HDF_SUCCESS;
145 }
146
CodecProxyParseParam(struct HdfSBuf * reply,Param * param)147 int32_t CodecProxyParseParam(struct HdfSBuf *reply, Param *param)
148 {
149 uint32_t tempKey = 0;
150 if (reply == NULL || param == NULL) {
151 HDF_LOGE("%{public}s: params NULL!", __func__);
152 return HDF_ERR_INVALID_PARAM;
153 }
154 if (!HdfSbufReadUint32(reply, &tempKey)) {
155 HDF_LOGE("%{public}s: read tempKey failed!", __func__);
156 return HDF_FAILURE;
157 }
158 param->key = (ParamKey)tempKey;
159 if (!HdfSbufReadUint32(reply, (uint32_t *)¶m->val)) {
160 HDF_LOGE("%{public}s: Read val failed!", __func__);
161 return HDF_FAILURE;
162 }
163 if (!HdfSbufReadInt32(reply, (int32_t*)¶m->size)) {
164 HDF_LOGE("%{public}s: read size failed!", __func__);
165 return HDF_FAILURE;
166 }
167 return HDF_SUCCESS;
168 }
169
CodecProxyPackBufferHandle(struct HdfSBuf * data,CodecBufferHandle * bufferHandle)170 int32_t CodecProxyPackBufferHandle(struct HdfSBuf *data, CodecBufferHandle *bufferHandle)
171 {
172 if (data == NULL || bufferHandle == NULL) {
173 HDF_LOGE("%{public}s: params NULL!", __func__);
174 return HDF_ERR_INVALID_PARAM;
175 }
176 if (!HdfSbufWriteUint8(data, (uint8_t)&bufferHandle->virAddr)) {
177 HDF_LOGE("%{public}s: Write virAddr failed!", __func__);
178 return HDF_FAILURE;
179 }
180 if (!HdfSbufWriteUint32(data, (uint32_t)bufferHandle->handle)) {
181 HDF_LOGE("%{public}s: Write handle failed!", __func__);
182 return HDF_FAILURE;
183 }
184 return HDF_SUCCESS;
185 }
186
CodecProxyPackBufferInfo(struct HdfSBuf * data,CodecBufferInfo * buffers)187 int32_t CodecProxyPackBufferInfo(struct HdfSBuf *data, CodecBufferInfo *buffers)
188 {
189 if (data == NULL || buffers == NULL) {
190 HDF_LOGE("%{public}s: params NULL!", __func__);
191 return HDF_ERR_INVALID_PARAM;
192 }
193 if (!HdfSbufWriteUint32(data, (uint32_t)buffers->type)) {
194 HDF_LOGE("%{public}s: Write tempType failed!", __func__);
195 return HDF_FAILURE;
196 }
197 if (buffers->type == BUFFER_TYPE_VIRTUAL) {
198 if (!HdfSbufWriteUint8(data, (uint8_t)&buffers->addr)) {
199 HDF_LOGE("%{public}s: Write addr failed!", __func__);
200 return HDF_FAILURE;
201 }
202 } else if (buffers->type == BUFFER_TYPE_FD) {
203 if (!HdfSbufWriteFileDescriptor(data, buffers->fd)) {
204 HDF_LOGE("%{public}s: Write fd failed!", __func__);
205 return HDF_FAILURE;
206 }
207 } else if (buffers->type == BUFFER_TYPE_HANDLE) {
208 if (CodecProxyPackBufferHandle(data, &buffers->handle)) {
209 HDF_LOGE("%{public}s: Write handle failed!", __func__);
210 return HDF_FAILURE;
211 }
212 } else {
213 HDF_LOGE("%{public}s: buffers->type is err!", __func__);
214 return HDF_FAILURE;
215 }
216 if (!HdfSbufWriteUint32(data, buffers->offset)) {
217 HDF_LOGE("%{public}s: Write offset failed!", __func__);
218 return HDF_FAILURE;
219 }
220 if (!HdfSbufWriteUint32(data, buffers->length)) {
221 HDF_LOGE("%{public}s: Write length failed!", __func__);
222 return HDF_FAILURE;
223 }
224 if (!HdfSbufWriteUint32(data, buffers->size)) {
225 HDF_LOGE("%{public}s: Write size failed!", __func__);
226 return HDF_FAILURE;
227 }
228 return HDF_SUCCESS;
229 }
230
CodecProxyPackInputInfo(struct HdfSBuf * data,const InputInfo * inputData)231 int32_t CodecProxyPackInputInfo(struct HdfSBuf *data, const InputInfo *inputData)
232 {
233 if (data == NULL || inputData == NULL || inputData->buffers == NULL) {
234 HDF_LOGE("%{public}s: params NULL!", __func__);
235 return HDF_ERR_INVALID_PARAM;
236 }
237 if (!HdfSbufWriteUint32(data, inputData->bufferCnt)) {
238 HDF_LOGE("%{public}s: Write bufferCnt failed!", __func__);
239 return HDF_FAILURE;
240 }
241 for (uint32_t i = 0; i < inputData->bufferCnt; i++) {
242 if (CodecProxyPackBufferInfo(data, &inputData->buffers[i])) {
243 HDF_LOGE("%{public}s: Write buffers failed!", __func__);
244 return HDF_FAILURE;
245 }
246 }
247 if (!HdfSbufWriteInt64(data, inputData->pts)) {
248 HDF_LOGE("%{public}s: Write pts failed!", __func__);
249 return HDF_FAILURE;
250 }
251 if (!HdfSbufWriteInt32(data, inputData->flag)) {
252 HDF_LOGE("%{public}s: Write flag failed!", __func__);
253 return HDF_FAILURE;
254 }
255 return HDF_SUCCESS;
256 }
257
CodecProxyParseBufferHandle(struct HdfSBuf * reply,CodecBufferHandle * bufferHandle)258 int32_t CodecProxyParseBufferHandle(struct HdfSBuf *reply, CodecBufferHandle *bufferHandle)
259 {
260 if (reply == NULL || bufferHandle == NULL) {
261 HDF_LOGE("%{public}s: params NULL!", __func__);
262 return HDF_ERR_INVALID_PARAM;
263 }
264 if (!HdfSbufReadUint8(reply, bufferHandle->virAddr)) {
265 HDF_LOGE("%{public}s: read virAddr failed!", __func__);
266 return HDF_FAILURE;
267 }
268 if (!HdfSbufReadUint32(reply, (uint32_t *)&bufferHandle->handle)) {
269 HDF_LOGE("%{public}s: read handle failed!", __func__);
270 return HDF_FAILURE;
271 }
272 return HDF_SUCCESS;
273 }
274
CodecProxyParseBufferInfo(struct HdfSBuf * reply,CodecBufferInfo * buffers)275 int32_t CodecProxyParseBufferInfo(struct HdfSBuf *reply, CodecBufferInfo *buffers)
276 {
277 uint32_t tempType = 0;
278 if (reply == NULL || buffers == NULL) {
279 HDF_LOGE("%{public}s: buffers null!", __func__);
280 return HDF_ERR_INVALID_PARAM;
281 }
282 if (!HdfSbufReadUint32(reply, &tempType)) {
283 HDF_LOGE("%{public}s: read type failed!", __func__);
284 return HDF_FAILURE;
285 }
286 buffers->type = (BufferType)tempType;
287 if (buffers->type == BUFFER_TYPE_VIRTUAL) {
288 if (!HdfSbufReadUint8(reply, buffers->addr)) {
289 HDF_LOGE("%{public}s: read addr failed!", __func__);
290 return HDF_FAILURE;
291 }
292 } else if (buffers->type == BUFFER_TYPE_FD) {
293 buffers->fd = HdfSbufReadFileDescriptor(reply);
294 if (buffers->fd < 0) {
295 HDF_LOGE("%{public}s: read fd failed!", __func__);
296 return HDF_FAILURE;
297 }
298 } else if (buffers->type == BUFFER_TYPE_HANDLE) {
299 if (CodecProxyParseBufferHandle(reply, &buffers->handle)) {
300 HDF_LOGE("%{public}s: read handle failed!", __func__);
301 return HDF_FAILURE;
302 }
303 }
304 if (!HdfSbufReadUint32(reply, &buffers->offset)) {
305 HDF_LOGE("%{public}s: read offset failed!", __func__);
306 return HDF_FAILURE;
307 }
308 if (!HdfSbufReadUint32(reply, &buffers->length)) {
309 HDF_LOGE("%{public}s: read length failed!", __func__);
310 return HDF_FAILURE;
311 }
312 if (!HdfSbufReadUint32(reply, &buffers->size)) {
313 HDF_LOGE("%{public}s: read size failed!", __func__);
314 return HDF_FAILURE;
315 }
316 return HDF_SUCCESS;
317 }
318
CodecProxyParseInputInfo(struct HdfSBuf * reply,InputInfo * inputData)319 int32_t CodecProxyParseInputInfo(struct HdfSBuf *reply, InputInfo *inputData)
320 {
321 if (reply == NULL || inputData == NULL || inputData->buffers == NULL) {
322 HDF_LOGE("%{public}s: params error!", __func__);
323 return HDF_ERR_INVALID_PARAM;
324 }
325 for (uint32_t i = 0; i < inputData->bufferCnt; i++) {
326 if (CodecProxyParseBufferInfo(reply, &inputData->buffers[i])) {
327 HDF_LOGE("%{public}s: read buffers failed!", __func__);
328 return HDF_FAILURE;
329 }
330 }
331 if (!HdfSbufReadInt64(reply, &inputData->pts)) {
332 HDF_LOGE("%{public}s: read pts failed!", __func__);
333 return HDF_FAILURE;
334 }
335 if (!HdfSbufReadInt32(reply, &inputData->flag)) {
336 HDF_LOGE("%{public}s: read flag failed!", __func__);
337 return HDF_FAILURE;
338 }
339 return HDF_SUCCESS;
340 }
341
CodecProxyParseOutputInfo(struct HdfSBuf * reply,OutputInfo * outInfo)342 int32_t CodecProxyParseOutputInfo(struct HdfSBuf *reply, OutputInfo *outInfo)
343 {
344 if (reply == NULL || outInfo == NULL || outInfo->buffers == NULL) {
345 HDF_LOGE("%{public}s: params error!", __func__);
346 return HDF_ERR_INVALID_PARAM;
347 }
348 for (uint32_t i = 0; i < outInfo->bufferCnt; i++) {
349 if (CodecProxyParseBufferInfo(reply, &outInfo->buffers[i])) {
350 HDF_LOGE("%{public}s: read buffers failed!", __func__);
351 return HDF_FAILURE;
352 }
353 }
354 if (!HdfSbufReadInt64(reply, &outInfo->timeStamp)) {
355 HDF_LOGE("%{public}s: read timeStamp failed!", __func__);
356 return HDF_FAILURE;
357 }
358 if (!HdfSbufReadUint32(reply, &outInfo->sequence)) {
359 HDF_LOGE("%{public}s: read sequence failed!", __func__);
360 return HDF_FAILURE;
361 }
362 if (!HdfSbufReadUint32(reply, &outInfo->flag)) {
363 HDF_LOGE("%{public}s: read flag failed!", __func__);
364 return HDF_FAILURE;
365 }
366 uint32_t tempType = 0;
367 if (!HdfSbufReadUint32(reply, &tempType)) {
368 HDF_LOGE("%{public}s: read tempType failed!", __func__);
369 return HDF_FAILURE;
370 }
371 outInfo->type = (CodecType)tempType;
372 if (!HdfSbufReadUint64(reply, (uint64_t *)&outInfo->vendorPrivate)) {
373 HDF_LOGE("%{public}s: read vendorPrivate failed!", __func__);
374 return HDF_FAILURE;
375 }
376 return HDF_SUCCESS;
377 }
378
CodecProxyPackOutputInfo(struct HdfSBuf * data,OutputInfo * outInfo)379 int32_t CodecProxyPackOutputInfo(struct HdfSBuf *data, OutputInfo *outInfo)
380 {
381 if (data == NULL || outInfo == NULL || outInfo->buffers == NULL) {
382 HDF_LOGE("%{public}s: params error!", __func__);
383 return HDF_ERR_INVALID_PARAM;
384 }
385 if (!HdfSbufWriteUint32(data, outInfo->bufferCnt)) {
386 HDF_LOGE("%{public}s: write bufferCnt failed!", __func__);
387 return HDF_FAILURE;
388 }
389 for (uint32_t i = 0; i < outInfo->bufferCnt; i++) {
390 if (CodecProxyPackBufferInfo(data, &outInfo->buffers[i])) {
391 HDF_LOGE("%{public}s: write buffers failed!", __func__);
392 return HDF_FAILURE;
393 }
394 }
395 if (!HdfSbufWriteInt64(data, outInfo->timeStamp)) {
396 HDF_LOGE("%{public}s: write timeStamp failed!", __func__);
397 return HDF_FAILURE;
398 }
399 if (!HdfSbufWriteUint32(data, outInfo->sequence)) {
400 HDF_LOGE("%{public}s: write sequence failed!", __func__);
401 return HDF_FAILURE;
402 }
403 if (!HdfSbufWriteUint32(data, outInfo->flag)) {
404 HDF_LOGE("%{public}s: write flag failed!", __func__);
405 return HDF_FAILURE;
406 }
407 if (!HdfSbufWriteUint32(data, outInfo->type)) {
408 HDF_LOGE("%{public}s: write outInfo->type failed!", __func__);
409 return HDF_FAILURE;
410 }
411 if (!HdfSbufWriteUint64(data, (uint64_t)&outInfo->vendorPrivate)) {
412 HDF_LOGE("%{public}s: write vendorPrivate failed!", __func__);
413 return HDF_FAILURE;
414 }
415 return HDF_SUCCESS;
416 }
417
418 #ifdef __cplusplus
419 }
420 #endif /* __cplusplus */