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