/*
* Copyright (C) 2025 Linux Studio Plugins Project
* (C) 2025 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 25 апр. 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
namespace lsp
{
namespace mm
{
MMIOWriter::MMIOWriter()
{
hMMIO = NULL;
nWritePos = 0;
nDataSize = 0;
nFrames = -1;
bSeekable = false;
::ZeroMemory(&ckRiff, sizeof(ckRiff));
::ZeroMemory(&ckData, sizeof(ckData));
::ZeroMemory(&ckFact, sizeof(ckFact));
}
MMIOWriter::~MMIOWriter()
{
close();
}
status_t MMIOWriter::open(const LSPString *path, WAVEFORMATEX *fmt, wssize_t frames)
{
MMRESULT error;
status_t res;
MMCKINFO ckOut;
nFrames = frames;
// Open MMIO file
hMMIO = ::mmioOpenW(const_cast(path->get_utf16()), NULL, MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_CREATE);
if (hMMIO == NULL)
return close(STATUS_IO_ERROR);
// Create the output file RIFF chunk of form type 'WAVE'
ckRiff.ckid = FOURCC_RIFF;
ckRiff.fccType = mmioFOURCC('W', 'A', 'V', 'E');
ckRiff.cksize = 0;
if ((error = ::mmioCreateChunk(hMMIO, &ckRiff, MMIO_CREATERIFF)) != 0)
return close(STATUS_IO_ERROR);
// Now create the 'fmt ' chunk. Since we know the size of this chunk,
ckOut.ckid = mmioFOURCC('f', 'm', 't', ' ');
ckOut.cksize =
((fmt->wFormatTag == WAVE_FORMAT_PCM) || (fmt->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)) ?
sizeof(PCMWAVEFORMAT) : sizeof(WAVEFORMATEX) + fmt->cbSize;
if ((error = ::mmioCreateChunk(hMMIO, &ckOut, 0)) != 0)
return close(STATUS_IO_ERROR);
// Write the format structure to the 'fmt ' chunk
if ((res = write_padded(fmt, ckOut.cksize)) != STATUS_OK)
return close(res);
// Ascend out of the 'fmt ' chunk, back into the 'RIFF' chunk.
if ((error = ::mmioAscend(hMMIO, &ckOut, 0)) != 0)
return close(STATUS_IO_ERROR);
// Now create the fact chunk, not required by PCM but nice to have.
ckFact.ckid = mmioFOURCC('f', 'a', 'c', 't');
ckFact.cksize = 0;
if ((error = ::mmioCreateChunk(hMMIO, &ckFact, 0)) != 0)
return close(STATUS_IO_ERROR);
DWORD factSize = 0;
if ((res = write_padded(&factSize, sizeof(DWORD))) != STATUS_OK)
return close(res);
// Ascend out of the 'fact' chunk, back into the 'RIFF' chunk.
if ((error = ::mmioAscend(hMMIO, &ckFact, 0)) != 0)
return close(STATUS_IO_ERROR);
// Create the 'data' chunk that holds the waveform samples.
ckData.ckid = mmioFOURCC('d', 'a', 't', 'a');
ckData.cksize = 0;
if ((error = ::mmioCreateChunk(hMMIO, &ckData, 0)) != 0)
return close(STATUS_IO_ERROR);
nWritePos = 0;
nDataSize = 0;
bSeekable = ((fmt->wFormatTag == WAVE_FORMAT_PCM) || (fmt->wFormatTag == WAVE_FORMAT_IEEE_FLOAT));
return STATUS_OK;
}
status_t MMIOWriter::finalize_riff_file()
{
MMRESULT error;
// Seek to the end of chunk if position is wrong
if (::mmioSeek(hMMIO, ckData.dwDataOffset + nDataSize, SEEK_SET) < 0)
return STATUS_IO_ERROR;
// Pad the ckData chunk
if (nDataSize & 1)
{
// Write padding data
BYTE data = 0;
ssize_t written = ::mmioWrite(hMMIO, reinterpret_cast(&data), sizeof(BYTE));
if (written != 1)
return STATUS_IO_ERROR;
nWritePos = ++nDataSize;
}
// Ascend the output file out of the 'data' chunk
// this will cause the chunk size of the 'data' chunk to be written.
if ((error = ::mmioAscend(hMMIO, &ckData, 0)) != 0)
return STATUS_IO_ERROR;
// Ascend the RIFF chunk
if ((error = ::mmioAscend(hMMIO, &ckRiff, 0)) != 0)
return STATUS_IO_ERROR;
// Seek to the begin of 'fact' chunk
if (::mmioSeek(hMMIO, ckFact.dwDataOffset, SEEK_SET) < 0)
return STATUS_IO_ERROR;
// Write actual size of the 'data' chunk in samples
DWORD factSize = nFrames;
factSize = CPU_TO_LE(factSize);
if ((mmioWrite(hMMIO, reinterpret_cast(&factSize), sizeof(DWORD))) != sizeof(DWORD))
return STATUS_IO_ERROR;
return STATUS_OK;
}
wssize_t MMIOWriter::seek(wsize_t offset)
{
if (!bSeekable)
return -STATUS_NOT_SUPPORTED;
if (offset > nDataSize)
offset = nDataSize;
if (::mmioSeek(hMMIO, ckData.dwDataOffset + offset, SEEK_SET) < 0)
return -STATUS_IO_ERROR;
return nWritePos = offset;
}
ssize_t MMIOWriter::write(const void *buf, size_t count)
{
ssize_t written = ::mmioWrite(hMMIO, reinterpret_cast(const_cast(buf)), count);
if (written < 0)
return -STATUS_IO_ERROR;
nWritePos += written;
if (nDataSize < nWritePos)
nDataSize = nWritePos;
return written;
}
status_t MMIOWriter::write_padded(const void *buf, size_t count)
{
// Write data
ssize_t written = ::mmioWrite(hMMIO, reinterpret_cast(const_cast(buf)), count);
if ((written < 0) || (size_t(written) != count))
return STATUS_IO_ERROR;
// Need to pad?
if (count & 1)
{
BYTE data = 0;
ssize_t written = ::mmioWrite(hMMIO, reinterpret_cast(&data), sizeof(BYTE));
if (written != 1)
return STATUS_IO_ERROR;
}
return STATUS_OK;
}
status_t MMIOWriter::flush()
{
return (::mmioFlush(hMMIO, MMIO_EMPTYBUF) == 0) ? STATUS_OK : STATUS_IO_ERROR;
}
status_t MMIOWriter::close(status_t code)
{
if (hMMIO != NULL)
{
// If all is OK, then finalize the RIFF file
if (code == STATUS_OK)
code = finalize_riff_file();
::mmioClose(hMMIO, 0);
hMMIO = NULL;
}
nWritePos = 0;
nDataSize = 0;
nFrames = -1;
bSeekable = false;
::ZeroMemory(&ckRiff, sizeof(ckRiff));
::ZeroMemory(&ckData, sizeof(ckData));
::ZeroMemory(&ckFact, sizeof(ckFact));
return code;
}
} /* namespace mm */
} /* namespace lsp */
#endif /* PLATFORM_WINDOWS */