1 /*
2 * Copyright (c) 2022-2023 Shenzhen Kaihong DID 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 "codec_component_type_stub.h"
17 #include <dlfcn.h>
18 #include <hdf_device_desc.h>
19 #include <hdf_device_object.h>
20 #include <osal_mem.h>
21 #include <securec.h>
22 #include "codec_callback_if.h"
23 #include "codec_component_capability_config.h"
24 #include "codec_util.h"
25 #include "codec_log_wrapper.h"
26
FreeMem(int8_t * mem,uint32_t memLen)27 static void FreeMem(int8_t *mem, uint32_t memLen)
28 {
29 if (memLen > 0 && mem != NULL) {
30 OsalMemFree(mem);
31 }
32 }
33
SerStubGetComponentVersion(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)34 static int32_t SerStubGetComponentVersion(struct CodecComponentType *serviceImpl, struct HdfSBuf *data,
35 struct HdfSBuf *reply)
36 {
37 int32_t ret;
38 struct CompVerInfo verInfo;
39 ret = memset_s(&verInfo, sizeof(verInfo), 0, sizeof(verInfo));
40 if (ret != EOK) {
41 CODEC_LOGE("memset_s verInfo err [%{public}d].", ret);
42 return ret;
43 }
44 ret = serviceImpl->GetComponentVersion(serviceImpl, &verInfo);
45 if (ret != HDF_SUCCESS) {
46 CODEC_LOGE("call GetComponentVersion function failed!");
47 return ret;
48 }
49 if (!HdfSbufWriteUnpadBuffer(reply, (const uint8_t *)&verInfo, sizeof(struct CompVerInfo))) {
50 CODEC_LOGE("write verInfo failed!");
51 return HDF_ERR_INVALID_PARAM;
52 }
53
54 return HDF_SUCCESS;
55 }
56
SerStubSendCommand(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)57 static int32_t SerStubSendCommand(struct CodecComponentType *serviceImpl, struct HdfSBuf *data, struct HdfSBuf *reply)
58 {
59 int32_t ret;
60 enum OMX_COMMANDTYPE cmd;
61 uint32_t param = 0;
62 int8_t *cmdData = NULL;
63 uint32_t cmdDataLen = 0;
64
65 if (!HdfSbufReadUint32(data, (uint32_t*)&cmd)) {
66 CODEC_LOGE("read &cmd failed!");
67 return HDF_ERR_INVALID_PARAM;
68 }
69
70 if (!HdfSbufReadUint32(data, ¶m)) {
71 CODEC_LOGE("read ¶m failed!");
72 return HDF_ERR_INVALID_PARAM;
73 }
74
75 if (!HdfSbufReadUint32(data, &cmdDataLen)) {
76 CODEC_LOGE("read cmdData size failed!");
77 return HDF_ERR_INVALID_PARAM;
78 }
79
80 if (cmdDataLen > 0) {
81 cmdData = (int8_t*)OsalMemCalloc(sizeof(int8_t) * (cmdDataLen));
82 if (cmdData == NULL) {
83 CODEC_LOGE("HDF_ERR_MALLOC_FAIL!");
84 return HDF_ERR_MALLOC_FAIL;
85 }
86
87 for (uint32_t i = 0; i < cmdDataLen; i++) {
88 if (!HdfSbufReadInt8(data, &cmdData[i])) {
89 CODEC_LOGE("read &cmdData[i] failed!");
90 FreeMem(cmdData, cmdDataLen);
91 return HDF_ERR_INVALID_PARAM;
92 }
93 }
94 }
95
96 ret = serviceImpl->SendCommand(serviceImpl, cmd, param, cmdData, cmdDataLen);
97 if (ret != HDF_SUCCESS) {
98 CODEC_LOGE("call SendCommand function failed!");
99 FreeMem(cmdData, cmdDataLen);
100 return ret;
101 }
102
103 FreeMem(cmdData, cmdDataLen);
104 #ifdef CONFIG_USE_JEMALLOC_DFX_INTF
105 ReleaseCodecCache();
106 #endif
107 return HDF_SUCCESS;
108 }
109
SerStubGetParameter(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)110 static int32_t SerStubGetParameter(struct CodecComponentType *serviceImpl, struct HdfSBuf *data, struct HdfSBuf *reply)
111 {
112 int32_t ret;
113 uint32_t paramIndex = 0;
114 int8_t *paramStruct = NULL;
115 uint32_t paramStructLen = 0;
116
117 if (!HdfSbufReadUint32(data, ¶mIndex)) {
118 CODEC_LOGE("read paramIndex failed!");
119 return HDF_ERR_INVALID_PARAM;
120 }
121
122 if (!HdfSbufReadUint32(data, ¶mStructLen)) {
123 CODEC_LOGE("read paramStructLen failed!");
124 return HDF_ERR_INVALID_PARAM;
125 }
126 paramStruct = (int8_t*)OsalMemCalloc(sizeof(int8_t) * (paramStructLen));
127 if (paramStruct == NULL) {
128 CODEC_LOGE("HDF_ERR_MALLOC_FAIL!");
129 return HDF_ERR_MALLOC_FAIL;
130 }
131
132 for (uint32_t i = 0; i < paramStructLen; i++) {
133 if (!HdfSbufReadInt8(data, ¶mStruct[i])) {
134 CODEC_LOGE("read paramStruct[%{public}d] failed!", i);
135 FreeMem(paramStruct, paramStructLen);
136 return HDF_ERR_INVALID_PARAM;
137 }
138 }
139
140 ret = serviceImpl->GetParameter(serviceImpl, paramIndex, paramStruct, paramStructLen);
141 if (ret != HDF_SUCCESS) {
142 CODEC_LOGE("call GetParameter function failed!");
143 FreeMem(paramStruct, paramStructLen);
144 return ret;
145 }
146
147 for (uint32_t i = 0; i < paramStructLen; i++) {
148 if (!HdfSbufWriteInt8(reply, paramStruct[i])) {
149 CODEC_LOGE("write paramStruct[i] failed!");
150 FreeMem(paramStruct, paramStructLen);
151 return HDF_ERR_INVALID_PARAM;
152 }
153 }
154
155 FreeMem(paramStruct, paramStructLen);
156 #ifdef CONFIG_USE_JEMALLOC_DFX_INTF
157 ReleaseCodecCache();
158 #endif
159 return HDF_SUCCESS;
160 }
161
SerStubSetParameter(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)162 static int32_t SerStubSetParameter(struct CodecComponentType *serviceImpl, struct HdfSBuf *data, struct HdfSBuf *reply)
163 {
164 int32_t ret;
165 uint32_t index = 0;
166 int8_t *paramStruct = NULL;
167 uint32_t paramStructLen = 0;
168
169 if (!HdfSbufReadUint32(data, &index)) {
170 CODEC_LOGE("read &index failed!");
171 return HDF_ERR_INVALID_PARAM;
172 }
173
174 if (!HdfSbufReadUint32(data, ¶mStructLen)) {
175 CODEC_LOGE("read paramStruct size failed!");
176 return HDF_ERR_INVALID_PARAM;
177 }
178
179 if (paramStructLen > 0) {
180 paramStruct = (int8_t*)OsalMemCalloc(sizeof(int8_t) * (paramStructLen));
181 if (paramStruct == NULL) {
182 CODEC_LOGE("HDF_ERR_MALLOC_FAIL!");
183 return HDF_ERR_MALLOC_FAIL;
184 }
185
186 for (uint32_t i = 0; i < paramStructLen; i++) {
187 if (!HdfSbufReadInt8(data, ¶mStruct[i])) {
188 CODEC_LOGE("read ¶mStruct[i] failed!");
189 FreeMem(paramStruct, paramStructLen);
190 return HDF_ERR_INVALID_PARAM;
191 }
192 }
193 }
194
195 ret = serviceImpl->SetParameter(serviceImpl, index, paramStruct, paramStructLen);
196 if (ret != HDF_SUCCESS) {
197 CODEC_LOGE("call SetParameter function failed!");
198 FreeMem(paramStruct, paramStructLen);
199 return ret;
200 }
201
202 FreeMem(paramStruct, paramStructLen);
203 #ifdef CONFIG_USE_JEMALLOC_DFX_INTF
204 ReleaseCodecCache();
205 #endif
206 return HDF_SUCCESS;
207 }
208
SerStubGetConfig(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)209 static int32_t SerStubGetConfig(struct CodecComponentType *serviceImpl, struct HdfSBuf *data, struct HdfSBuf *reply)
210 {
211 int32_t ret;
212 uint32_t index = 0;
213 int8_t *cfgStruct = NULL;
214 uint32_t cfgStructLen = 0;
215
216 if (!HdfSbufReadUint32(data, &index)) {
217 CODEC_LOGE("read &index failed!");
218 return HDF_ERR_INVALID_PARAM;
219 }
220
221 if (!HdfSbufReadUint32(data, &cfgStructLen)) {
222 CODEC_LOGE("read cfgStructLen failed!");
223 return HDF_ERR_INVALID_PARAM;
224 }
225 cfgStruct = (int8_t*)OsalMemCalloc(sizeof(int8_t) * (cfgStructLen));
226 if (cfgStruct == NULL) {
227 CODEC_LOGE("HDF_ERR_MALLOC_FAIL!");
228 return HDF_ERR_MALLOC_FAIL;
229 }
230
231 for (uint32_t i = 0; i < cfgStructLen; i++) {
232 if (!HdfSbufReadInt8(data, &cfgStruct[i])) {
233 CODEC_LOGE("read cfgStruct[i] failed!");
234 FreeMem(cfgStruct, cfgStructLen);
235 return HDF_ERR_INVALID_PARAM;
236 }
237 }
238
239 ret = serviceImpl->GetConfig(serviceImpl, index, cfgStruct, cfgStructLen);
240 if (ret != HDF_SUCCESS) {
241 CODEC_LOGE("call GetConfig function failed!");
242 FreeMem(cfgStruct, cfgStructLen);
243 return ret;
244 }
245
246 for (uint32_t i = 0; i < cfgStructLen; i++) {
247 if (!HdfSbufWriteInt8(reply, cfgStruct[i])) {
248 CODEC_LOGE("write cfgStruct[i] failed!");
249 FreeMem(cfgStruct, cfgStructLen);
250 return HDF_ERR_INVALID_PARAM;
251 }
252 }
253
254 FreeMem(cfgStruct, cfgStructLen);
255 #ifdef CONFIG_USE_JEMALLOC_DFX_INTF
256 ReleaseCodecCache();
257 #endif
258 return ret;
259 }
260
SerStubSetConfig(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)261 static int32_t SerStubSetConfig(struct CodecComponentType *serviceImpl, struct HdfSBuf *data, struct HdfSBuf *reply)
262 {
263 int32_t ret;
264 uint32_t index = 0;
265 int8_t *cfgStruct = NULL;
266 uint32_t cfgStructLen = 0;
267
268 if (!HdfSbufReadUint32(data, &index)) {
269 CODEC_LOGE("read &index failed!");
270 return HDF_ERR_INVALID_PARAM;
271 }
272
273 if (!HdfSbufReadUint32(data, &cfgStructLen)) {
274 CODEC_LOGE("read cfgStruct size failed!");
275 return HDF_ERR_INVALID_PARAM;
276 }
277
278 if (cfgStructLen > 0) {
279 cfgStruct = (int8_t*)OsalMemCalloc(sizeof(int8_t) * (cfgStructLen));
280 if (cfgStruct == NULL) {
281 CODEC_LOGE("HDF_ERR_MALLOC_FAIL!");
282 return HDF_ERR_MALLOC_FAIL;
283 }
284
285 for (uint32_t i = 0; i < cfgStructLen; i++) {
286 if (!HdfSbufReadInt8(data, &cfgStruct[i])) {
287 CODEC_LOGE("read &cfgStruct[i] failed!");
288 FreeMem(cfgStruct, cfgStructLen);
289 return HDF_ERR_INVALID_PARAM;
290 }
291 }
292 }
293
294 ret = serviceImpl->SetConfig(serviceImpl, index, cfgStruct, cfgStructLen);
295 if (ret != HDF_SUCCESS) {
296 CODEC_LOGE("call SetConfig function failed!");
297 FreeMem(cfgStruct, cfgStructLen);
298 return ret;
299 }
300
301 FreeMem(cfgStruct, cfgStructLen);
302 #ifdef CONFIG_USE_JEMALLOC_DFX_INTF
303 ReleaseCodecCache();
304 #endif
305 return ret;
306 }
307
SerStubGetExtensionIndex(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)308 static int32_t SerStubGetExtensionIndex(struct CodecComponentType *serviceImpl, struct HdfSBuf *data,
309 struct HdfSBuf *reply)
310 {
311 int32_t ret;
312 char *paramName = NULL;
313 uint32_t indexType = 0;
314
315 const char *paramNameCp = HdfSbufReadString(data);
316 if (paramNameCp == NULL) {
317 CODEC_LOGE("read paramNameCp failed!");
318 return HDF_ERR_INVALID_PARAM;
319 }
320 paramName = strdup(paramNameCp);
321
322 ret = serviceImpl->GetExtensionIndex(serviceImpl, paramName, &indexType);
323 if (paramName != NULL) {
324 OsalMemFree(paramName);
325 paramName = NULL;
326 }
327 if (ret != HDF_SUCCESS) {
328 CODEC_LOGE("call GetExtensionIndex function failed!");
329 return ret;
330 }
331
332 if (!HdfSbufWriteUint32(reply, indexType)) {
333 CODEC_LOGE("write indexType failed!");
334 ret = HDF_ERR_INVALID_PARAM;
335 }
336
337 return ret;
338 }
339
SerStubGetState(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)340 static int32_t SerStubGetState(struct CodecComponentType *serviceImpl, struct HdfSBuf *data, struct HdfSBuf *reply)
341 {
342 int32_t ret;
343 enum OMX_STATETYPE state;
344
345 ret = serviceImpl->GetState(serviceImpl, &state);
346 if (ret != HDF_SUCCESS) {
347 CODEC_LOGE("call GetState function failed!");
348 return ret;
349 }
350
351 if (!HdfSbufWriteUint32(reply, (uint32_t)state)) {
352 CODEC_LOGE("write state failed!");
353 return HDF_ERR_INVALID_PARAM;
354 }
355
356 return ret;
357 }
358
SerStubComponentTunnelRequest(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)359 static int32_t SerStubComponentTunnelRequest(struct CodecComponentType *serviceImpl, struct HdfSBuf *data,
360 struct HdfSBuf *reply)
361 {
362 int32_t ret;
363 uint32_t port = 0;
364 int32_t tunneledComp = 0;
365 uint32_t tunneledPort = 0;
366 struct OMX_TUNNELSETUPTYPE tunnelSetup;
367
368 if (!HdfSbufReadUint32(data, &port)) {
369 CODEC_LOGE("read &port failed!");
370 return HDF_ERR_INVALID_PARAM;
371 }
372
373 if (!HdfSbufReadInt32(data, &tunneledComp)) {
374 CODEC_LOGE("read &tunneledComp failed!");
375 return HDF_ERR_INVALID_PARAM;
376 }
377
378 if (!HdfSbufReadUint32(data, &tunneledPort)) {
379 CODEC_LOGE("read &tunneledPort failed!");
380 return HDF_ERR_INVALID_PARAM;
381 }
382
383 if (!OMX_TUNNELSETUPTYPEBlockUnmarshalling(data, &tunnelSetup)) {
384 CODEC_LOGE("read tunnelSetup failed!");
385 return HDF_ERR_INVALID_PARAM;
386 }
387
388 ret = serviceImpl->ComponentTunnelRequest(serviceImpl, port, tunneledComp, tunneledPort, &tunnelSetup);
389 if (ret != HDF_SUCCESS) {
390 CODEC_LOGE("call ComponentTunnelRequest function failed!");
391 return ret;
392 }
393
394 if (!OMX_TUNNELSETUPTYPEBlockMarshalling(reply, &tunnelSetup)) {
395 CODEC_LOGE("write tunnelSetup failed!");
396 return HDF_ERR_INVALID_PARAM;
397 }
398
399 return ret;
400 }
401
SerStubUseBuffer(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)402 static int32_t SerStubUseBuffer(struct CodecComponentType *serviceImpl, struct HdfSBuf *data, struct HdfSBuf *reply)
403 {
404 int32_t ret;
405 struct OmxCodecBuffer buffer;
406 uint32_t portIndex = 0;
407 InitOmxCodecBuffer(&buffer);
408
409 if (!HdfSbufReadUint32(data, &portIndex)) {
410 CODEC_LOGE("read &portIndex failed!");
411 return HDF_ERR_INVALID_PARAM;
412 }
413
414 if (!OmxCodecBufferBlockUnmarshalling(data, &buffer)) {
415 CODEC_LOGE("read buffer failed!");
416 ReleaseOmxCodecBuffer(&buffer);
417 return HDF_ERR_INVALID_PARAM;
418 }
419
420 ret = serviceImpl->UseBuffer(serviceImpl, portIndex, &buffer);
421 if (ret != HDF_SUCCESS) {
422 CODEC_LOGE("call UseBuffer function failed!");
423 ReleaseOmxCodecBuffer(&buffer);
424 return ret;
425 }
426
427 if (!OmxCodecBufferBlockMarshalling(reply, &buffer)) {
428 CODEC_LOGE("write buffer failed!");
429 ReleaseOmxCodecBuffer(&buffer);
430 return HDF_ERR_INVALID_PARAM;
431 }
432 ReleaseOmxCodecBuffer(&buffer);
433 #ifdef CONFIG_USE_JEMALLOC_DFX_INTF
434 ReleaseCodecCache();
435 #endif
436 return ret;
437 }
438
SerStubAllocateBuffer(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)439 static int32_t SerStubAllocateBuffer(struct CodecComponentType *serviceImpl, struct HdfSBuf *data,
440 struct HdfSBuf *reply)
441 {
442 int32_t ret;
443 struct OmxCodecBuffer buffer;
444 uint32_t portIndex = 0;
445 InitOmxCodecBuffer(&buffer);
446
447 if (!HdfSbufReadUint32(data, &portIndex)) {
448 CODEC_LOGE("read &portIndex failed!");
449 return HDF_ERR_INVALID_PARAM;
450 }
451
452 if (!OmxCodecBufferBlockUnmarshalling(data, &buffer)) {
453 CODEC_LOGE("read buffer failed!");
454 ReleaseOmxCodecBuffer(&buffer);
455 return HDF_ERR_INVALID_PARAM;
456 }
457
458 ret = serviceImpl->AllocateBuffer(serviceImpl, portIndex, &buffer);
459 if (ret != HDF_SUCCESS) {
460 CODEC_LOGE("call AllocateBuffer function failed!");
461 ReleaseOmxCodecBuffer(&buffer);
462 return ret;
463 }
464
465 if (!OmxCodecBufferBlockMarshalling(reply, &buffer)) {
466 CODEC_LOGE("write buffer failed!");
467 ReleaseOmxCodecBuffer(&buffer);
468 return HDF_ERR_INVALID_PARAM;
469 }
470 ReleaseOmxCodecBuffer(&buffer);
471 return ret;
472 }
473
SerStubFreeBuffer(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)474 static int32_t SerStubFreeBuffer(struct CodecComponentType *serviceImpl, struct HdfSBuf *data, struct HdfSBuf *reply)
475 {
476 int32_t ret;
477 uint32_t portIndex = 0;
478 struct OmxCodecBuffer buffer;
479 InitOmxCodecBuffer(&buffer);
480 if (!HdfSbufReadUint32(data, &portIndex)) {
481 CODEC_LOGE("read &portIndex failed!");
482 return HDF_ERR_INVALID_PARAM;
483 }
484
485 if (!OmxCodecBufferBlockUnmarshalling(data, &buffer)) {
486 CODEC_LOGE("read buffer failed!");
487 ReleaseOmxCodecBuffer(&buffer);
488 return HDF_ERR_INVALID_PARAM;
489 }
490
491 ret = serviceImpl->FreeBuffer(serviceImpl, portIndex, &buffer);
492 if (ret != HDF_SUCCESS) {
493 CODEC_LOGE("call FreeBuffer function failed!");
494 ReleaseOmxCodecBuffer(&buffer);
495 return ret;
496 }
497 ReleaseOmxCodecBuffer(&buffer);
498 #ifdef CONFIG_USE_JEMALLOC_DFX_INTF
499 ReleaseCodecCache();
500 #endif
501 return ret;
502 }
503
SerStubEmptyThisBuffer(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)504 static int32_t SerStubEmptyThisBuffer(struct CodecComponentType *serviceImpl, struct HdfSBuf *data,
505 struct HdfSBuf *reply)
506 {
507 int32_t ret;
508 struct OmxCodecBuffer buffer;
509 InitOmxCodecBuffer(&buffer);
510 if (!OmxCodecBufferBlockUnmarshalling(data, &buffer)) {
511 CODEC_LOGE("read buffer failed!");
512 ReleaseOmxCodecBuffer(&buffer);
513 return HDF_ERR_INVALID_PARAM;
514 }
515
516 ret = serviceImpl->EmptyThisBuffer(serviceImpl, &buffer);
517 if (ret != HDF_SUCCESS) {
518 CODEC_LOGE("call EmptyThisBuffer function failed!");
519 ReleaseOmxCodecBuffer(&buffer);
520 return ret;
521 }
522 ReleaseOmxCodecBuffer(&buffer);
523 #ifdef CONFIG_USE_JEMALLOC_DFX_INTF
524 ReleaseCodecCache();
525 #endif
526 return ret;
527 }
528
SerStubFillThisBuffer(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)529 static int32_t SerStubFillThisBuffer(struct CodecComponentType *serviceImpl, struct HdfSBuf *data,
530 struct HdfSBuf *reply)
531 {
532 int32_t ret;
533 struct OmxCodecBuffer buffer;
534 InitOmxCodecBuffer(&buffer);
535 if (!OmxCodecBufferBlockUnmarshalling(data, &buffer)) {
536 CODEC_LOGE("read buffer failed!");
537 ReleaseOmxCodecBuffer(&buffer);
538 return HDF_ERR_INVALID_PARAM;
539 }
540
541 ret = serviceImpl->FillThisBuffer(serviceImpl, &buffer);
542 if (ret != HDF_SUCCESS) {
543 CODEC_LOGE("call FillThisBuffer function failed!");
544 ReleaseOmxCodecBuffer(&buffer);
545 return ret;
546 }
547 ReleaseOmxCodecBuffer(&buffer);
548 #ifdef CONFIG_USE_JEMALLOC_DFX_INTF
549 ReleaseCodecCache();
550 #endif
551 return ret;
552 }
553
SerStubSetCallbacks(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)554 static int32_t SerStubSetCallbacks(struct CodecComponentType *serviceImpl, struct HdfSBuf *data, struct HdfSBuf *reply)
555 {
556 int32_t ret;
557 struct CodecCallbackType *callback = NULL;
558 int64_t appData = 0;
559
560 struct HdfRemoteService *callbackRemote = HdfSbufReadRemoteService(data);
561 if (callbackRemote == NULL) {
562 CODEC_LOGE("read callbackRemote failed!");
563 return HDF_ERR_INVALID_PARAM;
564 }
565 callback = CodecCallbackTypeGet(callbackRemote);
566
567 if (!HdfSbufReadInt64(data, &appData)) {
568 CODEC_LOGE("read appData size failed!");
569 return HDF_ERR_INVALID_PARAM;
570 }
571
572 ret = serviceImpl->SetCallbacks(serviceImpl, callback, appData);
573 if (ret != HDF_SUCCESS) {
574 CODEC_LOGE("call SetCallbacks function failed!");
575 return ret;
576 }
577 return ret;
578 }
579
SerStubComponentDeInit(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)580 static int32_t SerStubComponentDeInit(struct CodecComponentType *serviceImpl, struct HdfSBuf *data,
581 struct HdfSBuf *reply)
582 {
583 int32_t ret;
584
585 ret = serviceImpl->ComponentDeInit(serviceImpl);
586 if (ret != HDF_SUCCESS) {
587 CODEC_LOGE("call ComponentDeInit function failed!");
588 }
589
590 return ret;
591 }
592
SerStubUseEglImage(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)593 static int32_t SerStubUseEglImage(struct CodecComponentType *serviceImpl, struct HdfSBuf *data, struct HdfSBuf *reply)
594 {
595 int32_t ret;
596 struct OmxCodecBuffer buffer;
597 uint32_t portIndex = 0;
598 int8_t *eglImage = NULL;
599 uint32_t eglImageLen = 0;
600
601 if (!OmxCodecBufferBlockUnmarshalling(data, &buffer)) {
602 CODEC_LOGE("read buffer failed!");
603 return HDF_ERR_INVALID_PARAM;
604 }
605
606 if (!HdfSbufReadUint32(data, &portIndex)) {
607 CODEC_LOGE("read &portIndex failed!");
608 return HDF_ERR_INVALID_PARAM;
609 }
610
611 if (!HdfSbufReadUint32(data, &eglImageLen)) {
612 CODEC_LOGE("read eglImage size failed!");
613 return HDF_ERR_INVALID_PARAM;
614 }
615
616 if (eglImageLen > 0) {
617 eglImage = (int8_t*)OsalMemCalloc(sizeof(int8_t) * (eglImageLen));
618 if (eglImage == NULL) {
619 CODEC_LOGE("HDF_ERR_MALLOC_FAIL!");
620 return HDF_ERR_MALLOC_FAIL;
621 }
622
623 for (uint32_t i = 0; i < eglImageLen; i++) {
624 if (!HdfSbufReadInt8(data, &eglImage[i])) {
625 CODEC_LOGE("read &eglImage[i] failed!");
626 FreeMem(eglImage, eglImageLen);
627 return HDF_ERR_INVALID_PARAM;
628 }
629 }
630 }
631
632 ret = serviceImpl->UseEglImage(serviceImpl, &buffer, portIndex, eglImage, eglImageLen);
633 if (ret != HDF_SUCCESS) {
634 CODEC_LOGE("call UseEglImage function failed!");
635 FreeMem(eglImage, eglImageLen);
636 return ret;
637 }
638
639 if (!OmxCodecBufferBlockMarshalling(reply, &buffer)) {
640 CODEC_LOGE("write buffer failed!");
641 FreeMem(eglImage, eglImageLen);
642 return HDF_ERR_INVALID_PARAM;
643 }
644
645 FreeMem(eglImage, eglImageLen);
646 return ret;
647 }
648
SerStubComponentRoleEnum(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)649 static int32_t SerStubComponentRoleEnum(struct CodecComponentType *serviceImpl, struct HdfSBuf *data,
650 struct HdfSBuf *reply)
651 {
652 int32_t ret;
653 uint8_t *role = NULL;
654 uint32_t roleLen = 0;
655 uint32_t index = 0;
656
657 if (!HdfSbufReadUint32(data, &roleLen)) {
658 CODEC_LOGE("read &roleLen failed!");
659 return HDF_ERR_INVALID_PARAM;
660 }
661
662 role = (uint8_t*)OsalMemCalloc(sizeof(uint8_t) * (roleLen));
663 if (role == NULL) {
664 CODEC_LOGE("HDF_ERR_MALLOC_FAIL!");
665 return HDF_ERR_MALLOC_FAIL;
666 }
667
668 if (!HdfSbufReadUint32(data, &index)) {
669 CODEC_LOGE("read &index failed!");
670 FreeMem((int8_t*)role, roleLen);
671 return HDF_ERR_INVALID_PARAM;
672 }
673
674 ret = serviceImpl->ComponentRoleEnum(serviceImpl, role, roleLen, index);
675 if (ret != HDF_SUCCESS) {
676 CODEC_LOGE("call ComponentRoleEnum function failed!");
677 FreeMem((int8_t*)role, roleLen);
678 return ret;
679 }
680
681 for (uint32_t i = 0; i < roleLen; i++) {
682 if (!HdfSbufWriteUint8(reply, role[i])) {
683 CODEC_LOGE("write role[i] failed!");
684 FreeMem((int8_t*)role, roleLen);
685 return HDF_ERR_INVALID_PARAM;
686 }
687 }
688
689 FreeMem((int8_t*)role, roleLen);
690 return ret;
691 }
692
CodecComponentTypeServiceOnRemoteRequest(struct HdfRemoteService * remote,int32_t cmdId,struct HdfSBuf * data,struct HdfSBuf * reply)693 static int32_t CodecComponentTypeServiceOnRemoteRequest(struct HdfRemoteService *remote,
694 int32_t cmdId, struct HdfSBuf *data, struct HdfSBuf *reply)
695 {
696 struct CodecComponentType *serviceImpl = (struct CodecComponentType *)remote;
697 if (!HdfRemoteServiceCheckInterfaceToken(serviceImpl->AsObject(serviceImpl), data)) {
698 CODEC_LOGE("interface token check failed");
699 return HDF_ERR_INVALID_PARAM;
700 }
701
702 switch (cmdId) {
703 case CMD_GET_COMPONENT_VERSION:
704 return SerStubGetComponentVersion(serviceImpl, data, reply);
705 case CMD_SEND_COMMAND:
706 return SerStubSendCommand(serviceImpl, data, reply);
707 case CMD_GET_PARAMETER:
708 return SerStubGetParameter(serviceImpl, data, reply);
709 case CMD_SET_PARAMETER:
710 return SerStubSetParameter(serviceImpl, data, reply);
711 case CMD_GET_CONFIG:
712 return SerStubGetConfig(serviceImpl, data, reply);
713 case CMD_SET_CONFIG:
714 return SerStubSetConfig(serviceImpl, data, reply);
715 case CMD_GET_EXTENSION_INDEX:
716 return SerStubGetExtensionIndex(serviceImpl, data, reply);
717 case CMD_GET_STATE:
718 return SerStubGetState(serviceImpl, data, reply);
719 case CMD_COMPONENT_TUNNEL_REQUEST:
720 return SerStubComponentTunnelRequest(serviceImpl, data, reply);
721 case CMD_USE_BUFFER:
722 return SerStubUseBuffer(serviceImpl, data, reply);
723 case CMD_ALLOCATE_BUFFER:
724 return SerStubAllocateBuffer(serviceImpl, data, reply);
725 case CMD_FREE_BUFFER:
726 return SerStubFreeBuffer(serviceImpl, data, reply);
727 case CMD_EMPTY_THIS_BUFFER:
728 return SerStubEmptyThisBuffer(serviceImpl, data, reply);
729 case CMD_FILL_THIS_BUFFER:
730 return SerStubFillThisBuffer(serviceImpl, data, reply);
731 case CMD_SET_CALLBACKS:
732 return SerStubSetCallbacks(serviceImpl, data, reply);
733 case CMD_COMPONENT_DE_INIT:
734 return SerStubComponentDeInit(serviceImpl, data, reply);
735 case CMD_USE_EGL_IMAGE:
736 return SerStubUseEglImage(serviceImpl, data, reply);
737 case CMD_COMPONENT_ROLE_ENUM:
738 return SerStubComponentRoleEnum(serviceImpl, data, reply);
739 default:
740 CODEC_LOGE("not support cmd %{public}d", cmdId);
741 return HDF_ERR_INVALID_PARAM;
742 }
743 }
744
CodecComponentTypeAsObject(struct CodecComponentType * self)745 static struct HdfRemoteService *CodecComponentTypeAsObject(struct CodecComponentType *self)
746 {
747 if (self == NULL) {
748 return NULL;
749 }
750 struct CodecComponentTypeStub *stub = CONTAINER_OF(self, struct CodecComponentTypeStub, interface);
751 return stub->remote;
752 }
753
CodecComponentTypeStubConstruct(struct CodecComponentTypeStub * stub)754 bool CodecComponentTypeStubConstruct(struct CodecComponentTypeStub *stub)
755 {
756 if (stub == NULL) {
757 CODEC_LOGE("stub is null!");
758 return false;
759 }
760
761 stub->dispatcher.Dispatch = CodecComponentTypeServiceOnRemoteRequest;
762 stub->remote = HdfRemoteServiceObtain((struct HdfObject *)stub, &(stub->dispatcher));
763 if (stub->remote == NULL) {
764 CODEC_LOGE("stub->remote is null");
765 return false;
766 }
767
768 if (!HdfRemoteServiceSetInterfaceDesc(stub->remote, CODEC_COMPONENT_INTERFACE_DESC)) {
769 CODEC_LOGE("failed to set remote service interface descriptor");
770 CodecComponentTypeStubRelease(stub);
771 return false;
772 }
773
774 stub->interface.AsObject = CodecComponentTypeAsObject;
775 return true;
776 }
777
CodecComponentTypeStubRelease(struct CodecComponentTypeStub * stub)778 void CodecComponentTypeStubRelease(struct CodecComponentTypeStub *stub)
779 {
780 if (stub == NULL) {
781 return;
782 }
783 if (stub->remote != NULL) {
784 HdfRemoteServiceRecycle(stub->remote);
785 stub->remote = NULL;
786 }
787 }
788