/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 24 апр. 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 #ifdef PLATFORM_WINDOWS #include #include #include #include #include namespace lsp { namespace mm { MMIOReader::MMIOReader() { hMMIO = NULL; nReadPos = 0; nFrames = -1; bSeekable = false; pFormat = NULL; ::ZeroMemory(&ckRiff, sizeof(MMCKINFO)); ::ZeroMemory(&ckData, sizeof(MMCKINFO)); } MMIOReader::~MMIOReader() { close(); } status_t MMIOReader::close(status_t code) { if (hMMIO != NULL) { ::mmioClose(hMMIO, 0); hMMIO = NULL; } if (pFormat != NULL) { ::free(pFormat); pFormat = NULL; } nFrames = -1; bSeekable = false; ::ZeroMemory(&ckRiff, sizeof(MMCKINFO)); ::ZeroMemory(&ckData, sizeof(MMCKINFO)); return code; } status_t MMIOReader::open(const LSPString *path) { MMCKINFO ckIn; WAVEFORMATEX wfe; MMRESULT error; nReadPos = 0; nFrames = -1; bSeekable = false; if ((hMMIO = ::mmioOpenW(const_cast(path->get_utf16()), NULL, MMIO_ALLOCBUF | MMIO_READ)) == NULL) return STATUS_PERMISSION_DENIED; // Lookup for RIFF chunk if ((error = ::mmioDescend(hMMIO, &ckRiff, NULL, 0)) != 0) return close(STATUS_BAD_FORMAT); if ((ckRiff.ckid != FOURCC_RIFF) || (ckRiff.fccType != mmioFOURCC('W', 'A', 'V', 'E'))) return close(STATUS_BAD_FORMAT); // Reset position if (::mmioSeek(hMMIO, ckRiff.dwDataOffset + sizeof(FOURCC), SEEK_SET) < 0) return close(STATUS_CORRUPTED_FILE); // Lookup for format chunk ckIn.ckid = mmioFOURCC('f', 'm', 't', ' '); if ((error = ::mmioDescend(hMMIO, &ckIn, &ckRiff, MMIO_FINDCHUNK)) != 0) return close(STATUS_BAD_FORMAT); // Expect the 'fmt' chunk to be at least as large as sizeof(PCMWAVEFORMAT) if (ckIn.cksize < sizeof(PCMWAVEFORMAT)) return close(STATUS_CORRUPTED_FILE); // Read the 'fmt ' chunk size_t bytes = ::mmioRead(hMMIO, reinterpret_cast(&wfe), sizeof(PCMWAVEFORMAT)); if (bytes != sizeof(PCMWAVEFORMAT)) return close(STATUS_BAD_FORMAT); // Estimate number of bytes to allocate for the format descriptor size_t ftag = LE_TO_CPU(wfe.wFormatTag); if ((ftag != WAVE_FORMAT_PCM) && (ftag != WAVE_FORMAT_IEEE_FLOAT)) { // Read in length of extra bytes. bytes = ::mmioRead(hMMIO, reinterpret_cast(&wfe.cbSize), sizeof(WORD)); if (bytes != sizeof(WORD)) return close(STATUS_CORRUPTED_FILE); // Allocate memory size_t alloc = sizeof(WAVEFORMATEX) + LE_TO_CPU(wfe.cbSize); pFormat = static_cast(::malloc(align_size(alloc, DEFAULT_ALIGN))); if (pFormat == NULL) return close(STATUS_NO_MEM); ::memcpy(pFormat, &wfe, sizeof(WAVEFORMATEX)); // Read the rest part of format descriptor if (wfe.cbSize > 0) { bytes += ::mmioRead(hMMIO, reinterpret_cast(&pFormat[1]), wfe.cbSize); if (bytes != alloc) return close(STATUS_CORRUPTED_FILE); } } else { // Set size and copy wave format wfe.cbSize = 0; pFormat = static_cast(memdup(&wfe, sizeof(WAVEFORMATEX))); if (pFormat == NULL) return close(STATUS_NO_MEM); bSeekable = true; } // Reset position if (::mmioSeek(hMMIO, ckRiff.dwDataOffset + sizeof(FOURCC), SEEK_SET) < 0) return close(STATUS_CORRUPTED_FILE); // Lookup for 'fact' chunk, read number of samples ckIn.ckid = mmioFOURCC('f', 'a', 'c', 't'); if ((error = ::mmioDescend(hMMIO, &ckIn, &ckRiff, MMIO_FINDCHUNK)) == 0) { if (LE_TO_CPU(ckIn.cksize) >= sizeof(DWORD)) { DWORD factlen = 0; size_t bytes = ::mmioRead(hMMIO, reinterpret_cast(&factlen), sizeof(DWORD)); if (bytes != sizeof(DWORD)) return close(STATUS_CORRUPTED_FILE); nFrames = factlen; } } // Reset position if (::mmioSeek(hMMIO, ckRiff.dwDataOffset + sizeof(FOURCC), SEEK_SET) < 0) return close(STATUS_CORRUPTED_FILE); ckData.ckid = mmioFOURCC('d', 'a', 't', 'a'); if ((error = ::mmioDescend(hMMIO, &ckData, &ckRiff, MMIO_FINDCHUNK)) != 0) return close(STATUS_CORRUPTED_FILE); // Estimate number of frames by the other way (PCM allows this) if (nFrames < 0) { if (LE_TO_CPU(wfe.wFormatTag) == WAVE_FORMAT_PCM) { size_t fsize = LE_TO_CPU(wfe.wBitsPerSample) * LE_TO_CPU(wfe.nChannels); if (fsize & 0x07) // not multiple of 8? return close(STATUS_UNSUPPORTED_FORMAT); fsize >>= 3; // divide by 8 nFrames = ckData.cksize / fsize; if ((nFrames * fsize) != ckData.cksize) return close(STATUS_CORRUPTED_FILE); } else if (LE_TO_CPU(wfe.wFormatTag) == WAVE_FORMAT_IEEE_FLOAT) { if (LE_TO_CPU(wfe.wBitsPerSample) != sizeof(f32_t)*8) return close(STATUS_UNSUPPORTED_FORMAT); const size_t fsize = sizeof(f32_t) * LE_TO_CPU(wfe.nChannels); nFrames = ckData.cksize / fsize; if ((nFrames * fsize) != ckData.cksize) return close(STATUS_CORRUPTED_FILE); } } return STATUS_OK; } wssize_t MMIOReader::seek(wsize_t offset) { if (!bSeekable) return -STATUS_NOT_SUPPORTED; if (offset > ckData.cksize) offset = ckData.cksize; if (::mmioSeek(hMMIO, ckData.dwDataOffset + offset, SEEK_SET) < 0) return -STATUS_IO_ERROR; return nReadPos = offset; } ssize_t MMIOReader::read(void *buf, size_t count) { // Compute how many bytes we can read wssize_t can_read = ckData.cksize - nReadPos; if (can_read <= 0) return -STATUS_EOF; if (count > size_t(can_read)) count = can_read; // Perform read LONG res = ::mmioRead(hMMIO, reinterpret_cast(buf), count); if (res < 0) return -STATUS_IO_ERROR; nReadPos += res; return res; } } /* namespace mm */ } /* namespace lsp */ #endif /* PLATFORM_WINDOWS */