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 "component_node.h"
17 #include <ashmem.h>
18 #include <securec.h>
19 #include <unistd.h>
20 #include "icodec_buffer.h"
21 #include "codec_log_wrapper.h"
22 
23 #define FD_SIZE     sizeof(int)
24 namespace {
25     constexpr int ROLE_MAX_LEN = 256;
26 }
27 
28 namespace OHOS {
29 namespace Codec {
30 namespace Omx {
OnEvent(OMX_HANDLETYPE component,void * appData,OMX_EVENTTYPE event,uint32_t data1,uint32_t data2,void * eventData)31 OMX_ERRORTYPE ComponentNode::OnEvent(OMX_HANDLETYPE component, void *appData, OMX_EVENTTYPE event, uint32_t data1,
32                                      uint32_t data2, void *eventData)
33 {
34     ComponentNode *node = static_cast<ComponentNode *>(appData);
35     (void)component;
36     if (node != nullptr) {
37         node->OnEvent(event, data1, data2, eventData);
38     }
39 
40     return OMX_ErrorNone;
41 }
42 
OnEmptyBufferDone(OMX_HANDLETYPE component,void * appData,OMX_BUFFERHEADERTYPE * buffer)43 OMX_ERRORTYPE ComponentNode::OnEmptyBufferDone(OMX_HANDLETYPE component, void *appData, OMX_BUFFERHEADERTYPE *buffer)
44 {
45     ComponentNode *node = static_cast<ComponentNode *>(appData);
46     (void)component;
47     if (node != nullptr) {
48         node->OnEmptyBufferDone(buffer);
49     }
50     return OMX_ErrorNone;
51 }
52 
OnFillBufferDone(OMX_HANDLETYPE component,void * appData,OMX_BUFFERHEADERTYPE * buffer)53 OMX_ERRORTYPE ComponentNode::OnFillBufferDone(OMX_HANDLETYPE component, void *appData, OMX_BUFFERHEADERTYPE *buffer)
54 {
55     ComponentNode *node = static_cast<ComponentNode *>(appData);
56     (void)component;
57     if (node != nullptr) {
58         node->OnFillBufferDone(buffer);
59     }
60     return OMX_ErrorNone;
61 }
62 
63 OMX_CALLBACKTYPE ComponentNode::callbacks_ = {&ComponentNode::OnEvent, &ComponentNode::OnEmptyBufferDone,
64                                               &ComponentNode::OnFillBufferDone};
65 
ComponentNode(struct CodecCallbackType * callback,int64_t appData,const std::string & compName)66 ComponentNode::ComponentNode(struct CodecCallbackType *callback, int64_t appData, const std::string &compName)
67     : comp_(nullptr),
68       omxCallback_(callback),
69       appData_(appData),
70       bufferIdCount_(0),
71       name_(compName)
72 {
73 }
74 
~ComponentNode()75 ComponentNode::~ComponentNode()
76 {
77     if (omxCallback_ != nullptr) {
78         std::unique_lock<std::shared_mutex> lk(callbackMutex_);
79         CodecCallbackTypeRelease(omxCallback_);
80         omxCallback_ = nullptr;
81     }
82     std::unique_lock<std::shared_mutex> lk(mapMutex_);
83     if (codecBufferMap_.size() != 0) {
84         ReleaseOMXResource();
85     }
86     codecBufferMap_.clear();
87     bufferHeaderMap_.clear();
88     bufferHeaderPortMap_.clear();
89     bufferIdCount_ = 0;
90     name_ = "";
91 }
92 
GetComponentVersion(struct CompVerInfo & verInfo)93 int32_t ComponentNode::GetComponentVersion(struct CompVerInfo &verInfo)
94 {
95     if (comp_ == nullptr) {
96         CODEC_LOGE("comp_ is null");
97         return OMX_ErrorInvalidComponent;
98     }
99     int32_t err =
100         OMX_GetComponentVersion(comp_, verInfo.compName, &verInfo.compVersion, &verInfo.specVersion, &verInfo.compUUID);
101     if (err != OMX_ErrorNone) {
102         CODEC_LOGE("OMX_GetComponentVersion err = %{public}d", err);
103         return err;
104     }
105     return err;
106 }
107 
SendCommand(OMX_COMMANDTYPE cmd,uint32_t param,int8_t * cmdData,uint32_t cmdDataLen)108 int32_t ComponentNode::SendCommand(OMX_COMMANDTYPE cmd, uint32_t param, int8_t *cmdData, uint32_t cmdDataLen)
109 {
110     if (comp_ == nullptr) {
111         CODEC_LOGE("comp_ is null");
112         return OMX_ErrorInvalidComponent;
113     }
114     (void)cmdDataLen;
115     return OMX_SendCommand(comp_, cmd, param, cmdData);
116 }
117 
GetParameter(OMX_INDEXTYPE paramIndex,int8_t * param,uint32_t paramLen)118 int32_t ComponentNode::GetParameter(OMX_INDEXTYPE paramIndex, int8_t *param, uint32_t paramLen)
119 {
120     if (comp_ == nullptr) {
121         CODEC_LOGE("comp_ is null");
122         return OMX_ErrorInvalidComponent;
123     }
124     (void)paramLen;
125     return OMX_GetParameter(comp_, paramIndex, param);
126 }
127 
SetParameter(OMX_INDEXTYPE paramIndex,int8_t * param,uint32_t paramLen)128 int32_t ComponentNode::SetParameter(OMX_INDEXTYPE paramIndex, int8_t *param, uint32_t paramLen)
129 {
130     if (comp_ == nullptr || param == nullptr) {
131         CODEC_LOGE("comp_ is null or param is null");
132         return OMX_ErrorInvalidComponent;
133     }
134     (void)paramLen;
135     return OMX_SetParameter(comp_, paramIndex, param);
136 }
137 
GetConfig(OMX_INDEXTYPE index,int8_t * config,uint32_t configLen)138 int32_t ComponentNode::GetConfig(OMX_INDEXTYPE index, int8_t *config, uint32_t configLen)
139 {
140     if (comp_ == nullptr) {
141         CODEC_LOGE("comp_ is null");
142         return OMX_ErrorInvalidComponent;
143     }
144     (void)configLen;
145     return OMX_GetConfig(comp_, index, config);
146 }
147 
SetConfig(OMX_INDEXTYPE index,int8_t * config,uint32_t configLen)148 int32_t ComponentNode::SetConfig(OMX_INDEXTYPE index, int8_t *config, uint32_t configLen)
149 {
150     if (comp_ == nullptr) {
151         CODEC_LOGE("comp_ is null");
152         return OMX_ErrorInvalidComponent;
153     }
154     (void)configLen;
155     return OMX_SetConfig(comp_, index, config);
156 }
157 
GetExtensionIndex(const char * parameterName,OMX_INDEXTYPE * indexType)158 int32_t ComponentNode::GetExtensionIndex(const char *parameterName, OMX_INDEXTYPE *indexType)
159 {
160     if (comp_ == nullptr) {
161         CODEC_LOGE("comp_ is null");
162         return OMX_ErrorInvalidComponent;
163     }
164     // change name
165     return OMX_GetExtensionIndex(comp_, const_cast<char *>(parameterName), indexType);
166 }
167 
GetState(OMX_STATETYPE * state)168 int32_t ComponentNode::GetState(OMX_STATETYPE *state)
169 {
170     if (comp_ == nullptr) {
171         CODEC_LOGE("comp_ is null");
172         return OMX_ErrorInvalidComponent;
173     }
174 
175     return OMX_GetState(comp_, state);
176 }
177 
ComponentTunnelRequest(uint32_t port,int32_t omxHandleTypeTunneledComp,uint32_t tunneledPort,struct OMX_TUNNELSETUPTYPE * tunnelSetup)178 int32_t ComponentNode::ComponentTunnelRequest(uint32_t port, int32_t omxHandleTypeTunneledComp, uint32_t tunneledPort,
179                                               struct OMX_TUNNELSETUPTYPE *tunnelSetup)
180 {
181     if (comp_ == nullptr) {
182         CODEC_LOGE("comp_ is null");
183         return OMX_ErrorInvalidComponent;
184     }
185     OMX_COMPONENTTYPE *comType = static_cast<OMX_COMPONENTTYPE *>(comp_);
186     if (comType->ComponentTunnelRequest == nullptr) {
187         CODEC_LOGE("The requested function is not implemented.");
188         return OMX_ErrorNotImplemented;
189     }
190     unsigned long tunneledComp = static_cast<unsigned long>(omxHandleTypeTunneledComp);
191     return comType->ComponentTunnelRequest(comp_, port, reinterpret_cast<OMX_HANDLETYPE>(tunneledComp),
192         tunneledPort, tunnelSetup);
193 }
194 
SetCallbacks(struct CodecCallbackType * omxCallback,int64_t appData)195 int32_t ComponentNode::SetCallbacks(struct CodecCallbackType *omxCallback, int64_t appData)
196 {
197     // release this->omxCallback_
198     if (this->omxCallback_ != nullptr) {
199         CodecCallbackTypeRelease(this->omxCallback_);
200         this->omxCallback_ = nullptr;
201     }
202     this->omxCallback_ = omxCallback;
203     this->appData_ = appData;
204     return OMX_ErrorNone;
205 }
206 
UseEglImage(struct OmxCodecBuffer & buffer,uint32_t portIndex,int8_t * eglImage,uint32_t eglImageLen)207 int32_t ComponentNode::UseEglImage(struct OmxCodecBuffer &buffer, uint32_t portIndex, int8_t *eglImage,
208                                    uint32_t eglImageLen)
209 {
210     OMX_BUFFERHEADERTYPE *pBufferHdrType = nullptr;
211 
212     auto err = OMX_UseEGLImage(comp_, &pBufferHdrType, portIndex, nullptr, eglImage);
213     if (err != OMX_ErrorNone) {
214         CODEC_LOGE("OMX_UseEGLImage error[0x%{public}x]", err);
215         return err;
216     }
217     (void)buffer;
218     (void)eglImageLen;
219     return OMX_ErrorNotImplemented;
220 }
221 
ComponentRoleEnum(uint8_t * role,uint32_t roleLen,uint32_t index)222 int32_t ComponentNode::ComponentRoleEnum(uint8_t *role, uint32_t roleLen, uint32_t index)
223 {
224     if (comp_ == nullptr) {
225         CODEC_LOGE("comp_ is null ");
226         return OMX_ErrorInvalidComponent;
227     }
228     uint8_t omxRole[ROLE_MAX_LEN] = {0};
229     OMX_COMPONENTTYPE *comType = static_cast<OMX_COMPONENTTYPE *>(comp_);
230     if (comType->ComponentRoleEnum == nullptr) {
231         CODEC_LOGE("The requested function is not implemented.");
232         return OMX_ErrorNotImplemented;
233     }
234     int32_t err = comType->ComponentRoleEnum(comp_, omxRole, index);
235     if (err != OMX_ErrorNone) {
236         CODEC_LOGE("ComponentRoleEnum ret err [0x%{public}x]", err);
237         return err;
238     }
239 
240     size_t omxRoleLen = strlen(reinterpret_cast<const char *>(omxRole));
241     if (omxRoleLen == 0) {
242         CODEC_LOGW("omxRoleLen is 0");
243     } else {
244         int32_t ret = memcpy_s(role, roleLen, omxRole, omxRoleLen);
245         if (ret != EOK) {
246             CODEC_LOGE("memcpy_s ret [%{public}d]", ret);
247             return HDF_ERR_INVALID_PARAM;
248         }
249     }
250 
251     return OMX_ErrorNone;
252 }
253 
DeInit()254 int32_t ComponentNode::DeInit()
255 {
256     if (comp_ == nullptr) {
257         CODEC_LOGE("comp_ is null ");
258         return OMX_ErrorInvalidComponent;
259     }
260     OMX_COMPONENTTYPE *comType = static_cast<OMX_COMPONENTTYPE *>(comp_);
261     return comType->ComponentDeInit(comp_);
262 }
263 
OnEvent(OMX_EVENTTYPE event,uint32_t data1,uint32_t data2,void * eventData)264 int32_t ComponentNode::OnEvent(OMX_EVENTTYPE event, uint32_t data1, uint32_t data2, void *eventData)
265 {
266     std::shared_lock<std::shared_mutex> lk(callbackMutex_);
267     if (omxCallback_ == nullptr) {
268         CODEC_LOGE("omxCallback_ is null");
269         return OMX_ErrorNone;
270     }
271     CODEC_LOGD("event [%d], data1 [%d],data2 [%d]", event, data1, data2);
272     struct EventInfo info = {.appData = appData_,
273                              .data1 = data1,
274                              .data2 = data2,
275                              .eventData = static_cast<int8_t *>(eventData),
276                              .eventDataLen = 0};
277     (void)omxCallback_->EventHandler(omxCallback_, event, &info);
278 
279     return OMX_ErrorNone;
280 }
281 
OnEmptyBufferDone(OMX_BUFFERHEADERTYPE * buffer)282 int32_t ComponentNode::OnEmptyBufferDone(OMX_BUFFERHEADERTYPE *buffer)
283 {
284     std::shared_lock<std::shared_mutex> lk(callbackMutex_);
285     if ((omxCallback_ == nullptr) || (buffer == nullptr)) {
286         CODEC_LOGE("omxCallback_ or buffer is null");
287         return OMX_ErrorNone;
288     }
289     sptr<ICodecBuffer> codecBuffer = GetBufferInfoByHeader(buffer);
290     if (codecBuffer == nullptr || codecBuffer->EmptyOmxBufferDone(*buffer) != HDF_SUCCESS) {
291         CODEC_LOGE("codecBuffer is null or EmptyOmxBufferDone error");
292         return OMX_ErrorNone;
293     }
294     struct OmxCodecBuffer &codecOmxBuffer = codecBuffer->GetCodecBuffer();
295     (void)omxCallback_->EmptyBufferDone(omxCallback_, appData_, &codecOmxBuffer);
296     return OMX_ErrorNone;
297 }
298 
OnFillBufferDone(OMX_BUFFERHEADERTYPE * buffer)299 int32_t ComponentNode::OnFillBufferDone(OMX_BUFFERHEADERTYPE *buffer)
300 {
301     std::shared_lock<std::shared_mutex> lk(callbackMutex_);
302     if ((omxCallback_ == nullptr) || (buffer == nullptr)) {
303         CODEC_LOGE("omxCallback_ or buffer is null");
304         return OMX_ErrorNone;
305     }
306 
307     sptr<ICodecBuffer> codecBuffer = GetBufferInfoByHeader(buffer);
308     if (codecBuffer == nullptr || codecBuffer->FillOmxBufferDone(*buffer) != HDF_SUCCESS) {
309         CODEC_LOGE("codecBuffer is null or FillOmxBufferDone error");
310         return OMX_ErrorNone;
311     }
312 
313     struct OmxCodecBuffer &codecOmxBuffer = codecBuffer->GetCodecBuffer();
314     (void)omxCallback_->FillBufferDone(omxCallback_, appData_, &codecOmxBuffer);
315     return OMX_ErrorNone;
316 }
317 
UseBuffer(uint32_t portIndex,struct OmxCodecBuffer & buffer)318 int32_t ComponentNode::UseBuffer(uint32_t portIndex, struct OmxCodecBuffer &buffer)
319 {
320     if (comp_ == nullptr) {
321         CODEC_LOGE("comp_ is null");
322         return OMX_ErrorInvalidComponent;
323     }
324     if (buffer.fenceFd >= 0) {
325         close(buffer.fenceFd);
326         buffer.fenceFd = -1;
327     }
328 
329     int32_t err = OMX_ErrorBadParameter;
330     sptr<ICodecBuffer> codecBuffer = ICodecBuffer::CreateCodeBuffer(buffer);
331     if (codecBuffer == nullptr) {
332         CODEC_LOGE("codecBuffer is null");
333         return OMX_ErrorInvalidComponent;
334     }
335     OMX_BUFFERHEADERTYPE *bufferHdrType = nullptr;
336     if (buffer.bufferType == CODEC_BUFFER_TYPE_AVSHARE_MEM_FD) {
337         err = OMX_AllocateBuffer(static_cast<OMX_HANDLETYPE>(comp_), &bufferHdrType, portIndex, 0, buffer.allocLen);
338     } else {
339         err = OMX_UseBuffer(static_cast<OMX_HANDLETYPE>(comp_), &bufferHdrType, portIndex, 0, buffer.allocLen,
340                             codecBuffer->GetBuffer());
341     }
342 
343     if (err != OMX_ErrorNone) {
344         CODEC_LOGE("type [%{public}d] OMX_AllocateBuffer or OMX_UseBuffer ret err[%{public}x]",
345             buffer.bufferType, err);
346         codecBuffer = nullptr;
347         return err;
348     }
349     uint32_t bufferId = GenerateBufferId();
350     buffer.bufferId = bufferId;
351     codecBuffer->SetBufferId(bufferId);
352     {
353         std::unique_lock<std::shared_mutex> lk(mapMutex_);
354         codecBufferMap_.emplace(std::make_pair(bufferId, codecBuffer));
355         bufferHeaderMap_.emplace(std::make_pair(bufferHdrType, bufferId));
356         bufferHeaderPortMap_.emplace(std::make_pair(bufferHdrType, portIndex));
357     }
358     return err;
359 }
360 
AllocateBuffer(uint32_t portIndex,struct OmxCodecBuffer & buffer)361 int32_t ComponentNode::AllocateBuffer(uint32_t portIndex, struct OmxCodecBuffer &buffer)
362 {
363     if (comp_ == nullptr) {
364         CODEC_LOGE("comp_ is null");
365         return OMX_ErrorInvalidComponent;
366     }
367     OMX_BUFFERHEADERTYPE *bufferHdrType = 0;
368     int32_t err = OMX_AllocateBuffer(static_cast<OMX_HANDLETYPE>(comp_), &bufferHdrType, portIndex, 0, buffer.allocLen);
369     if (err != OMX_ErrorNone || bufferHdrType == nullptr) {
370         CODEC_LOGE("OMX_AllocateBuffer error, err = %{public}x", err);
371         return err;
372     }
373 
374     buffer.allocLen = bufferHdrType->nAllocLen;
375     sptr<ICodecBuffer> codecBuffer = ICodecBuffer::AllocateCodecBuffer(buffer);
376     if (codecBuffer == nullptr) {
377         CODEC_LOGE("codecBuffer is null");
378         (void)OMX_FreeBuffer(static_cast<OMX_HANDLETYPE>(comp_), portIndex, bufferHdrType);
379         return OMX_ErrorInvalidComponent;
380     }
381 
382     uint32_t bufferId = GenerateBufferId();
383     buffer.bufferId = bufferId;
384     {
385         std::unique_lock<std::shared_mutex> lk(mapMutex_);
386         codecBufferMap_.emplace(std::make_pair(bufferId, codecBuffer));
387         bufferHeaderMap_.emplace(std::make_pair(bufferHdrType, bufferId));
388         bufferHeaderPortMap_.emplace(std::make_pair(bufferHdrType, portIndex));
389     }
390     return OMX_ErrorNone;
391 }
392 
FreeBuffer(uint32_t portIndex,struct OmxCodecBuffer & buffer)393 int32_t ComponentNode::FreeBuffer(uint32_t portIndex, struct OmxCodecBuffer &buffer)
394 {
395     if (comp_ == nullptr) {
396         CODEC_LOGE("comp_ is nullptr");
397         return OMX_ErrorInvalidComponent;
398     }
399 
400     int32_t err = OMX_ErrorBadParameter;
401     sptr<ICodecBuffer> codecBufer = nullptr;
402     OMX_BUFFERHEADERTYPE *bufferHdrType = nullptr;
403     if (!GetBufferById(buffer.bufferId, codecBufer, bufferHdrType)) {
404         CODEC_LOGE("GetBufferById return false");
405         return err;
406     }
407 
408     err = OMX_FreeBuffer(static_cast<OMX_HANDLETYPE>(comp_), portIndex, bufferHdrType);
409     if (err != OMX_ErrorNone) {
410         CODEC_LOGE("OMX_FreeBuffer err [%{public}x]", err);
411         return err;
412     }
413 
414     {
415         std::unique_lock<std::shared_mutex> lk(mapMutex_);
416         auto iterOmxBuffer = bufferHeaderMap_.begin();
417         while (iterOmxBuffer != bufferHeaderMap_.end()) {
418             if (iterOmxBuffer->first == bufferHdrType) {
419                 bufferHeaderMap_.erase(iterOmxBuffer);
420                 break;
421             }
422             iterOmxBuffer++;
423         }
424 
425         iterOmxBuffer = bufferHeaderPortMap_.begin();
426         while (iterOmxBuffer != bufferHeaderPortMap_.end()) {
427             if (iterOmxBuffer->first == bufferHdrType) {
428                 bufferHeaderPortMap_.erase(iterOmxBuffer);
429                 break;
430             }
431             iterOmxBuffer++;
432         }
433 
434         auto iter = codecBufferMap_.find(buffer.bufferId);
435         if (iter != codecBufferMap_.end()) {
436             codecBufferMap_.erase(iter);
437         }
438     }
439 
440     (void)codecBufer->FreeBuffer(buffer);
441 
442     return err;
443 }
444 
EmptyThisBuffer(struct OmxCodecBuffer & buffer)445 int32_t ComponentNode::EmptyThisBuffer(struct OmxCodecBuffer &buffer)
446 {
447     if (comp_ == nullptr) {
448         CODEC_LOGE("comp_ is nullptr");
449         return OMX_ErrorInvalidComponent;
450     }
451     int32_t err = OMX_ErrorBadParameter;
452     OMX_BUFFERHEADERTYPE *bufferHdrType = nullptr;
453     sptr<ICodecBuffer> codecBuffer = nullptr;
454     if (!GetBufferById(buffer.bufferId, codecBuffer, bufferHdrType) || codecBuffer == nullptr) {
455         CODEC_LOGE("GetBufferById return false");
456         return err;
457     }
458     err = codecBuffer->EmptyOmxBuffer(buffer, *bufferHdrType);
459     if (err != HDF_SUCCESS) {
460         CODEC_LOGE("EmptyOmxBuffer err [%{public}d]", err);
461         return err;
462     }
463 
464     err = OMX_EmptyThisBuffer(static_cast<OMX_HANDLETYPE>(comp_), bufferHdrType);
465     return err;
466 }
467 
FillThisBuffer(struct OmxCodecBuffer & buffer)468 int32_t ComponentNode::FillThisBuffer(struct OmxCodecBuffer &buffer)
469 {
470     if (comp_ == nullptr) {
471         CODEC_LOGE("comp_ is nullptr");
472         return OMX_ErrorInvalidComponent;
473     }
474     int32_t err = OMX_ErrorBadParameter;
475     OMX_BUFFERHEADERTYPE *bufferHdrType = nullptr;
476     sptr<ICodecBuffer> codecBuffer = nullptr;
477     if (!GetBufferById(buffer.bufferId, codecBuffer, bufferHdrType)) {
478         CODEC_LOGE("GetBufferById return false");
479         return err;
480     }
481     if (codecBuffer == nullptr) {
482         CODEC_LOGE("fail to get codecBuffer");
483         return err;
484     }
485     err = codecBuffer->FillOmxBuffer(buffer, *bufferHdrType);
486     if (err != HDF_SUCCESS) {
487         CODEC_LOGE("FillOmxBuffer err [%{public}d]", err);
488         return err;
489     }
490 
491     err = OMX_FillThisBuffer(static_cast<OMX_HANDLETYPE>(comp_), bufferHdrType);
492     return err;
493 }
494 
GenerateBufferId()495 uint32_t ComponentNode::GenerateBufferId()
496 {
497     std::unique_lock<std::shared_mutex> lk(mapMutex_);
498     uint32_t bufferId = 0;
499     do {
500         if (++bufferIdCount_ == 0) {
501             ++bufferIdCount_;
502         }
503         bufferId = bufferIdCount_;
504     } while (codecBufferMap_.find(bufferId) != codecBufferMap_.end());
505     return bufferId;
506 }
507 
GetBufferInfoByHeader(OMX_BUFFERHEADERTYPE * buffer)508 sptr<ICodecBuffer> ComponentNode::GetBufferInfoByHeader(OMX_BUFFERHEADERTYPE *buffer)
509 {
510     if (buffer == nullptr) {
511         CODEC_LOGE("buffer is null");
512         return sptr<ICodecBuffer>();
513     }
514     std::shared_lock<std::shared_mutex> lk(mapMutex_);
515     auto iterHead = bufferHeaderMap_.find(buffer);
516     if (iterHead == bufferHeaderMap_.end()) {
517         CODEC_LOGE("can not find bufferID");
518         return sptr<ICodecBuffer>();
519     }
520 
521     uint32_t nBufferID = iterHead->second;
522     auto iter = codecBufferMap_.find(nBufferID);
523     if (iter == codecBufferMap_.end()) {
524         CODEC_LOGE("can not find bufferInfo by nBufferID = %{public}d", nBufferID);
525         return sptr<ICodecBuffer>();
526     }
527     return iter->second;
528 }
529 
GetBufferById(uint32_t bufferId,sptr<ICodecBuffer> & codecBuffer,OMX_BUFFERHEADERTYPE * & bufferHdrType)530 bool ComponentNode::GetBufferById(uint32_t bufferId, sptr<ICodecBuffer> &codecBuffer,
531                                   OMX_BUFFERHEADERTYPE *&bufferHdrType)
532 {
533     std::shared_lock<std::shared_mutex> lk(mapMutex_);
534     auto iter = codecBufferMap_.find(bufferId);
535     if ((iter == codecBufferMap_.end()) || (iter->second == nullptr)) {
536         CODEC_LOGE("can not find bufferIndo by bufferID [%{public}d]", bufferId);
537         return false;
538     }
539 
540     auto iterHead = bufferHeaderMap_.begin();
541     for (; iterHead != bufferHeaderMap_.end(); iterHead++) {
542         if (iterHead->second == bufferId) {
543             break;
544         }
545     }
546     if ((iterHead == bufferHeaderMap_.end()) || (iterHead->first == nullptr)) {
547         CODEC_LOGE("can not find bufferHeaderType by bufferID [%{public}d] or iterHead->first is null", bufferId);
548         return false;
549     }
550     bufferHdrType = iterHead->first;
551     codecBuffer = iter->second;
552     return true;
553 }
554 
WaitStateChange(uint32_t objState,OMX_STATETYPE * status)555 void ComponentNode::WaitStateChange(uint32_t objState, OMX_STATETYPE *status)
556 {
557     int32_t ret = GetState(status);
558     if (ret != HDF_SUCCESS) {
559         CODEC_LOGE("GetState error [%{public}x]", ret);
560         return;
561     }
562     uint32_t count = 0;
563     while (*status != objState && count++ < maxStateWaitCount) {
564         usleep(maxStateWaitTime);
565         ret = GetState(status);
566         if (ret != HDF_SUCCESS) {
567             CODEC_LOGE("GetState error [%{public}x]", ret);
568             return;
569         }
570     }
571 }
572 
ReleaseOMXResource()573 void ComponentNode::ReleaseOMXResource()
574 {
575     OMX_STATETYPE status = OMX_StateInvalid;
576     int32_t ret = GetState(&status);
577     if (ret != HDF_SUCCESS) {
578         CODEC_LOGE("ReleaseOMXResource GetState error [%{public}x]", ret);
579         return;
580     }
581     if (status == OMX_StateExecuting) {
582         SendCommand(OMX_CommandStateSet, OMX_StateIdle, NULL, 0);
583         WaitStateChange(OMX_StateIdle, &status);
584     }
585     if (status == OMX_StateIdle) {
586         SendCommand(OMX_CommandStateSet, OMX_StateLoaded, NULL, 0);
587         auto err = ReleaseAllBuffer();
588         if (err != HDF_SUCCESS) {
589             CODEC_LOGE("ReleaseAllBuffer err [%{public}x]", err);
590             return;
591         }
592         WaitStateChange(OMX_StateLoaded, &status);
593     }
594     CODEC_LOGI("Release OMX Resource success!");
595 }
596 
ReleaseAllBuffer()597 int32_t ComponentNode::ReleaseAllBuffer()
598 {
599     auto iter = bufferHeaderMap_.begin();
600     for (; iter != bufferHeaderMap_.end(); iter++) {
601         OMX_BUFFERHEADERTYPE *bufferHdrType = iter->first;
602         uint32_t protIndex = bufferHeaderPortMap_.find(bufferHdrType)->second;
603         auto ret = OMX_FreeBuffer((OMX_HANDLETYPE)comp_, protIndex, bufferHdrType);
604         if (ret != OMX_ErrorNone) {
605             CODEC_LOGE("OMX_FreeBuffer err [%{public}x]", ret);
606             return ret;
607         }
608     }
609     CODEC_LOGI("Release OMXBuffer and CodecBuffer success!");
610     return HDF_SUCCESS;
611 }
612 }  // namespace Omx
613 }  // namespace Codec
614 }  // namespace OHOS
615