static GstBuffer *
create_overlay_buffer (void)
{
GZlibDecompressor *decompress;
GConverterResult decomp_res;
guchar *gzipped_pixdata, *pixdata;
gsize gzipped_size, bytes_read, pixdata_size;
GstBuffer *logo_pixels;
guint w, h, stride;
gzipped_pixdata = g_base64_decode (gzipped_pixdata_base64, &gzipped_size);
g_assert (gzipped_pixdata != NULL);
pixdata = g_malloc (64 * 1024);
decompress = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_GZIP);
decomp_res = g_converter_convert (G_CONVERTER (decompress),
gzipped_pixdata, gzipped_size, pixdata, 64 * 1024,
G_CONVERTER_INPUT_AT_END, &bytes_read, &pixdata_size, NULL);
g_assert (decomp_res == G_CONVERTER_FINISHED);
g_assert (bytes_read == gzipped_size);
g_free (gzipped_pixdata);
g_object_unref (decompress);
/* 0: Pixbuf magic (0x47646b50) */
g_assert (GST_READ_UINT32_BE (pixdata) == 0x47646b50);
/* 4: length incl. header */
/* 8: pixdata_type */
/* 12: rowstride (900) */
stride = GST_READ_UINT32_BE (pixdata + 12);
/* 16: width (225) */
w = GST_READ_UINT32_BE (pixdata + 16);
/* 20: height (57) */
h = GST_READ_UINT32_BE (pixdata + 20);
/* 24: pixel_data */
GST_LOG ("%dx%d @ %d", w, h, stride);
/* we assume that the last line also has padding at the end */
g_assert (pixdata_size - 24 >= h * stride);
logo_pixels = gst_buffer_new_and_alloc (h * stride);
gst_buffer_fill (logo_pixels, 0, pixdata + 24, h * stride);
gst_buffer_add_video_meta (logo_pixels, GST_VIDEO_FRAME_FLAG_NONE,
GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_RGB, w, h);
g_free (pixdata);
return logo_pixels;
}
/**
* cockpit_web_response_gunzip:
* @bytes: the compressed bytes
* @error: place to put an error
*
* Perform gzip decompression on the @bytes.
*
* Returns: the uncompressed bytes, caller owns return value.
*/
GBytes *
cockpit_web_response_gunzip (GBytes *bytes,
GError **error)
{
GConverter *converter;
GConverterResult result;
const guint8 *in;
gsize inl, outl, read, written;
GByteArray *out;
converter = G_CONVERTER (g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_GZIP));
in = g_bytes_get_data (bytes, &inl);
out = g_byte_array_new ();
do
{
outl = out->len;
g_byte_array_set_size (out, outl + inl);
result = g_converter_convert (converter, in, inl, out->data + outl, inl,
G_CONVERTER_INPUT_AT_END, &read, &written, error);
if (result == G_CONVERTER_ERROR)
break;
g_byte_array_set_size (out, outl + written);
in += read;
inl -= read;
}
while (result != G_CONVERTER_FINISHED);
g_object_unref (converter);
if (result != G_CONVERTER_FINISHED)
{
g_byte_array_unref (out);
return NULL;
}
else
{
return g_byte_array_free_to_bytes (out);
}
}
static GByteArray *
fb_util_zlib_conv(GConverter *conv, const GByteArray *bytes, GError **error)
{
GByteArray *ret;
GConverterResult res;
gsize cize = 0;
gsize rize;
gsize wize;
guint8 data[1024];
ret = g_byte_array_new();
while (TRUE) {
rize = 0;
wize = 0;
res = g_converter_convert(conv,
bytes->data + cize,
bytes->len - cize,
data, sizeof data,
G_CONVERTER_INPUT_AT_END,
&rize, &wize, error);
switch (res) {
case G_CONVERTER_CONVERTED:
g_byte_array_append(ret, data, wize);
cize += rize;
break;
case G_CONVERTER_ERROR:
g_byte_array_free(ret, TRUE);
return NULL;
case G_CONVERTER_FINISHED:
g_byte_array_append(ret, data, wize);
return ret;
default:
break;
}
}
}
static gboolean
try_convert (GCharsetConverter *converter,
const void *inbuf,
gsize inbuf_size)
{
GError *err;
gsize bytes_read, nread;
gsize bytes_written, nwritten;
GConverterResult res;
gchar *out;
gboolean ret;
gsize out_size;
if (inbuf == NULL || inbuf_size == 0)
{
return FALSE;
}
err = NULL;
nread = 0;
nwritten = 0;
out_size = inbuf_size * 4;
out = g_malloc (out_size);
do
{
res = g_converter_convert (G_CONVERTER (converter),
(gchar *)inbuf + nread,
inbuf_size - nread,
(gchar *)out + nwritten,
out_size - nwritten,
G_CONVERTER_INPUT_AT_END,
&bytes_read,
&bytes_written,
&err);
nread += bytes_read;
nwritten += bytes_written;
} while (res != G_CONVERTER_FINISHED && res != G_CONVERTER_ERROR && err == NULL);
if (err != NULL)
{
if (err->code == G_CONVERT_ERROR_PARTIAL_INPUT)
{
/* FIXME We can get partial input while guessing the
encoding because we just take some amount of text
to guess from. */
ret = TRUE;
}
else
{
ret = FALSE;
}
g_error_free (err);
}
else
{
ret = TRUE;
}
/* FIXME: Check the remainder? */
if (ret == TRUE && !g_utf8_validate (out, nwritten, NULL))
{
ret = FALSE;
}
g_free (out);
return ret;
}
static gchar* skk_encoding_converter_convert (SkkEncodingConverter* self, GCharsetConverter* converter, const gchar* str, GError** error) {
gchar* result = NULL;
const gchar* _tmp0_;
guint8* _tmp1_;
gint _tmp1__length1;
guint8* _tmp2_;
gint _tmp2__length1;
guint8* _tmp3_;
gint _tmp3__length1;
guint8* inbuf;
gint inbuf_length1;
gint _inbuf_size_;
guint8* _tmp4_ = NULL;
guint8* outbuf;
gint outbuf_length1;
gint _outbuf_size_;
GString* _tmp5_;
GString* builder;
gsize total_bytes_read;
GString* _tmp26_;
const gchar* _tmp27_;
gchar* _tmp28_;
GError * _inner_error_ = NULL;
g_return_val_if_fail (self != NULL, NULL);
g_return_val_if_fail (converter != NULL, NULL);
g_return_val_if_fail (str != NULL, NULL);
_tmp0_ = str;
_tmp1_ = string_get_data (_tmp0_, &_tmp1__length1);
_tmp2_ = _tmp1_;
_tmp2__length1 = _tmp1__length1;
_tmp3_ = (_tmp2_ != NULL) ? _vala_array_dup1 (_tmp2_, _tmp2__length1) : ((gpointer) _tmp2_);
_tmp3__length1 = _tmp2__length1;
inbuf = _tmp3_;
inbuf_length1 = _tmp3__length1;
_inbuf_size_ = inbuf_length1;
_tmp4_ = g_new0 (guint8, SKK_ENCODING_CONVERTER_BUFSIZ);
outbuf = _tmp4_;
outbuf_length1 = SKK_ENCODING_CONVERTER_BUFSIZ;
_outbuf_size_ = outbuf_length1;
_tmp5_ = g_string_new ("");
builder = _tmp5_;
total_bytes_read = (gsize) 0;
while (TRUE) {
gsize _tmp6_;
guint8* _tmp7_;
gint _tmp7__length1;
gsize bytes_read = 0UL;
gsize bytes_written = 0UL;
GCharsetConverter* _tmp8_;
guint8* _tmp9_;
gint _tmp9__length1;
gsize _tmp10_;
guint8* _tmp11_;
gint _tmp11__length1;
guint8* _tmp12_;
gint _tmp12__length1;
gsize _tmp13_ = 0UL;
gsize _tmp14_ = 0UL;
gsize _tmp24_;
gsize _tmp25_;
_tmp6_ = total_bytes_read;
_tmp7_ = inbuf;
_tmp7__length1 = inbuf_length1;
if (!(_tmp6_ < ((gsize) _tmp7__length1))) {
break;
}
_tmp8_ = converter;
_tmp9_ = inbuf;
_tmp9__length1 = inbuf_length1;
_tmp10_ = total_bytes_read;
_tmp11_ = inbuf;
_tmp11__length1 = inbuf_length1;
_tmp12_ = outbuf;
_tmp12__length1 = outbuf_length1;
g_converter_convert ((GConverter*) _tmp8_, _tmp9_ + _tmp10_, (gsize) (_tmp11__length1 - _tmp10_), _tmp12_, (gsize) _tmp12__length1, G_CONVERTER_INPUT_AT_END, &_tmp13_, &_tmp14_, &_inner_error_);
bytes_read = _tmp13_;
bytes_written = _tmp14_;
if (_inner_error_ != NULL) {
g_propagate_error (error, _inner_error_);
_g_string_free0 (builder);
outbuf = (g_free (outbuf), NULL);
inbuf = (g_free (inbuf), NULL);
return NULL;
}
{
gint i;
i = 0;
{
gboolean _tmp15_;
_tmp15_ = TRUE;
while (TRUE) {
gboolean _tmp16_;
gint _tmp18_;
gsize _tmp19_;
GString* _tmp20_;
guint8* _tmp21_;
gint _tmp21__length1;
gint _tmp22_;
guint8 _tmp23_;
_tmp16_ = _tmp15_;
if (!_tmp16_) {
gint _tmp17_;
_tmp17_ = i;
i = _tmp17_ + 1;
}
_tmp15_ = FALSE;
_tmp18_ = i;
_tmp19_ = bytes_written;
if (!(((gsize) _tmp18_) < _tmp19_)) {
break;
}
_tmp20_ = builder;
_tmp21_ = outbuf;
_tmp21__length1 = outbuf_length1;
_tmp22_ = i;
_tmp23_ = _tmp21_[_tmp22_];
g_string_append_c (_tmp20_, (gchar) _tmp23_);
}
}
}
_tmp24_ = total_bytes_read;
_tmp25_ = bytes_read;
total_bytes_read = _tmp24_ + _tmp25_;
}
_tmp26_ = builder;
_tmp27_ = _tmp26_->str;
_tmp28_ = g_strdup (_tmp27_);
result = _tmp28_;
_g_string_free0 (builder);
outbuf = (g_free (outbuf), NULL);
inbuf = (g_free (inbuf), NULL);
return result;
}
static GConverterResult
cedit_smart_charset_converter_convert (GConverter *converter,
const void *inbuf,
gsize inbuf_size,
void *outbuf,
gsize outbuf_size,
GConverterFlags flags,
gsize *bytes_read,
gsize *bytes_written,
GError **error)
{
CeditSmartCharsetConverter *smart = CEDIT_SMART_CHARSET_CONVERTER (converter);
/* Guess the encoding if we didn't make it yet */
if (smart->priv->charset_conv == NULL &&
!smart->priv->is_utf8)
{
smart->priv->charset_conv = guess_encoding (smart, inbuf, inbuf_size);
/* If we still have the previous case is that we didn't guess
anything */
if (smart->priv->charset_conv == NULL &&
!smart->priv->is_utf8)
{
/* FIXME: Add a different domain when we kill cedit_convert */
g_set_error_literal (error, CEDIT_DOCUMENT_ERROR,
CEDIT_DOCUMENT_ERROR_ENCODING_AUTO_DETECTION_FAILED,
_("It is not possible to detect the encoding automatically"));
return G_CONVERTER_ERROR;
}
}
/* Now if the encoding is utf8 just redirect the input to the output */
if (smart->priv->is_utf8)
{
gsize size;
GConverterResult ret;
size = MIN (inbuf_size, outbuf_size);
memcpy (outbuf, inbuf, size);
*bytes_read = size;
*bytes_written = size;
ret = G_CONVERTER_CONVERTED;
if (flags & G_CONVERTER_INPUT_AT_END)
ret = G_CONVERTER_FINISHED;
else if (flags & G_CONVERTER_FLUSH)
ret = G_CONVERTER_FLUSHED;
return ret;
}
/* If we reached here is because we need to convert the text so, we
convert it with the charset converter */
return g_converter_convert (G_CONVERTER (smart->priv->charset_conv),
inbuf,
inbuf_size,
outbuf,
outbuf_size,
flags,
bytes_read,
bytes_written,
error);
}
/*
* emer_gzip_compress:
* @input_data: the data to compress.
* @input_length: the length of the data to compress in bytes.
* @compressed_length: (out): the length of the compressed data.
* @error: (out) (optional): if compression failed, error will be set to a GError
* describing the failure; otherwise it won't be modified. Pass NULL to ignore
* this value.
*
* Compresses input_data with the gzip algorithm at compression level 9. Returns
* NULL and sets error if compression fails. Sets compressed_length to the
* length of the compressed data in bytes.
*
* Returns: the compressed data or NULL if compression fails. Free with g_free.
*/
gpointer
emer_gzip_compress (gconstpointer input_data,
gsize input_length,
gsize *compressed_length,
GError **error)
{
GZlibCompressor *zlib_compressor =
g_zlib_compressor_new (G_ZLIB_COMPRESSOR_FORMAT_GZIP, COMPRESSION_LEVEL);
GConverter *converter = G_CONVERTER (zlib_compressor);
gsize allocated_space = input_length + 1;
GByteArray *byte_array = g_byte_array_sized_new (allocated_space);
gsize total_bytes_read = 0;
gsize total_bytes_written = 0;
while (TRUE)
{
gsize bytes_left_in_buffer = allocated_space - total_bytes_written;
if (bytes_left_in_buffer == 0)
{
allocated_space *= 2;
g_byte_array_set_size (byte_array, allocated_space);
continue;
}
gsize bytes_left_in_input = input_length - total_bytes_read;
GConverterFlags conversion_flags = bytes_left_in_input > 0 ?
G_CONVERTER_NO_FLAGS : G_CONVERTER_INPUT_AT_END;
guint8 *curr_output = byte_array->data + total_bytes_written;
const guint8 *curr_input =
((const guint8 *) input_data) + total_bytes_read;
gsize curr_bytes_written, curr_bytes_read;
GError *local_error = NULL;
GConverterResult conversion_result =
g_converter_convert (converter,
curr_input, bytes_left_in_input,
curr_output, bytes_left_in_buffer,
conversion_flags,
&curr_bytes_read, &curr_bytes_written,
&local_error);
if (conversion_result == G_CONVERTER_ERROR)
{
if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NO_SPACE))
{
g_error_free (local_error);
allocated_space *= 2;
g_byte_array_set_size (byte_array, allocated_space);
continue;
}
g_object_unref (zlib_compressor);
g_byte_array_free (byte_array, TRUE);
g_propagate_error (error, local_error);
return NULL;
}
total_bytes_read += curr_bytes_read;
total_bytes_written += curr_bytes_written;
if (conversion_result == G_CONVERTER_FINISHED)
break;
/* Expand the byte array. */
allocated_space *= 2;
g_byte_array_set_size (byte_array, allocated_space);
}
g_object_unref (zlib_compressor);
gpointer compressed_data = g_memdup (byte_array->data, total_bytes_written);
g_byte_array_free (byte_array, TRUE);
*compressed_length = total_bytes_written;
return compressed_data;
}
/**
* g_resource_lookup_data:
* @resource: A #GResource
* @path: A pathname inside the resource
* @lookup_flags: A #GResourceLookupFlags
* @error: return location for a #GError, or %NULL
*
* Looks for a file at the specified @path in the resource and
* returns a #GBytes that lets you directly access the data in
* memory.
*
* The data is always followed by a zero byte, so you
* can safely use the data as a C string. However, that byte
* is not included in the size of the GBytes.
*
* For uncompressed resource files this is a pointer directly into
* the resource bundle, which is typically in some readonly data section
* in the program binary. For compressed files we allocate memory on
* the heap and automatically uncompress the data.
*
* @lookup_flags controls the behaviour of the lookup.
*
* Returns: (transfer full): #GBytes or %NULL on error.
* Free the returned object with g_bytes_unref()
*
* Since: 2.32
**/
GBytes *
g_resource_lookup_data (GResource *resource,
const gchar *path,
GResourceLookupFlags lookup_flags,
GError **error)
{
const void *data;
guint32 flags;
gsize data_size;
gsize size;
if (!do_lookup (resource, path, lookup_flags, &size, &flags, &data, &data_size, error))
return NULL;
if (flags & G_RESOURCE_FLAGS_COMPRESSED)
{
char *uncompressed, *d;
const char *s;
GConverterResult res;
gsize d_size, s_size;
gsize bytes_read, bytes_written;
GZlibDecompressor *decompressor =
g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB);
uncompressed = g_malloc (size + 1);
s = data;
s_size = data_size;
d = uncompressed;
d_size = size;
do
{
res = g_converter_convert (G_CONVERTER (decompressor),
s, s_size,
d, d_size,
G_CONVERTER_INPUT_AT_END,
&bytes_read,
&bytes_written,
NULL);
if (res == G_CONVERTER_ERROR)
{
g_free (uncompressed);
g_object_unref (decompressor);
g_set_error (error, G_RESOURCE_ERROR, G_RESOURCE_ERROR_INTERNAL,
_("The resource at '%s' failed to decompress"),
path);
return NULL;
}
s += bytes_read;
s_size -= bytes_read;
d += bytes_written;
d_size -= bytes_written;
}
while (res != G_CONVERTER_FINISHED);
uncompressed[size] = 0; /* Zero terminate */
g_object_unref (decompressor);
return g_bytes_new_take (uncompressed, size);
}
else
return g_bytes_new_with_free_func (data, data_size, (GDestroyNotify)g_resource_unref, g_resource_ref (resource));
}
CString TextCodecGtk::encode(const UChar* characters, size_t length, UnencodableHandling handling)
{
if (!length)
return "";
if (!m_iconvEncoder)
createIConvEncoder();
if (!m_iconvEncoder) {
LOG_ERROR("Error creating IConv encoder even though encoding was in table.");
return CString();
}
gsize bytesRead = 0;
gsize bytesWritten = 0;
const gchar* input = reinterpret_cast<const char*>(characters);
gsize inputLength = length * sizeof(UChar);
gchar buffer[ConversionBufferSize];
Vector<char> result;
GOwnPtr<GError> error;
size_t size = 0;
do {
g_converter_convert(G_CONVERTER(m_iconvEncoder.get()),
input, inputLength,
buffer, sizeof(buffer),
G_CONVERTER_INPUT_AT_END,
&bytesRead, &bytesWritten,
&error.outPtr());
input += bytesRead;
inputLength -= bytesRead;
if (bytesWritten > 0) {
result.grow(size + bytesWritten);
memcpy(result.data() + size, buffer, bytesWritten);
size += bytesWritten;
}
if (error && g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_INVALID_DATA)) {
UChar codePoint = reinterpret_cast<const UChar*>(input)[0];
UnencodableReplacementArray replacement;
int replacementLength = TextCodec::getUnencodableReplacement(codePoint, handling, replacement);
// Consume the invalid character.
input += sizeof(UChar);
inputLength -= sizeof(UChar);
// Append replacement string to result buffer.
result.grow(size + replacementLength);
memcpy(result.data() + size, replacement, replacementLength);
size += replacementLength;
error.clear();
}
} while (inputLength && !error.get());
if (error) {
LOG_ERROR("GIConv conversion error, Code %d: \"%s\"", error->code, error->message);
return CString();
}
return CString(result.data(), size);
}
String TextCodecGtk::decode(const char* bytes, size_t length, bool flush, bool stopOnError, bool& sawError)
{
// Get a converter for the passed-in encoding.
if (!m_iconvDecoder)
createIConvDecoder();
if (!m_iconvDecoder) {
LOG_ERROR("Error creating IConv encoder even though encoding was in table.");
return String();
}
Vector<UChar> result;
gsize bytesRead = 0;
gsize bytesWritten = 0;
const gchar* input = bytes;
gsize inputLength = length;
gchar buffer[ConversionBufferSize];
int flags = !length ? G_CONVERTER_INPUT_AT_END : G_CONVERTER_NO_FLAGS;
if (flush)
flags |= G_CONVERTER_FLUSH;
bool bufferWasFull = false;
char* prefixedBytes = 0;
if (m_numBufferedBytes) {
inputLength = length + m_numBufferedBytes;
prefixedBytes = static_cast<char*>(fastMalloc(inputLength));
memcpy(prefixedBytes, m_bufferedBytes, m_numBufferedBytes);
memcpy(prefixedBytes + m_numBufferedBytes, bytes, length);
input = prefixedBytes;
// all buffered bytes are consumed now
m_numBufferedBytes = 0;
}
do {
GOwnPtr<GError> error;
GConverterResult res = g_converter_convert(G_CONVERTER(m_iconvDecoder.get()),
input, inputLength,
buffer, sizeof(buffer),
static_cast<GConverterFlags>(flags),
&bytesRead, &bytesWritten,
&error.outPtr());
input += bytesRead;
inputLength -= bytesRead;
if (res == G_CONVERTER_ERROR) {
if (g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_PARTIAL_INPUT)) {
// There is not enough input to fully determine what the conversion should produce,
// save it to a buffer to prepend it to the next input.
memcpy(m_bufferedBytes, input, inputLength);
m_numBufferedBytes = inputLength;
inputLength = 0;
} else if (g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_NO_SPACE))
bufferWasFull = true;
else if (g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_INVALID_DATA)) {
if (stopOnError)
sawError = true;
if (inputLength) {
// Ignore invalid character.
input += 1;
inputLength -= 1;
}
} else {
sawError = true;
LOG_ERROR("GIConv conversion error, Code %d: \"%s\"", error->code, error->message);
m_numBufferedBytes = 0; // Reset state for subsequent calls to decode.
fastFree(prefixedBytes);
return String();
}
}
result.append(reinterpret_cast<UChar*>(buffer), bytesWritten / sizeof(UChar));
} while ((inputLength || bufferWasFull) && !sawError);
fastFree(prefixedBytes);
return String::adopt(result);
}
