/*
* 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
#include
#include
#define DATA_BUFSIZE 0x1000
namespace lsp
{
namespace io
{
CharsetDecoder::CharsetDecoder()
{
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 */
}
CharsetDecoder::~CharsetDecoder()
{
close();
}
status_t CharsetDecoder::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_to_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(
DATA_BUFSIZE // The byte buffer size
+ sizeof(lsp_wchar_t) * DATA_BUFSIZE * 2 // The temporary 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 += DATA_BUFSIZE;
cBuffer = reinterpret_cast(buf);
cBufHead = cBuffer;
cBufTail = cBuffer;
#if defined(PLATFORM_WINDOWS)
buf += sizeof(lsp_wchar_t) * DATA_BUFSIZE * 2;
xBuffer = reinterpret_cast(buf);
#endif /* PLATFORM_WINDOWS */
return STATUS_OK;
}
void CharsetDecoder::close()
{
if (bBuffer != NULL)
{
free(bBuffer);
bBuffer = NULL;
bBufHead = NULL;
bBufTail = NULL;
cBuffer = NULL;
cBufHead = NULL;
cBufTail = NULL;
}
#ifdef 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 CharsetDecoder::decode(lsp_wchar_t **outbuf, size_t *outleft, void **inbuf, size_t *inleft)
{
size_t nconv;
#if defined(PLATFORM_WINDOWS)
CHAR *xinbuf = reinterpret_cast(*inbuf);
lsp_wchar_t *xoutbuf= *outbuf;
size_t xinleft = *inleft;
size_t xoutleft = *outleft;
nconv = 0;
while (xoutleft > 0)
{
// Is there a data in wchar_t buffer?
size_t nbuf = cBufTail - cBufHead;
if (nbuf > 0)
{
size_t nsrc = nbuf;
nbuf = utf16_to_utf32(xoutbuf, &xoutleft, cBufHead, &nsrc, false);
if (nbuf <= 0)
break;
nconv += nbuf;
xoutbuf += nbuf;
cBufHead += nbuf;
continue;
}
// Fill the rest space with converted UTF-16 data
// Each input character can take up to 2 UTF-16 characters, prevent from buffer overflows
// We can manipulate only with input buffer size because otherwise we will
// get a conversion error from dump MultiByteToWideChar routine
// character buffer is guaranteed to be empty
size_t xinamount = (xinleft > DATA_BUFSIZE) ? DATA_BUFSIZE : xinleft;
size_t bufcw = DATA_BUFSIZE*2;
size_t xincw = xinamount;
ssize_t nchars = multibyte_to_widechar(nCodePage, xinbuf, &xincw, cBuffer, &bufcw);
if (nchars <= 0)
{
if (nconv <= 0)
return nchars;
break;
}
// Update pointers and data
xinamount -= xincw;
cBufHead = cBuffer;
cBufTail = &cBuffer[nchars];
xinbuf += xinamount;
xinleft -= xinamount;
}
// Update pointers and values
*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;
size_t xoutleft = *outleft * sizeof(lsp_wchar_t);
// Perform conversion
nconv = ::iconv(hIconv, &xinbuf, &xinleft, &xoutbuf, &xoutleft);
if (nconv == size_t(-1))
{
int code = errno;
switch (code)
{
case E2BIG:
case EINVAL:
nconv = *outleft - (xoutleft/sizeof(lsp_wchar_t));
break;
default:
return -STATUS_BAD_FORMAT;
}
}
// Update pointers and values
*outbuf = reinterpret_cast(xoutbuf);
*outleft = xoutleft / sizeof(lsp_wchar_t);
*inbuf = reinterpret_cast(xinbuf);
*inleft = xinleft;
#endif /* PLATFORM_WINDOWS */
return nconv;
}
#endif
size_t CharsetDecoder::prepare_buffer()
{
size_t bufsz = bBufTail - bBufHead;
if (bufsz > (DATA_BUFSIZE >> 1))
return 0;
else if (bBufHead != bBuffer)
{
if (bufsz > 0)
::memmove(bBuffer, bBufHead, bufsz);
bBufHead = bBuffer;
bBufTail = &bBuffer[bufsz];
}
return DATA_BUFSIZE - bufsz;
}
ssize_t CharsetDecoder::decode_buffer()
{
// Prepare buffer
size_t bufsz = cBufTail - cBufHead;
if (bufsz > DATA_BUFSIZE)
return bufsz;
else if (cBufHead != cBuffer)
{
if (bufsz > 0)
::memmove(cBuffer, cBufHead, bufsz * sizeof(lsp_wchar_t));
cBufHead = cBuffer;
cBufTail = &cBuffer[bufsz];
}
// Is there any data in byte buffer?
size_t xinleft = bBufTail - bBufHead;
if (xinleft <= 0)
return bufsz;
// Now we can surely decode DATA_BUFSIZE characters
#ifdef PLATFORM_WINDOWS
// Round 1: Perform native -> UTF-16 decoding
char *xinbuf = reinterpret_cast(bBufHead);
size_t nsrc = xinleft;
size_t ndst = DATA_BUFSIZE*2;
ssize_t nbytes = multibyte_to_widechar(nCodePage, xinbuf, &nsrc, xBuffer, &ndst);
if (nbytes <= 0)
return nbytes;
uint8_t *bhead = &bBufHead[xinleft - nsrc];
// Round 2: Perform UTF-16 -> UTF-32 decoding
nsrc = DATA_BUFSIZE*2 - ndst;
ndst = DATA_BUFSIZE;
ssize_t nchars = utf16_to_utf32(cBufTail, &ndst, xBuffer, &nsrc, false);
if (nchars <= 0)
return nchars;
bBufHead = bhead;
cBufTail += DATA_BUFSIZE - ndst;
#else
char *xinbuf = reinterpret_cast(bBufHead);
char *xoutbuf = reinterpret_cast(cBufTail);
bufsz = DATA_BUFSIZE * sizeof(lsp_wchar_t);
size_t old_xinleft = xinleft;
// 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;
case EILSEQ:
if (old_xinleft > xinleft)
break;
return -STATUS_BAD_FORMAT;
default:
return -STATUS_BAD_FORMAT;
}
}
bBufHead = reinterpret_cast(xinbuf);
cBufTail = reinterpret_cast(xoutbuf);
#endif
return cBufTail - cBufHead;
}
lsp_swchar_t CharsetDecoder::fetch()
{
if (bBuffer == NULL)
return -STATUS_CLOSED;
// Is there any data in character buffer
if (cBufTail > cBufHead)
return *(cBufHead++);
ssize_t nchars = decode_buffer();
if (nchars > 0)
return *(cBufHead++);
return (nchars < 0) ? lsp_swchar_t(nchars) : -STATUS_EOF;
}
ssize_t CharsetDecoder::fetch(lsp_wchar_t *outbuf, size_t count)
{
if (bBuffer == NULL)
return -STATUS_CLOSED;
else if (outbuf == NULL)
return -STATUS_BAD_ARGUMENTS;
// Compute the amount of data to read
size_t processed = 0;
// Perform read
while (processed < count)
{
// Perform decoding
ssize_t nchars = decode_buffer();
if (nchars <= 0)
{
if (processed > 0)
break;
return nchars;
}
// Copy data to output buffer
ssize_t to_copy = count - processed;
if (nchars > to_copy)
nchars = to_copy;
::memcpy(outbuf, cBufHead, nchars * sizeof(lsp_wchar_t));
// Update state
cBufHead += nchars;
processed += nchars;
outbuf += nchars;
}
return processed;
}
ssize_t CharsetDecoder::fetch(LSPString *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 nchars = decode_buffer();
if (nchars <= 0)
{
if (processed > 0)
break;
return nchars;
}
// Copy data to output buffer
ssize_t to_copy = count - processed;
if (nchars > to_copy)
nchars = to_copy;
if (!out->append(cBufHead, nchars))
return -STATUS_NO_MEM;
// Update state
cBufHead += nchars;
processed += nchars;
}
return processed;
}
ssize_t CharsetDecoder::fetch(IOutSequence *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 nchars = decode_buffer();
if (nchars <= 0)
{
if (processed > 0)
break;
return nchars;
}
// Write data to output sequence
ssize_t to_copy = count - processed;
if (nchars > to_copy)
nchars = to_copy;
nchars = out->write(cBufHead, nchars);
if (nchars < 0)
{
if (processed > 0)
break;
return nchars;
}
// Update state
cBufHead += nchars;
processed += nchars;
}
return processed;
}
ssize_t CharsetDecoder::fill(const void *buf, size_t count)
{
if (bBuffer == NULL)
return -STATUS_CLOSED;
else if (buf == NULL)
return -STATUS_BAD_ARGUMENTS;
size_t bufsz = prepare_buffer();
if (bufsz <= 0)
return bufsz;
if (count > bufsz)
count = bufsz;
::memcpy(&bBufTail, buf, count);
bBufTail += count;
return count;
}
ssize_t CharsetDecoder::fill(File *fd, size_t count)
{
if (bBuffer == NULL)
return -STATUS_CLOSED;
else if (fd == 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 = fd->read(bBufTail, count - read);
if (nread <= 0)
{
if (read > 0) // Ignore error if there is data on the input
break;
return nread;
}
bBufTail += nread;
read += nread;
}
while (read < count);
return read;
}
ssize_t CharsetDecoder::fill(IInStream *is, size_t count)
{
if (bBuffer == NULL)
return -STATUS_CLOSED;
else if (is == 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 = is->read(bBufTail, count - read);
if (nread <= 0)
{
if (read > 0) // Ignore error if there is data on the input
break;
return nread;
}
bBufTail += nread;
read += nread;
}
while (read < count);
return read;
}
} /* namespace io */
} /* namespace lsp */