/*
* Copyright (C) 2024 Linux Studio Plugins Project
* (C) 2024 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
#include
#include
#include
#include
#include
namespace lsp
{
namespace mm
{
ACMStream::ACMStream()
{
pFmtIn = NULL;
pFmtOut = NULL;
hDriver = NULL;
hStream = NULL;
pHeader = NULL;
}
ACMStream::~ACMStream()
{
close();
}
void ACMStream::acm_query_formats(drv_lookup_t *s)
{
ACMFORMATTAGDETAILSW *ftd = &s->ftd;
ACMFORMATDETAILSW *fdw = &s->fd;
// Iterate all formats
for (size_t i=0, n=ftd->cStandardFormats; i < n; ++i)
{
::ZeroMemory(fdw, sizeof(ACMFORMATDETAILSW));
fdw->cbStruct = sizeof(ACMFORMATDETAILSW);
fdw->dwFormatTag = ftd->dwFormatTag;
fdw->dwFormatIndex = i;
fdw->pwfx = s->req;
fdw->cbwfx = s->req_sz;
if (::acmFormatDetailsW(s->hd, fdw, ACM_FORMATDETAILSF_INDEX) != 0)
continue;
// Create copy and add to driver list
if ((s->pfmt = s->ptag->vfmt.add()) == NULL)
continue;
s->pfmt->id = fdw->dwFormatIndex;
s->pfmt->fdw = fdw->fdwSupport;
s->pfmt->wfex = copy_fmt(fdw->pwfx);
}
}
void ACMStream::acm_query_format_tags(drv_lookup_t *s)
{
ACMFORMATTAGDETAILSW *ftd = &s->ftd;
for (size_t i=0, n=s->dd.cFormatTags; i < n; ++i)
{
// Prepare the structure
::ZeroMemory(ftd, sizeof(ACMFORMATTAGDETAILSW));
ftd->cbStruct = sizeof(ACMFORMATTAGDETAILSW);
ftd->dwFormatTagIndex = i;
// Get information
if (::acmFormatTagDetailsW(s->hd, ftd, ACM_FORMATTAGDETAILSF_INDEX) != 0)
continue;
// Create tag descriptor
if ((s->ptag = new fmt_tag_t()) == NULL)
continue;
if (!s->pdrv->vtag.add(s->ptag))
{
delete s->ptag;
continue;
}
s->ptag->id = ftd->dwFormatTag;
s->ptag->fdw = ftd->fdwSupport;
s->ptag->name.set_utf16(ftd->szFormatTag);
// Query formats
acm_query_formats(s);
}
}
WINBOOL CALLBACK ACMStream::acm_driver_enum_cb(HACMDRIVERID hadid, DWORD_PTR dwInstance, DWORD fdwSupport)
{
drv_lookup_t *s = reinterpret_cast(dwInstance);
// Get driver information
ACMDRIVERDETAILSW *dd = &s->dd;
::ZeroMemory(dd, sizeof(ACMDRIVERDETAILSW));
dd->cbStruct = sizeof(ACMDRIVERDETAILSW);
if (::acmDriverDetailsW(hadid, dd, 0) != 0)
return TRUE;
// Open driver
if (::acmDriverOpen(&s->hd, hadid, 0) != 0)
return TRUE;
// Allocate driver object
if ((s->pdrv = new drv_t()) == NULL)
{
::acmDriverClose(s->hd, 0);
return TRUE;
}
if (!s->vdrv.add(s->pdrv))
{
delete s->pdrv;
::acmDriverClose(s->hd, 0);
return TRUE;
}
s->pdrv->drv_id = hadid;
s->pdrv->short_name.set_utf16(dd->szShortName);
s->pdrv->full_name.set_utf16(dd->szLongName);
s->pdrv->copyright.set_utf16(dd->szCopyright);
s->pdrv->license.set_utf16(dd->szLicensing);
s->pdrv->features.set_utf16(dd->szFeatures);
// Query format metrics
s->req_sz = 0;
::acmMetrics((HACMOBJ)s->hd, ACM_METRIC_MAX_SIZE_FORMAT, &s->req_sz);
s->req_sz = align_size(s->req_sz, DEFAULT_ALIGN);
s->pdrv->pwfx_sz = s->req_sz;
s->req = reinterpret_cast(::malloc(s->req_sz));
if (s->req != NULL)
{
// Query format tags
acm_query_format_tags(s);
::free(s->req);
s->req = NULL;
}
// Close driver
::acmDriverClose(s->hd, 0);
s->hd = NULL;
return TRUE;
}
status_t ACMStream::acm_enum_drivers(lltl::parray *res)
{
drv_lookup_t lk;
MMRESULT result = ::acmDriverEnum(acm_driver_enum_cb, (DWORD_PTR)&lk, ACM_DRIVERENUMF_DISABLED);
if (result == 0)
{
res->swap(&lk.vdrv);
acm_destroy_drivers(&lk.vdrv);
}
#if 0
for (size_t i=0, n=res->size(); iuget(i);
info.fmt_utf8(
"DRV #%-4d : %p\n"
"Short Name: %s\n"
"Long Name : %s\n"
"Copyright : %s\n"
"License : %s\n"
"Features : %s\n"
"Formats :\n",
int(i),
drv->drv_id,
drv->short_name.get_utf8(),
drv->full_name.get_utf8(),
drv->copyright.get_utf8(),
drv->license.get_utf8(),
drv->features.get_utf8()
);
for (size_t j=0, m=drv->vtag.size(); jvtag.uget(j);
info.fmt_append_utf8(" %s [0x%x]: %d items\n",
tag->name.get_utf8(),
int(tag->id),
int(tag->vfmt.size())
);
for (size_t k=0, l=tag->vfmt.size(); kvfmt.uget(k);
idx.fmt_ascii("%d/%d", int(k), int(j));
info.fmt_append_utf8(
"%10s: %s %d Hz/%d ch @%d bit [0x%x:%d]\n",
idx.get_utf8(),
tag->name.get_utf8(),
int(fmt->wfex->nSamplesPerSec),
int(fmt->wfex->nChannels),
int(fmt->wfex->wBitsPerSample),
int(fmt->wfex->wFormatTag),
int(fmt->wfex->cbSize)
);
}
}
lsp_trace("\n%s\n", info.get_native());
#endif
}
#endif
return (result == 0) ? STATUS_OK : STATUS_UNKNOWN_ERR;
}
void ACMStream::acm_destroy_drivers(lltl::parray *res)
{
// Drop drivers
for (size_t i=0, n=res->size(); iuget(i);
// Drop tags
for (size_t j=0, m=pdrv->vtag.size(); jvtag.uget(j);
// Drop formats
for (size_t k=0, l=ptag->vfmt.size(); kvfmt.uget(k);
if (pfmt->wfex != NULL)
{
::free(pfmt->wfex);
pfmt->wfex = NULL;
}
}
delete ptag;
}
delete pdrv;
}
res->flush();
}
WAVEFORMATEX *ACMStream::copy_fmt(const WAVEFORMATEX *src)
{
/*
* cbSize
* Size, in bytes, of extra format information appended to the end
* of the WAVEFORMATEX structure. This information can be used by
* non-PCM formats to store extra attributes for the wFormatTag. If
* no extra information is required by the wFormatTag, this member must
* be set to 0. For WAVE_FORMAT_PCM formats (and only WAVE_FORMAT_PCM formats),
* this member is ignored. When this structure is included in a WAVEFORMATEXTENSIBLE
* structure, this value must be at least 22.
*/
size_t cbsize = (src->wFormatTag == WAVE_FORMAT_PCM) ? 0 : src->cbSize;
size_t bytes = sizeof(WAVEFORMATEX) + cbsize;
WAVEFORMATEX *res = static_cast(::malloc(align_size(bytes, DEFAULT_ALIGN)));
if (res != NULL)
{
::memcpy(res, src, bytes);
res->cbSize = cbsize; // Override original cbSize for PCM
}
return res;
}
ACMStream::fmt_tag_t *ACMStream::acm_find_tag(drv_t *drv, size_t fmt_tag)
{
for (size_t i=0, n=drv->vtag.size(); ivtag.uget(i);
if (tag == NULL)
continue;
if ((tag->id == fmt_tag) && (tag->fdw & ACMDRIVERDETAILS_SUPPORTF_CODEC))
return tag;
}
return NULL;
}
status_t ACMStream::acm_configure_stream(WAVEFORMATEX *dst, WAVEFORMATEX *src)
{
MMRESULT res;
// Succeeded, initialize stream
// Estimate size of conversion buffers
DWORD src_length = IO_BUF_SIZE, dst_length = IO_BUF_SIZE;
if ((dst->wFormatTag == WAVE_FORMAT_PCM) || (dst->wFormatTag == WAVE_FORMAT_IEEE_FLOAT))
{
res = ::acmStreamSize(hStream, IO_BUF_SIZE, &dst_length, ACM_STREAMSIZEF_SOURCE);
if ((res != 0) || (dst_length <= 0))
return STATUS_SKIP;
res = ::acmStreamSize(hStream, dst_length, &src_length, ACM_STREAMSIZEF_DESTINATION);
if ((res != 0) || (src_length <= 0))
return STATUS_SKIP;
}
else
{
res = ::acmStreamSize(hStream, IO_BUF_SIZE, &src_length, ACM_STREAMSIZEF_SOURCE);
if ((res != 0) || (src_length <= 0))
return STATUS_SKIP;
res = ::acmStreamSize(hStream, src_length, &dst_length, ACM_STREAMSIZEF_DESTINATION);
if ((res != 0) || (src_length <= 0))
return STATUS_SKIP;
}
// Allocate stream header
size_t hdr_alloc = align_size(sizeof(ACMSTREAMHEADER), DEFAULT_ALIGN);
size_t src_alloc = align_size(src_length, DEFAULT_ALIGN);
size_t dst_alloc = align_size(dst_length, DEFAULT_ALIGN);
size_t to_alloc = hdr_alloc + src_alloc + dst_alloc;
BYTE *buf = static_cast(::malloc(to_alloc));
if (buf == NULL)
return STATUS_NO_MEM;
::ZeroMemory(buf, to_alloc);
pHeader = reinterpret_cast(buf);
buf += hdr_alloc;
pHeader->pbSrc = buf;
buf += src_alloc;
pHeader->pbDst = buf;
buf += dst_alloc;
pHeader->cbStruct = sizeof(ACMSTREAMHEADER);
pHeader->dwSrcUser = src_length; // maximum size
pHeader->cbSrcLength = src_length; // This is required for initialization
pHeader->cbSrcLengthUsed = 0;
pHeader->dwDstUser = 0; // read offset
pHeader->cbDstLength = dst_length;
pHeader->cbDstLengthUsed = 0;
// Prepare stream header
if ((res = ::acmStreamPrepareHeader(hStream, pHeader, 0)) != 0)
return STATUS_UNKNOWN_ERR;
// Reset size of input buffer
pHeader->cbSrcLength = 0;
return STATUS_OK;
}
status_t ACMStream::acm_try_format_dec(WAVEFORMATEX *to, WAVEFORMATEX *from)
{
status_t res;
size_t ftag = ((to->wFormatTag == WAVE_FORMAT_PCM) || (to->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)) ?
from->wFormatTag : to->wFormatTag;
for (size_t i=0, n=vDrv.size(); idrv_id, 0) != 0)
continue;
// Try to open stream
if (::acmStreamOpen(&hStream, hDriver, from, to, NULL, 0, 0, ACM_STREAMOPENF_NONREALTIME) == 0)
{
res = acm_configure_stream(to, from);
if (res != STATUS_OK)
return res;
// Copy format descriptors
if ((pFmtIn = copy_fmt(from)) == NULL)
return STATUS_NO_MEM;
if ((pFmtOut = copy_fmt(to)) == NULL)
return STATUS_NO_MEM;
return STATUS_OK;
}
// Close ACM driver
::acmDriverClose(hDriver, 0);
hDriver = NULL;
}
return STATUS_OK;
}
ACMStream::fmt_t *ACMStream::acm_select_format(fmt_t *best, fmt_t *curr, WAVEFORMATEX *req)
{
if (curr == NULL)
return best;
if (best == NULL)
return curr;
// Minimize sample rate difference
size_t d1 = lsp_abs(ssize_t(best->wfex->nSamplesPerSec) - ssize_t(req->nSamplesPerSec));
size_t d2 = lsp_abs(ssize_t(curr->wfex->nSamplesPerSec) - ssize_t(req->nSamplesPerSec));
if ((d2 < d1) &&
(curr->wfex->nSamplesPerSec > best->wfex->nSamplesPerSec) &&
(curr->wfex->nSamplesPerSec <= req->nSamplesPerSec))
return curr;
// Optimize number of channels
d1 = lsp_abs(ssize_t(best->wfex->nChannels) - ssize_t(req->nChannels));
d2 = lsp_abs(ssize_t(curr->wfex->nChannels) - ssize_t(req->nChannels));
if (d1 > d2)
return curr;
// Optimize sample format
if ((best->wfex->wFormatTag != WAVE_FORMAT_IEEE_FLOAT) &&
(curr->wfex->wFormatTag == WAVE_FORMAT_IEEE_FLOAT))
return curr;
if (best->wfex->wBitsPerSample < curr->wfex->wBitsPerSample)
return curr;
return best;
}
status_t ACMStream::acm_find_standard_dec(WAVEFORMATEX *fmt)
{
status_t res;
lltl::parray blist; // List of all best-matching solutions
fmt_t *best = NULL;
for (size_t i=0, n=vDrv.size(); iwFormatTag);
if (tag == NULL)
continue;
best = NULL;
// Possible conversion to floating-point PCM ?
if ((tag = acm_find_tag(drv, WAVE_FORMAT_IEEE_FLOAT)) != NULL)
{
for (size_t j=0, m=tag->vfmt.size(); jvfmt.uget(j), fmt);
}
// Possible conversion to integer PCM ?
if ((tag = acm_find_tag(drv, WAVE_FORMAT_PCM)) != NULL)
{
for (size_t j=0, m=tag->vfmt.size(); jvfmt.uget(j), fmt);
}
// Add to list
if (best != NULL)
blist.add(best);
}
// Select the best matching format across all and make it first for test
best = NULL;
for (size_t j=0, m=blist.size(); jwfex : NULL;
if (pcm == NULL)
continue;
if ((pcm->nChannels != fmt->nChannels) ||
(pcm->nSamplesPerSec != fmt->nSamplesPerSec))
{
WAVEFORMATEX tmp = *pcm;
tmp.nChannels = fmt->nChannels;
tmp.nSamplesPerSec = fmt->nSamplesPerSec;
tmp.nBlockAlign = (tmp.wBitsPerSample * tmp.nChannels) >> 3;
tmp.nAvgBytesPerSec = tmp.nBlockAlign * tmp.nSamplesPerSec;
// Try modified mode
if ((res = acm_try_format_dec(pcm, fmt)) != STATUS_OK)
return res;
if (hStream != NULL)
return STATUS_OK;
}
// Try non-modified mode
if ((res = acm_try_format_dec(pcm, fmt)) != STATUS_OK)
return res;
if (hStream != NULL)
return STATUS_OK;
}
return STATUS_OK;
}
status_t ACMStream::acm_find_nonstandard_dec(WAVEFORMATEX *fmt)
{
status_t res;
WAVEFORMATEX pcm;
pcm.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
pcm.nChannels = fmt->nChannels;
pcm.nSamplesPerSec = fmt->nSamplesPerSec;
pcm.nAvgBytesPerSec = sizeof(f32_t) * fmt->nChannels * fmt->nSamplesPerSec;
pcm.nBlockAlign = sizeof(f32_t) * fmt->nChannels;
pcm.wBitsPerSample = sizeof(f32_t) * 8;
pcm.cbSize = 0;
// Try IEEE Float first as the best output format
if ((res = acm_try_format_dec(&pcm, fmt)) != STATUS_OK)
return res;
else if (hStream != NULL)
return STATUS_OK;
// No success, try 32, 24, 16, 8 bits per sample
for (size_t bps=4; bps > 0; --bps)
{
pcm.wFormatTag = WAVE_FORMAT_PCM;
pcm.nChannels = fmt->nChannels;
pcm.nSamplesPerSec = fmt->nSamplesPerSec;
pcm.nAvgBytesPerSec = bps * fmt->nChannels * fmt->nSamplesPerSec;
pcm.nBlockAlign = bps * fmt->nChannels;
pcm.wBitsPerSample = bps * 8;
pcm.cbSize = 0;
// Try non-standard modes
if ((res = acm_try_format_dec(&pcm, fmt)) != STATUS_OK)
return res;
if (hStream != NULL)
return STATUS_OK;
}
return STATUS_OK;
}
status_t ACMStream::read_pcm(WAVEFORMATEX *in)
{
status_t res = close();
if (res != STATUS_OK)
return res;
// We do not support PCM and IEEE FLOAT format since it doesn't require decoding/encoding
if ((in->wFormatTag == WAVE_FORMAT_PCM) || (in->wFormatTag == WAVE_FORMAT_IEEE_FLOAT))
return STATUS_UNSUPPORTED_FORMAT;
// Enumerate all drivers available in the system
acm_enum_drivers(&vDrv);
if ((res = acm_find_nonstandard_dec(in)) != STATUS_OK)
return close(res);
if (hStream == NULL)
{
if ((res = acm_find_standard_dec(in)) != STATUS_OK)
return close(res);
}
acm_destroy_drivers(&vDrv);
return (hStream != NULL) ? STATUS_OK : close(STATUS_UNSUPPORTED_FORMAT);
}
status_t ACMStream::acm_try_format_enc(HACMDRIVER drv, WAVEFORMATEX *to, WAVEFORMATEX *from, size_t szof)
{
size_t flags = ACM_FORMATSUGGESTF_NCHANNELS |
ACM_FORMATSUGGESTF_NSAMPLESPERSEC |
ACM_FORMATSUGGESTF_WFORMATTAG;
// Suggest format
if ((::acmFormatSuggest(drv, from, to, szof, flags)) != 0)
return STATUS_OK;
// Try to open stream
if (::acmStreamOpen(&hStream, hDriver, from, to, NULL, 0, 0, ACM_STREAMOPENF_NONREALTIME) != 0)
return STATUS_OK;
// Configure ACM stream
status_t res = acm_configure_stream(to, from);
if (res != STATUS_OK)
return res;
// Copy format descriptors
if ((pFmtIn = copy_fmt(from)) == NULL)
return STATUS_NO_MEM;
pFmtOut = to; // reuse 'to' pointer;
return STATUS_OK;
}
status_t ACMStream::acm_suggest_format_enc(WAVEFORMATEX *fmt)
{
status_t res;
for (size_t i=0, n=vDrv.size(); iwFormatTag);
if (tag == NULL)
continue;
WAVEFORMATEX pcm, *dst;
dst = reinterpret_cast(::malloc(drv->pwfx_sz));
if (dst == NULL)
return STATUS_NO_MEM;
::ZeroMemory(dst, drv->pwfx_sz);
dst->wFormatTag = fmt->wFormatTag;
dst->nChannels = fmt->nChannels;
dst->nSamplesPerSec = fmt->nSamplesPerSec;
dst->cbSize = 0;
// Open the specific ACM driver
if (::acmDriverOpen(&hDriver, drv->drv_id, 0) != 0)
{
::free(dst);
continue;
}
// Try PCM IIIE Float first
pcm.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
pcm.nChannels = fmt->nChannels;
pcm.nSamplesPerSec = fmt->nSamplesPerSec;
pcm.nAvgBytesPerSec = sizeof(f32_t) * fmt->nChannels * fmt->nSamplesPerSec;
pcm.nBlockAlign = sizeof(f32_t) * fmt->nChannels;
pcm.wBitsPerSample = sizeof(f32_t) * 8;
pcm.cbSize = 0;
if ((res = acm_try_format_enc(hDriver, dst, &pcm, drv->pwfx_sz)) != STATUS_OK)
{
::free(dst);
return res;
}
else if (hStream != NULL)
return STATUS_OK; // dst will be saved as format descriptor
// Try other PCM formats: 32, 24, 16, 8 bits per sample
for (size_t bps=4; bps > 0; --bps)
{
pcm.wFormatTag = WAVE_FORMAT_PCM;
pcm.nChannels = fmt->nChannels;
pcm.nSamplesPerSec = fmt->nSamplesPerSec;
pcm.nAvgBytesPerSec = bps * fmt->nChannels * fmt->nSamplesPerSec;
pcm.nBlockAlign = bps * fmt->nChannels;
pcm.wBitsPerSample = bps * 8;
pcm.cbSize = 0;
// Try non-standard modes
if ((res = acm_try_format_enc(hDriver, dst, &pcm, drv->pwfx_sz)) != STATUS_OK)
{
::free(dst);
return res;
}
if (hStream != NULL)
return STATUS_OK; // dst will be saved as format descriptor
}
// Close ACM driver
::free(dst);
::acmDriverClose(hDriver, 0);
hDriver = NULL;
}
return STATUS_OK;
}
status_t ACMStream::write_pcm(WAVEFORMATEX *out)
{
status_t res = close();
if (res != STATUS_OK)
return res;
// Enumerate all drivers available in the system
acm_enum_drivers(&vDrv);
if ((res = acm_suggest_format_enc(out)) != STATUS_OK)
return close(res);
return (hStream != NULL) ? STATUS_OK : close(STATUS_UNSUPPORTED_FORMAT);
}
status_t ACMStream::close(status_t res)
{
// Destroy information about all drivers
acm_destroy_drivers(&vDrv);
// Close stream
if (hStream != NULL)
{
// Unprepare ACM header first
if ((pHeader != NULL) && (pHeader->fdwStatus != 0))
::acmStreamUnprepareHeader(hStream, pHeader, 0);
::acmStreamClose(hStream, 0);
hStream = NULL;
}
// Close driver
if (hDriver != NULL)
{
::acmDriverClose(hDriver, 0);
hDriver = NULL;
}
// Free allocated memory
if (pFmtIn != NULL)
{
::free(pFmtIn);
pFmtIn = NULL;
}
if (pFmtOut != NULL)
{
::free(pFmtOut);
pFmtOut = NULL;
}
if (pHeader != NULL)
{
::free(pHeader);
pHeader = NULL;
}
return res;
}
ssize_t ACMStream::push(void **buf)
{
if (pHeader == NULL)
return -STATUS_CLOSED;
size_t avail = pHeader->dwSrcUser - pHeader->cbSrcLength;
if (buf != NULL)
*buf = &pHeader->pbSrc[pHeader->cbSrcLength];
return avail;
}
ssize_t ACMStream::pull(void **buf, size_t size, bool force)
{
if (hStream == NULL)
return -STATUS_CLOSED;
// Check if there is enough data in data buffer
size_t avail = pHeader->cbDstLengthUsed - pHeader->dwDstUser;
if (avail <= 0)
{
// Check buffer size
if (pHeader->cbSrcLength <= 0)
return (force) ? -STATUS_EOF : 0;
pHeader->cbSrcLengthUsed = 0;
pHeader->cbDstLengthUsed = 0;
// We consider that output buffer is block-aligned and can perform conversion now
// Perform conversion
size_t flags = (force) ? ACM_STREAMCONVERTF_BLOCKALIGN : 0;
if (::acmStreamConvert(hStream, pHeader, flags) != 0)
return -STATUS_IO_ERROR;
// Move the source buffer
size_t tail = pHeader->cbSrcLength - pHeader->cbSrcLengthUsed;
pHeader->cbSrcLength = tail;
if (tail > 0)
::memmove(pHeader->pbSrc, &pHeader->pbSrc[pHeader->cbSrcLengthUsed], tail);
// Update buffer information and check again
pHeader->dwDstUser = 0;
avail = pHeader->cbDstLengthUsed;
if (avail <= 0)
return (force) ? -STATUS_EOF : 0;
}
// Copy data to the output buffer
if (size > avail)
size = avail;
if (buf != NULL)
*buf = &pHeader->pbDst[pHeader->dwDstUser];
pHeader->dwDstUser += size;
return size;
}
size_t ACMStream::avail()
{
if (pHeader == NULL)
return 0;
return pHeader->cbDstLengthUsed;
}
} /* namespace mm */
} /* namespace lsp */
#endif /* PLATFORM_WINDOWS */