/* * Copyright (C) 2023 Linux Studio Plugins Project * (C) 2023 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 16 апр. 2020 г. * * 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 namespace lsp { namespace mm { IInAudioStream::IInAudioStream() { nOffset = -1; pBuffer = NULL; nBufSize = 0; nErrorCode = STATUS_CLOSED; pUserData = NULL; pDeleter = NULL; } IInAudioStream::~IInAudioStream() { do_close(); set_user_data(NULL); } void IInAudioStream::set_user_data(void *data, user_data_deleter_t deleter) { if (pDeleter != NULL) pDeleter(pUserData); pUserData = data; pDeleter = deleter; } void IInAudioStream::do_close() { // Free allocated buffer if present if (pBuffer != NULL) { ::free(pBuffer); pBuffer = NULL; } nOffset = -1; // Mark as closed } status_t IInAudioStream::close() { do_close(); return set_error(STATUS_OK); } status_t IInAudioStream::info(audio_stream_t *dst) const { if (dst == NULL) return STATUS_BAD_ARGUMENTS; dst->srate = sample_rate(); dst->channels = channels(); dst->frames = length(); dst->format = format(); return STATUS_OK; } size_t IInAudioStream::sample_rate() const { return 0; } size_t IInAudioStream::channels() const { return 0; } wssize_t IInAudioStream::length() const { return -1; } size_t IInAudioStream::format() const { return SFMT_NONE; } wssize_t IInAudioStream::skip(wsize_t nframes) { if (nframes == 0) { set_error(STATUS_OK); return 0; } // Select format and check frame size size_t afmt = select_format(0); size_t asize = sformat_size_of(afmt) * channels(); if (asize <= 0) return -set_error(STATUS_UNSUPPORTED_FORMAT); // Perform direct read wssize_t nread = 0; do { // Ensure capacity size_t to_read = (nframes > IO_BUF_SIZE) ? IO_BUF_SIZE : nframes; if (!ensure_capacity(to_read * asize)) return -set_error(STATUS_NO_MEM); // Perform read ssize_t read = direct_read(pBuffer, to_read, 0); if (read < 0) { if (nread > 0) break; set_error(-status_t(nread)); return nread; } // Update position nframes -= read; nread += read; } while (nframes > 0); // Update statistics set_error(STATUS_OK); nOffset += nread; return nread; } wssize_t IInAudioStream::position() { return (nOffset >= 0) ? nOffset : -set_error(STATUS_CLOSED); } wssize_t IInAudioStream::seek(wsize_t offset) { if (nOffset < 0) return -set_error(STATUS_CLOSED); if (nOffset > wssize_t(offset)) return -set_error(STATUS_NOT_SUPPORTED); return skip(offset - nOffset); } ssize_t IInAudioStream::direct_read(void *dst, size_t nframes, size_t fmt) { return -STATUS_NOT_IMPLEMENTED; } size_t IInAudioStream::select_format(size_t fmt) { return 0; } bool IInAudioStream::ensure_capacity(size_t bytes) { // Not enough space in temporary buffer? if (nBufSize >= bytes) return true; // Perform buffer re-allocation bytes = align_size(bytes, 0x200); uint8_t *buf = static_cast(::realloc(pBuffer, bytes)); if (buf == NULL) return false; pBuffer = buf; nBufSize = bytes; return true; } ssize_t IInAudioStream::conv_read(void *dst, size_t nframes, size_t fmt) { if (nOffset < 0) return -set_error(STATUS_CLOSED); // Prepare pointers and remember frame size size_t nchan = channels(); size_t fsize = sformat_size_of(fmt) * nchan; if (fsize <= 0) return -set_error(STATUS_BAD_FORMAT); size_t afmt = select_format(fmt); size_t asize = sformat_size_of(afmt) * nchan; if (asize <= 0) return -set_error(STATUS_UNSUPPORTED_FORMAT); uint8_t *dptr = static_cast(dst); size_t nread = 0; // Perform direct read if (fmt != afmt) { while (nframes > 0) { // Ensure capacity size_t to_read = lsp_min(nframes, IO_BUF_SIZE); if (!ensure_capacity(to_read * asize)) return -set_error(STATUS_NO_MEM); // Perform direct read ssize_t read = direct_read(pBuffer, to_read, afmt); // Analyze read status if (read < 0) { if (nread > 0) break; set_error(-status_t(read)); return read; } // Data is stored in pBuffer which can be updated, perform sample conversion if (!convert_samples(dptr, pBuffer, read * nchan, fmt, afmt)) return -set_error(STATUS_UNSUPPORTED_FORMAT); // Update position and pointers nframes -= read; nread += read; dptr += fsize * read; } } else { while (nframes > 0) { // Select number of frames and perform read size_t to_read = lsp_min(nframes, IO_BUF_SIZE); ssize_t read = direct_read(dptr, to_read, afmt); // Analyze read status if (read < 0) { if (nread > 0) break; set_error(-status_t(read)); return read; } // Update position and pointers nframes -= read; nread += read; dptr += fsize * read; } } // Update statistics set_error(STATUS_OK); nOffset += nread; return nread; } ssize_t IInAudioStream::read(uint8_t *dst, size_t nframes) { return conv_read(dst, nframes, SFMT_U8 | SFMT_CPU); } ssize_t IInAudioStream::read(int8_t *dst, size_t nframes) { return conv_read(dst, nframes, SFMT_S8 | SFMT_CPU); } ssize_t IInAudioStream::read(uint16_t *dst, size_t nframes) { return conv_read(dst, nframes, SFMT_U16 | SFMT_CPU); } ssize_t IInAudioStream::read(int16_t *dst, size_t nframes) { return conv_read(dst, nframes, SFMT_S16 | SFMT_CPU); } ssize_t IInAudioStream::read(uint32_t *dst, size_t nframes) { return conv_read(dst, nframes, SFMT_U32 | SFMT_CPU); } ssize_t IInAudioStream::read(int32_t *dst, size_t nframes) { return conv_read(dst, nframes, SFMT_S32 | SFMT_CPU); } ssize_t IInAudioStream::read(f32_t *dst, size_t nframes) { return conv_read(dst, nframes, SFMT_F32 | SFMT_CPU); } ssize_t IInAudioStream::read(f64_t *dst, size_t nframes) { return conv_read(dst, nframes, SFMT_F64 | SFMT_CPU); } } /* namespace mm */ } /* namespace lsp */