/*
* Copyright (C) 2020 Linux Studio Plugins Project
* (C) 2020 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 8 мар. 2019 г.
*
* 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
#define DATA_BUFSIZE 0x1000
namespace lsp
{
namespace io
{
CharsetEncoder::CharsetEncoder()
{
bBuffer = NULL;
bBufHead = NULL;
bBufTail = NULL;
cBuffer = NULL;
cBufHead = NULL;
cBufTail = NULL;
#if defined(PLATFORM_WINDOWS)
xBuffer = NULL;
nCodePage = uint32_t(-1);
#else
hIconv = iconv_t(-1);
#endif /* PLATFORM_WINDOWS */
}
CharsetEncoder::~CharsetEncoder()
{
close();
}
status_t CharsetEncoder::init(const char *charset)
{
#if defined(PLATFORM_WINDOWS)
if (nCodePage != uint32_t(-1))
return STATUS_BAD_STATE;
ssize_t cp = codepage_from_name(charset);
if (cp < 0)
return STATUS_BAD_LOCALE;
nCodePage = cp;
#else
if (hIconv != iconv_t(-1))
return STATUS_BAD_STATE;
iconv_t handle = init_iconv_from_wchar_t(charset);
if (handle == iconv_t(-1))
return STATUS_BAD_LOCALE;
hIconv = handle;
#endif /* PLATFORM_WINDOWS */
// Allocate buffer
uint8_t *buf= reinterpret_cast(::malloc(
sizeof(lsp_utf32_t) * DATA_BUFSIZE * 2 // Byte buffer size
+ sizeof(lsp_wchar_t) * DATA_BUFSIZE // wchar_t buffer size
#if defined(PLATFORM_WINDOWS)
+ sizeof(lsp_utf16_t) * DATA_BUFSIZE * 2
#endif /* PLATFORM_WINDOWS */
));
if (buf == NULL)
{
close();
return STATUS_NO_MEM;
}
bBuffer = buf;
bBufHead = bBuffer;
bBufTail = bBuffer;
buf += sizeof(lsp_utf32_t) * DATA_BUFSIZE * 2;
cBuffer = reinterpret_cast(buf);
cBufHead = cBuffer;
cBufTail = cBuffer;
#if defined(PLATFORM_WINDOWS)
buf += sizeof(lsp_wchar_t) * DATA_BUFSIZE;
xBuffer = reinterpret_cast(buf);
#endif /* PLATFORM_WINDOWS */
return STATUS_OK;
}
void CharsetEncoder::close()
{
if (bBuffer != NULL)
{
free(bBuffer);
bBuffer = NULL;
bBufHead = NULL;
bBufTail = NULL;
cBuffer = NULL;
cBufHead = NULL;
cBufTail = NULL;
}
#if defined(PLATFORM_WINDOWS)
xBuffer = NULL;
nCodePage = uint32_t(-1);
#else
if (hIconv != iconv_t(-1))
{
::iconv_close(hIconv);
hIconv = iconv_t(-1);
}
#endif /* PLATFORM_WINDOWS */
}
#if 0
ssize_t CharsetEncoder::encode(void **outbuf, size_t *outleft, lsp_wchar_t **inbuf, size_t *inleft)
{
size_t nconv;
#if defined(PLATFORM_WINDOWS)
lsp_wchar_t *xinbuf = *inbuf;
CHAR *xoutbuf = reinterpret_cast(*outbuf);
size_t xinleft = *inleft;
size_t xoutleft = *outleft;
nconv = 0;
while (xoutleft > 0)
{
// Perform optimistic UTF-32 -> UTF-16 encoding of the whole buffer
size_t nsrc = (xinleft > DATA_BUFSIZE) ? DATA_BUFSIZE : xinleft;
size_t ndst = DATA_BUFSIZE;
ssize_t nchars = utf32_to_utf16(cBuffer, &ndst, xinbuf, &nsrc, false);
if (nchars <= 0)
{
if (nconv <= 0)
return nchars;
break;
}
// Perform safe UTF-16 -> native encoding
size_t xnchars = nchars;
ssize_t nbytes = widechar_to_multibyte(nCodePage, cBuffer, &xnchars, xoutbuf, &xoutleft);
if (nbytes <= 0)
{
if (nconv <= 0)
return nbytes;
break;
}
nchars -= xnchars;
// Update statistics
xinbuf += nchars;
xinleft -= nchars;
xoutbuf += nbytes;
}
*outbuf = xoutbuf;
*outleft = xoutleft;
*inbuf = reinterpret_cast(xinbuf);
*inleft = xinleft;
#else
char *xinbuf = reinterpret_cast(*inbuf);
char *xoutbuf = reinterpret_cast(*outbuf);
size_t xinleft = *inleft * sizeof(lsp_wchar_t);
size_t xoutleft = *outleft;
// Perform conversion
nconv = ::iconv(hIconv, &xinbuf, &xinleft, &xoutbuf, &xoutleft);
if (nconv == size_t(-1))
{
int code = errno;
switch (code)
{
case E2BIG:
case EINVAL:
nconv = *inleft - (xinleft / sizeof(lsp_wchar_t));
break;
default:
return -STATUS_BAD_FORMAT;
}
}
// Update pointers and values
*outbuf = xoutbuf;
*outleft = xoutleft;
*inbuf = reinterpret_cast(xinbuf);
*inleft = xinleft / sizeof(lsp_wchar_t);
#endif /* PLATFORM_WINDOWS */
return nconv;
}
#endif
size_t CharsetEncoder::prepare_buffer()
{
size_t bufsz = cBufTail - cBufHead;
if (bufsz > (DATA_BUFSIZE >> 1))
return 0;
else if (cBufHead != cBuffer)
{
if (bufsz > 0)
::memmove(cBuffer, cBufHead, bufsz * sizeof(lsp_wchar_t));
cBufHead = cBuffer;
cBufTail = &cBuffer[bufsz];
}
return DATA_BUFSIZE - bufsz;
}
ssize_t CharsetEncoder::encode_buffer()
{
// Prepare buffer
size_t bufsz = bBufTail - bBufHead;
if (bufsz > DATA_BUFSIZE * sizeof(lsp_utf32_t))
return bufsz;
else if (bBufHead != bBuffer)
{
if (bufsz > 0)
::memmove(bBuffer, bBufHead, bufsz);
bBufHead = bBuffer;
bBufTail = &bBuffer[bufsz];
}
// Is there any data in byte buffer?
size_t xinleft = cBufTail - cBufHead;
if (!xinleft)
return bufsz;
#ifdef PLATFORM_WINDOWS
// Round 1: encode UTF-32 -> UTF-16
size_t nsrc = xinleft;
size_t ndst = DATA_BUFSIZE*2;
ssize_t nchars = utf32_to_utf16(xBuffer, &ndst, cBufHead, &nsrc, false);
if (nchars <= 0)
return nchars;
lsp_wchar_t *bhead = &cBufHead[xinleft - nsrc];
// Round 2: encode UTF-16 -> native charset
nsrc = DATA_BUFSIZE*2 - ndst;
ndst = DATA_BUFSIZE * sizeof(lsp_utf32_t);
char *xoutbuf = reinterpret_cast(bBufTail);
ssize_t nbytes = widechar_to_multibyte(nCodePage, xBuffer, &nsrc, xoutbuf, &ndst);
if (nbytes <= 0)
return nbytes;
cBufHead = bhead;
bBufTail += nbytes;
#else
char *xinbuf = reinterpret_cast(cBufHead);
char *xoutbuf = reinterpret_cast(bBufTail);
bufsz = DATA_BUFSIZE * sizeof(lsp_utf32_t);
xinleft *= sizeof(lsp_wchar_t);
// Perform conversion
size_t nconv = ::iconv(hIconv, &xinbuf, &xinleft, &xoutbuf, &bufsz);
if (nconv == size_t(-1))
{
int code = errno;
switch (code)
{
case E2BIG:
case EINVAL:
break;
default:
return -STATUS_BAD_FORMAT;
}
}
cBufHead = reinterpret_cast(xinbuf);
bBufTail = reinterpret_cast(xoutbuf);
#endif
return bBufTail - bBufHead;
}
ssize_t CharsetEncoder::fill(lsp_wchar_t ch)
{
if (bBuffer == NULL)
return -STATUS_CLOSED;
// Is there a space in the buffer for reading?
size_t bufsz = prepare_buffer();
if (bufsz <= 0)
return bufsz;
*(cBufTail++) = ch;
return 1;
}
ssize_t CharsetEncoder::fill(const lsp_wchar_t *buf, size_t count)
{
if (bBuffer == NULL)
return -STATUS_CLOSED;
else if (buf == NULL)
return -STATUS_BAD_ARGUMENTS;
// Is there a space in the buffer for reading?
size_t bufsz = prepare_buffer();
if (bufsz <= 0)
return bufsz;
if (count > bufsz)
count = bufsz;
::memcpy(cBufTail, buf, count * sizeof(lsp_wchar_t));
cBufTail += count;
return count;
}
ssize_t CharsetEncoder::fill(const char *buf, size_t count)
{
if (bBuffer == NULL)
return -STATUS_CLOSED;
else if (buf == NULL)
return -STATUS_BAD_ARGUMENTS;
// Is there a space in the buffer for reading?
size_t bufsz = prepare_buffer();
if (bufsz <= 0)
return bufsz;
if (count > bufsz)
count = bufsz;
for (size_t i=0; i last) || (last > in->length()))
return -STATUS_BAD_ARGUMENTS;
// Is there a space in the buffer for reading?
size_t bufsz = prepare_buffer();
if (bufsz <= 0)
return bufsz;
size_t count = last - first;
const lsp_wchar_t *buf = in->characters();
if (count > bufsz)
count = bufsz;
::memcpy(cBufTail, &buf[first], count * sizeof(lsp_wchar_t));
cBufTail += count;
return count;
}
ssize_t CharsetEncoder::fill(IInSequence *in, size_t count)
{
if (bBuffer == NULL)
return -STATUS_CLOSED;
else if (in == NULL)
return -STATUS_BAD_ARGUMENTS;
// Is there a space in the buffer for reading?
size_t bufsz = prepare_buffer();
if (bufsz <= 0)
return bufsz;
// Compute the amount of data to read
size_t read = 0;
if ((!count) || (count > bufsz))
count = bufsz;
// Perform read
do
{
ssize_t nread = in->read(cBufTail, count - read);
if (nread <= 0)
{
if (read > 0) // Ignore error if there is data on the input
break;
return nread;
}
cBufTail += nread;
read += nread;
}
while (read < count);
return read;
}
ssize_t CharsetEncoder::fetch(void *buf, size_t count)
{
if (bBuffer == NULL)
return -STATUS_CLOSED;
else if (buf == NULL)
return -STATUS_BAD_ARGUMENTS;
// Compute the amount of data to read
size_t processed = 0;
if (!count)
count = DATA_BUFSIZE*2;
// Perform read
uint8_t *dst = reinterpret_cast(buf);
while (processed < count)
{
// Perform decoding
ssize_t nbytes = encode_buffer();
if (nbytes <= 0)
{
if (processed > 0)
break;
return nbytes;
}
// Write data to output sequence
ssize_t to_copy = count - processed;
if (nbytes > to_copy)
nbytes = to_copy;
::memcpy(dst, bBufHead, nbytes);
// Update state
bBufHead += nbytes;
processed += nbytes;
dst += nbytes;
}
return processed;
}
ssize_t CharsetEncoder::fetch(File *out, size_t count)
{
if (bBuffer == NULL)
return -STATUS_CLOSED;
else if (out == NULL)
return -STATUS_BAD_ARGUMENTS;
// Compute the amount of data to read
size_t processed = 0;
if (!count)
count = DATA_BUFSIZE*2;
// Perform read
while (processed < count)
{
// Perform decoding
ssize_t nbytes = encode_buffer();
if (nbytes <= 0)
{
if (processed > 0)
break;
return nbytes;
}
// Write data to output sequence
ssize_t to_copy = count - processed;
if (nbytes > to_copy)
nbytes = to_copy;
nbytes = out->write(bBufHead, nbytes);
if (nbytes < 0)
{
if (processed > 0)
break;
return nbytes;
}
// Update state
bBufHead += nbytes;
processed += nbytes;
}
return processed;
}
ssize_t CharsetEncoder::fetch(IOutStream *out, size_t count)
{
if (bBuffer == NULL)
return -STATUS_CLOSED;
else if (out == NULL)
return -STATUS_BAD_ARGUMENTS;
// Compute the amount of data to read
size_t processed = 0;
if (!count)
count = DATA_BUFSIZE*2;
// Perform read
while (processed < count)
{
// Perform decoding
ssize_t nbytes = encode_buffer();
if (nbytes <= 0)
{
if (processed > 0)
break;
return nbytes;
}
// Write data to output sequence
ssize_t to_copy = count - processed;
if (nbytes > to_copy)
nbytes = to_copy;
nbytes = out->write(bBufHead, nbytes);
if (nbytes < 0)
{
if (processed > 0)
break;
return nbytes;
}
// Update state
bBufHead += nbytes;
processed += nbytes;
}
return processed;
}
} /* namespace io */
} /* namespace lsp */