/* * Copyright (C) 2026 Linux Studio Plugins Project * (C) 2026 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 25 янв. 2026 г. * * 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 #include #include #include namespace lsp { namespace mm { static inline bool is_exact_copy(pixel_format_t a, pixel_format_t b) { if (a == b) return true; switch (a) { case PIXFMT_G1: return b == PIXFMT_A1; case PIXFMT_G2: return b == PIXFMT_A2; case PIXFMT_G4: return b == PIXFMT_A4; case PIXFMT_G8: return b == PIXFMT_A8; case PIXFMT_A1: return b == PIXFMT_G1; case PIXFMT_A2: return b == PIXFMT_G2; case PIXFMT_A4: return b == PIXFMT_G4; case PIXFMT_A8: return b == PIXFMT_G8; default: break; } return false; } Bitmap::Bitmap() noexcept { pData = NULL; nWidth = 0; nHeight = 0; nStride = 0; enFormat = PIXFMT_RGBA8888; } Bitmap::Bitmap(const Bitmap & src) { pData = NULL; nWidth = 0; nHeight = 0; nStride = 0; enFormat = PIXFMT_RGBA8888; set(src); } Bitmap::Bitmap(const Bitmap * src) { pData = NULL; nWidth = 0; nHeight = 0; nStride = 0; enFormat = PIXFMT_RGBA8888; set(src); } Bitmap::Bitmap(Bitmap && src) noexcept { pData = lsp::exchange(src.pData, static_cast(NULL)); nWidth = lsp::exchange(src.nWidth, 0); nHeight = lsp::exchange(src.nHeight, 0); nStride = lsp::exchange(src.nStride, 0); enFormat = lsp::exchange(src.enFormat, PIXFMT_RGBA8888); } Bitmap::~Bitmap() { if (pData != NULL) { free(pData); pData = NULL; } } inline size_t Bitmap::calc_bytes_per_row(pixel_format_t format, size_t cols) noexcept { const size_t bpp = device_bits_per_pixel(format); return (bpp * cols + 7) >> 3; } inline size_t Bitmap::calc_stride(pixel_format_t format, size_t cols) noexcept { const size_t bpp = device_bits_per_pixel(format); return (bpp <= 8) ? (bpp * cols + 7) >> 3 : ((bpp * cols + 31) & (~size_t(0x1f))) >> 3; } Bitmap & Bitmap::operator = (Bitmap && src) noexcept { pData = lsp::exchange(src.pData, static_cast(NULL)); nWidth = lsp::exchange(src.nWidth, 0); nHeight = lsp::exchange(src.nHeight, 0); nStride = lsp::exchange(src.nStride, 0); enFormat = lsp::exchange(src.enFormat, PIXFMT_RGBA8888); return *this; } Bitmap & Bitmap::operator = (const Bitmap & src) { set(src); return *this; } Bitmap & Bitmap::operator = (const Bitmap * src) { set(src); return *this; } void Bitmap::swap(Bitmap & src) noexcept { lsp::swap(pData, src.pData); lsp::swap(nWidth, src.nWidth); lsp::swap(nHeight, src.nHeight); lsp::swap(nStride, src.nStride); lsp::swap(enFormat, src.enFormat); } void Bitmap::swap(Bitmap * src) noexcept { lsp::swap(pData, src->pData); lsp::swap(nWidth, src->nWidth); lsp::swap(nHeight, src->nHeight); lsp::swap(nStride, src->nStride); lsp::swap(enFormat, src->enFormat); } void Bitmap::reset() { if (pData != NULL) { free(pData); pData = NULL; } nWidth = 0; nHeight = 0; nStride = 0; } status_t Bitmap::init(pixel_format_t format, size_t width, size_t height) { if (format == PIXFMT_DEFAULT) return STATUS_INVALID_VALUE; if ((height <= 0) || (width <= 0)) { reset(); enFormat = format; return STATUS_OK; } const size_t stride = calc_stride(format, width); const size_t to_alloc = stride * height; uint8_t * data = static_cast(realloc(pData, to_alloc)); if (data == NULL) return STATUS_NO_MEM; // Cleanup data bzero(data, to_alloc); // Commit data pData = data; nWidth = width; nHeight = height; nStride = stride; enFormat = format; return STATUS_OK; } status_t Bitmap::set(const Bitmap & src) { if (src.pData == NULL) { reset(); enFormat = src.enFormat; return STATUS_OK; } // Compute parameters of the new bitmap uint8_t * data = static_cast(realloc(pData, src.nHeight * src.nStride)); if (data == NULL) return STATUS_NO_MEM; lsp_finally { if (data != NULL) free(data); }; // Copy data memcpy(data, src.pData, src.nHeight * src.nStride); pData = data; nWidth = src.nWidth; nHeight = src.nHeight; nStride = src.nStride; enFormat = src.enFormat; return STATUS_OK; } status_t Bitmap::set(const Bitmap * src) { if (src == NULL) return STATUS_BAD_ARGUMENTS; return set(*src); } status_t Bitmap::load(const char *path, pixel_format_t format, IColorMap *map) { if (path == NULL) return STATUS_BAD_ARGUMENTS; io::InFileStream ifs; status_t res = ifs.open(path); if (res != STATUS_OK) return res; res = update_status(res, do_load(&ifs, format, map)); return update_status(res, ifs.close()); } status_t Bitmap::load(const LSPString *path, pixel_format_t format, IColorMap *map) { return (path != NULL) ? load(*path, format, map) : STATUS_BAD_ARGUMENTS; } status_t Bitmap::load(const LSPString & path, pixel_format_t format, IColorMap *map) { io::InFileStream ifs; status_t res = ifs.open(&path); if (res != STATUS_OK) return res; res = update_status(res, do_load(&ifs, format, map)); return update_status(res, ifs.close()); } status_t Bitmap::load(const io::Path *path, pixel_format_t format, IColorMap *map) { return (path != NULL) ? load(*path, format, map) : STATUS_BAD_ARGUMENTS; } status_t Bitmap::load(const io::Path & path, pixel_format_t format, IColorMap *map) { io::InFileStream ifs; status_t res = ifs.open(&path); if (res != STATUS_OK) return res; res = update_status(res, do_load(&ifs, format, map)); return update_status(res, ifs.close()); } status_t Bitmap::load(const void *data, size_t size, pixel_format_t format, IColorMap *map) { if (data == NULL) return STATUS_BAD_ARGUMENTS; io::InMemoryStream ims; ims.wrap(data, size); status_t res = do_load(&ims, format, map); return update_status(res, ims.close()); } status_t Bitmap::load(io::IInStream *is, pixel_format_t format, IColorMap *map) { io::InBufStream ibs; status_t res = ibs.wrap(is, WRAP_NONE); if (res != STATUS_OK) return res; res = update_status(res, do_load(&ibs, format, map)); return update_status(res, ibs.close()); } status_t Bitmap::do_load(io::IInStream *is, pixel_format_t format, IColorMap *map) { status_t res = load_xpm(is, format, map); if ((res == STATUS_OK) || (res != STATUS_UNSUPPORTED_FORMAT)) return res; return STATUS_UNSUPPORTED_FORMAT; } status_t Bitmap::resize(size_t width, size_t height) { if ((nWidth == width) && (nHeight == height)) return STATUS_OK; // Compute parameters of the new bitmap const size_t stride = calc_stride(enFormat, width); const size_t to_alloc = stride * height; uint8_t * data = static_cast(malloc(to_alloc)); if (data == NULL) return STATUS_NO_MEM; lsp_finally { if (data != NULL) free(data); }; // Preserve previous picture if possible if ((pData != NULL) && (nWidth > 0) && (nHeight > 0)) { const size_t to_copy = lsp_min(stride, nStride); const size_t to_rows = lsp_min(height, nHeight); for (size_t i=0; i(malloc(to_alloc)); if (data == NULL) return STATUS_NO_MEM; lsp_finally { if (data != NULL) free(data); }; // Perform conversion for (size_t r = 0; r < nHeight; ++r) { conversion(&data[r*stride], &pData[r*nStride], nWidth); bzero(&data[r*stride + bpr], stride - bpr); } // Commit new data lsp::swap(dst.pData, data); } dst.nStride = stride; dst.nWidth = nWidth; dst.nHeight = nHeight; dst.enFormat = format; return STATUS_OK; } status_t Bitmap::convert_to(Bitmap *dst, pixel_format_t format) const { return (dst != NULL) ? convert_to(*dst, format) : STATUS_BAD_ARGUMENTS; } status_t Bitmap::convert(pixel_format_t format) { if (enFormat == format) return STATUS_OK; else if (format == PIXFMT_DEFAULT) return STATUS_INVALID_VALUE; // Check that no changes are required to be made if ((nWidth <= 0) || (nHeight <= 0) || (is_exact_copy(enFormat, format))) { enFormat = format; return STATUS_OK; } // Get pixel conversion function const pixel_conversion_t conversion = pixel_convert_function(format, enFormat); if (conversion == NULL) return STATUS_UNSUPPORTED_FORMAT; // Check if we need to perform reallocation const size_t stride = calc_stride(format, nWidth); if (stride == nStride) { // Perform conversion without reallocation for (size_t r = 0; r < nHeight; ++r) conversion(&pData[r*nStride], &pData[r*nStride], nWidth); } else { // Need to re-allocate memory const size_t bpr = calc_bytes_per_row(format, nWidth); const size_t to_alloc = stride * nHeight; uint8_t * data = static_cast(malloc(to_alloc)); if (data == NULL) return STATUS_NO_MEM; lsp_finally { if (data != NULL) free(data); }; // Perform conversion for (size_t r = 0; r < nHeight; ++r) { conversion(&data[r*stride], &pData[r*nStride], nWidth); bzero(&data[r*stride + bpr], stride - bpr); } // Commit new data lsp::swap(pData, data); } nStride = stride; enFormat = format; return STATUS_OK; } status_t Bitmap::convert_from(const Bitmap & src, pixel_format_t format) { return src.convert_to(*this, format); } status_t Bitmap::convert_from(const Bitmap * src, pixel_format_t format) { return (src != NULL) ? src->convert_to(*this, format) : STATUS_BAD_ARGUMENTS; } } /* namespace mm */ } /* namespace lsp */