Debian Codegraph @

modules/lsp-runtime-lib/src/main/io/InSharedMemoryStream.cpp

raw
1 /*
2 * Copyright (C) 2023 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2023 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 22 февр. 2023 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/io/InSharedMemoryStream.h>
23 #include <lsp-plug.in/stdlib/string.h>
24 #include <stdlib.h>
25
26 namespace lsp
27 {
28 namespace io
29 {
30
31 InSharedMemoryStream::InSharedMemoryStream()
32 {
33 pShared = NULL;
34 nOffset = 0;
35 }
36
37
38 InSharedMemoryStream::~InSharedMemoryStream()
39 {
40 release_shared();
41 }
42
43 InSharedMemoryStream::InSharedMemoryStream(void *data, size_t size, lsp_memdrop_t drop)
44 {
45 shared_data_t *shared = static_cast<shared_data_t *>(malloc(sizeof(shared_data_t)));
46 if (shared != NULL)
47 {
48 shared->pData = static_cast<uint8_t *>(data);
49 shared->nSize = size;
50 shared->nRefs = 1;
51 shared->enDrop = drop;
52 }
53
54 pShared = shared;
55 nOffset = 0;
56 }
57
58 InSharedMemoryStream::InSharedMemoryStream(const void *data, size_t size)
59 {
60 shared_data_t *shared = static_cast<shared_data_t *>(malloc(sizeof(shared_data_t)));
61 if (shared != NULL)
62 {
63 shared->pData = reinterpret_cast<uint8_t *>(const_cast<void *>(data));
64 shared->nSize = size;
65 shared->nRefs = 1;
66 shared->enDrop = MEMDROP_NONE;
67 }
68
69 pShared = shared;
70 nOffset = 0;
71 }
72
73 InSharedMemoryStream::InSharedMemoryStream(const InSharedMemoryStream *src)
74 {
75 pShared = src->pShared;
76 nOffset = src->nOffset;
77 if (pShared != NULL)
78 ++pShared->nRefs;
79 }
80
81 InSharedMemoryStream::InSharedMemoryStream(const InSharedMemoryStream &src)
82 {
83 pShared = src.pShared;
84 nOffset = src.nOffset;
85 if (pShared != NULL)
86 ++pShared->nRefs;
87 }
88
89 InSharedMemoryStream::InSharedMemoryStream(InSharedMemoryStream && src)
90 {
91 pShared = src.pShared;
92 nOffset = src.nOffset;
93 src.pShared = NULL;
94 src.nOffset = 0;
95 }
96
97 InSharedMemoryStream & InSharedMemoryStream::operator = (const InSharedMemoryStream & src)
98 {
99 release_shared();
100
101 pShared = src.pShared;
102 nOffset = src.nOffset;
103 if (pShared != NULL)
104 ++pShared->nRefs;
105 return *this;
106 }
107
108 InSharedMemoryStream & InSharedMemoryStream::operator = (InSharedMemoryStream && src)
109 {
110 release_shared();
111
112 pShared = src.pShared;
113 nOffset = src.nOffset;
114 src.pShared = NULL;
115 src.nOffset = 0;
116 return *this;
117 }
118
119 void InSharedMemoryStream::release_shared()
120 {
121 if (pShared == NULL)
122 return;
123 if ((--pShared->nRefs) == 0)
124 {
125 switch (pShared->enDrop)
126 {
127 case MEMDROP_FREE: free(pShared->pData); break;
128 case MEMDROP_DELETE: delete pShared->pData; break;
129 case MEMDROP_ARR_DELETE: delete [] pShared->pData; break;
130 default: break;
131 }
132 free(pShared);
133 }
134 pShared = NULL;
135 nOffset = 0;
136 }
137
138 status_t InSharedMemoryStream::wrap(void *data, size_t size, lsp_memdrop_t drop)
139 {
140 shared_data_t *shared = static_cast<shared_data_t *>(malloc(sizeof(shared_data_t)));
141 if (shared == NULL)
142 return STATUS_NO_MEM;
143
144 release_shared();
145
146 shared->pData = static_cast<uint8_t *>(data);
147 shared->nSize = size;
148 shared->nRefs = 1;
149 shared->enDrop = drop;
150
151 pShared = shared;
152 nOffset = 0;
153
154 return STATUS_OK;
155 }
156
157 status_t InSharedMemoryStream::wrap(const void *data, size_t size)
158 {
159 shared_data_t *shared = static_cast<shared_data_t *>(malloc(sizeof(shared_data_t)));
160 if (shared == NULL)
161 return STATUS_NO_MEM;
162
163 release_shared();
164
165 shared->pData = reinterpret_cast<uint8_t *>(const_cast<void *>(data));
166 shared->nSize = size;
167 shared->nRefs = 1;
168 shared->enDrop = MEMDROP_NONE;
169
170 pShared = shared;
171 nOffset = 0;
172
173 return STATUS_OK;
174 }
175
176 void InSharedMemoryStream::wrap(const InSharedMemoryStream &src)
177 {
178 release_shared();
179
180 pShared = src.pShared;
181 nOffset = src.nOffset;
182 if (pShared != NULL)
183 ++pShared->nRefs;
184 }
185
186 void InSharedMemoryStream::wrap(const InSharedMemoryStream *src)
187 {
188 release_shared();
189
190 pShared = src->pShared;
191 nOffset = src->nOffset;
192 if (pShared != NULL)
193 ++pShared->nRefs;
194 }
195
196 void InSharedMemoryStream::wrap(const InSharedMemoryStream &src, wsize_t offset)
197 {
198 release_shared();
199
200 pShared = src.pShared;
201 nOffset = offset;
202 if (pShared != NULL)
203 ++pShared->nRefs;
204 }
205
206 void InSharedMemoryStream::wrap(const InSharedMemoryStream *src, wsize_t offset)
207 {
208 release_shared();
209
210 pShared = src->pShared;
211 nOffset = offset;
212 if (pShared != NULL)
213 ++pShared->nRefs;
214 }
215
216 wssize_t InSharedMemoryStream::avail()
217 {
218 if (pShared == NULL)
219 return -set_error(STATUS_NO_DATA);
220 return pShared->nSize - nOffset;
221 }
222
223 wssize_t InSharedMemoryStream::position()
224 {
225 if (pShared == NULL)
226 return -set_error(STATUS_NO_DATA);
227 return nOffset;
228 }
229
230 ssize_t InSharedMemoryStream::read(void *dst, size_t count)
231 {
232 if (pShared == NULL)
233 return -set_error(STATUS_NO_DATA);
234
235 size_t avail = pShared->nSize - nOffset;
236 if (count > avail)
237 count = avail;
238 if (count <= 0)
239 return -set_error(STATUS_EOF);
240
241 ::memcpy(dst, &pShared->pData[nOffset], count);
242 nOffset += count;
243 return count;
244 }
245
246 ssize_t InSharedMemoryStream::read_byte()
247 {
248 if (pShared == NULL)
249 return -set_error(STATUS_NO_DATA);
250 return (nOffset < pShared->nSize) ? pShared->pData[nOffset++] : -STATUS_EOF;
251 }
252
253 wssize_t InSharedMemoryStream::seek(wsize_t position)
254 {
255 if (pShared == NULL)
256 return -set_error(STATUS_NO_DATA);
257 if (position > pShared->nSize)
258 position = pShared->nSize;
259
260 return nOffset = position;
261 }
262
263 wssize_t InSharedMemoryStream::skip(wsize_t amount)
264 {
265 if (pShared == NULL)
266 return -set_error(STATUS_NO_DATA);
267 size_t avail = pShared->nSize - nOffset;
268 if (avail > amount)
269 avail = amount;
270 nOffset += avail;
271 return avail;
272 }
273
274 status_t InSharedMemoryStream::close()
275 {
276 release_shared();
277 return STATUS_OK;
278 }
279
280 void InSharedMemoryStream::swap(InSharedMemoryStream &src)
281 {
282 lsp::swap(pShared, src.pShared);
283 lsp::swap(nOffset, src.nOffset);
284 }
285
286 void InSharedMemoryStream::swap(InSharedMemoryStream *src)
287 {
288 lsp::swap(pShared, src->pShared);
289 lsp::swap(nOffset, src->nOffset);
290 }
291
292 void InSharedMemoryStream::take(InSharedMemoryStream &src)
293 {
294 release_shared();
295
296 pShared = src.pShared;
297 nOffset = src.nOffset;
298
299 src.pShared = NULL;
300 src.nOffset = 0;
301 }
302
303 void InSharedMemoryStream::take(InSharedMemoryStream *src)
304 {
305 release_shared();
306
307 pShared = src->pShared;
308 nOffset = src->nOffset;
309
310 src->pShared = NULL;
311 src->nOffset = 0;
312 }
313
314 status_t InSharedMemoryStream::take(OutMemoryStream &src)
315 {
316 release_shared();
317 if (src.data() == NULL)
318 return STATUS_OK;
319
320 status_t res = wrap(const_cast<uint8_t *>(src.data()), src.size(), MEMDROP_FREE);
321 if (res == STATUS_OK)
322 src.release();
323 return res;
324 }
325
326 status_t InSharedMemoryStream::take(OutMemoryStream *src)
327 {
328 release_shared();
329 if (src->data() == NULL)
330 return STATUS_OK;
331
332 status_t res = wrap(const_cast<uint8_t *>(src->data()), src->size(), MEMDROP_FREE);
333 if (res == STATUS_OK)
334 src->release();
335 return res;
336 }
337
338 } /* namespace io */
339 } /* namespace lsp */
340
341