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, &param)) {
79         CODEC_LOGE("read &param 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, &paramIndex)) {
130         CODEC_LOGE("read paramIndex failed!");
131         return HDF_ERR_INVALID_PARAM;
132     }
133 
134     if (!HdfSbufReadUint32(data, &paramStructLen)) {
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, &paramStruct[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, &paramStructLen)) {
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, &paramStruct[i])) {
204                 CODEC_LOGE("read &paramStruct[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         CodecCallbackTypeRelease(callback);
630         return HDF_ERR_INVALID_PARAM;
631     }
632 
633     ret = serviceImpl->SetCallbacks(serviceImpl, callback, appData);
634     if (ret != HDF_SUCCESS) {
635         CODEC_LOGE("call SetCallbacks function failed!");
636         return ret;
637     }
638     return ret;
639 }
640 
SerStubComponentDeInit(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)641 static int32_t SerStubComponentDeInit(struct CodecComponentType *serviceImpl, struct HdfSBuf *data,
642                                       struct HdfSBuf *reply)
643 {
644     if (serviceImpl == NULL) {
645         CODEC_LOGE("invalid parameter");
646         return HDF_ERR_INVALID_PARAM;
647     }
648     int32_t ret;
649 
650     ret = serviceImpl->ComponentDeInit(serviceImpl);
651     if (ret != HDF_SUCCESS) {
652         CODEC_LOGE("call ComponentDeInit function failed!");
653     }
654 
655     return ret;
656 }
657 
SerStubUseEglImage(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)658 static int32_t SerStubUseEglImage(struct CodecComponentType *serviceImpl, struct HdfSBuf *data, struct HdfSBuf *reply)
659 {
660     if (serviceImpl == NULL) {
661         CODEC_LOGE("invalid parameter");
662         return HDF_ERR_INVALID_PARAM;
663     }
664     int32_t ret;
665     struct OmxCodecBuffer buffer;
666     uint32_t portIndex = 0;
667     int8_t *eglImage = NULL;
668     uint32_t eglImageLen = 0;
669 
670     if (!OmxCodecBufferBlockUnmarshalling(data, &buffer)) {
671         CODEC_LOGE("read buffer failed!");
672         return HDF_ERR_INVALID_PARAM;
673     }
674 
675     if (!HdfSbufReadUint32(data, &portIndex)) {
676         CODEC_LOGE("read &portIndex failed!");
677         return HDF_ERR_INVALID_PARAM;
678     }
679 
680     if (!HdfSbufReadUint32(data, &eglImageLen)) {
681         CODEC_LOGE("read eglImage size failed!");
682         return HDF_ERR_INVALID_PARAM;
683     }
684 
685     if (eglImageLen > 0) {
686         eglImage = (int8_t*)OsalMemCalloc(sizeof(int8_t) * (eglImageLen));
687         if (eglImage == NULL) {
688             CODEC_LOGE("HDF_ERR_MALLOC_FAIL!");
689             return HDF_ERR_MALLOC_FAIL;
690         }
691 
692         for (uint32_t i = 0; i < eglImageLen; i++) {
693             if (!HdfSbufReadInt8(data, &eglImage[i])) {
694                 CODEC_LOGE("read &eglImage[i] failed!");
695                 FreeMem(eglImage, eglImageLen);
696                 return HDF_ERR_INVALID_PARAM;
697             }
698         }
699     }
700 
701     ret = serviceImpl->UseEglImage(serviceImpl, &buffer, portIndex, eglImage, eglImageLen);
702     if (ret != HDF_SUCCESS) {
703         CODEC_LOGE("call UseEglImage function failed!");
704         FreeMem(eglImage, eglImageLen);
705         return ret;
706     }
707 
708     if (!OmxCodecBufferBlockMarshalling(reply, &buffer)) {
709         CODEC_LOGE("write buffer failed!");
710         FreeMem(eglImage, eglImageLen);
711         return HDF_ERR_INVALID_PARAM;
712     }
713 
714     FreeMem(eglImage, eglImageLen);
715     return ret;
716 }
717 
SerStubComponentRoleEnum(struct CodecComponentType * serviceImpl,struct HdfSBuf * data,struct HdfSBuf * reply)718 static int32_t SerStubComponentRoleEnum(struct CodecComponentType *serviceImpl, struct HdfSBuf *data,
719                                         struct HdfSBuf *reply)
720 {
721     if (serviceImpl == NULL) {
722         CODEC_LOGE("invalid parameter");
723         return HDF_ERR_INVALID_PARAM;
724     }
725     int32_t ret;
726     uint8_t *role = NULL;
727     uint32_t roleLen = 0;
728     uint32_t index = 0;
729 
730     if (!HdfSbufReadUint32(data, &roleLen)) {
731         CODEC_LOGE("read &roleLen failed!");
732         return HDF_ERR_INVALID_PARAM;
733     }
734 
735     role = (uint8_t*)OsalMemCalloc(sizeof(uint8_t) * (roleLen));
736     if (role == NULL) {
737         CODEC_LOGE("HDF_ERR_MALLOC_FAIL!");
738         return HDF_ERR_MALLOC_FAIL;
739     }
740 
741     if (!HdfSbufReadUint32(data, &index)) {
742         CODEC_LOGE("read &index failed!");
743         FreeMem((int8_t*)role, roleLen);
744         return HDF_ERR_INVALID_PARAM;
745     }
746 
747     ret = serviceImpl->ComponentRoleEnum(serviceImpl, role, roleLen, index);
748     if (ret != HDF_SUCCESS) {
749         CODEC_LOGE("call ComponentRoleEnum function failed!");
750         FreeMem((int8_t*)role, roleLen);
751         return ret;
752     }
753 
754     for (uint32_t i = 0; i < roleLen; i++) {
755         if (!HdfSbufWriteUint8(reply, role[i])) {
756             CODEC_LOGE("write role[i] failed!");
757             FreeMem((int8_t*)role, roleLen);
758             return HDF_ERR_INVALID_PARAM;
759         }
760     }
761 
762     FreeMem((int8_t*)role, roleLen);
763     return ret;
764 }
765 
CodecComponentTypeServiceOnRemoteRequest(struct HdfRemoteService * remote,int32_t cmdId,struct HdfSBuf * data,struct HdfSBuf * reply)766 static int32_t CodecComponentTypeServiceOnRemoteRequest(struct HdfRemoteService *remote,
767                                                         int32_t cmdId, struct HdfSBuf *data, struct HdfSBuf *reply)
768 {
769     struct CodecComponentType *serviceImpl = (struct CodecComponentType *)remote;
770     if (serviceImpl == NULL) {
771         CODEC_LOGE("invalid parameter");
772         return HDF_ERR_INVALID_PARAM;
773     }
774     if (!HdfRemoteServiceCheckInterfaceToken(serviceImpl->AsObject(serviceImpl), data)) {
775         CODEC_LOGE("interface token check failed");
776         return HDF_ERR_INVALID_PARAM;
777     }
778     if (cmdId < 0 || cmdId > CMD_COMPONENT_ROLE_ENUM) {
779         CODEC_LOGE("not support cmd %{public}d", cmdId);
780         return HDF_ERR_INVALID_PARAM;
781     }
782 
783     typedef int32_t(*SerStubFunc)(struct CodecComponentType*, struct HdfSBuf*, struct HdfSBuf*);
784     static SerStubFunc func[CMD_COMPONENT_ROLE_ENUM + 1] = {
785         NULL,
786         NULL,
787         NULL,
788         NULL,
789         SerStubGetComponentVersion,
790         SerStubSendCommand,
791         SerStubGetParameter,
792         SerStubSetParameter,
793         SerStubGetConfig,
794         SerStubSetConfig,
795         SerStubGetExtensionIndex,
796         SerStubGetState,
797         SerStubComponentTunnelRequest,
798         SerStubUseBuffer,
799         SerStubAllocateBuffer,
800         SerStubFreeBuffer,
801         SerStubEmptyThisBuffer,
802         SerStubFillThisBuffer,
803         SerStubSetCallbacks,
804         SerStubComponentDeInit,
805         SerStubUseEglImage,
806         SerStubComponentRoleEnum
807     };
808 
809     if (func[cmdId] != NULL) {
810         return func[cmdId](serviceImpl, data, reply);
811     } else {
812         CODEC_LOGE("not support cmd %{public}d", cmdId);
813         return HDF_ERR_INVALID_PARAM;
814     }
815 }
816 
CodecComponentTypeAsObject(struct CodecComponentType * self)817 static struct HdfRemoteService *CodecComponentTypeAsObject(struct CodecComponentType *self)
818 {
819     if (self == NULL) {
820         return NULL;
821     }
822     struct CodecComponentTypeStub *stub = CONTAINER_OF(self, struct CodecComponentTypeStub, interface);
823     if (stub == NULL) {
824         return NULL;
825     }
826     return stub->remote;
827 }
828 
CodecComponentTypeStubConstruct(struct CodecComponentTypeStub * stub)829 bool CodecComponentTypeStubConstruct(struct CodecComponentTypeStub *stub)
830 {
831     if (stub == NULL) {
832         CODEC_LOGE("stub is null!");
833         return false;
834     }
835 
836     stub->dispatcher.Dispatch = CodecComponentTypeServiceOnRemoteRequest;
837     stub->remote = HdfRemoteServiceObtain((struct HdfObject *)stub, &(stub->dispatcher));
838     if (stub->remote == NULL) {
839         CODEC_LOGE("stub->remote is null");
840         return false;
841     }
842 
843     if (!HdfRemoteServiceSetInterfaceDesc(stub->remote, CODEC_COMPONENT_INTERFACE_DESC)) {
844         CODEC_LOGE("failed to set remote service interface descriptor");
845         CodecComponentTypeStubRelease(stub);
846         return false;
847     }
848 
849     stub->interface.AsObject = CodecComponentTypeAsObject;
850     return true;
851 }
852 
CodecComponentTypeStubRelease(struct CodecComponentTypeStub * stub)853 void CodecComponentTypeStubRelease(struct CodecComponentTypeStub *stub)
854 {
855     if (stub == NULL) {
856         return;
857     }
858     if (stub->remote != NULL) {
859         HdfRemoteServiceRecycle(stub->remote);
860         stub->remote = NULL;
861     }
862 }
863