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_share_buffer.h"
17 #include <hdf_base.h>
18 #include <securec.h>
19 #include <unistd.h>
20 #include "codec_log_wrapper.h"
21
22 namespace OHOS {
23 namespace Codec {
24 namespace Omx {
CodecShareBuffer(struct OmxCodecBuffer & codecBuffer)25 CodecShareBuffer::CodecShareBuffer(struct OmxCodecBuffer &codecBuffer) : ICodecBuffer(codecBuffer)
26 {}
27
~CodecShareBuffer()28 CodecShareBuffer::~CodecShareBuffer()
29 {
30 if (shMem_ != nullptr) {
31 shMem_->UnmapAshmem();
32 shMem_->CloseAshmem();
33 shMem_ = nullptr;
34 }
35 }
36
SetAshMem(std::shared_ptr<OHOS::Ashmem> shMem)37 void CodecShareBuffer::SetAshMem(std::shared_ptr<OHOS::Ashmem> shMem)
38 {
39 shMem_ = shMem;
40 }
41
Create(struct OmxCodecBuffer & codecBuffer)42 OHOS::sptr<ICodecBuffer> CodecShareBuffer::Create(struct OmxCodecBuffer &codecBuffer)
43 {
44 int shardFd = (int)reinterpret_cast<uintptr_t>(codecBuffer.buffer);
45 if (shardFd < 0) {
46 CODEC_LOGE("shardFd < 0");
47 return OHOS::sptr<ICodecBuffer>();
48 }
49 int size = OHOS::AshmemGetSize(shardFd);
50 std::shared_ptr<OHOS::Ashmem> sharedMem = std::make_shared<OHOS::Ashmem>(shardFd, size);
51 if (sharedMem == nullptr) {
52 CODEC_LOGE("fail to init sharedMem");
53 return OHOS::sptr<ICodecBuffer>();
54 }
55 bool mapd = false;
56 if (codecBuffer.type == READ_WRITE_TYPE) {
57 mapd = sharedMem->MapReadAndWriteAshmem();
58 } else {
59 mapd = sharedMem->MapReadOnlyAshmem();
60 }
61 if (!mapd) {
62 CODEC_LOGE("MapReadAndWriteAshmem or MapReadOnlyAshmem return false");
63 return OHOS::sptr<ICodecBuffer>();
64 }
65
66 codecBuffer.buffer = nullptr;
67 codecBuffer.bufferLen = 0;
68 CodecShareBuffer *buffer = new CodecShareBuffer(codecBuffer);
69 buffer->SetAshMem(sharedMem);
70
71 return OHOS::sptr<ICodecBuffer>(buffer);
72 }
73
Allocate(struct OmxCodecBuffer & codecBuffer)74 OHOS::sptr<ICodecBuffer> CodecShareBuffer::Allocate(struct OmxCodecBuffer &codecBuffer)
75 {
76 codecBuffer.bufferType = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
77 // create shared memory
78 int sharedFD = AshmemCreate(nullptr, codecBuffer.allocLen);
79
80 std::shared_ptr<Ashmem> sharedMemory = std::make_shared<Ashmem>(sharedFD, codecBuffer.allocLen);
81 if (sharedMemory == nullptr) {
82 return OHOS::sptr<ICodecBuffer>();
83 }
84 codecBuffer.type = READ_WRITE_TYPE;
85 bool mapd = false;
86 if (codecBuffer.type == READ_WRITE_TYPE) {
87 mapd = sharedMemory->MapReadAndWriteAshmem();
88 } else {
89 mapd = sharedMemory->MapReadOnlyAshmem();
90 }
91 if (!mapd) {
92 CODEC_LOGE("MapReadAndWriteAshmem or MapReadOnlyAshmem return false");
93 return OHOS::sptr<ICodecBuffer>();
94 }
95 codecBuffer.offset = 0;
96 codecBuffer.filledLen = 0;
97
98 CodecShareBuffer *buffer = new CodecShareBuffer(codecBuffer);
99 codecBuffer.buffer = reinterpret_cast<uint8_t *>(sharedFD);
100 codecBuffer.bufferLen = sizeof(int);
101 buffer->SetAshMem(sharedMemory);
102 return OHOS::sptr<ICodecBuffer>(buffer);
103 }
104
FillOmxBuffer(struct OmxCodecBuffer & codecBuffer,OMX_BUFFERHEADERTYPE & omxBuffer)105 int32_t CodecShareBuffer::FillOmxBuffer(struct OmxCodecBuffer &codecBuffer, OMX_BUFFERHEADERTYPE &omxBuffer)
106 {
107 if (!CheckInvalid(codecBuffer) || codecBuffer_.type != READ_WRITE_TYPE) {
108 CODEC_LOGE("CheckInvalid return false or mem has no right to write ");
109 return HDF_ERR_INVALID_PARAM;
110 }
111
112 ReleaseFd(codecBuffer);
113
114 return ICodecBuffer::FillOmxBuffer(codecBuffer, omxBuffer);
115 }
116
EmptyOmxBuffer(struct OmxCodecBuffer & codecBuffer,OMX_BUFFERHEADERTYPE & omxBuffer)117 int32_t CodecShareBuffer::EmptyOmxBuffer(struct OmxCodecBuffer &codecBuffer, OMX_BUFFERHEADERTYPE &omxBuffer)
118 {
119 if (!CheckInvalid(codecBuffer)) {
120 CODEC_LOGE("shMem_ is null or CheckInvalid return false");
121 return HDF_ERR_INVALID_PARAM;
122 }
123
124 ReleaseFd(codecBuffer);
125
126 void *sharedPtr = const_cast<void *>(shMem_->ReadFromAshmem(codecBuffer.filledLen, codecBuffer.offset));
127 if (!sharedPtr) {
128 CODEC_LOGE("omxBuffer.length [%{public}d omxBuffer.offset[%{public}d]", codecBuffer.filledLen,
129 codecBuffer.offset);
130 return HDF_ERR_INVALID_PARAM;
131 }
132 auto ret = memcpy_s(omxBuffer.pBuffer + codecBuffer.offset, codecBuffer.allocLen - codecBuffer.offset, sharedPtr,
133 codecBuffer.filledLen);
134 if (ret != EOK) {
135 CODEC_LOGE("memcpy_s ret [%{public}d", ret);
136 return HDF_ERR_INVALID_PARAM;
137 }
138 return ICodecBuffer::EmptyOmxBuffer(codecBuffer, omxBuffer);
139 }
140
FreeBuffer(struct OmxCodecBuffer & codecBuffer)141 int32_t CodecShareBuffer::FreeBuffer(struct OmxCodecBuffer &codecBuffer)
142 {
143 if (!CheckInvalid(codecBuffer)) {
144 CODEC_LOGE("shMem_ is null or CheckInvalid return false");
145 return HDF_ERR_INVALID_PARAM;
146 }
147
148 ReleaseFd(codecBuffer);
149
150 shMem_->UnmapAshmem();
151 shMem_->CloseAshmem();
152 shMem_ = nullptr;
153 return HDF_SUCCESS;
154 }
155
GetBuffer()156 uint8_t *CodecShareBuffer::GetBuffer()
157 {
158 return nullptr;
159 }
160
EmptyOmxBufferDone(OMX_BUFFERHEADERTYPE & omxBuffer)161 int32_t CodecShareBuffer::EmptyOmxBufferDone(OMX_BUFFERHEADERTYPE &omxBuffer)
162 {
163 return ICodecBuffer::EmptyOmxBufferDone(omxBuffer);
164 }
165
FillOmxBufferDone(OMX_BUFFERHEADERTYPE & omxBuffer)166 int32_t CodecShareBuffer::FillOmxBufferDone(OMX_BUFFERHEADERTYPE &omxBuffer)
167 {
168 if (shMem_ == nullptr || !shMem_->WriteToAshmem(omxBuffer.pBuffer, omxBuffer.nFilledLen, omxBuffer.nOffset)) {
169 CODEC_LOGE("write to ashmem fail");
170 return HDF_ERR_INVALID_PARAM;
171 }
172
173 return ICodecBuffer::FillOmxBufferDone(omxBuffer);
174 }
175
CheckInvalid(struct OmxCodecBuffer & codecBuffer)176 bool CodecShareBuffer::CheckInvalid(struct OmxCodecBuffer &codecBuffer)
177 {
178 if (!ICodecBuffer::CheckInvalid(codecBuffer) || shMem_ == nullptr) {
179 CODEC_LOGE("shMem_ is null or CheckInvalid return false");
180 return false;
181 }
182 return true;
183 }
184
ReleaseFd(struct OmxCodecBuffer & codecBuffer)185 void CodecShareBuffer::ReleaseFd(struct OmxCodecBuffer &codecBuffer)
186 {
187 // close the fd, if fd is sent by codecBuffer
188 if (codecBuffer.buffer != nullptr) {
189 int fd = (int)reinterpret_cast<uintptr_t>(codecBuffer.buffer);
190 close(fd);
191 codecBuffer.buffer = 0;
192 codecBuffer.bufferLen = 0;
193 }
194 }
195 } // namespace Omx
196 } // namespace Codec
197 } // namespace OHOS