/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 24 окт. 2022 г. * * 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 #include #include #include namespace lsp { namespace lspc { static IAudioFormatSelector default_selector; LSP_RUNTIME_LIB_PUBLIC status_t write_audio(chunk_id_t *chunk_id, File *file, const char *path, IAudioFormatSelector *selector, size_t buf_size) { mm::InAudioFileStream is; status_t res = is.open(path); if (res != STATUS_OK) return res; res = write_audio(chunk_id, file, &is, selector, buf_size); status_t res2 = is.close(); return (res != STATUS_OK) ? res2 : res; } LSP_RUNTIME_LIB_PUBLIC status_t write_audio(chunk_id_t *chunk_id, File *file, const io::Path *path, IAudioFormatSelector *selector, size_t buf_size) { mm::InAudioFileStream is; status_t res = is.open(path); if (res != STATUS_OK) return res; res = write_audio(chunk_id, file, &is, selector, buf_size); status_t res2 = is.close(); return (res != STATUS_OK) ? res2 : res; } LSP_RUNTIME_LIB_PUBLIC status_t write_audio(chunk_id_t *chunk_id, File *file, const LSPString *path, IAudioFormatSelector *selector, size_t buf_size) { mm::InAudioFileStream is; status_t res = is.open(path); if (res != STATUS_OK) return res; res = write_audio(chunk_id, file, &is, selector, buf_size); status_t res2 = is.close(); return (res != STATUS_OK) ? res2 : res; } LSP_RUNTIME_LIB_PUBLIC status_t write_audio(chunk_id_t *chunk_id, File *file, mm::IInAudioStream *is, IAudioFormatSelector *selector, size_t buf_size) { status_t res; if (is == NULL) return STATUS_BAD_ARGUMENTS; // Select audio format audio_format_t ofmt; mm::audio_stream_t ifmt; if ((res = is->info(&ifmt)) != STATUS_OK) return res; if (selector == NULL) selector = &default_selector; if ((res = selector->decide(&ofmt, &ifmt)) != STATUS_OK) return res; // Create audio writer audio_parameters_t params; AudioWriter wr; params.channels = ifmt.channels; params.frames = ifmt.frames; params.sample_rate = ofmt.sample_rate; params.codec = ofmt.codec; params.sample_format= ofmt.sample_format; if ((res = wr.open(file, ¶ms, false)) != STATUS_OK) return res; lsp_finally { wr.close(); }; chunk_id_t res_chunk_id = wr.unique_id(); // Allocate buffer for I/O size_t min_buf_size = ifmt.channels * sizeof(float); buf_size = lsp_max(min_buf_size, buf_size - (buf_size % min_buf_size)); float *data = static_cast(malloc(buf_size)); if (data == NULL) return STATUS_NO_MEM; lsp_finally { free(data); }; ssize_t max_frames = buf_size / (ifmt.channels * sizeof(float)); // Perform data copy for (wssize_t frame = 0; frame < ifmt.frames; ) { size_t to_do = lsp_min(max_frames, ifmt.frames - frame); ssize_t nread = is->read(data, to_do); if (nread < 0) return status_t(-nread); if ((res = wr.write_frames(data, nread)) != STATUS_OK) return res; frame += nread; } // Close the audio chunk writer if ((res = wr.close()) != STATUS_OK) return res; // Return success result if (chunk_id != NULL) *chunk_id = res_chunk_id; return STATUS_OK; } LSP_RUNTIME_LIB_PUBLIC status_t write_audio( chunk_id_t *chunk_id, File *file, const float *frames, const audio_parameters_t *params) { status_t res; if ((frames == NULL) || (params == NULL)) return STATUS_BAD_ARGUMENTS; // Create audio writer AudioWriter wr; if ((res = wr.open(file, params, false)) != STATUS_OK) return res; lsp_finally { wr.close(); }; chunk_id_t res_chunk_id = wr.unique_id(); // Perform data write if ((res = wr.write_frames(frames, params->frames)) != STATUS_OK) return res; // Close the audio chunk writer if ((res = wr.close()) != STATUS_OK) return res; // Return success result if (chunk_id != NULL) *chunk_id = res_chunk_id; return STATUS_OK; } status_t copy_frames(mm::IOutAudioStream *os, lspc::AudioReader *is, const audio_parameters_t *params, size_t buf_size) { // Allocate buffer for I/O size_t min_buf_size = params->channels * sizeof(float); buf_size = lsp_max(min_buf_size, buf_size - (buf_size % min_buf_size)); float *data = static_cast(malloc(buf_size)); if (data == NULL) return STATUS_NO_MEM; lsp_finally { free(data); }; size_t max_frames = buf_size / (params->channels * sizeof(float)); // Perform data copy for (wsize_t frame = 0; frame < params->frames; ) { size_t to_do = lsp_min(max_frames, params->frames - frame); ssize_t nread = is->read_frames(data, to_do); if (nread < 0) return status_t(-nread); ssize_t nwritten = os->write(data, nread); if (nwritten < 0) return status_t(-nwritten); else if (nwritten < nread) return STATUS_IO_ERROR; frame += nread; } // Return success result return STATUS_OK; } LSP_RUNTIME_LIB_PUBLIC status_t read_audio( chunk_id_t chunk_id, File *file, const char *path, size_t format, size_t codec, size_t buf_size) { io::Path tmp; status_t res = tmp.set(path); if (res != STATUS_OK) return res; return read_audio(chunk_id, file, &tmp, format, codec, buf_size); } LSP_RUNTIME_LIB_PUBLIC status_t read_audio( chunk_id_t chunk_id, File *file, const LSPString *path, size_t format, size_t codec, size_t buf_size) { io::Path tmp; status_t res = tmp.set(path); if (res != STATUS_OK) return res; return read_audio(chunk_id, file, &tmp, format, codec, buf_size); } LSP_RUNTIME_LIB_PUBLIC status_t read_audio( chunk_id_t chunk_id, File *file, const io::Path *path, size_t format, size_t codec, size_t buf_size) { if ((file == NULL) || (path == NULL)) return STATUS_BAD_ARGUMENTS; // Read the chunk lspc::AudioReader rd; status_t res = rd.open(file, chunk_id); if (res != STATUS_OK) return res; lsp_finally { rd.close(); }; // Get audio parameters and open output audio stream audio_parameters_t aparams; mm::audio_stream_t sparams; mm::OutAudioFileStream os; if ((res = rd.get_parameters(&aparams)) != STATUS_OK) return res; sparams.channels = aparams.channels; sparams.srate = aparams.sample_rate; sparams.frames = aparams.frames; sparams.format = format; if ((res = os.open(path, &sparams, codec)) != STATUS_OK) return res; lsp_finally { os.close(); }; // Copy data and close streams if ((res = copy_frames(&os, &rd, &aparams, buf_size)) != STATUS_OK) return res; if ((res = os.close()) != STATUS_OK) return res; if ((res = rd.close()) != STATUS_OK) return res; // Return result return STATUS_OK; } LSP_RUNTIME_LIB_PUBLIC status_t read_audio( chunk_id_t chunk_id, File *file, float **frames, audio_parameters_t *params) { if ((file == NULL) || (frames == NULL)) return STATUS_BAD_ARGUMENTS; // Read the chunk lspc::AudioReader rd; status_t res = rd.open(file, chunk_id); if (res != STATUS_OK) return res; lsp_finally { rd.close(); }; // Get audio parameters audio_parameters_t aparams; if ((res = rd.get_parameters(&aparams)) != STATUS_OK) return res; // Allocate the buffer of necessary size size_t buf_size = align_size(sizeof(float) * aparams.channels * aparams.frames, DEFAULT_ALIGN); float *data = static_cast(malloc(buf_size)); if (data == NULL) return STATUS_NO_MEM; lsp_finally { if (data != NULL) free(data); }; // Read the contents and close stream wssize_t read = rd.read_frames(data, aparams.frames); if (read < 0) return status_t(-read); else if (read < wssize_t(aparams.frames)) return STATUS_CORRUPTED; if ((res = rd.close()) != STATUS_OK) return res; // Return the result *frames = data; data = NULL; if (params != NULL) *params = aparams; return STATUS_OK; } LSP_RUNTIME_LIB_PUBLIC status_t read_audio( chunk_id_t chunk_id, File *file, mm::IOutAudioStream *os, audio_parameters_t *params, size_t buf_size) { if ((file == NULL) || (os == NULL)) return STATUS_BAD_ARGUMENTS; // Read the chunk lspc::AudioReader rd; status_t res = rd.open(file, chunk_id); if (res != STATUS_OK) return res; lsp_finally { rd.close(); }; // Get audio parameters audio_parameters_t aparams; if ((res = rd.get_parameters(&aparams)) != STATUS_OK) return res; if (os->sample_rate() != aparams.sample_rate) return STATUS_INCOMPATIBLE; // Copy data and close streams if ((res = copy_frames(os, &rd, &aparams, buf_size)) != STATUS_OK) return res; if ((res = rd.close()) != STATUS_OK) return res; // Return result if (params != NULL) *params = aparams; return STATUS_OK; } LSP_RUNTIME_LIB_PUBLIC status_t read_audio(chunk_id_t chunk_id, File *file, mm::IInAudioStream **is) { if ((file == NULL) || (is == NULL)) return STATUS_BAD_ARGUMENTS; // Read the chunk lspc::AudioReader *rd = new lspc::AudioReader(); if (rd == NULL) return STATUS_NO_MEM; lsp_finally { if (rd != NULL) delete rd; }; status_t res = rd->open(file, chunk_id); if (res != STATUS_OK) return res; // Get audio parameters mm::audio_stream_t sparams; audio_parameters_t aparams; if ((res = rd->get_parameters(&aparams)) != STATUS_OK) return res; sparams.srate = aparams.sample_rate; sparams.channels = aparams.channels; sparams.frames = aparams.frames; sparams.format = mm::SFMT_F32_CPU; // Create audio stream InAudioStream *ias = new InAudioStream(rd, &sparams, true); if (ias == NULL) return STATUS_NO_MEM; // Return result *is = ias; ias = NULL; rd = NULL; return STATUS_OK; } } /* namespace lspc */ } /* namespace lsp */