/* * Copyright (C) 2023 Linux Studio Plugins Project * (C) 2023 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 22 февр. 2023 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #include #include #include namespace lsp { namespace io { InSharedMemoryStream::InSharedMemoryStream() { pShared = NULL; nOffset = 0; } InSharedMemoryStream::~InSharedMemoryStream() { release_shared(); } InSharedMemoryStream::InSharedMemoryStream(void *data, size_t size, lsp_memdrop_t drop) { shared_data_t *shared = static_cast(malloc(sizeof(shared_data_t))); if (shared != NULL) { shared->pData = static_cast(data); shared->nSize = size; shared->nRefs = 1; shared->enDrop = drop; } pShared = shared; nOffset = 0; } InSharedMemoryStream::InSharedMemoryStream(const void *data, size_t size) { shared_data_t *shared = static_cast(malloc(sizeof(shared_data_t))); if (shared != NULL) { shared->pData = reinterpret_cast(const_cast(data)); shared->nSize = size; shared->nRefs = 1; shared->enDrop = MEMDROP_NONE; } pShared = shared; nOffset = 0; } InSharedMemoryStream::InSharedMemoryStream(const InSharedMemoryStream *src) { pShared = src->pShared; nOffset = src->nOffset; if (pShared != NULL) ++pShared->nRefs; } InSharedMemoryStream::InSharedMemoryStream(const InSharedMemoryStream &src) { pShared = src.pShared; nOffset = src.nOffset; if (pShared != NULL) ++pShared->nRefs; } InSharedMemoryStream::InSharedMemoryStream(InSharedMemoryStream && src) { pShared = src.pShared; nOffset = src.nOffset; src.pShared = NULL; src.nOffset = 0; } InSharedMemoryStream & InSharedMemoryStream::operator = (const InSharedMemoryStream & src) { release_shared(); pShared = src.pShared; nOffset = src.nOffset; if (pShared != NULL) ++pShared->nRefs; return *this; } InSharedMemoryStream & InSharedMemoryStream::operator = (InSharedMemoryStream && src) { release_shared(); pShared = src.pShared; nOffset = src.nOffset; src.pShared = NULL; src.nOffset = 0; return *this; } void InSharedMemoryStream::release_shared() { if (pShared == NULL) return; if ((--pShared->nRefs) == 0) { switch (pShared->enDrop) { case MEMDROP_FREE: free(pShared->pData); break; case MEMDROP_DELETE: delete pShared->pData; break; case MEMDROP_ARR_DELETE: delete [] pShared->pData; break; default: break; } free(pShared); } pShared = NULL; nOffset = 0; } status_t InSharedMemoryStream::wrap(void *data, size_t size, lsp_memdrop_t drop) { shared_data_t *shared = static_cast(malloc(sizeof(shared_data_t))); if (shared == NULL) return STATUS_NO_MEM; release_shared(); shared->pData = static_cast(data); shared->nSize = size; shared->nRefs = 1; shared->enDrop = drop; pShared = shared; nOffset = 0; return STATUS_OK; } status_t InSharedMemoryStream::wrap(const void *data, size_t size) { shared_data_t *shared = static_cast(malloc(sizeof(shared_data_t))); if (shared == NULL) return STATUS_NO_MEM; release_shared(); shared->pData = reinterpret_cast(const_cast(data)); shared->nSize = size; shared->nRefs = 1; shared->enDrop = MEMDROP_NONE; pShared = shared; nOffset = 0; return STATUS_OK; } void InSharedMemoryStream::wrap(const InSharedMemoryStream &src) { release_shared(); pShared = src.pShared; nOffset = src.nOffset; if (pShared != NULL) ++pShared->nRefs; } void InSharedMemoryStream::wrap(const InSharedMemoryStream *src) { release_shared(); pShared = src->pShared; nOffset = src->nOffset; if (pShared != NULL) ++pShared->nRefs; } void InSharedMemoryStream::wrap(const InSharedMemoryStream &src, wsize_t offset) { release_shared(); pShared = src.pShared; nOffset = offset; if (pShared != NULL) ++pShared->nRefs; } void InSharedMemoryStream::wrap(const InSharedMemoryStream *src, wsize_t offset) { release_shared(); pShared = src->pShared; nOffset = offset; if (pShared != NULL) ++pShared->nRefs; } wssize_t InSharedMemoryStream::avail() { if (pShared == NULL) return -set_error(STATUS_NO_DATA); return pShared->nSize - nOffset; } wssize_t InSharedMemoryStream::position() { if (pShared == NULL) return -set_error(STATUS_NO_DATA); return nOffset; } ssize_t InSharedMemoryStream::read(void *dst, size_t count) { if (pShared == NULL) return -set_error(STATUS_NO_DATA); size_t avail = pShared->nSize - nOffset; if (count > avail) count = avail; if (count <= 0) return -set_error(STATUS_EOF); ::memcpy(dst, &pShared->pData[nOffset], count); nOffset += count; return count; } ssize_t InSharedMemoryStream::read_byte() { if (pShared == NULL) return -set_error(STATUS_NO_DATA); return (nOffset < pShared->nSize) ? pShared->pData[nOffset++] : -STATUS_EOF; } wssize_t InSharedMemoryStream::seek(wsize_t position) { if (pShared == NULL) return -set_error(STATUS_NO_DATA); if (position > pShared->nSize) position = pShared->nSize; return nOffset = position; } wssize_t InSharedMemoryStream::skip(wsize_t amount) { if (pShared == NULL) return -set_error(STATUS_NO_DATA); size_t avail = pShared->nSize - nOffset; if (avail > amount) avail = amount; nOffset += avail; return avail; } status_t InSharedMemoryStream::close() { release_shared(); return STATUS_OK; } void InSharedMemoryStream::swap(InSharedMemoryStream &src) { lsp::swap(pShared, src.pShared); lsp::swap(nOffset, src.nOffset); } void InSharedMemoryStream::swap(InSharedMemoryStream *src) { lsp::swap(pShared, src->pShared); lsp::swap(nOffset, src->nOffset); } void InSharedMemoryStream::take(InSharedMemoryStream &src) { release_shared(); pShared = src.pShared; nOffset = src.nOffset; src.pShared = NULL; src.nOffset = 0; } void InSharedMemoryStream::take(InSharedMemoryStream *src) { release_shared(); pShared = src->pShared; nOffset = src->nOffset; src->pShared = NULL; src->nOffset = 0; } status_t InSharedMemoryStream::take(OutMemoryStream &src) { release_shared(); if (src.data() == NULL) return STATUS_OK; status_t res = wrap(const_cast(src.data()), src.size(), MEMDROP_FREE); if (res == STATUS_OK) src.release(); return res; } status_t InSharedMemoryStream::take(OutMemoryStream *src) { release_shared(); if (src->data() == NULL) return STATUS_OK; status_t res = wrap(const_cast(src->data()), src->size(), MEMDROP_FREE); if (res == STATUS_OK) src->release(); return res; } } /* namespace io */ } /* namespace lsp */