/*
* Copyright (C) 2025 Linux Studio Plugins Project
* (C) 2025 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 20 апр. 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
#include
#endif /* PLATFORM_WINDOWS */
#if defined(PLATFORM_MACOSX)
#include
#include
#include
#endif /* PLATFORM_MACOSX */
#ifdef USE_LIBSNDFILE
#if (__SIZEOF_INT__ == 4)
#define AFS_S32_CPU mm::SFMT_S32_CPU
#endif
#if (__SIZEOF_SHORT__ == 2)
#define AFS_S16_CPU mm::SFMT_S16_CPU
#elif ((__SIZEOF_SHORT__ == 4) && (!defined(AFS_S32_CPU)))
#define AFS_S32_CPU mm::SFMT_S32_CPU
#endif
#endif /* USE_LIBSNDFILE */
namespace lsp
{
namespace mm
{
#if defined(PLATFORM_WINDOWS)
struct WAVEFILE
{
MMIOWriter *pMMIO; // MMIO writer
ACMStream *pACM; // ACM stream
WAVEFORMATEX *pFormat; // Actual PCM stream format
wsize_t nTotalFrames; // Total frames written
WAVEFORMATEX sPcmFmt; // PCM format descriptor
};
static ssize_t decode_sample_format(WAVEFORMATEX *wfe)
{
if (wfe->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
return SFMT_F32_LE;
if (wfe->wFormatTag == WAVE_FORMAT_PCM)
{
switch (wfe->wBitsPerSample)
{
case 8: return SFMT_U8_CPU;
case 16: return SFMT_S16_LE;
case 24: return SFMT_S24_LE;
case 32: return SFMT_S32_LE;
default:
break;
}
}
return -1;
}
#elif defined(PLATFORM_MACOSX)
static inline ExtAudioFileRef eaf_ref(void *handle)
{
return static_cast(handle);
}
status_t OutAudioFileStream::decode_os_status(uint32_t code)
{
return (code == kAudio_NoError) ? STATUS_OK : STATUS_UNKNOWN_ERR;
}
uint32_t OutAudioFileStream::select_file_format(size_t codec)
{
// Choose audio format
switch (codec & AFMT_MASK)
{
case AFMT_WAV: return kAudioFileWAVEType;
case AFMT_AIFF: return kAudioFileAIFFType;
case AFMT_AU: return kAudioFileNextType;
case AFMT_W64: return kAudioFileWave64Type;
case AFMT_SD2: return kAudioFileSoundDesigner2Type;
case AFMT_FLAC: return kAudioFileFLACType;
case AFMT_CAF: return kAudioFileCAFType;
case AFMT_RF64: return kAudioFileRF64Type;
default:
return 0;
}
}
static bool select_sample_format(AudioStreamBasicDescription *info, const audio_stream_t *fmt, size_t codec)
{
bzero(info, sizeof(AudioStreamBasicDescription));
info->mSampleRate = fmt->srate;
info->mFormatFlags = 0;
info->mChannelsPerFrame = uint32_t(fmt->channels);
// Choose codec
switch (codec & CFMT_MASK)
{
case CFMT_PCM:
info->mFormatID = kAudioFormatLinearPCM;
break;
case CFMT_ULAW:
info->mFormatID = kAudioFormatULaw;
info->mFormatFlags |= kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger;
info->mBytesPerPacket = 0;
info->mFramesPerPacket = 1;
info->mBytesPerFrame = uint32_t(8 * sizeof(int8_t) * fmt->channels);
info->mBitsPerChannel = 8 * sizeof(int8_t);
break;
case CFMT_ALAW:
info->mFormatID = kAudioFormatALaw;
info->mFormatFlags |= kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger;
info->mBytesPerPacket = 0;
info->mFramesPerPacket = 1;
info->mBytesPerFrame = uint32_t(8 * sizeof(int8_t) * fmt->channels);
info->mBitsPerChannel = 8 * sizeof(int8_t);
break;
default:
switch (codec & AFMT_MASK)
{
case AFMT_WAV:
info->mFormatID = kAudioFormatLinearPCM;
break;
case AFMT_FLAC:
info->mFormatID = kAudioFormatFLAC;
break;
default:
info->mFormatID = kAudioFormatLinearPCM;
break;
}
break;
}
// Choose endianess
switch (sformat_endian(fmt->format))
{
case SFMT_DFL:
if ((codec & AFMT_MASK) == AFMT_AU)
info->mFormatFlags |= kAudioFormatFlagIsBigEndian;
break;
case SFMT_LE:
break;
case SFMT_BE:
info->mFormatFlags |= kAudioFormatFlagIsBigEndian;
break;
default:
return false;
}
if (info->mFormatID == kAudioFormatLinearPCM)
{
info->mFormatFlags |= kAudioFormatFlagIsPacked;
// Set sample format
switch (sformat_format(fmt->format))
{
case SFMT_U8:
info->mBytesPerPacket = uint32_t(sizeof(uint8_t) * fmt->channels);
info->mFramesPerPacket = 1;
info->mBytesPerFrame = info->mBytesPerPacket;
info->mBitsPerChannel = 8 * sizeof(uint8_t);
break;
case SFMT_S8:
info->mFormatFlags |= kAudioFormatFlagIsSignedInteger;
info->mBytesPerPacket = uint32_t(sizeof(int8_t) * fmt->channels);
info->mFramesPerPacket = 1;
info->mBytesPerFrame = info->mBytesPerPacket;
info->mBitsPerChannel = 8 * sizeof(int8_t);
break;
case SFMT_U16:
info->mBytesPerPacket = uint32_t(sizeof(uint16_t) * fmt->channels);
info->mFramesPerPacket = 1;
info->mBytesPerFrame = info->mBytesPerPacket;
info->mBitsPerChannel = 8 * sizeof(uint16_t);
break;
case SFMT_S16:
info->mFormatFlags |= kAudioFormatFlagIsSignedInteger;
info->mBytesPerPacket = uint32_t(sizeof(int16_t) * fmt->channels);
info->mFramesPerPacket = 1;
info->mBytesPerFrame = info->mBytesPerPacket;
info->mBitsPerChannel = 8 * sizeof(int16_t);
break;
case SFMT_U24:
info->mBytesPerPacket = uint32_t(3 * sizeof(uint8_t) * fmt->channels);
info->mFramesPerPacket = 1;
info->mFramesPerPacket = 1;
info->mBytesPerFrame = info->mBytesPerPacket;
info->mBitsPerChannel = 24 * sizeof(uint8_t);
break;
case SFMT_S24:
info->mFormatFlags |= kAudioFormatFlagIsSignedInteger;
info->mBytesPerPacket = uint32_t(3 * sizeof(int8_t) * fmt->channels);
info->mFramesPerPacket = 1;
info->mBytesPerFrame = info->mBytesPerPacket;
info->mBitsPerChannel = 24 * sizeof(int8_t);
break;
case SFMT_U32:
info->mBytesPerPacket = uint32_t(sizeof(uint32_t) * fmt->channels);
info->mFramesPerPacket = 1;
info->mBytesPerFrame = info->mBytesPerPacket;
info->mBitsPerChannel = 8 * sizeof(uint32_t);
break;
case SFMT_S32:
info->mFormatFlags |= kAudioFormatFlagIsSignedInteger;
info->mBytesPerPacket = uint32_t(sizeof(int32_t) * fmt->channels);
info->mFramesPerPacket = 1;
info->mBytesPerFrame = info->mBytesPerPacket;
info->mBitsPerChannel = 8 * sizeof(int32_t);
break;
case SFMT_F32:
info->mFormatFlags |= kAudioFormatFlagIsFloat;
info->mBytesPerPacket = uint32_t(sizeof(f32_t) * fmt->channels);
info->mFramesPerPacket = 1;
info->mBytesPerFrame = info->mBytesPerPacket;
info->mBitsPerChannel = 8 * sizeof(f32_t);
break;
case SFMT_F64:
info->mFormatFlags |= kAudioFormatFlagIsFloat;
info->mBytesPerPacket = uint32_t(sizeof(f64_t) * fmt->channels);
info->mFramesPerPacket = 1;
info->mBytesPerFrame = info->mBytesPerPacket;
info->mBitsPerChannel = 8 * sizeof(f64_t);
break;
default:
return false;
}
}
return true;
}
#else
status_t OutAudioFileStream::decode_sf_error(SNDFILE *fd)
{
switch (sf_error(fd))
{
case SF_ERR_NO_ERROR:
return STATUS_OK;
case SF_ERR_UNRECOGNISED_FORMAT:
return STATUS_BAD_FORMAT;
case SF_ERR_MALFORMED_FILE:
return STATUS_CORRUPTED_FILE;
case SF_ERR_UNSUPPORTED_ENCODING:
return STATUS_BAD_FORMAT;
default:
return STATUS_UNKNOWN_ERR;
}
}
bool OutAudioFileStream::select_sndfile_format(SF_INFO *info, audio_stream_t *fmt, size_t codec)
{
int res = 0;
// Choose audio format
switch (codec & AFMT_MASK)
{
case AFMT_WAV: res |= SF_FORMAT_WAV; break;
case AFMT_AIFF: res |= SF_FORMAT_AIFF; break;
case AFMT_AU: res |= SF_FORMAT_AU; break;
case AFMT_RAW: res |= SF_FORMAT_RAW; break;
case AFMT_PAF: res |= SF_FORMAT_PAF; break;
case AFMT_SVX: res |= SF_FORMAT_SVX; break;
case AFMT_NIST: res |= SF_FORMAT_NIST; break;
case AFMT_VOC: res |= SF_FORMAT_VOC; break;
case AFMT_IRCAM: res |= SF_FORMAT_IRCAM; break;
case AFMT_W64: res |= SF_FORMAT_W64; break;
case AFMT_MAT4: res |= SF_FORMAT_MAT4; break;
case AFMT_MAT5: res |= SF_FORMAT_MAT5; break;
case AFMT_PVF: res |= SF_FORMAT_PVF; break;
case AFMT_XI: res |= SF_FORMAT_XI; break;
case AFMT_HTK: res |= SF_FORMAT_HTK; break;
case AFMT_SDS: res |= SF_FORMAT_SDS; break;
case AFMT_AVR: res |= SF_FORMAT_AVR; break;
case AFMT_WAVEX: res |= SF_FORMAT_WAVEX; break;
case AFMT_SD2: res |= SF_FORMAT_SD2; break;
case AFMT_FLAC: res |= SF_FORMAT_FLAC; break;
case AFMT_CAF: res |= SF_FORMAT_CAF; break;
case AFMT_WVE: res |= SF_FORMAT_WVE; break;
case AFMT_OGG: res |= SF_FORMAT_OGG; break;
case AFMT_MPC2K: res |= SF_FORMAT_MPC2K; break;
case AFMT_RF64: res |= SF_FORMAT_RF64; break;
default:
return false;
}
// Choose codec
switch (codec & CFMT_MASK)
{
case CFMT_PCM:
{
// Set sample format
switch (sformat_format(fmt->format))
{
case SFMT_U8: res |= SF_FORMAT_PCM_U8; break;
case SFMT_S8: res |= SF_FORMAT_PCM_S8; break;
case SFMT_U16:
case SFMT_S16:
res |= SF_FORMAT_PCM_16;
break;
case SFMT_S24:
case SFMT_U24:
res |= SF_FORMAT_PCM_24;
break;
case SFMT_S32:
case SFMT_U32:
res |= SF_FORMAT_PCM_32;
break;
case SFMT_F32: res |= SF_FORMAT_FLOAT; break;
case SFMT_F64: res |= SF_FORMAT_DOUBLE; break;
default:
return false;
}
}
break;
case CFMT_ULAW: res |= SF_FORMAT_ULAW; break;
case CFMT_ALAW: res |= SF_FORMAT_ALAW; break;
case CFMT_IMA_ADPCM: res |= SF_FORMAT_IMA_ADPCM; break;
case CFMT_MS_ADPCM: res |= SF_FORMAT_MS_ADPCM; break;
case CFMT_GSM610: res |= SF_FORMAT_GSM610; break;
case CFMT_VOX_ADPCM: res |= SF_FORMAT_VOX_ADPCM; break;
case CFMT_G721_32: res |= SF_FORMAT_G721_32; break;
case CFMT_G723_24: res |= SF_FORMAT_G723_24; break;
case CFMT_G723_40: res |= SF_FORMAT_G723_40; break;
case CFMT_DWVW_12: res |= SF_FORMAT_DWVW_12; break;
case CFMT_DWVW_16: res |= SF_FORMAT_DWVW_16; break;
case CFMT_DWVW_24: res |= SF_FORMAT_DWVW_24; break;
case CFMT_DWVW_N: res |= SF_FORMAT_DWVW_N; break;
case CFMT_DPCM_8: res |= SF_FORMAT_DPCM_8; break;
case CFMT_DPCM_16: res |= SF_FORMAT_DPCM_16; break;
case CFMT_VORBIS: res |= SF_FORMAT_VORBIS; break;
#ifdef LIBSNDFILE_HAS_ALAC
case CFMT_ALAC_16: res |= SF_FORMAT_ALAC_16; break;
case CFMT_ALAC_20: res |= SF_FORMAT_ALAC_20; break;
case CFMT_ALAC_24: res |= SF_FORMAT_ALAC_24; break;
case CFMT_ALAC_32: res |= SF_FORMAT_ALAC_32; break;
#endif /* LIBSNDFILE_HAS_ALAC */
default:
return false;
}
// Choose endianess
switch (sformat_endian(fmt->format))
{
case SFMT_DFL: res |= SF_ENDIAN_FILE; break;
case SFMT_LE: res |= SF_ENDIAN_LITTLE; break;
case SFMT_BE: res |= SF_ENDIAN_BIG; break;
default:
return false;
}
info->frames = fmt->frames;
info->samplerate = fmt->srate;
info->channels = fmt->channels;
info->format = res;
info->sections = 0;
info->seekable = 0;
return true;
}
#endif
OutAudioFileStream::OutAudioFileStream()
{
hHandle = NULL;
nCodec = 0;
bSeekable = false;
}
OutAudioFileStream::~OutAudioFileStream()
{
IOutAudioStream::close();
do_close();
}
status_t OutAudioFileStream::open(const char *path, const audio_stream_t *fmt, size_t codec)
{
if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
LSPString xpath;
if (!xpath.set_utf8(path))
return set_error(STATUS_NO_MEM);
return open(&xpath, fmt, codec);
}
status_t OutAudioFileStream::open(const io::Path *path, const audio_stream_t *fmt, size_t codec)
{
if (path == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
return open(path->as_string(), fmt, codec);
}
status_t OutAudioFileStream::open(const LSPString *path, const audio_stream_t *fmt, size_t codec)
{
if (!is_closed())
return set_error(STATUS_OPENED);
if (fmt == NULL)
return set_error(STATUS_BAD_ARGUMENTS);
#if defined(PLATFORM_WINDOWS)
if ((codec & AFMT_MASK) != AFMT_WAV)
return set_error(STATUS_UNSUPPORTED_FORMAT);
WAVEFORMATEX rfmt;
::ZeroMemory(&rfmt, sizeof(WAVEFORMATEX));
rfmt.cbSize = 0;
rfmt.nChannels = fmt->channels;
rfmt.nSamplesPerSec = fmt->srate;
rfmt.wBitsPerSample = sformat_size_of(fmt->format) * 8;
rfmt.nBlockAlign = fmt->channels * sformat_size_of(fmt->format);
rfmt.nAvgBytesPerSec = fmt->srate * rfmt.nBlockAlign;
switch (codec & CFMT_MASK)
{
case CFMT_PCM:
rfmt.wFormatTag = (sformat_format(fmt->format) == SFMT_F32) ?
WAVE_FORMAT_IEEE_FLOAT : WAVE_FORMAT_PCM;
break;
case CFMT_ULAW: rfmt.wFormatTag = WAVE_FORMAT_MULAW; break;
case CFMT_ALAW: rfmt.wFormatTag = WAVE_FORMAT_ALAW; break;
case CFMT_MS_ADPCM: rfmt.wFormatTag = WAVE_FORMAT_ADPCM; break;
case CFMT_IMA_ADPCM: rfmt.wFormatTag = WAVE_FORMAT_IMA_ADPCM; break;
case CFMT_GSM610: rfmt.wFormatTag = WAVE_FORMAT_GSM610; break;
case CFMT_G721_32: rfmt.wFormatTag = WAVE_FORMAT_G721_ADPCM; break;
case CFMT_G723_24: rfmt.wFormatTag = WAVE_FORMAT_G723_ADPCM; break;
case CFMT_G723_40: rfmt.wFormatTag = WAVE_FORMAT_G723_ADPCM; break;
default:
return set_error(STATUS_UNSUPPORTED_FORMAT);
}
// Allocate handle
handle_t *h = static_cast(malloc(sizeof(handle_t)));
if (h == NULL)
return set_error(STATUS_NO_MEM);
h->pMMIO = NULL;
h->pACM = NULL;
h->pFormat = NULL;
h->nTotalFrames = 0;
lsp_finally { close_handle(h); };
// Create MMIO
status_t res;
h->pMMIO = new MMIOWriter();
if (h->pMMIO == NULL)
return set_error(STATUS_NO_MEM);
if ((rfmt.wFormatTag == WAVE_FORMAT_IEEE_FLOAT) ||
(rfmt.wFormatTag == WAVE_FORMAT_PCM))
{
// Just open MMIO stream with specified format
if ((res = h->pMMIO->open(path, &rfmt, fmt->frames)) != STATUS_OK)
return set_error(res);
// Update state
h->nTotalFrames = 0;
h->pACM = NULL;
h->sPcmFmt = rfmt;
h->pFormat = &h->sPcmFmt;
sFormat = *fmt;
nCodec = codec;
nOffset = 0;
bSeekable = h->pMMIO->seekable();
// Commit the new handle and return success
lsp::swap(hHandle, h);
return set_error(STATUS_OK);
}
// Create ACM stream first and initialize it
h->pACM = new ACMStream();
if (h->pACM == NULL)
return set_error(STATUS_NO_MEM);
if ((res = h->pACM->write_pcm(&rfmt)) != STATUS_OK)
return set_error(res);
// Detect format
h->pFormat = h->pACM->in_format();
ssize_t sfmt = decode_sample_format(h->pFormat);
if (sfmt <= 0)
return set_error(STATUS_UNSUPPORTED_FORMAT);
// Now open MMIO with specified output format
if ((res = h->pMMIO->open(path, h->pACM->out_format(), fmt->frames)) != STATUS_OK)
return set_error(res);
// All is OK, update state
h->nTotalFrames = 0;
sFormat.srate = h->pFormat->nSamplesPerSec;
sFormat.channels = h->pFormat->nChannels;
sFormat.frames = fmt->frames;
sFormat.format = sfmt;
nCodec = codec;
nOffset = 0;
bSeekable = false;
// Commit the new handle and return success
lsp::swap(hHandle, h);
return set_error(STATUS_OK);
#elif defined(PLATFORM_MACOSX)
// Form the URL to open
CFStringRef str_ref = CFStringCreateWithCString(
kCFAllocatorDefault,
path->get_utf8(),
kCFStringEncodingUTF8);
lsp_finally { CFRelease(str_ref); };
CFURLRef url_ref = CFURLCreateWithFileSystemPath(
kCFAllocatorDefault,
str_ref,
kCFURLPOSIXPathStyle,
false);
lsp_finally { CFRelease(url_ref); };
const AudioFileTypeID file_type = select_file_format(codec);
if (file_type == 0)
return set_error(STATUS_UNSUPPORTED_FORMAT);
AudioStreamBasicDescription info;
if (!select_sample_format(&info, fmt, codec))
return set_error(STATUS_UNSUPPORTED_FORMAT);
// Open file
ExtAudioFileRef eaf = NULL;
OSStatus os_res = ExtAudioFileCreateWithURL(
url_ref,
file_type,
&info,
NULL,
kAudioFileFlags_EraseFile,
&eaf);
if (os_res != kAudio_NoError)
return set_error(decode_os_status(os_res));
lsp_finally {
if (eaf != NULL)
ExtAudioFileDispose(eaf);
};
// Decode sample format
size_t format = 0;
size_t be_flag = (info.mFormatFlags & kAudioFormatFlagIsBigEndian) ? mm::SFMT_BE : mm::SFMT_LE;
bool need_convert = info.mFormatID != kAudioFormatLinearPCM;
if (!need_convert)
{
if (info.mFormatFlags & kAudioFormatFlagIsFloat)
{
if (info.mBitsPerChannel == sizeof(float) * 8)
format = mm::SFMT_F32 | be_flag;
else if (info.mBitsPerChannel == sizeof(double) * 8)
format = mm::SFMT_F64 | be_flag;
else
need_convert = true;
}
else if (info.mFormatFlags & kAudioFormatFlagIsSignedInteger)
{
if (info.mBitsPerChannel == sizeof(int8_t) * 8)
format = mm::SFMT_S8 | be_flag;
else if (info.mBitsPerChannel == sizeof(int16_t) * 8)
format = mm::SFMT_S16 | be_flag;
else if (info.mBitsPerChannel == sizeof(int8_t) * 24)
format = mm::SFMT_S24 | be_flag;
else if (info.mBitsPerChannel == sizeof(int32_t) * 8)
format = mm::SFMT_S32 | be_flag;
else
need_convert = true;
}
else
{
if (info.mBitsPerChannel == sizeof(uint8_t) * 8)
format = mm::SFMT_U8 | be_flag;
else if (info.mBitsPerChannel == sizeof(uint16_t) * 8)
format = mm::SFMT_U16 | be_flag;
else if (info.mBitsPerChannel == sizeof(uint8_t) * 24)
format = mm::SFMT_U24 | be_flag;
else if (info.mBitsPerChannel == sizeof(uint32_t) * 8)
format = mm::SFMT_U32 | be_flag;
else
need_convert = true;
}
}
// Initialize audio converter if needed to match the selected sample format
if (need_convert)
{
AudioStreamBasicDescription cvt;
bzero(&cvt, sizeof(AudioStreamBasicDescription));
cvt.mSampleRate = info.mSampleRate;
cvt.mFormatID = kAudioFormatLinearPCM;
cvt.mFormatFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked;
if (info.mBitsPerChannel <= sizeof(f32_t)*8)
{
cvt.mBytesPerPacket = sizeof(f32_t) * info.mChannelsPerFrame;
cvt.mFramesPerPacket = 1;
cvt.mBytesPerFrame = sizeof(f32_t) * info.mChannelsPerFrame;
cvt.mChannelsPerFrame = info.mChannelsPerFrame;
cvt.mBitsPerChannel = sizeof(f32_t) * 8;
format = mm::SFMT_F32 | be_flag;
}
else
{
cvt.mBytesPerPacket = sizeof(f64_t) * info.mChannelsPerFrame;
cvt.mFramesPerPacket = 1;
cvt.mBytesPerFrame = sizeof(f64_t) * info.mChannelsPerFrame;
cvt.mChannelsPerFrame = info.mChannelsPerFrame;
cvt.mBitsPerChannel = sizeof(f64_t) * 8;
format = mm::SFMT_F64 | be_flag;
}
os_res = ExtAudioFileSetProperty(
eaf,
kExtAudioFileProperty_ClientDataFormat,
sizeof(AudioStreamBasicDescription),
&cvt);
if (os_res != kAudio_NoError)
return set_error(decode_os_status(os_res));
}
// Update state and return
sFormat.srate = info.mSampleRate;
sFormat.channels = info.mChannelsPerFrame;
sFormat.frames = fmt->frames;
sFormat.format = format;
nOffset = 0;
bSeekable = false;
hHandle = release_ptr(eaf);
return set_error(STATUS_OK);
#else
audio_stream_t tmp;
SF_INFO info;
tmp = *fmt;
if (!select_sndfile_format(&info, &tmp, codec))
return set_error(STATUS_UNSUPPORTED_FORMAT);
// Open handle
SNDFILE *sf = sf_open(path->get_native(), SFM_WRITE, &info);
if (sf == NULL)
return -set_error(decode_sf_error(sf));
// Commit new state
sFormat = tmp;
hHandle = sf;
nOffset = 0;
bSeekable = info.seekable;
return set_error(STATUS_OK);
#endif
}
status_t OutAudioFileStream::close_handle(handle_t *h)
{
if (h == NULL)
return STATUS_OK;
lsp_finally { h = NULL; };
#if defined(PLATFORM_WINDOWS)
status_t res = STATUS_OK;
// Flush all previously encoded data and close ACM
if (h->pACM != NULL)
{
res = update_status(res, h->pACM->close());
delete h->pACM;
h->pACM = NULL;
}
// Close MMIO
if (h->pMMIO != NULL)
{
h->pMMIO->set_frames(h->nTotalFrames);
res = update_status(res, h->pMMIO->close());
delete h->pMMIO;
h->pMMIO = NULL;
}
h->pFormat = NULL;
free(h);
return res;
#elif defined(PLATFORM_MACOSX)
OSStatus res = ExtAudioFileDispose(eaf_ref(h));
return decode_os_status(res);
#else
int res = sf_close(h);
return (res == 0) ? STATUS_OK : STATUS_IO_ERROR;
#endif
}
status_t OutAudioFileStream::do_close()
{
if (hHandle == NULL)
return STATUS_OK;
status_t res = flush_internal(true);
status_t res2= close_handle(hHandle);
hHandle = NULL;
bSeekable = false;
nOffset = -1; // Mark as closed
nCodec = 0;
return set_error((res == STATUS_OK) ? res2 : res);
}
#if defined(PLATFORM_WINDOWS)
status_t OutAudioFileStream::flush_handle(handle_t *hHandle, bool eof)
{
if (hHandle->pACM == NULL)
return STATUS_OK;
void *dptr;
while (true)
{
// Perform pull of portion of buffer
ssize_t count = hHandle->pACM->pull(&dptr, IO_BUF_SIZE, eof);
if (count < 0)
return (count == -STATUS_EOF) ? STATUS_OK : -count;
else if (count == 0)
break;
// Write pulled data to underlying storage
count = hHandle->pMMIO->write(dptr, count);
if (count < 0)
return count;
}
return STATUS_OK;
}
#endif /* PLATFORM_WINDOWS */
status_t OutAudioFileStream::flush_internal(bool eof)
{
#if defined(PLATFORM_WINDOWS)
status_t res = flush_handle(hHandle, eof);
return (res == STATUS_OK) ? hHandle->pMMIO->flush() : res;
#elif defined(PLATFORM_MACOSX)
return STATUS_OK;
#else
sf_write_sync(hHandle);
return STATUS_OK;
#endif /* USE_LIBSNDFILE */
}
status_t OutAudioFileStream::flush()
{
if (is_closed())
return -set_error(STATUS_CLOSED);
return set_error(flush_internal(false));
}
status_t OutAudioFileStream::close()
{
IOutAudioStream::close();
return do_close();
}
ssize_t OutAudioFileStream::direct_write(const void *src, size_t nframes, size_t fmt)
{
#if defined(PLATFORM_WINDOWS)
size_t fsize = hHandle->pFormat->nBlockAlign;
if (hHandle->pMMIO != NULL)
{
if (hHandle->pACM != NULL)
return write_acm_convert(src, nframes);
ssize_t nwritten = hHandle->pMMIO->write(src, fsize * nframes);
return (nwritten < 0) ? nwritten : nwritten / fsize;
}
return -STATUS_NOT_SUPPORTED;
#elif defined(PLATFORM_MACOSX)
const size_t fsize = sformat_size_of(sFormat.format) * sFormat.channels;
AudioBufferList list;
AudioBuffer *buf = &list.mBuffers[0];
list.mNumberBuffers = 1;
buf->mNumberChannels = UInt32(sFormat.channels);
buf->mDataByteSize = UInt32(fsize * nframes);
buf->mData = const_cast(src);
UInt32 count = UInt32(nframes);
OSStatus os_res = ExtAudioFileWrite(eaf_ref(hHandle), count, &list);
if (os_res != kAudio_NoError)
return -set_error(decode_os_status(os_res));
return count;
#else
sf_count_t count;
status_t res;
switch (sformat_format(fmt))
{
case SFMT_S32:
count = sf_writef_int(hHandle, static_cast(src), nframes);
break;
case SFMT_S16:
count = sf_writef_short(hHandle, static_cast(src), nframes);
break;
case SFMT_F32:
count = sf_writef_float(hHandle, static_cast(src), nframes);
break;
case SFMT_F64:
count = sf_writef_double(hHandle, static_cast(src), nframes);
break;
default: // Force SFMT_F32 sample format
count = sf_writef_float(hHandle, static_cast(src), nframes);
break;
}
// Is there data written?
if (count > 0)
return count;
res = decode_sf_error(hHandle);
return -((res == STATUS_OK) ? STATUS_EOF : res);
#endif
}
#if defined(PLATFORM_WINDOWS)
ssize_t OutAudioFileStream::conv_write(const void *src, size_t nframes, size_t fmt)
{
ssize_t res = IOutAudioStream::conv_write(src, nframes, fmt);
if (size_t(nOffset) > hHandle->nTotalFrames)
hHandle->nTotalFrames = nOffset;
return res;
}
ssize_t OutAudioFileStream::write_acm_convert(const void *src, size_t nframes)
{
size_t nwritten = 0;
void *dptr;
const uint8_t *sptr = static_cast(src);
size_t fsize = sformat_size_of(sFormat.format) * sFormat.channels;
nframes *= fsize;
while (nwritten < nframes)
{
// Perform push if possible
ssize_t count = hHandle->pACM->push(&dptr);
if (count > 0) // We're still able to push data
{
// Copy data to buffer
ssize_t can_push = nframes - nwritten;
if (count > can_push)
count = can_push;
::memcpy(dptr, sptr, count);
// Update pointers
sptr += count;
nwritten += count;
hHandle->pACM->commit(count);
continue;
}
else if (count < 0) // Error occurred?
{
if (nwritten > 0)
break;
return -set_error(STATUS_UNKNOWN_ERR);
}
// Need to perform flush
status_t res = flush_internal(false);
if (res != STATUS_OK)
{
if (nwritten > 0)
break;
return -set_error(res);
}
}
return nwritten / fsize;
}
#endif /* PLATFORM_WINDOWS */
size_t OutAudioFileStream::select_format(size_t rfmt)
{
#if defined(PLATFORM_WINDOWS)
if (hHandle->pFormat->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
return SFMT_F32_LE;
if (hHandle->pFormat->wFormatTag == WAVE_FORMAT_PCM)
{
switch (hHandle->pFormat->wBitsPerSample)
{
case 8: return SFMT_U8_CPU;
case 16: return SFMT_S16_LE;
case 24: return SFMT_S24_LE;
case 32: return SFMT_S32_LE;
default:
break;
}
}
return -1;
#elif defined(PLATFORM_MACOSX)
return sFormat.format;
#else
switch (sformat_format(rfmt))
{
#ifdef AFS_S32_CPU
case SFMT_S32:
case SFMT_U32:
case SFMT_S24:
case SFMT_U24:
return SFMT_S32_CPU;
#endif
#ifdef AFS_S16_CPU
case SFMT_S16:
case SFMT_U16:
case SFMT_S8:
case SFMT_U8:
return SFMT_S16_CPU;
#endif
case SFMT_F32:
return SFMT_F32_CPU;
case SFMT_F64:
return SFMT_F64_CPU;
default:
break;
}
return SFMT_F32_CPU;
#endif
}
wssize_t OutAudioFileStream::seek(wsize_t nframes)
{
if (is_closed())
return -set_error(STATUS_CLOSED);
#if defined(PLATFORM_WINDOWS)
size_t fsize = hHandle->pFormat->nBlockAlign;
if ((hHandle->pMMIO != NULL) && (bSeekable))
{
wssize_t res = hHandle->pMMIO->seek(nframes * fsize);
if (res < 0)
{
set_error(-res);
return res;
}
set_error(STATUS_OK);
return res / fsize;
}
return -set_error(STATUS_NOT_IMPLEMENTED);
#elif defined(PLATFORM_MACOSX)
OSStatus os_res = ExtAudioFileSeek(eaf_ref(hHandle), nframes);
if (os_res != kAudio_NoError)
return -set_error(decode_os_status(os_res));
nOffset = nframes;
set_error(STATUS_OK);
return nframes;
#else
sf_count_t offset = sf_seek(hHandle, nframes, SEEK_SET);
if (offset < 0)
return -set_error(decode_sf_error(hHandle));
set_error(STATUS_OK);
return nOffset = offset;
#endif /* USE_LIBSNDFILE */
}
} /* namespace mm */
} /* namespace lsp */